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 import mir.entity.Entity;
  35 import mir.session.Request;
  36
  37 import java.util.Arrays;
  38 import java.util.Iterator;
  39 import java.util.List;
  40
  41
  42 /**
  43   * A description of a regular expression filter.
  44   */
  45  public class RegularExpressionFilterType extends AbstractFilterType {
  46     private boolean exactMatch;
  47     private boolean caseSensitive;
  48     private int fieldKind;
  49     private List selectedFields;
  50
  51     public static final int ENTITY_FIELDS = 0;
  52     public static final int REQUEST_HEADERS = 2;
  53
  54     public RegularExpressionFilterType(String aName) {
  55       this(aName, false, false, null);
  56     }
  57
  58     public RegularExpressionFilterType(String aName, boolean aCaseSensitive, boolean anExactMatch, String[] aSelectedFields) {
  59       this (aName, aCaseSensitive, anExactMatch, ENTITY_FIELDS, aSelectedFields);
  60     }
  61
  62     public RegularExpressionFilterType(String aName, boolean aCaseSensitive, boolean anExactMatch, int aFieldKind, String[] aSelectedFields) {
  63       super(aName);
  64
  65       fieldKind = aFieldKind;
  66
  67       caseSensitive = aCaseSensitive;
  68       exactMatch = anExactMatch;
  69       if (aSelectedFields==null)
  70         selectedFields = null;
  71       else
  72         selectedFields = Arrays.asList(aSelectedFields);
  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                 else
 120                   j = anEntity.getFieldNames().iterator();
 121
 122                 while (j.hasNext()) {
 123                   String field = anEntity.getFieldValue( (String) j.next());
 124
 125                   if (exactMatch) {
 126                     if (field != null && regularExpression.isMatch(field)) {
 127                       return true;
 128                     }
 129                   }
 130                   else {
 131                     if (field != null && regularExpression.getMatch(field) != null) {
 132                       return true;
 133                     }
 134                   }
 135                 }
 136             }
 137           }
 138           catch (Throwable t) {
 139           }
 140           return false;
 141         }
 142
 143         public String status() {
 144           return null;
 145         }
 146       };
 147     }
 148     catch (Throwable t) {
 149       throw new AbuseExc("Invalid expression: " + t.getMessage());
 150     }
 151   }
 152 }