1 /*
2 * Copyright (c) 2001, 2006, Oracle and/or its affiliates. All rights reserved.
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * This code is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 only, as
7 * published by the Free Software Foundation. Oracle designates this
8 * particular file as subject to the "Classpath" exception as provided
9 * by Oracle in the LICENSE file that accompanied this code.
10 *
11 * This code is distributed in the hope that it will be useful, but WITHOUT
12 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
14 * version 2 for more details (a copy is included in the LICENSE file that
15 * accompanied this code).
16 *
17 * You should have received a copy of the GNU General Public License version
18 * 2 along with this work; if not, write to the Free Software Foundation,
19 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
20 *
21 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
22 * or visit www.oracle.com if you need additional information or have any
23 * questions.
24 */
25
26 package sun.reflect;
27
28 import java.lang.reflect;
29 import java.util.Collections;
30 import java.util.HashMap;
31 import java.util.Map;
32
33 /** Common utility routines used by both java.lang and
34 java.lang.reflect */
35
36 public class Reflection {
37
38 /** Used to filter out fields and methods from certain classes from public
39 view, where they are sensitive or they may contain VM-internal objects.
40 These Maps are updated very rarely. Rather than synchronize on
41 each access, we use copy-on-write */
42 private static volatile Map<Class,String[]> fieldFilterMap;
43 private static volatile Map<Class,String[]> methodFilterMap;
44
45 static {
46 Map<Class,String[]> map = new HashMap<Class,String[]>();
47 map.put(Reflection.class,
48 new String[] {"fieldFilterMap", "methodFilterMap"});
49 map.put(System.class, new String[] {"security"});
50 fieldFilterMap = map;
51
52 methodFilterMap = new HashMap<Class,String[]>();
53 }
54
55 /** Returns the class of the method <code>realFramesToSkip</code>
56 frames up the stack (zero-based), ignoring frames associated
57 with java.lang.reflect.Method.invoke() and its implementation.
58 The first frame is that associated with this method, so
59 <code>getCallerClass(0)</code> returns the Class object for
60 sun.reflect.Reflection. Frames associated with
61 java.lang.reflect.Method.invoke() and its implementation are
62 completely ignored and do not count toward the number of "real"
63 frames skipped. */
64 public static native Class getCallerClass(int realFramesToSkip);
65
66 /** Retrieves the access flags written to the class file. For
67 inner classes these flags may differ from those returned by
68 Class.getModifiers(), which searches the InnerClasses
69 attribute to find the source-level access flags. This is used
70 instead of Class.getModifiers() for run-time access checks due
71 to compatibility reasons; see 4471811. Only the values of the
72 low 13 bits (i.e., a mask of 0x1FFF) are guaranteed to be
73 valid. */
74 private static native int getClassAccessFlags(Class c);
75
76 /** A quick "fast-path" check to try to avoid getCallerClass()
77 calls. */
78 public static boolean quickCheckMemberAccess(Class memberClass,
79 int modifiers)
80 {
81 return Modifier.isPublic(getClassAccessFlags(memberClass) & modifiers);
82 }
83
84 public static void ensureMemberAccess(Class currentClass,
85 Class memberClass,
86 Object target,
87 int modifiers)
88 throws IllegalAccessException
89 {
90 if (currentClass == null || memberClass == null) {
91 throw new InternalError();
92 }
93
94 if (!verifyMemberAccess(currentClass, memberClass, target, modifiers)) {
95 throw new IllegalAccessException("Class " + currentClass.getName() +
96 " can not access a member of class " +
97 memberClass.getName() +
98 " with modifiers \"" +
99 Modifier.toString(modifiers) +
100 "\"");
101 }
102 }
103
104 public static boolean verifyMemberAccess(Class currentClass,
105 // Declaring class of field
106 // or method
107 Class memberClass,
108 // May be NULL in case of statics
109 Object target,
110 int modifiers)
111 {
112 // Verify that currentClass can access a field, method, or
113 // constructor of memberClass, where that member's access bits are
114 // "modifiers".
115
116 boolean gotIsSameClassPackage = false;
117 boolean isSameClassPackage = false;
118
119 if (currentClass == memberClass) {
120 // Always succeeds
121 return true;
122 }
123
124 if (!Modifier.isPublic(getClassAccessFlags(memberClass))) {
125 isSameClassPackage = isSameClassPackage(currentClass, memberClass);
126 gotIsSameClassPackage = true;
127 if (!isSameClassPackage) {
128 return false;
129 }
130 }
131
132 // At this point we know that currentClass can access memberClass.
133
134 if (Modifier.isPublic(modifiers)) {
135 return true;
136 }
137
138 boolean successSoFar = false;
139
140 if (Modifier.isProtected(modifiers)) {
141 // See if currentClass is a subclass of memberClass
142 if (isSubclassOf(currentClass, memberClass)) {
143 successSoFar = true;
144 }
145 }
146
147 if (!successSoFar && !Modifier.isPrivate(modifiers)) {
148 if (!gotIsSameClassPackage) {
149 isSameClassPackage = isSameClassPackage(currentClass,
150 memberClass);
151 gotIsSameClassPackage = true;
152 }
153
154 if (isSameClassPackage) {
155 successSoFar = true;
156 }
157 }
158
159 if (!successSoFar) {
160 return false;
161 }
162
163 if (Modifier.isProtected(modifiers)) {
164 // Additional test for protected members: JLS 6.6.2
165 Class targetClass = (target == null ? memberClass : target.getClass());
166 if (targetClass != currentClass) {
167 if (!gotIsSameClassPackage) {
168 isSameClassPackage = isSameClassPackage(currentClass, memberClass);
169 gotIsSameClassPackage = true;
170 }
171 if (!isSameClassPackage) {
172 if (!isSubclassOf(targetClass, currentClass)) {
173 return false;
174 }
175 }
176 }
177 }
178
179 return true;
180 }
181
182 private static boolean isSameClassPackage(Class c1, Class c2) {
183 return isSameClassPackage(c1.getClassLoader(), c1.getName(),
184 c2.getClassLoader(), c2.getName());
185 }
186
187 /** Returns true if two classes are in the same package; classloader
188 and classname information is enough to determine a class's package */
189 private static boolean isSameClassPackage(ClassLoader loader1, String name1,
190 ClassLoader loader2, String name2)
191 {
192 if (loader1 != loader2) {
193 return false;
194 } else {
195 int lastDot1 = name1.lastIndexOf('.');
196 int lastDot2 = name2.lastIndexOf('.');
197 if ((lastDot1 == -1) || (lastDot2 == -1)) {
198 // One of the two doesn't have a package. Only return true
199 // if the other one also doesn't have a package.
200 return (lastDot1 == lastDot2);
201 } else {
202 int idx1 = 0;
203 int idx2 = 0;
204
205 // Skip over '['s
206 if (name1.charAt(idx1) == '[') {
207 do {
208 idx1++;
209 } while (name1.charAt(idx1) == '[');
210 if (name1.charAt(idx1) != 'L') {
211 // Something is terribly wrong. Shouldn't be here.
212 throw new InternalError("Illegal class name " + name1);
213 }
214 }
215 if (name2.charAt(idx2) == '[') {
216 do {
217 idx2++;
218 } while (name2.charAt(idx2) == '[');
219 if (name2.charAt(idx2) != 'L') {
220 // Something is terribly wrong. Shouldn't be here.
221 throw new InternalError("Illegal class name " + name2);
222 }
223 }
224
225 // Check that package part is identical
226 int length1 = lastDot1 - idx1;
227 int length2 = lastDot2 - idx2;
228
229 if (length1 != length2) {
230 return false;
231 }
232 return name1.regionMatches(false, idx1, name2, idx2, length1);
233 }
234 }
235 }
236
237 static boolean isSubclassOf(Class queryClass,
238 Class ofClass)
239 {
240 while (queryClass != null) {
241 if (queryClass == ofClass) {
242 return true;
243 }
244 queryClass = queryClass.getSuperclass();
245 }
246 return false;
247 }
248
249 // fieldNames must contain only interned Strings
250 public static synchronized void registerFieldsToFilter(Class containingClass,
251 String ... fieldNames) {
252 fieldFilterMap =
253 registerFilter(fieldFilterMap, containingClass, fieldNames);
254 }
255
256 // methodNames must contain only interned Strings
257 public static synchronized void registerMethodsToFilter(Class containingClass,
258 String ... methodNames) {
259 methodFilterMap =
260 registerFilter(methodFilterMap, containingClass, methodNames);
261 }
262
263 private static Map<Class,String[]> registerFilter(Map<Class,String[]> map,
264 Class containingClass, String ... names) {
265 if (map.get(containingClass) != null) {
266 throw new IllegalArgumentException
267 ("Filter already registered: " + containingClass);
268 }
269 map = new HashMap<Class,String[]>(map);
270 map.put(containingClass, names);
271 return map;
272 }
273
274 public static Field[] filterFields(Class containingClass,
275 Field[] fields) {
276 if (fieldFilterMap == null) {
277 // Bootstrapping
278 return fields;
279 }
280 return (Field[])filter(fields, fieldFilterMap.get(containingClass));
281 }
282
283 public static Method[] filterMethods(Class containingClass, Method[] methods) {
284 if (methodFilterMap == null) {
285 // Bootstrapping
286 return methods;
287 }
288 return (Method[])filter(methods, methodFilterMap.get(containingClass));
289 }
290
291 private static Member[] filter(Member[] members, String[] filteredNames) {
292 if ((filteredNames == null) || (members.length == 0)) {
293 return members;
294 }
295 int numNewMembers = 0;
296 for (Member member : members) {
297 boolean shouldSkip = false;
298 for (String filteredName : filteredNames) {
299 if (member.getName() == filteredName) {
300 shouldSkip = true;
301 break;
302 }
303 }
304 if (!shouldSkip) {
305 ++numNewMembers;
306 }
307 }
308 Member[] newMembers =
309 (Member[])Array.newInstance(members[0].getClass(), numNewMembers);
310 int destIdx = 0;
311 for (Member member : members) {
312 boolean shouldSkip = false;
313 for (String filteredName : filteredNames) {
314 if (member.getName() == filteredName) {
315 shouldSkip = true;
316 break;
317 }
318 }
319 if (!shouldSkip) {
320 newMembers[destIdx++] = member;
321 }
322 }
323 return newMembers;
324 }
325 }
Save This Page