1 /*
2 * Copyright (c) 2015, 2025, Oracle and/or its affiliates. All rights reserved.
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * This code is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 only, as
7 * published by the Free Software Foundation. Oracle designates this
8 * particular file as subject to the "Classpath" exception as provided
9 * by Oracle in the LICENSE file that accompanied this code.
10 *
11 * This code is distributed in the hope that it will be useful, but WITHOUT
12 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
14 * version 2 for more details (a copy is included in the LICENSE file that
15 * accompanied this code).
16 *
17 * You should have received a copy of the GNU General Public License version
18 * 2 along with this work; if not, write to the Free Software Foundation,
19 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
20 *
21 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
22 * or visit www.oracle.com if you need additional information or have any
23 * questions.
24 */
25 package jdk.internal.loader;
26
27 import java.io.IOException;
28 import java.io.InputStream;
29 import java.lang.module.ModuleReference;
30 import java.net.MalformedURLException;
31 import java.net.URI;
32 import java.net.URL;
33 import java.nio.file.Files;
34 import java.nio.file.Path;
35 import java.util.Arrays;
36 import java.util.Enumeration;
37 import java.util.concurrent.ConcurrentHashMap;
38 import java.util.jar.JarInputStream;
39 import java.util.jar.Manifest;
40 import java.util.stream.Stream;
41
42 import jdk.internal.access.JavaLangAccess;
43 import jdk.internal.access.SharedSecrets;
44 import jdk.internal.module.Modules;
45 import jdk.internal.module.ServicesCatalog;
46 import jdk.internal.util.StaticProperty;
47
48 /**
49 * Find resources and packages in modules defined to the boot class loader or
50 * resources and packages on the "boot class path" specified via -Xbootclasspath/a.
51 */
52
53 public class BootLoader {
54 private BootLoader() { }
55
56 private static final JavaLangAccess JLA = SharedSecrets.getJavaLangAccess();
57
58 // The unnamed module for the boot loader
59 private static final Module UNNAMED_MODULE;
60 private static final String JAVA_HOME = StaticProperty.javaHome();
61
62 static {
63 JavaLangAccess jla = SharedSecrets.getJavaLangAccess();
64 ArchivedClassLoaders archivedClassLoaders = ArchivedClassLoaders.get();
65 if (archivedClassLoaders != null) {
66 UNNAMED_MODULE = archivedClassLoaders.unnamedModuleForBootLoader();
67 } else {
68 UNNAMED_MODULE = jla.defineUnnamedModule(null);
69 }
70 jla.addEnableNativeAccess(UNNAMED_MODULE);
71 setBootLoaderUnnamedModule0(UNNAMED_MODULE);
72 }
73
74 // ClassLoaderValue map for the boot class loader
75 private static final ConcurrentHashMap<?, ?> CLASS_LOADER_VALUE_MAP
76 = new ConcurrentHashMap<>();
77
78 // native libraries loaded by the boot class loader
79 private static final NativeLibraries NATIVE_LIBS
80 = NativeLibraries.newInstance(null);
81
82 /**
83 * Returns the unnamed module for the boot loader.
84 */
85 public static Module getUnnamedModule() {
86 return UNNAMED_MODULE;
87 }
88
89 /**
90 * Returns the ServiceCatalog for modules defined to the boot class loader.
91 */
92 public static ServicesCatalog getServicesCatalog() {
93 return ServicesCatalog.getServicesCatalog(ClassLoaders.bootLoader());
94 }
95
96 /**
97 * Returns the ClassLoaderValue map for the boot class loader.
98 */
99 public static ConcurrentHashMap<?, ?> getClassLoaderValueMap() {
100 return CLASS_LOADER_VALUE_MAP;
101 }
102
103 /**
104 * Returns NativeLibraries for the boot class loader.
105 */
106 public static NativeLibraries getNativeLibraries() {
107 return NATIVE_LIBS;
108 }
109
110 /**
111 * Returns {@code true} if there is a class path associated with the
112 * BootLoader.
113 */
114 public static boolean hasClassPath() {
115 return ClassLoaders.bootLoader().hasClassPath();
116 }
117
118 /**
119 * Registers a module with this class loader so that its classes
120 * (and resources) become visible via this class loader.
121 */
122 public static void loadModule(ModuleReference mref) {
123 ClassLoaders.bootLoader().loadModule(mref);
124 }
125
126 /**
127 * Loads the Class object with the given name defined to the boot loader.
128 */
129 public static Class<?> loadClassOrNull(String name) {
130 return JLA.findBootstrapClassOrNull(name);
131 }
132
133 /**
134 * Loads the Class object with the given name in the given module
135 * defined to the boot loader. Returns {@code null} if not found.
136 */
137 public static Class<?> loadClass(Module module, String name) {
138 Class<?> c = loadClassOrNull(name);
139 if (c != null && c.getModule() == module) {
140 return c;
141 } else {
142 return null;
143 }
144 }
145
146 /**
147 * Loads a native library from the system library path.
148 */
149 public static void loadLibrary(String name) {
150 getNativeLibraries().loadLibrary(name);
151 }
152
153 /**
154 * Returns a URL to a resource in a module defined to the boot loader.
155 */
156 public static URL findResource(String mn, String name) throws IOException {
157 return ClassLoaders.bootLoader().findResource(mn, name);
158 }
159
160 /**
161 * Returns an input stream to a resource in a module defined to the
162 * boot loader.
163 */
164 public static InputStream findResourceAsStream(String mn, String name)
165 throws IOException
166 {
167 return ClassLoaders.bootLoader().findResourceAsStream(mn, name);
168 }
169
170 /**
171 * Returns the URL to the given resource in any of the modules
172 * defined to the boot loader and the boot class path.
173 */
174 public static URL findResource(String name) {
175 return ClassLoaders.bootLoader().findResource(name);
176 }
177
178 /**
179 * Returns an Iterator to iterate over the resources of the given name
180 * in any of the modules defined to the boot loader.
181 */
182 public static Enumeration<URL> findResources(String name) throws IOException {
183 return ClassLoaders.bootLoader().findResources(name);
184 }
185
186 /**
187 * Define a package for the given class to the boot loader, if not already
188 * defined.
189 */
190 public static Package definePackage(Class<?> c) {
191 return getDefinedPackage(c.getPackageName());
192 }
193
194 /**
195 * Returns the Package of the given name defined to the boot loader or null
196 * if the package has not been defined.
197 */
198 public static Package getDefinedPackage(String pn) {
199 Package pkg = ClassLoaders.bootLoader().getDefinedPackage(pn);
200 if (pkg == null) {
201 String location = getSystemPackageLocation(pn.replace('.', '/'));
202 if (location != null) {
203 pkg = PackageHelper.definePackage(pn.intern(), location);
204 }
205 }
206 return pkg;
207 }
208
209 /**
210 * Returns a stream of the packages defined to the boot loader.
211 */
212 public static Stream<Package> packages() {
213 return Arrays.stream(getSystemPackageNames())
214 .map(name -> getDefinedPackage(name.replace('/', '.')));
215 }
216
217 /**
218 * Helper class to define {@code Package} objects for packages in modules
219 * defined to the boot loader.
220 */
221 static class PackageHelper {
222 private static final JavaLangAccess JLA = SharedSecrets.getJavaLangAccess();
223
224 /**
225 * Define the {@code Package} with the given name. The specified
226 * location is a jrt URL to a named module in the run-time image,
227 * a file URL to a module in an exploded run-time image, or a file
228 * path to an entry on the boot class path (java agent Boot-Class-Path
229 * or -Xbootclasspath/a.
230 *
231 * <p> If the given location is a JAR file containing a manifest,
232 * the defined Package contains the versioning information from
233 * the manifest, if present.
234 *
235 * @param name package name
236 * @param location location where the package is (jrt URL or file URL
237 * for a named module in the run-time or exploded image;
238 * a file path for a package from -Xbootclasspath/a)
239 */
240 static Package definePackage(String name, String location) {
241 Module module = findModule(location);
242 if (module != null) {
243 // named module from runtime image or exploded module
244 if (name.isEmpty())
245 throw new InternalError("empty package in " + location);
246 return JLA.definePackage(ClassLoaders.bootLoader(), name, module);
247 }
248
249 // package in unnamed module (-Xbootclasspath/a)
250 URL url = toFileURL(location);
251 Manifest man = url != null ? getManifest(location) : null;
252
253 return ClassLoaders.bootLoader().defineOrCheckPackage(name, man, url);
254 }
255
256 /**
257 * Finds the module at the given location defined to the boot loader.
258 * The module is either in runtime image or exploded image.
259 * Otherwise this method returns null.
260 */
261 private static Module findModule(String location) {
262 String mn = null;
263 if (location.startsWith("jrt:/")) {
264 // named module in runtime image ("jrt:/".length() == 5)
265 mn = location.substring(5, location.length());
266 } else if (location.startsWith("file:/")) {
267 // named module in exploded image
268 Path path = Path.of(URI.create(location));
269 Path modulesDir = Path.of(JAVA_HOME, "modules");
270 if (path.startsWith(modulesDir)) {
271 mn = path.getFileName().toString();
272 }
273 }
274
275 // return the Module object for the module name. The Module may
276 // in the boot layer or a child layer for the case that the module
277 // is loaded into a running VM
278 if (mn != null) {
279 String name = mn;
280 return Modules.findLoadedModule(mn)
281 .orElseThrow(() -> new InternalError(name + " not loaded"));
282 } else {
283 return null;
284 }
285 }
286
287 /**
288 * Returns URL if the given location is a regular file path.
289 */
290 private static URL toFileURL(String location) {
291 Path path = Path.of(location);
292 if (Files.isRegularFile(path)) {
293 try {
294 return path.toUri().toURL();
295 } catch (MalformedURLException e) {}
296 }
297 return null;
298 }
299
300 /**
301 * Returns the Manifest if the given location is a JAR file
302 * containing a manifest.
303 */
304 private static Manifest getManifest(String location) {
305 Path jar = Path.of(location);
306 try (InputStream in = Files.newInputStream(jar);
307 JarInputStream jis = new JarInputStream(in, false)) {
308 return jis.getManifest();
309 } catch (IOException e) {
310 return null;
311 }
312 }
313 }
314
315 /**
316 * Returns an array of the binary name of the packages defined by
317 * the boot loader, in VM internal form (forward slashes instead of dot).
318 */
319 private static native String[] getSystemPackageNames();
320
321 /**
322 * Returns the location of the package of the given name, if
323 * defined by the boot loader; otherwise {@code null} is returned.
324 *
325 * The location may be a module from the runtime image or exploded image,
326 * or from the boot class append path (i.e. -Xbootclasspath/a or
327 * BOOT-CLASS-PATH attribute specified in java agent).
328 */
329 private static native String getSystemPackageLocation(String name);
330 private static native void setBootLoaderUnnamedModule0(Module module);
331 }