DNS search domain fallbacks: increase test coverage

Increase test coverage and cleanup

Author: FR4NK-W

hinting/dns_search_domain_fallbacks.go

@@ -47,7 +47,7 @@ Fallback:
 		// if all configured IPs are private.
 		ip, err := queryExternalIP()
 		if err == nil {
-			ips = append(ips, *ip)
+			ips = append(ips, ip)
 		}
 	}
 
@@ -96,16 +96,17 @@ func getPublicAddresses() (ips []netip.Addr) {
 		return
 	}
 	for _, iface := range ifaces {
-		addrs, err := iface.Addrs()
+		ifaddrs, err := iface.Addrs()
 		if err != nil {
 			continue
 		}
-		for _, addr := range addrs {
-			ip, err := netip.ParseAddr(addr.String())
-			if err != nil {
+		for _, ifaddr := range ifaddrs {
+			ifaddr, ok := ifaddr.(*net.IPNet)
+			if !ok {
 				continue
 			}
-			if !ip.IsPrivate() {
+			ip, ok := netip.AddrFromSlice(ifaddr.IP)
+			if ok && !ip.IsPrivate() {
 				ips = append(ips, ip)
 			}
 		}

hinting/dns_search_domain_fallbacks_test.go

@@ -8,6 +8,7 @@ import (
 	"os"
 	"strings"
 	"testing"
+	"time"
 
 	"github.com/stretchr/testify/assert"
 )
@@ -244,6 +245,45 @@ func TestDomainsFromHostnamesDerivation(t *testing.T) {
 	}
 }
 
+func TestSearchDomainFallbacks(t *testing.T) {
+	dnsChanReadable := dispatcher.getDNSConfig()
+	var regular []DNSInfo
+	var fallback []DNSInfo
+
+	// get info from happy path
+	r := <-dnsChanReadable
+	regular = append(regular, r)
+	// wait for dnsInfoDone to be closed to move to fallback
+	time.Sleep(DNSInfoTimeout)
+
+	// get info from fallback
+	select {
+	case <-dnsInfoFallbackDone:
+		// Fallback timed out
+	case r, ok := <-dnsChanReadable:
+		if ok {
+			fallback = append(fallback, r)
+		}
+	}
+
+	t.Log(regular)
+	t.Log(fallback)
+	assert.Condition(t, func() bool { return len(regular) != 0 || len(fallback) != 0 },
+		"Both regular host system and DNS based DNS Search Domain discovery failed.")
+}
+
+func TestDNSLookupExternalIP(t *testing.T) {
+	ip, err := queryExternalIP()
+	assert.NoError(t, err, "queryExternalIP() failed with error %s.", err)
+	assert.NotEmpty(t, ip, "queryExternalIP() did not return any external IP.")
+}
+
+func TestDNSLookupAkaNS(t *testing.T) {
+	ns, err := getAkaNS()
+	assert.NoError(t, err, "getAkaNS() failed with error %s.", err)
+	assert.NotEmpty(t, ns, "getAkaNS() did not return the nameserver IP.")
+}
+
 // randIPFromCIDR returns a random host IP in the subnet specified by the CIDR
 func randIPFromCIDR(cidr string) (ip netip.Addr) {
 	_, ipNet, err := net.ParseCIDR(cidr)

hinting/dns_search_domain_fallbacks_whois.go

@@ -111,5 +111,13 @@ func extractEmailDomains(response string) (domains []string) {
 		}
 	}
 	// filter out RIR domains
-	return domainsFromHostnames(hostnames)
+	filteredHostnames := hostnames[:0] // in place slice filter: https://go.dev/wiki/SliceTricks
+	for _, hostname := range hostnames {
+		for _, rir := range rirWHOIS {
+			if !strings.HasSuffix(hostname, strings.TrimPrefix(rir, "whois.")) {
+				filteredHostnames = append(filteredHostnames, hostname)
+			}
+		}
+	}
+	return domainsFromHostnames(filteredHostnames)
 }

hinting/hinting.go

@@ -172,17 +172,20 @@ func initDispatcher() (dnsChan <-chan DNSInfo) {
 	// Signal dnsInfoChan fallback senders after timeout
 	dnsInfoTimeoutFallback := time.After(DNSInfoTimeoutFallback)
 	go func() {
-		select {
-		case <-dnsInfoTimeout:
-			// Signal senders about timeout
-			close(dnsInfoDone)
-		case <-dnsInfoTimeoutFallback:
-			// Signal fallback about timeout
-			close(dnsInfoFallbackDone)
-			// Wait for remaining senders
-			dnsInfoWriters.Wait()
-			// Stop publishing new DNSInfo
-			close(dnsInfoChan)
+		for {
+			select {
+			case <-dnsInfoTimeout:
+				// Signal senders about timeout
+				close(dnsInfoDone)
+			case <-dnsInfoTimeoutFallback:
+				// Signal fallback about timeout
+				close(dnsInfoFallbackDone)
+				// Wait for remaining senders
+				dnsInfoWriters.Wait()
+				// Stop publishing new DNSInfo
+				close(dnsInfoChan)
+				return
+			}
 		}
 	}()
 	return