SpamParameters.C

/*
  This email filter was written by Ian Kaplan, Bear Products
  International.  It is copyrighted by Ian Kaplan, 2004,
  www.bearcave.com.

  You have permission to use this software without restriction on two
  conditions:

    1. You must preserve this copyright notice in this software and
       any software derived from it.

    2. You accept any risk entailed in using this software.  By
       using this software, you acknowledge that you have a
       sophisticated background in software engineering and 
       understand the way this software functions.  You further
       acknowledge that using this software may result in the
       irretrievable loss of important e-email and you alone
       are responsible for this loss.

  If either of these conditions are unacceptable, you may not use any
  part of this software.

 */

#include <assert.h>
#include <stdlib.h>
#include <stdio.h>

#include <stdexcept>

#include "SpamUtil.h"
#include "Logger.h"
#include "SpamParameters.h"

using namespace std;

const SpamParameters::enumTableElem SpamParameters::enumTable[] = {
  enumTableElem("to_list", to_list ),
  enumTableElem("from_address", from_address ),
  enumTableElem("from_kill", from_kill ),
  enumTableElem("spam_words", spam_words),
  enumTableElem("kill_words", kill_words ),
  enumTableElem("flags", flags),
  enumTableElem("my_domain", my_domain ),
  enumTableElem("valid_users", valid_users ),
};

vector<const char *> SpamParameters::section[(size_t)SpamParameters::SpamEnumMax];

bool SpamParameters::initialized = false;

bool SpamParameters::skipLine(const char *buf)
{
  bool skipIt = false;
  char ch = *buf;
  if (ch == '\0' || ch == '#') {
    skipIt = true;
  }
  return skipIt;
}  // skipLine

SpamParameters::SpamEnum SpamParameters::findEnum(const char *str )
{
  SpamEnum enumVal = SpamEnumMax;
  size_t tableSize = sizeof(enumTable) / sizeof(enumTableElem);
  for (size_t i = 0; i < tableSize; i++) {
    const char *enumName = enumTable[i].name;
    if (strcmp(str, enumName) == 0) {
      enumVal = enumTable[i].enumVal;
      break;
    }
  }
  return enumVal;
} // findEnum


void SpamParameters::enterPhrase(const char *buf)
{
  size_t len = strlen( buf );
  char *storage = new char[ len + 1 ];
  SpamUtil().strncpy(storage, buf, len + 1);
  section[ (size_t)currentSection ].push_back( storage );
} // enterPhrase


void SpamParameters::finiteStateMachine( const char *buf )
  throw( SpamException )
{
  paramState nextState = BadState;
  switch (currentState) {
  case sectionDef: 
    {
      SpamEnum sec = findEnum(buf);
      if (sec != SpamEnumMax) {
        currentSection = sec;
        nextState = beginBracket;
      }
      else {
        throw SpamException("finiteStateMachine: section defintion expected");
      }
    }
    break;
  case beginBracket:
    {
      if (*buf == '[') {
        nextState = spamPhrase;
      }
      else {
        throw SpamException("finiteStateMachine: '[' expected");
      }
    }
    break;
  case spamPhrase:
    {
      if (*buf == ']') {
        nextState = sectionDef;
      }
      else {
        enterPhrase( buf );
        nextState = spamPhrase;
      }
    }
    break;
  default: 
    {
      throw SpamException("finiteStateMachine: unexpected state");
    }
    break;
  } // switch

  currentState = nextState;
} // finiteStateMachine


void SpamParameters::print()
{
  size_t tableSize = sizeof(enumTable) / sizeof(enumTableElem);
  for (size_t i = 0; i < tableSize; i++) {
    const char *name = enumTable[i].name;
    printf("%s\n", name );
    printf("[\n");
    vector<const char *> &vec = getSection( (SpamEnum)i );
    size_t len = vec.size();
    for (size_t j = 0; j < len; j++) {
      const char *ptr = vec[j];
      printf("   %s\n",  ptr );
    }

    printf("]\n");
  }  
} // print



vector<const char *> &SpamParameters::getSection( SpamEnum sec )
  throw( SpamException )
{
  static vector<const char *> bogus;
  vector<const char *> &vec = bogus;
  if (sec < SpamEnumMax) {
    vec = section[ (size_t)sec ];
  }
  else {
    throw out_of_range("getSection: bad enumeration argument");
  }
  return vec;
} // getSection


bool SpamParameters::hasFlag(const char *name)
{
  bool foundFlag = false;
  vector<const char *> flagVec = getSection( flags );
  size_t len = flagVec.size();
  for (size_t i = 0; i < len; i++) {
    if (strcmp(flagVec[i], name) == 0) {
      foundFlag = true;
      break;
    }
  }
  return foundFlag;
} // hasFlag



SpamParameters::~SpamParameters()
{
  for (size_t i = 0; i < (size_t)SpamEnumMax; i++) {
    vector<const char *> oneSec = section[i];
    size_t len = oneSec.size();
    for (size_t j = 0; j < len; j++) {
      const char *ptr = oneSec[j];
      if (ptr != 0) {
        delete [] (char *)ptr;
      }
    }
  }
} // SpamParameters destructor


SpamParameters::SpamParameters()
{
  assert( initialized );
}

SpamParameters::SpamParameters(const char *paramFileName )
  throw( SpamException )
{
  currentState = sectionDef;
  currentSection = SpamEnumMax;

  const size_t BUF_SIZE = 1024;
  const char *mode = "r";
  FILE *file = fopen( paramFileName, mode );
  if (file != 0) {
    size_t lineNum = 0;

    char buf[BUF_SIZE];
    while (fgets(buf, sizeof(buf), file) != 0) {
      lineNum++;
      SpamUtil().trim(buf); // remove leading and trailing spaces
      if (!skipLine(buf)) {
        try {
          finiteStateMachine( buf );
        }
        catch (SpamException e) {
          static char msg[128];
          sprintf(msg, "%s, line %d", e.what(), lineNum );
          throw SpamException( msg );
        }
      }
    }  // while
    if (lineNum > 0) {
      Logger log = pLogger->getLogger("SpamParameters");
      log.log(Logger::DEBUG, "SpamParameters", "finished reading parameter file");
    }
    if (feof(file)) {
      fclose(file);
    }
    else {
      throw SpamException("SpamParameters::SpamParameters:error reading file");
    }
  }
  else { 
    throw SpamException("SpamParameters::SpamParameters: could not open parameter file");
  }
  initialized = true;
} // SpamParameters

---