2439 if ((super_method->is_protected()) ||
2440 (super_method->is_public())) {
2441 return true;
2442 }
2443 // Package-private methods are not inherited outside of package
2444 assert(super_method->is_package_private(), "must be package private");
2445 return(is_same_class_package(targetclassloader(), targetclassname));
2446 }
2447
2448 /* defined for now in jvm.cpp, for historical reasons *--
2449 Klass* InstanceKlass::compute_enclosing_class_impl(instanceKlassHandle self,
2450 Symbol*& simple_name_result, TRAPS) {
2451 ...
2452 }
2453 */
2454
2455 // Only boot and platform class loaders can define classes in "java/" packages.
2456 void InstanceKlass::check_prohibited_package(Symbol* class_name,
2457 Handle class_loader,
2458 TRAPS) {
2459 ResourceMark rm(THREAD);
2460 if (!class_loader.is_null() &&
2461 !SystemDictionary::is_platform_class_loader(class_loader) &&
2462 class_name != NULL &&
2463 strncmp(class_name->as_C_string(), JAVAPKG, JAVAPKG_LEN) == 0) {
2464 TempNewSymbol pkg_name = InstanceKlass::package_from_name(class_name, CHECK);
2465 assert(pkg_name != NULL, "Error in parsing package name starting with 'java/'");
2466 char* name = pkg_name->as_C_string();
2467 const char* class_loader_name = SystemDictionary::loader_name(class_loader());
2468 StringUtils::replace_no_expand(name, "/", ".");
2469 const char* msg_text1 = "Class loader (instance of): ";
2470 const char* msg_text2 = " tried to load prohibited package name: ";
2471 size_t len = strlen(msg_text1) + strlen(class_loader_name) + strlen(msg_text2) + strlen(name) + 1;
2472 char* message = NEW_RESOURCE_ARRAY_IN_THREAD(THREAD, char, len);
2473 jio_snprintf(message, len, "%s%s%s%s", msg_text1, class_loader_name, msg_text2, name);
2474 THROW_MSG(vmSymbols::java_lang_SecurityException(), message);
2475 }
2476 return;
2477 }
2478
2479 // tell if two classes have the same enclosing class (at package level)
2480 bool InstanceKlass::is_same_package_member_impl(const InstanceKlass* class1,
2481 const Klass* class2,
2482 TRAPS) {
2483 if (class2 == class1) return true;
2484 if (!class2->is_instance_klass()) return false;
2485
2486 // must be in same package before we try anything else
2487 if (!class1->is_same_class_package(class2))
2488 return false;
2489
2490 // As long as there is an outer1.getEnclosingClass,
2491 // shift the search outward.
2492 const InstanceKlass* outer1 = class1;
2493 for (;;) {
2494 // As we walk along, look for equalities between outer1 and class2.
2495 // Eventually, the walks will terminate as outer1 stops
|
2439 if ((super_method->is_protected()) ||
2440 (super_method->is_public())) {
2441 return true;
2442 }
2443 // Package-private methods are not inherited outside of package
2444 assert(super_method->is_package_private(), "must be package private");
2445 return(is_same_class_package(targetclassloader(), targetclassname));
2446 }
2447
2448 /* defined for now in jvm.cpp, for historical reasons *--
2449 Klass* InstanceKlass::compute_enclosing_class_impl(instanceKlassHandle self,
2450 Symbol*& simple_name_result, TRAPS) {
2451 ...
2452 }
2453 */
2454
2455 // Only boot and platform class loaders can define classes in "java/" packages.
2456 void InstanceKlass::check_prohibited_package(Symbol* class_name,
2457 Handle class_loader,
2458 TRAPS) {
2459 if (!class_loader.is_null() &&
2460 !SystemDictionary::is_platform_class_loader(class_loader) &&
2461 class_name != NULL) {
2462 ResourceMark rm(THREAD);
2463 char* name = class_name->as_C_string();
2464 if (strncmp(name, JAVAPKG, JAVAPKG_LEN) == 0 && name[JAVAPKG_LEN] == '/') {
2465 TempNewSymbol pkg_name = InstanceKlass::package_from_name(class_name, CHECK);
2466 assert(pkg_name != NULL, "Error in parsing package name starting with 'java/'");
2467 name = pkg_name->as_C_string();
2468 const char* class_loader_name = SystemDictionary::loader_name(class_loader());
2469 StringUtils::replace_no_expand(name, "/", ".");
2470 const char* msg_text1 = "Class loader (instance of): ";
2471 const char* msg_text2 = " tried to load prohibited package name: ";
2472 size_t len = strlen(msg_text1) + strlen(class_loader_name) + strlen(msg_text2) + strlen(name) + 1;
2473 char* message = NEW_RESOURCE_ARRAY_IN_THREAD(THREAD, char, len);
2474 jio_snprintf(message, len, "%s%s%s%s", msg_text1, class_loader_name, msg_text2, name);
2475 THROW_MSG(vmSymbols::java_lang_SecurityException(), message);
2476 }
2477 }
2478 return;
2479 }
2480
2481 // tell if two classes have the same enclosing class (at package level)
2482 bool InstanceKlass::is_same_package_member_impl(const InstanceKlass* class1,
2483 const Klass* class2,
2484 TRAPS) {
2485 if (class2 == class1) return true;
2486 if (!class2->is_instance_klass()) return false;
2487
2488 // must be in same package before we try anything else
2489 if (!class1->is_same_class_package(class2))
2490 return false;
2491
2492 // As long as there is an outer1.getEnclosingClass,
2493 // shift the search outward.
2494 const InstanceKlass* outer1 = class1;
2495 for (;;) {
2496 // As we walk along, look for equalities between outer1 and class2.
2497 // Eventually, the walks will terminate as outer1 stops
|