2019-05-29 09:56:40 +02:00
|
|
|
// Copyright (C) 2019 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/.
|
|
|
|
|
2021-02-17 11:09:16 +01:00
|
|
|
// +build go1.14,!noquic,!go1.17
|
2019-05-29 09:56:40 +02:00
|
|
|
|
|
|
|
package connections
|
|
|
|
|
|
|
|
import (
|
2019-08-23 10:15:52 +02:00
|
|
|
"context"
|
2019-05-29 09:56:40 +02:00
|
|
|
"crypto/tls"
|
|
|
|
"net"
|
|
|
|
"net/url"
|
|
|
|
"sync"
|
|
|
|
"sync/atomic"
|
2021-04-13 13:59:58 +02:00
|
|
|
"syscall"
|
2019-10-18 09:55:37 +02:00
|
|
|
"time"
|
2019-05-29 09:56:40 +02:00
|
|
|
|
|
|
|
"github.com/lucas-clemente/quic-go"
|
|
|
|
|
|
|
|
"github.com/syncthing/syncthing/lib/config"
|
|
|
|
"github.com/syncthing/syncthing/lib/connections/registry"
|
|
|
|
"github.com/syncthing/syncthing/lib/nat"
|
|
|
|
"github.com/syncthing/syncthing/lib/stun"
|
2020-12-22 20:17:14 +01:00
|
|
|
"github.com/syncthing/syncthing/lib/svcutil"
|
2019-05-29 09:56:40 +02:00
|
|
|
)
|
|
|
|
|
|
|
|
func init() {
|
|
|
|
factory := &quicListenerFactory{}
|
|
|
|
for _, scheme := range []string{"quic", "quic4", "quic6"} {
|
|
|
|
listeners[scheme] = factory
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
type quicListener struct {
|
2020-12-22 20:17:14 +01:00
|
|
|
svcutil.ServiceWithError
|
2019-05-29 09:56:40 +02:00
|
|
|
nat atomic.Value
|
|
|
|
|
|
|
|
onAddressesChangedNotifier
|
|
|
|
|
|
|
|
uri *url.URL
|
|
|
|
cfg config.Wrapper
|
|
|
|
tlsCfg *tls.Config
|
|
|
|
conns chan internalConn
|
|
|
|
factory listenerFactory
|
|
|
|
|
|
|
|
address *url.URL
|
2021-05-10 16:44:47 +02:00
|
|
|
laddr net.Addr
|
2019-05-29 09:56:40 +02:00
|
|
|
mut sync.Mutex
|
|
|
|
}
|
|
|
|
|
|
|
|
func (t *quicListener) OnNATTypeChanged(natType stun.NATType) {
|
|
|
|
if natType != stun.NATUnknown {
|
|
|
|
l.Infof("%s detected NAT type: %s", t.uri, natType)
|
|
|
|
}
|
|
|
|
t.nat.Store(natType)
|
|
|
|
}
|
|
|
|
|
|
|
|
func (t *quicListener) OnExternalAddressChanged(address *stun.Host, via string) {
|
|
|
|
var uri *url.URL
|
|
|
|
if address != nil {
|
2019-06-09 23:14:00 +02:00
|
|
|
copy := *t.uri
|
|
|
|
uri = ©
|
2019-05-29 09:56:40 +02:00
|
|
|
uri.Host = address.TransportAddr()
|
|
|
|
}
|
|
|
|
|
|
|
|
t.mut.Lock()
|
|
|
|
existingAddress := t.address
|
|
|
|
t.address = uri
|
|
|
|
t.mut.Unlock()
|
|
|
|
|
|
|
|
if uri != nil && (existingAddress == nil || existingAddress.String() != uri.String()) {
|
|
|
|
l.Infof("%s resolved external address %s (via %s)", t.uri, uri.String(), via)
|
|
|
|
t.notifyAddressesChanged(t)
|
|
|
|
} else if uri == nil && existingAddress != nil {
|
|
|
|
t.notifyAddressesChanged(t)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-11-21 08:41:15 +01:00
|
|
|
func (t *quicListener) serve(ctx context.Context) error {
|
2021-07-10 13:53:51 +02:00
|
|
|
network := quicNetwork(t.uri)
|
2019-05-29 09:56:40 +02:00
|
|
|
|
2021-05-11 07:59:56 +02:00
|
|
|
udpAddr, err := net.ResolveUDPAddr(network, t.uri.Host)
|
2019-05-29 09:56:40 +02:00
|
|
|
if err != nil {
|
|
|
|
l.Infoln("Listen (BEP/quic):", err)
|
2019-07-09 11:40:30 +02:00
|
|
|
return err
|
2019-05-29 09:56:40 +02:00
|
|
|
}
|
|
|
|
|
2021-05-11 07:59:56 +02:00
|
|
|
udpConn, err := net.ListenUDP(network, udpAddr)
|
|
|
|
if err != nil {
|
|
|
|
l.Infoln("Listen (BEP/quic):", err)
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
defer func() { _ = udpConn.Close() }()
|
|
|
|
|
|
|
|
svc, conn := stun.New(t.cfg, t, udpConn)
|
2021-05-10 22:29:27 +02:00
|
|
|
defer conn.Close()
|
2021-05-11 07:59:56 +02:00
|
|
|
|
|
|
|
quicWrapper := quicWrapper{
|
2021-03-05 08:06:37 +01:00
|
|
|
PacketConn: conn,
|
2021-05-11 07:59:56 +02:00
|
|
|
underlying: udpConn,
|
|
|
|
}
|
|
|
|
var wrapped net.PacketConn = &quicWrapper
|
|
|
|
|
|
|
|
if oobConn, ok := conn.(oobConn); ok {
|
|
|
|
l.Debugf("wrapping in oob conn")
|
|
|
|
wrapped = &oobConnWrapper{
|
|
|
|
quicWrapper, oobConn,
|
|
|
|
}
|
2021-03-05 08:06:37 +01:00
|
|
|
}
|
2019-05-29 09:56:40 +02:00
|
|
|
|
2020-11-17 13:19:04 +01:00
|
|
|
go svc.Serve(ctx)
|
2019-05-29 09:56:40 +02:00
|
|
|
|
2021-03-05 08:06:37 +01:00
|
|
|
registry.Register(t.uri.Scheme, wrapped)
|
2021-05-10 22:29:27 +02:00
|
|
|
defer registry.Unregister(t.uri.Scheme, wrapped)
|
2019-05-29 09:56:40 +02:00
|
|
|
|
2021-03-05 08:06:37 +01:00
|
|
|
listener, err := quic.Listen(wrapped, t.tlsCfg, quicConfig)
|
2019-05-29 09:56:40 +02:00
|
|
|
if err != nil {
|
|
|
|
l.Infoln("Listen (BEP/quic):", err)
|
2019-07-09 11:40:30 +02:00
|
|
|
return err
|
2019-05-29 09:56:40 +02:00
|
|
|
}
|
2021-05-10 22:29:27 +02:00
|
|
|
defer listener.Close()
|
|
|
|
|
2020-05-11 15:02:22 +02:00
|
|
|
t.notifyAddressesChanged(t)
|
2021-05-10 22:29:27 +02:00
|
|
|
defer t.clearAddresses(t)
|
2019-05-29 09:56:40 +02:00
|
|
|
|
2021-05-11 07:59:56 +02:00
|
|
|
l.Infof("QUIC listener (%v) starting", udpConn.LocalAddr())
|
|
|
|
defer l.Infof("QUIC listener (%v) shutting down", udpConn.LocalAddr())
|
2021-05-10 22:29:27 +02:00
|
|
|
|
2021-05-10 16:44:47 +02:00
|
|
|
t.mut.Lock()
|
2021-05-11 07:59:56 +02:00
|
|
|
t.laddr = udpConn.LocalAddr()
|
2021-05-10 16:44:47 +02:00
|
|
|
t.mut.Unlock()
|
|
|
|
defer func() {
|
|
|
|
t.mut.Lock()
|
|
|
|
t.laddr = nil
|
|
|
|
t.mut.Unlock()
|
|
|
|
}()
|
2019-05-29 09:56:40 +02:00
|
|
|
|
2019-10-18 09:55:37 +02:00
|
|
|
acceptFailures := 0
|
|
|
|
const maxAcceptFailures = 10
|
|
|
|
|
2019-05-29 09:56:40 +02:00
|
|
|
for {
|
|
|
|
select {
|
2019-08-23 10:15:52 +02:00
|
|
|
case <-ctx.Done():
|
2020-11-17 13:19:04 +01:00
|
|
|
return ctx.Err()
|
2019-05-29 09:56:40 +02:00
|
|
|
default:
|
|
|
|
}
|
2019-08-23 10:15:52 +02:00
|
|
|
|
|
|
|
session, err := listener.Accept(ctx)
|
|
|
|
if err == context.Canceled {
|
|
|
|
return nil
|
|
|
|
} else if err != nil {
|
2019-10-18 09:55:37 +02:00
|
|
|
l.Infoln("Listen (BEP/quic): Accepting connection:", err)
|
|
|
|
|
|
|
|
acceptFailures++
|
|
|
|
if acceptFailures > maxAcceptFailures {
|
|
|
|
// Return to restart the listener, because something
|
|
|
|
// seems permanently damaged.
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
|
|
|
// Slightly increased delay for each failure.
|
|
|
|
time.Sleep(time.Duration(acceptFailures) * time.Second)
|
|
|
|
|
2019-05-29 09:56:40 +02:00
|
|
|
continue
|
|
|
|
}
|
2019-10-18 09:55:37 +02:00
|
|
|
|
|
|
|
acceptFailures = 0
|
|
|
|
|
2019-05-29 09:56:40 +02:00
|
|
|
l.Debugln("connect from", session.RemoteAddr())
|
|
|
|
|
2019-08-23 10:15:52 +02:00
|
|
|
streamCtx, cancel := context.WithTimeout(ctx, quicOperationTimeout)
|
|
|
|
stream, err := session.AcceptStream(streamCtx)
|
|
|
|
cancel()
|
2019-05-29 09:56:40 +02:00
|
|
|
if err != nil {
|
2019-08-23 10:15:52 +02:00
|
|
|
l.Debugf("failed to accept stream from %s: %v", session.RemoteAddr(), err)
|
2020-05-01 09:14:28 +02:00
|
|
|
_ = session.CloseWithError(1, err.Error())
|
2019-05-29 09:56:40 +02:00
|
|
|
continue
|
|
|
|
}
|
|
|
|
|
2021-01-05 17:45:07 +01:00
|
|
|
t.conns <- newInternalConn(&quicTlsConn{session, stream, nil}, connTypeQUICServer, quicPriority)
|
2019-05-29 09:56:40 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func (t *quicListener) URI() *url.URL {
|
|
|
|
return t.uri
|
|
|
|
}
|
|
|
|
|
|
|
|
func (t *quicListener) WANAddresses() []*url.URL {
|
|
|
|
t.mut.Lock()
|
2021-05-10 16:44:47 +02:00
|
|
|
uris := []*url.URL{maybeReplacePort(t.uri, t.laddr)}
|
2019-05-29 09:56:40 +02:00
|
|
|
if t.address != nil {
|
|
|
|
uris = append(uris, t.address)
|
|
|
|
}
|
|
|
|
t.mut.Unlock()
|
|
|
|
return uris
|
|
|
|
}
|
|
|
|
|
|
|
|
func (t *quicListener) LANAddresses() []*url.URL {
|
2021-05-10 16:44:47 +02:00
|
|
|
t.mut.Lock()
|
|
|
|
uri := maybeReplacePort(t.uri, t.laddr)
|
|
|
|
t.mut.Unlock()
|
|
|
|
addrs := []*url.URL{uri}
|
2021-07-10 13:53:51 +02:00
|
|
|
network := quicNetwork(uri)
|
2021-05-10 16:44:47 +02:00
|
|
|
addrs = append(addrs, getURLsForAllAdaptersIfUnspecified(network, uri)...)
|
2020-08-25 11:48:14 +02:00
|
|
|
return addrs
|
2019-05-29 09:56:40 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
func (t *quicListener) String() string {
|
|
|
|
return t.uri.String()
|
|
|
|
}
|
|
|
|
|
|
|
|
func (t *quicListener) Factory() listenerFactory {
|
|
|
|
return t.factory
|
|
|
|
}
|
|
|
|
|
|
|
|
func (t *quicListener) NATType() string {
|
|
|
|
v := t.nat.Load().(stun.NATType)
|
|
|
|
if v == stun.NATUnknown || v == stun.NATError {
|
|
|
|
return "unknown"
|
|
|
|
}
|
|
|
|
return v.String()
|
|
|
|
}
|
|
|
|
|
|
|
|
type quicListenerFactory struct{}
|
|
|
|
|
|
|
|
func (f *quicListenerFactory) Valid(config.Configuration) error {
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
|
|
|
func (f *quicListenerFactory) New(uri *url.URL, cfg config.Wrapper, tlsCfg *tls.Config, conns chan internalConn, natService *nat.Service) genericListener {
|
|
|
|
l := &quicListener{
|
|
|
|
uri: fixupPort(uri, config.DefaultQUICPort),
|
|
|
|
cfg: cfg,
|
|
|
|
tlsCfg: tlsCfg,
|
|
|
|
conns: conns,
|
|
|
|
factory: f,
|
|
|
|
}
|
2020-12-22 20:17:14 +01:00
|
|
|
l.ServiceWithError = svcutil.AsService(l.serve, l.String())
|
2019-05-29 09:56:40 +02:00
|
|
|
l.nat.Store(stun.NATUnknown)
|
|
|
|
return l
|
|
|
|
}
|
|
|
|
|
|
|
|
func (quicListenerFactory) Enabled(cfg config.Configuration) bool {
|
|
|
|
return true
|
|
|
|
}
|
2021-03-05 08:06:37 +01:00
|
|
|
|
2021-05-11 07:59:56 +02:00
|
|
|
// quicWrapper provides methods used by quic
|
|
|
|
// https://github.com/lucas-clemente/quic-go/blob/master/packet_handler_map.go#L85
|
|
|
|
type quicWrapper struct {
|
2021-03-05 08:06:37 +01:00
|
|
|
net.PacketConn
|
|
|
|
underlying *net.UDPConn
|
|
|
|
}
|
|
|
|
|
2021-05-11 07:59:56 +02:00
|
|
|
// SetReadBuffer is required by QUIC
|
|
|
|
func (s *quicWrapper) SetReadBuffer(size int) error {
|
2021-03-05 08:06:37 +01:00
|
|
|
return s.underlying.SetReadBuffer(size)
|
|
|
|
}
|
2021-04-13 13:59:58 +02:00
|
|
|
|
2021-05-11 07:59:56 +02:00
|
|
|
// SyscallConn is required by QUIC
|
|
|
|
func (s *quicWrapper) SyscallConn() (syscall.RawConn, error) {
|
2021-04-13 13:59:58 +02:00
|
|
|
return s.underlying.SyscallConn()
|
|
|
|
}
|
2021-05-11 07:59:56 +02:00
|
|
|
|
|
|
|
// oobConn is used to assert that stun package returned a net.PacketConn that implements this interface.
|
|
|
|
// If it does, we then wrap quicWrapper in oobConnWrapper, to expose those methods to QUIC package.
|
|
|
|
type oobConn interface {
|
|
|
|
ReadMsgUDP(b, oob []byte) (n, oobn, flags int, addr *net.UDPAddr, err error)
|
|
|
|
WriteMsgUDP(b, oob []byte, addr *net.UDPAddr) (n, oobn int, err error)
|
|
|
|
}
|
|
|
|
|
|
|
|
// See: https://pkg.go.dev/github.com/lucas-clemente/quic-go#OOBCapablePacketConn
|
|
|
|
type oobConnWrapper struct {
|
|
|
|
quicWrapper
|
|
|
|
oobConn
|
|
|
|
}
|