| /* URLClassLoader.java -- ClassLoader that loads classes from one or more URLs |
| Copyright (C) 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006 |
| Free Software Foundation, Inc. |
| |
| This file is part of GNU Classpath. |
| |
| GNU Classpath is free software; you can redistribute it and/or modify |
| it under the terms of the GNU General Public License as published by |
| the Free Software Foundation; either version 2, or (at your option) |
| any later version. |
| |
| GNU Classpath 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 for more details. |
| |
| You should have received a copy of the GNU General Public License |
| along with GNU Classpath; see the file COPYING. If not, write to the |
| Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA |
| 02110-1301 USA. |
| |
| Linking this library statically or dynamically with other modules is |
| making a combined work based on this library. Thus, the terms and |
| conditions of the GNU General Public License cover the whole |
| combination. |
| |
| As a special exception, the copyright holders of this library give you |
| permission to link this library with independent modules to produce an |
| executable, regardless of the license terms of these independent |
| modules, and to copy and distribute the resulting executable under |
| terms of your choice, provided that you also meet, for each linked |
| independent module, the terms and conditions of the license of that |
| module. An independent module is a module which is not derived from |
| or based on this library. If you modify this library, you may extend |
| this exception to your version of the library, but you are not |
| obligated to do so. If you do not wish to do so, delete this |
| exception statement from your version. */ |
| |
| |
| package java.net; |
| |
| import gnu.java.net.loader.FileURLLoader; |
| import gnu.java.net.loader.JarURLLoader; |
| import gnu.java.net.loader.RemoteURLLoader; |
| import gnu.java.net.loader.Resource; |
| import gnu.java.net.loader.URLLoader; |
| import gnu.java.net.loader.URLStreamHandlerCache; |
| |
| import java.io.ByteArrayOutputStream; |
| import java.io.EOFException; |
| import java.io.File; |
| import java.io.FilePermission; |
| import java.io.IOException; |
| import java.io.InputStream; |
| import java.lang.reflect.Constructor; |
| import java.lang.reflect.InvocationTargetException; |
| import java.security.AccessControlContext; |
| import java.security.AccessController; |
| import java.security.CodeSource; |
| import java.security.PermissionCollection; |
| import java.security.PrivilegedAction; |
| import java.security.SecureClassLoader; |
| import java.security.cert.Certificate; |
| import java.util.ArrayList; |
| import java.util.Enumeration; |
| import java.util.Vector; |
| import java.util.jar.Attributes; |
| import java.util.jar.Manifest; |
| |
| |
| /** |
| * A secure class loader that can load classes and resources from |
| * multiple locations. Given an array of <code>URL</code>s this class |
| * loader will retrieve classes and resources by fetching them from |
| * possible remote locations. Each <code>URL</code> is searched in |
| * order in which it was added. If the file portion of the |
| * <code>URL</code> ends with a '/' character then it is interpreted |
| * as a base directory, otherwise it is interpreted as a jar file from |
| * which the classes/resources are resolved. |
| * |
| * <p>New instances can be created by two static |
| * <code>newInstance()</code> methods or by three public |
| * contructors. Both ways give the option to supply an initial array |
| * of <code>URL</code>s and (optionally) a parent classloader (that is |
| * different from the standard system class loader).</p> |
| * |
| * <p>Normally creating a <code>URLClassLoader</code> throws a |
| * <code>SecurityException</code> if a <code>SecurityManager</code> is |
| * installed and the <code>checkCreateClassLoader()</code> method does |
| * not return true. But the <code>newInstance()</code> methods may be |
| * used by any code as long as it has permission to acces the given |
| * <code>URL</code>s. <code>URLClassLoaders</code> created by the |
| * <code>newInstance()</code> methods also explicitly call the |
| * <code>checkPackageAccess()</code> method of |
| * <code>SecurityManager</code> if one is installed before trying to |
| * load a class. Note that only subclasses of |
| * <code>URLClassLoader</code> can add new URLs after the |
| * URLClassLoader had been created. But it is always possible to get |
| * an array of all URLs that the class loader uses to resolve classes |
| * and resources by way of the <code>getURLs()</code> method.</p> |
| * |
| * <p>Open issues: |
| * <ul> |
| * |
| * <li>Should the URLClassLoader actually add the locations found in |
| * the manifest or is this the responsibility of some other |
| * loader/(sub)class? (see <a |
| * href="http://java.sun.com/products/jdk/1.4/docs/guide/extensions/spec.html"> |
| * Extension Mechanism Architecture - Bundles Extensions</a>)</li> |
| * |
| * <li>How does <code>definePackage()</code> and sealing work |
| * precisely?</li> |
| * |
| * <li>We save and use the security context (when a created by |
| * <code>newInstance()</code> but do we have to use it in more |
| * places?</li> |
| * |
| * <li>The use of <code>URLStreamHandler</code>s has not been tested.</li> |
| * |
| * </ul> |
| * </p> |
| * |
| * @since 1.2 |
| * |
| * @author Mark Wielaard (mark@klomp.org) |
| * @author Wu Gansha (gansha.wu@intel.com) |
| */ |
| public class URLClassLoader extends SecureClassLoader |
| { |
| // Class Variables |
| |
| /** |
| * A cache to store mappings between handler factory and its |
| * private protocol handler cache (also a HashMap), so we can avoid |
| * creating handlers each time the same protocol comes. |
| */ |
| private static URLStreamHandlerCache factoryCache |
| = new URLStreamHandlerCache(); |
| |
| /** |
| * The prefix for URL loaders. |
| */ |
| private static final String URL_LOADER_PREFIX = "gnu.java.net.loader.Load_"; |
| |
| // Instance variables |
| |
| /** Locations to load classes from */ |
| private final Vector urls = new Vector(); |
| |
| /** |
| * Store pre-parsed information for each url into this vector: each |
| * element is a URL loader. A jar file has its own class-path |
| * attribute which adds to the URLs that will be searched, but this |
| * does not add to the list of urls. |
| */ |
| private final Vector urlinfos = new Vector(); |
| |
| /** Factory used to get the protocol handlers of the URLs */ |
| private final URLStreamHandlerFactory factory; |
| |
| /** |
| * The security context when created from <code>newInstance()</code> |
| * or null when created through a normal constructor or when no |
| * <code>SecurityManager</code> was installed. |
| */ |
| private final AccessControlContext securityContext; |
| |
| // Helper classes |
| |
| /** |
| * Creates a URLClassLoader that gets classes from the supplied URLs. |
| * To determine if this classloader may be created the constructor of |
| * the super class (<code>SecureClassLoader</code>) is called first, which |
| * can throw a SecurityException. Then the supplied URLs are added |
| * in the order given to the URLClassLoader which uses these URLs to |
| * load classes and resources (after using the default parent ClassLoader). |
| * |
| * @param urls Locations that should be searched by this ClassLoader when |
| * resolving Classes or Resources. |
| * @exception SecurityException if the SecurityManager disallows the |
| * creation of a ClassLoader. |
| * @see SecureClassLoader |
| */ |
| public URLClassLoader(URL[] urls) throws SecurityException |
| { |
| super(); |
| this.factory = null; |
| this.securityContext = null; |
| addURLs(urls); |
| } |
| |
| /** |
| * Creates a <code>URLClassLoader</code> that gets classes from the supplied |
| * <code>URL</code>s. |
| * To determine if this classloader may be created the constructor of |
| * the super class (<code>SecureClassLoader</code>) is called first, which |
| * can throw a SecurityException. Then the supplied URLs are added |
| * in the order given to the URLClassLoader which uses these URLs to |
| * load classes and resources (after using the supplied parent ClassLoader). |
| * @param urls Locations that should be searched by this ClassLoader when |
| * resolving Classes or Resources. |
| * @param parent The parent class loader used before trying this class |
| * loader. |
| * @exception SecurityException if the SecurityManager disallows the |
| * creation of a ClassLoader. |
| * @exception SecurityException |
| * @see SecureClassLoader |
| */ |
| public URLClassLoader(URL[] urls, ClassLoader parent) |
| throws SecurityException |
| { |
| super(parent); |
| this.factory = null; |
| this.securityContext = null; |
| addURLs(urls); |
| } |
| |
| // Package-private to avoid a trampoline constructor. |
| /** |
| * Package-private constructor used by the static |
| * <code>newInstance(URL[])</code> method. Creates an |
| * <code>URLClassLoader</code> with the given parent but without any |
| * <code>URL</code>s yet. This is used to bypass the normal security |
| * check for creating classloaders, but remembers the security |
| * context which will be used when defining classes. The |
| * <code>URL</code>s to load from must be added by the |
| * <code>newInstance()</code> method in the security context of the |
| * caller. |
| * |
| * @param securityContext the security context of the unprivileged code. |
| */ |
| URLClassLoader(ClassLoader parent, AccessControlContext securityContext) |
| { |
| super(parent); |
| this.factory = null; |
| this.securityContext = securityContext; |
| } |
| |
| /** |
| * Creates a URLClassLoader that gets classes from the supplied URLs. |
| * To determine if this classloader may be created the constructor of |
| * the super class (<CODE>SecureClassLoader</CODE>) is called first, which |
| * can throw a SecurityException. Then the supplied URLs are added |
| * in the order given to the URLClassLoader which uses these URLs to |
| * load classes and resources (after using the supplied parent ClassLoader). |
| * It will use the supplied <CODE>URLStreamHandlerFactory</CODE> to get the |
| * protocol handlers of the supplied URLs. |
| * @param urls Locations that should be searched by this ClassLoader when |
| * resolving Classes or Resources. |
| * @param parent The parent class loader used before trying this class |
| * loader. |
| * @param factory Used to get the protocol handler for the URLs. |
| * @exception SecurityException if the SecurityManager disallows the |
| * creation of a ClassLoader. |
| * @exception SecurityException |
| * @see SecureClassLoader |
| */ |
| public URLClassLoader(URL[] urls, ClassLoader parent, |
| URLStreamHandlerFactory factory) |
| throws SecurityException |
| { |
| super(parent); |
| this.securityContext = null; |
| this.factory = factory; |
| addURLs(urls); |
| |
| // If this factory is still not in factoryCache, add it. |
| factoryCache.add(factory); |
| } |
| |
| // Methods |
| |
| /** |
| * Adds a new location to the end of the internal URL store. |
| * @param newUrl the location to add |
| */ |
| protected void addURL(URL newUrl) |
| { |
| urls.add(newUrl); |
| addURLImpl(newUrl); |
| } |
| |
| private void addURLImpl(URL newUrl) |
| { |
| synchronized (this) |
| { |
| if (newUrl == null) |
| return; // Silently ignore... |
| |
| // Reset the toString() value. |
| thisString = null; |
| |
| // Create a loader for this URL. |
| URLLoader loader = null; |
| String file = newUrl.getFile(); |
| String protocol = newUrl.getProtocol(); |
| |
| // If we have a file: URL, we want to make it absolute |
| // here, before we decide whether it is really a jar. |
| URL absoluteURL; |
| if ("file".equals (protocol)) |
| { |
| File dir = new File(file); |
| URL absUrl; |
| try |
| { |
| absoluteURL = dir.getCanonicalFile().toURL(); |
| } |
| catch (IOException ignore) |
| { |
| try |
| { |
| absoluteURL = dir.getAbsoluteFile().toURL(); |
| } |
| catch (MalformedURLException _) |
| { |
| // This really should not happen. |
| absoluteURL = newUrl; |
| } |
| } |
| } |
| else |
| { |
| // This doesn't hurt, and it simplifies the logic a |
| // little. |
| absoluteURL = newUrl; |
| } |
| |
| // First see if we can find a handler with the correct name. |
| try |
| { |
| Class handler = Class.forName(URL_LOADER_PREFIX + protocol); |
| Class[] argTypes = new Class[] { URLClassLoader.class, |
| URLStreamHandlerCache.class, |
| URLStreamHandlerFactory.class, |
| URL.class, |
| URL.class }; |
| Constructor k = handler.getDeclaredConstructor(argTypes); |
| loader |
| = (URLLoader) k.newInstance(new Object[] { this, |
| factoryCache, |
| factory, |
| newUrl, |
| absoluteURL }); |
| } |
| catch (ClassNotFoundException ignore) |
| { |
| // Fall through. |
| } |
| catch (NoSuchMethodException nsme) |
| { |
| // Programming error in the class library. |
| InternalError vme |
| = new InternalError("couldn't find URLLoader constructor"); |
| vme.initCause(nsme); |
| throw vme; |
| } |
| catch (InstantiationException inste) |
| { |
| // Programming error in the class library. |
| InternalError vme |
| = new InternalError("couldn't instantiate URLLoader"); |
| vme.initCause(inste); |
| throw vme; |
| } |
| catch (InvocationTargetException ite) |
| { |
| // Programming error in the class library. |
| InternalError vme |
| = new InternalError("error instantiating URLLoader"); |
| vme.initCause(ite); |
| throw vme; |
| } |
| catch (IllegalAccessException illae) |
| { |
| // Programming error in the class library. |
| InternalError vme |
| = new InternalError("invalid access to URLLoader"); |
| vme.initCause(illae); |
| throw vme; |
| } |
| |
| if (loader == null) |
| { |
| // If it is not a directory, use the jar loader. |
| if (! (file.endsWith("/") || file.endsWith(File.separator))) |
| loader = new JarURLLoader(this, factoryCache, factory, |
| newUrl, absoluteURL); |
| else if ("file".equals(protocol)) |
| loader = new FileURLLoader(this, factoryCache, factory, |
| newUrl, absoluteURL); |
| else |
| loader = new RemoteURLLoader(this, factoryCache, factory, |
| newUrl); |
| } |
| |
| urlinfos.add(loader); |
| ArrayList extra = loader.getClassPath(); |
| if (extra != null) |
| urlinfos.addAll(extra); |
| } |
| } |
| |
| /** |
| * Adds an array of new locations to the end of the internal URL |
| * store. Called from the the constructors. Should not call to the |
| * protected addURL() method since that can be overridden and |
| * subclasses are not yet in a good state at this point. |
| * jboss 4.0.3 for example depends on this. |
| * |
| * @param newUrls the locations to add |
| */ |
| private void addURLs(URL[] newUrls) |
| { |
| for (int i = 0; i < newUrls.length; i++) |
| { |
| urls.add(newUrls[i]); |
| addURLImpl(newUrls[i]); |
| } |
| } |
| |
| /** |
| * Look in both Attributes for a given value. The first Attributes |
| * object, if not null, has precedence. |
| */ |
| private String getAttributeValue(Attributes.Name name, Attributes first, |
| Attributes second) |
| { |
| String result = null; |
| if (first != null) |
| result = first.getValue(name); |
| if (result == null) |
| result = second.getValue(name); |
| return result; |
| } |
| |
| /** |
| * Defines a Package based on the given name and the supplied manifest |
| * information. The manifest indicates the title, version and |
| * vendor information of the specification and implementation and whether the |
| * package is sealed. If the Manifest indicates that the package is sealed |
| * then the Package will be sealed with respect to the supplied URL. |
| * |
| * @param name The name of the package |
| * @param manifest The manifest describing the specification, |
| * implementation and sealing details of the package |
| * @param url the code source url to seal the package |
| * @return the defined Package |
| * @throws IllegalArgumentException If this package name already exists |
| * in this class loader |
| */ |
| protected Package definePackage(String name, Manifest manifest, URL url) |
| throws IllegalArgumentException |
| { |
| // Compute the name of the package as it may appear in the |
| // Manifest. |
| StringBuffer xform = new StringBuffer(name); |
| for (int i = xform.length () - 1; i >= 0; --i) |
| if (xform.charAt(i) == '.') |
| xform.setCharAt(i, '/'); |
| xform.append('/'); |
| String xformName = xform.toString(); |
| |
| Attributes entryAttr = manifest.getAttributes(xformName); |
| Attributes attr = manifest.getMainAttributes(); |
| |
| String specTitle |
| = getAttributeValue(Attributes.Name.SPECIFICATION_TITLE, |
| entryAttr, attr); |
| String specVersion |
| = getAttributeValue(Attributes.Name.SPECIFICATION_VERSION, |
| entryAttr, attr); |
| String specVendor |
| = getAttributeValue(Attributes.Name.SPECIFICATION_VENDOR, |
| entryAttr, attr); |
| String implTitle |
| = getAttributeValue(Attributes.Name.IMPLEMENTATION_TITLE, |
| entryAttr, attr); |
| String implVersion |
| = getAttributeValue(Attributes.Name.IMPLEMENTATION_VERSION, |
| entryAttr, attr); |
| String implVendor |
| = getAttributeValue(Attributes.Name.IMPLEMENTATION_VENDOR, |
| entryAttr, attr); |
| |
| // Look if the Manifest indicates that this package is sealed |
| // XXX - most likely not completely correct! |
| // Shouldn't we also check the sealed attribute of the complete jar? |
| // http://java.sun.com/products/jdk/1.4/docs/guide/extensions/spec.html#bundled |
| // But how do we get that jar manifest here? |
| String sealed = attr.getValue(Attributes.Name.SEALED); |
| if ("false".equals(sealed)) |
| // make sure that the URL is null so the package is not sealed |
| url = null; |
| |
| return definePackage(name, |
| specTitle, specVendor, specVersion, |
| implTitle, implVendor, implVersion, |
| url); |
| } |
| |
| /** |
| * Finds (the first) class by name from one of the locations. The locations |
| * are searched in the order they were added to the URLClassLoader. |
| * |
| * @param className the classname to find |
| * @exception ClassNotFoundException when the class could not be found or |
| * loaded |
| * @return a Class object representing the found class |
| */ |
| protected Class findClass(final String className) |
| throws ClassNotFoundException |
| { |
| // Just try to find the resource by the (almost) same name |
| String resourceName = className.replace('.', '/') + ".class"; |
| int max = urlinfos.size(); |
| Resource resource = null; |
| for (int i = 0; i < max && resource == null; i++) |
| { |
| URLLoader loader = (URLLoader)urlinfos.elementAt(i); |
| if (loader == null) |
| continue; |
| |
| Class k = loader.getClass(className); |
| if (k != null) |
| return k; |
| |
| resource = loader.getResource(resourceName); |
| } |
| if (resource == null) |
| throw new ClassNotFoundException(className + " not found in " + this); |
| |
| // Try to read the class data, create the CodeSource, Package and |
| // construct the class (and watch out for those nasty IOExceptions) |
| try |
| { |
| byte[] data; |
| InputStream in = resource.getInputStream(); |
| try |
| { |
| int length = resource.getLength(); |
| if (length != -1) |
| { |
| // We know the length of the data. |
| // Just try to read it in all at once |
| data = new byte[length]; |
| int pos = 0; |
| while (length - pos > 0) |
| { |
| int len = in.read(data, pos, length - pos); |
| if (len == -1) |
| throw new EOFException("Not enough data reading from: " |
| + in); |
| pos += len; |
| } |
| } |
| else |
| { |
| // We don't know the data length. |
| // Have to read it in chunks. |
| ByteArrayOutputStream out = new ByteArrayOutputStream(4096); |
| byte[] b = new byte[4096]; |
| int l = 0; |
| while (l != -1) |
| { |
| l = in.read(b); |
| if (l != -1) |
| out.write(b, 0, l); |
| } |
| data = out.toByteArray(); |
| } |
| } |
| finally |
| { |
| in.close(); |
| } |
| final byte[] classData = data; |
| |
| // Now get the CodeSource |
| final CodeSource source = resource.getCodeSource(); |
| |
| // Find out package name |
| String packageName = null; |
| int lastDot = className.lastIndexOf('.'); |
| if (lastDot != -1) |
| packageName = className.substring(0, lastDot); |
| |
| if (packageName != null && getPackage(packageName) == null) |
| { |
| // define the package |
| Manifest manifest = resource.getLoader().getManifest(); |
| if (manifest == null) |
| definePackage(packageName, null, null, null, null, null, null, |
| null); |
| else |
| definePackage(packageName, manifest, |
| resource.getLoader().getBaseURL()); |
| } |
| |
| // And finally construct the class! |
| SecurityManager sm = System.getSecurityManager(); |
| Class result = null; |
| if (sm != null && securityContext != null) |
| { |
| result = (Class)AccessController.doPrivileged |
| (new PrivilegedAction() |
| { |
| public Object run() |
| { |
| return defineClass(className, classData, |
| 0, classData.length, |
| source); |
| } |
| }, securityContext); |
| } |
| else |
| result = defineClass(className, classData, 0, classData.length, source); |
| |
| // Avoid NullPointerExceptions. |
| Certificate[] resourceCertificates = resource.getCertificates(); |
| if(resourceCertificates != null) |
| super.setSigners(result, resourceCertificates); |
| |
| return result; |
| } |
| catch (IOException ioe) |
| { |
| ClassNotFoundException cnfe; |
| cnfe = new ClassNotFoundException(className + " not found in " + this); |
| cnfe.initCause(ioe); |
| throw cnfe; |
| } |
| } |
| |
| // Cached String representation of this URLClassLoader |
| private String thisString; |
| |
| /** |
| * Returns a String representation of this URLClassLoader giving the |
| * actual Class name, the URLs that are searched and the parent |
| * ClassLoader. |
| */ |
| public String toString() |
| { |
| synchronized (this) |
| { |
| if (thisString == null) |
| { |
| StringBuffer sb = new StringBuffer(); |
| sb.append(this.getClass().getName()); |
| sb.append("{urls=[" ); |
| URL[] thisURLs = getURLs(); |
| for (int i = 0; i < thisURLs.length; i++) |
| { |
| sb.append(thisURLs[i]); |
| if (i < thisURLs.length - 1) |
| sb.append(','); |
| } |
| sb.append(']'); |
| sb.append(", parent="); |
| sb.append(getParent()); |
| sb.append('}'); |
| thisString = sb.toString(); |
| } |
| return thisString; |
| } |
| } |
| |
| /** |
| * Finds the first occurrence of a resource that can be found. The locations |
| * are searched in the order they were added to the URLClassLoader. |
| * |
| * @param resourceName the resource name to look for |
| * @return the URLResource for the resource if found, null otherwise |
| */ |
| private Resource findURLResource(String resourceName) |
| { |
| int max = urlinfos.size(); |
| for (int i = 0; i < max; i++) |
| { |
| URLLoader loader = (URLLoader) urlinfos.elementAt(i); |
| if (loader == null) |
| continue; |
| |
| Resource resource = loader.getResource(resourceName); |
| if (resource != null) |
| return resource; |
| } |
| return null; |
| } |
| |
| /** |
| * Finds the first occurrence of a resource that can be found. |
| * |
| * @param resourceName the resource name to look for |
| * @return the URL if found, null otherwise |
| */ |
| public URL findResource(String resourceName) |
| { |
| Resource resource = findURLResource(resourceName); |
| if (resource != null) |
| return resource.getURL(); |
| |
| // Resource not found |
| return null; |
| } |
| |
| /** |
| * Finds all the resources with a particular name from all the locations. |
| * |
| * @param resourceName the name of the resource to lookup |
| * @return a (possible empty) enumeration of URLs where the resource can be |
| * found |
| * @exception IOException when an error occurs accessing one of the |
| * locations |
| */ |
| public Enumeration findResources(String resourceName) |
| throws IOException |
| { |
| Vector resources = new Vector(); |
| int max = urlinfos.size(); |
| for (int i = 0; i < max; i++) |
| { |
| URLLoader loader = (URLLoader) urlinfos.elementAt(i); |
| Resource resource = loader.getResource(resourceName); |
| if (resource != null) |
| resources.add(resource.getURL()); |
| } |
| return resources.elements(); |
| } |
| |
| /** |
| * Returns the permissions needed to access a particular code |
| * source. These permissions includes those returned by |
| * <code>SecureClassLoader.getPermissions()</code> and the actual |
| * permissions to access the objects referenced by the URL of the |
| * code source. The extra permissions added depend on the protocol |
| * and file portion of the URL in the code source. If the URL has |
| * the "file" protocol ends with a '/' character then it must be a |
| * directory and a file Permission to read everything in that |
| * directory and all subdirectories is added. If the URL had the |
| * "file" protocol and doesn't end with a '/' character then it must |
| * be a normal file and a file permission to read that file is |
| * added. If the <code>URL</code> has any other protocol then a |
| * socket permission to connect and accept connections from the host |
| * portion of the URL is added. |
| * |
| * @param source The codesource that needs the permissions to be accessed |
| * @return the collection of permissions needed to access the code resource |
| * @see java.security.SecureClassLoader#getPermissions(CodeSource) |
| */ |
| protected PermissionCollection getPermissions(CodeSource source) |
| { |
| // XXX - This implementation does exactly as the Javadoc describes. |
| // But maybe we should/could use URLConnection.getPermissions()? |
| // First get the permissions that would normally be granted |
| PermissionCollection permissions = super.getPermissions(source); |
| |
| // Now add any extra permissions depending on the URL location. |
| URL url = source.getLocation(); |
| String protocol = url.getProtocol(); |
| if (protocol.equals("file")) |
| { |
| String file = url.getFile(); |
| |
| // If the file end in / it must be an directory. |
| if (file.endsWith("/") || file.endsWith(File.separator)) |
| { |
| // Grant permission to read everything in that directory and |
| // all subdirectories. |
| permissions.add(new FilePermission(file + "-", "read")); |
| } |
| else |
| { |
| // It is a 'normal' file. |
| // Grant permission to access that file. |
| permissions.add(new FilePermission(file, "read")); |
| } |
| } |
| else |
| { |
| // Grant permission to connect to and accept connections from host |
| String host = url.getHost(); |
| if (host != null) |
| permissions.add(new SocketPermission(host, "connect,accept")); |
| } |
| |
| return permissions; |
| } |
| |
| /** |
| * Returns all the locations that this class loader currently uses the |
| * resolve classes and resource. This includes both the initially supplied |
| * URLs as any URLs added later by the loader. |
| * @return All the currently used URLs |
| */ |
| public URL[] getURLs() |
| { |
| return (URL[]) urls.toArray(new URL[urls.size()]); |
| } |
| |
| /** |
| * Creates a new instance of a <code>URLClassLoader</code> that gets |
| * classes from the supplied <code>URL</code>s. This class loader |
| * will have as parent the standard system class loader. |
| * |
| * @param urls the initial URLs used to resolve classes and |
| * resources |
| * |
| * @return the class loader |
| * |
| * @exception SecurityException when the calling code does not have |
| * permission to access the given <code>URL</code>s |
| */ |
| public static URLClassLoader newInstance(URL[] urls) |
| throws SecurityException |
| { |
| return newInstance(urls, null); |
| } |
| |
| /** |
| * Creates a new instance of a <code>URLClassLoader</code> that gets |
| * classes from the supplied <code>URL</code>s and with the supplied |
| * loader as parent class loader. |
| * |
| * @param urls the initial URLs used to resolve classes and |
| * resources |
| * @param parent the parent class loader |
| * |
| * @return the class loader |
| * |
| * @exception SecurityException when the calling code does not have |
| * permission to access the given <code>URL</code>s |
| */ |
| public static URLClassLoader newInstance(URL[] urls, final ClassLoader parent) |
| throws SecurityException |
| { |
| SecurityManager sm = System.getSecurityManager(); |
| if (sm == null) |
| return new URLClassLoader(urls, parent); |
| else |
| { |
| final Object securityContext = sm.getSecurityContext(); |
| |
| // XXX - What to do with anything else then an AccessControlContext? |
| if (! (securityContext instanceof AccessControlContext)) |
| throw new SecurityException("securityContext must be AccessControlContext: " |
| + securityContext); |
| |
| URLClassLoader loader = |
| (URLClassLoader) AccessController.doPrivileged(new PrivilegedAction() |
| { |
| public Object run() |
| { |
| return new URLClassLoader(parent, |
| (AccessControlContext) securityContext); |
| } |
| }); |
| loader.addURLs(urls); |
| return loader; |
| } |
| } |
| } |
