source/mircoders/abuse/RegularExpressionFilterType.java

   1 /*
   2  * Copyright (C) 2001, 2002 The Mir-coders group
   3  *
   4  * This file is part of Mir.
   5  *
   6  * Mir is free software; you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License as published by
   8  * the Free Software Foundation; either version 2 of the License, or
   9  * (at your option) any later version.
  10  *
  11  * Mir is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  * GNU General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public License
  17  * along with Mir; if not, write to the Free Software
  18  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  19  *
  20  * In addition, as a special exception, The Mir-coders gives permission to link
  21  * the code of this program with  any library licensed under the Apache Software License,
  22  * The Sun (tm) Java Advanced Imaging library (JAI), The Sun JIMI library
  23  * (or with modified versions of the above that use the same license as the above),
  24  * and distribute linked combinations including the two.  You must obey the
  25  * GNU General Public License in all respects for all of the code used other than
  26  * the above mentioned libraries.  If you modify this file, you may extend this
  27  * exception to your version of the file, but you are not obligated to do so.
  28  * If you do not wish to do so, delete this exception statement from your version.
  29  */
  30
  31 package mircoders.abuse;
  32
  33 import gnu.regexp.RE;
  34
  35 import java.util.Arrays;
  36 import java.util.Iterator;
  37 import java.util.List;
  38
  39 import mir.entity.Entity;
  40 import mir.session.Request;
  41
  42
  43 /**
  44   * A description of a regular expression filter.
  45   */
  46  public class RegularExpressionFilterType extends AbstractFilterType {
  47     private boolean exactMatch;
  48     private boolean caseSensitive;
  49     private int fieldKind;
  50     private List selectedFields;
  51
  52     public static final int ENTITY_FIELDS = 0;
  53     public static final int REQUEST_HEADERS = 2;
  54
  55     public RegularExpressionFilterType(String aName) {
  56       this(aName, false, false, null);
  57     }
  58
  59     public RegularExpressionFilterType(String aName, boolean aCaseSensitive, boolean anExactMatch, String[] aSelectedFields) {
  60       this (aName, aCaseSensitive, anExactMatch, ENTITY_FIELDS, aSelectedFields);
  61     }
  62
  63     public RegularExpressionFilterType(String aName, boolean aCaseSensitive, boolean anExactMatch, int aFieldKind, String[] aSelectedFields) {
  64       super(aName);
  65
  66       fieldKind = aFieldKind;
  67
  68       caseSensitive = aCaseSensitive;
  69       exactMatch = anExactMatch;
  70       if (aSelectedFields==null)
  71         selectedFields = null;
  72       else
  73         selectedFields = Arrays.asList(aSelectedFields);
  74     }
  75
  76
  77   public FilterInstance constructFilterInstance(final String anExpression) throws AbuseExc {
  78     try {
  79       new RE(anExpression);
  80
  81       return new FilterInstance() {
  82
  83         public boolean test(Entity anEntity, Request aRequest) {
  84
  85           try {
  86             Iterator j;
  87             int flags = 0;
  88
  89             if (!caseSensitive) {
  90               flags |= RE.REG_ICASE;
  91             }
  92
  93             RE regularExpression = new RE(anExpression, flags);
  94
  95             switch (fieldKind) {
  96               case REQUEST_HEADERS:
  97                 if (selectedFields != null) {
  98                   j = selectedFields.iterator();
  99
 100                   while (j.hasNext()) {
 101                     String fieldName = (String) j.next();
 102                     String field = aRequest.getHeader(fieldName);
 103
 104                     if (exactMatch) {
 105                       if (field != null && regularExpression.isMatch(field)) {
 106                         return true;
 107                       }
 108                     }
 109                     else {
 110                       if (field != null && regularExpression.getMatch(field) != null) {
 111                         return true;
 112                       }
 113                     }
 114                   }
 115                 }
 116                 break;
 117               case ENTITY_FIELDS:
 118                 if (selectedFields != null)
 119                   j = selectedFields.iterator();
 120                 else
 121                   j = anEntity.getFieldNames().iterator();
 122
 123                 while (j.hasNext()) {
 124                   String field = anEntity.getFieldValue( (String) j.next());
 125
 126                   if (exactMatch) {
 127                     if (field != null && regularExpression.isMatch(field)) {
 128                       return true;
 129                     }
 130                   }
 131                   else {
 132                     if (field != null && regularExpression.getMatch(field) != null) {
 133                       return true;
 134                     }
 135                   }
 136                 }
 137             }
 138           }
 139           catch (Throwable t) {
 140           }
 141           return false;
 142         }
 143
 144         public String status() {
 145           return null;
 146         }
 147       };
 148     }
 149     catch (Throwable t) {
 150       throw new AbuseExc("Invalid expression: " + t.getMessage());
 151     }
 152   }
 153 }