45 #include "memory/resourceArea.hpp"
46 #include "oops/instanceKlass.hpp"
47 #include "oops/klass.inline.hpp"
48 #include "oops/objArrayOop.inline.hpp"
49 #include "oops/oop.inline.hpp"
50 #include "oops/typeArrayOop.inline.hpp"
51 #include "runtime/handles.inline.hpp"
52 #include "runtime/java.hpp"
53 #include "runtime/javaCalls.hpp"
54 #include "runtime/mutexLocker.hpp"
55 #include "utilities/hashtable.inline.hpp"
56 #include "utilities/stringUtils.hpp"
57
58
59 objArrayOop SystemDictionaryShared::_shared_protection_domains = NULL;
60 objArrayOop SystemDictionaryShared::_shared_jar_urls = NULL;
61 objArrayOop SystemDictionaryShared::_shared_jar_manifests = NULL;
62
63 static Mutex* SharedDictionary_lock = NULL;
64
65 void SystemDictionaryShared::initialize(TRAPS) {
66 if (_java_system_loader != NULL) {
67 SharedDictionary_lock = new Mutex(Mutex::leaf, "SharedDictionary_lock", true);
68
69 // These classes need to be initialized before calling get_shared_jar_manifest(), etc.
70 SystemDictionary::ByteArrayInputStream_klass()->initialize(CHECK);
71 SystemDictionary::File_klass()->initialize(CHECK);
72 SystemDictionary::Jar_Manifest_klass()->initialize(CHECK);
73 SystemDictionary::CodeSource_klass()->initialize(CHECK);
74 }
75 }
76
77 oop SystemDictionaryShared::shared_protection_domain(int index) {
78 return _shared_protection_domains->obj_at(index);
79 }
80
81 oop SystemDictionaryShared::shared_jar_url(int index) {
82 return _shared_jar_urls->obj_at(index);
83 }
84
85 oop SystemDictionaryShared::shared_jar_manifest(int index) {
86 return _shared_jar_manifests->obj_at(index);
87 }
88
89
90 Handle SystemDictionaryShared::get_shared_jar_manifest(int shared_path_index, TRAPS) {
91 Handle empty;
92 Handle manifest ;
93 if (shared_jar_manifest(shared_path_index) == NULL) {
94 SharedClassPathEntry* ent = FileMapInfo::shared_path(shared_path_index);
95 long size = ent->manifest_size();
96 if (size <= 0) {
97 return empty; // No manifest - return NULL handle
98 }
99
100 // ByteArrayInputStream bais = new ByteArrayInputStream(buf);
101 InstanceKlass* bais_klass = SystemDictionary::ByteArrayInputStream_klass();
102 Handle bais = bais_klass->allocate_instance_handle(CHECK_(empty));
103 {
104 const char* src = ent->manifest();
105 assert(src != NULL, "No Manifest data");
106 typeArrayOop buf = oopFactory::new_byteArray(size, CHECK_(empty));
107 typeArrayHandle bufhandle(THREAD, buf);
108 char* dst = (char*)(buf->byte_at_addr(0));
109 memcpy(dst, src, (size_t)size);
110
111 JavaValue result(T_VOID);
112 JavaCalls::call_special(&result, bais, bais_klass,
113 vmSymbols::object_initializer_name(),
114 vmSymbols::byte_array_void_signature(),
115 bufhandle, CHECK_(empty));
116 }
117
118 // manifest = new Manifest(bais)
119 InstanceKlass* manifest_klass = SystemDictionary::Jar_Manifest_klass();
120 manifest = manifest_klass->allocate_instance_handle(CHECK_(empty));
121 {
122 JavaValue result(T_VOID);
123 JavaCalls::call_special(&result, manifest, manifest_klass,
124 vmSymbols::object_initializer_name(),
125 vmSymbols::input_stream_void_signature(),
126 bais, CHECK_(empty));
127 }
128 atomic_set_shared_jar_manifest(shared_path_index, manifest());
129 }
130
131 manifest = Handle(THREAD, shared_jar_manifest(shared_path_index));
132 assert(manifest.not_null(), "sanity");
133 return manifest;
134 }
135
136 Handle SystemDictionaryShared::get_shared_jar_url(int shared_path_index, TRAPS) {
137 Handle url_h;
138 if (shared_jar_url(shared_path_index) == NULL) {
139 JavaValue result(T_OBJECT);
157 Handle SystemDictionaryShared::get_package_name(Symbol* class_name, TRAPS) {
158 ResourceMark rm(THREAD);
159 Handle pkgname_string;
160 char* pkgname = (char*) ClassLoader::package_from_name((const char*) class_name->as_C_string());
161 if (pkgname != NULL) { // Package prefix found
162 StringUtils::replace_no_expand(pkgname, "/", ".");
163 pkgname_string = java_lang_String::create_from_str(pkgname,
164 CHECK_(pkgname_string));
165 }
166 return pkgname_string;
167 }
168
169 // Define Package for shared app classes from JAR file and also checks for
170 // package sealing (all done in Java code)
171 // See http://docs.oracle.com/javase/tutorial/deployment/jar/sealman.html
172 void SystemDictionaryShared::define_shared_package(Symbol* class_name,
173 Handle class_loader,
174 Handle manifest,
175 Handle url,
176 TRAPS) {
177 assert(class_loader == _java_system_loader, "unexpected class loader");
178 // get_package_name() returns a NULL handle if the class is in unnamed package
179 Handle pkgname_string = get_package_name(class_name, CHECK);
180 if (pkgname_string.not_null()) {
181 Klass* app_classLoader_klass = SystemDictionary::jdk_internal_loader_ClassLoaders_AppClassLoader_klass();
182 JavaValue result(T_OBJECT);
183 JavaCallArguments args(3);
184 args.set_receiver(class_loader);
185 args.push_oop(pkgname_string);
186 args.push_oop(manifest);
187 args.push_oop(url);
188 JavaCalls::call_virtual(&result, app_classLoader_klass,
189 vmSymbols::defineOrCheckPackage_name(),
190 vmSymbols::defineOrCheckPackage_signature(),
191 &args,
192 CHECK);
193 }
194 }
195
196 // Define Package for shared app/platform classes from named module
197 void SystemDictionaryShared::define_shared_package(Symbol* class_name,
212 classLoader_klass = SystemDictionary::jdk_internal_loader_ClassLoaders_PlatformClassLoader_klass();
213 }
214
215 JavaValue result(T_OBJECT);
216 JavaCallArguments args(2);
217 args.set_receiver(class_loader);
218 args.push_oop(pkg_name);
219 args.push_oop(module_handle);
220 JavaCalls::call_virtual(&result, classLoader_klass,
221 vmSymbols::definePackage_name(),
222 vmSymbols::definePackage_signature(),
223 &args,
224 CHECK);
225 }
226
227 // Get the ProtectionDomain associated with the CodeSource from the classloader.
228 Handle SystemDictionaryShared::get_protection_domain_from_classloader(Handle class_loader,
229 Handle url, TRAPS) {
230 // CodeSource cs = new CodeSource(url, null);
231 InstanceKlass* cs_klass = SystemDictionary::CodeSource_klass();
232 Handle cs = cs_klass->allocate_instance_handle(CHECK_NH);
233 JavaValue void_result(T_VOID);
234 JavaCalls::call_special(&void_result, cs, cs_klass,
235 vmSymbols::object_initializer_name(),
236 vmSymbols::url_code_signer_array_void_signature(),
237 url, Handle(), CHECK_NH);
238
239 // protection_domain = SecureClassLoader.getProtectionDomain(cs);
240 Klass* secureClassLoader_klass = SystemDictionary::SecureClassLoader_klass();
241 JavaValue obj_result(T_OBJECT);
242 JavaCalls::call_virtual(&obj_result, class_loader, secureClassLoader_klass,
243 vmSymbols::getProtectionDomain_name(),
244 vmSymbols::getProtectionDomain_signature(),
245 cs, CHECK_NH);
246 return Handle(THREAD, (oop)obj_result.get_jobject());
247 }
248
249 // Returns the ProtectionDomain associated with the JAR file identified by the url.
250 Handle SystemDictionaryShared::get_shared_protection_domain(Handle class_loader,
251 int shared_path_index,
|
45 #include "memory/resourceArea.hpp"
46 #include "oops/instanceKlass.hpp"
47 #include "oops/klass.inline.hpp"
48 #include "oops/objArrayOop.inline.hpp"
49 #include "oops/oop.inline.hpp"
50 #include "oops/typeArrayOop.inline.hpp"
51 #include "runtime/handles.inline.hpp"
52 #include "runtime/java.hpp"
53 #include "runtime/javaCalls.hpp"
54 #include "runtime/mutexLocker.hpp"
55 #include "utilities/hashtable.inline.hpp"
56 #include "utilities/stringUtils.hpp"
57
58
59 objArrayOop SystemDictionaryShared::_shared_protection_domains = NULL;
60 objArrayOop SystemDictionaryShared::_shared_jar_urls = NULL;
61 objArrayOop SystemDictionaryShared::_shared_jar_manifests = NULL;
62
63 static Mutex* SharedDictionary_lock = NULL;
64
65 void SystemDictionaryShared::initialize_locks() {
66 SharedDictionary_lock = new Mutex(Mutex::leaf, "SharedDictionary_lock", true);
67 }
68
69 oop SystemDictionaryShared::shared_protection_domain(int index) {
70 return _shared_protection_domains->obj_at(index);
71 }
72
73 oop SystemDictionaryShared::shared_jar_url(int index) {
74 return _shared_jar_urls->obj_at(index);
75 }
76
77 oop SystemDictionaryShared::shared_jar_manifest(int index) {
78 return _shared_jar_manifests->obj_at(index);
79 }
80
81
82 Handle SystemDictionaryShared::get_shared_jar_manifest(int shared_path_index, TRAPS) {
83 Handle empty;
84 Handle manifest ;
85 if (shared_jar_manifest(shared_path_index) == NULL) {
86 SharedClassPathEntry* ent = FileMapInfo::shared_path(shared_path_index);
87 long size = ent->manifest_size();
88 if (size <= 0) {
89 return empty; // No manifest - return NULL handle
90 }
91
92 // ByteArrayInputStream bais = new ByteArrayInputStream(buf);
93 InstanceKlass* bais_klass = SystemDictionary::ByteArrayInputStream_klass();
94 bais_klass->initialize(CHECK_NH);
95 Handle bais = bais_klass->allocate_instance_handle(CHECK_(empty));
96 {
97 const char* src = ent->manifest();
98 assert(src != NULL, "No Manifest data");
99 typeArrayOop buf = oopFactory::new_byteArray(size, CHECK_(empty));
100 typeArrayHandle bufhandle(THREAD, buf);
101 char* dst = (char*)(buf->byte_at_addr(0));
102 memcpy(dst, src, (size_t)size);
103
104 JavaValue result(T_VOID);
105 JavaCalls::call_special(&result, bais, bais_klass,
106 vmSymbols::object_initializer_name(),
107 vmSymbols::byte_array_void_signature(),
108 bufhandle, CHECK_(empty));
109 }
110
111 // manifest = new Manifest(bais)
112 InstanceKlass* manifest_klass = SystemDictionary::Jar_Manifest_klass();
113 manifest_klass->initialize(CHECK_NH);
114 manifest = manifest_klass->allocate_instance_handle(CHECK_(empty));
115 {
116 JavaValue result(T_VOID);
117 JavaCalls::call_special(&result, manifest, manifest_klass,
118 vmSymbols::object_initializer_name(),
119 vmSymbols::input_stream_void_signature(),
120 bais, CHECK_(empty));
121 }
122 atomic_set_shared_jar_manifest(shared_path_index, manifest());
123 }
124
125 manifest = Handle(THREAD, shared_jar_manifest(shared_path_index));
126 assert(manifest.not_null(), "sanity");
127 return manifest;
128 }
129
130 Handle SystemDictionaryShared::get_shared_jar_url(int shared_path_index, TRAPS) {
131 Handle url_h;
132 if (shared_jar_url(shared_path_index) == NULL) {
133 JavaValue result(T_OBJECT);
151 Handle SystemDictionaryShared::get_package_name(Symbol* class_name, TRAPS) {
152 ResourceMark rm(THREAD);
153 Handle pkgname_string;
154 char* pkgname = (char*) ClassLoader::package_from_name((const char*) class_name->as_C_string());
155 if (pkgname != NULL) { // Package prefix found
156 StringUtils::replace_no_expand(pkgname, "/", ".");
157 pkgname_string = java_lang_String::create_from_str(pkgname,
158 CHECK_(pkgname_string));
159 }
160 return pkgname_string;
161 }
162
163 // Define Package for shared app classes from JAR file and also checks for
164 // package sealing (all done in Java code)
165 // See http://docs.oracle.com/javase/tutorial/deployment/jar/sealman.html
166 void SystemDictionaryShared::define_shared_package(Symbol* class_name,
167 Handle class_loader,
168 Handle manifest,
169 Handle url,
170 TRAPS) {
171 assert(SystemDictionary::is_system_class_loader(class_loader()), "unexpected class loader");
172 // get_package_name() returns a NULL handle if the class is in unnamed package
173 Handle pkgname_string = get_package_name(class_name, CHECK);
174 if (pkgname_string.not_null()) {
175 Klass* app_classLoader_klass = SystemDictionary::jdk_internal_loader_ClassLoaders_AppClassLoader_klass();
176 JavaValue result(T_OBJECT);
177 JavaCallArguments args(3);
178 args.set_receiver(class_loader);
179 args.push_oop(pkgname_string);
180 args.push_oop(manifest);
181 args.push_oop(url);
182 JavaCalls::call_virtual(&result, app_classLoader_klass,
183 vmSymbols::defineOrCheckPackage_name(),
184 vmSymbols::defineOrCheckPackage_signature(),
185 &args,
186 CHECK);
187 }
188 }
189
190 // Define Package for shared app/platform classes from named module
191 void SystemDictionaryShared::define_shared_package(Symbol* class_name,
206 classLoader_klass = SystemDictionary::jdk_internal_loader_ClassLoaders_PlatformClassLoader_klass();
207 }
208
209 JavaValue result(T_OBJECT);
210 JavaCallArguments args(2);
211 args.set_receiver(class_loader);
212 args.push_oop(pkg_name);
213 args.push_oop(module_handle);
214 JavaCalls::call_virtual(&result, classLoader_klass,
215 vmSymbols::definePackage_name(),
216 vmSymbols::definePackage_signature(),
217 &args,
218 CHECK);
219 }
220
221 // Get the ProtectionDomain associated with the CodeSource from the classloader.
222 Handle SystemDictionaryShared::get_protection_domain_from_classloader(Handle class_loader,
223 Handle url, TRAPS) {
224 // CodeSource cs = new CodeSource(url, null);
225 InstanceKlass* cs_klass = SystemDictionary::CodeSource_klass();
226 cs_klass->initialize(CHECK_NH);
227 Handle cs = cs_klass->allocate_instance_handle(CHECK_NH);
228 JavaValue void_result(T_VOID);
229 JavaCalls::call_special(&void_result, cs, cs_klass,
230 vmSymbols::object_initializer_name(),
231 vmSymbols::url_code_signer_array_void_signature(),
232 url, Handle(), CHECK_NH);
233
234 // protection_domain = SecureClassLoader.getProtectionDomain(cs);
235 Klass* secureClassLoader_klass = SystemDictionary::SecureClassLoader_klass();
236 JavaValue obj_result(T_OBJECT);
237 JavaCalls::call_virtual(&obj_result, class_loader, secureClassLoader_klass,
238 vmSymbols::getProtectionDomain_name(),
239 vmSymbols::getProtectionDomain_signature(),
240 cs, CHECK_NH);
241 return Handle(THREAD, (oop)obj_result.get_jobject());
242 }
243
244 // Returns the ProtectionDomain associated with the JAR file identified by the url.
245 Handle SystemDictionaryShared::get_shared_protection_domain(Handle class_loader,
246 int shared_path_index,
|