Enlisting Java in the War Against SPAM: The Screening Module

/*Begin comment block
          outputStream.println(
                            "DELE " + msgNumber);
          textArea.append(
               "DELE "+validateOneLine()+"n");
          textArea.append(
                "Deleted:" + msgNumber + "n");
*/End comment block
Listing 1

class Screen{

  TreeSet subjWordList;
  TreeSet bodyWordList;
  TreeSet friendlyWordList;
  Pop302 theGui;//save callback reference here
  String phrase;

Listing 2

  Screen(Pop302 theGui){//constructor
    this.theGui = theGui;

    makeSubjWordList();
    makeBodyWordList();
    makeFriendlyWordList();
  }//end constructor

Listing 3

  private void makeSubjWordList(){
    subjWordList = new TreeSet();

    try{
      BufferedReader inData
        = new BufferedReader(new FileReader(
                                 "Pop302a.txt"));
      String data; //temp holding area

      while((data = inData.readLine()) != null){
        subjWordList.add(data);

      }//end while loop
      inData.close();//Close file
    }catch(Exception e){e.printStackTrace();}
  }//end makeSubjWordList

Listing 4

  private void makeBodyWordList(){
    bodyWordList = new TreeSet();

    try{
      BufferedReader inData
        = new BufferedReader(new FileReader(
                                 "Pop302b.txt"));
      String data; //temp holding area

      while((data = inData.readLine()) != null){
        bodyWordList.add(data);

      }//end while loop
      inData.close();//Close file
    }catch(Exception e){e.printStackTrace();}
  }//end makeBodyWordList

Listing 5

  private void makeFriendlyWordList(){
    friendlyWordList = new TreeSet();

    try{
      BufferedReader inData
        = new BufferedReader(new FileReader(
                                 "Pop302c.txt"));
      String data; //temp holding area

      while((data = inData.readLine()) != null){
        friendlyWordList.add(data);

      }//end while loop
      inData.close();//Close file
    }catch(Exception e){e.printStackTrace();}
  }//end makeFriendlyWordList

Listing 6

              match = screener.screenMsg(
                        fileName,uidl,theResult);

Listing 7

  public boolean screenMsg(String fileName,
             String uidl,ScreenResult theResult){

    //Initialize return value to false
    boolean match = false;

Listing 8

    try{
      BufferedReader inData
        = new BufferedReader(new FileReader(
                                      fileName));
      String data;//temp holding area

Listing 9

      inData.mark(10000);

      theResult.subject = "No Subj line found";
      theResult.from = "No From line found";

Listing 10

  private String removeStars(String stringIn){
    StringBuffer stringBuf =
                      new StringBuffer(stringIn);
    int index = 0;
    while(index > -1){
      index = stringBuf.lastIndexOf("*");
      if(index > -1){
        stringBuf.delete(index,index+1);
      }//end if
    }//end while
    stringBuf.append("**");
    return new String(stringBuf);
  }//end removeStars()

Listing 11

      while((data = inData.readLine()) != null){
        data = removeStars(data).toUpperCase();
        if(data.startsWith("SUBJECT:")){

Listing 12

          theResult.subject = data.toUpperCase();

Listing 13

          Iterator iterator =
                     friendlyWordList.iterator();
          while(iterator.hasNext()){
            String friendlyWord =
                     ((String)(iterator.next())).
                                   toUpperCase();
            match = false;
            if(!(friendlyWord.equals(""))){
              match = screenOnPhrase(
                            data,friendlyWord,0);
            }//end if

Listing 14

            if(match == true){
              inData.close();
              new File(fileName).delete();

              theResult.thePhrase = phrase;

              return false;
            }//end if match = true

          }//end while iterator has next

Listing 15

          break;
        }//end if data.startsWithSUBJECT:
      }//end while input is not null

Listing 16

      inData.reset();

Listing 17

      while((data = inData.readLine()) != null){
        data = removeStars(data.toUpperCase());
        if(data.startsWith("FROM:")){
          theResult.from = data;
          Iterator iterator =
                     friendlyWordList.iterator();
          while(iterator.hasNext()){
            String friendlyWord =
                     ((String)(iterator.next())).
                                   toUpperCase();
            match = false;
            if(!(friendlyWord.equals(""))){
              match = screenOnPhrase(
                            data,friendlyWord,0);
            }//end if

            if(match == true){
              inData.close();
              new File(fileName).delete();
              theResult.thePhrase = phrase;
              return false;
            }//end if match = true
          }//end while iterator has next
          break;
        }//end if data starts with From
      }//end while input is not null
  
      inData.reset();

Listing 18

  private boolean screenOnPhrase(String data,
                                 String phrase,
                                 int spanLim){
    this.phrase = phrase;
    StringBuffer str = new StringBuffer();
    ArrayList locationData = new ArrayList();

Listing 19

    TreeSet treeSet = new TreeSet();
    for(int cnt = 0; cnt < phrase.length();
                                          cnt++){
      treeSet.add(
              new Character(phrase.charAt(cnt)));
    }//end for loop

    Iterator iter = treeSet.iterator();
    StringBuffer tempPhrase = new StringBuffer();
    while(iter.hasNext()){
      tempPhrase.append(
         ((Character)(iter.next())).charValue());
    }//end while

Listing 20

    for(int i = 0; i < data.length(); i++){
      for(int j = 0; j < tempPhrase.length();
                                            j++){
        if(data.charAt(i) ==
                           tempPhrase.charAt(j)){
          str.append(data.charAt(i));
          locationData.add(new Integer(i));
        }//end if
      }//end for on tempPhrase
    }//end for on data

Listing 21

    int match = str.indexOf(phrase);
    if(match == -1){
      return false;//no match
    }//end if

Listing 22

    int maxSpan = 0;
    int locA = ((Integer)locationData.
                          get(match)).intValue();
    int locB = 0;
    for(int cnt = 1; cnt < phrase.length();
                                          cnt++){
      locB = ((Integer)locationData.get(
                        match + cnt)).intValue();
      int span = locB - locA;
      if(span > maxSpan){
        maxSpan = span;
      }//end if
      locA = locB;
    }//end for loop

    if(maxSpan > spanLim+1){
      return false;//span too large
    }else{
      return true;//made a match
    }//end else

  }//end screenOnPhrase

Listing 23

      int progressCounter = 0;
      while((data = inData.readLine()) != null){
        data = removeStars(data);
        if(data.startsWith("Subject")){

          data = data.toUpperCase();

          theResult.text =
                    theResult.text + data + "n";

          //Display progress on the GUI. 
          if(++progressCounter < 50){
            theGui.textArea.append(".");
          }else{//Display progress on a new line
            progressCounter = 0;
            theGui.textArea.append(".n");
          }//end else

Listing 24

          match = false;
          Iterator iterator =
                         subjWordList.iterator();
          while(iterator.hasNext()){
            String subjWord =
                     ((String)(iterator.next())).
                                   toUpperCase();
            if(!(subjWord.equals(""))){
              match = screenOnPhrase(
                                data,subjWord,1);
            }//end if

Listing 25

            if(match == true){
              //Move local message file
              inData.close();
              boolean moved =
                     new File(fileName).renameTo(
                       new File(
                         "c:/MailFiles/Archives/"
                                  +uidl+".txt"));
              if(!moved)System.out.println(
                "Unable to move file " + uidl);

              //Break out of Iterator loop
              break;
            }//end if match == true
          }//end while iterator has next
        }//end if data starts with Subject

Listing 26

        else{
          data = data.toUpperCase();
          theResult.text =
                    theResult.text + data + "n";
          if(++progressCounter < 50){
            theGui.textArea.append(".");
          }else{
            progressCounter = 0;
            theGui.textArea.append(".n");
          }//end else

Listing 27

          Iterator iterator = bodyWordList.
                                      iterator();
          match = false;
          while(iterator.hasNext()){
            String bodyWord =
                     ((String)(iterator.next())).
                                   toUpperCase();
            if(!(bodyWord.equals(""))){
              match = screenOnPhrase(
                                data,bodyWord,1);
            }//end if

Listing 28

            if(match == true){
              inData.close();
              boolean moved =
                     new File(fileName).renameTo(
                       new File(
                         "c:/MailFiles/Archives/"
                                  +uidl+".txt"));
              if(!moved)System.out.println(
                "Unable to move file " + uidl);

              break;
            }//end if match == true
          }//end while iterator has next
        }//end else for line not Subject line

Listing 29

        if(match == true)break;
      }//end while loop on read until null

Listing 30

      inData.close();//Close file if still open
    }catch(Exception e){e.printStackTrace();}

Listing 31

    theResult.thePhrase = phrase;

Listing 32

    return match;
  }//end screenMsg method

}//end class Screen

Listing 33

/*File Pop302.java Copyright 2004, R.G.Baldwin
Rev 01/02/04

Upgraded on 01/02/04 to do the following:
-Display msgNumber in text area while awaiting
 decision to delete or not to delete.
-Confirm that local msgNumber is in synch with
 message number on server (in UIDL) before
 deletion of a message from the server.

The purpose of this program is to read messages
from a POP3 server, analyze the messages
according to screening rules, and delete those
messages from the server that fail the screening
test.  (As written, the program asks the user
to confirm the deletion of each message, but
this confirmation step could easily be removed.)

This version of the program screens on the basis
of key words or phrases in the From line, key
words or phrases in the Subject line, and key
words or phrases in the body text.

A list of friendly Email addresses is used to
screen the From line.  Messages that are from
friendly Email addresses are not deleted from
the server and no information about those
messages is saved on the local disk.  They are
totally ignored after determining that they were
sent from a friendly Email address.

Different lists of words are used for screening
Subject lines and body text.  For example,
ANTIVIRUS is appropriate for screening the
Subject line, but is not appropriate for
screening the body text.  The word ANTIVIRUS
often appears legally in the header of Email
messages that have been scanned for viruses by
the server, but also often appears in the Subject
line of SPAM messages.

The common spammer tricks of inserting extra
characters between the characters in the
offending word and mixing the case of the
characters in the offending word is defeated by
this program.

For example, this program will flag for deletion
a message having any of the following in its
Subject line or its body text:

vIaGrA
V.IagRA
V.I.A.G.R.A

This program also defeats the common trick of
appending random characters to the end of the
Subject line, because it doesn't require a match
for the entire Subject line.

When the program detects a message that is a
candidate for deletion, the user is asked to
verify the deletion by clicking the Delete
button.  If the user doesn't want to delete the
message, she should click the Start/Next
button.

The following information is available to the
user for making that decision:
- From
- Subject
- Offending line, which may also be the subject
- Offending word or phrase
- Entire raw text of the message up to and
  including the offending line

All messages that are candidates for deletion
from the server are saved in an archive folder
on the local disk, regardless of whether the
user elects to delete them from the server. Thus
if a message is deleted from the server and it is
later determined that was a mistake, a raw text
copy of the deleted message is available locally
in the archive folder.  You should probably empty
this folder periodically so that it won't fill
up your disk.

Except for friendly messages, all messages that
are not candidates for deletion from the server
are saved in a history folder on the local
disk. These messages can be used later to train
the program to do a better job of recognizing
SPAM.

Before any message is saved in a local file,
asterisks are inserted into the text on
ten-character intervals in an attempt to destroy
any virus code that may be embedded in the
message.

Numerous upgrades are possible.  One possible
upgrade is to create a premium list of words and
phrases that will always result in deletion of
the message from the server without prior
approval by the user.  For example, the user
might want to have any message containing
VIAGRA to be automatically deleted.  However,
great care is urged in this regard.  Certain
words such as SPAM and PORN occasionally occur
in a message with the letters separated by only
a few characters.  This program would identify
those messages as being candidates for deletion.
For example, the offending word PORN occurs in
the non-offending word imPORtaNt with the letters
R and N separated by only two characters. The
word SLUT appears in the word SoLUTion with only
one character between the S and the L.  The word
SPAM often occurs in different variations of
body text.

Another possible upgrade would be to allow the
user to specify the number of characters that may
occur between the letters of an offending word
or phrase. As programmed, that value is
hard-coded into the program, and as of this
writing, that value is one.

If the number of characters is set to zero, many
spam messages will avoid detection.  If that
value is set to a large number, many false alarms
will occur.  Therefore, care should be taken when
adjusting this value.

Another possible modification would be to allow
the program to automatically delete all
messages that are determined to be candidates
for deletion.  Since these messages are saved
locally in an archive folder, a separate program
could be written to allow the user to review
those messages locally at her convenience just
in case a valid message was inadvertently
deleted from the server.

Companion programs that I have written provide
for creating and maintaining the word lists
discussed above in disk files.  These programs
are used to analyze the non-deleted message files
saved locally in the history folder in order to
train this program to do a better job of
identifying SPAM messages in the future. These
programs are designed for ease of use to
encourage the user to train the program
frequently.

All three word lists are maintained in simple
text files, which can be edited with an
ordinary text editor if need be.

For technical information on POP3, see RFC 1725
at
http://www.cis.ohio-state.edu/htbin/rfc/rfc1725.
html

A POP3 Command Summary follows based on the
information at that web site.

Minimal POP3 Commands:
USER name
PASS string
QUIT
STAT
LIST [msg]
RETR msg
DELE msg
NOOP
RSET
QUIT

Optional POP3 Commands:
APOP name digest
TOP msg n
UIDL [msg]

POP3 Replies:
+OK
-ERR

File names:  The following file names are hard-
coded into the program:

The file name for a local copy of a message is
the unique identifier for that message obtained
from the mail server.

Pop302a.txt - contains a word list for screening
 the Subject lines.

Pop302b.txt - contains a word list for screening
 the body text lines.

Pop302c.txt - contains a list of friendly Email
 addresses for screening the From lines to
 identify friendly messages.

This program consists of two main classes.  An
object of the class named Pop302 handles all
communications with the Pop3 server.

An object of the class named Screen screens each
message in an attempt to identify SPAM.  This
class can be totally replaced by Java programmers
who wish to design their own screening algorithm
provided they maintain the interface with the
object of the class named Pop302.

Tested using SDK 1.4.2 under WinXP
************************************************/

import java.net.*;
import java.io.*;
import java.util.*;
import java.awt.*;
import java.awt.event.*;

class Pop302 extends Frame{
  int msgCounter = 0;
  int msgNumber;
  TextArea textArea;
  TextField subjField;
  TextField fromField;
  TextField operMsgField;
  int numberMsgs = 0;
  String uidl = "";//unique msg ID
  BufferedReader inputStream;
  PrintWriter outputStream;
  Socket socket;
  Screen screener;
  String fileName;

  public static void main(String[] args){
    if(args.length != 3){
      System.out.println("Usage: java Pop301 "
                   + "server userName password");
      System.exit(0);
    }//end if

    new Pop302(args[0],args[1],args[2]);
  }//end main
  //===========================================//

  Pop302(String server,String userName,
                                String password){
    //Instantiate a new Screen object and pass
    // this to allow for the object to call back
    // and update the progress indicator.
    screener = new Screen(this);

    int port = 110; //pop3 mail port
    try{
      //Get a socket, connected to the
      // specified server on the specified
      // port.
      socket = new Socket(server,port);

      //Get an input stream from the socket
      inputStream = new BufferedReader(
                     new InputStreamReader(
                       socket.getInputStream()));

      //Get  an output stream to the socket.
      // Note that this stream will autoflush.
      outputStream = new PrintWriter(
               new OutputStreamWriter(
                 socket.getOutputStream()),true);

      //Display the msg received from the
      // server on the command-line screen
      // immediately following connection.
      String connectMsg = validateOneLine();
      System.out.println("Connected to server "
                                   + connectMsg);

      //The communication process is now in the
      // AUTHORIZATION state.  Send the user
      // name and password to the server. Note
      // that the use of an APOP command
      // for sending user name and password
      // would probably be more secure
      // if it is supported by the server.
      // However, my server apparently doesn't
      // support APOP.
      //Commands are sent in plain text, upper
      // case to the server.  Some commands
      // require an argument following the
      // command, as is the case with USER.
      //Send the command.
      outputStream.println("USER " + userName);
      //Get response and confirm that the
      // response was +OK and was not -ERR.
      String userResponse = validateOneLine();
      //Display the response on the command-
      // line screen.  Cannot display in the
      // GUI at this point in time because the
      // GUI object is not ready for use at
      // this point in the execution of the
      // constructor.
      System.out.println("USER " + userResponse);
      //Send the password to the server
      outputStream.println("PASS " + password);
      //Validate the server's response as +OK.
      // Display the response in the process.
      System.out.println(
                    "PASS " + validateOneLine());
    }catch(Exception e){e.printStackTrace();}

    //Register a window listener to service
    // the close button on the Frame.  This is
    // an anonymous class defiition.
    this.addWindowListener(
      new WindowAdapter(){
        public void windowClosing(WindowEvent e){

          //Terminate the session with the
          // server.
          outputStream.println("QUIT");
          String quitResponse =
                               validateOneLine();
          //Display the response on the
          // command-line screen.
          System.out.println(
                         "QUIT " + quitResponse);
          //Also display the response on the
          // GUI.  However, you probably won't
          // see it because the GUI is
          // closing.
          textArea.append(quitResponse + "n");

          //Server is now in the UPDATE mode.
          // It will delete all files marked
          // with the DELE command earlier
          // in the execution of the program.
          //Close the socket
          try{
            socket.close();
          }catch(Exception ex){
            ex.printStackTrace();}

          System.exit(0);
        }//end windowClosing
      }//end WindowAdapter()
    );//end addWindowListener

    //Note, this GUI was purposely made narrow
    // in order to make it fit into the
    // publication format.  You should make
    // it wider and also increase the width of
    // the text fields and the TextArea defined
    // below to make it more useful.
    setLayout(new FlowLayout());
    //Note that the compiler requires the
    // references to the following buttons to
    // be final because they are accessed from
    // within an anonymous class definition.
    final Button startButton =
                        new Button("Start/Next");
    final Button deleteButton =
                            new Button("Delete");
    subjField = new TextField(
                         "Display Subj here",50);
    fromField = new TextField(
                    "Display From line here",50);
    operMsgField = new TextField(
            "Display operator messages here",50);
    textArea = new TextArea(15,50);
    textArea.append("Display raw data heren");

    //Register an ActionListener on the
    // startButton.  This is an anonymous
    // class definition.
    startButton.addActionListener(
      new ActionListener(){
        public void actionPerformed(
                                  ActionEvent e){
          //Clear the operator message field
          operMsgField.setText("");

          try{
            //The communication process is now
            // in the TRANSACTION state.
            //Retrive and screen messages
            if(numberMsgs == 0){
              //Calculate numberMsgs only at
              // the beginning of the run,
              // because it changes when
              // messages are deleted.
              outputStream.println("STAT");
              String stat = validateOneLine();
              //Get the number of messages as
              // a String.
              String numberMsgsStr =
                       stat.substring(
                          4,stat.indexOf(" ",5));
              //Convert the String to an int.
              numberMsgs = Integer.parseInt(
                                  numberMsgsStr);
            }//end if numberMsgs == 0
            //NOTE: Msg numbers begin with 1,
            // not 0.
            //Retrieve and screen each
            // message.  Each msg ends with a
            // period on a new line.
            msgNumber = msgCounter + 1;

            if(msgNumber <= numberMsgs){
              //Process the next message.

              //Get and save a unique identifier
              // for the message from the server
              // and validate the response.
              outputStream.println(
                            "UIDL " + msgNumber);
              uidl = validateOneLine();

              //Open an output file to save
              // the message.  Use the UIDL
              // as the file name.  Others
              // may need to modify the
              // following code to identify
              // a folder for local storage of
              // the messages.
              fileName =
                  "c:/MailFiles/" + uidl +".txt";
              DataOutputStream dataOut =
                          new DataOutputStream(
                            new FileOutputStream(
                                      fileName));

              //Send a RETR command to begin
              // the message retrieval process
              outputStream.println(
                            "RETR " + msgNumber);
              //Validate the response.
              String retrResponse =
                               validateOneLine();

              //Clear the text in the TextArea
              // at the beginning of each new
              // message.  If you don't do
              // this, the String being
              // displayed will become very
              // long and the program will run
              // very slowly for large numbers
              // of messages.
              textArea.setText("");

              //Read the first line in the
              // message from the server.
              String msgLine =
                          inputStream.readLine();
              //Insert asterisks in the text
              // in an attempt to destroy
              // viruses before the file is
              // stored locally.
              msgLine = insertStars(msgLine);

              //Continue reading lines until
              // a "." is encountered as the
              // first char in a line.  That
              // signals the end of the msg.
              while(!(msgLine.equals("."))){
                //Write the line to the output
                // file and read the next
                // line.  Insert newline
                // characters when writing the
                // output to the file.
                dataOut.writeBytes(
                                 msgLine + "n");
                msgLine = inputStream.readLine();
                //Insert asterisks to destroy
                // virus code.
                msgLine = insertStars(msgLine);
              }//end while
              //Close the output file.  The
              // message is now stored in a
              // local file with a file name
              // based on the unique ID
              // provided by the server.  Note
              // that a unique ID provided by
              // one server may duplicate a
              // unique server provided by a
              // different server.
              dataOut.close();

              //Now screen the file testing
              // for reasons to delete the
              // message from the server.
              //First initialize the text showing
              // in the various components in the
              // GUI.
              fromField.setText("Call screener");
              subjField.setText("Call screener");
              operMsgField.setText(
                                "Call screener");
              textArea.setText(
                             "Progress Meter: ");
              //Initialize the match flag
              // to false.
              boolean match = false;

              //Now cause the message file to be
              // screened.  In the event that you
              // decide to design your own
              // screening algorithm, this is
              // where you you would probably
              // make the first modification to
              // the program.  Your version of
              // the method named screenMsg
              // should return true if it is
              // recommending that the message be
              // deleted from the server.  Also,
              // the object of type ScreenResult
              // passed as a parameter to the
              // method should be populated with
              // information to be displayed in
              // the text fields and text area of
              // the GUI.
              ScreenResult theResult =
                              new ScreenResult();
              match = screener.screenMsg(
                        fileName,uidl,theResult);

              //Now display the information
              // encapsulated in the ScreenResult
              // object by the screenMsg method.
              fromField.setText(theResult.from);
              subjField.setText(
                              theResult.subject);
              operMsgField.setText(
                          "Offending Phrase: "
                          + theResult.thePhrase);
              textArea.setText(theResult.text);
              textArea.append("Msg Number: "
                                    + msgNumber);

              //At this point, the user can
              // view the From line and the
              // Subject line for the message,
              // the complete text of the message
              // down to the line containing the
              // offending word or phrase, as
              // well as that word or phrase.

              //Increment the message counter
              // in preparation for
              // processing the next message.
              msgCounter++;

              //A return value of true means that
              // the screener is recommending
              // deletion of the message from the
              // Email server.
              if(match == true){
                //The message has been flagged
                // as a candidate for deletion
                // from the server.  Return
                // from the ActionPerformed
                // method and take no further
                // action until the user
                // presses the Delete button
                // or the Start/Next button.
                //Pressing the Delete button
                // causes the message to be
                // deleted from the server.
                //Pressing the Start/Next
                // button causes it to be
                // preserved.
                return;
              }//end if match == true

              //Control reaches this point only
              // if match is not true.
              //The messaage is not a
              // candidate for deletion from
              // the server.
              //At this point, we could
              // require the user to press
              // the Start/Next button to
              // process the next message.
              //However, we won't do that. The
              // following code fires an event
              // identical to that which would
              // be fired if the user pressed
              // the Start/Next button.
              Toolkit.getDefaultToolkit().
                     getSystemEventQueue().
                       postEvent(new ActionEvent(
                              startButton,
                              ActionEvent.
                                ACTION_PERFORMED,
                              "Start/Next"));
            }//end if msgNumber <= numberMsgs
            else{//msgNumber > numberMsgs
              //No more messages. Disable the
              //Start/Next button.
              startButton.setEnabled(false);
              //Instruct the user to terminate
              // the program.
              subjField.setText(
                "No more messages, press Close");
              fromField.setText(
                "No more messages, press Close");
              operMsgField.setText(
                "No more messages, press Close");
              textArea.setText(
                "No more messages, press Close");
            }//end else
          }//end try
          catch(Exception ex){
                         ex.printStackTrace();}
        }//end actionPerformed
      }//end ActionListener
    );//end addActionListener

    //Register an ActionListener on the Delete
    // button to make it possible for the
    // user to remove a message from the
    // server.
    deleteButton.addActionListener(
      new ActionListener(){
        public void actionPerformed(
                                  ActionEvent e){
          //Clear the operator message field
          operMsgField.setText("");

          //Confirm that local msgNumber is in
          // synch with message number on server
          int firstSpace = fileName.indexOf(" ");
          int secondSpace = fileName.indexOf(
                             " ",firstSpace + 1);
          String chunk = fileName.substring(
                     firstSpace + 1,secondSpace);
          if(Integer.parseInt(chunk)
                                   != msgNumber){
            System.out.println(
                        "msgNumber synch error");
            System.exit(0);//terminate
          }//end if

          //Deletion of a message from the
          // server is accomplished by marking
          // the message for deletion while in
          // the TRANSACTION state.  The
          // message is actually deleted when
          // the client sends a QUIT command
          // to the server causing the server
          // to enter the UPDATE state.  If the
          // program aborts prematurely before
          // sending a QUIT command, marked
          // messages are not deleted from the
          // server.
          //Mark the message for deletion.
//Note that the following three statements have
// been purposely disabled to prevent you from
// accidentally deleting messages from the server
// during your early testing of the program. Do
// not enable these three statements until you
// are certain that you really do want to delete
// messages from the server.  At that point in
// time, you can enable the three statements by
// removing the comment indicators.
/*
          outputStream.println(
                            "DELE " + msgNumber);
          //Validate the response and display
          // it on the GUI.  You probably won't
          // see it on the GUI because of what
          // heppens next.  The program
          // immediately clears the display
          // and begins processing the
          // next message.  If you modify the
          // program to eliminate the clearing
          // of the display between messages,
          // you will see this response.
          textArea.append(
               "DELE "+validateOneLine()+"n");
          textArea.append(
                "Deleted:" + msgNumber + "n");
*/
          //Create and fire a synthetic event
          // that simulates the user pressing
          // the Start/Next button.  This
          // initialtes the processing of the
          // next message.
          Toolkit.getDefaultToolkit().
                     getSystemEventQueue().
                       postEvent(new ActionEvent(
                              startButton,
                              ActionEvent.
                                ACTION_PERFORMED,
                              "Start/Next"));
        }//end actionPerformed
      }//end ActionListener
    );//end addActionListener

    //Configure the GUI by placing the
    // various components on it, setting the size
    // and making it visible.
    add(startButton);
    add(deleteButton);
    add(fromField);
    add(subjField);
    add(operMsgField);
    add(textArea);
    setTitle("Copyright 2004, R.G.Baldwin");
    //Increase the following parameters and
    // modify the construction parameters for
    // the text fields and the text area to
    // increase the size of the GUI.
    setSize(400,400);
    //Make the GUI visible.
    setVisible(true);
  }//end constructor
  //===========================================//

  //Validate a one-line response.
  //The purpose of this method is to confirm that
  // the server returned +OK and not -ERR to the
  // previous command.
  //If +OK, the method returns the string
  // returned by the server.
  //If -ERR, the method displays the string
  // returned by the server and terminates the
  // session.
  private String validateOneLine(){
    try{
      String response = inputStream.readLine();
      if(response.startsWith("+OK")){
        return response;
      }else{
        System.out.println(response);
        //Terminate the session.
        outputStream.println("QUIT");
        socket.close();
        System.out.println(
                       "Premature QUIT on -ERR");
        System.exit(0);
      }//end else
    }catch(IOException e){e.printStackTrace();}
    //The following return statement is required
    // to satisfy the compiler.
    return "Make compiler happy";
  }//end validateOneLine()
  //===========================================//

  //Purpose of this method is to insert an
  // asterisk (star) every tenth character in
  // order to destroy virus code before it is
  // written into the output file.  While this
  // makes the local version of the message
  // harder to read, it does little to reduce its
  // usefulness for computer analysis.
  private String insertStars(String stringIn){
    StringBuffer stringBuffer =
                      new StringBuffer(stringIn);
    int length = stringBuffer.length();
    for(int cnt = 9; cnt < length; cnt+=10){
      stringBuffer.insert(cnt,'*');
    }//end for loop
    return new String(stringBuffer);
  }//end insertStars
  //===========================================//
}//end class Pop302
//=============================================//

//Class to encapsulate screening results. An
// object of this type is passed to the screenMsg
// method where it is populated with the results
// of the screen.
class ScreenResult{
  public String subject = "";
  public String from = "";
  public String thePhrase = "";
  public String text = "";
}//end ScreenResults
//=============================================//

//This class implements a set of rules for
// detecting SPAM messages and for recommending
// whether or not a message should be deleted
// from the server.
//If you have a better way to detect SPAM, you
// can replace this class by a completely
// different class definition, so long as you
// maintain the user interface.
//
//An object of this class has one entry point and
// one exit point, which is the public method
// named screenMsg. However, the constructor
// receives a reference to the GUI object created
// by instantiating the class named Pop302.  The
// object of this class uses that reference to
// display progress on the text area belonging
// to the GUI.  This is comforting on those
// occasions when a very long message is
// encountered.  This callback link could easily
// be eliminated by deleting code from two
// locations in this class and removing the
// callback constructor parameter.
class Screen{

  TreeSet subjWordList;
  TreeSet bodyWordList;
  TreeSet friendlyWordList;
  Pop302 theGui;//save callback reference here
  String phrase;

  Screen(Pop302 theGui){//constructor
    this.theGui = theGui;
    //Read the files containing word lists and
    // create TreeSet objects containing those
    // words or phrases in alphabetical order.
    makeSubjWordList();
    makeBodyWordList();
    makeFriendlyWordList();
  }//end constructor

  //This method is used to identify messages that
  // are candidates for being deleted from the
  // server.  Such identification is based on
  // analyzing the file in which the message is
  // stored locally. A return value of true means
  // that the message is believed to be SPAM, and
  // that the method recommends deleting the
  // message from the server.  In addition to
  // the return value, certains strings are
  // encapsulated in the incoming object of type
  // ScreenResult.  This information is posted
  // on the GUI by the object of the class named
  // Pop302.
  public boolean screenMsg(String fileName,
             String uidl,ScreenResult theResult){
    //Initialize match to false
    boolean match = false;
    try{
      //Open the file containing a local copy of
      // the message.  Note that the message has
      // been modified by inserting asterisks
      // in an attempt to protect against
      // viruses.
      BufferedReader inData
        = new BufferedReader(new FileReader(
                                      fileName));
      String data;//temp holding area

      //Get the Subject line by skipping header
      // lines prior to the Subject line.  Mark
      // the beginning of the file to make it
      // easy to rewind later.  Set the readAhead
      // Limit to 10000 characters before the
      // mark will be lost.
      inData.mark(10000);
      //Populate the ScreenResult object just in
      // case a Subject line isn't found and a
      // From line isn't found later.
      theResult.subject = "No Subj line found";
      theResult.from = "No From line found";
      while((data = inData.readLine()) != null){
        //Remove the asterisks from the data that
        // were inserted earlier in an attempt
        // to defeat viruses.
        data = removeStars(data).toUpperCase();
        if(data.startsWith("SUBJECT:")){
          //Put the Subject line in the
          // ScreenResult object.
          theResult.subject = data.toUpperCase();
          //Screen against an upper-case version
          // of the words and phrases in a
          // TreeSet object containing friendly
          // email addresses and subjects
          Iterator iterator =
                     friendlyWordList.iterator();
          while(iterator.hasNext()){
            String friendlyWord =
                     ((String)(iterator.next())).
                                   toUpperCase();
            match = false;
            if(!(friendlyWord.equals(""))){
              //The screenOnPhrase method is used
              // to search for a match between
              // the entries in the friendlyWord
              // list and the text in the Subject
              // line of the message.  In this
              // case, no extra characters are
              // allowed in the phrase as
              // it appears in the Subject line.
              match = screenOnPhrase(
                            data,friendlyWord,0);
            }//end if

            if(match == true){
              //The screenOnPhrase method found a
              // match with an phrase in
              // the friendlyWord list.
              //The message should not
              // be deleted from the server and
              // the local copy should be
              // deleted from the disk to
              // prevent later analysis to
              // extract target words or phrases
              // for SPAM. This algorithm has no
              // way of blocking SPAM with a
              // Subject that matches a phrase
              // in the friendlyWord list.
              //Close the file and delete it from
              // the local disk.
              inData.close();
              new File(fileName).delete();
              //Store the phrase in the
              // ScreenResult object.
              theResult.thePhrase = phrase;
              //Terminate the execution of this
              // method, telling the program not
              // to delete the message from the
              // server by returning false. This
              // is one of three return points
              // from this method.
              return false;
            }//end if match = true
          }//end while iterator has next
          //Don't attempt to read any more lines
          // from this file in this while loop.
          break;
        }//end if
      }//end while loop

      //Reset back to beginning of file.  The
      // Subject for this message is now showing
      // in the GUI if the message contained a
      // Subject line.  Otherwise the GUI
      // contains a message indicating that
      // a Subject line wasn't found.
      inData.reset();

      //Get the From line by skipping header
      // lines prior to the From line.
      //Also test the From line against a list of
      // friendly email addresses.
      //If a match is found, do not delete the
      // message from the server, but do delete
      // the local file containing the message
      // from the disk to prevent it from being
      // analyzed later in an attempt to find
      // target words or phrases for SPAM.
      while((data = inData.readLine()) != null){
        //Convert the data to all upper case and
        // remove all asterisks from the data.
        // Note that this will remove naturally
        // occurring asterisks in addition to
        // those that were inserted in an attempt
        // to protect against virus code.  If
        // this proves to be a problem later, the
        // removeStars method can be modified to
        // remove only those asterisks that were
        // inserted on ten-character intervals.
        data = removeStars(data.toUpperCase());
        if(data.startsWith("FROM:")){
          //Put the From line in the ScreenResult
          // object.
          theResult.from = data;

          //Screen against an upper-case version
          // of the words and phrases in a
          // TreeSet object containing friendly
          // email addresses and subjects
          Iterator iterator =
                     friendlyWordList.iterator();
          while(iterator.hasNext()){
            String friendlyWord =
                     ((String)(iterator.next())).
                                   toUpperCase();
            match = false;
            if(!(friendlyWord.equals(""))){
              //The screenOnPhrase method is used
              // to search for a match between
              // the entries in the friendlyWord
              // list and the text in the From
              // line of the message.  In this
              // case, no extra characters are
              // allowed in the Email address as
              // it appears in the From line.
              match = screenOnPhrase(
                            data,friendlyWord,0);
            }//end if

            if(match == true){
              //The screenOnPhrase method found a
              // match with an Email address in
              // the friendlyWord list.
              //Either this msg was sent by a
              // friend, or a spammer sent it
              // claiming to be from a friend.
              // In either case, it should not
              // be deleted from the server and
              // the local copy should be
              // deleted from the disk to
              // prevent later analysis to
              // extract target words or phrases
              // for SPAM. This algorithm has no
              // way of blocking SPAM that claims
              // to have been sent by a friendly
              // Email address.
              //Close the file and delete it from
              // the local disk.
              inData.close();
              new File(fileName).delete();
              //Store the Email address in the
              // ScreenResult object.
              theResult.thePhrase = phrase;
              //Terminate the execution of this
              // method, telling the program not
              // to delete the message from the
              // server by returning false. This
              // is one of two return points from
              // this method.
              return false;
            }//end if match = true
          }//end while iterator has next
          //Don't attempt to read any more lines
          // from this file in this while loop.
          break;
        }//end if data starts with From
      }//end while loop on null

      //Reset back to beginning of the file.  The
      // From line for this message is now
      // showing  in the GUI.  Read and process
      // the entire file.
      inData.reset();

      //Read and process strings until eof is
      // indicated by null. Provide separate
      // processing for the Subject line and all
      // other lines in the message described
      // herein as body text, although this also
      // includes header data in the message.
      //Note that more sophisticated forms of
      // screening can be inserted at this point
      // in the program.
      int progressCounter = 0;
      while((data = inData.readLine()) != null){
        data = removeStars(data);
        if(data.startsWith("Subject")){
          //Process the Subject line.
          //Process all data as upper case data
          // to keep the spammer from hiding
          // behind random case conversions.
          data = data.toUpperCase();

          //Append each line of data to the
          // String stored in the ScreenResult
          // object.
          theResult.text =
                    theResult.text + data + "n";
          //Display progress on the GUI. Remove
          // this code to break this link with
          // the GUI object if desired.
          if(++progressCounter < 50){
            theGui.textArea.append(".");
          }else{//Display progress on a new line
            progressCounter = 0;
            theGui.textArea.append(".n");
          }//end else

          //Screen against an upper-case version
          // of the words and phrases in a
          // TreeSet object containing target
          // words and phrases in the Subject
          // line of the message.
          match = false;
          Iterator iterator =
                         subjWordList.iterator();
          while(iterator.hasNext()){
            String subjWord =
                     ((String)(iterator.next())).
                                   toUpperCase();
            if(!(subjWord.equals(""))){
              //Search for a match between the
              // words or phrases in the subjWord
              // list and the line of msg data.
              // Allow one extra character to
              // occur between the characters in
              // the data and still make a match.
              match = screenOnPhrase(
                                data,subjWord,1);
            }//end if

            if(match == true){
              //Msg is a candidate for deletion.
              //Don't need this local file for
              // statistical analysis.  Move it
              // to a local archive folder.
              inData.close();
              boolean moved =
                     new File(fileName).renameTo(
                       new File(
                         "c:/MailFiles/Archives/"
                                  +uidl+".txt"));
              if(!moved)System.out.println(
                "Unable to move file " + uidl);
              //There is no need to test against
              // any more words in this iterator
              // loop.
              break;
            }//end if
          }//end while iterator has next
        }//end if data starts with Subject
        //Data line does not start with Subject.
        // Process the line as body text. Note
        // that some body text occurs before the
        // Subject line in the format of a
        // typical message.  Therefore, the code
        // in the else clause will typically be
        // executed several times before the
        // code in the if clause discussed above
        // will be executed.
        else{
          //Screen on an upper-case version of
          // the message.
          data = data.toUpperCase();
          //Append the data line to the String
          // value being stored in the
          // ScreenResult object.
          theResult.text =
                    theResult.text + data + "n";
          //Display progress in the GUI.  Remove
          // this code to break the callback link
          // with the GUI if desirec.
          if(++progressCounter < 50){
            theGui.textArea.append(".");
          }else{
            progressCounter = 0;
            theGui.textArea.append(".n");
          }//end else
          //Screen against an upper-case version
          // of the words and phrases in a
          // TreeSet object designed
          // specifically for screening body
          // text.
          Iterator iterator = bodyWordList.
                                      iterator();
          match = false;
          while(iterator.hasNext()){
            String bodyWord =
                     ((String)(iterator.next())).
                                   toUpperCase();
            if(!(bodyWord.equals(""))){
              //Allow one character to occur
              // between the characters in the
              // data line and still make a
              // match.
              match = screenOnPhrase(
                                data,bodyWord,1);
            }//end if

            if(match == true){
              //Msg is a candidate for deletion.
              //Don't need this local file for
              // statistical analysis.  Move it
              // to a local archive folder.
              inData.close();
              boolean moved =
                     new File(fileName).renameTo(
                       new File(
                         "c:/MailFiles/Archives/"
                                  +uidl+".txt"));
              if(!moved)System.out.println(
                "Unable to move file " + uidl);
              //There is no need to test against
              // any more words in this iterator
              // loop.
              break;
            }//end if
          }//end while iterator has next
        }//end else for line not Subject line
        //A match has been found.  No need to
        // read any more data lines in this while
        // loop.
        if(match == true)break;
      }//end while loop on read until null
      inData.close();//Close file if still open
    }catch(Exception e){e.printStackTrace();}
    //Store the matching phrase (or the last
    // phrase processed) in the ScreenResult
    // object.
    theResult.thePhrase = phrase;
    //Return the value of match indicating
    // whether or not a match was found.Note that
    // this return statement is one of two return
    // points in this method.  This return will
    // not be reached if a friendly Email address
    // was found earlier when processing the From
    // line.
    return match;
  }//end screenMsg
  //===========================================//

  //This method tests a string to see if it
  // contains a word or phrase that may have
  // extraneous characters inserted into it,
  // such as VI*A-GRA.
  //If the string contains the sequence of
  // characters making up the word or phrase,
  // with spanLim or fewer extraneous characters
  // between any two of the word's characters,
  // the method returns true.  For example, if
  // spanLim = 1, the spammer can insert one
  // character between any two of the characters
  // that make up the word and the word will
  // still be detected.  However, if the
  // spammer inserts two or more characters,
  // the offending word will not be detected.
  //Need to be careful to avoid making spanLim
  // too large.  Large values of spanLim result
  // in false alarms due to the fact that
  // widely-separated characters can be
  // considered to be part of the word or
  // phrase.  For example, if spanLim = 2 or
  // greater, the word PORN will be found in
  // the word imPORtaNt.
  private boolean screenOnPhrase(String data,
                                 String phrase,
                                 int spanLim){
    this.phrase = phrase;
    StringBuffer str = new StringBuffer();
    ArrayList locationData = new ArrayList();

    //Compare each char in the data with each
    // unique char in the word or phrase.  If
    // there is a match, append the char to str
    // and save the location of the char in
    // the ArrayList referred to by locationData.

    //Eliminate duplicate char in the word or
    // phrase by storing in a TreeSet.  Note that
    // this will also sort the char, but that
    // doesn't matter.
    TreeSet treeSet = new TreeSet();
    for(int cnt = 0; cnt < phrase.length();
                                          cnt++){
      treeSet.add(
              new Character(phrase.charAt(cnt)));
    }//end for loop

    //Get the unique characters from the set and
    // save them in a StringBuffer
    Iterator iter = treeSet.iterator();
    StringBuffer tempPhrase = new StringBuffer();
    while(iter.hasNext()){
      tempPhrase.append(
         ((Character)(iter.next())).charValue());
    }//end while

    //Use the StringBuffer of unique characters
    // to test the string and extract matching
    // characters from the string. Discard all
    // non-matching characters.  This converts
    // the original data into a string of
    // characters, each of which is a character
    // in the word or phrase.  All other
    // characters have been removed.  Thus, if
    // the data contains the word or phrase, it
    // will occur somewhere in the compressed
    // string with no extra characters in
    // between. An example might be as follows:
    //   SMSPMASPAMMPAS
    for(int i = 0; i < data.length(); i++){
      for(int j = 0; j < tempPhrase.length();
                                            j++){
        if(data.charAt(i) ==
                           tempPhrase.charAt(j)){
          str.append(data.charAt(i));
          locationData.add(new Integer(i));
        }//end if
      }//end for on tempPhrase
    }//end for on data

    //Test to see if the extracted char sequence
    // contains the word or phrase.
    int match = str.indexOf(phrase);
    if(match == -1){
      return false;//no match
    }//end if

    //There is a match. Confirm that the span
    // between target characters in data is not
    // greater than allowed by the incoming
    // spanLim parameter.
    int maxSpan = 0;
    int locA = ((Integer)locationData.
                          get(match)).intValue();
    int locB = 0;
    for(int cnt = 1; cnt < phrase.length();
                                          cnt++){
      locB = ((Integer)locationData.get(
                        match + cnt)).intValue();
      int span = locB - locA;
      if(span > maxSpan){
        maxSpan = span;
      }//end if
      locA = locB;
    }//end for loop

    if(maxSpan > spanLim+1){
      return false;//span too large
    }else{
      return true;//made a match
    }//end else

  }//end screenOnPhrase

  //===========================================//
  //Purpose of this method is to remove the
  // asterisks inserted into the data by the
  // method named insertStars, and to append two
  // asterisks at the end of the line. Note that
  // this method removes all asterisks, not just
  // those inserted earlier.  If this proves to
  // be a problem, this method should be modified
  // to remove only those asterisks that occur on
  // ten-character intervals.
  private String removeStars(String stringIn){
    StringBuffer stringBuf =
                      new StringBuffer(stringIn);
    int index = 0;
    while(index > -1){
      index = stringBuf.lastIndexOf("*");
      if(index > -1){
        stringBuf.delete(index,index+1);
      }//end if
    }//end while
    stringBuf.append("**");
    return new String(stringBuf);
  }//end removeStars()
  //===========================================//

  //Purpose:  To create a TreeSet object
  // containing words used to screen the message
  // subject lines.
  //This method reads strings from a text file
  // named Pop302a.txt and creates the list as
  // a TreeSet object with no duplicates.
  //See additional comments in the later section
  // regarding the makeBodyList method.

  private void makeSubjWordList(){
    subjWordList = new TreeSet();

    //Read word list from text file and populate
    // the TreeSet object.
    try{
      BufferedReader inData
        = new BufferedReader(new FileReader(
                                 "Pop302a.txt"));
      String data; //temp holding area

      while((data = inData.readLine()) != null){
        subjWordList.add(data);

      }//end while loop
      inData.close();//Close file
    }catch(Exception e){e.printStackTrace();}
  }//end makeSubjWordList
  //===========================================//

  //Purpose:  To create a TreeSet object
  // containing words and phrases used to screen
  // the message BODY lines.  See notes above
  // regarding the list used to screen the
  // Subject line of each message in the method
  // named makeSubjWordList.

  //It is important to maintain these two lists
  // as separate lists.  Because of the much
  // larger number of characters in the body than
  // in the Subject, false alarms are much more
  // likely in the body.  Therefore, individual
  // words that work well when screening the
  // Subject line may produce false alarms when
  // screening the body.  For example, the word
  // PORN appears in the word IMPORTANT.  It is
  // much more likely that the word IMPORTANT
  // will appear somewhere in the body than in
  // the Subject line (although it may appear in
  // the Subject line as well, thus producing a
  // false alarm in both cases). Also, the word
  // ANTIVIRUS works well in the Subject, but
  // cannot be used to screen the body because
  // many servers insert that word into the
  // message header after they test the message
  // for viruses. Also, IP addresses and URLs
  // work well in the body, but rarely appear in
  // the Subject. Therefore, testing the Subject
  // against a long list of URLs simply wastes
  // time.

  //The following words (among others) should not
  // be added to the list for the reasons given:

  //PORN may be confused with IMPORTANT
  //SPAM causes lots of false alarms. I inserted
  // a space as in "SPAM " to decrease false
  // alarms.  Will probably also decrease valid
  // hits.
  //ANTIVIRUS appears in some valid message hdrs
  //WEIGHT often appears in messages regarding
  // html fonts
  //SLUT may be confused with SOLUTION
  //==End of prohibited list==


  private void makeBodyWordList(){
    bodyWordList = new TreeSet();

    //Read word list from text file and populate
    // the TreeSet object.
    try{
      BufferedReader inData
        = new BufferedReader(new FileReader(
                                 "Pop302b.txt"));
      String data; //temp holding area

      while((data = inData.readLine()) != null){
        bodyWordList.add(data);

      }//end while loop
      inData.close();//Close file
    }catch(Exception e){e.printStackTrace();}
  }//end makeBodyWordList
  //===========================================//

  //Purpose:  To create a TreeSet object
  // containing words used to screen the message
  // From lines.
  //This method reads strings from a text file
  // named Pop302c.txt and creates the list as
  // a TreeSet object with no duplicates.
  //Only the primary portion of the friends
  // Email address should be included in the
  // file used to create the list.  This would
  // be x@y.z

  private void makeFriendlyWordList(){
    friendlyWordList = new TreeSet();

    //Read word list from text file and populate
    // the TreeSet object.
    try{
      BufferedReader inData
        = new BufferedReader(new FileReader(
                                 "Pop302c.txt"));
      String data; //temp holding area

      while((data = inData.readLine()) != null){
        friendlyWordList.add(data);

      }//end while loop
      inData.close();//Close file
    }catch(Exception e){e.printStackTrace();}
  }//end makeFriendlyWordList
  //===========================================//
}//end class Screen

Listing 34

AGE REVERSING PRODUCT
ANNUAL FEE
AT THE PUMP
AUTO BONANZA
AUTO WARRANTY
BECAREFUL DOWNLOADING MUSIC FILES
BOTOX
BOTTLES SOLD DAILY
C1ALIS
CIALIS
CODEINE
LEVITRA
NA1L-FUNGUS
NEVER REPAY YOUR CREDIT CARD DEBT
ORDER YOUR DRUGS
PATCH
PILLS
PILLZ
SEXUA1
SEXUAL
SILDENAFIL CITRATE
SIZE DOES MATTER
SLZE MATTERS
SOLVE  THE PROBLEM DOWNSTAIRS
TERMINATE DEBT
TONER CARTRIDGES
V1@GRA
V1AGRA
VALIUM
VA|IUM
VI@GRA
VIAGRA
VIC0DIN
VICODAN
VICODIN
VIIAGRA
VLAGRA
VÍAGRA
XANAAX
XANAX
Z0LOFT
/IAGR@

Listing 35

123.456.789.123
HTTP://SOMESITE.ABC
AGE REVERSING PRODUCT
ANNUAL FEE
AT THE PUMP
AUTO BONANZA
AUTO WARRANTY
BECAREFUL DOWNLOADING MUSIC FILES
BOTOX
BOTTLES SOLD DAILY
C1ALIS
CIALIS
CODEINE
LEVITRA
NA1L-FUNGUS
NEVER REPAY YOUR CREDIT CARD DEBT
ORDER YOUR DRUGS
PATCH
PILLS
PILLZ
SEXUA1
SEXUAL
SILDENAFIL CITRATE
SIZE DOES MATTER
SLZE MATTERS
SOLVE  THE PROBLEM DOWNSTAIRS
TERMINATE DEBT
TONER CARTRIDGES
V1@GRA
V1AGRA
VALIUM
VA|IUM
VI@GRA
VIAGRA
VIC0DIN
VICODAN
VICODIN
VIIAGRA
VLAGRA
VÍAGRA
XANAAX
XANAX
Z0LOFT
/IAGR@

Listing 36

BALDWIN@DICKBALDWIN.COM
MSNBC_BREAKINGNEWS_NEWSMAIL@MSNBC.COM
BOOKSTORE@INFORMIT.COM
ENews@SSA.GOV
Developer.com Update
MSNBC_DAILYMARKETCLOSE_NEWSMAIL@MSNBC.COM
ITSC 1313
ITSC1313

Listing 37