Java/Swing Components/Email Client

A Client to Send SMTP Mail

import java.awt.*;
import javax.swing.*;
/**
 * Example program from Chapter 1 Programming Spiders, Bots and Aggregators in
 * Java Copyright 2001 by Jeff Heaton
 * 
 * SendMail is an example of client sockets. This program presents a simple
 * dialog box that prompts the user for information about how to send a mail.
 * 
 * @author Jeff Heaton
 * @version 1.0
 */
/*
 * Using the SMTP Program
 * 
 * To use the program in Listing 1.2, you must know the address of an SMTP
 * server usually provided by your ISP. If you are unsure of your SMTP server,
 * you should contact your ISP"s customer service. In order for outbound e-mail
 * messages to be sent, your e-mail program must have this address. Once it
 * does, you can enter who is sending the e-mail (if you are sending it, you
 * would type your e-mail address in) and who will be on the receiving end. This
 * is usually entered under the Reply To field of your e-mail program. Both of
 * these addresses must be valid. If they are invalid, the e-mail may not be
 * sent. After you have entered these addresses, you should continue by entering
 * the subject, writing the actual message, and then clicking send. Note
 * 
 * For more information on how to compile examples in this book, see Appendix E
 * "How to Compile Examples Under Windows."
 * 
 * As stated earlier, to send an e-mail with this program, you must enter who is
 * sending the message. You may be thinking that you could enter any e-mail
 * address you want here, right? Yes, this is true; as long as the SMTP server
 * allows it, this program will allow you to impersonate anyone you enter into
 * the To address field. However, as previously stated, a savvy Internet user
 * can tell whether the e-mail address is fake.
 * 
 * After the mention of possible misrepresentation of identity on the sender"s
 * end, you may now be asking yourself, Is this program dangerous? This
 * program is no more dangerous than any e-mail client (such as Microsoft
 * Outlook Express or Eudora) that also requires you to tell it who you are. In
 * general, all e-mail programs must request both your identity and that of the
 * SMTP server. Examining the SMTP Server
 * 
 * You will now be shown how this program works. We will begin by looking at how
 * a client socket is created. When the client socket is first instantiated, you
 * must specify two parameters. First, you must specify the host to connect to;
 * second, you must specify the port number (e.g., 80) you would like to connect
 * on. These two items are generally passed into the constructor. The following
 * line of code (from Listing 1.2) accomplishes this:
 * 
 * java.net.Socket s =new java.net.Socket( _smtp.getText(),25 );
 * 
 * This line of code creates a new socket, named s. The first parameter to the
 * constructor, _smtp .getText(), specifies the address to connect to. Here it
 * is being read directly from a text field. The second parameter specifies the
 * port to connect to. (The port for SMTP is 25.) Table 1.1 shows a listing of
 * the ports associated with most Internet services. The hostname is retrieved
 * from the _smtp class level variable, which is the JTextField control that the
 * SMTP hostname is entered into.
 * 
 * If any errors occur while you are making the connection to the specified
 * host, the Socket constructor will throw an IOException. Once this connection
 * is made, input and output streams are obtained from the Socket.getInputStream
 * and Socket.getOutputStream methods. This is done with the following lines of
 * code from Listing 1.2:
 * 
 * _out = new java.io.PrintWriter(s.getOutputStream());
 * _in = new java.io.BufferedReader(new java.io.InputStreamReader(s.getInputStream()));
 * 
 * These low-level stream types are only capable of reading binary data. Because
 * this data is needed in text format, filters are used to wrap the lower-level
 * input and output streams obtained from the socket.
 * 
 * In the code above, the output stream has been wrapped in a PrintWriter
 * object. This is because PrintWriter allows the program to output text to the
 * socket in a similar manner to the way an application would write data to the
 * System.out object by using the print and println methods. The application
 * presented here uses the println method to send commands to the SMTP server.
 * As you can see in the code, the InputStream object has also been wrapped; in
 * this case, it has been wrapped in a BufferedReader. Before this could happen,
 * however, this object must first have been wrapped in an InputStreamReader
 * object as shown here:
 * 
 * _in = new java.io.BufferedReader(new
 * java.io.InputStreamReader(s.getInputStream()));
 * 
 * This is done because the BufferedReader object provides reads that are made
 * up of lines of text instead of individual bytes. This way, the program can
 * read text up to a carriage return without having to parse the individual
 * characters. This is done with the readLine method.
 * 
 * You will now be shown how each command is sent to the SMTP server. Each of
 * these commands that is sent results in a response being issued from the SMTP
 * server. For the protocol to work correctly, each response must be read by the
 * SMTP client program. These responses start with a number and then they give a
 * textual description of what the result was. A full-featured SMTP client
 * should examine these codes and ensure that no error has occurred.
 * 
 * For the purposes of the SendMail example, we will simple ignore these
 * responses because most are informational and not needed. Instead, for our
 * purposes, the response will be read in and displayed to the _output list box.
 * Commands that have been sent to the server are displayed in this list with a
 * C: prefix to indicate that they are from the client. Responses returned from
 * the SMTP server will be displayed with the S: prefix.
 * 
 * To accomplish this, the example program will use the send method. The send
 * method accepts a single String parameter to indicate the SMTP command to be
 * issued. Once this command is sent, the send method awaits a response from the
 * SMTP host. The portion of Listing 1.2 that contains the send method is
 * displayed here:
 * 
 * protected void send(String s) throws java.io.IOException { 
        // Send the SMTP command 
         if(s!=null) { 
         _model.addElement("C:"+s); 
         _out.println(s);
        _out.flush(); } 
       // Wait for the response 
         String line = _in.readLine();
        if(line!=null) { 
       _model.addElement("S:"+line); 
       } 
 }
 * 
 * As you can see, the send method does not handle the exceptions that might
 * occur from its commands. Instead, they are thrown to the calling method as
 * indicated by the throws clause of the function declaration. The variable s is
 * checked to see if it is null. If s is null, then no command is to be sent and
 * only a response is sought. If s is not null, then the value of s is logged
 * and then sent to the socket. After this happens, the flush command is given
 * to the socket to ensure that the command was actually sent and not just
 * buffered. Once the command is sent, the readLine method is called to await
 * the response from the server. If a response is sent, then it is logged.
 * 
 * Once the socket is created and the input and output objects are created, the
 * SMTP session can begin. The following commands manage the entire SMTP
 * session:
 * 
 * send(null); 
 * send("HELO " + java.net.InetAddress.getLocalHost().getHostName() );
 * send("MAIL FROM: " + _from.getText() ); send("RCPT TO: " + _to.getText() );
 * send("DATA"); 
 * _out.println("Subject:" + _subject.getText()); _out.println(
 * _body.getText() ); send("."); s.close();
 * 
 * Tip
 * 
 * Refer to Table 1.4 in the preceding section to review the details of what
 * each of the SMTP commands actually means.
 * 
 * The rest of the SendMail program (as seen in Listing 1.2) is a typical Swing
 * application. The graphical user interface (GUI) layout for this application
 * was created using VisualCaf?. The VisualCaf? comments have been left in to
 * allow the form"s GUI layout to be edited by VisualCaf? if you are using it.
 * If you are using an environment other than VisualCaf?, you may safely delete
 * the VisualCaf? comments (lines starting in //). The VisualCaf? code only
 * consists of comments and does not need to be deleted to run on other
 * platforms.
 *  
 */
public class SendMail extends javax.swing.JFrame {
  /**
   * The constructor. Do all basic setup for this application.
   */
  public SendMail() {
    //{{INIT_CONTROLS
    setTitle("SendMail Example");
    getContentPane().setLayout(null);
    setSize(736, 312);
    setVisible(false);
    JLabel1.setText("From:");
    getContentPane().add(JLabel1);
    JLabel1.setBounds(12, 12, 36, 12);
    JLabel2.setText("To:");
    getContentPane().add(JLabel2);
    JLabel2.setBounds(12, 48, 36, 12);
    JLabel3.setText("Subject:");
    getContentPane().add(JLabel3);
    JLabel3.setBounds(12, 84, 48, 12);
    JLabel4.setText("SMTP Server:");
    getContentPane().add(JLabel4);
    JLabel4.setBounds(12, 120, 84, 12);
    getContentPane().add(_from);
    _from.setBounds(96, 12, 300, 24);
    getContentPane().add(_to);
    _to.setBounds(96, 48, 300, 24);
    getContentPane().add(_subject);
    _subject.setBounds(96, 84, 300, 24);
    getContentPane().add(_smtp);
    _smtp.setBounds(96, 120, 300, 24);
    getContentPane().add(_scrollPane2);
    _scrollPane2.setBounds(12, 156, 384, 108);
    _body.setText("Enter your message here.");
    _scrollPane2.getViewport().add(_body);
    _body.setBounds(0, 0, 381, 105);
    Send.setText("Send");
    Send.setActionCommand("Send");
    getContentPane().add(Send);
    Send.setBounds(60, 276, 132, 24);
    Cancel.setText("Cancel");
    Cancel.setActionCommand("Cancel");
    getContentPane().add(Cancel);
    Cancel.setBounds(216, 276, 120, 24);
    getContentPane().add(_scrollPane);
    _scrollPane.setBounds(408, 12, 312, 288);
    getContentPane().add(_output);
    _output.setBounds(408, 12, 309, 285);
    //}}
    //{{INIT_MENUS
    //}}
    //{{REGISTER_LISTENERS
    SymAction lSymAction = new SymAction();
    Send.addActionListener(lSymAction);
    Cancel.addActionListener(lSymAction);
    //}}
    _output.setModel(_model);
    _model.addElement("Server output displayed here:");
    _scrollPane.getViewport().setView(_output);
    _scrollPane2.getViewport().setView(_body);
  }
  /**
   * Moves the app to the correct position when it is made visible.
   * 
   * @param b
   *            True to make visible, false to make invisible.
   */
  public void setVisible(boolean b) {
    if (b)
      setLocation(50, 50);
    super.setVisible(b);
  }
  /**
   * The main function basically just creates a new object, then shows it.
   * 
   * @param args
   *            Command line arguments. Not used in this application.
   */
  static public void main(String args[]) {
    (new SendMail()).show();
  }
  /**
   * Created by VisualCafe. Sets the window size.
   */
  public void addNotify() {
    // Record the size of the window prior to
    // calling parents addNotify.
    Dimension size = getSize();
    super.addNotify();
    if (frameSizeAdjusted)
      return;
    frameSizeAdjusted = true;
    // Adjust size of frame according to the
    // insets and menu bar
    Insets insets = getInsets();
    javax.swing.JMenuBar menuBar = getRootPane().getJMenuBar();
    int menuBarHeight = 0;
    if (menuBar != null)
      menuBarHeight = menuBar.getPreferredSize().height;
    setSize(insets.left + insets.right + size.width, insets.top
        + insets.bottom + size.height + menuBarHeight);
  }
  // Used by addNotify
  boolean frameSizeAdjusted = false;
  //{{DECLARE_CONTROLS
  /**
   * A label.
   */
  javax.swing.JLabel JLabel1 = new javax.swing.JLabel();
  /**
   * A label.
   */
  javax.swing.JLabel JLabel2 = new javax.swing.JLabel();
  /**
   * A label.
   */
  javax.swing.JLabel JLabel3 = new javax.swing.JLabel();
  /**
   * A label.
   */
  javax.swing.JLabel JLabel4 = new javax.swing.JLabel();
  /**
   * Who this message is from.
   */
  javax.swing.JTextField _from = new javax.swing.JTextField();
  /**
   * Who this message is to.
   */
  javax.swing.JTextField _to = new javax.swing.JTextField();
  /**
   * The subject of this message.
   */
  javax.swing.JTextField _subject = new javax.swing.JTextField();
  /**
   * The SMTP server to use to send this message.
   */
  javax.swing.JTextField _smtp = new javax.swing.JTextField();
  /**
   * A scroll pane.
   */
  javax.swing.JScrollPane _scrollPane2 = new javax.swing.JScrollPane();
  /**
   * The body of this email message.
   */
  javax.swing.JTextArea _body = new javax.swing.JTextArea();
  /**
   * The send button.
   */
  javax.swing.JButton Send = new javax.swing.JButton();
  /**
   * The cancel button.
   */
  javax.swing.JButton Cancel = new javax.swing.JButton();
  /**
   * A scroll pain.
   */
  javax.swing.JScrollPane _scrollPane = new javax.swing.JScrollPane();
  /**
   * The output area. Server messages are displayed here.
   */
  javax.swing.JList _output = new javax.swing.JList();
  //}}
  /**
   * The list of items added to the output list box.
   */
  javax.swing.DefaultListModel _model = new javax.swing.DefaultListModel();
  /**
   * Input from the socket.
   */
  java.io.BufferedReader _in;
  /**
   * Output to the socket.
   */
  java.io.PrintWriter _out;
  //{{DECLARE_MENUS
  //}}
  /**
   * Internal class created by VisualCafe to route the events to the correct
   * functions.
   * 
   * @author VisualCafe
   * @version 1.0
   */
  class SymAction implements java.awt.event.ActionListener {
    /**
     * Route the event to the correction method.
     * 
     * @param event
     *            The event.
     */
    public void actionPerformed(java.awt.event.ActionEvent event) {
      Object object = event.getSource();
      if (object == Send)
        Send_actionPerformed(event);
      else if (object == Cancel)
        Cancel_actionPerformed(event);
    }
  }
  /**
   * Called to actually send a string of text to the socket. This method makes
   * note of the text sent and the response in the JList output box. Pass a
   * null value to simply wait for a response.
   * 
   * @param s
   *            A string to be sent to the socket. null to just wait for a
   *            response.
   * @exception java.io.IOException
   */
  protected void send(String s) throws java.io.IOException {
    // Send the SMTP command
    if (s != null) {
      _model.addElement("C:" + s);
      _out.println(s);
      _out.flush();
    }
    // Wait for the response
    String line = _in.readLine();
    if (line != null) {
      _model.addElement("S:" + line);
    }
  }
  /**
   * Called when the send button is clicked. Actually sends the mail message.
   * 
   * @param event
   *            The event.
   */
  void Send_actionPerformed(java.awt.event.ActionEvent event) {
    try {
      java.net.Socket s = new java.net.Socket(_smtp.getText(), 25);
      _out = new java.io.PrintWriter(s.getOutputStream());
      _in = new java.io.BufferedReader(new java.io.InputStreamReader(s
          .getInputStream()));
      send(null);
      send("HELO " + java.net.InetAddress.getLocalHost().getHostName());
      send("MAIL FROM: " + _from.getText());
      send("RCPT TO: " + _to.getText());
      send("DATA");
      _out.println("Subject:" + _subject.getText());
      _out.println(_body.getText());
      send(".");
      s.close();
    } catch (Exception e) {
      _model.addElement("Error: " + e);
    }
  }
  /**
   * Called when cancel is clicked. End the application.
   * 
   * @param event
   *            The event.
   */
  void Cancel_actionPerformed(java.awt.event.ActionEvent event) {
    System.exit(0);
  }
}