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       }
  70       else {
  71         selectedFields = Arrays.asList(aSelectedFields);
  72       }
  73     }
  74
  75
  76   public FilterInstance constructFilterInstance(final String anExpression) throws AbuseExc {
  77     try {
  78       new RE(anExpression);
  79
  80       return new FilterInstance() {
  81
  82         public boolean test(Entity anEntity, Request aRequest) {
  83
  84           try {
  85             Iterator j;
  86             int flags = 0;
  87
  88             if (!caseSensitive) {
  89               flags |= RE.REG_ICASE;
  90             }
  91
  92             RE regularExpression = new RE(anExpression, flags);
  93
  94             switch (fieldKind) {
  95               case REQUEST_HEADERS:
  96                 if (selectedFields != null) {
  97                   j = selectedFields.iterator();
  98
  99                   while (j.hasNext()) {
 100                     String fieldName = (String) j.next();
 101                     String field = aRequest.getHeader(fieldName);
 102
 103                     if (exactMatch) {
 104                       if (field != null && regularExpression.isMatch(field)) {
 105                         return true;
 106                       }
 107                     }
 108                     else {
 109                       if (field != null && regularExpression.getMatch(field) != null) {
 110                         return true;
 111                       }
 112                     }
 113                   }
 114                 }
 115                 break;
 116               case ENTITY_FIELDS:
 117                 if (selectedFields != null) {
 118                   j = selectedFields.iterator();
 119                 }
 120                 else {
 121                   j = anEntity.getFieldNames().iterator();
 122                 }
 123
 124                 while (j.hasNext()) {
 125                   String field = anEntity.getFieldValue( (String) j.next());
 126
 127                   if (exactMatch) {
 128                     if (field != null && regularExpression.isMatch(field)) {
 129                       return true;
 130                     }
 131                   }
 132                   else {
 133                     if (field != null && regularExpression.getMatch(field) != null) {
 134                       return true;
 135                     }
 136                   }
 137                 }
 138             }
 139           }
 140           catch (Throwable t) {
 141           }
 142           return false;
 143         }
 144
 145         public String status() {
 146           return null;
 147         }
 148       };
 149     }
 150     catch (Throwable t) {
 151       throw new AbuseExc("Invalid expression: " + t.getMessage());
 152     }
 153   }
 154 }