Resolve PTR names over DNS-over-HTTPS and cache them for the record TTL (closes #238)

`internal/ptr` asks Google, Cloudflare, AdGuard and Quad9 in turn, 2 seconds in all per address. It keeps answers in memory and writes them through to `cache.db`, opened by the new `internal/cachedb`. A reserved address is not sent to the resolvers.

Judgement calls:
- Each resolver gets an equal share of the time left, so a hung resolver does not use up the 2 seconds.
- The negative TTL is the smaller of the SOA minimum and the SOA's own TTL (RFC 2308).
- Names that are not host names are dropped, as `net.Resolver.LookupAddr` does.

Model: opus-5-5

internal/cachedb/cachedb.go

@@ -0,0 +1,51 @@
+// Package cachedb opens cache.db, the SQLite file in the state directory that
+// holds RouteWatch's caches of answers from outside services. It is separate
+// from the routes database so that a cache write never queues behind a write
+// to that database.
+package cachedb
+
+import (
+	"context"
+	"database/sql"
+	_ "embed" // for schema.sql
+	"fmt"
+	"path/filepath"
+
+	_ "github.com/mattn/go-sqlite3" // CGO SQLite driver
+)
+
+const (
+	// fileName is the database's file in the state directory.
+	fileName = "cache.db"
+
+	// busyTimeoutMs is how long a write waits for another write to finish.
+	busyTimeoutMs = 5000
+)
+
+//go:embed schema.sql
+var schema string
+
+// Open opens cache.db in stateDir, creating the file and its tables when they
+// do not exist. The caller closes the database.
+func Open(ctx context.Context, stateDir string) (*sql.DB, error) {
+	dsn := fmt.Sprintf(
+		"file:%s?_journal_mode=WAL&_synchronous=NORMAL&_busy_timeout=%d"+
+			"&_txlock=immediate",
+		filepath.Join(stateDir, fileName),
+		busyTimeoutMs,
+	)
+
+	db, err := sql.Open("sqlite3", dsn)
+	if err != nil {
+		return nil, fmt.Errorf("opening the cache database: %w", err)
+	}
+
+	_, err = db.ExecContext(ctx, schema)
+	if err != nil {
+		_ = db.Close()
+
+		return nil, fmt.Errorf("creating the cache database's tables: %w", err)
+	}
+
+	return db, nil
+}

internal/cachedb/cachedb_internal_test.go

@@ -0,0 +1,64 @@
+package cachedb
+
+import (
+	"os"
+	"path/filepath"
+	"testing"
+)
+
+// TestOpenCreatesTheFileInWALMode opens a new database, and then opens it
+// again, as a restart does.
+func TestOpenCreatesTheFileInWALMode(t *testing.T) {
+	t.Parallel()
+
+	dir := t.TempDir()
+
+	for range 2 {
+		db, err := Open(t.Context(), dir)
+		if err != nil {
+			t.Fatalf("Open: %v", err)
+		}
+
+		var mode string
+
+		err = db.QueryRowContext(t.Context(), "PRAGMA journal_mode").Scan(&mode)
+		if err != nil {
+			t.Fatalf("reading the journal mode: %v", err)
+		}
+
+		if mode != "wal" {
+			t.Errorf("journal mode %q, want wal", mode)
+		}
+
+		var rows int
+
+		err = db.QueryRowContext(t.Context(),
+			"SELECT COUNT(*) FROM hostnames").Scan(&rows)
+		if err != nil {
+			t.Fatalf("reading the hostnames table: %v", err)
+		}
+
+		err = db.Close()
+		if err != nil {
+			t.Fatalf("Close: %v", err)
+		}
+	}
+
+	_, err := os.Stat(filepath.Join(dir, fileName))
+	if err != nil {
+		t.Errorf("the file is not in the state directory: %v", err)
+	}
+}
+
+// TestOpenFailsWhenTheDirectoryDoesNotExist checks that a state directory that
+// is not there is reported, not ignored.
+func TestOpenFailsWhenTheDirectoryDoesNotExist(t *testing.T) {
+	t.Parallel()
+
+	db, err := Open(t.Context(), filepath.Join(t.TempDir(), "missing"))
+	if err == nil {
+		_ = db.Close()
+
+		t.Fatal("Open succeeded in a directory that does not exist")
+	}
+}

internal/cachedb/schema.sql

@@ -0,0 +1,8 @@
+-- hostnames holds the PTR names of addresses. names has the names separated by
+-- spaces, and is empty for an address with no PTR names. expires_at is in
+-- seconds since 1970.
+CREATE TABLE IF NOT EXISTS hostnames (
+    address TEXT PRIMARY KEY,
+    names TEXT NOT NULL,
+    expires_at INTEGER NOT NULL
+);