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");
2353 _package_entry = loader_data->packages()->lookup(pkg_name, ModuleEntryTable::javabase_moduleEntry());
2354 } else {
2355 assert(loader_data->unnamed_module() != NULL, "unnamed module is NULL");
2356 _package_entry = loader_data->packages()->lookup(pkg_name,
2357 loader_data->unnamed_module());
2358 }
2359
2360 // A package should have been successfully created
2361 assert(_package_entry != NULL, "Package entry for class %s not found, loader %s",
2362 name()->as_C_string(), loader_data->loader_name());
2363 }
2364
2365 if (log_is_enabled(Debug, module)) {
2366 ResourceMark rm;
2367 ModuleEntry* m = _package_entry->module();
2368 log_trace(module)("Setting package: class: %s, package: %s, loader: %s, module: %s",
2369 external_name(),
2370 pkg_name->as_C_string(),
2371 loader_data->loader_name(),
2372 (m->is_named() ? m->name()->as_C_string() : UNNAMED_MODULE));
2373 }
2374 } else {
2375 ResourceMark rm;
2376 log_trace(module)("Setting package: class: %s, package: unnamed, loader: %s, module: %s",
2377 external_name(),
2378 (loader_data != NULL) ? loader_data->loader_name() : "NULL",
2379 UNNAMED_MODULE);
2380 }
2381 }
2382
2383
2384 // different versions of is_same_class_package
2385
2386 bool InstanceKlass::is_same_class_package(const Klass* class2) const {
2387 oop classloader1 = this->class_loader();
2388 PackageEntry* classpkg1 = this->package();
2389 if (class2->is_objArray_klass()) {
2390 class2 = ObjArrayKlass::cast(class2)->bottom_klass();
2391 }
2392
2393 oop classloader2;
2394 PackageEntry* classpkg2;
2395 if (class2->is_instance_klass()) {
2396 classloader2 = class2->class_loader();
2397 classpkg2 = class2->package();
2398 } else {
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");
2352 _package_entry = loader_data->packages()->lookup(pkg_name, ModuleEntryTable::javabase_moduleEntry());
2353 } else {
2354 assert(loader_data->unnamed_module() != NULL, "unnamed module is NULL");
2355 _package_entry = loader_data->packages()->lookup(pkg_name,
2356 loader_data->unnamed_module());
2357 }
2358
2359 // A package should have been successfully created
2360 assert(_package_entry != NULL, "Package entry for class %s not found, loader %s",
2361 name()->as_C_string(), loader_data->loader_name_and_id());
2362 }
2363
2364 if (log_is_enabled(Debug, module)) {
2365 ResourceMark rm;
2366 ModuleEntry* m = _package_entry->module();
2367 log_trace(module)("Setting package: class: %s, package: %s, loader: %s, module: %s",
2368 external_name(),
2369 pkg_name->as_C_string(),
2370 loader_data->loader_name_and_id(),
2371 (m->is_named() ? m->name()->as_C_string() : UNNAMED_MODULE));
2372 }
2373 } else {
2374 ResourceMark rm;
2375 log_trace(module)("Setting package: class: %s, package: unnamed, loader: %s, module: %s",
2376 external_name(),
2377 (loader_data != NULL) ? loader_data->loader_name_and_id() : "NULL",
2378 UNNAMED_MODULE);
2379 }
2380 }
2381
2382
2383 // different versions of is_same_class_package
2384
2385 bool InstanceKlass::is_same_class_package(const Klass* class2) const {
2386 oop classloader1 = this->class_loader();
2387 PackageEntry* classpkg1 = this->package();
2388 if (class2->is_objArray_klass()) {
2389 class2 = ObjArrayKlass::cast(class2)->bottom_klass();
2390 }
2391
2392 oop classloader2;
2393 PackageEntry* classpkg2;
2394 if (class2->is_instance_klass()) {
2395 classloader2 = class2->class_loader();
2396 classpkg2 = class2->package();
2397 } else {
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_and_id();
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;
|