mirror of
https://github.com/tailscale/tailscale.git
synced 2024-11-26 03:25:35 +00:00
69cdc30c6d
We don't use the port that wireguard-go passes to us (via magicsock.connBind.Open).
We ignore it entirely and use the port we selected.
When we tell wireguard-go that we're changing the listen_port,
it calls connBind.Close and then connBind.Open.
And in the meantime, it stops calling the receive functions,
which means that we stop receiving and processing UDP and DERP packets.
And that is Very Bad.
That was never a problem prior to b3ceca1dd7,
because we passed the SkipBindUpdate flag to our wireguard-go fork,
which told wireguard-go not to re-bind on listen_port changes.
That commit eliminated the SkipBindUpdate flag.
We could write a bunch of code to work around the gap.
We could add background readers that process UDP and DERP packets when wireguard-go isn't.
But it's simpler to never create the conditions in which wireguard-go rebinds.
The other scenario in which wireguard-go re-binds is device.Down.
Conveniently, we never call device.Down. We go from device.Up to device.Close,
and the latter only when we're shutting down a magicsock.Conn completely.
Rubber-ducked-by: Avery Pennarun <apenwarr@tailscale.com>
Signed-off-by: Josh Bleecher Snyder <josh@tailscale.com>
72 lines
1.9 KiB
Go
72 lines
1.9 KiB
Go
// Copyright (c) 2021 Tailscale Inc & AUTHORS All rights reserved.
|
|
// Use of this source code is governed by a BSD-style
|
|
// license that can be found in the LICENSE file.
|
|
|
|
// Package wgcfg has types and a parser for representing WireGuard config.
|
|
package wgcfg
|
|
|
|
import (
|
|
"inet.af/netaddr"
|
|
)
|
|
|
|
// EndpointDiscoSuffix is appended to the hex representation of a peer's discovery key
|
|
// and is then the sole wireguard endpoint for peers with a non-zero discovery key.
|
|
// This form is then recognize by magicsock's CreateEndpoint.
|
|
const EndpointDiscoSuffix = ".disco.tailscale:12345"
|
|
|
|
// Config is a WireGuard configuration.
|
|
// It only supports the set of things Tailscale uses.
|
|
type Config struct {
|
|
Name string
|
|
PrivateKey PrivateKey
|
|
Addresses []netaddr.IPPrefix
|
|
MTU uint16
|
|
DNS []netaddr.IP
|
|
Peers []Peer
|
|
}
|
|
|
|
type Peer struct {
|
|
PublicKey Key
|
|
AllowedIPs []netaddr.IPPrefix
|
|
Endpoints string // comma-separated host/port pairs: "1.2.3.4:56,[::]:80"
|
|
PersistentKeepalive uint16
|
|
}
|
|
|
|
// Copy makes a deep copy of Config.
|
|
// The result aliases no memory with the original.
|
|
func (cfg Config) Copy() Config {
|
|
res := cfg
|
|
if res.Addresses != nil {
|
|
res.Addresses = append([]netaddr.IPPrefix{}, res.Addresses...)
|
|
}
|
|
if res.DNS != nil {
|
|
res.DNS = append([]netaddr.IP{}, res.DNS...)
|
|
}
|
|
peers := make([]Peer, 0, len(res.Peers))
|
|
for _, peer := range res.Peers {
|
|
peers = append(peers, peer.Copy())
|
|
}
|
|
res.Peers = peers
|
|
return res
|
|
}
|
|
|
|
// Copy makes a deep copy of Peer.
|
|
// The result aliases no memory with the original.
|
|
func (peer Peer) Copy() Peer {
|
|
res := peer
|
|
if res.AllowedIPs != nil {
|
|
res.AllowedIPs = append([]netaddr.IPPrefix{}, res.AllowedIPs...)
|
|
}
|
|
return res
|
|
}
|
|
|
|
// PeerWithKey returns the Peer with key k and reports whether it was found.
|
|
func (config Config) PeerWithKey(k Key) (Peer, bool) {
|
|
for _, p := range config.Peers {
|
|
if p.PublicKey == k {
|
|
return p, true
|
|
}
|
|
}
|
|
return Peer{}, false
|
|
}
|