force sending of a retransmittable packet every 20 packets

ackhandler/interfaces.go

@@ -15,6 +15,7 @@ type SentPacketHandler interface {
 
 	SendingAllowed() bool
 	GetStopWaitingFrame(force bool) *frames.StopWaitingFrame
+	ShouldSendRetransmittablePacket() bool
 	DequeuePacketForRetransmission() (packet *Packet)
 	GetLeastUnacked() protocol.PacketNumber
 

ackhandler/sent_packet_handler.go

@@ -40,6 +40,8 @@ type sentPacketHandler struct {
 	lastSentPacketNumber protocol.PacketNumber
 	skippedPackets       []protocol.PacketNumber
 
+	numNonRetransmittablePackets int // number of non-retransmittable packets since the last retransmittable packet
+
 	LargestAcked protocol.PacketNumber
 
 	largestReceivedPacketWithAck protocol.PacketNumber
@@ -89,6 +91,10 @@ func (h *sentPacketHandler) largestInOrderAcked() protocol.PacketNumber {
 	return h.LargestAcked
 }
 
+func (h *sentPacketHandler) ShouldSendRetransmittablePacket() bool {
+	return h.numNonRetransmittablePackets >= protocol.MaxNonRetransmittablePackets
+}
+
 func (h *sentPacketHandler) SentPacket(packet *Packet) error {
 	if packet.PacketNumber <= h.lastSentPacketNumber {
 		return errPacketNumberNotIncreasing
@@ -116,6 +122,9 @@ func (h *sentPacketHandler) SentPacket(packet *Packet) error {
 		packet.SendTime = now
 		h.bytesInFlight += packet.Length
 		h.packetHistory.PushBack(*packet)
+		h.numNonRetransmittablePackets = 0
+	} else {
+		h.numNonRetransmittablePackets++
 	}
 
 	h.congestion.OnPacketSent(

ackhandler/sent_packet_handler_test.go

@@ -61,6 +61,10 @@ func retransmittablePacket(num protocol.PacketNumber) *Packet {
 	return &Packet{PacketNumber: num, Length: 1, Frames: []frames.Frame{&frames.PingFrame{}}}
 }
 
+func nonRetransmittablePacket(num protocol.PacketNumber) *Packet {
+	return &Packet{PacketNumber: num, Length: 1, Frames: []frames.Frame{&frames.AckFrame{}}}
+}
+
 var _ = Describe("SentPacketHandler", func() {
 	var (
 		handler     *sentPacketHandler
@@ -222,6 +226,30 @@ var _ = Describe("SentPacketHandler", func() {
 		})
 	})
 
+	Context("forcing retransmittable packets", func() {
+		It("says that every 20th packet should be retransmittable", func() {
+			// send 19 non-retransmittable packets
+			for i := 1; i <= protocol.MaxNonRetransmittablePackets; i++ {
+				Expect(handler.ShouldSendRetransmittablePacket()).To(BeFalse())
+				err := handler.SentPacket(nonRetransmittablePacket(protocol.PacketNumber(i)))
+				Expect(err).ToNot(HaveOccurred())
+			}
+			Expect(handler.ShouldSendRetransmittablePacket()).To(BeTrue())
+		})
+
+		It("resets the counter when a retransmittable packet is sent", func() {
+			// send 19 non-retransmittable packets
+			for i := 1; i <= protocol.MaxNonRetransmittablePackets; i++ {
+				Expect(handler.ShouldSendRetransmittablePacket()).To(BeFalse())
+				err := handler.SentPacket(nonRetransmittablePacket(protocol.PacketNumber(i)))
+				Expect(err).ToNot(HaveOccurred())
+			}
+			err := handler.SentPacket(retransmittablePacket(20))
+			Expect(err).ToNot(HaveOccurred())
+			Expect(handler.ShouldSendRetransmittablePacket()).To(BeFalse())
+		})
+	})
+
 	Context("DoS mitigation", func() {
 		It("checks the size of the packet history, for unacked packets", func() {
 			i := protocol.PacketNumber(1)