From 9eb4d14a7033e9f47aa1063f57106c5e33d00661 Mon Sep 17 00:00:00 2001 From: tgiachi Date: Mon, 9 Nov 2026 15:03:08 +0100 Subject: [PATCH] feat(store): schema v2 with moderation, pending requests and bounce state - Add member id, disabled flag and bounce counter - Add per-list post and join policies - Add held message queue - Add expiring, rate-limited pending subscribe and unsubscribe tokens - Add persistent HMAC secret - Migrate databases created by milestone 1 --- internal/store/m2_test.go | 185 ++++++++++++++ internal/store/store.go | 514 ++++++++++++++++++++++++++++++-------- 2 files changed, 590 insertions(+), 109 deletions(-) create mode 100644 internal/store/m2_test.go diff --git a/internal/store/m2_test.go b/internal/store/m2_test.go new file mode 100644 index 0000000..67cd590 --- /dev/null +++ b/internal/store/m2_test.go @@ -0,0 +1,185 @@ +package store + +import ( + "database/sql" + "errors" + "path/filepath" + "testing" + "time" +) + +func TestListPolicies(t *testing.T) { + s := newTestStore(t) + l, _ := s.CreateList("dev", "example.org", "Dev") + if l.PostPolicy != "members" || l.JoinPolicy != "open" { + t.Fatalf("defaults: %+v", l) + } + if err := s.SetPolicies(l.ID, "moderated", "closed"); err != nil { + t.Fatal(err) + } + got, _ := s.GetList(l.ID) + if got.PostPolicy != "moderated" || got.JoinPolicy != "closed" { + t.Fatalf("policies: %+v", got) + } + if err := s.SetPolicies(l.ID, "bogus", "open"); err == nil { + t.Fatal("invalid policy must be rejected") + } + if err := s.SetPolicies(999, "members", "open"); !errors.Is(err, ErrNotFound) { + t.Fatalf("want ErrNotFound, got %v", err) + } +} + +func TestHeldQueue(t *testing.T) { + s := newTestStore(t) + l, _ := s.CreateList("dev", "example.org", "Dev") + id, err := s.HoldMessage(l.ID, "bob@x.com", []byte("Subject: hi\r\n\r\nx")) + if err != nil { + t.Fatal(err) + } + hs, err := s.ListHeld(l.ID) + if err != nil || len(hs) != 1 || hs[0].ID != id || hs[0].Sender != "bob@x.com" { + t.Fatalf("held: %+v %v", hs, err) + } + h, err := s.GetHeld(id) + if err != nil || string(h.Data) != "Subject: hi\r\n\r\nx" || h.ListID != l.ID { + t.Fatalf("get: %+v %v", h, err) + } + if err := s.DeleteHeld(id); err != nil { + t.Fatal(err) + } + if _, err := s.GetHeld(id); !errors.Is(err, ErrNotFound) { + t.Fatal("held message should be gone") + } + if err := s.DeleteHeld(id); !errors.Is(err, ErrNotFound) { + t.Fatalf("want ErrNotFound, got %v", err) + } +} + +func TestPendingTokens(t *testing.T) { + s := newTestStore(t) + now := time.Unix(1_000_000, 0) + s.Now = func() time.Time { return now } + l, _ := s.CreateList("dev", "example.org", "Dev") + + tok, created, err := s.CreatePending(l.ID, "A@x.com", "join") + if err != nil || !created || tok == "" { + t.Fatalf("create: %q %v %v", tok, created, err) + } + // Rate limit: same request within an hour is not recreated. + now = now.Add(30 * time.Minute) + if _, created, _ := s.CreatePending(l.ID, "a@x.com", "join"); created { + t.Fatal("must be rate limited") + } + // A different action is independent. + if _, created, _ := s.CreatePending(l.ID, "a@x.com", "leave"); !created { + t.Fatal("leave is a separate request") + } + p, err := s.ConfirmPending(tok) + if err != nil || p.Address != "a@x.com" || p.Action != "join" || p.ListID != l.ID { + t.Fatalf("confirm: %+v %v", p, err) + } + if _, err := s.ConfirmPending(tok); !errors.Is(err, ErrNotFound) { + t.Fatal("token is single use") + } + if _, err := s.ConfirmPending("nope"); !errors.Is(err, ErrNotFound) { + t.Fatal("unknown token") + } + // Expiry. + tok2, _, _ := s.CreatePending(l.ID, "b@x.com", "join") + now = now.Add(73 * time.Hour) + if _, err := s.ConfirmPending(tok2); !errors.Is(err, ErrNotFound) { + t.Fatal("token must expire after 72h") + } +} + +func TestSecretIsStable(t *testing.T) { + s := newTestStore(t) + a, err := s.Secret() + if err != nil || len(a) < 32 { + t.Fatalf("secret: %x %v", a, err) + } + b, _ := s.Secret() + if string(a) != string(b) { + t.Fatal("secret must not change") + } +} + +func TestBounceDisablesAfterThreshold(t *testing.T) { + s := newTestStore(t) + l, _ := s.CreateList("dev", "example.org", "Dev") + s.AddMember(l.ID, "a@x.com", "A") + ms, _ := s.Members(l.ID) + id := ms[0].ID + + for i := 1; i <= 2; i++ { + disabled, err := s.RecordHardBounce(id, 3) + if err != nil || disabled { + t.Fatalf("bounce %d: %v %v", i, disabled, err) + } + } + disabled, _ := s.RecordHardBounce(id, 3) + if !disabled { + t.Fatal("third hard bounce must disable") + } + ms, _ = s.Members(l.ID) + if !ms[0].Disabled || ms[0].BounceCount != 3 { + t.Fatalf("member: %+v", ms[0]) + } + if act, _ := s.ActiveMembers(l.ID); len(act) != 0 { + t.Fatalf("active: %+v", act) + } + // Re-adding resets the state. + s.AddMember(l.ID, "a@x.com", "A") + act, _ := s.ActiveMembers(l.ID) + if len(act) != 1 || act[0].BounceCount != 0 || act[0].ID != id { + t.Fatalf("after re-add: %+v", act) + } + m, err := s.MemberByID(id) + if err != nil || m.Address != "a@x.com" || m.ListID != l.ID { + t.Fatalf("by id: %+v %v", m, err) + } + if _, err := s.MemberByID(999); !errors.Is(err, ErrNotFound) { + t.Fatal("unknown id") + } + if _, err := s.RecordHardBounce(999, 3); !errors.Is(err, ErrNotFound) { + t.Fatal("unknown id") + } +} + +func TestMigrateFromM1(t *testing.T) { + path := filepath.Join(t.TempDir(), "old.db") + db, err := sql.Open("sqlite", path) + if err != nil { + t.Fatal(err) + } + _, err = db.Exec(` +CREATE TABLE lists (id INTEGER PRIMARY KEY AUTOINCREMENT, name TEXT NOT NULL, domain TEXT NOT NULL, title TEXT NOT NULL DEFAULT '', UNIQUE(name, domain)); +CREATE TABLE 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)); +INSERT INTO lists(name, domain, title) VALUES('dev','example.org','Dev'); +INSERT INTO members(list_id, address, display_name) VALUES(1,'a@x.com','A'),(1,'b@x.com','B');`) + if err != nil { + t.Fatal(err) + } + db.Close() + + s, err := Open(path) + if err != nil { + t.Fatalf("migrate: %v", err) + } + defer s.Close() + l, err := s.FindList("dev@example.org") + if err != nil || l.PostPolicy != "members" || l.JoinPolicy != "open" { + t.Fatalf("list: %+v %v", l, err) + } + ms, _ := s.Members(l.ID) + if len(ms) != 2 || ms[0].ID == 0 || ms[0].Address != "a@x.com" { + t.Fatalf("members: %+v", ms) + } + s.Close() + // Opening again is a no-op. + s2, err := Open(path) + if err != nil { + t.Fatal(err) + } + s2.Close() +} diff --git a/internal/store/store.go b/internal/store/store.go index 9bf527f..e74e487 100644 --- a/internal/store/store.go +++ b/internal/store/store.go @@ -1,27 +1,52 @@ -// Package store persists lists and members in SQLite. +// Package store persists lists, members and moderation state in SQLite. package store import ( + "crypto/rand" "database/sql" + "encoding/hex" "errors" "fmt" "strings" + "time" _ "modernc.org/sqlite" ) -// ErrNotFound is returned when a list or member does not exist. -var ErrNotFound = errors.New("not found") +var ( + // ErrNotFound is returned when a record does not exist. + ErrNotFound = errors.New("not found") + // ErrExists is returned when creating something that already exists. + ErrExists = errors.New("already exists") +) -// ErrExists is returned when creating something that already exists. -var ErrExists = errors.New("already exists") +// Policy values. +const ( + PostMembers = "members" // only members may post, others are rejected + PostModerated = "moderated" // every post waits for approval + JoinOpen = "open" // anyone can subscribe (with confirmation) + JoinClosed = "closed" // only the admin adds members +) + +// Pending actions. +const ( + ActionJoin = "join" + ActionLeave = "leave" +) + +const ( + pendingTTL = 72 * time.Hour + pendingRateLimit = time.Hour +) // List is a mailing list. type List struct { - ID int64 - Name string // local part, lowercase - Domain string // lowercase - Title string + ID int64 + Name string // local part, lowercase + Domain string // lowercase + Title string + PostPolicy string + JoinPolicy string } // Address returns the list posting address. @@ -29,26 +54,74 @@ func (l List) Address() string { return l.Name + "@" + l.Domain } // Member is a list subscriber. type Member struct { + ID int64 + ListID int64 Address string // lowercase DisplayName string + Disabled bool // too many hard bounces: no more delivery + BounceCount int +} + +// Held is a message waiting for moderation. +type Held struct { + ID int64 + ListID int64 + Sender string + Data []byte + CreatedAt time.Time +} + +// Pending is an unconfirmed subscribe or unsubscribe request. +type Pending struct { + Token string + ListID int64 + Address string + Action string } // Store wraps the SQLite database. -type Store struct{ db *sql.DB } +type Store struct { + db *sql.DB + // Now returns the current time; tests replace it. + Now func() time.Time +} 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 '', + id INTEGER PRIMARY KEY AUTOINCREMENT, + name TEXT NOT NULL, + domain TEXT NOT NULL, + title TEXT NOT NULL DEFAULT '', + post_policy TEXT NOT NULL DEFAULT 'members', + join_policy TEXT NOT NULL DEFAULT 'open', UNIQUE(name, domain) ); CREATE TABLE IF NOT EXISTS members ( + id INTEGER PRIMARY KEY AUTOINCREMENT, 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) + disabled INTEGER NOT NULL DEFAULT 0, + bounce_count INTEGER NOT NULL DEFAULT 0, + UNIQUE(list_id, address) +); +CREATE TABLE IF NOT EXISTS held ( + id INTEGER PRIMARY KEY AUTOINCREMENT, + list_id INTEGER NOT NULL REFERENCES lists(id) ON DELETE CASCADE, + sender TEXT NOT NULL, + data BLOB NOT NULL, + created_at INTEGER NOT NULL +); +CREATE TABLE IF NOT EXISTS pending ( + token TEXT PRIMARY KEY, + list_id INTEGER NOT NULL REFERENCES lists(id) ON DELETE CASCADE, + address TEXT NOT NULL, + action TEXT NOT NULL, + created_at INTEGER NOT NULL +); +CREATE TABLE IF NOT EXISTS settings ( + key TEXT PRIMARY KEY, + value TEXT NOT NULL );` // Open opens (and migrates) the database at path. Use ":memory:" for tests. @@ -63,106 +136,60 @@ func Open(path string) (*Store, error) { db.Close() return nil, err } - if _, err := db.Exec(schema); err != nil { + if err := migrate(db); err != nil { db.Close() return nil, fmt.Errorf("migrate: %w", err) } - return &Store{db: db}, nil + return &Store{db: db, Now: time.Now}, nil +} + +func hasColumn(db *sql.DB, table, column string) (bool, error) { + var n int + err := db.QueryRow(`SELECT COUNT(*) FROM pragma_table_info(?) WHERE name=?`, table, column).Scan(&n) + return n > 0, err +} + +// migrate upgrades a database created by milestone 1, then ensures the schema. +func migrate(db *sql.DB) error { + if ok, err := hasColumn(db, "members", "list_id"); err != nil { + return err + } else if ok { + if hasID, err := hasColumn(db, "members", "id"); err != nil { + return err + } else if !hasID { + if _, err := db.Exec(`ALTER TABLE members RENAME TO members_v1`); err != nil { + return err + } + if _, err := db.Exec(schema); err != nil { + return err + } + if _, err := db.Exec(`INSERT INTO members(list_id, address, display_name) + SELECT list_id, address, display_name FROM members_v1 ORDER BY list_id, address; + DROP TABLE members_v1;`); err != nil { + return err + } + } + } + if ok, err := hasColumn(db, "lists", "name"); err != nil { + return err + } else if ok { + if has, _ := hasColumn(db, "lists", "post_policy"); !has { + if _, err := db.Exec(`ALTER TABLE lists ADD COLUMN post_policy TEXT NOT NULL DEFAULT 'members'; + ALTER TABLE lists ADD COLUMN join_policy TEXT NOT NULL DEFAULT 'open';`); err != nil { + return err + } + } + } + _, err := db.Exec(schema) + return err } // 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 { - if strings.Contains(err.Error(), "UNIQUE") { - return List{}, ErrExists - } - return List{}, err - } - l.ID, _ = res.LastInsertId() - return l, nil -} +func norm(addr string) string { return strings.ToLower(strings.TrimSpace(addr)) } -// 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() -} - -// ListLists returns every list ordered by address. -func (s *Store) ListLists() ([]List, error) { - rows, err := s.db.Query(`SELECT id, name, domain, title FROM lists ORDER BY domain, name`) - if err != nil { - return nil, err - } - defer rows.Close() - var out []List - for rows.Next() { - var l List - if err := rows.Scan(&l.ID, &l.Name, &l.Domain, &l.Title); err != nil { - return nil, err - } - out = append(out, l) - } - return out, rows.Err() -} - -// GetList returns a list by id. -func (s *Store) GetList(id int64) (List, error) { - var l List - err := s.db.QueryRow(`SELECT id, name, domain, title FROM lists WHERE id=?`, id). - Scan(&l.ID, &l.Name, &l.Domain, &l.Title) - if errors.Is(err, sql.ErrNoRows) { - return List{}, ErrNotFound - } - return l, err -} +func isUnique(err error) bool { return err != nil && strings.Contains(err.Error(), "UNIQUE") } func affected(res sql.Result, err error) error { if err != nil { @@ -174,18 +201,287 @@ func affected(res sql.Result, err error) error { return nil } +// Lists. + +const listCols = `id, name, domain, title, post_policy, join_policy` + +func scanList(row interface{ Scan(...any) error }) (List, error) { + var l List + err := row.Scan(&l.ID, &l.Name, &l.Domain, &l.Title, &l.PostPolicy, &l.JoinPolicy) + if errors.Is(err, sql.ErrNoRows) { + return List{}, ErrNotFound + } + return l, err +} + +// CreateList adds a new list with default policies. +func (s *Store) CreateList(name, domain, title string) (List, error) { + res, err := s.db.Exec(`INSERT INTO lists(name, domain, title) VALUES(?,?,?)`, + strings.ToLower(name), strings.ToLower(domain), title) + if isUnique(err) { + return List{}, ErrExists + } + if err != nil { + return List{}, err + } + id, _ := res.LastInsertId() + return s.GetList(id) +} + +// FindList resolves a posting address like "dev@example.org". +func (s *Store) FindList(addr string) (List, error) { + name, domain, ok := strings.Cut(norm(addr), "@") + if !ok { + return List{}, ErrNotFound + } + return scanList(s.db.QueryRow(`SELECT `+listCols+` FROM lists WHERE name=? AND domain=?`, name, domain)) +} + +// GetList returns a list by id. +func (s *Store) GetList(id int64) (List, error) { + return scanList(s.db.QueryRow(`SELECT `+listCols+` FROM lists WHERE id=?`, id)) +} + +// ListLists returns every list ordered by address. +func (s *Store) ListLists() ([]List, error) { + rows, err := s.db.Query(`SELECT ` + listCols + ` FROM lists ORDER BY domain, name`) + if err != nil { + return nil, err + } + defer rows.Close() + var out []List + for rows.Next() { + l, err := scanList(rows) + if err != nil { + return nil, err + } + out = append(out, l) + } + return out, rows.Err() +} + // UpdateList changes the title of a list. func (s *Store) UpdateList(id int64, title string) error { return affected(s.db.Exec(`UPDATE lists SET title=? WHERE id=?`, title, id)) } -// DeleteList removes a list and its members. +// SetPolicies changes the post and join policies of a list. +func (s *Store) SetPolicies(id int64, post, join string) error { + if post != PostMembers && post != PostModerated { + return fmt.Errorf("invalid post policy %q", post) + } + if join != JoinOpen && join != JoinClosed { + return fmt.Errorf("invalid join policy %q", join) + } + return affected(s.db.Exec(`UPDATE lists SET post_policy=?, join_policy=? WHERE id=?`, post, join, id)) +} + +// DeleteList removes a list with its members, held messages and pending requests. func (s *Store) DeleteList(id int64) error { return affected(s.db.Exec(`DELETE FROM lists WHERE id=?`, id)) } +// Members. + +const memberCols = `id, list_id, address, display_name, disabled, bounce_count` + +func scanMember(row interface{ Scan(...any) error }) (Member, error) { + var m Member + var dis int + err := row.Scan(&m.ID, &m.ListID, &m.Address, &m.DisplayName, &dis, &m.BounceCount) + if errors.Is(err, sql.ErrNoRows) { + return Member{}, ErrNotFound + } + m.Disabled = dis != 0 + return m, err +} + +// AddMember subscribes an address to a list. Re-adding keeps the member id and +// clears the bounce state. +func (s *Store) AddMember(listID int64, addr, displayName string) error { + _, err := s.db.Exec(`INSERT INTO members(list_id, address, display_name) VALUES(?,?,?) + ON CONFLICT(list_id, address) DO UPDATE SET display_name=excluded.display_name, disabled=0, bounce_count=0`, + listID, norm(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, norm(addr)).Scan(&n) + return n > 0, err +} + +func (s *Store) queryMembers(where string, args ...any) ([]Member, error) { + rows, err := s.db.Query(`SELECT `+memberCols+` FROM members WHERE `+where+` ORDER BY address`, args...) + if err != nil { + return nil, err + } + defer rows.Close() + var out []Member + for rows.Next() { + m, err := scanMember(rows) + if err != nil { + return nil, err + } + out = append(out, m) + } + return out, rows.Err() +} + +// Members returns all subscribers of a list, including disabled ones. +func (s *Store) Members(listID int64) ([]Member, error) { + return s.queryMembers(`list_id=?`, listID) +} + +// ActiveMembers returns the subscribers that should receive mail. +func (s *Store) ActiveMembers(listID int64) ([]Member, error) { + return s.queryMembers(`list_id=? AND disabled=0`, listID) +} + +// MemberByID returns a member by its id. +func (s *Store) MemberByID(id int64) (Member, error) { + return scanMember(s.db.QueryRow(`SELECT `+memberCols+` FROM members WHERE id=?`, id)) +} + // RemoveMember unsubscribes an address from a list. func (s *Store) RemoveMember(listID int64, addr string) error { - return affected(s.db.Exec(`DELETE FROM members WHERE list_id=? AND address=?`, - listID, strings.ToLower(strings.TrimSpace(addr)))) + return affected(s.db.Exec(`DELETE FROM members WHERE list_id=? AND address=?`, listID, norm(addr))) +} + +// RecordHardBounce counts a hard bounce and disables the member once the count +// reaches threshold. It reports whether the member is now disabled. +func (s *Store) RecordHardBounce(memberID int64, threshold int) (bool, error) { + if err := affected(s.db.Exec(`UPDATE members SET bounce_count=bounce_count+1 WHERE id=?`, memberID)); err != nil { + return false, err + } + if _, err := s.db.Exec(`UPDATE members SET disabled=1 WHERE id=? AND bounce_count>=?`, memberID, threshold); err != nil { + return false, err + } + m, err := s.MemberByID(memberID) + return m.Disabled, err +} + +// Held messages. + +// HoldMessage queues a message for moderation and returns its id. +func (s *Store) HoldMessage(listID int64, sender string, data []byte) (int64, error) { + res, err := s.db.Exec(`INSERT INTO held(list_id, sender, data, created_at) VALUES(?,?,?,?)`, + listID, norm(sender), data, s.Now().Unix()) + if err != nil { + return 0, err + } + return res.LastInsertId() +} + +func scanHeld(row interface{ Scan(...any) error }) (Held, error) { + var h Held + var ts int64 + err := row.Scan(&h.ID, &h.ListID, &h.Sender, &h.Data, &ts) + if errors.Is(err, sql.ErrNoRows) { + return Held{}, ErrNotFound + } + h.CreatedAt = time.Unix(ts, 0) + return h, err +} + +// ListHeld returns the held messages of a list, oldest first. +func (s *Store) ListHeld(listID int64) ([]Held, error) { + rows, err := s.db.Query(`SELECT id, list_id, sender, data, created_at FROM held WHERE list_id=? ORDER BY id`, listID) + if err != nil { + return nil, err + } + defer rows.Close() + var out []Held + for rows.Next() { + h, err := scanHeld(rows) + if err != nil { + return nil, err + } + out = append(out, h) + } + return out, rows.Err() +} + +// GetHeld returns a held message by id. +func (s *Store) GetHeld(id int64) (Held, error) { + return scanHeld(s.db.QueryRow(`SELECT id, list_id, sender, data, created_at FROM held WHERE id=?`, id)) +} + +// DeleteHeld discards a held message. +func (s *Store) DeleteHeld(id int64) error { + return affected(s.db.Exec(`DELETE FROM held WHERE id=?`, id)) +} + +// Pending confirmations. + +func randomHex(n int) (string, error) { + b := make([]byte, n) + if _, err := rand.Read(b); err != nil { + return "", err + } + return hex.EncodeToString(b), nil +} + +// CreatePending records a subscribe or unsubscribe request and returns its +// token. created is false when an identical request was made in the last hour: +// this limits how often a third party can trigger confirmation mail. +func (s *Store) CreatePending(listID int64, addr, action string) (token string, created bool, err error) { + addr = norm(addr) + now := s.Now() + var n int + err = s.db.QueryRow(`SELECT COUNT(*) FROM pending WHERE list_id=? AND address=? AND action=? AND created_at>?`, + listID, addr, action, now.Add(-pendingRateLimit).Unix()).Scan(&n) + if err != nil || n > 0 { + return "", false, err + } + token, err = randomHex(16) + if err != nil { + return "", false, err + } + _, err = s.db.Exec(`INSERT INTO pending(token, list_id, address, action, created_at) VALUES(?,?,?,?,?)`, + token, listID, addr, action, now.Unix()) + if err != nil { + return "", false, err + } + return token, true, nil +} + +// ConfirmPending consumes a token. Unknown, used and expired tokens give ErrNotFound. +func (s *Store) ConfirmPending(token string) (Pending, error) { + var p Pending + var ts int64 + err := s.db.QueryRow(`SELECT token, list_id, address, action, created_at FROM pending WHERE token=?`, token). + Scan(&p.Token, &p.ListID, &p.Address, &p.Action, &ts) + if errors.Is(err, sql.ErrNoRows) { + return Pending{}, ErrNotFound + } + if err != nil { + return Pending{}, err + } + if _, err := s.db.Exec(`DELETE FROM pending WHERE token=?`, token); err != nil { + return Pending{}, err + } + if s.Now().Sub(time.Unix(ts, 0)) > pendingTTL { + return Pending{}, ErrNotFound + } + return p, nil +} + +// Secret returns the HMAC secret, generating and saving it on first use. +func (s *Store) Secret() ([]byte, error) { + var v string + err := s.db.QueryRow(`SELECT value FROM settings WHERE key='secret'`).Scan(&v) + if errors.Is(err, sql.ErrNoRows) { + v, err = randomHex(32) + if err != nil { + return nil, err + } + if _, err = s.db.Exec(`INSERT INTO settings(key, value) VALUES('secret', ?)`, v); err != nil { + return nil, err + } + } else if err != nil { + return nil, err + } + return hex.DecodeString(v) }