package main

import (
	"log"
	"net/smtp"
)

func main(a) {
	// Set PlainAuth authentication account and SMTP server information
	auth := smtp.PlainAuth(""."[email protected]"."password"."mail.example.com")

	// Set the sender. Each email address in the array will be RCPT called
	to := []string{"[email protected]"}

    // Write the sent message
	msg := []byte("To: [email protected]\r\n" +
		"Subject: discount Gophers! \r\n" +
		"\r\n" +
		"This is the email body.\r\n")

    // Call the function to send mail
	err := smtp.SendMail("mail.example.com:25", auth, "[email protected]", to, msg)
	iferr ! =nil {
		log.Fatal(err)
	}
}
Copy the code

type Auth interface {

    Start(server *ServerInfo) (proto string, toServer []byte, err error)

    Next(fromServer []byte, more bool) (toServer []byte, err error)
}
Copy the code

type cramMD5Auth struct {
	username, secret string
}
// Provide externally called methods, passing in username and secret, and the returned Auth authenticates the server using challenge-response mechanisms with the given username and password.
func CRAMMD5Auth(username, secret string) Auth {
	return &cramMD5Auth{username, secret}
}
// Implement Auth's Start method, return the protocol name 'CRAM-MD5'
func (a *cramMD5Auth) Start(server *ServerInfo) (stringAnd []byte, error) {
	return "CRAM-MD5".nil.nil
}
// Implement Auth's Next method to encrypt
func (a *cramMD5Auth) Next(fromServer []byte, more bool) ([]byte, error) {
	if more {
		d := hmac.New(md5.New, []byte(a.secret))
		d.Write(fromServer)
		s := make([]byte.0, d.Size())
		return []byte(fmt.Sprintf("%s %x", a.username, d.Sum(s))), nil
	}
	return nil.nil
}
Copy the code

type plainAuth struct {
	identity, username, password string
	host                         string
}
// Exposes methods to external calls, generally identity is an empty string. Pass in the account name, password, and SMTP server address
func PlainAuth(identity, username, password, host string) Auth {
	return &plainAuth{identity, username, password, host}
}
// Check whether it is a local address
func isLocalhost(name string) bool {
	return name == "localhost" || name == "127.0.0.1" || name == : : "1"
}
// Implement the Start method of the Auth interface to return the PLAIN protocol and the data in the initial Auth message sent to the server
func (a *plainAuth) Start(server *ServerInfo) (stringAnd []byte, error) {
	if! server.TLS && ! isLocalhost(server.Name) {return "".nil, errors.New("unencrypted connection")}ifserver.Name ! = a.host {return "".nil, errors.New("wrong host name")
	}
	resp := []byte(a.identity + "\x00" + a.username + "\x00" + a.password)
	return "PLAIN", resp, nil
}

func (a *plainAuth) Next(fromServer []byte, more bool) ([]byte, error) {
	if more {
		return nil, errors.New("unexpected server challenge")}return nil.nil
}
Copy the code

type Client struct {
	// The textProto.conn used by the client. It is exported to allow clients to add extensions.
	Text *textproto.Conn
	// Keep a reference to the connection for later creation of TLS links
	conn net.Conn
	// Whether the client is using TLS
	tls        bool
	serverName string
	// Support extended Map
	ext map[string]string
	// Support auth mechanism
	auth       []string
	localName  string
    // Whether HELLO/EHLO has been called
	didHello   bool   
    // HELO response error
	helloError error
}
Copy the code

func Dial(addr string) (*Client, error) {
	conn, err := net.Dial("tcp", addr)
	iferr ! =nil {
		return nil, err
	}
	host, _, _ := net.SplitHostPort(addr)
	return NewClient(conn, host)
}
Copy the code

func NewClient(conn net.Conn, host string) (*Client, error) {
	text := textproto.NewConn(conn)
	_, _, err := text.ReadResponse(220)
	iferr ! =nil {
		text.Close()
		return nil, err
	}
	c := &Client{Text: text, conn: conn, serverName: host, localName: "localhost"}
	_, c.tls = conn.(*tls.Conn)
	return c, nil
}
Copy the code

func (c *Client) Auth(a Auth) error {
	iferr := c.hello(); err ! =nil {
		return err
	}
	encoding := base64.StdEncoding
	mech, resp, err := a.Start(&ServerInfo{c.serverName, c.tls, c.auth})
	iferr ! =nil {
		c.Quit()
		return err
	}
	resp64 := make([]byte, encoding.EncodedLen(len(resp)))
	encoding.Encode(resp64, resp)
	code, msg64, err := c.cmd(0, strings.TrimSpace(fmt.Sprintf("AUTH %s %s", mech, resp64)))
	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)
		default:
			err = &textproto.Error{Code: code, Msg: msg64}
		}
		if err == nil {
			resp, err = a.Next(msg, code == 334)}iferr ! =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
}
Copy the code

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

func (c *Client) Data(a) (io.WriteCloser, error) {
	_, _, err := c.cmd(354."DATA")
	iferr ! =nil {
		return nil, err
	}
	return &dataCloser{c, c.Text.DotWriter()}, nil
}
Copy the code

func (c *Client) Extension(ext string) (bool.string) {
	iferr := c.hello(); err ! =nil {
		return false.""
	}
	if c.ext == nil {
		return false.""
	}
	ext = strings.ToUpper(ext)
	param, ok := c.ext[ext]
	return ok, param
}
Copy the code

func (c *Client) hello(a) error {
	if! c.didHello { c.didHello =true
		err := c.ehlo()
		iferr ! =nil {
			c.helloError = c.helo()
		}
	}
	return c.helloError
}
Copy the code

func (c *Client) Mail(from string) error {
	iferr := validateLine(from); err ! =nil {
		return err
	}
	iferr := c.hello(); err ! =nil {
		return err
	}
	cmdStr := "MAIL FROM:<%s>"
	ifc.ext ! =nil {
		if _, ok := c.ext["8BITMIME"]; ok {
			cmdStr += " BODY=8BITMIME"
		}
		if _, ok := c.ext["SMTPUTF8"]; ok {
			cmdStr += " SMTPUTF8"
		}
	}
	_, _, err := c.cmd(250, cmdStr, from)
	return err
}
Copy the code

func (c *Client) Noop(a) error {
	iferr := c.hello(); err ! =nil {
		return err
	}
	_, _, err := c.cmd(250."NOOP")
	return err
}
Copy the code

func (c *Client) Quit(a) error {
	iferr := c.hello(); err ! =nil {
		return err
	}
	_, _, err := c.cmd(221."QUIT")
	iferr ! =nil {
		return err
	}
	return c.Text.Close()
}
Copy the code

func (c *Client) Rcpt(to string) error {
	iferr := validateLine(to); err ! =nil {
		return err
	}
	_, _, err := c.cmd(25."RCPT TO:<%s>", to)
	return err
}
Copy the code

func (c *Client) Reset(a) error {
	iferr := c.hello(); err ! =nil {
		return err
	}
	_, _, err := c.cmd(250."RSET")
	return err
}
Copy the code

func (c *Client) StartTLS(config *tls.Config) error {
	iferr := c.hello(); err ! =nil {
		return err
	}
	_, _, err := c.cmd(220."STARTTLS")
	iferr ! =nil {
		return err
	}
	c.conn = tls.Client(c.conn, config)
	c.Text = textproto.NewConn(c.conn)
	c.tls = true
	return c.ehlo()
}
Copy the code

func (c *Client) TLSConnectionState(a) (state tls.ConnectionState, ok bool) {
	tc, ok := c.conn.(*tls.Conn)
	if! ok {return
	}
	return tc.ConnectionState(), true
}
Copy the code

func (c *Client) Verify(addr string) error {
	iferr := validateLine(addr); err ! =nil {
		return err
	}
	iferr := c.hello(); err ! =nil {
		return err
	}
	_, _, err := c.cmd(250."VRFY %s", addr)
	return err
}
Copy the code