ApplicationFilterConfig(Context context,
    FilterDef filterDef) throws ClassCastException, ClassNotFoundException, IllegalAccessException, InstantiationException, ServletException, InvocationTargetException, NamingException 
{
        super();
        if (restrictedFilters == null) {
            restrictedFilters = new Properties();
            try {
                InputStream is = 
                    this.getClass().getClassLoader().getResourceAsStream
                        ("org/apache/catalina/core/RestrictedFilters.properties");
                if (is != null) {
                    restrictedFilters.load(is);
                } else {
                    context.getLogger().error(sm.getString("applicationFilterConfig.restrictedFiltersResources"));
                }
            } catch (IOException e) {
                context.getLogger().error(sm.getString("applicationFilterConfig.restrictedServletsResources"), e);
            }
        }
        this.context = context;
        setFilterDef(filterDef);
}

Construct a new ApplicationFilterConfig for the specified filter definition.

Parameters:

context - The context with which we are associated

filterDef - Filter definition for which a FilterConfig is to be constructed

Throws:

ClassCastException - if the specified class does not implement the javax.servlet.Filter interface

ClassNotFoundException - if the filter class cannot be found

IllegalAccessException - if the filter class cannot be publicly instantiated

InstantiationException - if an exception occurs while instantiating the filter object

ServletException - if thrown by the filter's init() method

NamingException -

InvocationTargetException -

exception: ClassCastException - if the specified class does not implement the javax.servlet.Filter interface

exception: ClassNotFoundException - if the filter class cannot be found

exception: IllegalAccessException - if the filter class cannot be publicly instantiated

exception: InstantiationException - if an exception occurs while instantiating the filter object

exception: ServletException - if thrown by the filter's init() method

 Filter getFilter() throws ClassCastException, ClassNotFoundException, IllegalAccessException, InstantiationException, ServletException, InvocationTargetException, NamingException 
{
        // Return the existing filter instance, if any
        if (this.filter != null)
            return (this.filter);
        // Identify the class loader we will be using
        String filterClass = filterDef.getFilterClass();
        ClassLoader classLoader = null;
        if (filterClass.startsWith("org.apache.catalina."))
            classLoader = this.getClass().getClassLoader();
        else
            classLoader = context.getLoader().getClassLoader();
        ClassLoader oldCtxClassLoader =
            Thread.currentThread().getContextClassLoader();
        // Instantiate a new instance of this filter and return it
        Class clazz = classLoader.loadClass(filterClass);
        if (!isFilterAllowed(clazz)) {
            throw new SecurityException
                (sm.getString("applicationFilterConfig.privilegedFilter",
                        filterClass));
        }
        this.filter = (Filter) clazz.newInstance();
        if (!context.getIgnoreAnnotations()) {
            if (context instanceof StandardContext) {
               AnnotationProcessor processor = ((StandardContext)context).getAnnotationProcessor();
               processor.processAnnotations(this.filter);
               processor.postConstruct(this.filter);
            }
        }
        if (context instanceof StandardContext &&
            ((StandardContext) context).getSwallowOutput()) {
            try {
                SystemLogHandler.startCapture();
                filter.init(this);
            } finally {
                String log = SystemLogHandler.stopCapture();
                if (log != null && log.length()  > 0) {
                    getServletContext().log(log);
                }
            }
        } else {
            filter.init(this);
        }
        // Expose filter via JMX
        registerJMX();
        return (this.filter);
}

Return the application Filter we are configured for.

 public String getFilterClass() 
{
        return filterDef.getFilterClass();
}

Return the class of the filter we are configuring.

 FilterDef getFilterDef() 
{
        return (this.filterDef);
}

Return the filter definition we are configured for.

 public Map<String, String> getFilterInitParameterMap() 
{
        return Collections.unmodifiableMap(filterDef.getParameterMap());
}

 public String getFilterName() 
{
        return (filterDef.getFilterName());
}

Return the name of the filter we are configuring.

 public String getInitParameter(String name) 
{
        Map map = filterDef.getParameterMap();
        if (map == null)
            return (null);
        else
            return ((String) map.get(name));
}

Return a String containing the value of the named initialization parameter, or null if the parameter does not exist.

 public Enumeration getInitParameterNames() 
{
        Map map = filterDef.getParameterMap();
        if (map == null)
            return (new Enumerator(new ArrayList()));
        else
            return (new Enumerator(map.keySet()));
}

Return an Enumeration of the names of the initialization parameters for this Filter.

 public ServletContext getServletContext() 
{
        return (this.context.getServletContext());
}

Return the ServletContext of our associated web application.

 protected boolean isFilterAllowed(Class filterClass) 
{
        // Privileged webapps may load all servlets without restriction
        if (context.getPrivileged()) {
            return true;
        }
        Class clazz = filterClass;
        while (clazz != null && !clazz.getName().equals("javax.servlet.Filter")) {
            if ("restricted".equals(restrictedFilters.getProperty(clazz.getName()))) {
                return (false);
            }
            clazz = clazz.getSuperclass();
        }
        return (true);
}

Return true if loading this filter is allowed.

  void release() 
{
        unregisterJMX();
        if (this.filter != null)
        {
            if (Globals.IS_SECURITY_ENABLED) {
                try {
                    SecurityUtil.doAsPrivilege("destroy", filter); 
                } catch(java.lang.Exception ex){                    
                    context.getLogger().error("ApplicationFilterConfig.doAsPrivilege", ex);
                }
                SecurityUtil.remove(filter);
            } else { 
                filter.destroy();
            }
            if (!context.getIgnoreAnnotations()) {
                try {
                    ((StandardContext)context).getAnnotationProcessor().preDestroy(this.filter);
                } catch (Exception e) {
                    context.getLogger().error("ApplicationFilterConfig.preDestroy", e);
                }
            }
        }
        this.filter = null;
}

Release the Filter instance associated with this FilterConfig, if there is one.

  void setFilterDef(FilterDef filterDef) throws ClassCastException, ClassNotFoundException, IllegalAccessException, InstantiationException, ServletException, InvocationTargetException, NamingException 
{
        this.filterDef = filterDef;
        if (filterDef == null) {
            // Release any previously allocated filter instance
            if (this.filter != null){
                if (Globals.IS_SECURITY_ENABLED) {
                    try{
                        SecurityUtil.doAsPrivilege("destroy", filter);  
                    } catch(java.lang.Exception ex){    
                        context.getLogger().error("ApplicationFilterConfig.doAsPrivilege", ex);
                    }
                    SecurityUtil.remove(filter);
                } else { 
                    filter.destroy();
                }
                if (!context.getIgnoreAnnotations()) {
                    try {
                        ((StandardContext)context).getAnnotationProcessor().preDestroy(this.filter);
                    } catch (Exception e) {
                        context.getLogger().error("ApplicationFilterConfig.preDestroy", e);
                    }
                }
            }
            this.filter = null;
        } else {
            // Allocate a new filter instance
            Filter filter = getFilter();
        }
}

Set the filter definition we are configured for. This has the side effect of instantiating an instance of the corresponding filter class.

 public String toString() 
{
        StringBuffer sb = new StringBuffer("ApplicationFilterConfig[");
        sb.append("name=");
        sb.append(filterDef.getFilterName());
        sb.append(", filterClass=");
        sb.append(filterDef.getFilterClass());
        sb.append("]");
        return (sb.toString());
}

Return a String representation of this object.