wireguard-go/src/device.go

216 lines
4.6 KiB
Go
Raw Normal View History

package main
import (
"runtime"
"sync"
"sync/atomic"
"time"
)
type Device struct {
log *Logger // collection of loggers for levels
idCounter uint // for assigning debug ids to peers
fwMark uint32
tun struct {
device TUNDevice
isUp AtomicBool
mtu int32
}
pool struct {
messageBuffers sync.Pool
}
net struct {
2017-08-22 15:22:45 +00:00
mutex sync.RWMutex
2017-11-14 15:27:53 +00:00
bind UDPBind // bind interface
port uint16 // listening port
fwmark uint32 // mark value (0 = disabled)
}
mutex sync.RWMutex
privateKey NoisePrivateKey
publicKey NoisePublicKey
routingTable RoutingTable
indices IndexTable
queue struct {
2017-07-01 21:29:22 +00:00
encryption chan *QueueOutboundElement
decryption chan *QueueInboundElement
handshake chan QueueHandshakeElement
}
signal struct {
2017-11-11 14:43:55 +00:00
stop chan struct{}
}
underLoadUntil atomic.Value
ratelimiter Ratelimiter
peers map[NoisePublicKey]*Peer
2017-08-14 15:09:25 +00:00
mac CookieChecker
2017-06-01 19:31:30 +00:00
}
/* Warning:
* The caller must hold the device mutex (write lock)
*/
func removePeerUnsafe(device *Device, key NoisePublicKey) {
peer, ok := device.peers[key]
if !ok {
return
}
peer.mutex.Lock()
device.routingTable.RemovePeer(peer)
delete(device.peers, key)
peer.Close()
}
func (device *Device) IsUnderLoad() bool {
// check if currently under load
now := time.Now()
underLoad := len(device.queue.handshake) >= UnderLoadQueueSize
if underLoad {
device.underLoadUntil.Store(now.Add(time.Second))
return true
}
// check if recently under load
until := device.underLoadUntil.Load().(time.Time)
return until.After(now)
}
2017-08-04 14:15:53 +00:00
func (device *Device) SetPrivateKey(sk NoisePrivateKey) error {
2017-06-24 13:34:17 +00:00
device.mutex.Lock()
defer device.mutex.Unlock()
// remove peers with matching public keys
2017-08-04 14:15:53 +00:00
publicKey := sk.publicKey()
for key, peer := range device.peers {
2017-08-04 14:15:53 +00:00
h := &peer.handshake
h.mutex.RLock()
if h.remoteStatic.Equals(publicKey) {
removePeerUnsafe(device, key)
2017-08-04 14:15:53 +00:00
}
h.mutex.RUnlock()
}
2017-06-24 13:34:17 +00:00
// update key material
device.privateKey = sk
2017-08-04 14:15:53 +00:00
device.publicKey = publicKey
device.mac.Init(publicKey)
2017-06-24 13:34:17 +00:00
2017-06-27 15:33:06 +00:00
// do DH precomputations
2017-06-24 13:34:17 +00:00
rmKey := device.privateKey.IsZero()
2017-08-04 14:15:53 +00:00
for key, peer := range device.peers {
2017-06-24 13:34:17 +00:00
h := &peer.handshake
h.mutex.Lock()
if rmKey {
2017-08-04 14:15:53 +00:00
h.precomputedStaticStatic = [NoisePublicKeySize]byte{}
} else {
h.precomputedStaticStatic = device.privateKey.sharedSecret(h.remoteStatic)
if isZero(h.precomputedStaticStatic[:]) {
removePeerUnsafe(device, key)
}
2017-08-04 14:15:53 +00:00
}
2017-06-24 13:34:17 +00:00
h.mutex.Unlock()
2017-06-23 11:41:59 +00:00
}
2017-08-04 14:15:53 +00:00
return nil
2017-06-23 11:41:59 +00:00
}
func (device *Device) GetMessageBuffer() *[MaxMessageSize]byte {
return device.pool.messageBuffers.Get().(*[MaxMessageSize]byte)
}
func (device *Device) PutMessageBuffer(msg *[MaxMessageSize]byte) {
device.pool.messageBuffers.Put(msg)
}
func NewDevice(tun TUNDevice, logLevel int) *Device {
device := new(Device)
2017-06-24 13:34:17 +00:00
device.mutex.Lock()
defer device.mutex.Unlock()
device.log = NewLogger(logLevel, "("+tun.Name()+") ")
2017-06-24 13:34:17 +00:00
device.peers = make(map[NoisePublicKey]*Peer)
device.tun.device = tun
2017-06-24 13:34:17 +00:00
device.indices.Init()
device.ratelimiter.Init()
2017-06-24 13:34:17 +00:00
device.routingTable.Reset()
device.underLoadUntil.Store(time.Time{})
// setup buffer pool
device.pool.messageBuffers = sync.Pool{
New: func() interface{} {
return new([MaxMessageSize]byte)
},
}
// create queues
2017-07-01 21:29:22 +00:00
device.queue.handshake = make(chan QueueHandshakeElement, QueueHandshakeSize)
2017-07-07 11:47:09 +00:00
device.queue.encryption = make(chan *QueueOutboundElement, QueueOutboundSize)
2017-07-01 21:29:22 +00:00
device.queue.decryption = make(chan *QueueInboundElement, QueueInboundSize)
// prepare signals
device.signal.stop = make(chan struct{})
2017-11-11 14:43:55 +00:00
// prepare net
device.net.port = 0
device.net.bind = nil
// start workers
for i := 0; i < runtime.NumCPU(); i += 1 {
go device.RoutineEncryption()
2017-07-01 21:29:22 +00:00
go device.RoutineDecryption()
go device.RoutineHandshake()
}
go device.RoutineReadFromTUN()
go device.RoutineTUNEventReader()
go device.ratelimiter.RoutineGarbageCollector(device.signal.stop)
return device
2017-06-24 13:34:17 +00:00
}
func (device *Device) LookupPeer(pk NoisePublicKey) *Peer {
device.mutex.RLock()
defer device.mutex.RUnlock()
return device.peers[pk]
}
func (device *Device) RemovePeer(key NoisePublicKey) {
device.mutex.Lock()
defer device.mutex.Unlock()
removePeerUnsafe(device, key)
2017-06-01 19:31:30 +00:00
}
2017-06-24 13:34:17 +00:00
func (device *Device) RemoveAllPeers() {
device.mutex.Lock()
defer device.mutex.Unlock()
2017-06-01 19:31:30 +00:00
2017-06-24 13:34:17 +00:00
for key, peer := range device.peers {
2017-06-01 19:31:30 +00:00
peer.mutex.Lock()
2017-06-24 13:34:17 +00:00
delete(device.peers, key)
peer.Close()
peer.mutex.Unlock()
2017-06-01 19:31:30 +00:00
}
}
func (device *Device) Close() {
2017-11-11 22:26:44 +00:00
device.log.Info.Println("Closing device")
device.RemoveAllPeers()
2017-07-01 21:29:22 +00:00
close(device.signal.stop)
CloseUDPListener(device)
2017-11-11 22:26:44 +00:00
device.tun.device.Close()
}
2017-08-01 10:14:38 +00:00
func (device *Device) WaitChannel() chan struct{} {
return device.signal.stop
}