/*

 * Licensed to the Apache Software Foundation (ASF) under one or more

 * contributor license agreements.  See the NOTICE file distributed with

 * this work for additional information regarding copyright ownership.

 * The ASF licenses this file to You under the Apache License, Version 2.0

 * (the "License"); you may not use this file except in compliance with

 * the License.  You may obtain a copy of the License at

 * 

 *      http://www.apache.org/licenses/LICENSE-2.0

 * 

 * Unless required by applicable law or agreed to in writing, software

 * distributed under the License is distributed on an "AS IS" BASIS,

 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

 * See the License for the specific language governing permissions and

 * limitations under the License.

 */

package org.apache.catalina.loader;

import java.net.URL;

import java.net.URLClassLoader;

/**

 * Subclass implementation of <b>java.net.URLClassLoader</b>. There are no

 * functional differences between this class and <b>java.net.URLClassLoader</b>.

 *

 * @author Craig R. McClanahan

 * @author Remy Maucherat

 * @deprecated  Unnecessary. Will be removed in Tomcat 8.0.x.

 */

@Deprecated

public class StandardClassLoader

    extends URLClassLoader

    implements StandardClassLoaderMBean {

    public StandardClassLoader(URL repositories[]) {

        super(repositories);

    }

    public StandardClassLoader(URL repositories[], ClassLoader parent) {

        super(repositories, parent);

    }

}

/*

 * Licensed to the Apache Software Foundation (ASF) under one or more

 * contributor license agreements.  See the NOTICE file distributed with

 * this work for additional information regarding copyright ownership.

 * The ASF licenses this file to You under the Apache License, Version 2.0

 * (the "License"); you may not use this file except in compliance with

 * the License.  You may obtain a copy of the License at

 * 

 *      http://www.apache.org/licenses/LICENSE-2.0

 * 

 * Unless required by applicable law or agreed to in writing, software

 * distributed under the License is distributed on an "AS IS" BASIS,

 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

 * See the License for the specific language governing permissions and

 * limitations under the License.

 */

package org.apache.catalina.loader;

/**

 * MBean interface for StandardClassLoader, to allow JMX remote management.

 *

 * @author Remy Maucherat

 *

 * @deprecated  Unused. Will be removed in Tomcat 8.0.x.

 */

@Deprecated

public interface StandardClassLoaderMBean {

    // Marker interface

}

import java.io.ByteArrayInputStream;

import java.io.File;

import java.io.FileOutputStream;

import java.io.FilePermission;

import java.io.IOException;

import java.io.InputStream;

import java.lang.instrument.ClassFileTransformer;

import java.lang.instrument.IllegalClassFormatException;

import java.lang.ref.Reference;

import java.lang.ref.WeakReference;

import java.lang.reflect.Field;

import java.lang.reflect.Method;

import java.lang.reflect.Modifier;

import java.net.MalformedURLException;

import java.net.URL;

import java.net.URLClassLoader;

import java.nio.charset.Charset;

import java.security.AccessControlException;

import java.security.AccessController;

import java.security.CodeSource;

import java.security.Permission;

import java.security.PermissionCollection;

import java.security.Policy;

import java.security.PrivilegedAction;

import java.security.ProtectionDomain;

import java.util.ArrayList;

import java.util.Collection;

import java.util.Collections;

import java.util.ConcurrentModificationException;

import java.util.Enumeration;

import java.util.HashMap;

import java.util.Iterator;

import java.util.LinkedHashMap;

import java.util.LinkedHashSet;

import java.util.List;

import java.util.Map;

import java.util.ResourceBundle;

import java.util.Set;

import java.util.concurrent.CopyOnWriteArrayList;

import java.util.concurrent.ThreadPoolExecutor;

import java.util.jar.Attributes;

import java.util.jar.Attributes.Name;

import java.util.jar.JarEntry;

import java.util.jar.JarFile;

import java.util.jar.Manifest;

import javax.naming.Binding;

import javax.naming.NameClassPair;

import javax.naming.NamingEnumeration;

import javax.naming.NamingException;

import javax.naming.directory.DirContext;

import org.apache.catalina.Globals;

import org.apache.catalina.Lifecycle;

import org.apache.catalina.LifecycleListener;

import org.apache.catalina.LifecycleState;

import org.apache.naming.JndiPermission;

import org.apache.naming.resources.ProxyDirContext;

import org.apache.naming.resources.Resource;

import org.apache.naming.resources.ResourceAttributes;

import org.apache.tomcat.InstrumentableClassLoader;

import org.apache.tomcat.util.ExceptionUtils;

import org.apache.tomcat.util.IntrospectionUtils;

import org.apache.tomcat.util.res.StringManager;

    /**

     * 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.

     */

    protected static final String[] triggers = {

        "javax.servlet.Servlet", "javax.el.Expression"       // Servlet API

    };

    /**

     * Set of package names which are not allowed to be loaded from a webapp

     * class loader without delegating first.

     */

    protected static final String[] packageTriggers = {

    };

    /**

     * The string manager for this package.

     */

    protected static final StringManager sm =

        StringManager.getManager(Constants.Package);

    /**

     * Use anti JAR locking code, which does URL rerouting when accessing

     * resources.

     */

    boolean antiJARLocking = false;

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

    /**

     * Construct a new ClassLoader with no defined repositories and no

     * parent ClassLoader.

     */

    /**

     * Construct a new ClassLoader with no defined repositories and the given

     * parent ClassLoader.

     * <p>

     * Method is used via reflection -

     * see {@link WebappLoader#createClassLoader()}

     *

     * @param parent Our parent class loader

     */

    /**

     * @return Returns the searchExternalFirst.

     */

    public boolean getSearchExternalFirst() {

        return searchExternalFirst;

    }

    /**

     * @param searchExternalFirst Whether external repositories should be searched first

     */

    public void setSearchExternalFirst(boolean searchExternalFirst) {

        this.searchExternalFirst = searchExternalFirst;

    }

    /**

     * If there is a Java SecurityManager create a read FilePermission

     * or JndiPermission for the file directory path.

     *

     * @param filepath file directory path

     */

    public void addPermission(String filepath) {

        if (filepath == null) {

            return;

        }

        String path = filepath;

        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);

            }

        }

    }

    /**

     * 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

     */

    public void addPermission(URL url) {

        if (url != null) {

            addPermission(url.toString());

        }

    }

    /**

     * If there is a Java SecurityManager create a Permission.

     *

     * @param permission The permission

     */

    public void addPermission(Permission permission) {

        if ((securityManager != null) && (permission != null)) {

            permissionList.add(permission);

        }

    }

    /**

     * Return the JAR path.

     */

    public String getJarPath() {

        return this.jarPath;

    }

    /**

     * Change the Jar path.

     */

    public void setJarPath(String jarPath) {

        this.jarPath = jarPath;

    }

    /**

     * Change the work directory.

     */

    public void setWorkDir(File workDir) {

        this.loaderDir = new File(workDir, "loader");

        if (loaderDir == null) {

            canonicalLoaderDir = null;

        } else {

            try {

                canonicalLoaderDir = loaderDir.getCanonicalPath();

                if (!canonicalLoaderDir.endsWith(File.separator)) {

                    canonicalLoaderDir += File.separator;

                }

            } catch (IOException ioe) {

                canonicalLoaderDir = null;

            }

        }

    }

     /**

      * Utility method for use in subclasses.

      * Must be called before Lifecycle methods to have any effect.

      *

      * @deprecated Will be removed in 8.0.x onwards.

      */

    @Deprecated

     protected void setParentClassLoader(ClassLoader pcl) {

         parent = pcl;

     }

     /**

      * Return the clearReferencesStatic flag for this Context.

      */

     public boolean getClearReferencesStatic() {

         return (this.clearReferencesStatic);

     }

     /**

      * Set the clearReferencesStatic feature for this Context.

      *

      * @param clearReferencesStatic The new flag value

      */

     public void setClearReferencesStatic(boolean clearReferencesStatic) {

         this.clearReferencesStatic = clearReferencesStatic;

     }

     /**

      * Return the clearReferencesStopThreads flag for this Context.

      */

     public boolean getClearReferencesStopThreads() {

         return (this.clearReferencesStopThreads);

     }

     /**

      * Set the clearReferencesStopThreads feature for this Context.

      *

      * @param clearReferencesStopThreads The new flag value

      */

     public void setClearReferencesStopThreads(

             boolean clearReferencesStopThreads) {

         this.clearReferencesStopThreads = clearReferencesStopThreads;

     }

     /**

      * Return the clearReferencesStopTimerThreads flag for this Context.

      */

     public boolean getClearReferencesStopTimerThreads() {

         return (this.clearReferencesStopTimerThreads);

     }

     /**

      * Set the clearReferencesStopTimerThreads feature for this Context.

      *

      * @param clearReferencesStopTimerThreads The new flag value

      */

     public void setClearReferencesStopTimerThreads(

             boolean clearReferencesStopTimerThreads) {

         this.clearReferencesStopTimerThreads = clearReferencesStopTimerThreads;

     }

     /**

      * Return the clearReferencesLogFactoryRelease flag for this Context.

      */

     public boolean getClearReferencesLogFactoryRelease() {

         return (this.clearReferencesLogFactoryRelease);

     }

     /**

      * Set the clearReferencesLogFactoryRelease feature for this Context.

      *

      * @param clearReferencesLogFactoryRelease The new flag value

      */

     public void setClearReferencesLogFactoryRelease(

             boolean clearReferencesLogFactoryRelease) {

         this.clearReferencesLogFactoryRelease =

             clearReferencesLogFactoryRelease;

     }

     /**

      * Return the clearReferencesHttpClientKeepAliveThread flag for this

      * Context.

      */

     public boolean getClearReferencesHttpClientKeepAliveThread() {

         return (this.clearReferencesHttpClientKeepAliveThread);

     }

     /**

      * Set the clearReferencesHttpClientKeepAliveThread feature for this

      * Context.

      *

      * @param clearReferencesHttpClientKeepAliveThread The new flag value

      */

     public void setClearReferencesHttpClientKeepAliveThread(

             boolean clearReferencesHttpClientKeepAliveThread) {

         this.clearReferencesHttpClientKeepAliveThread =

             clearReferencesHttpClientKeepAliveThread;

     }

    // ------------------------------------------------------- Reloader Methods

    /**

     * Adds the specified class file transformer to this class loader. The

     * transformer will then be able to modify the bytecode of any classes

     * loaded by this class loader after the invocation of this method.

     *

     * @param transformer The transformer to add to the class loader

     */

    @Override

    public void addTransformer(ClassFileTransformer transformer) {

        if (transformer == null) {

            throw new IllegalArgumentException(sm.getString(

                    "webappClassLoader.addTransformer.illegalArgument", getContextName()));

        }

        if (this.transformers.contains(transformer)) {

            // if the same instance of this transformer was already added, bail out

            log.warn(sm.getString("webappClassLoader.addTransformer.duplicate",

                    transformer, getContextName()));

            return;

        }

        this.transformers.add(transformer);

        log.info(sm.getString("webappClassLoader.addTransformer", transformer, getContextName()));

    }

    /**

     * Removes the specified class file transformer from this class loader.

     * It will no longer be able to modify the byte code of any classes

     * loaded by the class loader after the invocation of this method.

     * However, any classes already modified by this transformer will

     * remain transformed.

     *

     * @param transformer The transformer to remove

     */

    @Override

    public void removeTransformer(ClassFileTransformer transformer) {

        if (transformer == null) {

            return;

        }

        if (this.transformers.remove(transformer)) {

            log.info(sm.getString("webappClassLoader.removeTransformer",

                    transformer, getContextName()));

            return;

        }

    }

    /**

     * Returns a copy of this class loader without any class file

     * transformers. This is a tool often used by Java Persistence API

     * providers to inspect entity classes in the absence of any

     * instrumentation, something that can't be guaranteed within the

     * context of a {@link ClassFileTransformer}'s

     * {@link ClassFileTransformer#transform(ClassLoader, String, Class,

     * ProtectionDomain, byte[]) transform} method.

     * <p>

     * The returned class loader's resource cache will have been cleared

     * so that classes already instrumented will not be retained or

     * returned.

     *

     * @return the transformer-free copy of this class loader.

     */

    @Override

    public WebappClassLoader copyWithoutTransformers() {

        WebappClassLoader result = new WebappClassLoader(this.parent);

        result.antiJARLocking = this.antiJARLocking;

        result.resources = this.resources;

        result.files = this.files;

        result.delegate = this.delegate;

        result.lastJarAccessed = this.lastJarAccessed;

        result.repositories = this.repositories;

        result.jarPath = this.jarPath;

        result.loaderDir = this.loaderDir;

        result.canonicalLoaderDir = this.canonicalLoaderDir;

        result.clearReferencesStatic = this.clearReferencesStatic;

        result.clearReferencesStopThreads = this.clearReferencesStopThreads;

        result.clearReferencesStopTimerThreads = this.clearReferencesStopTimerThreads;

        result.clearReferencesLogFactoryRelease = this.clearReferencesLogFactoryRelease;

        result.clearReferencesHttpClientKeepAliveThread = this.clearReferencesHttpClientKeepAliveThread;

        result.repositoryURLs = this.repositoryURLs.clone();

        result.jarFiles = this.jarFiles.clone();

        result.jarRealFiles = this.jarRealFiles.clone();

        result.jarNames = this.jarNames.clone();

        result.lastModifiedDates = this.lastModifiedDates.clone();

        result.paths = this.paths.clone();

        result.notFoundResources.putAll(this.notFoundResources);

        result.permissionList.addAll(this.permissionList);

        result.loaderPC.putAll(this.loaderPC);

        result.contextName = this.contextName;

        result.hasExternalRepositories = this.hasExternalRepositories;

        result.searchExternalFirst = this.searchExternalFirst;

        try {

            result.start();

        } catch (LifecycleException e) {

            throw new IllegalStateException(e);

        }

        return result;

    }

   /**

     * 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

     */

    public void addRepository(String repository) {

        // 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;

            repositoryURLs = null;

        } catch (MalformedURLException e) {

            IllegalArgumentException iae = new IllegalArgumentException

                ("Invalid repository: " + repository);

            iae.initCause(e);

            throw iae;

        }

    }

    /**

     * 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

     */

    synchronized void addRepository(String repository, File file) {

        // Note : There should be only one (of course), but I think we should

        // keep this a bit generic

        if (repository == null)

            return;

        if (log.isDebugEnabled())

            log.debug("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;

    }

    synchronized void addJar(String jar, JarFile jarFile, File file)

        throws IOException {

        if (jar == null)

            return;

        if (jarFile == null)

            return;

        if (file == null)

            return;

        if (log.isDebugEnabled())

            log.debug("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;

    }

    /**

     * 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).

     */

    public String[] findRepositories() {

        return (repositories.clone());

    }

    /**

     * Have one or more classes or resources been modified so that a reload

     * is appropriate?

     */

    public boolean modified() {

        if (log.isDebugEnabled())

            log.debug("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.isDebugEnabled() )

                        log.debug("  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<Binding> enumeration =

                    resources.listBindings(getJarPath());

                int i = 0;

                while (enumeration.hasMoreElements() && (i < length)) {

                    NameClassPair ncPair = enumeration.nextElement();

                    String name = ncPair.getName();

                    // Ignore non JARs present in the lib folder

                    if (!name.endsWith(".jar"))

                        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 = enumeration.nextElement();

                        String name = ncPair.getName();

                        // Additional non-JAR files are allowed

                        if (name.endsWith(".jar")) {

                            // 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.isDebugEnabled())

                    log.debug("    Failed tracking modifications of '"

                        + getJarPath() + "'");

            } catch (ClassCastException e) {

                log.error("    Failed tracking modifications of '"

                          + getJarPath() + "' : " + e.getMessage());

            }

        }

        // No classes have been modified

        return (false);

    }

    /**

     * Render a String representation of this object.

     */

    @Override

    public String toString() {

        StringBuilder sb = new StringBuilder("WebappClassLoader\r\n");

        sb.append("  context: ");

        sb.append(contextName);

        sb.append("\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");

        }

        if (this.transformers.size() > 0) {

            sb.append("----------> Class file transformers:\r\n");

            for (ClassFileTransformer transformer : this.transformers) {

                sb.append(transformer).append("\r\n");

            }

        }

        return (sb.toString());

    }

    // ---------------------------------------------------- ClassLoader Methods

    /**

     * Add the specified URL to the classloader.

     */

    @Override

    protected void addURL(URL url) {

        super.addURL(url);

        hasExternalRepositories = true;

        repositoryURLs = null;

    }

    /**

     * Expose this method for use by the unit tests.

     */

    protected final Class<?> doDefineClass(String name, byte[] b, int off, int len,

            ProtectionDomain protectionDomain) {

        return super.defineClass(name, b, off, len, protectionDomain);

    }

    /**

     * Find the specified class in our local repositories, if possible.  If

     * not found, throw <code>ClassNotFoundException</code>.

     *

     * @param name Name of the class to be loaded

     *

     * @exception ClassNotFoundException if the class was not found

     */

    @Override

    public Class<?> findClass(String name) throws ClassNotFoundException {

        if (log.isDebugEnabled())

            log.debug("    findClass(" + name + ")");

        // Cannot load anything from local repositories if class loader is stopped

        if (!started) {

            throw new ClassNotFoundException(name);

        }

        // (1) Permission to define this class when using a SecurityManager

        if (securityManager != null) {

            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 + ")");

            if (hasExternalRepositories && searchExternalFirst) {

                try {

                    clazz = super.findClass(name);

                } catch(ClassNotFoundException cnfe) {

                    // Ignore - will search internal repositories next

                } catch(AccessControlException ace) {

                    log.warn("WebappClassLoader.findClassInternal(" + name

                            + ") security exception: " + ace.getMessage(), ace);

                    throw new ClassNotFoundException(name, ace);

                } catch (RuntimeException e) {

                    if (log.isTraceEnabled())

                        log.trace("      -->RuntimeException Rethrown", e);

                    throw e;

                }

            }

            if ((clazz == null)) {

                try {

                    clazz = findClassInternal(name);

                } catch(ClassNotFoundException cnfe) {

                    if (!hasExternalRepositories || searchExternalFirst) {

                        throw cnfe;

                    }

                } catch(AccessControlException ace) {

                    log.warn("WebappClassLoader.findClassInternal(" + name

                            + ") security exception: " + ace.getMessage(), ace);

                    throw new ClassNotFoundException(name, ace);

                } catch (RuntimeException e) {

                    if (log.isTraceEnabled())

                        log.trace("      -->RuntimeException Rethrown", e);

                    throw e;

                }

            }

            if ((clazz == null) && hasExternalRepositories && !searchExternalFirst) {

                try {

                    clazz = super.findClass(name);

                } catch(AccessControlException ace) {

                    log.warn("WebappClassLoader.findClassInternal(" + name

                            + ") security exception: " + ace.getMessage(), ace);

                    throw new ClassNotFoundException(name, ace);

                } catch (RuntimeException e) {

                    if (log.isTraceEnabled())

                        log.trace("      -->RuntimeException Rethrown", e);

                    throw e;

                }

            }

            if (clazz == null) {

                if (log.isDebugEnabled())

                    log.debug("    --> 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.debug("      Returning class " + clazz);

        if (log.isTraceEnabled()) {

            ClassLoader cl;

            if (Globals.IS_SECURITY_ENABLED){

                cl = AccessController.doPrivileged(

                    new PrivilegedGetClassLoader(clazz));

            } else {

                cl = clazz.getClassLoader();

            }

            log.debug("      Loaded by " + cl.toString());

        }

        return (clazz);

    }

    /**

     * Find the specified resource in our local repository, and return a

     * <code>URL</code> referring to it, or <code>null</code> if this resource

     * cannot be found.

     *

     * @param name Name of the resource to be found

     */

    @Override

    public URL findResource(final String name) {

        if (log.isDebugEnabled())

            log.debug("    findResource(" + name + ")");

        URL url = null;

        if (hasExternalRepositories && searchExternalFirst)

            url = super.findResource(name);

        if (url == null) {

            ResourceEntry entry = resourceEntries.get(name);

            if (entry == null) {

                if (securityManager != null) {

                    PrivilegedAction<ResourceEntry> dp =

                        new PrivilegedFindResourceByName(name, name, false);

                    entry = AccessController.doPrivileged(dp);

                } else {

                    entry = findResourceInternal(name, name, false);

                }

            }

            if (entry != null) {

                url = entry.source;

            }

        }

        if ((url == null) && hasExternalRepositories && !searchExternalFirst)

            url = super.findResource(name);

        if (log.isDebugEnabled()) {

            if (url != null)

                log.debug("    --> Returning '" + url.toString() + "'");

            else

                log.debug("    --> Resource not found, returning null");

        }

        return (url);

    }

    /**

     * Return an enumeration of <code>URLs</code> 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

     */

    @Override

    public Enumeration<URL> findResources(String name) throws IOException {

        if (log.isDebugEnabled())

            log.debug("    findResources(" + name + ")");

        //we use a LinkedHashSet instead of a Vector to avoid duplicates with virtualmappings

        LinkedHashSet<URL> result = new LinkedHashSet<URL>();

        int jarFilesLength = jarFiles.length;

        int repositoriesLength = repositories.length;

        int i;

        // Adding the results of a call to the superclass

        if (hasExternalRepositories && searchExternalFirst) {

            Enumeration<URL> otherResourcePaths = super.findResources(name);

            while (otherResourcePaths.hasMoreElements()) {

                result.add(otherResourcePaths.nextElement());

            }

        }

        // 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.add(getURI(new File(files[i], name)));

                } catch (MalformedURLException e) {

                    // Ignore

                }

            } catch (NamingException e) {

                // Ignore

            }

        }

        // 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.add(new URL(jarFakeUrl));

                        } catch (MalformedURLException e) {

                            // Ignore

                        }

                    }

                }

            }

        }

        // Adding the results of a call to the superclass

        if (hasExternalRepositories && !searchExternalFirst) {

            Enumeration<URL> otherResourcePaths = super.findResources(name);

            while (otherResourcePaths.hasMoreElements()) {

                result.add(otherResourcePaths.nextElement());

            }

        }

        return Collections.enumeration(result);

    }

    /**

     * 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 <code>null</code>.

     * <p>

     * This method searches according to the following algorithm, returning

     * as soon as it finds the appropriate URL.  If the resource cannot be

     * found, returns <code>null</code>.

     * <ul>

     * <li>If the <code>delegate</code> property is set to <code>true</code>,

     *     call the <code>getResource()</code> method of the parent class

     *     loader, if any.</li>

     * <li>Call <code>findResource()</code> to find this resource in our

     *     locally defined repositories.</li>

     * <li>Call the <code>getResource()</code> method of the parent class

     *     loader, if any.</li>

     * </ul>

     *

     * @param name Name of the resource to return a URL for

     */

    @Override

    public URL getResource(String name) {

        if (log.isDebugEnabled())

            log.debug("getResource(" + name + ")");

        URL url = null;

        // (1) Delegate to parent if requested

        if (delegate) {

            if (log.isDebugEnabled())

                log.debug("  Delegating to parent classloader " + parent);

            url = parent.getResource(name);

            if (url != null) {

                if (log.isDebugEnabled())

                    log.debug("  --> 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

            if (antiJARLocking) {

                ResourceEntry entry = resourceEntries.get(name);

                try {

                    String repository = entry.codeBase.toString();

                    if ((repository.endsWith(".jar"))

                            && (!(name.endsWith(CLASS_FILE_SUFFIX)))) {

                        // Copy binary content to the work directory if not present

                        File resourceFile = new File(loaderDir, name);

                        url = getURI(resourceFile);

                    }

                } catch (Exception e) {

                    // Ignore

                }

            }

            if (log.isDebugEnabled())

                log.debug("  --> Returning '" + url.toString() + "'");

            return (url);

        }

        // (3) Delegate to parent unconditionally if not already attempted

        if( !delegate ) {

            url = parent.getResource(name);

            if (url != null) {

                if (log.isDebugEnabled())

                    log.debug("  --> Returning '" + url.toString() + "'");

                return (url);

            }

        }

        // (4) Resource was not found

        if (log.isDebugEnabled())

            log.debug("  --> Resource not found, returning null");

        return (null);

    }

    /**

     * 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 <code>getResource()</code>, after checking to see if the resource

     * data has been previously cached.  If the resource cannot be found,

     * return <code>null</code>.

     *

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

     */

    @Override

    public InputStream getResourceAsStream(String name) {

        if (log.isDebugEnabled())

            log.debug("getResourceAsStream(" + name + ")");

        InputStream stream = null;

        // (0) Check for a cached copy of this resource

        stream = findLoadedResource(name);

        if (stream != null) {

            if (log.isDebugEnabled())

                log.debug("  --> Returning stream from cache");

            return (stream);

        }

        // (1) Delegate to parent if requested

        if (delegate) {

            if (log.isDebugEnabled())

                log.debug("  Delegating to parent classloader " + parent);

            stream = parent.getResourceAsStream(name);

            if (stream != null) {

                // FIXME - cache???

                if (log.isDebugEnabled())

                    log.debug("  --> Returning stream from parent");

                return (stream);

            }

        }

        // (2) Search local repositories

        if (log.isDebugEnabled())

            log.debug("  Searching local repositories");

        URL url = findResource(name);

        if (url != null) {

            // FIXME - cache???

            if (log.isDebugEnabled())

                log.debug("  --> 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.isDebugEnabled())

                log.debug("  Delegating to parent classloader unconditionally " + parent);

            stream = parent.getResourceAsStream(name);

            if (stream != null) {

                // FIXME - cache???

                if (log.isDebugEnabled())

                    log.debug("  --> Returning stream from parent");

                return (stream);

            }

        }

        // (4) Resource was not found

        if (log.isDebugEnabled())

            log.debug("  --> Resource not found, returning null");

        return (null);

    }

    /**

     * Load the class with the specified name.  This method searches for

     * classes in the same manner as <code>loadClass(String, boolean)</code>

     * with <code>false</code> as the second argument.

     *

     * @param name Name of the class to be loaded

     *

     * @exception ClassNotFoundException if the class was not found

     */

    @Override

    public Class<?> loadClass(String name) throws ClassNotFoundException {

        return (loadClass(name, false));

    }

    /**

     * 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 <code>ClassNotFoundException</code>.

     * <ul>

     * <li>Call <code>findLoadedClass(String)</code> to check if the

     *     class has already been loaded.  If it has, the same

     *     <code>Class</code> object is returned.</li>

     * <li>If the <code>delegate</code> property is set to <code>true</code>,

     *     call the <code>loadClass()</code> method of the parent class

     *     loader, if any.</li>

     * <li>Call <code>findClass()</code> to find this class in our locally

     *     defined repositories.</li>

     * <li>Call the <code>loadClass()</code> method of our parent

     *     class loader, if any.</li>

     * </ul>

     * If the class was found using the above steps, and the

     * <code>resolve</code> flag is <code>true</code>, this method will then

     * call <code>resolveClass(Class)</code> on the resulting Class object.

     *

     * @param name Name of the class to be loaded

     * @param resolve If <code>true</code> then resolve the class

     *

     * @exception ClassNotFoundException if the class was not found

     */

    @Override

    public synchronized Class<?> loadClass(String name, boolean resolve)

        throws ClassNotFoundException {