rev 55686 : 8227587: Add internal privileged System.loadLibrary
Reviewed-by: rriggs, mchung

   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 }
--- EOF ---