lib/nat: Add a nat package and service to track mappings on multiple IGDs

lib/nat/debug.go

@@ -0,0 +1,22 @@
+// Copyright (C) 2015 The Syncthing Authors.
+//
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this file,
+// You can obtain one at http://mozilla.org/MPL/2.0/.
+
+package nat
+
+import (
+	"os"
+	"strings"
+
+	"github.com/syncthing/syncthing/lib/logger"
+)
+
+var (
+	l = logger.DefaultLogger.NewFacility("nat", "NAT discovery and port mapping")
+)
+
+func init() {
+	l.SetDebug("nat", strings.Contains(os.Getenv("STTRACE"), "nat") || os.Getenv("STTRACE") == "all")
+}

lib/nat/interface.go

@@ -0,0 +1,26 @@
+// Copyright (C) 2015 The Syncthing Authors.
+//
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this file,
+// You can obtain one at http://mozilla.org/MPL/2.0/.
+
+package nat
+
+import (
+	"net"
+	"time"
+)
+
+type Protocol string
+
+const (
+	TCP Protocol = "TCP"
+	UDP          = "UDP"
+)
+
+type Device interface {
+	ID() string
+	GetLocalIPAddress() net.IP
+	AddPortMapping(protocol Protocol, internalPort, externalPort int, description string, duration time.Duration) (int, error)
+	GetExternalIPAddress() (net.IP, error)
+}

lib/nat/registry.go

@@ -0,0 +1,30 @@
+// Copyright (C) 2015 The Syncthing Authors.
+//
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this file,
+// You can obtain one at http://mozilla.org/MPL/2.0/.
+
+package nat
+
+import (
+	"time"
+)
+
+type DiscoverFunc func(renewal, timeout time.Duration) []Device
+
+var providers []DiscoverFunc
+
+func Register(provider DiscoverFunc) {
+	providers = append(providers, provider)
+}
+
+func discoverAll(renewal, timeout time.Duration) map[string]Device {
+	nats := make(map[string]Device)
+	for _, discoverFunc := range providers {
+		discoveredNATs := discoverFunc(renewal, timeout)
+		for _, discoveredNAT := range discoveredNATs {
+			nats[discoveredNAT.ID()] = discoveredNAT
+		}
+	}
+	return nats
+}

lib/nat/service.go

@@ -0,0 +1,298 @@
+// Copyright (C) 2015 The Syncthing Authors.
+//
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this file,
+// You can obtain one at http://mozilla.org/MPL/2.0/.
+
+package nat
+
+import (
+	"fmt"
+	"math/rand"
+	"net"
+	stdsync "sync"
+	"time"
+
+	"github.com/syncthing/syncthing/lib/config"
+	"github.com/syncthing/syncthing/lib/protocol"
+	"github.com/syncthing/syncthing/lib/sync"
+)
+
+// Service runs a loop for discovery of IGDs (Internet Gateway Devices) and
+// setup/renewal of a port mapping.
+type Service struct {
+	id        protocol.DeviceID
+	cfg       *config.Wrapper
+	stop      chan struct{}
+	immediate chan chan struct{}
+	timer     *time.Timer
+	announce  *stdsync.Once
+
+	mappings []*Mapping
+	mut      sync.RWMutex
+}
+
+func NewService(id protocol.DeviceID, cfg *config.Wrapper) *Service {
+	return &Service{
+		id:  id,
+		cfg: cfg,
+
+		immediate: make(chan chan struct{}),
+		timer:     time.NewTimer(time.Second),
+
+		mut: sync.NewRWMutex(),
+	}
+}
+
+func (s *Service) Serve() {
+	s.timer.Reset(0)
+	s.stop = make(chan struct{})
+	s.announce = &stdsync.Once{}
+
+	for {
+		select {
+		case result := <-s.immediate:
+			s.process()
+			close(result)
+		case <-s.timer.C:
+			s.process()
+		case <-s.stop:
+			s.timer.Stop()
+			return
+		}
+	}
+}
+
+func (s *Service) process() {
+	// toRenew are mappings which are due for renewal
+	// toUpdate are the remaining mappings, which will only be updated if one of
+	// the old IGDs has gone away, or a new IGD has appeared, but only if we
+	// actually need to perform a renewal.
+	var toRenew, toUpdate []*Mapping
+
+	renewIn := time.Duration(s.cfg.Options().NATRenewalM) * time.Minute
+	if renewIn == 0 {
+		// We always want to do renewal so lets just pick a nice sane number.
+		renewIn = 30 * time.Minute
+	}
+
+	s.mut.RLock()
+	for _, mapping := range s.mappings {
+		if mapping.expires.Before(time.Now()) {
+			toRenew = append(toRenew, mapping)
+		} else {
+			toUpdate = append(toUpdate, mapping)
+			mappingRenewIn := mapping.expires.Sub(time.Now())
+			if mappingRenewIn < renewIn {
+				renewIn = mappingRenewIn
+			}
+		}
+	}
+	s.mut.RUnlock()
+
+	s.timer.Reset(renewIn)
+
+	// Don't do anything, unless we really need to renew
+	if len(toRenew) == 0 {
+		return
+	}
+
+	nats := discoverAll(time.Duration(s.cfg.Options().NATRenewalM)*time.Minute, time.Duration(s.cfg.Options().NATTimeoutS)*time.Second)
+
+	s.announce.Do(func() {
+		suffix := "s"
+		if len(nats) == 1 {
+			suffix = ""
+		}
+		l.Infoln("Detected", len(nats), "NAT device"+suffix)
+	})
+
+	for _, mapping := range toRenew {
+		s.updateMapping(mapping, nats, true)
+	}
+
+	for _, mapping := range toUpdate {
+		s.updateMapping(mapping, nats, false)
+	}
+}
+
+func (s *Service) Stop() {
+	close(s.stop)
+}
+
+func (s *Service) NewMapping(protocol Protocol, ip net.IP, port int) *Mapping {
+	mapping := &Mapping{
+		protocol: protocol,
+		address: Address{
+			IP:   ip,
+			Port: port,
+		},
+		extAddresses: make(map[string]Address),
+		mut:          sync.NewRWMutex(),
+	}
+
+	s.mut.Lock()
+	s.mappings = append(s.mappings, mapping)
+	s.mut.Unlock()
+
+	return mapping
+}
+
+// Sync forces the service to recheck all mappings.
+func (s *Service) Sync() {
+	wait := make(chan struct{})
+	s.immediate <- wait
+	<-wait
+}
+
+// updateMapping compares the addresses of the existing mapping versus the natds
+// discovered, and removes any addresses of natds that do not exist, or tries to
+// acquire mappings for natds which the mapping was unaware of before.
+// Optionally takes renew flag which indicates whether or not we should renew
+// mappings with existing natds
+func (s *Service) updateMapping(mapping *Mapping, nats map[string]Device, renew bool) {
+	var added, removed []Address
+
+	renewalTime := time.Duration(s.cfg.Options().NATRenewalM) * time.Minute
+	mapping.expires = time.Now().Add(renewalTime)
+
+	newAdded, newRemoved := s.verifyExistingMappings(mapping, nats, renew)
+	added = append(added, newAdded...)
+	removed = append(removed, newRemoved...)
+
+	newAdded, newRemoved = s.acquireNewMappings(mapping, nats)
+	added = append(added, newAdded...)
+	removed = append(removed, newRemoved...)
+
+	if len(added) > 0 || len(removed) > 0 {
+		mapping.notify(added, removed)
+	}
+}
+
+func (s *Service) verifyExistingMappings(mapping *Mapping, nats map[string]Device, renew bool) ([]Address, []Address) {
+	var added, removed []Address
+
+	leaseTime := time.Duration(s.cfg.Options().NATLeaseM) * time.Minute
+
+	for id, address := range mapping.addressMap() {
+		// Delete addresses for NATDevice's that do not exist anymore
+		nat, ok := nats[id]
+		if !ok {
+			mapping.removeAddress(id)
+			removed = append(removed, address)
+			continue
+		} else if renew {
+			// Only perform renewals on the nat's that have the right local IP
+			// address
+			localIP := nat.GetLocalIPAddress()
+			if !mapping.validGateway(localIP) {
+				l.Debugf("Skipping %s for %s because of IP mismatch. %s != %s", id, mapping, mapping.address.IP, localIP)
+				continue
+			}
+
+			l.Debugf("Renewing %s -> %s mapping on %s", mapping, address, id)
+
+			addr, err := s.tryNATDevice(nat, mapping.address.Port, address.Port, leaseTime)
+			if err != nil {
+				l.Debugf("Failed to renew %s -> mapping on %s", mapping, address, id)
+				mapping.removeAddress(id)
+				removed = append(removed, address)
+				continue
+			}
+
+			l.Debugf("Renewed %s -> %s mapping on %s", mapping, address, id)
+
+			if !addr.Equal(address) {
+				mapping.removeAddress(id)
+				mapping.setAddress(id, addr)
+				removed = append(removed, address)
+				added = append(added, address)
+			}
+		}
+	}
+
+	return added, removed
+}
+
+func (s *Service) acquireNewMappings(mapping *Mapping, nats map[string]Device) ([]Address, []Address) {
+	var added, removed []Address
+
+	leaseTime := time.Duration(s.cfg.Options().NATLeaseM) * time.Minute
+	addrMap := mapping.addressMap()
+
+	for id, nat := range nats {
+		if _, ok := addrMap[id]; ok {
+			continue
+		}
+
+		// Only perform mappings on the nat's that have the right local IP
+		// address
+		localIP := nat.GetLocalIPAddress()
+		if !mapping.validGateway(localIP) {
+			l.Debugf("Skipping %s for %s because of IP mismatch. %s != %s", id, mapping, mapping.address.IP, localIP)
+			continue
+		}
+
+		l.Debugf("Acquiring %s mapping on %s", mapping, id)
+
+		addr, err := s.tryNATDevice(nat, mapping.address.Port, 0, leaseTime)
+		if err != nil {
+			l.Debugf("Failed to acquire %s mapping on %s", mapping, id)
+			continue
+		}
+
+		l.Debugf("Acquired %s -> %s mapping on %s", mapping, addr, id)
+
+		mapping.setAddress(id, addr)
+		added = append(added, addr)
+	}
+
+	return added, removed
+}
+
+// tryNATDevice tries to acquire a port mapping for the given internal address to
+// the given external port. If external port is 0, picks a pseudo-random port.
+func (s *Service) tryNATDevice(natd Device, intPort, extPort int, leaseTime time.Duration) (Address, error) {
+	var err error
+
+	// Generate a predictable random which is based on device ID + local port
+	// number so that the ports we'd try to acquire for the mapping would always
+	// be the same.
+	predictableRand := rand.New(rand.NewSource(int64(s.id.Short()) + int64(intPort)))
+
+	if extPort != 0 {
+		// First try renewing our existing mapping, if we have one.
+		name := fmt.Sprintf("syncthing-%d", extPort)
+		port, err := natd.AddPortMapping(TCP, intPort, extPort, name, leaseTime)
+		if err == nil {
+			extPort = port
+			goto findIP
+		}
+		l.Debugln("Error extending lease on", natd.ID(), err)
+	}
+
+	for i := 0; i < 10; i++ {
+		// Then try up to ten random ports.
+		extPort = 1024 + predictableRand.Intn(65535-1024)
+		name := fmt.Sprintf("syncthing-%d", extPort)
+		port, err := natd.AddPortMapping(TCP, intPort, extPort, name, leaseTime)
+		if err == nil {
+			extPort = port
+			goto findIP
+		}
+		l.Debugln("Error getting new lease on", natd.ID(), err)
+	}
+
+	return Address{}, err
+
+findIP:
+	ip, err := natd.GetExternalIPAddress()
+	if err != nil {
+		l.Debugln("Error getting external ip on", natd.ID(), err)
+		ip = nil
+	}
+	return Address{
+		IP:   ip,
+		Port: extPort,
+	}, nil
+}

lib/nat/structs.go

@@ -0,0 +1,129 @@
+// Copyright (C) 2015 The Syncthing Authors.
+//
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this file,
+// You can obtain one at http://mozilla.org/MPL/2.0/.
+
+package nat
+
+import (
+	"fmt"
+	"net"
+	"time"
+
+	"github.com/syncthing/syncthing/lib/sync"
+)
+
+type MappingChangeSubscriber func(*Mapping, []Address, []Address)
+
+type Mapping struct {
+	protocol Protocol
+	address  Address
+
+	extAddresses map[string]Address // NAT ID -> Address
+	expires      time.Time
+	subscribers  []MappingChangeSubscriber
+	mut          sync.RWMutex
+}
+
+func (m *Mapping) setAddress(id string, address Address) {
+	m.mut.Lock()
+	if existing, ok := m.extAddresses[id]; !ok || !existing.Equal(address) {
+		l.Infof("New NAT port mapping: external %s address %s to local address %s.", m.protocol, address, m.address)
+		m.extAddresses[id] = address
+	}
+	m.mut.Unlock()
+}
+
+func (m *Mapping) removeAddress(id string) {
+	m.mut.Lock()
+	addr, ok := m.extAddresses[id]
+	if ok {
+		l.Infof("Removing NAT port mapping: external %s address %s, NAT %s is no longer available.", m.protocol, addr, id)
+		delete(m.extAddresses, id)
+	}
+	m.mut.Unlock()
+}
+
+func (m *Mapping) notify(added, removed []Address) {
+	m.mut.RLock()
+	for _, subscriber := range m.subscribers {
+		subscriber(m, added, removed)
+	}
+	m.mut.RUnlock()
+}
+
+func (m *Mapping) addressMap() map[string]Address {
+	m.mut.RLock()
+	addrMap := m.extAddresses
+	m.mut.RUnlock()
+	return addrMap
+}
+
+func (m *Mapping) Protocol() Protocol {
+	return m.protocol
+}
+
+func (m *Mapping) Address() Address {
+	return m.address
+}
+
+func (m *Mapping) ExternalAddresses() []Address {
+	m.mut.RLock()
+	addrs := make([]Address, 0, len(m.extAddresses))
+	for _, addr := range m.extAddresses {
+		addrs = append(addrs, addr)
+	}
+	m.mut.RUnlock()
+	return addrs
+}
+
+func (m *Mapping) OnChanged(subscribed MappingChangeSubscriber) {
+	m.mut.Lock()
+	m.subscribers = append(m.subscribers, subscribed)
+	m.mut.Unlock()
+}
+
+func (m *Mapping) String() string {
+	return fmt.Sprintf("%s %s", m.protocol, m.address)
+}
+
+func (m *Mapping) GoString() string {
+	return m.String()
+}
+
+// Checks if the mappings local IP address matches the IP address of the gateway
+// For example, if we are explicitly listening on 192.168.0.12, there is no
+// point trying to acquire a mapping on a gateway to which the local IP is
+// 10.0.0.1. Fallback to true if any of the IPs is not there.
+func (m *Mapping) validGateway(ip net.IP) bool {
+	if m.address.IP == nil || ip == nil || m.address.IP.IsUnspecified() || ip.IsUnspecified() {
+		return true
+	}
+	return m.address.IP.Equal(ip)
+}
+
+// Address is essentially net.TCPAddr yet is more general, and has a few helper
+// methods which reduce boilerplate code.
+type Address struct {
+	IP   net.IP
+	Port int
+}
+
+func (a Address) Equal(b Address) bool {
+	return a.Port == b.Port && a.IP.Equal(b.IP)
+}
+
+func (a Address) String() string {
+	var ipStr string
+	if a.IP == nil {
+		ipStr = net.IPv4zero.String()
+	} else {
+		ipStr = a.IP.String()
+	}
+	return net.JoinHostPort(ipStr, fmt.Sprintf("%d", a.Port))
+}
+
+func (a Address) GoString() string {
+	return a.String()
+}

lib/nat/structs_test.go

@@ -0,0 +1,54 @@
+// Copyright (C) 2016 The Syncthing Authors.
+//
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this file,
+// You can obtain one at http://mozilla.org/MPL/2.0/.
+
+package nat
+
+import (
+	"net"
+	"testing"
+)
+
+func TestMappingValidGateway(t *testing.T) {
+	a := net.ParseIP("10.0.0.1")
+	b := net.ParseIP("192.168.0.1")
+	tests := []struct {
+		mappingLocalIP net.IP
+		gatewayLocalIP net.IP
+		expected       bool
+	}{
+		// Any of the IPs is nil or unspecified implies correct
+		{nil, nil, true},
+		{net.IPv4zero, net.IPv4zero, true},
+		{nil, net.IPv4zero, true},
+		{net.IPv4zero, nil, true},
+		{a, nil, true},
+		{b, nil, true},
+		{a, net.IPv4zero, true},
+		{b, net.IPv4zero, true},
+		{nil, a, true},
+		{nil, b, true},
+		{net.IPv4zero, a, true},
+		{net.IPv4zero, b, true},
+		// IPs are the same implies correct
+		{a, a, true},
+		{b, b, true},
+		// IPs are specified and different, implies incorrect
+		{a, b, false},
+		{b, a, false},
+	}
+
+	for _, test := range tests {
+		m := Mapping{
+			address: Address{
+				IP: test.mappingLocalIP,
+			},
+		}
+		result := m.validGateway(test.gatewayLocalIP)
+		if result != test.expected {
+			t.Errorf("Incorrect: local %s gateway %s result %t expected %t", test.mappingLocalIP, test.gatewayLocalIP, result, test.expected)
+		}
+	}
+}