Javen-Studio 咖啡小屋

//------------------------------------------------------------------
//                              \\\|///
//                            \\  -^-  //
//                             (  @ @  )
//    +----------------------oOOo-(_)-oOOo---------------------+
//
//           FREE SOFTWARE WRITEN BY NAVY, COPYLEFT (C) 2002
//                       SmtpClient Class 1.0
//               Use smtp server with user authorization
//                         All rights reserved.
//
//                                    Oooo
//    +---------------------- oooO---(   )---------------------+
//                            (   )   ) /
//                             \ (   (_/
//                              \_)
//------------------------------------------------------------------

package encrypt;

import java.io.*;
import java.net.*;
import java.util.Vector;
//import org.apache.commons.logging.Log;
//import org.apache.commons.logging.LogFactory;
import encrypt.Base64;

/***
 * 標準SMTP發信類
 * <p>
 * 標準的純JAVA的SMTP發信客戶端程序，支持用戶認證。
 * <p>
 * <p>
 * @author Naven
 * @see SmtpClient
 ***/

public class SmtpClient
{
    //protected static final Log log = LogFactory.getLog(SmtpClient.class);
   
    private static final String CMD_HELO            = "HELO ";
    private static final String CMD_AUTH_LOGIN      = "AUTH LOGIN ";
    private static final String CMD_MAIL_FROM       = "MAIL FROM: ";
    private static final String CMD_RCPT_TO         = "RCPT TO: ";
    private static final String CMD_DATA            = "DATA";
    private static final String CMD_HELP            = "HELP";
    private static final String CMD_RSET            = "RSET";
    private static final String CMD_NOOP            = "NOOP";
    private static final String CMD_QUIT            = "QUIT";
    private static final String END_OF_MAIL         = "\r\n.\r\n";

    private static final String RCV_SERVOK          = "220";        // 220 服務就緒
    private static final String RCV_HELO            = "250";        // 250 要求的郵件操作完成
    private static final String RCV_AUTH_LOGIN      = "334";
    private static final String RCV_AUTH_USER       = "334";
    private static final String RCV_AUTH_PASSWD     = "334";
    private static final String RCV_AUTH_OK         = "235";
    private static final String RCV_MAIL_FROM       = "250";
    private static final String RCV_RCPT_TO         = "250";
    private static final String RCV_DATA            = "354";
    private static final String RCV_SEND_END        = "250";
    private static final String RCV_RSET            = "250";
    private static final String RCV_NOOP            = "250";
    private static final String RCV_QUIT            = "221";        // 221 服務關閉傳輸信道

    private static final int SEND_BLOCK_SIZE        = 1024;         // 每次發送信件內容的塊的大小
   
    /**
     * BASE64加密對象
     */
    //private Base64 base64 = new Base64();
   

    private static final int _NOTHING_SPECIAL_STATE = 0;
    private static final int _LAST_WAS_CR_STATE = 1;
    private static final int _LAST_WAS_NL_STATE = 2;

    /**
     * 記錄處理郵件正文數據發送的狀態
     */
    private int _state = 0;
   
    /**
     * 用于處理郵件正文數據發送同步處理的鎖定
     */
    private Integer lock = new Integer(0);
   
    /**
     * client socket
     */
    private Socket      socketSmtp = null;
   
    /**
     * socket out printwriter
     */
    private PrintWriter     sout = null;
   
    /**
     * socket int reader
     */
    private BufferedReader  sin = null;
   
    /**
     * smtp email server address
     */
    private String      smtpServer = null;
   
    /**
     * email from user for smtp server
     */
    private String      user = null;
   
    /**
     * user password
     */
    private String      passwd = null;
   
    /**
     * sender's email address
     */
    private String      sender = null;
   
    /**
     * email from user for smtp server, base64 encode
     */
    private String      encryptUser = null;
   
    /**
     * user password, base64 encode
     */
    private String      encryptPasswd = null;
   
    /**
     * client localhost
     */
    private String      localHost = null;

    /**
     * error message
     */
    private String      errorString = "NO ERROR";   
   

    /***
     * 初始化發信類
     * <p>
     * @param server  SMTP服務器地址
     * @param sender  SMTP發信人郵件地址
     ***/
    public SmtpClient(String server, String sender)
    {
        this(server, null, null, sender);
    }
   
    /***
     * 初始化發信類
     * <p>
     * @param server  SMTP服務器地址
     * @param user  SMTP發信人認證用戶名
     * @param passwd  SMTP發信人認證密碼
     * @param sender  SMTP發信人郵件地址
     ***/
    public SmtpClient(String server, String user, String passwd, String sender)
    {
        this.smtpServer = server;
        this.user       = user;
        this.passwd     = passwd;
        this.sender     = sender;

        if( this.user != null && this.passwd != null )
        {
            Base64 base64 = new Base64();
           
            // base64 encode begain
            byte[] buser  = user.getBytes();
            byte[] bpasswd= passwd.getBytes();
   
            base64.startEncode();
            base64.encode(buser, buser.length);
            base64.endEncode();
            this.encryptUser = new String(base64.getEncodedResult());
   
            base64.startEncode();
            base64.encode(bpasswd, bpasswd.length);
            base64.endEncode();
            this.encryptPasswd = new String(base64.getEncodedResult());
        }
    }

    /***
     * 獲取處理的錯誤信息
     * <p>
     * @return  錯誤信息
     ***/
    public String getError() {
        return errorString;
    }

    /***
     * 當出錯時拋出錯誤信息
     * <p>
     * @param e  錯誤異常
     ***/
    private void onError(Exception e)
    {
        this.errorString = e.getMessage();
        //log.error("onError() " + this.errorString);
        //if( log.isDebugEnabled() ) {
        //    log.debug("onError()", e);
        //}
    }

    /***
     * 檢查SMTP協議通訊收到的信息是否成功，即以指定返回代號開頭，SMTP協議標準。
     * <p>
     * @param rcvmsg  SMTP協議通訊收到的信息
     * @param code  SMTP協議通訊返回代號
     * @exception IOException  失敗時拋出異常
     ***/
    private void check(String rcvmsg, String code)
        throws IOException
    {
        if( code == null || code.length() == 0 ) return;
        if( rcvmsg == null || rcvmsg.startsWith(code) == false )
            throw ( new IOException(rcvmsg) );
    }

    /***
     * 檢查SMTP協議通訊收到的信息是否成功，即以指定返回代號數組中任意個開頭，SMTP協議標準。
     * <p>
     * @param rcvmsg  SMTP協議通訊收到的信息
     * @param codes  SMTP協議通訊返回代號數組
     * @exception IOException  失敗時拋出異常
     ***/
    private void check(String rcvmsg, String[] codes)
        throws IOException
    {
        if( codes == null || codes.length == 0 ) return;
        boolean result = false;
        for( int i=0; rcvmsg != null && i < codes.length && codes[i] != null; i++ ) {
            if( rcvmsg.startsWith(codes[i]) == false ) {
                result = true;
                break;
            }
        }
        if(!result) throw ( new IOException(rcvmsg) );
    }

    /***
     * 往SMTP服務器寫郵件正文數據的一個字節，并處理數據中“\r\n.”需轉換成“\r\n..”的情況。
     * <p>
     * @param ch  寫入的一個字節
     * @exception IOException  失敗時拋出異常
     ***/
    private void write(int ch)
        throws IOException
    {
        synchronized (lock)
        {
            switch (ch)
            {
            case '\r':
                _state = _LAST_WAS_CR_STATE;
                sout.write('\r');
                return ;
            case '\n':
                if (_state != _LAST_WAS_CR_STATE)
                    sout.write('\r');
                sout.write('\n');
                _state = _LAST_WAS_NL_STATE;
                return ;
            case '.':
                // Double the dot at the beginning of a line
                if (_state == _LAST_WAS_NL_STATE)
                    sout.write('.');
                // Fall through
            default:
                _state = _NOTHING_SPECIAL_STATE;
                sout.write(ch);
                return ;
            }
        }
    }

    /***
     * 往SMTP服務器寫郵件正文數據的一段數據，并處理數據中“\r\n.”需轉換成“\r\n..”的情況。
     * <p>
     * @param buffer  寫入的數據緩沖
     * @param offset  寫入的數據緩沖的偏移
     * @param length  寫入的數據緩沖的長度
     * @exception IOException  失敗時拋出異常
     ***/
    private void write(char[] buffer, int offset, int length)
        throws IOException
    {
        synchronized (lock)
        {
            while (length-- > 0)
                write(buffer[offset++]);
        }
    }

    /***
     * 往SMTP服務器寫郵件正文數據的一段數據，并處理數據中“\r\n.”需轉換成“\r\n..”的情況。
     * <p>
     * @param buffer  寫入的數據緩沖
     * @exception IOException  失敗時拋出異常
     ***/
    private void write(char[] buffer)
        throws IOException
    {
        write(buffer, 0, buffer.length);
    }

    /***
     * 往SMTP服務器寫郵件正文數據的一段數據，并處理數據中“\r\n.”需轉換成“\r\n..”的情況。
     * <p>
     * @param string  寫入的數據字符串
     * @exception IOException  失敗時拋出異常
     ***/
    private void write(String string)
        throws IOException
    {
        write(string.toCharArray());
    }

    /***
     * 將SOCKET STREAM緩沖區的數據刷新，提交出去。
     * <p>
     * @exception IOException  失敗時拋出異常
     ***/
    private void flush()
        throws IOException
    {
        synchronized (lock)
        {
            sout.flush();
        }
    }

    /***
     * 往SMTP服務器寫一行數據。
     * <p>
     * @param msg  寫入的一行數據字符串
     * @exception IOException  失敗時拋出異常
     ***/
    private void sendln(String msg)
        throws IOException
    {
        if( msg == null ) msg = "";
       
        sout.println(msg);
        sout.flush();
       
        //if( log.isDebugEnabled() ) {
        //    log.debug("sendln() ==>: "+msg);
        //}
    }

    /***
     * 往SMTP服務器寫字符串數據。
     * <p>
     * @param msg  寫入的字符串
     * @exception IOException  失敗時拋出異常
     ***/
    private void send(String msg)
        throws IOException
    {
        if( msg == null ) msg = "";
       
        sout.write(msg);
        sout.flush();
       
        //if( log.isDebugEnabled() ) {
        //    log.debug("send() ==>: "+msg);
        //}
    }

    /***
     * 往SMTP服務器寫一段大字符串數據。
     * <p>
     * @param text  寫入的字符串數據
     * @exception IOException  失敗時拋出異常
     ***/
    private void sendtext(String text)
        throws IOException
    {
        if( text == null ) text = "";
       
        if( text.length() > SEND_BLOCK_SIZE ) {
            int i = 0;
            while( i <= text.length() ) {
                if( (i + SEND_BLOCK_SIZE) < text.length() )
                    write(text.substring(i, (i+SEND_BLOCK_SIZE)));
                else
                    write(text.substring(i));
                flush();
                i = i + SEND_BLOCK_SIZE;
            }
           
            //if( log.isDebugEnabled() ) {
            //    log.debug("sendtext() ==>: <Email Mesg> "+text.length()+" chars");
            //}
        }
        else {
            write(text);
            flush();
           
            //if( log.isDebugEnabled() ) {
            //    log.debug("sendtext() ==>: "+text);
            //}
        }
    }

    /***
     * 從SMTP服務器接收一行字符串數據。
     * <p>
     * @return  讀取的字符串數據
     * @exception IOException  失敗時拋出異常
     ***/
    private String receive()
        throws IOException
    {
        String rcvmsg = sin.readLine();
        //if( log.isDebugEnabled() ) {
        //    log.debug("receive() <==: " + rcvmsg);
        //}
        return rcvmsg;
    }

    /***
     * 從SMTP服務器接收一行字符串數據，并判斷是否是成功的返回值。
     * <p>
     * @param code  正確的SMTP協議代碼
     * @return  讀取的字符串數據
     * @exception IOException  失敗時拋出異常
     ***/
    private String receive(String code)
        throws IOException
    {
        String rcvmsg = receive();
        check(rcvmsg, code);
        return rcvmsg;
    }
   
    /***
     * 從SMTP服務器接收一行字符串數據，并判斷是否是成功的返回值數組的一個。
     * <p>
     * @param codes  正確的SMTP協議代碼數組
     * @return  讀取的字符串數據
     * @exception IOException  失敗時拋出異常
     ***/
    private String receive(String[] codes)
        throws IOException
    {
        String rcvmsg = receive();
        check(rcvmsg, codes);
        return rcvmsg;
    }
   
    /***
     * 連接SMTP服務器并發送用戶名和密碼認證。
     * <p>
     * @return  返回成功失敗結果
     * @exception IOException  失敗時拋出異常
     ***/
    public boolean connect()
    {
        // connect to smtp server and autherize
        try{
            // get localhost name
            localHost = InetAddress.getLocalHost().getHostName();
            //if( log.isDebugEnabled() ) {
            //    log.debug("connect() localhost: " + localHost);
            //}

            // connect to smtp server
            socketSmtp = new Socket(smtpServer, 25);
            sout       = new PrintWriter(new OutputStreamWriter(socketSmtp.getOutputStream()));
            sin        = new BufferedReader(new InputStreamReader(socketSmtp.getInputStream()));
            receive(RCV_SERVOK);

            // hello
            sendln(CMD_HELO + localHost);
            receive(RCV_HELO);
           
            if( encryptUser != null && encryptPasswd != null )
            {
                // auth login
                sendln(CMD_AUTH_LOGIN);
                receive(RCV_AUTH_LOGIN);
   
                // base64 encode end
                sendln(encryptUser);
                receive(RCV_AUTH_USER);
                sendln(encryptPasswd);
                receive(RCV_AUTH_OK);
            }
        }
        catch(IOException e) {
            onError(e);
            closeall();
            return false;
        }
       
        return true;
    }

    /***
     * 連接SMTP服務器并發送郵件。
     * <p>
     * @param to  收件人郵件地址
     * @param msg  郵件數據
     * @return  返回成功失敗結果
     * @exception IOException  失敗時拋出異常
     ***/
    public boolean sendMail(String to, String msg) {   
        return sendMail(to, msg, null);
    }
   
    /***
     * 連接SMTP服務器并發送郵件。
     * <p>
     * @param to  收件人郵件地址
     * @param msg  郵件數據
     * @param cc  CC收件人郵件地址
     * @return  返回成功失敗結果
     * @exception IOException  失敗時拋出異常
     ***/
    public boolean sendMail(String to, String msg, Vector cc)
    {
        if( socketSmtp == null || sout == null || sin == null ) {
            closeall();
            if( !connect() ) return false;
        }

        boolean retval = false;
        int count = 0;
        // try send for 3 times if error
        while( retval == false && count < 3 ) {
          try {
            // mail from
            sendln(CMD_MAIL_FROM + sender);
            receive(RCV_MAIL_FROM);
           
            // send to
            sendln(CMD_RCPT_TO + to);
            receive(RCV_RCPT_TO);
           
            // perform cc
            int ccSize = 0;
            if(cc != null && (ccSize = cc.size()) > 0){
                for(int i = 0; i < ccSize; i ++){                   
                    sendln(CMD_RCPT_TO + (String)cc.elementAt(i));
                    receive(RCV_RCPT_TO);
                }
            }
            // end cc
           
            // begain send mail data
            sendln(CMD_DATA);
            receive(RCV_DATA);
            sendtext(msg);
            sendln(END_OF_MAIL);
            receive(RCV_SEND_END);
           
            // send success
            //receive(); // I dont know why 263.net.cn need receve again
            retval = true;
          }
          catch(IOException e) {
            onError(e);
            retval = false;
            count ++;
            try{
                // reset and send again
                sendln(CMD_RSET);
                receive(RCV_RSET);
            }
            catch(Exception e2) {
                //log.error("sendMail()", e2);
                break;
            }
          }
        }

        return retval;
    }

    /***
     * 關閉與SMTP服務器連接。
     * <p>
     ***/
    private void closeall()
    {
        try {
            if( sout != null ) {
                sout.close(); sout = null;
            }
            if( sin != null ) {
                sin.close(); sin = null;
            }
            if( socketSmtp != null ) {
                socketSmtp.close(); socketSmtp = null;
            }
        }
        catch(IOException e) {
            //log.error("closeall()", e);
        }
    }

    /***
     * 關閉與SMTP服務器連接并釋放資源。
     * <p>
     ***/
    public void release()
    {
        close();
       
        this.socketSmtp     = null;    // client socket
        this.sout           = null;    // socket out printstream
        this.sin            = null;    // socket int reader
        this.smtpServer     = null;    // smtp email server address
        this.user           = null;    // email from user for smtp server
        this.passwd         = null;    // user password
        this.sender         = null;    // sender's email address
        this.encryptUser    = null;    // base64 encode
        this.encryptPasswd  = null;    // base64 encode
        this.localHost      = null;    // client localhost

        this.errorString    = "NO ERROR";
    }

    /***
     * 發送QUIT命令并關閉與SMTP服務器連接。
     * <p>
     ***/
    public boolean close()
    {
        boolean retval = true;
       
        if( sout != null && sin != null ) {
            try {
                // send finish quit
                sendln(CMD_QUIT);
                //receive();
                retval = true;
            }
            catch(IOException e) {
                retval = false;
                //log.error("close()", e);
            }
        }
        closeall();
       
        return retval;
    }

    public String toString() {
        return getClass().getName() +
                " Server: " + smtpServer + " User: " + user +
                " Passwd: " + passwd + " Sender: " + sender;
    }
       
}///:~