net/smtp

8BITMIME  RFC 1652
AUTH      RFC 2554
STARTTLS  RFC 3207

https://godoc.org/?q=smtp

// Connect to the remote SMTP server.
c, err := smtp.Dial("mail.example.com:25")
if err != nil {
        log.Fatal(err)
}

// Set the sender and recipient first
if err := c.Mail("sender@example.org"); err != nil {
        log.Fatal(err)
}
if err := c.Rcpt("recipient@example.net"); err != nil {
        log.Fatal(err)
}

// Send the email body.
wc, err := c.Data()
if err != nil {
        log.Fatal(err)
}
_, err = fmt.Fprintf(wc, "This is the email body")
if err != nil {
        log.Fatal(err)
}
err = wc.Close()
if err != nil {
        log.Fatal(err)
}

// Send the QUIT command and close the connection.
err = c.Quit()
if err != nil {
        log.Fatal(err)
}

func SendMail(addr string, a Auth, from string, to []string, msg []byte) error

package main

import (
	"log"
	"net/smtp"
)

func main() {
	// Set up authentication information.
	auth := smtp.PlainAuth("", "user@example.com", "password", "mail.example.com")

	// Connect to the server, authenticate, set the sender and recipient,
	// and send the email all in one step.
	to := []string{"recipient@example.net"}
	msg := []byte("To: recipient@example.net\r\n" +
		"Subject: discount Gophers!\r\n" +
		"\r\n" +
		"This is the email body.\r\n")
	err := smtp.SendMail("mail.example.com:25", auth, "sender@example.org", to, msg)
	if err != nil {
		log.Fatal(err)
	}
}

type Auth interface {
        // Start begins an authentication with a server.
        // It returns the name of the authentication protocol
        // and optionally data to include in the initial AUTH message
        // sent to the server. It can return proto == "" to indicate
        // that the authentication should be skipped.
        // If it returns a non-nil error, the SMTP client aborts
        // the authentication attempt and closes the connection.
        Start(server *ServerInfo) (proto string, toServer []byte, err error)

        // Next continues the authentication. The server has just sent
        // the fromServer data. If more is true, the server expects a
        // response, which Next should return as toServer; otherwise
        // Next should return toServer == nil.
        // If Next returns a non-nil error, the SMTP client aborts
        // the authentication attempt and closes the connection.
        Next(fromServer []byte, more bool) (toServer []byte, err error)
}

func CRAMMD5Auth(username, secret string) Auth

func PlainAuth(identity, username, password, host string) Auth

// hostname is used by PlainAuth to validate the TLS certificate.
hostname := "mail.example.com"
auth := smtp.PlainAuth("", "user@example.com", "password", hostname)

err := smtp.SendMail(hostname+":25", auth, from, recipients, msg)
if err != nil {
        log.Fatal(err)
}

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
        // contains filtered or unexported fields
}

func Dial(addr string) (*Client, error)

func NewClient(conn net.Conn, host string) (*Client, error)

func (c *Client) Auth(a Auth) error

func (c *Client) Close() error

func (c *Client) Data() (io.WriteCloser, error)

func (c *Client) Extension(ext string) (bool, string)

func (c *Client) Hello(localName string) error

func (c *Client) Mail(from string) error

func (c *Client) Quit() error

func (c *Client) Rcpt(to string) error

func (c *Client) Reset() error

func (c *Client) StartTLS(config *tls.Config) error

func (c *Client) TLSConnectionState() (state tls.ConnectionState, ok bool)

func (c *Client) Verify(addr string) error

type ServerInfo struct {
        Name string   // SMTP server name
        TLS  bool     // using TLS, with valid certificate for Name
        Auth []string // advertised authentication mechanisms
}