all: guard vv/v/d logs with settings.Debug

Author: ignoramous

intra/bootstrap.go

@@ -22,6 +22,7 @@ import (
 	"github.com/celzero/firestack/intra/ipn"
 	"github.com/celzero/firestack/intra/log"
 	"github.com/celzero/firestack/intra/protect"
+	"github.com/celzero/firestack/intra/settings"
 	"github.com/celzero/firestack/intra/xdns"
 	"github.com/miekg/dns"
 )
@@ -267,7 +268,9 @@ func (b *bootstrap) Query(network string, q *dns.Msg, smm *x.DNSSummary) (*dns.M
 	smm.Type = b.typ
 	smm.UID = protect.UidSelf
 	if tr := b.tr; tr != nil {
-		log.V("dns: default: %s query? %t", network, q != nil)
+		if settings.Debug {
+			log.V("dns: default: %s query? %t", network, q != nil)
+		}
 		return dnsx.Req(tr, network, q, smm)
 	}
 	smm.Status = dnsx.TransportError // InternalError?

intra/dialers/cdial.go

@@ -16,6 +16,7 @@ import (
 	"github.com/celzero/firestack/intra/core"
 	"github.com/celzero/firestack/intra/log"
 	"github.com/celzero/firestack/intra/protect/ipmap"
+	"github.com/celzero/firestack/intra/settings"
 )
 
 const dialRetryTimeout = 35 * time.Second
@@ -64,8 +65,10 @@ func commondial2[D rdials, C rconns](d D, network, laddr, raddr string, connect
 	local, lerr := netip.ParseAddrPort(laddr) // okay if local is invalid
 	domain, portstr, err := net.SplitHostPort(raddr)
 
-	log.D("commondial: dialing (host:port) %s=>%s; errs? %v %v",
-		laddr, raddr, lerr, err)
+	if settings.Debug {
+		log.D("commondial: dialing (host:port) %s=>%s; errs? %v %v",
+			laddr, raddr, lerr, err)
+	}
 
 	if err != nil {
 		return nil, err
@@ -90,21 +93,27 @@ func commondial2[D rdials, C rconns](d D, network, laddr, raddr string, connect
 
 	defer func() {
 		dur := time.Since(start)
-		log.D("commondial: duration: %s; addr %s; confirmed? %s, sz: %d", dur, raddr, confirmed, ips.Size())
+		if settings.Debug {
+			log.D("commondial: duration: %s; addr %s; confirmed? %s, sz: %d", dur, raddr, confirmed, ips.Size())
+		}
 	}()
 
 	// One the TODO is fixed, change ipn/proxy.go:Reaches to rely on this behaviour
 	// TODO: confirmedIPOK must be used depending on network type "tcp4", "udp4", "tcp6", "udp6" etc
 	if confirmedIPOK {
 		remote := netip.AddrPortFrom(confirmed, uint16(port))
-		log.V("commondial: dialing confirmed ip %s for %s", confirmed, remote)
+		if settings.Debug {
+			log.V("commondial: dialing confirmed ip %s for %s", confirmed, remote)
+		}
 		conn, err = connect(d, network, local, remote)
 		// nilaway: tx.socks5 returns nil conn even if err == nil
 		if conn == nil {
 			err = core.OneErr(err, errNoConn)
 		}
 		if err == nil {
-			log.V("commondial: ip %s works for %s", confirmed, remote)
+			if settings.Debug {
+				log.V("commondial: ip %s works for %s", confirmed, remote)
+			}
 			return conn, nil
 		}
 		errs = core.JoinErr(errs, err)

intra/dialers/op.go

@@ -14,6 +14,7 @@ import (
 
 	"github.com/celzero/firestack/intra/core"
 	"github.com/celzero/firestack/intra/log"
+	"github.com/celzero/firestack/intra/settings"
 )
 
 // Copy one buffer from src to dst, using dst.Write.
@@ -81,7 +82,9 @@ func writeTCPSplit(w net.Conn, hello []byte) (n int, err error) {
 		log.E("op: splits: TCP2 %s (%d): err %v", to, len(second), err)
 		return p + q, err
 	}
-	log.D("op: splits: %s=>%s; TCP: %d/%d,%d/%d", from, to, p, len(first), q, len(second))
+	if settings.Debug {
+		log.D("op: splits: %s=>%s; TCP: %d/%d,%d/%d", from, to, p, len(first), q, len(second))
+	}
 
 	return p + q, nil
 }
@@ -94,7 +97,9 @@ func writeTCPOrTLSSplit(w net.Conn, hello []byte) (n int, err error) {
 
 	if len(hello) <= 1 {
 		n, err = w.Write(hello)
-		log.D("op: splits: %s=>%s; len(hello) <= 1; n: %d; err: %v", from, to, n, err)
+		if settings.Debug {
+			log.D("op: splits: %s=>%s; len(hello) <= 1; n: %d; err: %v", from, to, n, err)
+		}
 		return
 	}
 

intra/dns.go

@@ -20,6 +20,7 @@ import (
 	"github.com/celzero/firestack/intra/ipn"
 	"github.com/celzero/firestack/intra/log"
 	"github.com/celzero/firestack/intra/protect"
+	"github.com/celzero/firestack/intra/settings"
 	"github.com/celzero/firestack/intra/xdns"
 )
 
@@ -72,6 +73,9 @@ func SetSystemDNS(t Tunnel, ipcsvx *x.Gostr) error {
 	// this is the case if kotlin-land is unable to determine
 	// DNS servers. This is equivalent to using x.Goos Transport.
 	if strings.HasPrefix(ipcsv, "localhost") {
+		if settings.Debug {
+			log.D("dns: system dns is localhost, using loopback")
+		}
 		ipcsv = localip4 + "," + localip6
 	}
 

intra/dns53/dot.go

@@ -22,6 +22,7 @@ import (
 	"github.com/celzero/firestack/intra/dnsx"
 	"github.com/celzero/firestack/intra/ipn"
 	"github.com/celzero/firestack/intra/log"
+	"github.com/celzero/firestack/intra/settings"
 	"github.com/celzero/firestack/intra/xdns"
 	"github.com/miekg/dns"
 	_ "go4.org/unsafe/assume-no-moving-gc"
@@ -230,8 +231,10 @@ func (t *dot) pxdial(pid string) (*dns.Conn, string, uintptr, bool, error) {
 	}
 	pid = px.ID().V()
 	rpid := ipn.ViaID(px)
-	log.V("dot: pxdial: (%s) using relay/proxy %s (via: %s) at %s",
-		t.id, pid, rpid, px.GetAddr())
+	if settings.Debug {
+		log.V("dot: pxdial: (%s) using relay/proxy %s (via: %s) at %s",
+			t.id, pid, rpid, px.GetAddr())
+	}
 
 	c, who, ech, err := t.tlsdial(px)
 	return c, rpid, who, ech, err
@@ -261,7 +264,9 @@ func (t *dot) fromPool(id uintptr) (c *dns.Conn) {
 	if c, ok = pooled.(*dns.Conn); !ok { // unlikely
 		return &dns.Conn{Conn: pooled}
 	}
-	log.V("dot: pool: (%s) got conn from %v", t.id, id)
+	if settings.Debug {
+		log.V("dot: pool: (%s) got conn from %v", t.id, id)
+	}
 	return
 }
 
@@ -352,8 +357,10 @@ func (t *dot) Query(network string, q *dns.Msg, smm *x.DNSSummary) (ans *dns.Msg
 	smm.Status = status
 	t.est.Add(smm.Latency)
 
-	log.V("dot: %s ech? %t; len(res): fro %s:%d a:%d/sz:%d/pad:%d, data: %s / status: %d, via: %s, err? %v",
-		t.id, ech, smm.QName, smm.QType, xdns.Len(ans), xdns.Size(ans), xdns.EDNS0PadLen(ans), smm.RData, smm.Status, smm.PID, err)
+	if settings.Debug {
+		log.V("dot: %s ech? %t; len(res): fro %s:%d a:%d/sz:%d/pad:%d, data: %s / status: %d, via: %s, err? %v",
+			t.id, ech, smm.QName, smm.QType, xdns.Len(ans), xdns.Size(ans), xdns.EDNS0PadLen(ans), smm.RData, smm.Status, smm.PID, err)
+	}
 
 	return
 }

intra/dns53/ipmapper.go

@@ -20,6 +20,7 @@ import (
 	"github.com/celzero/firestack/intra/log"
 	"github.com/celzero/firestack/intra/protect"
 	"github.com/celzero/firestack/intra/protect/ipmap"
+	"github.com/celzero/firestack/intra/settings"
 	"github.com/celzero/firestack/intra/xdns"
 	"github.com/miekg/dns"
 )
@@ -122,7 +123,9 @@ func (m *ipmapper) queryIP2(_ context.Context, network, host, uid string, tid ..
 		return []netip.Addr{ip}, nil
 	}
 
-	log.V("ipmapper: lookup: host %s:%s for %s on %v", network, host, uid, tid)
+	if settings.Debug {
+		log.V("ipmapper: lookup: host %s:%s for %s on %v", network, host, uid, tid)
+	}
 
 	var q4, q6 []byte
 	var err4, err6 error
@@ -197,8 +200,10 @@ func (m *ipmapper) queryIP2(_ context.Context, network, host, uid string, tid ..
 	ip6 = m.undoAlgAndOrNat64(ip6, tid6, uid) // nat64 cannot really be "undone" for ip6!
 	ips := append(ip4, ip6...)
 
-	log.D("ipmapper: host %s => ips (out: %v / in: %d+%d); uid: %s, tids: %s+%s; err4: %v, err6: %v",
-		host, ips, len(r4), len(r6), uid, tid4, tid6, lerr4, lerr6)
+	if settings.Debug {
+		log.D("ipmapper: host %s => ips (out: %v / in: %d+%d); uid: %s, tids: %s+%s; err4: %v, err6: %v",
+			host, ips, len(r4), len(r6), uid, tid4, tid6, lerr4, lerr6)
+	}
 	return ips, nil
 }
 
@@ -216,7 +221,9 @@ func (m *ipmapper) queryAny2(q []byte, uid string, tids ...string) ([]byte, erro
 	qtype := int(xdns.QType(msg))
 	qtypestr := strconv.Itoa(qtype)
 
-	log.V("ipmapper: lookup: host %s, uid: %v", qname, uid)
+	if settings.Debug {
+		log.V("ipmapper: lookup: host %s, uid: %v", qname, uid)
+	}
 
 	var v *core.V[answer, string]
 	if len(tids) > 0 {
@@ -269,7 +276,9 @@ func (m *ipmapper) locallookup(q []byte) func() (answer, error) {
 func (m *ipmapper) undoAlg(ans []byte, tid, uid string) ([]byte, error) {
 	gw := m.g
 	if gw == nil {
-		log.V("ipmapper: undoAlg: no-op for %s[%s]; no gateway", tid, uid)
+		if settings.Debug {
+			log.V("ipmapper: undoAlg: no-op for %s[%s]; no gateway", tid, uid)
+		}
 		return ans, nil
 	}
 
@@ -286,8 +295,10 @@ func (m *ipmapper) undoAlg(ans []byte, tid, uid string) ([]byte, error) {
 	is6 := !is4 && xdns.HasAAAAQuestion(msg)
 
 	if !is4 && !is6 || noips {
-		log.VV("ipmapper: undoAlg: no a? (%t), aaaa? (%t), ans? (%t); no-op",
-			!is4, !is6, noips)
+		if settings.Debug {
+			log.VV("ipmapper: undoAlg: no a? (%t), aaaa? (%t), ans? (%t); no-op",
+				!is4, !is6, noips)
+		}
 		return ans, nil
 	}
 
@@ -348,7 +359,9 @@ func (m *ipmapper) undoAlgAndOrNat64(ip64 []netip.Addr, tid, uid string) []netip
 	// based on the dialers.Use4/Use6 settings.
 	gw := m.g
 	if gw == nil {
-		log.V("ipmapper: undoAlg: no-op for %v on %s[%s]; no gateway", ip64, tid, uid)
+		if settings.Debug {
+			log.V("ipmapper: undoAlg: no-op for %v on %s[%s]; no gateway", ip64, tid, uid)
+		}
 		return ip64
 	}
 	realips := make([]netip.Addr, 0, len(ip64))

intra/dns53/upstream.go

@@ -157,8 +157,10 @@ func (t *transport) pxdial(network, pid string) (*dns.Conn, string, uintptr, err
 		return c, rpid, who, nil
 	}
 
-	log.V("dns53: pxdial: (%s) using %s relay/proxy %s at %s",
-		t.id, network, px.ID(), px.GetAddr())
+	if settings.Debug {
+		log.V("dns53: pxdial: (%s) using %s relay/proxy %s at %s",
+			t.id, network, px.ID(), px.GetAddr())
+	}
 
 	pxconn, err := px.Dialer().Dial(network, t.addrport)
 	if err != nil {
@@ -198,7 +200,9 @@ func (t *transport) fromPool(id uintptr) (c *dns.Conn) {
 		log.W("dns53: pool: (%s) not a dns.Conn for %d!", t.id, id)
 		return &dns.Conn{Conn: pooled}
 	}
-	log.V("dns53: pool: (%s) got conn for %d", t.id, id)
+	if settings.Debug {
+		log.V("dns53: pool: (%s) got conn for %d", t.id, id)
+	}
 	return
 }
 
@@ -308,8 +312,10 @@ func (t *transport) Query(network string, q *dns.Msg, smm *x.DNSSummary) (ans *d
 	smm.Status = status
 	t.est.Add(smm.Latency)
 
-	log.V("dns53: (%s) len(res): %d, data: %s, via: %s, err? %v",
-		t.id, xdns.Len(ans), smm.RData, smm.PID, err)
+	if settings.Debug {
+		log.V("dns53: (%s) len(res): %d, data: %s, via: %s, err? %v",
+			t.id, xdns.Len(ans), smm.RData, smm.PID, err)
+	}
 
 	return ans, err
 }

intra/dnscrypt/multiserver.go

@@ -32,6 +32,7 @@ import (
 	"github.com/celzero/firestack/intra/ipn"
 	"github.com/celzero/firestack/intra/log"
 	"github.com/celzero/firestack/intra/protect"
+	"github.com/celzero/firestack/intra/settings"
 	"github.com/celzero/firestack/intra/xdns"
 	"github.com/miekg/dns"
 	"golang.org/x/crypto/curve25519"
@@ -349,8 +350,10 @@ func resolve(network string, data *dns.Msg, si *serverinfo, smm *x.DNSSummary) (
 		smm.PID = pid
 	}
 
-	log.V("dnscrypt: len(res): %d, data: %s, via: %s, err? %v",
-		xdns.Len(ans), smm.RData, smm.PID, err)
+	if settings.Debug {
+		log.V("dnscrypt: len(res): %d, data: %s, via: %s, err? %v",
+			xdns.Len(ans), smm.RData, smm.PID, err)
+	}
 
 	return // ans, err
 }
@@ -375,7 +378,9 @@ func (proxy *DcMulti) refreshOne(uid string) (bool, error) {
 		log.E("dnscrypt: refresh failed %s: %s; err: %v", r.name, stamp2str(r.stamp), err)
 		return false, err
 	}
-	log.D("dnscrypt: refresh success %s: %s", r.name, stamp2str(r.stamp))
+	if settings.Debug {
+		log.D("dnscrypt: refresh success %s: %s", r.name, stamp2str(r.stamp))
+	}
 	return true, nil
 }
 
@@ -523,7 +528,9 @@ func (proxy *DcMulti) RemoveGateways(routescsv string) (int, error) {
 	if l != n { // routes changed
 		go proxy.refreshRoutes()
 	}
-	log.V("dnscrypt: removed %d/%d; relays: %s", l-n, l, routescsv)
+	if settings.Debug {
+		log.V("dnscrypt: removed %d/%d; relays: %s", l-n, l, routescsv)
+	}
 	return l - n, nil
 }
 
@@ -534,7 +541,9 @@ func (proxy *DcMulti) removeOne(uid string) int {
 
 	// TODO: handle err
 	n, err := proxy.serversInfo.unregisterServer(uid)
-	log.D("dnscrypt: removed %s; %d servers (err? %v)", uid, n, err)
+	if settings.Debug {
+		log.D("dnscrypt: removed %s; %d servers (err? %v)", uid, n, err)
+	}
 	return n
 }
 
@@ -543,7 +552,9 @@ func (proxy *DcMulti) Remove(uid *x.Gostr) bool {
 	// may be a gateway / relay or a dnscrypt server
 	n := proxy.removeOne(uid.V())
 	nr, nerr := proxy.RemoveGateways(uid.V())
-	log.D("dnscrypt: removed %s; %d servers; %d relays [err %v]", uid, n, nr, nerr)
+	if settings.Debug {
+		log.D("dnscrypt: removed %s; %d servers; %d relays [err %v]", uid, n, nr, nerr)
+	}
 	return true
 }
 
@@ -580,7 +591,9 @@ func (proxy *DcMulti) addOne(uid, rawstamp string) (string, error) {
 	proxy.registeredServers[uid] = registeredserver{name: uid, stamp: stamp}
 	proxy.Unlock()
 
-	log.D("dnscrypt: added [%s] %s", uid, stamp2str(stamp))
+	if settings.Debug {
+		log.D("dnscrypt: added [%s] %s", uid, stamp2str(stamp))
+	}
 	return uid, nil
 }
 

intra/dnscrypt/servers.go

@@ -32,6 +32,7 @@ import (
 	"github.com/celzero/firestack/intra/dnsx"
 	"github.com/celzero/firestack/intra/ipn"
 	"github.com/celzero/firestack/intra/log"
+	"github.com/celzero/firestack/intra/settings"
 	"github.com/celzero/firestack/intra/xdns"
 	"github.com/miekg/dns"
 
@@ -101,7 +102,9 @@ func (serversInfo *ServersInfo) getAll() []*serverinfo {
 			servers = append(servers, si)
 		}
 	}
-	log.V("dnscrypt: getAll: servers [%d/%d]", len(servers), len(serversInfo.inner))
+	if settings.Debug {
+		log.V("dnscrypt: getAll: servers [%d/%d]", len(servers), len(serversInfo.inner))
+	}
 	return servers
 }
 
@@ -120,7 +123,9 @@ retry:
 	for _, si := range serversInfo.inner {
 		if i == candidate || selectAny {
 			if si != nil && si.status.Load() != dnsx.DEnd {
-				log.V("dnscrypt: candidate [%v]", si) // may be nil?
+				if settings.Debug {
+					log.V("dnscrypt: candidate [%v]", si) // may be nil?
+				}
 				serverInfo = si
 				break
 			}
@@ -168,7 +173,9 @@ func (serversInfo *ServersInfo) registerServer(name string, stamp stamps.ServerS
 }
 
 func (serversInfo *ServersInfo) refresh(proxy *DcMulti) ([]string, error) {
-	log.D("dnscrypt: refreshing certificates")
+	if settings.Debug {
+		log.D("dnscrypt: refreshing certificates")
+	}
 	var liveServers []string
 	var err error
 	for _, registeredServer := range serversInfo.registeredServers {