From 87744a0d97d6d481d5818f8142ff3b75a823f20f Mon Sep 17 00:00:00 2001 From: tgiachi Date: Mon, 9 Nov 2026 14:54:57 +0100 Subject: [PATCH] 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"]) + } +}