1 /*
   2  * Copyright (c) 1997, 2013, 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 
  26 package sun.misc;
  27 
  28 import java.io.ByteArrayInputStream;
  29 import java.io.Closeable;
  30 import java.io.File;
  31 import java.io.FileInputStream;
  32 import java.io.FileNotFoundException;
  33 import java.io.IOException;
  34 import java.io.InputStream;
  35 import java.net.HttpURLConnection;
  36 import java.net.JarURLConnection;
  37 import java.net.MalformedURLException;
  38 import java.net.URL;
  39 import java.net.URLConnection;
  40 import java.net.URLStreamHandler;
  41 import java.net.URLStreamHandlerFactory;
  42 import java.nio.ByteBuffer;
  43 import java.security.AccessControlException;
  44 import java.security.AccessController;
  45 import java.security.CodeSigner;
  46 import java.security.Permission;
  47 import java.security.PrivilegedExceptionAction;
  48 import java.security.cert.Certificate;
  49 import java.util.ArrayList;
  50 import java.util.Collections;
  51 import java.util.Enumeration;
  52 import java.util.HashMap;
  53 import java.util.HashSet;
  54 import java.util.LinkedList;
  55 import java.util.List;
  56 import java.util.NoSuchElementException;
  57 import java.util.Set;
  58 import java.util.Stack;
  59 import java.util.StringTokenizer;
  60 import java.util.concurrent.atomic.AtomicInteger;
  61 import java.util.jar.JarFile;
  62 import java.util.zip.ZipEntry;
  63 import java.util.jar.JarEntry;
  64 import java.util.jar.Manifest;
  65 import java.util.jar.Attributes;
  66 import java.util.jar.Attributes.Name;
  67 
  68 import jdk.internal.jimage.ImageLocation;
  69 import jdk.internal.jimage.ImageReader;
  70 
  71 import sun.net.util.URLUtil;
  72 import sun.net.www.ParseUtil;
  73 import sun.net.www.protocol.jrt.JavaRuntimeURLConnection;
  74 
  75 /**
  76  * This class is used to maintain a search path of URLs for loading classes
  77  * and resources from both JAR files and directories.
  78  *
  79  * @author  David Connelly
  80  */
  81 public class URLClassPath {
  82     private static final String USER_AGENT_JAVA_VERSION = "UA-Java-Version";
  83     private static final String JAVA_HOME;
  84     private static final String JAVA_VERSION;
  85     private static final boolean DEBUG;
  86     private static final boolean DISABLE_JAR_CHECKING;
  87 
  88     static {
  89         JAVA_HOME = java.security.AccessController.doPrivileged(
  90             new sun.security.action.GetPropertyAction("java.home"));
  91         JAVA_VERSION = java.security.AccessController.doPrivileged(
  92             new sun.security.action.GetPropertyAction("java.version"));
  93         DEBUG        = (java.security.AccessController.doPrivileged(
  94             new sun.security.action.GetPropertyAction("sun.misc.URLClassPath.debug")) != null);
  95         String p = java.security.AccessController.doPrivileged(
  96             new sun.security.action.GetPropertyAction("sun.misc.URLClassPath.disableJarChecking"));
  97         DISABLE_JAR_CHECKING = p != null ? p.equals("true") || p.equals("") : false;
  98     }
  99 
 100     /* The original search path of URLs. */
 101     private ArrayList<URL> path = new ArrayList<>();
 102 
 103     /* The stack of unopened URLs */
 104     Stack<URL> urls = new Stack<>();
 105 
 106     /* The resulting search path of Loaders */
 107     ArrayList<Loader> loaders = new ArrayList<>();
 108 
 109     /* Map of each URL opened to its corresponding Loader */
 110     HashMap<String, Loader> lmap = new HashMap<>();
 111 
 112     /* The jar protocol handler to use when creating new URLs */
 113     private URLStreamHandler jarHandler;
 114 
 115     /* Whether this URLClassLoader has been closed yet */
 116     private boolean closed = false;
 117 
 118     /**
 119      * Creates a new URLClassPath for the given URLs. The URLs will be
 120      * searched in the order specified for classes and resources. A URL
 121      * ending with a '/' is assumed to refer to a directory. Otherwise,
 122      * the URL is assumed to refer to a JAR file.
 123      *
 124      * @param urls the directory and JAR file URLs to search for classes
 125      *        and resources
 126      * @param factory the URLStreamHandlerFactory to use when creating new URLs
 127      */
 128     public URLClassPath(URL[] urls, URLStreamHandlerFactory factory) {
 129         for (int i = 0; i < urls.length; i++) {
 130             path.add(urls[i]);
 131         }
 132         push(urls);
 133         if (factory != null) {
 134             jarHandler = factory.createURLStreamHandler("jar");
 135         }
 136     }
 137 
 138     public URLClassPath(URL[] urls) {
 139         this(urls, null);
 140     }
 141 
 142     public synchronized List<IOException> closeLoaders() {
 143         if (closed) {
 144             return Collections.emptyList();
 145         }
 146         List<IOException> result = new LinkedList<>();
 147         for (Loader loader : loaders) {
 148             try {
 149                 loader.close();
 150             } catch (IOException e) {
 151                 result.add (e);
 152             }
 153         }
 154         closed = true;
 155         return result;
 156     }
 157 
 158     /**
 159      * Appends the specified URL to the search path of directory and JAR
 160      * file URLs from which to load classes and resources.
 161      * <p>
 162      * If the URL specified is null or is already in the list of
 163      * URLs, then invoking this method has no effect.
 164      */
 165     public synchronized void addURL(URL url) {
 166         if (closed)
 167             return;
 168         synchronized (urls) {
 169             if (url == null || path.contains(url))
 170                 return;
 171 
 172             urls.add(0, url);
 173             path.add(url);
 174         }
 175     }
 176 
 177     /**
 178      * Returns the original search path of URLs.
 179      */
 180     public URL[] getURLs() {
 181         synchronized (urls) {
 182             return path.toArray(new URL[path.size()]);
 183         }
 184     }
 185 
 186     /**
 187      * Finds the resource with the specified name on the URL search path
 188      * or null if not found or security check fails.
 189      *
 190      * @param name      the name of the resource
 191      * @param check     whether to perform a security check
 192      * @return a <code>URL</code> for the resource, or <code>null</code>
 193      * if the resource could not be found.
 194      */
 195     public URL findResource(String name, boolean check) {
 196         Loader loader;
 197         for (int i = 0; (loader = getLoader(i)) != null; i++) {
 198             URL url = loader.findResource(name, check);
 199             if (url != null) {
 200                 return url;
 201             }
 202         }
 203         return null;
 204     }
 205 
 206     /**
 207      * Finds the first Resource on the URL search path which has the specified
 208      * name. Returns null if no Resource could be found.
 209      *
 210      * @param name the name of the Resource
 211      * @param check     whether to perform a security check
 212      * @return the Resource, or null if not found
 213      */
 214     public Resource getResource(String name, boolean check) {
 215         if (DEBUG) {
 216             System.err.println("URLClassPath.getResource(\"" + name + "\")");
 217         }
 218 
 219         Loader loader;
 220         for (int i = 0; (loader = getLoader(i)) != null; i++) {
 221             Resource res = loader.getResource(name, check);
 222             if (res != null) {
 223                 return res;
 224             }
 225         }
 226         return null;
 227     }
 228 
 229     /**
 230      * Finds all resources on the URL search path with the given name.
 231      * Returns an enumeration of the URL objects.
 232      *
 233      * @param name the resource name
 234      * @return an Enumeration of all the urls having the specified name
 235      */
 236     public Enumeration<URL> findResources(final String name,
 237                                      final boolean check) {
 238         return new Enumeration<>() {
 239             private int index = 0;
 240             private URL url = null;
 241 
 242             private boolean next() {
 243                 if (url != null) {
 244                     return true;
 245                 } else {
 246                     Loader loader;
 247                     while ((loader = getLoader(index++)) != null) {
 248                         url = loader.findResource(name, check);
 249                         if (url != null) {
 250                             return true;
 251                         }
 252                     }
 253                     return false;
 254                 }
 255             }
 256 
 257             public boolean hasMoreElements() {
 258                 return next();
 259             }
 260 
 261             public URL nextElement() {
 262                 if (!next()) {
 263                     throw new NoSuchElementException();
 264                 }
 265                 URL u = url;
 266                 url = null;
 267                 return u;
 268             }
 269         };
 270     }
 271 
 272     public Resource getResource(String name) {
 273         return getResource(name, true);
 274     }
 275 
 276     /**
 277      * Finds all resources on the URL search path with the given name.
 278      * Returns an enumeration of the Resource objects.
 279      *
 280      * @param name the resource name
 281      * @return an Enumeration of all the resources having the specified name
 282      */
 283     public Enumeration<Resource> getResources(final String name,
 284                                     final boolean check) {
 285         return new Enumeration<>() {
 286             private int index = 0;
 287             private Resource res = null;
 288 
 289             private boolean next() {
 290                 if (res != null) {
 291                     return true;
 292                 } else {
 293                     Loader loader;
 294                     while ((loader = getLoader(index++)) != null) {
 295                         res = loader.getResource(name, check);
 296                         if (res != null) {
 297                             return true;
 298                         }
 299                     }
 300                     return false;
 301                 }
 302             }
 303 
 304             public boolean hasMoreElements() {
 305                 return next();
 306             }
 307 
 308             public Resource nextElement() {
 309                 if (!next()) {
 310                     throw new NoSuchElementException();
 311                 }
 312                 Resource r = res;
 313                 res = null;
 314                 return r;
 315             }
 316         };
 317     }
 318 
 319     public Enumeration<Resource> getResources(final String name) {
 320         return getResources(name, true);
 321     }
 322 
 323     /*
 324      * Returns the Loader at the specified position in the URL search
 325      * path. The URLs are opened and expanded as needed. Returns null
 326      * if the specified index is out of range.
 327      */
 328      private synchronized Loader getLoader(int index) {
 329         if (closed) {
 330             return null;
 331         }
 332          // Expand URL search path until the request can be satisfied
 333          // or the URL stack is empty.
 334         while (loaders.size() < index + 1) {
 335             // Pop the next URL from the URL stack
 336             URL url;
 337             synchronized (urls) {
 338                 if (urls.empty()) {
 339                     return null;
 340                 } else {
 341                     url = urls.pop();
 342                 }
 343             }
 344             // Skip this URL if it already has a Loader. (Loader
 345             // may be null in the case where URL has not been opened
 346             // but is referenced by a JAR index.)
 347             String urlNoFragString = URLUtil.urlNoFragString(url);
 348             if (lmap.containsKey(urlNoFragString)) {
 349                 continue;
 350             }
 351             // Otherwise, create a new Loader for the URL.
 352             Loader loader;
 353             try {
 354                 loader = getLoader(url);
 355                 // If the loader defines a local class path then add the
 356                 // URLs to the list of URLs to be opened.
 357                 URL[] urls = loader.getClassPath();
 358                 if (urls != null) {
 359                     push(urls);
 360                 }
 361             } catch (IOException e) {
 362                 // Silently ignore for now...
 363                 continue;
 364             }
 365             // Finally, add the Loader to the search path.
 366             loaders.add(loader);
 367             lmap.put(urlNoFragString, loader);
 368         }
 369         return loaders.get(index);
 370     }
 371 
 372     /*
 373      * Returns the Loader for the specified base URL.
 374      */
 375     private Loader getLoader(final URL url) throws IOException {
 376         try {
 377             return java.security.AccessController.doPrivileged(
 378                 new java.security.PrivilegedExceptionAction<>() {
 379                 public Loader run() throws IOException {
 380                     String file = url.getFile();
 381                     if (file != null && file.endsWith("/")) {
 382                         if ("file".equals(url.getProtocol())) {
 383                             return new FileLoader(url);
 384                         } else {
 385                             return new Loader(url);
 386                         }
 387                     } else {
 388                         if (file != null && "file".equals(url.getProtocol())) {
 389                             if (file.endsWith(".jimage"))
 390                                 return new JImageLoader(url);
 391                         }
 392                         return new JarLoader(url, jarHandler, lmap);
 393                     }
 394                 }
 395             });
 396         } catch (java.security.PrivilegedActionException pae) {
 397             throw (IOException)pae.getException();
 398         }
 399     }
 400 
 401     /*
 402      * Pushes the specified URLs onto the list of unopened URLs.
 403      */
 404     private void push(URL[] us) {
 405         synchronized (urls) {
 406             for (int i = us.length - 1; i >= 0; --i) {
 407                 urls.push(us[i]);
 408             }
 409         }
 410     }
 411 
 412     /**
 413      * Convert class path specification into an array of file URLs.
 414      *
 415      * The path of the file is encoded before conversion into URL
 416      * form so that reserved characters can safely appear in the path.
 417      */
 418     public static URL[] pathToURLs(String path) {
 419         StringTokenizer st = new StringTokenizer(path, File.pathSeparator);
 420         URL[] urls = new URL[st.countTokens()];
 421         int count = 0;
 422         while (st.hasMoreTokens()) {
 423             File f = new File(st.nextToken());
 424             try {
 425                 f = new File(f.getCanonicalPath());
 426             } catch (IOException x) {
 427                 // use the non-canonicalized filename
 428             }
 429             try {
 430                 urls[count++] = ParseUtil.fileToEncodedURL(f);
 431             } catch (IOException x) { }
 432         }
 433 
 434         if (urls.length != count) {
 435             URL[] tmp = new URL[count];
 436             System.arraycopy(urls, 0, tmp, 0, count);
 437             urls = tmp;
 438         }
 439         return urls;
 440     }
 441 
 442     /*
 443      * Check whether the resource URL should be returned.
 444      * Return null on security check failure.
 445      * Called by java.net.URLClassLoader.
 446      */
 447     public URL checkURL(URL url) {
 448         try {
 449             check(url);
 450         } catch (Exception e) {
 451             return null;
 452         }
 453 
 454         return url;
 455     }
 456 
 457     /*
 458      * Check whether the resource URL should be returned.
 459      * Throw exception on failure.
 460      * Called internally within this file.
 461      */
 462     static void check(URL url) throws IOException {
 463         SecurityManager security = System.getSecurityManager();
 464         if (security != null) {
 465             URLConnection urlConnection = url.openConnection();
 466             Permission perm = urlConnection.getPermission();
 467             if (perm != null) {
 468                 try {
 469                     security.checkPermission(perm);
 470                 } catch (SecurityException se) {
 471                     // fallback to checkRead/checkConnect for pre 1.2
 472                     // security managers
 473                     if ((perm instanceof java.io.FilePermission) &&
 474                         perm.getActions().indexOf("read") != -1) {
 475                         security.checkRead(perm.getName());
 476                     } else if ((perm instanceof
 477                         java.net.SocketPermission) &&
 478                         perm.getActions().indexOf("connect") != -1) {
 479                         URL locUrl = url;
 480                         if (urlConnection instanceof JarURLConnection) {
 481                             locUrl = ((JarURLConnection)urlConnection).getJarFileURL();
 482                         }
 483                         security.checkConnect(locUrl.getHost(),
 484                                               locUrl.getPort());
 485                     } else {
 486                         throw se;
 487                     }
 488                 }
 489             }
 490         }
 491     }
 492 
 493     /**
 494      * Inner class used to represent a loader of resources and classes
 495      * from a base URL.
 496      */
 497     private static class Loader implements Closeable {
 498         private final URL base;
 499         private JarFile jarfile; // if this points to a jar file
 500 
 501         /*
 502          * Creates a new Loader for the specified URL.
 503          */
 504         Loader(URL url) {
 505             base = url;
 506         }
 507 
 508         /*
 509          * Returns the base URL for this Loader.
 510          */
 511         URL getBaseURL() {
 512             return base;
 513         }
 514 
 515         URL findResource(final String name, boolean check) {
 516             URL url;
 517             try {
 518                 url = new URL(base, ParseUtil.encodePath(name, false));
 519             } catch (MalformedURLException e) {
 520                 throw new IllegalArgumentException("name");
 521             }
 522 
 523             try {
 524                 if (check) {
 525                     URLClassPath.check(url);
 526                 }
 527 
 528                 /*
 529                  * For a HTTP connection we use the HEAD method to
 530                  * check if the resource exists.
 531                  */
 532                 URLConnection uc = url.openConnection();
 533                 if (uc instanceof HttpURLConnection) {
 534                     HttpURLConnection hconn = (HttpURLConnection)uc;
 535                     hconn.setRequestMethod("HEAD");
 536                     if (hconn.getResponseCode() >= HttpURLConnection.HTTP_BAD_REQUEST) {
 537                         return null;
 538                     }
 539                 } else {
 540                     // our best guess for the other cases
 541                     uc.setUseCaches(false);
 542                     InputStream is = uc.getInputStream();
 543                     is.close();
 544                 }
 545                 return url;
 546             } catch (Exception e) {
 547                 return null;
 548             }
 549         }
 550 
 551         Resource getResource(final String name, boolean check) {
 552             final URL url;
 553             try {
 554                 url = new URL(base, ParseUtil.encodePath(name, false));
 555             } catch (MalformedURLException e) {
 556                 throw new IllegalArgumentException("name");
 557             }
 558             final URLConnection uc;
 559             try {
 560                 if (check) {
 561                     URLClassPath.check(url);
 562                 }
 563                 uc = url.openConnection();
 564                 InputStream in = uc.getInputStream();
 565                 if (uc instanceof JarURLConnection) {
 566                     /* Need to remember the jar file so it can be closed
 567                      * in a hurry.
 568                      */
 569                     JarURLConnection juc = (JarURLConnection)uc;
 570                     jarfile = JarLoader.checkJar(juc.getJarFile());
 571                 }
 572             } catch (Exception e) {
 573                 return null;
 574             }
 575             return new Resource() {
 576                 public String getName() { return name; }
 577                 public URL getURL() { return url; }
 578                 public URL getCodeSourceURL() { return base; }
 579                 public InputStream getInputStream() throws IOException {
 580                     return uc.getInputStream();
 581                 }
 582                 public int getContentLength() throws IOException {
 583                     return uc.getContentLength();
 584                 }
 585             };
 586         }
 587 
 588         /*
 589          * Returns the Resource for the specified name, or null if not
 590          * found or the caller does not have the permission to get the
 591          * resource.
 592          */
 593         Resource getResource(final String name) {
 594             return getResource(name, true);
 595         }
 596 
 597         /*
 598          * close this loader and release all resources
 599          * method overridden in sub-classes
 600          */
 601         public void close () throws IOException {
 602             if (jarfile != null) {
 603                 jarfile.close();
 604             }
 605         }
 606 
 607         /*
 608          * Returns the local class path for this loader, or null if none.
 609          */
 610         URL[] getClassPath() throws IOException {
 611             return null;
 612         }
 613     }
 614 
 615     /*
 616      * Inner class used to represent a Loader of resources from a JAR URL.
 617      */
 618     static class JarLoader extends Loader {
 619         private JarFile jar;
 620         private URL csu;
 621         private JarIndex index;
 622         private MetaIndex metaIndex;
 623         private URLStreamHandler handler;
 624         private HashMap<String, Loader> lmap;
 625         private boolean closed = false;
 626         private static final sun.misc.JavaUtilZipFileAccess zipAccess =
 627                 sun.misc.SharedSecrets.getJavaUtilZipFileAccess();
 628 
 629         /*
 630          * Creates a new JarLoader for the specified URL referring to
 631          * a JAR file.
 632          */
 633         JarLoader(URL url, URLStreamHandler jarHandler,
 634                   HashMap<String, Loader> loaderMap)
 635             throws IOException
 636         {
 637             super(new URL("jar", "", -1, url + "!/", jarHandler));
 638             csu = url;
 639             handler = jarHandler;
 640             lmap = loaderMap;
 641 
 642             if (!isOptimizable(url)) {
 643                 ensureOpen();
 644             } else {
 645                  String fileName = url.getFile();
 646                 if (fileName != null) {
 647                     fileName = ParseUtil.decode(fileName);
 648                     File f = new File(fileName);
 649                     metaIndex = MetaIndex.forJar(f);
 650                     // If the meta index is found but the file is not
 651                     // installed, set metaIndex to null. A typical
 652                     // senario is charsets.jar which won't be installed
 653                     // when the user is running in certain locale environment.
 654                     // The side effect of null metaIndex will cause
 655                     // ensureOpen get called so that IOException is thrown.
 656                     if (metaIndex != null && !f.exists()) {
 657                         metaIndex = null;
 658                     }
 659                 }
 660 
 661                 // metaIndex is null when either there is no such jar file
 662                 // entry recorded in meta-index file or such jar file is
 663                 // missing in JRE. See bug 6340399.
 664                 if (metaIndex == null) {
 665                     ensureOpen();
 666                 }
 667             }
 668         }
 669 
 670         @Override
 671         public void close () throws IOException {
 672             // closing is synchronized at higher level
 673             if (!closed) {
 674                 closed = true;
 675                 // in case not already open.
 676                 ensureOpen();
 677                 jar.close();
 678             }
 679         }
 680 
 681         JarFile getJarFile () {
 682             return jar;
 683         }
 684 
 685         private boolean isOptimizable(URL url) {
 686             return "file".equals(url.getProtocol());
 687         }
 688 
 689         private void ensureOpen() throws IOException {
 690             if (jar == null) {
 691                 try {
 692                     java.security.AccessController.doPrivileged(
 693                         new java.security.PrivilegedExceptionAction<>() {
 694                             public Void run() throws IOException {
 695                                 if (DEBUG) {
 696                                     System.err.println("Opening " + csu);
 697                                     Thread.dumpStack();
 698                                 }
 699 
 700                                 jar = getJarFile(csu);
 701                                 index = JarIndex.getJarIndex(jar, metaIndex);
 702                                 if (index != null) {
 703                                     String[] jarfiles = index.getJarFiles();
 704                                 // Add all the dependent URLs to the lmap so that loaders
 705                                 // will not be created for them by URLClassPath.getLoader(int)
 706                                 // if the same URL occurs later on the main class path.  We set
 707                                 // Loader to null here to avoid creating a Loader for each
 708                                 // URL until we actually need to try to load something from them.
 709                                     for(int i = 0; i < jarfiles.length; i++) {
 710                                         try {
 711                                             URL jarURL = new URL(csu, jarfiles[i]);
 712                                             // If a non-null loader already exists, leave it alone.
 713                                             String urlNoFragString = URLUtil.urlNoFragString(jarURL);
 714                                             if (!lmap.containsKey(urlNoFragString)) {
 715                                                 lmap.put(urlNoFragString, null);
 716                                             }
 717                                         } catch (MalformedURLException e) {
 718                                             continue;
 719                                         }
 720                                     }
 721                                 }
 722                                 return null;
 723                             }
 724                         }
 725                     );
 726                 } catch (java.security.PrivilegedActionException pae) {
 727                     throw (IOException)pae.getException();
 728                 }
 729             }
 730         }
 731 
 732         /* Throws if the given jar file is does not start with the correct LOC */
 733         static JarFile checkJar(JarFile jar) throws IOException {
 734             if (System.getSecurityManager() != null && !DISABLE_JAR_CHECKING
 735                 && !zipAccess.startsWithLocHeader(jar)) {
 736                 IOException x = new IOException("Invalid Jar file");
 737                 try {
 738                     jar.close();
 739                 } catch (IOException ex) {
 740                     x.addSuppressed(ex);
 741                 }
 742                 throw x;
 743             }
 744 
 745             return jar;
 746         }
 747 
 748         private JarFile getJarFile(URL url) throws IOException {
 749             // Optimize case where url refers to a local jar file
 750             if (isOptimizable(url)) {
 751                 FileURLMapper p = new FileURLMapper (url);
 752                 if (!p.exists()) {
 753                     throw new FileNotFoundException(p.getPath());
 754                 }
 755                 return checkJar(new JarFile(p.getPath()));
 756             }
 757             URLConnection uc = getBaseURL().openConnection();
 758             uc.setRequestProperty(USER_AGENT_JAVA_VERSION, JAVA_VERSION);
 759             JarFile jarFile = ((JarURLConnection)uc).getJarFile();
 760             return checkJar(jarFile);
 761         }
 762 
 763         /*
 764          * Returns the index of this JarLoader if it exists.
 765          */
 766         JarIndex getIndex() {
 767             try {
 768                 ensureOpen();
 769             } catch (IOException e) {
 770                 throw new InternalError(e);
 771             }
 772             return index;
 773         }
 774 
 775         /*
 776          * Creates the resource and if the check flag is set to true, checks if
 777          * is its okay to return the resource.
 778          */
 779         Resource checkResource(final String name, boolean check,
 780             final JarEntry entry) {
 781 
 782             final URL url;
 783             try {
 784                 url = new URL(getBaseURL(), ParseUtil.encodePath(name, false));
 785                 if (check) {
 786                     URLClassPath.check(url);
 787                 }
 788             } catch (MalformedURLException e) {
 789                 return null;
 790                 // throw new IllegalArgumentException("name");
 791             } catch (IOException e) {
 792                 return null;
 793             } catch (AccessControlException e) {
 794                 return null;
 795             }
 796 
 797             return new Resource() {
 798                 public String getName() { return name; }
 799                 public URL getURL() { return url; }
 800                 public URL getCodeSourceURL() { return csu; }
 801                 public InputStream getInputStream() throws IOException
 802                     { return jar.getInputStream(entry); }
 803                 @Override
 804                 public ByteBuffer getByteBuffer() throws IOException
 805                     { return ByteBuffer.wrap(getBytes()); }
 806                 @Override
 807                 public byte[] getBytes() throws IOException {
 808                     return zipAccess.getBytes(jar, entry);
 809                 }
 810                 public int getContentLength()
 811                     { return (int)entry.getSize(); }
 812                 public Manifest getManifest() throws IOException
 813                     { return jar.getManifest(); };
 814                 public Certificate[] getCertificates()
 815                     { return entry.getCertificates(); };
 816                 public CodeSigner[] getCodeSigners()
 817                     { return entry.getCodeSigners(); };
 818             };
 819         }
 820 
 821 
 822         /*
 823          * Returns true iff atleast one resource in the jar file has the same
 824          * package name as that of the specified resource name.
 825          */
 826         boolean validIndex(final String name) {
 827             String packageName = name;
 828             int pos;
 829             if((pos = name.lastIndexOf('/')) != -1) {
 830                 packageName = name.substring(0, pos);
 831             }
 832 
 833             String entryName;
 834             ZipEntry entry;
 835             Enumeration<JarEntry> enum_ = jar.entries();
 836             while (enum_.hasMoreElements()) {
 837                 entry = enum_.nextElement();
 838                 entryName = entry.getName();
 839                 if((pos = entryName.lastIndexOf('/')) != -1)
 840                     entryName = entryName.substring(0, pos);
 841                 if (entryName.equals(packageName)) {
 842                     return true;
 843                 }
 844             }
 845             return false;
 846         }
 847 
 848         /*
 849          * Returns the URL for a resource with the specified name
 850          */
 851         URL findResource(final String name, boolean check) {
 852             Resource rsc = getResource(name, check);
 853             if (rsc != null) {
 854                 return rsc.getURL();
 855             }
 856             return null;
 857         }
 858 
 859         /*
 860          * Returns the JAR Resource for the specified name.
 861          */
 862         Resource getResource(final String name, boolean check) {
 863             if (metaIndex != null) {
 864                 if (!metaIndex.mayContain(name)) {
 865                     return null;
 866                 }
 867             }
 868 
 869             try {
 870                 ensureOpen();
 871             } catch (IOException e) {
 872                 throw new InternalError(e);
 873             }
 874             final JarEntry entry = jar.getJarEntry(name);
 875             if (entry != null)
 876                 return checkResource(name, check, entry);
 877 
 878             if (index == null)
 879                 return null;
 880 
 881             HashSet<String> visited = new HashSet<>();
 882             return getResource(name, check, visited);
 883         }
 884 
 885         /*
 886          * Version of getResource() that tracks the jar files that have been
 887          * visited by linking through the index files. This helper method uses
 888          * a HashSet to store the URLs of jar files that have been searched and
 889          * uses it to avoid going into an infinite loop, looking for a
 890          * non-existent resource
 891          */
 892         Resource getResource(final String name, boolean check,
 893                              Set<String> visited) {
 894 
 895             Resource res;
 896             String[] jarFiles;
 897             int count = 0;
 898             LinkedList<String> jarFilesList = null;
 899 
 900             /* If there no jar files in the index that can potential contain
 901              * this resource then return immediately.
 902              */
 903             if((jarFilesList = index.get(name)) == null)
 904                 return null;
 905 
 906             do {
 907                 int size = jarFilesList.size();
 908                 jarFiles = jarFilesList.toArray(new String[size]);
 909                 /* loop through the mapped jar file list */
 910                 while(count < size) {
 911                     String jarName = jarFiles[count++];
 912                     JarLoader newLoader;
 913                     final URL url;
 914 
 915                     try{
 916                         url = new URL(csu, jarName);
 917                         String urlNoFragString = URLUtil.urlNoFragString(url);
 918                         if ((newLoader = (JarLoader)lmap.get(urlNoFragString)) == null) {
 919                             /* no loader has been set up for this jar file
 920                              * before
 921                              */
 922                             newLoader = AccessController.doPrivileged(
 923                                 new PrivilegedExceptionAction<>() {
 924                                     public JarLoader run() throws IOException {
 925                                         return new JarLoader(url, handler,
 926                                             lmap);
 927                                     }
 928                                 });
 929 
 930                             /* this newly opened jar file has its own index,
 931                              * merge it into the parent's index, taking into
 932                              * account the relative path.
 933                              */
 934                             JarIndex newIndex = newLoader.getIndex();
 935                             if(newIndex != null) {
 936                                 int pos = jarName.lastIndexOf('/');
 937                                 newIndex.merge(this.index, (pos == -1 ?
 938                                     null : jarName.substring(0, pos + 1)));
 939                             }
 940 
 941                             /* put it in the global hashtable */
 942                             lmap.put(urlNoFragString, newLoader);
 943                         }
 944                     } catch (java.security.PrivilegedActionException pae) {
 945                         continue;
 946                     } catch (MalformedURLException e) {
 947                         continue;
 948                     }
 949 
 950 
 951                     /* Note that the addition of the url to the list of visited
 952                      * jars incorporates a check for presence in the hashmap
 953                      */
 954                     boolean visitedURL = !visited.add(URLUtil.urlNoFragString(url));
 955                     if (!visitedURL) {
 956                         try {
 957                             newLoader.ensureOpen();
 958                         } catch (IOException e) {
 959                             throw new InternalError(e);
 960                         }
 961                         final JarEntry entry = newLoader.jar.getJarEntry(name);
 962                         if (entry != null) {
 963                             return newLoader.checkResource(name, check, entry);
 964                         }
 965 
 966                         /* Verify that at least one other resource with the
 967                          * same package name as the lookedup resource is
 968                          * present in the new jar
 969                          */
 970                         if (!newLoader.validIndex(name)) {
 971                             /* the mapping is wrong */
 972                             throw new InvalidJarIndexException("Invalid index");
 973                         }
 974                     }
 975 
 976                     /* If newLoader is the current loader or if it is a
 977                      * loader that has already been searched or if the new
 978                      * loader does not have an index then skip it
 979                      * and move on to the next loader.
 980                      */
 981                     if (visitedURL || newLoader == this ||
 982                             newLoader.getIndex() == null) {
 983                         continue;
 984                     }
 985 
 986                     /* Process the index of the new loader
 987                      */
 988                     if((res = newLoader.getResource(name, check, visited))
 989                             != null) {
 990                         return res;
 991                     }
 992                 }
 993                 // Get the list of jar files again as the list could have grown
 994                 // due to merging of index files.
 995                 jarFilesList = index.get(name);
 996 
 997             // If the count is unchanged, we are done.
 998             } while(count < jarFilesList.size());
 999             return null;
1000         }
1001 
1002 
1003         /*
1004          * Returns the JAR file local class path, or null if none.
1005          */
1006         URL[] getClassPath() throws IOException {
1007             if (index != null) {
1008                 return null;
1009             }
1010 
1011             if (metaIndex != null) {
1012                 return null;
1013             }
1014 
1015             ensureOpen();
1016 
1017             if (SharedSecrets.javaUtilJarAccess().jarFileHasClassPathAttribute(jar)) { // Only get manifest when necessary
1018                 Manifest man = jar.getManifest();
1019                 if (man != null) {
1020                     Attributes attr = man.getMainAttributes();
1021                     if (attr != null) {
1022                         String value = attr.getValue(Name.CLASS_PATH);
1023                         if (value != null) {
1024                             return parseClassPath(csu, value);
1025                         }
1026                     }
1027                 }
1028             }
1029             return null;
1030         }
1031 
1032         /*
1033          * Parses value of the Class-Path manifest attribute and returns
1034          * an array of URLs relative to the specified base URL.
1035          */
1036         private URL[] parseClassPath(URL base, String value)
1037             throws MalformedURLException
1038         {
1039             StringTokenizer st = new StringTokenizer(value);
1040             URL[] urls = new URL[st.countTokens()];
1041             int i = 0;
1042             while (st.hasMoreTokens()) {
1043                 String path = st.nextToken();
1044                 urls[i] = new URL(base, path);
1045                 i++;
1046             }
1047             return urls;
1048         }
1049     }
1050 
1051     /*
1052      * Inner class used to represent a loader of classes and resources
1053      * from a file URL that refers to a directory.
1054      */
1055     private static class FileLoader extends Loader {
1056         /* Canonicalized File */
1057         private File dir;
1058 
1059         FileLoader(URL url) throws IOException {
1060             super(url);
1061             if (!"file".equals(url.getProtocol())) {
1062                 throw new IllegalArgumentException("url");
1063             }
1064             String path = url.getFile().replace('/', File.separatorChar);
1065             path = ParseUtil.decode(path);
1066             dir = (new File(path)).getCanonicalFile();
1067         }
1068 
1069         /*
1070          * Returns the URL for a resource with the specified name
1071          */
1072         URL findResource(final String name, boolean check) {
1073             Resource rsc = getResource(name, check);
1074             if (rsc != null) {
1075                 return rsc.getURL();
1076             }
1077             return null;
1078         }
1079 
1080         Resource getResource(final String name, boolean check) {
1081             final URL url;
1082             try {
1083                 URL normalizedBase = new URL(getBaseURL(), ".");
1084                 url = new URL(getBaseURL(), ParseUtil.encodePath(name, false));
1085 
1086                 if (url.getFile().startsWith(normalizedBase.getFile()) == false) {
1087                     // requested resource had ../..'s in path
1088                     return null;
1089                 }
1090 
1091                 if (check)
1092                     URLClassPath.check(url);
1093 
1094                 final File file;
1095                 if (name.indexOf("..") != -1) {
1096                     file = (new File(dir, name.replace('/', File.separatorChar)))
1097                           .getCanonicalFile();
1098                     if ( !((file.getPath()).startsWith(dir.getPath())) ) {
1099                         /* outside of base dir */
1100                         return null;
1101                     }
1102                 } else {
1103                     file = new File(dir, name.replace('/', File.separatorChar));
1104                 }
1105 
1106                 if (file.exists()) {
1107                     return new Resource() {
1108                         public String getName() { return name; };
1109                         public URL getURL() { return url; };
1110                         public URL getCodeSourceURL() { return getBaseURL(); };
1111                         public InputStream getInputStream() throws IOException
1112                             { return new FileInputStream(file); };
1113                         public int getContentLength() throws IOException
1114                             { return (int)file.length(); };
1115                     };
1116                 }
1117             } catch (Exception e) {
1118                 return null;
1119             }
1120             return null;
1121         }
1122     }
1123 
1124     /**
1125      * A Loader of classes and resources from a jimage file located in the
1126      * runtime image.
1127      */
1128     private static class JImageLoader
1129         extends Loader implements JavaRuntimeURLConnection.ResourceFinder
1130     {
1131         private static final AtomicInteger NEXT_INDEX = new AtomicInteger();
1132 
1133         private final ImageReader jimage;
1134         private final int index;
1135 
1136         JImageLoader(URL url) throws IOException {
1137             super(url);
1138 
1139             // get path to image file and check that it's in the runtime
1140             String urlPath = url.getFile().replace('/', File.separatorChar);
1141 
1142             File filePath = new File(ParseUtil.decode(urlPath));
1143             File home = new File(JAVA_HOME).getCanonicalFile();
1144             File parent = filePath.getParentFile();
1145             while (parent != null) {
1146                 if (parent.equals(home))
1147                     break;
1148                 parent = parent.getParentFile();
1149             }
1150             if (parent == null)
1151                 throw new IOException(filePath + " not in runtime image");
1152 
1153             this.jimage = ImageReader.open(filePath.toString());
1154             this.index = NEXT_INDEX.getAndIncrement();
1155 
1156             // register with the jimage protocol handler
1157             JavaRuntimeURLConnection.register(this);
1158         }
1159 
1160         /**
1161          * Maps the given resource name to a module.
1162          */
1163         private String nameToModule(String name) {
1164             int pos = name.lastIndexOf('/');
1165             if (pos > 0) {
1166                 String pkg = name.substring(0, pos);
1167                 String module = jimage.getModule(pkg);
1168                 if (module != null)
1169                     return module;
1170             }
1171             // cannot map to module
1172             return "UNNAMED" + index;
1173         }
1174 
1175         /**
1176          * Constructs a URL for the resource name.
1177          */
1178         private URL toURL(String name) {
1179             String module = nameToModule(name);
1180             String encodedName = ParseUtil.encodePath(name, false);
1181             try {
1182                 return new URL("jrt:/" + module + "/" + encodedName);
1183             } catch (MalformedURLException e) {
1184                 throw new InternalError(e);
1185             }
1186         }
1187 
1188         @Override
1189         URL findResource(String name, boolean check) {
1190             ImageLocation location = jimage.findLocation(name);
1191             if (location == null)
1192                 return null;
1193             URL url = toURL(name);
1194             if (check) {
1195                 try {
1196                     URLClassPath.check(url);
1197                 } catch (IOException | SecurityException e) {
1198                     return null;
1199                 }
1200             }
1201             return url;
1202         }
1203 
1204         @Override
1205         Resource getResource(String name, boolean check) {
1206             ImageLocation location = jimage.findLocation(name);
1207             if (location == null)
1208                 return null;
1209             URL url = toURL(name);
1210             if (check) {
1211                 try {
1212                     URLClassPath.check(url);
1213                 } catch (IOException | SecurityException e) {
1214                     return null;
1215                 }
1216             }
1217             return new Resource() {
1218                 @Override
1219                 public String getName() { return name; }
1220                 @Override
1221                 public URL getURL() { return url; }
1222                 @Override
1223                 public URL getCodeSourceURL() {
1224                     try {
1225                         return new URL("jrt:/" + nameToModule(name));
1226                     } catch (MalformedURLException e) {
1227                         throw new InternalError(e);
1228                     }
1229                 }
1230                 @Override
1231                 public InputStream getInputStream() throws IOException {
1232                     byte[] resource = jimage.getResource(location);
1233                     return new ByteArrayInputStream(resource);
1234                 }
1235                 public int getContentLength() {
1236                     long size = location.getUncompressedSize();
1237                     return (size > Integer.MAX_VALUE) ? -1 : (int)size;
1238                 }
1239             };
1240         }
1241 
1242         @Override
1243         public Resource find(String module, String name) throws IOException {
1244             String m = nameToModule(name);
1245             if (!m.equals(module))
1246                 return null;
1247             // URLConnection will do the permission check
1248             return getResource(name, false);
1249         }
1250     }
1251 }
--- EOF ---