NAT Auto Discovery

addr.go

@@ -0,0 +1,70 @@
+package autonat
+
+import (
+	"net"
+
+	ma "github.com/multiformats/go-multiaddr"
+)
+
+var private4, private6 []*net.IPNet
+var privateCIDR4 = []string{
+	// localhost
+	"127.0.0.0/8",
+	// private networks
+	"10.0.0.0/8",
+	"100.64.0.0/10",
+	"172.16.0.0/12",
+	"192.168.0.0/16",
+	// link local
+	"169.254.0.0/16",
+}
+var privateCIDR6 = []string{
+	// localhost
+	"::1/128",
+	// ULA reserved
+	"fc00::/7",
+	// link local
+	"fe80::/10",
+}
+
+func init() {
+	private4 = parsePrivateCIDR(privateCIDR4)
+	private6 = parsePrivateCIDR(privateCIDR6)
+}
+
+func parsePrivateCIDR(cidrs []string) []*net.IPNet {
+	ipnets := make([]*net.IPNet, len(cidrs))
+	for i, cidr := range cidrs {
+		_, ipnet, err := net.ParseCIDR(cidr)
+		if err != nil {
+			panic(err)
+		}
+		ipnets[i] = ipnet
+	}
+	return ipnets
+}
+
+func isPublicAddr(a ma.Multiaddr) bool {
+	ip, err := a.ValueForProtocol(ma.P_IP4)
+	if err == nil {
+		return !inAddrRange(ip, private4)
+	}
+
+	ip, err = a.ValueForProtocol(ma.P_IP6)
+	if err == nil {
+		return !inAddrRange(ip, private6)
+	}
+
+	return false
+}
+
+func inAddrRange(s string, ipnets []*net.IPNet) bool {
+	ip := net.ParseIP(s)
+	for _, ipnet := range ipnets {
+		if ipnet.Contains(ip) {
+			return true
+		}
+	}
+
+	return false
+}

autonat.go

@@ -0,0 +1,173 @@
+package autonat
+
+import (
+	"context"
+	"errors"
+	"math/rand"
+	"sync"
+	"time"
+
+	host "github.com/libp2p/go-libp2p-host"
+	peer "github.com/libp2p/go-libp2p-peer"
+	ma "github.com/multiformats/go-multiaddr"
+)
+
+// NATStatus is the state of NAT as detected by the ambient service.
+type NATStatus int
+
+const (
+	// NAT status is unknown; this means that the ambient serice has not been
+	// able to decide the presence of NAT in the most recent attempt to test
+	// dial through known autonat peers.  initial state.
+	NATStatusUnknown NATStatus = iota
+	// NAT status is publicly dialable
+	NATStatusPublic
+	// NAT status is private network
+	NATStatusPrivate
+)
+
+var (
+	AutoNATBootDelay       = 15 * time.Second
+	AutoNATRefreshInterval = 15 * time.Minute
+
+	AutoNATRequestTimeout = 60 * time.Second
+)
+
+// AutoNAT is the interface for ambient NAT autodiscovery
+type AutoNAT interface {
+	// Status returns the current NAT status
+	Status() NATStatus
+	// PublicAddr returns the public dial address when NAT status is public and an
+	// error otherwise
+	PublicAddr() (ma.Multiaddr, error)
+}
+
+// AmbientAutoNAT is the implementation of ambient NAT autodiscovery
+type AmbientAutoNAT struct {
+	ctx  context.Context
+	host host.Host
+
+	mx     sync.Mutex
+	peers  map[peer.ID]struct{}
+	status NATStatus
+	addr   ma.Multiaddr
+}
+
+// NewAutoNAT creates a new ambient NAT autodiscovery instance attached to a host
+func NewAutoNAT(ctx context.Context, h host.Host) AutoNAT {
+	as := &AmbientAutoNAT{
+		ctx:    ctx,
+		host:   h,
+		peers:  make(map[peer.ID]struct{}),
+		status: NATStatusUnknown,
+	}
+
+	h.Network().Notify(as)
+	go as.background()
+
+	return as
+}
+
+func (as *AmbientAutoNAT) Status() NATStatus {
+	return as.status
+}
+
+func (as *AmbientAutoNAT) PublicAddr() (ma.Multiaddr, error) {
+	as.mx.Lock()
+	defer as.mx.Unlock()
+
+	if as.status != NATStatusPublic {
+		return nil, errors.New("NAT Status is not public")
+	}
+
+	return as.addr, nil
+}
+
+func (as *AmbientAutoNAT) background() {
+	// wait a bit for the node to come online and establish some connections
+	// before starting autodetection
+	time.Sleep(AutoNATBootDelay)
+	for {
+		as.autodetect()
+		select {
+		case <-time.After(AutoNATRefreshInterval):
+		case <-as.ctx.Done():
+			return
+		}
+	}
+}
+
+func (as *AmbientAutoNAT) autodetect() {
+	peers := as.getPeers()
+
+	if len(peers) == 0 {
+		log.Debugf("skipping NAT auto detection; no autonat peers")
+		return
+	}
+
+	cli := NewAutoNATClient(as.host)
+
+	for _, p := range peers {
+		ctx, cancel := context.WithTimeout(as.ctx, AutoNATRequestTimeout)
+		a, err := cli.Dial(ctx, p)
+		cancel()
+
+		switch {
+		case err == nil:
+			log.Debugf("NAT status is public; address through %s: %s", p.Pretty(), a.String())
+			as.mx.Lock()
+			as.addr = a
+			as.status = NATStatusPublic
+			as.mx.Unlock()
+			return
+
+		case IsDialError(err):
+			log.Debugf("NAT status is private; dial error through %s: %s", p.Pretty(), err.Error())
+			as.mx.Lock()
+			as.status = NATStatusPrivate
+			as.mx.Unlock()
+			return
+
+		default:
+			log.Debugf("Error dialing through %s: %s", p.Pretty(), err.Error())
+		}
+	}
+
+	as.mx.Lock()
+	as.status = NATStatusUnknown
+	as.mx.Unlock()
+}
+
+func (as *AmbientAutoNAT) getPeers() []peer.ID {
+	as.mx.Lock()
+	defer as.mx.Unlock()
+
+	if len(as.peers) == 0 {
+		return nil
+	}
+
+	peers := make([]peer.ID, 0, len(as.peers))
+	for p := range as.peers {
+		if len(as.host.Network().ConnsToPeer(p)) > 0 {
+			peers = append(peers, p)
+		}
+	}
+
+	if len(peers) == 0 {
+		// we don't have any open connections, try any autonat peer that we know about
+		for p := range as.peers {
+			peers = append(peers, p)
+		}
+	}
+
+	shufflePeers(peers)
+
+	return peers
+}
+
+func shufflePeers(peers []peer.ID) {
+	for i := range peers {
+		j := rand.Intn(i + 1)
+		peers[i], peers[j] = peers[j], peers[i]
+	}
+}

client.go

@@ -0,0 +1,97 @@
+package autonat
+
+import (
+	"context"
+	"fmt"
+
+	pb "github.com/libp2p/go-libp2p-autonat/pb"
+
+	ggio "github.com/gogo/protobuf/io"
+	host "github.com/libp2p/go-libp2p-host"
+	inet "github.com/libp2p/go-libp2p-net"
+	peer "github.com/libp2p/go-libp2p-peer"
+	pstore "github.com/libp2p/go-libp2p-peerstore"
+	ma "github.com/multiformats/go-multiaddr"
+)
+
+// AutoNATClient is a stateless client interface to AutoNAT peers
+type AutoNATClient interface {
+	// Dial requests from a peer providing AutoNAT services to test dial back
+	Dial(ctx context.Context, p peer.ID) (ma.Multiaddr, error)
+}
+
+// AutoNATError is the class of errors signalled by AutoNAT services
+type AutoNATError struct {
+	Status pb.Message_ResponseStatus
+	Text   string
+}
+
+// NewAutoNATClient creates a fresh instance of an AutoNATClient
+func NewAutoNATClient(h host.Host) AutoNATClient {
+	return &client{h: h}
+}
+
+type client struct {
+	h host.Host
+}
+
+func (c *client) Dial(ctx context.Context, p peer.ID) (ma.Multiaddr, error) {
+	s, err := c.h.NewStream(ctx, p, AutoNATProto)
+	if err != nil {
+		return nil, err
+	}
+	defer s.Close()
+
+	r := ggio.NewDelimitedReader(s, inet.MessageSizeMax)
+	w := ggio.NewDelimitedWriter(s)
+
+	req := newDialMessage(pstore.PeerInfo{ID: c.h.ID(), Addrs: c.h.Addrs()})
+	err = w.WriteMsg(req)
+	if err != nil {
+		return nil, err
+	}
+
+	var res pb.Message
+	err = r.ReadMsg(&res)
+	if err != nil {
+		return nil, err
+	}
+
+	if res.GetType() != pb.Message_DIAL_RESPONSE {
+		return nil, fmt.Errorf("Unexpected response: %s", res.GetType().String())
+	}
+
+	status := res.GetDialResponse().GetStatus()
+	switch status {
+	case pb.Message_OK:
+		addr := res.GetDialResponse().GetAddr()
+		return ma.NewMultiaddrBytes(addr)
+
+	default:
+		return nil, AutoNATError{Status: status, Text: res.GetDialResponse().GetStatusText()}
+	}
+}
+
+func (e AutoNATError) Error() string {
+	return fmt.Sprintf("AutoNAT error: %s (%s)", e.Text, e.Status.String())
+}
+
+func (e AutoNATError) IsDialError() bool {
+	return e.Status == pb.Message_E_DIAL_ERROR
+}
+
+func (e AutoNATError) IsDialRefused() bool {
+	return e.Status == pb.Message_E_DIAL_REFUSED
+}
+
+// IsDialError returns true if the AutoNAT peer signalled an error dialing back
+func IsDialError(e error) bool {
+	ae, ok := e.(AutoNATError)
+	return ok && ae.IsDialError()
+}
+
+// IsDialRefused returns true if the AutoNAT peer signalled refusal to dial back
+func IsDialRefused(e error) bool {
+	ae, ok := e.(AutoNATError)
+	return ok && ae.IsDialRefused()
+}

notify.go

@@ -0,0 +1,31 @@
+package autonat
+
+import (
+	inet "github.com/libp2p/go-libp2p-net"
+	peer "github.com/libp2p/go-libp2p-peer"
+	ma "github.com/multiformats/go-multiaddr"
+)
+
+var _ inet.Notifiee = (*AmbientAutoNAT)(nil)
+
+func (as *AmbientAutoNAT) Listen(net inet.Network, a ma.Multiaddr)      {}
+func (as *AmbientAutoNAT) ListenClose(net inet.Network, a ma.Multiaddr) {}
+func (as *AmbientAutoNAT) OpenedStream(net inet.Network, s inet.Stream) {}
+func (as *AmbientAutoNAT) ClosedStream(net inet.Network, s inet.Stream) {}
+
+func (as *AmbientAutoNAT) Connected(net inet.Network, c inet.Conn) {
+	go func(p peer.ID) {
+		s, err := as.host.NewStream(as.ctx, p, AutoNATProto)
+		if err != nil {
+			return
+		}
+		s.Close()
+
+		log.Infof("Discovered AutoNAT peer %s", p.Pretty())
+		as.mx.Lock()
+		as.peers[p] = struct{}{}
+		as.mx.Unlock()
+	}(c.RemotePeer())
+}
+
+func (as *AmbientAutoNAT) Disconnected(net inet.Network, c inet.Conn) {}