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