1b8b6e218c
Add the initial implementation of a backend for Maildir accounts. Much of the functionality required is implemented in the go-message and go-maildir libraries, so we use them as much as possible. The maildir worker hooks into a new maildir:// URL scheme in the accounts.conf file which points to a container of several maildir directories. From there, the OpenDirectory, FetchDirectoryContents, etc messages work on subdirectories. This is implemented as a Container struct which handles mapping between the symbolic email folder names and UIDs to the concrete directories and file names.
322 lines
8.2 KiB
Go
322 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
|
|
}
|