mv internal lib

2015-08-06 11:29:25 +02:00
parent 0a803891a4
commit 7705a6c1f1
197 changed files with 158 additions and 158 deletions
--- a/lib/discover/client.go
+++ b/lib/discover/client.go
@@ -0,0 +1,50 @@
+// Copyright (C) 2014 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 discover
+
+import (
+	"fmt"
+	"net/url"
+	"time"
+
+	"github.com/syncthing/protocol"
+)
+
+type Factory func(*url.URL, *Announce) (Client, error)
+
+var (
+	factories                      = make(map[string]Factory)
+	DefaultErrorRetryInternval     = 60 * time.Second
+	DefaultGlobalBroadcastInterval = 1800 * time.Second
+)
+
+func Register(proto string, factory Factory) {
+	factories[proto] = factory
+}
+
+func New(addr string, pkt *Announce) (Client, error) {
+	uri, err := url.Parse(addr)
+	if err != nil {
+		return nil, err
+	}
+	factory, ok := factories[uri.Scheme]
+	if !ok {
+		return nil, fmt.Errorf("Unsupported scheme: %s", uri.Scheme)
+	}
+	client, err := factory(uri, pkt)
+	if err != nil {
+		return nil, err
+	}
+	return client, nil
+}
+
+type Client interface {
+	Lookup(device protocol.DeviceID) []string
+	StatusOK() bool
+	Address() string
+	Stop()
+}
--- a/lib/discover/client_test.go
+++ b/lib/discover/client_test.go
@@ -0,0 +1,219 @@
+// Copyright (C) 2014 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 discover
+
+import (
+	"fmt"
+	"net"
+	"time"
+
+	"testing"
+
+	"github.com/syncthing/protocol"
+
+	"github.com/syncthing/syncthing/lib/sync"
+)
+
+var device protocol.DeviceID
+
+func init() {
+	device, _ = protocol.DeviceIDFromString("P56IOI7-MZJNU2Y-IQGDREY-DM2MGTI-MGL3BXN-PQ6W5BM-TBBZ4TJ-XZWICQ2")
+}
+
+func TestUDP4Success(t *testing.T) {
+	conn, err := net.ListenUDP("udp4", nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	port := conn.LocalAddr().(*net.UDPAddr).Port
+
+	address := fmt.Sprintf("udp4://127.0.0.1:%d", port)
+	pkt := &Announce{
+		Magic: AnnouncementMagic,
+		This: Device{
+			device[:],
+			[]Address{{
+				IP:   net.IPv4(123, 123, 123, 123),
+				Port: 1234,
+			}},
+		},
+	}
+
+	client, err := New(address, pkt)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	udpclient := client.(*UDPClient)
+	if udpclient.errorRetryInterval != DefaultErrorRetryInternval {
+		t.Fatal("Incorrect retry interval")
+	}
+
+	if udpclient.listenAddress.IP != nil || udpclient.listenAddress.Port != 0 {
+		t.Fatal("Wrong listen IP or port", udpclient.listenAddress)
+	}
+
+	if client.Address() != address {
+		t.Fatal("Incorrect address")
+	}
+
+	buf := make([]byte, 2048)
+
+	// First announcement
+	conn.SetDeadline(time.Now().Add(time.Millisecond * 100))
+	_, err = conn.Read(buf)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	// Announcement verification
+	conn.SetDeadline(time.Now().Add(time.Millisecond * 1100))
+	_, addr, err := conn.ReadFromUDP(buf)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	// Reply to it.
+	_, err = conn.WriteToUDP(pkt.MustMarshalXDR(), addr)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	// We should get nothing else
+	conn.SetDeadline(time.Now().Add(time.Millisecond * 100))
+	_, err = conn.Read(buf)
+	if err == nil {
+		t.Fatal("Expected error")
+	}
+
+	// Status should be ok
+	if !client.StatusOK() {
+		t.Fatal("Wrong status")
+	}
+
+	// Do a lookup in a separate routine
+	addrs := []string{}
+	wg := sync.NewWaitGroup()
+	wg.Add(1)
+	go func() {
+		addrs = client.Lookup(device)
+		wg.Done()
+	}()
+
+	// Receive the lookup and reply
+	conn.SetDeadline(time.Now().Add(time.Millisecond * 100))
+	_, addr, err = conn.ReadFromUDP(buf)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	conn.WriteToUDP(pkt.MustMarshalXDR(), addr)
+
+	// Wait for the lookup to arrive, verify that the number of answers is correct
+	wg.Wait()
+
+	if len(addrs) != 1 || addrs[0] != "123.123.123.123:1234" {
+		t.Fatal("Wrong number of answers")
+	}
+
+	client.Stop()
+}
+
+func TestUDP4Failure(t *testing.T) {
+	conn, err := net.ListenUDP("udp4", nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	port := conn.LocalAddr().(*net.UDPAddr).Port
+
+	address := fmt.Sprintf("udp4://127.0.0.1:%d/?listenaddress=127.0.0.1&retry=5", port)
+
+	pkt := &Announce{
+		Magic: AnnouncementMagic,
+		This: Device{
+			device[:],
+			[]Address{{
+				IP:   net.IPv4(123, 123, 123, 123),
+				Port: 1234,
+			}},
+		},
+	}
+
+	client, err := New(address, pkt)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	udpclient := client.(*UDPClient)
+	if udpclient.errorRetryInterval != time.Second*5 {
+		t.Fatal("Incorrect retry interval")
+	}
+
+	if !udpclient.listenAddress.IP.Equal(net.IPv4(127, 0, 0, 1)) || udpclient.listenAddress.Port != 0 {
+		t.Fatal("Wrong listen IP or port", udpclient.listenAddress)
+	}
+
+	if client.Address() != address {
+		t.Fatal("Incorrect address")
+	}
+
+	buf := make([]byte, 2048)
+
+	// First announcement
+	conn.SetDeadline(time.Now().Add(time.Millisecond * 100))
+	_, err = conn.Read(buf)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	// Announcement verification
+	conn.SetDeadline(time.Now().Add(time.Millisecond * 1100))
+	_, _, err = conn.ReadFromUDP(buf)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	// Don't reply
+	// We should get nothing else
+	conn.SetDeadline(time.Now().Add(time.Millisecond * 100))
+	_, err = conn.Read(buf)
+	if err == nil {
+		t.Fatal("Expected error")
+	}
+
+	// Status should be failure
+	if client.StatusOK() {
+		t.Fatal("Wrong status")
+	}
+
+	// Do a lookup in a separate routine
+	addrs := []string{}
+	wg := sync.NewWaitGroup()
+	wg.Add(1)
+	go func() {
+		addrs = client.Lookup(device)
+		wg.Done()
+	}()
+
+	// Receive the lookup and don't reply
+	conn.SetDeadline(time.Now().Add(time.Millisecond * 100))
+	_, _, err = conn.ReadFromUDP(buf)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	// Wait for the lookup to timeout, verify that the number of answers is none
+	wg.Wait()
+
+	if len(addrs) != 0 {
+		t.Fatal("Wrong number of answers")
+	}
+
+	client.Stop()
+}
--- a/lib/discover/client_udp.go
+++ b/lib/discover/client_udp.go
@@ -0,0 +1,243 @@
+// Copyright (C) 2014 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 discover
+
+import (
+	"encoding/hex"
+	"io"
+	"net"
+	"net/url"
+	"strconv"
+	"time"
+
+	"github.com/syncthing/protocol"
+	"github.com/syncthing/syncthing/lib/sync"
+)
+
+func init() {
+	for _, proto := range []string{"udp", "udp4", "udp6"} {
+		Register(proto, func(uri *url.URL, pkt *Announce) (Client, error) {
+			c := &UDPClient{
+				wg:  sync.NewWaitGroup(),
+				mut: sync.NewRWMutex(),
+			}
+			err := c.Start(uri, pkt)
+			if err != nil {
+				return nil, err
+			}
+			return c, nil
+		})
+	}
+}
+
+type UDPClient struct {
+	url *url.URL
+
+	id protocol.DeviceID
+
+	stop          chan struct{}
+	wg            sync.WaitGroup
+	listenAddress *net.UDPAddr
+
+	globalBroadcastInterval time.Duration
+	errorRetryInterval      time.Duration
+
+	status bool
+	mut    sync.RWMutex
+}
+
+func (d *UDPClient) Start(uri *url.URL, pkt *Announce) error {
+	d.url = uri
+	d.id = protocol.DeviceIDFromBytes(pkt.This.ID)
+	d.stop = make(chan struct{})
+
+	params := uri.Query()
+	// The address must not have a port, as otherwise both announce and lookup
+	// sockets would try to bind to the same port.
+	addr, err := net.ResolveUDPAddr(d.url.Scheme, params.Get("listenaddress")+":0")
+	if err != nil {
+		return err
+	}
+	d.listenAddress = addr
+
+	broadcastSeconds, err := strconv.ParseUint(params.Get("broadcast"), 0, 0)
+	if err != nil {
+		d.globalBroadcastInterval = DefaultGlobalBroadcastInterval
+	} else {
+		d.globalBroadcastInterval = time.Duration(broadcastSeconds) * time.Second
+	}
+
+	retrySeconds, err := strconv.ParseUint(params.Get("retry"), 0, 0)
+	if err != nil {
+		d.errorRetryInterval = DefaultErrorRetryInternval
+	} else {
+		d.errorRetryInterval = time.Duration(retrySeconds) * time.Second
+	}
+
+	d.wg.Add(1)
+	go d.broadcast(pkt.MustMarshalXDR())
+	return nil
+}
+
+func (d *UDPClient) broadcast(pkt []byte) {
+	defer d.wg.Done()
+
+	conn, err := net.ListenUDP(d.url.Scheme, d.listenAddress)
+	for err != nil {
+		if debug {
+			l.Debugf("discover %s: broadcast listen: %v; trying again in %v", d.url, err, d.errorRetryInterval)
+		}
+		select {
+		case <-d.stop:
+			return
+		case <-time.After(d.errorRetryInterval):
+		}
+		conn, err = net.ListenUDP(d.url.Scheme, d.listenAddress)
+	}
+	defer conn.Close()
+
+	remote, err := net.ResolveUDPAddr(d.url.Scheme, d.url.Host)
+	for err != nil {
+		if debug {
+			l.Debugf("discover %s: broadcast resolve: %v; trying again in %v", d.url, err, d.errorRetryInterval)
+		}
+		select {
+		case <-d.stop:
+			return
+		case <-time.After(d.errorRetryInterval):
+		}
+		remote, err = net.ResolveUDPAddr(d.url.Scheme, d.url.Host)
+	}
+
+	timer := time.NewTimer(0)
+	for {
+		select {
+		case <-d.stop:
+			return
+
+		case <-timer.C:
+			var ok bool
+
+			if debug {
+				l.Debugf("discover %s: broadcast: Sending self announcement to %v", d.url, remote)
+			}
+
+			_, err := conn.WriteTo(pkt, remote)
+			if err != nil {
+				if debug {
+					l.Debugf("discover %s: broadcast: Failed to send self announcement: %s", d.url, err)
+				}
+				ok = false
+			} else {
+				// Verify that the announce server responds positively for our device ID
+
+				time.Sleep(1 * time.Second)
+
+				res := d.Lookup(d.id)
+				if debug {
+					l.Debugf("discover %s: broadcast: Self-lookup returned: %v", d.url, res)
+				}
+				ok = len(res) > 0
+			}
+
+			d.mut.Lock()
+			d.status = ok
+			d.mut.Unlock()
+
+			if ok {
+				timer.Reset(d.globalBroadcastInterval)
+			} else {
+				timer.Reset(d.errorRetryInterval)
+			}
+		}
+	}
+}
+
+func (d *UDPClient) Lookup(device protocol.DeviceID) []string {
+	extIP, err := net.ResolveUDPAddr(d.url.Scheme, d.url.Host)
+	if err != nil {
+		if debug {
+			l.Debugf("discover %s: Lookup(%s): %s", d.url, device, err)
+		}
+		return nil
+	}
+
+	conn, err := net.DialUDP(d.url.Scheme, d.listenAddress, extIP)
+	if err != nil {
+		if debug {
+			l.Debugf("discover %s: Lookup(%s): %s", d.url, device, err)
+		}
+		return nil
+	}
+	defer conn.Close()
+
+	err = conn.SetDeadline(time.Now().Add(5 * time.Second))
+	if err != nil {
+		if debug {
+			l.Debugf("discover %s: Lookup(%s): %s", d.url, device, err)
+		}
+		return nil
+	}
+
+	buf := Query{QueryMagic, device[:]}.MustMarshalXDR()
+	_, err = conn.Write(buf)
+	if err != nil {
+		if debug {
+			l.Debugf("discover %s: Lookup(%s): %s", d.url, device, err)
+		}
+		return nil
+	}
+
+	buf = make([]byte, 2048)
+	n, err := conn.Read(buf)
+	if err != nil {
+		if err, ok := err.(net.Error); ok && err.Timeout() {
+			// Expected if the server doesn't know about requested device ID
+			return nil
+		}
+		if debug {
+			l.Debugf("discover %s: Lookup(%s): %s", d.url, device, err)
+		}
+		return nil
+	}
+
+	var pkt Announce
+	err = pkt.UnmarshalXDR(buf[:n])
+	if err != nil && err != io.EOF {
+		if debug {
+			l.Debugf("discover %s: Lookup(%s): %s\n%s", d.url, device, err, hex.Dump(buf[:n]))
+		}
+		return nil
+	}
+
+	var addrs []string
+	for _, a := range pkt.This.Addresses {
+		deviceAddr := net.JoinHostPort(net.IP(a.IP).String(), strconv.Itoa(int(a.Port)))
+		addrs = append(addrs, deviceAddr)
+	}
+	if debug {
+		l.Debugf("discover %s: Lookup(%s) result: %v", d.url, device, addrs)
+	}
+	return addrs
+}
+
+func (d *UDPClient) Stop() {
+	if d.stop != nil {
+		close(d.stop)
+		d.wg.Wait()
+	}
+}
+
+func (d *UDPClient) StatusOK() bool {
+	d.mut.RLock()
+	defer d.mut.RUnlock()
+	return d.status
+}
+
+func (d *UDPClient) Address() string {
+	return d.url.String()
+}
--- a/lib/discover/debug.go
+++ b/lib/discover/debug.go
@@ -0,0 +1,19 @@
+// Copyright (C) 2014 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 discover
+
+import (
+	"os"
+	"strings"
+
+	"github.com/calmh/logger"
+)
+
+var (
+	debug = strings.Contains(os.Getenv("STTRACE"), "discover") || os.Getenv("STTRACE") == "all"
+	l     = logger.DefaultLogger
+)
--- a/lib/discover/discover.go
+++ b/lib/discover/discover.go
@@ -0,0 +1,453 @@
+// Copyright (C) 2014 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 discover
+
+import (
+	"bytes"
+	"encoding/hex"
+	"errors"
+	"io"
+	"net"
+	"runtime"
+	"strconv"
+	"time"
+
+	"github.com/syncthing/protocol"
+	"github.com/syncthing/syncthing/lib/beacon"
+	"github.com/syncthing/syncthing/lib/events"
+	"github.com/syncthing/syncthing/lib/sync"
+)
+
+type Discoverer struct {
+	myID            protocol.DeviceID
+	listenAddrs     []string
+	localBcastIntv  time.Duration
+	localBcastStart time.Time
+	cacheLifetime   time.Duration
+	negCacheCutoff  time.Duration
+	beacons         []beacon.Interface
+	extPort         uint16
+	localBcastTick  <-chan time.Time
+	forcedBcastTick chan time.Time
+
+	registryLock sync.RWMutex
+	registry     map[protocol.DeviceID][]CacheEntry
+	lastLookup   map[protocol.DeviceID]time.Time
+
+	clients []Client
+	mut     sync.RWMutex
+}
+
+type CacheEntry struct {
+	Address string
+	Seen    time.Time
+}
+
+var (
+	ErrIncorrectMagic = errors.New("incorrect magic number")
+)
+
+func NewDiscoverer(id protocol.DeviceID, addresses []string) *Discoverer {
+	return &Discoverer{
+		myID:           id,
+		listenAddrs:    addresses,
+		localBcastIntv: 30 * time.Second,
+		cacheLifetime:  5 * time.Minute,
+		negCacheCutoff: 3 * time.Minute,
+		registry:       make(map[protocol.DeviceID][]CacheEntry),
+		lastLookup:     make(map[protocol.DeviceID]time.Time),
+		registryLock:   sync.NewRWMutex(),
+		mut:            sync.NewRWMutex(),
+	}
+}
+
+func (d *Discoverer) StartLocal(localPort int, localMCAddr string) {
+	if localPort > 0 {
+		d.startLocalIPv4Broadcasts(localPort)
+	}
+
+	if len(localMCAddr) > 0 {
+		d.startLocalIPv6Multicasts(localMCAddr)
+	}
+
+	if len(d.beacons) == 0 {
+		l.Warnln("Local discovery unavailable")
+		return
+	}
+
+	d.localBcastTick = time.Tick(d.localBcastIntv)
+	d.forcedBcastTick = make(chan time.Time)
+	d.localBcastStart = time.Now()
+	go d.sendLocalAnnouncements()
+}
+
+func (d *Discoverer) startLocalIPv4Broadcasts(localPort int) {
+	bb := beacon.NewBroadcast(localPort)
+	d.beacons = append(d.beacons, bb)
+	go d.recvAnnouncements(bb)
+	bb.ServeBackground()
+}
+
+func (d *Discoverer) startLocalIPv6Multicasts(localMCAddr string) {
+	intfs, err := net.Interfaces()
+	if err != nil {
+		if debug {
+			l.Debugln("discover: interfaces:", err)
+		}
+		l.Infoln("Local discovery over IPv6 unavailable")
+		return
+	}
+
+	v6Intfs := 0
+	for _, intf := range intfs {
+		// Interface flags seem to always be 0 on Windows
+		if runtime.GOOS != "windows" && (intf.Flags&net.FlagUp == 0 || intf.Flags&net.FlagMulticast == 0) {
+			continue
+		}
+
+		mb, err := beacon.NewMulticast(localMCAddr, intf.Name)
+		if err != nil {
+			if debug {
+				l.Debugln("discover: Start local v6:", err)
+			}
+			continue
+		}
+
+		d.beacons = append(d.beacons, mb)
+		go d.recvAnnouncements(mb)
+		v6Intfs++
+	}
+
+	if v6Intfs == 0 {
+		l.Infoln("Local discovery over IPv6 unavailable")
+	}
+}
+
+func (d *Discoverer) StartGlobal(servers []string, extPort uint16) {
+	d.mut.Lock()
+	defer d.mut.Unlock()
+
+	if len(d.clients) > 0 {
+		d.stopGlobal()
+	}
+
+	d.extPort = extPort
+	pkt := d.announcementPkt()
+	wg := sync.NewWaitGroup()
+	clients := make(chan Client, len(servers))
+	for _, address := range servers {
+		wg.Add(1)
+		go func(addr string) {
+			defer wg.Done()
+			client, err := New(addr, pkt)
+			if err != nil {
+				l.Infoln("Error creating discovery client", addr, err)
+				return
+			}
+			clients <- client
+		}(address)
+	}
+
+	wg.Wait()
+	close(clients)
+
+	for client := range clients {
+		d.clients = append(d.clients, client)
+	}
+}
+
+func (d *Discoverer) StopGlobal() {
+	d.mut.Lock()
+	defer d.mut.Unlock()
+	d.stopGlobal()
+}
+
+func (d *Discoverer) stopGlobal() {
+	for _, client := range d.clients {
+		client.Stop()
+	}
+	d.clients = []Client{}
+}
+
+func (d *Discoverer) ExtAnnounceOK() map[string]bool {
+	d.mut.RLock()
+	defer d.mut.RUnlock()
+
+	ret := make(map[string]bool)
+	for _, client := range d.clients {
+		ret[client.Address()] = client.StatusOK()
+	}
+	return ret
+}
+
+func (d *Discoverer) Lookup(device protocol.DeviceID) []string {
+	d.registryLock.RLock()
+	cached := d.filterCached(d.registry[device])
+	lastLookup := d.lastLookup[device]
+	d.registryLock.RUnlock()
+
+	d.mut.RLock()
+	defer d.mut.RUnlock()
+
+	if len(cached) > 0 {
+		// There are cached address entries.
+		addrs := make([]string, len(cached))
+		for i := range cached {
+			addrs[i] = cached[i].Address
+		}
+		return addrs
+	}
+
+	if time.Since(lastLookup) < d.negCacheCutoff {
+		// We have recently tried to lookup this address and failed. Lets
+		// chill for a while.
+		return nil
+	}
+
+	if len(d.clients) != 0 && time.Since(d.localBcastStart) > d.localBcastIntv {
+		// Only perform external lookups if we have at least one external
+		// server client and one local announcement interval has passed. This is
+		// to avoid finding local peers on their remote address at startup.
+		results := make(chan []string, len(d.clients))
+		wg := sync.NewWaitGroup()
+		for _, client := range d.clients {
+			wg.Add(1)
+			go func(c Client) {
+				defer wg.Done()
+				results <- c.Lookup(device)
+			}(client)
+		}
+
+		wg.Wait()
+		close(results)
+
+		cached := []CacheEntry{}
+		seen := make(map[string]struct{})
+		now := time.Now()
+
+		var addrs []string
+		for result := range results {
+			for _, addr := range result {
+				_, ok := seen[addr]
+				if !ok {
+					cached = append(cached, CacheEntry{
+						Address: addr,
+						Seen:    now,
+					})
+					seen[addr] = struct{}{}
+					addrs = append(addrs, addr)
+				}
+			}
+		}
+
+		d.registryLock.Lock()
+		d.registry[device] = cached
+		d.lastLookup[device] = time.Now()
+		d.registryLock.Unlock()
+
+		return addrs
+	}
+
+	return nil
+}
+
+func (d *Discoverer) Hint(device string, addrs []string) {
+	resAddrs := resolveAddrs(addrs)
+	var id protocol.DeviceID
+	id.UnmarshalText([]byte(device))
+	d.registerDevice(nil, Device{
+		Addresses: resAddrs,
+		ID:        id[:],
+	})
+}
+
+func (d *Discoverer) All() map[protocol.DeviceID][]CacheEntry {
+	d.registryLock.RLock()
+	devices := make(map[protocol.DeviceID][]CacheEntry, len(d.registry))
+	for device, addrs := range d.registry {
+		addrsCopy := make([]CacheEntry, len(addrs))
+		copy(addrsCopy, addrs)
+		devices[device] = addrsCopy
+	}
+	d.registryLock.RUnlock()
+	return devices
+}
+
+func (d *Discoverer) announcementPkt() *Announce {
+	var addrs []Address
+	if d.extPort != 0 {
+		addrs = []Address{{Port: d.extPort}}
+	} else {
+		for _, astr := range d.listenAddrs {
+			addr, err := net.ResolveTCPAddr("tcp", astr)
+			if err != nil {
+				l.Warnln("discover: %v: not announcing %s", err, astr)
+				continue
+			} else if debug {
+				l.Debugf("discover: resolved %s as %#v", astr, addr)
+			}
+			if len(addr.IP) == 0 || addr.IP.IsUnspecified() {
+				addrs = append(addrs, Address{Port: uint16(addr.Port)})
+			} else if bs := addr.IP.To4(); bs != nil {
+				addrs = append(addrs, Address{IP: bs, Port: uint16(addr.Port)})
+			} else if bs := addr.IP.To16(); bs != nil {
+				addrs = append(addrs, Address{IP: bs, Port: uint16(addr.Port)})
+			}
+		}
+	}
+	return &Announce{
+		Magic: AnnouncementMagic,
+		This:  Device{d.myID[:], addrs},
+	}
+}
+
+func (d *Discoverer) sendLocalAnnouncements() {
+	var addrs = resolveAddrs(d.listenAddrs)
+
+	var pkt = Announce{
+		Magic: AnnouncementMagic,
+		This:  Device{d.myID[:], addrs},
+	}
+	msg := pkt.MustMarshalXDR()
+
+	for {
+		for _, b := range d.beacons {
+			b.Send(msg)
+		}
+
+		select {
+		case <-d.localBcastTick:
+		case <-d.forcedBcastTick:
+		}
+	}
+}
+
+func (d *Discoverer) recvAnnouncements(b beacon.Interface) {
+	for {
+		buf, addr := b.Recv()
+
+		var pkt Announce
+		err := pkt.UnmarshalXDR(buf)
+		if err != nil && err != io.EOF {
+			if debug {
+				l.Debugf("discover: Failed to unmarshal local announcement from %s:\n%s", addr, hex.Dump(buf))
+			}
+			continue
+		}
+
+		if debug {
+			l.Debugf("discover: Received local announcement from %s for %s", addr, protocol.DeviceIDFromBytes(pkt.This.ID))
+		}
+
+		var newDevice bool
+		if bytes.Compare(pkt.This.ID, d.myID[:]) != 0 {
+			newDevice = d.registerDevice(addr, pkt.This)
+		}
+
+		if newDevice {
+			select {
+			case d.forcedBcastTick <- time.Now():
+			}
+		}
+	}
+}
+
+func (d *Discoverer) registerDevice(addr net.Addr, device Device) bool {
+	var id protocol.DeviceID
+	copy(id[:], device.ID)
+
+	d.registryLock.Lock()
+	defer d.registryLock.Unlock()
+
+	current := d.filterCached(d.registry[id])
+
+	orig := current
+
+	for _, a := range device.Addresses {
+		var deviceAddr string
+		if len(a.IP) > 0 {
+			deviceAddr = net.JoinHostPort(net.IP(a.IP).String(), strconv.Itoa(int(a.Port)))
+		} else if addr != nil {
+			ua := addr.(*net.UDPAddr)
+			ua.Port = int(a.Port)
+			deviceAddr = ua.String()
+		}
+		for i := range current {
+			if current[i].Address == deviceAddr {
+				current[i].Seen = time.Now()
+				goto done
+			}
+		}
+		current = append(current, CacheEntry{
+			Address: deviceAddr,
+			Seen:    time.Now(),
+		})
+	done:
+	}
+
+	if debug {
+		l.Debugf("discover: Caching %s addresses: %v", id, current)
+	}
+
+	d.registry[id] = current
+
+	if len(current) > len(orig) {
+		addrs := make([]string, len(current))
+		for i := range current {
+			addrs[i] = current[i].Address
+		}
+		events.Default.Log(events.DeviceDiscovered, map[string]interface{}{
+			"device": id.String(),
+			"addrs":  addrs,
+		})
+	}
+
+	return len(current) > len(orig)
+}
+
+func (d *Discoverer) filterCached(c []CacheEntry) []CacheEntry {
+	for i := 0; i < len(c); {
+		if ago := time.Since(c[i].Seen); ago > d.cacheLifetime {
+			if debug {
+				l.Debugf("discover: Removing cached address %s - seen %v ago", c[i].Address, ago)
+			}
+			c[i] = c[len(c)-1]
+			c = c[:len(c)-1]
+		} else {
+			i++
+		}
+	}
+	return c
+}
+
+func addrToAddr(addr *net.TCPAddr) Address {
+	if len(addr.IP) == 0 || addr.IP.IsUnspecified() {
+		return Address{Port: uint16(addr.Port)}
+	} else if bs := addr.IP.To4(); bs != nil {
+		return Address{IP: bs, Port: uint16(addr.Port)}
+	} else if bs := addr.IP.To16(); bs != nil {
+		return Address{IP: bs, Port: uint16(addr.Port)}
+	}
+	return Address{}
+}
+
+func resolveAddrs(addrs []string) []Address {
+	var raddrs []Address
+	for _, addrStr := range addrs {
+		addrRes, err := net.ResolveTCPAddr("tcp", addrStr)
+		if err != nil {
+			continue
+		}
+		addr := addrToAddr(addrRes)
+		if len(addr.IP) > 0 {
+			raddrs = append(raddrs, addr)
+		} else {
+			raddrs = append(raddrs, Address{Port: addr.Port})
+		}
+	}
+	return raddrs
+}
--- a/lib/discover/discover_test.go
+++ b/lib/discover/discover_test.go
@@ -0,0 +1,139 @@
+// Copyright (C) 2014 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 discover
+
+import (
+	"net/url"
+	"time"
+
+	"testing"
+
+	"github.com/syncthing/protocol"
+)
+
+type DummyClient struct {
+	url          *url.URL
+	lookups      []protocol.DeviceID
+	lookupRet    []string
+	stops        int
+	statusRet    bool
+	statusChecks int
+}
+
+func (c *DummyClient) Lookup(device protocol.DeviceID) []string {
+	c.lookups = append(c.lookups, device)
+	return c.lookupRet
+}
+
+func (c *DummyClient) StatusOK() bool {
+	c.statusChecks++
+	return c.statusRet
+}
+
+func (c *DummyClient) Stop() {
+	c.stops++
+}
+
+func (c *DummyClient) Address() string {
+	return c.url.String()
+}
+
+func TestGlobalDiscovery(t *testing.T) {
+	c1 := &DummyClient{
+		statusRet: false,
+		lookupRet: []string{"test.com:1234"},
+	}
+
+	c2 := &DummyClient{
+		statusRet: true,
+		lookupRet: []string{},
+	}
+
+	c3 := &DummyClient{
+		statusRet: true,
+		lookupRet: []string{"best.com:2345"},
+	}
+
+	clients := []*DummyClient{c1, c2}
+
+	Register("test1", func(uri *url.URL, pkt *Announce) (Client, error) {
+		c := clients[0]
+		clients = clients[1:]
+		c.url = uri
+		return c, nil
+	})
+
+	Register("test2", func(uri *url.URL, pkt *Announce) (Client, error) {
+		c3.url = uri
+		return c3, nil
+	})
+
+	d := NewDiscoverer(device, []string{})
+	d.localBcastStart = time.Time{}
+	servers := []string{
+		"test1://123.123.123.123:1234",
+		"test1://23.23.23.23:234",
+		"test2://234.234.234.234.2345",
+	}
+	d.StartGlobal(servers, 1234)
+
+	if len(d.clients) != 3 {
+		t.Fatal("Wrong number of clients")
+	}
+
+	status := d.ExtAnnounceOK()
+
+	for _, c := range []*DummyClient{c1, c2, c3} {
+		if status[c.url.String()] != c.statusRet || c.statusChecks != 1 {
+			t.Fatal("Wrong status")
+		}
+	}
+
+	addrs := d.Lookup(device)
+	if len(addrs) != 2 {
+		t.Fatal("Wrong number of addresses", addrs)
+	}
+
+	for _, addr := range []string{"test.com:1234", "best.com:2345"} {
+		found := false
+		for _, laddr := range addrs {
+			if laddr == addr {
+				found = true
+				break
+			}
+		}
+		if !found {
+			t.Fatal("Couldn't find", addr)
+		}
+	}
+
+	for _, c := range []*DummyClient{c1, c2, c3} {
+		if len(c.lookups) != 1 || c.lookups[0] != device {
+			t.Fatal("Wrong lookups")
+		}
+	}
+
+	addrs = d.Lookup(device)
+	if len(addrs) != 2 {
+		t.Fatal("Wrong number of addresses", addrs)
+	}
+
+	// Answer should be cached, so number of lookups should have not increased
+	for _, c := range []*DummyClient{c1, c2, c3} {
+		if len(c.lookups) != 1 || c.lookups[0] != device {
+			t.Fatal("Wrong lookups")
+		}
+	}
+
+	d.StopGlobal()
+
+	for _, c := range []*DummyClient{c1, c2, c3} {
+		if c.stops != 1 {
+			t.Fatal("Wrong number of stops")
+		}
+	}
+}
--- a/lib/discover/doc.go
+++ b/lib/discover/doc.go
@@ -0,0 +1,8 @@
+// Copyright (C) 2014 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 discover implements the device discovery protocol.
+package discover
--- a/lib/discover/packets.go
+++ b/lib/discover/packets.go
@@ -0,0 +1,36 @@
+// Copyright (C) 2014 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/.
+
+//go:generate -command genxdr go run ../../Godeps/_workspace/src/github.com/calmh/xdr/cmd/genxdr/main.go
+//go:generate genxdr -o packets_xdr.go packets.go
+
+package discover
+
+const (
+	AnnouncementMagic = 0x9D79BC39
+	QueryMagic        = 0x2CA856F5
+)
+
+type Query struct {
+	Magic    uint32
+	DeviceID []byte // max:32
+}
+
+type Announce struct {
+	Magic uint32
+	This  Device
+	Extra []Device // max:16
+}
+
+type Device struct {
+	ID        []byte    // max:32
+	Addresses []Address // max:16
+}
+
+type Address struct {
+	IP   []byte // max:16
+	Port uint16
+}
--- a/lib/discover/packets_xdr.go
+++ b/lib/discover/packets_xdr.go
@@ -0,0 +1,357 @@
+// ************************************************************
+// This file is automatically generated by genxdr. Do not edit.
+// ************************************************************
+
+package discover
+
+import (
+	"bytes"
+	"io"
+
+	"github.com/calmh/xdr"
+)
+
+/*
+
+Query Structure:
+
+ 0                   1                   2                   3
+ 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+|                             Magic                             |
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+|                      Length of Device ID                      |
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+/                                                               /
+\                  Device ID (variable length)                  \
+/                                                               /
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+
+
+struct Query {
+	unsigned int Magic;
+	opaque DeviceID<32>;
+}
+
+*/
+
+func (o Query) EncodeXDR(w io.Writer) (int, error) {
+	var xw = xdr.NewWriter(w)
+	return o.EncodeXDRInto(xw)
+}
+
+func (o Query) MarshalXDR() ([]byte, error) {
+	return o.AppendXDR(make([]byte, 0, 128))
+}
+
+func (o Query) MustMarshalXDR() []byte {
+	bs, err := o.MarshalXDR()
+	if err != nil {
+		panic(err)
+	}
+	return bs
+}
+
+func (o Query) AppendXDR(bs []byte) ([]byte, error) {
+	var aw = xdr.AppendWriter(bs)
+	var xw = xdr.NewWriter(&aw)
+	_, err := o.EncodeXDRInto(xw)
+	return []byte(aw), err
+}
+
+func (o Query) EncodeXDRInto(xw *xdr.Writer) (int, error) {
+	xw.WriteUint32(o.Magic)
+	if l := len(o.DeviceID); l > 32 {
+		return xw.Tot(), xdr.ElementSizeExceeded("DeviceID", l, 32)
+	}
+	xw.WriteBytes(o.DeviceID)
+	return xw.Tot(), xw.Error()
+}
+
+func (o *Query) DecodeXDR(r io.Reader) error {
+	xr := xdr.NewReader(r)
+	return o.DecodeXDRFrom(xr)
+}
+
+func (o *Query) UnmarshalXDR(bs []byte) error {
+	var br = bytes.NewReader(bs)
+	var xr = xdr.NewReader(br)
+	return o.DecodeXDRFrom(xr)
+}
+
+func (o *Query) DecodeXDRFrom(xr *xdr.Reader) error {
+	o.Magic = xr.ReadUint32()
+	o.DeviceID = xr.ReadBytesMax(32)
+	return xr.Error()
+}
+
+/*
+
+Announce Structure:
+
+ 0                   1                   2                   3
+ 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+|                             Magic                             |
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+/                                                               /
+\                       Device Structure                        \
+/                                                               /
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+|                        Number of Extra                        |
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+/                                                               /
+\                Zero or more Device Structures                 \
+/                                                               /
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+
+
+struct Announce {
+	unsigned int Magic;
+	Device This;
+	Device Extra<16>;
+}
+
+*/
+
+func (o Announce) EncodeXDR(w io.Writer) (int, error) {
+	var xw = xdr.NewWriter(w)
+	return o.EncodeXDRInto(xw)
+}
+
+func (o Announce) MarshalXDR() ([]byte, error) {
+	return o.AppendXDR(make([]byte, 0, 128))
+}
+
+func (o Announce) MustMarshalXDR() []byte {
+	bs, err := o.MarshalXDR()
+	if err != nil {
+		panic(err)
+	}
+	return bs
+}
+
+func (o Announce) AppendXDR(bs []byte) ([]byte, error) {
+	var aw = xdr.AppendWriter(bs)
+	var xw = xdr.NewWriter(&aw)
+	_, err := o.EncodeXDRInto(xw)
+	return []byte(aw), err
+}
+
+func (o Announce) EncodeXDRInto(xw *xdr.Writer) (int, error) {
+	xw.WriteUint32(o.Magic)
+	_, err := o.This.EncodeXDRInto(xw)
+	if err != nil {
+		return xw.Tot(), err
+	}
+	if l := len(o.Extra); l > 16 {
+		return xw.Tot(), xdr.ElementSizeExceeded("Extra", l, 16)
+	}
+	xw.WriteUint32(uint32(len(o.Extra)))
+	for i := range o.Extra {
+		_, err := o.Extra[i].EncodeXDRInto(xw)
+		if err != nil {
+			return xw.Tot(), err
+		}
+	}
+	return xw.Tot(), xw.Error()
+}
+
+func (o *Announce) DecodeXDR(r io.Reader) error {
+	xr := xdr.NewReader(r)
+	return o.DecodeXDRFrom(xr)
+}
+
+func (o *Announce) UnmarshalXDR(bs []byte) error {
+	var br = bytes.NewReader(bs)
+	var xr = xdr.NewReader(br)
+	return o.DecodeXDRFrom(xr)
+}
+
+func (o *Announce) DecodeXDRFrom(xr *xdr.Reader) error {
+	o.Magic = xr.ReadUint32()
+	(&o.This).DecodeXDRFrom(xr)
+	_ExtraSize := int(xr.ReadUint32())
+	if _ExtraSize < 0 {
+		return xdr.ElementSizeExceeded("Extra", _ExtraSize, 16)
+	}
+	if _ExtraSize > 16 {
+		return xdr.ElementSizeExceeded("Extra", _ExtraSize, 16)
+	}
+	o.Extra = make([]Device, _ExtraSize)
+	for i := range o.Extra {
+		(&o.Extra[i]).DecodeXDRFrom(xr)
+	}
+	return xr.Error()
+}
+
+/*
+
+Device Structure:
+
+ 0                   1                   2                   3
+ 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+|                         Length of ID                          |
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+/                                                               /
+\                     ID (variable length)                      \
+/                                                               /
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+|                      Number of Addresses                      |
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+/                                                               /
+\                Zero or more Address Structures                \
+/                                                               /
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+
+
+struct Device {
+	opaque ID<32>;
+	Address Addresses<16>;
+}
+
+*/
+
+func (o Device) EncodeXDR(w io.Writer) (int, error) {
+	var xw = xdr.NewWriter(w)
+	return o.EncodeXDRInto(xw)
+}
+
+func (o Device) MarshalXDR() ([]byte, error) {
+	return o.AppendXDR(make([]byte, 0, 128))
+}
+
+func (o Device) MustMarshalXDR() []byte {
+	bs, err := o.MarshalXDR()
+	if err != nil {
+		panic(err)
+	}
+	return bs
+}
+
+func (o Device) AppendXDR(bs []byte) ([]byte, error) {
+	var aw = xdr.AppendWriter(bs)
+	var xw = xdr.NewWriter(&aw)
+	_, err := o.EncodeXDRInto(xw)
+	return []byte(aw), err
+}
+
+func (o Device) EncodeXDRInto(xw *xdr.Writer) (int, error) {
+	if l := len(o.ID); l > 32 {
+		return xw.Tot(), xdr.ElementSizeExceeded("ID", l, 32)
+	}
+	xw.WriteBytes(o.ID)
+	if l := len(o.Addresses); l > 16 {
+		return xw.Tot(), xdr.ElementSizeExceeded("Addresses", l, 16)
+	}
+	xw.WriteUint32(uint32(len(o.Addresses)))
+	for i := range o.Addresses {
+		_, err := o.Addresses[i].EncodeXDRInto(xw)
+		if err != nil {
+			return xw.Tot(), err
+		}
+	}
+	return xw.Tot(), xw.Error()
+}
+
+func (o *Device) DecodeXDR(r io.Reader) error {
+	xr := xdr.NewReader(r)
+	return o.DecodeXDRFrom(xr)
+}
+
+func (o *Device) UnmarshalXDR(bs []byte) error {
+	var br = bytes.NewReader(bs)
+	var xr = xdr.NewReader(br)
+	return o.DecodeXDRFrom(xr)
+}
+
+func (o *Device) DecodeXDRFrom(xr *xdr.Reader) error {
+	o.ID = xr.ReadBytesMax(32)
+	_AddressesSize := int(xr.ReadUint32())
+	if _AddressesSize < 0 {
+		return xdr.ElementSizeExceeded("Addresses", _AddressesSize, 16)
+	}
+	if _AddressesSize > 16 {
+		return xdr.ElementSizeExceeded("Addresses", _AddressesSize, 16)
+	}
+	o.Addresses = make([]Address, _AddressesSize)
+	for i := range o.Addresses {
+		(&o.Addresses[i]).DecodeXDRFrom(xr)
+	}
+	return xr.Error()
+}
+
+/*
+
+Address Structure:
+
+ 0                   1                   2                   3
+ 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+|                         Length of IP                          |
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+/                                                               /
+\                     IP (variable length)                      \
+/                                                               /
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+|            0x0000             |             Port              |
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+
+
+struct Address {
+	opaque IP<16>;
+	unsigned int Port;
+}
+
+*/
+
+func (o Address) EncodeXDR(w io.Writer) (int, error) {
+	var xw = xdr.NewWriter(w)
+	return o.EncodeXDRInto(xw)
+}
+
+func (o Address) MarshalXDR() ([]byte, error) {
+	return o.AppendXDR(make([]byte, 0, 128))
+}
+
+func (o Address) MustMarshalXDR() []byte {
+	bs, err := o.MarshalXDR()
+	if err != nil {
+		panic(err)
+	}
+	return bs
+}
+
+func (o Address) AppendXDR(bs []byte) ([]byte, error) {
+	var aw = xdr.AppendWriter(bs)
+	var xw = xdr.NewWriter(&aw)
+	_, err := o.EncodeXDRInto(xw)
+	return []byte(aw), err
+}
+
+func (o Address) EncodeXDRInto(xw *xdr.Writer) (int, error) {
+	if l := len(o.IP); l > 16 {
+		return xw.Tot(), xdr.ElementSizeExceeded("IP", l, 16)
+	}
+	xw.WriteBytes(o.IP)
+	xw.WriteUint16(o.Port)
+	return xw.Tot(), xw.Error()
+}
+
+func (o *Address) DecodeXDR(r io.Reader) error {
+	xr := xdr.NewReader(r)
+	return o.DecodeXDRFrom(xr)
+}
+
+func (o *Address) UnmarshalXDR(bs []byte) error {
+	var br = bytes.NewReader(bs)
+	var xr = xdr.NewReader(br)
+	return o.DecodeXDRFrom(xr)
+}
+
+func (o *Address) DecodeXDRFrom(xr *xdr.Reader) error {
+	o.IP = xr.ReadBytesMax(16)
+	o.Port = xr.ReadUint16()
+	return xr.Error()
+}