- Rename the Go module from codeberg.org/squidd/parsimony to git.kmalloc.org/squid/parsimony in go.mod and every import. - Fix .gitignore: the bare `parsimony` pattern also ignored the cmd/parsimony folder, so the main package was never committed and a clean checkout could not be built. Anchor it to the root (`/parsimony`) and add cmd/parsimony.
485 lines
16 KiB
Go
485 lines
16 KiB
Go
// Package web serves the public archive pages and the unsubscribe links.
|
|
package web
|
|
|
|
import (
|
|
"bytes"
|
|
"encoding/base64"
|
|
"errors"
|
|
"html/template"
|
|
"log"
|
|
"net"
|
|
"net/http"
|
|
"net/mail"
|
|
"net/url"
|
|
"strconv"
|
|
"strings"
|
|
"time"
|
|
"unicode"
|
|
|
|
"git.kmalloc.org/squid/parsimony/assets"
|
|
"git.kmalloc.org/squid/parsimony/internal/archive"
|
|
"git.kmalloc.org/squid/parsimony/internal/router"
|
|
"git.kmalloc.org/squid/parsimony/internal/store"
|
|
)
|
|
|
|
const pageSize = 25
|
|
|
|
// faviconURL is the logo as a data: URI, the only kind of image the CSP allows.
|
|
var faviconURL = "data:image/svg+xml;base64," + base64.StdEncoding.EncodeToString([]byte(assets.Mark))
|
|
|
|
type server struct {
|
|
store *store.Store
|
|
router *router.Router
|
|
tmpl *template.Template
|
|
limit *subscribeLimiter
|
|
// trusted are the reverse proxies whose X-Forwarded-For is believed.
|
|
trusted []*net.IPNet
|
|
}
|
|
|
|
// New returns the public web handler. trustedProxies are the reverse proxies allowed to name the
|
|
// client in X-Forwarded-For (none: the TCP peer is the client).
|
|
func New(s *store.Store, rt *router.Router, trustedProxies []*net.IPNet) http.Handler {
|
|
return newHandler(s, rt, time.Now, trustedProxies)
|
|
}
|
|
|
|
// newHandler is New with an injectable clock, for the tests.
|
|
func newHandler(s *store.Store, rt *router.Router, now func() time.Time, trusted []*net.IPNet) http.Handler {
|
|
srv := &server{store: s, router: rt, limit: newSubscribeLimiter(now), trusted: trusted, tmpl: template.Must(template.New("").Funcs(template.FuncMap{
|
|
"hide": archive.Obfuscate,
|
|
// The logo is a trusted static asset: inline, so the strict CSP needs no image source for it.
|
|
"mark": func() template.HTML { return template.HTML(assets.Mark) },
|
|
"favicon": func() template.URL { return template.URL(faviconURL) },
|
|
"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 /subscribe/{address}", srv.subscribeForm)
|
|
mux.HandleFunc("POST /subscribe/{address}", srv.subscribe)
|
|
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'; img-src data:; 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
|
|
}
|
|
if strings.HasPrefix(r.URL.Path, "/subscribe/") {
|
|
h.Set("Cache-Control", "no-store") // a form with an address typed into it
|
|
}
|
|
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
|
|
// CanSubscribe is true when /subscribe/{address} serves this list.
|
|
CanSubscribe bool
|
|
}
|
|
|
|
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, CanSubscribe: l.JoinPolicy == store.JoinOpen}
|
|
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})
|
|
}
|
|
|
|
// subscribableList resolves a list for the subscribe form: it must have a public archive and accept
|
|
// self-service subscriptions. Anything else is reported as missing, so a private or closed list
|
|
// cannot be told from one that does not exist.
|
|
func (s *server) subscribableList(address string) (store.List, bool, error) {
|
|
l, ok, err := s.publicList(address)
|
|
if err != nil || !ok || l.JoinPolicy != store.JoinOpen {
|
|
return store.List{}, false, err
|
|
}
|
|
return l, true, nil
|
|
}
|
|
|
|
type subscribeView struct {
|
|
List store.List
|
|
Email string
|
|
Error string
|
|
}
|
|
|
|
func (s *server) subscribeForm(w http.ResponseWriter, r *http.Request) {
|
|
l, ok, err := s.subscribableList(r.PathValue("address"))
|
|
switch {
|
|
case err != nil:
|
|
s.fail(w, err)
|
|
case !ok:
|
|
s.notFound(w)
|
|
default:
|
|
s.render(w, http.StatusOK, "subscribe", subscribeView{List: l})
|
|
}
|
|
}
|
|
|
|
// maxSubscribeBody is plenty for an email address and a honeypot field.
|
|
const maxSubscribeBody = 4 << 10
|
|
|
|
func (s *server) subscribe(w http.ResponseWriter, r *http.Request) {
|
|
if wait, ok := s.limit.allow(clientKey(r, s.trusted)); !ok {
|
|
w.Header().Set("Retry-After", strconv.Itoa(int((wait+time.Second-1)/time.Second)))
|
|
s.render(w, http.StatusTooManyRequests, "toomany", nil)
|
|
return
|
|
}
|
|
l, ok, err := s.subscribableList(r.PathValue("address"))
|
|
if err != nil {
|
|
s.fail(w, err)
|
|
return
|
|
}
|
|
if !ok {
|
|
s.notFound(w)
|
|
return
|
|
}
|
|
r.Body = http.MaxBytesReader(w, r.Body, maxSubscribeBody)
|
|
if err := r.ParseForm(); err != nil {
|
|
var tooBig *http.MaxBytesError
|
|
if errors.As(err, &tooBig) {
|
|
http.Error(w, "request too large", http.StatusRequestEntityTooLarge)
|
|
return
|
|
}
|
|
}
|
|
// A bot that fills every field gets the page a person gets, and nothing happens.
|
|
if r.PostForm.Get("website") != "" {
|
|
s.render(w, http.StatusOK, "subscribed", nil)
|
|
return
|
|
}
|
|
typed := r.PostForm.Get("email")
|
|
addr, ok := plainAddress(typed)
|
|
if !ok {
|
|
s.render(w, http.StatusBadRequest, "subscribe", subscribeView{List: l, Email: printable(typed), Error: "Enter a valid email address."})
|
|
return
|
|
}
|
|
if err := s.router.RequestJoin(l.Address(), addr); err != nil {
|
|
s.fail(w, err)
|
|
return
|
|
}
|
|
s.render(w, http.StatusOK, "subscribed", nil)
|
|
}
|
|
|
|
// printable drops control characters, so what was typed can be shown back safely.
|
|
func printable(s string) string {
|
|
return strings.Map(func(r rune) rune {
|
|
if unicode.IsControl(r) {
|
|
return -1
|
|
}
|
|
return r
|
|
}, s)
|
|
}
|
|
|
|
// plainAddress accepts one bare ASCII address of at most 254 characters: no display name, no angle
|
|
// brackets, no list, no quoting, no control characters, and a public domain (see publicDomain).
|
|
func plainAddress(s string) (string, bool) {
|
|
s = strings.TrimSpace(s)
|
|
if s == "" || len(s) > 254 {
|
|
return "", false
|
|
}
|
|
for _, c := range []byte(s) {
|
|
if c <= ' ' || c >= 0x7f {
|
|
return "", false
|
|
}
|
|
}
|
|
a, err := mail.ParseAddress(s)
|
|
if err != nil || a.Name != "" || a.Address != s || !publicDomain(s[strings.LastIndexByte(s, '@')+1:]) {
|
|
return "", false
|
|
}
|
|
return s, true
|
|
}
|
|
|
|
// publicDomain accepts a domain name that can be on the Internet: dotted labels of letters, digits
|
|
// and hyphens, not an IP address, and not one of the names reserved for local use. A domain literal
|
|
// ([127.0.0.1]), a bare host (localhost) or a .local name would make the daemon mail itself or its
|
|
// network.
|
|
func publicDomain(d string) bool {
|
|
d = strings.ToLower(d)
|
|
if !strings.Contains(d, ".") {
|
|
return false
|
|
}
|
|
for _, label := range strings.Split(d, ".") {
|
|
if label == "" || strings.ContainsFunc(label, func(r rune) bool {
|
|
return !(r >= 'a' && r <= 'z' || r >= '0' && r <= '9' || r == '-')
|
|
}) {
|
|
return false
|
|
}
|
|
}
|
|
// No top-level domain is all digits: such a name is an IP address (a@127.0.0.1).
|
|
if strings.Trim(d[strings.LastIndexByte(d, '.')+1:], "0123456789") == "" {
|
|
return false
|
|
}
|
|
for _, local := range []string{".localhost", ".local", ".internal", ".invalid"} {
|
|
if strings.HasSuffix(d, local) {
|
|
return false
|
|
}
|
|
}
|
|
return true
|
|
}
|
|
|
|
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>
|
|
<link rel="icon" type="image/svg+xml" href="{{favicon}}">
|
|
<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}
|
|
.error{color:#b00020}
|
|
.hp{position:absolute;left:-10000px;width:1px;height:1px;overflow:hidden}
|
|
input[type=email]{padding:.35rem;width:20rem;max-width:100%}
|
|
.brand{display:inline-block;margin-bottom:1rem}
|
|
.brand svg{width:2rem;height:2rem;display:block}
|
|
</style></head><body>
|
|
<a class="brand" href="/" aria-label="All archives">{{mark}}</a>{{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>{{if .CanSubscribe}}<a href="/subscribe/{{.List.Address}}">Subscribe</a>{{end}}</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}}">← Newer</a>{{end}} {{if .NextURL}}<a href="{{.NextURL}}">Older →</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}} · {{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 "subscribe"}}{{template "head" (print "Subscribe to " .List.Title)}}
|
|
<nav><a href="/">All lists</a><a href="/archive/{{.List.Address}}">{{.List.Title}}</a></nav>
|
|
<h1>Subscribe to {{.List.Title}}</h1>
|
|
<p class="muted">{{.List.Address}}</p>
|
|
{{if .Error}}<p class="error" role="alert">{{.Error}}</p>{{end}}
|
|
<form method="post" action="/subscribe/{{.List.Address}}">
|
|
<p><label>Email address<br><input type="email" name="email" value="{{.Email}}" required maxlength="254" autocomplete="email"></label></p>
|
|
<div class="hp" aria-hidden="true"><label>Leave this empty<input type="text" name="website" tabindex="-1" autocomplete="off"></label></div>
|
|
<button>Subscribe</button>
|
|
</form>
|
|
<p class="muted">We send one message to confirm the address. Nothing happens until you reply to it.</p>
|
|
{{template "foot"}}{{end}}
|
|
|
|
{{define "subscribed"}}{{template "head" "Check your email"}}
|
|
<h1>Check your email</h1>
|
|
<p>If this address can subscribe, a confirmation message is on its way. Open it and reply to confirm.</p>
|
|
{{template "foot"}}{{end}}
|
|
|
|
{{define "toomany"}}{{template "head" "Too many requests"}}
|
|
<h1>Too many requests</h1><p>Please try again later.</p>
|
|
{{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}}
|
|
`
|