cleanup

Author: FR4NK-W

hinting/dns_search_domain_fallbacks.go

@@ -13,31 +13,31 @@ func domainsFromHostnames(hostnames []string) (domains []string) {
 			domains = append(domains, "local")
 			continue
 		}
-		domainString := ""
+		domain := ""
 		slices.Reverse(labels)
 		for _, label := range labels[:len(labels)-1] {
-			if domainString == "" {
-				domainString = label
+			if domain == "" {
+				domain = label
 				// do not add TLD to domains candidate list
 				continue
 			}
-			domainString = strings.Join([]string{label, domainString}, ".")
+			domain = strings.Join([]string{label, domain}, ".")
 			// Filter out Effective ccTLDs (of the form "co.uk"), as we are only interested in the ETLD+1 domains
-			if 5 == len(domainString) && // TODO: complete TLD specific exceptions, or directly use PSL
+			if 5 == len(domain) && // TODO: complete TLD specific exceptions, or directly use PSL
 				(label == "co" ||
 					label == "ac" ||
 					label == "re" ||
 					label == "ne") {
 				// do not add country-code second-level ETLD domains to domains candidate list
 				continue
 			}
-			if !slices.Contains(domains, domainString) {
-				domains = append(domains, domainString)
+			if !slices.Contains(domains, domain) {
+				domains = append(domains, domain)
 			}
 		}
 	}
 	// order search domains by hostname from most specific to least specific,
-	// a more specific search domains of an earlier hostname might sort after
+	// a more specific search domain of an earlier hostname might sort after
 	// a search domain derived from a later hostname.
 	slices.Reverse(domains)
 	return

hinting/dns_search_domain_fallbacks_reverse.go

@@ -28,68 +28,68 @@ func reverseLookupDomains(addr netip.Addr) (domains []string) {
 // Fallbacks to obtain an external public IP address using DNS.
 
 // getAkaNS returns one random authoritative nameserver for akamai.net.
-func getAkaNS() (nameserver *string, err error) {
+func getAkaNS() (nameserver string, err error) {
 	// try default resolver
 	resolver := net.Resolver{}
 	ctx := context.TODO()
 	nameservers, err := resolver.LookupNS(ctx, akamaiDomain)
 	if err == nil {
-		return &nameservers[rand.Intn(len(nameservers))].Host, err
+		return nameservers[rand.Intn(len(nameservers))].Host, err
 	}
 
 	m := new(dns.Msg)
 	m.SetQuestion(akamaiDomain, dns.TypeNS)
 	// try Quad9
 	in, err := dns.Exchange(m, quad9DNSResolver)
 	if err != nil {
-		return nil, err
+		return "", err
 	}
 	if len(in.Answer) < 1 {
 		err = errors.New("getAkaNS: No DNS RR answer")
-		return nil, err
+		return "", err
 	}
 	if ns, ok := in.Answer[rand.Intn(len(in.Answer))].(*dns.NS); ok {
-		return &ns.Ns, nil
+		return ns.Ns, nil
 	}
-	return nil, errors.New("getAkaNS: Invalid NS record")
+	return "", errors.New("getAkaNS: Invalid NS record")
 }
 
 // getExternalIP returns the external IP used for DNS resolution of the executing host using nameserver.
-func getExternalIPbyNS(nameserver *string) (addr *netip.Addr, err error) {
-	if nameserver == nil {
+func getExternalIP(nameserver string) (addr netip.Addr, err error) {
+	if nameserver == "" {
 		// Default external authoritative nameserver
-		nameserver = &akamaiNameserver
+		nameserver = akamaiNameserver
 	}
 	m := new(dns.Msg)
 	// The akamai.net nameservers reply to queries for the name `whoami`
 	// with the IP address of the host sending the query.
 	m.SetQuestion("whoami.akamai.net.", dns.TypeA)
-	in, err := dns.Exchange(m, net.JoinHostPort(*nameserver, "53"))
+	in, err := dns.Exchange(m, net.JoinHostPort(nameserver, "53"))
 	if err != nil {
-		return nil, err
+		return netip.Addr{}, err
 	}
 	if len(in.Answer) < 1 {
 		err = errors.New("getExternalIP: No DNS RR answer")
-		return nil, err
+		return netip.Addr{}, err
 	}
 	if a, ok := in.Answer[0].(*dns.A); ok {
 		if addr, ok := netip.AddrFromSlice(a.A); ok {
-			return &addr, nil
+			return addr, nil
 		}
-		return nil, &net.AddrError{Err: "invalid IP address", Addr: a.A.String()}
+		return netip.Addr{}, &net.AddrError{Err: "invalid IP address", Addr: a.A.String()}
 	}
-	return nil, errors.New("getExternalIP: Invalid A record")
+	return netip.Addr{}, errors.New("getExternalIP: Invalid A record")
 }
 
 // queryExternalIP returns the external IP used for DNS resolution of the executing host.
-func queryExternalIP() (addr *netip.Addr, err error) {
+func queryExternalIP() (addr netip.Addr, err error) {
 	// Try with default NS
-	addr, err = getExternalIPbyNS(nil)
+	addr, err = getExternalIP("")
 	if err != nil {
 		// try with looking up alternative NS
 		ns, err := getAkaNS()
 		if err == nil {
-			addr, err = getExternalIPbyNS(ns)
+			addr, err = getExternalIP(ns)
 		}
 	}
 	return

hinting/dns_search_domain_fallbacks_test.go

@@ -7,7 +7,6 @@ import (
 )
 
 func TestReverseLookupDomains(t *testing.T) {
-
 	testCases := []struct {
 		name   string
 		values []struct {
@@ -74,6 +73,7 @@ func TestReverseLookupDomains(t *testing.T) {
 			},
 		},
 	}
+
 	for _, tc := range testCases {
 		t.Log(tc.name)
 		for _, v := range tc.values {
@@ -86,7 +86,6 @@ func TestReverseLookupDomains(t *testing.T) {
 }
 
 func TestDomainsFromHostnamesDerivation(t *testing.T) {
-
 	testCases := []struct {
 		name   string
 		values []struct {