Enlisting Java in the War Against SPAM: The Communications Module

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

Figure 2

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;

Listing 1

  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

Listing 2

  Pop302(String server,String userName,
                                String password){
    screener = new Screen(this);

Listing 3

    int port = 110; //pop3 mail port
    try{
      socket = new Socket(server,port);

Listing 4

      inputStream = new BufferedReader(
                     new InputStreamReader(
                       socket.getInputStream()));

      outputStream = new PrintWriter(
               new OutputStreamWriter(
                 socket.getOutputStream()),true);

Listing 5

      String connectMsg = validateOneLine();
      System.out.println("Connected to server "
                                   + connectMsg);

Listing 6

  private String validateOneLine(){
    try{
      String response = inputStream.readLine();
      if(response.startsWith("+OK")){
        return response;
      }//end if

Listing 7

      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()

Listing 8

+OK POP3 server1.yohance.com v2001.78rh
 server ready

Figure 3

      //Send the command
      outputStream.println("USER " + userName);

      //Get and validate response
      String userResponse = validateOneLine();

      //Display the response
      System.out.println("USER " + userResponse);

Listing 9

USER +OK User name accepted, password please

Figure 4

      //Send the password to the server
      outputStream.println("PASS " + password);

      //Validate and display response
      System.out.println(
                    "PASS " + validateOneLine());
    }catch(Exception e){e.printStackTrace();}

Listing 10

PASS +OK Mailbox open, 7 messages

Figure 5

    this.addWindowListener(
      new WindowAdapter(){
        public void windowClosing(WindowEvent e){

          //Terminate the session
          outputStream.println("QUIT");

          //Validate and display response
          String quitResponse =
                               validateOneLine();
          System.out.println(
                         "QUIT " + quitResponse);
          textArea.append(quitResponse + "\n");

          //Close the socket
          try{
            socket.close();
          }catch(Exception ex){
            ex.printStackTrace();}

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

Listing 11

QUIT +OK Sayonara

Figure 6

    setLayout(new FlowLayout());

Listing 12

    final Button startButton =
                        new Button("Start/Next");
    final Button deleteButton =
                            new Button("Delete");
    fromField = new TextField(
                    "Display From line here",50);
    subjField = new TextField(
                         "Display Subj here",50);
    operMsgField = new TextField(
            "Display operator messages here",50);
    textArea = new TextArea(15,50);

    //Display initial message
    textArea.append("Display raw data here\n");

Listing 13

    startButton.addActionListener(
      new ActionListener(){
        public void actionPerformed(
                                  ActionEvent e){

          //Clear the operator message field
          operMsgField.setText("");

Listing 14

          try{
            if(numberMsgs == 0){
              outputStream.println("STAT");
              String stat = validateOneLine();

              //Get number of messages as String.
              String numberMsgsStr =
                       stat.substring(
                          4,stat.indexOf(" ",5));

              //Convert the String to an int.
              numberMsgs = Integer.parseInt(
                                  numberMsgsStr);
            }//end if numberMsgs == 0

Listing 15

            msgNumber = msgCounter + 1;

            if(msgNumber <= numberMsgs){
              outputStream.println(
                            "UIDL " + msgNumber);
              uidl = validateOneLine();

Listing 16

              String fileName =
                 "c:/MailFiles/" + uidl + ".txt";
              DataOutputStream dataOut =
                          new DataOutputStream(
                            new FileOutputStream(
                                      fileName));

Listing 17

              outputStream.println(
                            "RETR " + msgNumber);

              String retrResponse =
                               validateOneLine();

Listing 18

+OK 1818 octets

Figure 7

              textArea.setText("");

Listing 19

              //Read first line of message
              String msgLine =
                          inputStream.readLine();

              //Insert asterisks
              msgLine = insertStars(msgLine);

Listing 20

  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

Listing 21

              while(!(msgLine.equals("."))){
                dataOut.writeBytes(
                                 msgLine + "\n");
                msgLine = inputStream.readLine();
                msgLine = insertStars(msgLine);
              }//end while

              //Close the output file.
              dataOut.close();

Listing 22

              fromField.setText("Call screener");
              subjField.setText("Call screener");
              operMsgField.setText(
                                "Call screener");
              textArea.setText(
                             "Progress Meter: ");

Listing 23

class ScreenResult{
  public String subject = "";
  public String from = "";
  public String thePhrase = "";
  public String text = "";
}//end ScreenResults

Listing 24

              boolean match = false;

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

Listing 25

              fromField.setText(theResult.from);
              subjField.setText(
                              theResult.subject);
              operMsgField.setText(
                          "Offending Phrase: "
                          + theResult.thePhrase);
              textArea.setText(theResult.text);

              //Scroll the text area to the end
              textArea.select(
                      theResult.text.length()-2,
                      theResult.text.length()-1);

Listing 26

              msgCounter++;

Listing 27

              if(match == true){
                return;
              }//end if match == true

Listing 28

              Toolkit.getDefaultToolkit().
                     getSystemEventQueue().
                       postEvent(new ActionEvent(
                              startButton,
                              ActionEvent.
                                ACTION_PERFORMED,
                              "Start/Next"));
            }//end if msgNumber <= numberMsgs

Listing 29

            else{//msgNumber > numberMsgs
              startButton.setEnabled(false);

              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

Listing 30

    deleteButton.addActionListener(
      new ActionListener(){
        public void actionPerformed(
                                  ActionEvent e){

          operMsgField.setText("");

Listing 31

          outputStream.println(
                          "DELE " + msgNumber);
          textArea.append(
             "DELE "+validateOneLine()+"\n");
          textArea.append(
              "Deleted:" + msgNumber + "\n");

Listing 32

          Toolkit.getDefaultToolkit().
                     getSystemEventQueue().
                       postEvent(new ActionEvent(
                              startButton,
                              ActionEvent.
                                ACTION_PERFORMED,
                              "Start/Next"));
        }//end actionPerformed
      }//end ActionListener
    );//end addActionListener

Listing 33

    add(startButton);
    add(deleteButton);
    add(fromField);
    add(subjField);
    add(operMsgField);
    add(textArea);
    setTitle("Copyright 2004, R.G.Baldwin");
    setSize(400,400);//modify for larger GUI
    setVisible(true);
  }//end constructor

Listing 34

class Screen{
  boolean returnValue = true;

  Screen(Pop302 dummy){//dummy constructor
  }//end constructor

Listing 35

  public boolean screenMsg(String fileName,
             String uidl,ScreenResult theResult){
    try{
      BufferedReader inData
             = new BufferedReader(new FileReader(
                                      fileName));

Listing 36

      theResult.subject = "No Subj line found";
      theResult.from = "No From line found";
      theResult.thePhrase = "No phrase "
                 + "available for test program.";

Listing 37

      String data;
      inData.mark(10000);
      while((data = inData.readLine()) != null){
        if(data.startsWith("Subject:")){
          theResult.subject = data.toUpperCase();
          break;
        }//end if
      }//end while loop

Listing 38

      inData.reset();
      while((data = inData.readLine()) != null){
        if(data.toUpperCase().
                            startsWith("FROM:")){
          theResult.from = data;
          break;
        }//end if data starts with From
      }//end while loop on null

Listing 39

      inData.reset();
      while((data = inData.readLine()) != null){
        theResult.text =
                    theResult.text + data + "\n";
      }//end while loop on read until null
      inData.close();
    }catch(Exception e){e.printStackTrace();}

Listing 40

    if(returnValue == false){
      returnValue = true;
    }else{
      returnValue = false;
    }//end else
    return returnValue;
  }//end screenMsg

}//End stripped-down Screen class

Listing 41

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

Note:  This version has a stripped down class
named Screen.  This version allows testing of
the Email server communications without doing
any actual testing for SPAM.

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;

  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 here\n");

    //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.
              String 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);
              //Scroll the text area to the end
              textArea.select(
                      theResult.text.length()-2,
                      theResult.text.length()-1);

              //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("");

          //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.
//The following statement has been purposely
// disabled to prevent you from inadvertently
// deleting messages from your Email server. You
// should not enable this statement until you
// are confident that you really do want to
// delete messages from the server.
//          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 requied
    // 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 is a stripped-down version of the class
// named Screen, designed solely to make it
// possible for you to test the class named
// Pop302 on your system with your Email server.
//Each time the method named screenMsg is called,
// it's return value toggles between true and
// false.
class Screen{
  boolean returnValue = true;

  Screen(Pop302 dummy){//dummy constructor
  }//end constructor

  public boolean screenMsg(String fileName,
             String uidl,ScreenResult theResult){
    try{
      BufferedReader inData
             = new BufferedReader(new FileReader(
                                      fileName));

      theResult.subject = "No Subj line found";
      theResult.from = "No From line found";
      theResult.thePhrase = "No phrase "
                 + "available for test program.";

      String data;
      inData.mark(10000);
      while((data = inData.readLine()) != null){
        if(data.startsWith("Subject:")){
          theResult.subject = data.toUpperCase();
          break;
        }//end if
      }//end while loop

      inData.reset();
      while((data = inData.readLine()) != null){
        if(data.toUpperCase().
                            startsWith("FROM:")){
          theResult.from = data;
          break;
        }//end if data starts with From
      }//end while loop on null

      inData.reset();
      while((data = inData.readLine()) != null){
        theResult.text =
                    theResult.text + data + "\n";
      }//end while loop on read until null
      inData.close();
    }catch(Exception e){e.printStackTrace();}

    //Toggle return value between true and false
    if(returnValue == false){
      returnValue = true;
    }else{
      returnValue = false;
    }//end else
    return returnValue;
  }//end screenMsg
  //===========================================//
}//End stripped-down Screen class

Listing 42