eml.go

package main

import (
	"bytes"
	"encoding/base64"
	"io"
	"mime"
	"mime/multipart"
	"mime/quotedprintable"
	"net/mail"
	"net/textproto"
	"strings"
)

// parseEML parses an RFC-822/MIME message (.eml) into a Message.
func parseEML(data []byte) (*Message, error) {
	msg, err := mail.ReadMessage(bytes.NewReader(data))
	if err != nil {
		return nil, err
	}

	dec := &mime.WordDecoder{CharsetReader: charsetReader}
	m := &Message{}

	m.Subject = decodeHeaderValue(dec, msg.Header.Get("Subject"))
	m.From = strings.Join(parseAddrs(dec, msg.Header.Get("From")), "; ")
	m.To = parseAddrs(dec, msg.Header.Get("To"))
	m.Cc = parseAddrs(dec, msg.Header.Get("Cc"))

	if t, err := mail.ParseDate(msg.Header.Get("Date")); err == nil {
		m.Date, m.HasDate = t, true
	}

	walkMIME(textproto.MIMEHeader(msg.Header), msg.Body, m, 0)
	return m, nil
}

// walkMIME recursively descends a MIME tree, filling body text/html and
// collecting attachments.
func walkMIME(header textproto.MIMEHeader, body io.Reader, m *Message, depth int) {
	if depth > 25 {
		return
	}
	mediaType, params, err := mime.ParseMediaType(header.Get("Content-Type"))
	if err != nil {
		mediaType, params = "text/plain", map[string]string{}
	}

	if strings.HasPrefix(mediaType, "multipart/") {
		boundary := params["boundary"]
		if boundary == "" {
			return
		}
		mr := multipart.NewReader(body, boundary)
		for {
			part, err := mr.NextPart()
			if err != nil {
				break
			}
			walkMIME(part.Header, part, m, depth+1)
			part.Close()
		}
		return
	}

	raw, _ := io.ReadAll(decodeTransfer(header.Get("Content-Transfer-Encoding"), body))

	dispType, dispParams, _ := mime.ParseMediaType(header.Get("Content-Disposition"))
	filename := dispParams["filename"]
	if filename == "" {
		filename = params["name"]
	}

	isText := strings.HasPrefix(mediaType, "text/")
	if strings.EqualFold(dispType, "attachment") || (filename != "" && !isText) {
		name := decodeHeaderValue(&mime.WordDecoder{CharsetReader: charsetReader}, filename)
		if name == "" {
			name = "anhang"
		}
		m.Attachments = append(m.Attachments, Attachment{Name: name, Data: raw})
		return
	}

	charset := params["charset"]
	switch {
	case strings.EqualFold(mediaType, "text/html"):
		if m.HTML == "" {
			m.HTML = decodeCharset(raw, charset)
		}
	case isText:
		if m.Text == "" {
			m.Text = decodeCharset(raw, charset)
		}
	}
}

// decodeTransfer wraps r to undo the Content-Transfer-Encoding.
func decodeTransfer(enc string, r io.Reader) io.Reader {
	switch strings.ToLower(strings.TrimSpace(enc)) {
	case "base64":
		// The std base64 decoder already ignores embedded CR/LF.
		return base64.NewDecoder(base64.StdEncoding, r)
	case "quoted-printable":
		return quotedprintable.NewReader(r)
	default:
		return r
	}
}

// decodeHeaderValue RFC-2047-decodes an encoded-word header value.
func decodeHeaderValue(dec *mime.WordDecoder, s string) string {
	if out, err := dec.DecodeHeader(s); err == nil {
		return out
	}
	return s
}

// parseAddrs parses an address-list header into "Name <addr>" strings.
func parseAddrs(dec *mime.WordDecoder, s string) []string {
	s = strings.TrimSpace(s)
	if s == "" {
		return nil
	}
	parser := mail.AddressParser{WordDecoder: dec}
	list, err := parser.ParseList(s)
	if err != nil {
		return []string{decodeHeaderValue(dec, s)}
	}
	out := make([]string, 0, len(list))
	for _, a := range list {
		if a.Name != "" {
			out = append(out, a.Name+" <"+a.Address+">")
		} else {
			out = append(out, a.Address)
		}
	}
	return out
}