Package mail

Variables

var ErrHeaderNotPresent = errors.New("mail: header not in message")

func ParseDate ¶ 1.8

func ParseDate(date string) (time.Time, error)

ParseDate parses an RFC 5322 date string.

type Address ¶

Address represents a single mail address. An address such as "Barry Gibbs <bg@example.com>" is represented as Address{Name: "Barry Gibbs", Address: "bg@example.com"}.

type Address struct {
    Name    string // Proper name; may be empty.
    Address string // user@domain
}

func ParseAddress ¶ 1.1

func ParseAddress(address string) (*Address, error)

ParseAddress parses a single RFC 5322 address, e.g. "Barry Gibbs <bg@example.com>"

e, err := mail.ParseAddress("Alice <alice@example.com>")
if err != nil {
    log.Fatal(err)
}

fmt.Println(e.Name, e.Address)

Alice alice@example.com

func ParseAddressList ¶ 1.1

func ParseAddressList(list string) ([]*Address, error)

ParseAddressList parses the given string as a list of addresses.

const list = "Alice <alice@example.com>, Bob <bob@example.com>, Eve <eve@example.com>"
emails, err := mail.ParseAddressList(list)
if err != nil {
    log.Fatal(err)
}

for _, v := range emails {
    fmt.Println(v.Name, v.Address)
}

Alice alice@example.com
Bob bob@example.com
Eve eve@example.com

func (*Address) String ¶

func (a *Address) String() string

String formats the address as a valid RFC 5322 address. If the address's name contains non-ASCII characters the name will be rendered according to RFC 2047.

type AddressParser ¶ 1.5

An AddressParser is an RFC 5322 address parser.

type AddressParser struct {
    // WordDecoder optionally specifies a decoder for RFC 2047 encoded-words.
    WordDecoder *mime.WordDecoder
}

func (*AddressParser) Parse ¶ 1.5

func (p *AddressParser) Parse(address string) (*Address, error)

Parse parses a single RFC 5322 address of the form "Gogh Fir <gf@example.com>" or "foo@example.com".

func (*AddressParser) ParseList ¶ 1.5

func (p *AddressParser) ParseList(list string) ([]*Address, error)

ParseList parses the given string as a list of comma-separated addresses of the form "Gogh Fir <gf@example.com>" or "foo@example.com".

type Header ¶

A Header represents the key-value pairs in a mail message header.

type Header map[string][]string

func (Header) AddressList ¶

func (h Header) AddressList(key string) ([]*Address, error)

AddressList parses the named header field as a list of addresses.

func (Header) Date ¶

func (h Header) Date() (time.Time, error)

Date parses the Date header field.

func (Header) Get ¶

func (h Header) Get(key string) string

Get gets the first value associated with the given key. It is case insensitive; CanonicalMIMEHeaderKey is used to canonicalize the provided key. If there are no values associated with the key, Get returns "". To access multiple values of a key, or to use non-canonical keys, access the map directly.

type Message ¶

A Message represents a parsed mail message.

type Message struct {
    Header Header
    Body   io.Reader
}

func ReadMessage ¶

func ReadMessage(r io.Reader) (msg *Message, err error)

ReadMessage reads a message from r. The headers are parsed, and the body of the message will be available for reading from msg.Body.

msg := `Date: Mon, 23 Jun 2015 11:40:36 -0400
From: Gopher <from@example.com>
To: Another Gopher <to@example.com>
Subject: Gophers at Gophercon

Message body
`

r := strings.NewReader(msg)
m, err := mail.ReadMessage(r)
if err != nil {
    log.Fatal(err)
}

header := m.Header
fmt.Println("Date:", header.Get("Date"))
fmt.Println("From:", header.Get("From"))
fmt.Println("To:", header.Get("To"))
fmt.Println("Subject:", header.Get("Subject"))

body, err := io.ReadAll(m.Body)
if err != nil {
    log.Fatal(err)
}
fmt.Printf("%s", body)

Date: Mon, 23 Jun 2015 11:40:36 -0400
From: Gopher <from@example.com>
To: Another Gopher <to@example.com>
Subject: Gophers at Gophercon
Message body