jdk-sandbox: comparison jdk/src/share/classes/java/lang/Class.java

equal deleted inserted replaced

-:0419f45c7761
+:44dfee24cb71
 import java.util.Set;
 import java.util.Map;
 import java.util.HashMap;
 import java.util.Objects;
 import sun.misc.Unsafe;
+import sun.reflect.CallerSensitive;
 import sun.reflect.ConstantPool;
 import sun.reflect.Reflection;
 import sun.reflect.ReflectionFactory;
 import sun.reflect.generics.factory.CoreReflectionFactory;
 import sun.reflect.generics.factory.GenericsFactory;
 * @exception LinkageError if the linkage fails
 * @exception ExceptionInInitializerError if the initialization provoked
 *            by this method fails
 * @exception ClassNotFoundException if the class cannot be located
 */
+@CallerSensitive
 public static Class<?> forName(String className)
 throws ClassNotFoundException {
-return forName0(className, true, ClassLoader.getCallerClassLoader());
+return forName0(className, true,
+ClassLoader.getClassLoader(Reflection.getCallerClass()));
 }
 /**
 * Returns the {@code Class} object associated with the class or
 *
 * @see       java.lang.Class#forName(String)
 * @see       java.lang.ClassLoader
 * @since     1.2
 */
+@CallerSensitive
 public static Class<?> forName(String name, boolean initialize,
 ClassLoader loader)
 throws ClassNotFoundException
 {
 if (sun.misc.VM.isSystemDomainLoader(loader)) {
 SecurityManager sm = System.getSecurityManager();
 if (sm != null) {
-ClassLoader ccl = ClassLoader.getCallerClassLoader();
+ClassLoader ccl = ClassLoader.getClassLoader(Reflection.getCallerClass());
 if (!sun.misc.VM.isSystemDomainLoader(ccl)) {
 sm.checkPermission(
 SecurityConstants.GET_CLASSLOADER_PERMISSION);
 }
 }
 *             of this class
 *
 *             </ul>
 *
 */
+@CallerSensitive
 public T newInstance()
 throws InstantiationException, IllegalAccessException
 {
 if (System.getSecurityManager() != null) {
-checkMemberAccess(Member.PUBLIC, ClassLoader.getCallerClassLoader(), false);
+checkMemberAccess(Member.PUBLIC, Reflection.getCallerClass(), false);
 }
-return newInstance0();
-}
-private T newInstance0()
-throws InstantiationException, IllegalAccessException
-{
 // NOTE: the following code may not be strictly correct under
 // the current Java memory model.
 // Constructor lookup
 if (cachedConstructor == null) {
 }
 Constructor<T> tmpConstructor = cachedConstructor;
 // Security check (same as in java.lang.reflect.Constructor)
 int modifiers = tmpConstructor.getModifiers();
 if (!Reflection.quickCheckMemberAccess(this, modifiers)) {
-Class<?> caller = Reflection.getCallerClass(3);
+Class<?> caller = Reflection.getCallerClass();
 if (newInstanceCallerCache != caller) {
 Reflection.ensureMemberAccess(caller, this, null, modifiers);
 newInstanceCallerCache = caller;
 }
 }
 *    access to the class loader for the class.
 * @see java.lang.ClassLoader
 * @see SecurityManager#checkPermission
 * @see java.lang.RuntimePermission
 */
+@CallerSensitive
 public ClassLoader getClassLoader() {
 ClassLoader cl = getClassLoader0();
 if (cl == null)
 return null;
 SecurityManager sm = System.getSecurityManager();
 if (sm != null) {
-ClassLoader ccl = ClassLoader.getCallerClassLoader();
+ClassLoader.checkClassLoaderPermission(cl, Reflection.getCallerClass());
-if (ClassLoader.needsClassLoaderPermissionCheck(ccl, cl)) {
-sm.checkPermission(SecurityConstants.GET_CLASSLOADER_PERMISSION);
-}
 }
 return cl;
 }
 // Package-private to allow ClassLoader access
 *
 *             </ul>
 *
 * @since JDK1.1
 */
+@CallerSensitive
 public Class<?>[] getClasses() {
-// be very careful not to change the stack depth of this
+checkMemberAccess(Member.PUBLIC, Reflection.getCallerClass(), false);
-// checkMemberAccess call for security reasons
-// see java.lang.SecurityManager.checkMemberAccess
-checkMemberAccess(Member.PUBLIC, ClassLoader.getCallerClassLoader(), false);
 // Privileged so this implementation can look at DECLARED classes,
 // something the caller might not have privilege to do.  The code here
 // is allowed to look at DECLARED classes because (1) it does not hand
 // out anything other than public members and (2) public member access
 *
 *             </ul>
 *
 * @since JDK1.1
 */
+@CallerSensitive
 public Field[] getFields() throws SecurityException {
-// be very careful not to change the stack depth of this
+checkMemberAccess(Member.PUBLIC, Reflection.getCallerClass(), true);
-// checkMemberAccess call for security reasons
-// see java.lang.SecurityManager.checkMemberAccess
-checkMemberAccess(Member.PUBLIC, ClassLoader.getCallerClassLoader(), true);
 return copyFields(privateGetPublicFields(null));
 }
 /**
 *
 *             </ul>
 *
 * @since JDK1.1
 */
+@CallerSensitive
 public Method[] getMethods() throws SecurityException {
-// be very careful not to change the stack depth of this
+checkMemberAccess(Member.PUBLIC, Reflection.getCallerClass(), true);
-// checkMemberAccess call for security reasons
-// see java.lang.SecurityManager.checkMemberAccess
-checkMemberAccess(Member.PUBLIC, ClassLoader.getCallerClassLoader(), true);
 return copyMethods(privateGetPublicMethods());
 }
 /**
 *
 *             </ul>
 *
 * @since JDK1.1
 */
+@CallerSensitive
 public Constructor<?>[] getConstructors() throws SecurityException {
-// be very careful not to change the stack depth of this
+checkMemberAccess(Member.PUBLIC, Reflection.getCallerClass(), true);
-// checkMemberAccess call for security reasons
-// see java.lang.SecurityManager.checkMemberAccess
-checkMemberAccess(Member.PUBLIC, ClassLoader.getCallerClassLoader(), true);
 return copyConstructors(privateGetDeclaredConstructors(true));
 }
 /**
 *
 *             </ul>
 *
 * @since JDK1.1
 */
+@CallerSensitive
 public Field getField(String name)
 throws NoSuchFieldException, SecurityException {
-// be very careful not to change the stack depth of this
+checkMemberAccess(Member.PUBLIC, Reflection.getCallerClass(), true);
-// checkMemberAccess call for security reasons
-// see java.lang.SecurityManager.checkMemberAccess
-checkMemberAccess(Member.PUBLIC, ClassLoader.getCallerClassLoader(), true);
 Field field = getField0(name);
 if (field == null) {
 throw new NoSuchFieldException(name);
 }
 return field;
 *
 *             </ul>
 *
 * @since JDK1.1
 */
+@CallerSensitive
 public Method getMethod(String name, Class<?>... parameterTypes)
 throws NoSuchMethodException, SecurityException {
-// be very careful not to change the stack depth of this
+checkMemberAccess(Member.PUBLIC, Reflection.getCallerClass(), true);
-// checkMemberAccess call for security reasons
-// see java.lang.SecurityManager.checkMemberAccess
-checkMemberAccess(Member.PUBLIC, ClassLoader.getCallerClassLoader(), true);
 Method method = getMethod0(name, parameterTypes);
 if (method == null) {
 throw new NoSuchMethodException(getName() + "." + name + argumentTypesToString(parameterTypes));
 }
 return method;
 *
 *             </ul>
 *
 * @since JDK1.1
 */
+@CallerSensitive
 public Constructor<T> getConstructor(Class<?>... parameterTypes)
 throws NoSuchMethodException, SecurityException {
-// be very careful not to change the stack depth of this
+checkMemberAccess(Member.PUBLIC, Reflection.getCallerClass(), true);
-// checkMemberAccess call for security reasons
-// see java.lang.SecurityManager.checkMemberAccess
-checkMemberAccess(Member.PUBLIC, ClassLoader.getCallerClassLoader(), true);
 return getConstructor0(parameterTypes, Member.PUBLIC);
 }
 /**
 *
 *             </ul>
 *
 * @since JDK1.1
 */
+@CallerSensitive
 public Class<?>[] getDeclaredClasses() throws SecurityException {
-// be very careful not to change the stack depth of this
+checkMemberAccess(Member.DECLARED, Reflection.getCallerClass(), false);
-// checkMemberAccess call for security reasons
-// see java.lang.SecurityManager.checkMemberAccess
-checkMemberAccess(Member.DECLARED, ClassLoader.getCallerClassLoader(), false);
 return getDeclaredClasses0();
 }
 /**
 *
 *             </ul>
 *
 * @since JDK1.1
 */
+@CallerSensitive
 public Field[] getDeclaredFields() throws SecurityException {
-// be very careful not to change the stack depth of this
+checkMemberAccess(Member.DECLARED, Reflection.getCallerClass(), true);
-// checkMemberAccess call for security reasons
-// see java.lang.SecurityManager.checkMemberAccess
-checkMemberAccess(Member.DECLARED, ClassLoader.getCallerClassLoader(), true);
 return copyFields(privateGetDeclaredFields(false));
 }
 /**
 *
 *             </ul>
 *
 * @since JDK1.1
 */
+@CallerSensitive
 public Method[] getDeclaredMethods() throws SecurityException {
-// be very careful not to change the stack depth of this
+checkMemberAccess(Member.DECLARED, Reflection.getCallerClass(), true);
-// checkMemberAccess call for security reasons
-// see java.lang.SecurityManager.checkMemberAccess
-checkMemberAccess(Member.DECLARED, ClassLoader.getCallerClassLoader(), true);
 return copyMethods(privateGetDeclaredMethods(false));
 }
 /**
 *
 *             </ul>
 *
 * @since JDK1.1
 */
+@CallerSensitive
 public Constructor<?>[] getDeclaredConstructors() throws SecurityException {
-// be very careful not to change the stack depth of this
+checkMemberAccess(Member.DECLARED, Reflection.getCallerClass(), true);
-// checkMemberAccess call for security reasons
-// see java.lang.SecurityManager.checkMemberAccess
-checkMemberAccess(Member.DECLARED, ClassLoader.getCallerClassLoader(), true);
 return copyConstructors(privateGetDeclaredConstructors(false));
 }
 /**
 *
 *             </ul>
 *
 * @since JDK1.1
 */
+@CallerSensitive
 public Field getDeclaredField(String name)
 throws NoSuchFieldException, SecurityException {
-// be very careful not to change the stack depth of this
+checkMemberAccess(Member.DECLARED, Reflection.getCallerClass(), true);
-// checkMemberAccess call for security reasons
-// see java.lang.SecurityManager.checkMemberAccess
-checkMemberAccess(Member.DECLARED, ClassLoader.getCallerClassLoader(), true);
 Field field = searchFields(privateGetDeclaredFields(false), name);
 if (field == null) {
 throw new NoSuchFieldException(name);
 }
 return field;
 *
 *             </ul>
 *
 * @since JDK1.1
 */
+@CallerSensitive
 public Method getDeclaredMethod(String name, Class<?>... parameterTypes)
 throws NoSuchMethodException, SecurityException {
-// be very careful not to change the stack depth of this
+checkMemberAccess(Member.DECLARED, Reflection.getCallerClass(), true);
-// checkMemberAccess call for security reasons
-// see java.lang.SecurityManager.checkMemberAccess
-checkMemberAccess(Member.DECLARED, ClassLoader.getCallerClassLoader(), true);
 Method method = searchMethods(privateGetDeclaredMethods(false), name, parameterTypes);
 if (method == null) {
 throw new NoSuchMethodException(getName() + "." + name + argumentTypesToString(parameterTypes));
 }
 return method;
 *
 *             </ul>
 *
 * @since JDK1.1
 */
+@CallerSensitive
 public Constructor<T> getDeclaredConstructor(Class<?>... parameterTypes)
 throws NoSuchMethodException, SecurityException {
-// be very careful not to change the stack depth of this
+checkMemberAccess(Member.DECLARED, Reflection.getCallerClass(), true);
-// checkMemberAccess call for security reasons
-// see java.lang.SecurityManager.checkMemberAccess
-checkMemberAccess(Member.DECLARED, ClassLoader.getCallerClassLoader(), true);
 return getConstructor0(parameterTypes, Member.DECLARED);
 }
 /**
 * Finds a resource with a given name.  The rules for searching resources
 * Return the Virtual Machine's Class object for the named
 * primitive type.
 */
 static native Class<?> getPrimitiveClass(String name);
+private static boolean isCheckMemberAccessOverridden(SecurityManager smgr) {
+if (smgr.getClass() == SecurityManager.class) return false;
+Class<?>[] paramTypes = new Class<?>[] {Class.class, int.class};
+return smgr.getClass().getMethod0("checkMemberAccess", paramTypes).
+getDeclaringClass() != SecurityManager.class;
+}
 /*
 * Check if client is allowed to access members.  If access is denied,
 * throw a SecurityException.
 *
-* Be very careful not to change the stack depth of this checkMemberAccess
-* call for security reasons.
-* See java.lang.SecurityManager.checkMemberAccess.
-*
 * <p> Default policy: allow all clients access with normal Java access
 * control.
 */
-private void checkMemberAccess(int which, ClassLoader ccl, boolean checkProxyInterfaces) {
+private void checkMemberAccess(int which, Class<?> caller, boolean checkProxyInterfaces) {
-SecurityManager s = System.getSecurityManager();
+final SecurityManager s = System.getSecurityManager();
 if (s != null) {
-s.checkMemberAccess(this, which);
+final ClassLoader ccl = ClassLoader.getClassLoader(caller);
-ClassLoader cl = getClassLoader0();
+final ClassLoader cl = getClassLoader0();
+if (!isCheckMemberAccessOverridden(s)) {
+// Inlined SecurityManager.checkMemberAccess
+if (which != Member.PUBLIC) {
+if (ccl != cl) {
+s.checkPermission(SecurityConstants.CHECK_MEMBER_ACCESS_PERMISSION);
+}
+}
+} else {
+// Don't refactor; otherwise break the stack depth for
+// checkMemberAccess of subclasses of SecurityManager as specified.
+s.checkMemberAccess(this, which);
+}
 if (ReflectUtil.needsPackageAccessCheck(ccl, cl)) {
 String name = this.getName();
 int i = name.lastIndexOf('.');
 if (i != -1) {
 // skip the package access check on a proxy class in default proxy package

changeset 16906	44dfee24cb71
parent 16743	b0b34102bb4c
child 17710	ce8517f5a2fe
child 18234	996e8c4c858d