build/android/rezip/RezipApk.java - mirrors/engine - Git at Google

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.

 import java.io.File;
 import java.io.FileOutputStream;
 import java.io.IOException;
 import java.io.InputStream;
 import java.io.OutputStream;
 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.Comparator;
 import java.util.Enumeration;
 import java.util.List;
 import java.util.jar.JarEntry;
 import java.util.jar.JarFile;
 import java.util.jar.JarOutputStream;
 import java.util.regex.Pattern;
 import java.util.zip.CRC32;

 /**
  * Command line tool used to build APKs which support loading the native code library
  * directly from the APK file. To construct the APK we rename the native library by
  * adding the prefix "crazy." to the filename. This is done to prevent the Android
  * Package Manager from extracting the library. The native code must be page aligned
  * and uncompressed. The page alignment is implemented by adding a zero filled file
  * in front of the the native code library. This tool is designed so that running
  * SignApk and/or zipalign on the resulting APK does not break the page alignment.
  * This is achieved by outputing the filenames in the same canonical order used
  * by SignApk and adding the same alignment fields added by zipalign.
  */
 class RezipApk {
     // Alignment to use for non-compressed files (must match zipalign).
     private static final int ALIGNMENT = 4;

     // Alignment to use for non-compressed *.so files
     private static final int LIBRARY_ALIGNMENT = 4096;

     // Files matching this pattern are not copied to the output when adding alignment.
     // When reordering and verifying the APK they are copied to the end of the file.
     private static Pattern sMetaFilePattern =
             Pattern.compile("^(META-INF/((.*)[.](SF|RSA|DSA)|com/android/otacert))|("
                     + Pattern.quote(JarFile.MANIFEST_NAME) + ")$");

     // Pattern for matching a shared library in the APK
     private static Pattern sLibraryPattern = Pattern.compile("^lib/[^/]*/lib.*[.]so$");
     // Pattern for match the crazy linker in the APK
     private static Pattern sCrazyLinkerPattern =
             Pattern.compile("^lib/[^/]*/libchromium_android_linker.so$");
     // Pattern for matching a crazy loaded shared library in the APK
     private static Pattern sCrazyLibraryPattern = Pattern.compile("^lib/[^/]*/crazy.lib.*[.]so$");

     private static boolean isLibraryFilename(String filename) {
         return sLibraryPattern.matcher(filename).matches()
                 && !sCrazyLinkerPattern.matcher(filename).matches();
     }

     private static boolean isCrazyLibraryFilename(String filename) {
         return sCrazyLibraryPattern.matcher(filename).matches();
     }

     private static String renameLibraryForCrazyLinker(String filename) {
         int lastSlash = filename.lastIndexOf('/');
         // We rename the library, so that the Android Package Manager
         // no longer extracts the library.
         return filename.substring(0, lastSlash + 1) + "crazy." + filename.substring(lastSlash + 1);
     }

     /**
      * Wraps another output stream, counting the number of bytes written.
      */
     private static class CountingOutputStream extends OutputStream {
         private long mCount = 0;
         private OutputStream mOut;

         public CountingOutputStream(OutputStream out) {
             this.mOut = out;
         }

         /** Returns the number of bytes written. */
         public long getCount() {
             return mCount;
         }

         @Override public void write(byte[] b, int off, int len) throws IOException {
             mOut.write(b, off, len);
             mCount += len;
         }

         @Override public void write(int b) throws IOException {
             mOut.write(b);
             mCount++;
         }

         @Override public void close() throws IOException {
             mOut.close();
         }

         @Override public void flush() throws IOException {
             mOut.flush();
         }
     }

     private static String outputName(JarEntry entry, boolean rename) {
         String inName = entry.getName();
         if (rename && entry.getSize() > 0 && isLibraryFilename(inName)) {
             return renameLibraryForCrazyLinker(inName);
         }
         return inName;
     }

     /**
      * Comparator used to sort jar entries from the input file.
      * Sorting is done based on the output filename (which maybe renamed).
      * Filenames are in natural string order, except that filenames matching
      * the meta-file pattern are always after other files. This is so the manifest
      * and signature are at the end of the file after any alignment file.
      */
     private static class EntryComparator implements Comparator<JarEntry> {
         private boolean mRename;

         public EntryComparator(boolean rename) {
             mRename = rename;
         }

         @Override
         public int compare(JarEntry j1, JarEntry j2) {
             String o1 = outputName(j1, mRename);
             String o2 = outputName(j2, mRename);
             boolean o1Matches = sMetaFilePattern.matcher(o1).matches();
             boolean o2Matches = sMetaFilePattern.matcher(o2).matches();
             if (o1Matches != o2Matches) {
                 return o1Matches ? 1 : -1;
             } else {
                 return o1.compareTo(o2);
             }
         }
     }

     // Build an ordered list of jar entries. The jar entries from the input are
     // sorted based on the output filenames (which maybe renamed). If |omitMetaFiles|
     // is true do not include the jar entries for the META-INF files.
     // Entries are ordered in the deterministic order used by SignApk.
     private static List<JarEntry> getOutputFileOrderEntries(
             JarFile jar, boolean omitMetaFiles, boolean rename) {
         List<JarEntry> entries = new ArrayList<JarEntry>();
         for (Enumeration<JarEntry> e = jar.entries(); e.hasMoreElements(); ) {
             JarEntry entry = e.nextElement();
             if (entry.isDirectory()) {
                 continue;
             }
             if (omitMetaFiles && sMetaFilePattern.matcher(entry.getName()).matches()) {
                 continue;
             }
             entries.add(entry);
         }

         // We sort the input entries by name. When present META-INF files
         // are sorted to the end.
         Collections.sort(entries, new EntryComparator(rename));
         return entries;
     }

     /**
      * Add a zero filled alignment file at this point in the zip file,
      * The added file will be added before |name| and after |prevName|.
      * The size of the alignment file is such that the location of the
      * file |name| will be on a LIBRARY_ALIGNMENT boundary.
      *
      * Note this arrangement is devised so that running SignApk and/or zipalign on the resulting
      * file will not alter the alignment.
      *
      * @param offset number of bytes into the output file at this point.
      * @param timestamp time in millis since the epoch to include in the header.
      * @param name the name of the library filename.
      * @param prevName the name of the previous file in the archive (or null).
      * @param out jar output stream to write the alignment file to.
      *
      * @throws IOException if the output file can not be written.
      */
     private static void addAlignmentFile(
             long offset, long timestamp, String name, String prevName,
             JarOutputStream out) throws IOException {

         // Compute the start and alignment of the library, as if it was next.
         int headerSize = JarFile.LOCHDR + name.length();
         long libOffset = offset + headerSize;
         int libNeeded = LIBRARY_ALIGNMENT - (int) (libOffset % LIBRARY_ALIGNMENT);
         if (libNeeded == LIBRARY_ALIGNMENT) {
             // Already aligned, no need to added alignment file.
             return;
         }

         // Check that there is not another file between the library and the
         // alignment file.
         String alignName = name.substring(0, name.length() - 2) + "align";
         if (prevName != null && prevName.compareTo(alignName) >= 0) {
             throw new UnsupportedOperationException(
                 "Unable to insert alignment file, because there is "
                 + "another file in front of the file to be aligned. "
                 + "Other file: " + prevName + " Alignment file: " + alignName
                 + " file: " + name);
         }

         // Compute the size of the alignment file header.
         headerSize = JarFile.LOCHDR + alignName.length();
         // We are going to add an alignment file of type STORED. This file
         // will itself induce a zipalign alignment adjustment.
         int extraNeeded =
                 (ALIGNMENT - (int) ((offset + headerSize) % ALIGNMENT)) % ALIGNMENT;
         headerSize += extraNeeded;

         if (libNeeded < headerSize + 1) {
             // The header was bigger than the alignment that we need, add another page.
             libNeeded += LIBRARY_ALIGNMENT;
         }
         // Compute the size of the alignment file.
         libNeeded -= headerSize;

         // Build the header for the alignment file.
         byte[] zeroBuffer = new byte[libNeeded];
         JarEntry alignEntry = new JarEntry(alignName);
         alignEntry.setMethod(JarEntry.STORED);
         alignEntry.setSize(libNeeded);
         alignEntry.setTime(timestamp);
         CRC32 crc = new CRC32();
         crc.update(zeroBuffer);
         alignEntry.setCrc(crc.getValue());

         if (extraNeeded != 0) {
             alignEntry.setExtra(new byte[extraNeeded]);
         }

         // Output the alignment file.
         out.putNextEntry(alignEntry);
         out.write(zeroBuffer);
         out.closeEntry();
         out.flush();
     }

     // Make a JarEntry for the output file which corresponds to the input
     // file. The output file will be called |name|. The output file will always
     // be uncompressed (STORED). If the input is not STORED it is necessary to inflate
     // it to compute the CRC and size of the output entry.
     private static JarEntry makeStoredEntry(String name, JarEntry inEntry, JarFile in)
             throws IOException {
         JarEntry outEntry = new JarEntry(name);
         outEntry.setMethod(JarEntry.STORED);

         if (inEntry.getMethod() == JarEntry.STORED) {
             outEntry.setCrc(inEntry.getCrc());
             outEntry.setSize(inEntry.getSize());
         } else {
             // We are inflating the file. We need to compute the CRC and size.
             byte[] buffer = new byte[4096];
             CRC32 crc = new CRC32();
             int size = 0;
             int num;
             InputStream data = in.getInputStream(inEntry);
             while ((num = data.read(buffer)) > 0) {
                 crc.update(buffer, 0, num);
                 size += num;
             }
             data.close();
             outEntry.setCrc(crc.getValue());
             outEntry.setSize(size);
         }
         return outEntry;
     }

     /**
      * Copy the contents of the input APK file to the output APK file. If |rename| is
      * true then non-empty libraries (*.so) in the input will be renamed by prefixing
      * "crazy.". This is done to prevent the Android Package Manager extracting the
      * library. Note the crazy linker itself is not renamed, for bootstrapping reasons.
      * Empty libraries are not renamed (they are in the APK to workaround a bug where
      * the Android Package Manager fails to delete old versions when upgrading).
      * There must be exactly one "crazy" library in the output stream. The "crazy"
      * library will be uncompressed and page aligned in the output stream. Page
      * alignment is implemented by adding a zero filled file, regular alignment is
      * implemented by adding a zero filled extra field to the zip file header. If
      * |addAlignment| is true a page alignment file is added, otherwise the "crazy"
      * library must already be page aligned. Care is taken so that the output is generated
      * in the same way as SignApk. This is important so that running SignApk and
      * zipalign on the output does not break the page alignment. The archive may not
      * contain a "*.apk" as SignApk has special nested signing logic that we do not
      * support.
      *
      * @param in The input APK File.
      * @param out The output APK stream.
      * @param countOut Counting output stream (to measure the current offset).
      * @param addAlignment Whether to add the alignment file or just check.
      * @param rename Whether to rename libraries to be "crazy".
      *
      * @throws IOException if the output file can not be written.
      */
     private static void rezip(
             JarFile in, JarOutputStream out, CountingOutputStream countOut,
             boolean addAlignment, boolean rename) throws IOException {

         List<JarEntry> entries = getOutputFileOrderEntries(in, addAlignment, rename);
         long timestamp = System.currentTimeMillis();
         byte[] buffer = new byte[4096];
         boolean firstEntry = true;
         String prevName = null;
         int numCrazy = 0;
         for (JarEntry inEntry : entries) {
             // Rename files, if specied.
             String name = outputName(inEntry, rename);
             if (name.endsWith(".apk")) {
                 throw new UnsupportedOperationException(
                         "Nested APKs are not supported: " + name);
             }

             // Build the header.
             JarEntry outEntry = null;
             boolean isCrazy = isCrazyLibraryFilename(name);
             if (isCrazy) {
                 // "crazy" libraries are alway output uncompressed (STORED).
                 outEntry = makeStoredEntry(name, inEntry, in);
                 numCrazy++;
                 if (numCrazy > 1) {
                     throw new UnsupportedOperationException(
                             "Found more than one library\n"
                             + "Multiple libraries are not supported for APKs that use "
                             + "'load_library_from_zip'.\n"
                             + "See crbug/388223.\n"
                             + "Note, check that your build is clean.\n"
                             + "An unclean build can incorrectly incorporate old "
                             + "libraries in the APK.");
                 }
             } else if (inEntry.getMethod() == JarEntry.STORED) {
                 // Preserve the STORED method of the input entry.
                 outEntry = new JarEntry(inEntry);
                 outEntry.setExtra(null);
             } else {
                 // Create a new entry so that the compressed len is recomputed.
                 outEntry = new JarEntry(name);
             }
             outEntry.setTime(timestamp);

             // Compute and add alignment
             long offset = countOut.getCount();
             if (firstEntry) {
                 // The first entry in a jar file has an extra field of
                 // four bytes that you can't get rid of; any extra
                 // data you specify in the JarEntry is appended to
                 // these forced four bytes.  This is JAR_MAGIC in
                 // JarOutputStream; the bytes are 0xfeca0000.
                 firstEntry = false;
                 offset += 4;
             }
             if (outEntry.getMethod() == JarEntry.STORED) {
                 if (isCrazy) {
                     if (addAlignment) {
                         addAlignmentFile(offset, timestamp, name, prevName, out);
                     }
                     // We check that we did indeed get to a page boundary.
                     offset = countOut.getCount() + JarFile.LOCHDR + name.length();
                     if ((offset % LIBRARY_ALIGNMENT) != 0) {
                         throw new AssertionError(
                                 "Library was not page aligned when verifying page alignment. "
                                 + "Library name: " + name + " Expected alignment: "
                                 + LIBRARY_ALIGNMENT + "Offset: " + offset + " Error: "
                                 + (offset % LIBRARY_ALIGNMENT));
                     }
                 } else {
                     // This is equivalent to zipalign.
                     offset += JarFile.LOCHDR + name.length();
                     int needed = (ALIGNMENT - (int) (offset % ALIGNMENT)) % ALIGNMENT;
                     if (needed != 0) {
                         outEntry.setExtra(new byte[needed]);
                     }
                 }
             }
             out.putNextEntry(outEntry);

             // Copy the data from the input to the output
             int num;
             InputStream data = in.getInputStream(inEntry);
             while ((num = data.read(buffer)) > 0) {
                 out.write(buffer, 0, num);
             }
             data.close();
             out.closeEntry();
             out.flush();
             prevName = name;
         }
         if (numCrazy == 0) {
             throw new AssertionError("There was no crazy library in the archive");
         }
     }

     private static void usage() {
         System.err.println("Usage: prealignapk (addalignment|reorder) input.apk output.apk");
         System.err.println("\"crazy\" libraries are always inflated in the output");
         System.err.println(
                 "  renamealign  - rename libraries with \"crazy.\" prefix and add alignment file");
         System.err.println("  align        - add alignment file");
         System.err.println("  reorder      - re-creates canonical ordering and checks alignment");
         System.exit(2);
     }

     public static void main(String[] args) throws IOException {
         if (args.length != 3) usage();

         boolean addAlignment = false;
         boolean rename = false;
         if (args[0].equals("renamealign")) {
             // Normal case. Before signing we rename the library and add an alignment file.
             addAlignment = true;
             rename = true;
         } else if (args[0].equals("align")) {
             // LGPL compliance case. Before signing, we add an alignment file to a
             // reconstructed APK which already contains the "crazy" library.
             addAlignment = true;
             rename = false;
         } else if (args[0].equals("reorder")) {
             // Normal case. After jarsigning we write the file in the canonical order and check.
             addAlignment = false;
         } else {
             usage();
         }

         String inputFilename = args[1];
         String outputFilename = args[2];

         JarFile inputJar = null;
         FileOutputStream outputFile = null;

         try {
             inputJar = new JarFile(new File(inputFilename), true);
             outputFile = new FileOutputStream(outputFilename);

             CountingOutputStream outCount = new CountingOutputStream(outputFile);
             JarOutputStream outputJar = new JarOutputStream(outCount);

             // Match the compression level used by SignApk.
             outputJar.setLevel(9);

             rezip(inputJar, outputJar, outCount, addAlignment, rename);
             outputJar.close();
         } finally {
             if (inputJar != null) inputJar.close();
             if (outputFile != null) outputFile.close();
         }
     }
 }
	// Copyright 2014 The Chromium Authors. All rights reserved.
	// Use of this source code is governed by a BSD-style license that can be
	// found in the LICENSE file.

	import java.io.File;
	import java.io.FileOutputStream;
	import java.io.IOException;
	import java.io.InputStream;
	import java.io.OutputStream;
	import java.util.ArrayList;
	import java.util.Collections;
	import java.util.Comparator;
	import java.util.Enumeration;
	import java.util.List;
	import java.util.jar.JarEntry;
	import java.util.jar.JarFile;
	import java.util.jar.JarOutputStream;
	import java.util.regex.Pattern;
	import java.util.zip.CRC32;

	/**
	* Command line tool used to build APKs which support loading the native code library
	* directly from the APK file. To construct the APK we rename the native library by
	* adding the prefix "crazy." to the filename. This is done to prevent the Android
	* Package Manager from extracting the library. The native code must be page aligned
	* and uncompressed. The page alignment is implemented by adding a zero filled file
	* in front of the the native code library. This tool is designed so that running
	* SignApk and/or zipalign on the resulting APK does not break the page alignment.
	* This is achieved by outputing the filenames in the same canonical order used
	* by SignApk and adding the same alignment fields added by zipalign.
	*/
	class RezipApk {
	// Alignment to use for non-compressed files (must match zipalign).
	private static final int ALIGNMENT = 4;

	// Alignment to use for non-compressed *.so files
	private static final int LIBRARY_ALIGNMENT = 4096;

	// Files matching this pattern are not copied to the output when adding alignment.
	// When reordering and verifying the APK they are copied to the end of the file.
	private static Pattern sMetaFilePattern =
	Pattern.compile("^(META-INF/((.*)[.](SF\|RSA\|DSA)\|com/android/otacert))\|("
	+ Pattern.quote(JarFile.MANIFEST_NAME) + ")$");

	// Pattern for matching a shared library in the APK
	private static Pattern sLibraryPattern = Pattern.compile("^lib/[^/]/lib.[.]so$");
	// Pattern for match the crazy linker in the APK
	private static Pattern sCrazyLinkerPattern =
	Pattern.compile("^lib/[^/]*/libchromium_android_linker.so$");
	// Pattern for matching a crazy loaded shared library in the APK
	private static Pattern sCrazyLibraryPattern = Pattern.compile("^lib/[^/]/crazy.lib.[.]so$");

	private static boolean isLibraryFilename(String filename) {
	return sLibraryPattern.matcher(filename).matches()
	&& !sCrazyLinkerPattern.matcher(filename).matches();
	}

	private static boolean isCrazyLibraryFilename(String filename) {
	return sCrazyLibraryPattern.matcher(filename).matches();
	}

	private static String renameLibraryForCrazyLinker(String filename) {
	int lastSlash = filename.lastIndexOf('/');
	// We rename the library, so that the Android Package Manager
	// no longer extracts the library.
	return filename.substring(0, lastSlash + 1) + "crazy." + filename.substring(lastSlash + 1);
	}

	/**
	* Wraps another output stream, counting the number of bytes written.
	*/
	private static class CountingOutputStream extends OutputStream {
	private long mCount = 0;
	private OutputStream mOut;

	public CountingOutputStream(OutputStream out) {
	this.mOut = out;
	}

	/** Returns the number of bytes written. */
	public long getCount() {
	return mCount;
	}

	@Override public void write(byte[] b, int off, int len) throws IOException {
	mOut.write(b, off, len);
	mCount += len;
	}

	@Override public void write(int b) throws IOException {
	mOut.write(b);
	mCount++;
	}

	@Override public void close() throws IOException {
	mOut.close();
	}

	@Override public void flush() throws IOException {
	mOut.flush();
	}
	}

	private static String outputName(JarEntry entry, boolean rename) {
	String inName = entry.getName();
	if (rename && entry.getSize() > 0 && isLibraryFilename(inName)) {
	return renameLibraryForCrazyLinker(inName);
	}
	return inName;
	}

	/**
	* Comparator used to sort jar entries from the input file.
	* Sorting is done based on the output filename (which maybe renamed).
	* Filenames are in natural string order, except that filenames matching
	* the meta-file pattern are always after other files. This is so the manifest
	* and signature are at the end of the file after any alignment file.
	*/
	private static class EntryComparator implements Comparator<JarEntry> {
	private boolean mRename;

	public EntryComparator(boolean rename) {
	mRename = rename;
	}

	@Override
	public int compare(JarEntry j1, JarEntry j2) {
	String o1 = outputName(j1, mRename);
	String o2 = outputName(j2, mRename);
	boolean o1Matches = sMetaFilePattern.matcher(o1).matches();
	boolean o2Matches = sMetaFilePattern.matcher(o2).matches();
	if (o1Matches != o2Matches) {
	return o1Matches ? 1 : -1;
	} else {
	return o1.compareTo(o2);
	}
	}
	}

	// Build an ordered list of jar entries. The jar entries from the input are
	// sorted based on the output filenames (which maybe renamed). If \|omitMetaFiles\|
	// is true do not include the jar entries for the META-INF files.
	// Entries are ordered in the deterministic order used by SignApk.
	private static List<JarEntry> getOutputFileOrderEntries(
	JarFile jar, boolean omitMetaFiles, boolean rename) {
	List<JarEntry> entries = new ArrayList<JarEntry>();
	for (Enumeration<JarEntry> e = jar.entries(); e.hasMoreElements(); ) {
	JarEntry entry = e.nextElement();
	if (entry.isDirectory()) {
	continue;
	}
	if (omitMetaFiles && sMetaFilePattern.matcher(entry.getName()).matches()) {
	continue;
	}
	entries.add(entry);
	}

	// We sort the input entries by name. When present META-INF files
	// are sorted to the end.
	Collections.sort(entries, new EntryComparator(rename));
	return entries;
	}

	/**
	* Add a zero filled alignment file at this point in the zip file,
	* The added file will be added before \|name\| and after \|prevName\|.
	* The size of the alignment file is such that the location of the
	* file \|name\| will be on a LIBRARY_ALIGNMENT boundary.
	*
	* Note this arrangement is devised so that running SignApk and/or zipalign on the resulting
	* file will not alter the alignment.
	*
	* @param offset number of bytes into the output file at this point.
	* @param timestamp time in millis since the epoch to include in the header.
	* @param name the name of the library filename.
	* @param prevName the name of the previous file in the archive (or null).
	* @param out jar output stream to write the alignment file to.
	*
	* @throws IOException if the output file can not be written.
	*/
	private static void addAlignmentFile(
	long offset, long timestamp, String name, String prevName,
	JarOutputStream out) throws IOException {

	// Compute the start and alignment of the library, as if it was next.
	int headerSize = JarFile.LOCHDR + name.length();
	long libOffset = offset + headerSize;
	int libNeeded = LIBRARY_ALIGNMENT - (int) (libOffset % LIBRARY_ALIGNMENT);
	if (libNeeded == LIBRARY_ALIGNMENT) {
	// Already aligned, no need to added alignment file.
	return;
	}

	// Check that there is not another file between the library and the
	// alignment file.
	String alignName = name.substring(0, name.length() - 2) + "align";
	if (prevName != null && prevName.compareTo(alignName) >= 0) {
	throw new UnsupportedOperationException(
	"Unable to insert alignment file, because there is "
	+ "another file in front of the file to be aligned. "
	+ "Other file: " + prevName + " Alignment file: " + alignName
	+ " file: " + name);
	}

	// Compute the size of the alignment file header.
	headerSize = JarFile.LOCHDR + alignName.length();
	// We are going to add an alignment file of type STORED. This file
	// will itself induce a zipalign alignment adjustment.
	int extraNeeded =
	(ALIGNMENT - (int) ((offset + headerSize) % ALIGNMENT)) % ALIGNMENT;
	headerSize += extraNeeded;

	if (libNeeded < headerSize + 1) {
	// The header was bigger than the alignment that we need, add another page.
	libNeeded += LIBRARY_ALIGNMENT;
	}
	// Compute the size of the alignment file.
	libNeeded -= headerSize;

	// Build the header for the alignment file.
	byte[] zeroBuffer = new byte[libNeeded];
	JarEntry alignEntry = new JarEntry(alignName);
	alignEntry.setMethod(JarEntry.STORED);
	alignEntry.setSize(libNeeded);
	alignEntry.setTime(timestamp);
	CRC32 crc = new CRC32();
	crc.update(zeroBuffer);
	alignEntry.setCrc(crc.getValue());

	if (extraNeeded != 0) {
	alignEntry.setExtra(new byte[extraNeeded]);
	}

	// Output the alignment file.
	out.putNextEntry(alignEntry);
	out.write(zeroBuffer);
	out.closeEntry();
	out.flush();
	}

	// Make a JarEntry for the output file which corresponds to the input
	// file. The output file will be called \|name\|. The output file will always
	// be uncompressed (STORED). If the input is not STORED it is necessary to inflate
	// it to compute the CRC and size of the output entry.
	private static JarEntry makeStoredEntry(String name, JarEntry inEntry, JarFile in)
	throws IOException {
	JarEntry outEntry = new JarEntry(name);
	outEntry.setMethod(JarEntry.STORED);

	if (inEntry.getMethod() == JarEntry.STORED) {
	outEntry.setCrc(inEntry.getCrc());
	outEntry.setSize(inEntry.getSize());
	} else {
	// We are inflating the file. We need to compute the CRC and size.
	byte[] buffer = new byte[4096];
	CRC32 crc = new CRC32();
	int size = 0;
	int num;
	InputStream data = in.getInputStream(inEntry);
	while ((num = data.read(buffer)) > 0) {
	crc.update(buffer, 0, num);
	size += num;
	}
	data.close();
	outEntry.setCrc(crc.getValue());
	outEntry.setSize(size);
	}
	return outEntry;
	}

	/**
	* Copy the contents of the input APK file to the output APK file. If \|rename\| is
	* true then non-empty libraries (*.so) in the input will be renamed by prefixing
	* "crazy.". This is done to prevent the Android Package Manager extracting the
	* library. Note the crazy linker itself is not renamed, for bootstrapping reasons.
	* Empty libraries are not renamed (they are in the APK to workaround a bug where
	* the Android Package Manager fails to delete old versions when upgrading).
	* There must be exactly one "crazy" library in the output stream. The "crazy"
	* library will be uncompressed and page aligned in the output stream. Page
	* alignment is implemented by adding a zero filled file, regular alignment is
	* implemented by adding a zero filled extra field to the zip file header. If
	* \|addAlignment\| is true a page alignment file is added, otherwise the "crazy"
	* library must already be page aligned. Care is taken so that the output is generated
	* in the same way as SignApk. This is important so that running SignApk and
	* zipalign on the output does not break the page alignment. The archive may not
	* contain a "*.apk" as SignApk has special nested signing logic that we do not
	* support.
	*
	* @param in The input APK File.
	* @param out The output APK stream.
	* @param countOut Counting output stream (to measure the current offset).
	* @param addAlignment Whether to add the alignment file or just check.
	* @param rename Whether to rename libraries to be "crazy".
	*
	* @throws IOException if the output file can not be written.
	*/
	private static void rezip(
	JarFile in, JarOutputStream out, CountingOutputStream countOut,
	boolean addAlignment, boolean rename) throws IOException {

	List<JarEntry> entries = getOutputFileOrderEntries(in, addAlignment, rename);
	long timestamp = System.currentTimeMillis();
	byte[] buffer = new byte[4096];
	boolean firstEntry = true;
	String prevName = null;
	int numCrazy = 0;
	for (JarEntry inEntry : entries) {
	// Rename files, if specied.
	String name = outputName(inEntry, rename);
	if (name.endsWith(".apk")) {
	throw new UnsupportedOperationException(
	"Nested APKs are not supported: " + name);
	}

	// Build the header.
	JarEntry outEntry = null;
	boolean isCrazy = isCrazyLibraryFilename(name);
	if (isCrazy) {
	// "crazy" libraries are alway output uncompressed (STORED).
	outEntry = makeStoredEntry(name, inEntry, in);
	numCrazy++;
	if (numCrazy > 1) {
	throw new UnsupportedOperationException(
	"Found more than one library\n"
	+ "Multiple libraries are not supported for APKs that use "
	+ "'load_library_from_zip'.\n"
	+ "See crbug/388223.\n"
	+ "Note, check that your build is clean.\n"
	+ "An unclean build can incorrectly incorporate old "
	+ "libraries in the APK.");
	}
	} else if (inEntry.getMethod() == JarEntry.STORED) {
	// Preserve the STORED method of the input entry.
	outEntry = new JarEntry(inEntry);
	outEntry.setExtra(null);
	} else {
	// Create a new entry so that the compressed len is recomputed.
	outEntry = new JarEntry(name);
	}
	outEntry.setTime(timestamp);

	// Compute and add alignment
	long offset = countOut.getCount();
	if (firstEntry) {
	// The first entry in a jar file has an extra field of
	// four bytes that you can't get rid of; any extra
	// data you specify in the JarEntry is appended to
	// these forced four bytes. This is JAR_MAGIC in
	// JarOutputStream; the bytes are 0xfeca0000.
	firstEntry = false;
	offset += 4;
	}
	if (outEntry.getMethod() == JarEntry.STORED) {
	if (isCrazy) {
	if (addAlignment) {
	addAlignmentFile(offset, timestamp, name, prevName, out);
	}
	// We check that we did indeed get to a page boundary.
	offset = countOut.getCount() + JarFile.LOCHDR + name.length();
	if ((offset % LIBRARY_ALIGNMENT) != 0) {
	throw new AssertionError(
	"Library was not page aligned when verifying page alignment. "
	+ "Library name: " + name + " Expected alignment: "
	+ LIBRARY_ALIGNMENT + "Offset: " + offset + " Error: "
	+ (offset % LIBRARY_ALIGNMENT));
	}
	} else {
	// This is equivalent to zipalign.
	offset += JarFile.LOCHDR + name.length();
	int needed = (ALIGNMENT - (int) (offset % ALIGNMENT)) % ALIGNMENT;
	if (needed != 0) {
	outEntry.setExtra(new byte[needed]);
	}
	}
	}
	out.putNextEntry(outEntry);

	// Copy the data from the input to the output
	int num;
	InputStream data = in.getInputStream(inEntry);
	while ((num = data.read(buffer)) > 0) {
	out.write(buffer, 0, num);
	}
	data.close();
	out.closeEntry();
	out.flush();
	prevName = name;
	}
	if (numCrazy == 0) {
	throw new AssertionError("There was no crazy library in the archive");
	}
	}

	private static void usage() {
	System.err.println("Usage: prealignapk (addalignment\|reorder) input.apk output.apk");
	System.err.println("\"crazy\" libraries are always inflated in the output");
	System.err.println(
	" renamealign - rename libraries with \"crazy.\" prefix and add alignment file");
	System.err.println(" align - add alignment file");
	System.err.println(" reorder - re-creates canonical ordering and checks alignment");
	System.exit(2);
	}

	public static void main(String[] args) throws IOException {
	if (args.length != 3) usage();

	boolean addAlignment = false;
	boolean rename = false;
	if (args[0].equals("renamealign")) {
	// Normal case. Before signing we rename the library and add an alignment file.
	addAlignment = true;
	rename = true;
	} else if (args[0].equals("align")) {
	// LGPL compliance case. Before signing, we add an alignment file to a
	// reconstructed APK which already contains the "crazy" library.
	addAlignment = true;
	rename = false;
	} else if (args[0].equals("reorder")) {
	// Normal case. After jarsigning we write the file in the canonical order and check.
	addAlignment = false;
	} else {
	usage();
	}

	String inputFilename = args[1];
	String outputFilename = args[2];

	JarFile inputJar = null;
	FileOutputStream outputFile = null;

	try {
	inputJar = new JarFile(new File(inputFilename), true);
	outputFile = new FileOutputStream(outputFilename);

	CountingOutputStream outCount = new CountingOutputStream(outputFile);
	JarOutputStream outputJar = new JarOutputStream(outCount);

	// Match the compression level used by SignApk.
	outputJar.setLevel(9);

	rezip(inputJar, outputJar, outCount, addAlignment, rename);
	outputJar.close();
	} finally {
	if (inputJar != null) inputJar.close();
	if (outputFile != null) outputFile.close();
	}
	}
	}