Add sources for API 35 Downloaded from https://dl.google.com/android/repository/source-35_r01.zip using SdkManager in Studio Test: None Change-Id: I83f78aa820b66edfdc9f8594d17bc7b6cacccec1
diff --git a/android-35/java/util/zip/ZipFile.java b/android-35/java/util/zip/ZipFile.java new file mode 100644 index 0000000..ee23e55 --- /dev/null +++ b/android-35/java/util/zip/ZipFile.java
@@ -0,0 +1,1941 @@ +/* + * Copyright (C) 2014 The Android Open Source Project + * Copyright (c) 1995, 2021, Oracle and/or its affiliates. All rights reserved. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * This code is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License version 2 only, as + * published by the Free Software Foundation. Oracle designates this + * particular file as subject to the "Classpath" exception as provided + * by Oracle in the LICENSE file that accompanied this code. + * + * This code is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * version 2 for more details (a copy is included in the LICENSE file that + * accompanied this code). + * + * You should have received a copy of the GNU General Public License version + * 2 along with this work; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA + * or visit www.oracle.com if you need additional information or have any + * questions. + */ + +package java.util.zip; + +import java.io.Closeable; +import java.io.InputStream; +import java.io.IOException; +import java.io.EOFException; +import java.io.File; +import java.io.FileNotFoundException; +import java.io.RandomAccessFile; +import java.io.UncheckedIOException; +import java.lang.ref.Cleaner.Cleanable; +import java.nio.charset.CharacterCodingException; +import java.nio.charset.Charset; +import java.nio.charset.StandardCharsets; +import java.nio.file.InvalidPathException; +import java.nio.file.attribute.BasicFileAttributes; +import java.nio.file.Files; +import java.util.ArrayDeque; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.Collections; +import java.util.Deque; +import java.util.Enumeration; +import java.util.HashMap; +import java.util.HashSet; +import java.util.Iterator; +import java.util.List; +import java.util.Locale; +import java.util.Objects; +import java.util.NoSuchElementException; +import java.util.Set; +import java.util.Spliterator; +import java.util.Spliterators; +import java.util.TreeSet; +import java.util.WeakHashMap; +import java.util.function.Consumer; +import java.util.function.IntFunction; +import java.util.jar.JarEntry; +import java.util.jar.JarFile; +import java.util.stream.Stream; +import java.util.stream.StreamSupport; +import jdk.internal.access.SharedSecrets; +import jdk.internal.misc.VM; +import jdk.internal.ref.CleanerFactory; +import jdk.internal.vm.annotation.Stable; +import sun.security.util.SignatureFileVerifier; + +import dalvik.system.CloseGuard; +import dalvik.system.ZipPathValidator; + +import static java.util.zip.ZipConstants64.*; +import static java.util.zip.ZipUtils.*; + +/** + * This class is used to read entries from a zip file. + * + * <p> Unless otherwise noted, passing a {@code null} argument to a constructor + * or method in this class will cause a {@link NullPointerException} to be + * thrown. + * + * @apiNote + * To release resources used by this {@code ZipFile}, the {@link #close()} method + * should be called explicitly or by try-with-resources. Subclasses are responsible + * for the cleanup of resources acquired by the subclass. Subclasses that override + * {@link #finalize()} in order to perform cleanup should be modified to use alternative + * cleanup mechanisms such as {@link java.lang.ref.Cleaner} and remove the overriding + * {@code finalize} method. + * + * @author David Connelly + * @since 1.1 + */ +public class ZipFile implements ZipConstants, Closeable { + + private final String name; // zip file name + private volatile boolean closeRequested; + + // The "resource" used by this zip file that needs to be + // cleaned after use. + // a) the input streams that need to be closed + // b) the list of cached Inflater objects + // c) the "native" source of this zip file. + private final @Stable CleanableResource res; + + // Android-added: CloseGuard support. + private final CloseGuard guard = CloseGuard.get(); + + private static final int STORED = ZipEntry.STORED; + private static final int DEFLATED = ZipEntry.DEFLATED; + + /** + * Mode flag to open a zip file for reading. + */ + public static final int OPEN_READ = 0x1; + + /** + * Mode flag to open a zip file and mark it for deletion. The file will be + * deleted some time between the moment that it is opened and the moment + * that it is closed, but its contents will remain accessible via the + * {@code ZipFile} object until either the close method is invoked or the + * virtual machine exits. + */ + public static final int OPEN_DELETE = 0x4; + + // Android-changed: Additional ZipException throw scenario with ZipPathValidator. + /** + * Opens a zip file for reading. + * + * <p>First, if there is a security manager, its {@code checkRead} + * method is called with the {@code name} argument as its argument + * to ensure the read is allowed. + * + * <p>The UTF-8 {@link java.nio.charset.Charset charset} is used to + * decode the entry names and comments. + * + * <p>If the app targets Android U or above, zip file entry names containing + * ".." or starting with "/" passed here will throw a {@link ZipException}. + * For more details, see {@link dalvik.system.ZipPathValidator}. + * + * @param name the name of the zip file + * @throws ZipException if (1) a ZIP format error has occurred or + * (2) <code>targetSdkVersion >= BUILD.VERSION_CODES.UPSIDE_DOWN_CAKE</code> + * and (the <code>name</code> argument contains ".." or starts with "/"). + * @throws IOException if an I/O error has occurred + * @throws SecurityException if a security manager exists and its + * {@code checkRead} method doesn't allow read access to the file. + * + * @see SecurityManager#checkRead(java.lang.String) + */ + public ZipFile(String name) throws IOException { + this(new File(name), OPEN_READ); + } + + /** + * Opens a new {@code ZipFile} to read from the specified + * {@code File} object in the specified mode. The mode argument + * must be either {@code OPEN_READ} or {@code OPEN_READ | OPEN_DELETE}. + * + * <p>First, if there is a security manager, its {@code checkRead} + * method is called with the {@code name} argument as its argument to + * ensure the read is allowed. + * + * <p>The UTF-8 {@link java.nio.charset.Charset charset} is used to + * decode the entry names and comments + * + * @param file the ZIP file to be opened for reading + * @param mode the mode in which the file is to be opened + * @throws ZipException if a ZIP format error has occurred + * @throws IOException if an I/O error has occurred + * @throws SecurityException if a security manager exists and + * its {@code checkRead} method + * doesn't allow read access to the file, + * or its {@code checkDelete} method doesn't allow deleting + * the file when the {@code OPEN_DELETE} flag is set. + * @throws IllegalArgumentException if the {@code mode} argument is invalid + * @see SecurityManager#checkRead(java.lang.String) + * @since 1.3 + */ + public ZipFile(File file, int mode) throws IOException { + // Android-changed: Use StandardCharsets.UTF_8. + // this(file, mode, UTF_8.INSTANCE); + this(file, mode, StandardCharsets.UTF_8); + } + + /** + * Opens a ZIP file for reading given the specified File object. + * + * <p>The UTF-8 {@link java.nio.charset.Charset charset} is used to + * decode the entry names and comments. + * + * @param file the ZIP file to be opened for reading + * @throws ZipException if a ZIP format error has occurred + * @throws IOException if an I/O error has occurred + */ + public ZipFile(File file) throws ZipException, IOException { + this(file, OPEN_READ); + } + + // Android-changed: Use of the hidden constructor with a new argument for zip path validation. + /** + * Opens a new {@code ZipFile} to read from the specified + * {@code File} object in the specified mode. The mode argument + * must be either {@code OPEN_READ} or {@code OPEN_READ | OPEN_DELETE}. + * + * <p>First, if there is a security manager, its {@code checkRead} + * method is called with the {@code name} argument as its argument to + * ensure the read is allowed. + * + * @param file the ZIP file to be opened for reading + * @param mode the mode in which the file is to be opened + * @param charset + * the {@linkplain java.nio.charset.Charset charset} to + * be used to decode the ZIP entry name and comment that are not + * encoded by using UTF-8 encoding (indicated by entry's general + * purpose flag). + * + * @throws ZipException if a ZIP format error has occurred + * @throws IOException if an I/O error has occurred + * + * @throws SecurityException + * if a security manager exists and its {@code checkRead} + * method doesn't allow read access to the file,or its + * {@code checkDelete} method doesn't allow deleting the + * file when the {@code OPEN_DELETE} flag is set + * + * @throws IllegalArgumentException if the {@code mode} argument is invalid + * + * @see SecurityManager#checkRead(java.lang.String) + * + * @since 1.7 + */ + public ZipFile(File file, int mode, Charset charset) throws IOException + { + this(file, mode, charset, /* enableZipPathValidator */ true); + } + + // Android-added: New hidden constructor with an argument for zip path validation. + /** @hide */ + public ZipFile(File file, int mode, boolean enableZipPathValidator) throws IOException { + this(file, mode, StandardCharsets.UTF_8, enableZipPathValidator); + } + + // Android-changed: Change existing constructor ZipFile(File file, int mode, Charset charset) + // to have a new argument enableZipPathValidator in order to set the isZipPathValidatorEnabled + // variable before calling the native method open(). + /** @hide */ + public ZipFile(File file, int mode, Charset charset, boolean enableZipPathValidator) + throws IOException { + if (((mode & OPEN_READ) == 0) || + ((mode & ~(OPEN_READ | OPEN_DELETE)) != 0)) { + throw new IllegalArgumentException("Illegal mode: 0x"+ + Integer.toHexString(mode)); + } + String name = file.getPath(); + file = new File(name); + // Android-removed: SecurityManager is always null. + /* + @SuppressWarnings("removal") + SecurityManager sm = System.getSecurityManager(); + if (sm != null) { + sm.checkRead(name); + if ((mode & OPEN_DELETE) != 0) { + sm.checkDelete(name); + } + } + */ + + Objects.requireNonNull(charset, "charset"); + + this.name = name; + // Android-removed: Skip perf counters. + // long t0 = System.nanoTime(); + + // Android-changed: pass isZipPathValidatorEnabled flag. + // this.res = new CleanableResource(this, ZipCoder.get(charset), file, mode); + boolean isZipPathValidatorEnabled = enableZipPathValidator && !ZipPathValidator.isClear(); + this.res = new CleanableResource( + this, ZipCoder.get(charset), file, mode, isZipPathValidatorEnabled); + + // Android-removed: Skip perf counters. + // PerfCounter.getZipFileOpenTime().addElapsedTimeFrom(t0); + // PerfCounter.getZipFileCount().increment(); + } + + /** + * Opens a zip file for reading. + * + * <p>First, if there is a security manager, its {@code checkRead} + * method is called with the {@code name} argument as its argument + * to ensure the read is allowed. + * + * @param name the name of the zip file + * @param charset + * the {@linkplain java.nio.charset.Charset charset} to + * be used to decode the ZIP entry name and comment that are not + * encoded by using UTF-8 encoding (indicated by entry's general + * purpose flag). + * + * @throws ZipException if a ZIP format error has occurred + * @throws IOException if an I/O error has occurred + * @throws SecurityException + * if a security manager exists and its {@code checkRead} + * method doesn't allow read access to the file + * + * @see SecurityManager#checkRead(java.lang.String) + * + * @since 1.7 + */ + public ZipFile(String name, Charset charset) throws IOException + { + this(new File(name), OPEN_READ, charset); + } + + /** + * Opens a ZIP file for reading given the specified File object. + * + * @param file the ZIP file to be opened for reading + * @param charset + * The {@linkplain java.nio.charset.Charset charset} to be + * used to decode the ZIP entry name and comment (ignored if + * the <a href="package-summary.html#lang_encoding"> language + * encoding bit</a> of the ZIP entry's general purpose bit + * flag is set). + * + * @throws ZipException if a ZIP format error has occurred + * @throws IOException if an I/O error has occurred + * + * @since 1.7 + */ + public ZipFile(File file, Charset charset) throws IOException + { + this(file, OPEN_READ, charset); + } + + /** + * Returns the zip file comment, or null if none. + * + * @return the comment string for the zip file, or null if none + * + * @throws IllegalStateException if the zip file has been closed + * + * @since 1.7 + */ + public String getComment() { + synchronized (this) { + ensureOpen(); + if (res.zsrc.comment == null) { + return null; + } + return res.zsrc.zc.toString(res.zsrc.comment); + } + } + + /** + * Returns the zip file entry for the specified name, or null + * if not found. + * + * @param name the name of the entry + * @return the zip file entry, or null if not found + * @throws IllegalStateException if the zip file has been closed + */ + public ZipEntry getEntry(String name) { + Objects.requireNonNull(name, "name"); + ZipEntry entry = null; + synchronized (this) { + ensureOpen(); + int pos = res.zsrc.getEntryPos(name, true); + if (pos != -1) { + entry = getZipEntry(name, pos); + } + } + return entry; + } + + /** + * 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 + * @throws IllegalStateException if the zip file has been closed + */ + public InputStream getInputStream(ZipEntry entry) throws IOException { + Objects.requireNonNull(entry, "entry"); + int pos; + ZipFileInputStream in; + Source zsrc = res.zsrc; + Set<InputStream> istreams = res.istreams; + synchronized (this) { + ensureOpen(); + if (Objects.equals(lastEntryName, entry.name)) { + pos = lastEntryPos; + } else { + pos = zsrc.getEntryPos(entry.name, false); + } + if (pos == -1) { + return null; + } + in = new ZipFileInputStream(zsrc.cen, pos); + switch (CENHOW(zsrc.cen, pos)) { + case STORED: + synchronized (istreams) { + istreams.add(in); + } + return in; + case DEFLATED: + // Inflater likes a bit of slack + // MORE: Compute good size for inflater stream: + long size = CENLEN(zsrc.cen, pos) + 2; + if (size > 65536) { + // Android-changed: Use 64k buffer size, performs + // better than 8k. See http://b/65491407. + // size = 8192; + size = 65536; + } + if (size <= 0) { + size = 4096; + } + InputStream is = new ZipFileInflaterInputStream(in, res, (int)size); + synchronized (istreams) { + istreams.add(is); + } + return is; + default: + throw new ZipException("invalid compression method"); + } + } + } + + private static class InflaterCleanupAction implements Runnable { + private final Inflater inf; + private final CleanableResource res; + + InflaterCleanupAction(Inflater inf, CleanableResource res) { + this.inf = inf; + this.res = res; + } + + @Override + public void run() { + res.releaseInflater(inf); + } + } + + private class ZipFileInflaterInputStream extends InflaterInputStream { + private volatile boolean closeRequested; + private boolean eof = false; + private final Cleanable cleanable; + + ZipFileInflaterInputStream(ZipFileInputStream zfin, + CleanableResource res, int size) { + this(zfin, res, res.getInflater(), size); + } + + private ZipFileInflaterInputStream(ZipFileInputStream zfin, + CleanableResource res, + Inflater inf, int size) { + // Android-changed: ZipFileInflaterInputStream does not control its inflater's lifetime + // and hence it shouldn't be closed when the stream is closed. + // super(zfin, inf, size); + super(zfin, inf, size, /* ownsInflater */ false); + this.cleanable = CleanerFactory.cleaner().register(this, + new InflaterCleanupAction(inf, res)); + } + + public void close() throws IOException { + if (closeRequested) + return; + closeRequested = true; + super.close(); + synchronized (res.istreams) { + res.istreams.remove(this); + } + cleanable.clean(); + } + + // Override fill() method to provide an extra "dummy" byte + // at the end of the input stream. This is required when + // using the "nowrap" Inflater option. + protected void fill() throws IOException { + if (eof) { + throw new EOFException("Unexpected end of ZLIB input stream"); + } + len = in.read(buf, 0, buf.length); + if (len == -1) { + buf[0] = 0; + len = 1; + eof = true; + } + inf.setInput(buf, 0, len); + } + + public int available() throws IOException { + if (closeRequested) + return 0; + long avail = ((ZipFileInputStream)in).size() - inf.getBytesWritten(); + return (avail > (long) Integer.MAX_VALUE ? + Integer.MAX_VALUE : (int) avail); + } + } + + /** + * Returns the path name of the ZIP file. + * @return the path name of the ZIP file + */ + public String getName() { + return name; + } + + private class ZipEntryIterator<T extends ZipEntry> + implements Enumeration<T>, Iterator<T> { + + private int i = 0; + private final int entryCount; + + public ZipEntryIterator(int entryCount) { + this.entryCount = entryCount; + } + + @Override + public boolean hasMoreElements() { + return hasNext(); + } + + @Override + public boolean hasNext() { + // Android-changed: check that file is open. + // return i < entryCount; + synchronized (ZipFile.this) { + ensureOpen(); + return i < entryCount; + } + } + + @Override + public T nextElement() { + return next(); + } + + @Override + @SuppressWarnings("unchecked") + public T next() { + synchronized (ZipFile.this) { + ensureOpen(); + if (!hasNext()) { + throw new NoSuchElementException(); + } + // each "entry" has 3 ints in table entries + return (T)getZipEntry(null, res.zsrc.getEntryPos(i++ * 3)); + } + } + + @Override + public Iterator<T> asIterator() { + return this; + } + } + + /** + * Returns an enumeration of the ZIP file entries. + * @return an enumeration of the ZIP file entries + * @throws IllegalStateException if the zip file has been closed + */ + public Enumeration<? extends ZipEntry> entries() { + synchronized (this) { + ensureOpen(); + return new ZipEntryIterator<ZipEntry>(res.zsrc.total); + } + } + + private Enumeration<JarEntry> jarEntries() { + synchronized (this) { + ensureOpen(); + return new ZipEntryIterator<JarEntry>(res.zsrc.total); + } + } + + private class EntrySpliterator<T> extends Spliterators.AbstractSpliterator<T> { + private int index; + private final int fence; + private final IntFunction<T> gen; + + EntrySpliterator(int index, int fence, IntFunction<T> gen) { + super((long)fence, + Spliterator.ORDERED | Spliterator.DISTINCT | Spliterator.IMMUTABLE | + Spliterator.NONNULL); + this.index = index; + this.fence = fence; + this.gen = gen; + } + + @Override + public boolean tryAdvance(Consumer<? super T> action) { + if (action == null) + throw new NullPointerException(); + if (index >= 0 && index < fence) { + synchronized (ZipFile.this) { + ensureOpen(); + action.accept(gen.apply(res.zsrc.getEntryPos(index++ * 3))); + } + return true; + } + return false; + } + } + + /** + * Returns an ordered {@code Stream} over the ZIP file entries. + * + * Entries appear in the {@code Stream} in the order they appear in + * the central directory of the ZIP file. + * + * @return an ordered {@code Stream} of entries in this ZIP file + * @throws IllegalStateException if the zip file has been closed + * @since 1.8 + */ + public Stream<? extends ZipEntry> stream() { + synchronized (this) { + ensureOpen(); + return StreamSupport.stream(new EntrySpliterator<>(0, res.zsrc.total, + pos -> getZipEntry(null, pos)), false); + } + } + + private String getEntryName(int pos) { + byte[] cen = res.zsrc.cen; + int nlen = CENNAM(cen, pos); + ZipCoder zc = res.zsrc.zipCoderForPos(pos); + return zc.toString(cen, pos + CENHDR, nlen); + } + + /* + * Returns an ordered {@code Stream} over the zip file entry names. + * + * Entry names appear in the {@code Stream} in the order they appear in + * the central directory of the ZIP file. + * + * @return an ordered {@code Stream} of entry names in this zip file + * @throws IllegalStateException if the zip file has been closed + * @since 10 + */ + private Stream<String> entryNameStream() { + synchronized (this) { + ensureOpen(); + return StreamSupport.stream( + new EntrySpliterator<>(0, res.zsrc.total, this::getEntryName), false); + } + } + + /* + * Returns an ordered {@code Stream} over the zip file entries. + * + * Entries appear in the {@code Stream} in the order they appear in + * the central directory of the jar file. + * + * @return an ordered {@code Stream} of entries in this zip file + * @throws IllegalStateException if the zip file has been closed + * @since 10 + */ + private Stream<JarEntry> jarStream() { + synchronized (this) { + ensureOpen(); + return StreamSupport.stream(new EntrySpliterator<>(0, res.zsrc.total, + pos -> (JarEntry)getZipEntry(null, pos)), false); + } + } + + private String lastEntryName; + private int lastEntryPos; + + /* Check ensureOpen() before invoking this method */ + private ZipEntry getZipEntry(String name, int pos) { + byte[] cen = res.zsrc.cen; + int nlen = CENNAM(cen, pos); + int elen = CENEXT(cen, pos); + int clen = CENCOM(cen, pos); + + ZipCoder zc = res.zsrc.zipCoderForPos(pos); + if (name != null) { + // only need to check for mismatch of trailing slash + if (nlen > 0 && + !name.isEmpty() && + zc.hasTrailingSlash(cen, pos + CENHDR + nlen) && + !name.endsWith("/")) + { + name += '/'; + } + } else { + // invoked from iterator, use the entry name stored in cen + name = zc.toString(cen, pos + CENHDR, nlen); + } + ZipEntry e; + if (this instanceof JarFile) { + // Android-changed: access method directly. + // e = Source.JUJA.entryFor((JarFile)this, name); + e = ((JarFile) this).entryFor(name); + } else { + e = new ZipEntry(name); + } + e.flag = CENFLG(cen, pos); + e.xdostime = CENTIM(cen, pos); + e.crc = CENCRC(cen, pos); + e.size = CENLEN(cen, pos); + e.csize = CENSIZ(cen, pos); + e.method = CENHOW(cen, pos); + if (CENVEM_FA(cen, pos) == FILE_ATTRIBUTES_UNIX) { + // read all bits in this field, including sym link attributes + e.extraAttributes = CENATX_PERMS(cen, pos) & 0xFFFF; + } + + if (elen != 0) { + int start = pos + CENHDR + nlen; + e.setExtra0(Arrays.copyOfRange(cen, start, start + elen), true, false); + } + if (clen != 0) { + int start = pos + CENHDR + nlen + elen; + e.comment = zc.toString(cen, start, clen); + } + lastEntryName = e.name; + lastEntryPos = pos; + return e; + } + + /** + * Returns the number of entries in the ZIP file. + * + * @return the number of entries in the ZIP file + * @throws IllegalStateException if the zip file has been closed + */ + public int size() { + synchronized (this) { + ensureOpen(); + return res.zsrc.total; + } + } + + private static class CleanableResource implements Runnable { + // The outstanding inputstreams that need to be closed + final Set<InputStream> istreams; + + // List of cached Inflater objects for decompression + Deque<Inflater> inflaterCache; + + final Cleanable cleanable; + + Source zsrc; + + CleanableResource(ZipFile zf, ZipCoder zc, File file, int mode) throws IOException { + this(zf, zc, file, mode, false); + } + + // Android-added: added extra enableZipPathValidator argument. + CleanableResource(ZipFile zf, ZipCoder zc, File file, + int mode, boolean enableZipPathValidator) throws IOException { + this.cleanable = CleanerFactory.cleaner().register(zf, this); + this.istreams = Collections.newSetFromMap(new WeakHashMap<>()); + this.inflaterCache = new ArrayDeque<>(); + this.zsrc = Source.get(file, (mode & OPEN_DELETE) != 0, zc, enableZipPathValidator); + } + + void clean() { + cleanable.clean(); + } + + /* + * Gets an inflater from the list of available inflaters or allocates + * a new one. + */ + Inflater getInflater() { + Inflater inf; + synchronized (inflaterCache) { + if ((inf = inflaterCache.poll()) != null) { + return inf; + } + } + return new Inflater(true); + } + + /* + * Releases the specified inflater to the list of available inflaters. + */ + void releaseInflater(Inflater inf) { + Deque<Inflater> inflaters = this.inflaterCache; + if (inflaters != null) { + synchronized (inflaters) { + // double checked! + if (inflaters == this.inflaterCache) { + inf.reset(); + inflaters.add(inf); + return; + } + } + } + // inflaters cache already closed - just end it. + inf.end(); + } + + public void run() { + IOException ioe = null; + + // Release cached inflaters and close the cache first + Deque<Inflater> inflaters = this.inflaterCache; + if (inflaters != null) { + synchronized (inflaters) { + // no need to double-check as only one thread gets a + // chance to execute run() (Cleaner guarantee)... + Inflater inf; + while ((inf = inflaters.poll()) != null) { + inf.end(); + } + // close inflaters cache + this.inflaterCache = null; + } + } + + // Close streams, release their inflaters + if (istreams != null) { + synchronized (istreams) { + if (!istreams.isEmpty()) { + InputStream[] copy = istreams.toArray(new InputStream[0]); + istreams.clear(); + for (InputStream is : copy) { + try { + is.close(); + } catch (IOException e) { + if (ioe == null) ioe = e; + else ioe.addSuppressed(e); + } + } + } + } + } + + // Release zip src + if (zsrc != null) { + synchronized (zsrc) { + try { + Source.release(zsrc); + zsrc = null; + } catch (IOException e) { + if (ioe == null) ioe = e; + else ioe.addSuppressed(e); + } + } + } + if (ioe != null) { + throw new UncheckedIOException(ioe); + } + } + } + + /** + * Closes the ZIP file. + * + * <p> Closing this ZIP file will close all of the input streams + * previously returned by invocations of the {@link #getInputStream + * getInputStream} method. + * + * @throws IOException if an I/O error has occurred + */ + public void close() throws IOException { + if (closeRequested) { + return; + } + // Android-added: CloseGuard support. + if (guard != null) { + guard.close(); + } + closeRequested = true; + + synchronized (this) { + // Close streams, release their inflaters, release cached inflaters + // and release zip source + try { + res.clean(); + } catch (UncheckedIOException ioe) { + throw ioe.getCause(); + } + } + } + + private void ensureOpen() { + if (closeRequested) { + throw new IllegalStateException("zip file closed"); + } + if (res.zsrc == null) { + throw new IllegalStateException("The object is not initialized."); + } + } + + private void ensureOpenOrZipException() throws IOException { + if (closeRequested) { + throw new ZipException("ZipFile closed"); + } + } + + /* + * Inner class implementing the input stream used to read a + * (possibly compressed) zip file entry. + */ + private class ZipFileInputStream extends InputStream { + private volatile boolean closeRequested; + private long pos; // current position within entry data + private long startingPos; // Start position for the entry data + protected long rem; // number of remaining bytes within entry + protected long size; // uncompressed size of this entry + + ZipFileInputStream(byte[] cen, int cenpos) { + rem = CENSIZ(cen, cenpos); + size = CENLEN(cen, cenpos); + pos = CENOFF(cen, cenpos); + // zip64 + if (rem == ZIP64_MAGICVAL || size == ZIP64_MAGICVAL || + pos == ZIP64_MAGICVAL) { + checkZIP64(cen, cenpos); + } + // negative for lazy initialization, see getDataOffset(); + pos = - (pos + ZipFile.this.res.zsrc.locpos); + } + + private void checkZIP64(byte[] cen, int cenpos) { + int off = cenpos + CENHDR + CENNAM(cen, cenpos); + int end = off + CENEXT(cen, cenpos); + while (off + 4 < end) { + int tag = get16(cen, off); + int sz = get16(cen, off + 2); + off += 4; + if (off + sz > end) // invalid data + break; + if (tag == EXTID_ZIP64) { + if (size == ZIP64_MAGICVAL) { + if (sz < 8 || (off + 8) > end) + break; + size = get64(cen, off); + sz -= 8; + off += 8; + } + if (rem == ZIP64_MAGICVAL) { + if (sz < 8 || (off + 8) > end) + break; + rem = get64(cen, off); + sz -= 8; + off += 8; + } + if (pos == ZIP64_MAGICVAL) { + if (sz < 8 || (off + 8) > end) + break; + pos = get64(cen, off); + sz -= 8; + off += 8; + } + break; + } + off += sz; + } + } + + /* + * The Zip file spec explicitly allows the LOC extra data size to + * be different from the CEN extra data size. Since we cannot trust + * the CEN extra data size, we need to read the LOC to determine + * the entry data offset. + */ + private long initDataOffset() throws IOException { + if (pos <= 0) { + byte[] loc = new byte[LOCHDR]; + pos = -pos; + int len = ZipFile.this.res.zsrc.readFullyAt(loc, 0, loc.length, pos); + if (len != LOCHDR) { + throw new ZipException("ZipFile error reading zip file"); + } + if (LOCSIG(loc) != LOCSIG) { + throw new ZipException("ZipFile invalid LOC header (bad signature)"); + } + pos += LOCHDR + LOCNAM(loc) + LOCEXT(loc); + startingPos = pos; // Save starting position for the entry + } + return pos; + } + + public int read(byte b[], int off, int len) throws IOException { + synchronized (ZipFile.this) { + ensureOpenOrZipException(); + initDataOffset(); + if (rem == 0) { + return -1; + } + if (len > rem) { + len = (int) rem; + } + if (len <= 0) { + return 0; + } + len = ZipFile.this.res.zsrc.readAt(b, off, len, pos); + if (len > 0) { + pos += len; + rem -= len; + } + } + if (rem == 0) { + close(); + } + return len; + } + + public int read() throws IOException { + byte[] b = new byte[1]; + if (read(b, 0, 1) == 1) { + return b[0] & 0xff; + } else { + return -1; + } + } + + public long skip(long n) throws IOException { + synchronized (ZipFile.this) { + initDataOffset(); + long newPos = pos + n; + if (n > 0) { + // If we overflowed adding the skip value or are moving + // past EOF, set the skip value to number of bytes remaining + // to reach EOF + if (newPos < 0 || n > rem) { + n = rem; + } + } else if (newPos < startingPos) { + // Tried to position before BOF so set position to the + // BOF and return the number of bytes we moved backwards + // to reach BOF + n = startingPos - pos; + } + pos += n; + rem -= n; + } + if (rem == 0) { + close(); + } + return n; + } + + public int available() { + return rem > Integer.MAX_VALUE ? Integer.MAX_VALUE : (int) rem; + } + + public long size() { + return size; + } + + public void close() { + if (closeRequested) { + return; + } + closeRequested = true; + rem = 0; + synchronized (res.istreams) { + res.istreams.remove(this); + } + } + + } + + /** + * Returns {@code true} if, and only if, the zip file begins with {@code + * LOCSIG}. + * @hide + */ + // Android-added: Access startsWithLocHeader() directly. + // Make hidden public for use by sun.misc.URLClassPath + public boolean startsWithLocHeader() { + return res.zsrc.startsWithLoc; + } + + // Android-changed: marked as protected so JarFile can access it. + /** + * Returns the names of the META-INF/MANIFEST.MF entry - if exists - + * and any signature-related files under META-INF. This method is used in + * JarFile, via SharedSecrets, as an optimization. + * @hide + */ + protected List<String> getManifestAndSignatureRelatedFiles() { + synchronized (this) { + ensureOpen(); + Source zsrc = res.zsrc; + int[] metanames = zsrc.signatureMetaNames; + List<String> files = null; + if (zsrc.manifestPos >= 0) { + files = new ArrayList<>(); + files.add(getEntryName(zsrc.manifestPos)); + } + if (metanames != null) { + if (files == null) { + files = new ArrayList<>(); + } + for (int i = 0; i < metanames.length; i++) { + files.add(getEntryName(metanames[i])); + } + } + return files == null ? List.of() : files; + } + } + + /** + * Returns the number of the META-INF/MANIFEST.MF entries, case insensitive. + * When this number is greater than 1, JarVerifier will treat a file as + * unsigned. + */ + private int getManifestNum() { + synchronized (this) { + ensureOpen(); + return res.zsrc.manifestNum; + } + } + + // Android-changed: marked public and @hide as alternative to JavaUtilZipFileAccess.getManifestName. + /** + * Returns the name of the META-INF/MANIFEST.MF entry, ignoring + * case. If {@code onlyIfSignatureRelatedFiles} is true, we only return the + * manifest if there is also at least one signature-related file. + * This method is used in JarFile, via SharedSecrets, as an optimization + * when looking up the manifest file. + * @hide + */ + protected String getManifestName(boolean onlyIfSignatureRelatedFiles) { + synchronized (this) { + ensureOpen(); + Source zsrc = res.zsrc; + int pos = zsrc.manifestPos; + if (pos >= 0 && (!onlyIfSignatureRelatedFiles || zsrc.signatureMetaNames != null)) { + return getEntryName(pos); + } + } + return null; + } + + /** + * Returns the versions for which there exists a non-directory + * entry that begin with "META-INF/versions/" (case ignored). + * This method is used in JarFile, via SharedSecrets, as an + * optimization when looking up potentially versioned entries. + * Returns an empty array if no versioned entries exist. + */ + private int[] getMetaInfVersions() { + synchronized (this) { + ensureOpen(); + return res.zsrc.metaVersions; + } + } + + // Android-removed: this code does not run on Windows and JavaUtilZipFileAccess is not imported. + /* + private static boolean isWindows; + + static { + SharedSecrets.setJavaUtilZipFileAccess( + new JavaUtilZipFileAccess() { + @Override + public boolean startsWithLocHeader(ZipFile zip) { + return zip.res.zsrc.startsWithLoc; + } + @Override + public List<String> getManifestAndSignatureRelatedFiles(JarFile jar) { + return ((ZipFile)jar).getManifestAndSignatureRelatedFiles(); + } + @Override + public int getManifestNum(JarFile jar) { + return ((ZipFile)jar).getManifestNum(); + } + @Override + public String getManifestName(JarFile jar, boolean onlyIfHasSignatureRelatedFiles) { + return ((ZipFile)jar).getManifestName(onlyIfHasSignatureRelatedFiles); + } + @Override + public int[] getMetaInfVersions(JarFile jar) { + return ((ZipFile)jar).getMetaInfVersions(); + } + @Override + public Enumeration<JarEntry> entries(ZipFile zip) { + return zip.jarEntries(); + } + @Override + public Stream<JarEntry> stream(ZipFile zip) { + return zip.jarStream(); + } + @Override + public Stream<String> entryNameStream(ZipFile zip) { + return zip.entryNameStream(); + } + @Override + public int getExtraAttributes(ZipEntry ze) { + return ze.extraAttributes; + } + @Override + public void setExtraAttributes(ZipEntry ze, int extraAttrs) { + ze.extraAttributes = extraAttrs; + } + + } + ); + isWindows = VM.getSavedProperty("os.name").contains("Windows"); + } + */ + + private static class Source { + // While this is only used from ZipFile, defining it there would cause + // a bootstrap cycle that would leave this initialized as null + // Android-removed: JavaUtilJarAccess is not available. + // private static final JavaUtilJarAccess JUJA = SharedSecrets.javaUtilJarAccess(); + // "META-INF/".length() + private static final int META_INF_LEN = 9; + private static final int[] EMPTY_META_VERSIONS = new int[0]; + + private final Key key; // the key in files + private final @Stable ZipCoder zc; // zip coder used to decode/encode + + private int refs = 1; + + private RandomAccessFile zfile; // zfile of the underlying zip file + private byte[] cen; // CEN & ENDHDR + private long locpos; // position of first LOC header (usually 0) + private byte[] comment; // zip file comment + // list of meta entries in META-INF dir + private int manifestPos = -1; // position of the META-INF/MANIFEST.MF, if exists + private int manifestNum = 0; // number of META-INF/MANIFEST.MF, case insensitive + private int[] signatureMetaNames; // positions of signature related entries, if such exist + private int[] metaVersions; // list of unique versions found in META-INF/versions/ + private final boolean startsWithLoc; // true, if zip file starts with LOCSIG (usually true) + + // A Hashmap for all entries. + // + // A cen entry of Zip/JAR file. As we have one for every entry in every active Zip/JAR, + // We might have a lot of these in a typical system. In order to save space we don't + // keep the name in memory, but merely remember a 32 bit {@code hash} value of the + // entry name and its offset {@code pos} in the central directory hdeader. + // + // private static class Entry { + // int hash; // 32 bit hashcode on name + // int next; // hash chain: index into entries + // int pos; // Offset of central directory file header + // } + // private Entry[] entries; // array of hashed cen entry + // + // To reduce the total size of entries further, we use a int[] here to store 3 "int" + // {@code hash}, {@code next} and {@code pos} for each entry. The entry can then be + // referred by their index of their positions in the {@code entries}. + // + private int[] entries; // array of hashed cen entry + + // Checks the entry at offset pos in the CEN, calculates the Entry values as per above, + // then returns the length of the entry name. + private int checkAndAddEntry(int pos, int index) + throws ZipException + { + byte[] cen = this.cen; + if (CENSIG(cen, pos) != CENSIG) { + zerror("invalid CEN header (bad signature)"); + } + int method = CENHOW(cen, pos); + int flag = CENFLG(cen, pos); + if ((flag & 1) != 0) { + zerror("invalid CEN header (encrypted entry)"); + } + if (method != STORED && method != DEFLATED) { + zerror("invalid CEN header (bad compression method: " + method + ")"); + } + int entryPos = pos + CENHDR; + int nlen = CENNAM(cen, pos); + if (entryPos + nlen > cen.length - ENDHDR) { + zerror("invalid CEN header (bad header size)"); + } + try { + ZipCoder zcp = zipCoderForPos(pos); + int hash = zcp.checkedHash(cen, entryPos, nlen); + int hsh = (hash & 0x7fffffff) % tablelen; + int next = table[hsh]; + table[hsh] = index; + // Record the CEN offset and the name hash in our hash cell. + entries[index++] = hash; + entries[index++] = next; + entries[index ] = pos; + } catch (Exception e) { + zerror("invalid CEN header (bad entry name)"); + } + return nlen; + } + + private int getEntryHash(int index) { return entries[index]; } + private int getEntryNext(int index) { return entries[index + 1]; } + private int getEntryPos(int index) { return entries[index + 2]; } + private static final int ZIP_ENDCHAIN = -1; + private int total; // total number of entries + private int[] table; // Hash chain heads: indexes into entries + private int tablelen; // number of hash heads + + // Android-changed: isZipFilePathValidatorEnabled added as Key part. Key is used as key in + // files HashMap, so not including it could lead to opening ZipFile w/o entry names + // validation. + private static class Key { + final BasicFileAttributes attrs; + File file; + final boolean utf8; + // Android-added: isZipFilePathValidatorEnabled added as Key part. + final boolean isZipFilePathValidatorEnabled; + + public Key(File file, BasicFileAttributes attrs, ZipCoder zc) { + this(file, attrs, zc, /* isZipFilePathValidatorEnabled= */ false); + } + + // Android-added: added constructor with isZipFilePathValidatorEnabled argument. + public Key(File file, BasicFileAttributes attrs, ZipCoder zc, + boolean isZipFilePathValidatorEnabled) { + this.attrs = attrs; + this.file = file; + this.utf8 = zc.isUTF8(); + this.isZipFilePathValidatorEnabled = isZipFilePathValidatorEnabled; + } + + public int hashCode() { + long t = utf8 ? 0 : Long.MAX_VALUE; + t += attrs.lastModifiedTime().toMillis(); + // Android-changed: include izZipFilePathValidatorEnabled in hash computation. + // return ((int)(t ^ (t >>> 32))) + file.hashCode(); + return ((int)(t ^ (t >>> 32))) + file.hashCode() + + Boolean.hashCode(isZipFilePathValidatorEnabled); + } + + public boolean equals(Object obj) { + if (obj instanceof Key key) { + if (key.utf8 != utf8) { + return false; + } + if (!attrs.lastModifiedTime().equals(key.attrs.lastModifiedTime())) { + return false; + } + // Android-added: include isZipFilePathValidatorEnabled as equality part. + if (key.isZipFilePathValidatorEnabled != isZipFilePathValidatorEnabled) { + return false; + } + Object fk = attrs.fileKey(); + if (fk != null) { + return fk.equals(key.attrs.fileKey()); + } else { + return file.equals(key.file); + } + } + return false; + } + } + private static final HashMap<Key, Source> files = new HashMap<>(); + + + // Android-changed: pass izZipFilePathValidatorEnabled argument. + // static Source get(File file, boolean toDelete, ZipCoder zc) throws IOException { + static Source get(File file, boolean toDelete, ZipCoder zc, + boolean isZipPathValidatorEnabled) throws IOException { + final Key key; + try { + // BEGIN Android-changed: isZipFilePathValidatorEnabled passed as part of Key. + /* + key = new Key(file, + Files.readAttributes(file.toPath(), BasicFileAttributes.class), + zc); + */ + key = new Key(file, + Files.readAttributes(file.toPath(), BasicFileAttributes.class), + zc, isZipPathValidatorEnabled); + // END Android-changed: isZipFilePathValidatorEnabled passed as part of Key. + } catch (InvalidPathException ipe) { + throw new IOException(ipe); + } + Source src; + synchronized (files) { + src = files.get(key); + if (src != null) { + src.refs++; + return src; + } + } + src = new Source(key, toDelete, zc); + + synchronized (files) { + if (files.containsKey(key)) { // someone else put in first + src.close(); // close the newly created one + src = files.get(key); + src.refs++; + return src; + } + files.put(key, src); + return src; + } + } + + static void release(Source src) throws IOException { + synchronized (files) { + if (src != null && --src.refs == 0) { + files.remove(src.key); + src.close(); + } + } + } + + private Source(Key key, boolean toDelete, ZipCoder zc) throws IOException { + this.zc = zc; + this.key = key; + if (toDelete) { + // BEGIN Android-changed: we are not targeting Windows, keep else branch only. Also + // open file with O_CLOEXEC flag set. + /* + if (isWindows) { + this.zfile = SharedSecrets.getJavaIORandomAccessFileAccess() + .openAndDelete(key.file, "r"); + } else { + this.zfile = new RandomAccessFile(key.file, "r"); + key.file.delete(); + } + */ + this.zfile = new RandomAccessFile(key.file, "r", /* setCloExecFlag= */ true); + key.file.delete(); + // END Android-changed: we are not targeting Windows, keep else branch only. + } else { + // Android-changed: open with O_CLOEXEC flag set. + // this.zfile = new RandomAccessFile(key.file, "r"); + this.zfile = new RandomAccessFile(key.file, "r", /* setCloExecFlag= */ true); + } + try { + initCEN(-1); + byte[] buf = new byte[4]; + readFullyAt(buf, 0, 4, 0); + // BEGIN Android-changed: do not accept files with invalid header + // this.startsWithLoc = (LOCSIG(buf) == LOCSIG); + long locsig = LOCSIG(buf); + this.startsWithLoc = (locsig == LOCSIG); + // If a zip file starts with "end of central directory record" it means that such + // file is empty. + if (locsig != LOCSIG && locsig != ENDSIG) { + String msg = "Entry at offset zero has invalid LFH signature " + + Long.toHexString(locsig); + throw new ZipException(msg); + } + // END Android-changed: do not accept files with invalid header + } catch (IOException x) { + try { + this.zfile.close(); + } catch (IOException xx) {} + throw x; + } + } + + private void close() throws IOException { + zfile.close(); + zfile = null; + cen = null; + entries = null; + table = null; + manifestPos = -1; + manifestNum = 0; + signatureMetaNames = null; + metaVersions = EMPTY_META_VERSIONS; + } + + private static final int BUF_SIZE = 8192; + private final int readFullyAt(byte[] buf, int off, int len, long pos) + throws IOException + { + synchronized (zfile) { + zfile.seek(pos); + int N = len; + while (N > 0) { + int n = Math.min(BUF_SIZE, N); + zfile.readFully(buf, off, n); + off += n; + N -= n; + } + return len; + } + } + + private final int readAt(byte[] buf, int off, int len, long pos) + throws IOException + { + synchronized (zfile) { + zfile.seek(pos); + return zfile.read(buf, off, len); + } + } + + + private static class End { + int centot; // 4 bytes + long cenlen; // 4 bytes + long cenoff; // 4 bytes + long endpos; // 4 bytes + } + + /* + * Searches for end of central directory (END) header. The contents of + * the END header will be read and placed in endbuf. Returns the file + * position of the END header, otherwise returns -1 if the END header + * was not found or an error occurred. + */ + private End findEND() throws IOException { + long ziplen = zfile.length(); + if (ziplen <= 0) + zerror("zip file is empty"); + End end = new End(); + byte[] buf = new byte[READBLOCKSZ]; + long minHDR = (ziplen - END_MAXLEN) > 0 ? ziplen - END_MAXLEN : 0; + long minPos = minHDR - (buf.length - ENDHDR); + for (long pos = ziplen - buf.length; pos >= minPos; pos -= (buf.length - ENDHDR)) { + int off = 0; + if (pos < 0) { + // Pretend there are some NUL bytes before start of file + off = (int)-pos; + Arrays.fill(buf, 0, off, (byte)0); + } + int len = buf.length - off; + if (readFullyAt(buf, off, len, pos + off) != len ) { + zerror("zip END header not found"); + } + // Now scan the block backwards for END header signature + for (int i = buf.length - ENDHDR; i >= 0; i--) { + if (buf[i+0] == (byte)'P' && + buf[i+1] == (byte)'K' && + buf[i+2] == (byte)'\005' && + buf[i+3] == (byte)'\006') { + // Found ENDSIG header + byte[] endbuf = Arrays.copyOfRange(buf, i, i + ENDHDR); + end.centot = ENDTOT(endbuf); + end.cenlen = ENDSIZ(endbuf); + end.cenoff = ENDOFF(endbuf); + end.endpos = pos + i; + int comlen = ENDCOM(endbuf); + if (end.endpos + ENDHDR + comlen != ziplen) { + // ENDSIG matched, however the size of file comment in it does + // not match the real size. One "common" cause for this problem + // is some "extra" bytes are padded at the end of the zipfile. + // Let's do some extra verification, we don't care about the + // performance in this situation. + byte[] sbuf = new byte[4]; + long cenpos = end.endpos - end.cenlen; + long locpos = cenpos - end.cenoff; + if (cenpos < 0 || + locpos < 0 || + readFullyAt(sbuf, 0, sbuf.length, cenpos) != 4 || + GETSIG(sbuf) != CENSIG || + readFullyAt(sbuf, 0, sbuf.length, locpos) != 4 || + GETSIG(sbuf) != LOCSIG) { + continue; + } + } + if (comlen > 0) { // this zip file has comlen + comment = new byte[comlen]; + if (readFullyAt(comment, 0, comlen, end.endpos + ENDHDR) != comlen) { + zerror("zip comment read failed"); + } + } + // must check for a zip64 end record; it is always permitted to be present + try { + byte[] loc64 = new byte[ZIP64_LOCHDR]; + if (end.endpos < ZIP64_LOCHDR || + readFullyAt(loc64, 0, loc64.length, end.endpos - ZIP64_LOCHDR) + != loc64.length || GETSIG(loc64) != ZIP64_LOCSIG) { + return end; + } + long end64pos = ZIP64_LOCOFF(loc64); + byte[] end64buf = new byte[ZIP64_ENDHDR]; + if (readFullyAt(end64buf, 0, end64buf.length, end64pos) + != end64buf.length || GETSIG(end64buf) != ZIP64_ENDSIG) { + return end; + } + // end64 candidate found, + long cenlen64 = ZIP64_ENDSIZ(end64buf); + long cenoff64 = ZIP64_ENDOFF(end64buf); + long centot64 = ZIP64_ENDTOT(end64buf); + // double-check + if (cenlen64 != end.cenlen && end.cenlen != ZIP64_MAGICVAL || + cenoff64 != end.cenoff && end.cenoff != ZIP64_MAGICVAL || + centot64 != end.centot && end.centot != ZIP64_MAGICCOUNT) { + return end; + } + // to use the end64 values + end.cenlen = cenlen64; + end.cenoff = cenoff64; + end.centot = (int)centot64; // assume total < 2g + end.endpos = end64pos; + } catch (IOException x) {} // no zip64 loc/end + return end; + } + } + } + throw new ZipException("zip END header not found"); + } + + // Reads zip file central directory. + private void initCEN(int knownTotal) throws IOException { + // Prefer locals for better performance during startup + byte[] cen; + if (knownTotal == -1) { + End end = findEND(); + if (end.endpos == 0) { + locpos = 0; + total = 0; + entries = new int[0]; + this.cen = null; + return; // only END header present + } + if (end.cenlen > end.endpos) + zerror("invalid END header (bad central directory size)"); + long cenpos = end.endpos - end.cenlen; // position of CEN table + // Get position of first local file (LOC) header, taking into + // account that there may be a stub prefixed to the zip file. + locpos = cenpos - end.cenoff; + if (locpos < 0) { + zerror("invalid END header (bad central directory offset)"); + } + // read in the CEN and END + cen = this.cen = new byte[(int)(end.cenlen + ENDHDR)]; + if (readFullyAt(cen, 0, cen.length, cenpos) != end.cenlen + ENDHDR) { + zerror("read CEN tables failed"); + } + this.total = end.centot; + } else { + cen = this.cen; + this.total = knownTotal; + } + // hash table for entries + int entriesLength = this.total * 3; + entries = new int[entriesLength]; + + int tablelen = ((total/2) | 1); // Odd -> fewer collisions + this.tablelen = tablelen; + + int[] table = new int[tablelen]; + this.table = table; + + Arrays.fill(table, ZIP_ENDCHAIN); + + // list for all meta entries + ArrayList<Integer> signatureNames = null; + // Set of all version numbers seen in META-INF/versions/ + Set<Integer> metaVersionsSet = null; + + // Iterate through the entries in the central directory + int idx = 0; // Index into the entries array + int pos = 0; + int entryPos = CENHDR; + int limit = cen.length - ENDHDR; + manifestNum = 0; + // Android-added: duplicate entries are not allowed. See CVE-2013-4787 and b/8219321 + Set<String> entriesNames = new HashSet<>(); + while (entryPos <= limit) { + if (idx >= entriesLength) { + // This will only happen if the zip file has an incorrect + // ENDTOT field, which usually means it contains more than + // 65535 entries. + initCEN(countCENHeaders(cen, limit)); + return; + } + + // Checks the entry and adds values to entries[idx ... idx+2] + int nlen = checkAndAddEntry(pos, idx); + + // BEGIN Android-added: duplicate entries are not allowed. See CVE-2013-4787 + // and b/8219321. + // zipCoderForPos takes USE_UTF8 flag into account. + ZipCoder zcp = zipCoderForPos(entryPos); + String name = zcp.toString(cen, pos + CENHDR, nlen); + if (!entriesNames.add(name)) { + zerror("Duplicate entry name: " + name); + } + // END Android-added: duplicate entries are not allowed. See CVE-2013-4787 + // and b/8219321 + // BEGIN Android-added: don't allow NUL in entry names. We can handle it in Java fine, + // but it is of questionable utility as a valid pathname can't contain NUL. + for (int nameIdx = 0; nameIdx < nlen; ++nameIdx) { + byte b = cen[pos + CENHDR + nameIdx]; + + if (b == 0) { + zerror("Filename contains NUL byte: " + name); + } + } + // END Android-added: don't allow NUL in entry names. + // BEGIN Android-changed: validation of zip entry names. + if (key.isZipFilePathValidatorEnabled && !ZipPathValidator.isClear()) { + ZipPathValidator.getInstance().onZipEntryAccess(name); + } + // END Android-changed: validation of zip entry names. + idx += 3; + + // Adds name to metanames. + if (isMetaName(cen, entryPos, nlen)) { + // nlen is at least META_INF_LENGTH + if (isManifestName(entryPos + META_INF_LEN, nlen - META_INF_LEN)) { + manifestPos = pos; + manifestNum++; + } else { + if (isSignatureRelated(entryPos, nlen)) { + if (signatureNames == null) + signatureNames = new ArrayList<>(4); + signatureNames.add(pos); + } + + // If this is a versioned entry, parse the version + // and store it for later. This optimizes lookup + // performance in multi-release jar files + int version = getMetaVersion(entryPos + META_INF_LEN, nlen - META_INF_LEN); + if (version > 0) { + if (metaVersionsSet == null) + metaVersionsSet = new TreeSet<>(); + metaVersionsSet.add(version); + } + } + } + // skip to the start of the next entry + pos = nextEntryPos(pos, entryPos, nlen); + entryPos = pos + CENHDR; + } + + // Adjust the total entries + this.total = idx / 3; + + if (signatureNames != null) { + int len = signatureNames.size(); + signatureMetaNames = new int[len]; + for (int j = 0; j < len; j++) { + signatureMetaNames[j] = signatureNames.get(j); + } + } + if (metaVersionsSet != null) { + metaVersions = new int[metaVersionsSet.size()]; + int c = 0; + for (Integer version : metaVersionsSet) { + metaVersions[c++] = version; + } + } else { + metaVersions = EMPTY_META_VERSIONS; + } + if (pos + ENDHDR != cen.length) { + zerror("invalid CEN header (bad header size)"); + } + } + + private int nextEntryPos(int pos, int entryPos, int nlen) { + return entryPos + nlen + CENCOM(cen, pos) + CENEXT(cen, pos); + } + + private static void zerror(String msg) throws ZipException { + throw new ZipException(msg); + } + + /* + * Returns the {@code pos} of the zip cen entry corresponding to the + * specified entry name, or -1 if not found. + */ + private int getEntryPos(String name, boolean addSlash) { + if (total == 0) { + return -1; + } + + int hsh = ZipCoder.hash(name); + int idx = table[(hsh & 0x7fffffff) % tablelen]; + + // Search down the target hash chain for a entry whose + // 32 bit hash matches the hashed name. + while (idx != ZIP_ENDCHAIN) { + if (getEntryHash(idx) == hsh) { + // The CEN name must match the specfied one + int pos = getEntryPos(idx); + + try { + ZipCoder zc = zipCoderForPos(pos); + String entry = zc.toString(cen, pos + CENHDR, CENNAM(cen, pos)); + + // If addSlash is true we'll test for name+/ in addition to + // name, unless name is the empty string or already ends with a + // slash + int entryLen = entry.length(); + int nameLen = name.length(); + if ((entryLen == nameLen && entry.equals(name)) || + (addSlash && + nameLen + 1 == entryLen && + entry.startsWith(name) && + entry.charAt(entryLen - 1) == '/')) { + return pos; + } + } catch (IllegalArgumentException iae) { + // Ignore + } + } + idx = getEntryNext(idx); + } + return -1; + } + + private ZipCoder zipCoderForPos(int pos) { + if (zc.isUTF8()) { + return zc; + } + if ((CENFLG(cen, pos) & USE_UTF8) != 0) { + return ZipCoder.UTF8; + } + return zc; + } + + /** + * Returns true if the bytes represent a non-directory name + * beginning with "META-INF/", disregarding ASCII case. + */ + private static boolean isMetaName(byte[] name, int off, int len) { + // Use the "oldest ASCII trick in the book": + // ch | 0x20 == Character.toLowerCase(ch) + return len > META_INF_LEN // "META-INF/".length() + && name[off + len - 1] != '/' // non-directory + && (name[off++] | 0x20) == 'm' + && (name[off++] | 0x20) == 'e' + && (name[off++] | 0x20) == 't' + && (name[off++] | 0x20) == 'a' + && (name[off++] ) == '-' + && (name[off++] | 0x20) == 'i' + && (name[off++] | 0x20) == 'n' + && (name[off++] | 0x20) == 'f' + && (name[off] ) == '/'; + } + + /* + * Check if the bytes represents a name equals to MANIFEST.MF + */ + private boolean isManifestName(int off, int len) { + byte[] name = cen; + return (len == 11 // "MANIFEST.MF".length() + && (name[off++] | 0x20) == 'm' + && (name[off++] | 0x20) == 'a' + && (name[off++] | 0x20) == 'n' + && (name[off++] | 0x20) == 'i' + && (name[off++] | 0x20) == 'f' + && (name[off++] | 0x20) == 'e' + && (name[off++] | 0x20) == 's' + && (name[off++] | 0x20) == 't' + && (name[off++] ) == '.' + && (name[off++] | 0x20) == 'm' + && (name[off] | 0x20) == 'f'); + } + + private boolean isSignatureRelated(int off, int len) { + // Only called when isMetaName(name, off, len) is true, which means + // len is at least META_INF_LENGTH + // assert isMetaName(name, off, len) + boolean signatureRelated = false; + byte[] name = cen; + if (name[off + len - 3] == '.') { + // Check if entry ends with .EC and .SF + int b1 = name[off + len - 2] | 0x20; + int b2 = name[off + len - 1] | 0x20; + if ((b1 == 'e' && b2 == 'c') || (b1 == 's' && b2 == 'f')) { + signatureRelated = true; + } + } else if (name[off + len - 4] == '.') { + // Check if entry ends with .DSA and .RSA + int b1 = name[off + len - 3] | 0x20; + int b2 = name[off + len - 2] | 0x20; + int b3 = name[off + len - 1] | 0x20; + if ((b1 == 'r' || b1 == 'd') && b2 == 's' && b3 == 'a') { + signatureRelated = true; + } + } + // Above logic must match SignatureFileVerifier.isBlockOrSF + assert(signatureRelated == SignatureFileVerifier + // Android-changed: use StandardCharsets. + // .isBlockOrSF(new String(name, off, len, UTF_8.INSTANCE) + .isBlockOrSF(new String(name, off, len, StandardCharsets.UTF_8) + .toUpperCase(Locale.ENGLISH))); + return signatureRelated; + } + + /* + * If the bytes represents a non-directory name beginning + * with "versions/", continuing with a positive integer, + * followed by a '/', then return that integer value. + * Otherwise, return 0 + */ + private int getMetaVersion(int off, int len) { + byte[] name = cen; + int nend = off + len; + if (!(len > 10 // "versions//".length() + && name[off + len - 1] != '/' // non-directory + && (name[off++] | 0x20) == 'v' + && (name[off++] | 0x20) == 'e' + && (name[off++] | 0x20) == 'r' + && (name[off++] | 0x20) == 's' + && (name[off++] | 0x20) == 'i' + && (name[off++] | 0x20) == 'o' + && (name[off++] | 0x20) == 'n' + && (name[off++] | 0x20) == 's' + && (name[off++] ) == '/')) { + return 0; + } + int version = 0; + while (off < nend) { + final byte c = name[off++]; + if (c == '/') { + return version; + } + if (c < '0' || c > '9') { + return 0; + } + version = version * 10 + c - '0'; + // Check for overflow and leading zeros + if (version <= 0) { + return 0; + } + } + return 0; + } + + /** + * Returns the number of CEN headers in a central directory. + * Will not throw, even if the zip file is corrupt. + * + * @param cen copy of the bytes in a zip file's central directory + * @param size number of bytes in central directory + */ + private static int countCENHeaders(byte[] cen, int size) { + int count = 0; + for (int p = 0; + p + CENHDR <= size; + p += CENHDR + CENNAM(cen, p) + CENEXT(cen, p) + CENCOM(cen, p)) + count++; + return count; + } + } +}