SpamUtil.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 <stdio.h>

#include <string.h>
#include <ctype.h>

#include <sys/types.h>
#include <sys/stat.h>
#ifndef _WIN32
#include <unistd.h>
#include <errno.h>
#endif

#include "SpamUtil.h"


const int SpamUtil::getFileSize( FILE *fp, const char *fileName, char *msgbuf )
{
  int fileSize = -1;
  if (fp != 0) {
    struct stat s;
    int fd = fileno( fp );
    if (fstat( fd, &s) == 0) {
      fileSize = s.st_size;
    }
    else {
      char *err_reason = strerror( errno);
      sprintf( msgbuf, "SpamUtil::getFileSize: could not open %s.  Reason: %s", 
               fileName, err_reason );
    }
  }
  return fileSize;
} // getFileSize


void SpamUtil::strncpy(char *pDest, const char *pSrc, size_t destSize )
{
  const size_t maxCopy = destSize-1;
  size_t ix;
  for (ix = 0; ix < maxCopy && pSrc[ix] != '\0'; ix++) {
    pDest[ix] = pSrc[ix];
  }
  pDest[ix] = '\0';
} // strncpy


const char *SpamUtil::skipWhiteSpace( const char *pBuf )
{
  while (*pBuf != '\0' && isspace( *pBuf )) {
    pBuf++;
  }
  return pBuf;
} // skipWhiteSpace


const char *SpamUtil::trimEnd(char *str )
{
  if (str != 0 && str[0] != '\0') {
    int len = strlen( str );
    int i;
    for (i = len-1; i >=0 && isspace(str[i]); i--)
      /* nada */;
    str[i+1] = '\0';
  }
  return str;
} // trimEnd


void SpamUtil::trim(const char *str )
{
  if (str != 0) {
    char *start = (char *)skipWhiteSpace( str );

    char *ptr = (char *)str;
    if (*start != '\0') {
      size_t len = strlen( str );
      char *end = (char *)&str[len-1];

      while (end > start && isspace( *end )) {
        end--;
      }
      size_t trimLen = (end - start) + 1;
      for (size_t i = 0; i < trimLen; i++) {
        *ptr = *start;
        start++;
        ptr++;
      }
    }
   *ptr = '\0';
  }
} // trim



bool SpamUtil::isBlankLine(const char *buf)
{
  bool blankLine = true;
  if (buf != 0) {
    for (; *buf != '\0'; buf++) {
      if (! isspace( *buf ) ) {
        blankLine = false;
        break;
      }
    } // for
  }
  return blankLine;
} // isBlankLine



bool SpamUtil::match(const char *bufStart,
                     const size_t len,
                     const char *word )
{
  assert( bufStart != 0 && word != 0);

  bool wordsMatch = false;
  if (len > 0) {
    wordsMatch = true;
    for (size_t i = 0; i < len; i++) {
      if (tolower(bufStart[i]) != word[i]) {
        wordsMatch = false;
        break;
      }
    } // for
  }

  return wordsMatch;
} // match


bool SpamUtil::match(const char *bufStart,
                     const char *bufEnd,
                     const char *word )
{
  assert( bufStart != 0 && word != 0);

  bool wordsMatch = false;
  int regionLen = bufEnd - bufStart;
  int wordLen = strlen( word );
  if (wordLen > 0 && wordLen == regionLen) {
    wordsMatch = true;
    for (size_t i = 0; i < wordLen; i++) {
      if (tolower(bufStart[i]) != word[i]) {
        wordsMatch = false;
        break;
      }
    } // for
  }

  return wordsMatch;
} // match



const char *SpamUtil::findColon( const char *buf )
{
  const char *pColon = 0;
  if (buf != 0) {
    for (; *buf != '\0'; buf++) {
      if (*buf == ':') {
        pColon = buf;
        break;
      }
    } // for
  }
  return pColon;
} // findColon



void SpamUtil::toLower(char *dest, const char *src, size_t size)
{
  // convert to lower case
  size_t j;
  for (j = 0; j < size-1 && src[j] != '\0'; j++) {
    dest[j] = tolower(src[j]);
  } // for
  dest[j] = '\0';
}


void SpamUtil::toLower(char *dest, const char *src)
{
  // convert to lower case
  size_t j;
  for (j = 0; src[j] != '\0'; j++) {
    dest[j] = tolower(src[j]);
  } // for
  dest[j] = '\0';
}


SpamUtil::contentType SpamUtil::classifySection( const char *buf )
{
  contentType type = UNKNOWN;
  char tempBuf[128];

  SpamUtil().toLower(tempBuf, buf, sizeof(tempBuf));

  const char *typeName = "unknown";
  if (strstr(buf, "multipart") != 0) {
    type = MULTIPART;
  }
  else if (strstr(buf, "html") != 0) {
    type = HTML;
  }
  else if (strstr(buf, "text") != 0) {
    type = TEXT;
  }
  else if (strstr(buf, "image") != 0) {
    type = IMAGE;
  }
  else if (strstr(buf, "audio") != 0) {
    type = AUDIO;
  }
  else if (strstr(buf, "application") != 0) {
    type = APPLICATION;
  }

  return type;
} // classifySection


const char *SpamUtil::typeToStr( contentType type )
{
  const char *typeName;
  
  switch (type) {
  case BAD_CONT:
    typeName = "bad content";
    break;
  case UNKNOWN:
    typeName = "unknown";
    break;
  case BLANK:
    typeName = "blank section";
    break;
  case HTML:
    typeName = "html";
    break;
  case TEXT:
    typeName = "text";
    break;
  case MULTIPART:
    typeName = "multipart";
    break;
  case IMAGE:
    typeName = "image";
    break;
  case APPLICATION:
    typeName = "application";
    break;
  case AUDIO:
    typeName = "audio";
    break;
  case WINDOZ:
    typeName = "windows chars";
    break;
  case BASE64:
    typeName = "base64";
    break;
  default:
    typeName = "bad content type";
    break;
  }
  return typeName;
} // typeToStr



const char *SpamUtil::classificationToStr( MailFilter::classification klass )
{
  const char *str;

  switch (klass) {
  case MailFilter::UNKNOWN:
    str = "UNKNOWN";
    break;
  case MailFilter::EMAIL:
    str = "EMAIL";
    break;
  case MailFilter::SUSPECT:
    str = "SUSPECT";
    break;
  case MailFilter::GARBAGE:
    str = "GARBAGE";
    break;
  default:
    str = "bad value";
    break;
  }

  return str;
}  // classificationToStr



MailFilter::classification SpamUtil::checkLine(const char *buf, 
                                               SpamParameters &params,
                                               char *foundStr,
                                               const size_t foundStrSize )
{
  const char *HTMLtag = "<html>"; // remember, input line is in lower case
  const char *BODYtag = "<body";  // body may have attributes, so the closing
                                  // angle bracket is omitted.
  MailFilter::classification klass = MailFilter::UNKNOWN;
  std::vector<const char *> spamWords = params.getSection(SpamParameters::spam_words);
  std::vector<const char *> killWords = params.getSection(SpamParameters::kill_words);

  foundStr[0] = '\0';
  char *pHtmlTag = 0;

  if ((pHtmlTag = strstr(buf, HTMLtag)) == 0) {
    pHtmlTag = strstr(buf, BODYtag);
  }

  if (pHtmlTag != 0) {
    strncpy(foundStr, pHtmlTag, foundStrSize);
    klass = MailFilter::SUSPECT;
  }
  else {
    const size_t len = spamWords.size();
    for (size_t i = 0; i < len; i++) {
      if (strstr(buf, spamWords[i]) != 0) {
        strncpy(foundStr, spamWords[i], foundStrSize);
        klass = MailFilter::SUSPECT;
        break;
      }
    } // for

    if (klass == MailFilter::UNKNOWN) {
      const size_t len = killWords.size();
      for (size_t i = 0; i < len; i++) {
        if (strstr(buf, killWords[i]) != 0) {
          strncpy(foundStr, killWords[i], foundStrSize);
          klass = MailFilter::GARBAGE;
          break;
        }
      }
    }
  }
  return klass;
} // checkLine

---