state: a state file without a section loads it empty (closes #267)

Load fills in each of domains, hostnames, ports and certificates that
the file leaves out or holds as null with an empty map. Before, such a
section loaded as a nil map, and the first check's write into it
panicked, so a state file holding {} stopped the watcher at every
start.

A state test loads {} and a file missing each section in turn, and
checks that every section is an empty map. A watcher test loads {}, and
a file without the certificates section, runs the first check against
live DNS, and checks that it saved domain, hostname, port and
certificate entries.

Model: opus-5-5

README.md

@@ -104,11 +104,9 @@ notification endpoint set, changes show only on the dashboard; see
   NS change notification above. A domain listed in
   `DNSWATCHER_SKIP_RECORD_NOTIFICATIONS` gets no record change or inconsistency
   notification. A domain with no delegation of its own has these records asked
-  at the servers of the zone it is in, as a hostname has. When none of those
+  at the servers of the zone it is in, as a hostname has. A nameserver the
-  servers answers, the lookup of its NS record set fails, and they are saved as
+  domain's records were asked at on the previous check but not on this one gets
-  failed and notified as a hostname's are (see below). A nameserver the domain's
+  a hostname's NS change notification (see below), unless it was in the domain's
-  records were asked at on the previous check but not on this one gets a
-  hostname's NS change notification (see below), unless it was in the domain's
   delegation on the previous check, as when that delegation is withdrawn. A
   domain that does not exist has none: they are not asked for, and those saved
   by an earlier check are removed without a notification.
@@ -123,13 +121,7 @@ notification endpoint set, changes show only on the dashboard; see
   trace moves from a name to its parent only when the servers asked answer that
   the name has no delegation of its own, or does not exist. When they do not
   answer, the check fails and the hostname's records from the previous check are
-  kept, unless they are the nameservers the previous check saved for the
+  kept.
-  hostname. Each of those is then saved as failed, with the reason, as a
-  domain's nameservers are when none of them answers, so it gets an NS query
-  failure notification, and an NS recovery notification when it answers again
-  (see below). A trace that gets no answer before it reaches them, as when the
-  host running dnswatcher loses its network, fails the check without a
-  notification.
 - Queries **each** authoritative nameserver independently for **all** record
   types: A, AAAA, CNAME, MX, TXT, SRV, CAA, NS.
 - Each record type is a query of its own. When a nameserver answers some types
@@ -231,14 +223,8 @@ notification endpoint set, changes show only on the dashboard; see
     - Certificate CN, issuer, or SANs changed (replacement detected, reports old
       and new CN and issuer).
     - TLS connection failure to a previously-reachable IP:443 (handshake error,
-      timeout, or connection refused when port 443 closed after the port check
+      timeout, connection refused after previously succeeding).
-      that found it open).
     - TLS recovery: a previously-failing IP:443 now completes a handshake again.
-- A port check that finds port 443 closed removes the certificate entries for
-  that IP address, without a notification of its own: the port change
-  notification reports the closed port. When the port opens again, the next TLS
-  check saves the certificate as new, without a certificate change or recovery
-  notification.
 
 ### Notifications
 
@@ -308,10 +294,8 @@ clears them.
   port entry left with no name goes, so the dashboard and `/api/v1/status` no
   longer list or count it. The first check's port checks remove the port entries
   of addresses no configured name has.
-- Each port check also removes, without a notification, the certificate entries
+- Each port check also removes the certificate entries for an address their name
-  for an address whose port 443 it found closed, and those for an address their
+  no longer resolves to, except while none of the name's nameservers answer.
-  name no longer resolves to, except while none of the name's nameservers
-  answer.
 
 ### Web Dashboard
 
@@ -674,12 +658,6 @@ for A, AAAA and CNAME, the previous check's list is kept, or `null` when no
 earlier check saved one. A state file without it loads, and the first check
 after that saves it without a notification.
 
-A port entry's key is its address and port, and a certificate entry's key its
-address, port 443 and hostname, joined by colons. An IPv6 address is written in
-brackets in these keys, as in `[2001:db8::1]:443` and
-`[2001:db8::1]:443:www.example.com`. `/api/v1/status` and the dashboard show the
-same keys.
-
 A port entry's `hostnames` lists every name that resolves to its address,
 domains included. A port entry in the older format, with one `hostname` instead
 of the `hostnames` list, loads as a list of that one name.

TODO.md

@@ -10,23 +10,15 @@
 
 # Status
 
-pre-1.0. Work lands on `next` by PR. Open work for 1.0 is tracked on the 1.0
+pre-1.0. No git tags. Work lands on `next` by PR. Open work for 1.0 is tracked
-milestone: https://git.eeqj.de/sneak/dnswatcher/milestone/7
+on the 1.0 milestone: https://git.eeqj.de/sneak/dnswatcher/milestone/7
 
 # Next Step
 
-1.0 tracking issue: https://git.eeqj.de/sneak/dnswatcher/issues/66
+trial run of the finished image: https://git.eeqj.de/sneak/dnswatcher/issues/149
 
 # Completed Steps
 
-- 2026-10-13: a hostname or a domain whose zone's nameservers all stop answering
-  gets an NS Failure for each, then an NS Recovery (closes #284).
-- 2026-10-13: an IPv6 address is written in brackets before its port, as in
-  `[2001:db8::1]:443`, in keys and Port Change notifications (closes #270).
-- 2026-10-13: `TODO.md` names only open issues as next and future steps, and its
-  Status says nothing about git tags (closes #281).
-- 2026-10-13: a port check that finds port 443 closed removes that address's
-  certificate entries, so none is left shown as `ok` (closes #265).
 - 2026-10-13: a state file holding `{}`, or leaving out a section, loads with
   that section empty; the first check no longer crashes on it (closes #267).
 - 2026-10-13: a stop before the first scan completes sends no startup
@@ -207,4 +199,6 @@ milestone: https://git.eeqj.de/sneak/dnswatcher/milestone/7
 
 # Future Steps
 
-- DNSSEC validation, after 1.0: https://git.eeqj.de/sneak/dnswatcher/issues/59
+- 1.0 readiness: run it with a real config and read the logs:
+  https://git.eeqj.de/sneak/dnswatcher/issues/66
+- review toward 1.0: https://git.eeqj.de/sneak/dnswatcher/issues/144

internal/resolver/errors.go

@@ -2,23 +2,6 @@ package resolver
 
 import "errors"
 
-// NoAnswerError is returned when the walk to a name's nameservers
-// reached a zone through a referral and none of that zone's
-// nameservers, Nameservers as the referral names them, answered. Err
-// says why they did not.
-type NoAnswerError struct {
-	Nameservers []string
-	Err         error
-}
-
-func (e *NoAnswerError) Error() string {
-	return e.Err.Error()
-}
-
-func (e *NoAnswerError) Unwrap() error {
-	return e.Err
-}
-
 // Sentinel errors returned by the resolver.
 var (
 	// ErrNoNameservers is returned when no authoritative NS

internal/resolver/export_test.go

@@ -31,11 +31,9 @@ func NewWithQueryTimeout(log *slog.Logger, timeout time.Duration) *Resolver {
 func (r *Resolver) FollowDelegation(
 	ctx context.Context,
 	domain string,
-	zone string,
-	nameservers []string,
 	servers []string,
 ) ([]string, error) {
-	return r.followDelegation(ctx, domain, zone, nameservers, servers)
+	return r.followDelegation(ctx, domain, servers)
 }
 
 // FindAuthoritativeNameserversFrom exports findAuthoritativeNameservers

internal/resolver/iterative.go

@@ -204,24 +204,20 @@ func glueIPs(nsNames []string, glue map[string][]net.IP) []string {
 	return ips
 }
 
-// followDelegation follows referrals to domain from servers, the
+// followDelegation follows referrals from servers, the root servers, to
-// addresses of the servers of zone, and returns the NS set of domain's
+// domain and returns the NS set of domain's delegation. When the servers
-// delegation. nameservers are the names a referral gave the servers of
+// of the zone domain is in answer that domain does not exist, the error
-// zone; the walk to a name's nameservers starts at the root servers, the
+// is ErrNXDomain. When they answer that it has no delegation of its own,
-// servers of zone ".", which no referral names. When the servers of the
-// zone domain is in answer that domain does not exist, the error is
-// ErrNXDomain. When they answer that it has no delegation of its own,
 // because it is not the zone's apex, the set is empty and there is no
-// error. Any other error means that no such answer came; it is a
+// error. Any other error means that no such answer came.
-// *NoAnswerError when the servers that did not answer are those of a
-// zone a referral named.
 func (r *Resolver) followDelegation(
 	ctx context.Context,
 	domain string,
-	zone string,
-	nameservers []string,
 	servers []string,
 ) ([]string, error) {
+	// servers are the root servers, the servers of zone ".".
+	zone := "."
+
 	var withoutAddresses []string
 
 	for range maxDelegation {
@@ -232,12 +228,6 @@ func (r *Resolver) followDelegation(
 		resp, err := r.queryZone(
 			ctx, servers, withoutAddresses, zone, domain, dns.TypeNS, 0,
 		)
-
-		// A query that ctx cut short says nothing about the servers.
-		if err != nil && len(nameservers) > 0 && checkCtx(ctx) == nil {
-			return nil, &NoAnswerError{Nameservers: nameservers, Err: err}
-		}
-
 		if err != nil {
 			return nil, err
 		}
@@ -266,7 +256,6 @@ func (r *Resolver) followDelegation(
 			return r.resolveNSIterative(ctx, domain)
 		}
 
-		nameservers = authNS
 		servers, withoutAddresses = referralNameservers(resp)
 		zone = referralZone(resp)
 	}
@@ -637,8 +626,7 @@ func (r *Resolver) resolveARecord(
 // them. When the servers asked answer that the name has no delegation
 // of its own, or does not exist, it tries each parent name in turn, so
 // it returns the nameservers of the zone the name is in. When they do
-// not answer, it returns the error and tries no parent name; when a
+// not answer, it returns the error and tries no parent name.
-// referral named them, the error is a *NoAnswerError naming them.
 func (r *Resolver) FindAuthoritativeNameservers(
 	ctx context.Context,
 	domain string,
@@ -667,7 +655,7 @@ func (r *Resolver) findAuthoritativeNameservers(
 
 		candidate := strings.Join(labels[i:], ".") + "."
 
-		nsNames, err := r.followDelegation(ctx, candidate, ".", nil, servers)
+		nsNames, err := r.followDelegation(ctx, candidate, servers)
 		if err != nil && !errors.Is(err, ErrNXDomain) {
 			return nil, err
 		}
@@ -1079,7 +1067,7 @@ func (r *Resolver) LookupNS(
 	}
 
 	return r.followDelegation(
-		ctx, dns.Fqdn(strings.ToLower(domain)), ".", nil, rootServerList(),
+		ctx, dns.Fqdn(strings.ToLower(domain)), rootServerList(),
 	)
 }
 

internal/resolver/resolver_test.go

@@ -121,9 +121,7 @@ func TestFindAuthoritativeNameservers_DelegatedSubdomain(
 // delegation of its own, so the lookup returns that walk's error, about
 // www.google.com, and tries no parent name: trying google.com and com
 // would end in ErrNoNameservers, or in the error of a walk for one of
-// them. The servers that did not answer are those the walk started at,
+// them.
-// which no referral named, so the error is no NoAnswerError, as when
-// the host running dnswatcher has lost its network.
 func TestFindAuthoritativeNameservers_NoAnswer(t *testing.T) {
 	t.Parallel()
 
@@ -136,9 +134,6 @@ func TestFindAuthoritativeNameservers_NoAnswer(t *testing.T) {
 	require.NotErrorIs(t, err, resolver.ErrNoNameservers)
 	assert.Contains(t, err.Error(), "query www.google.com. @"+noAnswerAddress)
 	assert.Empty(t, nameservers)
-
-	var noAnswer *resolver.NoAnswerError
-	assert.NotErrorAs(t, err, &noAnswer)
 }
 
 func TestFindAuthoritativeNameservers_ReturnsSorted(
@@ -959,34 +954,12 @@ func TestFollowDelegation_NoAnswer(t *testing.T) {
 	r := resolver.NewWithQueryTimeout(slog.Default(), 100*time.Millisecond)
 
 	nameservers, err := r.FollowDelegation(
-		t.Context(), "google.com.", ".", nil, []string{noAnswerAddress},
+		t.Context(), "google.com.", []string{noAnswerAddress},
 	)
 	require.Error(t, err)
 	assert.Empty(t, nameservers)
 }
 
-// TestFollowDelegation_NoAnswerAfterReferral starts the walk for
-// www.example.net at the servers of example.net as a referral names
-// them, ns1.example.net and ns2.example.net, at 192.0.2.1, where nothing
-// answers. The error is a NoAnswerError naming them, which the watcher
-// compares with the nameservers it saved for the name.
-func TestFollowDelegation_NoAnswerAfterReferral(t *testing.T) {
-	t.Parallel()
-
-	r := resolver.NewWithQueryTimeout(slog.Default(), 100*time.Millisecond)
-	nameservers := []string{"ns1.example.net.", "ns2.example.net."}
-
-	_, err := r.FollowDelegation(
-		t.Context(), "www.example.net.", "example.net.", nameservers,
-		[]string{noAnswerAddress},
-	)
-
-	var noAnswer *resolver.NoAnswerError
-	require.ErrorAs(t, err, &noAnswer)
-	assert.Equal(t, nameservers, noAnswer.Nameservers)
-	assert.Contains(t, err.Error(), "query www.example.net. @"+noAnswerAddress)
-}
-
 // TestResolveNSIterative_NoDelegationOfItsOwn walks to the nameservers
 // of www.google.com as the fallback walk does. As in
 // TestLookupNS_NoDelegationOfItsOwn, the set is empty, with no error.

internal/watcher/export_test.go

@@ -122,34 +122,6 @@ func (w *Watcher) RunTLSChecks(ctx context.Context) {
 	w.runTLSChecks(ctx)
 }
 
-// CheckHostnameResult exports checkHostnameResult for testing.
-func (w *Watcher) CheckHostnameResult(
-	ctx context.Context,
-	hostname string,
-	results map[string]*resolver.NameserverResponse,
-	err error,
-) bool {
-	return w.checkHostnameResult(ctx, hostname, results, err)
-}
-
-// CheckDomainResult exports checkDomainResult for testing.
-func (w *Watcher) CheckDomainResult(
-	ctx context.Context,
-	domain string,
-	nameservers []string,
-	err error,
-) {
-	w.checkDomainResult(ctx, domain, nameservers, err)
-}
-
-// FailedNameservers exports failedNameservers for testing.
-func FailedNameservers(
-	err error,
-	prev *state.HostnameState,
-) map[string]*resolver.NameserverResponse {
-	return failedNameservers(err, prev)
-}
-
 // BuildHostnameState exports buildHostnameState for testing.
 func BuildHostnameState(
 	results map[string]*resolver.NameserverResponse,

internal/watcher/interfaces.go

@@ -20,10 +20,7 @@ type DNSResolver interface {
 	) ([]string, error)
 
 	// LookupAllRecords queries all record types for a hostname,
-	// returning each nameserver's response keyed by nameserver. When
+	// returning each nameserver's response keyed by nameserver.
-	// the walk to the nameservers reached a zone through a referral and
-	// none of that zone's nameservers answered, the error is a
-	// *resolver.NoAnswerError naming them.
 	LookupAllRecords(
 		ctx context.Context,
 		hostname string,

internal/watcher/ipv6_test.go

@@ -1,83 +0,0 @@
-package watcher_test
-
-import (
-	"maps"
-	"slices"
-	"testing"
-
-	"sneak.berlin/go/dnswatcher/internal/state"
-	"sneak.berlin/go/dnswatcher/internal/watcher"
-)
-
-// TestIPv6AddressInBrackets runs the port checks, not the watcher's
-// first, on hostname state built here for a hostname at an IPv6 address
-// whose port 443 the previous check found closed. It is open now. Then
-// it runs the TLS checks and the port checks again. The port and
-// certificate keys and the Port Change notification write the address
-// in brackets, so its last group cannot be read as the port, and the
-// second port checks keep the certificate entry, whose address they read
-// back from its key. When a last port check finds port 443 closed, the
-// certificate entry is removed. Nothing is looked up.
-func TestIPv6AddressInBrackets(t *testing.T) {
-	t.Parallel()
-
-	const aaaaType = "AAAA"
-
-	cfg := defaultTestConfig(t)
-	cfg.Hostnames = []string{host}
-
-	deps := newTestDeps(t, cfg)
-	w := watcher.NewForTest(
-		cfg, deps.state, nil,
-		deps.portChecker, deps.tlsChecker, deps.notifier,
-	)
-	w.SetFirstRun(false)
-
-	deps.state.SetHostnameState(host, saved(
-		map[string]*state.NameserverRecordState{
-			nsA: answered(map[string][]string{aaaaType: {"2001:db8::1"}}),
-		},
-	))
-	deps.state.SetPortState("[2001:db8::1]:443", &state.PortState{
-		Hostnames: []string{host},
-	})
-
-	w.CheckAllPorts(t.Context())
-	w.RunTLSChecks(t.Context())
-	w.CheckAllPorts(t.Context())
-
-	snap := deps.state.GetSnapshot()
-
-	gotPorts := slices.Sorted(maps.Keys(snap.Ports))
-	wantPorts := []string{"[2001:db8::1]:443", "[2001:db8::1]:80"}
-
-	if !slices.Equal(gotPorts, wantPorts) {
-		t.Errorf("port entries %v, want %v", gotPorts, wantPorts)
-	}
-
-	gotCerts := slices.Sorted(maps.Keys(snap.Certificates))
-	wantCerts := []string{"[2001:db8::1]:443:www.example.net"}
-
-	if !slices.Equal(gotCerts, wantCerts) {
-		t.Errorf("certificate entries %v, want %v", gotCerts, wantCerts)
-	}
-
-	title := "Port Change: [2001:db8::1]:443"
-	want := `Hostnames: www.example.net
-Address: [2001:db8::1]:443
-Port now open`
-
-	got := deps.notifier.getNotifications()
-	if len(got) != 1 || got[0].Title != title || got[0].Message != want {
-		t.Errorf("sent %v, want one %q with message:\n%s", got, title, want)
-	}
-
-	deps.portChecker.closed = true
-
-	w.CheckAllPorts(t.Context())
-
-	gotCerts = slices.Sorted(maps.Keys(deps.state.GetSnapshot().Certificates))
-	if len(gotCerts) != 0 {
-		t.Errorf("certificate entries %v with port 443 closed, want none", gotCerts)
-	}
-}

internal/watcher/nsfailure_test.go

@@ -2,7 +2,6 @@ package watcher_test
 
 import (
 	"context"
-	"errors"
 	"fmt"
 	"log/slog"
 	"strings"
@@ -15,10 +14,6 @@ import (
 	"sneak.berlin/go/dnswatcher/internal/watcher"
 )
 
-// errNoReply is why a walk that got no reply from a zone's servers
-// failed.
-var errNoReply = errors.New("all servers failed: i/o timeout")
-
 // answered is what a check saves for a nameserver that answered with
 // these records.
 func answered(records map[string][]string) *state.NameserverRecordState {
@@ -188,134 +183,6 @@ func TestNSFailureAlertNamesHostnameNameserverAndReason(t *testing.T) {
 	}
 }
 
-// TestZoneNameserversAllStopAnswering runs three checks of host from
-// the point where its lookup has returned. On the first, nsA and nsB,
-// the nameservers of its zone, answer. On the second, the lookup fails
-// with the error the walk to them returns when neither answers (see
-// the resolver's TestFollowDelegation_NoAnswerAfterReferral), given
-// here because no live zone has nameservers that never answer. For a
-// hostname it is the lookup of its records that fails, and for a domain
-// with no delegation of its own the lookup of its delegation. Both are
-// saved as failed, with the reason, and each gets an NS Failure. On the
-// third, both answer, and each gets an NS Recovery. A domain's records
-// are checked as a hostname's, so its first and third checks are too.
-func TestZoneNameserversAllStopAnswering(t *testing.T) {
-	t.Parallel()
-
-	records := map[string][]string{"A": {ip1}}
-	bothAnswer := map[string]*resolver.NameserverResponse{
-		nsA: response(records), nsB: response(records),
-	}
-	noAnswer := &resolver.NoAnswerError{
-		Nameservers: []string{nsA, nsB}, Err: errNoReply,
-	}
-
-	tests := []struct {
-		name     string
-		isDomain bool
-	}{
-		{"hostname", false},
-		{"domain with no delegation of its own", true},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			t.Parallel()
-
-			cfg := defaultTestConfig(t)
-			if tt.isDomain {
-				cfg.Domains = []string{host}
-			} else {
-				cfg.Hostnames = []string{host}
-			}
-
-			// The watcher is given each lookup's result, so it has no
-			// resolver.
-			deps := newTestDeps(t, cfg)
-			w := watcher.NewForTest(
-				cfg, deps.state, nil,
-				deps.portChecker, deps.tlsChecker, deps.notifier,
-			)
-			w.SetFirstRun(false)
-
-			w.CheckHostnameResult(t.Context(), host, bothAnswer, nil)
-
-			if tt.isDomain {
-				w.CheckDomainResult(t.Context(), host, nil, noAnswer)
-			} else {
-				w.CheckHostnameResult(t.Context(), host, nil, noAnswer)
-			}
-
-			current, _ := deps.state.GetHostnameState(host)
-
-			for _, ns := range []string{nsA, nsB} {
-				got := current.RecordsByNameserver[ns]
-				if got.Status != failed().Status || got.Error != errNoReply.Error() {
-					t.Errorf(
-						"%s saved with status %q, error %q; want %q, %q",
-						ns, got.Status, got.Error, failed().Status, errNoReply,
-					)
-				}
-			}
-
-			if n := countNotifications(deps, "NS Failure: "+host); n != 2 {
-				t.Errorf("sent %d NS Failure notifications, want 2", n)
-			}
-
-			w.CheckHostnameResult(t.Context(), host, bothAnswer, nil)
-
-			if n := countNotifications(deps, "NS Recovery: "+host); n != 2 {
-				t.Errorf("sent %d NS Recovery notifications, want 2", n)
-			}
-		})
-	}
-}
-
-// TestFailedNameserversOnlyForThoseOfThePreviousCheck gives
-// FailedNameservers lookup errors after a check in which nsA and nsB
-// answered. Only an error that names both makes them failed.
-func TestFailedNameserversOnlyForThoseOfThePreviousCheck(t *testing.T) {
-	t.Parallel()
-
-	records := map[string][]string{"A": {ip1}}
-	bothAnswered := saved(map[string]*state.NameserverRecordState{
-		nsA: answered(records), nsB: answered(records),
-	})
-	noAnswer := func(nameservers ...string) error {
-		return &resolver.NoAnswerError{Nameservers: nameservers, Err: errNoReply}
-	}
-
-	tests := []struct {
-		name       string
-		err        error
-		prev       *state.HostnameState
-		wantFailed bool
-	}{
-		{"both did not answer", noAnswer(nsA, nsB), bothAnswered, true},
-		{
-			"the servers of a parent zone did not answer",
-			noAnswer(nsC), bothAnswered, false,
-		},
-		{
-			"the zone's delegation lists only nsA now",
-			noAnswer(nsA), bothAnswered, false,
-		},
-		{"no root server answered", errNoReply, bothAnswered, false},
-		{"no previous check", noAnswer(nsA, nsB), nil, false},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			t.Parallel()
-
-			got := watcher.FailedNameservers(tt.err, tt.prev)
-			if (got != nil) != tt.wantFailed {
-				t.Errorf("returned %v, want failed: %v", got, tt.wantFailed)
-			}
-		})
-	}
-}
-
 // TestNameserverThatNeverAnswers asks a nameserver address where
 // nothing answers, 192.0.2.1, and checks what the watcher saves for it.
 // The deadline outlasts the resolver's first two-second try, as in the

internal/watcher/removed_test.go

@@ -2,9 +2,7 @@ package watcher_test
 
 import (
 	"maps"
-	"net"
 	"slices"
-	"strings"
 	"testing"
 
 	"sneak.berlin/go/dnswatcher/internal/state"
@@ -174,7 +172,7 @@ func TestCertificateStateForAnAddressGone(t *testing.T) {
 					"A": {ip1}, "AAAA": {ip6},
 				}),
 			}),
-			[]string{ip1 + ":443:" + host, "[" + ip6 + "]:443:" + host},
+			[]string{ip1 + ":443:" + host, ip6 + ":443:" + host},
 		},
 		{
 			"no nameserver answered",
@@ -184,7 +182,7 @@ func TestCertificateStateForAnAddressGone(t *testing.T) {
 			[]string{
 				ip1 + ":443:" + host,
 				ip2 + ":443:" + host,
-				"[" + ip6 + "]:443:" + host,
+				ip6 + ":443:" + host,
 			},
 		},
 	}
@@ -207,8 +205,7 @@ func TestCertificateStateForAnAddressGone(t *testing.T) {
 
 			for _, ip := range []string{ip1, ip2, ip6} {
 				deps.state.SetCertificateState(
-					net.JoinHostPort(ip, "443")+":"+host,
+					ip+":443:"+host, &state.CertificateState{Status: "ok"},
-					&state.CertificateState{Status: "ok"},
 				)
 			}
 
@@ -225,67 +222,3 @@ func TestCertificateStateForAnAddressGone(t *testing.T) {
 		})
 	}
 }
-
-// TestCertificateStateForAPortClosed runs the port checks on hostname
-// and port state built here for a configured hostname at ip1, whose
-// port 443 the previous check found open and whose certificate entry
-// is ok. The port is closed now: the certificate entry is removed, and
-// only the Port Change is notified. When the port opens again, the next
-// TLS check saves the certificate as new and notifies nothing about it.
-// Nothing is looked up.
-func TestCertificateStateForAPortClosed(t *testing.T) {
-	t.Parallel()
-
-	cfg := defaultTestConfig(t)
-	cfg.Hostnames = []string{host}
-
-	deps := newTestDeps(t, cfg)
-	w := watcher.NewForTest(
-		cfg, deps.state, nil,
-		deps.portChecker, deps.tlsChecker, deps.notifier,
-	)
-	w.SetFirstRun(false)
-
-	certKey := ip1 + ":443:" + host
-
-	deps.state.SetHostnameState(host, saved(
-		map[string]*state.NameserverRecordState{
-			nsA: answered(map[string][]string{"A": {ip1}}),
-		},
-	))
-	deps.state.SetPortState(ip1+":443", &state.PortState{
-		Open: true, Hostnames: []string{host},
-	})
-	deps.state.SetCertificateState(certKey, &state.CertificateState{
-		CommonName: host, Status: "ok",
-	})
-	deps.portChecker.closed = true
-
-	w.CheckAllPorts(t.Context())
-
-	if _, ok := deps.state.GetCertificateState(certKey); ok {
-		t.Errorf("certificate entry %s kept with port 443 closed", certKey)
-	}
-
-	sent := deps.notifier.getNotifications()
-	if title := "Port Change: " + ip1 + ":443"; len(sent) != 1 ||
-		sent[0].Title != title {
-		t.Errorf("sent %v, want one %q", sent, title)
-	}
-
-	deps.portChecker.closed = false
-
-	w.CheckAllPorts(t.Context())
-	w.RunTLSChecks(t.Context())
-
-	cert, ok := deps.state.GetCertificateState(certKey)
-	if !ok || cert.Status != "ok" {
-		t.Errorf("certificate entry %s after port 443 opened: %+v", certKey, cert)
-	}
-
-	for _, n := range deps.notifier.getNotifications() {
-		if strings.HasPrefix(n.Title, "TLS") {
-			t.Errorf("sent %v, want no TLS notification", n)
-		}
-	}
-}

internal/watcher/watcher.go

@@ -6,10 +6,8 @@ import (
 	"fmt"
 	"log/slog"
 	"maps"
-	"net"
 	"slices"
 	"sort"
-	"strconv"
 	"strings"
 	"time"
 
@@ -291,25 +289,12 @@ func (w *Watcher) logFailedLookup(
 	w.log.Error(msg, args...)
 }
 
-// checkDomain looks up domain's delegation and checks domain with it
-// (see checkDomainResult).
 func (w *Watcher) checkDomain(
 	ctx context.Context,
 	domain string,
 ) {
 	nameservers, err := w.resolver.LookupNS(ctx, domain)
 
-	w.checkDomainResult(ctx, domain, nameservers, err)
-}
-
-// checkDomainResult finishes a check of domain from nameservers and err,
-// what the lookup of its delegation returned.
-func (w *Watcher) checkDomainResult(
-	ctx context.Context,
-	domain string,
-	nameservers []string,
-	err error,
-) {
 	// A domain that does not exist has no nameservers.
 	nxdomain := errors.Is(err, resolver.ErrNXDomain)
 	if nxdomain {
@@ -324,12 +309,6 @@ func (w *Watcher) checkDomainResult(
 			"error", err,
 		)
 
-		// For a domain with no delegation of its own, the servers that
-		// did not answer can be those of the zone it is in, at which
-		// its records are asked. They are then saved as failed, as a
-		// hostname's are.
-		w.checkHostnameResult(ctx, domain, nil, err)
-
 		return
 	}
 
@@ -483,8 +462,8 @@ func (w *Watcher) detectNSAddressChanges(
 	}
 }
 
-// checkHostname looks up hostname's records and checks them (see
+// checkHostname checks hostname's records and reports whether it saved
-// checkHostnameResult). It reports whether it saved them.
+// them; it does not when their lookup fails.
 func (w *Watcher) checkHostname(
 	ctx context.Context,
 	hostname string,
@@ -497,31 +476,12 @@ func (w *Watcher) checkHostname(
 			"hostname", hostname,
 			"error", err,
 		)
+
+		return false
 	}
 
-	return w.checkHostnameResult(ctx, hostname, results, err)
-}
-
-// checkHostnameResult finishes a check of hostname from results and err,
-// what the lookup of its records returned, and reports whether it saved
-// them. When the lookup failed, it saves nothing, unless the nameservers
-// that did not answer are those of the previous check (see
-// failedNameservers).
-func (w *Watcher) checkHostnameResult(
-	ctx context.Context,
-	hostname string,
-	results map[string]*resolver.NameserverResponse,
-	err error,
-) bool {
 	prev, _ := w.state.GetHostnameState(hostname)
 
-	if err != nil {
-		results = failedNameservers(err, prev)
-		if results == nil {
-			return false
-		}
-	}
-
 	w.updateHostnameState(
 		ctx, hostname, buildHostnameState(results, prev, time.Now().UTC()),
 	)
@@ -529,40 +489,6 @@ func (w *Watcher) checkHostnameResult(
 	return true
 }
 
-// failedNameservers returns a failed response for each nameserver in
-// prev, a name's state from the previous check, with err as the reason,
-// when err says that the walk to the name's nameservers reached their
-// zone and none of them answered. For any other error, as when the walk
-// got no answer before it reached their zone, or when prev is nil, it
-// returns nil.
-func failedNameservers(
-	err error,
-	prev *state.HostnameState,
-) map[string]*resolver.NameserverResponse {
-	var noAnswer *resolver.NoAnswerError
-	if !errors.As(err, &noAnswer) || prev == nil {
-		return nil
-	}
-
-	saved := slices.Sorted(maps.Keys(prev.RecordsByNameserver))
-	if !slices.Equal(noAnswer.Nameservers, saved) {
-		return nil
-	}
-
-	results := make(map[string]*resolver.NameserverResponse)
-
-	for _, ns := range saved {
-		results[ns] = &resolver.NameserverResponse{
-			Nameserver: ns,
-			Records:    make(map[string][]string),
-			Status:     resolver.StatusError,
-			Error:      err.Error(),
-		}
-	}
-
-	return results
-}
-
 // updateHostnameState finishes a check of hostname from newState, built
 // from its nameservers' answers: it follows the CNAME in them, notifies
 // what changed since the previous check, and saves newState.
@@ -862,7 +788,7 @@ func (w *Watcher) detectRecordChanges(
 // saved delegation, which detectNSChanges notifies when they are removed
 // from it. checkDomain saves a new delegation only after this runs, and
 // only together with the records, so the saved delegation and the
-// nameservers in prev come from the same check.
+// records in prev come from the same check.
 func (w *Watcher) detectNSDisappearances(
 	ctx context.Context,
 	hostname string,
@@ -1052,8 +978,7 @@ func (w *Watcher) checkAllPorts(ctx context.Context) {
 
 	// Phase 3: Remove port state entries that no longer have
 	// any hostname referencing them, and certificate entries for
-	// an address whose port 443 is closed or that their name no
+	// an address their name no longer has.
-	// longer has.
 	w.cleanupStalePorts(associations)
 	w.cleanupStaleCertificates()
 }
@@ -1074,7 +999,7 @@ func (w *Watcher) buildPortAssociations() map[string][]string {
 		ips := w.collectIPs(name)
 		for _, ip := range ips {
 			for _, port := range monitoredPorts {
-				key := net.JoinHostPort(ip, strconv.Itoa(port))
+				key := fmt.Sprintf("%s:%d", ip, port)
 				if assoc[key] == nil {
 					assoc[key] = make(map[string]bool)
 				}
@@ -1099,15 +1024,18 @@ func (w *Watcher) buildPortAssociations() map[string][]string {
 	return result
 }
 
-// parsePortKey splits an "ip:port" key, written by net.JoinHostPort,
+// parsePortKey splits an "ip:port" key into its components.
-// into its components.
 func parsePortKey(key string) (string, int) {
-	ip, port, err := net.SplitHostPort(key)
+	lastColon := strings.LastIndex(key, ":")
-	if err != nil {
+	if lastColon < 0 {
 		return key, 0
 	}
 
-	p, err := strconv.Atoi(port)
+	ip := key[:lastColon]
+
+	var p int
+
+	_, err := fmt.Sscanf(key[lastColon+1:], "%d", &p)
 	if err != nil {
 		return ip, 0
 	}
@@ -1137,21 +1065,13 @@ func (w *Watcher) cleanupStalePorts(
 }
 
 // cleanupStaleCertificates removes the certificate entries for an
-// address whose port 443 was found closed, and for an address their
+// address their name no longer resolves to. An entry saved for a name
-// name no longer resolves to. An entry saved for a name none of whose
+// none of whose nameservers answered is kept: that name's addresses are
-// nameservers answered is kept unless its port is closed: that name's
+// not known, not gone.
-// addresses are not known, not gone.
 func (w *Watcher) cleanupStaleCertificates() {
 	for _, key := range w.state.GetAllCertificateKeys() {
 		ip, hostname := parseCertKey(key)
 
-		ps, ok := w.state.GetPortState(net.JoinHostPort(ip, strconv.Itoa(tlsPort)))
-		if ok && !ps.Open {
-			w.state.DeleteCertificateState(key)
-
-			continue
-		}
-
 		if slices.Contains(w.collectIPs(hostname), ip) ||
 			w.noNameserverAnswered(hostname) {
 			continue
@@ -1260,7 +1180,7 @@ func (w *Watcher) checkSinglePort(
 		return
 	}
 
-	key := net.JoinHostPort(ip, strconv.Itoa(port))
+	key := fmt.Sprintf("%s:%d", ip, port)
 	now := time.Now().UTC()
 	prev, hasPrev := w.state.GetPortState(key)
 
@@ -1322,7 +1242,7 @@ func (w *Watcher) checkTLSForHostname(
 	ips := w.collectIPs(hostname)
 
 	for _, ip := range ips {
-		portKey := net.JoinHostPort(ip, strconv.Itoa(tlsPort))
+		portKey := fmt.Sprintf("%s:%d", ip, tlsPort)
 
 		ps, ok := w.state.GetPortState(portKey)
 		if !ok || !ps.Open {
@@ -1346,7 +1266,7 @@ func (w *Watcher) checkTLSCert(
 		return
 	}
 
-	certKey := net.JoinHostPort(ip, strconv.Itoa(tlsPort)) + ":" + hostname
+	certKey := fmt.Sprintf("%s:%d:%s", ip, tlsPort, hostname)
 	now := time.Now().UTC()
 	prev, hasPrev := w.state.GetCertificateState(certKey)
 

internal/watcher/watcher_test.go

@@ -4,7 +4,6 @@ import (
 	"context"
 	"fmt"
 	"log/slog"
-	"net"
 	"os"
 	"slices"
 	"strings"
@@ -825,8 +824,7 @@ func TestPortStateChange(t *testing.T) {
 
 	hs, _ := deps.state.GetHostnameState(testHost)
 	assertNotified(
-		t, deps, "Port Change: "+net.JoinHostPort(addresses(hs)[0], "443"),
+		t, deps, "Port Change: "+addresses(hs)[0]+":443", "warning",
-		"warning",
 	)
 }
 
@@ -1033,12 +1031,11 @@ func TestDNSRunsBeforePortAndTLSChecks(t *testing.T) {
 
 	// Port and TLS checks must use the addresses this check found.
 	for _, ip := range addresses(snap.Hostnames[testHost]) {
-		portKey := net.JoinHostPort(ip, "80")
+		if _, ok := snap.Ports[ip+":80"]; !ok {
-		if _, ok := snap.Ports[portKey]; !ok {
+			t.Error("port check used stale DNS: missing " + ip + ":80")
-			t.Error("port check used stale DNS: missing " + portKey)
 		}
 
-		certKey := net.JoinHostPort(ip, "443") + ":" + testHost
+		certKey := ip + ":443:" + testHost
 		if _, ok := snap.Certificates[certKey]; !ok {
 			t.Error("TLS check used stale DNS: missing " + certKey)
 		}