wireguard-go/src/peer.go

106 lines
2.7 KiB
Go
Raw Normal View History

package main
import (
2017-06-26 11:14:02 +00:00
"errors"
2017-06-01 19:31:30 +00:00
"net"
"sync"
"time"
)
const ()
2017-06-26 11:14:02 +00:00
type Peer struct {
id uint
mutex sync.RWMutex
endpoint *net.UDPAddr
persistentKeepaliveInterval uint64
2017-06-26 11:14:02 +00:00
keyPairs KeyPairs
2017-06-24 13:34:17 +00:00
handshake Handshake
device *Device
tx_bytes uint64
rx_bytes uint64
time struct {
lastSend time.Time // last send message
lastHandshake time.Time // last completed handshake
}
signal struct {
newKeyPair chan struct{} // (size 1) : a new key pair was generated
handshakeBegin chan struct{} // (size 1) : request that a new handshake be started ("queue handshake")
handshakeCompleted chan struct{} // (size 1) : handshake completed
flushNonceQueue chan struct{} // (size 1) : empty queued packets
stop chan struct{} // (size 0) : close to stop all goroutines for peer
}
timer struct {
sendKeepalive *time.Timer
handshakeTimeout *time.Timer
}
queue struct {
nonce chan *QueueOutboundElement // nonce / pre-handshake queue
outbound chan *QueueOutboundElement // sequential ordering of work
2017-07-01 21:29:22 +00:00
inbound chan *QueueInboundElement // sequential ordering of work
}
mac MacStatePeer
2017-06-24 13:34:17 +00:00
}
func (device *Device) NewPeer(pk NoisePublicKey) *Peer {
2017-06-26 11:14:02 +00:00
// create peer
peer := new(Peer)
2017-06-26 11:14:02 +00:00
peer.mutex.Lock()
defer peer.mutex.Unlock()
2017-07-01 21:29:22 +00:00
2017-06-27 15:33:06 +00:00
peer.mac.Init(pk)
2017-07-01 21:29:22 +00:00
peer.device = device
peer.timer.sendKeepalive = stoppedTimer()
2017-06-26 11:14:02 +00:00
// assign id for debugging
2017-06-24 13:34:17 +00:00
device.mutex.Lock()
peer.id = device.idCounter
device.idCounter += 1
// map public key
2017-06-26 11:14:02 +00:00
_, ok := device.peers[pk]
if ok {
panic(errors.New("bug: adding existing peer"))
}
device.peers[pk] = peer
2017-06-24 13:34:17 +00:00
device.mutex.Unlock()
2017-06-26 11:14:02 +00:00
// precompute DH
2017-06-24 13:34:17 +00:00
2017-06-26 11:14:02 +00:00
handshake := &peer.handshake
handshake.mutex.Lock()
handshake.remoteStatic = pk
handshake.precomputedStaticStatic = device.privateKey.sharedSecret(handshake.remoteStatic)
handshake.mutex.Unlock()
2017-06-24 13:34:17 +00:00
2017-07-01 21:29:22 +00:00
// prepare queuing
peer.queue.nonce = make(chan *QueueOutboundElement, QueueOutboundSize)
2017-07-01 21:29:22 +00:00
peer.queue.outbound = make(chan *QueueOutboundElement, QueueOutboundSize)
peer.queue.inbound = make(chan *QueueInboundElement, QueueInboundSize)
2017-07-01 21:29:22 +00:00
// prepare signaling
peer.signal.stop = make(chan struct{})
peer.signal.newKeyPair = make(chan struct{}, 1)
peer.signal.handshakeBegin = make(chan struct{}, 1)
peer.signal.handshakeCompleted = make(chan struct{}, 1)
peer.signal.flushNonceQueue = make(chan struct{}, 1)
// outbound pipeline
go peer.RoutineNonce()
go peer.RoutineHandshakeInitiator()
go peer.RoutineSequentialSender()
2017-07-01 21:29:22 +00:00
go peer.RoutineSequentialReceiver()
return peer
}
func (peer *Peer) Close() {
close(peer.signal.stop)
}