一步一步從原理跟我學郵件收取及發送 11.完整的發送示例與go語言

    經過了這個系列的前幾篇文章的學習，現在要寫出一個完整的 smtp 郵件發送過程簡直易如反掌。
    例如我們可以輕松地寫出以下的純 C 語言代碼（引用的其他C語言文件請看文末的 github 地址）：

#include <stdio.h>
#include <windows.h>
#include <time.h>
#include <winsock.h>

#include "lstring.c"
#include "socketplus.c"
#include "lstring_functions.c"
#include "base64_functions.c"

//vc 下要有可能要加 lib 
//#pragma comment (lib,"*.lib")
//#pragma comment (lib,"libwsock32.a")
//#pragma comment (lib,"libwsock32.a")

//SOCKET gSo = 0;
SOCKET gSo = -1;


//收取一行,可再優化 
lstring * RecvLine(SOCKET so, struct MemPool * pool, lstring ** _buf)
{
    int i = 0;
    int index = -1;
    int canread = 0;
    lstring * r = NULL;
    lstring * s = NULL;
    lstring * buf = *_buf;

    for (i=0;i<10;i++) //安全起見,不用 while ,用 for 一定次數就可以了 
    {
        //index = pos("\n", buf);
        index = pos(NewString("\r\n", pool), buf);

        if (index>-1) break;
        
        canread = SelectRead_Timeout(so, 3);//是否可讀取,時間//超時返回,單位為秒 
        if (0 == canread) break;
        
        s = RecvBuf(so, pool);
        buf->Append(buf, s);
    }
    
    if (index <0 ) return NewString("", pool);
    
    r = substring(buf, 0, index);
    buf = substring(buf, index + 2, Length(buf));
    *_buf = buf;
    return r;
}//

//解碼一行命令,這里比較簡單就是按空格進行分隔就行了
//這是用可怕的指針運算的版本 
void DecodeCmd(lstring * line, char sp, char ** cmds, int cmds_count)
{
    int i = 0;
    int index = 0;
    int count = 0;
    
    cmds[index] = line->str;
    
    for (i=0; i<line->len; i++)
    {
        if (sp == line->str[i]) 
        {
            index++;
            line->str[i] = '\0'; //直接修改為字符串結束符號,如果是只讀的字符串這樣做其實是不對的,不過效率很高 
            
            cmds[index] = line->str + i; //指針向后移動 
            
            if (i >= line->len - 1) break;//如果是最后一定字符了就要退出,如果不是指針還要再移動一位
            cmds[index] = line->str + i + 1;
            
            count++;
            if (count >= cmds_count) break; //不要大於緩沖區 
        }
        
    }//


}//

//讀取多行結果 
lstring * RecvMCmd(SOCKET so, struct MemPool * pool, lstring ** _buf)
{
    int i = 0;
    int index = 0;
    int count = 0;
    lstring * rs;
    char c4 = '\0'; //判斷第4個字符 
    
    lstring * mline = NewString("", pool);

    
    for (i=0; i<50; i++)
    {
        rs = RecvLine(so, pool, _buf); //只收取一行 
        
        mline->Append(mline, rs);
        LString_AppendConst(mline, "\r\n");
        
        //printf("\r\nRecvMCmd:%s\r\n", rs->str); 
            
        if (rs->len<4) break; //長度要足夠 
        c4 = rs->str[4-1]; //第4個字符
        //if ('\x20' == c4) break; //"\xhh" 任意字符 二位十六進制//其實現在的轉義符已經擴展得相當復雜，不建議用這個表示空格 
        if (' ' == c4) break; //第4個字符是空格就表示讀取完了//也可以判斷 "250[空格]" 
    
        
    }//

    return mline;
}//


void main()
{
    int r;
    mempool mem, * m;
    lstring * s;
    lstring * rs;
    lstring * buf;
    lstring * domain;
    lstring * from;
    lstring * to;
    
    char * cmds[5] = {NULL}; 
    int cmds_count = 5;
    
    //--------------------------------------------------

    mem = makemem(); m = &mem; //內存池,重要 
    
    buf = NewString("", m);

    //--------------------------------------------------
    //直接裝載各個 dll 函數
    LoadFunctions_Socket();

    InitWinSocket(); //初始化 socket, windows 下一定要有 


    gSo = CreateTcpClient();
    r = ConnectHost(gSo, "newbt.net", 25);
    //r = ConnectHost(gSo, "smtp.163.com", 25); //可以換成 163 的郵箱 

    if (r == 1) printf("連接成功!\r\n");

    
    //--------------------------------------------------
    rs = RecvLine(gSo, m, &buf); //只收取一行 

    printf("\r\nRecvLine:");
    printf(rs->str); printf("\r\n");
    
    DecodeCmd(rs, ' ', cmds, cmds_count); 
    printf("\r\ndomain:%s\r\n", cmds[1]); 
    
    domain = NewString(cmds[1], m);
    
    s = NewString("EHLO", m);
    LString_AppendConst(s," ");
    s->Append(s, domain); //去掉這一行試試,163 郵箱就會返回錯誤了 
    LString_AppendConst(s,"\r\n");

    SendBuf(gSo, s->str, s->len);    

    
    ////rs = RecvLine(gSo, m, &buf); //只收取一行 
    rs = RecvMCmd(gSo, m, &buf); //只收取一行 

    printf("\r\nRecvLine:");
    printf(rs->str); printf("\r\n");
    
    //--------------------------------------------------
    //用 base64 登錄 
    s = NewString("AUTH LOGIN\r\n", m);
    SendBuf(gSo, s->str, s->len);    
    
    rs = RecvLine(gSo, m, &buf); //只收取一行 
    printf("\r\nRecvLine:%s\r\n", rs->str); 
    
    s = NewString("[e-mail]", m); //要換成你的用戶名,注意 163 郵箱的話不要帶后面的 @域名 部分 
    s = base64_encode(s);
    LString_AppendConst(s,"\r\n");
    SendBuf(gSo, s->str, s->len);    
    
    rs = RecvLine(gSo, m, &buf); //只收取一行 
    printf("\r\nRecvLine:%s\r\n", rs->str); 
    

    s = NewString("123456", m); //要換成您的密碼 
    s = base64_encode(s);
    LString_AppendConst(s,"\r\n");
    SendBuf(gSo, s->str, s->len);    
    
    rs = RecvLine(gSo, m, &buf); //只收取一行 
    printf("\r\nRecvLine:%s\r\n", rs->str); 
    
    //--------------------------------------------------
    //郵件內容 
    from = NewString("[e-mail]", m);
    to = NewString("[e-mail]", m);
    
    s = NewString("MAIL FROM: <", m); s->Append(s, from); s->AppendConst(s, ">\r\n"); //注意"<" 符號和前面的空格。空格在協議中有和沒有都可能，最好還是有 
    SendBuf(gSo, s->str, s->len);
    rs = RecvLine(gSo, m, &buf); //只收取一行 
    printf("\r\nRecvLine:%s\r\n", rs->str);         
    
    s = NewString("RCPT TO: <", m); s->Append(s, to); s->AppendConst(s, ">\r\n");
    SendBuf(gSo, s->str, s->len);    
    rs = RecvLine(gSo, m, &buf); //只收取一行 
    printf("\r\nRecvLine:%s\r\n", rs->str);     
    
    s = NewString("DATA\r\n", m);
    SendBuf(gSo, s->str, s->len);
    rs = RecvLine(gSo, m, &buf); //只收取一行 
    printf("\r\nRecvLine:%s\r\n", rs->str);         
    
    s = NewString("From: \"[e-mail]\" <[e-mail]>\r\nTo: \"[e-mail]\" <[e-mail]>\r\nSubject: test\r\nDate: Sun, 21 Jan 2018 11:48:15 GMT\r\n\r\nHello World.\r\n", m);//郵件內容，正式的應該用一個函數生成 
    SendBuf(gSo, s->str, s->len);    
    
    
    s = NewString("\r\n.\r\n", m); //郵件結束符 
    SendBuf(gSo, s->str, s->len);    
    
    rs = RecvLine(gSo, m, &buf); //只收取一行 
    printf("\r\nRecvLine:%s\r\n", rs->str); 
    

    //--------------------------------------------------
    
    Pool_Free(&mem); //釋放內存池 
    
    printf("gMallocCount:%d \r\n", gMallocCount); //看看有沒有內存泄漏//簡單的檢測而已  
    
    //-------------------------------------------------- 

    getch(); //getch().不過在VC中好象要用getch()，必須在頭文件中加上<conio.h> 

}

運行結果如圖：

 

    好了，我們用其他語言也來一個吧。但是這里有個問題：java 有很完善的電子郵件實現，實在是沒必要再寫一個。我換用一下 go 語言吧，之所以用 golang ，那是因為 golang 現在真的是開發服務器程序的極佳選擇，而因為它又非常的新，所以有些功能並不完善，特別是支持庫方面離 java 還有比較遠的距離。剛好在電子郵件方面就是，而我剛好最近 golang 又用得比較多。

    用過 golang 發送郵件的同學一定都知道 go 語言中默認的 smtp 模塊是無法在正常的 smtp 25 端口上去發送郵件的（有興趣的網友可以自行用 163 的郵箱試試）。原因是 golang 本身起源就是為 google 公司的需求服務的，所以很多功能都先優先做了 google 需要的部分，而對電子郵件有一點了解的網友們應該都知道 google 的 gmail 是不支持常規的 smtp 25 端口的，它需要安全連接的 ssl 接口。所以大家如果搜索 golang 的 smtp 發送示例的話，基本上都是要進行一點改造的。其實這樣的改造代碼都不完善，最后都會注明有問題。這個問題其實源於 golang 的 smtp 源碼（我看的是 1.7 版本）中對 "AUTH" 命令的實現與常規不太一樣，它的實現后面跟了兩個參數，而經過我們前幾篇的文章，大家都知道實現的只有一個參數，那就是 "AUTH LOGIN"。知道了這一點，要改造 golang 的源碼還是比較容易的。不過 golang 和 java 一樣有點過度設計的意思，所以要看懂它的代碼也不是太容易（不過 golang 中的各種協議代碼設計得很精巧，遠遠不是 java 可比的）。所以我們既然已經知道了怎樣自己寫一個，那還不如自己明明白白的寫一個出來。以下就是一個我寫的示例，對協議有一定了解的同學很容易進行改寫，為了方便大家理解我就沒有設計成類了，大家可以自己動手：

package main //clq

//用於不加密環境的 smtp 發送電子郵件過程,因為不是所有的 smtp 環境都有加密支持的,不加密的適用范圍更廣一點,而且 smtp 服務器之間沒有密碼加密的過程
//(因為對方 smtp 服務器不可能知道你的密碼)所以原有的 golang 1.7.3 net/smtp 過程就不適合 smtp 之間發送郵件

import (
    "fmt"
    "bufio"
//    "crypto/tls"
    "encoding/base64"
//    "errors"
//    "io"
    "net"
//    "net/smtp" //clq add
//    "net/textproto"
    "strings"
    "strconv"
)

var gConn net.Conn;
var gRead * bufio.Reader;
var gWrite * bufio.Writer;

//可以放到這樣的類里
type TcpClient struct {
    Conn net.Conn;
    Read * bufio.Reader;
    Write * bufio.Writer;
}//


func Connect(host string, port int) (net.Conn, * bufio.Reader, * bufio.Writer) {
    
    addr := host + ":" + strconv.Itoa(port);
    conn, err := net.Dial("tcp", addr);
    if err != nil {
        return nil, nil, nil
    }
    
    reader := bufio.NewReader(conn);
    writer := bufio.NewWriter(conn);
    
    //writer.WriteString("EHLO\r\n");
    //writer.Flush();
    
    //host, _, _ := net.SplitHostPort(addr)
    //return NewClient(conn, host)    
    return conn, reader, writer;
}//

//收取一行,可再優化 
//func RecvLine(conn *net.Conn) (string) {
//func RecvLine(conn net.Conn, reader * bufio.Reader) (string) {
func _RecvLine() (string) {
    
    //defer conn.Close();
    ////reader := bufio.NewReader(conn);
    //reader := bufio.NewReaderSize(conn,409600)
    
    //line, err := reader.ReadString('\n'); //如何設定超時?
    line, err := gRead.ReadString('\n'); //如何設定超時?
    
    if err != nil { return ""; }
    
    line = strings.Split(line, "\r")[0]; //還要再去掉 "\r"，其實不去掉也可以
    
    return line;
}//

func SendLine(line string){
    gWrite.WriteString(line + "\r\n");
    gWrite.Flush();
}//

//解碼一行命令,這里比較簡單就是按空格進行分隔就行了
func DecodeCmd(line string, sp string) ([]string){

    //String[] tmp = line.split(sp); //用空格分開//“.”和“|”都是轉義字符，必須得加"\\";//不一定是空格也有可能是其他的
    //String[] cmds = {"", "", "", "", ""}; //先定義多幾個，以面后面使用時產生異常
    
    tmp := strings.Split(line, sp);
    //var cmds = [5]string{"", "", "", "", ""}; //先定義多幾個，以面后面使用時產生異常
    var cmds = []string{"", "", "", "", ""}; //先定義多幾個，以面后面使用時產生異常
    //i:=0;
    for i:=0;i<len(tmp);i++ {
        if i >= len(cmds) { break;}
        cmds[i] = tmp[i];
    }
    return []string(cmds);
}//

//讀取多行結果
func RecvMCmd() (string) {
    i := 0;
    //index := 0;
    //count := 0;
    rs := "";
    //var c rune='\r';
    //var c4 rune = '\0'; //判斷第4個字符//golang 似乎不支持這種表示
    
    mline := "";

    for i=0; i<50; i++ {
        rs = _RecvLine(); //只收取一行
        
        mline = mline + rs + "\r\n";
        
        //printf("\r\nRecvMCmd:%s\r\n", rs->str);
            
        if len(rs)<4 {break;} //長度要足夠
        c4 := rs[4-1]; //第4個字符
        //if ('\x20' == c4) break; //"\xhh" 任意字符 二位十六進制//其實現在的轉義符已經擴展得相當復雜，不建議用這個表示空格
        if ' ' == c4 { break;} //第4個字符是空格就表示讀取完了//也可以判斷 "250[空格]"
    
        
    }//

    return mline;
    
}//

//簡單的測試一下 smtp
func test_smtp() {
    
    //連接
    //gConn, gRead, gWrite = Connect("newbt.net", 25);
    //gConn, gRead, gWrite = Connect("newbt.net", 25);
    gConn, gRead, gWrite = Connect("smtp.163.com", 25);
    
    //收取一行
    line := _RecvLine();
    fmt.Println("recv:" + line);
    
    //解碼一下,這樣后面的 EHLO 才能有正確的第二個參數
    cmds := DecodeCmd(line, " ");
    domain := cmds[1]; //要從對方的應答中取出域名//空格分開的各個命令參數中的第二個
    
    //發送一個命令
    //SendLine("EHLO"); //163 這樣是不行的,一定要有 domain
    SendLine("EHLO" + " " + domain); //domain 要求其實來自 HELO 命令//HELO <SP> <domain> <CRLF>    
    
    //收取多行
    //line = _RecvLine();
    line = RecvMCmd();
    fmt.Println("recv:" + line);
    
    //--------------------------------------------------
    //用 base64 登錄 
    SendLine("AUTH LOGIN");    
    
    //收取一行
    line = _RecvLine();
    fmt.Println("recv:" + line);
    
    //s :="[e-mail]"; //要換成你的用戶名,注意 163 郵箱的話不要帶后面的 @域名 部分 
    s :="clq_test"; //要換成你的用戶名,注意 163 郵箱的話不要帶后面的 @域名 部分 
    s = base64.StdEncoding.EncodeToString([]byte(s));
    //s = base64_encode(s);
    SendLine(s);    
    
    //收取一行
    line = _RecvLine();
    fmt.Println("recv:" + line);
    

    s = "123456"; //要換成您的密碼 
    //s = base64_encode(s);
    s = base64.StdEncoding.EncodeToString([]byte(s));
    SendLine(s);    
    
    //收取一行
    line = _RecvLine();
    fmt.Println("recv:" + line);
    
    //--------------------------------------------------    
    //郵件內容 
    //from := "[e-mail]";
    from := "[e-mail]";
    to := "[e-mail]";
    
    SendLine("MAIL FROM: <" + from +">"); //注意"<" 符號和前面的空格。空格在協議中有和沒有都可能，最好還是有 
    //收取一行
    line = _RecvLine();
    fmt.Println("recv:" + line);        
    
    SendLine("RCPT TO: <" + to+ ">");
    //收取一行
    line = _RecvLine();
    fmt.Println("recv:" + line);        
    
    SendLine("DATA");
    //收取一行
    line = _RecvLine();
    fmt.Println("recv:" + line)        
    
    // = "From: \"[e-mail]\" <[e-mail]>\r\nTo: \"[e-mail]\" <[e-mail]>\r\nSubject: test golang\r\nDate: Sun, 21 Jan 2018 11:48:15 GMT\r\n\r\nHello World.\r\n";//郵件內容，正式的應該用一個函數生成 
    s = MakeMail(from,to,"test golang","Hello World.");
    SendLine(s);    
    
    
    s = "\r\n.\r\n"; //郵件結束符 
    SendLine(s);
    
    //收取一行
    line = _RecvLine();
    fmt.Println("recv:" + line)        
    
}//

//這只是個簡單的內容，真實的郵件內容復雜得多
func MakeMail(from,to,subject,text string)(string) {
    //s := "From: \"[e-mail]\" <[e-mail]>\r\nTo: \"[e-mail]\" <[e-mail]>\r\nSubject: test golang\r\nDate: Sun, 21 Jan 2018 11:48:15 GMT\r\n\r\nHello World.\r\n";//郵件內容，正式的應該用一個函數生成 
    s := "From: \"" + from + "\"\r\nTo: \"" + to + "\" " + to + "\r\nSubject: " + subject + 
        "\r\nDate: Sun, 21 Jan 2018 11:48:15 GMT\r\n\r\n" + //內容前是兩個回車換行
        text + "\r\n";
    
    return s;    

}//

 

這份代碼可以直接使用在 163 的郵箱上，以下是 newbt 郵箱收到的 163 發送的郵件的真實截圖：

    不過用到真實環境中，大家要再測試一下超時的情況，可以考慮自己加點超時，然后生成郵件的時間那里注意一下就差不多了。我后面還會給出一個直接修改自 go 源碼的示例。

    既然說到了 gmail 是要 ssl 支持的，那么怎樣開發一個支持 ssl 的發送過程呢。其實一點也不難，ssl 不過是 socket 過程的加密版本而已，有興趣的同學大家可以看我的如下幾篇文章：
OpenSSL解惑1：原理 https://baijiahao.baidu.com/s?id=1591824116725476286&wfr=spider&for=pc

OpenSSL解惑2：如何強制選擇協議的版本 https://baijiahao.baidu.com/s?id=1591912273348927453&wfr=spider&for=pc

OpenSSL解惑3：SSL_read的阻塞超時與它是否等同於recv函 https://baijiahao.baidu.com/s?id=1592012048270657934&wfr=spider&for=pc

（我個人覺得第一二篇比較重要，百家號目前的問題比較多，鏈接代碼什么的都不太好處理，大家將就看吧）

    總的來說，增加了 ssl 連接過程后再將 recv 函數變成 SSL_read，send 函數變成 SS_send 就可以了。對 gmail 的支持很多年前我就在 eEmail 中實現過了，不過現在 ssl 升級得比較多，估計也不能用了吧，以后等 gmail 能在國內訪問了再修改了。關於協議升級的問題大家也可以看上面的提到的幾篇 openssl 文章。如果使用 openssl 開發的話，要支持新的協議是非常簡單的，用 golang 的話那就更不用說了。ssl 的示例，因為實在來不及了，所以以后再給出吧。

    另外，雖然我們沒有給出 java 的示例，不過有了前面的幾篇文章為基礎相信大家可以輕松地寫出來。

    再另外，我看過網友們對 golang smtp 的改造，說句不客氣的，大部分都不太正確，具體原因前面已經說了過。我的做法是直接修改 golang 的源碼，幸好 goalng 和以前的 delphi 一樣可以方便地在不改動源碼的情況下使用修改出來的另一份拷貝。我的方法是復制出來然后改掉 package 就可以了，以下是我修改過的 go1.7.3 的 smtp 源碼，可以直接使用的，修改的地方其實很少，已經在 newbt 郵箱和 163 郵箱上使用過。調用的方法如下（其中 loginAuth  來自網絡，不過實際上是有誤的）：

type loginAuth struct {
    username, password string
}

func LoginAuth(username, password string) smtp.Auth {
    return &loginAuth{username, password}
}

func (a *loginAuth) Start(server *smtp.ServerInfo) (string, []byte, error) {
    //return "LOGIN", []byte{}, nil
    //return "LOGIN", []byte(a.username), nil //clq 原作者說這個就 ok, 其實那只是對 163 郵箱, 大多數郵件服務器還要改 smtp.go 文件本身
    //return "LOGIN\r\n", []byte(a.username), nil
    return "LOGIN", []byte{}, nil
}

//clq 這個步驟會一直被調用直到成功或者錯誤
func (a *loginAuth) Next(fromServer []byte, more bool) ([]byte, error) {
    
    fmt.Println("smtp server:", string(fromServer));
    
    s_fromServer := strings.ToLower(string(fromServer)); 
    
    if more {
        //switch string(fromServer) {
        switch s_fromServer {
        //case "Username:":
        case "username:":
            return []byte(a.username), nil
        //case "Password:":
        case "password:":
            return []byte(a.password), nil
        }//switch
    }//if
    return nil, nil
}//

func SendMail_t1() {
    auth := LoginAuth("[e-mail]", "123456");
    to := []string{"[e-mail]"}

    mimes := //這里寫上郵件內容
    err2 := smtp_SendMail_new("newbt.net:25", auth, "[e-mail]", to, []byte(mimes));
    
    fmt.Println(err);
}//

新的文件名為 smtp_new.go ，內容如下（我其實還是推薦大家自己改前面的代碼，那樣更好把握，所以這份代碼我默認折疊了）：

// Copyright 2010 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// Package smtp implements the Simple Mail Transfer Protocol as defined in RFC 5321.
// It also implements the following extensions:
//    8BITMIME  RFC 1652
//    AUTH      RFC 2554
//    STARTTLS  RFC 3207
// Additional extensions may be handled by clients.
//
// The smtp package is frozen and not accepting new features.
// Some external packages provide more functionality. See:
//
//   https://godoc.org/?q=smtp
//package smtp
package main //clq

//用於不加密環境的 smtp 發送電子郵件過程,因為不是所有的 smtp 環境都有加密支持的,不加密的適用范圍更廣一點,而且 smtp 服務器之間沒有密碼加密的過程
//(因為對方 smtp 服務器不可能知道你的密碼)所以原有的 golang 1.7.3 net/smtp 過程就不適合 smtp 之間發送郵件
//修改自 smtp.go[1.7.3] , 原始文件為 go1.7.3 的 net/smtp
//原文件在 code, msg64, err := c.cmd(0, "AUTH %s %s", mech, resp64) 處有誤,因為第一個 AUTH 后面只有一個字符(指不加密的情況下) 

import (
    "crypto/tls"
    "encoding/base64"
    "errors"
    "io"
    "net"
    "net/smtp" //clq add
    "net/textproto"
    "strings"
)

// A Client represents a client connection to an SMTP server.
type Client struct {
    // Text is the textproto.Conn used by the Client. It is exported to allow for
    // clients to add extensions.
    Text *textproto.Conn
    // keep a reference to the connection so it can be used to create a TLS
    // connection later
    conn net.Conn
    // whether the Client is using TLS
    tls        bool
    serverName string
    // map of supported extensions
    ext map[string]string
    // supported auth mechanisms
    auth       []string
    localName  string // the name to use in HELO/EHLO
    didHello   bool   // whether we've said HELO/EHLO
    helloError error  // the error from the hello
}

// Dial returns a new Client connected to an SMTP server at addr.
// The addr must include a port, as in "mail.example.com:smtp".
func Dial(addr string) (*Client, error) {
    conn, err := net.Dial("tcp", addr)
    if err != nil {
        return nil, err
    }
    host, _, _ := net.SplitHostPort(addr)
    return NewClient(conn, host)
}

// NewClient returns a new Client using an existing connection and host as a
// server name to be used when authenticating.
func NewClient(conn net.Conn, host string) (*Client, error) {
    text := textproto.NewConn(conn)
    _, _, err := text.ReadResponse(220)
    if err != nil {
        text.Close()
        return nil, err
    }
    c := &Client{Text: text, conn: conn, serverName: host, localName: "localhost"}
    return c, nil
}

// Close closes the connection.
func (c *Client) Close() error {
    return c.Text.Close()
}

// hello runs a hello exchange if needed.
func (c *Client) hello() error {
    if !c.didHello {
        c.didHello = true
        err := c.ehlo()
        if err != nil {
            c.helloError = c.helo()
        }
    }
    return c.helloError
}

// Hello sends a HELO or EHLO to the server as the given host name.
// Calling this method is only necessary if the client needs control
// over the host name used. The client will introduce itself as "localhost"
// automatically otherwise. If Hello is called, it must be called before
// any of the other methods.
func (c *Client) Hello(localName string) error {
    if c.didHello {
        return errors.New("smtp: Hello called after other methods")
    }
    c.localName = localName
    return c.hello()
}

// cmd is a convenience function that sends a command and returns the response
func (c *Client) cmd(expectCode int, format string, args ...interface{}) (int, string, error) {
    id, err := c.Text.Cmd(format, args...)
    if err != nil {
        return 0, "", err
    }
    c.Text.StartResponse(id)
    defer c.Text.EndResponse(id)
    code, msg, err := c.Text.ReadResponse(expectCode)
    return code, msg, err
}

// helo sends the HELO greeting to the server. It should be used only when the
// server does not support ehlo.
func (c *Client) helo() error {
    c.ext = nil
    _, _, err := c.cmd(250, "HELO %s", c.localName)
    return err
}

// ehlo sends the EHLO (extended hello) greeting to the server. It
// should be the preferred greeting for servers that support it.
func (c *Client) ehlo() error {
    _, msg, err := c.cmd(250, "EHLO %s", c.localName)
    if err != nil {
        return err
    }
    ext := make(map[string]string)
    extList := strings.Split(msg, "\n")
    if len(extList) > 1 {
        extList = extList[1:]
        for _, line := range extList {
            args := strings.SplitN(line, " ", 2)
            if len(args) > 1 {
                ext[args[0]] = args[1]
            } else {
                ext[args[0]] = ""
            }
        }
    }
    if mechs, ok := ext["AUTH"]; ok {
        c.auth = strings.Split(mechs, " ")
    }
    c.ext = ext
    return err
}

// StartTLS sends the STARTTLS command and encrypts all further communication.
// Only servers that advertise the STARTTLS extension support this function.
func (c *Client) StartTLS(config *tls.Config) error {
    if err := c.hello(); err != nil {
        return err
    }
    _, _, err := c.cmd(220, "STARTTLS")
    if err != nil {
        return err
    }
    c.conn = tls.Client(c.conn, config)
    c.Text = textproto.NewConn(c.conn)
    c.tls = true
    return c.ehlo()
}

// TLSConnectionState returns the client's TLS connection state.
// The return values are their zero values if StartTLS did
// not succeed.
func (c *Client) TLSConnectionState() (state tls.ConnectionState, ok bool) {
    tc, ok := c.conn.(*tls.Conn)
    if !ok {
        return
    }
    return tc.ConnectionState(), true
}

// Verify checks the validity of an email address on the server.
// If Verify returns nil, the address is valid. A non-nil return
// does not necessarily indicate an invalid address. Many servers
// will not verify addresses for security reasons.
func (c *Client) Verify(addr string) error {
    if err := c.hello(); err != nil {
        return err
    }
    _, _, err := c.cmd(250, "VRFY %s", addr)
    return err
}

// Auth authenticates a client using the provided authentication mechanism.
// A failed authentication closes the connection.
// Only servers that advertise the AUTH extension support this function.
func (c *Client) Auth(a smtp.Auth) error {
    if err := c.hello(); err != nil {
        return err
    }
    encoding := base64.StdEncoding
    mech, resp, err := a.Start(&smtp.ServerInfo{c.serverName, c.tls, c.auth})
    if err != nil {
        c.Quit()
        return err
    }
    resp64 := make([]byte, encoding.EncodedLen(len(resp)))
    encoding.Encode(resp64, resp)
    //code, msg64, err := c.cmd(0, "AUTH %s %s", mech, resp64); //clq 這里有誤,標准就應該是先 'AUTH LOGIN' 后面並沒有其他內容
    code, msg64, err := c.cmd(0, "AUTH %s", mech); //clq 這里有誤,標准就應該是先 'AUTH LOGIN' 后面並沒有其他內容//對於不加密的來說
    for err == nil {
        var msg []byte
        switch code {
        case 334:
            msg, err = encoding.DecodeString(msg64)
        case 235:
            // the last message isn't base64 because it isn't a challenge
            msg = []byte(msg64); //clq 對於不加密的來說這里一般就是返回登錄成功了
        default:
            err = &textproto.Error{Code: code, Msg: msg64}
        }
        if err == nil {
            resp, err = a.Next(msg, code == 334)
        }
        if err != nil {
            // abort the AUTH
            c.cmd(501, "*")
            c.Quit()
            break
        }
        if resp == nil {
            break
        }
        resp64 = make([]byte, encoding.EncodedLen(len(resp)))
        encoding.Encode(resp64, resp)
        code, msg64, err = c.cmd(0, string(resp64))
    }
    return err
}

// Mail issues a MAIL command to the server using the provided email address.
// If the server supports the 8BITMIME extension, Mail adds the BODY=8BITMIME
// parameter.
// This initiates a mail transaction and is followed by one or more Rcpt calls.
func (c *Client) Mail(from string) error {
    if err := c.hello(); err != nil {
        return err
    }
    cmdStr := "MAIL FROM:<%s>"
    if c.ext != nil {
        if _, ok := c.ext["8BITMIME"]; ok {
            cmdStr += " BODY=8BITMIME"
        }
    }
    _, _, err := c.cmd(250, cmdStr, from)
    return err
}

// Rcpt issues a RCPT command to the server using the provided email address.
// A call to Rcpt must be preceded by a call to Mail and may be followed by
// a Data call or another Rcpt call.
func (c *Client) Rcpt(to string) error {
    _, _, err := c.cmd(25, "RCPT TO:<%s>", to)
    return err
}

type dataCloser struct {
    c *Client
    io.WriteCloser
}

func (d *dataCloser) Close() error {
    d.WriteCloser.Close()
    _, _, err := d.c.Text.ReadResponse(250)
    return err
}

// Data issues a DATA command to the server and returns a writer that
// can be used to write the mail headers and body. The caller should
// close the writer before calling any more methods on c. A call to
// Data must be preceded by one or more calls to Rcpt.
func (c *Client) Data() (io.WriteCloser, error) {
    _, _, err := c.cmd(354, "DATA")
    if err != nil {
        return nil, err
    }
    return &dataCloser{c, c.Text.DotWriter()}, nil
}

var testHookStartTLS func(*tls.Config) // nil, except for tests

// SendMail connects to the server at addr, switches to TLS if
// possible, authenticates with the optional mechanism a if possible,
// and then sends an email from address from, to addresses to, with
// message msg.
// The addr must include a port, as in "mail.example.com:smtp".
//
// The addresses in the to parameter are the SMTP RCPT addresses.
//
// The msg parameter should be an RFC 822-style email with headers
// first, a blank line, and then the message body. The lines of msg
// should be CRLF terminated. The msg headers should usually include
// fields such as "From", "To", "Subject", and "Cc".  Sending "Bcc"
// messages is accomplished by including an email address in the to
// parameter but not including it in the msg headers.
//
// The SendMail function and the the net/smtp package are low-level
// mechanisms and provide no support for DKIM signing, MIME
// attachments (see the mime/multipart package), or other mail
// functionality. Higher-level packages exist outside of the standard
// library.
//func SendMail(addr string, a smtp.Auth, from string, to []string, msg []byte) error {
func smtp_SendMail_new(addr string, a smtp.Auth, from string, to []string, msg []byte) error { //clq  這段注釋是說, msg 包含了 mime 的所有內容
    c, err := Dial(addr)
    if err != nil {
        return err
    }
    defer c.Close()
    if err = c.hello(); err != nil {
        return err
    }
    if ok, _ := c.Extension("STARTTLS"); ok {
        config := &tls.Config{ServerName: c.serverName}
        if testHookStartTLS != nil {
            testHookStartTLS(config)
        }
        if err = c.StartTLS(config); err != nil {
            return err
        }
    }
    if a != nil && c.ext != nil {
        if _, ok := c.ext["AUTH"]; ok {
            if err = c.Auth(a); err != nil { //clq c.Auth(a) 這個也有交互過程
                return err
            }
        }
    }
    if err = c.Mail(from); err != nil {
        return err
    }
    for _, addr := range to {
        if err = c.Rcpt(addr); err != nil {
            return err
        }
    }
    w, err := c.Data()
    if err != nil {
        return err
    }
    _, err = w.Write(msg)
    if err != nil {
        return err
    }
    err = w.Close()
    if err != nil {
        return err
    }
    return c.Quit()
}

// Extension reports whether an extension is support by the server.
// The extension name is case-insensitive. If the extension is supported,
// Extension also returns a string that contains any parameters the
// server specifies for the extension.
func (c *Client) Extension(ext string) (bool, string) {
    if err := c.hello(); err != nil {
        return false, ""
    }
    if c.ext == nil {
        return false, ""
    }
    ext = strings.ToUpper(ext)
    param, ok := c.ext[ext]
    return ok, param
}

// Reset sends the RSET command to the server, aborting the current mail
// transaction.
func (c *Client) Reset() error {
    if err := c.hello(); err != nil {
        return err
    }
    _, _, err := c.cmd(250, "RSET")
    return err
}

// Quit sends the QUIT command and closes the connection to the server.
func (c *Client) Quit() error {
    if err := c.hello(); err != nil {
        return err
    }
    _, _, err := c.cmd(221, "QUIT")
    if err != nil {
        return err
    }
    return c.Text.Close()
}

    可以看到 golang 的代碼是寫得真簡潔，所以也比較好改。

 

    一定有網友覺得我發送部分說得太多太久了，好吧，那我們下一篇插播一下 pop3 接收，到時候大家就會明白，其實還有好多內容沒講。

 

完整代碼大家可以到以下 github 地址下載或查看:    
https://github.com/clqsrc/c_lib_lstring/tree/master/email_book/book_11

--------------------------------------------------

版權聲明:

本系列文章已授權百家號 "clq的程序員學前班" .