src/main/java/com/android/tools/build/apkzlib/zip/Eocd.java - platform/tools/apkzlib - Git at Google

 /*
  * Copyright (C) 2015 The Android Open Source Project
  *
  * 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.android.tools.build.apkzlib.zip;

 import com.android.tools.build.apkzlib.utils.CachedSupplier;
 import com.google.common.annotations.VisibleForTesting;
 import com.google.common.base.Preconditions;
 import com.google.common.base.Verify;
 import com.google.common.primitives.Ints;
 import java.io.IOException;
 import java.io.UncheckedIOException;
 import java.nio.ByteBuffer;
 import javax.annotation.Nonnull;

 /**
  * End Of Central Directory record in a zip file.
  */
 class Eocd {
     /**
      * Field in the record: the record signature, fixed at this value by the specification.
      */
     private static final ZipField.F4 F_SIGNATURE = new ZipField.F4(0, 0x06054b50, "EOCD signature");

     /**
      * Field in the record: the number of the disk where the EOCD is located. It has to be zero
      * because we do not support multi-file archives.
      */
     private static final ZipField.F2 F_NUMBER_OF_DISK = new ZipField.F2(F_SIGNATURE.endOffset(), 0,
             "Number of this disk");

     /**
      * Field in the record: the number of the disk where the Central Directory starts. Has to be
      * zero because we do not support multi-file archives.
      */
     private static final ZipField.F2 F_DISK_CD_START = new ZipField.F2(F_NUMBER_OF_DISK.endOffset(),
             0, "Disk where CD starts");

     /**
      * Field in the record: the number of entries in the Central Directory on this disk. Because
      * we do not support multi-file archives, this is the same as {@link #F_RECORDS_TOTAL}.
      */
     private static final ZipField.F2 F_RECORDS_DISK = new ZipField.F2(F_DISK_CD_START.endOffset(),
             "Record on disk count", new ZipFieldInvariantNonNegative());

     /**
      * Field in the record: the total number of entries in the Central Directory.
      */
     private static final ZipField.F2 F_RECORDS_TOTAL = new ZipField.F2(F_RECORDS_DISK.endOffset(),
             "Total records", new ZipFieldInvariantNonNegative(),
             new ZipFieldInvariantMaxValue(Integer.MAX_VALUE));

     /**
      * Field in the record: number of bytes of the Central Directory.
      * This is not private because it is required in unit tests.
      */
     @VisibleForTesting
     static final ZipField.F4 F_CD_SIZE = new ZipField.F4(F_RECORDS_TOTAL.endOffset(),
             "Directory size", new ZipFieldInvariantNonNegative());

     /**
      * Field in the record: offset, from the archive start, where the Central Directory starts.
      * This is not private because it is required in unit tests.
      */
     @VisibleForTesting
     static final ZipField.F4 F_CD_OFFSET = new ZipField.F4(F_CD_SIZE.endOffset(),
             "Directory offset", new ZipFieldInvariantNonNegative());

     /**
      * Field in the record: number of bytes of the file comment (located at the end of the EOCD
      * record).
      */
     private static final ZipField.F2 F_COMMENT_SIZE = new ZipField.F2(F_CD_OFFSET.endOffset(),
             "File comment size", new ZipFieldInvariantNonNegative());

     /**
      * Number of entries in the central directory.
      */
     private final int totalRecords;

     /**
      * Offset from the beginning of the archive where the Central Directory is located.
      */
     private final long directoryOffset;

     /**
      * Number of bytes of the Central Directory.
      */
     private final long directorySize;

     /**
      * Contents of the EOCD comment.
      */
     @Nonnull
     private final byte[] comment;

     /**
      * Supplier of the byte representation of the EOCD.
      */
     @Nonnull
     private final CachedSupplier<byte[]> byteSupplier;

     /**
      * Creates a new EOCD, reading it from a byte source. This method will parse the byte source
      * and obtain the EOCD. It will check that the byte source starts with the EOCD signature.
      *
      * @param bytes the byte buffer with the EOCD data; when this method finishes, the byte
      * buffer's position will have moved to the end of the EOCD
      * @throws IOException failed to read information or the EOCD data is corrupt or invalid
      */
     Eocd(@Nonnull ByteBuffer bytes) throws IOException {

         /*
          * Read the EOCD record.
          */
         F_SIGNATURE.verify(bytes);
         F_NUMBER_OF_DISK.verify(bytes);
         F_DISK_CD_START.verify(bytes);
         long totalRecords1 = F_RECORDS_DISK.read(bytes);
         long totalRecords2 = F_RECORDS_TOTAL.read(bytes);
         long directorySize = F_CD_SIZE.read(bytes);
         long directoryOffset = F_CD_OFFSET.read(bytes);
         int commentSize = Ints.checkedCast(F_COMMENT_SIZE.read(bytes));

         /*
          * Some sanity checks.
          */
         if (totalRecords1 !=  totalRecords2) {
             throw new IOException("Zip states records split in multiple disks, which is not "
                     + "supported.");
         }

         Verify.verify(totalRecords1 <= Integer.MAX_VALUE);

         totalRecords = Ints.checkedCast(totalRecords1);
         this.directorySize = directorySize;
         this.directoryOffset = directoryOffset;

         if (bytes.remaining() < commentSize) {
             throw new IOException("Corrupt EOCD record: not enough data for comment (comment "
                     + "size is " + commentSize + ").");
         }

         comment = new byte[commentSize];
         bytes.get(comment);
         byteSupplier = new CachedSupplier<>(this::computeByteRepresentation);
     }

     /**
      * Creates a new EOCD. This is used when generating an EOCD for an Central Directory that has
      * just been generated. The EOCD will be generated without any comment.
      *
      * @param totalRecords total number of records in the directory
      * @param directoryOffset offset, since beginning of archive, where the Central Directory is
      * located
      * @param directorySize number of bytes of the Central Directory
      * @param comment the EOCD comment
      */
     Eocd(int totalRecords, long directoryOffset, long directorySize, @Nonnull byte[] comment) {
         Preconditions.checkArgument(totalRecords >= 0, "totalRecords < 0");
         Preconditions.checkArgument(directoryOffset >= 0, "directoryOffset < 0");
         Preconditions.checkArgument(directorySize >= 0, "directorySize < 0");

         this.totalRecords = totalRecords;
         this.directoryOffset = directoryOffset;
         this.directorySize = directorySize;
         this.comment = comment;
         byteSupplier = new CachedSupplier<>(this::computeByteRepresentation);
     }

     /**
      * Obtains the number of records in the Central Directory.
      *
      * @return the number of records
      */
     int getTotalRecords() {
         return totalRecords;
     }

     /**
      * Obtains the offset since the beginning of the zip archive where the Central Directory is
      * located.
      *
      * @return the offset where the Central Directory is located
      */
     long getDirectoryOffset() {
         return directoryOffset;
     }

     /**
      * Obtains the size of the Central Directory.
      *
      * @return the number of bytes that make up the Central Directory
      */
     long getDirectorySize() {
         return directorySize;
     }

     /**
      * Obtains the size of the EOCD.
      *
      * @return the size, in bytes, of the EOCD
      */
     long getEocdSize() {
         return (long) F_COMMENT_SIZE.endOffset() + comment.length;
     }

     /**
      * Generates the EOCD data.
      *
      * @return a byte representation of the EOCD that has exactly {@link #getEocdSize()} bytes
      * @throws IOException failed to generate the EOCD data
      */
     @Nonnull
     byte[] toBytes() throws IOException {
         return byteSupplier.get();
     }

     /*
      * Obtains the comment in the EOCD.
      *
      * @return the comment exactly as it is represented in the file (no encoding conversion is
      * done)
      */
     @Nonnull
     byte[] getComment() {
         byte[] commentCopy = new byte[comment.length];
         System.arraycopy(comment, 0, commentCopy, 0, comment.length);
         return commentCopy;
     }

     /**
      * Computes the byte representation of the EOCD.
      *
      * @return a byte representation of the EOCD that has exactly {@link #getEocdSize()} bytes
      * @throws UncheckedIOException failed to generate the EOCD data
      */
     @Nonnull
     private byte[] computeByteRepresentation() {
         ByteBuffer out = ByteBuffer.allocate(F_COMMENT_SIZE.endOffset() + comment.length);

         try {
             F_SIGNATURE.write(out);
             F_NUMBER_OF_DISK.write(out);
             F_DISK_CD_START.write(out);
             F_RECORDS_DISK.write(out, totalRecords);
             F_RECORDS_TOTAL.write(out, totalRecords);
             F_CD_SIZE.write(out, directorySize);
             F_CD_OFFSET.write(out, directoryOffset);
             F_COMMENT_SIZE.write(out, comment.length);
             out.put(comment);

             return out.array();
         } catch (IOException e) {
             throw new UncheckedIOException(e);
         }
     }
 }
	/*
	* Copyright (C) 2015 The Android Open Source Project
	*
	* 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.android.tools.build.apkzlib.zip;

	import com.android.tools.build.apkzlib.utils.CachedSupplier;
	import com.google.common.annotations.VisibleForTesting;
	import com.google.common.base.Preconditions;
	import com.google.common.base.Verify;
	import com.google.common.primitives.Ints;
	import java.io.IOException;
	import java.io.UncheckedIOException;
	import java.nio.ByteBuffer;
	import javax.annotation.Nonnull;

	/**
	* End Of Central Directory record in a zip file.
	*/
	class Eocd {
	/**
	* Field in the record: the record signature, fixed at this value by the specification.
	*/
	private static final ZipField.F4 F_SIGNATURE = new ZipField.F4(0, 0x06054b50, "EOCD signature");

	/**
	* Field in the record: the number of the disk where the EOCD is located. It has to be zero
	* because we do not support multi-file archives.
	*/
	private static final ZipField.F2 F_NUMBER_OF_DISK = new ZipField.F2(F_SIGNATURE.endOffset(), 0,
	"Number of this disk");

	/**
	* Field in the record: the number of the disk where the Central Directory starts. Has to be
	* zero because we do not support multi-file archives.
	*/
	private static final ZipField.F2 F_DISK_CD_START = new ZipField.F2(F_NUMBER_OF_DISK.endOffset(),
	0, "Disk where CD starts");

	/**
	* Field in the record: the number of entries in the Central Directory on this disk. Because
	* we do not support multi-file archives, this is the same as {@link #F_RECORDS_TOTAL}.
	*/
	private static final ZipField.F2 F_RECORDS_DISK = new ZipField.F2(F_DISK_CD_START.endOffset(),
	"Record on disk count", new ZipFieldInvariantNonNegative());

	/**
	* Field in the record: the total number of entries in the Central Directory.
	*/
	private static final ZipField.F2 F_RECORDS_TOTAL = new ZipField.F2(F_RECORDS_DISK.endOffset(),
	"Total records", new ZipFieldInvariantNonNegative(),
	new ZipFieldInvariantMaxValue(Integer.MAX_VALUE));

	/**
	* Field in the record: number of bytes of the Central Directory.
	* This is not private because it is required in unit tests.
	*/
	@VisibleForTesting
	static final ZipField.F4 F_CD_SIZE = new ZipField.F4(F_RECORDS_TOTAL.endOffset(),
	"Directory size", new ZipFieldInvariantNonNegative());

	/**
	* Field in the record: offset, from the archive start, where the Central Directory starts.
	* This is not private because it is required in unit tests.
	*/
	@VisibleForTesting
	static final ZipField.F4 F_CD_OFFSET = new ZipField.F4(F_CD_SIZE.endOffset(),
	"Directory offset", new ZipFieldInvariantNonNegative());

	/**
	* Field in the record: number of bytes of the file comment (located at the end of the EOCD
	* record).
	*/
	private static final ZipField.F2 F_COMMENT_SIZE = new ZipField.F2(F_CD_OFFSET.endOffset(),
	"File comment size", new ZipFieldInvariantNonNegative());

	/**
	* Number of entries in the central directory.
	*/
	private final int totalRecords;

	/**
	* Offset from the beginning of the archive where the Central Directory is located.
	*/
	private final long directoryOffset;

	/**
	* Number of bytes of the Central Directory.
	*/
	private final long directorySize;

	/**
	* Contents of the EOCD comment.
	*/
	@Nonnull
	private final byte[] comment;

	/**
	* Supplier of the byte representation of the EOCD.
	*/
	@Nonnull
	private final CachedSupplier<byte[]> byteSupplier;

	/**
	* Creates a new EOCD, reading it from a byte source. This method will parse the byte source
	* and obtain the EOCD. It will check that the byte source starts with the EOCD signature.
	*
	* @param bytes the byte buffer with the EOCD data; when this method finishes, the byte
	* buffer's position will have moved to the end of the EOCD
	* @throws IOException failed to read information or the EOCD data is corrupt or invalid
	*/
	Eocd(@Nonnull ByteBuffer bytes) throws IOException {

	/*
	* Read the EOCD record.
	*/
	F_SIGNATURE.verify(bytes);
	F_NUMBER_OF_DISK.verify(bytes);
	F_DISK_CD_START.verify(bytes);
	long totalRecords1 = F_RECORDS_DISK.read(bytes);
	long totalRecords2 = F_RECORDS_TOTAL.read(bytes);
	long directorySize = F_CD_SIZE.read(bytes);
	long directoryOffset = F_CD_OFFSET.read(bytes);
	int commentSize = Ints.checkedCast(F_COMMENT_SIZE.read(bytes));

	/*
	* Some sanity checks.
	*/
	if (totalRecords1 != totalRecords2) {
	throw new IOException("Zip states records split in multiple disks, which is not "
	+ "supported.");
	}

	Verify.verify(totalRecords1 <= Integer.MAX_VALUE);

	totalRecords = Ints.checkedCast(totalRecords1);
	this.directorySize = directorySize;
	this.directoryOffset = directoryOffset;

	if (bytes.remaining() < commentSize) {
	throw new IOException("Corrupt EOCD record: not enough data for comment (comment "
	+ "size is " + commentSize + ").");
	}

	comment = new byte[commentSize];
	bytes.get(comment);
	byteSupplier = new CachedSupplier<>(this::computeByteRepresentation);
	}

	/**
	* Creates a new EOCD. This is used when generating an EOCD for an Central Directory that has
	* just been generated. The EOCD will be generated without any comment.
	*
	* @param totalRecords total number of records in the directory
	* @param directoryOffset offset, since beginning of archive, where the Central Directory is
	* located
	* @param directorySize number of bytes of the Central Directory
	* @param comment the EOCD comment
	*/
	Eocd(int totalRecords, long directoryOffset, long directorySize, @Nonnull byte[] comment) {
	Preconditions.checkArgument(totalRecords >= 0, "totalRecords < 0");
	Preconditions.checkArgument(directoryOffset >= 0, "directoryOffset < 0");
	Preconditions.checkArgument(directorySize >= 0, "directorySize < 0");

	this.totalRecords = totalRecords;
	this.directoryOffset = directoryOffset;
	this.directorySize = directorySize;
	this.comment = comment;
	byteSupplier = new CachedSupplier<>(this::computeByteRepresentation);
	}

	/**
	* Obtains the number of records in the Central Directory.
	*
	* @return the number of records
	*/
	int getTotalRecords() {
	return totalRecords;
	}

	/**
	* Obtains the offset since the beginning of the zip archive where the Central Directory is
	* located.
	*
	* @return the offset where the Central Directory is located
	*/
	long getDirectoryOffset() {
	return directoryOffset;
	}

	/**
	* Obtains the size of the Central Directory.
	*
	* @return the number of bytes that make up the Central Directory
	*/
	long getDirectorySize() {
	return directorySize;
	}

	/**
	* Obtains the size of the EOCD.
	*
	* @return the size, in bytes, of the EOCD
	*/
	long getEocdSize() {
	return (long) F_COMMENT_SIZE.endOffset() + comment.length;
	}

	/**
	* Generates the EOCD data.
	*
	* @return a byte representation of the EOCD that has exactly {@link #getEocdSize()} bytes
	* @throws IOException failed to generate the EOCD data
	*/
	@Nonnull
	byte[] toBytes() throws IOException {
	return byteSupplier.get();
	}

	/*
	* Obtains the comment in the EOCD.
	*
	* @return the comment exactly as it is represented in the file (no encoding conversion is
	* done)
	*/
	@Nonnull
	byte[] getComment() {
	byte[] commentCopy = new byte[comment.length];
	System.arraycopy(comment, 0, commentCopy, 0, comment.length);
	return commentCopy;
	}

	/**
	* Computes the byte representation of the EOCD.
	*
	* @return a byte representation of the EOCD that has exactly {@link #getEocdSize()} bytes
	* @throws UncheckedIOException failed to generate the EOCD data
	*/
	@Nonnull
	private byte[] computeByteRepresentation() {
	ByteBuffer out = ByteBuffer.allocate(F_COMMENT_SIZE.endOffset() + comment.length);

	try {
	F_SIGNATURE.write(out);
	F_NUMBER_OF_DISK.write(out);
	F_DISK_CD_START.write(out);
	F_RECORDS_DISK.write(out, totalRecords);
	F_RECORDS_TOTAL.write(out, totalRecords);
	F_CD_SIZE.write(out, directorySize);
	F_CD_OFFSET.write(out, directoryOffset);
	F_COMMENT_SIZE.write(out, comment.length);
	out.put(comment);

	return out.array();
	} catch (IOException e) {
	throw new UncheckedIOException(e);
	}
	}
	}