2311 }
2312 Symbol* pkg_name = SymbolTable::new_symbol(package_name, THREAD);
2313 return pkg_name;
2314 }
2315 }
2316
2317 ModuleEntry* InstanceKlass::module() const {
2318 if (!in_unnamed_package()) {
2319 return _package_entry->module();
2320 }
2321 const Klass* host = host_klass();
2322 if (host == NULL) {
2323 return class_loader_data()->unnamed_module();
2324 }
2325 return host->class_loader_data()->unnamed_module();
2326 }
2327
2328 void InstanceKlass::set_package(ClassLoaderData* loader_data, TRAPS) {
2329
2330 // ensure java/ packages only loaded by boot or platform builtin loaders
2331 Handle class_loader(THREAD, loader_data->class_loader());
2332 check_prohibited_package(name(), class_loader, CHECK);
2333
2334 TempNewSymbol pkg_name = package_from_name(name(), CHECK);
2335
2336 if (pkg_name != NULL && loader_data != NULL) {
2337
2338 // Find in class loader's package entry table.
2339 _package_entry = loader_data->packages()->lookup_only(pkg_name);
2340
2341 // If the package name is not found in the loader's package
2342 // entry table, it is an indication that the package has not
2343 // been defined. Consider it defined within the unnamed module.
2344 if (_package_entry == NULL) {
2345 ResourceMark rm;
2346
2347 if (!ModuleEntryTable::javabase_defined()) {
2348 // Before java.base is defined during bootstrapping, define all packages in
2349 // the java.base module. If a non-java.base package is erroneously placed
2350 // in the java.base module it will be caught later when java.base
2351 // is defined by ModuleEntryTable::verify_javabase_packages check.
2352 assert(ModuleEntryTable::javabase_moduleEntry() != NULL, JAVA_BASE_NAME " module is NULL");
2454 // Assumes name-signature match
2455 // "this" is InstanceKlass of super_method which must exist
2456 // note that the InstanceKlass of the method in the targetclassname has not always been created yet
2457 bool InstanceKlass::is_override(const methodHandle& super_method, Handle targetclassloader, Symbol* targetclassname, TRAPS) {
2458 // Private methods can not be overridden
2459 if (super_method->is_private()) {
2460 return false;
2461 }
2462 // If super method is accessible, then override
2463 if ((super_method->is_protected()) ||
2464 (super_method->is_public())) {
2465 return true;
2466 }
2467 // Package-private methods are not inherited outside of package
2468 assert(super_method->is_package_private(), "must be package private");
2469 return(is_same_class_package(targetclassloader(), targetclassname));
2470 }
2471
2472 // Only boot and platform class loaders can define classes in "java/" packages.
2473 void InstanceKlass::check_prohibited_package(Symbol* class_name,
2474 Handle class_loader,
2475 TRAPS) {
2476 if (!class_loader.is_null() &&
2477 !SystemDictionary::is_platform_class_loader(class_loader()) &&
2478 class_name != NULL) {
2479 ResourceMark rm(THREAD);
2480 char* name = class_name->as_C_string();
2481 if (strncmp(name, JAVAPKG, JAVAPKG_LEN) == 0 && name[JAVAPKG_LEN] == '/') {
2482 TempNewSymbol pkg_name = InstanceKlass::package_from_name(class_name, CHECK);
2483 assert(pkg_name != NULL, "Error in parsing package name starting with 'java/'");
2484 name = pkg_name->as_C_string();
2485 const char* class_loader_name = SystemDictionary::loader_name(class_loader());
2486 StringUtils::replace_no_expand(name, "/", ".");
2487 const char* msg_text1 = "Class loader (instance of): ";
2488 const char* msg_text2 = " tried to load prohibited package name: ";
2489 size_t len = strlen(msg_text1) + strlen(class_loader_name) + strlen(msg_text2) + strlen(name) + 1;
2490 char* message = NEW_RESOURCE_ARRAY_IN_THREAD(THREAD, char, len);
2491 jio_snprintf(message, len, "%s%s%s%s", msg_text1, class_loader_name, msg_text2, name);
2492 THROW_MSG(vmSymbols::java_lang_SecurityException(), message);
2493 }
2494 }
2495 return;
2496 }
2497
2498 // tell if two classes have the same enclosing class (at package level)
2499 bool InstanceKlass::is_same_package_member(const Klass* class2, TRAPS) const {
2500 if (class2 == this) return true;
2501 if (!class2->is_instance_klass()) return false;
2502
2503 // must be in same package before we try anything else
2504 if (!is_same_class_package(class2))
2505 return false;
|
2311 }
2312 Symbol* pkg_name = SymbolTable::new_symbol(package_name, THREAD);
2313 return pkg_name;
2314 }
2315 }
2316
2317 ModuleEntry* InstanceKlass::module() const {
2318 if (!in_unnamed_package()) {
2319 return _package_entry->module();
2320 }
2321 const Klass* host = host_klass();
2322 if (host == NULL) {
2323 return class_loader_data()->unnamed_module();
2324 }
2325 return host->class_loader_data()->unnamed_module();
2326 }
2327
2328 void InstanceKlass::set_package(ClassLoaderData* loader_data, TRAPS) {
2329
2330 // ensure java/ packages only loaded by boot or platform builtin loaders
2331 check_prohibited_package(name(), loader_data, CHECK);
2332
2333 TempNewSymbol pkg_name = package_from_name(name(), CHECK);
2334
2335 if (pkg_name != NULL && loader_data != NULL) {
2336
2337 // Find in class loader's package entry table.
2338 _package_entry = loader_data->packages()->lookup_only(pkg_name);
2339
2340 // If the package name is not found in the loader's package
2341 // entry table, it is an indication that the package has not
2342 // been defined. Consider it defined within the unnamed module.
2343 if (_package_entry == NULL) {
2344 ResourceMark rm;
2345
2346 if (!ModuleEntryTable::javabase_defined()) {
2347 // Before java.base is defined during bootstrapping, define all packages in
2348 // the java.base module. If a non-java.base package is erroneously placed
2349 // in the java.base module it will be caught later when java.base
2350 // is defined by ModuleEntryTable::verify_javabase_packages check.
2351 assert(ModuleEntryTable::javabase_moduleEntry() != NULL, JAVA_BASE_NAME " module is NULL");
2453 // Assumes name-signature match
2454 // "this" is InstanceKlass of super_method which must exist
2455 // note that the InstanceKlass of the method in the targetclassname has not always been created yet
2456 bool InstanceKlass::is_override(const methodHandle& super_method, Handle targetclassloader, Symbol* targetclassname, TRAPS) {
2457 // Private methods can not be overridden
2458 if (super_method->is_private()) {
2459 return false;
2460 }
2461 // If super method is accessible, then override
2462 if ((super_method->is_protected()) ||
2463 (super_method->is_public())) {
2464 return true;
2465 }
2466 // Package-private methods are not inherited outside of package
2467 assert(super_method->is_package_private(), "must be package private");
2468 return(is_same_class_package(targetclassloader(), targetclassname));
2469 }
2470
2471 // Only boot and platform class loaders can define classes in "java/" packages.
2472 void InstanceKlass::check_prohibited_package(Symbol* class_name,
2473 ClassLoaderData* loader_data,
2474 TRAPS) {
2475 if (!loader_data->is_boot_class_loader_data() &&
2476 !loader_data->is_platform_class_loader_data() &&
2477 class_name != NULL) {
2478 ResourceMark rm(THREAD);
2479 char* name = class_name->as_C_string();
2480 if (strncmp(name, JAVAPKG, JAVAPKG_LEN) == 0 && name[JAVAPKG_LEN] == '/') {
2481 TempNewSymbol pkg_name = InstanceKlass::package_from_name(class_name, CHECK);
2482 assert(pkg_name != NULL, "Error in parsing package name starting with 'java/'");
2483 name = pkg_name->as_C_string();
2484 const char* class_loader_name = loader_data->loader_name();
2485 StringUtils::replace_no_expand(name, "/", ".");
2486 const char* msg_text1 = "Class loader (instance of): ";
2487 const char* msg_text2 = " tried to load prohibited package name: ";
2488 size_t len = strlen(msg_text1) + strlen(class_loader_name) + strlen(msg_text2) + strlen(name) + 1;
2489 char* message = NEW_RESOURCE_ARRAY_IN_THREAD(THREAD, char, len);
2490 jio_snprintf(message, len, "%s%s%s%s", msg_text1, class_loader_name, msg_text2, name);
2491 THROW_MSG(vmSymbols::java_lang_SecurityException(), message);
2492 }
2493 }
2494 return;
2495 }
2496
2497 // tell if two classes have the same enclosing class (at package level)
2498 bool InstanceKlass::is_same_package_member(const Klass* class2, TRAPS) const {
2499 if (class2 == this) return true;
2500 if (!class2->is_instance_klass()) return false;
2501
2502 // must be in same package before we try anything else
2503 if (!is_same_class_package(class2))
2504 return false;
|