NAT Auto Discovery

.travis.yml

@@ -0,0 +1,22 @@
+os:
+  - linux
+
+sudo: false
+
+language: go
+
+go:
+    - 1.9.x
+
+install:
+  - make deps
+
+script:
+  - bash <(curl -s https://raw.githubusercontent.com/ipfs/ci-helpers/master/travis-ci/run-standard-tests.sh)
+
+cache:
+    directories:
+        - $GOPATH/src/gx
+
+notifications:
+  email: false

Makefile

@@ -0,0 +1,7 @@
+gx:
+	go get -u github.com/whyrusleeping/gx
+	go get -u github.com/whyrusleeping/gx-go
+
+deps: gx
+	gx --verbose install --global
+	gx-go rewrite

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,178 @@
+package autonat
+
+import (
+	"context"
+	"errors"
+	"math/rand"
+	"sync"
+	"time"
+
+	host "github.com/libp2p/go-libp2p-host"
+	inet "github.com/libp2p/go-libp2p-net"
+	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 service 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
+	select {
+	case <-time.After(AutoNATBootDelay):
+	case <-as.ctx.Done():
+		return
+	}
+
+	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.DialBack(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 as.host.Network().Connectedness(p) == inet.Connected {
+			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]
+	}
+}

autonat_test.go

@@ -0,0 +1,84 @@
+package autonat
+
+import (
+	"context"
+	"net"
+	"testing"
+	"time"
+
+	libp2p "github.com/libp2p/go-libp2p"
+	host "github.com/libp2p/go-libp2p-host"
+)
+
+func makeAutoNAT(ctx context.Context, t *testing.T) (host.Host, AutoNAT) {
+	h, err := libp2p.New(ctx)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	a := NewAutoNAT(ctx, h)
+
+	return h, a
+}
+
+// Note: these tests assume the host has only private inet addresses!
+func TestAutoNATPrivate(t *testing.T) {
+	ctx, cancel := context.WithCancel(context.Background())
+	defer cancel()
+
+	save1 := AutoNATBootDelay
+	AutoNATBootDelay = 1 * time.Second
+	save2 := AutoNATRefreshInterval
+	AutoNATRefreshInterval = 1 * time.Second
+
+	hs, _ := makeAutoNATService(ctx, t)
+	hc, an := makeAutoNAT(ctx, t)
+
+	status := an.Status()
+	if status != NATStatusUnknown {
+		t.Fatalf("unexpected NAT status: %d", status)
+	}
+
+	connect(t, hs, hc)
+	time.Sleep(2 * time.Second)
+
+	status = an.Status()
+	if status != NATStatusPrivate {
+		t.Fatalf("unexpected NAT status: %d", status)
+	}
+
+	AutoNATBootDelay = save1
+	AutoNATRefreshInterval = save2
+}
+
+func TestAutoNATPublic(t *testing.T) {
+	ctx, cancel := context.WithCancel(context.Background())
+	defer cancel()
+
+	save1 := AutoNATBootDelay
+	AutoNATBootDelay = 1 * time.Second
+	save2 := AutoNATRefreshInterval
+	AutoNATRefreshInterval = 1 * time.Second
+	save3 := private4
+	private4 = []*net.IPNet{}
+
+	hs, _ := makeAutoNATService(ctx, t)
+	hc, an := makeAutoNAT(ctx, t)
+
+	status := an.Status()
+	if status != NATStatusUnknown {
+		t.Fatalf("unexpected NAT status: %d", status)
+	}
+
+	connect(t, hs, hc)
+	time.Sleep(2 * time.Second)
+
+	status = an.Status()
+	if status != NATStatusPublic {
+		t.Fatalf("unexpected NAT status: %d", status)
+	}
+
+	AutoNATBootDelay = save1
+	AutoNATRefreshInterval = save2
+	private4 = save3
+}