go-smtp: github.com/emersion/go-smtp Index | Examples | Files | Directories

package smtp

import "github.com/emersion/go-smtp"

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

LMTP (RFC 2033) is also supported.

Additional extensions may be handled by other packages.

Index

Examples

Package Files

backend.go client.go conn.go data.go parse.go server.go smtp.go

Variables

var (
    ErrAuthRequired    = errors.New("Please authenticate first")
    ErrAuthUnsupported = errors.New("Authentication not supported")
)
var ErrDataTooLarge = &SMTPError{
    Code:    552,
    Message: "Maximum message size exceeded",
}

func SendMail Uses

func SendMail(addr string, a sasl.Client, from string, to []string, r io.Reader) error

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 r. The addr must include a port, as in "mail.example.com:smtp".

The addresses in the to parameter are the SMTP RCPT addresses.

The r parameter should be an RFC 822-style email with headers first, a blank line, and then the message body. The lines of r should be CRLF terminated. The r 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 r headers.

The SendMail function and 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.

Code:

// Set up authentication information.
auth := sasl.NewPlainClient("", "user@example.com", "password")

// Connect to the server, authenticate, set the sender and recipient,
// and send the email all in one step.
to := []string{"recipient@example.net"}
msg := strings.NewReader("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 Backend Uses

type Backend interface {
    // Authenticate a user. Return smtp.ErrAuthUnsupported if you don't want to
    // support this.
    Login(state *ConnectionState, username, password string) (Session, error)

    // Called if the client attempts to send mail without logging in first.
    // Return smtp.ErrAuthRequired if you don't want to support this.
    AnonymousLogin(state *ConnectionState) (Session, error)
}

A SMTP server backend.

type Client Uses

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
}

A Client represents a client connection to an SMTP server.

func Dial Uses

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

Dial returns a new Client connected to an SMTP server at addr. The addr must include a port, as in "mail.example.com:smtp".

Code:

// 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 DialTLS Uses

func DialTLS(addr string, tlsConfig *tls.Config) (*Client, error)

DialTLS returns a new Client connected to an SMTP server via TLS at addr. The addr must include a port, as in "mail.example.com:smtps".

func NewClient Uses

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

NewClient returns a new Client using an existing connection and host as a server name to be used when authenticating.

func NewClientLMTP Uses

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

NewClientLMTP returns a new LMTP Client (as defined in RFC 2033) using an existing connector and host as a server name to be used when authenticating.

func (*Client) Auth Uses

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

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 (*Client) Close Uses

func (c *Client) Close() error

Close closes the connection.

func (*Client) Data Uses

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

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 (*Client) Extension Uses

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

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 (*Client) Hello Uses

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

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 (*Client) Mail Uses

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

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 (*Client) Noop Uses

func (c *Client) Noop() error

Noop sends the NOOP command to the server. It does nothing but check that the connection to the server is okay.

func (*Client) Quit Uses

func (c *Client) Quit() error

Quit sends the QUIT command and closes the connection to the server.

func (*Client) Rcpt Uses

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

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 (*Client) Reset Uses

func (c *Client) Reset() error

Reset sends the RSET command to the server, aborting the current mail transaction.

func (*Client) StartTLS Uses

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

StartTLS sends the STARTTLS command and encrypts all further communication. Only servers that advertise the STARTTLS extension support this function.

func (*Client) TLSConnectionState Uses

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

TLSConnectionState returns the client's TLS connection state. The return values are their zero values if StartTLS did not succeed.

func (*Client) Verify Uses

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

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.

type Conn Uses

type Conn struct {
    // contains filtered or unexported fields
}

func (*Conn) Close Uses

func (c *Conn) Close() error

func (*Conn) ReadLine Uses

func (c *Conn) ReadLine() (string, error)

Reads a line of input

func (*Conn) Reject Uses

func (c *Conn) Reject()

func (*Conn) Server Uses

func (c *Conn) Server() *Server

func (*Conn) Session Uses

func (c *Conn) Session() Session

func (*Conn) SetSession Uses

func (c *Conn) SetSession(session Session)

Setting the user resets any message beng generated

func (*Conn) State Uses

func (c *Conn) State() ConnectionState

func (*Conn) TLSConnectionState Uses

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

TLSConnectionState returns the connection's TLS connection state. Zero values are returned if the connection doesn't use TLS.

func (*Conn) WriteResponse Uses

func (c *Conn) WriteResponse(code int, text ...string)

type ConnectionState Uses

type ConnectionState struct {
    Hostname   string
    RemoteAddr net.Addr
    TLS        tls.ConnectionState
}

type SMTPError Uses

type SMTPError struct {
    Code    int
    Message string
}

SMTPError specifies the error code and message that needs to be returned to the client

func (*SMTPError) Error Uses

func (err *SMTPError) Error() string

type SaslServerFactory Uses

type SaslServerFactory func(conn *Conn) sasl.Server

A function that creates SASL servers.

type Server Uses

type Server struct {
    // TCP or Unix address to listen on.
    Addr string
    // The server TLS configuration.
    TLSConfig *tls.Config
    // Enable LMTP mode, as defined in RFC 2033. LMTP mode cannot be used with a
    // TCP listener.
    LMTP bool

    Domain            string
    MaxRecipients     int
    MaxIdleSeconds    int
    MaxMessageBytes   int
    AllowInsecureAuth bool
    Strict            bool
    Debug             io.Writer

    // If set, the AUTH command will not be advertised and authentication
    // attempts will be rejected. This setting overrides AllowInsecureAuth.
    AuthDisabled bool

    // The server backend.
    Backend Backend
    // contains filtered or unexported fields
}

A SMTP server.

func NewServer Uses

func NewServer(be Backend) *Server

New creates a new SMTP server.

Code:

be := &Backend{}

s := smtp.NewServer(be)

s.Addr = ":1025"
s.Domain = "localhost"
s.MaxIdleSeconds = 300
s.MaxMessageBytes = 1024 * 1024
s.MaxRecipients = 50
s.AllowInsecureAuth = true

log.Println("Starting server at", s.Addr)
if err := s.ListenAndServe(); err != nil {
    log.Fatal(err)
}

func (*Server) Close Uses

func (s *Server) Close()

Close stops the server.

func (*Server) EnableAuth Uses

func (s *Server) EnableAuth(name string, f SaslServerFactory)

EnableAuth enables an authentication mechanism on this server.

This function should not be called directly, it must only be used by libraries implementing extensions of the SMTP protocol.

func (*Server) ForEachConn Uses

func (s *Server) ForEachConn(f func(*Conn))

ForEachConn iterates through all opened connections.

func (*Server) ListenAndServe Uses

func (s *Server) ListenAndServe() error

ListenAndServe listens on the network address s.Addr and then calls Serve to handle requests on incoming connections.

If s.Addr is blank and LMTP is disabled, ":smtp" is used.

func (*Server) ListenAndServeTLS Uses

func (s *Server) ListenAndServeTLS() error

ListenAndServeTLS listens on the TCP network address s.Addr and then calls Serve to handle requests on incoming TLS connections.

If s.Addr is blank, ":smtps" is used.

func (*Server) Serve Uses

func (s *Server) Serve(l net.Listener) error

Serve accepts incoming connections on the Listener l.

type Session Uses

type Session interface {
    // Discard currently processed message.
    Reset()

    // Free all resources associated with session.
    Logout() error

    // Set return path for currently processed message.
    Mail(from string) error
    // Add recipient for currently processed message.
    Rcpt(to string) error
    // Set currently processed message contents and send it.
    Data(r io.Reader) error
}

Directories

PathSynopsis
backendutilPackage backendutil provide utilities to implement SMTP backends.

Package smtp imports 13 packages (graph) and is imported by 11 packages. Updated 2019-03-23. Refresh now. Tools for package owners.