/* * Copyright (c) 1997, 2019, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it * under the terms of the GNU General Public License version 2 only, as * published by the Free Software Foundation. Oracle designates this * particular file as subject to the "Classpath" exception as provided * by Oracle in the LICENSE file that accompanied this code. * * This code is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License * version 2 for more details (a copy is included in the LICENSE file that * accompanied this code). * * You should have received a copy of the GNU General Public License version * 2 along with this work; if not, write to the Free Software Foundation, * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. * * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA * or visit www.oracle.com if you need additional information or have any * questions. */ package sun.misc; import java.util.*; import java.util.jar.JarFile; import sun.misc.JarIndex; import sun.misc.InvalidJarIndexException; import sun.net.www.ParseUtil; import java.util.zip.ZipEntry; import java.util.jar.JarEntry; import java.util.jar.Manifest; import java.util.jar.Attributes; import java.util.jar.Attributes.Name; import java.net.JarURLConnection; import java.net.MalformedURLException; import java.net.URI; import java.net.URL; import java.net.URLClassLoader; import java.net.URLConnection; import java.net.HttpURLConnection; import java.net.URLStreamHandler; import java.net.URLStreamHandlerFactory; import java.io.*; import java.security.AccessControlContext; import java.security.AccessController; import java.security.AccessControlException; import java.security.CodeSigner; import java.security.Permission; import java.security.PrivilegedAction; import java.security.PrivilegedExceptionAction; import java.security.cert.Certificate; import sun.misc.FileURLMapper; import sun.net.util.URLUtil; import sun.security.action.GetPropertyAction; /** * This class is used to maintain a search path of URLs for loading classes * and resources from both JAR files and directories. * * @author David Connelly */ public class URLClassPath { final static String USER_AGENT_JAVA_VERSION = "UA-Java-Version"; final static String JAVA_VERSION; private static final boolean DEBUG; private static final boolean DEBUG_LOOKUP_CACHE; private static final boolean DISABLE_JAR_CHECKING; private static final boolean DISABLE_ACC_CHECKING; private static final boolean DISABLE_CP_URL_CHECK; private static final boolean DEBUG_CP_URL_CHECK; static { JAVA_VERSION = java.security.AccessController.doPrivileged( new GetPropertyAction("java.version")); DEBUG = (java.security.AccessController.doPrivileged( new GetPropertyAction("sun.misc.URLClassPath.debug")) != null); DEBUG_LOOKUP_CACHE = (java.security.AccessController.doPrivileged( new GetPropertyAction("sun.misc.URLClassPath.debugLookupCache")) != null); String p = java.security.AccessController.doPrivileged( new GetPropertyAction("sun.misc.URLClassPath.disableJarChecking")); DISABLE_JAR_CHECKING = p != null ? p.equals("true") || p.equals("") : false; p = AccessController.doPrivileged( new GetPropertyAction("jdk.net.URLClassPath.disableRestrictedPermissions")); DISABLE_ACC_CHECKING = p != null ? p.equals("true") || p.equals("") : false; // This property will be removed in a later release p = AccessController.doPrivileged( new GetPropertyAction("jdk.net.URLClassPath.disableClassPathURLCheck", "true")); DISABLE_CP_URL_CHECK = p != null ? p.equals("true") || p.isEmpty() : false; DEBUG_CP_URL_CHECK = "debug".equals(p); } /* The original search path of URLs. */ private ArrayList path = new ArrayList(); /* The stack of unopened URLs */ Stack urls = new Stack(); /* The resulting search path of Loaders */ ArrayList loaders = new ArrayList(); /* Map of each URL opened to its corresponding Loader */ HashMap lmap = new HashMap(); /* The jar protocol handler to use when creating new URLs */ private URLStreamHandler jarHandler; /* Whether this URLClassLoader has been closed yet */ private boolean closed = false; /* The context to be used when loading classes and resources. If non-null * this is the context that was captured during the creation of the * URLClassLoader. null implies no additional security restrictions. */ private final AccessControlContext acc; /** * Creates a new URLClassPath for the given URLs. The URLs will be * searched in the order specified for classes and resources. A URL * ending with a '/' is assumed to refer to a directory. Otherwise, * the URL is assumed to refer to a JAR file. * * @param urls the directory and JAR file URLs to search for classes * and resources * @param factory the URLStreamHandlerFactory to use when creating new URLs * @param acc the context to be used when loading classes and resources, may * be null */ public URLClassPath(URL[] urls, URLStreamHandlerFactory factory, AccessControlContext acc) { for (int i = 0; i < urls.length; i++) { path.add(urls[i]); } push(urls); if (factory != null) { jarHandler = factory.createURLStreamHandler("jar"); } if (DISABLE_ACC_CHECKING) this.acc = null; else this.acc = acc; } /** * Constructs a URLClassPath with no additional security restrictions. * Used by code that implements the class path. */ public URLClassPath(URL[] urls) { this(urls, null, null); } public URLClassPath(URL[] urls, AccessControlContext acc) { this(urls, null, acc); } public synchronized List closeLoaders() { if (closed) { return Collections.emptyList(); } List result = new LinkedList(); for (Loader loader : loaders) { try { loader.close(); } catch (IOException e) { result.add (e); } } closed = true; return result; } /** * Appends the specified URL to the search path of directory and JAR * file URLs from which to load classes and resources. *

* If the URL specified is null or is already in the list of * URLs, then invoking this method has no effect. */ public synchronized void addURL(URL url) { if (closed) return; synchronized (urls) { if (url == null || path.contains(url)) return; urls.add(0, url); path.add(url); if (lookupCacheURLs != null) { // The lookup cache is no longer valid, since getLookupCache() // does not consider the newly added url. disableAllLookupCaches(); } } } /** * Returns the original search path of URLs. */ public URL[] getURLs() { synchronized (urls) { return path.toArray(new URL[path.size()]); } } /** * Finds the resource with the specified name on the URL search path * or null if not found or security check fails. * * @param name the name of the resource * @param check whether to perform a security check * @return a URL for the resource, or null * if the resource could not be found. */ public URL findResource(String name, boolean check) { Loader loader; int[] cache = getLookupCache(name); for (int i = 0; (loader = getNextLoader(cache, i)) != null; i++) { URL url = loader.findResource(name, check); if (url != null) { return url; } } return null; } /** * Finds the first Resource on the URL search path which has the specified * name. Returns null if no Resource could be found. * * @param name the name of the Resource * @param check whether to perform a security check * @return the Resource, or null if not found */ public Resource getResource(String name, boolean check) { if (DEBUG) { System.err.println("URLClassPath.getResource(\"" + name + "\")"); } Loader loader; int[] cache = getLookupCache(name); for (int i = 0; (loader = getNextLoader(cache, i)) != null; i++) { Resource res = loader.getResource(name, check); if (res != null) { return res; } } return null; } /** * Finds all resources on the URL search path with the given name. * Returns an enumeration of the URL objects. * * @param name the resource name * @return an Enumeration of all the urls having the specified name */ public Enumeration findResources(final String name, final boolean check) { return new Enumeration() { private int index = 0; private int[] cache = getLookupCache(name); private URL url = null; private boolean next() { if (url != null) { return true; } else { Loader loader; while ((loader = getNextLoader(cache, index++)) != null) { url = loader.findResource(name, check); if (url != null) { return true; } } return false; } } public boolean hasMoreElements() { return next(); } public URL nextElement() { if (!next()) { throw new NoSuchElementException(); } URL u = url; url = null; return u; } }; } public Resource getResource(String name) { return getResource(name, true); } /** * Finds all resources on the URL search path with the given name. * Returns an enumeration of the Resource objects. * * @param name the resource name * @return an Enumeration of all the resources having the specified name */ public Enumeration getResources(final String name, final boolean check) { return new Enumeration() { private int index = 0; private int[] cache = getLookupCache(name); private Resource res = null; private boolean next() { if (res != null) { return true; } else { Loader loader; while ((loader = getNextLoader(cache, index++)) != null) { res = loader.getResource(name, check); if (res != null) { return true; } } return false; } } public boolean hasMoreElements() { return next(); } public Resource nextElement() { if (!next()) { throw new NoSuchElementException(); } Resource r = res; res = null; return r; } }; } public Enumeration getResources(final String name) { return getResources(name, true); } private static volatile boolean lookupCacheEnabled = "true".equals(VM.getSavedProperty("sun.cds.enableSharedLookupCache")); private URL[] lookupCacheURLs; private ClassLoader lookupCacheLoader; synchronized void initLookupCache(ClassLoader loader) { if ((lookupCacheURLs = getLookupCacheURLs(loader)) != null) { lookupCacheLoader = loader; } else { // This JVM instance does not support lookup cache. disableAllLookupCaches(); } } static void disableAllLookupCaches() { lookupCacheEnabled = false; } private static native URL[] getLookupCacheURLs(ClassLoader loader); private static native int[] getLookupCacheForClassLoader(ClassLoader loader, String name); private static native boolean knownToNotExist0(ClassLoader loader, String className); synchronized boolean knownToNotExist(String className) { if (lookupCacheURLs != null && lookupCacheEnabled) { return knownToNotExist0(lookupCacheLoader, className); } // Don't know if this class exists or not -- need to do a full search. return false; } /** * Returns an array of the index to lookupCacheURLs that may * contain the specified resource. The values in the returned * array are in strictly ascending order and must be a valid index * to lookupCacheURLs array. * * This method returns an empty array if the specified resource * cannot be found in this URLClassPath. If there is no lookup * cache or it's disabled, this method returns null and the lookup * should search the entire classpath. * * Example: if lookupCacheURLs contains {a.jar, b.jar, c.jar, d.jar} * and package "foo" only exists in a.jar and c.jar, * getLookupCache("foo/Bar.class") will return {0, 2} * * @param name the resource name * @return an array of the index to lookupCacheURLs that may contain the * specified resource; or null if no lookup cache is used. */ private synchronized int[] getLookupCache(String name) { if (lookupCacheURLs == null || !lookupCacheEnabled) { return null; } int[] cache = getLookupCacheForClassLoader(lookupCacheLoader, name); if (cache != null && cache.length > 0) { int maxindex = cache[cache.length - 1]; // cache[] is strictly ascending. if (!ensureLoaderOpened(maxindex)) { if (DEBUG_LOOKUP_CACHE) { System.out.println("Expanded loaders FAILED " + loaders.size() + " for maxindex=" + maxindex); } return null; } } return cache; } private boolean ensureLoaderOpened(int index) { if (loaders.size() <= index) { // Open all Loaders up to, and including, index if (getLoader(index) == null) { return false; } if (!lookupCacheEnabled) { // cache was invalidated as the result of the above call. return false; } if (DEBUG_LOOKUP_CACHE) { System.out.println("Expanded loaders " + loaders.size() + " to index=" + index); } } return true; } /* * The CLASS-PATH attribute was expanded by the VM when building * the resource lookup cache in the same order as the getLoader * method does. This method validates if the URL from the lookup * cache matches the URL of the Loader at the given index; * otherwise, this method disables the lookup cache. */ private synchronized void validateLookupCache(int index, String urlNoFragString) { if (lookupCacheURLs != null && lookupCacheEnabled) { if (index < lookupCacheURLs.length && urlNoFragString.equals( URLUtil.urlNoFragString(lookupCacheURLs[index]))) { return; } if (DEBUG || DEBUG_LOOKUP_CACHE) { System.out.println("WARNING: resource lookup cache invalidated " + "for lookupCacheLoader at " + index); } disableAllLookupCaches(); } } /** * Returns the next Loader that may contain the resource to * lookup. If the given cache is null, return loaders.get(index) * that may be lazily created; otherwise, cache[index] is the next * Loader that may contain the resource to lookup and so returns * loaders.get(cache[index]). * * If cache is non-null, loaders.get(cache[index]) must be present. * * @param cache lookup cache. If null, search the entire class path * @param index index to the given cache array; or to the loaders list. */ private synchronized Loader getNextLoader(int[] cache, int index) { if (closed) { return null; } if (cache != null) { if (index < cache.length) { Loader loader = loaders.get(cache[index]); if (DEBUG_LOOKUP_CACHE) { System.out.println("HASCACHE: Loading from : " + cache[index] + " = " + loader.getBaseURL()); } return loader; } else { return null; // finished iterating over cache[] } } else { return getLoader(index); } } /* * Returns the Loader at the specified position in the URL search * path. The URLs are opened and expanded as needed. Returns null * if the specified index is out of range. */ private synchronized Loader getLoader(int index) { if (closed) { return null; } // Expand URL search path until the request can be satisfied // or the URL stack is empty. while (loaders.size() < index + 1) { // Pop the next URL from the URL stack URL url; synchronized (urls) { if (urls.empty()) { return null; } else { url = urls.pop(); } } // Skip this URL if it already has a Loader. (Loader // may be null in the case where URL has not been opened // but is referenced by a JAR index.) String urlNoFragString = URLUtil.urlNoFragString(url); if (lmap.containsKey(urlNoFragString)) { continue; } // Otherwise, create a new Loader for the URL. Loader loader; try { loader = getLoader(url); // If the loader defines a local class path then add the // URLs to the list of URLs to be opened. URL[] urls = loader.getClassPath(); if (urls != null) { push(urls); } } catch (IOException e) { // Silently ignore for now... continue; } catch (SecurityException se) { // Always silently ignore. The context, if there is one, that // this URLClassPath was given during construction will never // have permission to access the URL. if (DEBUG) { System.err.println("Failed to access " + url + ", " + se ); } continue; } // Finally, add the Loader to the search path. validateLookupCache(loaders.size(), urlNoFragString); loaders.add(loader); lmap.put(urlNoFragString, loader); } if (DEBUG_LOOKUP_CACHE) { System.out.println("NOCACHE: Loading from : " + index ); } return loaders.get(index); } /* * Returns the Loader for the specified base URL. */ private Loader getLoader(final URL url) throws IOException { try { return java.security.AccessController.doPrivileged( new java.security.PrivilegedExceptionAction() { public Loader run() throws IOException { String file = url.getFile(); if (file != null && file.endsWith("/")) { if ("file".equals(url.getProtocol())) { return new FileLoader(url); } else { return new Loader(url); } } else { return new JarLoader(url, jarHandler, lmap, acc); } } }, acc); } catch (java.security.PrivilegedActionException pae) { throw (IOException)pae.getException(); } } /* * Pushes the specified URLs onto the list of unopened URLs. */ private void push(URL[] us) { synchronized (urls) { for (int i = us.length - 1; i >= 0; --i) { urls.push(us[i]); } } } /** * Convert class path specification into an array of file URLs. * * The path of the file is encoded before conversion into URL * form so that reserved characters can safely appear in the path. */ public static URL[] pathToURLs(String path) { StringTokenizer st = new StringTokenizer(path, File.pathSeparator); URL[] urls = new URL[st.countTokens()]; int count = 0; while (st.hasMoreTokens()) { File f = new File(st.nextToken()); try { f = new File(f.getCanonicalPath()); } catch (IOException x) { // use the non-canonicalized filename } try { urls[count++] = ParseUtil.fileToEncodedURL(f); } catch (IOException x) { } } if (urls.length != count) { URL[] tmp = new URL[count]; System.arraycopy(urls, 0, tmp, 0, count); urls = tmp; } return urls; } /* * Check whether the resource URL should be returned. * Return null on security check failure. * Called by java.net.URLClassLoader. */ public URL checkURL(URL url) { try { check(url); } catch (Exception e) { return null; } return url; } /* * Check whether the resource URL should be returned. * Throw exception on failure. * Called internally within this file. */ static void check(URL url) throws IOException { SecurityManager security = System.getSecurityManager(); if (security != null) { URLConnection urlConnection = url.openConnection(); Permission perm = urlConnection.getPermission(); if (perm != null) { try { security.checkPermission(perm); } catch (SecurityException se) { // fallback to checkRead/checkConnect for pre 1.2 // security managers if ((perm instanceof java.io.FilePermission) && perm.getActions().indexOf("read") != -1) { security.checkRead(perm.getName()); } else if ((perm instanceof java.net.SocketPermission) && perm.getActions().indexOf("connect") != -1) { URL locUrl = url; if (urlConnection instanceof JarURLConnection) { locUrl = ((JarURLConnection)urlConnection).getJarFileURL(); } security.checkConnect(locUrl.getHost(), locUrl.getPort()); } else { throw se; } } } } } /** * Inner class used to represent a loader of resources and classes * from a base URL. */ private static class Loader implements Closeable { private final URL base; private JarFile jarfile; // if this points to a jar file /* * Creates a new Loader for the specified URL. */ Loader(URL url) { base = url; } /* * Returns the base URL for this Loader. */ URL getBaseURL() { return base; } URL findResource(final String name, boolean check) { URL url; try { url = new URL(base, ParseUtil.encodePath(name, false)); } catch (MalformedURLException e) { throw new IllegalArgumentException("name"); } try { if (check) { URLClassPath.check(url); } /* * For a HTTP connection we use the HEAD method to * check if the resource exists. */ URLConnection uc = url.openConnection(); if (uc instanceof HttpURLConnection) { HttpURLConnection hconn = (HttpURLConnection)uc; hconn.setRequestMethod("HEAD"); if (hconn.getResponseCode() >= HttpURLConnection.HTTP_BAD_REQUEST) { return null; } } else { // our best guess for the other cases uc.setUseCaches(false); InputStream is = uc.getInputStream(); is.close(); } return url; } catch (Exception e) { return null; } } Resource getResource(final String name, boolean check) { final URL url; try { url = new URL(base, ParseUtil.encodePath(name, false)); } catch (MalformedURLException e) { throw new IllegalArgumentException("name"); } final URLConnection uc; try { if (check) { URLClassPath.check(url); } uc = url.openConnection(); InputStream in = uc.getInputStream(); if (uc instanceof JarURLConnection) { /* Need to remember the jar file so it can be closed * in a hurry. */ JarURLConnection juc = (JarURLConnection)uc; jarfile = JarLoader.checkJar(juc.getJarFile()); } } catch (Exception e) { return null; } return new Resource() { public String getName() { return name; } public URL getURL() { return url; } public URL getCodeSourceURL() { return base; } public InputStream getInputStream() throws IOException { return uc.getInputStream(); } public int getContentLength() throws IOException { return uc.getContentLength(); } }; } /* * Returns the Resource for the specified name, or null if not * found or the caller does not have the permission to get the * resource. */ Resource getResource(final String name) { return getResource(name, true); } /* * close this loader and release all resources * method overridden in sub-classes */ public void close () throws IOException { if (jarfile != null) { jarfile.close(); } } /* * Returns the local class path for this loader, or null if none. */ URL[] getClassPath() throws IOException { return null; } } /* * Inner class used to represent a Loader of resources from a JAR URL. */ static class JarLoader extends Loader { private JarFile jar; private final URL csu; private JarIndex index; private MetaIndex metaIndex; private URLStreamHandler handler; private final HashMap lmap; private final AccessControlContext acc; private boolean closed = false; private static final sun.misc.JavaUtilZipFileAccess zipAccess = sun.misc.SharedSecrets.getJavaUtilZipFileAccess(); /* * Creates a new JarLoader for the specified URL referring to * a JAR file. */ JarLoader(URL url, URLStreamHandler jarHandler, HashMap loaderMap, AccessControlContext acc) throws IOException { super(new URL("jar", "", -1, url + "!/", jarHandler)); csu = url; handler = jarHandler; lmap = loaderMap; this.acc = acc; if (!isOptimizable(url)) { ensureOpen(); } else { String fileName = url.getFile(); if (fileName != null) { fileName = ParseUtil.decode(fileName); File f = new File(fileName); metaIndex = MetaIndex.forJar(f); // If the meta index is found but the file is not // installed, set metaIndex to null. A typical // senario is charsets.jar which won't be installed // when the user is running in certain locale environment. // The side effect of null metaIndex will cause // ensureOpen get called so that IOException is thrown. if (metaIndex != null && !f.exists()) { metaIndex = null; } } // metaIndex is null when either there is no such jar file // entry recorded in meta-index file or such jar file is // missing in JRE. See bug 6340399. if (metaIndex == null) { ensureOpen(); } } } @Override public void close () throws IOException { // closing is synchronized at higher level if (!closed) { closed = true; // in case not already open. ensureOpen(); jar.close(); } } JarFile getJarFile () { return jar; } private boolean isOptimizable(URL url) { return "file".equals(url.getProtocol()); } private void ensureOpen() throws IOException { if (jar == null) { try { java.security.AccessController.doPrivileged( new java.security.PrivilegedExceptionAction() { public Void run() throws IOException { if (DEBUG) { System.err.println("Opening " + csu); Thread.dumpStack(); } jar = getJarFile(csu); index = JarIndex.getJarIndex(jar, metaIndex); if (index != null) { String[] jarfiles = index.getJarFiles(); // Add all the dependent URLs to the lmap so that loaders // will not be created for them by URLClassPath.getLoader(int) // if the same URL occurs later on the main class path. We set // Loader to null here to avoid creating a Loader for each // URL until we actually need to try to load something from them. for(int i = 0; i < jarfiles.length; i++) { try { URL jarURL = new URL(csu, jarfiles[i]); // If a non-null loader already exists, leave it alone. String urlNoFragString = URLUtil.urlNoFragString(jarURL); if (!lmap.containsKey(urlNoFragString)) { lmap.put(urlNoFragString, null); } } catch (MalformedURLException e) { continue; } } } return null; } }, acc); } catch (java.security.PrivilegedActionException pae) { throw (IOException)pae.getException(); } } } /* Throws if the given jar file is does not start with the correct LOC */ static JarFile checkJar(JarFile jar) throws IOException { if (System.getSecurityManager() != null && !DISABLE_JAR_CHECKING && !zipAccess.startsWithLocHeader(jar)) { IOException x = new IOException("Invalid Jar file"); try { jar.close(); } catch (IOException ex) { x.addSuppressed(ex); } throw x; } return jar; } private JarFile getJarFile(URL url) throws IOException { // Optimize case where url refers to a local jar file if (isOptimizable(url)) { FileURLMapper p = new FileURLMapper (url); if (!p.exists()) { throw new FileNotFoundException(p.getPath()); } return checkJar(new JarFile(p.getPath())); } URLConnection uc = getBaseURL().openConnection(); uc.setRequestProperty(USER_AGENT_JAVA_VERSION, JAVA_VERSION); JarFile jarFile = ((JarURLConnection)uc).getJarFile(); return checkJar(jarFile); } /* * Returns the index of this JarLoader if it exists. */ JarIndex getIndex() { try { ensureOpen(); } catch (IOException e) { throw new InternalError(e); } return index; } /* * Creates the resource and if the check flag is set to true, checks if * is its okay to return the resource. */ Resource checkResource(final String name, boolean check, final JarEntry entry) { final URL url; try { url = new URL(getBaseURL(), ParseUtil.encodePath(name, false)); if (check) { URLClassPath.check(url); } } catch (MalformedURLException e) { return null; // throw new IllegalArgumentException("name"); } catch (IOException e) { return null; } catch (AccessControlException e) { return null; } return new Resource() { public String getName() { return name; } public URL getURL() { return url; } public URL getCodeSourceURL() { return csu; } public InputStream getInputStream() throws IOException { return jar.getInputStream(entry); } public int getContentLength() { return (int)entry.getSize(); } public Manifest getManifest() throws IOException { SharedSecrets.javaUtilJarAccess().ensureInitialization(jar); return jar.getManifest(); } public Certificate[] getCertificates() { return entry.getCertificates(); }; public CodeSigner[] getCodeSigners() { return entry.getCodeSigners(); }; }; } /* * Returns true iff atleast one resource in the jar file has the same * package name as that of the specified resource name. */ boolean validIndex(final String name) { String packageName = name; int pos; if((pos = name.lastIndexOf("/")) != -1) { packageName = name.substring(0, pos); } String entryName; ZipEntry entry; Enumeration enum_ = jar.entries(); while (enum_.hasMoreElements()) { entry = enum_.nextElement(); entryName = entry.getName(); if((pos = entryName.lastIndexOf("/")) != -1) entryName = entryName.substring(0, pos); if (entryName.equals(packageName)) { return true; } } return false; } /* * Returns the URL for a resource with the specified name */ URL findResource(final String name, boolean check) { Resource rsc = getResource(name, check); if (rsc != null) { return rsc.getURL(); } return null; } /* * Returns the JAR Resource for the specified name. */ Resource getResource(final String name, boolean check) { if (metaIndex != null) { if (!metaIndex.mayContain(name)) { return null; } } try { ensureOpen(); } catch (IOException e) { throw new InternalError(e); } final JarEntry entry = jar.getJarEntry(name); if (entry != null) return checkResource(name, check, entry); if (index == null) return null; HashSet visited = new HashSet(); return getResource(name, check, visited); } /* * Version of getResource() that tracks the jar files that have been * visited by linking through the index files. This helper method uses * a HashSet to store the URLs of jar files that have been searched and * uses it to avoid going into an infinite loop, looking for a * non-existent resource */ Resource getResource(final String name, boolean check, Set visited) { Resource res; String[] jarFiles; int count = 0; LinkedList jarFilesList = null; /* If there no jar files in the index that can potential contain * this resource then return immediately. */ if((jarFilesList = index.get(name)) == null) return null; do { int size = jarFilesList.size(); jarFiles = jarFilesList.toArray(new String[size]); /* loop through the mapped jar file list */ while(count < size) { String jarName = jarFiles[count++]; JarLoader newLoader; final URL url; try{ url = new URL(csu, jarName); String urlNoFragString = URLUtil.urlNoFragString(url); if ((newLoader = (JarLoader)lmap.get(urlNoFragString)) == null) { /* no loader has been set up for this jar file * before */ newLoader = AccessController.doPrivileged( new PrivilegedExceptionAction() { public JarLoader run() throws IOException { return new JarLoader(url, handler, lmap, acc); } }, acc); /* this newly opened jar file has its own index, * merge it into the parent's index, taking into * account the relative path. */ JarIndex newIndex = newLoader.getIndex(); if(newIndex != null) { int pos = jarName.lastIndexOf("/"); newIndex.merge(this.index, (pos == -1 ? null : jarName.substring(0, pos + 1))); } /* put it in the global hashtable */ lmap.put(urlNoFragString, newLoader); } } catch (java.security.PrivilegedActionException pae) { continue; } catch (MalformedURLException e) { continue; } /* Note that the addition of the url to the list of visited * jars incorporates a check for presence in the hashmap */ boolean visitedURL = !visited.add(URLUtil.urlNoFragString(url)); if (!visitedURL) { try { newLoader.ensureOpen(); } catch (IOException e) { throw new InternalError(e); } final JarEntry entry = newLoader.jar.getJarEntry(name); if (entry != null) { return newLoader.checkResource(name, check, entry); } /* Verify that at least one other resource with the * same package name as the lookedup resource is * present in the new jar */ if (!newLoader.validIndex(name)) { /* the mapping is wrong */ throw new InvalidJarIndexException("Invalid index"); } } /* If newLoader is the current loader or if it is a * loader that has already been searched or if the new * loader does not have an index then skip it * and move on to the next loader. */ if (visitedURL || newLoader == this || newLoader.getIndex() == null) { continue; } /* Process the index of the new loader */ if((res = newLoader.getResource(name, check, visited)) != null) { return res; } } // Get the list of jar files again as the list could have grown // due to merging of index files. jarFilesList = index.get(name); // If the count is unchanged, we are done. } while(count < jarFilesList.size()); return null; } /* * Returns the JAR file local class path, or null if none. */ URL[] getClassPath() throws IOException { if (index != null) { return null; } if (metaIndex != null) { return null; } ensureOpen(); parseExtensionsDependencies(); if (SharedSecrets.javaUtilJarAccess().jarFileHasClassPathAttribute(jar)) { // Only get manifest when necessary Manifest man = jar.getManifest(); if (man != null) { Attributes attr = man.getMainAttributes(); if (attr != null) { String value = attr.getValue(Name.CLASS_PATH); if (value != null) { return parseClassPath(csu, value); } } } } return null; } /* * parse the standard extension dependencies */ private void parseExtensionsDependencies() throws IOException { ExtensionDependency.checkExtensionsDependencies(jar); } /* * Parses value of the Class-Path manifest attribute and returns * an array of URLs relative to the specified base URL. */ private URL[] parseClassPath(URL base, String value) throws MalformedURLException { StringTokenizer st = new StringTokenizer(value); URL[] urls = new URL[st.countTokens()]; int i = 0; while (st.hasMoreTokens()) { String path = st.nextToken(); URL url = DISABLE_CP_URL_CHECK ? new URL(base, path) : tryResolve(base, path); if (url != null) { urls[i] = url; i++; } else { if (DEBUG_CP_URL_CHECK) { System.err.println("Class-Path entry: \"" + path + "\" ignored in JAR file " + base); } } } if (i == 0) { urls = null; } else if (i != urls.length) { // Truncate nulls from end of array urls = Arrays.copyOf(urls, i); } return urls; } static URL tryResolve(URL base, String input) throws MalformedURLException { if ("file".equalsIgnoreCase(base.getProtocol())) { return tryResolveFile(base, input); } else { return tryResolveNonFile(base, input); } } /** * Attempt to return a file URL by resolving input against a base file * URL. The input is an absolute or relative file URL that encodes a * file path. * * @apiNote Nonsensical input such as a Windows file path with a drive * letter cannot be disambiguated from an absolute URL so will be rejected * (by returning null) by this method. * * @return the resolved URL or null if the input is an absolute URL with * a scheme other than file (ignoring case) * @throws MalformedURLException */ static URL tryResolveFile(URL base, String input) throws MalformedURLException { int index = input.indexOf(':'); boolean isFile; if (index >= 0) { String scheme = input.substring(0, index); isFile = "file".equalsIgnoreCase(scheme); } else { isFile = true; } return (isFile) ? new URL(base, input) : null; } /** * Attempt to return a URL by resolving input against a base URL. Returns * null if the resolved URL is not contained by the base URL. * * @return the resolved URL or null * @throws MalformedURLException */ static URL tryResolveNonFile(URL base, String input) throws MalformedURLException { String child = input.replace(File.separatorChar, '/'); if (isRelative(child)) { URL url = new URL(base, child); String bp = base.getPath(); String urlp = url.getPath(); int pos = bp.lastIndexOf('/'); if (pos == -1) { pos = bp.length() - 1; } if (urlp.regionMatches(0, bp, 0, pos + 1) && urlp.indexOf("..", pos) == -1) { return url; } } return null; } /** * Returns true if the given input is a relative URI. */ static boolean isRelative(String child) { try { return !URI.create(child).isAbsolute(); } catch (IllegalArgumentException e) { return false; } } } /* * Inner class used to represent a loader of classes and resources * from a file URL that refers to a directory. */ private static class FileLoader extends Loader { /* Canonicalized File */ private File dir; FileLoader(URL url) throws IOException { super(url); if (!"file".equals(url.getProtocol())) { throw new IllegalArgumentException("url"); } String path = url.getFile().replace('/', File.separatorChar); path = ParseUtil.decode(path); dir = (new File(path)).getCanonicalFile(); } /* * Returns the URL for a resource with the specified name */ URL findResource(final String name, boolean check) { Resource rsc = getResource(name, check); if (rsc != null) { return rsc.getURL(); } return null; } Resource getResource(final String name, boolean check) { final URL url; try { URL normalizedBase = new URL(getBaseURL(), "."); url = new URL(getBaseURL(), ParseUtil.encodePath(name, false)); if (url.getFile().startsWith(normalizedBase.getFile()) == false) { // requested resource had ../..'s in path return null; } if (check) URLClassPath.check(url); final File file; if (name.indexOf("..") != -1) { file = (new File(dir, name.replace('/', File.separatorChar))) .getCanonicalFile(); if ( !((file.getPath()).startsWith(dir.getPath())) ) { /* outside of base dir */ return null; } } else { file = new File(dir, name.replace('/', File.separatorChar)); } if (file.exists()) { return new Resource() { public String getName() { return name; }; public URL getURL() { return url; }; public URL getCodeSourceURL() { return getBaseURL(); }; public InputStream getInputStream() throws IOException { return new FileInputStream(file); }; public int getContentLength() throws IOException { return (int)file.length(); }; }; } } catch (Exception e) { return null; } return null; } } }