parsimony/internal/web/web.go
tgiachi 19c845caab feat(web): public archive pages and one-click unsubscribe
- Add list index, paginated archive with search, and message pages with thread links
- Show only lists whose archive policy is public; hide others and foreign messages with 404
- Escape all content and obfuscate email addresses in subjects, senders and bodies
- Add GET confirm page and POST one-click unsubscribe with signed tokens
- Send CSP, nosniff, no-referrer and no-store headers
2026-11-09 15:20:45 +01:00

299 lines
9.4 KiB
Go

// Package web serves the public archive pages and the unsubscribe links.
package web
import (
"bytes"
"errors"
"html/template"
"log"
"net/http"
"net/url"
"strconv"
"strings"
"time"
"codeberg.org/squidd/parsimony/internal/archive"
"codeberg.org/squidd/parsimony/internal/router"
"codeberg.org/squidd/parsimony/internal/store"
)
const pageSize = 25
type server struct {
store *store.Store
router *router.Router
tmpl *template.Template
}
// New returns the public web handler.
func New(s *store.Store, rt *router.Router) http.Handler {
srv := &server{store: s, router: rt, tmpl: template.Must(template.New("").Funcs(template.FuncMap{
"hide": archive.Obfuscate,
"date": func(t time.Time) string { return t.UTC().Format("2006-01-02 15:04") },
}).Parse(templates))}
mux := http.NewServeMux()
mux.HandleFunc("GET /{$}", srv.index)
mux.HandleFunc("GET /archive/{address}", srv.archive)
mux.HandleFunc("GET /archive/{address}/{id}", srv.message)
mux.HandleFunc("GET /unsubscribe/{token}", srv.unsubscribePage)
mux.HandleFunc("POST /unsubscribe/{token}", srv.unsubscribe)
// Catch-all for GET so unknown paths get the HTML 404 page and other
// methods on known paths still answer 405.
mux.HandleFunc("GET /", func(w http.ResponseWriter, r *http.Request) { srv.notFound(w) })
return secure(mux)
}
// secure adds the headers every page needs.
func secure(next http.Handler) http.Handler {
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
h := w.Header()
h.Set("Content-Security-Policy", "default-src 'none'; style-src 'unsafe-inline'; form-action 'self'; base-uri 'none'; frame-ancestors 'none'")
h.Set("X-Content-Type-Options", "nosniff")
h.Set("Referrer-Policy", "no-referrer")
h.Set("Content-Type", "text/html; charset=utf-8")
if strings.HasPrefix(r.URL.Path, "/unsubscribe/") {
h.Set("Cache-Control", "no-store") // the URL carries a secret
}
next.ServeHTTP(w, r)
})
}
func (s *server) render(w http.ResponseWriter, status int, name string, data any) {
var buf bytes.Buffer
if err := s.tmpl.ExecuteTemplate(&buf, name, data); err != nil {
log.Printf("web: render %s: %v", name, err)
http.Error(w, "internal error", http.StatusInternalServerError)
return
}
w.WriteHeader(status)
w.Write(buf.Bytes())
}
func (s *server) notFound(w http.ResponseWriter) { s.render(w, http.StatusNotFound, "notfound", nil) }
func (s *server) fail(w http.ResponseWriter, err error) {
log.Printf("web: %v", err)
http.Error(w, "internal error", http.StatusInternalServerError)
}
// publicList resolves a list address and only returns lists with a public archive.
func (s *server) publicList(address string) (store.List, bool, error) {
l, err := s.store.FindList(address)
if errors.Is(err, store.ErrNotFound) || (err == nil && l.ArchivePolicy != store.ArchivePublic) {
return store.List{}, false, nil
}
return l, err == nil, err
}
func (s *server) index(w http.ResponseWriter, r *http.Request) {
all, err := s.store.ListLists()
if err != nil {
s.fail(w, err)
return
}
var lists []store.List
for _, l := range all {
if l.ArchivePolicy == store.ArchivePublic {
lists = append(lists, l)
}
}
s.render(w, http.StatusOK, "index", lists)
}
type archiveView struct {
List store.List
Query string
Messages []store.Message
Total int
Page int
PrevURL string
NextURL string
ResultText string
}
func (s *server) archive(w http.ResponseWriter, r *http.Request) {
l, ok, err := s.publicList(r.PathValue("address"))
if err != nil {
s.fail(w, err)
return
}
if !ok {
s.notFound(w)
return
}
q := strings.TrimSpace(r.URL.Query().Get("q"))
page, _ := strconv.Atoi(r.URL.Query().Get("page"))
page = max(page, 1)
fetch := func(offset int) ([]store.Message, int, error) {
if q != "" {
return s.store.SearchMessages(l.ID, q, pageSize, offset)
}
return s.store.ListMessages(l.ID, pageSize, offset)
}
ms, total, err := fetch((page - 1) * pageSize)
if err == nil {
if pages := (total + pageSize - 1) / pageSize; pages > 0 && page > pages {
page = pages
ms, total, err = fetch((page - 1) * pageSize)
}
}
if err != nil {
s.fail(w, err)
return
}
v := archiveView{List: l, Query: q, Messages: ms, Total: total, Page: page}
link := func(p int) string {
vals := url.Values{}
if q != "" {
vals.Set("q", q)
}
if p > 1 {
vals.Set("page", strconv.Itoa(p))
}
u := "/archive/" + l.Address()
if len(vals) > 0 {
u += "?" + vals.Encode()
}
return u
}
if page > 1 {
v.PrevURL = link(page - 1)
}
if page*pageSize < total {
v.NextURL = link(page + 1)
}
if q != "" {
v.ResultText = strconv.Itoa(total) + " results"
if total == 1 {
v.ResultText = "1 result"
}
}
s.render(w, http.StatusOK, "archive", v)
}
type messageView struct {
List store.List
Message store.Message
Thread []store.Message
}
func (s *server) message(w http.ResponseWriter, r *http.Request) {
l, ok, err := s.publicList(r.PathValue("address"))
if err != nil {
s.fail(w, err)
return
}
id, perr := strconv.ParseInt(r.PathValue("id"), 10, 64)
if !ok || perr != nil || id <= 0 {
s.notFound(w)
return
}
m, err := s.store.GetMessage(id)
if errors.Is(err, store.ErrNotFound) || (err == nil && m.ListID != l.ID) {
s.notFound(w) // also hides messages that belong to other lists
return
}
if err != nil {
s.fail(w, err)
return
}
thread, err := s.store.ThreadMessages(l.ID, m.ThreadID)
if err != nil {
s.fail(w, err)
return
}
s.render(w, http.StatusOK, "message", messageView{List: l, Message: m, Thread: thread})
}
func (s *server) unsubscribePage(w http.ResponseWriter, r *http.Request) {
l, err := s.router.CheckUnsubscribe(r.PathValue("token"))
switch {
case errors.Is(err, router.ErrBadToken):
s.notFound(w)
case errors.Is(err, router.ErrGone):
s.render(w, http.StatusOK, "unsubscribed", map[string]any{"Already": true})
case err != nil:
s.fail(w, err)
default:
s.render(w, http.StatusOK, "unsubscribe", l)
}
}
func (s *server) unsubscribe(w http.ResponseWriter, r *http.Request) {
err := s.router.Unsubscribe(r.PathValue("token"))
switch {
case errors.Is(err, router.ErrBadToken):
s.notFound(w)
case err != nil:
s.fail(w, err)
default:
s.render(w, http.StatusOK, "unsubscribed", map[string]any{"Already": false})
}
}
const templates = `
{{define "head"}}<!doctype html>
<html lang="en"><head><meta charset="utf-8"><meta name="viewport" content="width=device-width, initial-scale=1">
<title>{{.}}</title>
<style>
body{font:16px/1.5 system-ui,sans-serif;max-width:50rem;margin:2rem auto;padding:0 1rem;color:#222}
a{color:#0b5cad}
h1{font-size:1.5rem}
table{border-collapse:collapse;width:100%}
td,th{text-align:left;padding:.35rem .5rem;border-bottom:1px solid #ddd;vertical-align:top}
pre{white-space:pre-wrap;word-wrap:break-word;background:#f6f6f6;padding:1rem;border-radius:4px}
.muted{color:#666;font-size:.9rem}
.cur{font-weight:bold}
input[type=search]{padding:.35rem;width:16rem}
button{padding:.5rem 1rem;font-size:1rem}
nav a{margin-right:1rem}
</style></head><body>{{end}}
{{define "foot"}}</body></html>{{end}}
{{define "index"}}{{template "head" "Mailing list archives"}}
<h1>Mailing list archives</h1>
{{if .}}<ul>{{range .}}<li><a href="/archive/{{.Address}}">{{.Address}}</a> <span class="muted">{{.Title}}</span></li>{{end}}</ul>
{{else}}<p>No public archives.</p>{{end}}
{{template "foot"}}{{end}}
{{define "archive"}}{{template "head" .List.Title}}
<nav><a href="/">All lists</a></nav>
<h1>{{.List.Title}}</h1>
<p class="muted">{{.List.Address}}</p>
<form method="get" action="/archive/{{.List.Address}}"><input type="search" name="q" value="{{.Query}}" placeholder="Search"> <button>Search</button></form>
{{if .Query}}<p class="muted">{{.ResultText}} for "{{.Query}}"</p>{{end}}
{{if .Messages}}<table><tr><th>Subject</th><th>From</th><th>Date</th></tr>
{{range .Messages}}<tr><td><a href="/archive/{{$.List.Address}}/{{.ID}}">{{hide .Subject}}</a></td><td>{{hide .Sender}}</td><td class="muted">{{date .Date}}</td></tr>
{{end}}</table>
<p>{{if .PrevURL}}<a href="{{.PrevURL}}">&larr; Newer</a>{{end}} {{if .NextURL}}<a href="{{.NextURL}}">Older &rarr;</a>{{end}}</p>
{{else}}<p>{{if .Query}}No messages found.{{else}}No messages yet.{{end}}</p>{{end}}
{{template "foot"}}{{end}}
{{define "message"}}{{template "head" (hide .Message.Subject)}}
<nav><a href="/">All lists</a><a href="/archive/{{.List.Address}}">{{.List.Title}}</a></nav>
<h1>{{hide .Message.Subject}}</h1>
<p class="muted">{{hide .Message.Sender}} &middot; {{date .Message.Date}}</p>
<pre>{{hide .Message.Body}}</pre>
{{if gt (len .Thread) 1}}<h2>Thread</h2><ul>
{{range .Thread}}<li>{{if eq .ID $.Message.ID}}<span class="cur">{{hide .Subject}}</span>{{else}}<a href="/archive/{{$.List.Address}}/{{.ID}}">{{hide .Subject}}</a>{{end}}
<span class="muted">{{hide .Sender}}, {{date .Date}}</span></li>{{end}}</ul>{{end}}
{{template "foot"}}{{end}}
{{define "unsubscribe"}}{{template "head" "Unsubscribe"}}
<h1>Unsubscribe</h1>
<p>Stop receiving messages from <strong>{{.Title}}</strong> ({{.Address}})?</p>
<form method="post"><button>Unsubscribe</button></form>
{{template "foot"}}{{end}}
{{define "unsubscribed"}}{{template "head" "Unsubscribed"}}
<h1>{{if .Already}}You are already unsubscribed{{else}}You are unsubscribed{{end}}</h1>
<p>{{if .Already}}This address no longer receives messages from the list.{{else}}You will not receive any more messages from the list.{{end}}</p>
{{template "foot"}}{{end}}
{{define "notfound"}}{{template "head" "Not found"}}
<h1>Not found</h1><p><a href="/">Back to the archives</a></p>
{{template "foot"}}{{end}}
`