/*

 * Copyright (c) 1996, 2013, 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 sun.rmi.server;

import java.io.File;

import java.io.FilePermission;

import java.io.IOException;

import java.lang.ref.ReferenceQueue;

import java.lang.ref.SoftReference;

import java.lang.ref.WeakReference;

import java.lang.reflect.Modifier;

import java.lang.reflect.Proxy;

import java.net.JarURLConnection;

import java.net.MalformedURLException;

import java.net.SocketPermission;

import java.net.URL;

import java.net.URLClassLoader;

import java.net.URLConnection;

import java.security.AccessControlContext;

import java.security.CodeSource;

import java.security.Permission;

import java.security.Permissions;

import java.security.PermissionCollection;

import java.security.Policy;

import java.security.ProtectionDomain;

import java.rmi.server.LogStream;

import java.security.PrivilegedAction;

import java.util.Arrays;

import java.util.Collections;

import java.util.Enumeration;

import java.util.HashMap;

import java.util.IdentityHashMap;

import java.util.Map;

import java.util.StringTokenizer;

import java.util.WeakHashMap;

import sun.reflect.misc.ReflectUtil;

import sun.rmi.runtime.Log;

/**

 * <code>LoaderHandler</code> provides the implementation of the static

 * methods of the <code>java.rmi.server.RMIClassLoader</code> class.

 *

 * @author      Ann Wollrath

 * @author      Peter Jones

 * @author      Laird Dornin

 */

@SuppressWarnings("deprecation")

public final class LoaderHandler {

    /** RMI class loader log level */

    static final int logLevel = LogStream.parseLevel(

        java.security.AccessController.doPrivileged(

            (PrivilegedAction<String>) () -> System.getProperty("sun.rmi.loader.logLevel")));

    /* loader system log */

    static final Log loaderLog =

        Log.getLog("sun.rmi.loader", "loader", LoaderHandler.logLevel);

    /**

     * value of "java.rmi.server.codebase" property, as cached at class

     * initialization time.  It may contain malformed URLs.

     */

    private static String codebaseProperty = null;

    static {

        String prop = java.security.AccessController.doPrivileged(

            (PrivilegedAction<String>) () -> System.getProperty("java.rmi.server.codebase"));

        if (prop != null && prop.trim().length() > 0) {

            codebaseProperty = prop;

        }

    }

    /** list of URLs represented by the codebase property, if valid */

    private static URL[] codebaseURLs = null;

    /** table of class loaders that use codebase property for annotation */

    private static final Map<ClassLoader, Void> codebaseLoaders =

        Collections.synchronizedMap(new IdentityHashMap<ClassLoader, Void>(5));

    static {

        for (ClassLoader codebaseLoader = ClassLoader.getSystemClassLoader();

             codebaseLoader != null;

             codebaseLoader = codebaseLoader.getParent())

        {

            codebaseLoaders.put(codebaseLoader, null);

        }

    }

    /**

     * table mapping codebase URL path and context class loader pairs

     * to class loader instances.  Entries hold class loaders with weak

     * references, so this table does not prevent loaders from being

     * garbage collected.

     */

    private static final HashMap<LoaderKey, LoaderEntry> loaderTable

        = new HashMap<>(5);

    /** reference queue for cleared class loader entries */

    private static final ReferenceQueue<Loader> refQueue

        = new ReferenceQueue<>();

    /*

     * Disallow anyone from creating one of these.

     */

    private LoaderHandler() {}

    /**

     * Returns an array of URLs initialized with the value of the

     * java.rmi.server.codebase property as the URL path.

     */

    private static synchronized URL[] getDefaultCodebaseURLs()

        throws MalformedURLException

    {

        /*

         * If it hasn't already been done, convert the codebase property

         * into an array of URLs; this may throw a MalformedURLException.

         */

        if (codebaseURLs == null) {

            if (codebaseProperty != null) {

                codebaseURLs = pathToURLs(codebaseProperty);

            } else {

                codebaseURLs = new URL[0];

            }

        }

        return codebaseURLs;

    }

    /**

     * Load a class from a network location (one or more URLs),

     * but first try to resolve the named class through the given

     * "default loader".

     */

    public static Class<?> loadClass(String codebase, String name,

                                     ClassLoader defaultLoader)

        throws MalformedURLException, ClassNotFoundException

    {

        if (loaderLog.isLoggable(Log.BRIEF)) {

            loaderLog.log(Log.BRIEF,

                "name = \"" + name + "\", " +

                "codebase = \"" + (codebase != null ? codebase : "") + "\"" +

                (defaultLoader != null ?

                 ", defaultLoader = " + defaultLoader : ""));

        }

        URL[] urls;

        if (codebase != null) {

            urls = pathToURLs(codebase);

        } else {

            urls = getDefaultCodebaseURLs();

        }

        if (defaultLoader != null) {

            try {

                Class<?> c = loadClassForName(name, false, defaultLoader);

                if (loaderLog.isLoggable(Log.VERBOSE)) {

                    loaderLog.log(Log.VERBOSE,

                        "class \"" + name + "\" found via defaultLoader, " +

                        "defined by " + c.getClassLoader());

                }

                return c;

            } catch (ClassNotFoundException e) {

            }

        }

        return loadClass(urls, name);

    }

    /**

     * Returns the class annotation (representing the location for

     * a class) that RMI will use to annotate the call stream when

     * marshalling objects of the given class.

     */

    public static String getClassAnnotation(Class<?> cl) {

        String name = cl.getName();

        /*

         * Class objects for arrays of primitive types never need an

         * annotation, because they never need to be (or can be) downloaded.

         *

         * REMIND: should we (not) be annotating classes that are in

         * "java.*" packages?

         */

        int nameLength = name.length();

        if (nameLength > 0 && name.charAt(0) == '[') {

            // skip past all '[' characters (see bugid 4211906)

            int i = 1;

            while (nameLength > i && name.charAt(i) == '[') {

                i++;

            }

            if (nameLength > i && name.charAt(i) != 'L') {

                return null;

            }

        }

        /*

         * Get the class's class loader.  If it is null, the system class

         * loader, an ancestor of the base class loader (such as the loader

         * for installed extensions), return the value of the

         * "java.rmi.server.codebase" property.

         */

        ClassLoader loader = cl.getClassLoader();

        if (loader == null || codebaseLoaders.containsKey(loader)) {

            return codebaseProperty;

        }

        /*

         * Get the codebase URL path for the class loader, if it supports

         * such a notion (i.e., if it is a URLClassLoader or subclass).

         */

        String annotation = null;

        if (loader instanceof Loader) {

            /*

             * If the class loader is one of our RMI class loaders, we have

             * already computed the class annotation string, and no

             * permissions are required to know the URLs.

             */

            annotation = ((Loader) loader).getClassAnnotation();

        } else if (loader instanceof URLClassLoader) {

            try {

                URL[] urls = ((URLClassLoader) loader).getURLs();

                if (urls != null) {

                    /*

                     * If the class loader is not one of our RMI class loaders,

                     * we must verify that the current access control context

                     * has permission to know all of these URLs.

                     */

                    SecurityManager sm = System.getSecurityManager();

                    if (sm != null) {

                        Permissions perms = new Permissions();

                        for (int i = 0; i < urls.length; i++) {

                            Permission p =

                                urls[i].openConnection().getPermission();

                            if (p != null) {

                                if (!perms.implies(p)) {

                                    sm.checkPermission(p);

                                    perms.add(p);

                                }

                            }

                        }

                    }

                    annotation = urlsToPath(urls);

                }

            } catch (SecurityException | IOException e) {

                /*

                 * SecurityException: If access was denied to the knowledge of

                 * the class loader's URLs, fall back to the default behavior.

                 *

                 * IOException: This shouldn't happen, although it is declared

                 * to be thrown by openConnection() and getPermission().  If it

                 * does happen, forget about this class loader's URLs and

                 * fall back to the default behavior.

                 */

            }

        }

        if (annotation != null) {

            return annotation;

        } else {

            return codebaseProperty;    // REMIND: does this make sense??

        }

    }

    /**

     * Returns a classloader that loads classes from the given codebase URL

     * path.  The parent classloader of the returned classloader is the

     * context class loader.

     */

    public static ClassLoader getClassLoader(String codebase)

        throws MalformedURLException

    {

        ClassLoader parent = getRMIContextClassLoader();

        URL[] urls;

        if (codebase != null) {

            urls = pathToURLs(codebase);

        } else {

            urls = getDefaultCodebaseURLs();

        }

        /*

         * If there is a security manager, the current access control

         * context must have the "getClassLoader" RuntimePermission.

         */

        SecurityManager sm = System.getSecurityManager();

        if (sm != null) {

            sm.checkPermission(new RuntimePermission("getClassLoader"));

        } else {

            /*

             * But if no security manager is set, disable access to

             * RMI class loaders and simply return the parent loader.

             */

            return parent;

        }

        Loader loader = lookupLoader(urls, parent);

        /*

         * Verify that the caller has permission to access this loader.

         */

        if (loader != null) {

            loader.checkPermissions();

        }

        return loader;

    }

    /**

     * Return the security context of the given class loader.

     */

    public static Object getSecurityContext(ClassLoader loader) {

        /*

         * REMIND: This is a bogus JDK1.1-compatible implementation.

         * This method should never be called by application code anyway

         * (hence the deprecation), but should it do something different

         * and perhaps more useful, like return a String or a URL[]?

         */

        if (loader instanceof Loader) {

            URL[] urls = ((Loader) loader).getURLs();

            if (urls.length > 0) {

                return urls[0];

            }

        }

        return null;

    }

    /**

     * Register a class loader as one whose classes should always be

     * annotated with the value of the "java.rmi.server.codebase" property.

     */

    public static void registerCodebaseLoader(ClassLoader loader) {

        codebaseLoaders.put(loader, null);

    }

    /**

     * Load a class from the RMI class loader corresponding to the given

     * codebase URL path in the current execution context.

     */

    private static Class<?> loadClass(URL[] urls, String name)

        throws ClassNotFoundException

    {

        ClassLoader parent = getRMIContextClassLoader();

        if (loaderLog.isLoggable(Log.VERBOSE)) {

            loaderLog.log(Log.VERBOSE,

                "(thread context class loader: " + parent + ")");

        }

        /*

         * If no security manager is set, disable access to RMI class

         * loaders and simply delegate request to the parent loader

         * (see bugid 4140511).

         */

        SecurityManager sm = System.getSecurityManager();

        if (sm == null) {

            try {

                Class<?> c = Class.forName(name, false, parent);

                if (loaderLog.isLoggable(Log.VERBOSE)) {

                    loaderLog.log(Log.VERBOSE,

                        "class \"" + name + "\" found via " +

                        "thread context class loader " +

                        "(no security manager: codebase disabled), " +

                        "defined by " + c.getClassLoader());

                }

                return c;

            } catch (ClassNotFoundException e) {

                if (loaderLog.isLoggable(Log.BRIEF)) {

                    loaderLog.log(Log.BRIEF,

                        "class \"" + name + "\" not found via " +

                        "thread context class loader " +

                        "(no security manager: codebase disabled)", e);

                }

                throw new ClassNotFoundException(e.getMessage() +

                    " (no security manager: RMI class loader disabled)",

                    e.getException());

            }

        }

        /*

         * Get or create the RMI class loader for this codebase URL path

         * and parent class loader pair.

         */

        Loader loader = lookupLoader(urls, parent);

        try {

            if (loader != null) {

                /*

                 * Verify that the caller has permission to access this loader.

                 */

                loader.checkPermissions();

            }

        } catch (SecurityException e) {

            /*

             * If the current access control context does not have permission

             * to access all of the URLs in the codebase path, wrap the

             * resulting security exception in a ClassNotFoundException, so

             * the caller can handle this outcome just like any other class

             * loading failure (see bugid 4146529).

             */

            try {

                /*

                 * But first, check to see if the named class could have been

                 * resolved without the security-offending codebase anyway;

                 * if so, return successfully (see bugids 4191926 & 4349670).

                 */

                Class<?> c = loadClassForName(name, false, parent);

                if (loaderLog.isLoggable(Log.VERBOSE)) {

                    loaderLog.log(Log.VERBOSE,

                        "class \"" + name + "\" found via " +

                        "thread context class loader " +

                        "(access to codebase denied), " +

                        "defined by " + c.getClassLoader());

                }

                return c;

            } catch (ClassNotFoundException unimportant) {

                /*

                 * Presumably the security exception is the more important

                 * exception to report in this case.

                 */

                if (loaderLog.isLoggable(Log.BRIEF)) {

                    loaderLog.log(Log.BRIEF,

                        "class \"" + name + "\" not found via " +

                        "thread context class loader " +

                        "(access to codebase denied)", e);

                }

                throw new ClassNotFoundException(

                    "access to class loader denied", e);

            }

        }

        try {

            Class<?> c = loadClassForName(name, false, loader);

            if (loaderLog.isLoggable(Log.VERBOSE)) {

                loaderLog.log(Log.VERBOSE,

                    "class \"" + name + "\" " + "found via codebase, " +

                    "defined by " + c.getClassLoader());

            }

            return c;

        } catch (ClassNotFoundException e) {

            if (loaderLog.isLoggable(Log.BRIEF)) {

                loaderLog.log(Log.BRIEF,

                    "class \"" + name + "\" not found via codebase", e);

            }

            throw e;

        }

    }

    /**

     * Define and return a dynamic proxy class in a class loader with

     * URLs supplied in the given location.  The proxy class will

     * implement interface classes named by the given array of

     * interface names.

     */

    public static Class<?> loadProxyClass(String codebase, String[] interfaces,

                                          ClassLoader defaultLoader)

        throws MalformedURLException, ClassNotFoundException

    {

        if (loaderLog.isLoggable(Log.BRIEF)) {

            loaderLog.log(Log.BRIEF,

                "interfaces = " + Arrays.asList(interfaces) + ", " +

                "codebase = \"" + (codebase != null ? codebase : "") + "\"" +

                (defaultLoader != null ?

                 ", defaultLoader = " + defaultLoader : ""));

        }

        /*

         * This method uses a fairly complex algorithm to load the

         * proxy class and its interface classes in order to maximize

         * the likelihood that the proxy's codebase annotation will be

         * preserved.  The algorithm is (assuming that all of the

         * proxy interface classes are public):

         *

         * If the default loader is not null, try to load the proxy

         * interfaces through that loader. If the interfaces can be

         * loaded in that loader, try to define the proxy class in an

         * RMI class loader (child of the context class loader) before

         * trying to define the proxy in the default loader.  If the

         * attempt to define the proxy class succeeds, the codebase

         * annotation is preserved.  If the attempt fails, try to

         * define the proxy class in the default loader.

         *

         * If the interface classes can not be loaded from the default

         * loader or the default loader is null, try to load them from

         * the RMI class loader.  Then try to define the proxy class

         * in the RMI class loader.

         *

         * Additionally, if any of the proxy interface classes are not

         * public, all of the non-public interfaces must reside in the

         * same class loader or it will be impossible to define the

         * proxy class (an IllegalAccessError will be thrown).  An

         * attempt to load the interfaces from the default loader is

         * made.  If the attempt fails, a second attempt will be made

         * to load the interfaces from the RMI loader. If all of the

         * non-public interfaces classes do reside in the same class

         * loader, then we attempt to define the proxy class in the

         * class loader of the non-public interfaces.  No other

         * attempt to define the proxy class will be made.

         */

        ClassLoader parent = getRMIContextClassLoader();

        if (loaderLog.isLoggable(Log.VERBOSE)) {

            loaderLog.log(Log.VERBOSE,

                "(thread context class loader: " + parent + ")");