wireguard-go/src/device.go

137 lines
3 KiB
Go
Raw Normal View History

package main
import (
"net"
"runtime"
"sync"
)
type Device struct {
mtu int
log *Logger // collection of loggers for levels
idCounter uint // for assigning debug ids to peers
fwMark uint32
net struct {
// seperate for performance reasons
mutex sync.RWMutex
addr *net.UDPAddr // UDP source address
conn *net.UDPConn // UDP "connection"
}
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
inbound chan []byte // inbound queue for TUN
}
signal struct {
stop chan struct{}
}
peers map[NoisePublicKey]*Peer
mac MacStateDevice
2017-06-01 19:31:30 +00:00
}
2017-06-24 13:34:17 +00:00
func (device *Device) SetPrivateKey(sk NoisePrivateKey) {
device.mutex.Lock()
defer device.mutex.Unlock()
// update key material
device.privateKey = sk
device.publicKey = sk.publicKey()
2017-06-27 15:33:06 +00:00
device.mac.Init(device.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
for _, peer := range device.peers {
h := &peer.handshake
h.mutex.Lock()
h.precomputedStaticStatic = device.privateKey.sharedSecret(h.remoteStatic)
h.mutex.Unlock()
2017-06-23 11:41:59 +00:00
}
}
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)
2017-07-01 21:29:22 +00:00
device.mtu = tun.MTU()
2017-06-24 13:34:17 +00:00
device.peers = make(map[NoisePublicKey]*Peer)
device.indices.Init()
device.routingTable.Reset()
// listen
device.net.mutex.Lock()
device.net.conn, _ = net.ListenUDP("udp", device.net.addr)
addr := device.net.conn.LocalAddr()
device.net.addr, _ = net.ResolveUDPAddr(addr.Network(), addr.String())
device.net.mutex.Unlock()
// create queues
device.queue.encryption = make(chan *QueueOutboundElement, QueueOutboundSize)
2017-07-01 21:29:22 +00:00
device.queue.handshake = make(chan QueueHandshakeElement, QueueHandshakeSize)
device.queue.decryption = make(chan *QueueInboundElement, QueueInboundSize)
// prepare signals
device.signal.stop = make(chan struct{})
// 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(tun)
2017-07-01 21:29:22 +00:00
go device.RoutineReceiveIncomming()
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()
peer, ok := device.peers[key]
2017-06-01 19:31:30 +00:00
if !ok {
return
}
peer.mutex.Lock()
2017-06-24 13:34:17 +00:00
device.routingTable.RemovePeer(peer)
delete(device.peers, key)
peer.Close()
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() {
device.RemoveAllPeers()
2017-07-01 21:29:22 +00:00
close(device.signal.stop)
close(device.queue.encryption)
}