remove Entropy from StopWaitingFrames for QUIC 34

fixes #181

frames/stop_waiting_frame.go

@@ -28,7 +28,9 @@ func (f *StopWaitingFrame) Write(b *bytes.Buffer, version protocol.VersionNumber
 	typeByte := uint8(0x06)
 	b.WriteByte(typeByte)
 
-	b.WriteByte(f.Entropy)
+	if version < protocol.Version34 {
+		b.WriteByte(f.Entropy)
+	}
 
 	// make sure the PacketNumber was set
 	if f.PacketNumber == protocol.PacketNumber(0) {
@@ -59,14 +61,24 @@ func (f *StopWaitingFrame) Write(b *bytes.Buffer, version protocol.VersionNumber
 
 // MinLength of a written frame
 func (f *StopWaitingFrame) MinLength(version protocol.VersionNumber) (protocol.ByteCount, error) {
+	var minLength protocol.ByteCount
+	minLength = 1 // typeByte
+
+	// Entropy Byte
+	if version < protocol.Version34 {
+		minLength++
+	}
+
 	if f.PacketNumberLen == protocol.PacketNumberLenInvalid {
 		return 0, errPacketNumberLenNotSet
 	}
-	return protocol.ByteCount(1 + 1 + f.PacketNumberLen), nil
+	minLength += protocol.ByteCount(f.PacketNumberLen)
+
+	return minLength, nil
 }
 
 // ParseStopWaitingFrame parses a StopWaiting frame
-func ParseStopWaitingFrame(r *bytes.Reader, packetNumber protocol.PacketNumber, packetNumberLen protocol.PacketNumberLen) (*StopWaitingFrame, error) {
+func ParseStopWaitingFrame(r *bytes.Reader, packetNumber protocol.PacketNumber, packetNumberLen protocol.PacketNumberLen, version protocol.VersionNumber) (*StopWaitingFrame, error) {
 	frame := &StopWaitingFrame{}
 
 	// read the TypeByte
@@ -75,9 +87,11 @@ func ParseStopWaitingFrame(r *bytes.Reader, packetNumber protocol.PacketNumber,
 		return nil, err
 	}
 
-	frame.Entropy, err = r.ReadByte()
-	if err != nil {
-		return nil, err
+	if version < protocol.Version34 {
+		frame.Entropy, err = r.ReadByte()
+		if err != nil {
+			return nil, err
+		}
 	}
 
 	leastUnackedDelta, err := utils.ReadUintN(r, uint8(packetNumberLen))

frames/stop_waiting_frame_test.go

@@ -13,7 +13,7 @@ var _ = Describe("StopWaitingFrame", func() {
 		Context("when parsing", func() {
 			It("accepts sample frame", func() {
 				b := bytes.NewReader([]byte{0x06, 0xA4, 0x03})
-				frame, err := ParseStopWaitingFrame(b, 5, 1)
+				frame, err := ParseStopWaitingFrame(b, 5, 1, protocol.Version33)
 				Expect(err).ToNot(HaveOccurred())
 				Expect(frame.Entropy).To(Equal(byte(0xA4)))
 				Expect(frame.LeastUnacked).To(Equal(protocol.PacketNumber(2)))
@@ -21,9 +21,16 @@ var _ = Describe("StopWaitingFrame", func() {
 
 			It("rejects frames with an invalid LeastUnackedDelta", func() {
 				b := bytes.NewReader([]byte{0x06, 0xA4, 0xD})
-				_, err := ParseStopWaitingFrame(b, 10, 1)
+				_, err := ParseStopWaitingFrame(b, 10, 1, protocol.Version33)
 				Expect(err).To(HaveOccurred())
 			})
+
+			It("reads a StopWaitingFrame, for QUIC version 34", func() {
+				b := bytes.NewReader([]byte{0x06, 0x03})
+				frame, err := ParseStopWaitingFrame(b, 5, 1, protocol.Version34)
+				Expect(err).ToNot(HaveOccurred())
+				Expect(frame.LeastUnacked).To(Equal(protocol.PacketNumber(2)))
+			})
 		})
 
 		Context("when writing", func() {
@@ -35,12 +42,24 @@ var _ = Describe("StopWaitingFrame", func() {
 					Entropy:         0xAD,
 					PacketNumberLen: protocol.PacketNumberLen6,
 				}
-				frame.Write(b, 0)
+				frame.Write(b, protocol.Version33)
 				Expect(b.Bytes()[0]).To(Equal(uint8(0x06)))
 				Expect(b.Bytes()[1]).To(Equal(uint8(frame.Entropy)))
 				Expect(b.Bytes()[2:8]).To(Equal([]byte{3, 0, 0, 0, 0, 0}))
 			})
 
+			It("writes a sample frame, for QUIC version 34", func() {
+				b := &bytes.Buffer{}
+				frame := &StopWaitingFrame{
+					LeastUnacked:    10,
+					PacketNumber:    13,
+					PacketNumberLen: protocol.PacketNumberLen6,
+				}
+				frame.Write(b, protocol.Version34)
+				Expect(b.Bytes()[0]).To(Equal(uint8(0x06)))
+				Expect(b.Bytes()[1:7]).To(Equal([]byte{3, 0, 0, 0, 0, 0}))
+			})
+
 			It("errors when PacketNumber was not set", func() {
 				b := &bytes.Buffer{}
 				frame := &StopWaitingFrame{
@@ -132,10 +151,18 @@ var _ = Describe("StopWaitingFrame", func() {
 						LeastUnacked:    10,
 						PacketNumberLen: length,
 					}
-					Expect(frame.MinLength(0)).To(Equal(protocol.ByteCount(length + 2)))
+					Expect(frame.MinLength(protocol.Version33)).To(Equal(protocol.ByteCount(length + 2)))
 				}
 			})
 
+			It("calculates the right minLength, for QUIC version 34", func() {
+				frame := &StopWaitingFrame{
+					LeastUnacked:    10,
+					PacketNumberLen: protocol.PacketNumberLen4,
+				}
+				Expect(frame.MinLength(protocol.Version34)).To(Equal(protocol.ByteCount(4 + 1)))
+			})
+
 			It("errors when packetNumberLen is not set", func() {
 				frame := &StopWaitingFrame{
 					LeastUnacked: 10,
@@ -156,7 +183,7 @@ var _ = Describe("StopWaitingFrame", func() {
 				}
 				b := &bytes.Buffer{}
 				frame.Write(b, 0)
-				readframe, err := ParseStopWaitingFrame(bytes.NewReader(b.Bytes()), packetNumber, protocol.PacketNumberLen4)
+				readframe, err := ParseStopWaitingFrame(bytes.NewReader(b.Bytes()), packetNumber, protocol.PacketNumberLen4, protocol.Version33)
 				Expect(err).ToNot(HaveOccurred())
 				Expect(readframe.Entropy).To(Equal(frame.Entropy))
 				Expect(readframe.LeastUnacked).To(Equal(frame.LeastUnacked))

packet_unpacker.go

@@ -97,7 +97,7 @@ ReadLoop:
 					err = qerr.Error(qerr.InvalidBlockedData, err.Error())
 				}
 			case 0x06:
-				frame, err = frames.ParseStopWaitingFrame(r, hdr.PacketNumber, hdr.PacketNumberLen)
+				frame, err = frames.ParseStopWaitingFrame(r, hdr.PacketNumber, hdr.PacketNumberLen, u.version)
 				if err != nil {
 					err = qerr.Error(qerr.InvalidStopWaitingData, err.Error())
 				}