/**
 * Cluster support is optional. The JARs may have been removed.
 */
private void addClusterRuleSet(Digester digester, String prefix) {
    Class<?> clazz = null;
    Constructor<?> constructor = null;
    try {
        clazz = Class.forName("org.apache.catalina.ha.ClusterRuleSet");
        constructor = clazz.getConstructor(String.class);
        RuleSet ruleSet = (RuleSet) constructor.newInstance(prefix);
        digester.addRuleSet(ruleSet);
    } catch (Exception e) {
        if (log.isDebugEnabled()) {
            log.debug(sm.getString("catalina.noCluster",
                    e.getClass().getName() + ": " +  e.getMessage()), e);
        } else if (log.isInfoEnabled()) {
            log.info(sm.getString("catalina.noCluster",
                    e.getClass().getName() + ": " +  e.getMessage()));
        }
    }
}
 

/**
 * Create and configure the Digester we will be using for shutdown.
 * @return the digester to process the stop operation
 */
protected Digester createStopDigester() {

    // Initialize the digester
    Digester digester = new Digester();
    digester.setUseContextClassLoader(true);

    // Configure the rules we need for shutting down
    digester.addObjectCreate("Server",
                             "org.apache.catalina.core.StandardServer",
                             "className");
    digester.addSetProperties("Server");
    digester.addSetNext("Server",
                        "setServer",
                        "org.apache.catalina.Server");

    return digester;

}
 

@Override
protected void contextConfig(final Digester digester) {
    final NamingResourcesImpl resources;
    if (context != null) {
        resources = context.getNamingResources();
    } else {
        resources = null;
    }

    if (resources instanceof OpenEJBNamingResource) {
        ((OpenEJBNamingResource) resources).setTomcatResource(true);
    }
    super.contextConfig(digester);
    if (resources instanceof OpenEJBNamingResource) {
        ((OpenEJBNamingResource) resources).setTomcatResource(false);
    }

    if (context instanceof StandardContext) {
        final StandardContext standardContext = (StandardContext) context;
        final NamingContextListener namingContextListener = standardContext.getNamingContextListener();
        if (null != namingContextListener) {
            namingContextListener.setExceptionOnFailedWrite(standardContext.getJndiExceptionOnFailedWrite());
        }
    }
}
 

/**
 * Create and configure the Digester we will be using for shutdown.
 */
protected Digester createStopDigester() {

    // Initialize the digester
    Digester digester = new Digester();
    digester.setUseContextClassLoader(true);

    // Configure the rules we need for shutting down
    digester.addObjectCreate("Server",
                             "org.apache.catalina.core.StandardServer",
                             "className");
    digester.addSetProperties("Server");
    digester.addSetNext("Server",
                        "setServer",
                        "org.apache.catalina.Server");

    return (digester);

}
 

/**
 * Create (if necessary) and return a Digester configured to process the
 * context configuration descriptor for an application.
 */
protected Digester createContextDigester() {
    Digester digester = new Digester();
    digester.setValidating(false);
    digester.setRulesValidation(true);
    HashMap<Class<?>, List<String>> fakeAttributes =
        new HashMap<Class<?>, List<String>>();
    ArrayList<String> attrs = new ArrayList<String>();
    attrs.add("className");
    fakeAttributes.put(Object.class, attrs);
    digester.setFakeAttributes(fakeAttributes);
    RuleSet contextRuleSet = new ContextRuleSet("", false);
    digester.addRuleSet(contextRuleSet);
    RuleSet namingRuleSet = new NamingRuleSet("Context/");
    digester.addRuleSet(namingRuleSet);
    return digester;
}
 

/**
 * Process a "init" event for this Context.
 */
protected void init() {
    // Called from StandardContext.init()

    Digester contextDigester = createContextDigester();
    contextDigester.getParser();

    if (log.isDebugEnabled())
        log.debug(sm.getString("contextConfig.init"));
    context.setConfigured(false);
    ok = true;

    contextConfig(contextDigester);

    createWebXmlDigester(context.getXmlNamespaceAware(),
            context.getXmlValidation());
}
 

/**
 * Create a <code>Digester</code> parser.
 * @param xmlValidation turn on/off xml validation
 * @param xmlNamespaceAware turn on/off namespace validation
 * @param rule an instance of <code>RuleSet</code> used for parsing the xml.
 */
public static Digester newDigester(boolean xmlValidation,
                                   boolean xmlNamespaceAware,
                                   RuleSet rule) {
    Digester digester = new Digester();
    digester.setNamespaceAware(xmlNamespaceAware);
    digester.setValidating(xmlValidation);
    digester.setUseContextClassLoader(true);

    SchemaResolver schemaResolver = new SchemaResolver(digester);
    registerLocalSchema(schemaResolver);
    
    digester.setEntityResolver(schemaResolver);
    if ( rule != null ) {
        digester.addRuleSet(rule);
    }

    return (digester);
}
 

/**
 * Create (if necessary) and return a Digester configured to process the
 * tld.
 */
private static synchronized Digester createTldDigester(boolean validation,
        boolean blockExternal) {

    Digester digester;
    int cacheIndex = 0;
    if (validation) {
        cacheIndex += 1;
    }
    if (blockExternal) {
        cacheIndex += 2;
    }
    digester = tldDigesters[cacheIndex];
    if (digester == null) {
        digester = DigesterFactory.newDigester(validation,
                true, new TldRuleSet(), blockExternal);
        digester.getParser();
        tldDigesters[cacheIndex] = digester;
    }
    return digester;
}
 

/**
 * Create a <code>Digester</code> parser.
 * @param xmlValidation turn on/off xml validation
 * @param xmlNamespaceAware turn on/off namespace validation
 * @param rule an instance of <code>RuleSet</code> used for parsing the xml.
 * @param blockExternal turn on/off the blocking of external resources
 */
public static Digester newDigester(boolean xmlValidation,
                                   boolean xmlNamespaceAware,
                                   RuleSet rule,
                                   boolean blockExternal) {
    Digester digester = new Digester();
    digester.setNamespaceAware(xmlNamespaceAware);
    digester.setValidating(xmlValidation);
    digester.setUseContextClassLoader(true);
    EntityResolver2 resolver = new LocalResolver(SERVLET_API_PUBLIC_IDS,
            SERVLET_API_SYSTEM_IDS, blockExternal);
    digester.setEntityResolver(resolver);
    if (rule != null) {
        digester.addRuleSet(rule);
    }

    return digester;
}
 

/**
 * Cluster support is optional. The JARs may have been removed.
 */
private void addClusterRuleSet(Digester digester, String prefix) {
    Class<?> clazz = null;
    Constructor<?> constructor = null;
    try {
        clazz = Class.forName("org.apache.catalina.ha.ClusterRuleSet");
        constructor = clazz.getConstructor(String.class);
        RuleSet ruleSet = (RuleSet) constructor.newInstance(prefix);
        digester.addRuleSet(ruleSet);
    } catch (Exception e) {
        if (log.isDebugEnabled()) {
            log.debug(sm.getString("catalina.noCluster",
                    e.getClass().getName() + ": " +  e.getMessage()), e);
        } else if (log.isInfoEnabled()) {
            log.info(sm.getString("catalina.noCluster",
                    e.getClass().getName() + ": " +  e.getMessage()));
        }
    }
}
 

/**
 * Create and configure the Digester we will be using for shutdown.
 */
protected Digester createStopDigester() {

    // Initialize the digester
    Digester digester = new Digester();
    digester.setUseContextClassLoader(true);

    // Configure the rules we need for shutting down
    digester.addObjectCreate("Server",
                             "org.apache.catalina.core.StandardServer",
                             "className");
    digester.addSetProperties("Server");
    digester.addSetNext("Server",
                        "setServer",
                        "org.apache.catalina.Server");

    return (digester);

}
 

/**
 * Create (if necessary) and return a Digester configured to process the
 * context configuration descriptor for an application.
 */
protected Digester createContextDigester() {
    Digester digester = new Digester();
    digester.setValidating(false);
    digester.setRulesValidation(true);
    HashMap<Class<?>, List<String>> fakeAttributes =
        new HashMap<Class<?>, List<String>>();
    ArrayList<String> attrs = new ArrayList<String>();
    attrs.add("className");
    fakeAttributes.put(Object.class, attrs);
    digester.setFakeAttributes(fakeAttributes);
    RuleSet contextRuleSet = new ContextRuleSet("", false);
    digester.addRuleSet(contextRuleSet);
    RuleSet namingRuleSet = new NamingRuleSet("Context/");
    digester.addRuleSet(namingRuleSet);
    return digester;
}
 

/**
 * Process a "init" event for this Context.
 */
protected void init() {
    // Called from StandardContext.init()

    Digester contextDigester = createContextDigester();
    contextDigester.getParser();

    if (log.isDebugEnabled())
        log.debug(sm.getString("contextConfig.init"));
    context.setConfigured(false);
    ok = true;

    contextConfig(contextDigester);

    createWebXmlDigester(context.getXmlNamespaceAware(),
            context.getXmlValidation());
}
 

/**
 * Create a <code>Digester</code> parser.
 * @param xmlValidation turn on/off xml validation
 * @param xmlNamespaceAware turn on/off namespace validation
 * @param rule an instance of <code>RuleSet</code> used for parsing the xml.
 */
public static Digester newDigester(boolean xmlValidation,
                                   boolean xmlNamespaceAware,
                                   RuleSet rule) {
    Digester digester = new Digester();
    digester.setNamespaceAware(xmlNamespaceAware);
    digester.setValidating(xmlValidation);
    digester.setUseContextClassLoader(true);

    SchemaResolver schemaResolver = new SchemaResolver(digester);
    registerLocalSchema(schemaResolver);
    
    digester.setEntityResolver(schemaResolver);
    if ( rule != null ) {
        digester.addRuleSet(rule);
    }

    return (digester);
}
 

/**
 * Create (if necessary) and return a Digester configured to process the
 * tld.
 */
private static synchronized Digester createTldDigester(boolean validation,
        boolean blockExternal) {

    Digester digester;
    int cacheIndex = 0;
    if (validation) {
        cacheIndex += 1;
    }
    if (blockExternal) {
        cacheIndex += 2;
    }
    digester = tldDigesters[cacheIndex];
    if (digester == null) {
        digester = DigesterFactory.newDigester(validation,
                true, new TldRuleSet(), blockExternal);
        digester.getParser();
        tldDigesters[cacheIndex] = digester;
    }
    return digester;
}
 

/**
 * Create a <code>Digester</code> parser.
 * @param xmlValidation turn on/off xml validation
 * @param xmlNamespaceAware turn on/off namespace validation
 * @param rule an instance of <code>RuleSet</code> used for parsing the xml.
 * @param blockExternal turn on/off the blocking of external resources
 */
public static Digester newDigester(boolean xmlValidation,
                                   boolean xmlNamespaceAware,
                                   RuleSet rule,
                                   boolean blockExternal) {
    Digester digester = new Digester();
    digester.setNamespaceAware(xmlNamespaceAware);
    digester.setValidating(xmlValidation);
    digester.setUseContextClassLoader(true);
    EntityResolver2 resolver = new LocalResolver(SERVLET_API_PUBLIC_IDS,
            SERVLET_API_SYSTEM_IDS, blockExternal);
    digester.setEntityResolver(resolver);
    if (rule != null) {
        digester.addRuleSet(rule);
    }

    return digester;
}
 

@Test
public void testWebapp_2_3() throws Exception {
    XmlErrorHandler handler = new XmlErrorHandler();
    Digester digester = DigesterFactory.newDigester(
            true, true, new WebRuleSet(false), true);
    digester.setErrorHandler(handler);
    digester.push(new WebXml());
    WebXml desc = (WebXml) digester.parse(
            new File("test/webapp-2.3/WEB-INF/web.xml"));
    Assert.assertEquals("2.3", desc.getVersion());
    Assert.assertEquals(XmlIdentifiers.WEB_23_PUBLIC, desc.getPublicId());
    Assert.assertEquals(0, handler.getErrors().size());
    Assert.assertEquals(0, handler.getWarnings().size());
}
 

/**
 * Create the digester which will be used to parse context config files.
 * @param contextClassName The class which will be used to create the
 *  context instance
 * @return the digester
 */
protected static Digester createDigester(String contextClassName) {
    Digester digester = new Digester();
    digester.setValidating(false);
    // Add object creation rule
    digester.addObjectCreate("Context", contextClassName, "className");
    // Set the properties on that object (it doesn't matter if extra
    // properties are set)
    digester.addSetProperties("Context");
    return digester;
}
 

/**
 * Process a "init" event for this Context.
 */
protected synchronized void init() {
    // Called from StandardContext.init()

    Digester contextDigester = createContextDigester();
    contextDigester.getParser();

    if (log.isDebugEnabled()) {
        log.debug(sm.getString("contextConfig.init"));
    }
    context.setConfigured(false);
    ok = true;

    contextConfig(contextDigester);
}
 

/**
 * <p>Add the set of Rule instances defined in this RuleSet to the
 * specified <code>Digester</code> instance, associating them with
 * our namespace URI (if any).  This method should only be called
 * by a Digester instance.</p>
 *
 * @param digester Digester instance to which the new Rule instances
 *  should be added.
 */
@Override
public void addRuleInstances(Digester digester) {
    StringBuilder pattern = new StringBuilder(prefix);
    for (int i = 0; i < MAX_NESTED_REALM_LEVELS; i++) {
        if (i > 0) {
            pattern.append('/');
        }
        pattern.append("Realm");
        addRuleInstances(digester, pattern.toString(), i == 0 ? "setRealm" : "addRealm");
    }
}
 

private void addRuleInstances(Digester digester, String pattern, String methodName) {
    digester.addObjectCreate(pattern, null /* MUST be specified in the element */,
            "className");
    digester.addSetProperties(pattern);
    digester.addSetNext(pattern, methodName, "org.apache.catalina.Realm");
    digester.addRuleSet(new CredentialHandlerRuleSet(pattern + "/"));
}
 

/**
 * <p>Add the set of Rule instances defined in this RuleSet to the
 * specified <code>Digester</code> instance, associating them with
 * our namespace URI (if any).  This method should only be called
 * by a Digester instance.</p>
 *
 * @param digester Digester instance to which the new Rule instances
 *  should be added.
 */
@Override
public void addRuleInstances(Digester digester) {
    StringBuilder pattern = new StringBuilder(prefix);
    for (int i = 0; i < MAX_NESTED_LEVELS; i++) {
        if (i > 0) {
            pattern.append('/');
        }
        pattern.append("CredentialHandler");
        addRuleInstances(digester, pattern.toString(), i == 0 ? "setCredentialHandler"
                : "addCredentialHandler");
    }
}
 

/**
 * Execute the specified command.  This logic only performs the common
 * attribute validation required by all subclasses; it does not perform
 * any functional logic directly.
 *
 * @exception BuildException if a validation error occurs
 */
@Override
public void execute() throws BuildException {

    if (path == null) {
        throw new BuildException("Must specify 'path'");
    }

    File file = new File(path, "WEB-INF/web.xml");
    if (!file.canRead()) {
        throw new BuildException("Cannot find web.xml");
    }

    // Commons-logging likes having the context classloader set
    ClassLoader oldCL = Thread.currentThread().getContextClassLoader();
    Thread.currentThread().setContextClassLoader
        (ValidatorTask.class.getClassLoader());

    // Called through trusted manager interface. If running under a
    // SecurityManager assume that untrusted applications may be deployed.
    Digester digester = DigesterFactory.newDigester(
            true, true, null, Globals.IS_SECURITY_ENABLED);
    try (InputStream stream = new BufferedInputStream(new FileInputStream(file.getCanonicalFile()));) {
        InputSource is = new InputSource(file.toURI().toURL().toExternalForm());
        is.setByteStream(stream);
        digester.parse(is);
        handleOutput("web.xml validated");
    } catch (Exception e) {
        if (isFailOnError()) {
            throw new BuildException("Validation failure", e);
        } else {
            handleErrorOutput("Validation failure: " + e);
        }
    } finally {
        Thread.currentThread().setContextClassLoader(oldCL);
        closeRedirector();
    }

}
 

/**
 * Prepare for the beginning of active use of the public methods of this
 * component and implement the requirements of
 * {@link org.apache.catalina.util.LifecycleBase#startInternal()}.
 *
 * @exception LifecycleException if this component detects a fatal error
 *  that prevents this component from being used
 */
@Override
protected void startInternal() throws LifecycleException {
    String pathName = getPathname();
    try (InputStream is = ConfigFileLoader.getInputStream(pathName)) {
        // Load the contents of the database file
        if (log.isDebugEnabled()) {
            log.debug(sm.getString("memoryRealm.loadPath", pathName));
        }

        Digester digester = getDigester();
        try {
            synchronized (digester) {
                digester.push(this);
                digester.parse(is);
            }
        } catch (Exception e) {
            throw new LifecycleException(sm.getString("memoryRealm.readXml"), e);
        } finally {
            digester.reset();
        }
    } catch (IOException ioe) {
        throw new LifecycleException(sm.getString("memoryRealm.loadExist", pathName), ioe);
    }

    super.startInternal();
}
 

/**
 * Create and configure the Digester we will be using for setup store
 * registry.
 * @return the XML digester that will be used to parse the configuration
 */
protected static Digester createDigester() {
    long t1 = System.currentTimeMillis();
    // Initialize the digester
    Digester digester = new Digester();
    digester.setValidating(false);
    digester.setClassLoader(StoreRegistry.class.getClassLoader());

    // Configure the actions we will be using
    digester.addObjectCreate("Registry",
            "org.apache.catalina.storeconfig.StoreRegistry", "className");
    digester.addSetProperties("Registry");
    digester
            .addObjectCreate("Registry/Description",
                    "org.apache.catalina.storeconfig.StoreDescription",
                    "className");
    digester.addSetProperties("Registry/Description");
    digester.addRule("Registry/Description", new StoreFactoryRule(
            "org.apache.catalina.storeconfig.StoreFactoryBase",
            "storeFactoryClass",
            "org.apache.catalina.storeconfig.StoreAppender",
            "storeAppenderClass"));
    digester.addSetNext("Registry/Description", "registerDescription",
            "org.apache.catalina.storeconfig.StoreDescription");
    digester.addCallMethod("Registry/Description/TransientAttribute",
            "addTransientAttribute", 0);
    digester.addCallMethod("Registry/Description/TransientChild",
            "addTransientChild", 0);

    long t2 = System.currentTimeMillis();
    if (log.isDebugEnabled())
        log.debug("Digester for server-registry.xml created " + (t2 - t1));
    return digester;

}
 

private void addDescriptionGroup(Digester digester, String prefix) {
    digester.addCallMethod(prefix + "/info", "setInfo", 0);
    digester.addCallMethod(prefix + "small-icon", "setSmallIcon", 0);
    digester.addCallMethod(prefix + "large-icon", "setLargeIcon", 0);

    digester.addCallMethod(prefix + "/description", "setInfo", 0);
    digester.addCallMethod(prefix + "/display-name", "setDisplayName", 0);
    digester.addCallMethod(prefix + "/icon/small-icon", "setSmallIcon", 0);
    digester.addCallMethod(prefix + "/icon/large-icon", "setLargeIcon", 0);
}
 

@Override
public void addRuleInstances(Digester digester) {

    digester.addCallMethod(PREFIX + "/tlibversion", "setTlibVersion", 0);
    digester.addCallMethod(PREFIX + "/tlib-version", "setTlibVersion", 0);
    digester.addCallMethod(PREFIX + "/jspversion", "setJspVersion", 0);
    digester.addCallMethod(PREFIX + "/jsp-version", "setJspVersion", 0);
    digester.addRule(PREFIX, new Rule() {
        // for TLD 2.0 and later, jsp-version is set by version attribute
        @Override
        public void begin(String namespace, String name, Attributes attributes) {
            TaglibXml taglibXml = (TaglibXml) digester.peek();
            taglibXml.setJspVersion(attributes.getValue("version"));
        }
    });
    digester.addCallMethod(PREFIX + "/shortname", "setShortName", 0);
    digester.addCallMethod(PREFIX + "/short-name", "setShortName", 0);

    // Elements not permitted
    digester.addRule(PREFIX + "/uri", new ElementNotAllowedRule());
    digester.addRule(PREFIX + "/info", new ElementNotAllowedRule());
    digester.addRule(PREFIX + "/description", new ElementNotAllowedRule());
    digester.addRule(PREFIX + "/listener/listener-class", new ElementNotAllowedRule());

    digester.addRule(VALIDATOR_PREFIX, new ElementNotAllowedRule());
    digester.addRule(TAG_PREFIX, new ElementNotAllowedRule());
    digester.addRule(TAGFILE_PREFIX, new ElementNotAllowedRule());
    digester.addRule(FUNCTION_PREFIX, new ElementNotAllowedRule());
}
 

@Override
protected void processContextConfig(final Digester digester, final URL contextXml, final InputStream stream) {
    try {
        super.processContextConfig(digester, replaceKnownRealmsByTomEEOnes(contextXml), stream);
    } catch (final MalformedURLException e) {
        super.processContextConfig(digester, contextXml, stream);
    }
}
 

@Test
public void testWebapp_2_5() throws Exception {
    XmlErrorHandler handler = new XmlErrorHandler();
    Digester digester = DigesterFactory.newDigester(
            true, true, new WebRuleSet(false), true);
    digester.setErrorHandler(handler);
    digester.push(new WebXml());
    WebXml desc = (WebXml) digester.parse(
            new File("test/webapp-2.5/WEB-INF/web.xml"));
    Assert.assertEquals("2.5", desc.getVersion());
    Assert.assertEquals(0, handler.getErrors().size());
    Assert.assertEquals(0, handler.getWarnings().size());
}
 

private void doTestValidateVersion(String version) throws IOException, SAXException {
    WebXml webxml = new WebXml();

    // Special cases
    if ("2.2".equals(version)) {
        webxml.setPublicId(XmlIdentifiers.WEB_22_PUBLIC);
    } else if ("2.3".equals(version)) {
        webxml.setPublicId(XmlIdentifiers.WEB_23_PUBLIC);
    } else {
        webxml.setVersion(version);
    }

    // Merged web.xml that is published as MERGED_WEB_XML context attribute
    // in the simplest case consists of webapp's web.xml file
    // plus the default conf/web.xml one.
    Set<WebXml> defaults = new HashSet<>();
    defaults.add(getDefaultWebXmlFragment());
    webxml.merge(defaults);

    Digester digester = DigesterFactory.newDigester(true, true, new WebRuleSet(), true);

    XmlErrorHandler handler = new XmlErrorHandler();
    digester.setErrorHandler(handler);

    InputSource is = new InputSource(new StringReader(webxml.toXml()));
    WebXml webxmlResult = new WebXml();
    digester.push(webxmlResult);
    digester.parse(is);

    Assert.assertEquals(0, handler.getErrors().size());
    Assert.assertEquals(0, handler.getWarnings().size());

    Assert.assertEquals(version, webxml.getVersion());
    Assert.assertEquals(version, webxmlResult.getVersion());
}