luni/src/main/java/java/util/jar/JarInputStream.java - platform/libcore - Git at Google

 /*
  * Licensed to the Apache Software Foundation (ASF) under one or more
  * contributor license agreements.  See the NOTICE file distributed with
  * this work for additional information regarding copyright ownership.
  * The ASF licenses this file to You 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 java.util.jar;

 import java.io.ByteArrayOutputStream;
 import java.io.IOException;
 import java.io.InputStream;
 import java.io.OutputStream;
 import java.util.HashMap;
 import java.util.Locale;
 import java.util.zip.ZipEntry;
 import java.util.zip.ZipInputStream;
 import libcore.io.Streams;

 /**
  * The input stream from which the JAR file to be read may be fetched. It is
  * used like the {@code ZipInputStream}.
  *
  * @see ZipInputStream
  */
 // TODO: The semantics provided by this class are really weird. The jar file
 // spec does not impose any ordering constraints on the entries of a jar file.
 // In particular, the Manifest and META-INF directory *need not appear first*. This
 // class will silently skip certificate checks for jar files where the manifest
 // isn't the first entry. To do this correctly, we need O(input_stream_length) memory.
 public class JarInputStream extends ZipInputStream {

     private Manifest manifest;

     private boolean verified = false;

     private JarEntry currentJarEntry;

     private JarEntry pendingJarEntry;

     private boolean isMeta;

     private JarVerifier verifier;

     private OutputStream verStream;

     /**
      * Constructs a new {@code JarInputStream} from an input stream.
      *
      * @param stream
      *            the input stream containing the JAR file.
      * @param verify
      *            if the file should be verified with a {@code JarVerifier}.
      * @throws IOException
      *             If an error occurs reading entries from the input stream.
      * @see ZipInputStream#ZipInputStream(InputStream)
      */
     public JarInputStream(InputStream stream, boolean verify) throws IOException {
         super(stream);

         verifier = null;
         pendingJarEntry = null;
         currentJarEntry = null;

         if (getNextJarEntry() == null) {
             return;
         }

         if (currentJarEntry.getName().equalsIgnoreCase(JarFile.META_DIR)) {
             // Fetch the next entry, in the hope that it's the manifest file.
             closeEntry();
             getNextJarEntry();
         }

         if (currentJarEntry.getName().equalsIgnoreCase(JarFile.MANIFEST_NAME)) {
             final byte[] manifestBytes = Streams.readFullyNoClose(this);
             manifest = new Manifest(manifestBytes, verify);
             closeEntry();

             if (verify) {
                 HashMap<String, byte[]> metaEntries = new HashMap<String, byte[]>();
                 metaEntries.put(JarFile.MANIFEST_NAME, manifestBytes);
                 verifier = new JarVerifier("JarInputStream", manifest, metaEntries);
             }
         }

         // There was no manifest available, so we should return the current
         // entry the next time getNextEntry is called.
         pendingJarEntry = currentJarEntry;
         currentJarEntry = null;

         // If the manifest isn't the first entry, we will not have enough
         // information to perform verification on entries that precede it.
         //
         // TODO: Should we throw if verify == true in this case ?
         // TODO: We need all meta entries to be placed before the manifest
         // as well.
     }

     /**
      * Constructs a new {@code JarInputStream} from an input stream.
      *
      * @param stream
      *            the input stream containing the JAR file.
      * @throws IOException
      *             If an error occurs reading entries from the input stream.
      * @see ZipInputStream#ZipInputStream(InputStream)
      */
     public JarInputStream(InputStream stream) throws IOException {
         this(stream, true);
     }

     /**
      * Returns the {@code Manifest} object associated with this {@code
      * JarInputStream} or {@code null} if no manifest entry exists.
      *
      * @return the MANIFEST specifying the contents of the JAR file.
      */
     public Manifest getManifest() {
         return manifest;
     }

     /**
      * Returns the next {@code JarEntry} contained in this stream or {@code
      * null} if no more entries are present.
      *
      * @return the next JAR entry.
      * @throws IOException
      *             if an error occurs while reading the entry.
      */
     public JarEntry getNextJarEntry() throws IOException {
         return (JarEntry) getNextEntry();
     }

     /**
      * Reads up to {@code byteCount} bytes of decompressed data and stores it in
      * {@code buffer} starting at {@code byteOffset}. Returns the number of uncompressed bytes read.
      *
      * @throws IOException
      *             if an IOException occurs.
      */
     @Override
     public int read(byte[] buffer, int byteOffset, int byteCount) throws IOException {
         if (currentJarEntry == null) {
             return -1;
         }

         int r = super.read(buffer, byteOffset, byteCount);
         // verifier can be null if we've been asked not to verify or if
         // the manifest wasn't found.
         //
         // verStream will be null if we're reading the manifest or if we have
         // no signatures or if the digest for this entry isn't present in the
         // manifest.
         if (verifier != null && verStream != null && !verified) {
             if (r == -1) {
                 // We've hit the end of this stream for the first time, so attempt
                 // a verification.
                 verified = true;
                 if (isMeta) {
                     verifier.addMetaEntry(currentJarEntry.getName(),
                             ((ByteArrayOutputStream) verStream).toByteArray());
                     try {
                         verifier.readCertificates();
                     } catch (SecurityException e) {
                         verifier = null;
                         throw e;
                     }
                 } else {
                     ((JarVerifier.VerifierEntry) verStream).verify();
                 }
             } else {
                 verStream.write(buffer, byteOffset, r);
             }
         }

         return r;
     }

     /**
      * Returns the next {@code ZipEntry} contained in this stream or {@code
      * null} if no more entries are present.
      *
      * @return the next extracted ZIP entry.
      * @throws IOException
      *             if an error occurs while reading the entry.
      */
     @Override
     public ZipEntry getNextEntry() throws IOException {
         // NOTE: This function must update the value of currentJarEntry
         // as a side effect.

         if (pendingJarEntry != null) {
             JarEntry pending = pendingJarEntry;
             pendingJarEntry = null;
             currentJarEntry = pending;
             return pending;
         }

         currentJarEntry = (JarEntry) super.getNextEntry();
         if (currentJarEntry == null) {
             return null;
         }

         if (verifier != null) {
             isMeta = currentJarEntry.getName().toUpperCase(Locale.US).startsWith(JarFile.META_DIR);
             if (isMeta) {
                 final int entrySize = (int) currentJarEntry.getSize();
                 verStream = new ByteArrayOutputStream(entrySize > 0 ? entrySize : 8192);
             } else {
                 verStream = verifier.initEntry(currentJarEntry.getName());
             }
         }

         verified = false;
         return currentJarEntry;
     }

     @Override
     public void closeEntry() throws IOException {
         // NOTE: This was the old behavior. A call to closeEntry() before the
         // first call to getNextEntry should be a no-op. If we don't return early
         // here, the super class will close pendingJarEntry for us and reads will
         // fail.
         if (pendingJarEntry != null) {
             return;
         }

         super.closeEntry();
         currentJarEntry = null;
     }

     @Override
     protected ZipEntry createZipEntry(String name) {
         JarEntry entry = new JarEntry(name);
         if (manifest != null) {
             entry.setAttributes(manifest.getAttributes(name));
         }
         return entry;
     }
 }
	/*
	* Licensed to the Apache Software Foundation (ASF) under one or more
	* contributor license agreements. See the NOTICE file distributed with
	* this work for additional information regarding copyright ownership.
	* The ASF licenses this file to You 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 java.util.jar;

	import java.io.ByteArrayOutputStream;
	import java.io.IOException;
	import java.io.InputStream;
	import java.io.OutputStream;
	import java.util.HashMap;
	import java.util.Locale;
	import java.util.zip.ZipEntry;
	import java.util.zip.ZipInputStream;
	import libcore.io.Streams;

	/**
	* The input stream from which the JAR file to be read may be fetched. It is
	* used like the {@code ZipInputStream}.
	*
	* @see ZipInputStream
	*/
	// TODO: The semantics provided by this class are really weird. The jar file
	// spec does not impose any ordering constraints on the entries of a jar file.
	// In particular, the Manifest and META-INF directory need not appear first. This
	// class will silently skip certificate checks for jar files where the manifest
	// isn't the first entry. To do this correctly, we need O(input_stream_length) memory.
	public class JarInputStream extends ZipInputStream {

	private Manifest manifest;

	private boolean verified = false;

	private JarEntry currentJarEntry;

	private JarEntry pendingJarEntry;

	private boolean isMeta;

	private JarVerifier verifier;

	private OutputStream verStream;

	/**
	* Constructs a new {@code JarInputStream} from an input stream.
	*
	* @param stream
	* the input stream containing the JAR file.
	* @param verify
	* if the file should be verified with a {@code JarVerifier}.
	* @throws IOException
	* If an error occurs reading entries from the input stream.
	* @see ZipInputStream#ZipInputStream(InputStream)
	*/
	public JarInputStream(InputStream stream, boolean verify) throws IOException {
	super(stream);

	verifier = null;
	pendingJarEntry = null;
	currentJarEntry = null;

	if (getNextJarEntry() == null) {
	return;
	}

	if (currentJarEntry.getName().equalsIgnoreCase(JarFile.META_DIR)) {
	// Fetch the next entry, in the hope that it's the manifest file.
	closeEntry();
	getNextJarEntry();
	}

	if (currentJarEntry.getName().equalsIgnoreCase(JarFile.MANIFEST_NAME)) {
	final byte[] manifestBytes = Streams.readFullyNoClose(this);
	manifest = new Manifest(manifestBytes, verify);
	closeEntry();

	if (verify) {
	HashMap<String, byte[]> metaEntries = new HashMap<String, byte[]>();
	metaEntries.put(JarFile.MANIFEST_NAME, manifestBytes);
	verifier = new JarVerifier("JarInputStream", manifest, metaEntries);
	}
	}

	// There was no manifest available, so we should return the current
	// entry the next time getNextEntry is called.
	pendingJarEntry = currentJarEntry;
	currentJarEntry = null;

	// If the manifest isn't the first entry, we will not have enough
	// information to perform verification on entries that precede it.
	//
	// TODO: Should we throw if verify == true in this case ?
	// TODO: We need all meta entries to be placed before the manifest
	// as well.
	}

	/**
	* Constructs a new {@code JarInputStream} from an input stream.
	*
	* @param stream
	* the input stream containing the JAR file.
	* @throws IOException
	* If an error occurs reading entries from the input stream.
	* @see ZipInputStream#ZipInputStream(InputStream)
	*/
	public JarInputStream(InputStream stream) throws IOException {
	this(stream, true);
	}

	/**
	* Returns the {@code Manifest} object associated with this {@code
	* JarInputStream} or {@code null} if no manifest entry exists.
	*
	* @return the MANIFEST specifying the contents of the JAR file.
	*/
	public Manifest getManifest() {
	return manifest;
	}

	/**
	* Returns the next {@code JarEntry} contained in this stream or {@code
	* null} if no more entries are present.
	*
	* @return the next JAR entry.
	* @throws IOException
	* if an error occurs while reading the entry.
	*/
	public JarEntry getNextJarEntry() throws IOException {
	return (JarEntry) getNextEntry();
	}

	/**
	* Reads up to {@code byteCount} bytes of decompressed data and stores it in
	* {@code buffer} starting at {@code byteOffset}. Returns the number of uncompressed bytes read.
	*
	* @throws IOException
	* if an IOException occurs.
	*/
	@Override
	public int read(byte[] buffer, int byteOffset, int byteCount) throws IOException {
	if (currentJarEntry == null) {
	return -1;
	}

	int r = super.read(buffer, byteOffset, byteCount);
	// verifier can be null if we've been asked not to verify or if
	// the manifest wasn't found.
	//
	// verStream will be null if we're reading the manifest or if we have
	// no signatures or if the digest for this entry isn't present in the
	// manifest.
	if (verifier != null && verStream != null && !verified) {
	if (r == -1) {
	// We've hit the end of this stream for the first time, so attempt
	// a verification.
	verified = true;
	if (isMeta) {
	verifier.addMetaEntry(currentJarEntry.getName(),
	((ByteArrayOutputStream) verStream).toByteArray());
	try {
	verifier.readCertificates();
	} catch (SecurityException e) {
	verifier = null;
	throw e;
	}
	} else {
	((JarVerifier.VerifierEntry) verStream).verify();
	}
	} else {
	verStream.write(buffer, byteOffset, r);
	}
	}

	return r;
	}

	/**
	* Returns the next {@code ZipEntry} contained in this stream or {@code
	* null} if no more entries are present.
	*
	* @return the next extracted ZIP entry.
	* @throws IOException
	* if an error occurs while reading the entry.
	*/
	@Override
	public ZipEntry getNextEntry() throws IOException {
	// NOTE: This function must update the value of currentJarEntry
	// as a side effect.

	if (pendingJarEntry != null) {
	JarEntry pending = pendingJarEntry;
	pendingJarEntry = null;
	currentJarEntry = pending;
	return pending;
	}

	currentJarEntry = (JarEntry) super.getNextEntry();
	if (currentJarEntry == null) {
	return null;
	}

	if (verifier != null) {
	isMeta = currentJarEntry.getName().toUpperCase(Locale.US).startsWith(JarFile.META_DIR);
	if (isMeta) {
	final int entrySize = (int) currentJarEntry.getSize();
	verStream = new ByteArrayOutputStream(entrySize > 0 ? entrySize : 8192);
	} else {
	verStream = verifier.initEntry(currentJarEntry.getName());
	}
	}

	verified = false;
	return currentJarEntry;
	}

	@Override
	public void closeEntry() throws IOException {
	// NOTE: This was the old behavior. A call to closeEntry() before the
	// first call to getNextEntry should be a no-op. If we don't return early
	// here, the super class will close pendingJarEntry for us and reads will
	// fail.
	if (pendingJarEntry != null) {
	return;
	}

	super.closeEntry();
	currentJarEntry = null;
	}

	@Override
	protected ZipEntry createZipEntry(String name) {
	JarEntry entry = new JarEntry(name);
	if (manifest != null) {
	entry.setAttributes(manifest.getAttributes(name));
	}
	return entry;
	}
	}