/*

 * Copyright 1997-2009 Sun Microsystems, Inc.  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.  Sun designates this

 * particular file as subject to the "Classpath" exception as provided

 * by Sun 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 Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,

 * CA 95054 USA or visit www.sun.com if you need additional information or

 * have any questions.

 */

package java.net;

import java.lang.reflect.Method;

import java.lang.reflect.Modifier;

import java.io.File;

import java.io.FilePermission;

import java.io.InputStream;

import java.io.IOException;

import java.io.Closeable;

import java.net.URL;

import java.net.URLConnection;

import java.net.URLStreamHandlerFactory;

import java.util.Enumeration;

import java.util.List;

import java.util.NoSuchElementException;

import java.util.StringTokenizer;

import java.util.jar.Manifest;

import java.util.jar.Attributes;

import java.util.jar.Attributes.Name;

import java.security.CodeSigner;

import java.security.PrivilegedAction;

import java.security.PrivilegedExceptionAction;

import java.security.AccessController;

import java.security.AccessControlContext;

import java.security.SecureClassLoader;

import java.security.CodeSource;

import java.security.Permission;

import java.security.PermissionCollection;

import sun.misc.Resource;

import sun.misc.URLClassPath;

import sun.net.www.ParseUtil;

import sun.security.util.SecurityConstants;

/**

 * This class loader is used to load classes and resources from a search

 * path of URLs referring to both JAR files and directories. Any URL that

 * ends with a '/' is assumed to refer to a directory. Otherwise, the URL

 * is assumed to refer to a JAR file which will be opened as needed.

 * <p>

 * The AccessControlContext of the thread that created the instance of

 * URLClassLoader will be used when subsequently loading classes and

 * resources.

 * <p>

 * The classes that are loaded are by default granted permission only to

 * access the URLs specified when the URLClassLoader was created.

 *

 * @author  David Connelly

 * @since   1.2

 */

public class URLClassLoader extends SecureClassLoader implements Closeable {

    /* The search path for classes and resources */

    private final URLClassPath ucp;

    /* The context to be used when loading classes and resources */

    private final AccessControlContext acc;

    /**

     * Constructs a new URLClassLoader for the given URLs. The URLs will be

     * searched in the order specified for classes and resources after first

     * searching in the specified parent class loader. Any URL that ends with

     * a '/' is assumed to refer to a directory. Otherwise, the URL is assumed

     * to refer to a JAR file which will be downloaded and opened as needed.

     *

     * <p>If there is a security manager, this method first

     * calls the security manager's {@code checkCreateClassLoader} method

     * to ensure creation of a class loader is allowed.

     *

     * @param urls the URLs from which to load classes and resources

     * @param parent the parent class loader for delegation

     * @exception  SecurityException  if a security manager exists and its

     *             {@code checkCreateClassLoader} method doesn't allow

     *             creation of a class loader.

     * @see SecurityManager#checkCreateClassLoader

     */

    public URLClassLoader(URL[] urls, ClassLoader parent) {

        super(parent);

        // this is to make the stack depth consistent with 1.1

        SecurityManager security = System.getSecurityManager();

        if (security != null) {

            security.checkCreateClassLoader();

        }

        ucp = new URLClassPath(urls);

        this.acc = AccessController.getContext();

    }

    URLClassLoader(URL[] urls, ClassLoader parent,

                   AccessControlContext acc) {

        super(parent);

        // this is to make the stack depth consistent with 1.1

        SecurityManager security = System.getSecurityManager();

        if (security != null) {

            security.checkCreateClassLoader();

        }

        ucp = new URLClassPath(urls);

        this.acc = acc;

    }

    /**

     * Constructs a new URLClassLoader for the specified URLs using the

     * default delegation parent <code>ClassLoader</code>. The URLs will

     * be searched in the order specified for classes and resources after

     * first searching in the parent class loader. Any URL that ends with

     * a '/' is assumed to refer to a directory. Otherwise, the URL is

     * assumed to refer to a JAR file which will be downloaded and opened

     * as needed.

     *

     * <p>If there is a security manager, this method first

     * calls the security manager's <code>checkCreateClassLoader</code> method

     * to ensure creation of a class loader is allowed.

     *

     * @param urls the URLs from which to load classes and resources

     *

     * @exception  SecurityException  if a security manager exists and its

     *             <code>checkCreateClassLoader</code> method doesn't allow

     *             creation of a class loader.

     * @see SecurityManager#checkCreateClassLoader

     */

    public URLClassLoader(URL[] urls) {

        super();

        // this is to make the stack depth consistent with 1.1

        SecurityManager security = System.getSecurityManager();

        if (security != null) {

            security.checkCreateClassLoader();

        }

        ucp = new URLClassPath(urls);

        this.acc = AccessController.getContext();

    }

    URLClassLoader(URL[] urls, AccessControlContext acc) {

        super();

        // this is to make the stack depth consistent with 1.1

        SecurityManager security = System.getSecurityManager();

        if (security != null) {

            security.checkCreateClassLoader();

        }

        ucp = new URLClassPath(urls);

        this.acc = acc;

    }

    /**

     * Constructs a new URLClassLoader for the specified URLs, parent

     * class loader, and URLStreamHandlerFactory. The parent argument

     * will be used as the parent class loader for delegation. The

     * factory argument will be used as the stream handler factory to

     * obtain protocol handlers when creating new jar URLs.

     *

     * <p>If there is a security manager, this method first

     * calls the security manager's <code>checkCreateClassLoader</code> method

     * to ensure creation of a class loader is allowed.

     *

     * @param urls the URLs from which to load classes and resources

     * @param parent the parent class loader for delegation

     * @param factory the URLStreamHandlerFactory to use when creating URLs

     *

     * @exception  SecurityException  if a security manager exists and its

     *             <code>checkCreateClassLoader</code> method doesn't allow

     *             creation of a class loader.

     * @see SecurityManager#checkCreateClassLoader

     */

    public URLClassLoader(URL[] urls, ClassLoader parent,

                          URLStreamHandlerFactory factory) {

        super(parent);

        // this is to make the stack depth consistent with 1.1

        SecurityManager security = System.getSecurityManager();

        if (security != null) {

            security.checkCreateClassLoader();

        }

        ucp = new URLClassPath(urls, factory);

        acc = AccessController.getContext();

    }

   /**

    * Closes this URLClassLoader, so that it can no longer be used to load

    * new classes or resources that are defined by this loader.

    * Classes and resources defined by any of this loader's parents in the

    * delegation hierarchy are still accessible. Also, any classes or resources

    * that are already loaded, are still accessible.

    * <p>

    * In the case of jar: and file: URLs, it also closes any class files,

    * or JAR files that were opened by it. If another thread is loading a

    * class when the {@code close} method is invoked, then the result of

    * that load is undefined.

    * <p>

    * The method makes a best effort attempt to close all opened files,

    * by catching {@link IOException}s internally. Unchecked exceptions

    * and errors are not caught. Calling close on an already closed

    * loader has no effect.

    * <p>

    * @throws IOException if closing any file opened by this class loader

    * resulted in an IOException. Any such exceptions are caught, and a

    * single IOException is thrown after the last file has been closed.

    * If only one exception was thrown, it will be set as the <i>cause</i>

    * of this IOException.

    *

    * @throws SecurityException if a security manager is set, and it denies

    *   {@link RuntimePermission}<tt>("closeClassLoader")</tt>

    *

    * @since 1.7

    */

    public void close() throws IOException {

        SecurityManager security = System.getSecurityManager();

        if (security != null) {

            security.checkPermission(new RuntimePermission("closeClassLoader"));

        }

        List<IOException> errors = ucp.closeLoaders();

        if (errors.isEmpty()) {

            return;

        }

        if (errors.size() == 1) {

            throw new IOException (

                "Error closing URLClassLoader resource",

                errors.get(0)

            );

        }

        // Several exceptions. So, just combine the error messages

        String errormsg = "Error closing resources: ";

        for (IOException error: errors) {

            errormsg = errormsg + "[" + error.toString() + "] ";

        }

        throw new IOException (errormsg);

    }

    /**

     * Appends the specified URL to the list of URLs to search for

     * classes and resources.

     * <p>

     * If the URL specified is <code>null</code> or is already in the

     * list of URLs, or if this loader is closed, then invoking this

     * method has no effect.

     *

     * @param url the URL to be added to the search path of URLs

     */

    protected void addURL(URL url) {

        ucp.addURL(url);

    }

    /**

     * Returns the search path of URLs for loading classes and resources.

     * This includes the original list of URLs specified to the constructor,

     * along with any URLs subsequently appended by the addURL() method.

     * @return the search path of URLs for loading classes and resources.

     */

    public URL[] getURLs() {

        return ucp.getURLs();

    }

    /**

     * Finds and loads the class with the specified name from the URL search

     * path. Any URLs referring to JAR files are loaded and opened as needed

     * until the class is found.

     *

     * @param name the name of the class

     * @return the resulting class

     * @exception ClassNotFoundException if the class could not be found,

     *            or if the loader is closed.

     */

    protected Class<?> findClass(final String name)

         throws ClassNotFoundException

    {

        try {

            return AccessController.doPrivileged(

                new PrivilegedExceptionAction<Class>() {

                    public Class run() throws ClassNotFoundException {

                        String path = name.replace('.', '/').concat(".class");

                        Resource res = ucp.getResource(path, false);

                        if (res != null) {

                            try {

                                return defineClass(name, res);

                            } catch (IOException e) {

                                throw new ClassNotFoundException(name, e);

                            }

                        } else {

                            throw new ClassNotFoundException(name);

                        }

                    }

                }, acc);

        } catch (java.security.PrivilegedActionException pae) {

            throw (ClassNotFoundException) pae.getException();

        }

    }

    /*

     * Retrieve the package using the specified package name.

     * If non-null, verify the package using the specified code

     * source and manifest.

     */

    private Package getAndVerifyPackage(String pkgname,

                                        Manifest man, URL url) {

        Package pkg = getPackage(pkgname);

        if (pkg != null) {

            // Package found, so check package sealing.

            if (pkg.isSealed()) {

                // Verify that code source URL is the same.

                if (!pkg.isSealed(url)) {

                    throw new SecurityException(

                        "sealing violation: package " + pkgname + " is sealed");

                }

            } else {

                // Make sure we are not attempting to seal the package

                // at this code source URL.

                if ((man != null) && isSealed(pkgname, man)) {

                    throw new SecurityException(

                        "sealing violation: can't seal package " + pkgname +

                        ": already loaded");

                }

            }

        }

        return pkg;

    }

    /*

     * Defines a Class using the class bytes obtained from the specified

     * Resource. The resulting Class must be resolved before it can be

     * used.

     */

    private Class defineClass(String name, Resource res) throws IOException {

        int i = name.lastIndexOf('.');

        URL url = res.getCodeSourceURL();

        if (i != -1) {

            String pkgname = name.substring(0, i);

            // Check if package already loaded.

            Manifest man = res.getManifest();

            if (getAndVerifyPackage(pkgname, man, url) == null) {

                try {

                    if (man != null) {

                        definePackage(pkgname, man, url);

                    } else {

                        definePackage(pkgname, null, null, null, null, null, null, null);

                    }

                } catch (IllegalArgumentException iae) {

                    // parallel-capable class loaders: re-verify in case of a

                    // race condition

                    if (getAndVerifyPackage(pkgname, man, url) == null) {

                        // Should never happen

                        throw new AssertionError("Cannot find package " +

                                                 pkgname);

                    }

                }

            }

        }

        // Now read the class bytes and define the class

        java.nio.ByteBuffer bb = res.getByteBuffer();

        if (bb != null) {

            // Use (direct) ByteBuffer:

            CodeSigner[] signers = res.getCodeSigners();

            CodeSource cs = new CodeSource(url, signers);

            return defineClass(name, bb, cs);

        } else {

            byte[] b = res.getBytes();

            // must read certificates AFTER reading bytes.

            CodeSigner[] signers = res.getCodeSigners();

            CodeSource cs = new CodeSource(url, signers);

            return defineClass(name, b, 0, b.length, cs);

        }

    }

    /**

     * Defines a new package by name in this ClassLoader. The attributes

     * contained in the specified Manifest will be used to obtain package

     * version and sealing information. For sealed packages, the additional

     * URL specifies the code source URL from which the package was loaded.

     *

     * @param name  the package name

     * @param man   the Manifest containing package version and sealing

     *              information

     * @param url   the code source url for the package, or null if none

     * @exception   IllegalArgumentException if the package name duplicates

     *              an existing package either in this class loader or one

     *              of its ancestors

     * @return the newly defined Package object

     */

    protected Package definePackage(String name, Manifest man, URL url)

        throws IllegalArgumentException

    {

        String path = name.replace('.', '/').concat("/");

        String specTitle = null, specVersion = null, specVendor = null;

        String implTitle = null, implVersion = null, implVendor = null;

        String sealed = null;

        URL sealBase = null;

        Attributes attr = man.getAttributes(path);

        if (attr != null) {

            specTitle   = attr.getValue(Name.SPECIFICATION_TITLE);

            specVersion = attr.getValue(Name.SPECIFICATION_VERSION);

            specVendor  = attr.getValue(Name.SPECIFICATION_VENDOR);

            implTitle   = attr.getValue(Name.IMPLEMENTATION_TITLE);

            implVersion = attr.getValue(Name.IMPLEMENTATION_VERSION);

            implVendor  = attr.getValue(Name.IMPLEMENTATION_VENDOR);

            sealed      = attr.getValue(Name.SEALED);

        }

        attr = man.getMainAttributes();

        if (attr != null) {

            if (specTitle == null) {

                specTitle = attr.getValue(Name.SPECIFICATION_TITLE);

            }

            if (specVersion == null) {

                specVersion = attr.getValue(Name.SPECIFICATION_VERSION);

            }

            if (specVendor == null) {

                specVendor = attr.getValue(Name.SPECIFICATION_VENDOR);

            }

            if (implTitle == null) {

                implTitle = attr.getValue(Name.IMPLEMENTATION_TITLE);

            }

            if (implVersion == null) {

                implVersion = attr.getValue(Name.IMPLEMENTATION_VERSION);

            }

            if (implVendor == null) {

                implVendor = attr.getValue(Name.IMPLEMENTATION_VENDOR);

            }

            if (sealed == null) {

                sealed = attr.getValue(Name.SEALED);

            }

        }

        if ("true".equalsIgnoreCase(sealed)) {

            sealBase = url;

        }

        return definePackage(name, specTitle, specVersion, specVendor,

                             implTitle, implVersion, implVendor, sealBase);

    }

    /*

     * Returns true if the specified package name is sealed according to the

     * given manifest.

     */

    private boolean isSealed(String name, Manifest man) {

        String path = name.replace('.', '/').concat("/");

        Attributes attr = man.getAttributes(path);

        String sealed = null;

        if (attr != null) {

            sealed = attr.getValue(Name.SEALED);

        }

        if (sealed == null) {

            if ((attr = man.getMainAttributes()) != null) {

                sealed = attr.getValue(Name.SEALED);

            }

        }

        return "true".equalsIgnoreCase(sealed);

    }

    /**

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

     *

     * @param name the name of the resource

     * @return a <code>URL</code> for the resource, or <code>null</code>

     * if the resource could not be found, or if the loader is closed.

     */

    public URL findResource(final String name) {

        /*

         * The same restriction to finding classes applies to resources

         */

        URL url = AccessController.doPrivileged(

            new PrivilegedAction<URL>() {

                public URL run() {

                    return ucp.findResource(name, true);

                }

            }, acc);

        return url != null ? ucp.checkURL(url) : null;

    }

    /**

     * Returns an Enumeration of URLs representing all of the resources

     * on the URL search path having the specified name.

     *

     * @param name the resource name

     * @exception IOException if an I/O exception occurs

     * @return an <code>Enumeration</code> of <code>URL</code>s

     *         If the loader is closed, the Enumeration will be empty.

     */

    public Enumeration<URL> findResources(final String name)

        throws IOException

    {

        final Enumeration<URL> e = ucp.findResources(name, true);

        return new Enumeration<URL>() {

            private URL url = null;

            private boolean next() {

                if (url != null) {

                    return true;

                }

                do {

                    URL u = AccessController.doPrivileged(

                        new PrivilegedAction<URL>() {

                            public URL run() {