1 /* 2 * Copyright (c) 2015, 2018, 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.security.AccessController; 36 import java.security.PrivilegedAction; 37 import java.util.Arrays; 38 import java.util.Enumeration; 39 import java.util.concurrent.ConcurrentHashMap; 40 import java.util.jar.JarInputStream; 41 import java.util.jar.Manifest; 42 import java.util.stream.Stream; 43 44 import jdk.internal.access.JavaLangAccess; 45 import jdk.internal.access.SharedSecrets; 46 import jdk.internal.module.Modules; 47 import jdk.internal.module.ServicesCatalog; 48 import jdk.internal.util.StaticProperty; 49 50 /** 51 * Find resources and packages in modules defined to the boot class loader or 52 * resources and packages on the "boot class path" specified via -Xbootclasspath/a. 53 */ 54 55 public class BootLoader { 56 private BootLoader() { } 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 UNNAMED_MODULE = SharedSecrets.getJavaLangAccess().defineUnnamedModule(null); 64 setBootLoaderUnnamedModule0(UNNAMED_MODULE); 65 } 66 67 // ServiceCatalog for the boot class loader 68 private static final ServicesCatalog SERVICES_CATALOG = ServicesCatalog.create(); 69 70 // ClassLoaderValue map for the boot class loader 71 private static final ConcurrentHashMap<?, ?> CLASS_LOADER_VALUE_MAP 72 = new ConcurrentHashMap<>(); 73 74 /** 75 * Returns the unnamed module for the boot loader. 76 */ 77 public static Module getUnnamedModule() { 78 return UNNAMED_MODULE; 79 } 80 81 /** 82 * Returns the ServiceCatalog for modules defined to the boot class loader. 83 */ 84 public static ServicesCatalog getServicesCatalog() { 85 return SERVICES_CATALOG; 86 } 87 88 /** 89 * Returns the ClassLoaderValue map for the boot class loader. 90 */ 91 public static ConcurrentHashMap<?, ?> getClassLoaderValueMap() { 92 return CLASS_LOADER_VALUE_MAP; 93 } 94 95 /** 96 * Returns {@code true} if there is a class path associated with the 97 * BootLoader. 98 */ 99 public static boolean hasClassPath() { 100 return ClassLoaders.bootLoader().hasClassPath(); 101 } 102 103 /** 104 * Registers a module with this class loader so that its classes 105 * (and resources) become visible via this class loader. 106 */ 107 public static void loadModule(ModuleReference mref) { 108 ClassLoaders.bootLoader().loadModule(mref); 109 } 110 111 /** 112 * Loads the Class object with the given name defined to the boot loader. 113 */ 114 public static Class<?> loadClassOrNull(String name) { 115 return ClassLoaders.bootLoader().loadClassOrNull(name); 116 } 117 118 /** 119 * Loads the Class object with the given name in the given module 120 * defined to the boot loader. Returns {@code null} if not found. 121 */ 122 public static Class<?> loadClass(Module module, String name) { 123 Class<?> c = loadClassOrNull(name); 124 if (c != null && c.getModule() == module) { 125 return c; 126 } else { 127 return null; 128 } 129 } 130 131 /** 132 * Loads a library from the system path. 133 */ 134 public static void loadLibrary(String library) { 135 if (System.getSecurityManager() == null) { 136 SharedSecrets.getJavaLangAccess().loadLibrary(BootLoader.class, library); 137 } else { 138 AccessController.doPrivileged( 139 new java.security.PrivilegedAction<>() { 140 public Void run() { 141 SharedSecrets.getJavaLangAccess().loadLibrary(BootLoader.class, library); 142 return null; 143 } 144 }); 145 } 146 } 147 148 /** 149 * Returns a URL to a resource in a module defined to the boot loader. 150 */ 151 public static URL findResource(String mn, String name) throws IOException { 152 return ClassLoaders.bootLoader().findResource(mn, name); 153 } 154 155 /** 156 * Returns an input stream to a resource in a module defined to the 157 * boot loader. 158 */ 159 public static InputStream findResourceAsStream(String mn, String name) 160 throws IOException 161 { 162 return ClassLoaders.bootLoader().findResourceAsStream(mn, name); 163 } 164 165 /** 166 * Returns the URL to the given resource in any of the modules 167 * defined to the boot loader and the boot class path. 168 */ 169 public static URL findResource(String name) { 170 return ClassLoaders.bootLoader().findResource(name); 171 } 172 173 /** 174 * Returns an Iterator to iterate over the resources of the given name 175 * in any of the modules defined to the boot loader. 176 */ 177 public static Enumeration<URL> findResources(String name) throws IOException { 178 return ClassLoaders.bootLoader().findResources(name); 179 } 180 181 /** 182 * Define a package for the given class to the boot loader, if not already 183 * defined. 184 */ 185 public static Package definePackage(Class<?> c) { 186 return getDefinedPackage(c.getPackageName()); 187 } 188 189 /** 190 * Returns the Package of the given name defined to the boot loader or null 191 * if the package has not been defined. 192 */ 193 public static Package getDefinedPackage(String pn) { 194 Package pkg = ClassLoaders.bootLoader().getDefinedPackage(pn); 195 if (pkg == null) { 196 String location = getSystemPackageLocation(pn.replace('.', '/')); 197 if (location != null) { 198 pkg = PackageHelper.definePackage(pn.intern(), location); 199 } 200 } 201 return pkg; 202 } 203 204 /** 205 * Returns a stream of the packages defined to the boot loader. 206 */ 207 public static Stream<Package> packages() { 208 return Arrays.stream(getSystemPackageNames()) 209 .map(name -> getDefinedPackage(name.replace('/', '.'))); 210 } 211 212 /** 213 * Helper class to define {@code Package} objects for packages in modules 214 * defined to the boot loader. 215 */ 216 static class PackageHelper { 217 private static final JavaLangAccess JLA = SharedSecrets.getJavaLangAccess(); 218 219 /** 220 * Define the {@code Package} with the given name. The specified 221 * location is a jrt URL to a named module in the run-time image, 222 * a file URL to a module in an exploded run-time image, or a file 223 * path to an entry on the boot class path (java agent Boot-Class-Path 224 * or -Xbootclasspath/a. 225 * 226 * <p> If the given location is a JAR file containing a manifest, 227 * the defined Package contains the versioning information from 228 * the manifest, if present. 229 * 230 * @param name package name 231 * @param location location where the package is (jrt URL or file URL 232 * for a named module in the run-time or exploded image; 233 * a file path for a package from -Xbootclasspath/a) 234 */ 235 static Package definePackage(String name, String location) { 236 Module module = findModule(location); 237 if (module != null) { 238 // named module from runtime image or exploded module 239 if (name.isEmpty()) 240 throw new InternalError("empty package in " + location); 241 return JLA.definePackage(ClassLoaders.bootLoader(), name, module); 242 } 243 244 // package in unnamed module (-Xbootclasspath/a) 245 URL url = toFileURL(location); 246 Manifest man = url != null ? getManifest(location) : null; 247 248 return ClassLoaders.bootLoader().defineOrCheckPackage(name, man, url); 249 } 250 251 /** 252 * Finds the module at the given location defined to the boot loader. 253 * The module is either in runtime image or exploded image. 254 * Otherwise this method returns null. 255 */ 256 private static Module findModule(String location) { 257 String mn = null; 258 if (location.startsWith("jrt:/")) { 259 // named module in runtime image ("jrt:/".length() == 5) 260 mn = location.substring(5, location.length()); 261 } else if (location.startsWith("file:/")) { 262 // named module in exploded image 263 Path path = Path.of(URI.create(location)); 264 Path modulesDir = Path.of(JAVA_HOME, "modules"); 265 if (path.startsWith(modulesDir)) { 266 mn = path.getFileName().toString(); 267 } 268 } 269 270 // return the Module object for the module name. The Module may 271 // in the boot layer or a child layer for the case that the module 272 // is loaded into a running VM 273 if (mn != null) { 274 String name = mn; 275 return Modules.findLoadedModule(mn) 276 .orElseThrow(() -> new InternalError(name + " not loaded")); 277 } else { 278 return null; 279 } 280 } 281 282 /** 283 * Returns URL if the given location is a regular file path. 284 */ 285 private static URL toFileURL(String location) { 286 return AccessController.doPrivileged(new PrivilegedAction<>() { 287 public URL run() { 288 Path path = Path.of(location); 289 if (Files.isRegularFile(path)) { 290 try { 291 return path.toUri().toURL(); 292 } catch (MalformedURLException e) {} 293 } 294 return null; 295 } 296 }); 297 } 298 299 /** 300 * Returns the Manifest if the given location is a JAR file 301 * containing a manifest. 302 */ 303 private static Manifest getManifest(String location) { 304 return AccessController.doPrivileged(new PrivilegedAction<>() { 305 public Manifest run() { 306 Path jar = Path.of(location); 307 try (InputStream in = Files.newInputStream(jar); 308 JarInputStream jis = new JarInputStream(in, false)) { 309 return jis.getManifest(); 310 } catch (IOException e) { 311 return null; 312 } 313 } 314 }); 315 } 316 } 317 318 /** 319 * Returns an array of the binary name of the packages defined by 320 * the boot loader, in VM internal form (forward slashes instead of dot). 321 */ 322 private static native String[] getSystemPackageNames(); 323 324 /** 325 * Returns the location of the package of the given name, if 326 * defined by the boot loader; otherwise {@code null} is returned. 327 * 328 * The location may be a module from the runtime image or exploded image, 329 * or from the boot class append path (i.e. -Xbootclasspath/a or 330 * BOOT-CLASS-PATH attribute specified in java agent). 331 */ 332 private static native String getSystemPackageLocation(String name); 333 private static native void setBootLoaderUnnamedModule0(Module module); 334 }