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 {
  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:";
  39   private final String COMMAND_DATA = "DATA";
  40   private final String COMMAND_RESET = "RSET";
  41   private final String COMMAND_TURN = "TURN";
  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);
  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);
  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       System.err.println("Execption occurred in Processer.");
 102       e.printStackTrace();
 103     } finally {
 104       //for failsafe Socket close.
 105       if (server != null) {
 106         try {
 107           server.close();
 108         } catch (IOException ioEx ) {
 109           //IGNORE close Exception
 110         }
 111       }
 112       if (client != null) {
 113         try {
 114           client.close();
 115         } catch (IOException ioEx ) {
 116           //IGNORE close Exception
 117         }
 118       }
 119     }
 120   }
 121
 122   private int getCode(String s) {
 123       return Integer.parseInt(s.substring(0, 3));
 124   }
 125
 126   private boolean isContinue(String s) {
 127       if ('-' == s.charAt(3)) {
 128           return true;
 129       }
 130
 131       return false;
 132   }
 133
 134   private boolean isRcptTo(String s) {
 135       if (s.startsWith(COMMAND_RCPT_TO)) {
 136           return true;
 137       }
 138
 139       return false;
 140   }
 141
 142   private boolean isData(String s) {
 143       if (s.startsWith(COMMAND_DATA)) {
 144           return true;
 145       }
 146
 147       return false;
 148   }
 149
 150   private boolean isTurn(String s) {
 151       if (s.startsWith(COMMAND_TURN)) {
 152           return true;
 153       }
 154
 155       return false;
 156   }
 157
 158   public void sayOK() {
 159       result = RESULT_OK;
 160       notifyResult();
 161   }
 162
 163   public void sayNG() {
 164       result = RESULT_NG;
 165       notifyResult();
 166   }
 167
 168   private synchronized void notifyResult() {
 169       notify();
 170   }
 171
 172   private void smtpStart(BufferedReader serverReader,
 173     PrintWriter clientWriter, BufferedReader clientReader,
 174     PrintWriter serverWriter) {
 175     String line;
 176
 177     try {
 178       ArrayList toList = new ArrayList();
 179
 180       while (true) {
 181         //Server responce
 182         line = serverReader.readLine();
 183         clientWriter.println(line);
 184         System.out.println(line);
 185
 186         if (isContinue(line)) {
 187           continue; //Server responce continue
 188         }
 189
 190         //Client request
 191         if (R221ServiceClosing == getCode(line)) {
 192           break; //end of session.
 193         } else if (R354StartInput == getCode(line)) {
 194           System.out.println("Send mail data.");
 195
 196           while (true) {
 197             line = clientReader.readLine();
 198             serverWriter.println(line);
 199
 200             if (line.equals(".")) {
 201               break; //end of mail dara.
 202             }
 203           }
 204         } else {
 205           while (true) {
 206             line = clientReader.readLine();
 207
 208             if (isRcptTo(line)) {
 209               //stored To: address.
 210               toList.add(formatToAddress(line));
 211             } else if (isTurn(line)) {
 212               System.err.println("'TURN' is unsupported command.");
 213               clientWriter.println(R502CommandNotImplemented);
 214
 215               continue; //read next client request.
 216             } else if (isData(line)) {
 217               //Client want to send data. Check out toList.
 218               ListIterator iterater = toList.listIterator();
 219
 220               while (iterater.hasNext()) {
 221                 System.out.println("ADDRESS CHECK:" + iterater.next());
 222               }
 223
 224               //checkout toList
 225               new ToListDialog(this, toList);
 226
 227               while (result == RESULT_UNKNOWN) {
 228                 try {
 229                     synchronized (this) {
 230                         wait();
 231                     }
 232                 } catch (InterruptedException e) {
 233                     System.err.println("Dialg wait interrupted");
 234                     e.printStackTrace();
 235                 }
 236               }
 237
 238               if (result == RESULT_NG) {
 239                 System.out.println("CANCEL sending mail.");
 240                 serverWriter.println(COMMAND_RESET);
 241                 line = serverReader.readLine(); //Server MUST retrun "250 OK"
 242                 System.out.println(COMMAND_RESET + ":ANSER is " + line);
 243                 clientWriter.println(R451RequestedActionAbort);
 244
 245                 continue; //I think Client QUIT or Retry.
 246               }
 247             }
 248
 249             break; // client read while(true);
 250           }
 251
 252           serverWriter.println(line);
 253           System.out.println(line);
 254         }
 255       }
 256     } catch (IOException e) {
 257       e.printStackTrace();
 258     }
 259
 260     System.out.println("End of Session.");
 261   }
 262
 263   private String formatToAddress(String line) {
 264     System.out.println("FIND To: " + line);
 265
 266     //Splitting Mail address.
 267     String str = line.substring(COMMAND_RCPT_TO.length() + 1);
 268     Pattern pattern = Pattern.compile("[< >]+");
 269     String[] address = pattern.split(str); // 0<1>2 3
 270     int i;
 271
 272     for (i = 0; i < address.length; i++) {
 273       if (!address[i].equals("")) {
 274         break;
 275       }
 276     }
 277
 278     //Search LDAP
 279     str = address[i] + " " + LDAPSearch.search(address[i]);
 280     return str;
 281   }
 282 }