pan callers: reuse context where available in call to pan.ResolveUDPAddr

Add a context to all callers of ResolveUDPAddr

Author: FR4NK-W

_examples/helloquic/helloquic.go

@@ -106,7 +106,7 @@ func workSession(session quic.Session) error {
 }
 
 func runClient(address string, count int) error {
-	addr, err := pan.ResolveUDPAddr(address)
+	addr, err := pan.ResolveUDPAddr(context.TODO(), address)
 	if err != nil {
 		return err
 	}

_examples/helloworld/helloworld.go

@@ -75,7 +75,7 @@ func runServer(listen netaddr.IPPort) error {
 }
 
 func runClient(address string, count int) error {
-	addr, err := pan.ResolveUDPAddr(address)
+	addr, err := pan.ResolveUDPAddr(context.TODO(), address)
 	if err != nil {
 		return err
 	}

netcat/quic.go

@@ -65,7 +65,7 @@ func DoListenQUIC(port uint16) (chan io.ReadWriteCloser, error) {
 
 // DoDialQUIC dials with a QUIC socket
 func DoDialQUIC(remote string, policy pan.Policy) (io.ReadWriteCloser, error) {
-	remoteAddr, err := pan.ResolveUDPAddr(remote)
+	remoteAddr, err := pan.ResolveUDPAddr(context.TODO(), remote)
 	if err != nil {
 		return nil, err
 	}

netcat/udp.go

@@ -55,7 +55,7 @@ func (conn *udpListenConn) Close() error {
 
 // DoDialUDP dials with a UDP socket
 func DoDialUDP(remote string, policy pan.Policy) (io.ReadWriteCloser, error) {
-	remoteAddr, err := pan.ResolveUDPAddr(remote)
+	remoteAddr, err := pan.ResolveUDPAddr(context.TODO(), remote)
 	if err != nil {
 		return nil, err
 	}

pkg/pan/dns_txt.go

@@ -16,6 +16,7 @@ package pan
 
 import (
 	"context"
+	"errors"
 	"fmt"
 	"net"
 	"strings"
@@ -49,8 +50,9 @@ func queryTXTRecord(ctx context.Context, host string) (addresses []string, err e
 	}
 	resolver := net.Resolver{}
 	txtRecords, err := resolver.LookupHost(ctx, host)
-	if dnsError, ok := err.(*net.DNSError); ok {
-		if dnsError.IsNotFound {
+	var errDNSError *net.DNSError
+	if errors.As(err, &errDNSError) {
+		if errDNSError.IsNotFound {
 			return addresses, HostNotFoundError{host}
 		}
 	}

pkg/pan/hosts.go

@@ -26,7 +26,7 @@ var (
 	resolveEtcHosts      resolver = &hostsfileResolver{"/etc/hosts"}
 	resolveEtcScionHosts resolver = &hostsfileResolver{"/etc/scion/hosts"}
 	resolveRains         resolver = nil
-	resolveDnsTxt        resolver = &dnsResolver{}
+	resolveDNSTxt        resolver = &dnsResolver{}
 )
 
 // resolveUDPAddrAt parses the address and resolves the hostname.
@@ -66,7 +66,7 @@ func defaultResolver() resolver {
 		resolveEtcHosts,
 		resolveEtcScionHosts,
 		resolveRains,
-		resolveDnsTxt,
+		resolveDNSTxt,
 	}
 }
 

pkg/pan/hostsfile.go

@@ -20,29 +20,21 @@ import (
 	"fmt"
 	"os"
 	"strings"
-	"sync"
-	"time"
 )
 
 type hostsTable map[string]scionAddr
 
-var cachedHostsTable struct {
-	mapping hostsTable
-	updated time.Time
-	sync.Mutex
-}
-
 // hostsfileResolver is an implementation of the resolver interface, backed
 // by an /etc/hosts-like file.
 type hostsfileResolver struct {
 	path string
 }
 
-var _ resolver = &hostsfileResolver{}
-
 func (r *hostsfileResolver) Resolve(ctx context.Context, name string) (scionAddr, error) {
-	cachedHostsTable.Lock()
-	defer cachedHostsTable.Unlock()
+	// Note: obviously not perfectly elegant to parse the entire file for
+	// every query. However, properly caching this and still always provide
+	// fresh results after changes to the hosts file seems like a bigger task and
+	// for now that would be overkill.
 	table, err := loadHostsFile(r.path)
 	if err != nil {
 		return scionAddr{}, fmt.Errorf("error loading %s: %w", r.path, err)
@@ -54,34 +46,17 @@ func (r *hostsfileResolver) Resolve(ctx context.Context, name string) (scionAddr
 	return addr, nil
 }
 
-// loadHostsFile provides a cached copy of the hostsTable or loads and parses the host file at path if it was modified
-// since the last update.
 func loadHostsFile(path string) (hostsTable, error) {
-	stat, err := os.Stat(path)
+	file, err := os.Open(path)
 	if os.IsNotExist(err) {
 		// not existing file treated like an empty file,
 		// just return an empty table
 		return hostsTable(nil), nil
-	}
-	if err != nil {
-		return hostsTable(nil), err
-	}
-	if stat.ModTime().Before(cachedHostsTable.updated) {
-		return cachedHostsTable.mapping, nil
-	}
-
-	file, err := os.Open(path)
-	if err != nil {
-		return hostsTable(nil), err
+	} else if err != nil {
+		return nil, err
 	}
 	defer file.Close()
-	mapping, err := parseHostsFile(file)
-	if err != nil {
-		return hostsTable(nil), err
-	}
-	cachedHostsTable.mapping = mapping
-	cachedHostsTable.updated = time.Now()
-	return cachedHostsTable.mapping, nil
+	return parseHostsFile(file)
 }
 
 func parseHostsFile(file *os.File) (hostsTable, error) {

pkg/pan/pan.go

@@ -105,11 +105,8 @@ package pan
 import (
 	"context"
 	"fmt"
-	"time"
 )
 
-var defaultResolveTimeout = time.Second
-
 // ResolveUDPAddr parses the address and resolves the hostname.
 // The address can be of the form of a SCION address (i.e. of the form "ISD-AS,[IP]:port")
 // or in the form of "hostname:port".
@@ -123,25 +120,8 @@ var defaultResolveTimeout = time.Second
 //  - DNS TXT records using the local DNS resolver (depending on OS config, see "Name Resolution" in net package docs)
 //
 // Returns HostNotFoundError if none of the sources did resolve the hostname.
-func ResolveUDPAddr(address string) (addr UDPAddr, err error) {
-	ctx, cancel := context.WithTimeout(context.Background(), defaultResolveTimeout)
-	defer cancel()
-	return ResolveUDPAddrContext(ctx, address)
-}
-
-// ResolveUDPAddrContext resolves address, taking a context and a cancel function, see ResolveUDPAddr.
-func ResolveUDPAddrContext(ctx context.Context, address string) (addr UDPAddr, err error) {
-	done := make(chan struct{})
-	go func() {
-		defer close(done)
-		addr, err = resolveUDPAddrAt(ctx, address, defaultResolver())
-	}()
-	select {
-	case <-ctx.Done():
-		return UDPAddr{}, context.DeadlineExceeded
-	case <-done:
-	}
-	return
+func ResolveUDPAddr(ctx context.Context, address string) (UDPAddr, error) {
+	return resolveUDPAddrAt(ctx, address, defaultResolver())
 }
 
 // HostNotFoundError is returned by ResolveUDPAddr when the name was not found, but

pkg/pan/rains.go

@@ -64,7 +64,7 @@ func readRainsConfig() (UDPAddr, error) {
 	return address, nil
 }
 
-func rainsQuery(ctx context.Context, server UDPAddr, hostname string) (scionAddr, error) {
+func rainsQuery(ctx context.Context, server UDPAddr, hostname string) (addr scionAddr, err error) {
 	const (
 		rainsCtx = "."                    // use global context
 		qType    = rains.OTScionAddr      // request SCION addresses
@@ -79,17 +79,34 @@ func rainsQuery(ctx context.Context, server UDPAddr, hostname string) (scionAddr
 	// TODO(chaehni): This call can sometimes cause a timeout even though the server is reachable (see issue #221)
 	// The timeout value has been decreased to counter this behavior until the problem is resolved.
 	srv := server.snetUDPAddr()
-	reply, err := rains.Query(hostname, rainsCtx, []rains.Type{qType}, qOpts, expire, timeout, srv)
-	if err != nil {
-		return scionAddr{}, fmt.Errorf("address for host %q not found: %w", hostname, err)
-	}
-	addrStr, ok := reply[qType]
-	if !ok {
-		return scionAddr{}, &HostNotFoundError{hostname}
+
+	done := make(chan struct{})
+	go func() {
+		defer close(done)
+		var reply map[rains.Type]string
+		reply, err = rains.Query(hostname, rainsCtx, []rains.Type{qType}, qOpts, expire, timeout, srv)
+		if err != nil {
+			err = fmt.Errorf("address for host %q not found: %w", hostname, err)
+			return
+		}
+		addrStr, ok := reply[qType]
+		if !ok {
+			err = &HostNotFoundError{hostname}
+			return
+		}
+		addr, err = parseSCIONAddr(addrStr)
+		if err != nil {
+			err = fmt.Errorf("address for host %q invalid: %w", hostname, err)
+			addr = scionAddr{}
+		}
+	}()
+	select {
+	case <-ctx.Done():
+		return scionAddr{}, context.DeadlineExceeded
+	case <-done:
 	}
-	addr, err := parseSCIONAddr(addrStr)
 	if err != nil {
-		return scionAddr{}, fmt.Errorf("address for host %q invalid: %w", hostname, err)
+		return scionAddr{}, err
 	}
 	return addr, nil
 }

pkg/shttp/transport.go

@@ -79,7 +79,7 @@ func (d *Dialer) DialContext(ctx context.Context, network, addr string) (net.Con
 		InsecureSkipVerify: true,
 	}
 
-	remote, err := pan.ResolveUDPAddr(pan.UnmangleSCIONAddr(addr))
+	remote, err := pan.ResolveUDPAddr(ctx, pan.UnmangleSCIONAddr(addr))
 	if err != nil {
 		return nil, err
 	}