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.Closeable;

    29 import java.io.File;

    30 import java.io.FileInputStream;

    31 import java.io.FileNotFoundException;

    32 import java.io.IOException;

    33 import java.io.InputStream;

    34 import java.net.HttpURLConnection;

    35 import java.net.JarURLConnection;

    36 import java.net.MalformedURLException;

    37 import java.net.URL;

    38 import java.net.URLConnection;

    39 import java.net.URLStreamHandler;

    40 import java.net.URLStreamHandlerFactory;

    41 import java.security.AccessControlException;

    42 import java.security.AccessController;

    43 import java.security.CodeSigner;

    44 import java.security.Permission;

    45 import java.security.PrivilegedExceptionAction;

    46 import java.security.cert.Certificate;

    47 import java.util.ArrayList;

    48 import java.util.Collections;

    49 import java.util.Enumeration;

    50 import java.util.HashMap;

    51 import java.util.HashSet;

    52 import java.util.LinkedList;

    53 import java.util.List;

    54 import java.util.NoSuchElementException;

    55 import java.util.Set;

    56 import java.util.Stack;

    57 import java.util.StringTokenizer;

    58 import java.util.jar.JarFile;

    59 import java.util.zip.ZipEntry;

    60 import java.util.jar.JarEntry;

    61 import java.util.jar.Manifest;

    62 import java.util.jar.Attributes;

    63 import java.util.jar.Attributes.Name;

    64 import java.util.zip.ZipFile;

    65 

    66 import jdk.internal.misc.JavaUtilZipFileAccess;

    67 import jdk.internal.misc.SharedSecrets;

    68 import sun.net.util.URLUtil;

    69 import sun.net.www.ParseUtil;

    70 

    71 /**

    72  * This class is used to maintain a search path of URLs for loading classes

    73  * and resources from both JAR files and directories.

    74  *

    75  * @author  David Connelly

    76  */

    77 public class URLClassPath {

    78     private static final String USER_AGENT_JAVA_VERSION = "UA-Java-Version";

    79     private static final String JAVA_HOME;

    80     private static final String JAVA_VERSION;

    81     private static final boolean DEBUG;

    82     private static final boolean DISABLE_JAR_CHECKING;

    83 

    84     static {

    85         JAVA_HOME = java.security.AccessController.doPrivileged(

    86             new sun.security.action.GetPropertyAction("java.home"));

    87         JAVA_VERSION = java.security.AccessController.doPrivileged(

    88             new sun.security.action.GetPropertyAction("java.version"));

    89         DEBUG        = (java.security.AccessController.doPrivileged(

    90             new sun.security.action.GetPropertyAction("sun.misc.URLClassPath.debug")) != null);

    91         String p = java.security.AccessController.doPrivileged(

    92             new sun.security.action.GetPropertyAction("sun.misc.URLClassPath.disableJarChecking"));

    93         DISABLE_JAR_CHECKING = p != null ? p.equals("true") || p.equals("") : false;

    94     }

    95 

    96     /* The original search path of URLs. */

    97     private ArrayList<URL> path = new ArrayList<>();

    98 

    99     /* The stack of unopened URLs */

   100     Stack<URL> urls = new Stack<>();

   101 

   102     /* The resulting search path of Loaders */

   103     ArrayList<Loader> loaders = new ArrayList<>();

   104 

   105     /* Map of each URL opened to its corresponding Loader */

   106     HashMap<String, Loader> lmap = new HashMap<>();

   107 

   108     /* The jar protocol handler to use when creating new URLs */

   109     private URLStreamHandler jarHandler;

   110 

   111     /* Whether this URLClassLoader has been closed yet */

   112     private boolean closed = false;

   113 

   114     /**

   115      * Creates a new URLClassPath for the given URLs. The URLs will be

   116      * searched in the order specified for classes and resources. A URL

   117      * ending with a '/' is assumed to refer to a directory. Otherwise,

   118      * the URL is assumed to refer to a JAR file.

   119      *

   120      * @param urls the directory and JAR file URLs to search for classes

   121      *        and resources

   122      * @param factory the URLStreamHandlerFactory to use when creating new URLs

   123      */

   124     public URLClassPath(URL[] urls, URLStreamHandlerFactory factory) {

   125         for (int i = 0; i < urls.length; i++) {

   126             path.add(urls[i]);

   127         }

   128         push(urls);

   129         if (factory != null) {

   130             jarHandler = factory.createURLStreamHandler("jar");

   131         }

   132     }

   133 

   134     public URLClassPath(URL[] urls) {

   135         this(urls, null);

   136     }

   137 

   138     public synchronized List<IOException> closeLoaders() {

   139         if (closed) {

   140             return Collections.emptyList();

   141         }

   142         List<IOException> result = new LinkedList<>();

   143         for (Loader loader : loaders) {

   144             try {

   145                 loader.close();

   146             } catch (IOException e) {

   147                 result.add (e);

   148             }

   149         }

   150         closed = true;

   151         return result;

   152     }

   153 

   154     /**

   155      * Appends the specified URL to the search path of directory and JAR

   156      * file URLs from which to load classes and resources.

   157      * <p>

   158      * If the URL specified is null or is already in the list of

   159      * URLs, then invoking this method has no effect.

   160      */

   161     public synchronized void addURL(URL url) {

   162         if (closed)

   163             return;

   164         synchronized (urls) {

   165             if (url == null || path.contains(url))

   166                 return;

   167 

   168             urls.add(0, url);

   169             path.add(url);

   170         }

   171     }

   172 

   173     /**

   174      * Returns the original search path of URLs.

   175      */

   176     public URL[] getURLs() {

   177         synchronized (urls) {

   178             return path.toArray(new URL[path.size()]);

   179         }

   180     }

   181 

   182     /**

   183      * Finds the resource with the specified name on the URL search path

   184      * or null if not found or security check fails.

   185      *

   186      * @param name      the name of the resource

   187      * @param check     whether to perform a security check

   188      * @return a <code>URL</code> for the resource, or <code>null</code>

   189      * if the resource could not be found.

   190      */

   191     public URL findResource(String name, boolean check) {

   192         Loader loader;

   193         for (int i = 0; (loader = getLoader(i)) != null; i++) {

   194             URL url = loader.findResource(name, check);

   195             if (url != null) {

   196                 return url;

   197             }

   198         }

   199         return null;

   200     }

   201 

   202     /**

   203      * Finds the first Resource on the URL search path which has the specified

   204      * name. Returns null if no Resource could be found.

   205      *

   206      * @param name the name of the Resource

   207      * @param check     whether to perform a security check

   208      * @return the Resource, or null if not found

   209      */

   210     public Resource getResource(String name, boolean check) {

   211         if (DEBUG) {

   212             System.err.println("URLClassPath.getResource(\"" + name + "\")");

   213         }

   214 

   215         Loader loader;

   216         for (int i = 0; (loader = getLoader(i)) != null; i++) {

   217             Resource res = loader.getResource(name, check);

   218             if (res != null) {

   219                 return res;

   220             }

   221         }

   222         return null;

   223     }

   224 

   225     /**

   226      * Finds all resources on the URL search path with the given name.

   227      * Returns an enumeration of the URL objects.

   228      *

   229      * @param name the resource name

   230      * @return an Enumeration of all the urls having the specified name

   231      */

   232     public Enumeration<URL> findResources(final String name,

   233                                      final boolean check) {

   234         return new Enumeration<>() {

   235             private int index = 0;

   236             private URL url = null;

   237 

   238             private boolean next() {

   239                 if (url != null) {

   240                     return true;

   241                 } else {

   242                     Loader loader;

   243                     while ((loader = getLoader(index++)) != null) {

   244                         url = loader.findResource(name, check);

   245                         if (url != null) {

   246                             return true;

   247                         }

   248                     }

   249                     return false;

   250                 }

   251             }

   252 

   253             public boolean hasMoreElements() {

   254                 return next();

   255             }

   256 

   257             public URL nextElement() {

   258                 if (!next()) {

   259                     throw new NoSuchElementException();

   260                 }

   261                 URL u = url;

   262                 url = null;

   263                 return u;

   264             }

   265         };

   266     }

   267 

   268     public Resource getResource(String name) {

   269         return getResource(name, true);

   270     }

   271 

   272     /**

   273      * Finds all resources on the URL search path with the given name.

   274      * Returns an enumeration of the Resource objects.

   275      *

   276      * @param name the resource name

   277      * @return an Enumeration of all the resources having the specified name

   278      */

   279     public Enumeration<Resource> getResources(final String name,

   280                                     final boolean check) {

   281         return new Enumeration<>() {

   282             private int index = 0;

   283             private Resource res = null;

   284 

   285             private boolean next() {

   286                 if (res != null) {

   287                     return true;

   288                 } else {

   289                     Loader loader;

   290                     while ((loader = getLoader(index++)) != null) {

   291                         res = loader.getResource(name, check);

   292                         if (res != null) {

   293                             return true;

   294                         }

   295                     }

   296                     return false;

   297                 }

   298             }

   299 

   300             public boolean hasMoreElements() {

   301                 return next();

   302             }

   303 

   304             public Resource nextElement() {

   305                 if (!next()) {

   306                     throw new NoSuchElementException();

   307                 }

   308                 Resource r = res;

   309                 res = null;

   310                 return r;

   311             }

   312         };

   313     }

   314 

   315     public Enumeration<Resource> getResources(final String name) {

   316         return getResources(name, true);

   317     }

   318 

   319     /*

   320      * Returns the Loader at the specified position in the URL search

   321      * path. The URLs are opened and expanded as needed. Returns null

   322      * if the specified index is out of range.

   323      */

   324      private synchronized Loader getLoader(int index) {

   325         if (closed) {

   326             return null;

   327         }

   328          // Expand URL search path until the request can be satisfied

   329          // or the URL stack is empty.

   330         while (loaders.size() < index + 1) {

   331             // Pop the next URL from the URL stack

   332             URL url;

   333             synchronized (urls) {

   334                 if (urls.empty()) {

   335                     return null;

   336                 } else {

   337                     url = urls.pop();

   338                 }

   339             }

   340             // Skip this URL if it already has a Loader. (Loader

   341             // may be null in the case where URL has not been opened

   342             // but is referenced by a JAR index.)

   343             String urlNoFragString = URLUtil.urlNoFragString(url);

   344             if (lmap.containsKey(urlNoFragString)) {

   345                 continue;

   346             }

   347             // Otherwise, create a new Loader for the URL.

   348             Loader loader;

   349             try {

   350                 loader = getLoader(url);

   351                 // If the loader defines a local class path then add the

   352                 // URLs to the list of URLs to be opened.

   353                 URL[] urls = loader.getClassPath();

   354                 if (urls != null) {

   355                     push(urls);

   356                 }

   357             } catch (IOException e) {

   358                 // Silently ignore for now...

   359                 continue;

   360             }

   361             // Finally, add the Loader to the search path.

   362             loaders.add(loader);

   363             lmap.put(urlNoFragString, loader);

   364         }

   365         return loaders.get(index);

   366     }

   367 

   368     /*

   369      * Returns the Loader for the specified base URL.

   370      */

   371     private Loader getLoader(final URL url) throws IOException {

   372         try {

   373             return java.security.AccessController.doPrivileged(

   374                 new java.security.PrivilegedExceptionAction<>() {

   375                 public Loader run() throws IOException {

   376                     String file = url.getFile();

   377                     if (file != null && file.endsWith("/")) {

   378                         if ("file".equals(url.getProtocol())) {

   379                             return new FileLoader(url);

   380                         } else {

   381                             return new Loader(url);

   382                         }

   383                     } else {

   384                         return new JarLoader(url, jarHandler, lmap);

   385                     }

   386                 }

   387             });

   388         } catch (java.security.PrivilegedActionException pae) {

   389             throw (IOException)pae.getException();

   390         }

   391     }

   392 

   393     /*

   394      * Pushes the specified URLs onto the list of unopened URLs.

   395      */

   396     private void push(URL[] us) {

   397         synchronized (urls) {

   398             for (int i = us.length - 1; i >= 0; --i) {

   399                 urls.push(us[i]);

   400             }

   401         }

   402     }

   403 

   404     /**

   405      * Convert class path specification into an array of file URLs.

   406      *

   407      * The path of the file is encoded before conversion into URL

   408      * form so that reserved characters can safely appear in the path.

   409      */

   410     public static URL[] pathToURLs(String path) {

   411         StringTokenizer st = new StringTokenizer(path, File.pathSeparator);

   412         URL[] urls = new URL[st.countTokens()];

   413         int count = 0;

   414         while (st.hasMoreTokens()) {

   415             File f = new File(st.nextToken());

   416             try {

   417                 f = new File(f.getCanonicalPath());

   418             } catch (IOException x) {

   419                 // use the non-canonicalized filename

   420             }

   421             try {

   422                 urls[count++] = ParseUtil.fileToEncodedURL(f);

   423             } catch (IOException x) { }

   424         }

   425 

   426         if (urls.length != count) {

   427             URL[] tmp = new URL[count];

   428             System.arraycopy(urls, 0, tmp, 0, count);

   429             urls = tmp;

   430         }

   431         return urls;

   432     }

   433 

   434     /*

   435      * Check whether the resource URL should be returned.

   436      * Return null on security check failure.

   437      * Called by java.net.URLClassLoader.

   438      */

   439     public static URL checkURL(URL url) {

   440         if (url != null) {

   441             try {

   442                 check(url);

   443             } catch (Exception e) {

   444                 return null;

   445             }

   446         }

   447         return url;

   448     }

   449 

   450     /*

   451      * Check whether the resource URL should be returned.

   452      * Throw exception on failure.

   453      * Called internally within this file.

   454      */

   455     public static void check(URL url) throws IOException {

   456         SecurityManager security = System.getSecurityManager();

   457         if (security != null) {

   458             URLConnection urlConnection = url.openConnection();

   459             Permission perm = urlConnection.getPermission();

   460             if (perm != null) {

   461                 try {

   462                     security.checkPermission(perm);

   463                 } catch (SecurityException se) {

   464                     // fallback to checkRead/checkConnect for pre 1.2

   465                     // security managers

   466                     if ((perm instanceof java.io.FilePermission) &&

   467                         perm.getActions().indexOf("read") != -1) {

   468                         security.checkRead(perm.getName());

   469                     } else if ((perm instanceof

   470                         java.net.SocketPermission) &&

   471                         perm.getActions().indexOf("connect") != -1) {

   472                         URL locUrl = url;

   473                         if (urlConnection instanceof JarURLConnection) {

   474                             locUrl = ((JarURLConnection)urlConnection).getJarFileURL();

   475                         }

   476                         security.checkConnect(locUrl.getHost(),

   477                                               locUrl.getPort());

   478                     } else {

   479                         throw se;

   480                     }

   481                 }

   482             }

   483         }

   484     }

   485 

   486     /**

   487      * Inner class used to represent a loader of resources and classes

   488      * from a base URL.

   489      */

   490     private static class Loader implements Closeable {

   491         private final URL base;

   492         private JarFile jarfile; // if this points to a jar file

   493 

   494         /*

   495          * Creates a new Loader for the specified URL.

   496          */

   497         Loader(URL url) {

   498             base = url;

   499         }

   500 

   501         /*

   502          * Returns the base URL for this Loader.

   503          */

   504         URL getBaseURL() {

   505             return base;

   506         }

   507 

   508         URL findResource(final String name, boolean check) {

   509             URL url;

   510             try {

   511                 url = new URL(base, ParseUtil.encodePath(name, false));

   512             } catch (MalformedURLException e) {

   513                 throw new IllegalArgumentException("name");

   514             }

   515 

   516             try {

   517                 if (check) {

   518                     URLClassPath.check(url);

   519                 }

   520 

   521                 /*

   522                  * For a HTTP connection we use the HEAD method to

   523                  * check if the resource exists.

   524                  */

   525                 URLConnection uc = url.openConnection();

   526                 if (uc instanceof HttpURLConnection) {

   527                     HttpURLConnection hconn = (HttpURLConnection)uc;

   528                     hconn.setRequestMethod("HEAD");

   529                     if (hconn.getResponseCode() >= HttpURLConnection.HTTP_BAD_REQUEST) {

   530                         return null;

   531                     }

   532                 } else {

   533                     // our best guess for the other cases

   534                     uc.setUseCaches(false);

   535                     InputStream is = uc.getInputStream();

   536                     is.close();

   537                 }

   538                 return url;

   539             } catch (Exception e) {

   540                 return null;

   541             }

   542         }

   543 

   544         Resource getResource(final String name, boolean check) {

   545             final URL url;

   546             try {

   547                 url = new URL(base, ParseUtil.encodePath(name, false));

   548             } catch (MalformedURLException e) {

   549                 throw new IllegalArgumentException("name");

   550             }

   551             final URLConnection uc;

   552             try {

   553                 if (check) {

   554                     URLClassPath.check(url);

   555                 }

   556                 uc = url.openConnection();

   557                 InputStream in = uc.getInputStream();

   558                 if (uc instanceof JarURLConnection) {

   559                     /* Need to remember the jar file so it can be closed

   560                      * in a hurry.

   561                      */

   562                     JarURLConnection juc = (JarURLConnection)uc;

   563                     jarfile = JarLoader.checkJar(juc.getJarFile());

   564                 }

   565             } catch (Exception e) {

   566                 return null;

   567             }

   568             return new Resource() {

   569                 public String getName() { return name; }

   570                 public URL getURL() { return url; }

   571                 public URL getCodeSourceURL() { return base; }

   572                 public InputStream getInputStream() throws IOException {

   573                     return uc.getInputStream();

   574                 }

   575                 public int getContentLength() throws IOException {

   576                     return uc.getContentLength();

   577                 }

   578             };

   579         }

   580 

   581         /*

   582          * Returns the Resource for the specified name, or null if not

   583          * found or the caller does not have the permission to get the

   584          * resource.

   585          */

   586         Resource getResource(final String name) {

   587             return getResource(name, true);

   588         }

   589 

   590         /*

   591          * close this loader and release all resources

   592          * method overridden in sub-classes

   593          */

   594         public void close () throws IOException {

   595             if (jarfile != null) {

   596                 jarfile.close();

   597             }

   598         }

   599 

   600         /*

   601          * Returns the local class path for this loader, or null if none.

   602          */

   603         URL[] getClassPath() throws IOException {

   604             return null;

   605         }

   606     }

   607 

   608     /*

   609      * Inner class used to represent a Loader of resources from a JAR URL.

   610      */

   611     static class JarLoader extends Loader {

   612         private JarFile jar;

   613         private URL csu;

   614         private JarIndex index;

   615         private URLStreamHandler handler;

   616         private HashMap<String, Loader> lmap;

   617         private boolean closed = false;

   618         private static final JavaUtilZipFileAccess zipAccess =

   619                 SharedSecrets.getJavaUtilZipFileAccess();

   620 

   621         /*

   622          * Creates a new JarLoader for the specified URL referring to

   623          * a JAR file.

   624          */

   625         JarLoader(URL url, URLStreamHandler jarHandler,

   626                   HashMap<String, Loader> loaderMap)

   627             throws IOException

   628         {

   629             super(new URL("jar", "", -1, url + "!/", jarHandler));

   630             csu = url;

   631             handler = jarHandler;

   632             lmap = loaderMap;

   633 

   634             ensureOpen();

   635         }

   636 

   637         @Override

   638         public void close () throws IOException {

   639             // closing is synchronized at higher level

   640             if (!closed) {

   641                 closed = true;

   642                 // in case not already open.

   643                 ensureOpen();

   644                 jar.close();

   645             }

   646         }

   647 

   648         JarFile getJarFile () {

   649             return jar;

   650         }

   651 

   652         private boolean isOptimizable(URL url) {

   653             return "file".equals(url.getProtocol());

   654         }

   655 

   656         private void ensureOpen() throws IOException {

   657             if (jar == null) {

   658                 try {

   659                     java.security.AccessController.doPrivileged(

   660                         new java.security.PrivilegedExceptionAction<>() {

   661                             public Void run() throws IOException {

   662                                 if (DEBUG) {

   663                                     System.err.println("Opening " + csu);

   664                                     Thread.dumpStack();

   665                                 }

   666 

   667                                 jar = getJarFile(csu);

   668                                 index = JarIndex.getJarIndex(jar);

   669                                 if (index != null) {

   670                                     String[] jarfiles = index.getJarFiles();

   671                                 // Add all the dependent URLs to the lmap so that loaders

   672                                 // will not be created for them by URLClassPath.getLoader(int)

   673                                 // if the same URL occurs later on the main class path.  We set

   674                                 // Loader to null here to avoid creating a Loader for each

   675                                 // URL until we actually need to try to load something from them.

   676                                     for(int i = 0; i < jarfiles.length; i++) {

   677                                         try {

   678                                             URL jarURL = new URL(csu, jarfiles[i]);

   679                                             // If a non-null loader already exists, leave it alone.

   680                                             String urlNoFragString = URLUtil.urlNoFragString(jarURL);

   681                                             if (!lmap.containsKey(urlNoFragString)) {

   682                                                 lmap.put(urlNoFragString, null);

   683                                             }

   684                                         } catch (MalformedURLException e) {

   685                                             continue;

   686                                         }

   687                                     }

   688                                 }

   689                                 return null;

   690                             }

   691                         }

   692                     );

   693                 } catch (java.security.PrivilegedActionException pae) {

   694                     throw (IOException)pae.getException();

   695                 }

   696             }

   697         }

   698 

   699         /* Throws if the given jar file is does not start with the correct LOC */

   700         static JarFile checkJar(JarFile jar) throws IOException {

   701             if (System.getSecurityManager() != null && !DISABLE_JAR_CHECKING

   702                 && !zipAccess.startsWithLocHeader(jar)) {

   703                 IOException x = new IOException("Invalid Jar file");

   704                 try {

   705                     jar.close();

   706                 } catch (IOException ex) {

   707                     x.addSuppressed(ex);

   708                 }

   709                 throw x;

   710             }

   711 

   712             return jar;

   713         }

   714 

   715         private JarFile getJarFile(URL url) throws IOException {

   716             // Optimize case where url refers to a local jar file

   717             if (isOptimizable(url)) {

   718                 FileURLMapper p = new FileURLMapper (url);

   719                 if (!p.exists()) {

   720                     throw new FileNotFoundException(p.getPath());

   721                 }

   722                 return checkJar(new JarFile(new File(p.getPath()), true, ZipFile.OPEN_READ,

   723                         JarFile.Release.RUNTIME));

   724             }

   725             URLConnection uc = (new URL(getBaseURL(), "#runtime")).openConnection();

   726             uc.setRequestProperty(USER_AGENT_JAVA_VERSION, JAVA_VERSION);

   727             JarFile jarFile = ((JarURLConnection)uc).getJarFile();

   728             return checkJar(jarFile);

   729         }

   730 

   731         /*

   732          * Returns the index of this JarLoader if it exists.

   733          */

   734         JarIndex getIndex() {

   735             try {

   736                 ensureOpen();

   737             } catch (IOException e) {

   738                 throw new InternalError(e);

   739             }

   740             return index;

   741         }

   742 

   743         /*

   744          * Creates the resource and if the check flag is set to true, checks if

   745          * is its okay to return the resource.

   746          */

   747         Resource checkResource(final String name, boolean check,

   748             final JarEntry entry) {

   749 

   750             final URL url;

   751             try {

   752                 if (jar.isMultiRelease()) {

   753                     // add #runtime fragment to tell JarURLConnection to use

   754                     // runtime versioning if the underlying jar file is multi-release

   755                     url = new URL(getBaseURL(), ParseUtil.encodePath(name, false) + "#runtime");

   756                 } else {

   757                     url = new URL(getBaseURL(), ParseUtil.encodePath(name, false));

   758                 }

   759                 if (check) {

   760                     URLClassPath.check(url);

   761                 }

   762             } catch (MalformedURLException e) {

   763                 return null;

   764                 // throw new IllegalArgumentException("name");

   765             } catch (IOException e) {

   766                 return null;

   767             } catch (AccessControlException e) {

   768                 return null;

   769             }

   770 

   771             return new Resource() {

   772                 public String getName() { return name; }

   773                 public URL getURL() { return url; }

   774                 public URL getCodeSourceURL() { return csu; }

   775                 public InputStream getInputStream() throws IOException

   776                     { return jar.getInputStream(entry); }

   777                 public int getContentLength()

   778                     { return (int)entry.getSize(); }

   779                 public Manifest getManifest() throws IOException

   780                     { return jar.getManifest(); };

   781                 public Certificate[] getCertificates()

   782                     { return entry.getCertificates(); };

   783                 public CodeSigner[] getCodeSigners()

   784                     { return entry.getCodeSigners(); };

   785             };

   786         }

   787 

   788 

   789         /*

   790          * Returns true iff atleast one resource in the jar file has the same

   791          * package name as that of the specified resource name.

   792          */

   793         boolean validIndex(final String name) {

   794             String packageName = name;

   795             int pos;

   796             if((pos = name.lastIndexOf('/')) != -1) {

   797                 packageName = name.substring(0, pos);

   798             }

   799 

   800             String entryName;

   801             ZipEntry entry;

   802             Enumeration<JarEntry> enum_ = jar.entries();

   803             while (enum_.hasMoreElements()) {

   804                 entry = enum_.nextElement();

   805                 entryName = entry.getName();

   806                 if((pos = entryName.lastIndexOf('/')) != -1)

   807                     entryName = entryName.substring(0, pos);

   808                 if (entryName.equals(packageName)) {

   809                     return true;

   810                 }

   811             }

   812             return false;

   813         }

   814 

   815         /*

   816          * Returns the URL for a resource with the specified name

   817          */

   818         URL findResource(final String name, boolean check) {

   819             Resource rsc = getResource(name, check);

   820             if (rsc != null) {

   821                 return rsc.getURL();

   822             }

   823             return null;

   824         }

   825 

   826         /*

   827          * Returns the JAR Resource for the specified name.

   828          */

   829         Resource getResource(final String name, boolean check) {

   830             try {

   831                 ensureOpen();

   832             } catch (IOException e) {

   833                 throw new InternalError(e);

   834             }

   835             final JarEntry entry = jar.getJarEntry(name);

   836             if (entry != null)

   837                 return checkResource(name, check, entry);

   838 

   839             if (index == null)

   840                 return null;

   841 

   842             HashSet<String> visited = new HashSet<>();

   843             return getResource(name, check, visited);

   844         }

   845 

   846         /*

   847          * Version of getResource() that tracks the jar files that have been

   848          * visited by linking through the index files. This helper method uses

   849          * a HashSet to store the URLs of jar files that have been searched and

   850          * uses it to avoid going into an infinite loop, looking for a

   851          * non-existent resource

   852          */

   853         Resource getResource(final String name, boolean check,

   854                              Set<String> visited) {

   855 

   856             Resource res;

   857             String[] jarFiles;

   858             int count = 0;

   859             LinkedList<String> jarFilesList = null;

   860 

   861             /* If there no jar files in the index that can potential contain

   862              * this resource then return immediately.

   863              */

   864             if((jarFilesList = index.get(name)) == null)

   865                 return null;

   866 

   867             do {

   868                 int size = jarFilesList.size();

   869                 jarFiles = jarFilesList.toArray(new String[size]);

   870                 /* loop through the mapped jar file list */

   871                 while(count < size) {

   872                     String jarName = jarFiles[count++];

   873                     JarLoader newLoader;

   874                     final URL url;

   875 

   876                     try{

   877                         url = new URL(csu, jarName);

   878                         String urlNoFragString = URLUtil.urlNoFragString(url);

   879                         if ((newLoader = (JarLoader)lmap.get(urlNoFragString)) == null) {

   880                             /* no loader has been set up for this jar file

   881                              * before

   882                              */

   883                             newLoader = AccessController.doPrivileged(

   884                                 new PrivilegedExceptionAction<>() {

   885                                     public JarLoader run() throws IOException {

   886                                         return new JarLoader(url, handler,

   887                                             lmap);

   888                                     }

   889                                 });

   890 

   891                             /* this newly opened jar file has its own index,

   892                              * merge it into the parent's index, taking into

   893                              * account the relative path.

   894                              */

   895                             JarIndex newIndex = newLoader.getIndex();

   896                             if(newIndex != null) {

   897                                 int pos = jarName.lastIndexOf('/');

   898                                 newIndex.merge(this.index, (pos == -1 ?

   899                                     null : jarName.substring(0, pos + 1)));

   900                             }

   901 

   902                             /* put it in the global hashtable */

   903                             lmap.put(urlNoFragString, newLoader);

   904                         }

   905                     } catch (java.security.PrivilegedActionException pae) {

   906                         continue;

   907                     } catch (MalformedURLException e) {

   908                         continue;

   909                     }

   910 

   911 

   912                     /* Note that the addition of the url to the list of visited

   913                      * jars incorporates a check for presence in the hashmap

   914                      */

   915                     boolean visitedURL = !visited.add(URLUtil.urlNoFragString(url));

   916                     if (!visitedURL) {

   917                         try {

   918                             newLoader.ensureOpen();

   919                         } catch (IOException e) {

   920                             throw new InternalError(e);

   921                         }

   922                         final JarEntry entry = newLoader.jar.getJarEntry(name);

   923                         if (entry != null) {

   924                             return newLoader.checkResource(name, check, entry);

   925                         }

   926 

   927                         /* Verify that at least one other resource with the

   928                          * same package name as the lookedup resource is

   929                          * present in the new jar

   930                          */

   931                         if (!newLoader.validIndex(name)) {

   932                             /* the mapping is wrong */

   933                             throw new InvalidJarIndexException("Invalid index");

   934                         }

   935                     }

   936 

   937                     /* If newLoader is the current loader or if it is a

   938                      * loader that has already been searched or if the new

   939                      * loader does not have an index then skip it

   940                      * and move on to the next loader.

   941                      */

   942                     if (visitedURL || newLoader == this ||

   943                             newLoader.getIndex() == null) {

   944                         continue;

   945                     }

   946 

   947                     /* Process the index of the new loader

   948                      */

   949                     if((res = newLoader.getResource(name, check, visited))

   950                             != null) {

   951                         return res;

   952                     }

   953                 }

   954                 // Get the list of jar files again as the list could have grown

   955                 // due to merging of index files.

   956                 jarFilesList = index.get(name);

   957 

   958             // If the count is unchanged, we are done.

   959             } while(count < jarFilesList.size());

   960             return null;

   961         }

   962 

   963 

   964         /*

   965          * Returns the JAR file local class path, or null if none.

   966          */

   967         URL[] getClassPath() throws IOException {

   968             if (index != null) {

   969                 return null;

   970             }

   971 

   972             ensureOpen();

   973 

   974             if (SharedSecrets.javaUtilJarAccess().jarFileHasClassPathAttribute(jar)) { // Only get manifest when necessary

   975                 Manifest man = jar.getManifest();

   976                 if (man != null) {

   977                     Attributes attr = man.getMainAttributes();

   978                     if (attr != null) {

   979                         String value = attr.getValue(Name.CLASS_PATH);

   980                         if (value != null) {

   981                             return parseClassPath(csu, value);

   982                         }

   983                     }

   984                 }

   985             }

   986             return null;

   987         }

   988 

   989         /*

   990          * Parses value of the Class-Path manifest attribute and returns

   991          * an array of URLs relative to the specified base URL.

   992          */

   993         private URL[] parseClassPath(URL base, String value)

   994             throws MalformedURLException

   995         {

   996             StringTokenizer st = new StringTokenizer(value);

   997             URL[] urls = new URL[st.countTokens()];

   998             int i = 0;

   999             while (st.hasMoreTokens()) {

  1000                 String path = st.nextToken();

  1001                 urls[i] = new URL(base, path);

  1002                 i++;

  1003             }

  1004             return urls;

  1005         }

  1006     }

  1007 

  1008     /*

  1009      * Inner class used to represent a loader of classes and resources

  1010      * from a file URL that refers to a directory.

  1011      */

  1012     private static class FileLoader extends Loader {

  1013         /* Canonicalized File */

  1014         private File dir;

  1015 

  1016         FileLoader(URL url) throws IOException {

  1017             super(url);

  1018             if (!"file".equals(url.getProtocol())) {

  1019                 throw new IllegalArgumentException("url");

  1020             }

  1021             String path = url.getFile().replace('/', File.separatorChar);

  1022             path = ParseUtil.decode(path);

  1023             dir = (new File(path)).getCanonicalFile();

  1024         }

  1025 

  1026         /*

  1027          * Returns the URL for a resource with the specified name

  1028          */

  1029         URL findResource(final String name, boolean check) {

  1030             Resource rsc = getResource(name, check);

  1031             if (rsc != null) {

  1032                 return rsc.getURL();

  1033             }

  1034             return null;

  1035         }

  1036 

  1037         Resource getResource(final String name, boolean check) {

  1038             final URL url;

  1039             try {

  1040                 URL normalizedBase = new URL(getBaseURL(), ".");

  1041                 url = new URL(getBaseURL(), ParseUtil.encodePath(name, false));

  1042 

  1043                 if (url.getFile().startsWith(normalizedBase.getFile()) == false) {

  1044                     // requested resource had ../..'s in path

  1045                     return null;

  1046                 }

  1047 

  1048                 if (check)

  1049                     URLClassPath.check(url);

  1050 

  1051                 final File file;

  1052                 if (name.indexOf("..") != -1) {

  1053                     file = (new File(dir, name.replace('/', File.separatorChar)))

  1054                           .getCanonicalFile();

  1055                     if ( !((file.getPath()).startsWith(dir.getPath())) ) {

  1056                         /* outside of base dir */

  1057                         return null;

  1058                     }

  1059                 } else {

  1060                     file = new File(dir, name.replace('/', File.separatorChar));

  1061                 }

  1062 

  1063                 if (file.exists()) {

  1064                     return new Resource() {

  1065                         public String getName() { return name; };

  1066                         public URL getURL() { return url; };

  1067                         public URL getCodeSourceURL() { return getBaseURL(); };

  1068                         public InputStream getInputStream() throws IOException

  1069                             { return new FileInputStream(file); };

  1070                         public int getContentLength() throws IOException

  1071                             { return (int)file.length(); };

  1072                     };

  1073                 }

  1074             } catch (Exception e) {

  1075                 return null;

  1076             }

  1077             return null;

  1078         }

  1079     }

  1080 }