/*

 * Copyright (c) 1997, 2019, 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 jdk.internal.loader;

import java.io.Closeable;

import java.io.File;

import java.io.FileInputStream;

import java.io.FileNotFoundException;

import java.io.IOException;

import java.io.InputStream;

import java.net.HttpURLConnection;

import java.net.JarURLConnection;

import java.net.MalformedURLException;

import java.net.URI;

import java.net.URL;

import java.net.URLConnection;

import java.net.URLStreamHandler;

import java.net.URLStreamHandlerFactory;

import java.security.AccessControlContext;

import java.security.AccessControlException;

import java.security.AccessController;

import java.security.CodeSigner;

import java.security.Permission;

import java.security.PrivilegedActionException;

import java.security.PrivilegedExceptionAction;

import java.security.cert.Certificate;

import java.util.ArrayDeque;

import java.util.ArrayList;

import java.util.Arrays;

import java.util.Collections;

import java.util.Enumeration;

import java.util.HashMap;

import java.util.HashSet;

import java.util.LinkedList;

import java.util.List;

import java.util.NoSuchElementException;

import java.util.Properties;

import java.util.Set;

import java.util.StringTokenizer;

import java.util.jar.JarFile;

import java.util.zip.ZipEntry;

import java.util.jar.JarEntry;

import java.util.jar.Manifest;

import java.util.jar.Attributes;

import java.util.jar.Attributes.Name;

import java.util.zip.ZipFile;

import jdk.internal.access.JavaNetURLAccess;

import jdk.internal.access.JavaUtilZipFileAccess;

import jdk.internal.access.SharedSecrets;

import jdk.internal.util.jar.InvalidJarIndexError;

import jdk.internal.util.jar.JarIndex;

import sun.net.util.URLUtil;

import sun.net.www.ParseUtil;

import sun.security.action.GetPropertyAction;

/**

 * This class is used to maintain a search path of URLs for loading classes

 * and resources from both JAR files and directories.

 *

 * @author  David Connelly

 */

public class URLClassPath {

    private static final String USER_AGENT_JAVA_VERSION = "UA-Java-Version";

    private static final String JAVA_VERSION;

    private static final boolean DEBUG;

    private static final boolean DISABLE_JAR_CHECKING;

    private static final boolean DISABLE_ACC_CHECKING;

    private static final boolean DISABLE_CP_URL_CHECK;

    private static final boolean DEBUG_CP_URL_CHECK;

    static {

        Properties props = GetPropertyAction.privilegedGetProperties();

        JAVA_VERSION = props.getProperty("java.version");

        DEBUG = (props.getProperty("sun.misc.URLClassPath.debug") != null);

        String p = props.getProperty("sun.misc.URLClassPath.disableJarChecking");

        DISABLE_JAR_CHECKING = p != null ? p.equals("true") || p.isEmpty() : false;

        p = props.getProperty("jdk.net.URLClassPath.disableRestrictedPermissions");

        DISABLE_ACC_CHECKING = p != null ? p.equals("true") || p.isEmpty() : false;

        // This property will be removed in a later release

        p = props.getProperty("jdk.net.URLClassPath.disableClassPathURLCheck");

        DISABLE_CP_URL_CHECK = p != null ? p.equals("true") || p.isEmpty() : false;

        // Print a message for each Class-Path entry that is ignored (assuming

        // the check is not disabled).

        p = props.getProperty("jdk.net.URLClassPath.showIgnoredClassPathEntries");

        DEBUG_CP_URL_CHECK = p != null ? p.equals("true") || p.isEmpty() : false;

    }

    /* The original search path of URLs. */

    private final ArrayList<URL> path;

    /* The deque of unopened URLs */

    private final ArrayDeque<URL> unopenedUrls;

    /* The resulting search path of Loaders */

    private final ArrayList<Loader> loaders = new ArrayList<>();

    /* Map of each URL opened to its corresponding Loader */

    private final HashMap<String, Loader> lmap = new HashMap<>();

    /* The jar protocol handler to use when creating new URLs */

    private final URLStreamHandler jarHandler;

    /* Whether this URLClassLoader has been closed yet */

    private boolean closed = false;

    /* The context to be used when loading classes and resources.  If non-null

     * this is the context that was captured during the creation of the

     * URLClassLoader. null implies no additional security restrictions. */

    private final AccessControlContext acc;

    /**

     * Creates a new URLClassPath for the given URLs. The URLs will be

     * searched in the order specified for classes and resources. A URL

     * ending with a '/' is assumed to refer to a directory. Otherwise,

     * the URL is assumed to refer to a JAR file.

     *

     * @param urls the directory and JAR file URLs to search for classes

     *        and resources

     * @param factory the URLStreamHandlerFactory to use when creating new URLs

     * @param acc the context to be used when loading classes and resources, may

     *            be null

     */

    public URLClassPath(URL[] urls,

                        URLStreamHandlerFactory factory,

                        AccessControlContext acc) {

        ArrayList<URL> path = new ArrayList<>(urls.length);

        ArrayDeque<URL> unopenedUrls = new ArrayDeque<>(urls.length);

        for (URL url : urls) {

            path.add(url);

            unopenedUrls.add(url);

        }

        this.path = path;

        this.unopenedUrls = unopenedUrls;

        if (factory != null) {

            jarHandler = factory.createURLStreamHandler("jar");

        } else {

            jarHandler = null;

        }

        if (DISABLE_ACC_CHECKING)

            this.acc = null;

        else

            this.acc = acc;

    }

    public URLClassPath(URL[] urls, AccessControlContext acc) {

        this(urls, null, acc);

    }

    /**

     * Constructs a URLClassPath from a class path string.

     *

     * @param cp the class path string

     * @param skipEmptyElements indicates if empty elements are ignored or

     *        treated as the current working directory

     *

     * @apiNote Used to create the application class path.

     */

    URLClassPath(String cp, boolean skipEmptyElements) {

        ArrayList<URL> path = new ArrayList<>();

        if (cp != null) {

            // map each element of class path to a file URL

            int off = 0, next;

            do {

                next = cp.indexOf(File.pathSeparator, off);

                String element = (next == -1)

                    ? cp.substring(off)

                    : cp.substring(off, next);

                if (!element.isEmpty() || !skipEmptyElements) {

                    URL url = toFileURL(element);

                    if (url != null) path.add(url);

                }

                off = next + 1;

            } while (next != -1);

        }

        // can't use ArrayDeque#addAll or new ArrayDeque(Collection);

        // it's too early in the bootstrap to trigger use of lambdas

        int size = path.size();

        ArrayDeque<URL> unopenedUrls = new ArrayDeque<>(size);

        for (int i = 0; i < size; i++)

            unopenedUrls.add(path.get(i));

        this.unopenedUrls = unopenedUrls;

        this.path = path;

        this.jarHandler = null;

        this.acc = null;

    }

    public synchronized List<IOException> closeLoaders() {

        if (closed) {

            return Collections.emptyList();

        }

        List<IOException> result = new LinkedList<>();

        for (Loader loader : loaders) {

            try {

                loader.close();

            } catch (IOException e) {

                result.add(e);

            }

        }

        closed = true;

        return result;

    }

    /**

     * Appends the specified URL to the search path of directory and JAR

     * file URLs from which to load classes and resources.

     * <p>

     * If the URL specified is null or is already in the list of

     * URLs, then invoking this method has no effect.

     */

    public synchronized void addURL(URL url) {

        if (closed || url == null)

            return;

        synchronized (unopenedUrls) {

            if (! path.contains(url)) {

                unopenedUrls.addLast(url);

                path.add(url);

            }

        }

    }

    /**

     * Appends the specified file path as a file URL to the search path.

     */

    public void addFile(String s) {

        URL url = toFileURL(s);

        if (url != null) {

            addURL(url);

        }

    }

    /**

     * Returns a file URL for the given file path.

     */

    private static URL toFileURL(String s) {

        try {

            File f = new File(s).getCanonicalFile();

            return ParseUtil.fileToEncodedURL(f);

        } catch (IOException e) {

            return null;

        }

    }

    /**

     * Returns the original search path of URLs.

     */

    public URL[] getURLs() {

        synchronized (unopenedUrls) {

            return path.toArray(new URL[0]);

        }

    }

    /**

     * Finds the resource with the specified name on the URL search path

     * or null if not found or security check fails.

     *

     * @param name      the name of the resource

     * @param check     whether to perform a security check

     * @return a {@code URL} for the resource, or {@code null}

     * if the resource could not be found.

     */

    public URL findResource(String name, boolean check) {

        Loader loader;

        for (int i = 0; (loader = getLoader(i)) != null; i++) {

            URL url = loader.findResource(name, check);

            if (url != null) {

                return url;

            }

        }

        return null;

    }

    /**

     * Finds the first Resource on the URL search path which has the specified

     * name. Returns null if no Resource could be found.

     *

     * @param name the name of the Resource

     * @param check     whether to perform a security check

     * @return the Resource, or null if not found

     */

    public Resource getResource(String name, boolean check) {

        if (DEBUG) {

            System.err.println("URLClassPath.getResource(\"" + name + "\")");

        }

        Loader loader;

        for (int i = 0; (loader = getLoader(i)) != null; i++) {

            Resource res = loader.getResource(name, check);

            if (res != null) {

                return res;

            }

        }

        return null;

    }

    /**

     * Finds all resources on the URL search path with the given name.

     * Returns an enumeration of the URL objects.

     *

     * @param name the resource name

     * @return an Enumeration of all the urls having the specified name

     */

    public Enumeration<URL> findResources(final String name,

                                     final boolean check) {

        return new Enumeration<>() {

            private int index = 0;

            private URL url = null;

            private boolean next() {

                if (url != null) {

                    return true;

                } else {

                    Loader loader;

                    while ((loader = getLoader(index++)) != null) {

                        url = loader.findResource(name, check);

                        if (url != null) {

                            return true;

                        }

                    }

                    return false;

                }

            }

            public boolean hasMoreElements() {

                return next();

            }

            public URL nextElement() {

                if (!next()) {

                    throw new NoSuchElementException();

                }

                URL u = url;

                url = null;

                return u;

            }

        };

    }

    public Resource getResource(String name) {

        return getResource(name, true);

    }

    /**

     * Finds all resources on the URL search path with the given name.

     * Returns an enumeration of the Resource objects.

     *

     * @param name the resource name

     * @return an Enumeration of all the resources having the specified name

     */

    public Enumeration<Resource> getResources(final String name,

                                    final boolean check) {

        return new Enumeration<>() {

            private int index = 0;

            private Resource res = null;

            private boolean next() {

                if (res != null) {

                    return true;

                } else {

                    Loader loader;

                    while ((loader = getLoader(index++)) != null) {

                        res = loader.getResource(name, check);

                        if (res != null) {

                            return true;

                        }

                    }

                    return false;

                }

            }

            public boolean hasMoreElements() {

                return next();

            }

            public Resource nextElement() {

                if (!next()) {

                    throw new NoSuchElementException();

                }

                Resource r = res;

                res = null;

                return r;

            }

        };

    }

    public Enumeration<Resource> getResources(final String name) {

        return getResources(name, true);

    }

    /*

     * Returns the Loader at the specified position in the URL search

     * path. The URLs are opened and expanded as needed. Returns null

     * if the specified index is out of range.

     */

    private synchronized Loader getLoader(int index) {

        if (closed) {

            return null;

        }

        // Expand URL search path until the request can be satisfied

        // or unopenedUrls is exhausted.

        while (loaders.size() < index + 1) {

            final URL url;

            synchronized (unopenedUrls) {

                url = unopenedUrls.pollFirst();

                if (url == null)

                    return null;

            }

            // Skip this URL if it already has a Loader. (Loader

            // may be null in the case where URL has not been opened

            // but is referenced by a JAR index.)

            String urlNoFragString = URLUtil.urlNoFragString(url);

            if (lmap.containsKey(urlNoFragString)) {

                continue;

            }

            // Otherwise, create a new Loader for the URL.

            Loader loader;

            try {

                loader = getLoader(url);

                // If the loader defines a local class path then add the

                // URLs as the next URLs to be opened.

                URL[] urls = loader.getClassPath();

                if (urls != null) {

                    push(urls);

                }

            } catch (IOException e) {

                // Silently ignore for now...

                continue;

            } catch (SecurityException se) {

                // Always silently ignore. The context, if there is one, that

                // this URLClassPath was given during construction will never

                // have permission to access the URL.

                if (DEBUG) {

                    System.err.println("Failed to access " + url + ", " + se );

                }

                continue;

            }

            // Finally, add the Loader to the search path.

            loaders.add(loader);

            lmap.put(urlNoFragString, loader);

        }

        return loaders.get(index);

    }

    /*

     * Returns the Loader for the specified base URL.

     */

    private Loader getLoader(final URL url) throws IOException {

        try {

            return AccessController.doPrivileged(

                    new PrivilegedExceptionAction<>() {

                        public Loader run() throws IOException {

                            String protocol = url.getProtocol();  // lower cased in URL

                            String file = url.getFile();

                            if (file != null && file.endsWith("/")) {

                                if ("file".equals(protocol)) {

                                    return new FileLoader(url);

                                } else if ("jar".equals(protocol) &&

                                        isDefaultJarHandler(url) &&

                                        file.endsWith("!/")) {

                                    // extract the nested URL

                                    URL nestedUrl = new URL(file.substring(0, file.length() - 2));

                                    return new JarLoader(nestedUrl, jarHandler, lmap, acc);

                                } else {

                                    return new Loader(url);

                                }

                            } else {

                                return new JarLoader(url, jarHandler, lmap, acc);

                            }

                        }

                    }, acc);

        } catch (PrivilegedActionException pae) {

            throw (IOException)pae.getException();

        }