dnsx: preserve summary as sent by actual dns transports

decorative transports such as alg, cacher, dns64, resolver may meddle
with summaries, but ideally, we want to preserve the original summary
as transformed by an actual transport (doh, dot, upstream, goos, bootstrap etc)
as-is.

Author: ignoramous

intra/dnsx/alg.go

@@ -934,8 +934,8 @@ func (t *dnsgateway) q(t1, t2 Transport, preset []netip.Addr, network, uid strin
 
 	// todo: skip alg for undelegated domains like ipv4only.arpa?
 	if !hasq || !hasans || !rgood || ans0000 || dontalg {
-		log.D("alg: skip; query %s<>%s[%s]:%s:%d / a:%d, dnssec(do? %t /ad? %t) self(%t) dontalg(%t) hasq(%t) hasans(%t) rgood(%t), ans0000(%t)",
-			smm.ID, idstr(t1), uid, qname, qtyp, xdns.Len(ansin), smm.DO, smm.AD, uidself, dontalg, hasq, hasans, rgood, ans0000)
+		log.D("alg: skip; query %s<>%s[%s]:%s:%d / a:%d + rdata: %s + status: %d, dnssec(do? %t /ad? %t) self(%t) dontalg(%t) hasq(%t) hasans(%t) rgood(%t), ans0000(%t)",
+			smm.ID, idstr(t1), uid, qname, qtyp, xdns.Len(ansin), smm.RData, smm.Status, smm.DO, smm.AD, uidself, dontalg, hasq, hasans, rgood, ans0000)
 		return ansin, nil
 	}
 
@@ -1854,14 +1854,16 @@ func Req(t Transport, network string, q *dns.Msg, smm *x.DNSSummary) (*dns.Msg,
 	r, err := t.Query(network, q, smm)
 
 	if r == nil {
-		log.V("alg: Req: %s:%d no answer; rdata: %s, rcode: %d; err? %v", qname, qtyp, smm.RData, smm.Status, err)
+		log.V("alg: Req: %s:%d no answer; by: %s, rdata: %s, status: %d; err? %v",
+			qname, qtyp, smm.ID, smm.RData, smm.Status, err)
 		return nil, err // err may be nil
 	}
 	if !xdns.IsServFailOrInvalid(r) {
 		return r, nil
 	}
 
-	log.V("alg: Req: %s:%d servfail; status: %d, rdata: %s, rcode %d", qname, qtyp, smm.RData, smm.Status, xdns.Rcode(r))
+	log.V("alg: Req: %s:%d servfail; by: %s, rdata: %d, status: %s, rcode %d",
+		qname, qtyp, smm.ID, smm.RData, smm.Status, xdns.Rcode(r))
 	return r, err
 }
 

intra/dnsx/cacher.go

@@ -380,54 +380,51 @@ func (t *ctransport) fetch(network string, q *dns.Msg, smmout *x.DNSSummary, cb
 			}
 		}()
 
-		cc := &cres{ans: nil, s: copySummary(smm2)}
+		ccx := &cres{ans: nil, s: copySummary(smm2)}
 		cc, err := t.reqbarrier.DoIt(key, func() (_ *cres, qerr error) {
 			reqsent = true
 			// ans may be nil
-			cc.ans, qerr = Req(t.Transport, network, q, smm2)
-			cc.s = copySummary(smm2) // copy summary to cc
+			ccx.ans, qerr = Req(t.Transport, network, q, smm2)
+			ccx.s = copySummary(smm2) // copy summary to cc
 			t.hangoverCheckpoint()
 			// cb.put no-ops when ans is nil or rcode != success (0)
-			cb.put(key, cc)
-			return cc, qerr
+			cb.put(key, ccx)
+			return ccx, qerr
 		})
 
 		cachedres, fresh := cb.freshCopy(key) // always prefer value from cache
 		cachehit := cachedres != nil
 		// nil ans when Transport returns err (no servfail) and cache is empty
-		hasans := cachedres != nil && cachedres.ans != nil
+		cachedans := cachedres != nil && cachedres.ans != nil
+
+		// if there's no network connectivity (in hangover for 10s) don't
+		// return cached/barriered response, instead return an error
+		inhangover := t.hangover.Exceeds(httl)
 
 		// expect fresh values, except on verrs
-		logwif(!fresh)("cache: barrier: (k: %s) hit? %t / hasans? %t / stale? %t; sent? %t, barrier: %s (cache: %s); qerr? %v",
-			key, cachehit, hasans, !fresh, reqsent, cc, cachedres, err)
+		logwif(cachehit && !fresh || err != nil)("cache: barrier: (k: %s) hit? %t / hitans? %t / stale? %t / sent? %t / hangover? %t, barrier: %s (cache: %s); qerr? %v",
+			key, cachehit, cachedans, !fresh, reqsent, inhangover, cc, cachedres, err)
 
-		if !cachehit || !hasans { // cc.Val may be uncacheable (ex: rcode != 0)
-			cachedres = cc.copy() // cc (cres) never nil; but cc.ans may be nil
+		if !cachehit || !cachedans { // cc.Val may be uncacheable (ex: rcode != 0)
+			cachedres = cc // cc (cres) never nil; but cc.ans may be nil
 		}
 
-		// if there's no network connectivity (in hangover for 10s) don't
-		// return cached/barriered response, instead return an error
-		inhangover := t.hangover.Exceeds(httl)
 		if inhangover {
 			err = core.JoinErr(err, errHangover)
 			log.W("cache: barrier: hangover(k: %s); sent? %t, discard ans (has? %t)",
-				key, reqsent, hasans)
-			if cachehit {
-				fillSummary(cachedres.s, smm2)
-			}
+				key, reqsent, cachedans)
+			fillSummary(cachedres.s, smm2)
 			// mimic send fail
 			smm2.Msg = err.Error()
-			smm2.RCode = dns.RcodeServerFailure
+			smm2.RCode = dns.RcodeBadTime
 			smm2.Status = SendFailed
 			// do not return any response (stall / drop silently)
 			return nil, err
 		}
 
 		// fres may be nil
 		fres, cachedsmm, ferr := asResponse(q, cachedres, fresh)
-		if cachehit { // fill from cachedsmm despite any err if cache was hit
-			fillSummary(cachedsmm, smm2) // cachedsmm may itself be smm2
-		}
+		fillSummary(cachedsmm, smm2) // cachedsmm may itself be smm2
 
 		return fres, core.JoinErr(err, ferr)
 	}
@@ -504,7 +501,6 @@ func (t *ctransport) Query(network string, q *dns.Msg, smm *x.DNSSummary) (*dns.
 		t.Unlock()
 
 		response, err = t.fetch(network, q, smm, cb, key)
-
 	} else {
 		err = errMissingQueryName // not really a transport error
 	}
@@ -561,9 +557,6 @@ func fillSummary(s *x.DNSSummary, out *x.DNSSummary) {
 	if out == nil || s == out {
 		return
 	}
-	if s == out {
-		return
-	}
 
 	// prefer out
 

intra/doh/doh.go

@@ -753,8 +753,8 @@ func (t *transport) Query(network string, q *dns.Msg, smm *x.DNSSummary) (r *dns
 	if err != nil {
 		smm.Msg = err.Error()
 	}
-	log.V("doh: (p/px/via %s/%s/%s); a:%d/sz:%d/pad:%d, q: %s:%s, data: %s, via: %s, err? %v",
-		network, pid, rpid, xdns.Len(r), xdns.Size(r), xdns.EDNS0PadLen(r), smm.QName, smm.QType, smm.RData, smm.PID, err)
+	log.V("doh: (p/px/via %s/%s/%s); a:%d/sz:%d/pad:%d, q: %s:%d, data: %s, code: %d, via: %s, err? %v",
+		network, pid, rpid, xdns.Len(r), xdns.Size(r), xdns.EDNS0PadLen(r), smm.QName, smm.QType, smm.RData, smm.RCode, smm.PID, err)
 	return r, err
 }