diff --git a/internal/router/commands.go b/internal/router/commands.go index bd8ab3d..b8c621a 100644 --- a/internal/router/commands.go +++ b/internal/router/commands.go @@ -94,6 +94,24 @@ func (r *Router) join(l store.List, sender string) error { return r.askConfirmation(l, sender, store.ActionJoin) } +// RequestJoin does what the +join command does for addr, for a caller that is not an LMTP session +// (the public subscribe form): there is no envelope sender to check, so the caller must have +// validated addr. It returns nil whenever nothing should be revealed: an unknown or closed list, an +// active member, a request the store rate limits. It returns an error only for internal failures. +func (r *Router) RequestJoin(listAddress, addr string) error { + l, err := r.store.FindList(listAddress) + if errors.Is(err, store.ErrNotFound) { + return nil + } + if err != nil { + return err + } + if err := r.join(l, addr); err != nil && !errors.Is(err, ErrJoinClosed) { + return err + } + return nil +} + func (r *Router) leave(l store.List, sender string) error { if ok, err := r.store.IsMember(l.ID, sender); err != nil || !ok { return err diff --git a/internal/router/m2_test.go b/internal/router/m2_test.go index ab9d060..92c96c7 100644 --- a/internal/router/m2_test.go +++ b/internal/router/m2_test.go @@ -628,3 +628,76 @@ func TestDroppingARCHeadersKeepsSimilarlyNamedOnes(t *testing.T) { t.Errorf("only the ARC- prefix is dropped: %v", h) } } + +func TestRequestJoinQueuesTheConfirmationMail(t *testing.T) { + e := newEnv(t) + if err := e.r.RequestJoin("dev@example.org", "carol@x.com"); err != nil { + t.Fatal(err) + } + e.flush() + m := lastMail(t, e.out) + if len(m.To) != 1 || m.To[0] != "carol@x.com" { + t.Fatalf("confirmation must go to the requester: %+v", m.To) + } + if ok, _ := e.s.IsMember(e.list.ID, "carol@x.com"); ok { + t.Fatal("not a member before confirming") + } + // The mail is the usual one: replying to it confirms. + if _, err := e.command("carol@x.com", "dev+confirm-"+token(t, m)+"@example.org", nil); err != nil { + t.Fatal(err) + } + if ok, _ := e.s.IsMember(e.list.ID, "carol@x.com"); !ok { + t.Fatal("carol must be a member after confirming") + } +} + +// Nothing may tell the caller whether the list exists, is closed, or the address is known. +func TestRequestJoinRevealsNothing(t *testing.T) { + e := newEnv(t) + closed, _ := e.s.CreateList("closed", "example.org", "Closed") + e.s.SetPolicies(closed.ID, store.PostMembers, store.JoinClosed, store.ArchivePrivate) + for _, c := range []struct{ name, list, addr string }{ + {"unknown list", "nope@example.org", "carol@x.com"}, + {"closed list", "closed@example.org", "carol@x.com"}, + {"active member", "dev@example.org", "alice@example.com"}, + } { + if err := e.r.RequestJoin(c.list, c.addr); err != nil { + t.Errorf("%s: want nil, got %v", c.name, err) + } + } + e.flush() + if len(e.out.Sent) != 0 { + t.Fatalf("no mail for these cases, sent %d", len(e.out.Sent)) + } + // Asking twice is rate limited by the store: still nil, still one mail. + e.r.RequestJoin("dev@example.org", "carol@x.com") + if err := e.r.RequestJoin("dev@example.org", "carol@x.com"); err != nil { + t.Fatalf("rate limited: want nil, got %v", err) + } + e.flush() + if len(e.out.Sent) != 1 { + t.Fatalf("one mail expected, sent %d", len(e.out.Sent)) + } +} + +func TestRequestJoinLetsABounceDisabledMemberRejoin(t *testing.T) { + e := newEnv(t) + for i := 0; i < store.BounceThreshold; i++ { + e.s.RecordHardBounce(e.alice, store.BounceThreshold) + } + if err := e.r.RequestJoin("dev@example.org", "alice@example.com"); err != nil { + t.Fatal(err) + } + e.flush() + if m := lastMail(t, e.out); len(m.To) != 1 || m.To[0] != "alice@example.com" { + t.Fatalf("to = %v", m.To) + } +} + +func TestRequestJoinReportsAnInternalFailure(t *testing.T) { + e := newEnv(t) + e.s.Close() + if err := e.r.RequestJoin("dev@example.org", "carol@x.com"); err == nil { + t.Fatal("a database failure must be reported") + } +}