mirror of
https://github.com/syncthing/syncthing.git
synced 2026-11-21 01:21:27 -08:00
This implements a new peer-to-peer-based discovery protocol. - The DHT is based on libp2p (of IPFS etc) and constitutes a new, separate Syncthing-specific network. It does not piggyback on any existing non-Syncthing nodes out there. - It uses existing device IDs as the keys, and publishes discovery documents that include the device certificate and are signed by the same. This enables validation that the discovery data is _for_ the right device ID, as well as published _by_ that device. - The DHT runs on the QUIC socket, so it shares UPnP/NAT-PMP whole punches and STUN discovery. (Unless the QUIC listener is disabled, then it runs on an ephemeral socket and can effectively do only queries and not participate as a full DHT node.) - There is a hardcoded default pointing to three bootstrap nodes hosted in the usual manner. - Currently it's strictly additive -- it runs separately and in parallell with the usual global discovery. Once proven and scaled, it will gradually take over the duties of the global discovery. - There is a new command line tool `stdht` which just runs a DHT node to assist with discovery (the bootstrap nodes are this). The diff is large and terrifying, but that's how it is. Signed-off-by: Jakob Borg <[email protected]>
163 lines
4.2 KiB
Go
163 lines
4.2 KiB
Go
// 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 connections
|
|
|
|
import (
|
|
"errors"
|
|
"net"
|
|
"net/url"
|
|
"strconv"
|
|
"strings"
|
|
|
|
"github.com/syncthing/syncthing/lib/nat"
|
|
"github.com/syncthing/syncthing/lib/osutil"
|
|
)
|
|
|
|
func fixupPort(uri *url.URL, defaultPort int) *url.URL {
|
|
copyURI := *uri
|
|
|
|
host, port, err := net.SplitHostPort(uri.Host)
|
|
e := &net.AddrError{}
|
|
if errors.As(err, &e) && strings.Contains(e.Err, "missing port") {
|
|
// addr is of the form "1.2.3.4" or "[fe80::1]"
|
|
host = uri.Host
|
|
if strings.HasPrefix(host, "[") && strings.HasSuffix(host, "]") {
|
|
// net.JoinHostPort will add the brackets again
|
|
host = host[1 : len(host)-1]
|
|
}
|
|
copyURI.Host = net.JoinHostPort(host, strconv.Itoa(defaultPort))
|
|
} else if err == nil && port == "" {
|
|
// addr is on the form "1.2.3.4:" or "[fe80::1]:"
|
|
copyURI.Host = net.JoinHostPort(host, strconv.Itoa(defaultPort))
|
|
}
|
|
|
|
return ©URI
|
|
}
|
|
|
|
func getURLsForAllAdaptersIfUnspecified(network string, uri *url.URL) []*url.URL {
|
|
ip, port, err := resolve(network, uri.Host)
|
|
// Failed to resolve
|
|
if err != nil || port == 0 {
|
|
return nil
|
|
}
|
|
|
|
// Not an unspecified address, so no point of substituting with local
|
|
// interface addresses as it's listening on a specific adapter anyway.
|
|
if len(ip) != 0 && !ip.IsUnspecified() {
|
|
return nil
|
|
}
|
|
|
|
hostPorts := getHostPortsForAllAdapters(network, port)
|
|
addrs := make([]*url.URL, 0, len(hostPorts))
|
|
for _, hostPort := range hostPorts {
|
|
newUri := *uri
|
|
newUri.Host = hostPort
|
|
addrs = append(addrs, &newUri)
|
|
}
|
|
|
|
return addrs
|
|
}
|
|
|
|
func getHostPortsForAllAdapters(network string, port int) []string {
|
|
nets, err := osutil.GetInterfaceAddrs(true)
|
|
if err != nil {
|
|
// Ignore failure.
|
|
return nil
|
|
}
|
|
|
|
hostPorts := make([]string, 0, len(nets))
|
|
|
|
portStr := strconv.Itoa(port)
|
|
|
|
for _, iface := range nets {
|
|
if strings.HasSuffix(network, "4") && iface.IP.To4() == nil || strings.HasSuffix(network, "6") && iface.IP.To4() != nil {
|
|
continue
|
|
}
|
|
// Only accept IPv4 link-local unicast and the private ranges defined in RFC 1918 and RFC 4193
|
|
// IPv6 link-local addresses require an interface identifier to work correctly
|
|
if (iface.IP.To4() != nil && iface.IP.IsLinkLocalUnicast()) || iface.IP.IsPrivate() {
|
|
hostPorts = append(hostPorts, net.JoinHostPort(iface.IP.String(), portStr))
|
|
}
|
|
}
|
|
return hostPorts
|
|
}
|
|
|
|
func resolve(network, hostPort string) (net.IP, int, error) {
|
|
switch network {
|
|
case "tcp", "tcp4", "tcp6":
|
|
if addr, err := net.ResolveTCPAddr(network, hostPort); err != nil {
|
|
return net.IPv4zero, 0, err
|
|
} else {
|
|
return addr.IP, addr.Port, nil
|
|
}
|
|
case "udp", "udp4", "udp6":
|
|
if addr, err := net.ResolveUDPAddr(network, hostPort); err != nil {
|
|
return net.IPv4zero, 0, err
|
|
} else {
|
|
return addr.IP, addr.Port, nil
|
|
}
|
|
case "ip", "ip4", "ip6":
|
|
if addr, err := net.ResolveIPAddr(network, hostPort); err != nil {
|
|
return net.IPv4zero, 0, err
|
|
} else {
|
|
return addr.IP, 0, nil
|
|
}
|
|
}
|
|
return net.IPv4zero, 0, net.UnknownNetworkError(network)
|
|
}
|
|
|
|
func maybeReplacePort(uri *url.URL, laddr net.Addr) *url.URL {
|
|
if laddr == nil {
|
|
return uri
|
|
}
|
|
|
|
host, portStr, err := net.SplitHostPort(uri.Host)
|
|
if err != nil {
|
|
return uri
|
|
}
|
|
port, err := strconv.Atoi(portStr)
|
|
if err != nil {
|
|
return uri
|
|
}
|
|
if port != 0 {
|
|
return uri
|
|
}
|
|
|
|
_, lportStr, err := net.SplitHostPort(laddr.String())
|
|
if err != nil {
|
|
return uri
|
|
}
|
|
|
|
uriCopy := *uri
|
|
uriCopy.Host = net.JoinHostPort(host, lportStr)
|
|
return &uriCopy
|
|
}
|
|
|
|
func portMappingURIs(mapping *nat.Mapping, listener_uri url.URL) []*url.URL {
|
|
var uris []*url.URL
|
|
if mapping != nil {
|
|
addrs := mapping.ExternalAddresses()
|
|
for _, addr := range addrs {
|
|
uri := listener_uri
|
|
// Does net.JoinHostPort internally
|
|
uri.Host = addr.String()
|
|
uris = append(uris, &uri)
|
|
|
|
// For every address with a specified IP, add one without an IP,
|
|
// just in case the specified IP is still internal (router behind DMZ).
|
|
if len(addr.IP) != 0 && !addr.IP.IsUnspecified() {
|
|
zeroUri := listener_uri
|
|
addr.IP = nil
|
|
zeroUri.Host = addr.String()
|
|
uris = append(uris, &zeroUri)
|
|
}
|
|
}
|
|
}
|
|
|
|
return uris
|
|
}
|