src/org/jent/checksmtp/Processer.java

   1 package org.jent.checksmtp;
   2
   3 import java.io.BufferedReader;
   4 import java.io.IOException;
   5 import java.io.InputStream;
   6 import java.io.InputStreamReader;
   7 import java.io.OutputStream;
   8
   9 /*
  10  * Socket accept proceed
  11  */
  12 import java.io.OutputStreamWriter;
  13 import java.io.PrintWriter;
  14
  15 import java.net.Socket;
  16
  17 import java.util.ArrayList;
  18 import java.util.ListIterator;
  19 import java.util.regex.Pattern;
  20
  21
  22 public class Processer implements Runnable, ResultNotify {
  23   private Socket client;
  24
  25   //Conform status.
  26   private final int RESULT_UNKNOWN = 0;
  27   private final int RESULT_OK = 1;
  28   private final int RESULT_NG = 2;
  29   private int result = RESULT_UNKNOWN;
  30
  31   //SMTP result code
  32   private final int R354StartInput = 354;
  33   private final int R221ServiceClosing = 221;
  34   private final int R451RequestedActionAbort = 451;
  35   private final int R502CommandNotImplemented = 502;
  36
  37   //SMTP command
  38   private final String COMMAND_RCPT_TO = "RCPT TO:"; // NOI18N
  39   private final String COMMAND_DATA = "DATA"; // NOI18N
  40   private final String COMMAND_RESET = "RSET"; // NOI18N
  41   private final String COMMAND_TURN = "TURN"; // NOI18N
  42
  43   //private final String COMMAND_NOOP = "NOOP";
  44   //private final String COMAMND_QUIT = "QUIT";
  45   public Processer(Socket client) {
  46       this.client = client;
  47   }
  48
  49   public void run() {
  50     InputStream serverInput;
  51     OutputStream serverOutput;
  52     InputStream clientInput;
  53     OutputStream clientOutput;
  54
  55     BufferedReader serverReader;
  56     PrintWriter serverWriter;
  57     BufferedReader clientReader;
  58     PrintWriter clientWriter;
  59
  60     Socket server = null;
  61
  62     try {
  63       //Connect to SMTP Server host
  64       String servername = ApplicationProperties.getSmtpServerHost();
  65
  66       //SMTP Server port
  67       int serverport = ApplicationProperties.getSmtpServerPort();
  68
  69       //Connection to true SMTP server.
  70       server = new Socket(servername, serverport);
  71       serverInput = server.getInputStream();
  72       serverOutput = server.getOutputStream();
  73       clientInput = client.getInputStream();
  74       clientOutput = client.getOutputStream();
  75
  76       serverReader = new BufferedReader(new InputStreamReader(
  77                   server.getInputStream()));
  78       serverWriter = new PrintWriter(new SmtpBufferedWriter(
  79                   new OutputStreamWriter(server.getOutputStream(),
  80                       "ISO-8859-1")), true); // NOI18N
  81       clientReader = new BufferedReader(new InputStreamReader(
  82                   client.getInputStream()));
  83       clientWriter = new PrintWriter(new SmtpBufferedWriter(
  84                   new OutputStreamWriter(client.getOutputStream(),
  85                       "ISO-8859-1")), true); // NOI18N
  86
  87       smtpStart(serverReader, clientWriter, clientReader, serverWriter);
  88
  89       //for SMTP Server connection test
  90       //SocketProxy forServer = new SocketProxy(clientInput, serverOutput, 0);
  91       //SocketProxy forClient = new SocketProxy(serverInput, clientOutput, 1);
  92       //Thread forServerThread = new Thread(forServer);
  93       //Thread forClientThread = new Thread(forClient);
  94       //forServerThread.start();
  95       ////Use this ThreadforClientThread.run();
  96       server.close();
  97       server = null;
  98       client.close();
  99       client = null;
 100     } catch (IOException e) {
 101       String errorMessage = java.util.ResourceBundle.getBundle("org/jent/checksmtp/Bundle").getString("Processer.error.Execption_occurred_at_starting_SMTP_thread.");
 102       System.err.println(errorMessage);
 103       new MessageDialogUI(errorMessage, e, MessageDialogUI.ERROR_MODE);
 104     } catch (RuntimeException runEx) {
 105       new MessageDialogUI(java.util.ResourceBundle.getBundle("org/jent/checksmtp/Bundle").getString("Processer.error.Runtime_Exception_occurred_in_SMTP_parse"),
 106               runEx, MessageDialogUI.ERROR_MODE);
 107     } finally {
 108       //for failsafe Socket close.
 109       if (server != null) {
 110         try {
 111           server.close();
 112         } catch (IOException ioEx ) {
 113           //IGNORE close Exception
 114         }
 115       }
 116       if (client != null) {
 117         try {
 118           client.close();
 119         } catch (IOException ioEx ) {
 120           //IGNORE close Exception
 121         }
 122       }
 123       //LDAP Connection close.
 124       LDAPSearch.close();
 125     }
 126   }
 127
 128   private int getCode(String s) {
 129       return Integer.parseInt(s.substring(0, 3));
 130   }
 131
 132   private boolean isContinue(String s) {
 133       if ('-' == s.charAt(3)) {
 134           return true;
 135       }
 136
 137       return false;
 138   }
 139
 140   private boolean isRcptTo(String s) {
 141       if (s.startsWith(COMMAND_RCPT_TO)) {
 142           return true;
 143       }
 144
 145       return false;
 146   }
 147
 148   private boolean isData(String s) {
 149       if (s.startsWith(COMMAND_DATA)) {
 150           return true;
 151       }
 152
 153       return false;
 154   }
 155
 156   private boolean isTurn(String s) {
 157       if (s.startsWith(COMMAND_TURN)) {
 158           return true;
 159       }
 160
 161       return false;
 162   }
 163
 164   public void sayOK() {
 165       result = RESULT_OK;
 166       notifyResult();
 167   }
 168
 169   public void sayNG() {
 170       result = RESULT_NG;
 171       notifyResult();
 172   }
 173
 174   private synchronized void notifyResult() {
 175       notify();
 176   }
 177
 178   private void smtpStart(BufferedReader serverReader,
 179     PrintWriter clientWriter, BufferedReader clientReader,
 180     PrintWriter serverWriter) {
 181     String line;
 182
 183     try {
 184       ArrayList toList = new ArrayList();
 185
 186       while (true) {
 187         //Server responce
 188         line = serverReader.readLine();
 189         clientWriter.println(line);
 190         System.out.println(line);
 191
 192         if (isContinue(line)) {
 193           continue; //Server responce continue
 194         }
 195
 196         //Client request
 197         if (R221ServiceClosing == getCode(line)) {
 198           break; //end of session.
 199         } else if (R354StartInput == getCode(line)) {
 200           System.out.println("Send mail data.");
 201
 202           while (true) {
 203             line = clientReader.readLine();
 204             serverWriter.println(line);
 205
 206             if (line.equals(".")) { // NOI18N
 207               break; //end of mail dara.
 208             }
 209           }
 210         } else {
 211           while (true) {
 212             line = clientReader.readLine();
 213
 214             if (line == null) {
 215               //Finish client stream.
 216               System.err.println("Client disconnected.");
 217               break; //force disconnect.
 218             }
 219
 220             if (isRcptTo(line)) {
 221               //stored To: address.
 222               toList.add(formatToAddress(line));
 223             } else if (isTurn(line)) {
 224               System.err.println("'TURN' is unsupported command.");
 225               clientWriter.println(R502CommandNotImplemented);
 226
 227               continue; //read next client request.
 228             } else if (isData(line)) {
 229               //Client want to send data. Check out toList.
 230               ListIterator iterater = toList.listIterator();
 231
 232               while (iterater.hasNext()) {
 233                 System.out.println("ADDRESS CHECK:" + iterater.next());
 234               }
 235
 236               //checkout toList
 237               new ToListUI(this, toList);
 238
 239               while (result == RESULT_UNKNOWN) {
 240                 try {
 241                     synchronized (this) {
 242                         wait();
 243                     }
 244                 } catch (InterruptedException e) {
 245                     System.err.println("Confirm dialog wait interrupted");
 246                     e.printStackTrace();
 247                 }
 248               }
 249
 250               if (result != RESULT_OK ) {
 251                 System.out.println("CANCEL sending mail.");
 252                 serverWriter.println(COMMAND_RESET);
 253                 line = serverReader.readLine(); //Server MUST retrun "250 OK"
 254                 System.out.println(COMMAND_RESET + ":ANSER is " + line);
 255                 clientWriter.println(R451RequestedActionAbort);
 256
 257                 continue; //I think Client QUIT or Retry.
 258               }
 259             }
 260
 261             break; // client read while(true);
 262           }
 263
 264           if (line == null ) {
 265             break;
 266           }
 267           serverWriter.println(line);
 268           System.out.println(line);
 269         }
 270       }
 271     } catch (IOException e) {
 272       String errorMessage = java.util.ResourceBundle.getBundle("org/jent/checksmtp/Bundle").getString("Processer.error.Error_occurred_in_SMTP_parse.");
 273       System.err.println(errorMessage);
 274       new MessageDialogUI(errorMessage, e, MessageDialogUI.ERROR_MODE);
 275     } catch (RuntimeException runEx) {
 276       new MessageDialogUI(java.util.ResourceBundle.getBundle("org/jent/checksmtp/Bundle").getString("Processer.error.Runtime_Exception_occurred_in_SMTP_parse"),
 277               runEx, MessageDialogUI.ERROR_MODE);
 278     }
 279
 280     System.out.println("End of Session.");
 281   }
 282
 283   private String formatToAddress(String line) {
 284     System.out.println("FIND To: " + line);
 285
 286     //Splitting Mail address.
 287     String str = line.substring(COMMAND_RCPT_TO.length() + 1);
 288     Pattern pattern = Pattern.compile("[< >]+"); // NOI18N
 289     String[] address = pattern.split(str); // 0<1>2 3
 290     int i;
 291
 292     for (i = 0; i < address.length; i++) {
 293       if (!address[i].equals("")) { // NOI18N
 294         break;
 295       }
 296     }
 297
 298     //Search LDAP
 299     str = address[i] + " " + LDAPSearch.search(address[i]); // NOI18N
 300     return str;
 301   }
 302 }