From 504c287c19d428bfbb862d7a09a7dfc4589f7cde Mon Sep 17 00:00:00 2001 From: Frank Denis Date: Thu, 6 Aug 2026 23:00:58 +0200 Subject: [PATCH] Remove interface enumeration Enumerating the interfaces is not free, especially on Windows where every address lookup goes through the IP Helper service, so we sample slowly. Losing a minute before rotating our client key after a network change is harmless; burning CPU cycles every few seconds on an idle machine is not. --- dnscrypt-proxy/netmon.go | 117 +------------- dnscrypt-proxy/netmon_test.go | 292 +++++++++------------------------- 2 files changed, 86 insertions(+), 323 deletions(-) diff --git a/dnscrypt-proxy/netmon.go b/dnscrypt-proxy/netmon.go index 50d84305..f0ad9e1f 100644 --- a/dnscrypt-proxy/netmon.go +++ b/dnscrypt-proxy/netmon.go @@ -14,11 +14,7 @@ "github.com/jedisct1/dlog" ) -const ( - defaultNetworkMonitorInterval = 5 * time.Second - maxNetworkMonitorBackoff = 30 * time.Second - offlineNetworkFingerprint = "offline" -) +const defaultNetworkMonitorInterval = 60 * time.Second type networkInterfaceSnapshot struct { Name string @@ -29,35 +25,17 @@ type networkInterfaceSnapshot struct { Addrs []*net.IPNet } -type networkMonitorProbeState struct { - address string - retryAt time.Time - backoff time.Duration -} - type networkMonitor struct { epochValue atomic.Uint64 sampling atomic.Bool initialized bool lastInterfaces string - lastRoutes string - probes [2]networkMonitorProbeState - now func() time.Time interfaces func() ([]networkInterfaceSnapshot, error) - probe func(string) (net.IP, error) onChange func() } func newNetworkMonitor() *networkMonitor { - return &networkMonitor{ - probes: [2]networkMonitorProbeState{ - {address: "192.0.2.1:9"}, - {address: "[2001:db8::1]:9"}, - }, - now: time.Now, - interfaces: snapshotNetworkInterfaces, - probe: probeNetworkMonitorLocalIP, - } + return &networkMonitor{interfaces: snapshotNetworkInterfaces} } func (monitor *networkMonitor) epoch() uint64 { @@ -120,27 +98,13 @@ func (monitor *networkMonitor) check() { func (monitor *networkMonitor) sample(notify bool) { interfaces, err := monitor.interfaces() - interfacesChanged := false - if err == nil { - interfaceFingerprint := buildNetworkInterfaceFingerprint(interfaces) - interfacesChanged = monitor.lastInterfaces != "" && monitor.lastInterfaces != interfaceFingerprint - monitor.lastInterfaces = interfaceFingerprint - if interfacesChanged { - for i := range monitor.probes { - monitor.probes[i].retryAt = time.Time{} - monitor.probes[i].backoff = 0 - } - if notify { - monitor.notifyNetworkChange() - } - } + if err != nil { + return } - - localIPs := monitor.discoverLocalIPs(monitor.now()) - routeFingerprint := buildNetworkFingerprint(localIPs) - routesChanged := monitor.lastRoutes != "" && monitor.lastRoutes != routeFingerprint - monitor.lastRoutes = routeFingerprint - if notify && routesChanged && !interfacesChanged { + fingerprint := buildNetworkInterfaceFingerprint(interfaces) + changed := monitor.lastInterfaces != "" && monitor.lastInterfaces != fingerprint + monitor.lastInterfaces = fingerprint + if changed && notify { monitor.notifyNetworkChange() } } @@ -153,53 +117,6 @@ func (monitor *networkMonitor) notifyNetworkChange() { } } -func (monitor *networkMonitor) discoverLocalIPs(now time.Time) []net.IP { - localIPs := make([]net.IP, 0, len(monitor.probes)) - seen := make(map[string]struct{}, len(monitor.probes)) - for i := range monitor.probes { - state := &monitor.probes[i] - if !state.retryAt.IsZero() && now.Before(state.retryAt) { - continue - } - ip, err := monitor.probe(state.address) - if err != nil { - if state.backoff == 0 { - state.backoff = defaultNetworkMonitorInterval - } else { - state.backoff = min(state.backoff*2, maxNetworkMonitorBackoff) - } - state.retryAt = now.Add(state.backoff) - continue - } - state.retryAt = time.Time{} - state.backoff = 0 - if ip == nil || ip.IsUnspecified() { - continue - } - ip = append(net.IP(nil), ip...) - key := ip.String() - if _, ok := seen[key]; ok { - continue - } - seen[key] = struct{}{} - localIPs = append(localIPs, ip) - } - return localIPs -} - -func probeNetworkMonitorLocalIP(address string) (net.IP, error) { - conn, err := net.DialTimeout("udp", address, time.Second) - if err != nil { - return nil, err - } - defer conn.Close() - localAddr, ok := conn.LocalAddr().(*net.UDPAddr) - if !ok || localAddr.IP == nil || localAddr.IP.IsUnspecified() { - return nil, net.InvalidAddrError("missing local IP") - } - return append(net.IP(nil), localAddr.IP...), nil -} - func snapshotNetworkInterfaces() ([]networkInterfaceSnapshot, error) { interfaces, err := net.Interfaces() if err != nil { @@ -299,24 +216,6 @@ func buildNetworkInterfaceFingerprint(interfaces []networkInterfaceSnapshot) str return hashNetworkFingerprint(parts) } -func buildNetworkFingerprint(localIPs []net.IP) string { - if len(localIPs) == 0 { - return offlineNetworkFingerprint - } - parts := make([]string, 0, len(localIPs)) - for _, ip := range localIPs { - if ip == nil || ip.IsUnspecified() { - continue - } - ip = append(net.IP(nil), ip...) - parts = append(parts, "ip="+ip.String()) - } - if len(parts) == 0 { - return offlineNetworkFingerprint - } - return hashNetworkFingerprint(parts) -} - func hashNetworkFingerprint(parts []string) string { sort.Strings(parts) h := sha256.New() diff --git a/dnscrypt-proxy/netmon_test.go b/dnscrypt-proxy/netmon_test.go index 915c5c08..98765b9b 100644 --- a/dnscrypt-proxy/netmon_test.go +++ b/dnscrypt-proxy/netmon_test.go @@ -5,7 +5,6 @@ "net" "slices" "testing" - "time" ) func TestNetworkInterfaceFingerprintIsStable(t *testing.T) { @@ -112,275 +111,140 @@ func TestSnapshotNetworkAddressPreservesHost(t *testing.T) { } } -func TestNetworkMonitorPassiveChangeWakesProbesBeforeCallbackReturns(t *testing.T) { - now := time.Unix(1_000_000, 0) +func TestNetworkMonitorNotifiesOnInterfaceChange(t *testing.T) { interfaces := testNetworkMonitorInterfaces(t) - failing := true - events := make([]string, 0, 3) + changes := 0 monitor := newNetworkMonitor() - monitor.now = func() time.Time { return now } monitor.interfaces = func() ([]networkInterfaceSnapshot, error) { return interfaces, nil } - monitor.probe = func(address string) (net.IP, error) { - if address == monitor.probes[0].address { - events = append(events, "ipv4") - if failing { - return nil, errors.New("IPv4 unavailable") - } - return net.ParseIP("192.168.1.10"), nil - } - events = append(events, "ipv6") - if failing { - return nil, errors.New("IPv6 unavailable") - } - return net.ParseIP("2001:db8:1::10"), nil - } monitor.onChange = func() { - events = append(events, "change") - if got := monitor.epoch(); got != 1 { - t.Errorf("epoch in callback = %d, want 1", got) + changes++ + if got := monitor.epoch(); got != uint64(changes) { + t.Errorf("epoch in callback = %d, want %d", got, changes) } - monitor.check() } monitor.init() - now = now.Add(5 * time.Second) monitor.check() - now = now.Add(5 * time.Second) + if changes != 0 || monitor.epoch() != 0 { + t.Fatalf("stable network produced %d callbacks and epoch %d", changes, monitor.epoch()) + } + interfaces = append(cloneNetworkMonitorInterfaces(interfaces), networkInterfaceSnapshot{ Name: "vpn0", Index: 8, Flags: net.FlagUp | net.FlagPointToPoint, - Addrs: []*net.IPNet{testNetworkMonitorIPNet(t, "fe80::8/64")}, + Addrs: []*net.IPNet{testNetworkMonitorIPNet(t, "10.8.0.2/24")}, }) - failing = false - events = events[:0] - monitor.check() - - wantEvents := []string{"change", "ipv4", "ipv6"} - if !slices.Equal(events, wantEvents) { - t.Fatalf("events = %v, want %v", events, wantEvents) - } - if got := monitor.epoch(); got != 1 { - t.Fatalf("epoch = %d, want 1", got) - } - now = now.Add(5 * time.Second) - monitor.check() - if got := monitor.epoch(); got != 1 { - t.Fatalf("stable check changed epoch to %d", got) - } -} - -func TestNetworkMonitorBacksOffFailedFamilyIndependently(t *testing.T) { - testErrors := []struct { - name string - err error - }{ - {"plain error", errors.New("unavailable")}, - {"wrapped network error", &net.OpError{Op: "dial", Net: "udp", Err: errors.New("unavailable")}}, - } - for _, testError := range testErrors { - t.Run(testError.name, func(t *testing.T) { - now := time.Unix(1_000_000, 0) - ipv4Calls := 0 - ipv6Calls := 0 - monitor := newNetworkMonitor() - monitor.now = func() time.Time { return now } - monitor.interfaces = func() ([]networkInterfaceSnapshot, error) { - return testNetworkMonitorInterfaces(t), nil - } - monitor.probe = func(address string) (net.IP, error) { - if address == monitor.probes[0].address { - ipv4Calls++ - return net.ParseIP("192.168.1.10"), nil - } - ipv6Calls++ - return nil, testError.err - } - - monitor.init() - for _, elapsed := range []time.Duration{5, 10, 15, 20, 35} { - now = time.Unix(1_000_000, 0).Add(elapsed * time.Second) - monitor.check() - } - if ipv4Calls != 6 { - t.Fatalf("IPv4 probes = %d, want 6", ipv4Calls) - } - if ipv6Calls != 4 { - t.Fatalf("IPv6 probes = %d, want 4", ipv6Calls) - } - }) - } -} - -func TestNetworkMonitorBackoffStopsAtThirtySeconds(t *testing.T) { - now := time.Unix(1_000_000, 0) - monitor := newNetworkMonitor() - monitor.now = func() time.Time { return now } - monitor.interfaces = func() ([]networkInterfaceSnapshot, error) { - return testNetworkMonitorInterfaces(t), nil - } - monitor.probe = func(address string) (net.IP, error) { - if address == monitor.probes[0].address { - return net.ParseIP("192.168.1.10"), nil - } - return nil, errors.New("IPv6 unavailable") - } - - monitor.init() - for _, want := range []time.Duration{ - 10 * time.Second, - 20 * time.Second, - 30 * time.Second, - 30 * time.Second, - } { - now = monitor.probes[1].retryAt - monitor.check() - if got := monitor.probes[1].backoff; got != want { - t.Fatalf("backoff = %s, want %s", got, want) - } - if got := monitor.probes[1].retryAt.Sub(now); got != want { - t.Fatalf("retry delay = %s, want %s", got, want) - } - } -} - -func TestNetworkMonitorKeepsProbingAfterInterfaceSnapshotError(t *testing.T) { - now := time.Unix(1_000_000, 0) - ipv6Failing := false - changes := 0 - monitor := newNetworkMonitor() - monitor.now = func() time.Time { return now } - monitor.interfaces = func() ([]networkInterfaceSnapshot, error) { - return nil, errors.New("interfaces unavailable") - } - monitor.probe = func(address string) (net.IP, error) { - if address == monitor.probes[0].address { - return net.ParseIP("192.168.1.10"), nil - } - if ipv6Failing { - return nil, errors.New("IPv6 unavailable") - } - return net.ParseIP("2001:db8:1::10"), nil - } - monitor.onChange = func() { changes++ } - - monitor.init() - ipv6Failing = true - now = now.Add(5 * time.Second) monitor.check() if changes != 1 || monitor.epoch() != 1 { - t.Fatalf("active change produced %d callbacks and epoch %d", changes, monitor.epoch()) + t.Fatalf("interface change produced %d callbacks and epoch %d", changes, monitor.epoch()) + } + + monitor.check() + if changes != 1 || monitor.epoch() != 1 { + t.Fatalf("stable check produced %d callbacks and epoch %d", changes, monitor.epoch()) } } -func TestNetworkMonitorProbeRecovery(t *testing.T) { - now := time.Unix(1_000_000, 0) - ipv6Failing := false - ipv6Calls := 0 +func TestNetworkMonitorFirstCheckOnlyRecordsBaseline(t *testing.T) { + interfaces := testNetworkMonitorInterfaces(t) changes := 0 monitor := newNetworkMonitor() - monitor.now = func() time.Time { return now } - monitor.interfaces = func() ([]networkInterfaceSnapshot, error) { - return testNetworkMonitorInterfaces(t), nil - } - monitor.probe = func(address string) (net.IP, error) { - if address == monitor.probes[0].address { - return net.ParseIP("192.168.1.10"), nil - } - ipv6Calls++ - if ipv6Failing { - return nil, errors.New("IPv6 unavailable") - } - return net.ParseIP("2001:db8:1::10"), nil - } + monitor.interfaces = func() ([]networkInterfaceSnapshot, error) { return interfaces, nil } monitor.onChange = func() { changes++ } - monitor.init() - ipv6Failing = true - now = now.Add(5 * time.Second) monitor.check() - now = now.Add(5 * time.Second) - monitor.check() - now = now.Add(5 * time.Second) - monitor.check() - if changes != 1 || ipv6Calls != 3 { - t.Fatalf("during failure: changes = %d, IPv6 probes = %d, want 1 and 3", changes, ipv6Calls) + if changes != 0 || monitor.epoch() != 0 { + t.Fatalf("first check produced %d callbacks and epoch %d", changes, monitor.epoch()) } - - ipv6Failing = false - now = now.Add(5 * time.Second) + interfaces = cloneNetworkMonitorInterfaces(interfaces) + interfaces[0].Addrs[0].IP = net.ParseIP("192.168.1.20") monitor.check() - if changes != 2 || ipv6Calls != 4 { - t.Fatalf("after recovery: changes = %d, IPv6 probes = %d, want 2 and 4", changes, ipv6Calls) - } - now = now.Add(5 * time.Second) - monitor.check() - if changes != 2 { - t.Fatalf("stable recovery changed callback count to %d", changes) - } - - ipv6Failing = true - now = now.Add(5 * time.Second) - monitor.check() - now = now.Add(5 * time.Second) - monitor.check() - if changes != 3 || ipv6Calls != 7 { - t.Fatalf("after reset: changes = %d, IPv6 probes = %d, want 3 and 7", changes, ipv6Calls) + if changes != 1 || monitor.epoch() != 1 { + t.Fatalf("change after the baseline produced %d callbacks and epoch %d", changes, monitor.epoch()) } } -func TestNetworkMonitorCoalescesFamilyChanges(t *testing.T) { - now := time.Unix(1_000_000, 0) +func TestNetworkMonitorIgnoresInterfaceSnapshotErrors(t *testing.T) { + interfaces := testNetworkMonitorInterfaces(t) failing := false changes := 0 monitor := newNetworkMonitor() - monitor.now = func() time.Time { return now } monitor.interfaces = func() ([]networkInterfaceSnapshot, error) { - return testNetworkMonitorInterfaces(t), nil - } - monitor.probe = func(address string) (net.IP, error) { if failing { - return nil, errors.New("unavailable") + return nil, errors.New("interfaces unavailable") } - if address == monitor.probes[0].address { - return net.ParseIP("192.168.1.10"), nil - } - return net.ParseIP("2001:db8:1::10"), nil + return interfaces, nil } monitor.onChange = func() { changes++ } - monitor.init() + monitor.init() failing = true - now = now.Add(5 * time.Second) + monitor.check() + if changes != 0 || monitor.epoch() != 0 { + t.Fatalf("snapshot error produced %d callbacks and epoch %d", changes, monitor.epoch()) + } + + failing = false + monitor.check() + if changes != 0 || monitor.epoch() != 0 { + t.Fatalf("recovery from a snapshot error produced %d callbacks and epoch %d", changes, monitor.epoch()) + } + + // A failed enumeration keeps the last known fingerprint around, so a change + // that happens while we are blind is still reported once we can see again. + failing = true + monitor.check() + interfaces = cloneNetworkMonitorInterfaces(interfaces) + interfaces[0].Addrs[0].IP = net.ParseIP("192.168.1.20") + monitor.check() + failing = false monitor.check() if changes != 1 || monitor.epoch() != 1 { - t.Fatalf("simultaneous failure produced %d callbacks and epoch %d", changes, monitor.epoch()) + t.Fatalf("change during a snapshot error produced %d callbacks and epoch %d", changes, monitor.epoch()) } - failing = false - now = now.Add(5 * time.Second) +} + +func TestNetworkMonitorIgnoresReentrantChecks(t *testing.T) { + interfaces := testNetworkMonitorInterfaces(t) + snapshots := 0 + changes := 0 + monitor := newNetworkMonitor() + monitor.interfaces = func() ([]networkInterfaceSnapshot, error) { + snapshots++ + return interfaces, nil + } + monitor.onChange = func() { + changes++ + monitor.check() + } + + monitor.init() + interfaces = cloneNetworkMonitorInterfaces(interfaces) + interfaces[0].Addrs[0].IP = net.ParseIP("192.168.1.20") monitor.check() - if changes != 2 || monitor.epoch() != 2 { - t.Fatalf("simultaneous recovery produced %d callbacks and epoch %d", changes, monitor.epoch()) + if changes != 1 || monitor.epoch() != 1 { + t.Fatalf("reentrant check produced %d callbacks and epoch %d", changes, monitor.epoch()) + } + if snapshots != 2 { + t.Fatalf("interfaces were sampled %d times, want 2", snapshots) } } func TestNetworkMonitorInitializationIsIdempotent(t *testing.T) { - probeCalls := 0 + snapshots := 0 callbackCalls := 0 monitor := newNetworkMonitor() monitor.interfaces = func() ([]networkInterfaceSnapshot, error) { + snapshots++ return testNetworkMonitorInterfaces(t), nil } - monitor.probe = func(string) (net.IP, error) { - probeCalls++ - return nil, errors.New("unavailable") - } monitor.onChange = func() { callbackCalls++ } monitor.init() monitor.init() - if probeCalls != 2 { - t.Fatalf("initialization made %d probes, want 2", probeCalls) + if snapshots != 1 { + t.Fatalf("initialization sampled the interfaces %d times, want 1", snapshots) } if callbackCalls != 0 || monitor.epoch() != 0 { t.Fatalf("initialization produced %d callbacks and epoch %d", callbackCalls, monitor.epoch())