MailFilter.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 <stdlib.h>
#include <ctype.h>
#include <string.h>

#ifdef _WIN32
#include <io.h>      // for unlink on WIN32
#include <process.h>
#else
#include <errno.h>
#include <sys/types.h>
#include <unistd.h>  // for unlink on UNIX
#endif

#include "SpamUtil.h"
#include "MailHeader.h"
#include "MailBody.h"
#include "MailFilter.h"

// for vector
using namespace std;


const char *MailFilter::getNewTempFileName()
{
  const char* TEMP_NAME_ROOT = "mail_temp";
  const size_t BUF_SIZE = 64;;
  char *pBuf = new char[ BUF_SIZE ];
  
  int pid = getpid();
  // create a unique temporary file name
  mFileCount++;
  sprintf(pBuf, "%s_%d_%d", TEMP_NAME_ROOT, pid, mFileCount );
  fileNames.push_back( pBuf );
  return pBuf;
} // getNewTempFileName



FILE *MailFilter::openFile( const char *fileName, 
                            const char *mode,
                            const char *callingFunc )
{
  char msgbuf[ 128];

  FILE *fp = fopen( fileName, mode );
  if (fp == 0) {
    char *err_reason = strerror( errno);
    sprintf(msgbuf, "error opening %s.  Reason = %s", fileName, err_reason );
    log.log(Logger::ERROR, callingFunc, msgbuf );
  }
  else {
    sprintf(msgbuf, "Opened file %s", fileName );
    log.log(Logger::DEBUG, callingFunc, msgbuf );
  }
  return fp;
} // openFile


void MailFilter::closeFile( FILE *fp, 
                            const char *fileName, 
                            const char *callingFunc )
{
  char msgbuf[ 128];
  if (fp != 0) {
    fflush( fp );
    if (fclose( fp ) != 0) {
      char *err_reason = strerror( errno );
      sprintf(msgbuf, "Error closing %s.  Reason = %s", fileName, err_reason );
      log.log(Logger::ERROR, callingFunc, msgbuf );
    }
    else {
      sprintf(msgbuf, "Close file %s", fileName );
      log.log(Logger::DEBUG, callingFunc, msgbuf );
    }
  }
  else {
    log.log(Logger::DEBUG, callingFunc, "MailFilter::closeFile called with null file ptr.");
  }
} // closeFile


bool MailFilter::writeLine(const char *buf,
                           FILE *fp, 
                           const char *fileName, 
                           const char *callingFunc )
{
  bool writeOK = true;

  if (fputs( buf, fp ) == EOF) {
    writeOK = false;
    char msgbuf[128];
    char *err_reason = strerror( errno );
    sprintf(msgbuf, "Error writing to %s.  Reason = %s", fileName, err_reason );
    log.log(Logger::ERROR, callingFunc, msgbuf );
  }
  return writeOK;
} // writeLine


const char *MailFilter::readLine(char *buf, 
                                 const size_t bufSize,
                                 FILE *fp, 
                                 const char *fileName, 
                                 const char *callingFunc )
{
  char *inLine = 0;
  *buf = '\0';
  if ((inLine = fgets( buf, bufSize, fp )) == 0) {
    if (! feof(fp)) {
      char msgbuf[128];
      char *err_reason = strerror( errno );
      if (fileName != 0) {
        sprintf(msgbuf, "Error reading from %s.  Reason = %s", fileName, err_reason );
      }
      else if (fp == stdin) {
        sprintf(msgbuf, "Error reading from stdin.  Reason = %s", err_reason );
      }
      log.log(Logger::ERROR, callingFunc, msgbuf );
    }
  }
  return inLine;
} // readLine


MailFilter::~MailFilter()
{
  size_t numFiles = fileNames.size();
  for (int i = 0; i < numFiles; i++) {
    char *pStr = fileNames[i];
    delete [] pStr;
  }
} // ~MailFilter



bool MailFilter::isFromLine(const char *buf)
{
  static const char *FROM = "From ";
  static const size_t FROM_LEN = strlen( FROM );
  static const char *dow[] = {"Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat", 0 };
  static const char *mon[] =  {"Jan", "Feb", "Mar", "Apr",
                               "May", "Jun",  "Jul",  "Aug",  
                               "Sep",  "Oct",  "Nov", "Dec", 0 };
  char msgbuf[128];
  bool isFrom = false;

  if (buf != 0) {
    // find "From "
    if (strncmp(buf, FROM, FROM_LEN) == 0) {
      sprintf(msgbuf, "Found from line: %s", buf );
      log.log(Logger::DEBUG, "isFromLine", msgbuf);
      // find a day-of-the-week
      const char *pDOW = 0;
      for (const char **pDay = dow; *pDay != 0; pDay++) {
        if ((pDOW = strstr(buf, *pDay)) != 0) {
          break;
        }
      } // for
      if (pDOW != 0) {// if a day-of-the-week was found, find a month
        const char *pStartMonth = 0;
        for (const char **pMon = mon; *pMon != 0; pMon++) {
          if ((pStartMonth = strstr(pDOW+3, *pMon)) != 0) {
            break;
          }
        } // for
        // look for the day of the month (1..31)
        if (pStartMonth != 0) {
          const char *pDate = pStartMonth + 3;
          pDate = SpamUtil().skipWhiteSpace( pDate );
          if (isdigit(*pDate)) {
            int date = atoi( pDate );
            if (date >= 1 && date <= 31) {
              log.log(Logger::DEBUG, "isFromLine", "Found start of email");
              isFrom = true;
            }
          }
        }
      } // if pDow != 0
    }
  }
  return isFrom;
} // isFromLine



bool MailFilter::copyToTempFiles()
{
  const char *mode = "w";
  char buf[ 1024 ];
  char msgbuf[ 128];
  bool copyOK = true;
  const char *inLine = 0;
  const char *fileName = 0;
  FILE *fp = 0;
  bool firstFrom = true;

  log.log(Logger::DEBUG, "copyToTempFiles", "enter");

  do {
    if ((inLine = readLine(buf, sizeof(buf), stdin, 0, "copyToTempFiles"))) {
      if (isFromLine( buf )) {
        if (firstFrom) {
          firstFrom = false;
        }
        else {
          closeFile( fp, fileName, "copyToTempFiles");
        }
        fileName = getNewTempFileName();
        fp = openFile( fileName, mode, "copyToTempFiles" );
      } // isFromLine
      if (fp) {
        if (! writeLine(buf, fp, fileName, "copyToTempFiles")) {
          copyOK = false;
          break;
        }
      }
    } // inLine = readLine
    else {
      if (! feof(stdin)) {
        copyOK = false;
      }
      else {
        closeFile( fp, fileName, "copyToTempFiles");
      }
    }
  } while (inLine != 0);

  log.log(Logger::DEBUG, "copyToTempFiles", "exit");

  return copyOK;
} // copyToTempFiles



void MailFilter::error_append_file( const char *srcfile, 
                                    const char *destfile)
{
  static const char *SUBJECT = "subject";
  static size_t SUBJECT_LEN = strlen( SUBJECT );
  char msgbuf[ 128];
  const char *read_only = "r";
  const char *append = "a+";
  FILE *read_fp;
  FILE *write_fp;

  log.log(Logger::DEBUG, "error_append_file", "enter");
  
  if ((read_fp = fopen( srcfile, read_only )) != NULL) {
    if ((write_fp = fopen( destfile, append )) != NULL) {
      char line[ 4096 ];
      size_t amt_read;
      size_t amt_written;

      fprintf(write_fp, "\n");  // add a carriage return (blank line)

      while (fgets(line, sizeof(line), read_fp) != 0) {
        fputs(line, write_fp);
        // append "X-MailFilterError:" after the "Subject:" line
        if (SpamUtil().match(line, SUBJECT_LEN, SUBJECT)) {
          fprintf(write_fp, "X-MailFilterError:\n");
        }
      } // while 

      fclose( write_fp );
    }
    else {
      sprintf(msgbuf, "error opening file %s", destfile );
      log.log(Logger::ERROR, "error_append_file", msgbuf );
    }
    fclose( read_fp );
  }
  else {
    sprintf( msgbuf, "error opening file %s", srcfile );
    log.log(Logger::ERROR, "error_append_file", msgbuf );
  }
  log.log(Logger::DEBUG, "error_append_file", "exit");  
} // error_append_file


void MailFilter::append_file( const char *srcfile, 
                              const char *destfile)
{
  char msgbuf[ 128];
  const char *read_only = "r";
  const char *append = "a+";
  FILE *read_fp;
  FILE *write_fp;

  log.log(Logger::DEBUG, "append_file", "enter");
  
  if ((read_fp = fopen( srcfile, read_only )) != NULL) {
    if ((write_fp = fopen( destfile, append )) != NULL) {
      char buf[ 4096 ];
      size_t amt_read;
      size_t amt_written;

      fprintf(write_fp, "\n");  // add a carriage return (blank line)

      while ((amt_read = fread(buf, 1, sizeof(buf), read_fp)) > 0) {
        amt_written = fwrite(buf, 1, amt_read, write_fp );
        if (amt_written < amt_read) {
          char *err_reason = strerror( errno );
          sprintf(msgbuf, "error writing file %s.  Reason = %s", destfile, err_reason);
          log.log(Logger::ERROR, "append_file", msgbuf );
        }
      } // while 

      fclose( write_fp );
    }
    else {
      char *err_reason = strerror( errno );
      sprintf(msgbuf, "append_file: error opening file %s.  Reason = %s", 
              destfile, err_reason );
      log.log(Logger::ERROR, "append_file", msgbuf );
    }
    fclose( read_fp );
  }
  else {
    char *err_reason = strerror( errno );
    sprintf( msgbuf, "append_file: error opening file %s.  Reason = %s", 
             srcfile, err_reason );
    log.log(Logger::ERROR, "append_file", msgbuf );
  }
  log.log(Logger::DEBUG, "append_file", "exit");
}  // append_file



MailFilter::classification MailFilter::checkMail(const char *tempFileName, 
                                                 SpamParameters &params,
                                                 HeaderInfo &headInfo)
{
  const char *mode = "r";
  classification mailClass = EMAIL;
  char msgbuf[256];
  log.log(Logger::DEBUG, "checkMail", "enter");

  FILE *fp = openFile(tempFileName, mode, "checkMail");
  if (fp != NULL) {
    MailHeader headFilter( params, headInfo );
    mailClass = headFilter.checkHeader(fp);
    if (mailClass == UNKNOWN) {
      MailBody bodyFilter( params, headInfo );
      const char *boundaryStr = headFilter.getBoundaryStr();
      mailClass = bodyFilter.checkBody(boundaryStr, fp);
      headInfo.klass(mailClass);
    }
    fclose( fp );
  }

  log.log(Logger::DEBUG, "checkMail", "exit");
  return mailClass;
} // checkMail


MailFilter::MailFilter(SpamParameters &params) 
{
  // file for email
  const char* INBOX          = "inbox";
  // fiile for email that is suspected of being spam
  const char* SPAM           = "junk_mail";
  // File for email that is "garbage".
  const char* GARBAGE_MAIL   = "garbage_mail";

  mFileCount = 0;
  log = pLogger->getLogger("MailFilter");
  log.log(Logger::DEBUG, "MailFilter", "enter");

  bool doGarbageTrace = params.hasFlag("trace_garbage") &&
                        (! params.hasFlag("keep_garbage"));

  // read mail file from stdin into one or more temporary file
  if (copyToTempFiles()) {
    size_t numFiles = fileNames.size();
    for (int i = 0; i < numFiles; i++) {
      const char *tempFileName = fileNames[i];

      HeaderInfo headInfo( doGarbageTrace );

      char msg[256];
      classification kind = checkMail(tempFileName, 
                                      params,
                                      headInfo);

      Logger::LogLevel mode;

      switch (kind) {
      case UNKNOWN:
        {
          // If the email is classified as "UNKNOWN" then something is
          // wrong.  But we don't want to lose the email, so append it
          // to the inbox.
          sprintf(msg, "email classified as UNKNOWN");
          append_file( tempFileName, INBOX );
          mode = Logger::ERROR;
        }
        break;
      case EMAIL: 
        {
          sprintf(msg, "Subject: %s added to mail in %s", 
                  headInfo.subject(), INBOX );
          append_file( tempFileName, INBOX );
          mode = Logger::DEBUG;
        }
        break;
      case SUSPECT: {
        sprintf(msg, "Subject: %s added to suspected spam in %s", 
                headInfo.subject(), SPAM );
        append_file( tempFileName, SPAM );
        mode = Logger::DEBUG;
      }
        break;
      case GARBAGE: {
        if (params.hasFlag("keep_garbage")) {
          sprintf(msg, "Subject: %s is garbage, copied to %s", 
                  headInfo.subject(), GARBAGE_MAIL );
          append_file( tempFileName, GARBAGE_MAIL );
        }
        else {
          sprintf(msg, "Subject: %s deleted", headInfo.subject() );
        }
        mode = Logger::DEBUG;
      }
        break;
      case BAD_VALUE: { // something went wrong processing the e-mail
        sprintf(msg, "Mail filter error: Subject = %s", headInfo.subject() );
        // Append it to the inbox so it is not lost.  The error_append_file
        // function will add a marker to the file to indicate that there
        // was an error
        error_append_file( tempFileName, INBOX );
        mode = Logger::ERROR;
      }
        break;
      default: {
        sprintf(msg, "bad classification value" );
        mode = Logger::ERROR;
      }
        break;
      } // switch

      log.log( mode, "MailFilter", msg );

      if (! log.errorFound()) {
        // remove temporary file
        sprintf(msg, "removing %s", tempFileName );
        log.log(Logger::DEBUG, "MailFilter", msg );
        int unlinkRslt = unlink( tempFileName );
        if (unlinkRslt != 0) {
          sprintf(msg, "error unlinking %s.  Error = %s\n",
                  tempFileName, strerror(errno));
          log.log(Logger::ERROR, "MailFilter", msg );
        }
      }
      else {
        sprintf(msg, "email that caused the error is in %s", tempFileName );
        log.log(Logger::ERROR, "MailFilter", msg );
      }
    } // for
  } // if copyToTempFiles

  log.log(Logger::DEBUG, "MailFilter", "exit");
} // MailFilter constructor

---