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      * Returns a URL to a resource in a module defined to the boot loader.
 133      */
 134     public static URL findResource(String mn, String name) throws IOException {
 135         return ClassLoaders.bootLoader().findResource(mn, name);
 136     }
 137 
 138     /**
 139      * Returns an input stream to a resource in a module defined to the
 140      * boot loader.
 141      */
 142     public static InputStream findResourceAsStream(String mn, String name)
 143         throws IOException
 144     {
 145         return ClassLoaders.bootLoader().findResourceAsStream(mn, name);
 146     }
 147 
 148     /**
 149      * Returns the URL to the given resource in any of the modules
 150      * defined to the boot loader and the boot class path.
 151      */
 152     public static URL findResource(String name) {
 153         return ClassLoaders.bootLoader().findResource(name);
 154     }
 155 
 156     /**
 157      * Returns an Iterator to iterate over the resources of the given name
 158      * in any of the modules defined to the boot loader.
 159      */
 160     public static Enumeration<URL> findResources(String name) throws IOException {
 161         return ClassLoaders.bootLoader().findResources(name);
 162     }
 163 
 164     /**
 165      * Define a package for the given class to the boot loader, if not already
 166      * defined.
 167      */
 168     public static Package definePackage(Class<?> c) {
 169         return getDefinedPackage(c.getPackageName());
 170     }
 171 
 172     /**
 173      * Returns the Package of the given name defined to the boot loader or null
 174      * if the package has not been defined.
 175      */
 176     public static Package getDefinedPackage(String pn) {
 177         Package pkg = ClassLoaders.bootLoader().getDefinedPackage(pn);
 178         if (pkg == null) {
 179             String location = getSystemPackageLocation(pn.replace('.', '/'));
 180             if (location != null) {
 181                 pkg = PackageHelper.definePackage(pn.intern(), location);
 182             }
 183         }
 184         return pkg;
 185     }
 186 
 187     /**
 188      * Returns a stream of the packages defined to the boot loader.
 189      */
 190     public static Stream<Package> packages() {
 191         return Arrays.stream(getSystemPackageNames())
 192                      .map(name -> getDefinedPackage(name.replace('/', '.')));
 193     }
 194 
 195     /**
 196      * Helper class to define {@code Package} objects for packages in modules
 197      * defined to the boot loader.
 198      */
 199     static class PackageHelper {
 200         private static final JavaLangAccess JLA = SharedSecrets.getJavaLangAccess();
 201 
 202         /**
 203          * Define the {@code Package} with the given name. The specified
 204          * location is a jrt URL to a named module in the run-time image,
 205          * a file URL to a module in an exploded run-time image, or a file
 206          * path to an entry on the boot class path (java agent Boot-Class-Path
 207          * or -Xbootclasspath/a.
 208          *
 209          * <p> If the given location is a JAR file containing a manifest,
 210          * the defined Package contains the versioning information from
 211          * the manifest, if present.
 212          *
 213          * @param name     package name
 214          * @param location location where the package is (jrt URL or file URL
 215          *                 for a named module in the run-time or exploded image;
 216          *                 a file path for a package from -Xbootclasspath/a)
 217          */
 218         static Package definePackage(String name, String location) {
 219             Module module = findModule(location);
 220             if (module != null) {
 221                 // named module from runtime image or exploded module
 222                 if (name.isEmpty())
 223                     throw new InternalError("empty package in " + location);
 224                 return JLA.definePackage(ClassLoaders.bootLoader(), name, module);
 225             }
 226 
 227             // package in unnamed module (-Xbootclasspath/a)
 228             URL url = toFileURL(location);
 229             Manifest man = url != null ? getManifest(location) : null;
 230 
 231             return ClassLoaders.bootLoader().defineOrCheckPackage(name, man, url);
 232         }
 233 
 234         /**
 235          * Finds the module at the given location defined to the boot loader.
 236          * The module is either in runtime image or exploded image.
 237          * Otherwise this method returns null.
 238          */
 239         private static Module findModule(String location) {
 240             String mn = null;
 241             if (location.startsWith("jrt:/")) {
 242                 // named module in runtime image ("jrt:/".length() == 5)
 243                 mn = location.substring(5, location.length());
 244             } else if (location.startsWith("file:/")) {
 245                 // named module in exploded image
 246                 Path path = Path.of(URI.create(location));
 247                 Path modulesDir = Path.of(JAVA_HOME, "modules");
 248                 if (path.startsWith(modulesDir)) {
 249                     mn = path.getFileName().toString();
 250                 }
 251             }
 252 
 253             // return the Module object for the module name. The Module may
 254             // in the boot layer or a child layer for the case that the module
 255             // is loaded into a running VM
 256             if (mn != null) {
 257                 String name = mn;
 258                 return Modules.findLoadedModule(mn)
 259                     .orElseThrow(() -> new InternalError(name + " not loaded"));
 260             } else {
 261                 return null;
 262             }
 263         }
 264 
 265         /**
 266          * Returns URL if the given location is a regular file path.
 267          */
 268         private static URL toFileURL(String location) {
 269             return AccessController.doPrivileged(new PrivilegedAction<>() {
 270                 public URL run() {
 271                     Path path = Path.of(location);
 272                     if (Files.isRegularFile(path)) {
 273                         try {
 274                             return path.toUri().toURL();
 275                         } catch (MalformedURLException e) {}
 276                     }
 277                     return null;
 278                 }
 279             });
 280         }
 281 
 282         /**
 283          * Returns the Manifest if the given location is a JAR file
 284          * containing a manifest.
 285          */
 286         private static Manifest getManifest(String location) {
 287             return AccessController.doPrivileged(new PrivilegedAction<>() {
 288                 public Manifest run() {
 289                     Path jar = Path.of(location);
 290                     try (InputStream in = Files.newInputStream(jar);
 291                          JarInputStream jis = new JarInputStream(in, false)) {
 292                         return jis.getManifest();
 293                     } catch (IOException e) {
 294                         return null;
 295                     }
 296                 }
 297             });
 298         }
 299     }
 300 
 301     /**
 302      * Returns an array of the binary name of the packages defined by
 303      * the boot loader, in VM internal form (forward slashes instead of dot).
 304      */
 305     private static native String[] getSystemPackageNames();
 306 
 307     /**
 308      * Returns the location of the package of the given name, if
 309      * defined by the boot loader; otherwise {@code null} is returned.
 310      *
 311      * The location may be a module from the runtime image or exploded image,
 312      * or from the boot class append path (i.e. -Xbootclasspath/a or
 313      * BOOT-CLASS-PATH attribute specified in java agent).
 314      */
 315     private static native String getSystemPackageLocation(String name);
 316     private static native void setBootLoaderUnnamedModule0(Module module);
 317 }
--- EOF ---