Whether the stream will try to read STORED entries that use a data descriptor. Setting it to true means we will not stop reading an entry with the compressed size, instead we will stop reading an entry when a data descriptor is met (by finding the Data Descriptor Signature). This will completely break down in some cases - like JARs in WARs.

See also : https://issues.apache.org/jira/projects/COMPRESS/issues/COMPRESS-555 https://github.com/apache/commons-compress/pull/137#issuecomment-690835644

Buffer used to read from the wrapped stream.

Whether the stream has been closed.

The entry that is currently being read.

The factory for extra fields or null.

Whether the stream has reached the central directory - and thus found all entries.

Inflater used for all deflated entries.

When reading a stored entry that uses the data descriptor this stream has to read the full entry and caches it. This is the cache.

Cached buffers - must only be used locally in the class (COMPRESS-172 - reduce garbage collection).

Whether the stream will try to skip the ZIP split signature(08074B50) at the beginning

Count decompressed bytes for current entry

Whether to look for and use Unicode extra fields.

The ZIP encoding to use for file names and the file comment.

Checks whether the current buffer contains the signature of a "data descriptor", "local file header" or "central directory entry".

If it contains such a signature, reads the data descriptor and positions the stream right after the data descriptor.

If the last read bytes could hold a data descriptor and an incomplete signature then save the last bytes to the front of the buffer and cache everything in front of the potential data descriptor into the given ByteArrayOutputStream.

Data descriptor plus incomplete signature (3 bytes in the worst case) can be 20 bytes max.

Closes the current ZIP archive entry and positions the underlying stream to the beginning of the next entry. All per-entry variables and data structures are cleared.

If the compressed size of this entry is included in the entry header, then any outstanding bytes are simply skipped from the underlying stream without uncompressing them. This allows an entry to be safely closed even if the compression method is unsupported.

In case we don't know the compressed size of this entry or have already buffered too much data from the underlying stream to support uncompression, then the uncompression process is completed and the end position of the stream is adjusted based on the result of that process.

Exceptions

IOException:

if an error occurs

If the compressed size of the current entry is included in the entry header and there are any outstanding bytes in the underlying stream, then this returns true.

Returns:boolean

true, if current entry is determined to have outstanding bytes, false otherwise

Read all data of the current entry from the underlying stream that hasn't been read, yet.

Reads forward until the signature of the "End of central directory" record is found.

Gets the number of bytes Inflater has actually processed.

for Java < Java7 the getBytes* methods in Inflater/Deflater seem to return unsigned ints rather than longs that start over with 0 at 2^32.

The stream knows how many bytes it has read, but not how many the Inflater actually consumed - it should be between the total number of bytes read for the entry and the total number minus the last read operation. Here we just try to make the value close enough to the bytes we've read by assuming the number of bytes consumed must be smaller than (or equal to) the number of bytes read but not smaller by more than 2^32.

Checks whether this might be an APK Signing Block.

Unfortunately the APK signing block does not start with some kind of signature, it rather ends with one. It starts with a length, so what we do is parse the suspect length, skip ahead far enough, look for the signature and if we've found it, return true.

Parameters

suspectLocalFileHeader:byte[]

the bytes read from the underlying stream in the expectation that they would hold the local file header of the next entry.

Returns:boolean

true if this looks like an APK signing block

See Also

https://source.android.com/security/apksigning/v2

Records whether a Zip64 extra is present and sets the size information from it if sizes are 0xFFFFFFFF and the entry doesn't use a data descriptor.

Implementation of read for DEFLATED entries.

Fills the given array with the first local file header and deals with splitting/spanning markers that may prefix the first LFH.

Potentially reads more bytes to fill the inflater's buffer and reads from it.

Reads bytes by reading from the underlying stream rather than the (potentially inflating) archive stream - which read would do. Also updates bytes-read counter.

Implementation of read for STORED entries.

Caches a stored entry that uses the data descriptor.

• Reads a stored entry until the signature of a local file header, central directory header or data descriptor has been found.
• Stores all entry data in lastStoredEntry.

• Rewinds the stream to position at the data descriptor.
• reads the data descriptor

After calling this method the entry should know its size, the entry's data is cached and the stream is positioned at the next local file or central directory header.

Skips bytes by reading from the underlying stream rather than the (potentially inflating) archive stream - which skip would do. Also updates bytes-read counter.

Reads the stream until it find the "End of central directory record" and consumes it as well.

Whether the compressed size for the entry is either known or not required by the compression method being used.

Whether this entry requires a data descriptor this library can work with.

Returns:boolean

true if allowStoredEntriesWithDataDescriptor is true, the entry doesn't require any data descriptor or the method is DEFLATED or ENHANCED_DEFLATED.