limit.c

Go to the documentation of this file.

#include "evl.h"

/* Data structure for storing statistics */

typedef struct Uc_Limit_t {
  int totalPkts;
  int maxPkts;
  util_timing_t lastArrivalTime;
  util_timing_t interval;
} Uc_Limit_t;

/**AutomaticStart */

// prototypes of static functions
static int Uc_UpdateLimit( Hash_t **hashPtr, char *argument );

/**AutomaticEnd */


/* \brief Code for limiting number of packets in a given time window.  

  Argument is of the form "double:int:string"
    - the double represents the time interval over which we measure
      the number of packets, in seconds
    - the int is the maximum number of packets we will allow
      in the specified time interval
    - the string represents the particular id of the calling rule

  Examples: "1.0:10:http req"  "0.01:1:ssh login"

  We need the string field, since there's a single function limit
  which may be used to limit the number of packets coming in more than
  one rule.  The string is used as a key in a hash table to get
  the corresponding limit structure.

*/

int
limit (Evl_Manager_t * mgr, Pkt_ProcessPkt_t * pp, void **mystate, void *argument )
{
  static Hash_t *limitHash;

  return Uc_UpdateLimit( & limitHash, argument );
}


/** \brief Allocate and initialize the stats structure, add to hash */

static Uc_Limit_t *
Uc_GetLimitStruct( 
  Hash_t *hash,
  char *argument
)
{
  Uc_Limit_t *result;

  if ( Hash_Lookup( hash, argument, & result ) ) {
    return result;
  }

  result = ( Uc_Limit_t * ) malloc( sizeof( Uc_Limit_t ) );

  result->totalPkts = 0;
  util_timing_set( & result->lastArrivalTime );

  double interval;
  int maxPkts;
  sscanf( argument, "%lf %d", & interval, & maxPkts );
  result->interval = util_timing_pair( interval );
  result->maxPkts = maxPkts;

  Hash_Insert( hash, argument, result );

  return result;
}


/** \brief Update limits data */

static int 
Uc_UpdateLimit(
  Hash_t **hashPtr,
  char *argument
)
{
  if ( NIL( Hash_t ) == *hashPtr ) {
    // first ever call, so initialize the hashPtr
    *hashPtr = Hash_InitTable( strcmp, st_strhash );
  }
  Hash_t *hash = *hashPtr;
  Uc_Limit_t *limit = Uc_GetLimitStruct( hash, argument );

  util_timing_t currentTime;
  util_timing_set( & currentTime );
  util_timing_t diffTime = util_timing_diff( currentTime, limit->lastArrivalTime );

  if ( util_timing_compare( diffTime, limit->interval ) ) {
    limit->totalPkts++;
    if ( limit->totalPkts > limit->maxPkts ) {
      return 1; // should drop, over limit
    }
    else {
      return 0;
    }
  }
  else {
    // more than the interval time has elapsed, reset
    limit->lastArrivalTime = currentTime;
    limit->totalPkts = 0;
  }
  return 0;
}