go-mail/msg.go

526 lines
14 KiB
Go
Raw Normal View History

2022-03-09 16:52:23 +01:00
package mail
import (
"bytes"
"errors"
2022-03-09 16:52:23 +01:00
"fmt"
"io"
2022-03-09 16:52:23 +01:00
"math/rand"
"mime"
2022-03-10 16:19:51 +01:00
"net/mail"
2022-03-09 16:52:23 +01:00
"os"
2022-03-14 10:29:53 +01:00
"path/filepath"
2022-03-09 16:52:23 +01:00
"time"
)
var (
// ErrNoFromAddress should be used when a FROM address is requrested but not set
ErrNoFromAddress = errors.New("no FROM address set")
// ErrNoRcptAddresses should be used when the list of RCPTs is empty
ErrNoRcptAddresses = errors.New("no recipient addresses set")
)
2022-03-09 16:52:23 +01:00
// Msg is the mail message struct
type Msg struct {
// addrHeader is a slice of strings that the different mail AddrHeader fields
addrHeader map[AddrHeader][]*mail.Address
// boundary is the MIME content boundary
boundary string
2022-03-09 16:52:23 +01:00
// charset represents the charset of the mail (defaults to UTF-8)
charset Charset
// encoding represents the message encoding (the encoder will be a corresponding WordEncoder)
encoding Encoding
2022-03-09 16:52:23 +01:00
// encoder represents a mime.WordEncoder from the std lib
encoder mime.WordEncoder
2022-03-09 16:52:23 +01:00
2022-03-10 16:19:51 +01:00
// genHeader is a slice of strings that the different generic mail Header fields
genHeader map[Header][]string
// mimever represents the MIME version
mimever MIMEVersion
// parts represent the different parts of the Msg
parts []*Part
2022-03-09 16:52:23 +01:00
2022-03-14 10:29:53 +01:00
// attachments represent the different attachment File of the Msg
attachments []*File
2022-03-14 10:29:53 +01:00
// embeds represent the different embedded File of the Msg
embeds []*File
}
// MsgOption returns a function that can be used for grouping Msg options
type MsgOption func(*Msg)
2022-03-09 16:52:23 +01:00
// NewMsg returns a new Msg pointer
func NewMsg(o ...MsgOption) *Msg {
2022-03-09 16:52:23 +01:00
m := &Msg{
addrHeader: make(map[AddrHeader][]*mail.Address),
charset: CharsetUTF8,
encoding: EncodingQP,
2022-03-10 16:19:51 +01:00
genHeader: make(map[Header][]string),
mimever: Mime10,
2022-03-09 16:52:23 +01:00
}
// Override defaults with optionally provided MsgOption functions
for _, co := range o {
if co == nil {
continue
}
co(m)
}
// Set the matcing mime.WordEncoder for the Msg
m.setEncoder()
2022-03-09 16:52:23 +01:00
return m
}
// WithCharset overrides the default message charset
func WithCharset(c Charset) MsgOption {
return func(m *Msg) {
m.charset = c
}
}
// WithEncoding overrides the default message encoding
func WithEncoding(e Encoding) MsgOption {
return func(m *Msg) {
m.encoding = e
}
}
// WithMIMEVersion overrides the default MIME version
func WithMIMEVersion(mv MIMEVersion) MsgOption {
return func(m *Msg) {
m.mimever = mv
}
}
// SetCharset sets the encoding charset of the Msg
func (m *Msg) SetCharset(c Charset) {
m.charset = c
}
// SetEncoding sets the encoding of the Msg
func (m *Msg) SetEncoding(e Encoding) {
m.encoding = e
2022-03-13 20:01:02 +01:00
m.setEncoder()
}
// SetBoundary sets the boundary of the Msg
func (m *Msg) SetBoundary(b string) {
m.boundary = b
}
// SetMIMEVersion sets the MIME version of the Msg
func (m *Msg) SetMIMEVersion(mv MIMEVersion) {
m.mimever = mv
}
2022-03-13 10:49:07 +01:00
// Encoding returns the currently set encoding of the Msg
func (m *Msg) Encoding() string {
return m.encoding.String()
}
// Charset returns the currently set charset of the Msg
func (m *Msg) Charset() string {
return m.charset.String()
}
2022-03-10 16:19:51 +01:00
// SetHeader sets a generic header field of the Msg
2022-03-09 16:52:23 +01:00
func (m *Msg) SetHeader(h Header, v ...string) {
for i, hv := range v {
v[i] = m.encodeString(hv)
}
2022-03-10 16:19:51 +01:00
m.genHeader[h] = v
}
// SetAddrHeader sets an address related header field of the Msg
func (m *Msg) SetAddrHeader(h AddrHeader, v ...string) error {
var al []*mail.Address
for _, av := range v {
a, err := mail.ParseAddress(m.encodeString(av))
2022-03-10 16:19:51 +01:00
if err != nil {
return fmt.Errorf("failed to parse mail address header %q: %w", av, err)
}
al = append(al, a)
}
2022-03-09 16:52:23 +01:00
switch h {
case HeaderFrom:
2022-03-10 16:19:51 +01:00
m.addrHeader[h] = []*mail.Address{al[0]}
2022-03-09 16:52:23 +01:00
default:
2022-03-10 16:19:51 +01:00
m.addrHeader[h] = al
2022-03-09 16:52:23 +01:00
}
2022-03-10 16:19:51 +01:00
return nil
}
// SetAddrHeaderIgnoreInvalid sets an address related header field of the Msg and ignores invalid address
// in the validation process
func (m *Msg) SetAddrHeaderIgnoreInvalid(h AddrHeader, v ...string) {
var al []*mail.Address
for _, av := range v {
a, err := mail.ParseAddress(m.encodeString(av))
2022-03-10 16:19:51 +01:00
if err != nil {
continue
}
al = append(al, a)
}
m.addrHeader[h] = al
}
// From takes and validates a given mail address and sets it as "From" genHeader of the Msg
func (m *Msg) From(f string) error {
return m.SetAddrHeader(HeaderFrom, f)
2022-03-09 16:52:23 +01:00
}
2022-03-12 20:05:43 +01:00
// FromFormat takes a name and address, formats them RFC5322 compliant and stores them as
// the From address header field
func (m *Msg) FromFormat(n, a string) error {
return m.SetAddrHeader(HeaderFrom, fmt.Sprintf(`"%s" <%s>`, n, a))
}
2022-03-10 16:19:51 +01:00
// To takes and validates a given mail address list sets the To: addresses of the Msg
func (m *Msg) To(t ...string) error {
return m.SetAddrHeader(HeaderTo, t...)
2022-03-09 16:52:23 +01:00
}
2022-03-12 20:05:43 +01:00
// AddTo adds an additional address to the To address header field
func (m *Msg) AddTo(t string) error {
2022-03-13 10:49:07 +01:00
return m.addAddr(HeaderTo, t)
2022-03-12 20:05:43 +01:00
}
2022-03-13 10:49:07 +01:00
// AddToFormat takes a name and address, formats them RFC5322 compliant and stores them as
// as additional To address header field
func (m *Msg) AddToFormat(n, a string) error {
return m.addAddr(HeaderTo, fmt.Sprintf(`"%s" <%s>`, n, a))
}
2022-03-10 16:19:51 +01:00
// ToIgnoreInvalid takes and validates a given mail address list sets the To: addresses of the Msg
// Any provided address that is not RFC5322 compliant, will be ignored
func (m *Msg) ToIgnoreInvalid(t ...string) {
m.SetAddrHeaderIgnoreInvalid(HeaderTo, t...)
2022-03-09 16:52:23 +01:00
}
2022-03-10 16:19:51 +01:00
// Cc takes and validates a given mail address list sets the Cc: addresses of the Msg
func (m *Msg) Cc(c ...string) error {
return m.SetAddrHeader(HeaderCc, c...)
}
2022-03-13 10:49:07 +01:00
// AddCc adds an additional address to the Cc address header field
func (m *Msg) AddCc(t string) error {
return m.addAddr(HeaderCc, t)
}
// AddCcFormat takes a name and address, formats them RFC5322 compliant and stores them as
// as additional Cc address header field
func (m *Msg) AddCcFormat(n, a string) error {
return m.addAddr(HeaderCc, fmt.Sprintf(`"%s" <%s>`, n, a))
}
2022-03-10 16:19:51 +01:00
// CcIgnoreInvalid takes and validates a given mail address list sets the Cc: addresses of the Msg
// Any provided address that is not RFC5322 compliant, will be ignored
func (m *Msg) CcIgnoreInvalid(c ...string) {
m.SetAddrHeaderIgnoreInvalid(HeaderCc, c...)
}
// Bcc takes and validates a given mail address list sets the Bcc: addresses of the Msg
func (m *Msg) Bcc(b ...string) error {
return m.SetAddrHeader(HeaderBcc, b...)
}
2022-03-13 10:49:07 +01:00
// AddBcc adds an additional address to the Bcc address header field
func (m *Msg) AddBcc(t string) error {
return m.addAddr(HeaderBcc, t)
}
// AddBccFormat takes a name and address, formats them RFC5322 compliant and stores them as
// as additional Bcc address header field
func (m *Msg) AddBccFormat(n, a string) error {
return m.addAddr(HeaderBcc, fmt.Sprintf(`"%s" <%s>`, n, a))
}
2022-03-10 16:19:51 +01:00
// BccIgnoreInvalid takes and validates a given mail address list sets the Bcc: addresses of the Msg
// Any provided address that is not RFC5322 compliant, will be ignored
func (m *Msg) BccIgnoreInvalid(b ...string) {
m.SetAddrHeaderIgnoreInvalid(HeaderBcc, b...)
2022-03-09 16:52:23 +01:00
}
2022-03-13 19:36:24 +01:00
// ReplyTo takes and validates a given mail address and sets it as "Reply-To" addrHeader of the Msg
func (m *Msg) ReplyTo(r string) error {
rt, err := mail.ParseAddress(m.encodeString(r))
if err != nil {
return fmt.Errorf("failed to parse reply-to address: %w", err)
}
m.SetHeader(HeaderReplyTo, rt.String())
return nil
}
// ReplyToFormat takes a name and address, formats them RFC5322 compliant and stores them as
// the Reply-To header field
func (m *Msg) ReplyToFormat(n, a string) error {
return m.ReplyTo(fmt.Sprintf(`"%s" <%s>`, n, a))
}
2022-03-13 10:49:07 +01:00
// addAddr adds an additional address to the given addrHeader of the Msg
func (m *Msg) addAddr(h AddrHeader, a string) error {
var al []string
for _, ca := range m.addrHeader[h] {
al = append(al, ca.String())
}
al = append(al, a)
return m.SetAddrHeader(h, al...)
}
// Subject sets the "Subject" header field of the Msg
func (m *Msg) Subject(s string) {
m.SetHeader(HeaderSubject, s)
}
2022-03-09 16:52:23 +01:00
// SetMessageID generates a random message id for the mail
func (m *Msg) SetMessageID() {
hn, err := os.Hostname()
if err != nil {
hn = "localhost.localdomain"
}
ct := time.Now().Unix()
2022-03-09 16:52:23 +01:00
r := rand.New(rand.NewSource(ct))
rn := r.Int()
pid := os.Getpid()
mid := fmt.Sprintf("%d.%d.%d@%s", pid, rn, ct, hn)
m.SetMessageIDWithValue(mid)
}
// SetMessageIDWithValue sets the message id for the mail
func (m *Msg) SetMessageIDWithValue(v string) {
m.SetHeader(HeaderMessageID, fmt.Sprintf("<%s>", v))
2022-03-09 16:52:23 +01:00
}
2022-03-10 16:19:51 +01:00
// SetBulk sets the "Precedence: bulk" genHeader which is recommended for
2022-03-09 16:52:23 +01:00
// automated mails like OOO replies
// See: https://www.rfc-editor.org/rfc/rfc2076#section-3.9
func (m *Msg) SetBulk() {
m.SetHeader(HeaderPrecedence, "bulk")
}
2022-03-10 16:19:51 +01:00
// SetDate sets the Date genHeader field to the current time in a valid format
func (m *Msg) SetDate() {
ts := time.Now().Format(time.RFC1123Z)
m.SetHeader(HeaderDate, ts)
}
2022-03-13 19:24:46 +01:00
// SetImportance sets the Msg Importance/Priority header to given Importance
func (m *Msg) SetImportance(i Importance) {
if i == ImportanceNormal {
return
}
m.SetHeader(HeaderImportance, i.String())
m.SetHeader(HeaderPriority, i.NumString())
2022-03-13 19:28:40 +01:00
m.SetHeader(HeaderXPriority, i.XPrioString())
2022-03-13 19:24:46 +01:00
m.SetHeader(HeaderXMSMailPriority, i.NumString())
}
// GetSender returns the currently set FROM address. If f is true, it will return the full
// address string including the address name, if set
func (m *Msg) GetSender(ff bool) (string, error) {
f, ok := m.addrHeader[HeaderFrom]
if !ok || len(f) == 0 {
return "", ErrNoFromAddress
2022-03-11 16:57:14 +01:00
}
if ff {
return f[0].String(), nil
2022-03-11 16:57:14 +01:00
}
return f[0].Address, nil
}
// GetRecipients returns a list of the currently set TO/CC/BCC addresses.
func (m *Msg) GetRecipients() ([]string, error) {
var rl []string
for _, t := range []AddrHeader{HeaderTo, HeaderCc, HeaderBcc} {
al, ok := m.addrHeader[t]
if !ok || len(al) == 0 {
continue
}
for _, r := range al {
rl = append(rl, r.Address)
}
}
if len(rl) <= 0 {
return rl, ErrNoRcptAddresses
}
return rl, nil
}
// SetBodyString sets the body of the message.
func (m *Msg) SetBodyString(ct ContentType, b string, o ...PartOption) {
buf := bytes.NewBufferString(b)
w := func(w io.Writer) error {
_, err := io.Copy(w, buf)
return err
}
m.SetBodyWriter(ct, w, o...)
}
// SetBodyWriter sets the body of the message.
func (m *Msg) SetBodyWriter(ct ContentType, w func(io.Writer) error, o ...PartOption) {
2022-03-14 10:29:53 +01:00
p := m.newPart(ct, o...)
p.w = w
m.parts = []*Part{p}
}
// AddAlternativeString sets the alternative body of the message.
func (m *Msg) AddAlternativeString(ct ContentType, b string, o ...PartOption) {
buf := bytes.NewBufferString(b)
w := func(w io.Writer) error {
_, err := io.Copy(w, buf)
return err
}
m.AddAlternativeWriter(ct, w, o...)
}
// AddAlternativeWriter sets the body of the message.
func (m *Msg) AddAlternativeWriter(ct ContentType, w func(io.Writer) error, o ...PartOption) {
2022-03-14 10:29:53 +01:00
p := m.newPart(ct, o...)
p.w = w
m.parts = append(m.parts, p)
}
2022-03-14 10:29:53 +01:00
// AttachFile adds an attachment File to the Msg
func (m *Msg) AttachFile(n string, o ...FileOption) {
m.attachments = m.appendFile(m.attachments, fileFromFS(n), o...)
}
// AttachReader adds an attachment File via io.Reader to the Msg
func (m *Msg) AttachReader(n string, r io.Reader, o ...FileOption) {
m.attachments = m.appendFile(m.attachments, fileFromReader(n, r), o...)
}
// EmbedFile adds an embedded File to the Msg
func (m *Msg) EmbedFile(n string, o ...FileOption) {
m.embeds = m.appendFile(m.embeds, fileFromFS(n), o...)
}
// EmbedReader adds an embedded File from an io.Reader to the Msg
func (m *Msg) EmbedReader(n string, r io.Reader, o ...FileOption) {
m.embeds = m.appendFile(m.embeds, fileFromReader(n, r), o...)
}
// Write writes the formated Msg into a give io.Writer
func (m *Msg) Write(w io.Writer) (int64, error) {
mw := &msgWriter{w: w}
mw.writeMsg(m)
return mw.n, mw.err
2022-03-09 16:52:23 +01:00
}
2022-03-14 10:29:53 +01:00
// appendFile adds a File to the Msg (as attachment or embed)
func (m *Msg) appendFile(c []*File, f *File, o ...FileOption) []*File {
// Override defaults with optionally provided FileOption functions
for _, co := range o {
if co == nil {
continue
}
co(f)
}
if c == nil {
return []*File{f}
}
return append(c, f)
}
// encodeString encodes a string based on the configured message encoder and the corresponding
// charset for the Msg
func (m *Msg) encodeString(s string) string {
return m.encoder.Encode(string(m.charset), s)
}
// hasAlt returns true if the Msg has more than one part
func (m *Msg) hasAlt() bool {
return len(m.parts) > 1
}
// hasMixed returns true if the Msg has mixed parts
func (m *Msg) hasMixed() bool {
return (len(m.parts) > 0 && len(m.attachments) > 0) || len(m.attachments) > 1
}
// hasRelated returns true if the Msg has related parts
func (m *Msg) hasRelated() bool {
return (len(m.parts) > 0 && len(m.embeds) > 0) || len(m.embeds) > 1
}
// newPart returns a new Part for the Msg
func (m *Msg) newPart(ct ContentType, o ...PartOption) *Part {
p := &Part{
ctype: ct,
enc: m.encoding,
}
// Override defaults with optionally provided MsgOption functions
for _, co := range o {
if co == nil {
continue
}
co(p)
}
return p
}
2022-03-14 10:29:53 +01:00
// setEncoder creates a new mime.WordEncoder based on the encoding setting of the message
func (m *Msg) setEncoder() {
m.encoder = getEncoder(m.encoding)
}
2022-03-14 10:29:53 +01:00
// fileFromFS returns a File pointer from a given file in the system's file system
func fileFromFS(n string) *File {
return &File{
Name: filepath.Base(n),
Header: make(map[string][]string),
Writer: func(w io.Writer) error {
h, err := os.Open(n)
if err != nil {
return err
}
if _, err := io.Copy(w, h); err != nil {
_ = h.Close()
return fmt.Errorf("failed to copy file to io.Writer: %w", err)
}
return h.Close()
},
}
}
2022-03-14 10:29:53 +01:00
// fileFromReader returns a File pointer from a given io.Reader
func fileFromReader(n string, r io.Reader) *File {
return &File{
Name: filepath.Base(n),
Header: make(map[string][]string),
Writer: func(w io.Writer) error {
if _, err := io.Copy(w, r); err != nil {
return err
}
return nil
},
}
}
// getEncoder creates a new mime.WordEncoder based on the encoding setting of the message
func getEncoder(e Encoding) mime.WordEncoder {
switch e {
case EncodingQP:
return mime.QEncoding
case EncodingB64:
return mime.BEncoding
default:
return mime.QEncoding
}
}