fix: Documentation, parsing, JVM format fixes

Author: xxDark

src/main/java/software/coley/llzip/ZipCompressions.java

@@ -5,7 +5,6 @@
 import software.coley.llzip.util.ByteData;
 
 import java.io.IOException;
-import java.nio.ByteBuffer;
 
 /**
  * Constants for {@link LocalFileHeader#getCompressionMethod()}.
@@ -16,7 +15,7 @@ public interface ZipCompressions {
 	/**
 	 * The file is stored <i>(no compression)</i>.
 	 */
-	int STRORED = 0;
+	int STORED = 0;
 	/**
 	 * The file is Shrunk.
 	 */
@@ -134,7 +133,7 @@ public interface ZipCompressions {
 	 */
 	static String getName(int method) {
 		switch (method) {
-			case STRORED:
+			case STORED:
 				return "STRORED";
 			case SHRUNK:
 				return "SHRUNK";
@@ -207,7 +206,7 @@ static String getName(int method) {
 	static ByteData decompress(LocalFileHeader header) throws IOException {
 		int method = header.getCompressionMethod();
 		switch (method) {
-			case STRORED:
+			case STORED:
 				return header.getFileData();
 			case DEFLATED:
 				return header.decompress(new DeflateDecompressor());

src/main/java/software/coley/llzip/part/JvmLocalFileHeader.java

@@ -1,8 +1,9 @@
 package software.coley.llzip.part;
 
-import software.coley.llzip.ZipPatterns;
 import software.coley.llzip.util.ByteData;
-import software.coley.llzip.util.ByteDataUtil;
+
+import java.util.NavigableSet;
+
 
 /**
  * An extension of {@link LocalFileHeader} with adjustments to the file-data parse logic to support
@@ -12,16 +13,27 @@
  * @author Wolfie / win32kbase <i>(Reverse engineering JVM specific zip handling)</i>
  */
 public class JvmLocalFileHeader extends LocalFileHeader {
+	
+	private final NavigableSet<Long> offsets;
+
+	/**
+	 * @param offsets
+	 * 		Set containing all local file header offsets.
+	 */
+	public JvmLocalFileHeader(NavigableSet<Long> offsets) {
+		this.offsets = offsets;
+	}
+
 	@Override
 	public void read(ByteData data, long offset) {
 		super.read(data, offset);
-		long start = offset + 30 + getFileNameLength() + getExtraFieldLength();
 		// JVM file data reading does NOT use the compressed/uncompressed fields.
 		// Instead, it scans data until the next header/EOF.
-		long nextPk = ByteDataUtil.indexOf(data, offset + 1, ZipPatterns.PK);
-		if (nextPk == -1L)
-			nextPk = data.length();
-		ByteData slice = data.slice(start, nextPk);
-		setFileData(slice);
+		offset += 30 + getFileNameLength() + getExtraFieldLength();
+		Long nextOffset = offsets.ceiling(offset);
+		if (nextOffset != null)
+			setFileData(data.slice(offset, nextOffset));
+		else 
+			setFileData(data.slice(offset, data.length()));
 	}
 }

src/main/java/software/coley/llzip/part/LocalFileHeader.java

@@ -6,7 +6,8 @@
 import software.coley.llzip.util.ByteDataUtil;
 
 import java.io.IOException;
-import java.nio.ByteBuffer;
+
+import static software.coley.llzip.ZipCompressions.*;
 
 /**
  * ZIP LocalFileHeader structure.
@@ -48,7 +49,13 @@ public void read(ByteData data, long offset) {
 		extraFieldLength = ByteDataUtil.readWord(data, offset + 28);
 		fileName = data.sliceOf(offset + 30, fileNameLength);
 		extraField = data.sliceOf(offset + 30 + fileNameLength, extraFieldLength);
-		fileData = data.sliceOf(offset + 30 + fileNameLength + extraFieldLength, compressedSize);
+		int fileDataLength;
+		if (compressionMethod == STORED) {
+			fileDataLength = uncompressedSize;
+		} else {
+			fileDataLength = compressedSize;
+		}
+		fileData = data.sliceOf(offset + 30 + fileNameLength + extraFieldLength, fileDataLength);
 	}
 
 	@Override

src/main/java/software/coley/llzip/strategy/DeflateDecompressor.java

@@ -4,12 +4,12 @@
 import software.coley.llzip.part.LocalFileHeader;
 import software.coley.llzip.util.BufferData;
 import software.coley.llzip.util.ByteData;
-import software.coley.llzip.util.ByteDataInputStream;
 
 import java.io.ByteArrayOutputStream;
 import java.io.IOException;
+import java.util.zip.DataFormatException;
 import java.util.zip.Inflater;
-import java.util.zip.InflaterInputStream;
+import java.util.zip.ZipException;
 
 /**
  * Decompressor implementation for {@link ZipCompressions#DEFLATED}.
@@ -24,12 +24,34 @@ public ByteData decompress(LocalFileHeader header, ByteData bytes) throws IOExce
 		Inflater inflater = new Inflater(true);
 		ByteArrayOutputStream out = new ByteArrayOutputStream();
 		try {
-			InflaterInputStream in = new InflaterInputStream(new ByteDataInputStream(bytes), inflater);
-			// We can't trust the uncompressed size, so we will keep going until the inflater stream says we're done.
+			byte[] output = new byte[1024];
 			byte[] buffer = new byte[1024];
-			int len;
-			while ((len = in.read(buffer)) != -1)
-				out.write(buffer, 0, len);
+			long position = 0L;
+			long length = bytes.length();
+			boolean eof;
+			do {
+				eof = false;
+				if (inflater.needsInput()) {
+					int remaining = (int) Math.min(buffer.length, length);
+					if (remaining == 0) {
+						buffer[0] = 0;
+						inflater.setInput(buffer, 0, 1);
+						eof = true;
+					} else {
+						bytes.get(position, buffer, 0, remaining);
+						length -= remaining;
+						position += remaining;
+						inflater.setInput(buffer, 0, remaining);
+					}
+				}
+				int count = inflater.inflate(output);
+				if (count != 0) {
+					out.write(output, 0, count);
+				}
+			} while (!eof && !inflater.finished() && !inflater.needsDictionary());
+		}catch (DataFormatException e) {
+			String s = e.getMessage();
+			throw (ZipException) new ZipException(s != null ? null : "Invalid ZLIB data format").initCause(e);
 		} finally {
 			inflater.end();
 		}

src/main/java/software/coley/llzip/strategy/JvmZipReaderStrategy.java

@@ -15,6 +15,7 @@
 import java.io.IOException;
 import java.util.HashSet;
 import java.util.Set;
+import java.util.TreeSet;
 
 /**
  * The JVM has some edge cases in how it parses zip/jar files.
@@ -41,8 +42,8 @@ public void read(ZipArchive zip, ByteData data) throws IOException {
 		long precedingEndOfCentralDirectory = ByteDataUtil.lastIndexOf(data, endOfCentralDirectoryOffset - 1, ZipPatterns.END_OF_CENTRAL_DIRECTORY);
 		if (precedingEndOfCentralDirectory == endOfCentralDirectoryOffset) {
 			// The prior end part match is target end part, so we can't use it as a base offset.
-			jvmBaseOffset = 0;
-		} else if (precedingEndOfCentralDirectory == -1) {
+			jvmBaseOffset = 0L;
+		} else if (precedingEndOfCentralDirectory == -1L) {
 			// There was no match for a prior end part. We will seek forwards until finding a *VALID* PK starting header.
 			jvmBaseOffset = ByteDataUtil.indexOf(data, ZipPatterns.PK);
 			while (jvmBaseOffset >= 0L) {
@@ -56,13 +57,13 @@ else if (ByteDataUtil.startsWith(data, jvmBaseOffset, ZipPatterns.CENTRAL_DIRECT
 					break;
 				} catch (Exception ex) {
 					// Invalid, seek forward
-					jvmBaseOffset = ByteDataUtil.indexOf(data, jvmBaseOffset+1, ZipPatterns.PK);
+					jvmBaseOffset = ByteDataUtil.indexOf(data, jvmBaseOffset+1L, ZipPatterns.PK);
 				}
 			}
 		} else {
 			// There was a prior end part, so we will seek past it's length and use that as the base offset.
 			// 22 is the minimum possible size of an end part. It can be longer with comments applied, but there are almost never comments.
-			jvmBaseOffset = precedingEndOfCentralDirectory + 22;
+			jvmBaseOffset = precedingEndOfCentralDirectory + 22L;
 		}
 		// Read end header
 		EndOfCentralDirectory end = new EndOfCentralDirectory();
@@ -71,9 +72,9 @@ else if (ByteDataUtil.startsWith(data, jvmBaseOffset, ZipPatterns.CENTRAL_DIRECT
 		// Read central directories
 		long len = data.length();
 		long centralDirectoryOffset = len - ZipPatterns.CENTRAL_DIRECTORY_FILE_HEADER.length;
-		while (centralDirectoryOffset > 0) {
-			centralDirectoryOffset = ByteDataUtil.lastIndexOf(data, centralDirectoryOffset - 1, ZipPatterns.CENTRAL_DIRECTORY_FILE_HEADER);
-			if (centralDirectoryOffset >= 0) {
+		while (centralDirectoryOffset > 0L) {
+			centralDirectoryOffset = ByteDataUtil.lastIndexOf(data, centralDirectoryOffset - 1L, ZipPatterns.CENTRAL_DIRECTORY_FILE_HEADER);
+			if (centralDirectoryOffset >= 0L) {
 				CentralDirectoryFileHeader directory = new CentralDirectoryFileHeader();
 				directory.read(data, centralDirectoryOffset);
 				zip.getParts().add(directory);
@@ -82,12 +83,15 @@ else if (ByteDataUtil.startsWith(data, jvmBaseOffset, ZipPatterns.CENTRAL_DIRECT
 		// Read local files
 		// - Set to prevent duplicate file header entries for the same offset
 		Set<Long> offsets = new HashSet<>();
+		TreeSet<Long> lfhOffsets = new TreeSet<>();
+		for (CentralDirectoryFileHeader directory : zip.getCentralDirectories()) {
+			lfhOffsets.add(jvmBaseOffset + directory.getRelativeOffsetOfLocalHeader());
+		}
 		for (CentralDirectoryFileHeader directory : zip.getCentralDirectories()) {
 			long offset = jvmBaseOffset + directory.getRelativeOffsetOfLocalHeader();
 			if (!offsets.contains(offset) && ByteDataUtil.startsWith(data, offset, ZipPatterns.LOCAL_FILE_HEADER)) {
-				// JVM local file header needs to be aware of where the NEXT entry is.
 				try {
-					JvmLocalFileHeader file = new JvmLocalFileHeader();
+					JvmLocalFileHeader file = new JvmLocalFileHeader(lfhOffsets);
 					file.read(data, offset);
 					zip.getParts().add(file);
 					directory.link(file);

src/main/java/software/coley/llzip/util/BufferData.java

@@ -1,5 +1,7 @@
 package software.coley.llzip.util;
 
+import java.io.IOException;
+import java.io.OutputStream;
 import java.nio.ByteBuffer;
 import java.nio.ByteOrder;
 
@@ -39,6 +41,25 @@ public void get(long position, byte[] b, int off, int len) {
 				.get(b, off, len);
 	}
 
+	@Override
+	public void transferTo(OutputStream out, byte[] buf) throws IOException {
+		ByteBuffer buffer = this.buffer;
+		int remaining = buffer.remaining();
+		if (buffer.hasArray()) {
+			out.write(buffer.array(), buffer.arrayOffset(), remaining);
+		} else {
+			buffer.mark();
+			int copyThreshold = buf.length;
+			while (remaining != 0) {
+				int length = Math.min(copyThreshold, remaining);
+				buffer.get(buf, 0, length);
+				out.write(buf, 0, length);
+				remaining -= length;
+			}
+			buffer.reset();
+		}
+	}
+
 	@Override
 	public ByteData slice(long startIndex, long endIndex) {
 		return new BufferData(ByteDataUtil.sliceExact(buffer, validate(startIndex), validate(endIndex)));
@@ -69,6 +90,16 @@ private static int validate(long v) {
 		return (int) v;
 	}
 
+	/**
+	 * @param buffer
+	 * 		Byte buffer to wrap.
+	 *
+	 * @return Buffer data.
+	 */
+	public static BufferData wrap(ByteBuffer buffer) {
+		return new BufferData(buffer);
+	}
+
 	/**
 	 * @param array
 	 * 		Byte array to wrap.

src/main/java/software/coley/llzip/util/ByteData.java

@@ -1,25 +1,94 @@
 package software.coley.llzip.util;
 
+import java.io.IOException;
+import java.io.OutputStream;
+
 /**
  * Byte array data.
  *
  * @author xDark
  */
 public interface ByteData {
 
+	/**
+	 * Gets int at specific position.
+	 *
+	 * @param position
+	 * 		Position to read int from.
+	 *
+	 * @return Read int.
+	 */
 	int getInt(long position);
 
+	/**
+	 * Gets short at specific position.
+	 *
+	 * @param position
+	 * 		Position to short int from.
+	 *
+	 * @return Read short.
+	 */
 	short getShort(long position);
 
+	/**
+	 * Gets byte at specific position.
+	 *
+	 * @param position
+	 * 		Position to read byte from.
+	 *
+	 * @return Read byte.
+	 */
 	byte get(long position);
 
+	/**
+	 * Copied array of bytes from position.
+	 *
+	 * @param position
+	 * 		Position to copy from.
+	 */
 	void get(long position, byte[] b, int off, int len);
 
+	/**
+	 * Transfers data to target output stream.
+	 *
+	 * @param out
+	 * 		Stream to transfer data to.
+	 * @param buf
+	 * 		Buffer to use for transferring.
+	 *
+	 * @throws IOException
+	 * 		If any I/O error occurs.
+	 */
+	void transferTo(OutputStream out, byte[] buf) throws IOException;
+
+	/**
+	 * Makes a slice of data.
+	 *
+	 * @param startIndex
+	 * 		Starting index.
+	 * @param endIndex
+	 * 		End index.
+	 *
+	 * @return Slice of this data.
+	 */
 	ByteData slice(long startIndex, long endIndex);
 
+	/**
+	 * Same as above, but with relative length.
+	 *
+	 * @param startIndex
+	 * 		Starting index.
+	 * @param length
+	 * 		Slice length.
+	 *
+	 * @return Slice of this data.
+	 */
 	default ByteData sliceOf(long startIndex, long length) {
 		return slice(startIndex, startIndex + length);
 	}
 
+	/**
+	 * @return Length of the data.
+	 */
 	long length();
 }