generator/src/main/java/com/google/archivepatcher/generator/MinimalZipParser.java - platform/external/archive-patcher - Git at Google

 // Copyright 2016 Google Inc. All rights reserved.
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
 // You may obtain a copy of the License at
 //
 //     http://www.apache.org/licenses/LICENSE-2.0
 //
 // Unless required by applicable law or agreed to in writing, software
 // distributed under the License is distributed on an "AS IS" BASIS,
 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 // See the License for the specific language governing permissions and
 // limitations under the License.

 package com.google.archivepatcher.generator;

 import com.google.archivepatcher.shared.RandomAccessFileInputStream;

 import java.io.IOException;
 import java.io.InputStream;
 import java.util.zip.ZipException;

 /**
  * A minimal set of zip-parsing utilities just adequate to produce a {@link MinimalZipEntry} and
  * update it. This parser is neither robust nor exhaustive. The parser is built to understand
  * version 2.0 of the ZIP specification, with the notable exception that it does not have support
  * for encrypted central directories.
  * <p>
  * The offsets, lengths and fields that this parser understands and exposes are based on version
  * 6.3.3 of the ZIP specification (the most recent available at the time of this writing), which may
  * be found at the following URL:
  * <br><ul><li>https://www.pkware.com/documents/APPNOTE/APPNOTE-6.3.3.TXT</li></ul>
  * <p>
  * Please note that the parser does not attempt to verify the version-needed-to-extract field, since
  * there is no guarantee that all ZIP implementations have set the value correctly to the minimum
  * needed to truly support extraction.
  */
 class MinimalZipParser {

   /**
    * Standard 32-bit signature for a "end-of-central-directory" record in a ZIP-like archive. This
    * is in little-endian order.
    */
   public static final int EOCD_SIGNATURE = 0x06054b50;

   /**
    * Standard 32-bit signature for a "central directory entry" record in a ZIP-like archive. This is
    * in little-endian order.
    */
   public static final int CENTRAL_DIRECTORY_ENTRY_SIGNATURE = 0x02014b50;

   /**
    * Standard 32-bit signature for a "local file entry" in a ZIP-like archive. This is in
    * little-endian order.
    */
   public static final int LOCAL_ENTRY_SIGNATURE = 0x04034b50;

   /**
    * Read exactly one byte, throwing an exception if unsuccessful.
    * @param in the stream to read from
    * @return the byte read
    * @throws IOException if EOF is reached
    */
   private static int readByteOrDie(InputStream in) throws IOException {
     int result = in.read();
     if (result == -1) {
       throw new IOException("EOF");
     }
     return result;
   }

   /**
    * Skips exactly the specified number of bytes, throwing an exception if unsuccessful.
    * @param in the stream to read from
    * @param numBytes the number of bytes to skip
    * @throws IOException if EOF is reached or no more bytes can be skipped
    */
   private static void skipOrDie(InputStream in, long numBytes) throws IOException {
     long numLeft = numBytes;
     long numSkipped = 0;
     while ((numSkipped = in.skip(numLeft)) > 0) {
       numLeft -= numSkipped;
     }
     if (numLeft != 0) {
       throw new IOException("Unable to skip");
     }
   }

   /**
    * Reads 2 bytes from the current offset as an unsigned, 32-bit little-endian value.
    * @param in the stream to read from
    * @return the value as a java int
    * @throws IOException if unable to read
    */
   private static int read16BitUnsigned(InputStream in) throws IOException {
     int value = readByteOrDie(in);
     value |= readByteOrDie(in) << 8;
     return value;
   }

   /**
    * Reads 4 bytes from the current offset as an unsigned, 32-bit little-endian value.
    * @param in the stream to read from
    * @return the value as a java long
    * @throws IOException if unable to read
    */
   private static long read32BitUnsigned(InputStream in) throws IOException {
     long value = readByteOrDie(in);
     value |= ((long) readByteOrDie(in)) << 8;
     value |= ((long) readByteOrDie(in)) << 16;
     value |= ((long) readByteOrDie(in)) << 24;
     return value;
   }

   /**
    * Read exactly the specified amount of data into the specified buffer, throwing an exception if
    * unsuccessful.
    * @param in the stream to read from
    * @param buffer the buffer to file
    * @param offset the offset at which to start writing to the buffer
    * @param length the number of bytes to place into the buffer from the input stream
    * @throws IOException if unable to read
    */
   private static void readOrDie(InputStream in, byte[] buffer, int offset, int length)
       throws IOException {
     if (length < 0) {
       throw new IllegalArgumentException("length must be >= 0");
     }
     int numRead = 0;
     while (numRead < length) {
       int readThisRound = in.read(buffer, offset + numRead, length - numRead);
       if (numRead == -1) {
         throw new IOException("EOF");
       }
       numRead += readThisRound;
     }
   }

   /**
    * Parse one central directory entry, starting at the current file position.
    * @param in the input stream to read from, assumed to start at the first byte of the entry
    * @return the entry that was parsed
    * @throws IOException if unable to complete the parsing
    */
   public static MinimalZipEntry parseCentralDirectoryEntry(InputStream in) throws IOException {
     // *** 4 bytes encode the CENTRAL_DIRECTORY_ENTRY_SIGNATURE, verify for sanity
     // 2 bytes encode the version-made-by, ignore
     // 2 bytes encode the version-needed-to-extract, ignore
     // *** 2 bytes encode the general-purpose flags, read for language encoding. [READ THIS]
     // *** 2 bytes encode the compression method, [READ THIS]
     // 2 bytes encode the MSDOS last modified file time, ignore
     // 2 bytes encode the MSDOS last modified file date, ignore
     // *** 4 bytes encode the CRC32 of the uncompressed data [READ THIS]
     // *** 4 bytes encode the compressed size [READ THIS]
     // *** 4 bytes encode the uncompressed size [READ THIS]
     // *** 2 bytes encode the length of the file name [READ THIS]
     // *** 2 bytes encode the length of the extras, needed to skip the bytes later [READ THIS]
     // *** 2 bytes encode the length of the comment, needed to skip the bytes later [READ THIS]
     // 2 bytes encode the disk number, ignore
     // 2 bytes encode the internal file attributes, ignore
     // 4 bytes encode the external file attributes, ignore
     // *** 4 bytes encode the offset of the local section entry, where the data is [READ THIS]
     // n bytes encode the file name
     // n bytes encode the extras
     // n bytes encode the comment
     if (((int) read32BitUnsigned(in)) != CENTRAL_DIRECTORY_ENTRY_SIGNATURE) {
       throw new ZipException("Bad central directory header");
     }
     skipOrDie(in, 2 + 2); // Skip version stuff
     int generalPurposeFlags = read16BitUnsigned(in);
     int compressionMethod = read16BitUnsigned(in);
     skipOrDie(in, 2 + 2); // Skip MSDOS junk
     long crc32OfUncompressedData = read32BitUnsigned(in);
     long compressedSize = read32BitUnsigned(in);
     long uncompressedSize = read32BitUnsigned(in);
     int fileNameLength = read16BitUnsigned(in);
     int extrasLength = read16BitUnsigned(in);
     int commentLength = read16BitUnsigned(in);
     skipOrDie(in, 2 + 2 + 4); // Skip the disk number and file attributes
     long fileOffsetOfLocalEntry = read32BitUnsigned(in);
     byte[] fileNameBuffer = new byte[fileNameLength];
     readOrDie(in, fileNameBuffer, 0, fileNameBuffer.length);
     skipOrDie(in, extrasLength + commentLength);
     // General purpose flag bit 11 is an important hint for the character set used for file names.
     boolean generalPurposeFlagBit11 = (generalPurposeFlags & (0x1 << 10)) != 0;
     return new MinimalZipEntry(
         compressionMethod,
         crc32OfUncompressedData,
         compressedSize,
         uncompressedSize,
         fileNameBuffer,
         generalPurposeFlagBit11,
         fileOffsetOfLocalEntry);
   }

   /**
    * Parses one local file entry and returns the offset from the first byte at which the compressed
    * data begins
    * @param in the input stream to read from, assumed to start at the first byte of the entry
    * @return as described
    * @throws IOException if unable to complete the parsing
    */
   public static long parseLocalEntryAndGetCompressedDataOffset(InputStream in) throws IOException {
     // *** 4 bytes encode the LOCAL_ENTRY_SIGNATURE, verify for sanity
     // 2 bytes encode the version-needed-to-extract, ignore
     // 2 bytes encode the general-purpose flags, ignore
     // 2 bytes encode the compression method, ignore (redundant with central directory)
     // 2 bytes encode the MSDOS last modified file time, ignore
     // 2 bytes encode the MSDOS last modified file date, ignore
     // 4 bytes encode the CRC32 of the uncompressed data, ignore (redundant with central directory)
     // 4 bytes encode the compressed size, ignore (redundant with central directory)
     // 4 bytes encode the uncompressed size, ignore (redundant with central directory)
     // *** 2 bytes encode the length of the file name, needed to skip the bytes later [READ THIS]
     // *** 2 bytes encode the length of the extras, needed to skip the bytes later [READ THIS]
     // The rest is the data, which is the main attraction here.
     if (((int) read32BitUnsigned(in)) != LOCAL_ENTRY_SIGNATURE) {
       throw new ZipException("Bad local entry header");
     }
     int junkLength = 2 + 2 + 2 + 2 + 2 + 4 + 4 + 4;
     skipOrDie(in, junkLength); // Skip everything up to the length of the file name
     final int fileNameLength = read16BitUnsigned(in);
     final int extrasLength = read16BitUnsigned(in);

     // The file name is already known and will match the central directory, so no need to read it.
     // The extra field length can be different here versus in the central directory and is used for
     // things like zipaligning APKs. This single value is the critical part as it dictates where the
     // actual DATA for the entry begins.
     return 4 + junkLength + 2 + 2 + fileNameLength + extrasLength;
   }

   /**
    * Find the end-of-central-directory record by scanning backwards from the end of a file looking
    * for the signature of the record.
    * @param in the file to read from
    * @param searchBufferLength the length of the search buffer, starting from the end of the file
    * @return the offset in the file at which the first byte of the EOCD signature is located, or -1
    * if the signature is not found in the search buffer
    * @throws IOException if there is a problem reading
    */
   public static long locateStartOfEocd(RandomAccessFileInputStream in, int searchBufferLength)
       throws IOException {
     final int maxBufferSize = (int) Math.min(searchBufferLength, in.length());
     final byte[] buffer = new byte[maxBufferSize];
     final long rangeStart = in.length() - buffer.length;
     in.setRange(rangeStart, buffer.length);
     readOrDie(in, buffer, 0, buffer.length);
     int offset = locateStartOfEocd(buffer);
     if (offset == -1) {
       return -1;
     }
     return rangeStart + offset;
   }

   /**
    * Find the end-of-central-directory record by scanning backwards looking for the signature of the
    * record.
    * @param buffer the buffer in which to search
    * @return the offset in the buffer at which the first byte of the EOCD signature is located, or
    * -1 if the complete signature is not found
    */
   public static int locateStartOfEocd(byte[] buffer) {
     int last4Bytes = 0; // This is the 32 bits of data from the file
     for (int offset = buffer.length - 1; offset >= 0; offset--) {
       last4Bytes <<= 8;
       last4Bytes |= buffer[offset];
       if (last4Bytes == EOCD_SIGNATURE) {
         return offset;
       }
     }
     return -1;
   }

   /**
    * Parse the end-of-central-directory record and return the critical information from it.
    * @param in the input stream to read from, assumed to start at the first byte of the entry
    * @return the metadata
    * @throws IOException if unable to read
    * @throws ZipException if the metadata indicates this is a zip64 archive, which is not supported
    */
   public static MinimalCentralDirectoryMetadata parseEocd(InputStream in)
       throws IOException, ZipException {
     if (((int) read32BitUnsigned(in)) != EOCD_SIGNATURE) {
       throw new ZipException("Bad eocd header");
     }

     // *** 4 bytes encode EOCD_SIGNATURE, ignore (already found and verified).
     // 2 bytes encode disk number for this archive, ignore.
     // 2 bytes encode disk number for the central directory, ignore.
     // 2 bytes encode num entries in the central directory on this disk, ignore.
     // *** 2 bytes encode num entries in the central directory overall [READ THIS]
     // *** 4 bytes encode the length of the central directory [READ THIS]
     // *** 4 bytes encode the file offset of the central directory [READ THIS]
     // 2 bytes encode the length of the zip file comment, ignore.
     // Everything else from here to the EOF is the zip file comment, or junk. Ignore.
     skipOrDie(in, 2 + 2 + 2);
     int numEntriesInCentralDirectory = read16BitUnsigned(in);
     if (numEntriesInCentralDirectory == 0xffff) {
       // If 0xffff, this is a zip64 archive and this code doesn't handle that.
       throw new ZipException("No support for zip64");
     }
     long lengthOfCentralDirectory = read32BitUnsigned(in);
     long offsetOfCentralDirectory = read32BitUnsigned(in);
     return new MinimalCentralDirectoryMetadata(
         numEntriesInCentralDirectory, offsetOfCentralDirectory, lengthOfCentralDirectory);
   }
 }
	// Copyright 2016 Google Inc. All rights reserved.
	//
	// Licensed under the Apache License, Version 2.0 (the "License");
	// you may not use this file except in compliance with the License.
	// You may obtain a copy of the License at
	//
	// http://www.apache.org/licenses/LICENSE-2.0
	//
	// Unless required by applicable law or agreed to in writing, software
	// distributed under the License is distributed on an "AS IS" BASIS,
	// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	// See the License for the specific language governing permissions and
	// limitations under the License.

	package com.google.archivepatcher.generator;

	import com.google.archivepatcher.shared.RandomAccessFileInputStream;

	import java.io.IOException;
	import java.io.InputStream;
	import java.util.zip.ZipException;

	/**
	* A minimal set of zip-parsing utilities just adequate to produce a {@link MinimalZipEntry} and
	* update it. This parser is neither robust nor exhaustive. The parser is built to understand
	* version 2.0 of the ZIP specification, with the notable exception that it does not have support
	* for encrypted central directories.
	* <p>
	* The offsets, lengths and fields that this parser understands and exposes are based on version
	* 6.3.3 of the ZIP specification (the most recent available at the time of this writing), which may
	* be found at the following URL:
	* <br><ul><li>https://www.pkware.com/documents/APPNOTE/APPNOTE-6.3.3.TXT</li></ul>
	* <p>
	* Please note that the parser does not attempt to verify the version-needed-to-extract field, since
	* there is no guarantee that all ZIP implementations have set the value correctly to the minimum
	* needed to truly support extraction.
	*/
	class MinimalZipParser {

	/**
	* Standard 32-bit signature for a "end-of-central-directory" record in a ZIP-like archive. This
	* is in little-endian order.
	*/
	public static final int EOCD_SIGNATURE = 0x06054b50;

	/**
	* Standard 32-bit signature for a "central directory entry" record in a ZIP-like archive. This is
	* in little-endian order.
	*/
	public static final int CENTRAL_DIRECTORY_ENTRY_SIGNATURE = 0x02014b50;

	/**
	* Standard 32-bit signature for a "local file entry" in a ZIP-like archive. This is in
	* little-endian order.
	*/
	public static final int LOCAL_ENTRY_SIGNATURE = 0x04034b50;

	/**
	* Read exactly one byte, throwing an exception if unsuccessful.
	* @param in the stream to read from
	* @return the byte read
	* @throws IOException if EOF is reached
	*/
	private static int readByteOrDie(InputStream in) throws IOException {
	int result = in.read();
	if (result == -1) {
	throw new IOException("EOF");
	}
	return result;
	}

	/**
	* Skips exactly the specified number of bytes, throwing an exception if unsuccessful.
	* @param in the stream to read from
	* @param numBytes the number of bytes to skip
	* @throws IOException if EOF is reached or no more bytes can be skipped
	*/
	private static void skipOrDie(InputStream in, long numBytes) throws IOException {
	long numLeft = numBytes;
	long numSkipped = 0;
	while ((numSkipped = in.skip(numLeft)) > 0) {
	numLeft -= numSkipped;
	}
	if (numLeft != 0) {
	throw new IOException("Unable to skip");
	}
	}

	/**
	* Reads 2 bytes from the current offset as an unsigned, 32-bit little-endian value.
	* @param in the stream to read from
	* @return the value as a java int
	* @throws IOException if unable to read
	*/
	private static int read16BitUnsigned(InputStream in) throws IOException {
	int value = readByteOrDie(in);
	value \|= readByteOrDie(in) << 8;
	return value;
	}

	/**
	* Reads 4 bytes from the current offset as an unsigned, 32-bit little-endian value.
	* @param in the stream to read from
	* @return the value as a java long
	* @throws IOException if unable to read
	*/
	private static long read32BitUnsigned(InputStream in) throws IOException {
	long value = readByteOrDie(in);
	value \|= ((long) readByteOrDie(in)) << 8;
	value \|= ((long) readByteOrDie(in)) << 16;
	value \|= ((long) readByteOrDie(in)) << 24;
	return value;
	}

	/**
	* Read exactly the specified amount of data into the specified buffer, throwing an exception if
	* unsuccessful.
	* @param in the stream to read from
	* @param buffer the buffer to file
	* @param offset the offset at which to start writing to the buffer
	* @param length the number of bytes to place into the buffer from the input stream
	* @throws IOException if unable to read
	*/
	private static void readOrDie(InputStream in, byte[] buffer, int offset, int length)
	throws IOException {
	if (length < 0) {
	throw new IllegalArgumentException("length must be >= 0");
	}
	int numRead = 0;
	while (numRead < length) {
	int readThisRound = in.read(buffer, offset + numRead, length - numRead);
	if (numRead == -1) {
	throw new IOException("EOF");
	}
	numRead += readThisRound;
	}
	}

	/**
	* Parse one central directory entry, starting at the current file position.
	* @param in the input stream to read from, assumed to start at the first byte of the entry
	* @return the entry that was parsed
	* @throws IOException if unable to complete the parsing
	*/
	public static MinimalZipEntry parseCentralDirectoryEntry(InputStream in) throws IOException {
	// *** 4 bytes encode the CENTRAL_DIRECTORY_ENTRY_SIGNATURE, verify for sanity
	// 2 bytes encode the version-made-by, ignore
	// 2 bytes encode the version-needed-to-extract, ignore
	// *** 2 bytes encode the general-purpose flags, read for language encoding. [READ THIS]
	// *** 2 bytes encode the compression method, [READ THIS]
	// 2 bytes encode the MSDOS last modified file time, ignore
	// 2 bytes encode the MSDOS last modified file date, ignore
	// *** 4 bytes encode the CRC32 of the uncompressed data [READ THIS]
	// *** 4 bytes encode the compressed size [READ THIS]
	// *** 4 bytes encode the uncompressed size [READ THIS]
	// *** 2 bytes encode the length of the file name [READ THIS]
	// *** 2 bytes encode the length of the extras, needed to skip the bytes later [READ THIS]
	// *** 2 bytes encode the length of the comment, needed to skip the bytes later [READ THIS]
	// 2 bytes encode the disk number, ignore
	// 2 bytes encode the internal file attributes, ignore
	// 4 bytes encode the external file attributes, ignore
	// *** 4 bytes encode the offset of the local section entry, where the data is [READ THIS]
	// n bytes encode the file name
	// n bytes encode the extras
	// n bytes encode the comment
	if (((int) read32BitUnsigned(in)) != CENTRAL_DIRECTORY_ENTRY_SIGNATURE) {
	throw new ZipException("Bad central directory header");
	}
	skipOrDie(in, 2 + 2); // Skip version stuff
	int generalPurposeFlags = read16BitUnsigned(in);
	int compressionMethod = read16BitUnsigned(in);
	skipOrDie(in, 2 + 2); // Skip MSDOS junk
	long crc32OfUncompressedData = read32BitUnsigned(in);
	long compressedSize = read32BitUnsigned(in);
	long uncompressedSize = read32BitUnsigned(in);
	int fileNameLength = read16BitUnsigned(in);
	int extrasLength = read16BitUnsigned(in);
	int commentLength = read16BitUnsigned(in);
	skipOrDie(in, 2 + 2 + 4); // Skip the disk number and file attributes
	long fileOffsetOfLocalEntry = read32BitUnsigned(in);
	byte[] fileNameBuffer = new byte[fileNameLength];
	readOrDie(in, fileNameBuffer, 0, fileNameBuffer.length);
	skipOrDie(in, extrasLength + commentLength);
	// General purpose flag bit 11 is an important hint for the character set used for file names.
	boolean generalPurposeFlagBit11 = (generalPurposeFlags & (0x1 << 10)) != 0;
	return new MinimalZipEntry(
	compressionMethod,
	crc32OfUncompressedData,
	compressedSize,
	uncompressedSize,
	fileNameBuffer,
	generalPurposeFlagBit11,
	fileOffsetOfLocalEntry);
	}

	/**
	* Parses one local file entry and returns the offset from the first byte at which the compressed
	* data begins
	* @param in the input stream to read from, assumed to start at the first byte of the entry
	* @return as described
	* @throws IOException if unable to complete the parsing
	*/
	public static long parseLocalEntryAndGetCompressedDataOffset(InputStream in) throws IOException {
	// *** 4 bytes encode the LOCAL_ENTRY_SIGNATURE, verify for sanity
	// 2 bytes encode the version-needed-to-extract, ignore
	// 2 bytes encode the general-purpose flags, ignore
	// 2 bytes encode the compression method, ignore (redundant with central directory)
	// 2 bytes encode the MSDOS last modified file time, ignore
	// 2 bytes encode the MSDOS last modified file date, ignore
	// 4 bytes encode the CRC32 of the uncompressed data, ignore (redundant with central directory)
	// 4 bytes encode the compressed size, ignore (redundant with central directory)
	// 4 bytes encode the uncompressed size, ignore (redundant with central directory)
	// *** 2 bytes encode the length of the file name, needed to skip the bytes later [READ THIS]
	// *** 2 bytes encode the length of the extras, needed to skip the bytes later [READ THIS]
	// The rest is the data, which is the main attraction here.
	if (((int) read32BitUnsigned(in)) != LOCAL_ENTRY_SIGNATURE) {
	throw new ZipException("Bad local entry header");
	}
	int junkLength = 2 + 2 + 2 + 2 + 2 + 4 + 4 + 4;
	skipOrDie(in, junkLength); // Skip everything up to the length of the file name
	final int fileNameLength = read16BitUnsigned(in);
	final int extrasLength = read16BitUnsigned(in);

	// The file name is already known and will match the central directory, so no need to read it.
	// The extra field length can be different here versus in the central directory and is used for
	// things like zipaligning APKs. This single value is the critical part as it dictates where the
	// actual DATA for the entry begins.
	return 4 + junkLength + 2 + 2 + fileNameLength + extrasLength;
	}

	/**
	* Find the end-of-central-directory record by scanning backwards from the end of a file looking
	* for the signature of the record.
	* @param in the file to read from
	* @param searchBufferLength the length of the search buffer, starting from the end of the file
	* @return the offset in the file at which the first byte of the EOCD signature is located, or -1
	* if the signature is not found in the search buffer
	* @throws IOException if there is a problem reading
	*/
	public static long locateStartOfEocd(RandomAccessFileInputStream in, int searchBufferLength)
	throws IOException {
	final int maxBufferSize = (int) Math.min(searchBufferLength, in.length());
	final byte[] buffer = new byte[maxBufferSize];
	final long rangeStart = in.length() - buffer.length;
	in.setRange(rangeStart, buffer.length);
	readOrDie(in, buffer, 0, buffer.length);
	int offset = locateStartOfEocd(buffer);
	if (offset == -1) {
	return -1;
	}
	return rangeStart + offset;
	}

	/**
	* Find the end-of-central-directory record by scanning backwards looking for the signature of the
	* record.
	* @param buffer the buffer in which to search
	* @return the offset in the buffer at which the first byte of the EOCD signature is located, or
	* -1 if the complete signature is not found
	*/
	public static int locateStartOfEocd(byte[] buffer) {
	int last4Bytes = 0; // This is the 32 bits of data from the file
	for (int offset = buffer.length - 1; offset >= 0; offset--) {
	last4Bytes <<= 8;
	last4Bytes \|= buffer[offset];
	if (last4Bytes == EOCD_SIGNATURE) {
	return offset;
	}
	}
	return -1;
	}

	/**
	* Parse the end-of-central-directory record and return the critical information from it.
	* @param in the input stream to read from, assumed to start at the first byte of the entry
	* @return the metadata
	* @throws IOException if unable to read
	* @throws ZipException if the metadata indicates this is a zip64 archive, which is not supported
	*/
	public static MinimalCentralDirectoryMetadata parseEocd(InputStream in)
	throws IOException, ZipException {
	if (((int) read32BitUnsigned(in)) != EOCD_SIGNATURE) {
	throw new ZipException("Bad eocd header");
	}

	// *** 4 bytes encode EOCD_SIGNATURE, ignore (already found and verified).
	// 2 bytes encode disk number for this archive, ignore.
	// 2 bytes encode disk number for the central directory, ignore.
	// 2 bytes encode num entries in the central directory on this disk, ignore.
	// *** 2 bytes encode num entries in the central directory overall [READ THIS]
	// *** 4 bytes encode the length of the central directory [READ THIS]
	// *** 4 bytes encode the file offset of the central directory [READ THIS]
	// 2 bytes encode the length of the zip file comment, ignore.
	// Everything else from here to the EOF is the zip file comment, or junk. Ignore.
	skipOrDie(in, 2 + 2 + 2);
	int numEntriesInCentralDirectory = read16BitUnsigned(in);
	if (numEntriesInCentralDirectory == 0xffff) {
	// If 0xffff, this is a zip64 archive and this code doesn't handle that.
	throw new ZipException("No support for zip64");
	}
	long lengthOfCentralDirectory = read32BitUnsigned(in);
	long offsetOfCentralDirectory = read32BitUnsigned(in);
	return new MinimalCentralDirectoryMetadata(
	numEntriesInCentralDirectory, offsetOfCentralDirectory, lengthOfCentralDirectory);
	}
	}