295 THROW_MSG(vmSymbols::java_lang_IllegalArgumentException(),
296 "Module name cannot be null");
297 }
298
299 // Special handling of java.base definition
300 if (strcmp(module_name, JAVA_BASE_NAME) == 0) {
301 assert(is_open == JNI_FALSE, "java.base module cannot be open");
302 define_javabase_module(module, version, location, packages, num_packages, CHECK);
303 return;
304 }
305
306 const char* module_version = get_module_version(version);
307
308 oop loader = java_lang_Module::loader(module_handle());
309 // Make sure loader is not the jdk.internal.reflect.DelegatingClassLoader.
310 if (loader != java_lang_ClassLoader::non_reflection_class_loader(loader)) {
311 THROW_MSG(vmSymbols::java_lang_IllegalArgumentException(),
312 "Class loader is an invalid delegating class loader");
313 }
314 Handle h_loader = Handle(THREAD, loader);
315
316 // Check that the list of packages has no duplicates and that the
317 // packages are syntactically ok.
318 GrowableArray<Symbol*>* pkg_list = new GrowableArray<Symbol*>(num_packages);
319 for (int x = 0; x < num_packages; x++) {
320 const char* package_name = packages[x];
321 if (!verify_package_name(package_name)) {
322 THROW_MSG(vmSymbols::java_lang_IllegalArgumentException(),
323 err_msg("Invalid package name: %s for module: %s",
324 package_name, module_name));
325 }
326
327 // Only modules defined to either the boot or platform class loader, can define a "java/" package.
328 if (!h_loader.is_null() &&
329 !SystemDictionary::is_platform_class_loader(h_loader()) &&
330 (strncmp(package_name, JAVAPKG, JAVAPKG_LEN) == 0 &&
331 (package_name[JAVAPKG_LEN] == '/' || package_name[JAVAPKG_LEN] == '\0'))) {
332 const char* class_loader_name = SystemDictionary::loader_name(h_loader());
333 size_t pkg_len = strlen(package_name);
334 char* pkg_name = NEW_RESOURCE_ARRAY_IN_THREAD(THREAD, char, pkg_len);
335 strncpy(pkg_name, package_name, pkg_len);
336 StringUtils::replace_no_expand(pkg_name, "/", ".");
337 const char* msg_text1 = "Class loader (instance of): ";
338 const char* msg_text2 = " tried to define prohibited package name: ";
339 size_t len = strlen(msg_text1) + strlen(class_loader_name) + strlen(msg_text2) + pkg_len + 1;
340 char* message = NEW_RESOURCE_ARRAY_IN_THREAD(THREAD, char, len);
341 jio_snprintf(message, len, "%s%s%s%s", msg_text1, class_loader_name, msg_text2, pkg_name);
342 THROW_MSG(vmSymbols::java_lang_IllegalArgumentException(), message);
343 }
344
345 Symbol* pkg_symbol = SymbolTable::new_symbol(package_name, CHECK);
346 pkg_list->append(pkg_symbol);
347 }
348
349 ModuleEntryTable* module_table = get_module_entry_table(h_loader);
350 assert(module_table != NULL, "module entry table shouldn't be null");
351
352 // Create symbol* entry for module name.
355 bool dupl_modules = false;
356
357 // Create symbol* entry for module version.
358 TempNewSymbol version_symbol;
359 if (module_version != NULL) {
360 version_symbol = SymbolTable::new_symbol(module_version, CHECK);
361 } else {
362 version_symbol = NULL;
363 }
364
365 // Create symbol* entry for module location.
366 const char* module_location = NULL;
367 TempNewSymbol location_symbol = NULL;
368 if (location != NULL) {
369 module_location =
370 java_lang_String::as_utf8_string(JNIHandles::resolve_non_null(location));
371 if (module_location != NULL) {
372 location_symbol = SymbolTable::new_symbol(module_location, CHECK);
373 }
374 }
375
376 ClassLoaderData* loader_data = ClassLoaderData::class_loader_data_or_null(h_loader());
377 assert(loader_data != NULL, "class loader data shouldn't be null");
378
379 PackageEntryTable* package_table = NULL;
380 PackageEntry* existing_pkg = NULL;
381 {
382 MutexLocker ml(Module_lock, THREAD);
383
384 if (num_packages > 0) {
385 package_table = get_package_entry_table(h_loader);
386 assert(package_table != NULL, "Missing package_table");
387
388 // Check that none of the packages exist in the class loader's package table.
389 for (int x = 0; x < pkg_list->length(); x++) {
390 existing_pkg = package_table->lookup_only(pkg_list->at(x));
391 if (existing_pkg != NULL) {
392 // This could be because the module was already defined. If so,
393 // report that error instead of the package error.
394 if (module_table->lookup_only(module_symbol) != NULL) {
395 dupl_modules = true;
396 }
397 break;
|
295 THROW_MSG(vmSymbols::java_lang_IllegalArgumentException(),
296 "Module name cannot be null");
297 }
298
299 // Special handling of java.base definition
300 if (strcmp(module_name, JAVA_BASE_NAME) == 0) {
301 assert(is_open == JNI_FALSE, "java.base module cannot be open");
302 define_javabase_module(module, version, location, packages, num_packages, CHECK);
303 return;
304 }
305
306 const char* module_version = get_module_version(version);
307
308 oop loader = java_lang_Module::loader(module_handle());
309 // Make sure loader is not the jdk.internal.reflect.DelegatingClassLoader.
310 if (loader != java_lang_ClassLoader::non_reflection_class_loader(loader)) {
311 THROW_MSG(vmSymbols::java_lang_IllegalArgumentException(),
312 "Class loader is an invalid delegating class loader");
313 }
314 Handle h_loader = Handle(THREAD, loader);
315 // define_module can be called during start-up, before the class loader's ClassLoaderData
316 // has been created. SystemDictionary::register_loader ensures creation, if needed.
317 ClassLoaderData* loader_data = SystemDictionary::register_loader(h_loader);
318 assert(loader_data != NULL, "class loader data shouldn't be null");
319
320 // Check that the list of packages has no duplicates and that the
321 // packages are syntactically ok.
322 GrowableArray<Symbol*>* pkg_list = new GrowableArray<Symbol*>(num_packages);
323 for (int x = 0; x < num_packages; x++) {
324 const char* package_name = packages[x];
325 if (!verify_package_name(package_name)) {
326 THROW_MSG(vmSymbols::java_lang_IllegalArgumentException(),
327 err_msg("Invalid package name: %s for module: %s",
328 package_name, module_name));
329 }
330
331 // Only modules defined to either the boot or platform class loader, can define a "java/" package.
332 if (!h_loader.is_null() &&
333 !SystemDictionary::is_platform_class_loader(h_loader()) &&
334 (strncmp(package_name, JAVAPKG, JAVAPKG_LEN) == 0 &&
335 (package_name[JAVAPKG_LEN] == '/' || package_name[JAVAPKG_LEN] == '\0'))) {
336 const char* class_loader_name = loader_data->loader_name_and_id();
337 size_t pkg_len = strlen(package_name);
338 char* pkg_name = NEW_RESOURCE_ARRAY_IN_THREAD(THREAD, char, pkg_len);
339 strncpy(pkg_name, package_name, pkg_len);
340 StringUtils::replace_no_expand(pkg_name, "/", ".");
341 const char* msg_text1 = "Class loader (instance of): ";
342 const char* msg_text2 = " tried to define prohibited package name: ";
343 size_t len = strlen(msg_text1) + strlen(class_loader_name) + strlen(msg_text2) + pkg_len + 1;
344 char* message = NEW_RESOURCE_ARRAY_IN_THREAD(THREAD, char, len);
345 jio_snprintf(message, len, "%s%s%s%s", msg_text1, class_loader_name, msg_text2, pkg_name);
346 THROW_MSG(vmSymbols::java_lang_IllegalArgumentException(), message);
347 }
348
349 Symbol* pkg_symbol = SymbolTable::new_symbol(package_name, CHECK);
350 pkg_list->append(pkg_symbol);
351 }
352
353 ModuleEntryTable* module_table = get_module_entry_table(h_loader);
354 assert(module_table != NULL, "module entry table shouldn't be null");
355
356 // Create symbol* entry for module name.
359 bool dupl_modules = false;
360
361 // Create symbol* entry for module version.
362 TempNewSymbol version_symbol;
363 if (module_version != NULL) {
364 version_symbol = SymbolTable::new_symbol(module_version, CHECK);
365 } else {
366 version_symbol = NULL;
367 }
368
369 // Create symbol* entry for module location.
370 const char* module_location = NULL;
371 TempNewSymbol location_symbol = NULL;
372 if (location != NULL) {
373 module_location =
374 java_lang_String::as_utf8_string(JNIHandles::resolve_non_null(location));
375 if (module_location != NULL) {
376 location_symbol = SymbolTable::new_symbol(module_location, CHECK);
377 }
378 }
379
380 PackageEntryTable* package_table = NULL;
381 PackageEntry* existing_pkg = NULL;
382 {
383 MutexLocker ml(Module_lock, THREAD);
384
385 if (num_packages > 0) {
386 package_table = get_package_entry_table(h_loader);
387 assert(package_table != NULL, "Missing package_table");
388
389 // Check that none of the packages exist in the class loader's package table.
390 for (int x = 0; x < pkg_list->length(); x++) {
391 existing_pkg = package_table->lookup_only(pkg_list->at(x));
392 if (existing_pkg != NULL) {
393 // This could be because the module was already defined. If so,
394 // report that error instead of the package error.
395 if (module_table->lookup_only(module_symbol) != NULL) {
396 dupl_modules = true;
397 }
398 break;
|