dnsx/resolver: unset errs if answer non-empty

In some cases, the transports both error out (EOF) and send a response; and
in such cases (EOF denotes a force close), errors should not override the
actual answer, that is, it being overlooked by caching and alg layers.

This results in rest of the engine behaving as if these queries were never
resolved (neither cached nor mapped) when in fact they were.

A wrapper func, dnsx.Req, unset err if returned answer is not empty.

Author: ignoramous

intra/bootstrap.go

@@ -199,7 +199,7 @@ func (b *bootstrap) Query(network string, q []byte, summary *x.DNSSummary) ([]by
 	tr := b.Transport
 	if tr != nil {
 		log.V("dns: default: query %s %d", network, len(q))
-		return tr.Query(network, q, summary)
+		return dnsx.Req(tr, network, q, summary)
 	}
 	return nil, errDefaultTransportNotReady
 }

intra/dnsx/alg.go

@@ -186,19 +186,17 @@ func (t *dnsgateway) querySecondary(t2 Transport, network string, q []byte, out
 			ticker.Stop()
 			return
 		}
-	} else { // query secondary to get answer for q
-		if r, err = t2.Query(network, q, result.summary); err != nil {
-			log.D("alg: skip; sec transport %s err %v", t2.ID(), err)
-			return
-		}
+	} else {
+		// query secondary to get answer for q
+		r, err = Req(t2, network, q, result.summary)
 	}
 
-	if len(r) == 0 {
-		log.W("alg: skip; no primary or sec ans")
+	if err != nil {
+		log.D("alg: skip; sec transport %s err? %v", t2.ID(), err)
 		return
 	}
 
-	// check if answer r is blocked
+	// check if answer r is blocked; r is either from t2 or from <-in
 	if ans2 := xdns.AsMsg(r); ans2 == nil {
 		// not a valid dns answer
 		return
@@ -254,16 +252,19 @@ func (t *dnsgateway) q(t1, t2 Transport, preset []*netip.Addr, network string, q
 	if usepreset {
 		r, err = synthesizeOrQuery(preset, t1, q, network, innersummary)
 	} else {
-		r, err = query(t1, network, q, innersummary)
+		r, err = Req(t1, network, q, innersummary)
 	}
 	resch <- r
 
 	// override relevant values in summary
 	fillSummary(innersummary, summary)
 
 	if err != nil {
-		log.D("alg: abort; qerr %v", err)
-		return
+		if len(r) <= 0 {
+			log.D("alg: abort; r: 0, qerr %v", err)
+			return
+		}
+		log.D("alg: err but r ok; r: %d, qerr %v", len(r), err)
 	}
 
 	ansin := &dns.Msg{}
@@ -824,7 +825,7 @@ func hash48(s string) uint64 {
 func synthesizeOrQuery(pre []*netip.Addr, tr Transport, q []byte, network string, smm *x.DNSSummary) ([]byte, error) {
 	// synthesize a response with the given ips
 	if len(pre) == 0 {
-		return query(tr, network, q, smm)
+		return Req(tr, network, q, smm)
 	}
 	msg := xdns.AsMsg(q)
 	if msg == nil {
@@ -840,7 +841,7 @@ func synthesizeOrQuery(pre []*netip.Addr, tr Transport, q []byte, network string
 		// if no ips are of the same family as the question xdns.AQuadAForQuery returns error
 		ans, err := xdns.AQuadAForQuery(msg, unptr(pre)...)
 		if err != nil { // errors on invalid msg, question, or mismatched ips
-			return query(tr, network, q, smm)
+			return Req(tr, network, q, smm)
 		}
 		withPresetSummary(smm)
 		smm.RCode = xdns.Rcode(ans)
@@ -850,7 +851,7 @@ func synthesizeOrQuery(pre []*netip.Addr, tr Transport, q []byte, network string
 		log.D("alg: synthesize: q(4? %t / 6? %t) rdata(%s)", qname, is4, is6, smm.RData)
 		return ans.Pack()
 	} else if isHTTPS || isSVCB {
-		r, err := tr.Query(network, q, smm)
+		r, err := Req(tr, network, q, smm)
 		if err != nil {
 			return r, err
 		}
@@ -877,12 +878,29 @@ func synthesizeOrQuery(pre []*netip.Addr, tr Transport, q []byte, network string
 
 		return ans.Pack()
 	} else {
-		return query(tr, network, q, smm)
+		return Req(tr, network, q, smm)
 	}
 }
 
-func query(t Transport, network string, q []byte, smm *x.DNSSummary) ([]byte, error) {
-	return t.Query(network, q, smm)
+// Req sends q to transport t and returns the answer, if any;
+// errors are unset unless answer is empty;
+// smm, the in/out parameter, is dns summary as got from t.
+func Req(t Transport, network string, q []byte, smm *x.DNSSummary) ([]byte, error) {
+	if t == nil {
+		return nil, errNoSuchTransport
+	}
+	if len(q) <= 0 {
+		return nil, errNoQuestion
+	}
+	if smm == nil { // discard smm
+		discarded := new(x.DNSSummary)
+		smm = discarded
+	}
+	r, err := t.Query(network, q, smm)
+	if len(r) > 0 {
+		return r, nil
+	}
+	return r, err
 }
 
 func splitIPFamilies(ips []*netip.Addr) (ip4s, ip6s []*netip.Addr) {

intra/dnsx/cacher.go

@@ -310,7 +310,7 @@ func (t *ctransport) fetch(network string, q []byte, msg *dns.Msg, summary *x.DN
 		fsmm.Type = t.Transport.Type()
 
 		v, _ := t.reqbarrier.Do(key, func() (*cres, error) {
-			ans, qerr := t.Transport.Query(network, q, fsmm)
+			ans, qerr := Req(t.Transport, network, q, fsmm)
 			// cb.put no-ops when len(ans) is 0
 			cb.put(key, ans, fsmm)
 			// cres.ans may be nil

intra/doh/doh.go

@@ -483,11 +483,12 @@ func (t *transport) Query(network string, q []byte, smm *x.DNSSummary) (r []byte
 	}
 
 	status := dnsx.Complete
+	ans := xdns.AsMsg(r)
+
 	if qerr != nil {
 		status = qerr.Status()
 		err = qerr.Unwrap()
 	}
-	ans := xdns.AsMsg(r)
 	t.status = status
 
 	t.est.Add(elapsed.Seconds())

intra/x64/dns64.go

@@ -102,7 +102,7 @@ func (d *dns64) AddResolver(id string, r dnsx.Transport) bool {
 	d.register(id)
 
 	discarded := new(x.DNSSummary)
-	b, err := r.Query(dnsx.NetTypeUDP, arpa64, discarded)
+	b, err := dnsx.Req(r, dnsx.NetTypeUDP, arpa64, discarded)
 	if err != nil {
 		log.W("dns64: udp: could not query resolver %s", id)
 		return false
@@ -114,7 +114,7 @@ func (d *dns64) AddResolver(id string, r dnsx.Transport) bool {
 		return false
 	} else if ans.Truncated { // should never be the case for DOH, ODOH, DOT
 		// else if: returned response is truncated dns ans, retry over tcp
-		b, err = r.Query(dnsx.NetTypeTCP, arpa64, discarded)
+		b, err = dnsx.Req(r, dnsx.NetTypeTCP, arpa64, discarded)
 		if err != nil {
 			log.W("dns64: tcp: could not query resolver %s", id)
 			return false
@@ -240,7 +240,7 @@ func (d *dns64) query64(msg6 *dns.Msg, r dnsx.Transport) (*dns.Msg, error) {
 	}
 
 	discarded := new(x.DNSSummary)
-	a4, err := r.Query(dnsx.NetTypeUDP, q4, discarded)
+	a4, err := dnsx.Req(r, dnsx.NetTypeUDP, q4, discarded)
 	log.D("dns64: udp: upstream q(%s) / a(%d) / e(%v) / e-not-nil(%t)", xdns.QName(msg4), len(a4), err, err != nil)
 	if err != nil {
 		return nil, err
@@ -253,7 +253,7 @@ func (d *dns64) query64(msg6 *dns.Msg, r dnsx.Transport) (*dns.Msg, error) {
 		return nil, err
 	} else if res.Truncated { // should never be the case for DOH, ODOH, DOT
 		// else if: returned response is truncated dns ans, retry over tcp
-		a4, err = r.Query(dnsx.NetTypeTCP, q4, discarded)
+		a4, err = dnsx.Req(r, dnsx.NetTypeTCP, q4, discarded)
 		log.D("dns64: tcp: upstream q(%s) / a(%d) / e(%v) / e-not-nil(%t)", xdns.QName(msg4), len(a4), err, err != nil)
 		if err != nil {
 			return nil, err