Completed initial version of outbound flow

src/peer.go

@@ -10,26 +10,29 @@ import (
 const ()
 
 type Peer struct {
+	id                          uint
 	mutex                       sync.RWMutex
 	endpoint                    *net.UDPAddr
-	persistentKeepaliveInterval time.Duration // 0 = disabled
+	persistentKeepaliveInterval uint64
 	keyPairs                    KeyPairs
 	handshake                   Handshake
 	device                      *Device
 	tx_bytes                    uint64
 	rx_bytes                    uint64
 	time                        struct {
-		lastSend time.Time // last send message
+		lastSend      time.Time // last send message
+		lastHandshake time.Time // last completed handshake
 	}
 	signal struct {
-		newHandshake    chan bool
-		flushNonceQueue chan bool // empty queued packets
-		stopSending     chan bool // stop sending pipeline
-		stopInitiator   chan bool // stop initiator timer
+		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
+		sendKeepalive    *time.Timer
+		handshakeTimeout *time.Timer
 	}
 	queue struct {
 		nonce    chan []byte                // nonce / pre-handshake queue
@@ -39,25 +42,30 @@ type Peer struct {
 }
 
 func (device *Device) NewPeer(pk NoisePublicKey) *Peer {
-	var peer Peer
-
 	// create peer
 
+	peer := new(Peer)
 	peer.mutex.Lock()
+	defer peer.mutex.Unlock()
 	peer.device = device
-	peer.keyPairs.Init()
 	peer.mac.Init(pk)
 	peer.queue.outbound = make(chan *QueueOutboundElement, QueueOutboundSize)
 	peer.queue.nonce = make(chan []byte, QueueOutboundSize)
+	peer.timer.sendKeepalive = StoppedTimer()
+
+	// assign id for debugging
+
+	device.mutex.Lock()
+	peer.id = device.idCounter
+	device.idCounter += 1
 
 	// map public key
 
-	device.mutex.Lock()
 	_, ok := device.peers[pk]
 	if ok {
 		panic(errors.New("bug: adding existing peer"))
 	}
-	device.peers[pk] = &peer
+	device.peers[pk] = peer
 	device.mutex.Unlock()
 
 	// precompute DH
@@ -67,22 +75,24 @@ func (device *Device) NewPeer(pk NoisePublicKey) *Peer {
 	handshake.remoteStatic = pk
 	handshake.precomputedStaticStatic = device.privateKey.sharedSecret(handshake.remoteStatic)
 	handshake.mutex.Unlock()
-	peer.mutex.Unlock()
 
-	// start workers
+	// prepare signaling
 
-	peer.signal.stopSending = make(chan bool, 1)
-	peer.signal.stopInitiator = make(chan bool, 1)
-	peer.signal.newHandshake = make(chan bool, 1)
-	peer.signal.flushNonceQueue = make(chan bool, 1)
+	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()
 
-	return &peer
+	return peer
 }
 
 func (peer *Peer) Close() {
-	peer.signal.stopSending <- true
-	peer.signal.stopInitiator <- true
+	close(peer.signal.stop)
 }