src/java_tools/singlejar/java/com/google/devtools/build/zip/ZipReader.java - bazel - Git at Google

 // Copyright 2015 The Bazel Authors. 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.devtools.build.zip;

 import static java.nio.charset.StandardCharsets.UTF_8;

 import java.io.BufferedInputStream;
 import java.io.Closeable;
 import java.io.File;
 import java.io.IOException;
 import java.io.InputStream;
 import java.io.RandomAccessFile;
 import java.nio.channels.Channels;
 import java.nio.charset.Charset;
 import java.util.Collection;
 import java.util.zip.ZipEntry;
 import java.util.zip.ZipException;
 import java.util.zip.ZipFile;

 /**
  * A ZIP file reader.
  *
  * <p>This class provides entry data in the form of {@link ZipFileEntry}, which provides more detail
  * about the entry than the JDK equivalent {@link ZipEntry}. In addition to providing
  * {@link InputStream}s for entries, similar to JDK {@link ZipFile#getInputStream(ZipEntry)}, it
  * also provides access to the raw byte entry data via {@link #getRawInputStream(ZipFileEntry)}.
  *
  * <p>Using the raw access capabilities allows for more efficient ZIP file processing, such as
  * merging, by not requiring each entry's data to be decompressed when read.
  *
  * <p><em>NOTE:</em> The entries are read from the central directory. If the entry is not listed
  * there, it will not be returned from {@link #entries()} or {@link #getEntry(String)}.
  */
 public class ZipReader implements Closeable, AutoCloseable {

   private final File file;
   private final RandomAccessFile in;
   private final ZipFileData zipData;

   /**
    * Opens a zip file for raw acceess.
    *
    * <p>The UTF-8 charset is used to decode the entry names and comments.
    *
    * @param file the zip file
    * @throws ZipException if a ZIP format error has occurred
    * @throws IOException if an I/O error has occurred
    */
   public ZipReader(File file) throws IOException {
     this(file, UTF_8);
   }

   /**
    * Opens a zip file for raw acceess.
    *
    * @param file the zip file
    * @param charset the charset to use to decode the entry names and comments
    * @throws ZipException if a ZIP format error has occurred
    * @throws IOException if an I/O error has occurred
    */
   public ZipReader(File file, Charset charset) throws IOException {
     this(file, charset, false);
   }

   /**
    * Opens a zip file for raw acceess.
    *
    * @param file the zip file
    * @param charset the charset to use to decode the entry names and comments
    * @param strictEntries force parsing to use the number of entries recorded in the end of
    *     central directory as the correct value, not as an estimate
    * @throws ZipException if a ZIP format error has occurred
    * @throws IOException if an I/O error has occurred
    */
   public ZipReader(File file, Charset charset, boolean strictEntries) throws IOException {
     if (file == null || charset == null) {
       throw new NullPointerException();
     }
     this.file = file;
     this.in = new RandomAccessFile(file, "r");
     this.zipData = new ZipFileData(charset);
     readCentralDirectory(strictEntries);
   }

   /**
    * Returns the zip file's name.
    */
   public String getFilename() {
     return file.getName();
   }

   /**
    * Returns the ZIP file comment.
    */
   public String getComment() {
     return zipData.getComment();
   }

   /**
    * Returns a collection of the ZIP file entries.
    */
   public Collection<ZipFileEntry> entries() {
     return zipData.getEntries();
   }

   /**
    * Returns the ZIP file entry for the specified name, or null if not found.
    */
   public ZipFileEntry getEntry(String name) {
     return zipData.getEntry(name);
   }

   /**
    * Returns the number of entries in the ZIP file.
    */
   public long size() {
     return zipData.getNumEntries();
   }

   /**
    * Returns an input stream for reading the contents of the specified ZIP file entry.
    *
    * <p>Closing this ZIP file will, in turn, close all input streams that have been returned by
    * invocations of this method.
    *
    * @param entry the ZIP file entry
    * @return the input stream for reading the contents of the specified zip file entry
    * @throws ZipException if a ZIP format error has occurred
    * @throws IOException if an I/O error has occurred
    */
   public InputStream getInputStream(ZipFileEntry entry) throws IOException {
     if (!zipData.getEntry(entry.getName()).equals(entry)) {
       throw new ZipException(String.format(
           "Zip file '%s' does not contain the requested entry '%s'.", file.getName(),
           entry.getName()));
     }
     return new ZipEntryInputStream(this, entry, /* raw */ false);
   }

   /**
    * Returns an input stream for reading the raw contents of the specified ZIP file entry.
    *
    * <p><em>NOTE:</em> No inflating will take place; The data read from the input stream will be
    * the exact byte content of the ZIP file entry on disk.
    *
    * <p>Closing this ZIP file will, in turn, close all input streams that have been returned by
    * invocations of this method.
    *
    * @param entry the ZIP file entry
    * @return the input stream for reading the contents of the specified zip file entry
    * @throws ZipException if a ZIP format error has occurred
    * @throws IOException if an I/O error has occurred
    */
   public InputStream getRawInputStream(ZipFileEntry entry) throws IOException {
     if (!zipData.getEntry(entry.getName()).equals(entry)) {
       throw new ZipException(String.format(
           "Zip file '%s' does not contain the requested entry '%s'.", file.getName(),
           entry.getName()));
     }
     return new ZipEntryInputStream(this, entry, /* raw */ true);
   }

   /**
    * Closes the ZIP file.
    *
    * <p>Closing this ZIP file will close all of the input streams previously returned by invocations
    * of the {@link #getRawInputStream(ZipFileEntry)} method.
    */
   @Override public void close() throws IOException {
     in.close();
   }

   /**
    * Finds, reads and parses ZIP file entries from the central directory.
    *
    * @param strictEntries force parsing to use the number of entries recorded in the end of
    *     central directory as the correct value, not as an estimate
    * @throws ZipException if a ZIP format error has occurred
    * @throws IOException if an I/O error has occurred
    */
   private void readCentralDirectory(boolean strictEntries) throws IOException {
     long eocdLocation = findEndOfCentralDirectoryRecord();
     InputStream stream = getStreamAt(eocdLocation);
     EndOfCentralDirectoryRecord.read(stream, zipData);

     if (zipData.isMaybeZip64()) {
       try {
         stream = getStreamAt(eocdLocation - Zip64EndOfCentralDirectoryLocator.FIXED_DATA_SIZE);
         Zip64EndOfCentralDirectoryLocator.read(stream, zipData);

         stream = getStreamAt(zipData.getZip64EndOfCentralDirectoryOffset());
         Zip64EndOfCentralDirectory.read(stream, zipData);
       } catch (ZipException e) {
         // expected if not in Zip64 format
       }
     }

     if (zipData.isZip64() || strictEntries) {
       // If in Zip64 format or using strict entry numbers, use the parsed information as is to read
       // the central directory file headers.
       readCentralDirectoryFileHeaders(zipData.getExpectedEntries(),
           zipData.getCentralDirectoryOffset());
     } else {
       // If not in Zip64 format, compute central directory offset by end of central directory record
       // offset and central directory size to allow reading large non-compliant Zip32 directories.
       long centralDirectoryOffset = eocdLocation - zipData.getCentralDirectorySize();
       // If the lower 4 bytes match, the above calculation is correct; otherwise fallback to
       // reported offset.
       if ((int) centralDirectoryOffset == (int) zipData.getCentralDirectoryOffset()) {
         readCentralDirectoryFileHeaders(centralDirectoryOffset);
       } else {
         readCentralDirectoryFileHeaders(zipData.getExpectedEntries(),
             zipData.getCentralDirectoryOffset());
       }
     }
   }

   /**
    * Looks for the target sub array in the buffer scanning backwards starting at offset. Returns the
    * index where the target is found or -1 if not found.
    *
    * @param target the sub array to find
    * @param buffer the array to scan
    * @param offset the index of where to begin scanning
    * @return the index of target within buffer or -1 if not found
    */
   private int scanBackwards(byte[] target, byte[] buffer, int offset) {
     int start = Math.min(offset, buffer.length - target.length);
     for (int i = start; i >= 0; i--) {
       for (int j = 0; j < target.length; j++) {
         if (buffer[i + j] != target[j]) {
           break;
         } else if (j == target.length - 1) {
           return i;
         }
       }
     }
     return -1;
   }

   /**
    * Finds the file offset of the end of central directory record.
    *
    * @return the file offset of the end of central directory record
    * @throws ZipException if a ZIP format error has occurred
    * @throws IOException if an I/O error has occurred
    */
   private long findEndOfCentralDirectoryRecord() throws IOException {
     byte[] signature = ZipUtil.intToLittleEndian(EndOfCentralDirectoryRecord.SIGNATURE);
     byte[] buffer = new byte[(int) Math.min(64, in.length())];
     int readLength = buffer.length;
     if (readLength < EndOfCentralDirectoryRecord.FIXED_DATA_SIZE) {
       throw new ZipException(String.format("Zip file '%s' is malformed. It does not contain an end"
           + " of central directory record.", file.getName()));
     }

     long offset = in.length() - buffer.length;
     while (offset >= 0) {
       in.seek(offset);
       in.readFully(buffer, 0, readLength);
       int signatureLocation = scanBackwards(signature, buffer, buffer.length);
       while (signatureLocation != -1) {
         long eocdSize = in.length() - offset - signatureLocation;
         if (eocdSize >= EndOfCentralDirectoryRecord.FIXED_DATA_SIZE) {
           int commentLength = ZipUtil.getUnsignedShort(buffer, signatureLocation
               + EndOfCentralDirectoryRecord.COMMENT_LENGTH_OFFSET);
           long readCommentLength = eocdSize - EndOfCentralDirectoryRecord.FIXED_DATA_SIZE;
           if (commentLength == readCommentLength) {
             return offset + signatureLocation;
           }
         }
         signatureLocation = scanBackwards(signature, buffer, signatureLocation - 1);
       }
       readLength = buffer.length - 3;
       buffer[buffer.length - 3] = buffer[0];
       buffer[buffer.length - 2] = buffer[1];
       buffer[buffer.length - 1] = buffer[2];
       offset -= readLength;
     }
     throw new ZipException(String.format("Zip file '%s' is malformed. It does not contain an end"
         + " of central directory record.", file.getName()));
   }

   /**
    * Reads and parses ZIP file entries from the central directory.
    *
    * @param count the number of entries in the central directory
    * @param fileOffset the file offset of the start of the central directory
    * @throws ZipException if a ZIP format error has occurred
    * @throws IOException if an I/O error has occurred
    */
   private void readCentralDirectoryFileHeaders(long count, long fileOffset) throws IOException {
     InputStream centralDirectory = getStreamAt(fileOffset);
     for (long i = 0; i < count; i++) {
       ZipFileEntry entry = CentralDirectoryFileHeader.read(centralDirectory, zipData.getCharset());
       zipData.addEntry(entry);
     }
   }

   /**
    * Reads and parses ZIP file entries from the central directory.
    *
    * @param fileOffset the file offset of the start of the central directory
    * @throws ZipException if a ZIP format error has occurred
    * @throws IOException if an I/O error has occurred
    */
   private void readCentralDirectoryFileHeaders(long fileOffset) throws IOException {
     CountingInputStream centralDirectory = new CountingInputStream(getStreamAt(fileOffset));
     while (centralDirectory.getCount() < zipData.getCentralDirectorySize()) {
       ZipFileEntry entry = CentralDirectoryFileHeader.read(centralDirectory, zipData.getCharset());
       zipData.addEntry(entry);
     }
   }

   /**
    * Returns a new {@link InputStream} positioned at fileOffset.
    *
    * @throws IOException if an I/O error has occurred
    */
   protected InputStream getStreamAt(long fileOffset) throws IOException {
     return new BufferedInputStream(Channels.newInputStream(in.getChannel().position(fileOffset)));
   }
 }
	// Copyright 2015 The Bazel Authors. 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.devtools.build.zip;

	import static java.nio.charset.StandardCharsets.UTF_8;

	import java.io.BufferedInputStream;
	import java.io.Closeable;
	import java.io.File;
	import java.io.IOException;
	import java.io.InputStream;
	import java.io.RandomAccessFile;
	import java.nio.channels.Channels;
	import java.nio.charset.Charset;
	import java.util.Collection;
	import java.util.zip.ZipEntry;
	import java.util.zip.ZipException;
	import java.util.zip.ZipFile;

	/**
	* A ZIP file reader.
	*
	* <p>This class provides entry data in the form of {@link ZipFileEntry}, which provides more detail
	* about the entry than the JDK equivalent {@link ZipEntry}. In addition to providing
	* {@link InputStream}s for entries, similar to JDK {@link ZipFile#getInputStream(ZipEntry)}, it
	* also provides access to the raw byte entry data via {@link #getRawInputStream(ZipFileEntry)}.
	*
	* <p>Using the raw access capabilities allows for more efficient ZIP file processing, such as
	* merging, by not requiring each entry's data to be decompressed when read.
	*
	* <p><em>NOTE:</em> The entries are read from the central directory. If the entry is not listed
	* there, it will not be returned from {@link #entries()} or {@link #getEntry(String)}.
	*/
	public class ZipReader implements Closeable, AutoCloseable {

	private final File file;
	private final RandomAccessFile in;
	private final ZipFileData zipData;

	/**
	* Opens a zip file for raw acceess.
	*
	* <p>The UTF-8 charset is used to decode the entry names and comments.
	*
	* @param file the zip file
	* @throws ZipException if a ZIP format error has occurred
	* @throws IOException if an I/O error has occurred
	*/
	public ZipReader(File file) throws IOException {
	this(file, UTF_8);
	}

	/**
	* Opens a zip file for raw acceess.
	*
	* @param file the zip file
	* @param charset the charset to use to decode the entry names and comments
	* @throws ZipException if a ZIP format error has occurred
	* @throws IOException if an I/O error has occurred
	*/
	public ZipReader(File file, Charset charset) throws IOException {
	this(file, charset, false);
	}

	/**
	* Opens a zip file for raw acceess.
	*
	* @param file the zip file
	* @param charset the charset to use to decode the entry names and comments
	* @param strictEntries force parsing to use the number of entries recorded in the end of
	* central directory as the correct value, not as an estimate
	* @throws ZipException if a ZIP format error has occurred
	* @throws IOException if an I/O error has occurred
	*/
	public ZipReader(File file, Charset charset, boolean strictEntries) throws IOException {
	if (file == null \|\| charset == null) {
	throw new NullPointerException();
	}
	this.file = file;
	this.in = new RandomAccessFile(file, "r");
	this.zipData = new ZipFileData(charset);
	readCentralDirectory(strictEntries);
	}

	/**
	* Returns the zip file's name.
	*/
	public String getFilename() {
	return file.getName();
	}

	/**
	* Returns the ZIP file comment.
	*/
	public String getComment() {
	return zipData.getComment();
	}

	/**
	* Returns a collection of the ZIP file entries.
	*/
	public Collection<ZipFileEntry> entries() {
	return zipData.getEntries();
	}

	/**
	* Returns the ZIP file entry for the specified name, or null if not found.
	*/
	public ZipFileEntry getEntry(String name) {
	return zipData.getEntry(name);
	}

	/**
	* Returns the number of entries in the ZIP file.
	*/
	public long size() {
	return zipData.getNumEntries();
	}

	/**
	* Returns an input stream for reading the contents of the specified ZIP file entry.
	*
	* <p>Closing this ZIP file will, in turn, close all input streams that have been returned by
	* invocations of this method.
	*
	* @param entry the ZIP file entry
	* @return the input stream for reading the contents of the specified zip file entry
	* @throws ZipException if a ZIP format error has occurred
	* @throws IOException if an I/O error has occurred
	*/
	public InputStream getInputStream(ZipFileEntry entry) throws IOException {
	if (!zipData.getEntry(entry.getName()).equals(entry)) {
	throw new ZipException(String.format(
	"Zip file '%s' does not contain the requested entry '%s'.", file.getName(),
	entry.getName()));
	}
	return new ZipEntryInputStream(this, entry, /* raw */ false);
	}

	/**
	* Returns an input stream for reading the raw contents of the specified ZIP file entry.
	*
	* <p><em>NOTE:</em> No inflating will take place; The data read from the input stream will be
	* the exact byte content of the ZIP file entry on disk.
	*
	* <p>Closing this ZIP file will, in turn, close all input streams that have been returned by
	* invocations of this method.
	*
	* @param entry the ZIP file entry
	* @return the input stream for reading the contents of the specified zip file entry
	* @throws ZipException if a ZIP format error has occurred
	* @throws IOException if an I/O error has occurred
	*/
	public InputStream getRawInputStream(ZipFileEntry entry) throws IOException {
	if (!zipData.getEntry(entry.getName()).equals(entry)) {
	throw new ZipException(String.format(
	"Zip file '%s' does not contain the requested entry '%s'.", file.getName(),
	entry.getName()));
	}
	return new ZipEntryInputStream(this, entry, /* raw */ true);
	}

	/**
	* Closes the ZIP file.
	*
	* <p>Closing this ZIP file will close all of the input streams previously returned by invocations
	* of the {@link #getRawInputStream(ZipFileEntry)} method.
	*/
	@Override public void close() throws IOException {
	in.close();
	}

	/**
	* Finds, reads and parses ZIP file entries from the central directory.
	*
	* @param strictEntries force parsing to use the number of entries recorded in the end of
	* central directory as the correct value, not as an estimate
	* @throws ZipException if a ZIP format error has occurred
	* @throws IOException if an I/O error has occurred
	*/
	private void readCentralDirectory(boolean strictEntries) throws IOException {
	long eocdLocation = findEndOfCentralDirectoryRecord();
	InputStream stream = getStreamAt(eocdLocation);
	EndOfCentralDirectoryRecord.read(stream, zipData);

	if (zipData.isMaybeZip64()) {
	try {
	stream = getStreamAt(eocdLocation - Zip64EndOfCentralDirectoryLocator.FIXED_DATA_SIZE);
	Zip64EndOfCentralDirectoryLocator.read(stream, zipData);

	stream = getStreamAt(zipData.getZip64EndOfCentralDirectoryOffset());
	Zip64EndOfCentralDirectory.read(stream, zipData);
	} catch (ZipException e) {
	// expected if not in Zip64 format
	}
	}

	if (zipData.isZip64() \|\| strictEntries) {
	// If in Zip64 format or using strict entry numbers, use the parsed information as is to read
	// the central directory file headers.
	readCentralDirectoryFileHeaders(zipData.getExpectedEntries(),
	zipData.getCentralDirectoryOffset());
	} else {
	// If not in Zip64 format, compute central directory offset by end of central directory record
	// offset and central directory size to allow reading large non-compliant Zip32 directories.
	long centralDirectoryOffset = eocdLocation - zipData.getCentralDirectorySize();
	// If the lower 4 bytes match, the above calculation is correct; otherwise fallback to
	// reported offset.
	if ((int) centralDirectoryOffset == (int) zipData.getCentralDirectoryOffset()) {
	readCentralDirectoryFileHeaders(centralDirectoryOffset);
	} else {
	readCentralDirectoryFileHeaders(zipData.getExpectedEntries(),
	zipData.getCentralDirectoryOffset());
	}
	}
	}

	/**
	* Looks for the target sub array in the buffer scanning backwards starting at offset. Returns the
	* index where the target is found or -1 if not found.
	*
	* @param target the sub array to find
	* @param buffer the array to scan
	* @param offset the index of where to begin scanning
	* @return the index of target within buffer or -1 if not found
	*/
	private int scanBackwards(byte[] target, byte[] buffer, int offset) {
	int start = Math.min(offset, buffer.length - target.length);
	for (int i = start; i >= 0; i--) {
	for (int j = 0; j < target.length; j++) {
	if (buffer[i + j] != target[j]) {
	break;
	} else if (j == target.length - 1) {
	return i;
	}
	}
	}
	return -1;
	}

	/**
	* Finds the file offset of the end of central directory record.
	*
	* @return the file offset of the end of central directory record
	* @throws ZipException if a ZIP format error has occurred
	* @throws IOException if an I/O error has occurred
	*/
	private long findEndOfCentralDirectoryRecord() throws IOException {
	byte[] signature = ZipUtil.intToLittleEndian(EndOfCentralDirectoryRecord.SIGNATURE);
	byte[] buffer = new byte[(int) Math.min(64, in.length())];
	int readLength = buffer.length;
	if (readLength < EndOfCentralDirectoryRecord.FIXED_DATA_SIZE) {
	throw new ZipException(String.format("Zip file '%s' is malformed. It does not contain an end"
	+ " of central directory record.", file.getName()));
	}

	long offset = in.length() - buffer.length;
	while (offset >= 0) {
	in.seek(offset);
	in.readFully(buffer, 0, readLength);
	int signatureLocation = scanBackwards(signature, buffer, buffer.length);
	while (signatureLocation != -1) {
	long eocdSize = in.length() - offset - signatureLocation;
	if (eocdSize >= EndOfCentralDirectoryRecord.FIXED_DATA_SIZE) {
	int commentLength = ZipUtil.getUnsignedShort(buffer, signatureLocation
	+ EndOfCentralDirectoryRecord.COMMENT_LENGTH_OFFSET);
	long readCommentLength = eocdSize - EndOfCentralDirectoryRecord.FIXED_DATA_SIZE;
	if (commentLength == readCommentLength) {
	return offset + signatureLocation;
	}
	}
	signatureLocation = scanBackwards(signature, buffer, signatureLocation - 1);
	}
	readLength = buffer.length - 3;
	buffer[buffer.length - 3] = buffer[0];
	buffer[buffer.length - 2] = buffer[1];
	buffer[buffer.length - 1] = buffer[2];
	offset -= readLength;
	}
	throw new ZipException(String.format("Zip file '%s' is malformed. It does not contain an end"
	+ " of central directory record.", file.getName()));
	}

	/**
	* Reads and parses ZIP file entries from the central directory.
	*
	* @param count the number of entries in the central directory
	* @param fileOffset the file offset of the start of the central directory
	* @throws ZipException if a ZIP format error has occurred
	* @throws IOException if an I/O error has occurred
	*/
	private void readCentralDirectoryFileHeaders(long count, long fileOffset) throws IOException {
	InputStream centralDirectory = getStreamAt(fileOffset);
	for (long i = 0; i < count; i++) {
	ZipFileEntry entry = CentralDirectoryFileHeader.read(centralDirectory, zipData.getCharset());
	zipData.addEntry(entry);
	}
	}

	/**
	* Reads and parses ZIP file entries from the central directory.
	*
	* @param fileOffset the file offset of the start of the central directory
	* @throws ZipException if a ZIP format error has occurred
	* @throws IOException if an I/O error has occurred
	*/
	private void readCentralDirectoryFileHeaders(long fileOffset) throws IOException {
	CountingInputStream centralDirectory = new CountingInputStream(getStreamAt(fileOffset));
	while (centralDirectory.getCount() < zipData.getCentralDirectorySize()) {
	ZipFileEntry entry = CentralDirectoryFileHeader.read(centralDirectory, zipData.getCharset());
	zipData.addEntry(entry);
	}
	}

	/**
	* Returns a new {@link InputStream} positioned at fileOffset.
	*
	* @throws IOException if an I/O error has occurred
	*/
	protected InputStream getStreamAt(long fileOffset) throws IOException {
	return new BufferedInputStream(Channels.newInputStream(in.getChannel().position(fileOffset)));
	}
	}