FileDocCategorySizeDatePackage
WebappClassLoader.javaAPI DocGlassfish v2 API87366Fri May 25 10:59:42 BST 2007org.apache.catalina.loader

WebappClassLoader

public class WebappClassLoader extends URLClassLoader implements org.apache.catalina.Lifecycle, Reloader
Specialized web application class loader.

This class loader is a full reimplementation of the URLClassLoader from the JDK. It is desinged to be fully compatible with a normal URLClassLoader, although its internal behavior may be completely different.

IMPLEMENTATION NOTE - This class loader faithfully follows the delegation model recommended in the specification. The system class loader will be queried first, then the local repositories, and only then delegation to the parent class loader will occur. This allows the web application to override any shared class except the classes from J2SE. Special handling is provided from the JAXP XML parser interfaces, the JNDI interfaces, and the classes from the servlet API, which are never loaded from the webapp repository.

IMPLEMENTATION NOTE - Due to limitations in Jasper compilation technology, any repository which contains classes from the servlet API will be ignored by the class loader.

IMPLEMENTATION NOTE - The class loader generates source URLs which include the full JAR URL when a class is loaded from a JAR file, which allows setting security permission at the class level, even when a class is contained inside a JAR.

IMPLEMENTATION NOTE - Local repositories are searched in the order they are added via the initial constructor and/or any subsequent calls to addRepository() or addJar().

IMPLEMENTATION NOTE - No check for sealing violations or security is made unless a security manager is present.

author
Remy Maucherat
author
Craig R. McClanahan
version
$Revision: 1.34 $ $Date: 2007/05/25 17:59:42 $

Fields Summary
private static com.sun.org.apache.commons.logging.Log
log
private static final String[]
triggers
The set of trigger classes that will cause a proposed repository not to be added if this class is visible to the class loader that loaded this factory class. Typically, trigger classes will be listed for components that have been integrated into the JDK for later versions, but where the corresponding JAR files are required to run on earlier versions.
private static org.apache.tomcat.util.compat.JdkCompat
jdkCompat
Jdk Compatibility Support.
private static final String[]
packageTriggers
Set of package names which are not allowed to be loaded from a webapp class loader without delegating first.
private ArrayList
overridablePackages
List of packages that may always be overridden, regardless of whether they belong to a protected namespace (i.e., a namespace that may never be overridden by a webapp)
protected static final org.apache.catalina.util.StringManager
sm
The string manager for this package.
protected DirContext
resources
Associated directory context giving access to the resources in this webapp.
protected HashMap
resourceEntries
The cache of ResourceEntry for classes and resources we have loaded, keyed by resource name.
protected HashMap
notFoundResources
The list of not found resources.
protected int
debug
The debugging detail level of this component.
protected boolean
delegate
Should this class loader delegate to the parent class loader before searching its own repositories (i.e. the usual Java2 delegation model)? If set to false, this class loader will search its own repositories first, and delegate to the parent only if the class or resource is not found locally.
protected long
lastJarAccessed
Last time a JAR was accessed.
protected String[]
repositories
The list of local repositories, in the order they should be searched for locally loaded classes or resources.
protected URL[]
repositoryURLs
Repositories URLs, used to cache the result of getURLs.
protected File[]
files
Repositories translated as path in the work directory (for Jasper originally), but which is used to generate fake URLs should getURLs be called.
protected JarFile[]
jarFiles
The list of JARs, in the order they should be searched for locally loaded classes or resources.
protected File[]
jarRealFiles
The list of JARs, in the order they should be searched for locally loaded classes or resources.
protected String
jarPath
The path which will be monitored for added Jar files.
protected String[]
jarNames
The list of JARs, in the order they should be searched for locally loaded classes or resources.
protected long[]
lastModifiedDates
The list of JARs last modified dates, in the order they should be searched for locally loaded classes or resources.
protected String[]
paths
The list of resources which should be checked when checking for modifications.
private ArrayList
permissionList
A list of read File and Jndi Permission's required if this loader is for a web application context.
private File
loaderDir
Path where resources loaded from JARs will be extracted.
private HashMap
loaderPC
The PermissionCollection for each CodeSource for a web application context.
private SecurityManager
securityManager
Instance of the SecurityManager installed.
private ClassLoader
parent
The parent class loader.
private ClassLoader
system
The system class loader.
protected boolean
started
Has this component been started?
protected boolean
hasExternalRepositories
Has external repositories.
private Permission
allPermission
All permission.
ArrayList
byteCodePreprocessors
List of byte code pre-processors per webapp class loader.
private boolean
useMyFaces
Constructors Summary
public WebappClassLoader()
Construct a new ClassLoader with no defined repositories and no parent ClassLoader.



    // ----------------------------------------------------------- Constructors


                     
      
        super(new URL[0]);
        init();
public WebappClassLoader(ClassLoader parent)
Construct a new ClassLoader with no defined repositories and no parent ClassLoader.

        super(new URL[0], parent);
        init();
Methods Summary
public voidaddByteCodePreprocessor(com.sun.appserv.BytecodePreprocessor preprocessor)

        byteCodePreprocessors.add(preprocessor);
synchronized voidaddJar(java.lang.String jar, java.util.jar.JarFile jarFile, java.io.File file)


        if (jar == null)
            return;
        if (jarFile == null)
            return;
        if (file == null)
            return;

        if (log.isTraceEnabled())
            log.trace("addJar(" + jar + ")");

        int i;

        if ((jarPath != null) && (jar.startsWith(jarPath))) {

            String jarName = jar.substring(jarPath.length());
            while (jarName.startsWith("/"))
                jarName = jarName.substring(1);

            String[] result = new String[jarNames.length + 1];
            for (i = 0; i < jarNames.length; i++) {
                result[i] = jarNames[i];
            }
            result[jarNames.length] = jarName;
            jarNames = result;

        }

        try {

            // Register the JAR for tracking

            long lastModified =
                ((ResourceAttributes) resources.getAttributes(jar))
                .getLastModified();

            String[] result = new String[paths.length + 1];
            for (i = 0; i < paths.length; i++) {
                result[i] = paths[i];
            }
            result[paths.length] = jar;
            paths = result;

            long[] result3 = new long[lastModifiedDates.length + 1];
            for (i = 0; i < lastModifiedDates.length; i++) {
                result3[i] = lastModifiedDates[i];
            }
            result3[lastModifiedDates.length] = lastModified;
            lastModifiedDates = result3;

        } catch (NamingException e) {
            // Ignore
        }

        // If the JAR currently contains invalid classes, don't actually use it
        // for classloading
        if (!validateJarFile(file))
            return;

        JarFile[] result2 = new JarFile[jarFiles.length + 1];
        for (i = 0; i < jarFiles.length; i++) {
            result2[i] = jarFiles[i];
        }
        result2[jarFiles.length] = jarFile;
        jarFiles = result2;

        // Add the file to the list
        File[] result4 = new File[jarRealFiles.length + 1];
        for (i = 0; i < jarRealFiles.length; i++) {
            result4[i] = jarRealFiles[i];
        }
        result4[jarRealFiles.length] = file;
        jarRealFiles = result4;
public voidaddLifecycleListener(org.apache.catalina.LifecycleListener listener)
Add a lifecycle event listener to this component.

param
listener The listener to add
public voidaddOverridablePackage(java.lang.String packageName)
Adds the given package name to the list of packages that may always be overriden, regardless of whether they belong to a protected namespace


    // ------------------------------------------------------------- Properties
    
    // START PE 4985680
                                 
       
        if (overridablePackages == null){
            overridablePackages = new ArrayList();
        }
        overridablePackages.add(packageName);
public voidaddPermission(java.lang.String path)
If there is a Java SecurityManager create a read FilePermission or JndiPermission for the file directory path.

param
path file directory path

        if (path == null) {
            return;
        }

        if (securityManager != null) {
            Permission permission = null;
            if( path.startsWith("jndi:") || path.startsWith("jar:jndi:") ) {
                if (!path.endsWith("/")) {
                    path = path + "/";
                }
                permission = new JndiPermission(path + "*");
                addPermission(permission);
            } else {
                if (!path.endsWith(File.separator)) {
                    permission = new FilePermission(path, "read");
                    addPermission(permission);
                    path = path + File.separator;
                }
                permission = new FilePermission(path + "-", "read");
                addPermission(permission);
            }
        }
public voidaddPermission(java.net.URL url)
If there is a Java SecurityManager create a read FilePermission or JndiPermission for URL.

param
url URL for a file or directory on local system

        if (url != null) {
            addPermission(url.toString());
        }
public voidaddPermission(java.security.Permission permission)
If there is a Java SecurityManager create a Permission.

param
url URL for a file or directory on local system

        if ((securityManager != null) && (permission != null)) {
            permissionList.add(permission);
        }
public voidaddRepository(java.lang.String repository)
Add a new repository to the set of places this ClassLoader can look for classes to be loaded.

param
repository Name of a source of classes to be loaded, such as a directory pathname, a JAR file pathname, or a ZIP file pathname
exception
IllegalArgumentException if the specified repository is invalid or does not exist


        // Ignore any of the standard repositories, as they are set up using
        // either addJar or addRepository
        if (repository.startsWith("/WEB-INF/lib")
            || repository.startsWith("/WEB-INF/classes"))
            return;

        // Add this repository to our underlying class loader
        try {
            URL url = new URL(repository);
            super.addURL(url);
            hasExternalRepositories = true;
        } catch (MalformedURLException e) {
            IllegalArgumentException iae = new IllegalArgumentException
                ("Invalid repository: " + repository);
            iae.initCause(e);
            throw iae;
        }
synchronized voidaddRepository(java.lang.String repository, java.io.File file)
Add a new repository to the set of places this ClassLoader can look for classes to be loaded.

param
repository Name of a source of classes to be loaded, such as a directory pathname, a JAR file pathname, or a ZIP file pathname
exception
IllegalArgumentException if the specified repository is invalid or does not exist


        // Note : There should be only one (of course), but I think we should
        // keep this a bit generic

        if (repository == null)
            return;

        if (log.isTraceEnabled())
            log.trace("addRepository(" + repository + ")");

        int i;

        // Add this repository to our internal list
        String[] result = new String[repositories.length + 1];
        for (i = 0; i < repositories.length; i++) {
            result[i] = repositories[i];
        }
        result[repositories.length] = repository;
        repositories = result;

        // Add the file to the list
        File[] result2 = new File[files.length + 1];
        for (i = 0; i < files.length; i++) {
            result2[i] = files[i];
        }
        result2[files.length] = file;
        files = result2;
protected voidclearReferences()
Clear references.


        // Unregister any JDBC drivers loaded by this classloader
        Enumeration drivers = DriverManager.getDrivers();
        while (drivers.hasMoreElements()) {
            Driver driver = (Driver) drivers.nextElement();
            if (driver.getClass().getClassLoader() == this) {
                try {
                    DriverManager.deregisterDriver(driver);
                } catch (SQLException e) {
                    log.warn("SQL driver deregistration failed", e);
                }
            }
        }
        
        // Null out any static or final fields from loaded classes,
        // as a workaround for apparent garbage collection bugs
        Iterator loadedClasses = ((HashMap) resourceEntries.clone()).values().
                                    iterator();
        while (loadedClasses.hasNext()) {
            ResourceEntry entry = (ResourceEntry) loadedClasses.next();
            if (entry.loadedClass != null) {
                Class clazz = entry.loadedClass;
                try {
                    Field[] fields = clazz.getDeclaredFields();
                    for (int i = 0; i < fields.length; i++) {
                        Field field = fields[i];
                        int mods = field.getModifiers();
                        if (field.getType().isPrimitive() 
                                || (field.getName().indexOf("$") != -1)) {
                            continue;
                        }
                        if (Modifier.isStatic(mods)) {
                            try {
                                field.setAccessible(true);
                                if (Modifier.isFinal(mods)) {
                                    if (!((field.getType().getName().startsWith("java."))
                                            || (field.getType().getName().startsWith("javax.")))) {
                                        nullInstance(field.get(null));
                                    }
                                } else {
                                    field.set(null, null);
                                    if (log.isDebugEnabled()) {
                                        log.debug("Set field " + field.getName() 
                                                + " to null in class " + clazz.getName());
                                    }
                                }
                            } catch (Throwable t) {
                                if (log.isDebugEnabled()) {
                                    log.debug("Could not set field " + field.getName() 
                                            + " to null in class " + clazz.getName(), t);
                                }
                            }
                        }
                    }
                } catch (Throwable t) {
                    if (log.isDebugEnabled()) {
                        log.debug("Could not clean fields for class " + clazz.getName(), t);
                    }
                }
            }
        }

        // START SJSAS 6390584
        com.sun.org.apache.commons.beanutils.PropertyUtils.clearDescriptors();
        // END SJSAS 6390584
        
        // Clear the IntrospectionUtils cache.
        IntrospectionUtils.clear();
       
        MappedPropertyDescriptor.clear();

        // START S1AS 5032338
        //com.sun.org.apache.commons.logging.LogFactory.release(this);
        // Clear the classloader reference in commons-logging.
        LogFactory.release(this);
        // END S1AS 5032338
        
        // Clear the classloader reference in the VM's bean introspector
        java.beans.Introspector.flushCaches();
public voidcloseJARs(boolean force)
Used to periodically signal to the classloader to release JAR resources.

        if (jarFiles.length > 0) {
            synchronized (jarFiles) {
                if (force || (System.currentTimeMillis() 
                              > (lastJarAccessed + 90000))) {
                    for (int i = 0; i < jarFiles.length; i++) {
                        try {
                            if (jarFiles[i] != null) {
                                jarFiles[i].close();
                                jarFiles[i] = null;
                            }
                        } catch (IOException e) {
                            if (log.isDebugEnabled()) {
                                log.warn("Failed to close JAR", e);
                            }
                        }
                    }
                }
            }
        }
protected static voiddeleteDir(java.io.File dir)
Delete the specified directory, including all of its contents and subdirectories recursively.

param
dir File object representing the directory to be deleted


        String files[] = dir.list();
        if (files == null) {
            files = new String[0];
        }
        for (int i = 0; i < files.length; i++) {
            File file = new File(dir, files[i]);
            if (file.isDirectory()) {
                deleteDir(file);
            } else {
                file.delete();
            }
        }
        dir.delete();
protected booleanfilter(java.lang.String name)
Filter classes.

param
name class name
return
true if the class should be filtered


        if (name == null)
            return false;

        // START PE 4985680
        // Special case for performance reason.
        if (name.startsWith("java."))
            return true;
        // END PE 4985680

        // Looking up the package
        String packageName = null;
        int pos = name.lastIndexOf('.");
        if (pos != -1)
            packageName = name.substring(0, pos);
        else
            return false;
        
        if (overridablePackages != null){
            for (int i = 0; i < overridablePackages.size(); i++) {
                if (packageName.
                        startsWith((String)overridablePackages.get(i)))
                    return false;
            }
        }

        for (int i = 0; i < packageTriggers.length; i++) {
            if (packageName.startsWith(packageTriggers[i]))
                return true;
        }

        return false;
public java.lang.ClassfindClass(java.lang.String name)
Find the specified class in our local repositories, if possible. If not found, throw ClassNotFoundException.

param
name Name of the class to be loaded
exception
ClassNotFoundException if the class was not found


        if (log.isTraceEnabled())
            log.trace("    findClass(" + name + ")");

        // (1) Permission to define this class when using a SecurityManager
        // START PE 4989455
        //if (securityManager != null) {
        if (SecurityUtil.isPackageProtectionEnabled()){    
        // END PE 4989455
            int i = name.lastIndexOf('.");
            if (i >= 0) {
                try {
                    if (log.isTraceEnabled())
                        log.trace("      securityManager.checkPackageDefinition");
                    securityManager.checkPackageDefinition(name.substring(0,i));
                } catch (Exception se) {
                    if (log.isTraceEnabled())
                        log.trace("      -->Exception-->ClassNotFoundException", se);
                    throw new ClassNotFoundException(name, se);
                }
            }
        }

        // Ask our superclass to locate this class, if possible
        // (throws ClassNotFoundException if it is not found)
        Class clazz = null;
        try {
            if (log.isTraceEnabled())
                log.trace("      findClassInternal(" + name + ")");
            try {
                ResourceEntry entry = findClassInternal(name);
                // Create the code source object
                CodeSource codeSource =
                    new CodeSource(entry.codeBase, entry.certificates);
                synchronized (this) {
                    if (entry.loadedClass == null) {
                        /* START GlassFish [680]
                        clazz = defineClass(name, entry.binaryContent, 0,
                                entry.binaryContent.length, 
                                codeSource);
                        */
                        // START GlassFish [680]
                        // We use a temporary byte[] so that we don't change
                        // the content of entry in case bytecode
                        // preprocessing takes place.
                        byte[] binaryContent = entry.binaryContent;
                        if (!byteCodePreprocessors.isEmpty()) {
                            // ByteCodePreprpcessor expects name as
                            // java/lang/Object.class
                            String resourceName =
                                name.replace('.", '/") + ".class";
                            for(BytecodePreprocessor preprocessor : byteCodePreprocessors) {
                                binaryContent = preprocessor.preprocess(
                                    resourceName, binaryContent);
                            }
                        }
                        clazz = defineClass(name, binaryContent, 0,
                                binaryContent.length,
                                codeSource);
                        // END GlassFish [680]
                        entry.loadedClass = clazz;
                        entry.binaryContent = null;
                        entry.source = null;
                        entry.codeBase = null;
                        entry.manifest = null;
                        entry.certificates = null;
                    } else {
                        clazz = entry.loadedClass;
                    }
                }
            } catch(ClassNotFoundException cnfe) {
                if (!hasExternalRepositories) {
                    throw cnfe;
                }
            } catch (UnsupportedClassVersionError ucve) {
                throw new UnsupportedClassVersionError(
                    sm.getString("webappLoader.unsupportedVersion", name,
                                 getJavaVersion()));
            } catch(AccessControlException ace) {
                throw new ClassNotFoundException(name, ace);
            } catch (RuntimeException e) {
                if (log.isTraceEnabled())
                    log.trace("      -->RuntimeException Rethrown", e);
                throw e;
            }
            if ((clazz == null) && hasExternalRepositories) {
                try {
                    clazz = super.findClass(name);
                } catch(AccessControlException ace) {
                    throw new ClassNotFoundException(name, ace);
                } catch (RuntimeException e) {
                    if (log.isTraceEnabled())
                        log.trace("      -->RuntimeException Rethrown", e);
                    throw e;
                }
            }
            if (clazz == null) {
                if (log.isTraceEnabled())
                    log.trace("    --> Returning ClassNotFoundException");
                throw new ClassNotFoundException(name);
            }
        } catch (ClassNotFoundException e) {
            if (log.isTraceEnabled())
                log.trace("    --> Passing on ClassNotFoundException");
            throw e;
        }

        // Return the class we have located
        if (log.isTraceEnabled())
            log.trace("      Returning class " + clazz);
        if ((log.isTraceEnabled()) && (clazz != null))
            log.trace("      Loaded by " + clazz.getClassLoader());
        return (clazz);
protected ResourceEntryfindClassInternal(java.lang.String name)
Find specified class in local repositories.

return
the loaded class, or null if the class isn't found


        if (!validate(name))
            throw new ClassNotFoundException(name);

        String tempPath = name.replace('.", '/");
        String classPath = tempPath + ".class";

        ResourceEntry entry = findResourceInternal(name, classPath);

        if (entry == null)
               throw new ClassNotFoundException(name);

        Class clazz = entry.loadedClass;
        if (clazz != null)
            return entry;

        synchronized (this) {
            if (entry.binaryContent == null && entry.loadedClass == null)
                throw new ClassNotFoundException(name);
        }

        // Looking up the package
        String packageName = null;
        int pos = name.lastIndexOf('.");
        if (pos != -1)
            packageName = name.substring(0, pos);

        Package pkg = null;

        if (packageName != null) {

// START OF IASRI 4717252
          synchronized (loaderPC) {
// END OF IASRI 4717252
            pkg = getPackage(packageName);

            // Define the package (if null)
            if (pkg == null) {
                if (entry.manifest == null) {
                    definePackage(packageName, null, null, null, null, null,
                                  null, null);
                } else {
                    definePackage(packageName, entry.manifest, entry.codeBase);
                }
            }
// START OF IASRI 4717252
          }
// END OF IASRI 4717252
        }

        if (securityManager != null) {

            // Checking sealing
            if (pkg != null) {
                boolean sealCheck = true;
                if (pkg.isSealed()) {
                    sealCheck = pkg.isSealed(entry.codeBase);
                } else {
                    sealCheck = (entry.manifest == null)
                        || !isPackageSealed(packageName, entry.manifest);
                }
                if (!sealCheck)
                    throw new SecurityException
                        ("Sealing violation loading " + name + " : Package "
                         + packageName + " is sealed.");
            }

        }

        return entry;
public org.apache.catalina.LifecycleListener[]findLifecycleListeners()
Get the lifecycle listeners associated with this lifecycle. If this Lifecycle has no listeners registered, a zero-length array is returned.

        return new LifecycleListener[0];
protected java.lang.ClassfindLoadedClass0(java.lang.String name)
Finds the class with the given name if it has previously been loaded and cached by this class loader, and return the Class object. If this class has not been cached, return null.

param
name Name of the resource to return


        ResourceEntry entry = (ResourceEntry) resourceEntries.get(name);
        if (entry != null) {
            return entry.loadedClass;
        }
        return (null);  // FIXME - findLoadedResource()
protected java.io.InputStreamfindLoadedResource(java.lang.String name)
Finds the resource with the given name if it has previously been loaded and cached by this class loader, and return an input stream to the resource data. If this resource has not been cached, return null.

param
name Name of the resource to return


        ResourceEntry entry = (ResourceEntry) resourceEntries.get(name);
        if (entry != null) {
            if (entry.binaryContent != null)
                return new ByteArrayInputStream(entry.binaryContent);
        }
        return (null);
public java.lang.String[]findRepositories()
Return a String array of the current repositories for this class loader. If there are no repositories, a zero-length array is returned.For security reason, returns a clone of the Array (since String are immutable).


        return ((String[])repositories.clone());
public java.net.URLfindResource(java.lang.String name)
Find the specified resource in our local repository, and return a URL refering to it, or null if this resource cannot be found.

param
name Name of the resource to be found


        if (log.isTraceEnabled())
            log.trace("    findResource(" + name + ")");

        URL url = null;

        ResourceEntry entry = (ResourceEntry) resourceEntries.get(name);
        if (entry == null) {
            entry = findResourceInternal(name, name);
        }
        if (entry != null) {
            url = entry.source;
        }

        if ((url == null) && hasExternalRepositories)
            url = super.findResource(name);

        if (log.isTraceEnabled()) {
            if (url != null)
                log.trace("    --> Returning '" + url.toString() + "'");
            else
                log.trace("    --> Resource not found, returning null");
        }
        return (url);
private ResourceEntryfindResourceInternal(java.io.File file, java.lang.String path)
Find specified resource in local repositories. This block will execute under an AccessControl.doPrivilege block.

return
the loaded resource, or null if the resource isn't found

        ResourceEntry entry = new ResourceEntry();
        try {
            entry.source = getURI(new File(file, path));
            entry.codeBase = getURL(new File(file, path));
        } catch (MalformedURLException e) {
            return null;
        }   
        return entry;
protected ResourceEntryfindResourceInternal(java.lang.String name, java.lang.String path)
Attempts to find the specified resource in local repositories.

return
the loaded resource, or null if the resource isn't found


        if (!started) {
            log.info(sm.getString("webappClassLoader.stopped"));
            return null;
        }

        if ((name == null) || (path == null)) {
            return null;
        }

        ResourceEntry entry = (ResourceEntry) resourceEntries.get(name);
        if (entry != null) {
            return entry;
        } else if (notFoundResources.containsKey(name)) {
            return null;
        }

        entry = findResourceInternalFromRepositories(name, path);
        if (entry == null) {
            synchronized (jarFiles) {
                entry = findResourceInternalFromJars(name, path);
            }
        }

        if (entry == null) {
            synchronized (notFoundResources) {
                notFoundResources.put(name, name);
            }
            return null;
        }

        // Add the entry in the local resource repository
        synchronized (resourceEntries) {
            // Ensures that all the threads which may be in a race to load
            // a particular class all end up with the same ResourceEntry
            // instance
            ResourceEntry entry2 = (ResourceEntry) resourceEntries.get(name);
            if (entry2 == null) {
                resourceEntries.put(name, entry);
            } else {
                entry = entry2;
            }
        }

        return entry;
private ResourceEntryfindResourceInternalFromJars(java.lang.String name, java.lang.String path)
Attempts to load the requested resource from this classloader's JAR files.

return
The requested resource, or null if not found


        ResourceEntry entry = null;
        JarEntry jarEntry = null;
        int contentLength = -1;
        InputStream binaryStream = null;

        if (!openJARs()){
            return null;
        }

        int jarFilesLength = jarFiles.length;

        for (int i=0; (entry == null) && (i < jarFilesLength); i++) {
            jarEntry = jarFiles[i].getJarEntry(path);

            if (jarEntry != null) {

                entry = new ResourceEntry();
                try {
                    entry.codeBase = getURL(jarRealFiles[i]);
                    String jarFakeUrl = getURI(jarRealFiles[i]).toString();
                    jarFakeUrl = "jar:" + jarFakeUrl + "!/" + path;
                    entry.source = new URL(jarFakeUrl);
                    entry.lastModified = jarRealFiles[i].lastModified();
                } catch (MalformedURLException e) {
                    return null;
                }

                contentLength = (int) jarEntry.getSize();
                try {
                    entry.manifest = jarFiles[i].getManifest();
                    binaryStream = jarFiles[i].getInputStream(jarEntry);
                } catch (IOException e) {
                    return null;
                }

                // Extract resources contained in JAR to the workdir
                if (!(path.endsWith(".class"))) {
                    byte[] buf = new byte[1024];
                    File resourceFile = new File
                        (loaderDir, jarEntry.getName());
                    if (!resourceFile.exists()) {
                        Enumeration entries = jarFiles[i].entries();
                        while (entries.hasMoreElements()) {
                            JarEntry jarEntry2 = 
                                (JarEntry) entries.nextElement();
                            if (!(jarEntry2.isDirectory()) 
                                && (!jarEntry2.getName().endsWith(".class"))) {
                                resourceFile = new File
                                    (loaderDir, jarEntry2.getName());
                                resourceFile.getParentFile().mkdirs();
                                FileOutputStream os = null;
                                InputStream is = null;
                                try {
                                    is = jarFiles[i].getInputStream(jarEntry2);
                                    os = new FileOutputStream(resourceFile);
                                    while (true) {
                                        int n = is.read(buf);
                                        if (n <= 0) {
                                            break;
                                        }
                                        os.write(buf, 0, n);
                                    }
                                } catch (IOException e) {
                                    // Ignore
                                } finally {
                                    try {
                                        if (is != null) {
                                            is.close();
                                        }
                                    } catch (IOException e) {
                                    }
                                    try {
                                        if (os != null) {
                                            os.close();
                                        }
                                    } catch (IOException e) {
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }

        if (entry != null) {
            readEntryData(entry, name, binaryStream, contentLength, jarEntry);
        }

        return entry;
private ResourceEntryfindResourceInternalFromRepositories(java.lang.String name, java.lang.String path)
Attempts to load the requested resource from this classloader's internal repositories.

return
The requested resource, or null if not found


        ResourceEntry entry = null;
        int contentLength = -1;
        InputStream binaryStream = null;
        int repositoriesLength = repositories.length;
        Resource resource = null;

        for (int i=0; (entry == null) && (i < repositoriesLength); i++) {

            try {

                String fullPath = repositories[i] + path;

                Object lookupResult = resources.lookup(fullPath);
                if (lookupResult instanceof Resource) {
                    resource = (Resource) lookupResult;
                }

                // Note : Not getting an exception here means the resource was
                // found
                 if (securityManager != null) {
                    PrivilegedAction dp =
                        new PrivilegedFindResource(files[i], path);
                    entry = (ResourceEntry)AccessController.doPrivileged(dp);
                 } else {
                    entry = findResourceInternal(files[i], path);
                 }

                ResourceAttributes attributes =
                    (ResourceAttributes) resources.getAttributes(fullPath);
                contentLength = (int) attributes.getContentLength();
                entry.lastModified = attributes.getLastModified();

                if (resource != null) {

                    try {
                        binaryStream = resource.streamContent();
                    } catch (IOException e) {
                        return null;
                    }

                    // Register the full path for modification checking
                    // Note: Only syncing on a 'constant' object is needed
                    synchronized (allPermission) {

                        int j;

                        long[] result2 = 
                            new long[lastModifiedDates.length + 1];
                        for (j = 0; j < lastModifiedDates.length; j++) {
                            result2[j] = lastModifiedDates[j];
                        }
                        result2[lastModifiedDates.length] = entry.lastModified;
                        lastModifiedDates = result2;

                        String[] result = new String[paths.length + 1];
                        for (j = 0; j < paths.length; j++) {
                            result[j] = paths[j];
                        }
                        result[paths.length] = fullPath;
                        paths = result;

                    }
                }
            } catch (NamingException e) {
            }
        }

        if (entry != null) {
            readEntryData(entry, name, binaryStream, contentLength, null);
        }

        return entry;
public java.util.EnumerationfindResources(java.lang.String name)
Return an enumeration of URLs representing all of the resources with the given name. If no resources with this name are found, return an empty enumeration.

param
name Name of the resources to be found
exception
IOException if an input/output error occurs


        if (log.isTraceEnabled())
            log.trace("    findResources(" + name + ")");

        Vector result = new Vector();

        int jarFilesLength = jarFiles.length;
        int repositoriesLength = repositories.length;

        int i;

        // Looking at the repositories
        for (i = 0; i < repositoriesLength; i++) {
            try {
                String fullPath = repositories[i] + name;
                resources.lookup(fullPath);
                // Note : Not getting an exception here means the resource was
                // found
                try {
                    result.addElement(getURI(new File(files[i], name)));
                } catch (MalformedURLException e) {
                    // Ignore
                }
            } catch (NamingException e) {
            }
        }

        // Looking at the JAR files
        synchronized (jarFiles) {
            if (openJARs()) {
                for (i = 0; i < jarFilesLength; i++) {
                    JarEntry jarEntry = jarFiles[i].getJarEntry(name);
                    if (jarEntry != null) {
                        try {
                            String jarFakeUrl = getURI(jarRealFiles[i]).toString();
                            jarFakeUrl = "jar:" + jarFakeUrl + "!/" + name;
                            result.addElement(new URL(jarFakeUrl));
                        } catch (MalformedURLException e) {
                            // Ignore
                        }
                    }
                }
            }
        }

        // Adding the results of a call to the superclass
        if (hasExternalRepositories) {

            Enumeration otherResourcePaths = super.findResources(name);

            while (otherResourcePaths.hasMoreElements()) {
                result.addElement(otherResourcePaths.nextElement());
            }

        }

        return result.elements();
public intgetDebug()
Return the debugging detail level for this component.


        return (this.debug);
public booleangetDelegate()
Return the "delegate first" flag for this class loader.


        return (this.delegate);
public java.lang.StringgetJarPath()
Return the JAR path.


        return this.jarPath;
private java.lang.StringgetJavaVersion()


        String version = null;

	SecurityManager sm = System.getSecurityManager();
	if (sm != null) {
            version = (String) AccessController.doPrivileged(
                new PrivilegedAction() {
                    public Object run() {
                        return System.getProperty("java.version");
                    }
            });
        } else {
            version = System.getProperty("java.version");
        }

        return version;
protected java.security.PermissionCollectiongetPermissions(java.security.CodeSource codeSource)
Get the Permissions for a CodeSource. If this instance of WebappClassLoader is for a web application context, add read FilePermission or JndiPermissions for the base directory (if unpacked), the context URL, and jar file resources.

param
CodeSource where the code was loaded from
return
PermissionCollection for CodeSource


        String codeUrl = codeSource.getLocation().toString();
        PermissionCollection pc;
        if ((pc = (PermissionCollection)loaderPC.get(codeUrl)) == null) {
            pc = super.getPermissions(codeSource);
            if (pc != null) {
                Iterator perms = permissionList.iterator();
                while (perms.hasNext()) {
                    Permission p = (Permission)perms.next();
                    pc.add(p);
                }
                loaderPC.put(codeUrl,pc);
            }
        }
        return (pc);
public java.net.URLgetResource(java.lang.String name)
Find the resource with the given name. A resource is some data (images, audio, text, etc.) that can be accessed by class code in a way that is independent of the location of the code. The name of a resource is a "/"-separated path name that identifies the resource. If the resource cannot be found, return null.

This method searches according to the following algorithm, returning as soon as it finds the appropriate URL. If the resource cannot be found, returns null.

  • If the delegate property is set to true, call the getResource() method of the parent class loader, if any.
  • Call findResource() to find this resource in our locally defined repositories.
  • Call the getResource() method of the parent class loader, if any.

param
name Name of the resource to return a URL for


        if (log.isTraceEnabled())
            log.trace("getResource(" + name + ")");
        URL url = null;

        /*
         * (1) Delegate to parent if requested, or if the requested resource
         * belongs to one of the packages that are part of the Java EE platform
         */
        if (delegate
                || name.startsWith("javax")
                || name.startsWith("sun")
                || (name.startsWith("com/sun/faces")
                    && !name.startsWith("com/sun/faces/extensions"))
                || name.startsWith("org/apache/taglibs/standard")) {
            if (log.isTraceEnabled())
                log.trace("  Delegating to parent classloader " + parent);
            ClassLoader loader = parent;
            if (loader == null)
                loader = system;
            url = loader.getResource(name);
            if (url != null) {
                if (log.isTraceEnabled())
                    log.trace("  --> Returning '" + url.toString() + "'");
                return (url);
            }
        }

        // (2) Search local repositories
        url = findResource(name);
        if (url != null) {
            // Locating the repository for special handling in the case 
            // of a JAR
            ResourceEntry entry = (ResourceEntry) resourceEntries.get(name);
            try {
                String repository = entry.codeBase.toString();
                if ((repository.endsWith(".jar"))
                        && !(name.endsWith(".class"))
                        && !(name.endsWith(".jar"))) {
                    // Copy binary content to the work directory if not present
                    File resourceFile = new File(loaderDir, name);
                    url = resourceFile.toURL();
                }
            } catch (Exception e) {
                // Ignore
            }
            if (log.isTraceEnabled())
                log.trace("  --> Returning '" + url.toString() + "'");
            return (url);
        }

        // (3) Delegate to parent unconditionally if not already attempted
        if( !delegate ) {
            ClassLoader loader = parent;
            if (loader == null)
                loader = system;
            url = loader.getResource(name);
            if (url != null) {
                if (log.isTraceEnabled())
                    log.trace("  --> Returning '" + url.toString() + "'");
                return (url);
            }
        }

        // (4) Resource was not found
        if (log.isTraceEnabled())
            log.trace("  --> Resource not found, returning null");
        return (null);
public java.io.InputStreamgetResourceAsStream(java.lang.String name)
Find the resource with the given name, and return an input stream that can be used for reading it. The search order is as described for getResource(), after checking to see if the resource data has been previously cached. If the resource cannot be found, return null.

param
name Name of the resource to return an input stream for


        if (log.isTraceEnabled())
            log.trace("getResourceAsStream(" + name + ")");
        InputStream stream = null;

        // (0) Check for a cached copy of this resource
        stream = findLoadedResource(name);
        if (stream != null) {
            if (log.isTraceEnabled())
                log.trace("  --> Returning stream from cache");
            return (stream);
        }

        /*
         * (1) Delegate to parent if requested, or if the requested resource
         * belongs to one of the packages that are part of the Java EE platform
         */
        if (delegate
                || name.startsWith("javax")
                || name.startsWith("sun")
                || (name.startsWith("com/sun/faces")
                    && !name.startsWith("com/sun/faces/extensions"))
                || name.startsWith("org/apache/taglibs/standard")) {
            if (log.isTraceEnabled())
                log.trace("  Delegating to parent classloader " + parent);
            ClassLoader loader = parent;
            if (loader == null)
                loader = system;
            stream = loader.getResourceAsStream(name);
            if (stream != null) {
                // FIXME - cache???
                if (log.isTraceEnabled())
                    log.trace("  --> Returning stream from parent");
                return (stream);
            }
        }

        // (2) Search local repositories
        if (log.isTraceEnabled())
            log.trace("  Searching local repositories");
        URL url = findResource(name);
        if (url != null) {
            // FIXME - cache???
            if (log.isTraceEnabled())
                log.trace("  --> Returning stream from local");
            stream = findLoadedResource(name);
            try {
                if (hasExternalRepositories && (stream == null))
                    stream = url.openStream();
            } catch (IOException e) {
                ; // Ignore
            }
            if (stream != null)
                return (stream);
        }

        // (3) Delegate to parent unconditionally
        if (!delegate) {
            if (log.isTraceEnabled())
                log.trace("  Delegating to parent classloader unconditionally " + parent);
            ClassLoader loader = parent;
            if (loader == null)
                loader = system;
            stream = loader.getResourceAsStream(name);
            if (stream != null) {
                // FIXME - cache???
                if (log.isTraceEnabled())
                    log.trace("  --> Returning stream from parent");
                return (stream);
            }
        }

        // (4) Resource was not found
        if (log.isTraceEnabled())
            log.trace("  --> Resource not found, returning null");
        return (null);
public javax.naming.directory.DirContextgetResources()
Get associated resources.


        return this.resources;
protected java.net.URLgetURI(java.io.File file)
Get URL.


        return jdkCompat.getURI(file);
protected java.net.URLgetURL(java.io.File file)
Get URL.


        File realFile = file;
        try {
            realFile = realFile.getCanonicalFile();
        } catch (IOException e) {
            // Ignore
        }
        return realFile.toURL();
public java.net.URL[]getURLs()
Returns the search path of URLs for loading classes and resources. This includes the original list of URLs specified to the constructor, along with any URLs subsequently appended by the addURL() method.

return
the search path of URLs for loading classes and resources.


        if (repositoryURLs != null) {
            return repositoryURLs;
        }

        URL[] external = super.getURLs();

        int filesLength = files.length;
        int jarFilesLength = jarRealFiles.length;
        int length = filesLength + jarFilesLength + external.length;
        int i;

        try {

            URL[] urls = new URL[length];
            for (i = 0; i < length; i++) {
                if (i < filesLength) {
                    urls[i] = getURL(files[i]);
                } else if (i < filesLength + jarFilesLength) {
                    urls[i] = getURL(jarRealFiles[i - filesLength]);
                } else {
                    urls[i] = external[i - filesLength - jarFilesLength];
                }
            }

            repositoryURLs = urls;

        } catch (MalformedURLException e) {
            repositoryURLs = new URL[0];
        }

        return repositoryURLs;
private voidinit()


        this.parent = getParent();

        /* SJSAS 6317864
        system = getSystemClassLoader();
        */
        // START SJSAS 6317864
        system = this.getClass().getClassLoader();
        // END SJSAS 6317864
        securityManager = System.getSecurityManager();

        if (securityManager != null) {
            refreshPolicy();
        }

        addOverridablePackage("com.sun.faces.extensions");
protected booleanisPackageSealed(java.lang.String name, java.util.jar.Manifest man)
Returns true if the specified package name is sealed according to the given manifest.


        String path = name + "/";
        Attributes attr = man.getAttributes(path);
        String sealed = null;
        if (attr != null) {
            sealed = attr.getValue(Name.SEALED);
        }
        if (sealed == null) {
            if ((attr = man.getMainAttributes()) != null) {
                sealed = attr.getValue(Name.SEALED);
            }
        }
        return "true".equalsIgnoreCase(sealed);
public java.lang.ClassloadClass(java.lang.String name)
Load the class with the specified name. This method searches for classes in the same manner as loadClass(String, boolean) with false as the second argument.

param
name Name of the class to be loaded
exception
ClassNotFoundException if the class was not found


        if (log.isTraceEnabled())
            log.trace("loadClass(" + name + ")");

        Class clazz = null;

        // Don't load classes if class loader is stopped
        if (!started) {
            log.info(sm.getString("webappClassLoader.stopped"));
            throw new ThreadDeath(); 
        }

        // (0) Check our previously loaded local class cache
        clazz = findLoadedClass0(name);
        if (clazz != null) {
            if (log.isTraceEnabled())
                log.trace("  Returning class from cache");
            return (clazz);
        }

        // (0.1) Check our previously loaded class cache
        clazz = findLoadedClass(name);
        if (clazz != null) {
            if (log.isTraceEnabled())
                log.trace("  Returning class from cache");
            return (clazz);
        }

        // START PE 4985680
        // (0.2) Try loading the class with the system class loader, to prevent
        //       the webapp from overriding J2SE classes
        /*
        try {
            clazz = system.loadClass(name);
            if (clazz != null) {
                if (resolve)
                    resolveClass(clazz);
                return (clazz);
            }
        } catch (ClassNotFoundException e) {
            // Ignore
        }
        */
        // END PE 4985680

        // (0.5) Permission to access this class when using a SecurityManager
        // START PE 4989455
        //if (securityManager != null) {
        if (SecurityUtil.isPackageProtectionEnabled()){    
        // END PE 4989455
            int i = name.lastIndexOf('.");
            if (i >= 0) {
                try {
                    securityManager.checkPackageAccess(name.substring(0,i));
                } catch (SecurityException se) {
                    String error = "Security Violation, attempt to use " +
                        "Restricted Class: " + name;
                    log.info(error, se);
                    throw new ClassNotFoundException(error, se);
                }
            }
        }

        // START PE 4985680
        // boolean delegateLoad = delegate ||filter(name);
        boolean delegateLoad = delegate;
        // END PE 4985680

        // (1) Delegate to our parent if requested
        if (delegateLoad) {
            if (log.isTraceEnabled())
                log.trace("  Delegating to parent classloader1 " + parent);
            ClassLoader loader = parent;
            if (loader == null) 
                loader = system;

            // START PE 4985680
            try {
                clazz = loader.loadClass(name);
                if (clazz != null) {
                    if (log.isTraceEnabled())
                        log.trace("  Loading class from parent");
                    return (clazz);
                }
            } catch (ClassNotFoundException e) {
                ;
            }
            // END PE 4985680    
        }

        // (2) Search local repositories
        // START PE 4985680
        boolean filterCoreClasses = filter(name);
        if ( !filterCoreClasses ) {
            // (2) Search local repositories
        // END PE 4985680    
            if (log.isTraceEnabled())
                log.trace("  Searching local repositories");
            try {
                clazz = findClass(name);
                if (clazz != null) {
                    if (log.isTraceEnabled())
                        log.trace("  Loading class from local repository");
                    return (clazz);
                }
            } catch (ClassNotFoundException e) {
                ;
            }
        }

        // START PE 4985680
        // (3) Delegate to parent unconditionally
        /*
        if (!delegateLoad) {
            if (log.isTraceEnabled())
                log.trace("  Delegating to parent classloader at end: " + parent);
            ClassLoader loader = parent;
            if (loader == null)
                loader = system;
            try {
                clazz = loader.loadClass(name);
        */

        // (3) Delegate to system unconditionally
        if (log.isTraceEnabled())
            log.trace("  Delegating to system classloader at end: " + parent);

        try {
            clazz = system.loadClass(name);
        // END PE 4985680
            if (clazz != null) {
                if (log.isTraceEnabled())
                // START PE 4985680
                    //log.debug("  Loading class from parent");
                    log.trace("  Loading class from system");
                // END PE 4985680
                return (clazz);
            }
        } catch (ClassNotFoundException e) {
            ;
        }

        // START PE 4985680
        // (4) Delegate to parent finally if the class wasn't found 
        try {
            if (log.isTraceEnabled())
                log.trace("  Delegating to parent classloader " + parent);
            ClassLoader loader = parent;
            if (loader != null) {

                clazz = parent.loadClass(name);
                if (log.isTraceEnabled())
                    log.trace("  Loading class from parent");
                return (clazz);
            }
        } catch (ClassNotFoundException e) {
            ;
        }

        // if filter(..) return true and if we did not find
        // the class using the parent/system classloader,
        // then give a chance to this classloader.
        if ( filterCoreClasses ) {
            if (log.isTraceEnabled())
                log.trace("  Searching local repositories");
            clazz = findClass(name);
            if (clazz != null) {
                if (log.isTraceEnabled())
                    log.trace("  Loading class from local repository");
                return (clazz);
            }
        }
        // END PE 4985680

        throw new ClassNotFoundException(name);
public java.lang.ClassloadClass(java.lang.String name, boolean resolve)
Load the class with the specified name, searching using the following algorithm until it finds and returns the class. If the class cannot be found, returns ClassNotFoundException.
  • Call findLoadedClass(String) to check if the class has already been loaded. If it has, the same Class object is returned.
  • If the delegate property is set to true, call the loadClass() method of the parent class loader, if any.
  • Call findClass() to find this class in our locally defined repositories.
  • Call the loadClass() method of our parent class loader, if any.
If the class was found using the above steps, and the resolve flag is true, this method will then call resolveClass(Class) on the resulting Class object.

param
name Name of the class to be loaded
param
resolve If true then resolve the class
exception
ClassNotFoundException if the class was not found


        Class clazz = loadClass(name);
        if (clazz != null) {
            if (resolve) {
                resolveClass(clazz);
            }
            return (clazz);
        }

        throw new ClassNotFoundException(name);
protected booleanloadedByThisOrChild(java.lang.Class clazz)
Determine whether a class was loaded by this class loader or one of its child class loaders.

        boolean result = false;
        for (ClassLoader classLoader = clazz.getClassLoader();
                null != classLoader; classLoader = classLoader.getParent()) {
            if (classLoader.equals(this)) {
                result = true;
                break;
            }
        }
        return result;
public booleanmodified()
Have one or more classes or resources been modified so that a reload is appropriate?


        if (log.isTraceEnabled())
            log.trace("modified()");

        // Checking for modified loaded resources
        int length = paths.length;

        // A rare race condition can occur in the updates of the two arrays
        // It's totally ok if the latest class added is not checked (it will
        // be checked the next time
        int length2 = lastModifiedDates.length;
        if (length > length2)
            length = length2;

        for (int i = 0; i < length; i++) {
            try {
                long lastModified =
                    ((ResourceAttributes) resources.getAttributes(paths[i]))
                    .getLastModified();
                if (lastModified != lastModifiedDates[i]) {
                    if( log.isTraceEnabled() ) 
                        log.trace("  Resource '" + paths[i]
                                  + "' was modified; Date is now: "
                                  + new java.util.Date(lastModified) + " Was: "
                                  + new java.util.Date(lastModifiedDates[i]));
                    return (true);
                }
            } catch (NamingException e) {
                log.error("    Resource '" + paths[i] + "' is missing");
                return (true);
            }
        }

        length = jarNames.length;

        // Check if JARs have been added or removed
        if (getJarPath() != null) {

            try {
                NamingEnumeration enumeration = resources.listBindings(getJarPath());
                int i = 0;
                while (enumeration.hasMoreElements() && (i < length)) {
                    NameClassPair ncPair = (NameClassPair) enumeration.nextElement();
                    String name = ncPair.getName();
                    // Ignore non JARs present in the lib folder
// START OF IASRI 4657979
                    if (!name.endsWith(".jar") && !name.endsWith(".zip"))
// END OF IASRI 4657979
                        continue;
                    if (!name.equals(jarNames[i])) {
                        // Missing JAR
                        log.info("    Additional JARs have been added : '" 
                                 + name + "'");
                        return (true);
                    }
                    i++;
                }
                if (enumeration.hasMoreElements()) {
                    while (enumeration.hasMoreElements()) {
                        NameClassPair ncPair = 
                            (NameClassPair) enumeration.nextElement();
                        String name = ncPair.getName();
                        // Additional non-JAR files are allowed
// START OF IASRI 4657979
                        if (name.endsWith(".jar") || name.endsWith(".zip")) {
// END OF IASRI 4657979
                            // There was more JARs
                            log.info("    Additional JARs have been added");
                            return (true);
                        }
                    }
                } else if (i < jarNames.length) {
                    // There was less JARs
                    log.info("    Additional JARs have been added");
                    return (true);
                }
            } catch (NamingException e) {
                if (log.isTraceEnabled())
                    log.trace("    Failed tracking modifications of '"
                        + getJarPath() + "'");
            } catch (ClassCastException e) {
                log.error("    Failed tracking modifications of '"
                          + getJarPath() + "' : " + e.getMessage());
            }

        }

        // No classes have been modified
        return (false);
protected voidnullInstance(java.lang.Object instance)

        if (instance == null) {
            return;
        }
        Field[] fields = instance.getClass().getDeclaredFields();
        for (int i = 0; i < fields.length; i++) {
            Field field = fields[i];
            int mods = field.getModifiers();
            if (field.getType().isPrimitive() 
                    || (field.getName().indexOf("$") != -1)) {
                continue;
            }
            try {
                field.setAccessible(true);
                if (Modifier.isStatic(mods) && Modifier.isFinal(mods)) {
                    // Doing something recursively is too risky
                    continue;
                } else {
                    Object value = field.get(instance);
                    if (null != value) {
                        Class valueClass = value.getClass();
                        if (!loadedByThisOrChild(valueClass)) {
                            if (log.isDebugEnabled()) {
                                log.debug("Not setting field " + field.getName() +
                                        " to null in object of class " + 
                                        instance.getClass().getName() +
                                        " because the referenced object was of type " +
                                        valueClass.getName() + 
                                        " which was not loaded by this WebappClassLoader.");
                            }
                        } else {
                            field.set(instance, null);
                            if (log.isDebugEnabled()) {
                                log.debug("Set field " + field.getName() 
                                        + " to null in class " + instance.getClass().getName());
                        }
                    }
                }
                }
            } catch (Throwable t) {
                if (log.isDebugEnabled()) {
                    log.debug("Could not set field " + field.getName() 
                            + " to null in object instance of class " 
                            + instance.getClass().getName(), t);
                }
            }
        }
protected booleanopenJARs()
Used to periodically signal to the classloader to release JAR resources.

        if (started && (jarFiles.length > 0)) {
            lastJarAccessed = System.currentTimeMillis();
            if (jarFiles[0] == null) {
                for (int i = 0; i < jarFiles.length; i++) {
                    try {
                        jarFiles[i] = new JarFile(jarRealFiles[i]);
                    } catch (IOException e) {
                        if (log.isDebugEnabled()) {
                            log.warn("Failed to open JAR", e);
                        }
                        return false;
                    }
                }
            }
        }
        return true;
private voidpurgeELBeanClasses()


        Field fieldlist[] = javax.el.BeanELResolver.class.getDeclaredFields();
        for (int i = 0; i < fieldlist.length; i++) {
            Field fld = fieldlist[i];
            if (fld.getName().equals("properties")) {
                purgeELBeanClasses(fld);
            }
        }
private voidpurgeELBeanClasses(java.lang.reflect.Field fld)


	SecurityManager sm = System.getSecurityManager();
	if (sm != null) {
            AccessController.doPrivileged(new PrivilegedAction() {
                    public Object run() {
                        fld.setAccessible(true);
                        return null;
                    }
            });
        } else {
            fld.setAccessible(true);
        }

        Map m = null;
        try {
            m = (Map) fld.get(null);
        } catch (IllegalAccessException iae) {
            log.warn("Unable to purge bean classes from BeanELResolver", iae);
            return;
        }

        if (m.size() == 0) {
            return;
        }

        Iterator<Class> iter = m.keySet().iterator();
        while (iter.hasNext()) {
            Class mbeanClass = iter.next();
            if (this.equals(mbeanClass.getClassLoader())) {
                iter.remove();
            }    
        }
private voidreadEntryData(ResourceEntry entry, java.lang.String name, java.io.InputStream binaryStream, int contentLength, java.util.jar.JarEntry jarEntry)
Reads the resource's binary data from the given input stream.


        if (binaryStream == null) {
            return;
        }

        byte[] binaryContent = new byte[contentLength];

        try {
            int pos = 0;

            while (true) {
                int n = binaryStream.read(binaryContent, pos,
                                          binaryContent.length - pos);
                if (n <= 0)
                    break;
                pos += n;
            }
            binaryStream.close();
        } catch (IOException e) {
            e.printStackTrace();
            return;
        } catch (Exception e) {
            e.printStackTrace();
            return;
        }

        // START OF IASRI 4709374
        // Preprocess the loaded byte code if bytecode preprocesser is
        // enabled
        if (PreprocessorUtil.isPreprocessorEnabled()) {
            binaryContent =
                PreprocessorUtil.processClass(name, binaryContent);
        }
        // END OF IASRI 4709374

        entry.binaryContent = binaryContent;

        // The certificates are only available after the JarEntry 
        // associated input stream has been fully read
        if (jarEntry != null) {
            entry.certificates = jarEntry.getCertificates();
        }
protected voidrefreshPolicy()
Refresh the system policy file, to pick up eventual changes.


        try {
            // The policy file may have been modified to adjust 
            // permissions, so we're reloading it when loading or 
            // reloading a Context
            Policy policy = Policy.getPolicy();
            policy.refresh();
        } catch (AccessControlException e) {
            // Some policy files may restrict this, even for the core,
            // so this exception is ignored
        }
public voidremoveLifecycleListener(org.apache.catalina.LifecycleListener listener)
Remove a lifecycle event listener from this component.

param
listener The listener to remove
public voidsetDebug(int debug)
Set the debugging detail level for this component.

param
debug The new debugging detail level


        this.debug = debug;
public voidsetDelegate(boolean delegate)
Set the "delegate first" flag for this class loader.

param
delegate The new "delegate first" flag


        this.delegate = delegate;
public voidsetJarPath(java.lang.String jarPath)
Change the Jar path.


        this.jarPath = jarPath;
public voidsetResources(javax.naming.directory.DirContext resources)
Set associated resources.


        this.resources = resources;
public voidsetUseMyFaces(boolean useMyFaces)

        this.useMyFaces = useMyFaces;
        if (useMyFaces) {
            addOverridablePackage("javax.faces");
            addOverridablePackage("com.sun.faces");
        }
public voidsetWorkDir(java.io.File workDir)
Change the work directory.

        this.loaderDir = new File(workDir, "loader");
public voidstart()
Start the class loader.

exception
LifecycleException if a lifecycle error occurs


        started = true;
public voidstop()
Stop the class loader.

exception
LifecycleException if a lifecycle error occurs


        // START GlassFish Issue 587
        purgeELBeanClasses();
        // END GlassFish Issue 587

        // Clearing references should be done before setting started to
        // false, due to possible side effects
        clearReferences();

        // START SJSAS 6258619
        ClassLoaderUtil.releaseLoader(this);
        // END SJSAS 6258619

        // START GlassFish 2840
        Provider[] providers = Security.getProviders();
        if (providers != null) {
            for (Provider provider : providers) {
                if (provider.getClass().getClassLoader() == this) {
                    Security.removeProvider(provider.getName());
                }
            }
        }
        // END GlassFish 2840

        started = false;

        int length = files.length;
        for (int i = 0; i < length; i++) {
            files[i] = null;
        }

        length = jarFiles.length;
        for (int i = 0; i < length; i++) {
            try {
                if (jarFiles[i] != null) {
                    jarFiles[i].close();
                }
            } catch (IOException e) {
                // Ignore
            }
            jarFiles[i] = null;
        }

        notFoundResources.clear();
        resourceEntries.clear();
        resources = null;
        repositories = null;
        repositoryURLs = null;
        files = null;
        jarFiles = null;
        jarRealFiles = null;
        jarPath = null;
        jarNames = null;
        lastModifiedDates = null;
        paths = null;
        hasExternalRepositories = false;
        parent = null;

        permissionList.clear();
        loaderPC.clear();

        if (loaderDir != null) {
            deleteDir(loaderDir);
        }
public java.lang.StringtoString()
Render a String representation of this object.


        StringBuffer sb = new StringBuffer("WebappClassLoader\r\n");
        sb.append("  delegate: ");
        sb.append(delegate);
        sb.append("\r\n");
        sb.append("  repositories:\r\n");
        if (repositories != null) {
            for (int i = 0; i < repositories.length; i++) {
                sb.append("    ");
                sb.append(repositories[i]);
                sb.append("\r\n");
            }
        }
        if (this.parent != null) {
            sb.append("----------> Parent Classloader:\r\n");
            sb.append(this.parent.toString());
            sb.append("\r\n");
        }
        return (sb.toString());
protected booleanvalidate(java.lang.String name)
Validate a classname. As per SRV.9.7.2, we must restict loading of classes from J2SE (java.*) and classes of the servlet API (javax.servlet.*). That should enhance robustness and prevent a number of user error (where an older version of servlet.jar would be present in /WEB-INF/lib).

param
name class name
return
true if the name is valid


        if (name == null)
            return false;
        if (name.startsWith("java."))
            return false;

        return true;
private booleanvalidateJarFile(java.io.File jarfile)
Check the specified JAR file, and return true if it does not contain any of the trigger classes.

param
jarFile The JAR file to be checked
exception
IOException if an input/output error occurs


        if (triggers == null)
            return (true);
        JarFile jarFile = new JarFile(jarfile);
        for (int i = 0; i < triggers.length; i++) {
            Class clazz = null;
            try {
                if (parent != null) {
                    clazz = parent.loadClass(triggers[i]);
                } else {
                    clazz = Class.forName(triggers[i]);
                }
            } catch (Throwable t) {
                clazz = null;
            }
            if (clazz == null)
                continue;
            String name = triggers[i].replace('.", '/") + ".class";
            if (log.isTraceEnabled())
                log.trace(" Checking for " + name);
            JarEntry jarEntry = jarFile.getJarEntry(name);
            if (jarEntry != null) {
                log.info("validateJarFile(" + jarfile + 
                    ") - jar not loaded. See Servlet Spec 2.3, "
                    + "section 9.7.2. Offending class: " + name);
                jarFile.close();
                return (false);
            }
        }
        jarFile.close();
        return (true);