implement Writing of StopWaitingFrames

frames/stop_waiting_frame.go

@@ -2,6 +2,7 @@ package frames
 
 import (
 	"bytes"
+	"errors"
 
 	"github.com/lucas-clemente/quic-go/protocol"
 	"github.com/lucas-clemente/quic-go/utils"
@@ -10,20 +11,32 @@ import (
 // A StopWaitingFrame in QUIC
 type StopWaitingFrame struct {
 	Entropy      byte
-	LeastUnackedDelta uint64
+	LeastUnacked protocol.PacketNumber
 }
 
 func (f *StopWaitingFrame) Write(b *bytes.Buffer, packetNumber protocol.PacketNumber, packetNumberLen uint8) error {
-	panic("StopWaitingFrame: Write not yet implemented")
+	// packetNumber is the packet number of the packet that this StopWaitingFrame will be sent with
+	typeByte := uint8(0x06)
+	b.WriteByte(typeByte)
+
+	b.WriteByte(f.Entropy)
+
+	if f.LeastUnacked > packetNumber {
+		return errors.New("StopWaitingFrame: LeastUnacked can't be greater than the packet number")
+	}
+	leastUnackedDelta := uint64(packetNumber - f.LeastUnacked)
+
+	utils.WriteUint48(b, leastUnackedDelta)
+	return nil
 }
 
 // MaxLength of a written frame
 func (f *StopWaitingFrame) MaxLength() int {
-	panic("StopWaitingFrame: Write not yet implemented")
+	return 1 + 1 + 6
 }
 
 // ParseStopWaitingFrame parses a StopWaiting frame
-func ParseStopWaitingFrame(r *bytes.Reader, packetNumberLen uint8) (*StopWaitingFrame, error) {
+func ParseStopWaitingFrame(r *bytes.Reader, packetNumber protocol.PacketNumber, packetNumberLen uint8) (*StopWaitingFrame, error) {
 	frame := &StopWaitingFrame{}
 
 	// read the TypeByte
@@ -37,10 +50,16 @@ func ParseStopWaitingFrame(r *bytes.Reader, packetNumberLen uint8) (*StopWaiting
 		return nil, err
 	}
 
-	frame.LeastUnackedDelta, err = utils.ReadUintN(r, packetNumberLen)
+	leastUnackedDelta, err := utils.ReadUintN(r, packetNumberLen)
 	if err != nil {
 		return nil, err
 	}
 
+	if leastUnackedDelta > uint64(packetNumber) {
+		return nil, errors.New("StopWaitingFrame: Invalid LeastUnackedDelta")
+	}
+
+	frame.LeastUnacked = protocol.PacketNumber(uint64(packetNumber) - leastUnackedDelta)
+
 	return frame, nil
 }

frames/stop_waiting_frame_test.go

@@ -3,19 +3,56 @@ package frames
 import (
 	"bytes"
 
+	"github.com/lucas-clemente/quic-go/protocol"
 	. "github.com/onsi/ginkgo"
 	. "github.com/onsi/gomega"
 )
 
-var _ = Describe("StreamFrame", func() {
-	Context("stream frames", func() {
+var _ = Describe("StopWaitingFrame", func() {
+	Context("stop waiting frames", func() {
 		Context("when parsing", func() {
 			It("accepts sample frame", func() {
 				b := bytes.NewReader([]byte{0x06, 0xA4, 0x03})
-				frame, err := ParseStopWaitingFrame(b, 1)
+				frame, err := ParseStopWaitingFrame(b, 5, 1)
 				Expect(err).ToNot(HaveOccurred())
 				Expect(frame.Entropy).To(Equal(byte(0xA4)))
-				Expect(frame.LeastUnackedDelta).To(Equal(uint64(0x03)))
+				Expect(frame.LeastUnacked).To(Equal(protocol.PacketNumber(2)))
+			})
+
+			It("rejects frames with an invalid LeastUnackedDelta", func() {
+				b := bytes.NewReader([]byte{0x06, 0xA4, 0xD})
+				_, err := ParseStopWaitingFrame(b, 10, 1)
+				Expect(err).To(HaveOccurred())
+			})
+		})
+
+		Context("when writing", func() {
+			It("writes a sample frame", func() {
+				b := &bytes.Buffer{}
+				packetNumber := protocol.PacketNumber(13)
+				frame := &StopWaitingFrame{
+					LeastUnacked: 10,
+					Entropy:      0xE,
+				}
+				frame.Write(b, packetNumber, 6)
+				Expect(b.Bytes()[0]).To(Equal(uint8(0x06)))
+				// todo: check more
+			})
+		})
+
+		Context("self consistency", func() {
+			It("reads a stop waiting frame that it wrote", func() {
+				packetNumber := protocol.PacketNumber(13)
+				frame := &StopWaitingFrame{
+					LeastUnacked: 10,
+					Entropy:      0xE,
+				}
+				b := &bytes.Buffer{}
+				frame.Write(b, packetNumber, 6)
+				readframe, err := ParseStopWaitingFrame(bytes.NewReader(b.Bytes()), packetNumber, 6)
+				Expect(err).ToNot(HaveOccurred())
+				Expect(readframe.Entropy).To(Equal(frame.Entropy))
+				Expect(readframe.LeastUnacked).To(Equal(frame.LeastUnacked))
 			})
 		})
 	})

packet_unpacker.go

@@ -68,7 +68,7 @@ ReadLoop:
 				_, err = r.Read(p)
 				frame = nil
 			case 0x06:
-				frame, err = frames.ParseStopWaitingFrame(r, publicHeader.PacketNumberLen)
+				frame, err = frames.ParseStopWaitingFrame(r, publicHeader.PacketNumber, publicHeader.PacketNumberLen)
 			case 0x07:
 				// PING, do nothing
 				r.ReadByte()

packet_unpacker_test.go

@@ -23,7 +23,7 @@ var _ = Describe("Packet unpacker", func() {
 	BeforeEach(func() {
 		aead = &crypto.NullAEAD{}
 		hdr = &PublicHeader{
-			PacketNumber:    1,
+			PacketNumber:    10,
 			PacketNumberLen: 1,
 		}
 		hdrBin = []byte{0x04, 0x4c, 0x01}
@@ -151,7 +151,7 @@ var _ = Describe("Packet unpacker", func() {
 		Expect(packet.frames).To(Equal([]frames.Frame{
 			&frames.StopWaitingFrame{
 				Entropy:      0xA4,
-				LeastUnackedDelta: 0x03,
+				LeastUnacked: 7,
 			},
 		}))
 	})