1 /*
2 * Copyright (C) 2008 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17 /*
18 * java.lang.reflect.Field
19 */
20 #include "Dalvik.h"
21 #include "native/InternalNativePriv.h"
22
23
24 /*
25 * Get the address of a field from an object. This can be used with "get"
26 * or "set".
27 *
28 * "declaringClass" is the class in which the field was declared. For an
29 * instance field, "obj" is the object that holds the field data; for a
30 * static field its value is ignored.
31 *
32 * "If the underlying field is static, the class that declared the
33 * field is initialized if it has not already been initialized."
34 *
35 * On failure, throws an exception and returns NULL.
36 *
37 * The documentation lists exceptional conditions and the exceptions that
38 * should be thrown, but doesn't say which exception previals when two or
39 * more exceptional conditions exist at the same time. For example,
40 * attempting to set a protected field from an unrelated class causes an
41 * IllegalAccessException, while passing in a data type that doesn't match
42 * the field causes an IllegalArgumentException. If code does both at the
43 * same time, we have to choose one or othe other.
44 *
45 * The expected order is:
46 * (1) Check for illegal access. Throw IllegalAccessException.
47 * (2) Make sure the object actually has the field. Throw
48 * IllegalArgumentException.
49 * (3) Make sure the field matches the expected type, e.g. if we issued
50 * a "getInteger" call make sure the field is an integer or can be
51 * converted to an int with a widening conversion. Throw
52 * IllegalArgumentException.
53 * (4) Make sure "obj" is not null. Throw NullPointerException.
54 *
55 * TODO: we're currently handling #3 after #4, because we don't check the
56 * widening conversion until we're actually extracting the value from the
57 * object (which won't work well if it's a null reference).
58 */
getFieldDataAddr(Object * obj,ClassObject * declaringClass,int slot,bool isSetOperation,bool noAccessCheck)59 static JValue* getFieldDataAddr(Object* obj, ClassObject* declaringClass,
60 int slot, bool isSetOperation, bool noAccessCheck)
61 {
62 Field* field;
63 JValue* result;
64
65 field = dvmSlotToField(declaringClass, slot);
66 assert(field != NULL);
67
68 /* verify access */
69 if (!noAccessCheck) {
70 if (isSetOperation && dvmIsFinalField(field)) {
71 dvmThrowException("Ljava/lang/IllegalAccessException;",
72 "field is marked 'final'");
73 return NULL;
74 }
75
76 ClassObject* callerClass =
77 dvmGetCaller2Class(dvmThreadSelf()->curFrame);
78
79 /*
80 * We need to check two things:
81 * (1) Would an instance of the calling class have access to the field?
82 * (2) If the field is "protected", is the object an instance of the
83 * calling class, or is the field's declaring class in the same
84 * package as the calling class?
85 *
86 * #1 is basic access control. #2 ensures that, just because
87 * you're a subclass of Foo, you can't mess with protected fields
88 * in arbitrary Foo objects from other packages.
89 */
90 if (!dvmCheckFieldAccess(callerClass, field)) {
91 dvmThrowException("Ljava/lang/IllegalAccessException;",
92 "access to field not allowed");
93 return NULL;
94 }
95 if (dvmIsProtectedField(field)) {
96 bool isInstance, samePackage;
97
98 if (obj != NULL)
99 isInstance = dvmInstanceof(obj->clazz, callerClass);
100 else
101 isInstance = false;
102 samePackage = dvmInSamePackage(declaringClass, callerClass);
103
104 if (!isInstance && !samePackage) {
105 dvmThrowException("Ljava/lang/IllegalAccessException;",
106 "access to protected field not allowed");
107 return NULL;
108 }
109 }
110 }
111
112 if (dvmIsStaticField(field)) {
113 /* init class if necessary, then return ptr to storage in "field" */
114 if (!dvmIsClassInitialized(declaringClass)) {
115 if (!dvmInitClass(declaringClass)) {
116 assert(dvmCheckException(dvmThreadSelf()));
117 return NULL;
118 }
119 }
120
121 result = dvmStaticFieldPtr((StaticField*) field);
122 } else {
123 /*
124 * Verify object is of correct type (i.e. it actually has the
125 * expected field in it), then grab a pointer to obj storage.
126 * The call to dvmVerifyObjectInClass throws an NPE if "obj" is NULL.
127 */
128 if (!dvmVerifyObjectInClass(obj, declaringClass)) {
129 assert(dvmCheckException(dvmThreadSelf()));
130 if (obj != NULL) {
131 LOGD("Wrong type of object for field lookup: %s %s\n",
132 obj->clazz->descriptor, declaringClass->descriptor);
133 }
134 return NULL;
135 }
136 result = dvmFieldPtr(obj, ((InstField*) field)->byteOffset);
137 }
138
139 return result;
140 }
141
142 /*
143 * public int getFieldModifiers(Class declaringClass, int slot)
144 */
Dalvik_java_lang_reflect_Field_getFieldModifiers(const u4 * args,JValue * pResult)145 static void Dalvik_java_lang_reflect_Field_getFieldModifiers(
146 const u4* args, JValue* pResult)
147 {
148 // ignore thisPtr in args[0]
149 ClassObject* declaringClass = (ClassObject*) args[1];
150 int slot = args[2];
151 Field* field;
152
153 field = dvmSlotToField(declaringClass, slot);
154 RETURN_INT(field->accessFlags & JAVA_FLAGS_MASK);
155 }
156
157 /*
158 * private Object getField(Object o, Class declaringClass, Class type,
159 * int slot, boolean noAccessCheck)
160 *
161 * Primitive types need to be boxed.
162 */
Dalvik_java_lang_reflect_Field_getField(const u4 * args,JValue * pResult)163 static void Dalvik_java_lang_reflect_Field_getField(const u4* args,
164 JValue* pResult)
165 {
166 // ignore thisPtr in args[0]
167 Object* obj = (Object*) args[1];
168 ClassObject* declaringClass = (ClassObject*) args[2];
169 ClassObject* fieldType = (ClassObject*) args[3];
170 int slot = args[4];
171 bool noAccessCheck = (args[5] != 0);
172 JValue value;
173 const JValue* fieldPtr;
174 DataObject* result;
175
176 //dvmDumpClass(obj->clazz, kDumpClassFullDetail);
177
178 /* get a pointer to the field's data; performs access checks */
179 fieldPtr = getFieldDataAddr(obj, declaringClass, slot, false,noAccessCheck);
180 if (fieldPtr == NULL)
181 RETURN_VOID();
182
183 /* copy 4 or 8 bytes out */
184 if (fieldType->primitiveType == PRIM_LONG ||
185 fieldType->primitiveType == PRIM_DOUBLE)
186 {
187 value.j = fieldPtr->j;
188 } else {
189 value.i = fieldPtr->i;
190 }
191
192 result = dvmWrapPrimitive(value, fieldType);
193 dvmReleaseTrackedAlloc((Object*) result, NULL);
194 RETURN_PTR(result);
195 }
196
197 /*
198 * private void setField(Object o, Class declaringClass, Class type,
199 * int slot, boolean noAccessCheck, Object value)
200 *
201 * When assigning into a primitive field we will automatically extract
202 * the value from box types.
203 */
Dalvik_java_lang_reflect_Field_setField(const u4 * args,JValue * pResult)204 static void Dalvik_java_lang_reflect_Field_setField(const u4* args,
205 JValue* pResult)
206 {
207 // ignore thisPtr in args[0]
208 Object* obj = (Object*) args[1];
209 ClassObject* declaringClass = (ClassObject*) args[2];
210 ClassObject* fieldType = (ClassObject*) args[3];
211 int slot = args[4];
212 bool noAccessCheck = (args[5] != 0);
213 Object* valueObj = (Object*) args[6];
214 JValue* fieldPtr;
215 JValue value;
216
217 /* unwrap primitive, or verify object type */
218 if (!dvmUnwrapPrimitive(valueObj, fieldType, &value)) {
219 dvmThrowException("Ljava/lang/IllegalArgumentException;",
220 "invalid value for field");
221 RETURN_VOID();
222 }
223
224 /* get a pointer to the field's data; performs access checks */
225 fieldPtr = getFieldDataAddr(obj, declaringClass, slot, true, noAccessCheck);
226 if (fieldPtr == NULL)
227 RETURN_VOID();
228
229 /* store 4 or 8 bytes */
230 if (fieldType->primitiveType == PRIM_LONG ||
231 fieldType->primitiveType == PRIM_DOUBLE)
232 {
233 fieldPtr->j = value.j;
234 } else if (fieldType->primitiveType == PRIM_NOT) {
235 if (slot < 0) {
236 StaticField *sfield;
237 sfield = (StaticField *)dvmSlotToField(declaringClass, slot);
238 assert(fieldPtr == &sfield->value);
239 dvmSetStaticFieldObject(sfield, value.l);
240 } else {
241 int offset = declaringClass->ifields[slot].byteOffset;
242 assert(fieldPtr == (JValue *)BYTE_OFFSET(obj, offset));
243 dvmSetFieldObject(obj, offset, value.l);
244 }
245 } else {
246 fieldPtr->i = value.i;
247 }
248
249 RETURN_VOID();
250 }
251
252 /*
253 * Convert a reflection primitive type ordinal (inherited from the previous
254 * VM's reflection classes) to our value.
255 */
convPrimType(int typeNum)256 static PrimitiveType convPrimType(int typeNum)
257 {
258 static const PrimitiveType conv[PRIM_MAX] = {
259 PRIM_NOT, PRIM_BOOLEAN, PRIM_BYTE, PRIM_CHAR, PRIM_SHORT,
260 PRIM_INT, PRIM_FLOAT, PRIM_LONG, PRIM_DOUBLE
261 };
262 if (typeNum <= 0 || typeNum > 8)
263 return PRIM_NOT;
264 return conv[typeNum];
265 }
266
267 /*
268 * Primitive field getters, e.g.:
269 * private double getIField(Object o, Class declaringClass,
270 * Class type, int slot, boolean noAccessCheck, int type_no)
271 *
272 * The "type_no" is defined by the java.lang.reflect.Field class.
273 */
Dalvik_java_lang_reflect_Field_getPrimitiveField(const u4 * args,JValue * pResult)274 static void Dalvik_java_lang_reflect_Field_getPrimitiveField(const u4* args,
275 JValue* pResult)
276 {
277 // ignore thisPtr in args[0]
278 Object* obj = (Object*) args[1];
279 ClassObject* declaringClass = (ClassObject*) args[2];
280 ClassObject* fieldType = (ClassObject*) args[3];
281 int slot = args[4];
282 bool noAccessCheck = (args[5] != 0);
283 int typeNum = args[6];
284 PrimitiveType targetType = convPrimType(typeNum);
285 const JValue* fieldPtr;
286 JValue value;
287
288 if (!dvmIsPrimitiveClass(fieldType)) {
289 dvmThrowException("Ljava/lang/IllegalArgumentException;",
290 "not a primitive field");
291 RETURN_VOID();
292 }
293
294 /* get a pointer to the field's data; performs access checks */
295 fieldPtr = getFieldDataAddr(obj, declaringClass, slot, false,noAccessCheck);
296 if (fieldPtr == NULL)
297 RETURN_VOID();
298
299 /* copy 4 or 8 bytes out */
300 if (fieldType->primitiveType == PRIM_LONG ||
301 fieldType->primitiveType == PRIM_DOUBLE)
302 {
303 value.j = fieldPtr->j;
304 } else {
305 value.i = fieldPtr->i;
306 }
307
308 /* retrieve value, performing a widening conversion if necessary */
309 if (dvmConvertPrimitiveValue(fieldType->primitiveType, targetType,
310 &(value.i), &(pResult->i)) < 0)
311 {
312 dvmThrowException("Ljava/lang/IllegalArgumentException;",
313 "invalid primitive conversion");
314 RETURN_VOID();
315 }
316 }
317
318 /*
319 * Primitive field setters, e.g.:
320 * private void setIField(Object o, Class declaringClass,
321 * Class type, int slot, boolean noAccessCheck, int type_no, int value)
322 *
323 * The "type_no" is defined by the java.lang.reflect.Field class.
324 */
Dalvik_java_lang_reflect_Field_setPrimitiveField(const u4 * args,JValue * pResult)325 static void Dalvik_java_lang_reflect_Field_setPrimitiveField(const u4* args,
326 JValue* pResult)
327 {
328 // ignore thisPtr in args[0]
329 Object* obj = (Object*) args[1];
330 ClassObject* declaringClass = (ClassObject*) args[2];
331 ClassObject* fieldType = (ClassObject*) args[3];
332 int slot = args[4];
333 bool noAccessCheck = (args[5] != 0);
334 int typeNum = args[6];
335 const s4* valuePtr = (s4*) &args[7];
336 PrimitiveType srcType = convPrimType(typeNum);
337 JValue* fieldPtr;
338 JValue value;
339
340 if (!dvmIsPrimitiveClass(fieldType)) {
341 dvmThrowException("Ljava/lang/IllegalArgumentException;",
342 "not a primitive field");
343 RETURN_VOID();
344 }
345
346 /* convert the 32/64-bit arg to a JValue matching the field type */
347 if (dvmConvertPrimitiveValue(srcType, fieldType->primitiveType,
348 valuePtr, &(value.i)) < 0)
349 {
350 dvmThrowException("Ljava/lang/IllegalArgumentException;",
351 "invalid primitive conversion");
352 RETURN_VOID();
353 }
354
355 /* get a pointer to the field's data; performs access checks */
356 fieldPtr = getFieldDataAddr(obj, declaringClass, slot, true, noAccessCheck);
357 if (fieldPtr == NULL)
358 RETURN_VOID();
359
360 /* store 4 or 8 bytes */
361 if (fieldType->primitiveType == PRIM_LONG ||
362 fieldType->primitiveType == PRIM_DOUBLE)
363 {
364 fieldPtr->j = value.j;
365 } else {
366 fieldPtr->i = value.i;
367 }
368
369 RETURN_VOID();
370 }
371
372 /*
373 * public Annotation[] getDeclaredAnnotations(Class declaringClass, int slot)
374 *
375 * Return the annotations declared for this field.
376 */
Dalvik_java_lang_reflect_Field_getDeclaredAnnotations(const u4 * args,JValue * pResult)377 static void Dalvik_java_lang_reflect_Field_getDeclaredAnnotations(
378 const u4* args, JValue* pResult)
379 {
380 // ignore thisPtr in args[0]
381 ClassObject* declaringClass = (ClassObject*) args[1];
382 int slot = args[2];
383 Field* field;
384
385 field = dvmSlotToField(declaringClass, slot);
386 assert(field != NULL);
387
388 ArrayObject* annos = dvmGetFieldAnnotations(field);
389 dvmReleaseTrackedAlloc((Object*) annos, NULL);
390 RETURN_PTR(annos);
391 }
392
393 /*
394 * private Object[] getSignatureAnnotation()
395 *
396 * Returns the signature annotation.
397 */
Dalvik_java_lang_reflect_Field_getSignatureAnnotation(const u4 * args,JValue * pResult)398 static void Dalvik_java_lang_reflect_Field_getSignatureAnnotation(const u4* args,
399 JValue* pResult)
400 {
401 // ignore thisPtr in args[0]
402 ClassObject* declaringClass = (ClassObject*) args[1];
403 int slot = args[2];
404 Field* field;
405
406 field = dvmSlotToField(declaringClass, slot);
407 assert(field != NULL);
408
409 ArrayObject* arr = dvmGetFieldSignatureAnnotation(field);
410 dvmReleaseTrackedAlloc((Object*) arr, NULL);
411 RETURN_PTR(arr);
412 }
413
414 const DalvikNativeMethod dvm_java_lang_reflect_Field[] = {
415 { "getFieldModifiers", "(Ljava/lang/Class;I)I",
416 Dalvik_java_lang_reflect_Field_getFieldModifiers },
417 { "getField", "(Ljava/lang/Object;Ljava/lang/Class;Ljava/lang/Class;IZ)Ljava/lang/Object;",
418 Dalvik_java_lang_reflect_Field_getField },
419 { "getBField", "(Ljava/lang/Object;Ljava/lang/Class;Ljava/lang/Class;IZI)B",
420 Dalvik_java_lang_reflect_Field_getPrimitiveField },
421 { "getCField", "(Ljava/lang/Object;Ljava/lang/Class;Ljava/lang/Class;IZI)C",
422 Dalvik_java_lang_reflect_Field_getPrimitiveField },
423 { "getDField", "(Ljava/lang/Object;Ljava/lang/Class;Ljava/lang/Class;IZI)D",
424 Dalvik_java_lang_reflect_Field_getPrimitiveField },
425 { "getFField", "(Ljava/lang/Object;Ljava/lang/Class;Ljava/lang/Class;IZI)F",
426 Dalvik_java_lang_reflect_Field_getPrimitiveField },
427 { "getIField", "(Ljava/lang/Object;Ljava/lang/Class;Ljava/lang/Class;IZI)I",
428 Dalvik_java_lang_reflect_Field_getPrimitiveField },
429 { "getJField", "(Ljava/lang/Object;Ljava/lang/Class;Ljava/lang/Class;IZI)J",
430 Dalvik_java_lang_reflect_Field_getPrimitiveField },
431 { "getSField", "(Ljava/lang/Object;Ljava/lang/Class;Ljava/lang/Class;IZI)S",
432 Dalvik_java_lang_reflect_Field_getPrimitiveField },
433 { "getZField", "(Ljava/lang/Object;Ljava/lang/Class;Ljava/lang/Class;IZI)Z",
434 Dalvik_java_lang_reflect_Field_getPrimitiveField },
435 { "setField", "(Ljava/lang/Object;Ljava/lang/Class;Ljava/lang/Class;IZLjava/lang/Object;)V",
436 Dalvik_java_lang_reflect_Field_setField },
437 { "setBField", "(Ljava/lang/Object;Ljava/lang/Class;Ljava/lang/Class;IZIB)V",
438 Dalvik_java_lang_reflect_Field_setPrimitiveField },
439 { "setCField", "(Ljava/lang/Object;Ljava/lang/Class;Ljava/lang/Class;IZIC)V",
440 Dalvik_java_lang_reflect_Field_setPrimitiveField },
441 { "setDField", "(Ljava/lang/Object;Ljava/lang/Class;Ljava/lang/Class;IZID)V",
442 Dalvik_java_lang_reflect_Field_setPrimitiveField },
443 { "setFField", "(Ljava/lang/Object;Ljava/lang/Class;Ljava/lang/Class;IZIF)V",
444 Dalvik_java_lang_reflect_Field_setPrimitiveField },
445 { "setIField", "(Ljava/lang/Object;Ljava/lang/Class;Ljava/lang/Class;IZII)V",
446 Dalvik_java_lang_reflect_Field_setPrimitiveField },
447 { "setJField", "(Ljava/lang/Object;Ljava/lang/Class;Ljava/lang/Class;IZIJ)V",
448 Dalvik_java_lang_reflect_Field_setPrimitiveField },
449 { "setSField", "(Ljava/lang/Object;Ljava/lang/Class;Ljava/lang/Class;IZIS)V",
450 Dalvik_java_lang_reflect_Field_setPrimitiveField },
451 { "setZField", "(Ljava/lang/Object;Ljava/lang/Class;Ljava/lang/Class;IZIZ)V",
452 Dalvik_java_lang_reflect_Field_setPrimitiveField },
453 { "getDeclaredAnnotations", "(Ljava/lang/Class;I)[Ljava/lang/annotation/Annotation;",
454 Dalvik_java_lang_reflect_Field_getDeclaredAnnotations },
455 { "getSignatureAnnotation", "(Ljava/lang/Class;I)[Ljava/lang/Object;",
456 Dalvik_java_lang_reflect_Field_getSignatureAnnotation },
457 { NULL, NULL, NULL },
458 };
459