44     /**

    44     private static final int PACKAGE_ONLY = 0;

    45      * Evaluate the JVM linkage rules for access to the given method on behalf of caller.

    45     private static final int ALL_ACCESS_MODES = (PUBLIC|PRIVATE|PROTECTED|PACKAGE_ONLY);

    46      * Return non-null if and only if the given accessing class has at least partial

    46 

    47      * privileges to invoke the given method.  The return value {@code Object.class}

    47     /**

    48      * denotes unlimited privileges.

    48      * Evaluate the JVM linkage rules for access to the given method

    49      * on behalf of a caller class which proposes to perform the access.

    50      * Return true if the caller class has privileges to invoke a method

    51      * or access a field with the given properties.

    52      * This requires an accessibility check of the referencing class,

    53      * plus an accessibility check of the member within the class,

    54      * which depends on the member's modifier flags.

    50      * Some circumstances require an additional check on the

    56      * The relevant properties include the defining class ({@code defc})

    51      * leading parameter (the receiver) of the method, if it is non-static.

    57      * of the member, and its modifier flags ({@code mods}).

    52      * In the case of {@code invokespecial} ({@code isSpecialInvoke} is true),

    58      * Also relevant is the class used to make the initial symbolic reference

    53      * the leading parameter must be the accessing class or a subclass.

    59      * to the member ({@code refc}).  If this latter class is not distinguished,

    54      * In the case of a call to a {@code protected} method outside the same

    60      * the defining class should be passed for both arguments ({@code defc == refc}).

    55      * package, the same constraint applies.

    61      * <h3>JVM Specification, 5.4.4 "Access Control"</h3>

    56      * @param m the proposed callee

    62      * A field or method R is accessible to a class or interface D if

    57      * @param isSpecialInvoke if true, a non-static method m is checked as if for {@code invokespecial}

    63      * and only if any of the following conditions is true:<ul>

    64      * <li>R is public.

    65      * <li>R is protected and is declared in a class C, and D is either

    66      *     a subclass of C or C itself.  Furthermore, if R is not

    67      *     static, then the symbolic reference to R must contain a

    68      *     symbolic reference to a class T, such that T is either a

    69      *     subclass of D, a superclass of D or D itself.

    70      * <li>R is either protected or has default access (that is,

    71      *     neither public nor protected nor private), and is declared

    72      *     by a class in the same runtime package as D.

    73      * <li>R is private and is declared in D.

    74      * </ul>

    75      * This discussion of access control omits a related restriction

    76      * on the target of a protected field access or method invocation

    77      * (the target must be of class D or a subtype of D). That

    78      * requirement is checked as part of the verification process

    79      * (5.4.1); it is not part of link-time access control.

    80      * @param refc the class used in the symbolic reference to the proposed member

    81      * @param defc the class in which the proposed member is actually defined

    82      * @param mods modifier flags for the proposed member

    59      * @return null if the method is not accessible, else a receiver type constraint, else {@code Object.class}

    84      * @return true iff the the accessing class can access such a member

    60      */

    85      */

    61     public static Class<?> isAccessible(Class<?> defc, int mods,

    86     public static boolean isMemberAccessible(Class<?> refc,  // symbolic ref class

    62             Class<?> lookupClass, boolean isSpecialInvoke) {

    87                                              Class<?> defc,  // actual def class

    63         if (!isAccessible(defc, lookupClass))

    88                                              int      mods,  // actual member mods

    64             return null;

    89                                              Class<?> lookupClass) {

    65         Class<?> constraint = Object.class;

    90         // Usually refc and defc are the same, but if they differ, verify them both.

    66         if (isSpecialInvoke && !Modifier.isStatic(mods)) {

    91         if (refc != defc) {

    67             constraint = lookupClass;

    92             if (!isClassAccessible(refc, lookupClass)) {

    68         }

    93                 // Note that defc is verified in the switch below.

    69         if (Modifier.isPublic(mods))

    94                 return false;

    70             return constraint;

    95             }

    71         if (Modifier.isPrivate(mods))

    96             if ((mods & (ALL_ACCESS_MODES|STATIC)) == (PROTECTED|STATIC)) {

    72             return isSamePackageMember(defc, lookupClass) ? constraint : null;

    97                 // Apply the special rules for refc here.

    73         if (isSamePackage(defc, lookupClass))

    98                 if (!isRelatedClass(refc, lookupClass))

    74             return constraint;

    99                     return isSamePackage(defc, lookupClass);

    75         if (Modifier.isProtected(mods) && defc.isAssignableFrom(lookupClass))

   100                 // If refc == defc, the call to isPublicSuperClass will do

    76             return constraint;

   101                 // the whole job, since in that case refc (as defc) will be

    77         // else it is private or package scoped, and not close enough

   102                 // a superclass of the lookup class.

    78         return null;

   103             }

   104         }

   105         switch (mods & ALL_ACCESS_MODES) {

   106         case PUBLIC:

   107             if (refc != defc)  return true;  // already checked above

   108             return isClassAccessible(refc, lookupClass);

   109         case PROTECTED:

   110             return isSamePackage(defc, lookupClass) || isPublicSuperClass(defc, lookupClass);

   111         case PACKAGE_ONLY:

   112             return isSamePackage(defc, lookupClass);

   113         case PRIVATE:

   114             // Loosened rules for privates follows access rules for inner classes.

   115             return isSamePackageMember(defc, lookupClass);

   116         default:

   117             throw new IllegalArgumentException("bad modifiers: "+Modifier.toString(mods));

   118         }

   119     }

   120 

   121     static boolean isRelatedClass(Class<?> refc, Class<?> lookupClass) {

   122         return (refc == lookupClass ||

   123                 refc.isAssignableFrom(lookupClass) ||

   124                 lookupClass.isAssignableFrom(refc));

   125     }

   126 

   127     static boolean isPublicSuperClass(Class<?> defc, Class<?> lookupClass) {

   128         return isPublic(defc.getModifiers()) && defc.isAssignableFrom(lookupClass);

    83      */

   133      * <h3>JVM Specification, 5.4.4 "Access Control"</h3>

    84     public static boolean isAccessible(Class<?> refc, Class<?> lookupClass) {

   134      * A class or interface C is accessible to a class or interface D

   135      * if and only if either of the following conditions are true:<ul>

   136      * <li>C is public.

   137      * <li>C and D are members of the same runtime package.

   138      * </ul>

   139      */

   140     public static boolean isClassAccessible(Class<?> refc, Class<?> lookupClass) {

    86         if (Modifier.isPublic(mods))

   142         if (isPublic(mods))