aerc/worker/maildir/message.go

323 lines
8.2 KiB
Go

package maildir
import (
"bytes"
"encoding/base64"
"fmt"
"io"
"io/ioutil"
"mime/quotedprintable"
gomail "net/mail"
"strings"
"github.com/emersion/go-maildir"
"github.com/emersion/go-message"
_ "github.com/emersion/go-message/charset"
"github.com/emersion/go-message/mail"
"git.sr.ht/~sircmpwn/aerc/models"
)
// A Message is an individual email inside of a maildir.Dir.
type Message struct {
dir maildir.Dir
uid uint32
key string
}
// NewReader reads a message into memory and returns an io.Reader for it.
func (m Message) NewReader() (io.Reader, error) {
f, err := m.dir.Open(m.key)
if err != nil {
return nil, err
}
defer f.Close()
b, err := ioutil.ReadAll(f)
if err != nil {
return nil, err
}
return bytes.NewReader(b), nil
}
// Flags fetches the set of flags currently applied to the message.
func (m Message) Flags() ([]maildir.Flag, error) {
return m.dir.Flags(m.key)
}
// SetFlags replaces the message's flags with a new set.
func (m Message) SetFlags(flags []maildir.Flag) error {
return m.dir.SetFlags(m.key, flags)
}
// MarkRead either adds or removes the maildir.FlagSeen flag from the message.
func (m Message) MarkRead(seen bool) error {
flags, err := m.Flags()
if err != nil {
return fmt.Errorf("could not read previous flags: %v", err)
}
if seen {
flags = append(flags, maildir.FlagSeen)
return m.SetFlags(flags)
}
var newFlags []maildir.Flag
for _, flag := range flags {
if flag != maildir.FlagSeen {
newFlags = append(newFlags, flag)
}
}
return m.SetFlags(newFlags)
}
// Remove deletes the email immediately.
func (m Message) Remove() error {
return m.dir.Remove(m.key)
}
// MessageInfo populates a models.MessageInfo struct for the message.
func (m Message) MessageInfo() (*models.MessageInfo, error) {
f, err := m.dir.Open(m.key)
if err != nil {
return nil, err
}
defer f.Close()
msg, err := message.Read(f)
if err != nil {
return nil, fmt.Errorf("could not read message: %v", err)
}
bs, err := parseEntityStructure(msg)
if err != nil {
return nil, fmt.Errorf("could not get structure: %v", err)
}
env, err := parseEnvelope(&msg.Header)
if err != nil {
return nil, fmt.Errorf("could not get envelope: %v", err)
}
flags, err := m.Flags()
if err != nil {
return nil, fmt.Errorf("could not read flags: %v", err)
}
return &models.MessageInfo{
BodyStructure: bs,
Envelope: env,
Flags: translateFlags(flags),
InternalDate: env.Date,
RFC822Headers: &mail.Header{msg.Header},
Size: 0,
Uid: m.uid,
}, nil
}
// NewBodyPartReader creates a new io.Reader for the requested body part(s) of
// the message.
func (m Message) NewBodyPartReader(requestedParts []int) (io.Reader, error) {
f, err := m.dir.Open(m.key)
if err != nil {
return nil, err
}
defer f.Close()
msg, err := message.Read(f)
if err != nil {
return nil, fmt.Errorf("could not read message: %v", err)
}
return fetchEntityPartReader(msg, requestedParts)
}
func fetchEntityPartReader(e *message.Entity, index []int) (io.Reader, error) {
if len(index) < 1 {
return nil, fmt.Errorf("no part to read")
}
if mpr := e.MultipartReader(); mpr != nil {
idx := 0
for {
idx++
part, err := mpr.NextPart()
if err != nil {
return nil, err
}
if idx == index[0] {
rest := index[1:]
if len(rest) < 1 {
return fetchEntityReader(part)
}
return fetchEntityPartReader(part, index[1:])
}
}
}
if index[0] != 1 {
return nil, fmt.Errorf("cannont return non-first part of non-multipart")
}
return fetchEntityReader(e)
}
// fetchEntityReader makes an io.Reader for the given entity. Since the
// go-message package decodes the body for us, and the UI expects to deal with
// a reader whose bytes are encoded with the part's encoding, we are in the
// interesting position of needing to re-encode the reader before sending it
// off to the UI layer.
//
// TODO: probably change the UI to expect an already-decoded reader and decode
// in the IMAP worker.
func fetchEntityReader(e *message.Entity) (io.Reader, error) {
enc := e.Header.Get("content-transfer-encoding")
var buf bytes.Buffer
// base64
if strings.EqualFold(enc, "base64") {
wc := base64.NewEncoder(base64.StdEncoding, &buf)
defer wc.Close()
if _, err := io.Copy(wc, e.Body); err != nil {
return nil, fmt.Errorf("could not base64 encode: %v", err)
}
return &buf, nil
}
// quoted-printable
if strings.EqualFold(enc, "quoted-printable") {
wc := quotedprintable.NewWriter(&buf)
defer wc.Close()
if _, err := io.Copy(wc, e.Body); err != nil {
return nil, fmt.Errorf("could not quoted-printable encode: %v", err)
}
return &buf, nil
}
// other general encoding
if _, err := io.Copy(&buf, e.Body); err != nil {
return nil, err
}
return &buf, nil
}
// split a MIME type into its major and minor parts
func splitMIME(m string) (string, string) {
parts := strings.Split(m, "/")
if len(parts) != 2 {
return parts[0], ""
}
return parts[0], parts[1]
}
func parseEntityStructure(e *message.Entity) (*models.BodyStructure, error) {
var body models.BodyStructure
contentType, ctParams, err := e.Header.ContentType()
if err != nil {
return nil, fmt.Errorf("could not parse content type: %v", err)
}
mimeType, mimeSubType := splitMIME(contentType)
body.MIMEType = mimeType
body.MIMESubType = mimeSubType
body.Params = ctParams
body.Description = e.Header.Get("content-description")
body.Encoding = e.Header.Get("content-transfer-encoding")
if cd := e.Header.Get("content-disposition"); cd != "" {
contentDisposition, cdParams, err := e.Header.ContentDisposition()
if err != nil {
return nil, fmt.Errorf("could not parse content disposition: %v", err)
}
body.Disposition = contentDisposition
body.DispositionParams = cdParams
}
body.Parts = []*models.BodyStructure{}
if mpr := e.MultipartReader(); mpr != nil {
for {
part, err := mpr.NextPart()
if err == io.EOF {
return &body, nil
} else if err != nil {
return nil, err
}
ps, err := parseEntityStructure(part)
if err != nil {
return nil, fmt.Errorf("could not parse child entity structure: %v", err)
}
body.Parts = append(body.Parts, ps)
}
}
return &body, nil
}
func parseEnvelope(h *message.Header) (*models.Envelope, error) {
date, err := gomail.ParseDate(h.Get("date"))
if err != nil {
return nil, fmt.Errorf("could not parse date header: %v", err)
}
from, err := parseAddressList(h, "from")
if err != nil {
return nil, fmt.Errorf("could not read from address: %v", err)
}
to, err := parseAddressList(h, "to")
if err != nil {
return nil, fmt.Errorf("could not read to address: %v", err)
}
cc, err := parseAddressList(h, "cc")
if err != nil {
return nil, fmt.Errorf("could not read cc address: %v", err)
}
bcc, err := parseAddressList(h, "bcc")
if err != nil {
return nil, fmt.Errorf("could not read bcc address: %v", err)
}
return &models.Envelope{
Date: date,
Subject: h.Get("subject"),
MessageId: h.Get("message-id"),
From: from,
To: to,
Cc: cc,
Bcc: bcc,
}, nil
}
func parseAddressList(h *message.Header, key string) ([]*models.Address, error) {
var converted []*models.Address
hdr := h.Get(key)
if strings.TrimSpace(hdr) == "" {
return converted, nil
}
addrs, err := gomail.ParseAddressList(hdr)
if err != nil {
if strings.Index(hdr, "@") < 0 {
return []*models.Address{&models.Address{
Name: hdr,
}}, nil
}
return nil, err
}
for _, addr := range addrs {
parts := strings.Split(addr.Address, "@")
var mbox, host string
if len(parts) > 1 {
mbox = strings.Join(parts[0:len(parts)-1], "@")
host = parts[len(parts)-1]
} else {
mbox = addr.Address
}
converted = append(converted, &models.Address{
Name: addr.Name,
Mailbox: mbox,
Host: host,
})
}
return converted, nil
}
var flagMap = map[maildir.Flag]models.Flag{
maildir.FlagReplied: models.AnsweredFlag,
maildir.FlagSeen: models.SeenFlag,
maildir.FlagTrashed: models.DeletedFlag,
maildir.FlagFlagged: models.FlaggedFlag,
// maildir.FlagDraft Flag = 'D'
// maildir.FlagPassed Flag = 'P'
}
func translateFlags(maildirFlags []maildir.Flag) []models.Flag {
var flags []models.Flag
for _, maildirFlag := range maildirFlags {
if flag, ok := flagMap[maildirFlag]; ok {
flags = append(flags, flag)
}
}
return flags
}