SpamParameters Class Reference

#include <SpamParameters.h>

List of all members.

Public Types
enum	SpamEnum {   to_list = 0, from_address, from_kill, spam_words,   kill_words, flags, my_domain, valid_users,   SpamEnumMax }
Public Member Functions
	SpamParameters (const char *paramFileName) throw ( SpamException )
	SpamParameters ()
	~SpamParameters ()
std::vector< const char * > &	getSection (SpamEnum sec) throw ( SpamException )
bool	hasFlag (const char *name)
void	print ()
Private Types
enum	paramState { BadState = 0, sectionDef, beginBracket, spamPhrase }
Private Member Functions
bool	skipLine (const char *buf)
void	finiteStateMachine (const char *buf) throw ( SpamException )
SpamEnum	findEnum (const char *str)
void	enterPhrase (const char *buf)
Private Attributes
SpamEnum	currentSection
paramState	currentState
Static Private Attributes
std::vector< const char * >	section [(size_t) SpamEnumMax]
const enumTableElem	enumTable []
bool	initialized = false

---

Detailed Description

Structure of the spam parameters file:

   to_list
   [
      allowed e-mail addresses in the "To:" part of the email.  For
      example: iank@bearcave.com.  Spammers frequently either don't
      have a "To:" (its filled in via SMTP)
   ]

   from_address
   [
      allowed from e-mail addresses.  These are email addresses that
      will not be checked for SPAM content.
   ]

   from_kill
   [
      strings that, when found in the from address will result in the
      email being marked as garbage.
   ]

   spam_words
   [
      words that probably mark the email as spam, but the email will still
      be placed in the junk_mail file.
   ]

   kill_words
   [
      email containing these words will be marked as garbage.
      Examples of such words are drug names, like viagra and xanax and
      penis.
   ]

   flags
   [
      The flags section contains various flags which control the
      operation of the spam filter.  By default, if a "kill" option is
      not selected, the e-mail will be sent to the spam file.  The
      flags section may be omitted, in which case no flags are active.

      kill_base64    Mark email that contains a base64 section as garbage
      debug          run spam filter in debug mode
      keep_garbage   Don't delete email that is marked as garbage, put it
                     in the garbage_mail file.
      trace_garbage  Generate a trace file that tracks the email that is 
                     marked as garbage and deleted.
   ]

  my_domain
  [
    A single line, with your domain address (for example, "bearcave.com"
  ]

  valid_users
  [
    Valid user names for the domain specified in my_domain
  ]

Comments: lines beginning with '#'

Words or phrases are listed, one per line. For example:

  kill_words
  [
    fuck
    hot sluts
  ]

Leading spaces are ignored, as are blank lines.

Definition at line 125 of file SpamParameters.h.

---

Constructor & Destructor Documentation

SpamParameters::SpamParameters (  const char *  paramFileName  )  throw ( SpamException )

Open the parameter file and read it into the SpamParameters object. Definition at line 250 of file SpamParameters.C. References Logger::getLogger(), and Logger::log(). { 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

SpamParameters::SpamParameters (   )

The default, argumentless constructor should only be called when the static parts of the object have been initialized. This happens via the constructor which is passed the parameter file name. Definition at line 241 of file SpamParameters.C. { assert( initialized ); }

SpamParameters::~SpamParameters (   )

The section array of vector<const char *> objects is a container for strings which were allocated via new. Recover this storage. Definition at line 221 of file SpamParameters.C. { 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

---

Member Function Documentation

void SpamParameters::enterPhrase (  const char *  buf  )  [private]

Enter a parameter phrase (a word or set of words) in the current section (for example, spam_words). Definition at line 91 of file SpamParameters.C. { 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

SpamParameters::SpamEnum SpamParameters::findEnum (  const char *  str  )  [private]

Given a string, like "kill_words" return the associated enumeration value (which happens to the the enumeration kill_words). Definition at line 72 of file SpamParameters.C. { 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::finiteStateMachine (  const char *  buf  )  throw ( SpamException ) [private]

A finite state machine which drives processing the sections. E.g., a section defintion is followed by a begin bracket, which is followed by zero or more spam phrases, which is followed by an end bracket. Definition at line 106 of file SpamParameters.C. { 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

vector< const char * > & SpamParameters::getSection (  SpamEnum  sec  )  throw ( SpamException )

Given a section enumeration, return the associated vector which contains the data for that section. Definition at line 182 of file SpamParameters.C. Referenced by MailHeader::checkAddressSection(), MailHeader::checkDomainAddrs(), MailHeader::checkFrom(), SpamUtil::checkLine(), hasFlag(), and print(). { 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  )

Look for a flag in the flags section. The function returns true if the flag is found, false otherwise. Definition at line 201 of file SpamParameters.C. References getSection(). Referenced by MailFilter::MailFilter(), main(), MailHeader::parseContentType(), and MailBody::processBySection(). { 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

void SpamParameters::print (   )

Print the parameter vectors for debugging. Definition at line 158 of file SpamParameters.C. References getSection(). { 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

bool SpamParameters::skipLine (  const char *  buf  )  [private]

Skip a blank line or a comment line. Note that leading and trailing spaces are "trimmed" from the line, so a blank line will consist of just the null character. Definition at line 58 of file SpamParameters.C. { bool skipIt = false; char ch = *buf; if (ch == '\0' || ch == '#') { skipIt = true; } return skipIt; } // skipLine

---

Member Data Documentation

const SpamParameters::enumTableElem SpamParameters::enumTable [static, private]

Initial value: { 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 ), } Definition at line 38 of file SpamParameters.C.

---

The documentation for this class was generated from the following files:

• SpamParameters.h
• SpamParameters.C

---