Servlets Java


 * This filter is based on, and is a modification of, the request 
 * interception mechanism provided by Tomcat's remote request 
 * filter valves. Instead of returning a forbidden HTTP response,
 * it forwards the request to a custom blocked page.
 * 
 * In particular, it uses code from org.apache.catalina.valves.RequestFilterValve
 * to process a list of allowed and denied IP addresses and remote hosts, as well
 * as code to check the user's details against this list. The difference in this
 * filter is that it doesn't have implementing classes to differentiate between
 * IP addresses and remote hosts. It simply checks them all at once.
 *
 * @author Matthew Moodie
 * @version $Revision: 1.0 $ $Date: 2004/08/04 23:07:00 $
 */
public class RequestFilter implements Filter {
    // ----------------------------------------------------- Instance Variables
    /**
     * The comma-delimited set of allow expressions.
     */
    protected String allowedList = null;
    /**
     * The set of allow regular expressions we will evaluate.
     */
    protected RE allows[] = new RE[0];
    /**
     * The set of deny regular expressions we will evaluate.
     */
    protected RE denies[] = new RE[0];
    /**
     * The comma-delimited set of deny expressions.
     */
    protected String deniedList = null;
    /* The configuration associated with this filter */
    private FilterConfig config =  null;
    /* The page informing users that their request has been blocked */
    private String blockPage = "";
    /* The remote host and IP address of the client */
    private String host = null;
    private String ip = null; 
    /**
     * Initializes the filter at server startup.
     * Initialization consists of setting the list of allowed
     * and disallowed remote hosts and IP addresses.
     * @param _config The configuration associated with this filter
     *
     * @exception ServletException if there was a problem initializing this filter
     */
    public void init(FilterConfig _config)
      throws ServletException {
        this.config = _config;
        /* Get the initialization parameters as a string */
        allowedList = _config.getInitParameter("allow");
        deniedList = _config.getInitParameter("deny");
  blockPage = _config.getInitParameter("blockPage");
        /* Turn the lists into regular expression lists */
        allows = precalculate(allowedList);
        denies = precalculate(deniedList);
    }
    /**
     * Processes a request and blocks it as appropriate.
     * This method takes the list of allowed and disallowed
     * remote hosts and IP addresses and checks if the client's
     * details match them.
     *
     * Some of the code in this method comes from org.apache.catalina.valves.RequestFilterValve.
     *
     * @param _req The request
     * @param _res The response
     * @param _chain The filter chain that this filter belongs to
     *
     * @exception IOException if there is a problem with the filter
     *  chain or the forward
     * @exception ServletException if there is a problem with the filter
     *  chain or the forward
     */
    public void doFilter(ServletRequest _req, ServletResponse _res,
        FilterChain _chain) throws IOException, ServletException {
        /* Get the type */
        if (_req instanceof HttpServletRequest) {
            host = _req.getRemoteHost();
            ip = _req.getRemoteAddr();
        }
        // Check the deny patterns, if any
        for (int i = 0; i < denies.length; i++) {
            if (denies[i].match(host) || denies[i].match(ip)) {
                if (_req instanceof HttpServletRequest) {
              config.getServletContext().getRequestDispatcher(blockPage).forward(_req, _res);
              return;
                }
            }
        }
        if(!(_res.isCommitted())){
            // Check the allow patterns, if any
            for (int i = 0; i < allows.length; i++) {
                if (allows[i].match(host) || allows[i].match(ip)) {
        _chain.doFilter(_req, _res);
        return;
                }
            }
        }
        if(!(_res.isCommitted())){
            // Allow if denies specified but not allows
            if ((denies.length > 0) && (allows.length == 0)) {
                _chain.doFilter(_req, _res);
                return;
            }
        }
       if(!(_res.isCommitted())){
           // Deny this request
           if (_req instanceof HttpServletRequest) {
        config.getServletContext().getRequestDispatcher(blockPage).forward(_req, _res);
           } 
       }
    }
  
    /**
     * Return an array of regular expression objects initialized from the
     * specified argument, which must be null or a comma-delimited
     * list of regular expression patterns.
     *
     * This method comes from org.apache.catalina.valves.RequestFilterValve.
     *
     * @param list The comma-separated list of patterns
     *
     * @exception IllegalArgumentException if one of the patterns has
     *  invalid syntax
     */
    protected RE[] precalculate(String list) {
        if (list == null)
            return (new RE[0]);
        list = list.trim();
        if (list.length() < 1)
            return (new RE[0]);
        list += ",";
        ArrayList reList = new ArrayList();
        while (list.length() > 0) {
            int comma = list.indexOf(',');
            if (comma < 0)
                break;
            String pattern = list.substring(0, comma).trim();
            try {
                reList.add(new RE(pattern));
            } catch (RESyntaxException e) {
                IllegalArgumentException iae = new IllegalArgumentException("Illegal pattern: " +  pattern);
                throw iae;
            }
            list = list.substring(comma + 1);
        }
        RE reArray[] = new RE[reList.size()];
        return ((RE[]) reList.toArray(reArray));
    }
    /**
     * Called when the filter is taken out of service at server shutdown.
     *
     */
    public void destroy() {
        config = null;
    }
}