swarm: use shared black hole filters for autonat

config/config.go

@@ -128,6 +128,13 @@ type Config struct {
 	DialRanker network.DialRanker
 
 	SwarmOpts []swarm.Option
+
+	DisableAutoNATv2 bool
+
+	UDPBlackHoleFilter        *swarm.BlackHoleFilter
+	CustomUDPBlackHoleFilter  bool
+	IPv6BlackHoleFilter       *swarm.BlackHoleFilter
+	CustomIPv6BlackHoleFilter bool
 }
 
 func (cfg *Config) makeSwarm(eventBus event.Bus, enableMetrics bool) (*swarm.Swarm, error) {
@@ -162,7 +169,10 @@ func (cfg *Config) makeSwarm(eventBus event.Bus, enableMetrics bool) (*swarm.Swa
 		return nil, err
 	}
 
-	opts := cfg.SwarmOpts
+	opts := append(cfg.SwarmOpts,
+		swarm.WithUDPBlackHoleFilter(cfg.UDPBlackHoleFilter),
+		swarm.WithIPv6BlackHoleFilter(cfg.IPv6BlackHoleFilter),
+	)
 	if cfg.Reporter != nil {
 		opts = append(opts, swarm.WithMetrics(cfg.Reporter))
 	}
@@ -190,6 +200,50 @@ func (cfg *Config) makeSwarm(eventBus event.Bus, enableMetrics bool) (*swarm.Swa
 	return swarm.NewSwarm(pid, cfg.Peerstore, eventBus, opts...)
 }
 
+func (cfg *Config) makeAutoNATHost() (*blankhost.BlankHost, error) {
+	autonatPrivKey, _, err := crypto.GenerateEd25519Key(rand.Reader)
+	if err != nil {
+		return nil, err
+	}
+	ps, err := pstoremem.NewPeerstore()
+	if err != nil {
+		return nil, err
+	}
+
+	// Pull out the pieces of the config that we _actually_ care about.
+	// Specifically, don't set up things like autorelay, listeners,
+	// identify, etc.
+	autoNatCfg := Config{
+		Transports:          cfg.Transports,
+		Muxers:              cfg.Muxers,
+		SecurityTransports:  cfg.SecurityTransports,
+		Insecure:            cfg.Insecure,
+		PSK:                 cfg.PSK,
+		ConnectionGater:     cfg.ConnectionGater,
+		Reporter:            cfg.Reporter,
+		PeerKey:             autonatPrivKey,
+		Peerstore:           ps,
+		DialRanker:          swarm.NoDelayDialRanker,
+		UDPBlackHoleFilter:  cfg.UDPBlackHoleFilter,
+		IPv6BlackHoleFilter: cfg.IPv6BlackHoleFilter,
+		SwarmOpts: []swarm.Option{
+			// Don't update black hole state for failed autonat dials
+			swarm.WithReadOnlyBlackHoleDetector(),
+		},
+	}
+
+	dialer, err := autoNatCfg.makeSwarm(eventbus.NewBus(), false)
+	if err != nil {
+		return nil, err
+	}
+	dialerHost := blankhost.NewBlankHost(dialer)
+	if err := autoNatCfg.addTransports(dialerHost); err != nil {
+		dialerHost.Close()
+		return nil, err
+	}
+	return dialerHost, nil
+}
+
 func (cfg *Config) addTransports(h host.Host) error {
 	swrm, ok := h.Network().(transport.TransportNetwork)
 	if !ok {
@@ -305,6 +359,15 @@ func (cfg *Config) NewNode() (host.Host, error) {
 		rcmgr.MustRegisterWith(cfg.PrometheusRegisterer)
 	}
 
+	var autonatv2Dialer *blankhost.BlankHost
+	if !cfg.DisableAutoNATv2 {
+		ah, err := cfg.makeAutoNATHost()
+		if err != nil {
+			return nil, err
+		}
+		autonatv2Dialer = ah
+	}
+
 	h, err := bhost.NewHost(swrm, &bhost.HostOpts{
 		EventBus:             eventBus,
 		ConnManager:          cfg.ConnManager,
@@ -319,6 +382,8 @@ func (cfg *Config) NewNode() (host.Host, error) {
 		RelayServiceOpts:     cfg.RelayServiceOpts,
 		EnableMetrics:        !cfg.DisableMetrics,
 		PrometheusRegisterer: cfg.PrometheusRegisterer,
+		EnableAutoNATv2:      !cfg.DisableAutoNATv2,
+		AutoNATv2Dialer:      autonatv2Dialer,
 	})
 	if err != nil {
 		swrm.Close()
@@ -396,46 +461,15 @@ func (cfg *Config) NewNode() (host.Host, error) {
 			autonat.WithPeerThrottling(cfg.AutoNATConfig.ThrottlePeerLimit))
 	}
 	if cfg.AutoNATConfig.EnableService {
-		autonatPrivKey, _, err := crypto.GenerateEd25519Key(rand.Reader)
+		ah, err := cfg.makeAutoNATHost()
 		if err != nil {
-			return nil, err
-		}
-		ps, err := pstoremem.NewPeerstore()
-		if err != nil {
-			return nil, err
-		}
-
-		// Pull out the pieces of the config that we _actually_ care about.
-		// Specifically, don't set up things like autorelay, listeners,
-		// identify, etc.
-		autoNatCfg := Config{
-			Transports:         cfg.Transports,
-			Muxers:             cfg.Muxers,
-			SecurityTransports: cfg.SecurityTransports,
-			Insecure:           cfg.Insecure,
-			PSK:                cfg.PSK,
-			ConnectionGater:    cfg.ConnectionGater,
-			Reporter:           cfg.Reporter,
-			PeerKey:            autonatPrivKey,
-			Peerstore:          ps,
-			DialRanker:         swarm.NoDelayDialRanker,
-		}
-
-		dialer, err := autoNatCfg.makeSwarm(eventbus.NewBus(), false)
-		if err != nil {
-			h.Close()
-			return nil, err
-		}
-		dialerHost := blankhost.NewBlankHost(dialer)
-		if err := autoNatCfg.addTransports(dialerHost); err != nil {
-			dialerHost.Close()
 			h.Close()
 			return nil, err
 		}
 		// NOTE: We're dropping the blank host here but that's fine. It
 		// doesn't really _do_ anything and doesn't even need to be
 		// closed (as long as we close the underlying network).
-		autonatOpts = append(autonatOpts, autonat.EnableService(dialerHost.Network()))
+		autonatOpts = append(autonatOpts, autonat.EnableService(ah.Network()))
 	}
 	if cfg.AutoNATConfig.ForceReachability != nil {
 		autonatOpts = append(autonatOpts, autonat.WithReachability(*cfg.AutoNATConfig.ForceReachability))

core/network/network.go

@@ -185,6 +185,9 @@ type Dialer interface {
 	// Notify/StopNotify register and unregister a notifiee for signals
 	Notify(Notifiee)
 	StopNotify(Notifiee)
+
+	// CanDial returns whether the dialer can dial peer p at addr
+	CanDial(p peer.ID, addr ma.Multiaddr) bool
 }
 
 // AddrDelay provides an address along with the delay after which the address

defaults.go

@@ -10,6 +10,7 @@ import (
 	rcmgr "github.com/libp2p/go-libp2p/p2p/host/resource-manager"
 	"github.com/libp2p/go-libp2p/p2p/muxer/yamux"
 	"github.com/libp2p/go-libp2p/p2p/net/connmgr"
+	"github.com/libp2p/go-libp2p/p2p/net/swarm"
 	"github.com/libp2p/go-libp2p/p2p/security/noise"
 	tls "github.com/libp2p/go-libp2p/p2p/security/tls"
 	quic "github.com/libp2p/go-libp2p/p2p/transport/quic"
@@ -133,6 +134,18 @@ var DefaultPrometheusRegisterer = func(cfg *Config) error {
 	return cfg.Apply(PrometheusRegisterer(prometheus.DefaultRegisterer))
 }
 
+var defaultUDPBlackHoleDetector = func(cfg *Config) error {
+	// A black hole is a binary property. On a network if UDP dials are blocked, all dials will
+	// fail. So a low success rate of 5 out 100 dials is good enough.
+	return cfg.Apply(UDPBlackHoleFilter(&swarm.BlackHoleFilter{N: 100, MinSuccesses: 5, Name: "UDP"}))
+}
+
+var defaultIPv6BlackHoleDetector = func(cfg *Config) error {
+	// A black hole is a binary property. On a network if there is no IPv6 connectivity, all
+	// dials will fail. So a low success rate of 5 out 100 dials is good enough.
+	return cfg.Apply(IPv6BlackHoleFilter(&swarm.BlackHoleFilter{N: 100, MinSuccesses: 5, Name: "IPv6"}))
+}
+
 // Complete list of default options and when to fallback on them.
 //
 // Please *DON'T* specify default options any other way. Putting this all here
@@ -189,6 +202,18 @@ var defaults = []struct {
 		fallback: func(cfg *Config) bool { return !cfg.DisableMetrics && cfg.PrometheusRegisterer == nil },
 		opt:      DefaultPrometheusRegisterer,
 	},
+	{
+		fallback: func(cfg *Config) bool {
+			return !cfg.CustomUDPBlackHoleFilter && cfg.UDPBlackHoleFilter == nil
+		},
+		opt: defaultUDPBlackHoleDetector,
+	},
+	{
+		fallback: func(cfg *Config) bool {
+			return !cfg.CustomIPv6BlackHoleFilter && cfg.IPv6BlackHoleFilter == nil
+		},
+		opt: defaultIPv6BlackHoleDetector,
+	},
 }
 
 // Defaults configures libp2p to use the default options. Can be combined with

options.go

@@ -597,3 +597,29 @@ func SwarmOpts(opts ...swarm.Option) Option {
 		return nil
 	}
 }
+
+// DisableAutoNATv2 disables autonat
+func DisableAutoNATv2() Option {
+	return func(cfg *Config) error {
+		cfg.DisableAutoNATv2 = true
+		return nil
+	}
+}
+
+// UDPBlackHoleFilter configures libp2p to use f as the black hole filter for UDP addrs
+func UDPBlackHoleFilter(f *swarm.BlackHoleFilter) Option {
+	return func(cfg *Config) error {
+		cfg.UDPBlackHoleFilter = f
+		cfg.CustomUDPBlackHoleFilter = true
+		return nil
+	}
+}
+
+// IPv6BlackHoleFilter configures libp2p to use f as the black hole filter for IPv6 addrs
+func IPv6BlackHoleFilter(f *swarm.BlackHoleFilter) Option {
+	return func(cfg *Config) error {
+		cfg.IPv6BlackHoleFilter = f
+		cfg.CustomIPv6BlackHoleFilter = true
+		return nil
+	}
+}

p2p/host/basic/basic_host.go

@@ -23,6 +23,7 @@ import (
 	"github.com/libp2p/go-libp2p/p2p/host/eventbus"
 	"github.com/libp2p/go-libp2p/p2p/host/pstoremanager"
 	"github.com/libp2p/go-libp2p/p2p/host/relaysvc"
+	"github.com/libp2p/go-libp2p/p2p/protocol/autonatv2"
 	relayv2 "github.com/libp2p/go-libp2p/p2p/protocol/circuitv2/relay"
 	"github.com/libp2p/go-libp2p/p2p/protocol/holepunch"
 	"github.com/libp2p/go-libp2p/p2p/protocol/identify"
@@ -101,6 +102,8 @@ type BasicHost struct {
 	caBook                  peerstore.CertifiedAddrBook
 
 	autoNat autonat.AutoNAT
+
+	autonatv2 *autonatv2.AutoNAT
 }
 
 var _ host.Host = (*BasicHost)(nil)
@@ -160,6 +163,9 @@ type HostOpts struct {
 	EnableMetrics bool
 	// PrometheusRegisterer is the PrometheusRegisterer used for metrics
 	PrometheusRegisterer prometheus.Registerer
+
+	EnableAutoNATv2 bool
+	AutoNATv2Dialer host.Host
 }
 
 // NewHost constructs a new *BasicHost and activates it by attaching its stream and connection handlers to the given inet.Network.
@@ -301,6 +307,13 @@ func NewHost(n network.Network, opts *HostOpts) (*BasicHost, error) {
 		h.pings = ping.NewPingService(h)
 	}
 
+	if opts.EnableAutoNATv2 {
+		h.autonatv2, err = autonatv2.New(h, opts.AutoNATv2Dialer)
+		if err != nil {
+			return nil, fmt.Errorf("failed to create autonatv2: %w", err)
+		}
+	}
+
 	n.SetStreamHandler(h.newStreamHandler)
 
 	// register to be notified when the network's listen addrs change,
@@ -1025,6 +1038,9 @@ func (h *BasicHost) Close() error {
 		if h.hps != nil {
 			h.hps.Close()
 		}
+		if h.autonatv2 != nil {
+			h.autonatv2.Close()
+		}
 
 		_ = h.emitters.evtLocalProtocolsUpdated.Close()
 		_ = h.emitters.evtLocalAddrsUpdated.Close()

p2p/host/blank/blank.go

@@ -63,9 +63,10 @@ func NewBlankHost(n network.Network, options ...Option) *BlankHost {
 	}
 
 	bh := &BlankHost{
-		n:    n,
-		cmgr: cfg.cmgr,
-		mux:  mstream.NewMultistreamMuxer[protocol.ID](),
+		n:        n,
+		cmgr:     cfg.cmgr,
+		mux:      mstream.NewMultistreamMuxer[protocol.ID](),
+		eventbus: cfg.eventBus,
 	}
 	if bh.eventbus == nil {
 		bh.eventbus = eventbus.NewBus(eventbus.WithMetricsTracer(eventbus.NewMetricsTracer()))

p2p/net/mock/mock_peernet.go

@@ -434,3 +434,7 @@ func (pn *peernet) notifyAll(notification func(f network.Notifiee)) {
 func (pn *peernet) ResourceManager() network.ResourceManager {
 	return &network.NullResourceManager{}
 }
+
+func (pn *peernet) CanDial(p peer.ID, addr ma.Multiaddr) bool {
+	return true
+}