dnsx/mdns: propogate link changes to existing mdns

Author: ignoramous

intra/dns.go

@@ -113,7 +113,7 @@ func newDNSCryptTransport(ctx context.Context, px ipn.ProxyProvider, bdg Bridge)
 	return
 }
 
-func newMDNSTransport(ctx context.Context, protos string, px ipn.ProxyProvider) (d dnsx.Transport) {
+func newMDNSTransport(ctx context.Context, protos string, px ipn.ProxyProvider) (d dnsx.MDNSTransport) {
 	return dns53.NewMDNSTransport(ctx, protos, px)
 }
 

intra/dns53/mdns.go

@@ -47,13 +47,13 @@ type dnssd struct {
 	dialer ipn.Proxy
 	id     string              // ID of this transport
 	ipport string              // IP:Port queries are sent to (v4)
-	use4   bool                // Use IPv4
-	use6   bool                // Use IPv6
+	use4   atomic.Bool         // Use IPv4
+	use6   atomic.Bool         // Use IPv6
 	status *core.Volatile[int] // Status of this transport
 	est    core.P2QuantileEstimator
 }
 
-var _ dnsx.Transport = (*dnssd)(nil)
+var _ dnsx.MDNSTransport = (*dnssd)(nil)
 
 // NewMDNSTransport returns a DNS transport that sends all DNS queries to mDNS endpoint.
 func NewMDNSTransport(pctx context.Context, protos string, pxr ipn.ProxyProvider) *dnssd {
@@ -72,12 +72,12 @@ func NewMDNSTransport(pctx context.Context, protos string, pxr ipn.ProxyProvider
 		done:   done,
 		id:     dnsx.Local,
 		dialer: exit,
-		use4:   use4(protos),
-		use6:   use6(protos),
 		ipport: xdns.MDNSAddr4.String(), // ip6: ff02::fb:5353
 		status: core.NewVolatile(dnsx.Start),
 		est:    core.NewP50Estimator(ctx),
 	}
+	t.use4.Store(use4(protos))
+	t.use6.Store(use6(protos))
 	log.I("mdns: setup: %s", protos)
 	return t
 }
@@ -100,6 +100,14 @@ func use6(l3 string) bool {
 	}
 }
 
+func (t *dnssd) RefreshProto(protos string) {
+	n4 := use4(protos)
+	n6 := use6(protos)
+	o4 := t.use4.Swap(n4)
+	o6 := t.use6.Swap(n6)
+	log.I("mdns: proto change: %s; 4(%s => %s) 6(%s => %s)", protos, o4, n4, o6, n6)
+}
+
 func (t *dnssd) oneshotQuery(msg *dns.Msg) (*dns.Msg, *dnsx.QueryError) {
 	if qerr := dnsx.WillErr(t); qerr != nil {
 		return nil, qerr
@@ -291,15 +299,17 @@ func (c *client) String() string {
 
 // newClient creates a new mdns unicast and multicast client
 func (t *dnssd) newClient(oneshot bool) (*client, error) {
-	if !t.use4 && !t.use6 {
+	use4 := t.use4.Load()
+	use6 := t.use6.Load()
+	if !use4 && !use6 {
 		return nil, errNoProtos
 	}
 
 	var uconn4, uconn6 net.PacketConn // bind to higher port for unicast
 	var mconn4, mconn6 net.PacketConn // bind to port 5353 for multicast
 	var err error
 
-	if t.use4 {
+	if use4 {
 		uconn4, err = t.dialer.Announce("udp4", "0.0.0.0:0")
 		if err != nil {
 			log.E("mdns: new-client: unicast4 bind fail: %v", err)
@@ -314,7 +324,7 @@ func (t *dnssd) newClient(oneshot bool) (*client, error) {
 		}
 	}
 
-	if t.use6 {
+	if use6 {
 		uconn6, err = t.dialer.Announce("udp6", "[::]:0")
 		if err != nil {
 			log.E("mdns: new-client: unicast6 bind fail: %v", err)
@@ -328,16 +338,16 @@ func (t *dnssd) newClient(oneshot bool) (*client, error) {
 		}
 	}
 
-	has4 := t.use4 && uconn4 != nil && (oneshot || mconn4 != nil)
-	has6 := t.use6 && uconn6 != nil && (oneshot || mconn6 != nil)
+	has4 := use4 && uconn4 != nil && (oneshot || mconn4 != nil)
+	has6 := use6 && uconn6 != nil && (oneshot || mconn6 != nil)
 	if !has4 && !has6 {
 		log.E("mdns: new-client: oneshot? %t with no4? %t / no6? %t", oneshot, has4, has6)
 		return nil, errBindFail
 	}
 
 	c := &client{
-		use4:       t.use4,
-		use6:       t.use6,
+		use4:       use4,
+		use6:       use6,
 		multicast4: mconn4, // nil if oneshot
 		multicast6: mconn6, // nil if oneshot
 		unicast4:   uconn4,

intra/dnsx/transport.go

@@ -107,10 +107,16 @@ var (
 	errBlockFreeTransport      = errors.New("dns: block free transport")
 	errNoRdns                  = errors.New("dns: no rdns")
 	errTransportNotMult        = errors.New("dns: not a multi-transport")
+	errTransportNotMDNS        = errors.New("dns: not an mdns transport")
 	errMissingQueryName        = errors.New("dns: no query name")
 	errResolverClosed          = errors.New("dns: closed for business")
 )
 
+type MDNSTransport interface {
+	Transport
+	RefreshProto(protos string)
+}
+
 // Transport represents a DNS query transport.  This interface is exported by gobind,
 // so it has to be very simple.
 type Transport interface {
@@ -150,6 +156,8 @@ type TransportProviderInternal interface {
 
 	// Gateway implements a DNS ALG transport
 	Gateway() Gateway
+	// MDNS returns the mdns transport, if available; error otherwise.
+	MDNS() (MDNSTransport, error)
 }
 
 type Resolver interface {
@@ -260,6 +268,18 @@ func (r *resolver) Gateway() Gateway {
 	return r.gateway
 }
 
+func (r *resolver) MDNS() (MDNSTransport, error) {
+	r.RLock()
+	defer r.RUnlock()
+	if t, ok := r.transports[Local]; ok {
+		if mdnst, ok := t.(MDNSTransport); ok {
+			return mdnst, nil
+		}
+		return nil, errTransportNotMDNS
+	}
+	return nil, errNoSuchTransport
+}
+
 func (r *resolver) Translate(b bool) {
 	r.gateway.translate(b)
 }

intra/tunnel.go

@@ -305,15 +305,18 @@ func (t *rtunnel) SetLinkAndRoutes2(fd, tunmtu, linkmtu, engine int) error {
 
 	err := tunnel.SetLinkAndRoutes(fd, tunmtu, engine) // route is always dual-stack
 
+	if l3diff {
+		if mdns, err := t.resolver.MDNS(); err == nil {
+			mdns.RefreshProto(l3)
+		}
+	}
+
 	// TODO: skip refresh on err?
 	core.Gx("i.setLinkAndRoutesRefresh", func() {
 		if l3diff || mtudiff {
-			// dialers.IPProtos must always preced calls to other refreshes
+			// dialers.IPProtos must always precede calls to other refreshes
 			// as it carries the global state for dialers and ipn/multihost
-			go t.proxies.RefreshProto(l3, linkmtu, false /*force*/)
-		}
-		if l3diff {
-			t.resolver.Add(newMDNSTransport(t.ctx, l3, t.proxies))
+			t.proxies.RefreshProto(l3, linkmtu, false /*force*/)
 		}
 	})
 
@@ -365,12 +368,14 @@ func (t *rtunnel) Restart(fd, linkmtu, tunmtu, engine int) error {
 
 	log.I("tun: <<< restart >>>; for: %d (linkmtu: %d / tunmtu: %d), netstack ok; rev err? %v", fd, linkmtu, tunmtu, rerr)
 
+	if l3diff {
+		if mdns, err := t.resolver.MDNS(); err == nil {
+			mdns.RefreshProto(l3)
+		}
+	}
 	core.Gx("i.RestartRefresh", func() {
 		// Refresh proxies to update to the new reverser
-		go t.proxies.RefreshProto(l3, linkmtu, true /*force; reverser changed*/) // also updates reverser
-		if l3diff {
-			t.resolver.Add(newMDNSTransport(t.ctx, l3, t.proxies))
-		}
+		t.proxies.RefreshProto(l3, linkmtu, true /*force; reverser changed*/) // also updates reverser
 	})
 
 	return err