gbn: change implication of processNACK signature

The processNACK function returns two booleans as its signature.
The first boolean used to only indicate if the NACK was part of the
queue, but is with this commit expanded to indicate if the queue needs
to be resent or not as a result of the NACK.

The second boolean indicates if the queue sequence base was bumped or
not. Previously, the bumped value for processNACK didn't accurately
reflect if the queue sequence base was actually bumped or not for the
cases when we didn't trigger a resend. This commit addresses that issue.
Updating the bumped value to be correct has no real impact on the
current implementation of the gbn conn, but it might start having an
effect if the implementation is modified in the future.

Author: ViktorTigerstrom

gbn/gbn_conn.go

@@ -582,15 +582,12 @@ func (g *GoBackNConn) receivePacketsForever() error { // nolint:gocyclo
 			// sent was dropped, or maybe we sent a duplicate
 			// message. The NACK message contains the sequence
 			// number that the receiver was expecting.
-			inQueue, bumped := g.sendQueue.processNACK(m.Seq)
-
-			// If the NACK sequence number is not in our queue
-			// then we ignore it. We must have received the ACK
-			// for the sequence number in the meantime.
-			if !inQueue {
-				g.log.Tracef("NACK seq %d is not in the "+
-					"queue. Ignoring", m.Seq)
+			shouldResend, bumped := g.sendQueue.processNACK(m.Seq)
 
+			// If we don't need to resend the queue after processing
+			// the NACK, we can continue without sending the resend
+			// signal.
+			if !shouldResend {
 				continue
 			}
 

gbn/queue.go

@@ -188,6 +188,12 @@ func (q *queue) processACK(seq uint8) bool {
 }
 
 // processNACK processes an incoming NACK of a given sequence number.
+// The function returns two booleans. The first boolean is set to true if we
+// should resend the queue after processing the NACK. The second boolean is set
+// to true if the NACK sequence number is a packet in the queue which isn't the
+// queue base, and we therefore don't need to resend any of the packets before
+// the NACK sequence number. This equivalent to receiving the ACKs for the
+// packets before the NACK sequence number.
 func (q *queue) processNACK(seq uint8) (bool, bool) {
 	q.baseMtx.Lock()
 	defer q.baseMtx.Unlock()
@@ -203,11 +209,15 @@ func (q *queue) processNACK(seq uint8) (bool, bool) {
 	// trigger a resend.
 	if seq == q.sequenceTop {
 		q.sequenceBase = q.sequenceTop
-		return true, false
+
+		return false, true
 	}
 
 	// Is the NACKed sequence even in our queue?
 	if !containsSequence(q.sequenceBase, q.sequenceTop, seq) {
+		q.cfg.log.Tracef("NACK seq %d is not in the queue. Ignoring.",
+			seq)
+
 		return false, false
 	}