From 33c0f3a5df1f6fecad21d5e73d1a8bbb4cff627e Mon Sep 17 00:00:00 2001 From: Marten Seemann Date: Thu, 12 May 2016 13:05:42 +0700 Subject: [PATCH] set LeastUnackedDelta length in StopWaitingFrame fixes #79 --- ackhandler/stop_waiting_manager.go | 2 +- frames/ack_frame.go | 4 +- frames/blocked_frame.go | 4 +- frames/connection_close_frame.go | 4 +- frames/frame.go | 2 +- frames/ping_frame.go | 4 +- frames/rst_stream_frame.go | 2 +- frames/stop_waiting_frame.go | 34 ++++++++-- frames/stop_waiting_frame_test.go | 104 +++++++++++++++++++++++++++-- frames/stream_frame.go | 9 +-- frames/stream_frame_test.go | 13 ++-- frames/window_update_frame.go | 2 +- packet_packer.go | 29 ++++---- packet_packer_test.go | 23 +++++-- protocol/protocol.go | 2 + 15 files changed, 187 insertions(+), 51 deletions(-) diff --git a/ackhandler/stop_waiting_manager.go b/ackhandler/stop_waiting_manager.go index bd265a5d7..947541ff9 100644 --- a/ackhandler/stop_waiting_manager.go +++ b/ackhandler/stop_waiting_manager.go @@ -30,7 +30,7 @@ func (h *stopWaitingManager) RegisterPacketForRetransmission(packet *Packet) { if h.currentStopWaitingFrame == nil || h.currentStopWaitingFrame.LeastUnacked <= packet.PacketNumber { // <= because for StopWaitingFrames LeastUnacked = packet.PacketNumber + 1 h.currentStopWaitingFrame = &frames.StopWaitingFrame{ LeastUnacked: packet.PacketNumber + 1, - Entropy: byte(packet.Entropy), // TODO: do we have to send out the entropy of this packet or of the next packet, possible fix for #29 + Entropy: byte(packet.Entropy), } h.maxRetransmittedPacketNumber = packet.PacketNumber h.currentStopWaitingFrameSent = false diff --git a/frames/ack_frame.go b/frames/ack_frame.go index c2858a88e..af1a66e74 100644 --- a/frames/ack_frame.go +++ b/frames/ack_frame.go @@ -94,14 +94,14 @@ func (f *AckFrame) Write(b *bytes.Buffer, packetNumber protocol.PacketNumber, ve } // MinLength of a written frame -func (f *AckFrame) MinLength() protocol.ByteCount { +func (f *AckFrame) MinLength() (protocol.ByteCount, error) { l := 1 + 1 + 6 + 2 + 1 + 1 + 4 l += (1 + 2) * 0 /* TODO: num_timestamps */ if f.HasNACK() { l += 1 + (6+1)*len(f.NackRanges) l++ // TODO: Remove once we drop support for <32 } - return protocol.ByteCount(l) + return protocol.ByteCount(l), nil } // HasNACK returns if the frame has NACK ranges diff --git a/frames/blocked_frame.go b/frames/blocked_frame.go index a96a917a4..e5ef653a5 100644 --- a/frames/blocked_frame.go +++ b/frames/blocked_frame.go @@ -26,8 +26,8 @@ func (f *BlockedFrame) Write(b *bytes.Buffer, packetNumber protocol.PacketNumber } // MinLength of a written frame -func (f *BlockedFrame) MinLength() protocol.ByteCount { - return 1 + 4 +func (f *BlockedFrame) MinLength() (protocol.ByteCount, error) { + return 1 + 4, nil } // ParseBlockedFrame parses a BLOCKED frame diff --git a/frames/connection_close_frame.go b/frames/connection_close_frame.go index 1a0967464..3f3a74c0c 100644 --- a/frames/connection_close_frame.go +++ b/frames/connection_close_frame.go @@ -47,8 +47,8 @@ func ParseConnectionCloseFrame(r *bytes.Reader) (*ConnectionCloseFrame, error) { } // MinLength of a written frame -func (f *ConnectionCloseFrame) MinLength() protocol.ByteCount { - return 1 + 4 + 2 + protocol.ByteCount(len(f.ReasonPhrase)) +func (f *ConnectionCloseFrame) MinLength() (protocol.ByteCount, error) { + return 1 + 4 + 2 + protocol.ByteCount(len(f.ReasonPhrase)), nil } // Write writes an CONNECTION_CLOSE frame. diff --git a/frames/frame.go b/frames/frame.go index ebbdc12df..e6237e59e 100644 --- a/frames/frame.go +++ b/frames/frame.go @@ -9,5 +9,5 @@ import ( // A Frame in QUIC type Frame interface { Write(b *bytes.Buffer, packetNumber protocol.PacketNumber, version protocol.VersionNumber) error - MinLength() protocol.ByteCount + MinLength() (protocol.ByteCount, error) } diff --git a/frames/ping_frame.go b/frames/ping_frame.go index 7e66b7b3b..25fd5c3fa 100644 --- a/frames/ping_frame.go +++ b/frames/ping_frame.go @@ -28,6 +28,6 @@ func (f *PingFrame) Write(b *bytes.Buffer, packetNumber protocol.PacketNumber, v } // MinLength of a written frame -func (f *PingFrame) MinLength() protocol.ByteCount { - return 1 +func (f *PingFrame) MinLength() (protocol.ByteCount, error) { + return 1, nil } diff --git a/frames/rst_stream_frame.go b/frames/rst_stream_frame.go index c43d07b97..80f73d179 100644 --- a/frames/rst_stream_frame.go +++ b/frames/rst_stream_frame.go @@ -20,7 +20,7 @@ func (f *RstStreamFrame) Write(b *bytes.Buffer, packetNumber protocol.PacketNumb } // MinLength of a written frame -func (f *RstStreamFrame) MinLength() protocol.ByteCount { +func (f *RstStreamFrame) MinLength() (protocol.ByteCount, error) { panic("RstStreamFrame: Write not yet implemented") } diff --git a/frames/stop_waiting_frame.go b/frames/stop_waiting_frame.go index a6a428c7f..766fc6047 100644 --- a/frames/stop_waiting_frame.go +++ b/frames/stop_waiting_frame.go @@ -10,10 +10,16 @@ import ( // A StopWaitingFrame in QUIC type StopWaitingFrame struct { - Entropy byte - LeastUnacked protocol.PacketNumber + LeastUnacked protocol.PacketNumber + Entropy byte + PacketNumberLen protocol.PacketNumberLen } +var ( + errLeastUnackedHigherThanPacketNumber = errors.New("StopWaitingFrame: LeastUnacked can't be greater than the packet number") + errPacketNumberLenNotSet = errors.New("StopWaitingFrame: PacketNumberLen not set") +) + func (f *StopWaitingFrame) Write(b *bytes.Buffer, packetNumber protocol.PacketNumber, version protocol.VersionNumber) error { // packetNumber is the packet number of the packet that this StopWaitingFrame will be sent with typeByte := uint8(0x06) @@ -22,17 +28,33 @@ func (f *StopWaitingFrame) Write(b *bytes.Buffer, packetNumber protocol.PacketNu b.WriteByte(f.Entropy) if f.LeastUnacked > packetNumber { - return errors.New("StopWaitingFrame: LeastUnacked can't be greater than the packet number") + return errLeastUnackedHigherThanPacketNumber } + leastUnackedDelta := uint64(packetNumber - f.LeastUnacked) - utils.WriteUint48(b, leastUnackedDelta) + switch f.PacketNumberLen { + case protocol.PacketNumberLen1: + b.WriteByte(uint8(leastUnackedDelta)) + case protocol.PacketNumberLen2: + utils.WriteUint16(b, uint16(leastUnackedDelta)) + case protocol.PacketNumberLen4: + utils.WriteUint32(b, uint32(leastUnackedDelta)) + case protocol.PacketNumberLen6: + utils.WriteUint48(b, leastUnackedDelta) + default: + return errPacketNumberLenNotSet + } + return nil } // MinLength of a written frame -func (f *StopWaitingFrame) MinLength() protocol.ByteCount { - return 1 + 1 + 6 +func (f *StopWaitingFrame) MinLength() (protocol.ByteCount, error) { + if f.PacketNumberLen == protocol.PacketNumberLenInvalid { + return 0, errPacketNumberLenNotSet + } + return protocol.ByteCount(1 + 1 + f.PacketNumberLen), nil } // ParseStopWaitingFrame parses a StopWaiting frame diff --git a/frames/stop_waiting_frame_test.go b/frames/stop_waiting_frame_test.go index 0d1814e35..13ce47a43 100644 --- a/frames/stop_waiting_frame_test.go +++ b/frames/stop_waiting_frame_test.go @@ -31,12 +31,103 @@ var _ = Describe("StopWaitingFrame", func() { b := &bytes.Buffer{} packetNumber := protocol.PacketNumber(13) frame := &StopWaitingFrame{ - LeastUnacked: 10, - Entropy: 0xE, + LeastUnacked: 10, + Entropy: 0xAD, + PacketNumberLen: protocol.PacketNumberLen6, } frame.Write(b, packetNumber, 0) Expect(b.Bytes()[0]).To(Equal(uint8(0x06))) - // todo: check more + Expect(b.Bytes()[1]).To(Equal(uint8(frame.Entropy))) + Expect(b.Bytes()[2:8]).To(Equal([]byte{3, 0, 0, 0, 0, 0})) + }) + + It("errors when PacketNumberLen was not set", func() { + b := &bytes.Buffer{} + frame := &StopWaitingFrame{ + LeastUnacked: 10, + Entropy: 0xAD, + } + err := frame.Write(b, 13, 0) + Expect(err).To(HaveOccurred()) + Expect(err).To(Equal(errPacketNumberLenNotSet)) + }) + + It("errors when the LeastUnackedDelta would be negative", func() { + b := &bytes.Buffer{} + frame := &StopWaitingFrame{ + LeastUnacked: 10, + PacketNumberLen: protocol.PacketNumberLen1, + } + err := frame.Write(b, 5, 0) + Expect(err).To(HaveOccurred()) + Expect(err).To(Equal(errLeastUnackedHigherThanPacketNumber)) + }) + + Context("LeastUnackedDelta length", func() { + It("writes a 1-byte LeastUnackedDelta", func() { + b := &bytes.Buffer{} + frame := &StopWaitingFrame{ + LeastUnacked: 10, + PacketNumberLen: protocol.PacketNumberLen1, + } + frame.Write(b, 13, 0) + Expect(b.Len()).To(Equal(3)) + Expect(b.Bytes()[2]).To(Equal(uint8(3))) + }) + + It("writes a 2-byte LeastUnackedDelta", func() { + b := &bytes.Buffer{} + frame := &StopWaitingFrame{ + LeastUnacked: 0x10, + PacketNumberLen: protocol.PacketNumberLen2, + } + frame.Write(b, 0x1300, 0) + Expect(b.Len()).To(Equal(4)) + Expect(b.Bytes()[2:4]).To(Equal([]byte{0xF0, 0x12})) + }) + + It("writes a 4-byte LeastUnackedDelta", func() { + b := &bytes.Buffer{} + frame := &StopWaitingFrame{ + LeastUnacked: 0x1000, + PacketNumberLen: protocol.PacketNumberLen4, + } + frame.Write(b, 0x12345678, 0) + Expect(b.Len()).To(Equal(6)) + Expect(b.Bytes()[2:6]).To(Equal([]byte{0x78, 0x46, 0x34, 0x12})) + }) + + It("writes a 6-byte LeastUnackedDelta", func() { + b := &bytes.Buffer{} + frame := &StopWaitingFrame{ + LeastUnacked: 0x10, + PacketNumberLen: protocol.PacketNumberLen6, + } + frame.Write(b, 0x123456789ABC, 0) + Expect(b.Len()).To(Equal(8)) + Expect(b.Bytes()[2:8]).To(Equal([]byte{0xAC, 0x9A, 0x78, 0x56, 0x34, 0x12})) + }) + }) + }) + + Context("minLength", func() { + It("calculates the right minLength", func() { + for _, length := range []protocol.PacketNumberLen{protocol.PacketNumberLen1, protocol.PacketNumberLen2, protocol.PacketNumberLen4, protocol.PacketNumberLen6} { + frame := &StopWaitingFrame{ + LeastUnacked: 10, + PacketNumberLen: length, + } + Expect(frame.MinLength()).To(Equal(protocol.ByteCount(length + 2))) + } + }) + + It("errors when packetNumberLen is not set", func() { + frame := &StopWaitingFrame{ + LeastUnacked: 10, + } + _, err := frame.MinLength() + Expect(err).To(HaveOccurred()) + Expect(err).To(Equal(errPacketNumberLenNotSet)) }) }) @@ -44,12 +135,13 @@ var _ = Describe("StopWaitingFrame", func() { It("reads a stop waiting frame that it wrote", func() { packetNumber := protocol.PacketNumber(13) frame := &StopWaitingFrame{ - LeastUnacked: 10, - Entropy: 0xE, + LeastUnacked: 10, + Entropy: 0xAC, + PacketNumberLen: protocol.PacketNumberLen4, } b := &bytes.Buffer{} frame.Write(b, packetNumber, 0) - readframe, err := ParseStopWaitingFrame(bytes.NewReader(b.Bytes()), packetNumber, 6) + readframe, err := ParseStopWaitingFrame(bytes.NewReader(b.Bytes()), packetNumber, protocol.PacketNumberLen4) Expect(err).ToNot(HaveOccurred()) Expect(readframe.Entropy).To(Equal(frame.Entropy)) Expect(readframe.LeastUnacked).To(Equal(frame.LeastUnacked)) diff --git a/frames/stream_frame.go b/frames/stream_frame.go index 05f0a20bd..87de503a5 100644 --- a/frames/stream_frame.go +++ b/frames/stream_frame.go @@ -182,7 +182,7 @@ func (f *StreamFrame) getOffsetLength() protocol.ByteCount { } // MinLength of a written frame -func (f *StreamFrame) MinLength() protocol.ByteCount { +func (f *StreamFrame) MinLength() (protocol.ByteCount, error) { if f.streamIDLen == 0 { f.calculateStreamIDLength() } @@ -192,15 +192,16 @@ func (f *StreamFrame) MinLength() protocol.ByteCount { length += 2 } - return length + 1 + return length + 1, nil } // MaybeSplitOffFrame removes the first n bytes and returns them as a separate frame. If n >= len(n), nil is returned and nothing is modified. func (f *StreamFrame) MaybeSplitOffFrame(n protocol.ByteCount) *StreamFrame { - if n >= f.MinLength()-1+protocol.ByteCount(len(f.Data)) { + minLength, _ := f.MinLength() // StreamFrame.MinLength *never* errors + if n >= minLength-1+protocol.ByteCount(len(f.Data)) { return nil } - n -= f.MinLength() - 1 + n -= minLength - 1 defer func() { f.Data = f.Data[n:] diff --git a/frames/stream_frame_test.go b/frames/stream_frame_test.go index a7bd5d7b4..05c3089c1 100644 --- a/frames/stream_frame_test.go +++ b/frames/stream_frame_test.go @@ -77,7 +77,8 @@ var _ = Describe("StreamFrame", func() { Offset: 0, } f.Write(b, 1, 0) - headerLength := f.MinLength() - 1 + minLength, _ := f.MinLength() + headerLength := minLength - 1 Expect(b.Bytes()[0] & 0x20).To(Equal(uint8(0x20))) Expect(b.Bytes()[headerLength-2 : headerLength]).To(Equal([]byte{0x37, 0x13})) }) @@ -94,9 +95,10 @@ var _ = Describe("StreamFrame", func() { f.Write(b, 1, 0) Expect(b.Bytes()[0] & 0x20).To(Equal(uint8(0))) Expect(b.Bytes()[1 : b.Len()-dataLen]).ToNot(ContainSubstring(string([]byte{0x37, 0x13}))) - minLength := f.MinLength() + minLength, _ := f.MinLength() f.DataLenPresent = true - Expect(minLength).To(Equal(f.MinLength() - 2)) + minLengthWithoutDataLen, _ := f.MinLength() + Expect(minLength).To(Equal(minLengthWithoutDataLen - 2)) }) It("calculates the correcct min-length", func() { @@ -106,7 +108,7 @@ var _ = Describe("StreamFrame", func() { DataLenPresent: false, Offset: 0xDEADBEEF, } - minLengthWithoutDataLen := f.MinLength() + minLengthWithoutDataLen, _ := f.MinLength() f.DataLenPresent = true Expect(f.MinLength()).To(Equal(minLengthWithoutDataLen + 2)) }) @@ -346,7 +348,8 @@ var _ = Describe("StreamFrame", func() { Offset: 3, FinBit: true, } - previous := f.MaybeSplitOffFrame(f.MinLength() - 1 + 3) + minLength, _ := f.MinLength() + previous := f.MaybeSplitOffFrame(minLength - 1 + 3) Expect(previous).ToNot(BeNil()) Expect(previous.StreamID).To(Equal(protocol.StreamID(1))) Expect(previous.Data).To(Equal([]byte("foo"))) diff --git a/frames/window_update_frame.go b/frames/window_update_frame.go index d28b8aab3..6b96b9230 100644 --- a/frames/window_update_frame.go +++ b/frames/window_update_frame.go @@ -19,7 +19,7 @@ func (f *WindowUpdateFrame) Write(b *bytes.Buffer, packetNumber protocol.PacketN } // MinLength of a written frame -func (f *WindowUpdateFrame) MinLength() protocol.ByteCount { +func (f *WindowUpdateFrame) MinLength() (protocol.ByteCount, error) { panic("WindowUpdateFrame: Write not yet implemented") } diff --git a/packet_packer.go b/packet_packer.go index f4e01b60c..7b376e1e9 100644 --- a/packet_packer.go +++ b/packet_packer.go @@ -53,10 +53,11 @@ func (p *packetPacker) PackPacket(stopWaitingFrame *frames.StopWaitingFrame, con 1, )) + packetNumberLen := getPacketNumberLength(currentPacketNumber, p.sentPacketHandler.GetLargestObserved()) responsePublicHeader := &PublicHeader{ ConnectionID: p.connectionID, PacketNumber: currentPacketNumber, - PacketNumberLen: getPacketNumberLength(currentPacketNumber, p.sentPacketHandler.GetLargestObserved()), + PacketNumberLen: packetNumberLen, TruncateConnectionID: p.connectionParametersManager.TruncateConnectionID(), } @@ -65,6 +66,10 @@ func (p *packetPacker) PackPacket(stopWaitingFrame *frames.StopWaitingFrame, con return nil, err } + if stopWaitingFrame != nil { + stopWaitingFrame.PacketNumberLen = packetNumberLen + } + payloadFrames, err := p.composeNextPacket(stopWaitingFrame, controlFrames, publicHeaderLength, includeStreamFrames) if err != nil { return nil, err @@ -112,14 +117,6 @@ func (p *packetPacker) getPayload(frames []frames.Frame, currentPacketNumber pro return payload.Bytes(), nil } -// func (p *packetPacker) composeNextPacketControlFrames(stopWaitingFrame *frames.StopWaitingFrame, controlFrames []frames.Frame) (uint8, []frames.Frame, error) { -// -// } -// -// func (p *packetPacker) composeNextPacketStreamFrames() ([]frames.Frame, error) { -// -// } - func (p *packetPacker) composeNextPacket(stopWaitingFrame *frames.StopWaitingFrame, controlFrames []frames.Frame, publicHeaderLength protocol.ByteCount, includeStreamFrames bool) ([]frames.Frame, error) { payloadLength := protocol.ByteCount(0) var payloadFrames []frames.Frame @@ -127,13 +124,18 @@ func (p *packetPacker) composeNextPacket(stopWaitingFrame *frames.StopWaitingFra // TODO: handle the case where there are more controlFrames than we can put into one packet if stopWaitingFrame != nil { payloadFrames = append(payloadFrames, stopWaitingFrame) - payloadLength += stopWaitingFrame.MinLength() + minLength, err := stopWaitingFrame.MinLength() + if err != nil { + return nil, err + } + payloadLength += minLength } for len(controlFrames) > 0 { frame := controlFrames[0] payloadFrames = append(payloadFrames, frame) - payloadLength += frame.MinLength() + minLength, _ := frame.MinLength() // controlFrames does not contain any StopWaitingFrames. So it will *never* return an error + payloadLength += minLength controlFrames = controlFrames[1:] } @@ -163,7 +165,8 @@ func (p *packetPacker) composeNextPacket(stopWaitingFrame *frames.StopWaitingFra } // Does the frame fit into the remaining space? - if payloadLength+frame.MinLength() > maxFrameSize { + frameMinLength, _ := frame.MinLength() // StreamFrame.MinLength *never* returns an error + if payloadLength+frameMinLength > maxFrameSize { break } @@ -178,7 +181,7 @@ func (p *packetPacker) composeNextPacket(stopWaitingFrame *frames.StopWaitingFra payloadLength += protocol.ByteCount(len(frame.Data)) - 1 } - payloadLength += frame.MinLength() + payloadLength += frameMinLength payloadFrames = append(payloadFrames, frame) hasStreamFrames = true } diff --git a/packet_packer_test.go b/packet_packer_test.go index d09a39a70..d3ae92a67 100644 --- a/packet_packer_test.go +++ b/packet_packer_test.go @@ -102,12 +102,21 @@ var _ = Describe("Packet packer", func() { It("packs a StopWaitingFrame first", func() { swf := &frames.StopWaitingFrame{LeastUnacked: 10} p, err := packer.PackPacket(swf, []frames.Frame{&frames.ConnectionCloseFrame{}}, false) - Expect(p).ToNot(BeNil()) Expect(err).ToNot(HaveOccurred()) + Expect(p).ToNot(BeNil()) Expect(len(p.frames)).To(Equal(2)) Expect(p.frames[0]).To(Equal(swf)) }) + It("sets the LeastUnackedDelta length of a StopWaitingFrame", func() { + packetNumber := protocol.PacketNumber(0xDECAFB) // will result in a 4 byte packet number + packer.lastPacketNumber = packetNumber - 1 + swf := &frames.StopWaitingFrame{LeastUnacked: packetNumber - 0x100} + p, err := packer.PackPacket(swf, []frames.Frame{&frames.ConnectionCloseFrame{}}, false) + Expect(err).ToNot(HaveOccurred()) + Expect(p.frames[0].(*frames.StopWaitingFrame).PacketNumberLen).To(Equal(protocol.PacketNumberLen4)) + }) + It("does not pack a packet containing only a StopWaitingFrame", func() { swf := &frames.StopWaitingFrame{LeastUnacked: 10} p, err := packer.PackPacket(swf, []frames.Frame{}, false) @@ -159,7 +168,8 @@ var _ = Describe("Packet packer", func() { Offset: 1, DataLenPresent: false, } - maxStreamFrameDataLen := protocol.MaxFrameAndPublicHeaderSize - publicHeaderLen - f.MinLength() + minLength, _ := f.MinLength() + maxStreamFrameDataLen := protocol.MaxFrameAndPublicHeaderSize - publicHeaderLen - minLength f.Data = bytes.Repeat([]byte{'f'}, int(maxStreamFrameDataLen)) packer.AddStreamFrame(f) payloadFrames, err := packer.composeNextPacket(nil, []frames.Frame{}, publicHeaderLen, true) @@ -230,7 +240,8 @@ var _ = Describe("Packet packer", func() { StreamID: 7, Offset: 1, } - maxStreamFrameDataLen := protocol.MaxFrameAndPublicHeaderSize - publicHeaderLen - f.MinLength() + 1 // + 1 since MinceLength is 1 bigger than the actual StreamFrame header + minLength, _ := f.MinLength() + maxStreamFrameDataLen := protocol.MaxFrameAndPublicHeaderSize - publicHeaderLen - minLength + 1 // + 1 since MinceLength is 1 bigger than the actual StreamFrame header f.Data = bytes.Repeat([]byte{'f'}, int(maxStreamFrameDataLen)+200) packer.AddStreamFrame(f) payloadFrames, err := packer.composeNextPacket(nil, []frames.Frame{}, publicHeaderLen, true) @@ -285,7 +296,8 @@ var _ = Describe("Packet packer", func() { f := frames.StreamFrame{ Offset: 1, } - f.Data = bytes.Repeat([]byte{'f'}, int(protocol.MaxFrameAndPublicHeaderSize-publicHeaderLen-f.MinLength()+1)) // + 1 since MinceLength is 1 bigger than the actual StreamFrame header + minLength, _ := f.MinLength() + f.Data = bytes.Repeat([]byte{'f'}, int(protocol.MaxFrameAndPublicHeaderSize-publicHeaderLen-minLength+1)) // + 1 since MinceLength is 1 bigger than the actual StreamFrame header packer.AddStreamFrame(f) p, err := packer.PackPacket(nil, []frames.Frame{}, true) Expect(err).ToNot(HaveOccurred()) @@ -298,7 +310,8 @@ var _ = Describe("Packet packer", func() { StreamID: 5, Offset: 1, } - f.Data = bytes.Repeat([]byte{'f'}, int(protocol.MaxFrameAndPublicHeaderSize-publicHeaderLen-f.MinLength()+2)) // + 2 since MinceLength is 1 bigger than the actual StreamFrame header + minLength, _ := f.MinLength() + f.Data = bytes.Repeat([]byte{'f'}, int(protocol.MaxFrameAndPublicHeaderSize-publicHeaderLen-minLength+2)) // + 2 since MinceLength is 1 bigger than the actual StreamFrame header packer.AddStreamFrame(f) payloadFrames, err := packer.composeNextPacket(nil, []frames.Frame{}, publicHeaderLen, true) diff --git a/protocol/protocol.go b/protocol/protocol.go index a3773e8b4..c880b55d0 100644 --- a/protocol/protocol.go +++ b/protocol/protocol.go @@ -7,6 +7,8 @@ type PacketNumber uint64 type PacketNumberLen uint8 const ( + // PacketNumberLenInvalid is the default value and not a valid length for a packet number + PacketNumberLenInvalid PacketNumberLen = 0 // PacketNumberLen1 is a packet number length of 1 byte PacketNumberLen1 PacketNumberLen = 1 // PacketNumberLen2 is a packet number length of 2 bytes