relay: always filter out relay addresses

Also, remove the "RelayHost".

config/config.go

@@ -109,10 +109,31 @@ func (cfg *Config) NewNode(ctx context.Context) (host.Host, error) {
 		swrm.Filters = cfg.Filters
 	}
 
+	addrsFactory := cfg.AddrsFactory
+	if cfg.Relay {
+		// If we've enabled the relay, we should filter out relay
+		// addresses by default.
+		//
+		// TODO: We shouldn't be doing this here.
+		oldFactory := addrsFactory
+		addrsFactory = func(addrs []ma.Multiaddr) []ma.Multiaddr {
+			addrs = oldFactory(addrs)
+			raddrs := make([]ma.Multiaddr, 0, len(addrs))
+			for _, addr := range addrs {
+				_, err := addr.ValueForProtocol(circuit.P_CIRCUIT)
+				if err == nil {
+					continue
+				}
+				raddrs = append(raddrs, addr)
+			}
+			return raddrs
+		}
+	}
+
 	var h host.Host
 	h, err = bhost.NewHost(ctx, swrm, &bhost.HostOpts{
 		ConnManager:  cfg.ConnManager,
-		AddrsFactory: cfg.AddrsFactory,
+		AddrsFactory: addrsFactory,
 		NATManager:   cfg.NATManager,
 		EnablePing:   !cfg.DisablePing,
 	})
@@ -206,7 +227,11 @@ func (cfg *Config) NewNode(ctx context.Context) (host.Host, error) {
 		}
 
 		if hop {
-			h = relay.NewRelayHost(swrm.Context(), h.(*bhost.BasicHost), discovery)
+			// advertise ourselves
+			// TODO: Why do we only do this when EnableAutoRelay is
+			// set? This has absolutely _nothing_ to do with
+			// autorelay.
+			relay.Advertise(ctx, discovery)
 		} else {
 			h = relay.NewAutoRelayHost(swrm.Context(), h.(*bhost.BasicHost), discovery, router)
 		}

p2p/host/relay/autorelay.go

@@ -29,8 +29,6 @@ var (
 	DesiredRelays = 3
 
 	BootDelay = 20 * time.Second
-
-	unspecificRelay = ma.StringCast("/p2p-circuit")
 )
 
 // AutoRelayHost is a Host that uses relays for connectivity when a NAT is detected.
@@ -70,12 +68,12 @@ func (h *AutoRelayHost) hostAddrs(addrs []ma.Multiaddr) []ma.Multiaddr {
 	if h.addrs != nil && h.autonat.Status() == autonat.NATStatusPrivate {
 		return h.addrs
 	} else {
-		return filterUnspecificRelay(h.addrsF(addrs))
+		return h.addrsF(addrs)
 	}
 }
 
 func (h *AutoRelayHost) baseAddrs() []ma.Multiaddr {
-	return filterUnspecificRelay(h.addrsF(h.AllAddrs()))
+	return h.addrsF(h.AllAddrs())
 }
 
 func (h *AutoRelayHost) background(ctx context.Context) {
@@ -256,17 +254,6 @@ func (h *AutoRelayHost) doUpdateAddrs() {
 	h.addrs = raddrs
 }
 
-func filterUnspecificRelay(addrs []ma.Multiaddr) []ma.Multiaddr {
-	res := make([]ma.Multiaddr, 0, len(addrs))
-	for _, addr := range addrs {
-		if addr.Equal(unspecificRelay) {
-			continue
-		}
-		res = append(res, addr)
-	}
-	return res
-}
-
 func shuffleRelays(pis []pstore.PeerInfo) {
 	for i := range pis {
 		j := rand.Intn(i + 1)

p2p/host/relay/doc.go

@@ -14,11 +14,6 @@ How it works:
 - `AutoNATService` instances are instantiated in the
   bootstrappers (or other well known publicly reachable hosts)
 
-- `RelayHost`s are constructed with
-  `libp2p.New(libp2p.EnableRelay(circuit.OptHop), libp2p.Routing(makeDHT))`.
-  They provide Relay Hop services, and advertise through the DHT
-  in the `/libp2p/relay` namespace
-
 - `AutoRelayHost`s are constructed with `libp2p.New(libp2p.Routing(makeDHT))`
   They passively discover autonat service instances and test dialability of
   their listen address set through them.  When the presence of NAT is detected,

p2p/host/relay/relay.go

@@ -4,44 +4,19 @@ import (
 	"context"
 	"time"
 
-	basic "github.com/libp2p/go-libp2p/p2p/host/basic"
-
 	discovery "github.com/libp2p/go-libp2p-discovery"
-	host "github.com/libp2p/go-libp2p-host"
-	ma "github.com/multiformats/go-multiaddr"
 )
 
 var (
 	AdvertiseBootDelay = 30 * time.Second
 )
 
-// RelayHost is a Host that provides Relay services.
-type RelayHost struct {
-	*basic.BasicHost
-	advertise discovery.Advertiser
-	addrsF    basic.AddrsFactory
-}
-
-// New constructs a new RelayHost
-func NewRelayHost(ctx context.Context, bhost *basic.BasicHost, advertise discovery.Advertiser) *RelayHost {
-	h := &RelayHost{
-		BasicHost: bhost,
-		addrsF:    bhost.AddrsFactory,
-		advertise: advertise,
-	}
-	bhost.AddrsFactory = h.hostAddrs
+func Advertise(ctx context.Context, advertise discovery.Advertiser) {
 	go func() {
 		select {
 		case <-time.After(AdvertiseBootDelay):
 			discovery.Advertise(ctx, advertise, RelayRendezvous)
 		case <-ctx.Done():
 		}
 	}()
-	return h
 }
-
-func (h *RelayHost) hostAddrs(addrs []ma.Multiaddr) []ma.Multiaddr {
-	return filterUnspecificRelay(h.addrsF(addrs))
-}
-
-var _ host.Host = (*RelayHost)(nil)