/*

 * Copyright (c) 1997, 2015, 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.jar;

import java.io.*;

import java.lang.ref.SoftReference;

import java.net.URL;

import java.security.PrivilegedAction;

import java.util.*;

import java.util.stream.Stream;

import java.util.stream.StreamSupport;

import java.util.zip.*;

import java.security.CodeSigner;

import java.security.cert.Certificate;

import java.security.AccessController;

import java.security.CodeSource;

import jdk.internal.misc.SharedSecrets;

import sun.security.util.ManifestEntryVerifier;

import sun.security.util.SignatureFileVerifier;

import static java.util.jar.Attributes.Name.MULTI_RELEASE;

/**

 * The {@code JarFile} class is used to read the contents of a jar file

 * from any file that can be opened with {@code java.io.RandomAccessFile}.

 * It extends the class {@code java.util.zip.ZipFile} with support

 * for reading an optional {@code Manifest} entry, and support for

 * processing multi-release jar files.  The {@code Manifest} can be used

 * to specify meta-information about the jar file and its entries.

 *

 * <p>A multi-release jar file is a jar file that contains

 * a manifest with a main attribute named "Multi-Release",

 * a set of "base" entries, some of which are public classes with public

 * or protected methods that comprise the public interface of the jar file,

 * and a set of "versioned" entries contained in subdirectories of the

 * "META-INF/versions" directory.  The versioned entries are partitioned by the

 * major version of the Java platform.  A versioned entry, with a version

 * {@code n}, {@code 8 < n}, in the "META-INF/versions/{n}" directory overrides

 * the base entry as well as any entry with a version number {@code i} where

 * {@code 8 < i < n}.

 *

 * <p>By default, a {@code JarFile} for a multi-release jar file is configured

 * to process the multi-release jar file as if it were a plain (unversioned) jar

 * file, and as such an entry name is associated with at most one base entry.

 * The {@code JarFile} may be configured to process a multi-release jar file by

 * creating the {@code JarFile} with the

 * {@link JarFile#JarFile(File, boolean, int, Release)} constructor.  The

 * {@code Release} object sets a maximum version used when searching for

 * versioned entries.  When so configured, an entry name

 * can correspond with at most one base entry and zero or more versioned

 * entries. A search is required to associate the entry name with the latest

 * versioned entry whose version is less than or equal to the maximum version

 * (see {@link #getEntry(String)}).

 *

 * <p>Class loaders that utilize {@code JarFile} to load classes from the

 * contents of {@code JarFile} entries should construct the {@code JarFile}

 * by invoking the {@link JarFile#JarFile(File, boolean, int, Release)}

 * constructor with the value {@code Release.RUNTIME} assigned to the last

 * argument.  This assures that classes compatible with the major

 * version of the running JVM are loaded from multi-release jar files.

 *

 * <p>If the verify flag is on when opening a signed jar file, the content of

 * the file is verified against its signature embedded inside the file. Please

 * note that the verification process does not include validating the signer's

 * certificate. A caller should inspect the return value of

 * {@link JarEntry#getCodeSigners()} to further determine if the signature

 * can be trusted.

 *

 * <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.

 *

 * @implNote

 * <div class="block">

 * If the API can not be used to configure a {@code JarFile} (e.g. to override

 * the configuration of a compiled application or library), two {@code System}

 * properties are available.

 * <ul>

 * <li>

 * {@code jdk.util.jar.version} can be assigned a value that is the

 * {@code String} representation of a non-negative integer

 * {@code <= Version.current().major()}.  The value is used to set the effective

 * runtime version to something other than the default value obtained by

 * evaluating {@code Version.current().major()}. The effective runtime version

 * is the version that the {@link JarFile#JarFile(File, boolean, int, Release)}

 * constructor uses when the value of the last argument is

 * {@code Release.RUNTIME}.

 * </li>

 * <li>

 * {@code jdk.util.jar.enableMultiRelease} can be assigned one of the three

 * {@code String} values <em>true</em>, <em>false</em>, or <em>force</em>.  The

 * value <em>true</em>, the default value, enables multi-release jar file

 * processing.  The value <em>false</em> disables multi-release jar processing,

 * ignoring the "Multi-Release" manifest attribute, and the versioned

 * directories in a multi-release jar file if they exist.  Furthermore,

 * the method {@link JarFile#isMultiRelease()} returns <em>false</em>. The value

 * <em>force</em> causes the {@code JarFile} to be initialized to runtime

 * versioning after construction.  It effectively does the same as this code:

 * {@code (new JarFile(File, boolean, int, Release.RUNTIME)}.

 * </li>

 * </ul>

 * </div>

 *

 * @author  David Connelly

 * @see     Manifest

 * @see     java.util.zip.ZipFile

 * @see     java.util.jar.JarEntry

 * @since   1.2

 */

public

class JarFile extends ZipFile {

    private final static int BASE_VERSION;

    private final static int RUNTIME_VERSION;

    private final static boolean MULTI_RELEASE_ENABLED;

    private final static boolean MULTI_RELEASE_FORCED;

    private SoftReference<Manifest> manRef;

    private JarEntry manEntry;

    private JarVerifier jv;

    private boolean jvInitialized;

    private boolean verify;

    private final int version;

    private boolean notVersioned;

    private final boolean runtimeVersioned;

    // indicates if Class-Path attribute present (only valid if hasCheckedSpecialAttributes true)

    private boolean hasClassPathAttribute;

    // true if manifest checked for special attributes

    private volatile boolean hasCheckedSpecialAttributes;

    static {

        // Set up JavaUtilJarAccess in SharedSecrets

        SharedSecrets.setJavaUtilJarAccess(new JavaUtilJarAccessImpl());

        BASE_VERSION = 8;  // one less than lowest version for versioned entries

        RUNTIME_VERSION = AccessController.doPrivileged(

                new PrivilegedAction<Integer>() {

                    public Integer run() {

                        Integer i = Integer.getInteger("jdk.util.jar.version", v);

                        i = i < 0 ? 0 : i;

                        return i > v ? v : i;

                    }

                }

        );

        String multi_release = AccessController.doPrivileged(

                new PrivilegedAction<String>() {

                    public String run() {

                        return System.getProperty("jdk.util.jar.enableMultiRelease", "true");

                    }

                }

        );

        switch (multi_release) {

            case "true":

            default:

                MULTI_RELEASE_ENABLED = true;

                MULTI_RELEASE_FORCED = false;

                break;

            case "false":

                MULTI_RELEASE_ENABLED = false;

                MULTI_RELEASE_FORCED = false;

                break;

            case "force":

                MULTI_RELEASE_ENABLED = true;

                MULTI_RELEASE_FORCED = true;

                break;

        }

    }

    /**

     * A set of constants that represent the entries in either the base directory

     * or one of the versioned directories in a multi-release jar file.  It's

     * possible for a multi-release jar file to contain versioned directories

     * that are not represented by the constants of the {@code Release} enum.

     * In those cases, the entries will not be located by this {@code JarFile}

     * through the aliasing mechanism, but they can be directly accessed by

     * specifying the full path name of the entry.

     *

     * @since 9

     */

    public enum Release {

        /**

         * Represents unversioned entries, or entries in "regular", as opposed

         * to multi-release jar files.

         */

        BASE(BASE_VERSION),

        /**

         * Represents entries found in the META-INF/versions/9 directory of a

         * multi-release jar file.

         */

        VERSION_9(9),

        // fill in the "blanks" for future releases

        /**

         * Represents entries found in the META-INF/versions/{n} directory of a

         * multi-release jar file, where {@code n} is the effective runtime

         * version of the jar file.

         *

         * @implNote

         * <div class="block">

         * The effective runtime version is determined

         * by evaluating {@code Version.current().major()} or by using the value

         * of the {@code jdk.util.jar.version} System property if it exists.

         * </div>

         */

        RUNTIME(RUNTIME_VERSION);

        Release(int version) {

            this.version = version;

        }

        private static Release valueOf(int version) {

            return version <= BASE.value() ? BASE : valueOf("VERSION_" + version);

        }

        private final int version;

        private int value() {

            return this.version;

        }

    }

    private static final String META_INF = "META-INF/";

    private static final String META_INF_VERSIONS = META_INF + "versions/";

    /**

     * The JAR manifest file name.

     */

    public static final String MANIFEST_NAME = META_INF + "MANIFEST.MF";

    /**

     * Creates a new {@code JarFile} to read from the specified

     * file {@code name}. The {@code JarFile} will be verified if

     * it is signed.

     * @param name the name of the jar file to be opened for reading

     * @throws IOException if an I/O error has occurred

     * @throws SecurityException if access to the file is denied

     *         by the SecurityManager

     */

    public JarFile(String name) throws IOException {

        this(new File(name), true, ZipFile.OPEN_READ);

    }

    /**

     * Creates a new {@code JarFile} to read from the specified

     * file {@code name}.

     * @param name the name of the jar file to be opened for reading

     * @param verify whether or not to verify the jar file if

     * it is signed.

     * @throws IOException if an I/O error has occurred

     * @throws SecurityException if access to the file is denied

     *         by the SecurityManager

     */

    public JarFile(String name, boolean verify) throws IOException {

        this(new File(name), verify, ZipFile.OPEN_READ);

    }

    /**

     * Creates a new {@code JarFile} to read from the specified

     * {@code File} object. The {@code JarFile} will be verified if

     * it is signed.

     * @param file the jar file to be opened for reading

     * @throws IOException if an I/O error has occurred

     * @throws SecurityException if access to the file is denied

     *         by the SecurityManager

     */

    public JarFile(File file) throws IOException {

        this(file, true, ZipFile.OPEN_READ);

    }

    /**

     * Creates a new {@code JarFile} to read from the specified

     * {@code File} object.

     * @param file the jar file to be opened for reading

     * @param verify whether or not to verify the jar file if

     * it is signed.

     * @throws IOException if an I/O error has occurred

     * @throws SecurityException if access to the file is denied

     *         by the SecurityManager.

     */

    public JarFile(File file, boolean verify) throws IOException {

        this(file, verify, ZipFile.OPEN_READ);

    }

    /**

     * Creates a new {@code JarFile} 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}.

     *

     * @param file the jar file to be opened for reading

     * @param verify whether or not to verify the jar file if

     * it is signed.

     * @param mode the mode in which the file is to be opened

     * @throws IOException if an I/O error has occurred

     * @throws IllegalArgumentException

     *         if the {@code mode} argument is invalid

     * @throws SecurityException if access to the file is denied

     *         by the SecurityManager

     * @since 1.3

     */

    public JarFile(File file, boolean verify, int mode) throws IOException {

        this(file, verify, mode, Release.BASE);

        this.notVersioned = true;

    }

    /**

     * Creates a new {@code JarFile} 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}.

     * The version argument configures the {@code JarFile} for processing

     * multi-release jar files.

     *

     * @param file the jar file to be opened for reading

     * @param verify whether or not to verify the jar file if

     * it is signed.

     * @param mode the mode in which the file is to be opened

     * @param version specifies the release version for a multi-release jar file

     * @throws IOException if an I/O error has occurred

     * @throws IllegalArgumentException

     *         if the {@code mode} argument is invalid

     * @throws SecurityException if access to the file is denied

     *         by the SecurityManager

     * @throws NullPointerException if {@code version} is {@code null}

     * @since 9

     */

    public JarFile(File file, boolean verify, int mode, Release version) throws IOException {

        super(file, mode);

        Objects.requireNonNull(version);

        this.verify = verify;

        // version applies to multi-release jar files, ignored for regular jar files

        this.version = MULTI_RELEASE_FORCED ? RUNTIME_VERSION : version.value();

        this.runtimeVersioned = version == Release.RUNTIME;

        assert runtimeVersionExists();

    }

    private boolean runtimeVersionExists() {

        try {

            Release.valueOf(version);

            return true;

        } catch (IllegalArgumentException x) {

            System.err.println("No JarFile.Release object for release " + version);

            return false;

        }

    }

    /**

     * Returns the maximum version used when searching for versioned entries.

     *

     * @return the maximum version, or {@code Release.BASE} if this jar file is

     *         processed as if it is an unversioned jar file or is not a

     *         multi-release jar file

     * @since 9

     */

    public final Release getVersion() {

        if (isMultiRelease()) {

            return runtimeVersioned ? Release.RUNTIME : Release.valueOf(version);

        } else {

            return Release.BASE;

        }

    }

    /**

     * Indicates whether or not this jar file is a multi-release jar file.

     *

     * @return true if this JarFile is a multi-release jar file

     * @since 9

     */

    public final boolean isMultiRelease() {

        // do not call this code in a constructor because some subclasses use

        // lazy loading of manifest so it won't be available at construction time

        if (MULTI_RELEASE_ENABLED) {

            // Doubled-checked locking pattern

            Boolean result = isMultiRelease;

            if (result == null) {

                synchronized (this) {

                    result = isMultiRelease;

                    if (result == null) {

                        Manifest man = null;

                        try {

                            man = getManifest();

                        } catch (IOException e) {

                            //Ignored, manifest cannot be read

                        }

                        isMultiRelease = result = (man != null)

                                && man.getMainAttributes().containsKey(MULTI_RELEASE)

                                ? Boolean.TRUE : Boolean.FALSE;

                    }

                }

            }

            return result == Boolean.TRUE;

        } else {

            return false;

        }

    }

    // the following field, isMultiRelease, should only be used in the method

    // isMultiRelease(), like a static local

    private volatile Boolean isMultiRelease;    // is jar multi-release?

    /**

     * Returns the jar file manifest, or {@code null} if none.

     *

     * @return the jar file manifest, or {@code null} if none

     *

     * @throws IllegalStateException

     *         may be thrown if the jar file has been closed

     * @throws IOException  if an I/O error has occurred

     */

    public Manifest getManifest() throws IOException {

        return getManifestFromReference();

    }

    private Manifest getManifestFromReference() throws IOException {

        Manifest man = manRef != null ? manRef.get() : null;

        if (man == null) {

            JarEntry manEntry = getManEntry();

            // If found then load the manifest

            if (manEntry != null) {

                if (verify) {

                    byte[] b = getBytes(manEntry);

                    man = new Manifest(new ByteArrayInputStream(b));

                    if (!jvInitialized) {

                        jv = new JarVerifier(b);

                    }

                } else {

                    man = new Manifest(super.getInputStream(manEntry));

                }

                manRef = new SoftReference<>(man);

            }

        }

        return man;

    }

    private String[] getMetaInfEntryNames() {

        return jdk.internal.misc.SharedSecrets.getJavaUtilZipFileAccess()

                                              .getMetaInfEntryNames((ZipFile)this);

    }

    /**

     * Returns the {@code JarEntry} for the given base entry name or

     * {@code null} if not found.

     *

     * <p>If this {@code JarFile} is a multi-release jar file and is configured

     * to be processed as such, then a search is performed to find and return

     * a {@code JarEntry} that is the latest versioned entry associated with the

     * given entry name.  The returned {@code JarEntry} is the versioned entry

     * corresponding to the given base entry name prefixed with the string

     * {@code "META-INF/versions/{n}/"}, for the largest value of {@code n} for

     * which an entry exists.  If such a versioned entry does not exist, then

     * the {@code JarEntry} for the base entry is returned, otherwise

     * {@code null} is returned if no entries are found.  The initial value for

     * the version {@code n} is the maximum version as returned by the method

     * {@link JarFile#getVersion()}.

     *

     * @param name the jar file entry name

     * @return the {@code JarEntry} for the given entry name, or

     *         the versioned entry name, or {@code null} if not found

     *

     * @throws IllegalStateException

     *         may be thrown if the jar file has been closed

     *

     * @see java.util.jar.JarEntry

     *

     * @implSpec

     * <div class="block">

     * This implementation invokes {@link JarFile#getEntry(String)}.

     * </div>

     */

    public JarEntry getJarEntry(String name) {

        return (JarEntry)getEntry(name);

    }