431 NativeReportJNIFatalError(thr, "Unrecognized array release mode");
432 }
433 // We always need to release the copy we made with GuardedMemory
434 GuardedMemory::free_copy(carray);
435 return orig_result;
436 }
437
438 oop jniCheck::validate_handle(JavaThread* thr, jobject obj) {
439 if ((obj != NULL) && (JNIHandles::handle_type(thr, obj) != JNIInvalidRefType)) {
440 ASSERT_OOPS_ALLOWED;
441 return JNIHandles::resolve_external_guard(obj);
442 }
443 ReportJNIFatalError(thr, fatal_bad_ref_to_jni);
444 return NULL;
445 }
446
447
448 Method* jniCheck::validate_jmethod_id(JavaThread* thr, jmethodID method_id) {
449 ASSERT_OOPS_ALLOWED;
450 // do the fast jmethodID check first
451 Method* moop = Method::checked_resolve_jmethod_id(method_id);
452 if (moop == NULL) {
453 ReportJNIFatalError(thr, fatal_wrong_class_or_method);
454 }
455 // jmethodIDs are supposed to be weak handles in the class loader data,
456 // but that can be expensive so check it last
457 else if (!Method::is_method_id(method_id)) {
458 ReportJNIFatalError(thr, fatal_non_weak_method);
459 }
460 return moop;
461 }
462
463
464 oop jniCheck::validate_object(JavaThread* thr, jobject obj) {
465 if (obj == NULL) return NULL;
466 ASSERT_OOPS_ALLOWED;
467 oop oopObj = jniCheck::validate_handle(thr, obj);
468 if (oopObj == NULL) {
469 ReportJNIFatalError(thr, fatal_bad_ref_to_jni);
470 }
471 return oopObj;
472 }
473
474 // Warn if a class descriptor is in decorated form; class descriptors
475 // passed to JNI findClass should not be decorated unless they are
476 // array descriptors.
477 void jniCheck::validate_class_descriptor(JavaThread* thr, const char* name) {
478 if (name == NULL) return; // implementation accepts NULL so just return
479
480 size_t len = strlen(name);
501 }
502
503 Klass* k = java_lang_Class::as_Klass(mirror);
504 // Make allowances for primitive classes ...
505 if (!(k != NULL || (allow_primitive && java_lang_Class::is_primitive(mirror)))) {
506 ReportJNIFatalError(thr, fatal_class_not_a_class);
507 }
508 return k;
509 }
510
511 void jniCheck::validate_throwable_klass(JavaThread* thr, Klass* klass) {
512 ASSERT_OOPS_ALLOWED;
513 assert(klass != NULL, "klass argument must have a value");
514
515 if (!klass->is_instance_klass() ||
516 !InstanceKlass::cast(klass)->is_subclass_of(SystemDictionary::Throwable_klass())) {
517 ReportJNIFatalError(thr, fatal_class_not_a_throwable_class);
518 }
519 }
520
521 void jniCheck::validate_call_object(JavaThread* thr, jobject obj, jmethodID method_id) {
522 /* validate the object being passed */
523 ASSERT_OOPS_ALLOWED;
524 jniCheck::validate_jmethod_id(thr, method_id);
525 jniCheck::validate_object(thr, obj);
526 }
527
528 void jniCheck::validate_call_class(JavaThread* thr, jclass clazz, jmethodID method_id) {
529 /* validate the class being passed */
530 ASSERT_OOPS_ALLOWED;
531 jniCheck::validate_jmethod_id(thr, method_id);
532 jniCheck::validate_class(thr, clazz, false);
533 }
534
535
536 /*
537 * IMPLEMENTATION OF FUNCTIONS IN CHECKED TABLE
538 */
539
540 JNI_ENTRY_CHECKED(jclass,
541 checked_jni_DefineClass(JNIEnv *env,
542 const char *name,
543 jobject loader,
544 const jbyte *buf,
545 jsize len))
546 functionEnter(thr);
547 IN_VM(
548 jniCheck::validate_object(thr, loader);
549 )
550 jclass result = UNCHECKED()->DefineClass(env, name, loader, buf, len);
551 functionExit(thr);
552 return result;
578
579 JNI_ENTRY_CHECKED(jfieldID,
580 checked_jni_FromReflectedField(JNIEnv *env,
581 jobject field))
582 functionEnter(thr);
583 IN_VM(
584 jniCheck::validate_object(thr, field);
585 )
586 jfieldID result = UNCHECKED()->FromReflectedField(env, field);
587 functionExit(thr);
588 return result;
589 JNI_END
590
591 JNI_ENTRY_CHECKED(jobject,
592 checked_jni_ToReflectedMethod(JNIEnv *env,
593 jclass cls,
594 jmethodID methodID,
595 jboolean isStatic))
596 functionEnter(thr);
597 IN_VM(
598 jniCheck::validate_class(thr, cls, false);
599 jniCheck::validate_jmethod_id(thr, methodID);
600 )
601 jobject result = UNCHECKED()->ToReflectedMethod(env, cls, methodID,
602 isStatic);
603 functionExit(thr);
604 return result;
605 JNI_END
606
607 JNI_ENTRY_CHECKED(jclass,
608 checked_jni_GetSuperclass(JNIEnv *env,
609 jclass sub))
610 functionEnter(thr);
611 IN_VM(
612 jniCheck::validate_class(thr, sub, true);
613 )
614 jclass result = UNCHECKED()->GetSuperclass(env, sub);
615 functionExit(thr);
616 return result;
617 JNI_END
618
619 JNI_ENTRY_CHECKED(jboolean,
835 JNI_ENTRY_CHECKED(jobject,
836 checked_jni_AllocObject(JNIEnv *env,
837 jclass clazz))
838 functionEnter(thr);
839 IN_VM(
840 jniCheck::validate_class(thr, clazz, false);
841 )
842 jobject result = UNCHECKED()->AllocObject(env,clazz);
843 functionExit(thr);
844 return result;
845 JNI_END
846
847 JNI_ENTRY_CHECKED(jobject,
848 checked_jni_NewObject(JNIEnv *env,
849 jclass clazz,
850 jmethodID methodID,
851 ...))
852 functionEnter(thr);
853 va_list args;
854 IN_VM(
855 jniCheck::validate_class(thr, clazz, false);
856 jniCheck::validate_jmethod_id(thr, methodID);
857 )
858 va_start(args, methodID);
859 jobject result = UNCHECKED()->NewObjectV(env,clazz,methodID,args);
860 va_end(args);
861 functionExit(thr);
862 return result;
863 JNI_END
864
865 JNI_ENTRY_CHECKED(jobject,
866 checked_jni_NewObjectV(JNIEnv *env,
867 jclass clazz,
868 jmethodID methodID,
869 va_list args))
870 functionEnter(thr);
871 IN_VM(
872 jniCheck::validate_class(thr, clazz, false);
873 jniCheck::validate_jmethod_id(thr, methodID);
874 )
875 jobject result = UNCHECKED()->NewObjectV(env,clazz,methodID,args);
876 functionExit(thr);
877 return result;
878 JNI_END
879
880 JNI_ENTRY_CHECKED(jobject,
881 checked_jni_NewObjectA(JNIEnv *env,
882 jclass clazz,
883 jmethodID methodID,
884 const jvalue *args))
885 functionEnter(thr);
886 IN_VM(
887 jniCheck::validate_class(thr, clazz, false);
888 jniCheck::validate_jmethod_id(thr, methodID);
889 )
890 jobject result = UNCHECKED()->NewObjectA(env,clazz,methodID,args);
891 functionExit(thr);
892 return result;
893 JNI_END
894
895 JNI_ENTRY_CHECKED(jclass,
896 checked_jni_GetObjectClass(JNIEnv *env,
897 jobject obj))
898 functionEnter(thr);
899 IN_VM(
900 jniCheck::validate_object(thr, obj);
901 )
902 jclass result = UNCHECKED()->GetObjectClass(env,obj);
903 functionExit(thr);
904 return result;
905 JNI_END
906
907 JNI_ENTRY_CHECKED(jboolean,
908 checked_jni_IsInstanceOf(JNIEnv *env,
924 const char *name,
925 const char *sig))
926 functionEnter(thr);
927 IN_VM(
928 jniCheck::validate_class(thr, clazz, false);
929 )
930 jmethodID result = UNCHECKED()->GetMethodID(env,clazz,name,sig);
931 functionExit(thr);
932 return result;
933 JNI_END
934
935 #define WRAPPER_CallMethod(ResultType, Result) \
936 JNI_ENTRY_CHECKED(ResultType, \
937 checked_jni_Call##Result##Method(JNIEnv *env, \
938 jobject obj, \
939 jmethodID methodID, \
940 ...)) \
941 functionEnter(thr); \
942 va_list args; \
943 IN_VM( \
944 jniCheck::validate_call_object(thr, obj, methodID); \
945 ) \
946 va_start(args,methodID); \
947 ResultType result =UNCHECKED()->Call##Result##MethodV(env, obj, methodID, \
948 args); \
949 va_end(args); \
950 thr->set_pending_jni_exception_check("Call"#Result"Method"); \
951 functionExit(thr); \
952 return result; \
953 JNI_END \
954 \
955 JNI_ENTRY_CHECKED(ResultType, \
956 checked_jni_Call##Result##MethodV(JNIEnv *env, \
957 jobject obj, \
958 jmethodID methodID, \
959 va_list args)) \
960 functionEnter(thr); \
961 IN_VM(\
962 jniCheck::validate_call_object(thr, obj, methodID); \
963 ) \
964 ResultType result = UNCHECKED()->Call##Result##MethodV(env, obj, methodID,\
965 args); \
966 thr->set_pending_jni_exception_check("Call"#Result"MethodV"); \
967 functionExit(thr); \
968 return result; \
969 JNI_END \
970 \
971 JNI_ENTRY_CHECKED(ResultType, \
972 checked_jni_Call##Result##MethodA(JNIEnv *env, \
973 jobject obj, \
974 jmethodID methodID, \
975 const jvalue * args)) \
976 functionEnter(thr); \
977 IN_VM( \
978 jniCheck::validate_call_object(thr, obj, methodID); \
979 ) \
980 ResultType result = UNCHECKED()->Call##Result##MethodA(env, obj, methodID,\
981 args); \
982 thr->set_pending_jni_exception_check("Call"#Result"MethodA"); \
983 functionExit(thr); \
984 return result; \
985 JNI_END
986
987 WRAPPER_CallMethod(jobject,Object)
988 WRAPPER_CallMethod(jboolean,Boolean)
989 WRAPPER_CallMethod(jbyte,Byte)
990 WRAPPER_CallMethod(jshort,Short)
991 WRAPPER_CallMethod(jchar,Char)
992 WRAPPER_CallMethod(jint,Int)
993 WRAPPER_CallMethod(jlong,Long)
994 WRAPPER_CallMethod(jfloat,Float)
995 WRAPPER_CallMethod(jdouble,Double)
996
997 JNI_ENTRY_CHECKED(void,
998 checked_jni_CallVoidMethod(JNIEnv *env, \
999 jobject obj, \
1000 jmethodID methodID, \
1001 ...))
1002 functionEnter(thr);
1003 va_list args;
1004 IN_VM(
1005 jniCheck::validate_call_object(thr, obj, methodID);
1006 )
1007 va_start(args,methodID);
1008 UNCHECKED()->CallVoidMethodV(env,obj,methodID,args);
1009 va_end(args);
1010 thr->set_pending_jni_exception_check("CallVoidMethod");
1011 functionExit(thr);
1012 JNI_END
1013
1014 JNI_ENTRY_CHECKED(void,
1015 checked_jni_CallVoidMethodV(JNIEnv *env,
1016 jobject obj,
1017 jmethodID methodID,
1018 va_list args))
1019 functionEnter(thr);
1020 IN_VM(
1021 jniCheck::validate_call_object(thr, obj, methodID);
1022 )
1023 UNCHECKED()->CallVoidMethodV(env,obj,methodID,args);
1024 thr->set_pending_jni_exception_check("CallVoidMethodV");
1025 functionExit(thr);
1026 JNI_END
1027
1028 JNI_ENTRY_CHECKED(void,
1029 checked_jni_CallVoidMethodA(JNIEnv *env,
1030 jobject obj,
1031 jmethodID methodID,
1032 const jvalue * args))
1033 functionEnter(thr);
1034 IN_VM(
1035 jniCheck::validate_call_object(thr, obj, methodID);
1036 )
1037 UNCHECKED()->CallVoidMethodA(env,obj,methodID,args);
1038 thr->set_pending_jni_exception_check("CallVoidMethodA");
1039 functionExit(thr);
1040 JNI_END
1041
1042 #define WRAPPER_CallNonvirtualMethod(ResultType, Result) \
1043 JNI_ENTRY_CHECKED(ResultType, \
1044 checked_jni_CallNonvirtual##Result##Method(JNIEnv *env, \
1045 jobject obj, \
1046 jclass clazz, \
1047 jmethodID methodID, \
1048 ...)) \
1049 functionEnter(thr); \
1050 va_list args; \
1051 IN_VM( \
1052 jniCheck::validate_call_object(thr, obj, methodID); \
1053 jniCheck::validate_call_class(thr, clazz, methodID); \
1054 ) \
1055 va_start(args,methodID); \
1056 ResultType result = UNCHECKED()->CallNonvirtual##Result##MethodV(env, \
1057 obj, \
1058 clazz, \
1059 methodID,\
1060 args); \
1061 va_end(args); \
1062 thr->set_pending_jni_exception_check("CallNonvirtual"#Result"Method"); \
1063 functionExit(thr); \
1064 return result; \
1065 JNI_END \
1066 \
1067 JNI_ENTRY_CHECKED(ResultType, \
1068 checked_jni_CallNonvirtual##Result##MethodV(JNIEnv *env, \
1069 jobject obj, \
1070 jclass clazz, \
1071 jmethodID methodID, \
1072 va_list args)) \
1073 functionEnter(thr); \
1074 IN_VM( \
1075 jniCheck::validate_call_object(thr, obj, methodID); \
1076 jniCheck::validate_call_class(thr, clazz, methodID); \
1077 ) \
1078 ResultType result = UNCHECKED()->CallNonvirtual##Result##MethodV(env, \
1079 obj, \
1080 clazz, \
1081 methodID,\
1082 args); \
1083 thr->set_pending_jni_exception_check("CallNonvirtual"#Result"MethodV"); \
1084 functionExit(thr); \
1085 return result; \
1086 JNI_END \
1087 \
1088 JNI_ENTRY_CHECKED(ResultType, \
1089 checked_jni_CallNonvirtual##Result##MethodA(JNIEnv *env, \
1090 jobject obj, \
1091 jclass clazz, \
1092 jmethodID methodID, \
1093 const jvalue * args)) \
1094 functionEnter(thr); \
1095 IN_VM( \
1096 jniCheck::validate_call_object(thr, obj, methodID); \
1097 jniCheck::validate_call_class(thr, clazz, methodID); \
1098 ) \
1099 ResultType result = UNCHECKED()->CallNonvirtual##Result##MethodA(env, \
1100 obj, \
1101 clazz, \
1102 methodID,\
1103 args); \
1104 thr->set_pending_jni_exception_check("CallNonvirtual"#Result"MethodA"); \
1105 functionExit(thr); \
1106 return result; \
1107 JNI_END
1108
1109 WRAPPER_CallNonvirtualMethod(jobject,Object)
1110 WRAPPER_CallNonvirtualMethod(jboolean,Boolean)
1111 WRAPPER_CallNonvirtualMethod(jbyte,Byte)
1112 WRAPPER_CallNonvirtualMethod(jshort,Short)
1113 WRAPPER_CallNonvirtualMethod(jchar,Char)
1114 WRAPPER_CallNonvirtualMethod(jint,Int)
1115 WRAPPER_CallNonvirtualMethod(jlong,Long)
1116 WRAPPER_CallNonvirtualMethod(jfloat,Float)
1117 WRAPPER_CallNonvirtualMethod(jdouble,Double)
1118
1119 JNI_ENTRY_CHECKED(void,
1120 checked_jni_CallNonvirtualVoidMethod(JNIEnv *env,
1121 jobject obj,
1122 jclass clazz,
1123 jmethodID methodID,
1124 ...))
1125 functionEnter(thr);
1126 va_list args;
1127 IN_VM(
1128 jniCheck::validate_call_object(thr, obj, methodID);
1129 jniCheck::validate_call_class(thr, clazz, methodID);
1130 )
1131 va_start(args,methodID);
1132 UNCHECKED()->CallNonvirtualVoidMethodV(env,obj,clazz,methodID,args);
1133 va_end(args);
1134 thr->set_pending_jni_exception_check("CallNonvirtualVoidMethod");
1135 functionExit(thr);
1136 JNI_END
1137
1138 JNI_ENTRY_CHECKED(void,
1139 checked_jni_CallNonvirtualVoidMethodV(JNIEnv *env,
1140 jobject obj,
1141 jclass clazz,
1142 jmethodID methodID,
1143 va_list args))
1144 functionEnter(thr);
1145 IN_VM(
1146 jniCheck::validate_call_object(thr, obj, methodID);
1147 jniCheck::validate_call_class(thr, clazz, methodID);
1148 )
1149 UNCHECKED()->CallNonvirtualVoidMethodV(env,obj,clazz,methodID,args);
1150 thr->set_pending_jni_exception_check("CallNonvirtualVoidMethodV");
1151 functionExit(thr);
1152 JNI_END
1153
1154 JNI_ENTRY_CHECKED(void,
1155 checked_jni_CallNonvirtualVoidMethodA(JNIEnv *env,
1156 jobject obj,
1157 jclass clazz,
1158 jmethodID methodID,
1159 const jvalue * args))
1160 functionEnter(thr);
1161 IN_VM(
1162 jniCheck::validate_call_object(thr, obj, methodID);
1163 jniCheck::validate_call_class(thr, clazz, methodID);
1164 )
1165 UNCHECKED()->CallNonvirtualVoidMethodA(env,obj,clazz,methodID,args);
1166 thr->set_pending_jni_exception_check("CallNonvirtualVoidMethodA");
1167 functionExit(thr);
1168 JNI_END
1169
1170 JNI_ENTRY_CHECKED(jfieldID,
1171 checked_jni_GetFieldID(JNIEnv *env,
1172 jclass clazz,
1173 const char *name,
1174 const char *sig))
1175 functionEnter(thr);
1176 IN_VM(
1177 jniCheck::validate_class(thr, clazz, false);
1178 )
1179 jfieldID result = UNCHECKED()->GetFieldID(env,clazz,name,sig);
1180 functionExit(thr);
1181 return result;
1182 JNI_END
1183
1236 const char *name,
1237 const char *sig))
1238 functionEnter(thr);
1239 IN_VM(
1240 jniCheck::validate_class(thr, clazz, false);
1241 )
1242 jmethodID result = UNCHECKED()->GetStaticMethodID(env,clazz,name,sig);
1243 functionExit(thr);
1244 return result;
1245 JNI_END
1246
1247 #define WRAPPER_CallStaticMethod(ReturnType,Result) \
1248 JNI_ENTRY_CHECKED(ReturnType, \
1249 checked_jni_CallStatic##Result##Method(JNIEnv *env, \
1250 jclass clazz, \
1251 jmethodID methodID, \
1252 ...)) \
1253 functionEnter(thr); \
1254 va_list args; \
1255 IN_VM( \
1256 jniCheck::validate_jmethod_id(thr, methodID); \
1257 jniCheck::validate_class(thr, clazz, false); \
1258 ) \
1259 va_start(args,methodID); \
1260 ReturnType result = UNCHECKED()->CallStatic##Result##MethodV(env, \
1261 clazz, \
1262 methodID, \
1263 args); \
1264 va_end(args); \
1265 thr->set_pending_jni_exception_check("CallStatic"#Result"Method"); \
1266 functionExit(thr); \
1267 return result; \
1268 JNI_END \
1269 \
1270 JNI_ENTRY_CHECKED(ReturnType, \
1271 checked_jni_CallStatic##Result##MethodV(JNIEnv *env, \
1272 jclass clazz, \
1273 jmethodID methodID,\
1274 va_list args)) \
1275 functionEnter(thr); \
1276 IN_VM( \
1277 jniCheck::validate_jmethod_id(thr, methodID); \
1278 jniCheck::validate_class(thr, clazz, false); \
1279 ) \
1280 ReturnType result = UNCHECKED()->CallStatic##Result##MethodV(env, \
1281 clazz, \
1282 methodID, \
1283 args); \
1284 thr->set_pending_jni_exception_check("CallStatic"#Result"MethodV"); \
1285 functionExit(thr); \
1286 return result; \
1287 JNI_END \
1288 \
1289 JNI_ENTRY_CHECKED(ReturnType, \
1290 checked_jni_CallStatic##Result##MethodA(JNIEnv *env, \
1291 jclass clazz, \
1292 jmethodID methodID, \
1293 const jvalue *args)) \
1294 functionEnter(thr); \
1295 IN_VM( \
1296 jniCheck::validate_jmethod_id(thr, methodID); \
1297 jniCheck::validate_class(thr, clazz, false); \
1298 ) \
1299 ReturnType result = UNCHECKED()->CallStatic##Result##MethodA(env, \
1300 clazz, \
1301 methodID, \
1302 args); \
1303 thr->set_pending_jni_exception_check("CallStatic"#Result"MethodA"); \
1304 functionExit(thr); \
1305 return result; \
1306 JNI_END
1307
1308 WRAPPER_CallStaticMethod(jobject,Object)
1309 WRAPPER_CallStaticMethod(jboolean,Boolean)
1310 WRAPPER_CallStaticMethod(jbyte,Byte)
1311 WRAPPER_CallStaticMethod(jshort,Short)
1312 WRAPPER_CallStaticMethod(jchar,Char)
1313 WRAPPER_CallStaticMethod(jint,Int)
1314 WRAPPER_CallStaticMethod(jlong,Long)
1315 WRAPPER_CallStaticMethod(jfloat,Float)
1316 WRAPPER_CallStaticMethod(jdouble,Double)
1317
1318 JNI_ENTRY_CHECKED(void,
1319 checked_jni_CallStaticVoidMethod(JNIEnv *env,
1320 jclass cls,
1321 jmethodID methodID,
1322 ...))
1323 functionEnter(thr);
1324 va_list args;
1325 IN_VM(
1326 jniCheck::validate_jmethod_id(thr, methodID);
1327 jniCheck::validate_class(thr, cls, false);
1328 )
1329 va_start(args,methodID);
1330 UNCHECKED()->CallStaticVoidMethodV(env,cls,methodID,args);
1331 va_end(args);
1332 thr->set_pending_jni_exception_check("CallStaticVoidMethod");
1333 functionExit(thr);
1334 JNI_END
1335
1336 JNI_ENTRY_CHECKED(void,
1337 checked_jni_CallStaticVoidMethodV(JNIEnv *env,
1338 jclass cls,
1339 jmethodID methodID,
1340 va_list args))
1341 functionEnter(thr);
1342 IN_VM(
1343 jniCheck::validate_jmethod_id(thr, methodID);
1344 jniCheck::validate_class(thr, cls, false);
1345 )
1346 UNCHECKED()->CallStaticVoidMethodV(env,cls,methodID,args);
1347 thr->set_pending_jni_exception_check("CallStaticVoidMethodV");
1348 functionExit(thr);
1349 JNI_END
1350
1351 JNI_ENTRY_CHECKED(void,
1352 checked_jni_CallStaticVoidMethodA(JNIEnv *env,
1353 jclass cls,
1354 jmethodID methodID,
1355 const jvalue * args))
1356 functionEnter(thr);
1357 IN_VM(
1358 jniCheck::validate_jmethod_id(thr, methodID);
1359 jniCheck::validate_class(thr, cls, false);
1360 )
1361 UNCHECKED()->CallStaticVoidMethodA(env,cls,methodID,args);
1362 thr->set_pending_jni_exception_check("CallStaticVoidMethodA");
1363 functionExit(thr);
1364 JNI_END
1365
1366 JNI_ENTRY_CHECKED(jfieldID,
1367 checked_jni_GetStaticFieldID(JNIEnv *env,
1368 jclass clazz,
1369 const char *name,
1370 const char *sig))
1371 functionEnter(thr);
1372 IN_VM(
1373 jniCheck::validate_class(thr, clazz, false);
1374 )
1375 jfieldID result = UNCHECKED()->GetStaticFieldID(env,clazz,name,sig);
1376 functionExit(thr);
1377 return result;
1378 JNI_END
1379
|
431 NativeReportJNIFatalError(thr, "Unrecognized array release mode");
432 }
433 // We always need to release the copy we made with GuardedMemory
434 GuardedMemory::free_copy(carray);
435 return orig_result;
436 }
437
438 oop jniCheck::validate_handle(JavaThread* thr, jobject obj) {
439 if ((obj != NULL) && (JNIHandles::handle_type(thr, obj) != JNIInvalidRefType)) {
440 ASSERT_OOPS_ALLOWED;
441 return JNIHandles::resolve_external_guard(obj);
442 }
443 ReportJNIFatalError(thr, fatal_bad_ref_to_jni);
444 return NULL;
445 }
446
447
448 Method* jniCheck::validate_jmethod_id(JavaThread* thr, jmethodID method_id) {
449 ASSERT_OOPS_ALLOWED;
450 // do the fast jmethodID check first
451 Method* m = Method::checked_resolve_jmethod_id(method_id);
452 if (m == NULL) {
453 ReportJNIFatalError(thr, fatal_wrong_class_or_method);
454 }
455 // jmethodIDs are handles in the class loader data,
456 // but that can be expensive so check it last
457 else if (!Method::is_method_id(method_id)) {
458 ReportJNIFatalError(thr, fatal_non_weak_method);
459 }
460 return m;
461 }
462
463
464 oop jniCheck::validate_object(JavaThread* thr, jobject obj) {
465 if (obj == NULL) return NULL;
466 ASSERT_OOPS_ALLOWED;
467 oop oopObj = jniCheck::validate_handle(thr, obj);
468 if (oopObj == NULL) {
469 ReportJNIFatalError(thr, fatal_bad_ref_to_jni);
470 }
471 return oopObj;
472 }
473
474 // Warn if a class descriptor is in decorated form; class descriptors
475 // passed to JNI findClass should not be decorated unless they are
476 // array descriptors.
477 void jniCheck::validate_class_descriptor(JavaThread* thr, const char* name) {
478 if (name == NULL) return; // implementation accepts NULL so just return
479
480 size_t len = strlen(name);
501 }
502
503 Klass* k = java_lang_Class::as_Klass(mirror);
504 // Make allowances for primitive classes ...
505 if (!(k != NULL || (allow_primitive && java_lang_Class::is_primitive(mirror)))) {
506 ReportJNIFatalError(thr, fatal_class_not_a_class);
507 }
508 return k;
509 }
510
511 void jniCheck::validate_throwable_klass(JavaThread* thr, Klass* klass) {
512 ASSERT_OOPS_ALLOWED;
513 assert(klass != NULL, "klass argument must have a value");
514
515 if (!klass->is_instance_klass() ||
516 !InstanceKlass::cast(klass)->is_subclass_of(SystemDictionary::Throwable_klass())) {
517 ReportJNIFatalError(thr, fatal_class_not_a_throwable_class);
518 }
519 }
520
521 void jniCheck::validate_call(JavaThread* thr, jclass clazz, jmethodID method_id, jobject obj) {
522 ASSERT_OOPS_ALLOWED;
523 Method* m = jniCheck::validate_jmethod_id(thr, method_id);
524 InstanceKlass* holder = m->method_holder();
525
526 if (clazz != NULL) {
527 Klass* k = jniCheck::validate_class(thr, clazz, false);
528 // Check that method is in the class, must be InstanceKlass
529 if (!InstanceKlass::cast(k)->is_subtype_of(holder)) {
530 ReportJNIFatalError(thr, fatal_wrong_class_or_method);
531 }
532 }
533
534 if (obj != NULL) {
535 oop recv = jniCheck::validate_object(thr, obj);
536 assert(recv != NULL, "validate_object checks that");
537 Klass* ik = recv->klass();
538
539 // Check that the object is a subtype of method holder too.
540 if (!InstanceKlass::cast(ik)->is_subtype_of(holder)) {
541 ReportJNIFatalError(thr, fatal_wrong_class_or_method);
542 }
543 }
544 }
545
546
547 /*
548 * IMPLEMENTATION OF FUNCTIONS IN CHECKED TABLE
549 */
550
551 JNI_ENTRY_CHECKED(jclass,
552 checked_jni_DefineClass(JNIEnv *env,
553 const char *name,
554 jobject loader,
555 const jbyte *buf,
556 jsize len))
557 functionEnter(thr);
558 IN_VM(
559 jniCheck::validate_object(thr, loader);
560 )
561 jclass result = UNCHECKED()->DefineClass(env, name, loader, buf, len);
562 functionExit(thr);
563 return result;
589
590 JNI_ENTRY_CHECKED(jfieldID,
591 checked_jni_FromReflectedField(JNIEnv *env,
592 jobject field))
593 functionEnter(thr);
594 IN_VM(
595 jniCheck::validate_object(thr, field);
596 )
597 jfieldID result = UNCHECKED()->FromReflectedField(env, field);
598 functionExit(thr);
599 return result;
600 JNI_END
601
602 JNI_ENTRY_CHECKED(jobject,
603 checked_jni_ToReflectedMethod(JNIEnv *env,
604 jclass cls,
605 jmethodID methodID,
606 jboolean isStatic))
607 functionEnter(thr);
608 IN_VM(
609 jniCheck::validate_call(thr, cls, methodID);
610 )
611 jobject result = UNCHECKED()->ToReflectedMethod(env, cls, methodID,
612 isStatic);
613 functionExit(thr);
614 return result;
615 JNI_END
616
617 JNI_ENTRY_CHECKED(jclass,
618 checked_jni_GetSuperclass(JNIEnv *env,
619 jclass sub))
620 functionEnter(thr);
621 IN_VM(
622 jniCheck::validate_class(thr, sub, true);
623 )
624 jclass result = UNCHECKED()->GetSuperclass(env, sub);
625 functionExit(thr);
626 return result;
627 JNI_END
628
629 JNI_ENTRY_CHECKED(jboolean,
845 JNI_ENTRY_CHECKED(jobject,
846 checked_jni_AllocObject(JNIEnv *env,
847 jclass clazz))
848 functionEnter(thr);
849 IN_VM(
850 jniCheck::validate_class(thr, clazz, false);
851 )
852 jobject result = UNCHECKED()->AllocObject(env,clazz);
853 functionExit(thr);
854 return result;
855 JNI_END
856
857 JNI_ENTRY_CHECKED(jobject,
858 checked_jni_NewObject(JNIEnv *env,
859 jclass clazz,
860 jmethodID methodID,
861 ...))
862 functionEnter(thr);
863 va_list args;
864 IN_VM(
865 jniCheck::validate_call(thr, clazz, methodID);
866 )
867 va_start(args, methodID);
868 jobject result = UNCHECKED()->NewObjectV(env,clazz,methodID,args);
869 va_end(args);
870 functionExit(thr);
871 return result;
872 JNI_END
873
874 JNI_ENTRY_CHECKED(jobject,
875 checked_jni_NewObjectV(JNIEnv *env,
876 jclass clazz,
877 jmethodID methodID,
878 va_list args))
879 functionEnter(thr);
880 IN_VM(
881 jniCheck::validate_call(thr, clazz, methodID);
882 )
883 jobject result = UNCHECKED()->NewObjectV(env,clazz,methodID,args);
884 functionExit(thr);
885 return result;
886 JNI_END
887
888 JNI_ENTRY_CHECKED(jobject,
889 checked_jni_NewObjectA(JNIEnv *env,
890 jclass clazz,
891 jmethodID methodID,
892 const jvalue *args))
893 functionEnter(thr);
894 IN_VM(
895 jniCheck::validate_call(thr, clazz, methodID);
896 )
897 jobject result = UNCHECKED()->NewObjectA(env,clazz,methodID,args);
898 functionExit(thr);
899 return result;
900 JNI_END
901
902 JNI_ENTRY_CHECKED(jclass,
903 checked_jni_GetObjectClass(JNIEnv *env,
904 jobject obj))
905 functionEnter(thr);
906 IN_VM(
907 jniCheck::validate_object(thr, obj);
908 )
909 jclass result = UNCHECKED()->GetObjectClass(env,obj);
910 functionExit(thr);
911 return result;
912 JNI_END
913
914 JNI_ENTRY_CHECKED(jboolean,
915 checked_jni_IsInstanceOf(JNIEnv *env,
931 const char *name,
932 const char *sig))
933 functionEnter(thr);
934 IN_VM(
935 jniCheck::validate_class(thr, clazz, false);
936 )
937 jmethodID result = UNCHECKED()->GetMethodID(env,clazz,name,sig);
938 functionExit(thr);
939 return result;
940 JNI_END
941
942 #define WRAPPER_CallMethod(ResultType, Result) \
943 JNI_ENTRY_CHECKED(ResultType, \
944 checked_jni_Call##Result##Method(JNIEnv *env, \
945 jobject obj, \
946 jmethodID methodID, \
947 ...)) \
948 functionEnter(thr); \
949 va_list args; \
950 IN_VM( \
951 jniCheck::validate_call(thr, NULL, methodID, obj); \
952 ) \
953 va_start(args,methodID); \
954 ResultType result =UNCHECKED()->Call##Result##MethodV(env, obj, methodID, \
955 args); \
956 va_end(args); \
957 thr->set_pending_jni_exception_check("Call"#Result"Method"); \
958 functionExit(thr); \
959 return result; \
960 JNI_END \
961 \
962 JNI_ENTRY_CHECKED(ResultType, \
963 checked_jni_Call##Result##MethodV(JNIEnv *env, \
964 jobject obj, \
965 jmethodID methodID, \
966 va_list args)) \
967 functionEnter(thr); \
968 IN_VM(\
969 jniCheck::validate_call(thr, NULL, methodID, obj); \
970 ) \
971 ResultType result = UNCHECKED()->Call##Result##MethodV(env, obj, methodID,\
972 args); \
973 thr->set_pending_jni_exception_check("Call"#Result"MethodV"); \
974 functionExit(thr); \
975 return result; \
976 JNI_END \
977 \
978 JNI_ENTRY_CHECKED(ResultType, \
979 checked_jni_Call##Result##MethodA(JNIEnv *env, \
980 jobject obj, \
981 jmethodID methodID, \
982 const jvalue * args)) \
983 functionEnter(thr); \
984 IN_VM( \
985 jniCheck::validate_call(thr, NULL, methodID, obj); \
986 ) \
987 ResultType result = UNCHECKED()->Call##Result##MethodA(env, obj, methodID,\
988 args); \
989 thr->set_pending_jni_exception_check("Call"#Result"MethodA"); \
990 functionExit(thr); \
991 return result; \
992 JNI_END
993
994 WRAPPER_CallMethod(jobject,Object)
995 WRAPPER_CallMethod(jboolean,Boolean)
996 WRAPPER_CallMethod(jbyte,Byte)
997 WRAPPER_CallMethod(jshort,Short)
998 WRAPPER_CallMethod(jchar,Char)
999 WRAPPER_CallMethod(jint,Int)
1000 WRAPPER_CallMethod(jlong,Long)
1001 WRAPPER_CallMethod(jfloat,Float)
1002 WRAPPER_CallMethod(jdouble,Double)
1003
1004 JNI_ENTRY_CHECKED(void,
1005 checked_jni_CallVoidMethod(JNIEnv *env, \
1006 jobject obj, \
1007 jmethodID methodID, \
1008 ...))
1009 functionEnter(thr);
1010 va_list args;
1011 IN_VM(
1012 jniCheck::validate_call(thr, NULL, methodID, obj);
1013 )
1014 va_start(args,methodID);
1015 UNCHECKED()->CallVoidMethodV(env,obj,methodID,args);
1016 va_end(args);
1017 thr->set_pending_jni_exception_check("CallVoidMethod");
1018 functionExit(thr);
1019 JNI_END
1020
1021 JNI_ENTRY_CHECKED(void,
1022 checked_jni_CallVoidMethodV(JNIEnv *env,
1023 jobject obj,
1024 jmethodID methodID,
1025 va_list args))
1026 functionEnter(thr);
1027 IN_VM(
1028 jniCheck::validate_call(thr, NULL, methodID, obj);
1029 )
1030 UNCHECKED()->CallVoidMethodV(env,obj,methodID,args);
1031 thr->set_pending_jni_exception_check("CallVoidMethodV");
1032 functionExit(thr);
1033 JNI_END
1034
1035 JNI_ENTRY_CHECKED(void,
1036 checked_jni_CallVoidMethodA(JNIEnv *env,
1037 jobject obj,
1038 jmethodID methodID,
1039 const jvalue * args))
1040 functionEnter(thr);
1041 IN_VM(
1042 jniCheck::validate_call(thr, NULL, methodID, obj);
1043 )
1044 UNCHECKED()->CallVoidMethodA(env,obj,methodID,args);
1045 thr->set_pending_jni_exception_check("CallVoidMethodA");
1046 functionExit(thr);
1047 JNI_END
1048
1049 #define WRAPPER_CallNonvirtualMethod(ResultType, Result) \
1050 JNI_ENTRY_CHECKED(ResultType, \
1051 checked_jni_CallNonvirtual##Result##Method(JNIEnv *env, \
1052 jobject obj, \
1053 jclass clazz, \
1054 jmethodID methodID, \
1055 ...)) \
1056 functionEnter(thr); \
1057 va_list args; \
1058 IN_VM( \
1059 jniCheck::validate_call(thr, clazz, methodID, obj); \
1060 ) \
1061 va_start(args,methodID); \
1062 ResultType result = UNCHECKED()->CallNonvirtual##Result##MethodV(env, \
1063 obj, \
1064 clazz, \
1065 methodID,\
1066 args); \
1067 va_end(args); \
1068 thr->set_pending_jni_exception_check("CallNonvirtual"#Result"Method"); \
1069 functionExit(thr); \
1070 return result; \
1071 JNI_END \
1072 \
1073 JNI_ENTRY_CHECKED(ResultType, \
1074 checked_jni_CallNonvirtual##Result##MethodV(JNIEnv *env, \
1075 jobject obj, \
1076 jclass clazz, \
1077 jmethodID methodID, \
1078 va_list args)) \
1079 functionEnter(thr); \
1080 IN_VM( \
1081 jniCheck::validate_call(thr, clazz, methodID, obj); \
1082 ) \
1083 ResultType result = UNCHECKED()->CallNonvirtual##Result##MethodV(env, \
1084 obj, \
1085 clazz, \
1086 methodID,\
1087 args); \
1088 thr->set_pending_jni_exception_check("CallNonvirtual"#Result"MethodV"); \
1089 functionExit(thr); \
1090 return result; \
1091 JNI_END \
1092 \
1093 JNI_ENTRY_CHECKED(ResultType, \
1094 checked_jni_CallNonvirtual##Result##MethodA(JNIEnv *env, \
1095 jobject obj, \
1096 jclass clazz, \
1097 jmethodID methodID, \
1098 const jvalue * args)) \
1099 functionEnter(thr); \
1100 IN_VM( \
1101 jniCheck::validate_call(thr, clazz, methodID, obj); \
1102 ) \
1103 ResultType result = UNCHECKED()->CallNonvirtual##Result##MethodA(env, \
1104 obj, \
1105 clazz, \
1106 methodID,\
1107 args); \
1108 thr->set_pending_jni_exception_check("CallNonvirtual"#Result"MethodA"); \
1109 functionExit(thr); \
1110 return result; \
1111 JNI_END
1112
1113 WRAPPER_CallNonvirtualMethod(jobject,Object)
1114 WRAPPER_CallNonvirtualMethod(jboolean,Boolean)
1115 WRAPPER_CallNonvirtualMethod(jbyte,Byte)
1116 WRAPPER_CallNonvirtualMethod(jshort,Short)
1117 WRAPPER_CallNonvirtualMethod(jchar,Char)
1118 WRAPPER_CallNonvirtualMethod(jint,Int)
1119 WRAPPER_CallNonvirtualMethod(jlong,Long)
1120 WRAPPER_CallNonvirtualMethod(jfloat,Float)
1121 WRAPPER_CallNonvirtualMethod(jdouble,Double)
1122
1123 JNI_ENTRY_CHECKED(void,
1124 checked_jni_CallNonvirtualVoidMethod(JNIEnv *env,
1125 jobject obj,
1126 jclass clazz,
1127 jmethodID methodID,
1128 ...))
1129 functionEnter(thr);
1130 va_list args;
1131 IN_VM(
1132 jniCheck::validate_call(thr, clazz, methodID, obj);
1133 )
1134 va_start(args,methodID);
1135 UNCHECKED()->CallNonvirtualVoidMethodV(env,obj,clazz,methodID,args);
1136 va_end(args);
1137 thr->set_pending_jni_exception_check("CallNonvirtualVoidMethod");
1138 functionExit(thr);
1139 JNI_END
1140
1141 JNI_ENTRY_CHECKED(void,
1142 checked_jni_CallNonvirtualVoidMethodV(JNIEnv *env,
1143 jobject obj,
1144 jclass clazz,
1145 jmethodID methodID,
1146 va_list args))
1147 functionEnter(thr);
1148 IN_VM(
1149 jniCheck::validate_call(thr, clazz, methodID, obj);
1150 )
1151 UNCHECKED()->CallNonvirtualVoidMethodV(env,obj,clazz,methodID,args);
1152 thr->set_pending_jni_exception_check("CallNonvirtualVoidMethodV");
1153 functionExit(thr);
1154 JNI_END
1155
1156 JNI_ENTRY_CHECKED(void,
1157 checked_jni_CallNonvirtualVoidMethodA(JNIEnv *env,
1158 jobject obj,
1159 jclass clazz,
1160 jmethodID methodID,
1161 const jvalue * args))
1162 functionEnter(thr);
1163 IN_VM(
1164 jniCheck::validate_call(thr, clazz, methodID, obj);
1165 )
1166 UNCHECKED()->CallNonvirtualVoidMethodA(env,obj,clazz,methodID,args);
1167 thr->set_pending_jni_exception_check("CallNonvirtualVoidMethodA");
1168 functionExit(thr);
1169 JNI_END
1170
1171 JNI_ENTRY_CHECKED(jfieldID,
1172 checked_jni_GetFieldID(JNIEnv *env,
1173 jclass clazz,
1174 const char *name,
1175 const char *sig))
1176 functionEnter(thr);
1177 IN_VM(
1178 jniCheck::validate_class(thr, clazz, false);
1179 )
1180 jfieldID result = UNCHECKED()->GetFieldID(env,clazz,name,sig);
1181 functionExit(thr);
1182 return result;
1183 JNI_END
1184
1237 const char *name,
1238 const char *sig))
1239 functionEnter(thr);
1240 IN_VM(
1241 jniCheck::validate_class(thr, clazz, false);
1242 )
1243 jmethodID result = UNCHECKED()->GetStaticMethodID(env,clazz,name,sig);
1244 functionExit(thr);
1245 return result;
1246 JNI_END
1247
1248 #define WRAPPER_CallStaticMethod(ReturnType,Result) \
1249 JNI_ENTRY_CHECKED(ReturnType, \
1250 checked_jni_CallStatic##Result##Method(JNIEnv *env, \
1251 jclass clazz, \
1252 jmethodID methodID, \
1253 ...)) \
1254 functionEnter(thr); \
1255 va_list args; \
1256 IN_VM( \
1257 jniCheck::validate_call(thr, clazz, methodID); \
1258 ) \
1259 va_start(args,methodID); \
1260 ReturnType result = UNCHECKED()->CallStatic##Result##MethodV(env, \
1261 clazz, \
1262 methodID, \
1263 args); \
1264 va_end(args); \
1265 thr->set_pending_jni_exception_check("CallStatic"#Result"Method"); \
1266 functionExit(thr); \
1267 return result; \
1268 JNI_END \
1269 \
1270 JNI_ENTRY_CHECKED(ReturnType, \
1271 checked_jni_CallStatic##Result##MethodV(JNIEnv *env, \
1272 jclass clazz, \
1273 jmethodID methodID,\
1274 va_list args)) \
1275 functionEnter(thr); \
1276 IN_VM( \
1277 jniCheck::validate_call(thr, clazz, methodID); \
1278 ) \
1279 ReturnType result = UNCHECKED()->CallStatic##Result##MethodV(env, \
1280 clazz, \
1281 methodID, \
1282 args); \
1283 thr->set_pending_jni_exception_check("CallStatic"#Result"MethodV"); \
1284 functionExit(thr); \
1285 return result; \
1286 JNI_END \
1287 \
1288 JNI_ENTRY_CHECKED(ReturnType, \
1289 checked_jni_CallStatic##Result##MethodA(JNIEnv *env, \
1290 jclass clazz, \
1291 jmethodID methodID, \
1292 const jvalue *args)) \
1293 functionEnter(thr); \
1294 IN_VM( \
1295 jniCheck::validate_call(thr, clazz, methodID); \
1296 ) \
1297 ReturnType result = UNCHECKED()->CallStatic##Result##MethodA(env, \
1298 clazz, \
1299 methodID, \
1300 args); \
1301 thr->set_pending_jni_exception_check("CallStatic"#Result"MethodA"); \
1302 functionExit(thr); \
1303 return result; \
1304 JNI_END
1305
1306 WRAPPER_CallStaticMethod(jobject,Object)
1307 WRAPPER_CallStaticMethod(jboolean,Boolean)
1308 WRAPPER_CallStaticMethod(jbyte,Byte)
1309 WRAPPER_CallStaticMethod(jshort,Short)
1310 WRAPPER_CallStaticMethod(jchar,Char)
1311 WRAPPER_CallStaticMethod(jint,Int)
1312 WRAPPER_CallStaticMethod(jlong,Long)
1313 WRAPPER_CallStaticMethod(jfloat,Float)
1314 WRAPPER_CallStaticMethod(jdouble,Double)
1315
1316 JNI_ENTRY_CHECKED(void,
1317 checked_jni_CallStaticVoidMethod(JNIEnv *env,
1318 jclass cls,
1319 jmethodID methodID,
1320 ...))
1321 functionEnter(thr);
1322 va_list args;
1323 IN_VM(
1324 jniCheck::validate_call(thr, cls, methodID);
1325 )
1326 va_start(args,methodID);
1327 UNCHECKED()->CallStaticVoidMethodV(env,cls,methodID,args);
1328 va_end(args);
1329 thr->set_pending_jni_exception_check("CallStaticVoidMethod");
1330 functionExit(thr);
1331 JNI_END
1332
1333 JNI_ENTRY_CHECKED(void,
1334 checked_jni_CallStaticVoidMethodV(JNIEnv *env,
1335 jclass cls,
1336 jmethodID methodID,
1337 va_list args))
1338 functionEnter(thr);
1339 IN_VM(
1340 jniCheck::validate_call(thr, cls, methodID);
1341 )
1342 UNCHECKED()->CallStaticVoidMethodV(env,cls,methodID,args);
1343 thr->set_pending_jni_exception_check("CallStaticVoidMethodV");
1344 functionExit(thr);
1345 JNI_END
1346
1347 JNI_ENTRY_CHECKED(void,
1348 checked_jni_CallStaticVoidMethodA(JNIEnv *env,
1349 jclass cls,
1350 jmethodID methodID,
1351 const jvalue * args))
1352 functionEnter(thr);
1353 IN_VM(
1354 jniCheck::validate_call(thr, cls, methodID);
1355 )
1356 UNCHECKED()->CallStaticVoidMethodA(env,cls,methodID,args);
1357 thr->set_pending_jni_exception_check("CallStaticVoidMethodA");
1358 functionExit(thr);
1359 JNI_END
1360
1361 JNI_ENTRY_CHECKED(jfieldID,
1362 checked_jni_GetStaticFieldID(JNIEnv *env,
1363 jclass clazz,
1364 const char *name,
1365 const char *sig))
1366 functionEnter(thr);
1367 IN_VM(
1368 jniCheck::validate_class(thr, clazz, false);
1369 )
1370 jfieldID result = UNCHECKED()->GetStaticFieldID(env,clazz,name,sig);
1371 functionExit(thr);
1372 return result;
1373 JNI_END
1374
|