From 015e0bbd0f43adbd3f220888c9ffac71a176486d Mon Sep 17 00:00:00 2001 From: tgiachi Date: Mon, 9 Nov 2026 14:46:35 +0100 Subject: [PATCH 1/6] feat(store): SQLite store for lists and members - Add schema with lists and members tables - Add CreateList, FindList, AddMember, IsMember, Members - Normalize addresses to lowercase --- go.mod | 14 ++++ go.sum | 50 ++++++++++++++ internal/store/store.go | 130 +++++++++++++++++++++++++++++++++++ internal/store/store_test.go | 65 ++++++++++++++++++ 4 files changed, 259 insertions(+) create mode 100644 go.sum create mode 100644 internal/store/store.go create mode 100644 internal/store/store_test.go diff --git a/go.mod b/go.mod index 8ab8343..a0b004f 100644 --- a/go.mod +++ b/go.mod @@ -1,3 +1,17 @@ module codeberg.org/squidd/parsimony go 1.27.1 + +require modernc.org/sqlite v1.62.0 + +require ( + github.com/dustin/go-humanize v1.1.0 // indirect + github.com/google/uuid v1.6.0 // indirect + github.com/mattn/go-isatty v0.0.24 // indirect + github.com/ncruces/go-strftime v1.1.0 // indirect + github.com/remyoudompheng/bigfft v0.0.0-20230129092748-24d4a6f8daec // indirect + golang.org/x/sys v0.49.0 // indirect + modernc.org/libc v1.80.1 // indirect + modernc.org/mathutil v1.7.1 // indirect + modernc.org/memory v1.12.1 // indirect +) diff --git a/go.sum b/go.sum new file mode 100644 index 0000000..9f88b65 --- /dev/null +++ b/go.sum @@ -0,0 +1,50 @@ +github.com/dustin/go-humanize v1.1.0 h1:dbKTrvD0klcbBV/h4AWJdMuZogJACoMlvWIWZ5b2xWg= +github.com/dustin/go-humanize v1.1.0/go.mod h1:hc1CvRkJMsgxqjmjMQF3QNRAZBwY8AXBAzKYoSX9sFI= +github.com/google/pprof v0.0.0-20261016150608-1facf8f91b50 h1:PlNWJRxu5APSV0pWqfIsZ0qt9OOGHSWfZQ4zvx+WgWs= +github.com/google/pprof v0.0.0-20261016150608-1facf8f91b50/go.mod h1:yUo1AMMpsPIDFGuwDK8nLcf8+vvAd5l2O6JDZ6hpwrM= +github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0= +github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo= +github.com/hashicorp/golang-lru/v2 v2.0.7 h1:a+bsQ5rvGLjzHuww6tVxozPZFVghXaHOwFs4luLUK2k= +github.com/hashicorp/golang-lru/v2 v2.0.7/go.mod h1:QeFd9opnmA6QUJc5vARoKUSoFhyfM2/ZepoAG6RGpeM= +github.com/mattn/go-isatty v0.0.24 h1:tGZZoVgT/KiqK1c8ocVLeDS8BSWMRd47J3Lbz7vsReI= +github.com/mattn/go-isatty v0.0.24/go.mod h1:nMCL3Zebbrt45jsMDgnfIwz6ydEQApk5oEI3HqDio6A= +github.com/ncruces/go-strftime v1.1.0 h1:vtPmPWMkb539RGV9WpWT9EwJGvrOCKvMNI4obWL47Hk= +github.com/ncruces/go-strftime v1.1.0/go.mod h1:yVaq7iwCN09vHRrKBrrflXT0M9tTMG2KmZ9Fj7xeG/g= +github.com/remyoudompheng/bigfft v0.0.0-20230129092748-24d4a6f8daec h1:W09IVJc94icq4NjY3clb7Lk8O1qJ8BdBEF8z0ibU0rE= +github.com/remyoudompheng/bigfft v0.0.0-20230129092748-24d4a6f8daec/go.mod h1:qqbHyh8v60DhA7CoWK5oRCqLrMHRGoxYCSS9EjAz6Eo= +golang.org/x/mod v0.42.0 h1:ICeL3t2L30ljSPHHxDnR4fqVcBt/zR2zJAb9juavmQg= +golang.org/x/mod v0.42.0/go.mod h1:u5fzIrRInkL8MaO1cbRkUHT64v303YIT5KEqpNr7jRs= +golang.org/x/sync v0.24.0 h1:iqiDrGoDgyuvAKrhLQthUEzU/R378N78gXbBjxed7oA= +golang.org/x/sync v0.24.0/go.mod h1:sUUOizhqBxiL6pEWpqNLUiaJn1ShEbZ6BBqskPbjZm0= +golang.org/x/sys v0.49.0 h1:XbzkgYJHdqh/8m2Uu0W/dQv8nktxx4BFHp1M0gROTXA= +golang.org/x/sys v0.49.0/go.mod h1:hNLxWAXmnKAxqDtdwIYC4bM9oQPEecfsnNMuSxOs3og= +golang.org/x/tools v0.52.0 h1:ryxg4U63oaUYk7uOLTF37n43f4qgtGvqV4Ioit1BaEs= +golang.org/x/tools v0.52.0/go.mod h1:ItcP5UNaVGG+Yc4eIYmaFLNJ4soEopkx5Y2d4lcEurs= +modernc.org/cc/v4 v4.30.6-0.20261101114202-1b9d1a076f6b h1:WE5SLOURcNd8s6uPR/n4WV4weQxxYKi5OpEZkfNVvdE= +modernc.org/cc/v4 v4.30.6-0.20261101114202-1b9d1a076f6b/go.mod h1:OnovgIhbbMXMu1aISnJ0wvVD1KnW+cAUJkIrAWh+kVI= +modernc.org/ccgo/v4 v4.38.1 h1:wdxJVBuFT8JufZnnQyS6Bbz3NOWhViD0xJOGR96Bpd4= +modernc.org/ccgo/v4 v4.38.1/go.mod h1:kOpEkJRbFwBvjUWwn4j1j9B7iFHbl1+orhgTMCDkDBk= +modernc.org/fileutil v1.4.0 h1:j6ZzNTftVS054gi281TyLjHPp6CPHr2KCxEXjEbD6SM= +modernc.org/fileutil v1.4.0/go.mod h1:EqdKFDxiByqxLk8ozOxObDSfcVOv/54xDs/DUHdvCUU= +modernc.org/gc/v2 v2.6.5 h1:nyqdV8q46KvTpZlsw66kWqwXRHdjIlJOhG6kxiV/9xI= +modernc.org/gc/v2 v2.6.5/go.mod h1:YgIahr1ypgfe7chRuJi2gD7DBQiKSLMPgBQe9oIiito= +modernc.org/gc/v3 v3.2.0 h1:/Y3LGDMQaoYf55PebP1qsZ5FDGgAZyG1RYKEHeQzh1o= +modernc.org/gc/v3 v3.2.0/go.mod h1:HFK/6AGESC7Ex+EZJhJ2Gni6cTaYpSMmU/cT9RmlfYY= +modernc.org/goabi0 v0.2.0 h1:HvEowk7LxcPd0eq6mVOAEMai46V+i7Jrj13t4AzuNks= +modernc.org/goabi0 v0.2.0/go.mod h1:CEFRnnJhKvWT1c1JTI3Avm+tgOWbkOu5oPA8eH8LnMI= +modernc.org/libc v1.80.1 h1:ejn7HtTV3GknNKbklqWQ1nvUrfX8mTxs1D+xp/JQwy4= +modernc.org/libc v1.80.1/go.mod h1:pvo25Rs3OJEbDqhUV9jdEGevxeLJrJeDmNid/AcQV1g= +modernc.org/mathutil v1.7.1 h1:GCZVGXdaN8gTqB1Mf/usp1Y/hSqgI2vAGGP4jZMCxOU= +modernc.org/mathutil v1.7.1/go.mod h1:4p5IwJITfppl0G4sUEDtCr4DthTaT47/N3aT6MhfgJg= +modernc.org/memory v1.12.1 h1:nFMiWrpStgZczNl6XI9GnIk/rWhYIyHGUaR04pGbp9g= +modernc.org/memory v1.12.1/go.mod h1:/JP4VbVC+K5sU2wZi9bHoq2MAkCnrt2r98UGeSK7Mjw= +modernc.org/opt v0.2.0 h1:tGyef5ApycA7FSEOMraay9SaTk5zmbx7Tu+cJs4QKZg= +modernc.org/opt v0.2.0/go.mod h1:03fq9lsNfvkYSfxrfUhZCWPk1lm4cq4N+Bh//bEtgns= +modernc.org/sortutil v1.2.1 h1:+xyoGf15mM3NMlPDnFqrteY07klSFxLElE2PVuWIJ7w= +modernc.org/sortutil v1.2.1/go.mod h1:7ZI3a3REbai7gzCLcotuw9AC4VZVpYMjDzETGsSMqJE= +modernc.org/sqlite v1.62.0 h1:gMaCjSM1qpl+iOjiWhR1LYP3zqrYDI+5GYLGt6veP2g= +modernc.org/sqlite v1.62.0/go.mod h1:Jzjh1mt4s0HuQ0KvtB1LIuHiGRmU2D5pgj8dUhW7/SE= +modernc.org/strutil v1.2.1 h1:UneZBkQA+DX2Rp35KcM69cSsNES9ly8mQWD71HKlOA0= +modernc.org/strutil v1.2.1/go.mod h1:EHkiggD70koQxjVdSBM3JKM7k6L0FbGE5eymy9i3B9A= +modernc.org/token v1.1.0 h1:Xl7Ap9dKaEs5kLoOQeQmPWevfnk/DM5qcLcYlA8ys6Y= +modernc.org/token v1.1.0/go.mod h1:UGzOrNV1mAFSEB63lOFHIpNRUVMvYTc6yu1SMY/XTDM= diff --git a/internal/store/store.go b/internal/store/store.go new file mode 100644 index 0000000..3884cd4 --- /dev/null +++ b/internal/store/store.go @@ -0,0 +1,130 @@ +// Package store persists lists and members in SQLite. +package store + +import ( + "database/sql" + "errors" + "fmt" + "strings" + + _ "modernc.org/sqlite" +) + +// ErrNotFound is returned when a list or member does not exist. +var ErrNotFound = errors.New("not found") + +// List is a mailing list. +type List struct { + ID int64 + Name string // local part, lowercase + Domain string // lowercase + Title string +} + +// Address returns the list posting address. +func (l List) Address() string { return l.Name + "@" + l.Domain } + +// Member is a list subscriber. +type Member struct { + Address string // lowercase + DisplayName string +} + +// Store wraps the SQLite database. +type Store struct{ db *sql.DB } + +const schema = ` +CREATE TABLE IF NOT EXISTS lists ( + id INTEGER PRIMARY KEY AUTOINCREMENT, + name TEXT NOT NULL, + domain TEXT NOT NULL, + title TEXT NOT NULL DEFAULT '', + UNIQUE(name, domain) +); +CREATE TABLE IF NOT EXISTS members ( + list_id INTEGER NOT NULL REFERENCES lists(id) ON DELETE CASCADE, + address TEXT NOT NULL, + display_name TEXT NOT NULL DEFAULT '', + PRIMARY KEY(list_id, address) +);` + +// Open opens (and migrates) the database at path. Use ":memory:" for tests. +func Open(path string) (*Store, error) { + db, err := sql.Open("sqlite", path) + if err != nil { + return nil, err + } + // An in-memory database is per-connection: keep a single one. + db.SetMaxOpenConns(1) + if _, err := db.Exec("PRAGMA foreign_keys=ON; PRAGMA journal_mode=WAL;"); err != nil { + db.Close() + return nil, err + } + if _, err := db.Exec(schema); err != nil { + db.Close() + return nil, fmt.Errorf("migrate: %w", err) + } + return &Store{db: db}, nil +} + +// Close closes the database. +func (s *Store) Close() error { return s.db.Close() } + +// CreateList adds a new list. +func (s *Store) CreateList(name, domain, title string) (List, error) { + l := List{Name: strings.ToLower(name), Domain: strings.ToLower(domain), Title: title} + res, err := s.db.Exec(`INSERT INTO lists(name, domain, title) VALUES(?,?,?)`, l.Name, l.Domain, l.Title) + if err != nil { + return List{}, err + } + l.ID, _ = res.LastInsertId() + return l, nil +} + +// FindList resolves a posting address like "dev@example.org". +func (s *Store) FindList(addr string) (List, error) { + name, domain, ok := strings.Cut(strings.ToLower(strings.TrimSpace(addr)), "@") + if !ok { + return List{}, ErrNotFound + } + var l List + err := s.db.QueryRow(`SELECT id, name, domain, title FROM lists WHERE name=? AND domain=?`, name, domain). + Scan(&l.ID, &l.Name, &l.Domain, &l.Title) + if errors.Is(err, sql.ErrNoRows) { + return List{}, ErrNotFound + } + return l, err +} + +// AddMember subscribes an address to a list (idempotent). +func (s *Store) AddMember(listID int64, addr, displayName string) error { + _, err := s.db.Exec(`INSERT OR REPLACE INTO members(list_id, address, display_name) VALUES(?,?,?)`, + listID, strings.ToLower(strings.TrimSpace(addr)), displayName) + return err +} + +// IsMember reports whether addr is subscribed to the list. +func (s *Store) IsMember(listID int64, addr string) (bool, error) { + var n int + err := s.db.QueryRow(`SELECT COUNT(*) FROM members WHERE list_id=? AND address=?`, + listID, strings.ToLower(strings.TrimSpace(addr))).Scan(&n) + return n > 0, err +} + +// Members returns all subscribers of a list. +func (s *Store) Members(listID int64) ([]Member, error) { + rows, err := s.db.Query(`SELECT address, display_name FROM members WHERE list_id=? ORDER BY address`, listID) + if err != nil { + return nil, err + } + defer rows.Close() + var out []Member + for rows.Next() { + var m Member + if err := rows.Scan(&m.Address, &m.DisplayName); err != nil { + return nil, err + } + out = append(out, m) + } + return out, rows.Err() +} diff --git a/internal/store/store_test.go b/internal/store/store_test.go new file mode 100644 index 0000000..afecaf1 --- /dev/null +++ b/internal/store/store_test.go @@ -0,0 +1,65 @@ +package store + +import ( + "errors" + "testing" +) + +func newTestStore(t *testing.T) *Store { + t.Helper() + s, err := Open(":memory:") + if err != nil { + t.Fatalf("open: %v", err) + } + t.Cleanup(func() { s.Close() }) + return s +} + +func TestCreateAndFindList(t *testing.T) { + s := newTestStore(t) + if _, err := s.CreateList("dev", "example.org", "Dev list"); err != nil { + t.Fatalf("create: %v", err) + } + l, err := s.FindList("dev@example.org") + if err != nil { + t.Fatalf("find: %v", err) + } + if l.Name != "dev" || l.Domain != "example.org" || l.Title != "Dev list" { + t.Fatalf("unexpected list: %+v", l) + } +} + +func TestFindListUnknown(t *testing.T) { + s := newTestStore(t) + if _, err := s.FindList("nope@example.org"); !errors.Is(err, ErrNotFound) { + t.Fatalf("want ErrNotFound, got %v", err) + } +} + +func TestFindListCaseInsensitive(t *testing.T) { + s := newTestStore(t) + s.CreateList("dev", "example.org", "Dev") + if _, err := s.FindList("DEV@Example.ORG"); err != nil { + t.Fatalf("find: %v", err) + } +} + +func TestMembers(t *testing.T) { + s := newTestStore(t) + l, _ := s.CreateList("dev", "example.org", "Dev") + if err := s.AddMember(l.ID, "Alice@Example.com", "Alice"); err != nil { + t.Fatalf("add: %v", err) + } + ok, err := s.IsMember(l.ID, "alice@example.com") + if err != nil || !ok { + t.Fatalf("want member, got %v %v", ok, err) + } + ok, _ = s.IsMember(l.ID, "bob@example.com") + if ok { + t.Fatal("bob should not be a member") + } + ms, err := s.Members(l.ID) + if err != nil || len(ms) != 1 || ms[0].Address != "alice@example.com" { + t.Fatalf("members: %+v %v", ms, err) + } +} From eb9e992f4a2ba838a3348a7291d4551c681092fa Mon Sep 17 00:00:00 2001 From: tgiachi Date: Mon, 9 Nov 2026 14:47:44 +0100 Subject: [PATCH 2/6] feat(router): accept posts only from list members - Add Router.Route resolving list, checking sender membership - Return ErrUnknownList and ErrNotMember - Return subscriber addresses as recipients --- internal/router/router.go | 55 ++++++++++++++++++++++++++++++++ internal/router/router_test.go | 58 ++++++++++++++++++++++++++++++++++ 2 files changed, 113 insertions(+) create mode 100644 internal/router/router.go create mode 100644 internal/router/router_test.go diff --git a/internal/router/router.go b/internal/router/router.go new file mode 100644 index 0000000..936f678 --- /dev/null +++ b/internal/router/router.go @@ -0,0 +1,55 @@ +// Package router decides what happens to an incoming message. +package router + +import ( + "errors" + + "codeberg.org/squidd/parsimony/internal/store" +) + +var ( + // ErrUnknownList means the recipient address is not a list. + ErrUnknownList = errors.New("unknown list") + // ErrNotMember means the sender may not post to the list. + ErrNotMember = errors.New("sender is not a member") +) + +// Result describes how to deliver an accepted message. +type Result struct { + List store.List + Recipients []string // subscriber addresses + Data []byte // message to send +} + +// Router applies list policy to incoming messages. +type Router struct{ store *store.Store } + +// New creates a Router backed by s. +func New(s *store.Store) *Router { return &Router{store: s} } + +// Route validates a message from sender to the list address rcpt. +func (r *Router) Route(sender, rcpt string, data []byte) (Result, error) { + l, err := r.store.FindList(rcpt) + if errors.Is(err, store.ErrNotFound) { + return Result{}, ErrUnknownList + } + if err != nil { + return Result{}, err + } + ok, err := r.store.IsMember(l.ID, sender) + if err != nil { + return Result{}, err + } + if !ok { + return Result{}, ErrNotMember + } + members, err := r.store.Members(l.ID) + if err != nil { + return Result{}, err + } + rcpts := make([]string, len(members)) + for i, m := range members { + rcpts[i] = m.Address + } + return Result{List: l, Recipients: rcpts, Data: data}, nil +} diff --git a/internal/router/router_test.go b/internal/router/router_test.go new file mode 100644 index 0000000..6c20209 --- /dev/null +++ b/internal/router/router_test.go @@ -0,0 +1,58 @@ +package router + +import ( + "errors" + "testing" + + "codeberg.org/squidd/parsimony/internal/store" +) + +func setup(t *testing.T) *Router { + t.Helper() + s, err := store.Open(":memory:") + if err != nil { + t.Fatal(err) + } + t.Cleanup(func() { s.Close() }) + l, _ := s.CreateList("dev", "example.org", "Dev") + s.AddMember(l.ID, "alice@example.com", "Alice") + s.AddMember(l.ID, "bob@example.com", "Bob") + return New(s) +} + +func TestRouteMemberPost(t *testing.T) { + r := setup(t) + res, err := r.Route("alice@example.com", "dev@example.org", []byte("Subject: hi\r\n\r\nbody\r\n")) + if err != nil { + t.Fatalf("route: %v", err) + } + if res.List.Name != "dev" { + t.Fatalf("list: %+v", res.List) + } + if len(res.Recipients) != 2 { + t.Fatalf("want 2 recipients, got %v", res.Recipients) + } +} + +func TestRouteSenderCaseInsensitive(t *testing.T) { + r := setup(t) + if _, err := r.Route("ALICE@Example.com", "dev@example.org", nil); err != nil { + t.Fatalf("route: %v", err) + } +} + +func TestRouteNonMemberRejected(t *testing.T) { + r := setup(t) + _, err := r.Route("mallory@evil.com", "dev@example.org", nil) + if !errors.Is(err, ErrNotMember) { + t.Fatalf("want ErrNotMember, got %v", err) + } +} + +func TestRouteUnknownList(t *testing.T) { + r := setup(t) + _, err := r.Route("alice@example.com", "nope@example.org", nil) + if !errors.Is(err, ErrUnknownList) { + t.Fatalf("want ErrUnknownList, got %v", err) + } +} From d8f31d9b3ef4f07fc6d6955fa9d569588540ff6b Mon Sep 17 00:00:00 2001 From: tgiachi Date: Mon, 9 Nov 2026 14:50:56 +0100 Subject: [PATCH 3/6] feat(router): rewrite headers for list delivery - Add List-Id, List-Post, List-Unsubscribe and Precedence headers - Add one-click unsubscribe (RFC 8058) when a base URL is configured - Strip incoming List-* headers to prevent spoofing - Rewrite From as "Name via List" and keep the original in Reply-To - Copy the message body byte for byte --- go.mod | 5 ++- go.sum | 33 ++++++++++++++++ internal/router/headers.go | 64 +++++++++++++++++++++++++++++++ internal/router/router.go | 12 +++++- internal/router/router_test.go | 70 ++++++++++++++++++++++++++++++++++ 5 files changed, 181 insertions(+), 3 deletions(-) create mode 100644 internal/router/headers.go diff --git a/go.mod b/go.mod index a0b004f..61de0eb 100644 --- a/go.mod +++ b/go.mod @@ -2,7 +2,10 @@ module codeberg.org/squidd/parsimony go 1.27.1 -require modernc.org/sqlite v1.62.0 +require ( + github.com/emersion/go-message v0.18.2 + modernc.org/sqlite v1.62.0 +) require ( github.com/dustin/go-humanize v1.1.0 // indirect diff --git a/go.sum b/go.sum index 9f88b65..c28e7d8 100644 --- a/go.sum +++ b/go.sum @@ -1,5 +1,7 @@ github.com/dustin/go-humanize v1.1.0 h1:dbKTrvD0klcbBV/h4AWJdMuZogJACoMlvWIWZ5b2xWg= github.com/dustin/go-humanize v1.1.0/go.mod h1:hc1CvRkJMsgxqjmjMQF3QNRAZBwY8AXBAzKYoSX9sFI= +github.com/emersion/go-message v0.18.2 h1:rl55SQdjd9oJcIoQNhubD2Acs1E6IzlZISRTK7x/Lpg= +github.com/emersion/go-message v0.18.2/go.mod h1:XpJyL70LwRvq2a8rVbHXikPgKj8+aI0kGdHlg16ibYA= github.com/google/pprof v0.0.0-20261016150608-1facf8f91b50 h1:PlNWJRxu5APSV0pWqfIsZ0qt9OOGHSWfZQ4zvx+WgWs= github.com/google/pprof v0.0.0-20261016150608-1facf8f91b50/go.mod h1:yUo1AMMpsPIDFGuwDK8nLcf8+vvAd5l2O6JDZ6hpwrM= github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0= @@ -12,14 +14,45 @@ github.com/ncruces/go-strftime v1.1.0 h1:vtPmPWMkb539RGV9WpWT9EwJGvrOCKvMNI4obWL github.com/ncruces/go-strftime v1.1.0/go.mod h1:yVaq7iwCN09vHRrKBrrflXT0M9tTMG2KmZ9Fj7xeG/g= github.com/remyoudompheng/bigfft v0.0.0-20230129092748-24d4a6f8daec h1:W09IVJc94icq4NjY3clb7Lk8O1qJ8BdBEF8z0ibU0rE= github.com/remyoudompheng/bigfft v0.0.0-20230129092748-24d4a6f8daec/go.mod h1:qqbHyh8v60DhA7CoWK5oRCqLrMHRGoxYCSS9EjAz6Eo= +github.com/yuin/goldmark v1.4.13/go.mod h1:6yULJ656Px+3vBD8DxQVa3kxgyrAnzto9xy5taEt/CY= +golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w= +golang.org/x/crypto v0.0.0-20210921155107-089bfa567519/go.mod h1:GvvjBRRGRdwPK5ydBHafDWAxML/pGHZbMvKqRZ5+Abc= +golang.org/x/mod v0.6.0-dev.0.20220419223038-86c51ed26bb4/go.mod h1:jJ57K6gSWd91VN4djpZkiMVwK6gcyfeH4XE8wZrZaV4= +golang.org/x/mod v0.8.0/go.mod h1:iBbtSCu2XBx23ZKBPSOrRkjjQPZFPuis4dIYUhu/chs= golang.org/x/mod v0.42.0 h1:ICeL3t2L30ljSPHHxDnR4fqVcBt/zR2zJAb9juavmQg= golang.org/x/mod v0.42.0/go.mod h1:u5fzIrRInkL8MaO1cbRkUHT64v303YIT5KEqpNr7jRs= +golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= +golang.org/x/net v0.0.0-20210226172049-e18ecbb05110/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg= +golang.org/x/net v0.0.0-20220722155237-a158d28d115b/go.mod h1:XRhObCWvk6IyKnWLug+ECip1KBveYUHfp+8e9klMJ9c= +golang.org/x/net v0.6.0/go.mod h1:2Tu9+aMcznHK/AK1HMvgo6xiTLG5rD5rZLDS+rp2Bjs= +golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= +golang.org/x/sync v0.0.0-20220722155255-886fb9371eb4/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= +golang.org/x/sync v0.1.0/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= golang.org/x/sync v0.24.0 h1:iqiDrGoDgyuvAKrhLQthUEzU/R378N78gXbBjxed7oA= golang.org/x/sync v0.24.0/go.mod h1:sUUOizhqBxiL6pEWpqNLUiaJn1ShEbZ6BBqskPbjZm0= +golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= +golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20210615035016-665e8c7367d1/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.0.0-20220520151302-bc2c85ada10a/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.0.0-20220722155257-8c9f86f7a55f/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.5.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.49.0 h1:XbzkgYJHdqh/8m2Uu0W/dQv8nktxx4BFHp1M0gROTXA= golang.org/x/sys v0.49.0/go.mod h1:hNLxWAXmnKAxqDtdwIYC4bM9oQPEecfsnNMuSxOs3og= +golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo= +golang.org/x/term v0.0.0-20210927222741-03fcf44c2211/go.mod h1:jbD1KX2456YbFQfuXm/mYQcufACuNUgVhRMnK/tPxf8= +golang.org/x/term v0.5.0/go.mod h1:jMB1sMXY+tzblOD4FWmEbocvup2/aLOaQEp7JmGp78k= +golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ= +golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ= +golang.org/x/text v0.3.7/go.mod h1:u+2+/6zg+i71rQMx5EYifcz6MCKuco9NR6JIITiCfzQ= +golang.org/x/text v0.7.0/go.mod h1:mrYo+phRRbMaCq/xk9113O4dZlRixOauAjOtrjsXDZ8= +golang.org/x/text v0.14.0/go.mod h1:18ZOQIKpY8NJVqYksKHtTdi31H5itFRjB5/qKTNYzSU= +golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ= +golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= +golang.org/x/tools v0.1.12/go.mod h1:hNGJHUnrk76NpqgfD5Aqm5Crs+Hm0VOH/i9J2+nxYbc= +golang.org/x/tools v0.6.0/go.mod h1:Xwgl3UAJ/d3gWutnCtw505GrjyAbvKui8lOU390QaIU= golang.org/x/tools v0.52.0 h1:ryxg4U63oaUYk7uOLTF37n43f4qgtGvqV4Ioit1BaEs= golang.org/x/tools v0.52.0/go.mod h1:ItcP5UNaVGG+Yc4eIYmaFLNJ4soEopkx5Y2d4lcEurs= +golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= modernc.org/cc/v4 v4.30.6-0.20261101114202-1b9d1a076f6b h1:WE5SLOURcNd8s6uPR/n4WV4weQxxYKi5OpEZkfNVvdE= modernc.org/cc/v4 v4.30.6-0.20261101114202-1b9d1a076f6b/go.mod h1:OnovgIhbbMXMu1aISnJ0wvVD1KnW+cAUJkIrAWh+kVI= modernc.org/ccgo/v4 v4.38.1 h1:wdxJVBuFT8JufZnnQyS6Bbz3NOWhViD0xJOGR96Bpd4= diff --git a/internal/router/headers.go b/internal/router/headers.go new file mode 100644 index 0000000..1763a75 --- /dev/null +++ b/internal/router/headers.go @@ -0,0 +1,64 @@ +package router + +import ( + "bufio" + "bytes" + "fmt" + "io" + "net/mail" + "strings" + + "github.com/emersion/go-message/textproto" + + "codeberg.org/squidd/parsimony/internal/store" +) + +// rewrite adds list headers and rewrites From so DMARC alignment holds. +// The body is copied byte for byte. +func rewrite(l store.List, baseURL string, data []byte) ([]byte, error) { + br := bufio.NewReader(bytes.NewReader(data)) + h, err := textproto.ReadHeader(br) + if err != nil { + return nil, fmt.Errorf("parse header: %w", err) + } + + // Never trust list headers coming from outside. + for _, k := range []string{"List-Id", "List-Post", "List-Unsubscribe", "List-Unsubscribe-Post", "Precedence"} { + h.Del(k) + } + + id := l.Name + "." + l.Domain + h.Set("List-Id", fmt.Sprintf("%s <%s>", l.Title, id)) + h.Set("List-Post", "") + unsub := "" + if baseURL != "" { + unsub = "<" + strings.TrimRight(baseURL, "/") + "/unsubscribe/" + id + ">, " + unsub + h.Set("List-Unsubscribe-Post", "List-Unsubscribe=One-Click") + } + h.Set("List-Unsubscribe", unsub) + h.Set("Precedence", "list") + + if orig := h.Get("From"); orig != "" { + name := orig + if a, err := mail.ParseAddress(orig); err == nil { + name = a.Name + if name == "" { + name = a.Address + } + } + if h.Get("Reply-To") == "" { + h.Set("Reply-To", orig) + } + from := mail.Address{Name: name + " via " + l.Title, Address: l.Address()} + h.Set("From", from.String()) + } + + var out bytes.Buffer + if err := textproto.WriteHeader(&out, h); err != nil { + return nil, err + } + if _, err := io.Copy(&out, br); err != nil { + return nil, err + } + return out.Bytes(), nil +} diff --git a/internal/router/router.go b/internal/router/router.go index 936f678..4e40206 100644 --- a/internal/router/router.go +++ b/internal/router/router.go @@ -22,7 +22,11 @@ type Result struct { } // Router applies list policy to incoming messages. -type Router struct{ store *store.Store } +type Router struct { + store *store.Store + // BaseURL is the public web URL; enables one-click unsubscribe when set. + BaseURL string +} // New creates a Router backed by s. func New(s *store.Store) *Router { return &Router{store: s} } @@ -51,5 +55,9 @@ func (r *Router) Route(sender, rcpt string, data []byte) (Result, error) { for i, m := range members { rcpts[i] = m.Address } - return Result{List: l, Recipients: rcpts, Data: data}, nil + out, err := rewrite(l, r.BaseURL, data) + if err != nil { + return Result{}, err + } + return Result{List: l, Recipients: rcpts, Data: out}, nil } diff --git a/internal/router/router_test.go b/internal/router/router_test.go index 6c20209..0acf5e5 100644 --- a/internal/router/router_test.go +++ b/internal/router/router_test.go @@ -1,7 +1,10 @@ package router import ( + "bytes" "errors" + "net/mail" + "strings" "testing" "codeberg.org/squidd/parsimony/internal/store" @@ -56,3 +59,70 @@ func TestRouteUnknownList(t *testing.T) { t.Fatalf("want ErrUnknownList, got %v", err) } } + +func header(t *testing.T, data []byte) mail.Header { + t.Helper() + m, err := mail.ReadMessage(bytes.NewReader(data)) + if err != nil { + t.Fatalf("parse: %v", err) + } + return m.Header +} + +const sample = "From: Alice \r\nTo: dev@example.org\r\nSubject: hi\r\nList-Id: \r\n\r\nbody line\r\n" + +func TestRewriteHeaders(t *testing.T) { + r := setup(t) + r.BaseURL = "https://lists.example.org" + res, err := r.Route("alice@example.com", "dev@example.org", []byte(sample)) + if err != nil { + t.Fatal(err) + } + h := header(t, res.Data) + if got := h.Get("List-Id"); got != "Dev " { + t.Errorf("List-Id = %q", got) + } + if got := h.Get("List-Post"); got != "" { + t.Errorf("List-Post = %q", got) + } + if got := h.Get("List-Unsubscribe"); !strings.Contains(got, "") || + !strings.Contains(got, "") { + t.Errorf("List-Unsubscribe = %q", got) + } + if got := h.Get("List-Unsubscribe-Post"); got != "List-Unsubscribe=One-Click" { + t.Errorf("List-Unsubscribe-Post = %q", got) + } + if got := h.Get("From"); got != `"Alice via Dev" ` { + t.Errorf("From = %q", got) + } + if got := h.Get("Reply-To"); got != "Alice " { + t.Errorf("Reply-To = %q", got) + } + if !strings.HasSuffix(string(res.Data), "\r\n\r\nbody line\r\n") { + t.Errorf("body altered: %q", res.Data) + } + if n := len(h["List-Id"]); n != 1 { + t.Errorf("want a single List-Id, got %d", n) + } +} + +func TestRewriteKeepsExistingReplyTo(t *testing.T) { + r := setup(t) + msg := "From: Alice \r\nReply-To: team@example.com\r\n\r\nx\r\n" + res, _ := r.Route("alice@example.com", "dev@example.org", []byte(msg)) + if got := header(t, res.Data).Get("Reply-To"); got != "team@example.com" { + t.Errorf("Reply-To = %q", got) + } +} + +func TestNoOneClickWithoutBaseURL(t *testing.T) { + r := setup(t) + res, _ := r.Route("alice@example.com", "dev@example.org", []byte(sample)) + h := header(t, res.Data) + if h.Get("List-Unsubscribe-Post") != "" { + t.Error("one-click header needs a base URL") + } + if got := h.Get("List-Unsubscribe"); got != "" { + t.Errorf("List-Unsubscribe = %q", got) + } +} From dd2818d392eec11e648cad593a919e43edb845fa Mon Sep 17 00:00:00 2001 From: tgiachi Date: Mon, 9 Nov 2026 14:52:40 +0100 Subject: [PATCH 4/6] feat(outbound): SMTP relay sender with batching - Add Sender interface - Add SMTPRelay sending in batches of 50 recipients per transaction - Add Fake sender that records messages for tests --- go.mod | 2 + go.sum | 4 + internal/outbound/outbound.go | 81 ++++++++++++++++++++ internal/outbound/outbound_test.go | 115 +++++++++++++++++++++++++++++ 4 files changed, 202 insertions(+) create mode 100644 internal/outbound/outbound.go create mode 100644 internal/outbound/outbound_test.go diff --git a/go.mod b/go.mod index 61de0eb..357dd1a 100644 --- a/go.mod +++ b/go.mod @@ -4,11 +4,13 @@ go 1.27.1 require ( github.com/emersion/go-message v0.18.2 + github.com/emersion/go-smtp v0.25.1 modernc.org/sqlite v1.62.0 ) require ( github.com/dustin/go-humanize v1.1.0 // indirect + github.com/emersion/go-sasl v0.0.0-20241020182733-b788ff22d5a6 // indirect github.com/google/uuid v1.6.0 // indirect github.com/mattn/go-isatty v0.0.24 // indirect github.com/ncruces/go-strftime v1.1.0 // indirect diff --git a/go.sum b/go.sum index c28e7d8..ad6caee 100644 --- a/go.sum +++ b/go.sum @@ -2,6 +2,10 @@ github.com/dustin/go-humanize v1.1.0 h1:dbKTrvD0klcbBV/h4AWJdMuZogJACoMlvWIWZ5b2 github.com/dustin/go-humanize v1.1.0/go.mod h1:hc1CvRkJMsgxqjmjMQF3QNRAZBwY8AXBAzKYoSX9sFI= github.com/emersion/go-message v0.18.2 h1:rl55SQdjd9oJcIoQNhubD2Acs1E6IzlZISRTK7x/Lpg= github.com/emersion/go-message v0.18.2/go.mod h1:XpJyL70LwRvq2a8rVbHXikPgKj8+aI0kGdHlg16ibYA= +github.com/emersion/go-sasl v0.0.0-20241020182733-b788ff22d5a6 h1:oP4q0fw+fOSWn3DfFi4EXdT+B+gTtzx8GC9xsc26Znk= +github.com/emersion/go-sasl v0.0.0-20241020182733-b788ff22d5a6/go.mod h1:iL2twTeMvZnrg54ZoPDNfJaJaqy0xIQFuBdrLsmspwQ= +github.com/emersion/go-smtp v0.25.1 h1:y6nzefT6PtFeMItFw97GX/ZCkVbh0rqSXG8b3ang8/w= +github.com/emersion/go-smtp v0.25.1/go.mod h1:ZtRRkbTyp2XTHCA+BmyTFTrj8xY4I+b4McvHxCU2gsQ= github.com/google/pprof v0.0.0-20261016150608-1facf8f91b50 h1:PlNWJRxu5APSV0pWqfIsZ0qt9OOGHSWfZQ4zvx+WgWs= github.com/google/pprof v0.0.0-20261016150608-1facf8f91b50/go.mod h1:yUo1AMMpsPIDFGuwDK8nLcf8+vvAd5l2O6JDZ6hpwrM= github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0= diff --git a/internal/outbound/outbound.go b/internal/outbound/outbound.go new file mode 100644 index 0000000..9ca977a --- /dev/null +++ b/internal/outbound/outbound.go @@ -0,0 +1,81 @@ +// Package outbound delivers messages to the SMTP relay. +package outbound + +import ( + "bytes" + "context" + "fmt" + "net" + "sync" + "time" + + "github.com/emersion/go-smtp" +) + +// Sender delivers one message to a set of recipients. +type Sender interface { + // Send submits data with the given envelope sender to every address in to. + Send(ctx context.Context, from string, to []string, data []byte) error +} + +// DefaultBatchSize is the number of recipients per SMTP transaction. +const DefaultBatchSize = 50 + +// SMTPRelay sends through a plain SMTP relay such as a local Postfix. +type SMTPRelay struct { + Addr string // host:port + BatchSize int // recipients per transaction; DefaultBatchSize if zero +} + +// Send splits recipients in batches and sends one transaction per batch. +func (r *SMTPRelay) Send(ctx context.Context, from string, to []string, data []byte) error { + size := r.BatchSize + if size <= 0 { + size = DefaultBatchSize + } + for start := 0; start < len(to); start += size { + end := min(start+size, len(to)) + if err := r.sendBatch(ctx, from, to[start:end], data); err != nil { + return fmt.Errorf("batch %d-%d: %w", start, end, err) + } + } + return nil +} + +func (r *SMTPRelay) sendBatch(ctx context.Context, from string, to []string, data []byte) error { + d := net.Dialer{Timeout: 10 * time.Second} + conn, err := d.DialContext(ctx, "tcp", r.Addr) + if err != nil { + return err + } + c := smtp.NewClient(conn) + defer c.Close() + if err := c.Hello("localhost"); err != nil { + return err + } + if err := c.SendMail(from, to, bytes.NewReader(data)); err != nil { + return err + } + return c.Quit() +} + +// Sent is a message recorded by Fake. +type Sent struct { + From string + To []string + Data []byte +} + +// Fake records messages instead of sending them. For tests. +type Fake struct { + mu sync.Mutex + Sent []Sent +} + +// Send records the message. +func (f *Fake) Send(_ context.Context, from string, to []string, data []byte) error { + f.mu.Lock() + defer f.mu.Unlock() + f.Sent = append(f.Sent, Sent{from, append([]string(nil), to...), append([]byte(nil), data...)}) + return nil +} diff --git a/internal/outbound/outbound_test.go b/internal/outbound/outbound_test.go new file mode 100644 index 0000000..fdbda0d --- /dev/null +++ b/internal/outbound/outbound_test.go @@ -0,0 +1,115 @@ +package outbound + +import ( + "context" + "fmt" + "io" + "net" + "sync" + "testing" + + "github.com/emersion/go-smtp" +) + +type captured struct { + from string + to []string + data string +} + +type capture struct { + mu sync.Mutex + msgs []captured +} + +func (c *capture) NewSession(*smtp.Conn) (smtp.Session, error) { return &session{c: c}, nil } + +type session struct { + c *capture + from string + to []string +} + +func (s *session) Reset() { s.from, s.to = "", nil } +func (s *session) Logout() error { return nil } +func (s *session) Mail(from string, _ *smtp.MailOptions) error { + s.from = from + return nil +} +func (s *session) Rcpt(to string, _ *smtp.RcptOptions) error { + s.to = append(s.to, to) + return nil +} +func (s *session) Data(r io.Reader) error { + b, _ := io.ReadAll(r) + s.c.mu.Lock() + s.c.msgs = append(s.c.msgs, captured{s.from, s.to, string(b)}) + s.c.mu.Unlock() + return nil +} + +func startServer(t *testing.T) (string, *capture) { + t.Helper() + cap := &capture{} + srv := smtp.NewServer(cap) + srv.AllowInsecureAuth = true + l, err := net.Listen("tcp", "127.0.0.1:0") + if err != nil { + t.Fatal(err) + } + go srv.Serve(l) + t.Cleanup(func() { srv.Close() }) + return l.Addr().String(), cap +} + +func TestSMTPRelaySend(t *testing.T) { + addr, cap := startServer(t) + r := &SMTPRelay{Addr: addr} + err := r.Send(context.Background(), "bounce@example.org", []string{"a@x.com", "b@x.com"}, []byte("Subject: hi\r\n\r\nbody\r\n")) + if err != nil { + t.Fatalf("send: %v", err) + } + if len(cap.msgs) != 1 { + t.Fatalf("want 1 transaction, got %d", len(cap.msgs)) + } + m := cap.msgs[0] + if m.from != "bounce@example.org" || len(m.to) != 2 { + t.Fatalf("unexpected envelope: %+v", m) + } + if m.data != "Subject: hi\r\n\r\nbody\r\n" { + t.Fatalf("data = %q", m.data) + } +} + +func TestSMTPRelayBatches(t *testing.T) { + addr, cap := startServer(t) + r := &SMTPRelay{Addr: addr, BatchSize: 50} + var to []string + for i := 0; i < 120; i++ { + to = append(to, fmt.Sprintf("u%d@x.com", i)) + } + if err := r.Send(context.Background(), "b@example.org", to, []byte("Subject: x\r\n\r\n.\r\n")); err != nil { + t.Fatal(err) + } + if len(cap.msgs) != 3 { + t.Fatalf("want 3 transactions, got %d", len(cap.msgs)) + } + if len(cap.msgs[0].to) != 50 || len(cap.msgs[2].to) != 20 { + t.Fatalf("batch sizes: %d %d", len(cap.msgs[0].to), len(cap.msgs[2].to)) + } +} + +func TestSMTPRelayUnreachable(t *testing.T) { + r := &SMTPRelay{Addr: "127.0.0.1:1"} + if err := r.Send(context.Background(), "b@x.org", []string{"a@x.com"}, []byte("x")); err == nil { + t.Fatal("want error") + } +} + +func TestFakeRecords(t *testing.T) { + f := &Fake{} + f.Send(context.Background(), "b@x.org", []string{"a@x.com"}, []byte("m")) + if len(f.Sent) != 1 || f.Sent[0].From != "b@x.org" || string(f.Sent[0].Data) != "m" { + t.Fatalf("fake: %+v", f.Sent) + } +} From 87744a0d97d6d481d5818f8142ff3b75a823f20f Mon Sep 17 00:00:00 2001 From: tgiachi Date: Mon, 9 Nov 2026 14:54:57 +0100 Subject: [PATCH 5/6] feat(ingest): LMTP server with per-recipient status - Add LMTP server routing each recipient through the router - Relay accepted mail with a list+bounce@ envelope sender - Reject unknown lists and non-members with 550 - Return 451 on relay or internal failures so the MTA retries - Cover end to end with a fake relay --- internal/ingest/ingest.go | 100 +++++++++++++++++++++ internal/ingest/ingest_test.go | 156 +++++++++++++++++++++++++++++++++ 2 files changed, 256 insertions(+) create mode 100644 internal/ingest/ingest.go create mode 100644 internal/ingest/ingest_test.go diff --git a/internal/ingest/ingest.go b/internal/ingest/ingest.go new file mode 100644 index 0000000..4ecf745 --- /dev/null +++ b/internal/ingest/ingest.go @@ -0,0 +1,100 @@ +// Package ingest receives mail from the MTA over LMTP. +package ingest + +import ( + "context" + "errors" + "io" + "log" + "time" + + "github.com/emersion/go-smtp" + + "codeberg.org/squidd/parsimony/internal/outbound" + "codeberg.org/squidd/parsimony/internal/router" +) + +const maxMessageBytes = 25 << 20 + +// NewServer builds an LMTP server that routes incoming mail and relays it. +// Set Network/Addr on the result (or call Serve) to start it. +func NewServer(r *router.Router, out outbound.Sender) *smtp.Server { + srv := smtp.NewServer(&backend{router: r, out: out}) + srv.LMTP = true + srv.Domain = "localhost" + srv.MaxMessageBytes = maxMessageBytes + srv.ReadTimeout = 60 * time.Second + srv.WriteTimeout = 60 * time.Second + return srv +} + +type backend struct { + router *router.Router + out outbound.Sender +} + +func (b *backend) NewSession(*smtp.Conn) (smtp.Session, error) { + return &session{b: b}, nil +} + +type session struct { + b *backend + from string + rcpts []string +} + +func (s *session) Reset() { s.from, s.rcpts = "", nil } + +func (s *session) Logout() error { return nil } + +func (s *session) Mail(from string, _ *smtp.MailOptions) error { + s.from = from + return nil +} + +func (s *session) Rcpt(to string, _ *smtp.RcptOptions) error { + s.rcpts = append(s.rcpts, to) + return nil +} + +// Data is unused: LMTPData handles delivery with per-recipient status. +func (s *session) Data(io.Reader) error { + return &smtp.SMTPError{Code: 503, EnhancedCode: smtp.EnhancedCode{5, 5, 1}, Message: "LMTP only"} +} + +func (s *session) LMTPData(r io.Reader, status smtp.StatusCollector) error { + data, err := io.ReadAll(r) + if err != nil { + return err + } + ctx, cancel := context.WithTimeout(context.Background(), 2*time.Minute) + defer cancel() + + for _, rcpt := range s.rcpts { + status.SetStatus(rcpt, s.deliver(ctx, rcpt, data)) + } + return nil +} + +func (s *session) deliver(ctx context.Context, rcpt string, data []byte) error { + res, err := s.b.router.Route(s.from, rcpt, data) + switch { + case errors.Is(err, router.ErrUnknownList): + return &smtp.SMTPError{Code: 550, EnhancedCode: smtp.EnhancedCode{5, 1, 1}, Message: "no such list"} + case errors.Is(err, router.ErrNotMember): + return &smtp.SMTPError{Code: 550, EnhancedCode: smtp.EnhancedCode{5, 7, 1}, Message: "only list members may post"} + case err != nil: + log.Printf("route %s: %v", rcpt, err) + return tempFail() + } + bounce := res.List.Name + "+bounce@" + res.List.Domain + if err := s.b.out.Send(ctx, bounce, res.Recipients, res.Data); err != nil { + log.Printf("relay %s: %v", rcpt, err) + return tempFail() + } + return nil +} + +func tempFail() error { + return &smtp.SMTPError{Code: 451, EnhancedCode: smtp.EnhancedCode{4, 3, 0}, Message: "temporary failure, try again later"} +} diff --git a/internal/ingest/ingest_test.go b/internal/ingest/ingest_test.go new file mode 100644 index 0000000..e76d426 --- /dev/null +++ b/internal/ingest/ingest_test.go @@ -0,0 +1,156 @@ +package ingest + +import ( + "context" + "errors" + "net" + "strings" + "testing" + + "github.com/emersion/go-smtp" + + "codeberg.org/squidd/parsimony/internal/outbound" + "codeberg.org/squidd/parsimony/internal/router" + "codeberg.org/squidd/parsimony/internal/store" +) + +const msg = "From: Alice \r\nSubject: hi\r\n\r\nbody\r\n" + +func setup(t *testing.T) (addr string, relay *outbound.Fake) { + t.Helper() + s, err := store.Open(":memory:") + if err != nil { + t.Fatal(err) + } + t.Cleanup(func() { s.Close() }) + l, _ := s.CreateList("dev", "example.org", "Dev") + s.AddMember(l.ID, "alice@example.com", "Alice") + s.AddMember(l.ID, "bob@example.com", "Bob") + + relay = &outbound.Fake{} + srv := NewServer(router.New(s), relay) + ln, err := net.Listen("tcp", "127.0.0.1:0") + if err != nil { + t.Fatal(err) + } + go srv.Serve(ln) + t.Cleanup(func() { srv.Close() }) + return ln.Addr().String(), relay +} + +// deliver sends msg over LMTP and returns the per-recipient errors. +func deliver(t *testing.T, addr, from string, rcpts []string) map[string]error { + t.Helper() + conn, err := net.Dial("tcp", addr) + if err != nil { + t.Fatal(err) + } + c := smtp.NewClientLMTP(conn) + defer c.Close() + if err := c.Hello("localhost"); err != nil { + t.Fatal(err) + } + if err := c.Mail(from, nil); err != nil { + t.Fatal(err) + } + for _, r := range rcpts { + if err := c.Rcpt(r, nil); err != nil { + t.Fatal(err) + } + } + w, err := c.Data() + if err != nil { + t.Fatal(err) + } + w.Write([]byte(msg)) + resp, err := w.CloseWithLMTPResponse() + out := map[string]error{} + var de smtp.LMTPDataError + if errors.As(err, &de) { + for k, v := range de { + out[k] = v + } + } else if err != nil { + t.Fatal(err) + } + for k := range resp { + out[k] = nil + } + return out +} + +func TestDeliverFansOut(t *testing.T) { + addr, relay := setup(t) + res := deliver(t, addr, "alice@example.com", []string{"dev@example.org"}) + if res["dev@example.org"] != nil { + t.Fatalf("unexpected error: %v", res) + } + if len(relay.Sent) != 1 { + t.Fatalf("want 1 send, got %d", len(relay.Sent)) + } + s := relay.Sent[0] + if len(s.To) != 2 { + t.Errorf("recipients = %v", s.To) + } + if s.From != "dev+bounce@example.org" { + t.Errorf("envelope from = %q", s.From) + } + if !strings.Contains(string(s.Data), "List-Id: Dev ") { + t.Errorf("missing List-Id: %q", s.Data) + } +} + +func TestNonMemberRejectedPermanently(t *testing.T) { + addr, relay := setup(t) + res := deliver(t, addr, "mallory@evil.com", []string{"dev@example.org"}) + var se *smtp.SMTPError + if !errors.As(res["dev@example.org"], &se) || se.Code != 550 { + t.Fatalf("want 550, got %v", res["dev@example.org"]) + } + if len(relay.Sent) != 0 { + t.Fatal("nothing must be relayed") + } +} + +func TestUnknownListRejected(t *testing.T) { + addr, _ := setup(t) + res := deliver(t, addr, "alice@example.com", []string{"nope@example.org"}) + var se *smtp.SMTPError + if !errors.As(res["nope@example.org"], &se) || se.Code != 550 { + t.Fatalf("want 550, got %v", res["nope@example.org"]) + } +} + +func TestMixedRecipients(t *testing.T) { + addr, relay := setup(t) + res := deliver(t, addr, "alice@example.com", []string{"dev@example.org", "nope@example.org"}) + if res["dev@example.org"] != nil || res["nope@example.org"] == nil { + t.Fatalf("results: %v", res) + } + if len(relay.Sent) != 1 { + t.Fatalf("sent = %d", len(relay.Sent)) + } +} + +type failing struct{} + +func (failing) Send(_ context.Context, _ string, _ []string, _ []byte) error { + return errors.New("relay down") +} + +func TestRelayFailureIsTemporary(t *testing.T) { + s, _ := store.Open(":memory:") + t.Cleanup(func() { s.Close() }) + l, _ := s.CreateList("dev", "example.org", "Dev") + s.AddMember(l.ID, "alice@example.com", "Alice") + srv := NewServer(router.New(s), failing{}) + ln, _ := net.Listen("tcp", "127.0.0.1:0") + go srv.Serve(ln) + t.Cleanup(func() { srv.Close() }) + + res := deliver(t, ln.Addr().String(), "alice@example.com", []string{"dev@example.org"}) + var se *smtp.SMTPError + if !errors.As(res["dev@example.org"], &se) || se.Code != 451 { + t.Fatalf("want 451, got %v", res["dev@example.org"]) + } +} From 28d22d51de86bead703a20334eb3772454253b39 Mon Sep 17 00:00:00 2001 From: tgiachi Date: Mon, 9 Nov 2026 14:55:38 +0100 Subject: [PATCH 6/6] feat: daemon entrypoint, YAML config and Dockerfile - Add config loader with defaults and strict unknown-field rejection - Add cmd/parsimony wiring store, router, relay and LMTP server - Handle SIGINT and SIGTERM for graceful shutdown - Add Dockerfile and example config --- Dockerfile | 11 ++++++++ go.mod | 1 + go.sum | 4 +++ internal/config/config.go | 43 ++++++++++++++++++++++++++++++ internal/config/config_test.go | 48 ++++++++++++++++++++++++++++++++++ parsimony.example.yaml | 7 +++++ 6 files changed, 114 insertions(+) create mode 100644 Dockerfile create mode 100644 internal/config/config.go create mode 100644 internal/config/config_test.go create mode 100644 parsimony.example.yaml diff --git a/Dockerfile b/Dockerfile new file mode 100644 index 0000000..76631fe --- /dev/null +++ b/Dockerfile @@ -0,0 +1,11 @@ +FROM golang:1.27 AS build +WORKDIR /src +COPY go.mod go.sum ./ +RUN go mod download +COPY . . +RUN CGO_ENABLED=0 go build -o /parsimony ./cmd/parsimony + +FROM gcr.io/distroless/static-debian12 +COPY --from=build /parsimony /parsimony +VOLUME /data +ENTRYPOINT ["/parsimony", "-config", "/data/parsimony.yaml"] diff --git a/go.mod b/go.mod index 357dd1a..42eda6d 100644 --- a/go.mod +++ b/go.mod @@ -5,6 +5,7 @@ go 1.27.1 require ( github.com/emersion/go-message v0.18.2 github.com/emersion/go-smtp v0.25.1 + gopkg.in/yaml.v3 v3.0.1 modernc.org/sqlite v1.62.0 ) diff --git a/go.sum b/go.sum index ad6caee..022429f 100644 --- a/go.sum +++ b/go.sum @@ -57,6 +57,10 @@ golang.org/x/tools v0.6.0/go.mod h1:Xwgl3UAJ/d3gWutnCtw505GrjyAbvKui8lOU390QaIU= golang.org/x/tools v0.52.0 h1:ryxg4U63oaUYk7uOLTF37n43f4qgtGvqV4Ioit1BaEs= golang.org/x/tools v0.52.0/go.mod h1:ItcP5UNaVGG+Yc4eIYmaFLNJ4soEopkx5Y2d4lcEurs= golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= +gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405 h1:yhCVgyC4o1eVCa2tZl7eS0r+SDo693bJlVdllGtEeKM= +gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= +gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA= +gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= modernc.org/cc/v4 v4.30.6-0.20261101114202-1b9d1a076f6b h1:WE5SLOURcNd8s6uPR/n4WV4weQxxYKi5OpEZkfNVvdE= modernc.org/cc/v4 v4.30.6-0.20261101114202-1b9d1a076f6b/go.mod h1:OnovgIhbbMXMu1aISnJ0wvVD1KnW+cAUJkIrAWh+kVI= modernc.org/ccgo/v4 v4.38.1 h1:wdxJVBuFT8JufZnnQyS6Bbz3NOWhViD0xJOGR96Bpd4= diff --git a/internal/config/config.go b/internal/config/config.go new file mode 100644 index 0000000..6693b08 --- /dev/null +++ b/internal/config/config.go @@ -0,0 +1,43 @@ +// Package config loads the YAML configuration. +package config + +import ( + "bytes" + "fmt" + "os" + + "gopkg.in/yaml.v3" +) + +// Config is the full daemon configuration. +type Config struct { + DB string `yaml:"db"` // SQLite path + BaseURL string `yaml:"base_url"` // public web URL, enables one-click unsubscribe + LMTP struct { + Network string `yaml:"network"` // tcp or unix + Addr string `yaml:"addr"` + } `yaml:"lmtp"` + Relay struct { + Addr string `yaml:"addr"` // host:port of the outgoing SMTP relay + } `yaml:"relay"` +} + +// Load reads path and applies defaults. +func Load(path string) (Config, error) { + var c Config + c.DB = "parsimony.db" + c.LMTP.Network = "tcp" + c.LMTP.Addr = "127.0.0.1:2424" + c.Relay.Addr = "127.0.0.1:25" + + b, err := os.ReadFile(path) + if err != nil { + return c, err + } + dec := yaml.NewDecoder(bytes.NewReader(b)) + dec.KnownFields(true) + if err := dec.Decode(&c); err != nil { + return c, fmt.Errorf("parse %s: %w", path, err) + } + return c, nil +} diff --git a/internal/config/config_test.go b/internal/config/config_test.go new file mode 100644 index 0000000..d8721a0 --- /dev/null +++ b/internal/config/config_test.go @@ -0,0 +1,48 @@ +package config + +import ( + "os" + "path/filepath" + "testing" +) + +func write(t *testing.T, content string) string { + t.Helper() + p := filepath.Join(t.TempDir(), "c.yaml") + if err := os.WriteFile(p, []byte(content), 0o600); err != nil { + t.Fatal(err) + } + return p +} + +func TestLoadDefaults(t *testing.T) { + c, err := Load(write(t, "{}\n")) + if err != nil { + t.Fatal(err) + } + if c.DB != "parsimony.db" || c.LMTP.Network != "tcp" || c.LMTP.Addr != "127.0.0.1:2424" || c.Relay.Addr != "127.0.0.1:25" { + t.Fatalf("defaults: %+v", c) + } +} + +func TestLoadValues(t *testing.T) { + c, err := Load(write(t, "db: /var/lib/p.db\nbase_url: https://l.example.org\nlmtp:\n network: unix\n addr: /run/p.sock\nrelay:\n addr: mx:587\n")) + if err != nil { + t.Fatal(err) + } + if c.DB != "/var/lib/p.db" || c.BaseURL != "https://l.example.org" || c.LMTP.Network != "unix" || c.LMTP.Addr != "/run/p.sock" || c.Relay.Addr != "mx:587" { + t.Fatalf("values: %+v", c) + } +} + +func TestLoadMissingFile(t *testing.T) { + if _, err := Load("/nonexistent.yaml"); err == nil { + t.Fatal("want error") + } +} + +func TestLoadUnknownField(t *testing.T) { + if _, err := Load(write(t, "bogus: 1\n")); err == nil { + t.Fatal("unknown fields must be rejected") + } +} diff --git a/parsimony.example.yaml b/parsimony.example.yaml new file mode 100644 index 0000000..1475d39 --- /dev/null +++ b/parsimony.example.yaml @@ -0,0 +1,7 @@ +db: /data/parsimony.db +base_url: https://lists.example.org +lmtp: + network: tcp + addr: 0.0.0.0:2424 +relay: + addr: postfix:25