Replace hand-rolled IMAP with go-imap
This commit is contained in:
DonVoo
parent
21aa6e39e1
commit
253435d87f
7 changed files with 449 additions and 346 deletions
|
|
@ -1,72 +1,64 @@
|
|||
package backend
|
||||
|
||||
import (
|
||||
"bufio"
|
||||
"crypto/sha256"
|
||||
"crypto/tls"
|
||||
"errors"
|
||||
"fmt"
|
||||
"io"
|
||||
"net"
|
||||
"net/mail"
|
||||
"strconv"
|
||||
"strings"
|
||||
"time"
|
||||
|
||||
"github.com/emersion/go-imap/v2"
|
||||
"github.com/emersion/go-imap/v2/imapclient"
|
||||
)
|
||||
|
||||
// RawMessage ist eine 1:1 aus der Quelle geholte Nachricht: der Rohkoerper
|
||||
// plus die Metadaten, die den sauberen Umzug ausmachen.
|
||||
type RawMessage struct {
|
||||
MessageID string // aus Header, Schluessel fuer Idempotenz
|
||||
MessageID string // aus Envelope/Header, Schluessel fuer Idempotenz
|
||||
Body []byte // kompletter RFC822-Rohtext, wird NICHT umgeschrieben
|
||||
Flags []string // \Seen \Answered \Flagged ... 1:1 uebernehmen
|
||||
InternalDate time.Time // Original-Zeit, per APPEND erhalten
|
||||
}
|
||||
|
||||
// Folder ist ein Ordner der Quelle MIT den Infos, die 11-folders.go fuer die
|
||||
// Rollen-Zuordnung braucht: dekodierter Name (Umlaute als Klartext, NICHT
|
||||
// modified-UTF-7), SPECIAL-USE-Attribute und der Hierarchie-Trenner.
|
||||
// Rollen-Zuordnung braucht: dekodierter Name, SPECIAL-USE-Attribute und der
|
||||
// Hierarchie-Trenner.
|
||||
type Folder struct {
|
||||
Name string // dekodiert, z.B. "Gelöschte Objekte" oder "INBOX.Sent"
|
||||
Name string // dekodiert, z.B. "Geloeschte Objekte" oder "INBOX.Sent"
|
||||
Attrs []string // z.B. ["\\Sent"] aus SPECIAL-USE
|
||||
Delim string // "." oder "/" — servereigener Trenner
|
||||
Delim string // "." oder "/" - servereigener Trenner
|
||||
}
|
||||
|
||||
// SourceMailbox abstrahiert Quelle (IMAP primaer, POP3 Fallback), damit
|
||||
// 07-migrate.go gegen ein Interface arbeitet.
|
||||
type SourceMailbox interface {
|
||||
Folders() ([]Folder, error) // rekursiver Ordnerbaum
|
||||
Fetch(folder string) ([]RawMessage, error) // Stream: BODY[] FLAGS INTERNALDATE
|
||||
Fetch(folder string) ([]RawMessage, error) // BODY[] FLAGS INTERNALDATE
|
||||
Close() error
|
||||
}
|
||||
|
||||
// OpenIMAPSource verbindet die Quelle per go-imap/v2.
|
||||
//
|
||||
// Verschluesselung nach a.SrcSecurity:
|
||||
// - "tls": imapclient.DialTLS (impliziter TLS, Port 993)
|
||||
// - "starttls": imapclient.DialStartTLS auf Klartext-Port 143
|
||||
// - "none": imapclient.Dial (REINER KLARTEXT, alte Provider!)
|
||||
//
|
||||
// a.SrcInsecure -> tls.Config{InsecureSkipVerify:true} fuer kaputte/selbst-
|
||||
// signierte Zerts. go-imap dekodiert modified-UTF-7-Ordnernamen selbst; wir
|
||||
// geben in Folder.Name den Klartext weiter.
|
||||
func OpenIMAPSource(a Account) (SourceMailbox, error) {
|
||||
c, err := dialIMAP(a.SrcHost, a.SrcPort, a.SrcSecurity, a.SrcInsecure)
|
||||
c, err := dialIMAPClient(a.SrcHost, a.SrcPort, a.SrcSecurity, a.SrcInsecure)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
if err := c.login(a.SrcUser, a.SrcPass); err != nil {
|
||||
if err := c.Login(a.SrcUser, a.SrcPass).Wait(); err != nil {
|
||||
_ = c.Close()
|
||||
return nil, err
|
||||
}
|
||||
return &imapSource{c: c}, nil
|
||||
return &imapSource{mailbox: &imapClientMailbox{c: c}}, nil
|
||||
}
|
||||
|
||||
type imapSource struct {
|
||||
c *simpleIMAP
|
||||
mailbox *imapClientMailbox
|
||||
}
|
||||
|
||||
func (s *imapSource) Folders() ([]Folder, error) {
|
||||
boxes, err := s.c.listMailboxes()
|
||||
boxes, err := s.mailbox.listMailboxes()
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
|
@ -84,132 +76,15 @@ func (s *imapSource) Folders() ([]Folder, error) {
|
|||
}
|
||||
|
||||
func (s *imapSource) Fetch(folder string) ([]RawMessage, error) {
|
||||
if err := s.c.selectMailbox(folder); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
return s.c.fetchAll()
|
||||
return s.mailbox.fetchAll(folder)
|
||||
}
|
||||
|
||||
func (s *imapSource) Close() error {
|
||||
return s.c.Close()
|
||||
return s.mailbox.Close()
|
||||
}
|
||||
|
||||
type simpleIMAP struct {
|
||||
conn net.Conn
|
||||
r *bufio.Reader
|
||||
w *bufio.Writer
|
||||
tag int
|
||||
}
|
||||
|
||||
func dialIMAP(host string, port int, security string, insecure bool) (*simpleIMAP, error) {
|
||||
addr := net.JoinHostPort(host, strconv.Itoa(port))
|
||||
tlsCfg := &tls.Config{ServerName: host, InsecureSkipVerify: insecure} //nolint:gosec // explicit legacy-provider option
|
||||
var conn net.Conn
|
||||
var err error
|
||||
if security == "tls" {
|
||||
conn, err = tls.Dial("tcp", addr, tlsCfg)
|
||||
} else {
|
||||
conn, err = net.DialTimeout("tcp", addr, 30*time.Second)
|
||||
}
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
c := &simpleIMAP{conn: conn, r: bufio.NewReader(conn), w: bufio.NewWriter(conn)}
|
||||
if _, err := c.r.ReadString('\n'); err != nil {
|
||||
_ = conn.Close()
|
||||
return nil, err
|
||||
}
|
||||
if security == "starttls" {
|
||||
if err := c.simple("STARTTLS"); err != nil {
|
||||
_ = conn.Close()
|
||||
return nil, err
|
||||
}
|
||||
tlsConn := tls.Client(conn, tlsCfg)
|
||||
if err := tlsConn.Handshake(); err != nil {
|
||||
_ = conn.Close()
|
||||
return nil, err
|
||||
}
|
||||
c.conn = tlsConn
|
||||
c.r = bufio.NewReader(tlsConn)
|
||||
c.w = bufio.NewWriter(tlsConn)
|
||||
}
|
||||
return c, nil
|
||||
}
|
||||
|
||||
func (c *simpleIMAP) login(user, pass string) error {
|
||||
return c.simpleLabel("LOGIN "+imapQuote(user)+" "+imapQuote(pass), "LOGIN "+imapQuote(user)+" <redacted>")
|
||||
}
|
||||
|
||||
func (c *simpleIMAP) selectMailbox(name string) error {
|
||||
return c.simple("SELECT " + imapQuote(name))
|
||||
}
|
||||
|
||||
func (c *simpleIMAP) simple(cmd string) error {
|
||||
return c.simpleLabel(cmd, cmd)
|
||||
}
|
||||
|
||||
func (c *simpleIMAP) simpleLabel(cmd, label string) error {
|
||||
tag := c.nextTag()
|
||||
if _, err := fmt.Fprintf(c.w, "%s %s\r\n", tag, cmd); err != nil {
|
||||
return err
|
||||
}
|
||||
if err := c.w.Flush(); err != nil {
|
||||
return err
|
||||
}
|
||||
for {
|
||||
line, err := c.r.ReadString('\n')
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
if strings.HasPrefix(line, tag+" ") {
|
||||
if strings.Contains(line, " OK") {
|
||||
return nil
|
||||
}
|
||||
return fmt.Errorf("imap %s failed: %s", label, strings.TrimSpace(line))
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func (c *simpleIMAP) fetchAll() ([]RawMessage, error) {
|
||||
tag := c.nextTag()
|
||||
if _, err := fmt.Fprintf(c.w, "%s UID FETCH 1:* (UID FLAGS INTERNALDATE BODY.PEEK[])\r\n", tag); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
if err := c.w.Flush(); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
var out []RawMessage
|
||||
for {
|
||||
line, err := c.r.ReadString('\n')
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
if strings.HasPrefix(line, tag+" ") {
|
||||
if strings.Contains(line, " OK") {
|
||||
return out, nil
|
||||
}
|
||||
return out, fmt.Errorf("imap fetch failed: %s", strings.TrimSpace(line))
|
||||
}
|
||||
if !strings.HasPrefix(line, "* ") || !strings.Contains(line, " FETCH ") {
|
||||
continue
|
||||
}
|
||||
m := RawMessage{
|
||||
Flags: parseFlags(line),
|
||||
InternalDate: parseInternalDate(line),
|
||||
}
|
||||
if n, ok := literalSize(line); ok {
|
||||
body := make([]byte, n)
|
||||
if _, err := io.ReadFull(c.r, body); err != nil {
|
||||
return out, err
|
||||
}
|
||||
m.Body = body
|
||||
m.MessageID = messageID(body)
|
||||
if rest, err := c.r.ReadString('\n'); err == nil {
|
||||
_ = rest
|
||||
}
|
||||
out = append(out, m)
|
||||
}
|
||||
}
|
||||
type imapClientMailbox struct {
|
||||
c *imapclient.Client
|
||||
}
|
||||
|
||||
type imapListMailbox struct {
|
||||
|
|
@ -218,93 +93,100 @@ type imapListMailbox struct {
|
|||
Delim string
|
||||
}
|
||||
|
||||
func (c *simpleIMAP) listMailboxes() ([]imapListMailbox, error) {
|
||||
tag := c.nextTag()
|
||||
if _, err := fmt.Fprintf(c.w, "%s LIST \"\" \"*\"\r\n", tag); err != nil {
|
||||
return nil, err
|
||||
func dialIMAPClient(host string, port int, security string, insecure bool) (*imapclient.Client, error) {
|
||||
addr := net.JoinHostPort(host, strconv.Itoa(port))
|
||||
opts := &imapclient.Options{
|
||||
TLSConfig: &tls.Config{
|
||||
ServerName: host,
|
||||
MinVersion: tls.VersionTLS12,
|
||||
InsecureSkipVerify: insecure, //nolint:gosec // explicit legacy-provider option
|
||||
},
|
||||
}
|
||||
if err := c.w.Flush(); err != nil {
|
||||
return nil, err
|
||||
switch strings.ToLower(strings.TrimSpace(security)) {
|
||||
case "tls", "":
|
||||
return imapclient.DialTLS(addr, opts)
|
||||
case "starttls":
|
||||
return imapclient.DialStartTLS(addr, opts)
|
||||
case "none":
|
||||
return imapclient.DialInsecure(addr, opts)
|
||||
default:
|
||||
return nil, fmt.Errorf("unbekannter IMAP-Security-Modus %q", security)
|
||||
}
|
||||
}
|
||||
|
||||
func (m *imapClientMailbox) listMailboxes() ([]imapListMailbox, error) {
|
||||
cmd := m.c.List("", "*", &imap.ListOptions{ReturnSpecialUse: true})
|
||||
defer cmd.Close()
|
||||
|
||||
var out []imapListMailbox
|
||||
for {
|
||||
line, err := c.r.ReadString('\n')
|
||||
data := cmd.Next()
|
||||
if data == nil {
|
||||
break
|
||||
}
|
||||
out = append(out, imapListMailbox{
|
||||
Name: data.Mailbox,
|
||||
Attrs: mailboxAttrsToStrings(data.Attrs),
|
||||
Delim: delimString(data.Delim),
|
||||
})
|
||||
}
|
||||
if err := cmd.Close(); err != nil {
|
||||
return out, err
|
||||
}
|
||||
return out, nil
|
||||
}
|
||||
|
||||
func (m *imapClientMailbox) fetchAll(folder string) ([]RawMessage, error) {
|
||||
if _, err := m.c.Select(folder, &imap.SelectOptions{ReadOnly: true}).Wait(); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
section := &imap.FetchItemBodySection{Peek: true}
|
||||
seqSet := imap.SeqSet{}
|
||||
seqSet.AddRange(1, 0)
|
||||
cmd := m.c.Fetch(seqSet, &imap.FetchOptions{
|
||||
Envelope: true,
|
||||
Flags: true,
|
||||
InternalDate: true,
|
||||
BodySection: []*imap.FetchItemBodySection{section},
|
||||
})
|
||||
defer cmd.Close()
|
||||
|
||||
var out []RawMessage
|
||||
for {
|
||||
data := cmd.Next()
|
||||
if data == nil {
|
||||
break
|
||||
}
|
||||
buf, err := data.Collect()
|
||||
if err != nil {
|
||||
return nil, err
|
||||
return out, err
|
||||
}
|
||||
if strings.HasPrefix(line, tag+" ") {
|
||||
if strings.Contains(line, " OK") {
|
||||
return out, nil
|
||||
}
|
||||
return out, fmt.Errorf("imap list failed: %s", strings.TrimSpace(line))
|
||||
}
|
||||
if !strings.HasPrefix(line, "* LIST ") {
|
||||
continue
|
||||
}
|
||||
if box, ok := parseListMailbox(strings.TrimSpace(line)); ok {
|
||||
out = append(out, box)
|
||||
body := buf.FindBodySection(section)
|
||||
if body == nil {
|
||||
body = []byte{}
|
||||
}
|
||||
out = append(out, RawMessage{
|
||||
MessageID: messageIDFromFetch(buf, body),
|
||||
Body: body,
|
||||
Flags: flagsToStrings(sanitizeIMAPFlags(buf.Flags)),
|
||||
InternalDate: buf.InternalDate,
|
||||
})
|
||||
}
|
||||
if err := cmd.Close(); err != nil {
|
||||
return out, err
|
||||
}
|
||||
return out, nil
|
||||
}
|
||||
|
||||
func parseListMailbox(line string) (imapListMailbox, bool) {
|
||||
rest := strings.TrimSpace(strings.TrimPrefix(line, "* LIST "))
|
||||
if !strings.HasPrefix(rest, "(") {
|
||||
return imapListMailbox{}, false
|
||||
func (m *imapClientMailbox) Close() error {
|
||||
if m == nil || m.c == nil {
|
||||
return nil
|
||||
}
|
||||
endAttrs := strings.Index(rest, ")")
|
||||
if endAttrs < 0 {
|
||||
return imapListMailbox{}, false
|
||||
if err := m.c.Logout().Wait(); err != nil {
|
||||
return m.c.Close()
|
||||
}
|
||||
attrs := strings.Fields(rest[1:endAttrs])
|
||||
rest = strings.TrimSpace(rest[endAttrs+1:])
|
||||
delim, next, ok := parseIMAPAtomOrQuoted(rest)
|
||||
if !ok {
|
||||
return imapListMailbox{}, false
|
||||
}
|
||||
if strings.EqualFold(delim, "NIL") {
|
||||
delim = "/"
|
||||
}
|
||||
rest = strings.TrimSpace(rest[next:])
|
||||
name, _, ok := parseIMAPAtomOrQuoted(rest)
|
||||
if !ok || name == "" {
|
||||
return imapListMailbox{}, false
|
||||
}
|
||||
return imapListMailbox{Name: name, Attrs: attrs, Delim: delim}, true
|
||||
}
|
||||
|
||||
func parseIMAPAtomOrQuoted(s string) (string, int, bool) {
|
||||
s = strings.TrimLeft(s, " \t")
|
||||
trimmed := len(s)
|
||||
if s == "" {
|
||||
return "", 0, false
|
||||
}
|
||||
if s[0] != '"' {
|
||||
end := strings.IndexAny(s, " \t\r\n")
|
||||
if end < 0 {
|
||||
end = len(s)
|
||||
}
|
||||
return s[:end], trimmed - len(s) + end, true
|
||||
}
|
||||
var b strings.Builder
|
||||
escaped := false
|
||||
for i := 1; i < len(s); i++ {
|
||||
ch := s[i]
|
||||
if escaped {
|
||||
b.WriteByte(ch)
|
||||
escaped = false
|
||||
continue
|
||||
}
|
||||
if ch == '\\' {
|
||||
escaped = true
|
||||
continue
|
||||
}
|
||||
if ch == '"' {
|
||||
return b.String(), trimmed - len(s) + i + 1, true
|
||||
}
|
||||
b.WriteByte(ch)
|
||||
}
|
||||
return "", 0, false
|
||||
return m.c.Close()
|
||||
}
|
||||
|
||||
func hasIMAPAttr(attrs []string, want string) bool {
|
||||
|
|
@ -316,111 +198,60 @@ func hasIMAPAttr(attrs []string, want string) bool {
|
|||
return false
|
||||
}
|
||||
|
||||
func (c *simpleIMAP) appendMessage(folder string, m RawMessage) error {
|
||||
tag := c.nextTag()
|
||||
flags := ""
|
||||
if len(m.Flags) > 0 {
|
||||
flags = " (" + strings.Join(m.Flags, " ") + ")"
|
||||
func mailboxAttrsToStrings(attrs []imap.MailboxAttr) []string {
|
||||
out := make([]string, 0, len(attrs))
|
||||
for _, attr := range attrs {
|
||||
out = append(out, string(attr))
|
||||
}
|
||||
date := ""
|
||||
if !m.InternalDate.IsZero() {
|
||||
date = " " + imapQuote(m.InternalDate.Format("02-Jan-2006 15:04:05 -0700"))
|
||||
return out
|
||||
}
|
||||
|
||||
func delimString(delim rune) string {
|
||||
if delim == 0 {
|
||||
return "/"
|
||||
}
|
||||
if _, err := fmt.Fprintf(c.w, "%s APPEND %s%s%s {%d}\r\n", tag, imapQuote(folder), flags, date, len(m.Body)); err != nil {
|
||||
return err
|
||||
}
|
||||
if err := c.w.Flush(); err != nil {
|
||||
return err
|
||||
}
|
||||
line, err := c.r.ReadString('\n')
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
if !strings.HasPrefix(line, "+") {
|
||||
return fmt.Errorf("imap append literal rejected: %s", strings.TrimSpace(line))
|
||||
}
|
||||
if _, err := c.w.Write(m.Body); err != nil {
|
||||
return err
|
||||
}
|
||||
if _, err := c.w.WriteString("\r\n"); err != nil {
|
||||
return err
|
||||
}
|
||||
if err := c.w.Flush(); err != nil {
|
||||
return err
|
||||
}
|
||||
for {
|
||||
line, err := c.r.ReadString('\n')
|
||||
if err != nil {
|
||||
return err
|
||||
return string(delim)
|
||||
}
|
||||
|
||||
func sanitizeIMAPFlags(in []imap.Flag) []imap.Flag {
|
||||
out := make([]imap.Flag, 0, len(in))
|
||||
for _, flag := range in {
|
||||
switch strings.ToLower(string(flag)) {
|
||||
case `\recent`, `\*`:
|
||||
continue
|
||||
default:
|
||||
out = append(out, flag)
|
||||
}
|
||||
if strings.HasPrefix(line, tag+" ") {
|
||||
if strings.Contains(line, " OK") {
|
||||
return nil
|
||||
}
|
||||
return out
|
||||
}
|
||||
|
||||
func flagsToStrings(flags []imap.Flag) []string {
|
||||
out := make([]string, 0, len(flags))
|
||||
for _, flag := range flags {
|
||||
out = append(out, string(flag))
|
||||
}
|
||||
return out
|
||||
}
|
||||
|
||||
func stringsToFlags(flags []string) []imap.Flag {
|
||||
return sanitizeIMAPFlags(func() []imap.Flag {
|
||||
out := make([]imap.Flag, 0, len(flags))
|
||||
for _, flag := range flags {
|
||||
flag = strings.TrimSpace(flag)
|
||||
if flag != "" {
|
||||
out = append(out, imap.Flag(flag))
|
||||
}
|
||||
return fmt.Errorf("imap append failed: %s", strings.TrimSpace(line))
|
||||
}
|
||||
}
|
||||
return out
|
||||
}())
|
||||
}
|
||||
|
||||
func (c *simpleIMAP) nextTag() string {
|
||||
c.tag++
|
||||
return fmt.Sprintf("A%04d", c.tag)
|
||||
}
|
||||
|
||||
func (c *simpleIMAP) Close() error {
|
||||
_ = c.simple("LOGOUT")
|
||||
return c.conn.Close()
|
||||
}
|
||||
|
||||
func imapQuote(s string) string {
|
||||
s = strings.ReplaceAll(s, `\`, `\\`)
|
||||
s = strings.ReplaceAll(s, `"`, `\"`)
|
||||
return `"` + s + `"`
|
||||
}
|
||||
|
||||
func literalSize(line string) (int, bool) {
|
||||
end := strings.LastIndex(line, "}")
|
||||
start := strings.LastIndex(line[:end+1], "{")
|
||||
if start < 0 || end < 0 || end <= start+1 {
|
||||
return 0, false
|
||||
func messageIDFromFetch(buf *imapclient.FetchMessageBuffer, body []byte) string {
|
||||
if buf != nil && buf.Envelope != nil && strings.TrimSpace(buf.Envelope.MessageID) != "" {
|
||||
return strings.TrimSpace(buf.Envelope.MessageID)
|
||||
}
|
||||
n, err := strconv.Atoi(line[start+1 : end])
|
||||
return n, err == nil
|
||||
}
|
||||
|
||||
func parseFlags(line string) []string {
|
||||
i := strings.Index(line, "FLAGS (")
|
||||
if i < 0 {
|
||||
return nil
|
||||
}
|
||||
i += len("FLAGS (")
|
||||
j := strings.Index(line[i:], ")")
|
||||
if j < 0 {
|
||||
return nil
|
||||
}
|
||||
fields := strings.Fields(line[i : i+j])
|
||||
return fields
|
||||
}
|
||||
|
||||
func parseInternalDate(line string) time.Time {
|
||||
i := strings.Index(line, "INTERNALDATE ")
|
||||
if i < 0 {
|
||||
return time.Now()
|
||||
}
|
||||
rest := line[i+len("INTERNALDATE "):]
|
||||
if !strings.HasPrefix(rest, `"`) {
|
||||
return time.Now()
|
||||
}
|
||||
rest = rest[1:]
|
||||
j := strings.Index(rest, `"`)
|
||||
if j < 0 {
|
||||
return time.Now()
|
||||
}
|
||||
t, err := time.Parse("02-Jan-2006 15:04:05 -0700", rest[:j])
|
||||
if err != nil {
|
||||
return time.Now()
|
||||
}
|
||||
return t
|
||||
return messageID(body)
|
||||
}
|
||||
|
||||
func messageID(body []byte) string {
|
||||
|
|
@ -430,10 +261,15 @@ func messageID(body []byte) string {
|
|||
return id
|
||||
}
|
||||
}
|
||||
return fmt.Sprintf("sha256:%x", sha256Bytes(body))
|
||||
return fmt.Sprintf("sha256:%x", sha256.Sum256(body))
|
||||
}
|
||||
|
||||
func sha256Bytes(b []byte) []byte {
|
||||
h := sha256.Sum256(b)
|
||||
return h[:]
|
||||
func isAlreadyExistsError(err error) bool {
|
||||
var imapErr *imap.Error
|
||||
if errors.As(err, &imapErr) {
|
||||
text := strings.ToLower(imapErr.Text)
|
||||
return strings.Contains(text, "exist") || strings.Contains(text, "already")
|
||||
}
|
||||
text := strings.ToLower(err.Error())
|
||||
return strings.Contains(text, "exist") || strings.Contains(text, "already")
|
||||
}
|
||||
|
|
|
|||
26
backend/04-imap-source_test.go
Normal file
26
backend/04-imap-source_test.go
Normal file
|
|
@ -0,0 +1,26 @@
|
|||
package backend
|
||||
|
||||
import (
|
||||
"strings"
|
||||
"testing"
|
||||
|
||||
"github.com/emersion/go-imap/v2"
|
||||
)
|
||||
|
||||
func TestSanitizeIMAPFlagsDropsRecentAndWildcard(t *testing.T) {
|
||||
got := sanitizeIMAPFlags([]imap.Flag{imap.FlagSeen, imap.Flag(`\Recent`), imap.FlagWildcard, imap.FlagAnswered})
|
||||
if len(got) != 2 || got[0] != imap.FlagSeen || got[1] != imap.FlagAnswered {
|
||||
t.Fatalf("sanitizeIMAPFlags returned %#v", got)
|
||||
}
|
||||
}
|
||||
|
||||
func TestMessageIDFallsBackToBodyHash(t *testing.T) {
|
||||
body := []byte("From: a@example.com\r\nSubject: Test\r\n\r\nBody")
|
||||
id := messageID(body)
|
||||
if !strings.HasPrefix(id, "sha256:") {
|
||||
t.Fatalf("expected sha256 fallback, got %q", id)
|
||||
}
|
||||
if id != messageID(body) {
|
||||
t.Fatal("messageID hash fallback is not stable")
|
||||
}
|
||||
}
|
||||
|
|
@ -1,41 +1,44 @@
|
|||
package backend
|
||||
|
||||
import "strings"
|
||||
import (
|
||||
"fmt"
|
||||
"strings"
|
||||
|
||||
"github.com/emersion/go-imap/v2"
|
||||
)
|
||||
|
||||
// TargetMailbox = das Ziel-Postfach (neuer Host). Der Umzug schreibt hier per
|
||||
// IMAP APPEND hinein -- NICHT per SMTP. APPEND erhaelt Ordner, Flags und
|
||||
// Original-Datum; SMTP wuerde alles als "neu/ungelesen" mit falschem Datum
|
||||
// zustellen und die Ordnerstruktur zerstoeren.
|
||||
type TargetMailbox interface {
|
||||
Folders() ([]TargetFolder, error) // vorhandene Ziel-Ordner (fuer Rollen-Zuordnung)
|
||||
Delim() string // Hierarchie-Trenner des Ziels
|
||||
EnsureFolder(name string) error // anlegen + subscriben, falls fehlt
|
||||
Append(folder string, m RawMessage) error // mit m.Flags und m.InternalDate
|
||||
Folders() ([]TargetFolder, error) // vorhandene Ziel-Ordner (fuer Rollen-Zuordnung)
|
||||
Delim() string // Hierarchie-Trenner des Ziels
|
||||
EnsureFolder(name string) error // anlegen + subscriben, falls fehlt
|
||||
Append(folder string, m RawMessage) error // mit m.Flags und m.InternalDate
|
||||
Fetch(folder string) ([]RawMessage, error) // Ziel-Audit: geschriebene Mail wiederfinden
|
||||
Close() error
|
||||
}
|
||||
|
||||
// OpenIMAPTarget verbindet das Ziel per go-imap/v2 (Security wie Quelle, siehe
|
||||
// a.DstSecurity/a.DstInsecure; meist "tls").
|
||||
func OpenIMAPTarget(a Account) (TargetMailbox, error) {
|
||||
c, err := dialIMAP(a.DstHost, a.DstPort, a.DstSecurity, a.DstInsecure)
|
||||
c, err := dialIMAPClient(a.DstHost, a.DstPort, a.DstSecurity, a.DstInsecure)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
if err := c.login(a.DstUser, a.DstPass); err != nil {
|
||||
if err := c.Login(a.DstUser, a.DstPass).Wait(); err != nil {
|
||||
_ = c.Close()
|
||||
return nil, err
|
||||
}
|
||||
return &imapTarget{c: c}, nil
|
||||
return &imapTarget{mailbox: &imapClientMailbox{c: c}}, nil
|
||||
}
|
||||
|
||||
type imapTarget struct {
|
||||
c *simpleIMAP
|
||||
delim string
|
||||
mailbox *imapClientMailbox
|
||||
delim string
|
||||
}
|
||||
|
||||
func (t *imapTarget) Folders() ([]TargetFolder, error) {
|
||||
boxes, err := t.c.listMailboxes()
|
||||
boxes, err := t.mailbox.listMailboxes()
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
|
@ -63,29 +66,64 @@ func (t *imapTarget) Delim() string {
|
|||
}
|
||||
|
||||
func (t *imapTarget) EnsureFolder(name string) error {
|
||||
if name == "INBOX" {
|
||||
name = strings.TrimSpace(name)
|
||||
if name == "" || strings.EqualFold(name, "INBOX") {
|
||||
return nil
|
||||
}
|
||||
if err := t.c.simple("CREATE " + imapQuote(name)); err != nil {
|
||||
if !strings.Contains(strings.ToLower(err.Error()), "exist") && !strings.Contains(strings.ToLower(err.Error()), "already") {
|
||||
return err
|
||||
}
|
||||
if err := t.ensureParentFolders(name); err != nil {
|
||||
return err
|
||||
}
|
||||
_ = t.c.simple("SUBSCRIBE " + imapQuote(name))
|
||||
if err := t.createFolder(name); err != nil {
|
||||
return err
|
||||
}
|
||||
_ = t.mailbox.c.Subscribe(name).Wait()
|
||||
return nil
|
||||
}
|
||||
|
||||
func (t *imapTarget) ensureParentFolders(name string) error {
|
||||
delim := t.Delim()
|
||||
if delim == "" || !strings.Contains(name, delim) {
|
||||
return nil
|
||||
}
|
||||
parts := strings.Split(name, delim)
|
||||
for i := 1; i < len(parts); i++ {
|
||||
parent := strings.Join(parts[:i], delim)
|
||||
if strings.TrimSpace(parent) == "" || strings.EqualFold(parent, "INBOX") {
|
||||
continue
|
||||
}
|
||||
if err := t.createFolder(parent); err != nil {
|
||||
return err
|
||||
}
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func (t *imapTarget) createFolder(name string) error {
|
||||
err := t.mailbox.c.Create(name, nil).Wait()
|
||||
if err == nil || isAlreadyExistsError(err) {
|
||||
return nil
|
||||
}
|
||||
return fmt.Errorf("imap create %q failed: %w", name, err)
|
||||
}
|
||||
|
||||
func (t *imapTarget) Append(folder string, m RawMessage) error {
|
||||
return t.c.appendMessage(folder, m)
|
||||
opts := &imap.AppendOptions{Flags: stringsToFlags(m.Flags), Time: m.InternalDate}
|
||||
cmd := t.mailbox.c.Append(folder, int64(len(m.Body)), opts)
|
||||
if _, err := cmd.Write(m.Body); err != nil {
|
||||
_ = cmd.Close()
|
||||
return err
|
||||
}
|
||||
if err := cmd.Close(); err != nil {
|
||||
return err
|
||||
}
|
||||
_, err := cmd.Wait()
|
||||
return err
|
||||
}
|
||||
|
||||
func (t *imapTarget) Fetch(folder string) ([]RawMessage, error) {
|
||||
if err := t.c.selectMailbox(folder); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
return t.c.fetchAll()
|
||||
return t.mailbox.fetchAll(folder)
|
||||
}
|
||||
|
||||
func (t *imapTarget) Close() error {
|
||||
return t.c.Close()
|
||||
return t.mailbox.Close()
|
||||
}
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue