2009/05/20 - Apache Shale has been retired.

 /*

  * 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.shale.remoting.impl;

 import java.io.IOException;

 import java.io.StreamTokenizer;

 import java.io.StringReader;

 import java.util.ArrayList;

 import java.util.List;

 import org.apache.shale.remoting.Processor;

 /**

  * <p>Abstract base class for {@link Processor} implementations that filter

  * requests based on matching the resource identifier against a set of

  * <code>includes</code> and <code>excludes</code> regular expressions.</p>

  *

  * @since 1.0.4

  */

 public abstract class FilteringProcessor implements Processor {

     // ------------------------------------------------------ Instance Variables

     /**

      * <p>Comma-delimited regular expression patterns to exclude remote host

      * names that match.</p>

      */

     private String excludes = null;

     /**

      * <p>Array of regular expression patterns for the excludes list.</p>

      */

     private String excludesPatterns[] = new String[0];

     /**

      * <p>Comma-delimited regular expression patterns to include remote host

      * names that match.</p>

      */

     private String includes = null;

     /**

      * <p>Array of regular expression patterns for the includes list.</p>

      */

     private String includesPatterns[] = new String[0];

     // -------------------------------------------------------------- Properties

     /**

      * <p>Return the comma-delimited regular expresson patterns to exclude

      * remote host names that match, if any; otherwise, return

      * <code>null</code>.</p>

      */

     public String getExcludes() { return this.excludes; }

     /**

      * <p>Set the comma-delimited regular expression patterns to exclude

      * remote host names that match, if any; or <code>null</code> for no

      * restrictions.</p>

      *

      * @param excludes New exclude pattern(s)

      */

     public void setExcludes(String excludes) {

         this.excludes = excludes;

         this.excludesPatterns = precompile(excludes);

     }

     /**

      * <p>Return the comma-delimited regular expresson patterns to include

      * remote host names that match, if any; otherwise, return

      * <code>null</code>.</p>

      */

     public String getIncludes() { return this.includes; }

     /**

      * <p>Set the comma-delimited regular expression patterns to include

      * remote host names that match, if any; or <code>null</code> for no

      * restrictions.</p>

      *

      * @param includes New include pattern(s)

      */

     public void setIncludes(String includes) {

         this.includes = includes;

         this.includesPatterns = precompile(includes);

     }

     // ------------------------------------------------------- Protected Methods

     /**

      * <p>Return <code>true</code> if we should accept a request for the

      * specified resource identifier, based upon our configured includes

      * and excludes patterns (if any).</p>

      *

      * @param resourceId Resource identifier to validate

      */

     protected boolean accept(String resourceId) {

         // Check for a match on the excluded list

         if (matches(resourceId, excludesPatterns, false)) {

             return false;

         }

         // Check for a match on the included list

         if (matches(resourceId, includesPatterns, true)) {

             return true;

         }

         // If there was at least one include pattern,

         // unconditionally reject this request

         if ((includesPatterns != null) && (includesPatterns.length > 0)) {

             return false;

         }

         // Unconditionally accept this request

         return true;

     }

     // --------------------------------------------------------- Private Methods

     /**

      * <p>Match the specified expression against the specified precompiled

      * patterns.  If there are no patterns, return the specified unrestricted

      * return value; otherwise, return <code>true</code> if the expression

      * matches one of the patterns, or <code>false</code> otherwise.</p>

      *

      * @param expr Expression to be tested

      * @param patterns Array of <code>Pattern</code> to be tested against

      * @param unrestricted Result to be returned if there are no matches

      */

     private boolean matches(String expr, String patterns[],

                             boolean unrestricted) {

         // Check for the unrestricted case

         if ((patterns == null) || (patterns.length == 0)) {

             return unrestricted;

         }

         // Compare each pattern in turn for a match

         for (int i = 0; i < patterns.length; i++) {

             if (patterns[i].startsWith("*")) {

                 if (expr.endsWith(patterns[i].substring(1))) {

                     return true;

                 }

             } else if (patterns[i].endsWith("*")) {

                 if (expr.startsWith(patterns[i].substring(0, patterns[i].length() - 1))) {

                     return true;

                 }

             } else {

                 if (patterns[i].equals(expr)) {

                     return true;

                 }

             }

         }

         // No match found, so return false

         return false;

     }

     /**

      * <p>Parse the specified string of comma-delimited URL pattern

      * matching expressions into an array of patterns that can be processed

      * at runtime more quickly.  Valid patterns are the same as those

      * supported for matching a request URI to a Processor instance:</p>

      * <ul>

      * <li>Must not be null or zero-length string</li>

      * <li>EITHER must start with "/" and end with "/*"</li>

      * <li>OR must start with "*." and not have any other period</li>

      * </ul>

      *

      * @param expr Comma-delimited URL pattern matching expressions

      *

      * @exception IllegalArgumentException if an invalid pattern is encountered

      */

      private String[] precompile(String expr) {

         if (expr == null) {

             return new String[0];

         }

         // Set up to parse the specified expression

         String pattern = null;

         StreamTokenizer st =

           new StreamTokenizer(new StringReader(expr));

         st.eolIsSignificant(false);

         st.lowerCaseMode(false);

         st.slashSlashComments(false);

         st.slashStarComments(false);

         st.wordChars(0x00, 0xff);

         st.quoteChar('\'');

         st.quoteChar('"');

         st.whitespaceChars(0, ' ');

         st.whitespaceChars(',', ',');

         List list = new ArrayList();

         int type = 0;

         // Parse and validate each included pattern

         while (true) {

             // Parse the next pattern

             try {

                 type = st.nextToken();

             } catch (IOException e) {

                 ; // Can not happen

             }

             if (type == StreamTokenizer.TT_EOF) {

                 break;

             } else if (type == StreamTokenizer.TT_NUMBER) {

                 pattern = "" + st.nval;

             } else if (type == StreamTokenizer.TT_WORD) {

                 pattern = st.sval.trim();

             } else {

                 throw new IllegalArgumentException(expr);

             }

             // Validate this pattern

             if (pattern.length() < 1) {

                 throw new IllegalArgumentException(pattern);

             }

             if (pattern.startsWith("/")) {

                 if (!pattern.endsWith("/*")) {

                     throw new IllegalArgumentException(pattern);

                 }

             } else if (pattern.startsWith("*.")) {

                 if (pattern.substring(2).indexOf('.') > 0) {

                     throw new IllegalArgumentException(pattern);

                 }

             } else {

                 throw new IllegalArgumentException(pattern);

             }

             // Add this pattern to our list

             list.add(pattern);

         }

         // Return the precompiled patterns as an array

         return (String[]) list.toArray(new String[list.size()]);

     }

 }