< prev index next >
src/java.base/share/classes/jdk/internal/reflect/Reflection.java
Print this page
*** 29,41 ****
import java.lang.reflect.*;
import java.util.HashMap;
import java.util.Map;
import java.util.Objects;
import jdk.internal.HotSpotIntrinsicCandidate;
- import jdk.internal.misc.SharedSecrets;
import jdk.internal.misc.VM;
- import sun.security.action.GetPropertyAction;
/** Common utility routines used by both java.lang and
java.lang.reflect */
public class Reflection {
--- 29,39 ----
*** 102,144 ****
Class<?> memberClass,
Class<?> targetClass,
int modifiers)
throws IllegalAccessException
{
- if (currentClass == null || memberClass == null) {
- throw new InternalError();
- }
-
if (!verifyMemberAccess(currentClass, memberClass, targetClass, modifiers)) {
! throwIllegalAccessException(currentClass, memberClass, targetClass, modifiers);
}
}
/**
! * Verify access to a member, returning {@code false} if no access
*/
public static boolean verifyMemberAccess(Class<?> currentClass,
Class<?> memberClass,
Class<?> targetClass,
int modifiers)
{
- // Verify that currentClass can access a field, method, or
- // constructor of memberClass, where that member's access bits are
- // "modifiers".
-
- boolean gotIsSameClassPackage = false;
- boolean isSameClassPackage = false;
-
if (currentClass == memberClass) {
// Always succeeds
return true;
}
! if (!verifyModuleAccess(currentClass, memberClass)) {
return false;
}
if (!Modifier.isPublic(getClassAccessFlags(memberClass))) {
isSameClassPackage = isSameClassPackage(currentClass, memberClass);
gotIsSameClassPackage = true;
if (!isSameClassPackage) {
return false;
--- 100,143 ----
Class<?> memberClass,
Class<?> targetClass,
int modifiers)
throws IllegalAccessException
{
if (!verifyMemberAccess(currentClass, memberClass, targetClass, modifiers)) {
! throw newIllegalAccessException(currentClass, memberClass, targetClass, modifiers);
}
}
/**
! * Verify access to a member and return {@code true} if it is granted.
! *
! * @param currentClass the class performing the access
! * @param memberClass the declaring class of the member being accessed
! * @param targetClass the class of target object if accessing instance
! * field or method;
! * or the declaring class if accessing constructor;
! * or null if accessing static field or method
! * @param modifiers the member's access modifiers
! * @return {@code true} if access to member is granted
*/
public static boolean verifyMemberAccess(Class<?> currentClass,
Class<?> memberClass,
Class<?> targetClass,
int modifiers)
{
if (currentClass == memberClass) {
// Always succeeds
return true;
}
! if (!verifyModuleAccess(currentClass.getModule(), memberClass)) {
return false;
}
+ boolean gotIsSameClassPackage = false;
+ boolean isSameClassPackage = false;
+
if (!Modifier.isPublic(getClassAccessFlags(memberClass))) {
isSameClassPackage = isSameClassPackage(currentClass, memberClass);
gotIsSameClassPackage = true;
if (!isSameClassPackage) {
return false;
*** 194,228 ****
return true;
}
/**
! * Returns {@code true} if memberClass's's module exports memberClass's
! * package to currentClass's module.
*/
- public static boolean verifyModuleAccess(Class<?> currentClass,
- Class<?> memberClass) {
- return verifyModuleAccess(currentClass.getModule(), memberClass);
- }
-
public static boolean verifyModuleAccess(Module currentModule, Class<?> memberClass) {
Module memberModule = memberClass.getModule();
!
! // module may be null during startup (initLevel 0)
! if (currentModule == memberModule)
! return true; // same module (named or unnamed)
!
String pkg = memberClass.getPackageName();
! boolean allowed = memberModule.isExported(pkg, currentModule);
! if (allowed && memberModule.isNamed() && printStackTraceWhenAccessSucceeds()) {
! if (!SharedSecrets.getJavaLangReflectModuleAccess()
! .isStaticallyExported(memberModule, pkg, currentModule)) {
! String msg = currentModule + " allowed access to member of " + memberClass;
! new Exception(msg).printStackTrace(System.err);
! }
}
- return allowed;
}
/**
* Returns true if two classes in the same package.
*/
--- 193,216 ----
return true;
}
/**
! * Returns {@code true} if memberClass's module exports memberClass's
! * package to currentModule.
*/
public static boolean verifyModuleAccess(Module currentModule, Class<?> memberClass) {
Module memberModule = memberClass.getModule();
! if (currentModule == memberModule) {
! // same module (named or unnamed) or both null if called
! // before module system is initialized, which means we are
! // dealing with java.base only.
! return true;
! } else {
String pkg = memberClass.getPackageName();
! return memberModule.isExported(pkg, currentModule);
}
}
/**
* Returns true if two classes in the same package.
*/
*** 342,390 ****
cl = cl.getParent();
}
return false;
}
-
- // true to print a stack trace when access fails
- private static volatile boolean printStackWhenAccessFails;
-
- // true to print a stack trace when access succeeds
- private static volatile boolean printStackWhenAccessSucceeds;
-
- // true if printStack* values are initialized
- private static volatile boolean printStackPropertiesSet;
-
- private static void ensurePrintStackPropertiesSet() {
- if (!printStackPropertiesSet && VM.initLevel() >= 1) {
- String s = GetPropertyAction.privilegedGetProperty(
- "sun.reflect.debugModuleAccessChecks");
- if (s != null) {
- printStackWhenAccessFails = !s.equalsIgnoreCase("false");
- printStackWhenAccessSucceeds = s.equalsIgnoreCase("access");
- }
- printStackPropertiesSet = true;
- }
- }
-
- public static boolean printStackTraceWhenAccessFails() {
- ensurePrintStackPropertiesSet();
- return printStackWhenAccessFails;
- }
-
- public static boolean printStackTraceWhenAccessSucceeds() {
- ensurePrintStackPropertiesSet();
- return printStackWhenAccessSucceeds;
- }
-
/**
! * Throws IllegalAccessException with the an exception message based on
* the access that is denied.
*/
! private static void throwIllegalAccessException(Class<?> currentClass,
Class<?> memberClass,
! Object target,
int modifiers)
throws IllegalAccessException
{
String currentSuffix = "";
String memberSuffix = "";
--- 330,346 ----
cl = cl.getParent();
}
return false;
}
/**
! * Returns an IllegalAccessException with an exception message based on
* the access that is denied.
*/
! public static IllegalAccessException newIllegalAccessException(Class<?> currentClass,
Class<?> memberClass,
! Class<?> targetClass,
int modifiers)
throws IllegalAccessException
{
String currentSuffix = "";
String memberSuffix = "";
*** 409,430 ****
msg += memberClass + memberSuffix+ " because "
+ m2 + " does not export " + memberPackageName;
if (m2.isNamed()) msg += " to " + m1;
}
! throwIllegalAccessException(msg);
! }
!
! /**
! * Throws IllegalAccessException with the given exception message.
! */
! public static void throwIllegalAccessException(String msg)
! throws IllegalAccessException
! {
! IllegalAccessException e = new IllegalAccessException(msg);
! ensurePrintStackPropertiesSet();
! if (printStackWhenAccessFails) {
! e.printStackTrace(System.err);
! }
! throw e;
}
}
--- 365,372 ----
msg += memberClass + memberSuffix+ " because "
+ m2 + " does not export " + memberPackageName;
if (m2.isNamed()) msg += " to " + m1;
}
! return new IllegalAccessException(msg);
}
}
< prev index next >