/* * Copyright (C) 2014 The Android Open Source Project * Copyright (c) 1999, 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 java.lang.reflect; import dalvik.annotation.optimization.FastNative; import java.lang.ref.Reference; import java.lang.ref.WeakReference; import java.security.Permission; import java.security.PrivilegedAction; import java.util.ArrayList; import java.util.Arrays; import java.util.Arrays; import java.util.Collections; import java.util.Comparator; import java.util.HashMap; import java.util.HashSet; import java.util.IdentityHashMap; import java.util.List; import java.util.Map; import java.util.Objects; import java.util.Set; import java.util.WeakHashMap; import java.util.concurrent.atomic.AtomicLong; import java.util.function.BiFunction; import libcore.util.EmptyArray; import sun.reflect.CallerSensitive; import sun.reflect.misc.ReflectUtil; import sun.security.util.SecurityConstants; /** * {@code Proxy} provides static methods for creating dynamic proxy * classes and instances, and it is also the superclass of all * dynamic proxy classes created by those methods. * *

To create a proxy for some interface {@code Foo}: * 

 *     InvocationHandler handler = new MyInvocationHandler(...);
 *     Class<?> proxyClass = Proxy.getProxyClass(Foo.class.getClassLoader(), Foo.class);
 *     Foo f = (Foo) proxyClass.getConstructor(InvocationHandler.class).
 *                     newInstance(handler);
 *
* or more simply: * 
 *     Foo f = (Foo) Proxy.newProxyInstance(Foo.class.getClassLoader(),
 *                                          new Class<?>[] { Foo.class },
 *                                          handler);
 *
* *

A dynamic proxy class (simply referred to as a proxy * class below) is a class that implements a list of interfaces * specified at runtime when the class is created, with behavior as * described below. * * A proxy interface is such an interface that is implemented * by a proxy class. * * A proxy instance is an instance of a proxy class. * * Each proxy instance has an associated invocation handler * object, which implements the interface {@link InvocationHandler}. * A method invocation on a proxy instance through one of its proxy * interfaces will be dispatched to the {@link InvocationHandler#invoke * invoke} method of the instance's invocation handler, passing the proxy * instance, a {@code java.lang.reflect.Method} object identifying * the method that was invoked, and an array of type {@code Object} * containing the arguments. The invocation handler processes the * encoded method invocation as appropriate and the result that it * returns will be returned as the result of the method invocation on * the proxy instance. * *

A proxy class has the following properties: * *

* *

A proxy instance has the following properties: * *

* *

Methods Duplicated in Multiple Proxy Interfaces

* *

When two or more interfaces of a proxy class contain a method with * the same name and parameter signature, the order of the proxy class's * interfaces becomes significant. When such a duplicate method * is invoked on a proxy instance, the {@code Method} object passed * to the invocation handler will not necessarily be the one whose * declaring class is assignable from the reference type of the interface * that the proxy's method was invoked through. This limitation exists * because the corresponding method implementation in the generated proxy * class cannot determine which interface it was invoked through. * Therefore, when a duplicate method is invoked on a proxy instance, * the {@code Method} object for the method in the foremost interface * that contains the method (either directly or inherited through a * superinterface) in the proxy class's list of interfaces is passed to * the invocation handler's {@code invoke} method, regardless of the * reference type through which the method invocation occurred. * *

If a proxy interface contains a method with the same name and * parameter signature as the {@code hashCode}, {@code equals}, * or {@code toString} methods of {@code java.lang.Object}, * when such a method is invoked on a proxy instance, the * {@code Method} object passed to the invocation handler will have * {@code java.lang.Object} as its declaring class. In other words, * the public, non-final methods of {@code java.lang.Object} * logically precede all of the proxy interfaces for the determination of * which {@code Method} object to pass to the invocation handler. * *

Note also that when a duplicate method is dispatched to an * invocation handler, the {@code invoke} method may only throw * checked exception types that are assignable to one of the exception * types in the {@code throws} clause of the method in all of * the proxy interfaces that it can be invoked through. If the * {@code invoke} method throws a checked exception that is not * assignable to any of the exception types declared by the method in one * of the proxy interfaces that it can be invoked through, then an * unchecked {@code UndeclaredThrowableException} will be thrown by * the invocation on the proxy instance. This restriction means that not * all of the exception types returned by invoking * {@code getExceptionTypes} on the {@code Method} object * passed to the {@code invoke} method can necessarily be thrown * successfully by the {@code invoke} method. * * @author Peter Jones * @see InvocationHandler * @since 1.3 */ public class Proxy implements java.io.Serializable { private static final long serialVersionUID = -2222568056686623797L; /** prefix for all proxy class names */ private final static String proxyClassNamePrefix = "$Proxy"; /** parameter types of a proxy class constructor */ private static final Class[] constructorParams = { InvocationHandler.class }; /** * a cache of proxy classes */ private static final WeakCache[], Class> proxyClassCache = new WeakCache<>(new KeyFactory(), new ProxyClassFactory()); /** * the invocation handler for this proxy instance. * @serial */ protected InvocationHandler h; /** * Orders methods by their name, parameters, return type and inheritance relationship. * * @hide */ private static final Comparator ORDER_BY_SIGNATURE_AND_SUBTYPE = new Comparator() { @Override public int compare(Method a, Method b) { int comparison = Method.ORDER_BY_SIGNATURE.compare(a, b); if (comparison != 0) { return comparison; } Class aClass = a.getDeclaringClass(); Class bClass = b.getDeclaringClass(); if (aClass == bClass) { return 0; } else if (aClass.isAssignableFrom(bClass)) { return 1; } else if (bClass.isAssignableFrom(aClass)) { return -1; } else { return 0; } } }; /** * Prohibits instantiation. */ private Proxy() { } /** * Constructs a new {@code Proxy} instance from a subclass * (typically, a dynamic proxy class) with the specified value * for its invocation handler. * * @param h the invocation handler for this proxy instance * * @throws NullPointerException if the given invocation handler, {@code h}, * is {@code null}. */ protected Proxy(InvocationHandler h) { Objects.requireNonNull(h); this.h = h; } /** * Returns the {@code java.lang.Class} object for a proxy class * given a class loader and an array of interfaces. The proxy class * will be defined by the specified class loader and will implement * all of the supplied interfaces. If any of the given interfaces * is non-public, the proxy class will be non-public. If a proxy class * for the same permutation of interfaces has already been defined by the * class loader, then the existing proxy class will be returned; otherwise, * a proxy class for those interfaces will be generated dynamically * and defined by the class loader. * *

There are several restrictions on the parameters that may be * passed to {@code Proxy.getProxyClass}: * *

* *

If any of these restrictions are violated, * {@code Proxy.getProxyClass} will throw an * {@code IllegalArgumentException}. If the {@code interfaces} * array argument or any of its elements are {@code null}, a * {@code NullPointerException} will be thrown. * *

Note that the order of the specified proxy interfaces is * significant: two requests for a proxy class with the same combination * of interfaces but in a different order will result in two distinct * proxy classes. * * @param loader the class loader to define the proxy class * @param interfaces the list of interfaces for the proxy class * to implement * @return a proxy class that is defined in the specified class loader * and that implements the specified interfaces * @throws IllegalArgumentException if any of the restrictions on the * parameters that may be passed to {@code getProxyClass} * are violated * @throws SecurityException if a security manager, s, is present * and any of the following conditions is met: *

* @throws NullPointerException if the {@code interfaces} array * argument or any of its elements are {@code null} */ @CallerSensitive public static Class getProxyClass(ClassLoader loader, Class... interfaces) throws IllegalArgumentException { return getProxyClass0(loader, interfaces); } /** * Generate a proxy class. Must call the checkProxyAccess method * to perform permission checks before calling this. */ private static Class getProxyClass0(ClassLoader loader, Class... interfaces) { if (interfaces.length > 65535) { throw new IllegalArgumentException("interface limit exceeded"); } // If the proxy class defined by the given loader implementing // the given interfaces exists, this will simply return the cached copy; // otherwise, it will create the proxy class via the ProxyClassFactory return proxyClassCache.get(loader, interfaces); } /* * a key used for proxy class with 0 implemented interfaces */ private static final Object key0 = new Object(); /* * Key1 and Key2 are optimized for the common use of dynamic proxies * that implement 1 or 2 interfaces. */ /* * a key used for proxy class with 1 implemented interface */ private static final class Key1 extends WeakReference> { private final int hash; Key1(Class intf) { super(intf); this.hash = intf.hashCode(); } @Override public int hashCode() { return hash; } @Override public boolean equals(Object obj) { Class intf; return this == obj || obj != null && obj.getClass() == Key1.class && (intf = get()) != null && intf == ((Key1) obj).get(); } } /* * a key used for proxy class with 2 implemented interfaces */ private static final class Key2 extends WeakReference> { private final int hash; private final WeakReference> ref2; Key2(Class intf1, Class intf2) { super(intf1); hash = 31 * intf1.hashCode() + intf2.hashCode(); ref2 = new WeakReference>(intf2); } @Override public int hashCode() { return hash; } @Override public boolean equals(Object obj) { Class intf1, intf2; return this == obj || obj != null && obj.getClass() == Key2.class && (intf1 = get()) != null && intf1 == ((Key2) obj).get() && (intf2 = ref2.get()) != null && intf2 == ((Key2) obj).ref2.get(); } } /* * a key used for proxy class with any number of implemented interfaces * (used here for 3 or more only) */ private static final class KeyX { private final int hash; private final WeakReference>[] refs; @SuppressWarnings("unchecked") KeyX(Class[] interfaces) { hash = Arrays.hashCode(interfaces); refs = (WeakReference>[])new WeakReference[interfaces.length]; for (int i = 0; i < interfaces.length; i++) { refs[i] = new WeakReference<>(interfaces[i]); } } @Override public int hashCode() { return hash; } @Override public boolean equals(Object obj) { return this == obj || obj != null && obj.getClass() == KeyX.class && equals(refs, ((KeyX) obj).refs); } private static boolean equals(WeakReference>[] refs1, WeakReference>[] refs2) { if (refs1.length != refs2.length) { return false; } for (int i = 0; i < refs1.length; i++) { Class intf = refs1[i].get(); if (intf == null || intf != refs2[i].get()) { return false; } } return true; } } /** * A function that maps an array of interfaces to an optimal key where * Class objects representing interfaces are weakly referenced. */ private static final class KeyFactory implements BiFunction[], Object> { @Override public Object apply(ClassLoader classLoader, Class[] interfaces) { switch (interfaces.length) { case 1: return new Key1(interfaces[0]); // the most frequent case 2: return new Key2(interfaces[0], interfaces[1]); case 0: return key0; default: return new KeyX(interfaces); } } } /** * A factory function that generates, defines and returns the proxy class given * the ClassLoader and array of interfaces. */ private static final class ProxyClassFactory implements BiFunction[], Class> { // prefix for all proxy class names private static final String proxyClassNamePrefix = "$Proxy"; // next number to use for generation of unique proxy class names private static final AtomicLong nextUniqueNumber = new AtomicLong(); @Override public Class apply(ClassLoader loader, Class[] interfaces) { Map, Boolean> interfaceSet = new IdentityHashMap<>(interfaces.length); for (Class intf : interfaces) { /* * Verify that the class loader resolves the name of this * interface to the same Class object. */ Class interfaceClass = null; try { interfaceClass = Class.forName(intf.getName(), false, loader); } catch (ClassNotFoundException e) { } if (interfaceClass != intf) { throw new IllegalArgumentException( intf + " is not visible from class loader"); } /* * Verify that the Class object actually represents an * interface. */ if (!interfaceClass.isInterface()) { throw new IllegalArgumentException( interfaceClass.getName() + " is not an interface"); } /* * Verify that this interface is not a duplicate. */ if (interfaceSet.put(interfaceClass, Boolean.TRUE) != null) { throw new IllegalArgumentException( "repeated interface: " + interfaceClass.getName()); } } String proxyPkg = null; // package to define proxy class in int accessFlags = Modifier.PUBLIC | Modifier.FINAL; /* * Record the package of a non-public proxy interface so that the * proxy class will be defined in the same package. Verify that * all non-public proxy interfaces are in the same package. */ for (Class intf : interfaces) { int flags = intf.getModifiers(); if (!Modifier.isPublic(flags)) { accessFlags = Modifier.FINAL; String name = intf.getName(); int n = name.lastIndexOf('.'); String pkg = ((n == -1) ? "" : name.substring(0, n + 1)); if (proxyPkg == null) { proxyPkg = pkg; } else if (!pkg.equals(proxyPkg)) { throw new IllegalArgumentException( "non-public interfaces from different packages"); } } } if (proxyPkg == null) { // if no non-public proxy interfaces, use the default package. proxyPkg = ""; } { // Android-changed: Generate the proxy directly instead of calling // through to ProxyGenerator. List methods = getMethods(interfaces); Collections.sort(methods, ORDER_BY_SIGNATURE_AND_SUBTYPE); validateReturnTypes(methods); List[]> exceptions = deduplicateAndGetExceptions(methods); Method[] methodsArray = methods.toArray(new Method[methods.size()]); Class[][] exceptionsArray = exceptions.toArray(new Class[exceptions.size()][]); /* * Choose a name for the proxy class to generate. */ long num = nextUniqueNumber.getAndIncrement(); String proxyName = proxyPkg + proxyClassNamePrefix + num; return generateProxy(proxyName, interfaces, loader, methodsArray, exceptionsArray); } } } /** * Remove methods that have the same name, parameters and return type. This * computes the exceptions of each method; this is the intersection of the * exceptions of equivalent methods. * * @param methods the methods to find exceptions for, ordered by name and * signature. */ private static List[]> deduplicateAndGetExceptions(List methods) { List[]> exceptions = new ArrayList[]>(methods.size()); for (int i = 0; i < methods.size(); ) { Method method = methods.get(i); Class[] exceptionTypes = method.getExceptionTypes(); if (i > 0 && Method.ORDER_BY_SIGNATURE.compare(method, methods.get(i - 1)) == 0) { exceptions.set(i - 1, intersectExceptions(exceptions.get(i - 1), exceptionTypes)); methods.remove(i); } else { exceptions.add(exceptionTypes); i++; } } return exceptions; } /** * Returns the exceptions that are declared in both {@code aExceptions} and * {@code bExceptions}. If an exception type in one array is a subtype of an * exception from the other, the subtype is included in the intersection. */ private static Class[] intersectExceptions(Class[] aExceptions, Class[] bExceptions) { if (aExceptions.length == 0 || bExceptions.length == 0) { return EmptyArray.CLASS; } if (Arrays.equals(aExceptions, bExceptions)) { return aExceptions; } Set> intersection = new HashSet>(); for (Class a : aExceptions) { for (Class b : bExceptions) { if (a.isAssignableFrom(b)) { intersection.add(b); } else if (b.isAssignableFrom(a)) { intersection.add(a); } } } return intersection.toArray(new Class[intersection.size()]); } /** * Throws if any two methods in {@code methods} have the same name and * parameters but incompatible return types. * * @param methods the methods to find exceptions for, ordered by name and * signature. */ private static void validateReturnTypes(List methods) { Method vs = null; for (Method method : methods) { if (vs == null || !vs.equalNameAndParameters(method)) { vs = method; // this has a different name or parameters continue; } Class returnType = method.getReturnType(); Class vsReturnType = vs.getReturnType(); if (returnType.isInterface() && vsReturnType.isInterface()) { // all interfaces are mutually compatible } else if (vsReturnType.isAssignableFrom(returnType)) { vs = method; // the new return type is a subtype; use it instead } else if (!returnType.isAssignableFrom(vsReturnType)) { throw new IllegalArgumentException("proxied interface methods have incompatible " + "return types:\n " + vs + "\n " + method); } } } private static List getMethods(Class[] interfaces) { List result = new ArrayList(); try { result.add(Object.class.getMethod("equals", Object.class)); result.add(Object.class.getMethod("hashCode", EmptyArray.CLASS)); result.add(Object.class.getMethod("toString", EmptyArray.CLASS)); } catch (NoSuchMethodException e) { throw new AssertionError(); } getMethodsRecursive(interfaces, result); return result; } /** * Fills {@code proxiedMethods} with the methods of {@code interfaces} and * the interfaces they extend. May contain duplicates. */ private static void getMethodsRecursive(Class[] interfaces, List methods) { for (Class i : interfaces) { getMethodsRecursive(i.getInterfaces(), methods); Collections.addAll(methods, i.getDeclaredMethods()); } } /** * Returns an instance of a proxy class for the specified interfaces * that dispatches method invocations to the specified invocation * handler. * *

{@code Proxy.newProxyInstance} throws * {@code IllegalArgumentException} for the same reasons that * {@code Proxy.getProxyClass} does. * * @param loader the class loader to define the proxy class * @param interfaces the list of interfaces for the proxy class * to implement * @param h the invocation handler to dispatch method invocations to * @return a proxy instance with the specified invocation handler of a * proxy class that is defined by the specified class loader * and that implements the specified interfaces * @throws IllegalArgumentException if any of the restrictions on the * parameters that may be passed to {@code getProxyClass} * are violated * @throws SecurityException if a security manager, s, is present * and any of the following conditions is met: *

    *
  • the given {@code loader} is {@code null} and * the caller's class loader is not {@code null} and the * invocation of {@link SecurityManager#checkPermission * s.checkPermission} with * {@code RuntimePermission("getClassLoader")} permission * denies access;
    • *
  • for each proxy interface, {@code intf}, * the caller's class loader is not the same as or an * ancestor of the class loader for {@code intf} and * invocation of {@link SecurityManager#checkPackageAccess * s.checkPackageAccess()} denies access to {@code intf};
    • *
  • any of the given proxy interfaces is non-public and the * caller class is not in the same {@linkplain Package runtime package} * as the non-public interface and the invocation of * {@link SecurityManager#checkPermission s.checkPermission} with * {@code ReflectPermission("newProxyInPackage.{package name}")} * permission denies access.
    • *
* @throws NullPointerException if the {@code interfaces} array * argument or any of its elements are {@code null}, or * if the invocation handler, {@code h}, is * {@code null} */ @CallerSensitive public static Object newProxyInstance(ClassLoader loader, Class[] interfaces, InvocationHandler h) throws IllegalArgumentException { Objects.requireNonNull(h); final Class[] intfs = interfaces.clone(); // Android-changed: sm is always null // final SecurityManager sm = System.getSecurityManager(); // if (sm != null) { // checkProxyAccess(Reflection.getCallerClass(), loader, intfs); // } /* * Look up or generate the designated proxy class. */ Class cl = getProxyClass0(loader, intfs); /* * Invoke its constructor with the designated invocation handler. */ try { // Android-changed: sm is always null // if (sm != null) { // checkNewProxyPermission(Reflection.getCallerClass(), cl); // } final Constructor cons = cl.getConstructor(constructorParams); final InvocationHandler ih = h; if (!Modifier.isPublic(cl.getModifiers())) { // Android-changed: Removed AccessController.doPrivileged cons.setAccessible(true); } return cons.newInstance(new Object[]{h}); } catch (IllegalAccessException|InstantiationException e) { throw new InternalError(e.toString(), e); } catch (InvocationTargetException e) { Throwable t = e.getCause(); if (t instanceof RuntimeException) { throw (RuntimeException) t; } else { throw new InternalError(t.toString(), t); } } catch (NoSuchMethodException e) { throw new InternalError(e.toString(), e); } } /** * Returns true if and only if the specified class was dynamically * generated to be a proxy class using the {@code getProxyClass} * method or the {@code newProxyInstance} method. * *

The reliability of this method is important for the ability * to use it to make security decisions, so its implementation should * not just test if the class in question extends {@code Proxy}. * * @param cl the class to test * @return {@code true} if the class is a proxy class and * {@code false} otherwise * @throws NullPointerException if {@code cl} is {@code null} */ public static boolean isProxyClass(Class cl) { return Proxy.class.isAssignableFrom(cl) && proxyClassCache.containsValue(cl); } /** * Returns the invocation handler for the specified proxy instance. * * @param proxy the proxy instance to return the invocation handler for * @return the invocation handler for the proxy instance * @throws IllegalArgumentException if the argument is not a * proxy instance * @throws SecurityException if a security manager, s, is present * and the caller's class loader is not the same as or an * ancestor of the class loader for the invocation handler * and invocation of {@link SecurityManager#checkPackageAccess * s.checkPackageAccess()} denies access to the invocation * handler's class. */ @CallerSensitive public static InvocationHandler getInvocationHandler(Object proxy) throws IllegalArgumentException { /* * Verify that the object is actually a proxy instance. */ if (!isProxyClass(proxy.getClass())) { throw new IllegalArgumentException("not a proxy instance"); } final Proxy p = (Proxy) proxy; final InvocationHandler ih = p.h; // Android-changed, System.getSecurityManager() is always null // if (System.getSecurityManager() != null) { // Class ihClass = ih.getClass(); // Class caller = Reflection.getCallerClass(); // if (ReflectUtil.needsPackageAccessCheck(caller.getClassLoader(), // ihClass.getClassLoader())) // { // ReflectUtil.checkPackageAccess(ihClass); // } // } return ih; } // Android-changed: helper for art native code. private static Object invoke(Proxy proxy, Method method, Object[] args) throws Throwable { InvocationHandler h = proxy.h; return h.invoke(proxy, method, args); } @FastNative private static native Class generateProxy(String name, Class[] interfaces, ClassLoader loader, Method[] methods, Class[][] exceptions); // Temporary methods. private static void reserved1() {}; private static void reserved2() {}; }