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
This commit is contained in:
tgiachi 2026-11-09 14:54:57 +01:00
commit 87744a0d97
2 changed files with 256 additions and 0 deletions

100
internal/ingest/ingest.go Normal file
View file

@ -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"}
}

View file

@ -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 <alice@example.com>\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 <dev.example.org>") {
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"])
}
}