go-message: github.com/emersion/go-message/mail Index | Examples | Files

package mail

import "github.com/emersion/go-message/mail"

Package mail implements reading and writing mail messages.

This package assumes that a mail message contains one or more text parts and zero or more attachment parts. Each text part represents a different version of the message content (e.g. a different type, a different language and so on).

RFC 5322 defines the Internet Message Format.

Index

Examples

Package Files

address.go attachment.go header.go inline.go mail.go reader.go writer.go

func CreateSingleInlineWriter Uses

func CreateSingleInlineWriter(w io.Writer, header Header) (io.WriteCloser, error)

CreateSingleInlineWriter writes a mail header to w. The mail will contain a single inline part. The body of the part should be written to the returned io.WriteCloser. Only one single inline part should be written, use CreateWriter if you want multiple parts.

func GenerateMessageID Uses

func GenerateMessageID() string

Generates an RFC 2822-compliant Message-Id based on the informational draft "Recommendations for generating Message IDs", for lack of a better authoritative source.

type Address Uses

type Address mail.Address

Address represents a single mail address.

func (*Address) String Uses

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 AttachmentHeader Uses

type AttachmentHeader struct {
    message.Header
}

An AttachmentHeader represents an attachment's header.

func (*AttachmentHeader) Filename Uses

func (h *AttachmentHeader) Filename() (string, error)

Filename parses the attachment's filename.

func (*AttachmentHeader) SetFilename Uses

func (h *AttachmentHeader) SetFilename(filename string)

SetFilename formats the attachment's filename.

type Header struct {
    message.Header
}

A Header is a mail header.

func (*Header) AddressList Uses

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

AddressList parses the named header field as a list of addresses. If the header is missing, it returns nil.

func (*Header) Date Uses

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

Date parses the Date header field.

func (*Header) SetAddressList Uses

func (h *Header) SetAddressList(key string, addrs []*Address)

SetAddressList formats the named header to the provided list of addresses.

func (*Header) SetDate Uses

func (h *Header) SetDate(t time.Time)

SetDate formats the Date header field.

func (*Header) SetSubject Uses

func (h *Header) SetSubject(s string)

SetSubject formats the Subject header field.

func (*Header) Subject Uses

func (h *Header) Subject() (string, error)

Subject parses the Subject header field. If there is an error, the raw field value is returned alongside the error.

type InlineHeader Uses

type InlineHeader struct {
    message.Header
}

A InlineHeader represents a message text header.

type InlineWriter Uses

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

InlineWriter writes a mail message's text.

func (*InlineWriter) Close Uses

func (w *InlineWriter) Close() error

Close finishes the InlineWriter.

func (*InlineWriter) CreatePart Uses

func (w *InlineWriter) CreatePart(h InlineHeader) (io.WriteCloser, error)

CreatePart creates a new text part with the provided header. The body of the part should be written to the returned io.WriteCloser.

type Part Uses

type Part struct {
    Header PartHeader
    Body   io.Reader
}

A Part is either a mail text or an attachment. Header is either a InlineHeader or an AttachmentHeader.

type PartHeader Uses

type PartHeader interface {
    // Add adds the key, value pair to the header.
    Add(key, value string)
    // Del deletes the values associated with key.
    Del(key string)
    // Get gets the first value associated with the given key. If there are no
    // values associated with the key, Get returns "".
    Get(key string) string
    // Set sets the header entries associated with key to the single element
    // value. It replaces any existing values associated with key.
    Set(key, value string)
}

A PartHeader is a mail part header. It contains convenience functions to get and set header fields.

type Reader Uses

type Reader struct {
    Header Header
    // contains filtered or unexported fields
}

A Reader reads a mail message.

Code:

// Let's assume r is an io.Reader that contains a mail.
var r io.Reader

// Create a new mail reader
mr, err := mail.CreateReader(r)
if err != nil {
    log.Fatal(err)
}

// Read each mail's part
for {
    p, err := mr.NextPart()
    if err == io.EOF {
        break
    } else if err != nil {
        log.Fatal(err)
    }

    switch h := p.Header.(type) {
    case *mail.InlineHeader:
        b, _ := ioutil.ReadAll(p.Body)
        log.Printf("Got text: %v\n", string(b))
    case *mail.AttachmentHeader:
        filename, _ := h.Filename()
        log.Printf("Got attachment: %v\n", filename)
    }
}

func CreateReader Uses

func CreateReader(r io.Reader) (*Reader, error)

CreateReader reads a mail header from r and returns a new mail reader.

If the message uses an unknown transfer encoding or charset, CreateReader returns an error that verifies message.IsUnknownCharset, but also returns a Reader that can be used.

func NewReader Uses

func NewReader(e *message.Entity) *Reader

NewReader creates a new mail reader.

func (*Reader) Close Uses

func (r *Reader) Close() error

Close finishes the reader.

func (*Reader) NextPart Uses

func (r *Reader) NextPart() (*Part, error)

NextPart returns the next mail part. If there is no more part, io.EOF is returned as error.

The returned Part.Body must be read completely before the next call to NextPart, otherwise it will be discarded.

If the part uses an unknown transfer encoding or charset, NextPart returns an error that verifies message.IsUnknownCharset, but also returns a Part that can be used.

type Writer Uses

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

A Writer writes a mail message. A mail message contains one or more text parts and zero or more attachments.

Code:

var b bytes.Buffer

from := []*mail.Address{{"Mitsuha Miyamizu", "mitsuha.miyamizu@example.org"}}
to := []*mail.Address{{"Taki Tachibana", "taki.tachibana@example.org"}}

// Create our mail header
var h mail.Header
h.SetDate(time.Now())
h.SetAddressList("From", from)
h.SetAddressList("To", to)

// Create a new mail writer
mw, err := mail.CreateWriter(&b, h)
if err != nil {
    log.Fatal(err)
}

// Create a text part
tw, err := mw.CreateInline()
if err != nil {
    log.Fatal(err)
}
var th mail.InlineHeader
th.Set("Content-Type", "text/plain")
w, err := tw.CreatePart(th)
if err != nil {
    log.Fatal(err)
}
io.WriteString(w, "Who are you?")
w.Close()
tw.Close()

// Create an attachment
var ah mail.AttachmentHeader
ah.Set("Content-Type", "image/jpeg")
ah.SetFilename("picture.jpg")
w, err = mw.CreateAttachment(ah)
if err != nil {
    log.Fatal(err)
}
// TODO: write a JPEG file to w
w.Close()

mw.Close()

log.Println(b.String())

func CreateWriter Uses

func CreateWriter(w io.Writer, header Header) (*Writer, error)

CreateWriter writes a mail header to w and creates a new Writer.

func (*Writer) Close Uses

func (w *Writer) Close() error

Close finishes the Writer.

func (*Writer) CreateAttachment Uses

func (w *Writer) CreateAttachment(h AttachmentHeader) (io.WriteCloser, error)

CreateAttachment creates a new attachment with the provided header. The body of the part should be written to the returned io.WriteCloser.

func (*Writer) CreateInline Uses

func (w *Writer) CreateInline() (*InlineWriter, error)

CreateInline creates a InlineWriter. One or more parts representing the same text in different formats can be written to a InlineWriter.

func (*Writer) CreateSingleInline Uses

func (w *Writer) CreateSingleInline(h InlineHeader) (io.WriteCloser, error)

CreateSingleInline creates a new single text part with the provided header. The body of the part should be written to the returned io.WriteCloser. Only one single text part should be written, use CreateInline if you want multiple text parts.

Package mail imports 14 packages (graph) and is imported by 16 packages. Updated 2019-08-20. Refresh now. Tools for package owners.