source/mircoders/abuse/RegularExpressionFilterType.java

   1 /*
   2  * Copyright (C) 2001-2006 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  * and distribute linked combinations including the two.  You must obey the
  23  * GNU General Public License in all respects for all of the code used other than
  24  * the above mentioned libraries.  If you modify this file, you may extend this
  25  * exception to your version of the file, but you are not obligated to do so.
  26  * If you do not wish to do so, delete this exception statement from your version.
  27  */
  28
  29 package mircoders.abuse;
  30
  31 import gnu.regexp.RE;
  32 import mir.entity.Entity;
  33 import mir.session.Request;
  34
  35 import java.util.Arrays;
  36 import java.util.Iterator;
  37 import java.util.List;
  38
  39
  40 /**
  41   * A description of a regular expression filter.
  42   */
  43  public class RegularExpressionFilterType extends AbstractFilterType {
  44     private boolean exactMatch;
  45     private boolean caseSensitive;
  46     private int fieldKind;
  47     private List selectedFields;
  48
  49     public static final int ENTITY_FIELDS = 0;
  50     public static final int REQUEST_HEADERS = 2;
  51
  52     public RegularExpressionFilterType(String aName) {
  53       this(aName, false, false, null);
  54     }
  55
  56     public RegularExpressionFilterType(String aName, boolean aCaseSensitive, boolean anExactMatch, String[] aSelectedFields) {
  57       this (aName, aCaseSensitive, anExactMatch, ENTITY_FIELDS, aSelectedFields);
  58     }
  59
  60     public RegularExpressionFilterType(String aName, boolean aCaseSensitive, boolean anExactMatch, int aFieldKind, String[] aSelectedFields) {
  61       super(aName);
  62
  63       fieldKind = aFieldKind;
  64
  65       caseSensitive = aCaseSensitive;
  66       exactMatch = anExactMatch;
  67       if (aSelectedFields==null)
  68         selectedFields = null;
  69       else
  70         selectedFields = Arrays.asList(aSelectedFields);
  71     }
  72
  73
  74   public FilterInstance constructFilterInstance(final String anExpression) throws AbuseExc {
  75     try {
  76       new RE(anExpression);
  77
  78       return new FilterInstance() {
  79
  80         public boolean test(Entity anEntity, Request aRequest) {
  81
  82           try {
  83             Iterator j;
  84             int flags = 0;
  85
  86             if (!caseSensitive) {
  87               flags |= RE.REG_ICASE;
  88             }
  89
  90             RE regularExpression = new RE(anExpression, flags);
  91
  92             switch (fieldKind) {
  93               case REQUEST_HEADERS:
  94                 if (selectedFields != null) {
  95                   j = selectedFields.iterator();
  96
  97                   while (j.hasNext()) {
  98                     String fieldName = (String) j.next();
  99                     String field = aRequest.getHeader(fieldName);
 100
 101                     if (exactMatch) {
 102                       if (field != null && regularExpression.isMatch(field)) {
 103                         return true;
 104                       }
 105                     }
 106                     else {
 107                       if (field != null && regularExpression.getMatch(field) != null) {
 108                         return true;
 109                       }
 110                     }
 111                   }
 112                 }
 113                 break;
 114               case ENTITY_FIELDS:
 115                 if (selectedFields != null)
 116                   j = selectedFields.iterator();
 117                 else
 118                   j = anEntity.getFieldNames().iterator();
 119
 120                 while (j.hasNext()) {
 121                   String field = anEntity.getFieldValue( (String) j.next());
 122
 123                   if (exactMatch) {
 124                     if (field != null && regularExpression.isMatch(field)) {
 125                       return true;
 126                     }
 127                   }
 128                   else {
 129                     if (field != null && regularExpression.getMatch(field) != null) {
 130                       return true;
 131                     }
 132                   }
 133                 }
 134             }
 135           }
 136           catch (Throwable t) {
 137           }
 138           return false;
 139         }
 140
 141         public String status() {
 142           return null;
 143         }
 144       };
 145     }
 146     catch (Throwable t) {
 147       throw new AbuseExc("Invalid expression: " + t.getMessage());
 148     }
 149   }
 150 }