move the packet number generator to the ackhandler package

internal/ackhandler/interfaces.go

@@ -30,6 +30,9 @@ type SentPacketHandler interface {
 	GetLowestPacketNotConfirmedAcked() protocol.PacketNumber
 	DequeuePacketForRetransmission() *Packet
 	DequeueProbePacket() (*Packet, error)
+
+	PeekPacketNumber() protocol.PacketNumber
+	PopPacketNumber() protocol.PacketNumber
 	GetPacketNumberLen(protocol.PacketNumber) protocol.PacketNumberLen
 
 	GetAlarmTimeout() time.Time

internal/ackhandler/packet_number_generator.go

@@ -0,0 +1,62 @@
+package ackhandler
+
+import (
+	"crypto/rand"
+	"math"
+
+	"github.com/lucas-clemente/quic-go/internal/protocol"
+)
+
+// The packetNumberGenerator generates the packet number for the next packet
+// it randomly skips a packet number every averagePeriod packets (on average)
+// it is guarantued to never skip two consecutive packet numbers
+type packetNumberGenerator struct {
+	averagePeriod protocol.PacketNumber
+
+	next       protocol.PacketNumber
+	nextToSkip protocol.PacketNumber
+}
+
+func newPacketNumberGenerator(initial, averagePeriod protocol.PacketNumber) *packetNumberGenerator {
+	g := &packetNumberGenerator{
+		next:          initial,
+		averagePeriod: averagePeriod,
+	}
+	g.generateNewSkip()
+	return g
+}
+
+func (p *packetNumberGenerator) Peek() protocol.PacketNumber {
+	return p.next
+}
+
+func (p *packetNumberGenerator) Pop() protocol.PacketNumber {
+	next := p.next
+
+	// generate a new packet number for the next packet
+	p.next++
+
+	if p.next == p.nextToSkip {
+		p.next++
+		p.generateNewSkip()
+	}
+
+	return next
+}
+
+func (p *packetNumberGenerator) generateNewSkip() {
+	num := p.getRandomNumber()
+	skip := protocol.PacketNumber(num) * (p.averagePeriod - 1) / (math.MaxUint16 / 2)
+	// make sure that there are never two consecutive packet numbers that are skipped
+	p.nextToSkip = p.next + 2 + skip
+}
+
+// getRandomNumber() generates a cryptographically secure random number between 0 and MaxUint16 (= 65535)
+// The expectation value is 65535/2
+func (p *packetNumberGenerator) getRandomNumber() uint16 {
+	b := make([]byte, 2)
+	rand.Read(b) // ignore the error here
+
+	num := uint16(b[0])<<8 + uint16(b[1])
+	return num
+}

internal/ackhandler/packet_number_generator_test.go

@@ -0,0 +1,100 @@
+package ackhandler
+
+import (
+	"math"
+
+	"github.com/lucas-clemente/quic-go/internal/protocol"
+	. "github.com/onsi/ginkgo"
+	. "github.com/onsi/gomega"
+)
+
+var _ = Describe("Packet Number Generator", func() {
+	var png *packetNumberGenerator
+
+	BeforeEach(func() {
+		png = newPacketNumberGenerator(1, 100)
+	})
+
+	It("can be initialized to return any first packet number", func() {
+		png = newPacketNumberGenerator(12345, 100)
+		Expect(png.Pop()).To(Equal(protocol.PacketNumber(12345)))
+	})
+
+	It("gets 1 as the first packet number", func() {
+		num := png.Pop()
+		Expect(num).To(Equal(protocol.PacketNumber(1)))
+	})
+
+	It("allows peeking", func() {
+		png.nextToSkip = 1000
+		Expect(png.Peek()).To(Equal(protocol.PacketNumber(1)))
+		Expect(png.Peek()).To(Equal(protocol.PacketNumber(1)))
+		num := png.Pop()
+		Expect(num).To(Equal(protocol.PacketNumber(1)))
+		Expect(png.Peek()).To(Equal(protocol.PacketNumber(2)))
+		Expect(png.Peek()).To(Equal(protocol.PacketNumber(2)))
+	})
+
+	It("skips a packet number", func() {
+		var last protocol.PacketNumber
+		var skipped bool
+		for i := 0; i < 1000; i++ {
+			num := png.Pop()
+			if num > last+1 {
+				skipped = true
+				break
+			}
+			last = num
+		}
+		Expect(skipped).To(BeTrue())
+	})
+
+	It("skips a specific packet number", func() {
+		png.nextToSkip = 2
+		num := png.Pop()
+		Expect(num).To(Equal(protocol.PacketNumber(1)))
+		Expect(png.Peek()).To(Equal(protocol.PacketNumber(3)))
+		num = png.Pop()
+		Expect(num).To(Equal(protocol.PacketNumber(3)))
+	})
+
+	It("generates a new packet number to skip", func() {
+		png.next = 100
+		png.averagePeriod = 100
+
+		rep := 5000
+		var sum protocol.PacketNumber
+
+		for i := 0; i < rep; i++ {
+			png.generateNewSkip()
+			Expect(png.nextToSkip).ToNot(Equal(protocol.PacketNumber(101)))
+			sum += png.nextToSkip
+		}
+
+		average := sum / protocol.PacketNumber(rep)
+		Expect(average).To(BeNumerically("==", protocol.PacketNumber(200), 4))
+	})
+
+	It("uses random numbers", func() {
+		var smallest uint16 = math.MaxUint16
+		var largest uint16
+		var sum uint64
+
+		rep := 10000
+
+		for i := 0; i < rep; i++ {
+			num := png.getRandomNumber()
+			sum += uint64(num)
+			if num > largest {
+				largest = num
+			}
+			if num < smallest {
+				smallest = num
+			}
+		}
+
+		Expect(smallest).To(BeNumerically("<", 300))
+		Expect(largest).To(BeNumerically(">", math.MaxUint16-300))
+		Expect(sum / uint64(rep)).To(BeNumerically("==", uint64(math.MaxUint16/2), 1000))
+	})
+})

internal/ackhandler/sent_packet_handler.go

@@ -30,7 +30,9 @@ const (
 )
 
 type sentPacketHandler struct {
-	lastSentPacketNumber              protocol.PacketNumber
+	lastSentPacketNumber  protocol.PacketNumber
+	packetNumberGenerator *packetNumberGenerator
+
 	lastSentRetransmittablePacketTime time.Time
 	lastSentHandshakePacketTime       time.Time
 
@@ -89,11 +91,12 @@ func NewSentPacketHandler(rttStats *congestion.RTTStats, logger utils.Logger, ve
 	)
 
 	return &sentPacketHandler{
-		packetHistory: newSentPacketHistory(),
-		rttStats:      rttStats,
-		congestion:    congestion,
-		logger:        logger,
-		version:       version,
+		packetNumberGenerator: newPacketNumberGenerator(1, protocol.SkipPacketAveragePeriodLength),
+		packetHistory:         newSentPacketHistory(),
+		rttStats:              rttStats,
+		congestion:            congestion,
+		logger:                logger,
+		version:               version,
 	}
 }
 
@@ -518,6 +521,14 @@ func (h *sentPacketHandler) DequeueProbePacket() (*Packet, error) {
 	return h.DequeuePacketForRetransmission(), nil
 }
 
+func (h *sentPacketHandler) PeekPacketNumber() protocol.PacketNumber {
+	return h.packetNumberGenerator.Peek()
+}
+
+func (h *sentPacketHandler) PopPacketNumber() protocol.PacketNumber {
+	return h.packetNumberGenerator.Pop()
+}
+
 func (h *sentPacketHandler) GetPacketNumberLen(p protocol.PacketNumber) protocol.PacketNumberLen {
 	return protocol.GetPacketNumberLengthForHeader(p, h.lowestUnacked(), h.version)
 }