jaxws/src/java.xml.ws/share/classes/com/sun/xml/internal/ws/util/MethodUtil.java - platform/libcore - Git at Google

 /*
  * Copyright (c) 2017, 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 com.sun.xml.internal.ws.util;

 import java.io.IOException;
 import java.io.InputStream;
 import java.lang.reflect.InvocationTargetException;
 import java.lang.reflect.Method;
 import java.lang.reflect.Proxy;
 import java.security.AccessController;
 import java.security.AllPermission;
 import java.security.CodeSource;
 import java.security.PermissionCollection;
 import java.security.PrivilegedExceptionAction;
 import java.security.SecureClassLoader;
 import java.util.Arrays;

 /*
  * This copies from sun.reflect.misc.MethodUtil to implement the trampoline
  * code such that when a Method is invoked, it will be called through
  * the trampoline that is defined by this MethodUtil class loader.
  */
 class Trampoline {
     static {
         if (Trampoline.class.getClassLoader() == null) {
             throw new Error(
                     "Trampoline must not be defined by the bootstrap classloader");
         }
     }

     private static void ensureInvocableMethod(Method m)
             throws InvocationTargetException {
         Class<?> clazz = m.getDeclaringClass();
         if (clazz.equals(AccessController.class) ||
                 clazz.equals(Method.class) ||
                 clazz.getName().startsWith("java.lang.invoke."))
             throw new InvocationTargetException(
                     new UnsupportedOperationException("invocation not supported"));
     }

     private static Object invoke(Method m, Object obj, Object[] params)
             throws InvocationTargetException, IllegalAccessException {
         ensureInvocableMethod(m);
         return m.invoke(obj, params);
     }
 }

 /*
  * Create a trampoline class.
  */
 public final class MethodUtil extends SecureClassLoader {
     private static final String WS_UTIL_PKG = "com.sun.xml.internal.ws.util.";
     private static final String TRAMPOLINE = WS_UTIL_PKG + "Trampoline";
     private static final Method bounce = getTrampoline();
     private static final int DEFAULT_BUFFER_SIZE = 8192;
     private static final int MAX_BUFFER_SIZE = Integer.MAX_VALUE - 8;


     private MethodUtil() {
         super();
     }

     /*
      * Bounce through the trampoline.
      */
     public static Object invoke(Method m, Object obj, Object[] params)
             throws InvocationTargetException, IllegalAccessException {
         try {
             return bounce.invoke(null, m, obj, params);
         } catch (InvocationTargetException ie) {
             Throwable t = ie.getCause();

             if (t instanceof InvocationTargetException) {
                 throw (InvocationTargetException) t;
             } else if (t instanceof IllegalAccessException) {
                 throw (IllegalAccessException) t;
             } else if (t instanceof RuntimeException) {
                 throw (RuntimeException) t;
             } else if (t instanceof Error) {
                 throw (Error) t;
             } else {
                 throw new Error("Unexpected invocation error", t);
             }
         } catch (IllegalAccessException iae) {
             // this can't happen
             throw new Error("Unexpected invocation error", iae);
         }
     }

     private static Method getTrampoline() {
         try {
             return AccessController.doPrivileged(
                     new PrivilegedExceptionAction<Method>() {
                         public Method run() throws Exception {
                             Class<?> t = getTrampolineClass();
                             Method b = t.getDeclaredMethod("invoke",
                                     Method.class, Object.class, Object[].class);
                             b.setAccessible(true);
                             return b;
                         }
                     });
         } catch (Exception e) {
             throw new InternalError("bouncer cannot be found", e);
         }
     }


     protected synchronized Class<?> loadClass(String name, boolean resolve)
             throws ClassNotFoundException {
         // First, check if the class has already been loaded
         checkPackageAccess(name);
         Class<?> c = findLoadedClass(name);
         if (c == null) {
             try {
                 c = findClass(name);
             } catch (ClassNotFoundException e) {
                 // Fall through ...
             }
             if (c == null) {
                 c = getParent().loadClass(name);
             }
         }
         if (resolve) {
             resolveClass(c);
         }
         return c;
     }


     protected Class<?> findClass(final String name)
             throws ClassNotFoundException {
         if (!name.startsWith(WS_UTIL_PKG)) {
             throw new ClassNotFoundException(name);
         }
         String path = "/".concat(name.replace('.', '/').concat(".class"));
         try (InputStream in = MethodUtil.class.getResourceAsStream(path)) {
             byte[] b = readAllBytes(in);
             return defineClass(name, b);
         } catch (IOException e) {
             throw new ClassNotFoundException(name, e);
         }
     }

     /**
      * JDK9 {@link InputStream#readAllBytes()} substitution.
      */
     private byte[] readAllBytes(InputStream in) throws IOException {
         byte[] buf = new byte[DEFAULT_BUFFER_SIZE];
         int capacity = buf.length;
         int nread = 0;
         int n;
         for (; ; ) {
             // read to EOF which may read more or less than initial buffer size
             while ((n = in.read(buf, nread, capacity - nread)) > 0)
                 nread += n;

             // if the last call to read returned -1, then we're done
             if (n < 0)
                 break;

             // need to allocate a larger buffer
             if (capacity <= MAX_BUFFER_SIZE - capacity) {
                 capacity = capacity << 1;
             } else {
                 if (capacity == MAX_BUFFER_SIZE)
                     throw new OutOfMemoryError("Required array size too large");
                 capacity = MAX_BUFFER_SIZE;
             }
             buf = Arrays.copyOf(buf, capacity);
         }
         return (capacity == nread) ? buf : Arrays.copyOf(buf, nread);
     }


     /*
      * Define the proxy classes
      */
     private Class<?> defineClass(String name, byte[] b) throws IOException {
         CodeSource cs = new CodeSource(null, (java.security.cert.Certificate[]) null);
         if (!name.equals(TRAMPOLINE)) {
             throw new IOException("MethodUtil: bad name " + name);
         }
         return defineClass(name, b, 0, b.length, cs);
     }

     protected PermissionCollection getPermissions(CodeSource codesource) {
         PermissionCollection perms = super.getPermissions(codesource);
         perms.add(new AllPermission());
         return perms;
     }

     private static Class<?> getTrampolineClass() {
         try {
             return Class.forName(TRAMPOLINE, true, new MethodUtil());
         } catch (ClassNotFoundException e) {
         }
         return null;
     }

     /**
      * Checks package access on the given classname.
      * This method is typically called when the Class instance is not
      * available and the caller attempts to load a class on behalf
      * the true caller (application).
      */
     private static void checkPackageAccess(String name) {
         SecurityManager s = System.getSecurityManager();
         if (s != null) {
             String cname = name.replace('/', '.');
             if (cname.startsWith("[")) {
                 int b = cname.lastIndexOf('[') + 2;
                 if (b > 1 && b < cname.length()) {
                     cname = cname.substring(b);
                 }
             }
             int i = cname.lastIndexOf('.');
             if (i != -1) {
                 s.checkPackageAccess(cname.substring(0, i));
             }
         }
     }

     /**
      * Checks package access on the given class.
      * <p>
      * If it is a {@link Proxy#isProxyClass(Class)} that implements
      * a non-public interface (i.e. may be in a non-restricted package),
      * also check the package access on the proxy interfaces.
      */
     private static void checkPackageAccess(Class<?> clazz) {
         checkPackageAccess(clazz.getName());
         if (isNonPublicProxyClass(clazz)) {
             checkProxyPackageAccess(clazz);
         }
     }

     // Note that bytecode instrumentation tools may exclude 'sun.*'
     // classes but not generated proxy classes and so keep it in com.sun.*
     private static final String PROXY_PACKAGE = "com.sun.proxy";

     /**
      * Test if the given class is a proxy class that implements
      * non-public interface.  Such proxy class may be in a non-restricted
      * package that bypasses checkPackageAccess.
      */
     private static boolean isNonPublicProxyClass(Class<?> cls) {
         String name = cls.getName();
         int i = name.lastIndexOf('.');
         String pkg = (i != -1) ? name.substring(0, i) : "";
         return Proxy.isProxyClass(cls) && !pkg.startsWith(PROXY_PACKAGE);
     }

     /**
      * Check package access on the proxy interfaces that the given proxy class
      * implements.
      *
      * @param clazz Proxy class object
      */
     private static void checkProxyPackageAccess(Class<?> clazz) {
         SecurityManager s = System.getSecurityManager();
         if (s != null) {
             // check proxy interfaces if the given class is a proxy class
             if (Proxy.isProxyClass(clazz)) {
                 for (Class<?> intf : clazz.getInterfaces()) {
                     checkPackageAccess(intf);
                 }
             }
         }
     }
 }
	/*
	* Copyright (c) 2017, 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 com.sun.xml.internal.ws.util;

	import java.io.IOException;
	import java.io.InputStream;
	import java.lang.reflect.InvocationTargetException;
	import java.lang.reflect.Method;
	import java.lang.reflect.Proxy;
	import java.security.AccessController;
	import java.security.AllPermission;
	import java.security.CodeSource;
	import java.security.PermissionCollection;
	import java.security.PrivilegedExceptionAction;
	import java.security.SecureClassLoader;
	import java.util.Arrays;

	/*
	* This copies from sun.reflect.misc.MethodUtil to implement the trampoline
	* code such that when a Method is invoked, it will be called through
	* the trampoline that is defined by this MethodUtil class loader.
	*/
	class Trampoline {
	static {
	if (Trampoline.class.getClassLoader() == null) {
	throw new Error(
	"Trampoline must not be defined by the bootstrap classloader");
	}
	}

	private static void ensureInvocableMethod(Method m)
	throws InvocationTargetException {
	Class<?> clazz = m.getDeclaringClass();
	if (clazz.equals(AccessController.class) \|\|
	clazz.equals(Method.class) \|\|
	clazz.getName().startsWith("java.lang.invoke."))
	throw new InvocationTargetException(
	new UnsupportedOperationException("invocation not supported"));
	}

	private static Object invoke(Method m, Object obj, Object[] params)
	throws InvocationTargetException, IllegalAccessException {
	ensureInvocableMethod(m);
	return m.invoke(obj, params);
	}
	}

	/*
	* Create a trampoline class.
	*/
	public final class MethodUtil extends SecureClassLoader {
	private static final String WS_UTIL_PKG = "com.sun.xml.internal.ws.util.";
	private static final String TRAMPOLINE = WS_UTIL_PKG + "Trampoline";
	private static final Method bounce = getTrampoline();
	private static final int DEFAULT_BUFFER_SIZE = 8192;
	private static final int MAX_BUFFER_SIZE = Integer.MAX_VALUE - 8;


	private MethodUtil() {
	super();
	}

	/*
	* Bounce through the trampoline.
	*/
	public static Object invoke(Method m, Object obj, Object[] params)
	throws InvocationTargetException, IllegalAccessException {
	try {
	return bounce.invoke(null, m, obj, params);
	} catch (InvocationTargetException ie) {
	Throwable t = ie.getCause();

	if (t instanceof InvocationTargetException) {
	throw (InvocationTargetException) t;
	} else if (t instanceof IllegalAccessException) {
	throw (IllegalAccessException) t;
	} else if (t instanceof RuntimeException) {
	throw (RuntimeException) t;
	} else if (t instanceof Error) {
	throw (Error) t;
	} else {
	throw new Error("Unexpected invocation error", t);
	}
	} catch (IllegalAccessException iae) {
	// this can't happen
	throw new Error("Unexpected invocation error", iae);
	}
	}

	private static Method getTrampoline() {
	try {
	return AccessController.doPrivileged(
	new PrivilegedExceptionAction<Method>() {
	public Method run() throws Exception {
	Class<?> t = getTrampolineClass();
	Method b = t.getDeclaredMethod("invoke",
	Method.class, Object.class, Object[].class);
	b.setAccessible(true);
	return b;
	}
	});
	} catch (Exception e) {
	throw new InternalError("bouncer cannot be found", e);
	}
	}


	protected synchronized Class<?> loadClass(String name, boolean resolve)
	throws ClassNotFoundException {
	// First, check if the class has already been loaded
	checkPackageAccess(name);
	Class<?> c = findLoadedClass(name);
	if (c == null) {
	try {
	c = findClass(name);
	} catch (ClassNotFoundException e) {
	// Fall through ...
	}
	if (c == null) {
	c = getParent().loadClass(name);
	}
	}
	if (resolve) {
	resolveClass(c);
	}
	return c;
	}


	protected Class<?> findClass(final String name)
	throws ClassNotFoundException {
	if (!name.startsWith(WS_UTIL_PKG)) {
	throw new ClassNotFoundException(name);
	}
	String path = "/".concat(name.replace('.', '/').concat(".class"));
	try (InputStream in = MethodUtil.class.getResourceAsStream(path)) {
	byte[] b = readAllBytes(in);
	return defineClass(name, b);
	} catch (IOException e) {
	throw new ClassNotFoundException(name, e);
	}
	}

	/**
	* JDK9 {@link InputStream#readAllBytes()} substitution.
	*/
	private byte[] readAllBytes(InputStream in) throws IOException {
	byte[] buf = new byte[DEFAULT_BUFFER_SIZE];
	int capacity = buf.length;
	int nread = 0;
	int n;
	for (; ; ) {
	// read to EOF which may read more or less than initial buffer size
	while ((n = in.read(buf, nread, capacity - nread)) > 0)
	nread += n;

	// if the last call to read returned -1, then we're done
	if (n < 0)
	break;

	// need to allocate a larger buffer
	if (capacity <= MAX_BUFFER_SIZE - capacity) {
	capacity = capacity << 1;
	} else {
	if (capacity == MAX_BUFFER_SIZE)
	throw new OutOfMemoryError("Required array size too large");
	capacity = MAX_BUFFER_SIZE;
	}
	buf = Arrays.copyOf(buf, capacity);
	}
	return (capacity == nread) ? buf : Arrays.copyOf(buf, nread);
	}


	/*
	* Define the proxy classes
	*/
	private Class<?> defineClass(String name, byte[] b) throws IOException {
	CodeSource cs = new CodeSource(null, (java.security.cert.Certificate[]) null);
	if (!name.equals(TRAMPOLINE)) {
	throw new IOException("MethodUtil: bad name " + name);
	}
	return defineClass(name, b, 0, b.length, cs);
	}

	protected PermissionCollection getPermissions(CodeSource codesource) {
	PermissionCollection perms = super.getPermissions(codesource);
	perms.add(new AllPermission());
	return perms;
	}

	private static Class<?> getTrampolineClass() {
	try {
	return Class.forName(TRAMPOLINE, true, new MethodUtil());
	} catch (ClassNotFoundException e) {
	}
	return null;
	}

	/**
	* Checks package access on the given classname.
	* This method is typically called when the Class instance is not
	* available and the caller attempts to load a class on behalf
	* the true caller (application).
	*/
	private static void checkPackageAccess(String name) {
	SecurityManager s = System.getSecurityManager();
	if (s != null) {
	String cname = name.replace('/', '.');
	if (cname.startsWith("[")) {
	int b = cname.lastIndexOf('[') + 2;
	if (b > 1 && b < cname.length()) {
	cname = cname.substring(b);
	}
	}
	int i = cname.lastIndexOf('.');
	if (i != -1) {
	s.checkPackageAccess(cname.substring(0, i));
	}
	}
	}

	/**
	* Checks package access on the given class.
	* <p>
	* If it is a {@link Proxy#isProxyClass(Class)} that implements
	* a non-public interface (i.e. may be in a non-restricted package),
	* also check the package access on the proxy interfaces.
	*/
	private static void checkPackageAccess(Class<?> clazz) {
	checkPackageAccess(clazz.getName());
	if (isNonPublicProxyClass(clazz)) {
	checkProxyPackageAccess(clazz);
	}
	}

	// Note that bytecode instrumentation tools may exclude 'sun.*'
	// classes but not generated proxy classes and so keep it in com.sun.*
	private static final String PROXY_PACKAGE = "com.sun.proxy";

	/**
	* Test if the given class is a proxy class that implements
	* non-public interface. Such proxy class may be in a non-restricted
	* package that bypasses checkPackageAccess.
	*/
	private static boolean isNonPublicProxyClass(Class<?> cls) {
	String name = cls.getName();
	int i = name.lastIndexOf('.');
	String pkg = (i != -1) ? name.substring(0, i) : "";
	return Proxy.isProxyClass(cls) && !pkg.startsWith(PROXY_PACKAGE);
	}

	/**
	* Check package access on the proxy interfaces that the given proxy class
	* implements.
	*
	* @param clazz Proxy class object
	*/
	private static void checkProxyPackageAccess(Class<?> clazz) {
	SecurityManager s = System.getSecurityManager();
	if (s != null) {
	// check proxy interfaces if the given class is a proxy class
	if (Proxy.isProxyClass(clazz)) {
	for (Class<?> intf : clazz.getInterfaces()) {
	checkPackageAccess(intf);
	}
	}
	}
	}
	}