/* * Copyright (c) 1996, 2008, 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.ByteArrayOutputStream;import java.io.IOException;import java.io.DataOutputStream;import java.lang.reflect.Constructor;import java.lang.reflect.InvocationHandler;import java.lang.reflect.InvocationTargetException;import java.lang.reflect.Proxy;import java.lang.reflect.Method;import java.rmi.Remote;import java.rmi.RemoteException;import java.rmi.StubNotFoundException;import java.rmi.registry.Registry;import java.rmi.server.LogStream;import java.rmi.server.ObjID;import java.rmi.server.RMIClientSocketFactory;import java.rmi.server.RemoteObjectInvocationHandler;import java.rmi.server.RemoteRef;import java.rmi.server.RemoteStub;import java.rmi.server.Skeleton;import java.rmi.server.SkeletonNotFoundException;import java.security.AccessController;import java.security.MessageDigest;import java.security.DigestOutputStream;import java.security.NoSuchAlgorithmException;import java.util.ArrayList;import java.util.Collections;import java.util.Map;import java.util.WeakHashMap;import sun.rmi.registry.RegistryImpl;import sun.rmi.runtime.Log;import sun.rmi.transport.LiveRef;import sun.rmi.transport.tcp.TCPEndpoint;import sun.security.action.GetBooleanAction;import sun.security.action.GetPropertyAction; /** * A utility class with static methods for creating stubs/proxies and * skeletons for remote objects. */public final class Util {     /** "server" package log level */    static final int logLevel = LogStream.parseLevel(        AccessController.doPrivileged(            new GetPropertyAction("sun.rmi.server.logLevel")));     /** server reference log */    public static final Log serverRefLog =        Log.getLog("sun.rmi.server.ref", "transport", Util.logLevel);     /** cached value of property java.rmi.server.ignoreStubClasses */    private static final boolean ignoreStubClasses =        AccessController.doPrivileged(            new GetBooleanAction("java.rmi.server.ignoreStubClasses")).            booleanValue();     /** cache of  impl classes that have no corresponding stub class */    private static final Map<Class<?>, Void> withoutStubs =        Collections.synchronizedMap(new WeakHashMap<Class<?>, Void>(11));     /** parameter types for stub constructor */    private static final Class[] stubConsParamTypes = { RemoteRef.class };     private Util() {    }     /**     * Returns a proxy for the specified implClass.     *     * If both of the following criteria is satisfied, a dynamic proxy for     * the specified implClass is returned (otherwise a RemoteStub instance     * for the specified implClass is returned):     *     *    a) either the property java.rmi.server.ignoreStubClasses is true or     *       a pregenerated stub class does not exist for the impl class, and     *    b) forceStubUse is false.     *     * If the above criteria are satisfied, this method constructs a     * dynamic proxy instance (that implements the remote interfaces of     * implClass) constructed with a RemoteObjectInvocationHandler instance     * constructed with the clientRef.     *     * Otherwise, this method loads the pregenerated stub class (which     * extends RemoteStub and implements the remote interfaces of     * implClass) and constructs an instance of the pregenerated stub     * class with the clientRef.     *     * @param implClass the class to obtain remote interfaces from     * @param clientRef the remote ref to use in the invocation handler     * @param forceStubUse if true, forces creation of a RemoteStub     * @throws IllegalArgumentException if implClass implements illegal     * remote interfaces     * @throws StubNotFoundException if problem locating/creating stub or     * creating the dynamic proxy instance     **/    public static Remote createProxy(Class implClass,                                     RemoteRef clientRef,                                     boolean forceStubUse)        throws StubNotFoundException    {        Class remoteClass;         try {            remoteClass = getRemoteClass(implClass);        } catch (ClassNotFoundException ex ) {            throw new StubNotFoundException(                "object does not implement a remote interface: " +                implClass.getName());        }         if (forceStubUse ||            !(ignoreStubClasses || !stubClassExists(remoteClass)))        {            return createStub(remoteClass, clientRef);        }         ClassLoader loader = implClass.getClassLoader();        Class[] interfaces = getRemoteInterfaces(implClass);        InvocationHandler handler =            new RemoteObjectInvocationHandler(clientRef);         /* REMIND: private remote interfaces? */         try {            return (Remote) Proxy.newProxyInstance(loader,                                                   interfaces,                                                   handler);        } catch (IllegalArgumentException e) {            throw new StubNotFoundException("unable to create proxy", e);        }    }     /**     * Returns true if a stub class for the given impl class can be loaded,     * otherwise returns false.     *     * @param remoteClass the class to obtain remote interfaces from     */    private static boolean stubClassExists(Class remoteClass) {        if (!withoutStubs.containsKey(remoteClass)) {            try {                Class.forName(remoteClass.getName() + "_Stub",                              false,                              remoteClass.getClassLoader());                return true;             } catch (ClassNotFoundException cnfe) {                withoutStubs.put(remoteClass, null);            }        }        return false;    }     /*     * Returns the class/superclass that implements the remote interface.     * @throws ClassNotFoundException if no class is found to have a     * remote interface     */    private static Class getRemoteClass(Class cl)        throws ClassNotFoundException    {        while (cl != null) {            Class[] interfaces = cl.getInterfaces();            for (int i = interfaces.length -1; i >= 0; i--) {                if (Remote.class.isAssignableFrom(interfaces[i]))                    return cl;          // this class implements remote object            }            cl = cl.getSuperclass();        }        throw new ClassNotFoundException(                "class does not implement java.rmi.Remote");    }     /**     * Returns an array containing the remote interfaces implemented     * by the given class.     *     * @param   remoteClass the class to obtain remote interfaces from     * @throws  IllegalArgumentException if remoteClass implements     *          any illegal remote interfaces     * @throws  NullPointerException if remoteClass is null     */    private static Class[] getRemoteInterfaces(Class remoteClass) {        ArrayList<Class<?>> list = new ArrayList<Class<?>>();        getRemoteInterfaces(list, remoteClass);        return list.toArray(new Class<?>[list.size()]);    }     /**     * Fills the given array list with the remote interfaces implemented     * by the given class.     *     * @throws  IllegalArgumentException if the specified class implements     *          any illegal remote interfaces     * @throws  NullPointerException if the specified class or list is null     */    private static void getRemoteInterfaces(ArrayList<Class<?>> list, Class cl) {        Class superclass = cl.getSuperclass();        if (superclass != null) {            getRemoteInterfaces(list, superclass);        }         Class[] interfaces = cl.getInterfaces();        for (int i = 0; i < interfaces.length; i++) {            Class intf = interfaces[i];            /*             * If it is a remote interface (if it extends from             * java.rmi.Remote) and is not already in the list,             * then add the interface to the list.             */            if (Remote.class.isAssignableFrom(intf)) {                if (!(list.contains(intf))) {                    Method[] methods = intf.getMethods();                    for (int j = 0; j < methods.length; j++) {                        checkMethod(methods[j]);                    }                    list.add(intf);                }            }        }    }     /**     * Verifies that the supplied method has at least one declared exception     * type that is RemoteException or one of its superclasses.  If not,     * then this method throws IllegalArgumentException.     *     * @throws IllegalArgumentException if m is an illegal remote method     */    private static void checkMethod(Method m) {        Class<?>[] ex = m.getExceptionTypes();        for (int i = 0; i < ex.length; i++) {            if (ex[i].isAssignableFrom(RemoteException.class))                return;        }        throw new IllegalArgumentException(            "illegal remote method encountered: " + m);    }     /**     * Creates a RemoteStub instance for the specified class, constructed     * with the specified RemoteRef.  The supplied class must be the most     * derived class in the remote object's superclass chain that     * implements a remote interface.  The stub class name is the name of     * the specified remoteClass with the suffix "_Stub".  The loading of     * the stub class is initiated from class loader of the specified class     * (which may be the bootstrap class loader).     **/    private static RemoteStub createStub(Class remoteClass, RemoteRef ref)        throws StubNotFoundException    {        String stubname = remoteClass.getName() + "_Stub";         /* Make sure to use the local stub loader for the stub classes.         * When loaded by the local loader the load path can be         * propagated to remote clients, by the MarshalOutputStream/InStream         * pickle methods         */        try {            Class<?> stubcl =                Class.forName(stubname, false, remoteClass.getClassLoader());            Constructor cons = stubcl.getConstructor(stubConsParamTypes);            return (RemoteStub) cons.newInstance(new Object[] { ref });         } catch (ClassNotFoundException e) {            throw new StubNotFoundException(                "Stub class not found: " + stubname, e);        } catch (NoSuchMethodException e) {            throw new StubNotFoundException(                "Stub class missing constructor: " + stubname, e);        } catch (InstantiationException e) {            throw new StubNotFoundException(                "Can't create instance of stub class: " + stubname, e);        } catch (IllegalAccessException e) {            throw new StubNotFoundException(                "Stub class constructor not public: " + stubname, e);        } catch (InvocationTargetException e) {            throw new StubNotFoundException(                "Exception creating instance of stub class: " + stubname, e);        } catch (ClassCastException e) {            throw new StubNotFoundException(                "Stub class not instance of RemoteStub: " + stubname, e);        }    }     /**     * Locate and return the Skeleton for the specified remote object     */    static Skeleton createSkeleton(Remote object)        throws SkeletonNotFoundException    {        Class cl;        try {            cl = getRemoteClass(object.getClass());        } catch (ClassNotFoundException ex ) {            throw new SkeletonNotFoundException(                "object does not implement a remote interface: " +                object.getClass().getName());        }         // now try to load the skeleton based ont he name of the class        String skelname = cl.getName() + "_Skel";        try {            Class skelcl = Class.forName(skelname, false, cl.getClassLoader());             return (Skeleton)skelcl.newInstance();        } catch (ClassNotFoundException ex) {            throw new SkeletonNotFoundException("Skeleton class not found: " +                                                skelname, ex);        } catch (InstantiationException ex) {            throw new SkeletonNotFoundException("Can't create skeleton: " +                                                skelname, ex);        } catch (IllegalAccessException ex) {            throw new SkeletonNotFoundException("No public constructor: " +                                                skelname, ex);        } catch (ClassCastException ex) {            throw new SkeletonNotFoundException(                "Skeleton not of correct class: " + skelname, ex);        }    }     /**     * Compute the "method hash" of a remote method.  The method hash     * is a long containing the first 64 bits of the SHA digest from     * the UTF encoded string of the method name and descriptor.     */    public static long computeMethodHash(Method m) {        long hash = 0;        ByteArrayOutputStream sink = new ByteArrayOutputStream(127);        try {            MessageDigest md = MessageDigest.getInstance("SHA");            DataOutputStream out = new DataOutputStream(                new DigestOutputStream(sink, md));             String s = getMethodNameAndDescriptor(m);            if (serverRefLog.isLoggable(Log.VERBOSE)) {                serverRefLog.log(Log.VERBOSE,                    "string used for method hash: \"" + s + "\"");            }            out.writeUTF(s);             // use only the first 64 bits of the digest for the hash            out.flush();            byte hasharray[] = md.digest();            for (int i = 0; i < Math.min(8, hasharray.length); i++) {                hash += ((long) (hasharray[i] & 0xFF)) << (i * 8);            }        } catch (IOException ignore) {            /* can't happen, but be deterministic anyway. */            hash = -1;        } catch (NoSuchAlgorithmException complain) {            throw new SecurityException(complain.getMessage());        }        return hash;    }     /**     * Return a string consisting of the given method's name followed by     * its "method descriptor", as appropriate for use in the computation     * of the "method hash".     *     * See section 4.3.3 of The Java Virtual Machine Specification for     * the definition of a "method descriptor".     */    private static String getMethodNameAndDescriptor(Method m) {        StringBuffer desc = new StringBuffer(m.getName());        desc.append('(');        Class[] paramTypes = m.getParameterTypes();        for (int i = 0; i < paramTypes.length; i++) {            desc.append(getTypeDescriptor(paramTypes[i]));        }        desc.append(')');        Class returnType = m.getReturnType();        if (returnType == void.class) { // optimization: handle void here            desc.append('V');        } else {            desc.append(getTypeDescriptor(returnType));        }        return desc.toString();    }     /**     * Get the descriptor of a particular type, as appropriate for either     * a parameter or return type in a method descriptor.     */    private static String getTypeDescriptor(Class type) {        if (type.isPrimitive()) {            if (type == int.class) {                return "I";            } else if (type == boolean.class) {                return "Z";            } else if (type == byte.class) {                return "B";            } else if (type == char.class) {                return "C";            } else if (type == short.class) {                return "S";            } else if (type == long.class) {                return "J";            } else if (type == float.class) {                return "F";            } else if (type == double.class) {                return "D";            } else if (type == void.class) {                return "V";            } else {                throw new Error("unrecognized primitive type: " + type);            }        } else if (type.isArray()) {            /*             * According to JLS 20.3.2, the getName() method on Class does             * return the VM type descriptor format for array classes (only);             * using that should be quicker than the otherwise obvious code:             *             *     return "[" + getTypeDescriptor(type.getComponentType());             */            return type.getName().replace('.', '/');        } else {            return "L" + type.getName().replace('.', '/') + ";";        }    }     /**     * Returns the binary name of the given type without package     * qualification.  Nested types are treated no differently from     * top-level types, so for a nested type, the returned name will     * still be qualified with the simple name of its enclosing     * top-level type (and perhaps other enclosing types), the     * separator will be '$', etc.     **/    public static String getUnqualifiedName(Class c) {        String binaryName = c.getName();        return binaryName.substring(binaryName.lastIndexOf('.') + 1);    }}