source/mircoders/abuse/ThrottleFilter.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 package mircoders.abuse;
  31
  32 import java.util.ArrayList;
  33 import java.util.Iterator;
  34 import java.util.List;
  35
  36 import mir.entity.Entity;
  37 import mir.session.Request;
  38 import mir.util.StringRoutines;
  39
  40 /**
  41  * A ip-based throttling filter.
  42  *
  43  * <p>
  44  * Expressions have the form <time in minutes>:<posting limit>
  45  */
  46 public class ThrottleFilter extends AbstractFilterType {
  47
  48   public ThrottleFilter(String aName) {
  49     super(aName);
  50   }
  51
  52   public FilterInstance constructFilterInstance(String anExpression) throws AbuseExc {
  53     List parts = StringRoutines.splitString(anExpression.trim(), ":");
  54
  55     if (parts.size()==2) {
  56       try {
  57         final int interval = Integer.parseInt((String) parts.get(0));
  58         final int limit = Integer.parseInt((String) parts.get(1));
  59
  60         if (interval<1) {
  61           throw new AbuseExc("Interval should be larger than 0");
  62         }
  63         if (limit<1) {
  64           throw new AbuseExc("Limit should be larger than 0");
  65         }
  66         final ThrottleManager manager = new ThrottleManager(interval*1000*60);
  67
  68         return new FilterInstance() {
  69           public boolean test(Entity anEntity, Request aRequest) {
  70             manager.addMessage(aRequest.getHeader("ip"));
  71             if (manager.count(aRequest.getHeader("ip")) > limit) {
  72               return true;
  73             }
  74
  75             return false;
  76           }
  77
  78           public String status() {
  79             return Integer.toString(manager.messages.size()) + " messages";
  80           }
  81         };
  82       }
  83       catch (AbuseExc e) {
  84         throw e;
  85       }
  86       catch (Throwable t) {
  87         throw new AbuseExc("Invalid expression: <interval>:<limit> expected");
  88       }
  89     }
  90                 throw new AbuseExc("Invalid expression: <interval>:<limit> expected");
  91   }
  92
  93   private class ThrottleManager {
  94     private long horizon;
  95     private List messages;
  96
  97     public ThrottleManager(long aHorizon) {
  98       horizon = aHorizon;
  99
 100       messages = new ArrayList();
 101     }
 102
 103     public void flush() {
 104       long limit = System.currentTimeMillis() - horizon;
 105
 106       while (messages.size()>0 && ((Message) messages.get(0)).getTime()<=limit) {
 107         messages.remove(0);
 108       }
 109     }
 110
 111     public void addMessage(String anIp) {
 112       Message newMessage = new Message(anIp, System.currentTimeMillis());
 113       messages.add(newMessage);
 114     }
 115
 116     public int count(String anIp) {
 117       flush();
 118
 119       int result = 0;
 120       Iterator i = messages.iterator();
 121       while (i.hasNext()) {
 122         Message message = (Message) i.next();
 123         if (message.getIp().equals(anIp)) {
 124           result = result + 1;
 125         }
 126       }
 127
 128       return result;
 129     }
 130
 131     private class Message {
 132       private String ip;
 133       private long time;
 134
 135       public Message(String anIp, long aTime) {
 136         ip = anIp;
 137         time = aTime;
 138       }
 139
 140       public String getIp() {
 141         return ip;
 142       }
 143
 144       public long getTime() {
 145         return time;
 146       }
 147     }
 148   }
 149 }