67 /**
68 * @deprecated This method will be removed.
69 * This method is a private JDK API and retained temporarily to
70 * simplify the implementation of sun.misc.Reflection.getCallerClass.
71 */
72 @Deprecated(forRemoval=true)
73 public static native Class<?> getCallerClass(int depth);
74
75 /** Retrieves the access flags written to the class file. For
76 inner classes these flags may differ from those returned by
77 Class.getModifiers(), which searches the InnerClasses
78 attribute to find the source-level access flags. This is used
79 instead of Class.getModifiers() for run-time access checks due
80 to compatibility reasons; see 4471811. Only the values of the
81 low 13 bits (i.e., a mask of 0x1FFF) are guaranteed to be
82 valid. */
83 @HotSpotIntrinsicCandidate
84 public static native int getClassAccessFlags(Class<?> c);
85
86
87 public static void ensureMemberAccess(Class<?> currentClass,
88 Class<?> memberClass,
89 Object target,
90 int modifiers)
91 throws IllegalAccessException
92 {
93 if (currentClass == null || memberClass == null) {
94 throw new InternalError();
95 }
96
97 if (!verifyMemberAccess(currentClass, memberClass, target, modifiers)) {
98 throwIllegalAccessException(currentClass, memberClass, target, modifiers);
99 }
100 }
101
102 public static boolean verifyMemberAccess(Class<?> currentClass,
103 // Declaring class of field
104 // or method
105 Class<?> memberClass,
106 // May be NULL in case of statics
107 Object target,
108 int modifiers)
109 {
110 // Verify that currentClass can access a field, method, or
111 // constructor of memberClass, where that member's access bits are
112 // "modifiers".
113
114 boolean gotIsSameClassPackage = false;
115 boolean isSameClassPackage = false;
116
117 if (currentClass == memberClass) {
118 // Always succeeds
119 return true;
120 }
121
122 if (!verifyModuleAccess(currentClass, memberClass)) {
123 return false;
124 }
125
126 if (!Modifier.isPublic(getClassAccessFlags(memberClass))) {
127 isSameClassPackage = isSameClassPackage(currentClass, memberClass);
145 successSoFar = true;
146 }
147 }
148
149 if (!successSoFar && !Modifier.isPrivate(modifiers)) {
150 if (!gotIsSameClassPackage) {
151 isSameClassPackage = isSameClassPackage(currentClass,
152 memberClass);
153 gotIsSameClassPackage = true;
154 }
155
156 if (isSameClassPackage) {
157 successSoFar = true;
158 }
159 }
160
161 if (!successSoFar) {
162 return false;
163 }
164
165 if (Modifier.isProtected(modifiers)) {
166 // Additional test for protected members: JLS 6.6.2
167 Class<?> targetClass = (target == null ? memberClass : target.getClass());
168 if (targetClass != currentClass) {
169 if (!gotIsSameClassPackage) {
170 isSameClassPackage = isSameClassPackage(currentClass, memberClass);
171 gotIsSameClassPackage = true;
172 }
173 if (!isSameClassPackage) {
174 if (!isSubclassOf(targetClass, currentClass)) {
175 return false;
176 }
177 }
178 }
179 }
180
181 return true;
182 }
183
184 /**
185 * Returns {@code true} if memberClass's's module exports memberClass's
186 * package to currentClass's module.
187 */
188 public static boolean verifyModuleAccess(Class<?> currentClass,
189 Class<?> memberClass) {
190 return verifyModuleAccess(currentClass.getModule(), memberClass);
191 }
192
193 public static boolean verifyModuleAccess(Module currentModule, Class<?> memberClass) {
194 Module memberModule = memberClass.getModule();
195
196 // module may be null during startup (initLevel 0)
|
67 /**
68 * @deprecated This method will be removed.
69 * This method is a private JDK API and retained temporarily to
70 * simplify the implementation of sun.misc.Reflection.getCallerClass.
71 */
72 @Deprecated(forRemoval=true)
73 public static native Class<?> getCallerClass(int depth);
74
75 /** Retrieves the access flags written to the class file. For
76 inner classes these flags may differ from those returned by
77 Class.getModifiers(), which searches the InnerClasses
78 attribute to find the source-level access flags. This is used
79 instead of Class.getModifiers() for run-time access checks due
80 to compatibility reasons; see 4471811. Only the values of the
81 low 13 bits (i.e., a mask of 0x1FFF) are guaranteed to be
82 valid. */
83 @HotSpotIntrinsicCandidate
84 public static native int getClassAccessFlags(Class<?> c);
85
86
87 /**
88 * Ensures that access to a member is granted and throws
89 * IllegalAccessException if not.
90 *
91 * @param currentClass the class performing the access
92 * @param memberClass the declaring class of the member being accessed
93 * @param targetClass the class of target object if accessing instance
94 * field or method;
95 * or the declaring class if accessing constructor;
96 * or null if accessing static field or method
97 * @param modifiers the member's access modifiers
98 * @throws IllegalAccessException if access to member is denied
99 */
100 public static void ensureMemberAccess(Class<?> currentClass,
101 Class<?> memberClass,
102 Class<?> targetClass,
103 int modifiers)
104 throws IllegalAccessException
105 {
106 if (currentClass == null || memberClass == null) {
107 throw new InternalError();
108 }
109
110 if (!verifyMemberAccess(currentClass, memberClass, targetClass, modifiers)) {
111 throwIllegalAccessException(currentClass, memberClass, targetClass, modifiers);
112 }
113 }
114
115 private static boolean verifyMemberAccess(Class<?> currentClass,
116 Class<?> memberClass,
117 Class<?> targetClass,
118 int modifiers)
119 {
120 // Verify that currentClass can access a field, method, or
121 // constructor of memberClass, where that member's access bits are
122 // "modifiers".
123
124 boolean gotIsSameClassPackage = false;
125 boolean isSameClassPackage = false;
126
127 if (currentClass == memberClass) {
128 // Always succeeds
129 return true;
130 }
131
132 if (!verifyModuleAccess(currentClass, memberClass)) {
133 return false;
134 }
135
136 if (!Modifier.isPublic(getClassAccessFlags(memberClass))) {
137 isSameClassPackage = isSameClassPackage(currentClass, memberClass);
155 successSoFar = true;
156 }
157 }
158
159 if (!successSoFar && !Modifier.isPrivate(modifiers)) {
160 if (!gotIsSameClassPackage) {
161 isSameClassPackage = isSameClassPackage(currentClass,
162 memberClass);
163 gotIsSameClassPackage = true;
164 }
165
166 if (isSameClassPackage) {
167 successSoFar = true;
168 }
169 }
170
171 if (!successSoFar) {
172 return false;
173 }
174
175 // Additional test for protected instance members
176 // and protected constructors: JLS 6.6.2
177 if (targetClass != null && Modifier.isProtected(modifiers) &&
178 targetClass != currentClass)
179 {
180 if (!gotIsSameClassPackage) {
181 isSameClassPackage = isSameClassPackage(currentClass, memberClass);
182 gotIsSameClassPackage = true;
183 }
184 if (!isSameClassPackage) {
185 if (!isSubclassOf(targetClass, currentClass)) {
186 return false;
187 }
188 }
189 }
190
191 return true;
192 }
193
194 /**
195 * Returns {@code true} if memberClass's's module exports memberClass's
196 * package to currentClass's module.
197 */
198 public static boolean verifyModuleAccess(Class<?> currentClass,
199 Class<?> memberClass) {
200 return verifyModuleAccess(currentClass.getModule(), memberClass);
201 }
202
203 public static boolean verifyModuleAccess(Module currentModule, Class<?> memberClass) {
204 Module memberModule = memberClass.getModule();
205
206 // module may be null during startup (initLevel 0)
|