From 21b608daac481c9245ce66497759fafae8ae1e91 Mon Sep 17 00:00:00 2001 From: Marten Seemann Date: Sun, 25 Mar 2018 14:02:41 +0200 Subject: [PATCH 1/2] move frame parsing to the wire package --- internal/wire/frame_parser.go | 152 +++++++++++ internal/wire/frame_parser_test.go | 323 +++++++++++++++++++++++ packet_unpacker.go | 149 +---------- packet_unpacker_test.go | 407 ++--------------------------- 4 files changed, 501 insertions(+), 530 deletions(-) create mode 100644 internal/wire/frame_parser.go create mode 100644 internal/wire/frame_parser_test.go diff --git a/internal/wire/frame_parser.go b/internal/wire/frame_parser.go new file mode 100644 index 000000000..9745a9ba6 --- /dev/null +++ b/internal/wire/frame_parser.go @@ -0,0 +1,152 @@ +package wire + +import ( + "bytes" + "fmt" + + "github.com/lucas-clemente/quic-go/internal/protocol" + "github.com/lucas-clemente/quic-go/qerr" +) + +// ParseNextFrame parses the next frame +// It skips PADDING frames. +func ParseNextFrame(r *bytes.Reader, hdr *Header, v protocol.VersionNumber) (Frame, error) { + if r.Len() == 0 { + return nil, nil + } + typeByte, _ := r.ReadByte() + if typeByte == 0x0 { // PADDING frame + return ParseNextFrame(r, hdr, v) + } + r.UnreadByte() + + if !v.UsesIETFFrameFormat() { + return parseGQUICFrame(r, typeByte, hdr, v) + } + return parseIETFFrame(r, typeByte, v) +} + +func parseIETFFrame(r *bytes.Reader, typeByte byte, v protocol.VersionNumber) (Frame, error) { + var frame Frame + var err error + if typeByte&0xf8 == 0x10 { + frame, err = ParseStreamFrame(r, v) + if err != nil { + err = qerr.Error(qerr.InvalidStreamData, err.Error()) + } + return frame, err + } + // TODO: implement all IETF QUIC frame types + switch typeByte { + case 0x1: + frame, err = ParseRstStreamFrame(r, v) + if err != nil { + err = qerr.Error(qerr.InvalidRstStreamData, err.Error()) + } + case 0x2: + frame, err = ParseConnectionCloseFrame(r, v) + if err != nil { + err = qerr.Error(qerr.InvalidConnectionCloseData, err.Error()) + } + case 0x4: + frame, err = ParseMaxDataFrame(r, v) + if err != nil { + err = qerr.Error(qerr.InvalidWindowUpdateData, err.Error()) + } + case 0x5: + frame, err = ParseMaxStreamDataFrame(r, v) + if err != nil { + err = qerr.Error(qerr.InvalidWindowUpdateData, err.Error()) + } + case 0x6: + frame, err = ParseMaxStreamIDFrame(r, v) + if err != nil { + err = qerr.Error(qerr.InvalidFrameData, err.Error()) + } + case 0x7: + frame, err = ParsePingFrame(r, v) + case 0x8: + frame, err = ParseBlockedFrame(r, v) + if err != nil { + err = qerr.Error(qerr.InvalidBlockedData, err.Error()) + } + case 0x9: + frame, err = ParseStreamBlockedFrame(r, v) + if err != nil { + err = qerr.Error(qerr.InvalidBlockedData, err.Error()) + } + case 0xa: + frame, err = ParseStreamIDBlockedFrame(r, v) + if err != nil { + err = qerr.Error(qerr.InvalidFrameData, err.Error()) + } + case 0xc: + frame, err = ParseStopSendingFrame(r, v) + if err != nil { + err = qerr.Error(qerr.InvalidFrameData, err.Error()) + } + case 0xe: + frame, err = ParseAckFrame(r, v) + if err != nil { + err = qerr.Error(qerr.InvalidAckData, err.Error()) + } + default: + err = qerr.Error(qerr.InvalidFrameData, fmt.Sprintf("unknown type byte 0x%x", typeByte)) + } + return frame, err +} + +func parseGQUICFrame(r *bytes.Reader, typeByte byte, hdr *Header, v protocol.VersionNumber) (Frame, error) { + var frame Frame + var err error + if typeByte&0x80 == 0x80 { + frame, err = ParseStreamFrame(r, v) + if err != nil { + err = qerr.Error(qerr.InvalidStreamData, err.Error()) + } + return frame, err + } else if typeByte&0xc0 == 0x40 { + frame, err = ParseAckFrame(r, v) + if err != nil { + err = qerr.Error(qerr.InvalidAckData, err.Error()) + } + return frame, err + } + switch typeByte { + case 0x1: + frame, err = ParseRstStreamFrame(r, v) + if err != nil { + err = qerr.Error(qerr.InvalidRstStreamData, err.Error()) + } + case 0x2: + frame, err = ParseConnectionCloseFrame(r, v) + if err != nil { + err = qerr.Error(qerr.InvalidConnectionCloseData, err.Error()) + } + case 0x3: + frame, err = ParseGoawayFrame(r, v) + if err != nil { + err = qerr.Error(qerr.InvalidGoawayData, err.Error()) + } + case 0x4: + frame, err = ParseWindowUpdateFrame(r, v) + if err != nil { + err = qerr.Error(qerr.InvalidWindowUpdateData, err.Error()) + } + case 0x5: + frame, err = ParseBlockedFrameLegacy(r, v) + if err != nil { + err = qerr.Error(qerr.InvalidBlockedData, err.Error()) + } + case 0x6: + frame, err = ParseStopWaitingFrame(r, hdr.PacketNumber, hdr.PacketNumberLen, v) + if err != nil { + err = qerr.Error(qerr.InvalidStopWaitingData, err.Error()) + } + case 0x7: + frame, err = ParsePingFrame(r, v) + default: + err = qerr.Error(qerr.InvalidFrameData, fmt.Sprintf("unknown type byte 0x%x", typeByte)) + } + return frame, err +} diff --git a/internal/wire/frame_parser_test.go b/internal/wire/frame_parser_test.go new file mode 100644 index 000000000..e809b2313 --- /dev/null +++ b/internal/wire/frame_parser_test.go @@ -0,0 +1,323 @@ +package wire + +import ( + "bytes" + + "github.com/lucas-clemente/quic-go/internal/protocol" + "github.com/lucas-clemente/quic-go/qerr" + . "github.com/onsi/ginkgo" + . "github.com/onsi/gomega" +) + +var _ = Describe("Frame parsing", func() { + var buf *bytes.Buffer + + BeforeEach(func() { + buf = &bytes.Buffer{} + }) + + It("returns nil if there's nothing more to read", func() { + f, err := ParseNextFrame(bytes.NewReader(nil), nil, protocol.VersionWhatever) + Expect(err).ToNot(HaveOccurred()) + Expect(f).To(BeNil()) + }) + + It("skips PADDING frames", func() { + buf.Write([]byte{0}) // PADDING frame + (&PingFrame{}).Write(buf, versionIETFFrames) + f, err := ParseNextFrame(bytes.NewReader(buf.Bytes()), nil, versionIETFFrames) + Expect(err).ToNot(HaveOccurred()) + Expect(f).To(Equal(&PingFrame{})) + }) + + It("handles PADDING at the end", func() { + r := bytes.NewReader([]byte{0, 0, 0}) + f, err := ParseNextFrame(r, nil, versionIETFFrames) + Expect(err).ToNot(HaveOccurred()) + Expect(f).To(BeNil()) + Expect(r.Len()).To(BeZero()) + }) + + Context("for gQUIC frames", func() { + It("unpacks RST_STREAM frames", func() { + f := &RstStreamFrame{ + StreamID: 0xdeadbeef, + ByteOffset: 0xdecafbad11223344, + ErrorCode: 0x1337, + } + err := f.Write(buf, versionBigEndian) + Expect(err).ToNot(HaveOccurred()) + frame, err := ParseNextFrame(bytes.NewReader(buf.Bytes()), nil, versionBigEndian) + Expect(err).ToNot(HaveOccurred()) + Expect(frame).To(Equal(f)) + }) + + It("unpacks CONNECTION_CLOSE frames", func() { + f := &ConnectionCloseFrame{ReasonPhrase: "foo"} + err := f.Write(buf, versionBigEndian) + Expect(err).ToNot(HaveOccurred()) + frame, err := ParseNextFrame(bytes.NewReader(buf.Bytes()), nil, versionBigEndian) + Expect(err).ToNot(HaveOccurred()) + Expect(frame).To(Equal(f)) + }) + + It("unpacks GOAWAY frames", func() { + f := &GoawayFrame{ + ErrorCode: 1, + LastGoodStream: 2, + ReasonPhrase: "foo", + } + err := f.Write(buf, 0) + Expect(err).ToNot(HaveOccurred()) + frame, err := ParseNextFrame(bytes.NewReader(buf.Bytes()), nil, versionBigEndian) + Expect(err).ToNot(HaveOccurred()) + Expect(frame).To(Equal(f)) + }) + + It("unpacks a stream-level WINDOW_UPDATE frame", func() { + f := &MaxStreamDataFrame{ + StreamID: 0xdeadbeef, + ByteOffset: 0xcafe000000001337, + } + buf := &bytes.Buffer{} + err := f.Write(buf, versionBigEndian) + Expect(err).ToNot(HaveOccurred()) + frame, err := ParseNextFrame(bytes.NewReader(buf.Bytes()), nil, versionBigEndian) + Expect(err).ToNot(HaveOccurred()) + Expect(frame).To(Equal(f)) + }) + + It("unpacks a connection-level WINDOW_UPDATE frame", func() { + f := &MaxDataFrame{ + ByteOffset: 0xcafe000000001337, + } + err := f.Write(buf, versionBigEndian) + Expect(err).ToNot(HaveOccurred()) + frame, err := ParseNextFrame(bytes.NewReader(buf.Bytes()), nil, versionBigEndian) + Expect(err).ToNot(HaveOccurred()) + Expect(frame).To(Equal(f)) + }) + + It("unpacks connection-level BLOCKED frames", func() { + f := &BlockedFrame{} + err := f.Write(buf, versionBigEndian) + Expect(err).ToNot(HaveOccurred()) + frame, err := ParseNextFrame(bytes.NewReader(buf.Bytes()), nil, versionBigEndian) + Expect(err).ToNot(HaveOccurred()) + Expect(frame).To(Equal(f)) + }) + + It("unpacks stream-level BLOCKED frames", func() { + f := &StreamBlockedFrame{StreamID: 0xdeadbeef} + err := f.Write(buf, versionBigEndian) + Expect(err).ToNot(HaveOccurred()) + frame, err := ParseNextFrame(bytes.NewReader(buf.Bytes()), nil, versionBigEndian) + Expect(err).ToNot(HaveOccurred()) + Expect(frame).To(Equal(f)) + }) + + It("unpacks STOP_WAITING frames", func() { + hdr := &Header{ + PacketNumber: 0x1338, + PacketNumberLen: protocol.PacketNumberLen4, + } + f := &StopWaitingFrame{ + LeastUnacked: 0x1337, + PacketNumber: hdr.PacketNumber, + PacketNumberLen: hdr.PacketNumberLen, + } + err := f.Write(buf, versionBigEndian) + Expect(err).ToNot(HaveOccurred()) + frame, err := ParseNextFrame(bytes.NewReader(buf.Bytes()), hdr, versionBigEndian) + Expect(err).ToNot(HaveOccurred()) + Expect(frame).To(BeAssignableToTypeOf(f)) + Expect(frame.(*StopWaitingFrame).LeastUnacked).To(Equal(protocol.PacketNumber(0x1337))) + }) + + It("unpacks PING frames", func() { + f := &PingFrame{} + err := f.Write(buf, versionBigEndian) + Expect(err).ToNot(HaveOccurred()) + frame, err := ParseNextFrame(bytes.NewReader(buf.Bytes()), nil, versionBigEndian) + Expect(err).ToNot(HaveOccurred()) + Expect(frame).To(Equal(f)) + }) + + It("unpacks ACK frames", func() { + f := &AckFrame{ + LargestAcked: 0x13, + LowestAcked: 1, + } + err := f.Write(buf, versionBigEndian) + Expect(err).ToNot(HaveOccurred()) + frame, err := ParseNextFrame(bytes.NewReader(buf.Bytes()), nil, versionBigEndian) + Expect(err).ToNot(HaveOccurred()) + Expect(frame).ToNot(BeNil()) + Expect(frame).To(BeAssignableToTypeOf(f)) + Expect(frame.(*AckFrame).LargestAcked).To(Equal(protocol.PacketNumber(0x13))) + }) + + It("errors on invalid type", func() { + _, err := ParseNextFrame(bytes.NewReader([]byte{0xf}), nil, versionBigEndian) + Expect(err).To(MatchError("InvalidFrameData: unknown type byte 0xf")) + }) + + It("errors on invalid frames", func() { + for b, e := range map[byte]qerr.ErrorCode{ + 0x80: qerr.InvalidStreamData, + 0x40: qerr.InvalidAckData, + 0x01: qerr.InvalidRstStreamData, + 0x02: qerr.InvalidConnectionCloseData, + 0x03: qerr.InvalidGoawayData, + 0x04: qerr.InvalidWindowUpdateData, + 0x05: qerr.InvalidBlockedData, + 0x06: qerr.InvalidStopWaitingData, + } { + _, err := ParseNextFrame(bytes.NewReader([]byte{b}), &Header{PacketNumberLen: 2}, versionBigEndian) + Expect(err).To(HaveOccurred()) + Expect(err.(*qerr.QuicError).ErrorCode).To(Equal(e)) + } + }) + }) + + Context("for IETF draft frames", func() { + It("unpacks RST_STREAM frames", func() { + f := &RstStreamFrame{ + StreamID: 0xdeadbeef, + ByteOffset: 0xdecafbad1234, + ErrorCode: 0x1337, + } + err := f.Write(buf, versionIETFFrames) + Expect(err).ToNot(HaveOccurred()) + frame, err := ParseNextFrame(bytes.NewReader(buf.Bytes()), nil, versionIETFFrames) + Expect(err).ToNot(HaveOccurred()) + Expect(frame).To(Equal(f)) + }) + + It("unpacks CONNECTION_CLOSE frames", func() { + f := &ConnectionCloseFrame{ReasonPhrase: "foo"} + err := f.Write(buf, versionIETFFrames) + Expect(err).ToNot(HaveOccurred()) + frame, err := ParseNextFrame(bytes.NewReader(buf.Bytes()), nil, versionIETFFrames) + Expect(err).ToNot(HaveOccurred()) + Expect(frame).To(Equal(f)) + }) + + It("unpacks MAX_DATA frames", func() { + f := &MaxDataFrame{ + ByteOffset: 0xcafe, + } + buf := &bytes.Buffer{} + err := f.Write(buf, versionIETFFrames) + Expect(err).ToNot(HaveOccurred()) + frame, err := ParseNextFrame(bytes.NewReader(buf.Bytes()), nil, versionIETFFrames) + Expect(err).ToNot(HaveOccurred()) + Expect(frame).To(Equal(f)) + }) + + It("unpacks MAX_STREAM_DATA frames", func() { + f := &MaxStreamDataFrame{ + StreamID: 0xdeadbeef, + ByteOffset: 0xdecafbad, + } + buf := &bytes.Buffer{} + err := f.Write(buf, versionIETFFrames) + Expect(err).ToNot(HaveOccurred()) + frame, err := ParseNextFrame(bytes.NewReader(buf.Bytes()), nil, versionIETFFrames) + Expect(err).ToNot(HaveOccurred()) + Expect(frame).To(Equal(f)) + }) + + It("unpacks MAX_STREAM_ID frames", func() { + f := &MaxStreamIDFrame{StreamID: 0x1337} + buf := &bytes.Buffer{} + err := f.Write(buf, versionIETFFrames) + Expect(err).ToNot(HaveOccurred()) + frame, err := ParseNextFrame(bytes.NewReader(buf.Bytes()), nil, versionIETFFrames) + Expect(err).ToNot(HaveOccurred()) + Expect(frame).To(Equal(f)) + }) + + It("unpacks connection-level BLOCKED frames", func() { + f := &BlockedFrame{Offset: 0x1234} + buf := &bytes.Buffer{} + err := f.Write(buf, versionIETFFrames) + Expect(err).ToNot(HaveOccurred()) + frame, err := ParseNextFrame(bytes.NewReader(buf.Bytes()), nil, versionIETFFrames) + Expect(err).ToNot(HaveOccurred()) + Expect(frame).To(Equal(f)) + }) + + It("unpacks stream-level BLOCKED frames", func() { + f := &StreamBlockedFrame{ + StreamID: 0xdeadbeef, + Offset: 0xdead, + } + buf := &bytes.Buffer{} + err := f.Write(buf, versionIETFFrames) + Expect(err).ToNot(HaveOccurred()) + frame, err := ParseNextFrame(bytes.NewReader(buf.Bytes()), nil, versionIETFFrames) + Expect(err).ToNot(HaveOccurred()) + Expect(frame).To(Equal(f)) + }) + + It("unpacks STREAM_ID_BLOCKED frames", func() { + f := &StreamIDBlockedFrame{StreamID: 0x1234567} + buf := &bytes.Buffer{} + err := f.Write(buf, versionIETFFrames) + Expect(err).ToNot(HaveOccurred()) + frame, err := ParseNextFrame(bytes.NewReader(buf.Bytes()), nil, versionIETFFrames) + Expect(err).ToNot(HaveOccurred()) + Expect(frame).To(Equal(f)) + }) + + It("unpacks STOP_SENDING frames", func() { + f := &StopSendingFrame{StreamID: 0x42} + buf := &bytes.Buffer{} + err := f.Write(buf, versionIETFFrames) + Expect(err).ToNot(HaveOccurred()) + frame, err := ParseNextFrame(bytes.NewReader(buf.Bytes()), nil, versionIETFFrames) + Expect(err).ToNot(HaveOccurred()) + Expect(frame).To(Equal(f)) + }) + + It("unpacks ACK frames", func() { + f := &AckFrame{ + LargestAcked: 0x13, + LowestAcked: 1, + } + err := f.Write(buf, versionIETFFrames) + Expect(err).ToNot(HaveOccurred()) + frame, err := ParseNextFrame(bytes.NewReader(buf.Bytes()), nil, versionIETFFrames) + Expect(err).ToNot(HaveOccurred()) + Expect(frame).ToNot(BeNil()) + Expect(frame).To(BeAssignableToTypeOf(f)) + Expect(frame.(*AckFrame).LargestAcked).To(Equal(protocol.PacketNumber(0x13))) + }) + + It("errors on invalid type", func() { + _, err := ParseNextFrame(bytes.NewReader([]byte{0xf}), nil, versionIETFFrames) + Expect(err).To(MatchError("InvalidFrameData: unknown type byte 0xf")) + }) + + It("errors on invalid frames", func() { + for b, e := range map[byte]qerr.ErrorCode{ + 0x01: qerr.InvalidRstStreamData, + 0x02: qerr.InvalidConnectionCloseData, + 0x04: qerr.InvalidWindowUpdateData, + 0x05: qerr.InvalidWindowUpdateData, + 0x06: qerr.InvalidFrameData, + 0x08: qerr.InvalidBlockedData, + 0x09: qerr.InvalidBlockedData, + 0x0a: qerr.InvalidFrameData, + 0x0c: qerr.InvalidFrameData, + 0x0e: qerr.InvalidAckData, + 0x10: qerr.InvalidStreamData, + } { + _, err := ParseNextFrame(bytes.NewReader([]byte{b}), nil, versionIETFFrames) + Expect(err).To(HaveOccurred()) + Expect(err.(*qerr.QuicError).ErrorCode).To(Equal(e)) + } + }) + }) +}) diff --git a/packet_unpacker.go b/packet_unpacker.go index a978675d8..0a98dc06f 100644 --- a/packet_unpacker.go +++ b/packet_unpacker.go @@ -41,25 +41,20 @@ func (u *packetUnpacker) Unpack(headerBinary []byte, hdr *wire.Header, data []by fs := make([]wire.Frame, 0, 2) // Read all frames in the packet - for r.Len() > 0 { - typeByte, _ := r.ReadByte() - if typeByte == 0x0 { // PADDING frame - continue - } - r.UnreadByte() - - frame, err := u.parseFrame(r, typeByte, hdr) + for { + frame, err := wire.ParseNextFrame(r, hdr, u.version) if err != nil { return nil, err } + if frame == nil { + break + } if sf, ok := frame.(*wire.StreamFrame); ok { if sf.StreamID != u.version.CryptoStreamID() && encryptionLevel <= protocol.EncryptionUnencrypted { return nil, qerr.Error(qerr.UnencryptedStreamData, fmt.Sprintf("received unencrypted stream data on stream %d", sf.StreamID)) } } - if frame != nil { - fs = append(fs, frame) - } + fs = append(fs, frame) } return &unpackedPacket{ @@ -67,135 +62,3 @@ func (u *packetUnpacker) Unpack(headerBinary []byte, hdr *wire.Header, data []by frames: fs, }, nil } - -func (u *packetUnpacker) parseFrame(r *bytes.Reader, typeByte byte, hdr *wire.Header) (wire.Frame, error) { - if u.version.UsesIETFFrameFormat() { - return u.parseIETFFrame(r, typeByte, hdr) - } - return u.parseGQUICFrame(r, typeByte, hdr) -} - -func (u *packetUnpacker) parseIETFFrame(r *bytes.Reader, typeByte byte, hdr *wire.Header) (wire.Frame, error) { - var frame wire.Frame - var err error - if typeByte&0xf8 == 0x10 { - frame, err = wire.ParseStreamFrame(r, u.version) - if err != nil { - err = qerr.Error(qerr.InvalidStreamData, err.Error()) - } - return frame, err - } - // TODO: implement all IETF QUIC frame types - switch typeByte { - case 0x1: - frame, err = wire.ParseRstStreamFrame(r, u.version) - if err != nil { - err = qerr.Error(qerr.InvalidRstStreamData, err.Error()) - } - case 0x2: - frame, err = wire.ParseConnectionCloseFrame(r, u.version) - if err != nil { - err = qerr.Error(qerr.InvalidConnectionCloseData, err.Error()) - } - case 0x4: - frame, err = wire.ParseMaxDataFrame(r, u.version) - if err != nil { - err = qerr.Error(qerr.InvalidWindowUpdateData, err.Error()) - } - case 0x5: - frame, err = wire.ParseMaxStreamDataFrame(r, u.version) - if err != nil { - err = qerr.Error(qerr.InvalidWindowUpdateData, err.Error()) - } - case 0x6: - frame, err = wire.ParseMaxStreamIDFrame(r, u.version) - if err != nil { - err = qerr.Error(qerr.InvalidFrameData, err.Error()) - } - case 0x7: - frame, err = wire.ParsePingFrame(r, u.version) - case 0x8: - frame, err = wire.ParseBlockedFrame(r, u.version) - if err != nil { - err = qerr.Error(qerr.InvalidBlockedData, err.Error()) - } - case 0x9: - frame, err = wire.ParseStreamBlockedFrame(r, u.version) - if err != nil { - err = qerr.Error(qerr.InvalidBlockedData, err.Error()) - } - case 0xa: - frame, err = wire.ParseStreamIDBlockedFrame(r, u.version) - if err != nil { - err = qerr.Error(qerr.InvalidFrameData, err.Error()) - } - case 0xc: - frame, err = wire.ParseStopSendingFrame(r, u.version) - if err != nil { - err = qerr.Error(qerr.InvalidFrameData, err.Error()) - } - case 0xe: - frame, err = wire.ParseAckFrame(r, u.version) - if err != nil { - err = qerr.Error(qerr.InvalidAckData, err.Error()) - } - default: - err = qerr.Error(qerr.InvalidFrameData, fmt.Sprintf("unknown type byte 0x%x", typeByte)) - } - return frame, err -} - -func (u *packetUnpacker) parseGQUICFrame(r *bytes.Reader, typeByte byte, hdr *wire.Header) (wire.Frame, error) { - var frame wire.Frame - var err error - if typeByte&0x80 == 0x80 { - frame, err = wire.ParseStreamFrame(r, u.version) - if err != nil { - err = qerr.Error(qerr.InvalidStreamData, err.Error()) - } - return frame, err - } else if typeByte&0xc0 == 0x40 { - frame, err = wire.ParseAckFrame(r, u.version) - if err != nil { - err = qerr.Error(qerr.InvalidAckData, err.Error()) - } - return frame, err - } - switch typeByte { - case 0x1: - frame, err = wire.ParseRstStreamFrame(r, u.version) - if err != nil { - err = qerr.Error(qerr.InvalidRstStreamData, err.Error()) - } - case 0x2: - frame, err = wire.ParseConnectionCloseFrame(r, u.version) - if err != nil { - err = qerr.Error(qerr.InvalidConnectionCloseData, err.Error()) - } - case 0x3: - frame, err = wire.ParseGoawayFrame(r, u.version) - if err != nil { - err = qerr.Error(qerr.InvalidGoawayData, err.Error()) - } - case 0x4: - frame, err = wire.ParseWindowUpdateFrame(r, u.version) - if err != nil { - err = qerr.Error(qerr.InvalidWindowUpdateData, err.Error()) - } - case 0x5: - frame, err = wire.ParseBlockedFrameLegacy(r, u.version) - if err != nil { - err = qerr.Error(qerr.InvalidBlockedData, err.Error()) - } - case 0x6: - frame, err = wire.ParseStopWaitingFrame(r, hdr.PacketNumber, hdr.PacketNumberLen, u.version) - if err != nil { - err = qerr.Error(qerr.InvalidStopWaitingData, err.Error()) - } - case 0x7: - frame, err = wire.ParsePingFrame(r, u.version) - default: - err = qerr.Error(qerr.InvalidFrameData, fmt.Sprintf("unknown type byte 0x%x", typeByte)) - } - return frame, err -} diff --git a/packet_unpacker_test.go b/packet_unpacker_test.go index 88a342d5e..50548d7a4 100644 --- a/packet_unpacker_test.go +++ b/packet_unpacker_test.go @@ -72,37 +72,16 @@ var _ = Describe("Packet unpacker", func() { Expect(packet.encryptionLevel).To(Equal(protocol.EncryptionSecure)) }) - Context("for gQUIC frames", func() { + Context("unpacking STREAM frames", func() { BeforeEach(func() { unpacker.version = versionGQUICFrames }) - It("handles PADDING frames", func() { - setData([]byte{0, 0, 0}) // 3 bytes PADDING - packet, err := unpacker.Unpack(hdrBin, hdr, data) - Expect(err).ToNot(HaveOccurred()) - Expect(packet.frames).To(BeEmpty()) - }) - - It("handles PADDING between two other frames", func() { - f := &wire.PingFrame{} - err := f.Write(buf, versionGQUICFrames) - Expect(err).ToNot(HaveOccurred()) - _, err = buf.Write(bytes.Repeat([]byte{0}, 10)) // 10 bytes PADDING - Expect(err).ToNot(HaveOccurred()) - err = f.Write(buf, versionGQUICFrames) - Expect(err).ToNot(HaveOccurred()) - setData(buf.Bytes()) - packet, err := unpacker.Unpack(hdrBin, hdr, data) - Expect(err).ToNot(HaveOccurred()) - Expect(packet.frames).To(HaveLen(2)) - }) - - It("unpacks RST_STREAM frames", func() { - f := &wire.RstStreamFrame{ - StreamID: 0xdeadbeef, - ByteOffset: 0xdecafbad11223344, - ErrorCode: 0x1337, + It("unpacks unencrypted STREAM frames on the crypto stream", func() { + unpacker.aead.(*mockAEAD).encLevelOpen = protocol.EncryptionUnencrypted + f := &wire.StreamFrame{ + StreamID: versionGQUICFrames.CryptoStreamID(), + Data: []byte("foobar"), } err := f.Write(buf, versionGQUICFrames) Expect(err).ToNot(HaveOccurred()) @@ -112,377 +91,31 @@ var _ = Describe("Packet unpacker", func() { Expect(packet.frames).To(Equal([]wire.Frame{f})) }) - It("unpacks CONNECTION_CLOSE frames", func() { - f := &wire.ConnectionCloseFrame{ReasonPhrase: "foo"} - err := f.Write(buf, versionGQUICFrames) - Expect(err).ToNot(HaveOccurred()) - setData(buf.Bytes()) - packet, err := unpacker.Unpack(hdrBin, hdr, data) - Expect(err).ToNot(HaveOccurred()) - Expect(packet.frames).To(Equal([]wire.Frame{f})) - }) - - It("unpacks GOAWAY frames", func() { - f := &wire.GoawayFrame{ - ErrorCode: 1, - LastGoodStream: 2, - ReasonPhrase: "foo", - } - err := f.Write(buf, 0) - Expect(err).ToNot(HaveOccurred()) - setData(buf.Bytes()) - packet, err := unpacker.Unpack(hdrBin, hdr, data) - Expect(err).ToNot(HaveOccurred()) - Expect(packet.frames).To(Equal([]wire.Frame{f})) - }) - - It("unpacks a stream-level WINDOW_UPDATE frame", func() { - f := &wire.MaxStreamDataFrame{ - StreamID: 0xdeadbeef, - ByteOffset: 0xcafe000000001337, - } - buf := &bytes.Buffer{} - err := f.Write(buf, versionGQUICFrames) - Expect(err).ToNot(HaveOccurred()) - setData(buf.Bytes()) - packet, err := unpacker.Unpack(hdrBin, hdr, data) - Expect(err).ToNot(HaveOccurred()) - Expect(packet.frames).To(Equal([]wire.Frame{f})) - }) - - It("unpacks a connection-level WINDOW_UPDATE frame", func() { - f := &wire.MaxDataFrame{ - ByteOffset: 0xcafe000000001337, - } - buf := &bytes.Buffer{} - err := f.Write(buf, versionGQUICFrames) - Expect(err).ToNot(HaveOccurred()) - setData(buf.Bytes()) - packet, err := unpacker.Unpack(hdrBin, hdr, data) - Expect(err).ToNot(HaveOccurred()) - Expect(packet.frames).To(Equal([]wire.Frame{f})) - }) - - It("unpacks connection-level BLOCKED frames", func() { - f := &wire.BlockedFrame{} - buf := &bytes.Buffer{} - err := f.Write(buf, versionGQUICFrames) - Expect(err).ToNot(HaveOccurred()) - setData(buf.Bytes()) - packet, err := unpacker.Unpack(hdrBin, hdr, data) - Expect(err).ToNot(HaveOccurred()) - Expect(packet.frames).To(Equal([]wire.Frame{f})) - }) - - It("unpacks stream-level BLOCKED frames", func() { - f := &wire.StreamBlockedFrame{StreamID: 0xdeadbeef} - buf := &bytes.Buffer{} - err := f.Write(buf, versionGQUICFrames) - Expect(err).ToNot(HaveOccurred()) - setData(buf.Bytes()) - packet, err := unpacker.Unpack(hdrBin, hdr, data) - Expect(err).ToNot(HaveOccurred()) - Expect(packet.frames).To(Equal([]wire.Frame{f})) - }) - - It("unpacks STOP_WAITING frames", func() { - setData([]byte{0x06, 0x03}) - packet, err := unpacker.Unpack(hdrBin, hdr, data) - Expect(err).ToNot(HaveOccurred()) - Expect(packet.frames).To(Equal([]wire.Frame{ - &wire.StopWaitingFrame{LeastUnacked: 7}, - })) - }) - - It("unpacks PING frames", func() { - setData([]byte{0x07}) - packet, err := unpacker.Unpack(hdrBin, hdr, data) - Expect(err).ToNot(HaveOccurred()) - Expect(packet.frames).To(Equal([]wire.Frame{ - &wire.PingFrame{}, - })) - }) - - It("errors on invalid type", func() { - setData([]byte{0xf}) - _, err := unpacker.Unpack(hdrBin, hdr, data) - Expect(err).To(MatchError("InvalidFrameData: unknown type byte 0xf")) - }) - - It("errors on invalid frames", func() { - for b, e := range map[byte]qerr.ErrorCode{ - 0x80: qerr.InvalidStreamData, - 0x40: qerr.InvalidAckData, - 0x01: qerr.InvalidRstStreamData, - 0x02: qerr.InvalidConnectionCloseData, - 0x03: qerr.InvalidGoawayData, - 0x04: qerr.InvalidWindowUpdateData, - 0x05: qerr.InvalidBlockedData, - 0x06: qerr.InvalidStopWaitingData, - } { - setData([]byte{b}) - _, err := unpacker.Unpack(hdrBin, hdr, data) - Expect(err.(*qerr.QuicError).ErrorCode).To(Equal(e)) - } - }) - - It("unpacks ACK frames", func() { - f := &wire.AckFrame{ - LargestAcked: 0x13, - LowestAcked: 1, + It("unpacks encrypted STREAM frames on the crypto stream", func() { + unpacker.aead.(*mockAEAD).encLevelOpen = protocol.EncryptionSecure + f := &wire.StreamFrame{ + StreamID: versionGQUICFrames.CryptoStreamID(), + Data: []byte("foobar"), } err := f.Write(buf, versionGQUICFrames) Expect(err).ToNot(HaveOccurred()) setData(buf.Bytes()) packet, err := unpacker.Unpack(hdrBin, hdr, data) Expect(err).ToNot(HaveOccurred()) - Expect(packet.frames).To(HaveLen(1)) - readFrame := packet.frames[0].(*wire.AckFrame) - Expect(readFrame).ToNot(BeNil()) - Expect(readFrame.LargestAcked).To(Equal(protocol.PacketNumber(0x13))) + Expect(packet.frames).To(Equal([]wire.Frame{f})) }) - Context("unpacking STREAM frames", func() { - It("unpacks unencrypted STREAM frames on the crypto stream", func() { - unpacker.aead.(*mockAEAD).encLevelOpen = protocol.EncryptionUnencrypted - f := &wire.StreamFrame{ - StreamID: versionGQUICFrames.CryptoStreamID(), - Data: []byte("foobar"), - } - err := f.Write(buf, versionGQUICFrames) - Expect(err).ToNot(HaveOccurred()) - setData(buf.Bytes()) - packet, err := unpacker.Unpack(hdrBin, hdr, data) - Expect(err).ToNot(HaveOccurred()) - Expect(packet.frames).To(Equal([]wire.Frame{f})) - }) - - It("unpacks encrypted STREAM frames on the crypto stream", func() { - unpacker.aead.(*mockAEAD).encLevelOpen = protocol.EncryptionSecure - f := &wire.StreamFrame{ - StreamID: versionGQUICFrames.CryptoStreamID(), - Data: []byte("foobar"), - } - err := f.Write(buf, versionGQUICFrames) - Expect(err).ToNot(HaveOccurred()) - setData(buf.Bytes()) - packet, err := unpacker.Unpack(hdrBin, hdr, data) - Expect(err).ToNot(HaveOccurred()) - Expect(packet.frames).To(Equal([]wire.Frame{f})) - }) - - It("does not unpack unencrypted STREAM frames on higher streams", func() { - unpacker.aead.(*mockAEAD).encLevelOpen = protocol.EncryptionUnencrypted - f := &wire.StreamFrame{ - StreamID: 3, - Data: []byte("foobar"), - } - err := f.Write(buf, versionGQUICFrames) - Expect(err).ToNot(HaveOccurred()) - setData(buf.Bytes()) - _, err = unpacker.Unpack(hdrBin, hdr, data) - Expect(err).To(MatchError(qerr.Error(qerr.UnencryptedStreamData, "received unencrypted stream data on stream 3"))) - }) - }) - }) - - Context("for IETF draft frames", func() { - BeforeEach(func() { - unpacker.version = versionIETFFrames - }) - - It("unpacks RST_STREAM frames", func() { - f := &wire.RstStreamFrame{ - StreamID: 0xdeadbeef, - ByteOffset: 0xdecafbad1234, - ErrorCode: 0x1337, + It("does not unpack unencrypted STREAM frames on higher streams", func() { + unpacker.aead.(*mockAEAD).encLevelOpen = protocol.EncryptionUnencrypted + f := &wire.StreamFrame{ + StreamID: 3, + Data: []byte("foobar"), } - err := f.Write(buf, versionIETFFrames) + err := f.Write(buf, versionGQUICFrames) Expect(err).ToNot(HaveOccurred()) setData(buf.Bytes()) - packet, err := unpacker.Unpack(hdrBin, hdr, data) - Expect(err).ToNot(HaveOccurred()) - Expect(packet.frames).To(Equal([]wire.Frame{f})) - }) - - It("unpacks CONNECTION_CLOSE frames", func() { - f := &wire.ConnectionCloseFrame{ReasonPhrase: "foo"} - err := f.Write(buf, versionIETFFrames) - Expect(err).ToNot(HaveOccurred()) - setData(buf.Bytes()) - packet, err := unpacker.Unpack(hdrBin, hdr, data) - Expect(err).ToNot(HaveOccurred()) - Expect(packet.frames).To(Equal([]wire.Frame{f})) - }) - - It("unpacks MAX_DATA frames", func() { - f := &wire.MaxDataFrame{ - ByteOffset: 0xcafe, - } - buf := &bytes.Buffer{} - err := f.Write(buf, versionIETFFrames) - Expect(err).ToNot(HaveOccurred()) - setData(buf.Bytes()) - packet, err := unpacker.Unpack(hdrBin, hdr, data) - Expect(err).ToNot(HaveOccurred()) - Expect(packet.frames).To(Equal([]wire.Frame{f})) - }) - - It("unpacks MAX_STREAM_DATA frames", func() { - f := &wire.MaxStreamDataFrame{ - StreamID: 0xdeadbeef, - ByteOffset: 0xdecafbad, - } - buf := &bytes.Buffer{} - err := f.Write(buf, versionIETFFrames) - Expect(err).ToNot(HaveOccurred()) - setData(buf.Bytes()) - packet, err := unpacker.Unpack(hdrBin, hdr, data) - Expect(err).ToNot(HaveOccurred()) - Expect(packet.frames).To(Equal([]wire.Frame{f})) - }) - - It("unpacks MAX_STREAM_ID frames", func() { - f := &wire.MaxStreamIDFrame{StreamID: 0x1337} - buf := &bytes.Buffer{} - err := f.Write(buf, versionIETFFrames) - Expect(err).ToNot(HaveOccurred()) - setData(buf.Bytes()) - packet, err := unpacker.Unpack(hdrBin, hdr, data) - Expect(err).ToNot(HaveOccurred()) - Expect(packet.frames).To(Equal([]wire.Frame{f})) - }) - - It("unpacks connection-level BLOCKED frames", func() { - f := &wire.BlockedFrame{Offset: 0x1234} - buf := &bytes.Buffer{} - err := f.Write(buf, versionIETFFrames) - Expect(err).ToNot(HaveOccurred()) - setData(buf.Bytes()) - packet, err := unpacker.Unpack(hdrBin, hdr, data) - Expect(err).ToNot(HaveOccurred()) - Expect(packet.frames).To(Equal([]wire.Frame{f})) - }) - - It("unpacks stream-level BLOCKED frames", func() { - f := &wire.StreamBlockedFrame{ - StreamID: 0xdeadbeef, - Offset: 0xdead, - } - buf := &bytes.Buffer{} - err := f.Write(buf, versionIETFFrames) - Expect(err).ToNot(HaveOccurred()) - setData(buf.Bytes()) - packet, err := unpacker.Unpack(hdrBin, hdr, data) - Expect(err).ToNot(HaveOccurred()) - Expect(packet.frames).To(Equal([]wire.Frame{f})) - }) - - It("unpacks STREAM_ID_BLOCKED frames", func() { - f := &wire.StreamIDBlockedFrame{StreamID: 0x1234567} - buf := &bytes.Buffer{} - err := f.Write(buf, versionIETFFrames) - Expect(err).ToNot(HaveOccurred()) - setData(buf.Bytes()) - packet, err := unpacker.Unpack(hdrBin, hdr, data) - Expect(err).ToNot(HaveOccurred()) - Expect(packet.frames).To(Equal([]wire.Frame{f})) - }) - - It("unpacks STOP_SENDING frames", func() { - f := &wire.StopSendingFrame{StreamID: 0x42} - buf := &bytes.Buffer{} - err := f.Write(buf, versionIETFFrames) - Expect(err).ToNot(HaveOccurred()) - setData(buf.Bytes()) - packet, err := unpacker.Unpack(hdrBin, hdr, data) - Expect(err).ToNot(HaveOccurred()) - Expect(packet.frames).To(Equal([]wire.Frame{f})) - }) - - It("unpacks ACK frames", func() { - f := &wire.AckFrame{ - LargestAcked: 0x13, - LowestAcked: 1, - } - err := f.Write(buf, versionIETFFrames) - Expect(err).ToNot(HaveOccurred()) - setData(buf.Bytes()) - packet, err := unpacker.Unpack(hdrBin, hdr, data) - Expect(err).ToNot(HaveOccurred()) - Expect(packet.frames).To(HaveLen(1)) - readFrame := packet.frames[0].(*wire.AckFrame) - Expect(readFrame).ToNot(BeNil()) - Expect(readFrame.LargestAcked).To(Equal(protocol.PacketNumber(0x13))) - }) - - It("errors on invalid type", func() { - setData([]byte{0xf}) - _, err := unpacker.Unpack(hdrBin, hdr, data) - Expect(err).To(MatchError("InvalidFrameData: unknown type byte 0xf")) - }) - - It("errors on invalid frames", func() { - for b, e := range map[byte]qerr.ErrorCode{ - 0x01: qerr.InvalidRstStreamData, - 0x02: qerr.InvalidConnectionCloseData, - 0x04: qerr.InvalidWindowUpdateData, - 0x05: qerr.InvalidWindowUpdateData, - 0x06: qerr.InvalidFrameData, - 0x08: qerr.InvalidBlockedData, - 0x09: qerr.InvalidBlockedData, - 0x0a: qerr.InvalidFrameData, - 0x0c: qerr.InvalidFrameData, - 0x0e: qerr.InvalidAckData, - 0x10: qerr.InvalidStreamData, - } { - setData([]byte{b}) - _, err := unpacker.Unpack(hdrBin, hdr, data) - Expect(err.(*qerr.QuicError).ErrorCode).To(Equal(e)) - } - }) - - Context("unpacking STREAM frames", func() { - It("unpacks unencrypted STREAM frames on the crypto stream", func() { - unpacker.aead.(*mockAEAD).encLevelOpen = protocol.EncryptionUnencrypted - f := &wire.StreamFrame{ - StreamID: versionIETFFrames.CryptoStreamID(), - Data: []byte("foobar"), - } - err := f.Write(buf, versionIETFFrames) - Expect(err).ToNot(HaveOccurred()) - setData(buf.Bytes()) - packet, err := unpacker.Unpack(hdrBin, hdr, data) - Expect(err).ToNot(HaveOccurred()) - Expect(packet.frames).To(Equal([]wire.Frame{f})) - }) - - It("unpacks encrypted STREAM frames on the crypto stream", func() { - unpacker.aead.(*mockAEAD).encLevelOpen = protocol.EncryptionSecure - f := &wire.StreamFrame{ - StreamID: versionIETFFrames.CryptoStreamID(), - Data: []byte("foobar"), - } - err := f.Write(buf, versionIETFFrames) - Expect(err).ToNot(HaveOccurred()) - setData(buf.Bytes()) - packet, err := unpacker.Unpack(hdrBin, hdr, data) - Expect(err).ToNot(HaveOccurred()) - Expect(packet.frames).To(Equal([]wire.Frame{f})) - }) - - It("does not unpack unencrypted STREAM frames on higher streams", func() { - unpacker.aead.(*mockAEAD).encLevelOpen = protocol.EncryptionUnencrypted - f := &wire.StreamFrame{ - StreamID: 3, - Data: []byte("foobar"), - } - err := f.Write(buf, versionIETFFrames) - Expect(err).ToNot(HaveOccurred()) - setData(buf.Bytes()) - _, err = unpacker.Unpack(hdrBin, hdr, data) - Expect(err).To(MatchError(qerr.Error(qerr.UnencryptedStreamData, "received unencrypted stream data on stream 3"))) - }) + _, err = unpacker.Unpack(hdrBin, hdr, data) + Expect(err).To(MatchError(qerr.Error(qerr.UnencryptedStreamData, "received unencrypted stream data on stream 3"))) }) }) }) From be066e825ce038401f3ac8b8b4d633a52fee36ba Mon Sep 17 00:00:00 2001 From: Marten Seemann Date: Sun, 25 Mar 2018 18:07:03 +0200 Subject: [PATCH 2/2] privatize the frame parsing functions --- internal/wire/ack_frame.go | 4 +- internal/wire/ack_frame_legacy_test.go | 108 +++++++++--------- internal/wire/ack_frame_test.go | 24 ++-- internal/wire/blocked_frame.go | 4 +- internal/wire/blocked_frame_legacy.go | 4 +- internal/wire/blocked_frame_legacy_test.go | 8 +- internal/wire/blocked_frame_test.go | 6 +- internal/wire/connection_close_frame.go | 4 +- internal/wire/connection_close_frame_test.go | 20 ++-- internal/wire/frame_parser.go | 42 +++---- internal/wire/goaway_frame.go | 4 +- internal/wire/goaway_frame_test.go | 8 +- internal/wire/max_data_frame.go | 4 +- internal/wire/max_data_frame_test.go | 6 +- internal/wire/max_stream_data_frame.go | 4 +- internal/wire/max_stream_data_frame_test.go | 6 +- internal/wire/max_stream_id_frame.go | 4 +- internal/wire/max_stream_id_frame_test.go | 6 +- internal/wire/ping_frame.go | 4 +- internal/wire/ping_frame_test.go | 4 +- internal/wire/rst_stream_frame.go | 4 +- internal/wire/rst_stream_frame_test.go | 12 +- internal/wire/stop_sending_frame.go | 4 +- internal/wire/stop_sending_frame_test.go | 6 +- internal/wire/stop_waiting_frame.go | 4 +- internal/wire/stop_waiting_frame_test.go | 14 +-- internal/wire/stream_blocked_frame.go | 4 +- internal/wire/stream_blocked_frame_test.go | 6 +- internal/wire/stream_frame.go | 4 +- internal/wire/stream_frame_legacy_test.go | 22 ++-- internal/wire/stream_frame_test.go | 14 +-- internal/wire/stream_id_blocked_frame.go | 4 +- internal/wire/stream_id_blocked_frame_test.go | 6 +- internal/wire/window_update_frame.go | 4 +- internal/wire/window_update_frame_test.go | 8 +- server_tls_test.go | 4 +- 36 files changed, 198 insertions(+), 196 deletions(-) diff --git a/internal/wire/ack_frame.go b/internal/wire/ack_frame.go index d85c33a0d..1a95bb9f3 100644 --- a/internal/wire/ack_frame.go +++ b/internal/wire/ack_frame.go @@ -24,8 +24,8 @@ type AckFrame struct { DelayTime time.Duration } -// ParseAckFrame reads an ACK frame -func ParseAckFrame(r *bytes.Reader, version protocol.VersionNumber) (*AckFrame, error) { +// parseAckFrame reads an ACK frame +func parseAckFrame(r *bytes.Reader, version protocol.VersionNumber) (*AckFrame, error) { if !version.UsesIETFFrameFormat() { return parseAckFrameLegacy(r, version) } diff --git a/internal/wire/ack_frame_legacy_test.go b/internal/wire/ack_frame_legacy_test.go index 563210ce3..d600d2f24 100644 --- a/internal/wire/ack_frame_legacy_test.go +++ b/internal/wire/ack_frame_legacy_test.go @@ -19,7 +19,7 @@ var _ = Describe("ACK Frame (for gQUIC)", func() { 0x1c, // block length 0, }) - frame, err := ParseAckFrame(b, versionBigEndian) + frame, err := parseAckFrame(b, versionBigEndian) Expect(err).ToNot(HaveOccurred()) Expect(frame.LargestAcked).To(Equal(protocol.PacketNumber(0x1c))) Expect(frame.LowestAcked).To(Equal(protocol.PacketNumber(1))) @@ -34,7 +34,7 @@ var _ = Describe("ACK Frame (for gQUIC)", func() { 0x1, // block length 0, }) - frame, err := ParseAckFrame(b, versionBigEndian) + frame, err := parseAckFrame(b, versionBigEndian) Expect(err).ToNot(HaveOccurred()) Expect(frame.LargestAcked).To(Equal(protocol.PacketNumber(0))) Expect(frame.LowestAcked).To(Equal(protocol.PacketNumber(0))) @@ -49,7 +49,7 @@ var _ = Describe("ACK Frame (for gQUIC)", func() { 0x1, // block length 0, }) - frame, err := ParseAckFrame(b, versionBigEndian) + frame, err := parseAckFrame(b, versionBigEndian) Expect(err).ToNot(HaveOccurred()) Expect(frame.LargestAcked).To(Equal(protocol.PacketNumber(0x10))) Expect(frame.LowestAcked).To(Equal(protocol.PacketNumber(0x10))) @@ -64,7 +64,7 @@ var _ = Describe("ACK Frame (for gQUIC)", func() { 0x11, // block length 0, }) - frame, err := ParseAckFrame(b, versionBigEndian) + frame, err := parseAckFrame(b, versionBigEndian) Expect(err).ToNot(HaveOccurred()) Expect(frame.LargestAcked).To(Equal(protocol.PacketNumber(0x10))) Expect(frame.LowestAcked).To(Equal(protocol.PacketNumber(0))) @@ -83,7 +83,7 @@ var _ = Describe("ACK Frame (for gQUIC)", func() { 0x2, 0, 0, // 3rd timestamp 0x1, 0, 0, // 4th timestamp }) - _, err := ParseAckFrame(b, versionBigEndian) + _, err := parseAckFrame(b, versionBigEndian) Expect(err).ToNot(HaveOccurred()) Expect(b.Len()).To(BeZero()) }) @@ -97,7 +97,7 @@ var _ = Describe("ACK Frame (for gQUIC)", func() { 0x1e, // block length 0, }) - _, err := ParseAckFrame(b, versionBigEndian) + _, err := parseAckFrame(b, versionBigEndian) Expect(err).To(MatchError(errInvalidAckRanges)) }) @@ -108,7 +108,7 @@ var _ = Describe("ACK Frame (for gQUIC)", func() { 0x0, // block length 0, }) - _, err := ParseAckFrame(b, versionBigEndian) + _, err := parseAckFrame(b, versionBigEndian) Expect(err).To(MatchError("invalid first ACK range")) }) @@ -119,7 +119,7 @@ var _ = Describe("ACK Frame (for gQUIC)", func() { 0x3, // block length 0, }) - frame, err := ParseAckFrame(b, versionBigEndian) + frame, err := parseAckFrame(b, versionBigEndian) Expect(err).ToNot(HaveOccurred()) Expect(frame.LargestAcked).To(Equal(protocol.PacketNumber(3))) Expect(frame.DelayTime).To(Equal(142 * time.Microsecond)) @@ -142,10 +142,10 @@ var _ = Describe("ACK Frame (for gQUIC)", func() { 0x1, 0x13, 0xae, 0xb, 0x0, // 1st timestamp 0x0, 0x80, 0x5, // 2nd timestamp } - _, err := ParseAckFrame(bytes.NewReader(data), versionBigEndian) + _, err := parseAckFrame(bytes.NewReader(data), versionBigEndian) Expect(err).NotTo(HaveOccurred()) for i := range data { - _, err := ParseAckFrame(bytes.NewReader(data[0:i]), versionBigEndian) + _, err := parseAckFrame(bytes.NewReader(data[0:i]), versionBigEndian) Expect(err).To(MatchError(io.EOF)) } }) @@ -158,7 +158,7 @@ var _ = Describe("ACK Frame (for gQUIC)", func() { 0x9, // block length 0, }) - frame, err := ParseAckFrame(b, versionBigEndian) + frame, err := parseAckFrame(b, versionBigEndian) Expect(err).ToNot(HaveOccurred()) Expect(frame.LargestAcked).To(Equal(protocol.PacketNumber(0x1337))) Expect(frame.LowestAcked).To(Equal(protocol.PacketNumber(0x1337 - 0x9 + 1))) @@ -173,7 +173,7 @@ var _ = Describe("ACK Frame (for gQUIC)", func() { 0x5, // block length 0, }) - frame, err := ParseAckFrame(b, versionBigEndian) + frame, err := parseAckFrame(b, versionBigEndian) Expect(err).ToNot(HaveOccurred()) Expect(frame.LargestAcked).To(Equal(protocol.PacketNumber(0xdecafbad))) Expect(frame.LowestAcked).To(Equal(protocol.PacketNumber(0xdecafbad - 5 + 1))) @@ -188,7 +188,7 @@ var _ = Describe("ACK Frame (for gQUIC)", func() { 0x5, // block length 0, }) - frame, err := ParseAckFrame(b, versionBigEndian) + frame, err := parseAckFrame(b, versionBigEndian) Expect(err).ToNot(HaveOccurred()) Expect(frame.LargestAcked).To(Equal(protocol.PacketNumber(0xdeadbeefcafe))) Expect(frame.LowestAcked).To(Equal(protocol.PacketNumber(0xdeadbeefcafe - 5 + 1))) @@ -207,7 +207,7 @@ var _ = Describe("ACK Frame (for gQUIC)", func() { 0x2, 0x10, // 2nd block 0, }) - frame, err := ParseAckFrame(b, versionBigEndian) + frame, err := parseAckFrame(b, versionBigEndian) Expect(err).ToNot(HaveOccurred()) Expect(frame.LargestAcked).To(Equal(protocol.PacketNumber(0x18))) Expect(frame.HasMissingRanges()).To(BeTrue()) @@ -228,7 +228,7 @@ var _ = Describe("ACK Frame (for gQUIC)", func() { 0x2, 0x15, // 2nd block 0, }) - _, err := ParseAckFrame(b, versionBigEndian) + _, err := parseAckFrame(b, versionBigEndian) Expect(err).To(MatchError(errInvalidAckRanges)) }) @@ -239,7 +239,7 @@ var _ = Describe("ACK Frame (for gQUIC)", func() { 0, // num ACK blocks 0, }) - _, err := ParseAckFrame(b, versionBigEndian) + _, err := parseAckFrame(b, versionBigEndian) Expect(err).To(MatchError(errInvalidAckRanges)) }) @@ -257,7 +257,7 @@ var _ = Describe("ACK Frame (for gQUIC)", func() { 0x1, 0x13, // 7th block 0, }) - frame, err := ParseAckFrame(b, versionBigEndian) + frame, err := parseAckFrame(b, versionBigEndian) Expect(err).ToNot(HaveOccurred()) Expect(frame.LargestAcked).To(Equal(protocol.PacketNumber(0x27))) Expect(frame.HasMissingRanges()).To(BeTrue()) @@ -284,7 +284,7 @@ var _ = Describe("ACK Frame (for gQUIC)", func() { 0x2, 0x12, // 4th block 0, }) - frame, err := ParseAckFrame(b, versionBigEndian) + frame, err := parseAckFrame(b, versionBigEndian) Expect(err).ToNot(HaveOccurred()) Expect(frame.LargestAcked).To(Equal(protocol.PacketNumber(0x52))) Expect(frame.HasMissingRanges()).To(BeTrue()) @@ -308,7 +308,7 @@ var _ = Describe("ACK Frame (for gQUIC)", func() { 0xff, 0x13, // 2nd block 0, }) - frame, err := ParseAckFrame(b, versionBigEndian) + frame, err := parseAckFrame(b, versionBigEndian) Expect(err).ToNot(HaveOccurred()) Expect(frame.LargestAcked).To(Equal(protocol.PacketNumber(0x115))) Expect(frame.HasMissingRanges()).To(BeTrue()) @@ -330,7 +330,7 @@ var _ = Describe("ACK Frame (for gQUIC)", func() { 0x1, 0x13, // 3rd block 0, }) - frame, err := ParseAckFrame(b, versionBigEndian) + frame, err := parseAckFrame(b, versionBigEndian) Expect(err).ToNot(HaveOccurred()) Expect(frame.LargestAcked).To(Equal(protocol.PacketNumber(0x114))) Expect(frame.HasMissingRanges()).To(BeTrue()) @@ -357,7 +357,7 @@ var _ = Describe("ACK Frame (for gQUIC)", func() { 0xff, 0x0, /*0x2d, 0x14,*/ // 6th block 0, }) - frame, err := ParseAckFrame(b, versionBigEndian) + frame, err := parseAckFrame(b, versionBigEndian) Expect(err).ToNot(HaveOccurred()) Expect(frame.LargestAcked).To(Equal(protocol.PacketNumber(0x39b))) Expect(frame.HasMissingRanges()).To(BeTrue()) @@ -379,7 +379,7 @@ var _ = Describe("ACK Frame (for gQUIC)", func() { 0x19, 0x13, // 3rd block 0, }) - frame, err := ParseAckFrame(b, versionBigEndian) + frame, err := parseAckFrame(b, versionBigEndian) Expect(err).ToNot(HaveOccurred()) Expect(frame.LargestAcked).To(Equal(protocol.PacketNumber(0x144))) Expect(frame.HasMissingRanges()).To(BeTrue()) @@ -409,7 +409,7 @@ var _ = Describe("ACK Frame (for gQUIC)", func() { 0x32, 0x13, // 11th block 0, }) - frame, err := ParseAckFrame(b, versionBigEndian) + frame, err := parseAckFrame(b, versionBigEndian) Expect(err).ToNot(HaveOccurred()) Expect(frame.LargestAcked).To(Equal(protocol.PacketNumber(0x95b))) Expect(frame.HasMissingRanges()).To(BeTrue()) @@ -435,7 +435,7 @@ var _ = Describe("ACK Frame (for gQUIC)", func() { 0x23, 0x0, 0x13, // 8th block 0, }) - frame, err := ParseAckFrame(b, versionBigEndian) + frame, err := parseAckFrame(b, versionBigEndian) Expect(err).ToNot(HaveOccurred()) Expect(frame.LargestAcked).To(Equal(protocol.PacketNumber(0x966))) Expect(frame.HasMissingRanges()).To(BeTrue()) @@ -457,7 +457,7 @@ var _ = Describe("ACK Frame (for gQUIC)", func() { 0x20, 0x12, 0x34, 0x56, 0x78, // 2nd block 0, }) - frame, err := ParseAckFrame(b, versionBigEndian) + frame, err := parseAckFrame(b, versionBigEndian) Expect(err).ToNot(HaveOccurred()) Expect(frame.LargestAcked).To(Equal(protocol.PacketNumber(0xdeadbeefcafe))) Expect(frame.HasMissingRanges()).To(BeTrue()) @@ -475,7 +475,7 @@ var _ = Describe("ACK Frame (for gQUIC)", func() { 0x20, 0x0, 0xab, 0x12, 0x34, 0x56, 0x78, // 2nd block 0, }) - frame, err := ParseAckFrame(b, versionBigEndian) + frame, err := parseAckFrame(b, versionBigEndian) Expect(err).ToNot(HaveOccurred()) Expect(frame.LargestAcked).To(Equal(protocol.PacketNumber(0xdeadbeefcafe))) Expect(frame.HasMissingRanges()).To(BeTrue()) @@ -503,7 +503,7 @@ var _ = Describe("ACK Frame (for gQUIC)", func() { err := frameOrig.Write(b, versionBigEndian) Expect(err).ToNot(HaveOccurred()) r := bytes.NewReader(b.Bytes()) - frame, err := ParseAckFrame(r, versionBigEndian) + frame, err := parseAckFrame(r, versionBigEndian) Expect(err).ToNot(HaveOccurred()) Expect(frame.LargestAcked).To(Equal(frameOrig.LargestAcked)) Expect(frame.HasMissingRanges()).To(BeFalse()) @@ -518,7 +518,7 @@ var _ = Describe("ACK Frame (for gQUIC)", func() { err := frameOrig.Write(b, versionBigEndian) Expect(err).ToNot(HaveOccurred()) r := bytes.NewReader(b.Bytes()) - frame, err := ParseAckFrame(r, versionBigEndian) + frame, err := parseAckFrame(r, versionBigEndian) Expect(err).ToNot(HaveOccurred()) Expect(frame.LargestAcked).To(Equal(frameOrig.LargestAcked)) Expect(frame.HasMissingRanges()).To(BeFalse()) @@ -533,7 +533,7 @@ var _ = Describe("ACK Frame (for gQUIC)", func() { err := frameOrig.Write(b, versionBigEndian) Expect(err).ToNot(HaveOccurred()) r := bytes.NewReader(b.Bytes()) - frame, err := ParseAckFrame(r, versionBigEndian) + frame, err := parseAckFrame(r, versionBigEndian) Expect(err).ToNot(HaveOccurred()) Expect(frame.LargestAcked).To(Equal(frameOrig.LargestAcked)) Expect(frame.LowestAcked).To(Equal(frameOrig.LowestAcked)) @@ -549,7 +549,7 @@ var _ = Describe("ACK Frame (for gQUIC)", func() { err := frameOrig.Write(b, versionBigEndian) Expect(err).ToNot(HaveOccurred()) r := bytes.NewReader(b.Bytes()) - frame, err := ParseAckFrame(r, versionBigEndian) + frame, err := parseAckFrame(r, versionBigEndian) Expect(err).ToNot(HaveOccurred()) Expect(frame.LargestAcked).To(Equal(frameOrig.LargestAcked)) Expect(frame.HasMissingRanges()).To(BeFalse()) @@ -568,7 +568,7 @@ var _ = Describe("ACK Frame (for gQUIC)", func() { err := frameOrig.Write(b, versionBigEndian) Expect(err).ToNot(HaveOccurred()) r := bytes.NewReader(b.Bytes()) - frame, err := ParseAckFrame(r, versionBigEndian) + frame, err := parseAckFrame(r, versionBigEndian) Expect(err).ToNot(HaveOccurred()) Expect(frame.LargestAcked).To(Equal(frameOrig.LargestAcked)) Expect(frame.LowestAcked).To(Equal(frameOrig.LowestAcked)) @@ -590,7 +590,7 @@ var _ = Describe("ACK Frame (for gQUIC)", func() { err := frameOrig.Write(b, versionBigEndian) Expect(err).ToNot(HaveOccurred()) r := bytes.NewReader(b.Bytes()) - frame, err := ParseAckFrame(r, versionBigEndian) + frame, err := parseAckFrame(r, versionBigEndian) Expect(err).ToNot(HaveOccurred()) Expect(frame.LargestAcked).To(Equal(frameOrig.LargestAcked)) Expect(frame.LowestAcked).To(Equal(frameOrig.LowestAcked)) @@ -638,7 +638,7 @@ var _ = Describe("ACK Frame (for gQUIC)", func() { err := frameOrig.Write(b, versionBigEndian) Expect(err).ToNot(HaveOccurred()) r := bytes.NewReader(b.Bytes()) - frame, err := ParseAckFrame(r, versionBigEndian) + frame, err := parseAckFrame(r, versionBigEndian) Expect(err).ToNot(HaveOccurred()) Expect(frame.LargestAcked).To(Equal(frameOrig.LargestAcked)) Expect(frame.AckRanges).To(Equal(frameOrig.AckRanges)) @@ -657,7 +657,7 @@ var _ = Describe("ACK Frame (for gQUIC)", func() { err := frameOrig.Write(b, versionBigEndian) Expect(err).ToNot(HaveOccurred()) r := bytes.NewReader(b.Bytes()) - frame, err := ParseAckFrame(r, versionBigEndian) + frame, err := parseAckFrame(r, versionBigEndian) Expect(err).ToNot(HaveOccurred()) Expect(frame.LargestAcked).To(Equal(frameOrig.LargestAcked)) Expect(frame.AckRanges).To(Equal(frameOrig.AckRanges)) @@ -676,7 +676,7 @@ var _ = Describe("ACK Frame (for gQUIC)", func() { err := frameOrig.Write(b, versionBigEndian) Expect(err).ToNot(HaveOccurred()) r := bytes.NewReader(b.Bytes()) - frame, err := ParseAckFrame(r, versionBigEndian) + frame, err := parseAckFrame(r, versionBigEndian) Expect(err).ToNot(HaveOccurred()) Expect(frame.LargestAcked).To(Equal(frameOrig.LargestAcked)) Expect(frame.AckRanges).To(Equal(frameOrig.AckRanges)) @@ -695,7 +695,7 @@ var _ = Describe("ACK Frame (for gQUIC)", func() { err := frameOrig.Write(b, versionBigEndian) Expect(err).ToNot(HaveOccurred()) r := bytes.NewReader(b.Bytes()) - frame, err := ParseAckFrame(r, versionBigEndian) + frame, err := parseAckFrame(r, versionBigEndian) Expect(err).ToNot(HaveOccurred()) Expect(frame.LargestAcked).To(Equal(frameOrig.LargestAcked)) Expect(frame.AckRanges).To(Equal(frameOrig.AckRanges)) @@ -714,7 +714,7 @@ var _ = Describe("ACK Frame (for gQUIC)", func() { err := frameOrig.Write(b, versionBigEndian) Expect(err).ToNot(HaveOccurred()) r := bytes.NewReader(b.Bytes()) - frame, err := ParseAckFrame(r, versionBigEndian) + frame, err := parseAckFrame(r, versionBigEndian) Expect(err).ToNot(HaveOccurred()) Expect(frame.LargestAcked).To(Equal(frameOrig.LargestAcked)) Expect(frame.AckRanges).To(Equal(frameOrig.AckRanges)) @@ -733,7 +733,7 @@ var _ = Describe("ACK Frame (for gQUIC)", func() { err := frameOrig.Write(b, versionBigEndian) Expect(err).ToNot(HaveOccurred()) r := bytes.NewReader(b.Bytes()) - frame, err := ParseAckFrame(r, versionBigEndian) + frame, err := parseAckFrame(r, versionBigEndian) Expect(err).ToNot(HaveOccurred()) Expect(frame.LargestAcked).To(Equal(frameOrig.LargestAcked)) Expect(frame.AckRanges).To(Equal(frameOrig.AckRanges)) @@ -751,7 +751,7 @@ var _ = Describe("ACK Frame (for gQUIC)", func() { err := frameOrig.Write(b, versionBigEndian) Expect(err).ToNot(HaveOccurred()) r := bytes.NewReader(b.Bytes()) - frame, err := ParseAckFrame(r, versionBigEndian) + frame, err := parseAckFrame(r, versionBigEndian) Expect(err).ToNot(HaveOccurred()) Expect(frame.LargestAcked).To(Equal(frameOrig.LargestAcked)) Expect(frame.AckRanges).To(Equal(frameOrig.AckRanges)) @@ -770,7 +770,7 @@ var _ = Describe("ACK Frame (for gQUIC)", func() { err := frameOrig.Write(b, versionBigEndian) Expect(err).ToNot(HaveOccurred()) r := bytes.NewReader(b.Bytes()) - frame, err := ParseAckFrame(r, versionBigEndian) + frame, err := parseAckFrame(r, versionBigEndian) Expect(err).ToNot(HaveOccurred()) Expect(frame.LargestAcked).To(Equal(frameOrig.LargestAcked)) Expect(frame.AckRanges).To(Equal(frameOrig.AckRanges)) @@ -787,7 +787,7 @@ var _ = Describe("ACK Frame (for gQUIC)", func() { Expect(err).ToNot(HaveOccurred()) Expect(b.Bytes()[0] & 0x3).To(Equal(byte(0x0))) r := bytes.NewReader(b.Bytes()) - frame, err := ParseAckFrame(r, versionBigEndian) + frame, err := parseAckFrame(r, versionBigEndian) Expect(err).ToNot(HaveOccurred()) Expect(frame.LargestAcked).To(Equal(frameOrig.LargestAcked)) Expect(frame.LowestAcked).To(Equal(frameOrig.LowestAcked)) @@ -803,7 +803,7 @@ var _ = Describe("ACK Frame (for gQUIC)", func() { Expect(err).ToNot(HaveOccurred()) Expect(b.Bytes()[0] & 0x3).To(Equal(byte(0x1))) r := bytes.NewReader(b.Bytes()) - frame, err := ParseAckFrame(r, versionBigEndian) + frame, err := parseAckFrame(r, versionBigEndian) Expect(err).ToNot(HaveOccurred()) Expect(frame.LargestAcked).To(Equal(frameOrig.LargestAcked)) Expect(frame.LowestAcked).To(Equal(frameOrig.LowestAcked)) @@ -819,7 +819,7 @@ var _ = Describe("ACK Frame (for gQUIC)", func() { Expect(err).ToNot(HaveOccurred()) Expect(b.Bytes()[0] & 0x3).To(Equal(byte(0x2))) r := bytes.NewReader(b.Bytes()) - frame, err := ParseAckFrame(r, versionBigEndian) + frame, err := parseAckFrame(r, versionBigEndian) Expect(err).ToNot(HaveOccurred()) Expect(frame.LargestAcked).To(Equal(frameOrig.LargestAcked)) Expect(frame.LowestAcked).To(Equal(frameOrig.LowestAcked)) @@ -835,7 +835,7 @@ var _ = Describe("ACK Frame (for gQUIC)", func() { Expect(err).ToNot(HaveOccurred()) Expect(b.Bytes()[0] & 0x3).To(Equal(byte(0x3))) r := bytes.NewReader(b.Bytes()) - frame, err := ParseAckFrame(r, versionBigEndian) + frame, err := parseAckFrame(r, versionBigEndian) Expect(err).ToNot(HaveOccurred()) Expect(frame.LargestAcked).To(Equal(frameOrig.LargestAcked)) Expect(frame.LowestAcked).To(Equal(frameOrig.LowestAcked)) @@ -858,7 +858,7 @@ var _ = Describe("ACK Frame (for gQUIC)", func() { Expect(err).ToNot(HaveOccurred()) Expect(b.Bytes()[0] & 0x3).To(Equal(byte(0x0))) r := bytes.NewReader(b.Bytes()) - frame, err := ParseAckFrame(r, versionBigEndian) + frame, err := parseAckFrame(r, versionBigEndian) Expect(err).ToNot(HaveOccurred()) Expect(frame.LargestAcked).To(Equal(frameOrig.LargestAcked)) Expect(frame.LowestAcked).To(Equal(frameOrig.LowestAcked)) @@ -879,7 +879,7 @@ var _ = Describe("ACK Frame (for gQUIC)", func() { Expect(err).ToNot(HaveOccurred()) Expect(b.Bytes()[0] & 0x3).To(Equal(byte(0x1))) r := bytes.NewReader(b.Bytes()) - frame, err := ParseAckFrame(r, versionBigEndian) + frame, err := parseAckFrame(r, versionBigEndian) Expect(err).ToNot(HaveOccurred()) Expect(frame.LargestAcked).To(Equal(frameOrig.LargestAcked)) Expect(frame.LowestAcked).To(Equal(frameOrig.LowestAcked)) @@ -900,7 +900,7 @@ var _ = Describe("ACK Frame (for gQUIC)", func() { Expect(err).ToNot(HaveOccurred()) Expect(b.Bytes()[0] & 0x3).To(Equal(byte(0x1))) r := bytes.NewReader(b.Bytes()) - frame, err := ParseAckFrame(r, versionBigEndian) + frame, err := parseAckFrame(r, versionBigEndian) Expect(err).ToNot(HaveOccurred()) Expect(frame.LargestAcked).To(Equal(frameOrig.LargestAcked)) Expect(frame.LowestAcked).To(Equal(frameOrig.LowestAcked)) @@ -921,7 +921,7 @@ var _ = Describe("ACK Frame (for gQUIC)", func() { Expect(err).ToNot(HaveOccurred()) Expect(b.Bytes()[0] & 0x3).To(Equal(byte(0x2))) r := bytes.NewReader(b.Bytes()) - frame, err := ParseAckFrame(r, versionBigEndian) + frame, err := parseAckFrame(r, versionBigEndian) Expect(err).ToNot(HaveOccurred()) Expect(frame.LargestAcked).To(Equal(frameOrig.LargestAcked)) Expect(frame.LowestAcked).To(Equal(frameOrig.LowestAcked)) @@ -942,7 +942,7 @@ var _ = Describe("ACK Frame (for gQUIC)", func() { Expect(err).ToNot(HaveOccurred()) Expect(b.Bytes()[0] & 0x3).To(Equal(byte(0x2))) r := bytes.NewReader(b.Bytes()) - frame, err := ParseAckFrame(r, versionBigEndian) + frame, err := parseAckFrame(r, versionBigEndian) Expect(err).ToNot(HaveOccurred()) Expect(frame.LargestAcked).To(Equal(frameOrig.LargestAcked)) Expect(frame.LowestAcked).To(Equal(frameOrig.LowestAcked)) @@ -963,7 +963,7 @@ var _ = Describe("ACK Frame (for gQUIC)", func() { Expect(err).ToNot(HaveOccurred()) Expect(b.Bytes()[0] & 0x3).To(Equal(byte(0x3))) r := bytes.NewReader(b.Bytes()) - frame, err := ParseAckFrame(r, versionBigEndian) + frame, err := parseAckFrame(r, versionBigEndian) Expect(err).ToNot(HaveOccurred()) Expect(frame.LargestAcked).To(Equal(frameOrig.LargestAcked)) Expect(frame.LowestAcked).To(Equal(frameOrig.LowestAcked)) @@ -984,7 +984,7 @@ var _ = Describe("ACK Frame (for gQUIC)", func() { Expect(err).ToNot(HaveOccurred()) Expect(b.Bytes()[0] & 0x3).To(Equal(byte(0x3))) r := bytes.NewReader(b.Bytes()) - frame, err := ParseAckFrame(r, versionBigEndian) + frame, err := parseAckFrame(r, versionBigEndian) Expect(err).ToNot(HaveOccurred()) Expect(frame.LargestAcked).To(Equal(frameOrig.LargestAcked)) Expect(frame.LowestAcked).To(Equal(frameOrig.LowestAcked)) @@ -1007,7 +1007,7 @@ var _ = Describe("ACK Frame (for gQUIC)", func() { err := frameOrig.Write(b, versionBigEndian) Expect(err).ToNot(HaveOccurred()) r := bytes.NewReader(b.Bytes()) - frame, err := ParseAckFrame(r, versionBigEndian) + frame, err := parseAckFrame(r, versionBigEndian) Expect(err).ToNot(HaveOccurred()) Expect(frame.LargestAcked).To(Equal(frameOrig.LargestAcked)) Expect(frame.LowestAcked).To(Equal(ackRanges[254].First)) @@ -1029,7 +1029,7 @@ var _ = Describe("ACK Frame (for gQUIC)", func() { err := frameOrig.Write(b, versionBigEndian) Expect(err).ToNot(HaveOccurred()) r := bytes.NewReader(b.Bytes()) - frame, err := ParseAckFrame(r, versionBigEndian) + frame, err := parseAckFrame(r, versionBigEndian) Expect(err).ToNot(HaveOccurred()) Expect(frame.LargestAcked).To(Equal(frameOrig.LargestAcked)) Expect(frame.LowestAcked).To(Equal(ackRanges[255/4].First)) @@ -1050,7 +1050,7 @@ var _ = Describe("ACK Frame (for gQUIC)", func() { err := frameOrig.Write(b, versionBigEndian) Expect(err).ToNot(HaveOccurred()) r := bytes.NewReader(b.Bytes()) - frame, err := ParseAckFrame(r, versionBigEndian) + frame, err := parseAckFrame(r, versionBigEndian) Expect(err).ToNot(HaveOccurred()) Expect(frame.LargestAcked).To(Equal(frameOrig.LargestAcked)) Expect(frame.AckRanges).To(HaveLen(2)) diff --git a/internal/wire/ack_frame_test.go b/internal/wire/ack_frame_test.go index 35952fc59..86eb2d454 100644 --- a/internal/wire/ack_frame_test.go +++ b/internal/wire/ack_frame_test.go @@ -19,7 +19,7 @@ var _ = Describe("ACK Frame (for IETF QUIC)", func() { data = append(data, encodeVarInt(0)...) // num blocks data = append(data, encodeVarInt(10)...) // first ack block b := bytes.NewReader(data) - frame, err := ParseAckFrame(b, versionIETFFrames) + frame, err := parseAckFrame(b, versionIETFFrames) Expect(err).ToNot(HaveOccurred()) Expect(frame.LargestAcked).To(Equal(protocol.PacketNumber(100))) Expect(frame.LowestAcked).To(Equal(protocol.PacketNumber(90))) @@ -34,7 +34,7 @@ var _ = Describe("ACK Frame (for IETF QUIC)", func() { data = append(data, encodeVarInt(0)...) // num blocks data = append(data, encodeVarInt(0)...) // first ack block b := bytes.NewReader(data) - frame, err := ParseAckFrame(b, versionIETFFrames) + frame, err := parseAckFrame(b, versionIETFFrames) Expect(err).ToNot(HaveOccurred()) Expect(frame.LargestAcked).To(Equal(protocol.PacketNumber(55))) Expect(frame.LowestAcked).To(Equal(protocol.PacketNumber(55))) @@ -49,7 +49,7 @@ var _ = Describe("ACK Frame (for IETF QUIC)", func() { data = append(data, encodeVarInt(0)...) // num blocks data = append(data, encodeVarInt(20)...) // first ack block b := bytes.NewReader(data) - frame, err := ParseAckFrame(b, versionIETFFrames) + frame, err := parseAckFrame(b, versionIETFFrames) Expect(err).ToNot(HaveOccurred()) Expect(frame.LargestAcked).To(Equal(protocol.PacketNumber(20))) Expect(frame.LowestAcked).To(Equal(protocol.PacketNumber(0))) @@ -64,7 +64,7 @@ var _ = Describe("ACK Frame (for IETF QUIC)", func() { data = append(data, encodeVarInt(0)...) // num blocks data = append(data, encodeVarInt(21)...) // first ack block b := bytes.NewReader(data) - _, err := ParseAckFrame(b, versionIETFFrames) + _, err := parseAckFrame(b, versionIETFFrames) Expect(err).To(MatchError("invalid first ACK range")) }) @@ -77,7 +77,7 @@ var _ = Describe("ACK Frame (for IETF QUIC)", func() { data = append(data, encodeVarInt(98)...) // gap data = append(data, encodeVarInt(50)...) // ack block b := bytes.NewReader(data) - frame, err := ParseAckFrame(b, versionIETFFrames) + frame, err := parseAckFrame(b, versionIETFFrames) Expect(err).ToNot(HaveOccurred()) Expect(frame.LargestAcked).To(Equal(protocol.PacketNumber(1000))) Expect(frame.LowestAcked).To(Equal(protocol.PacketNumber(750))) @@ -100,7 +100,7 @@ var _ = Describe("ACK Frame (for IETF QUIC)", func() { data = append(data, encodeVarInt(1)...) // gap data = append(data, encodeVarInt(1)...) // ack block b := bytes.NewReader(data) - frame, err := ParseAckFrame(b, versionIETFFrames) + frame, err := parseAckFrame(b, versionIETFFrames) Expect(err).ToNot(HaveOccurred()) Expect(frame.LargestAcked).To(Equal(protocol.PacketNumber(100))) Expect(frame.LowestAcked).To(Equal(protocol.PacketNumber(94))) @@ -121,10 +121,10 @@ var _ = Describe("ACK Frame (for IETF QUIC)", func() { data = append(data, encodeVarInt(100)...) // first ack block data = append(data, encodeVarInt(98)...) // gap data = append(data, encodeVarInt(50)...) // ack block - _, err := ParseAckFrame(bytes.NewReader(data), versionIETFFrames) + _, err := parseAckFrame(bytes.NewReader(data), versionIETFFrames) Expect(err).NotTo(HaveOccurred()) for i := range data { - _, err := ParseAckFrame(bytes.NewReader(data[0:i]), versionIETFFrames) + _, err := parseAckFrame(bytes.NewReader(data[0:i]), versionIETFFrames) Expect(err).To(MatchError(io.EOF)) } }) @@ -142,7 +142,7 @@ var _ = Describe("ACK Frame (for IETF QUIC)", func() { Expect(err).ToNot(HaveOccurred()) Expect(f.Length(versionIETFFrames)).To(BeEquivalentTo(buf.Len())) b := bytes.NewReader(buf.Bytes()) - frame, err := ParseAckFrame(b, versionIETFFrames) + frame, err := parseAckFrame(b, versionIETFFrames) Expect(err).ToNot(HaveOccurred()) Expect(frame).To(Equal(f)) Expect(frame.HasMissingRanges()).To(BeFalse()) @@ -159,7 +159,7 @@ var _ = Describe("ACK Frame (for IETF QUIC)", func() { Expect(err).ToNot(HaveOccurred()) Expect(f.Length(versionIETFFrames)).To(BeEquivalentTo(buf.Len())) b := bytes.NewReader(buf.Bytes()) - frame, err := ParseAckFrame(b, versionIETFFrames) + frame, err := parseAckFrame(b, versionIETFFrames) Expect(err).ToNot(HaveOccurred()) Expect(frame).To(Equal(f)) Expect(frame.HasMissingRanges()).To(BeFalse()) @@ -181,7 +181,7 @@ var _ = Describe("ACK Frame (for IETF QUIC)", func() { Expect(err).ToNot(HaveOccurred()) Expect(f.Length(versionIETFFrames)).To(BeEquivalentTo(buf.Len())) b := bytes.NewReader(buf.Bytes()) - frame, err := ParseAckFrame(b, versionIETFFrames) + frame, err := parseAckFrame(b, versionIETFFrames) Expect(err).ToNot(HaveOccurred()) Expect(frame).To(Equal(f)) Expect(frame.HasMissingRanges()).To(BeTrue()) @@ -205,7 +205,7 @@ var _ = Describe("ACK Frame (for IETF QUIC)", func() { Expect(err).ToNot(HaveOccurred()) Expect(f.Length(versionIETFFrames)).To(BeEquivalentTo(buf.Len())) b := bytes.NewReader(buf.Bytes()) - frame, err := ParseAckFrame(b, versionIETFFrames) + frame, err := parseAckFrame(b, versionIETFFrames) Expect(err).ToNot(HaveOccurred()) Expect(frame).To(Equal(f)) Expect(frame.HasMissingRanges()).To(BeTrue()) diff --git a/internal/wire/blocked_frame.go b/internal/wire/blocked_frame.go index e4cad2d6d..1d3e56e59 100644 --- a/internal/wire/blocked_frame.go +++ b/internal/wire/blocked_frame.go @@ -12,8 +12,8 @@ type BlockedFrame struct { Offset protocol.ByteCount } -// ParseBlockedFrame parses a BLOCKED frame -func ParseBlockedFrame(r *bytes.Reader, _ protocol.VersionNumber) (*BlockedFrame, error) { +// parseBlockedFrame parses a BLOCKED frame +func parseBlockedFrame(r *bytes.Reader, _ protocol.VersionNumber) (*BlockedFrame, error) { if _, err := r.ReadByte(); err != nil { return nil, err } diff --git a/internal/wire/blocked_frame_legacy.go b/internal/wire/blocked_frame_legacy.go index 41cf0ee7e..9943e1668 100644 --- a/internal/wire/blocked_frame_legacy.go +++ b/internal/wire/blocked_frame_legacy.go @@ -11,11 +11,11 @@ type blockedFrameLegacy struct { StreamID protocol.StreamID } -// ParseBlockedFrameLegacy parses a BLOCKED frame (in gQUIC format) +// parseBlockedFrameLegacy parses a BLOCKED frame (in gQUIC format) // The frame returned is // * a STREAM_BLOCKED frame, if the BLOCKED applies to a stream // * a BLOCKED frame, if the BLOCKED applies to the connection -func ParseBlockedFrameLegacy(r *bytes.Reader, _ protocol.VersionNumber) (Frame, error) { +func parseBlockedFrameLegacy(r *bytes.Reader, _ protocol.VersionNumber) (Frame, error) { if _, err := r.ReadByte(); err != nil { // read the TypeByte return nil, err } diff --git a/internal/wire/blocked_frame_legacy_test.go b/internal/wire/blocked_frame_legacy_test.go index a2d1ccbb4..6bd5abcf4 100644 --- a/internal/wire/blocked_frame_legacy_test.go +++ b/internal/wire/blocked_frame_legacy_test.go @@ -12,7 +12,7 @@ var _ = Describe("legacy BLOCKED Frame", func() { Context("when parsing", func() { It("accepts sample frame for a stream", func() { b := bytes.NewReader([]byte{0x5, 0xde, 0xad, 0xbe, 0xef}) - f, err := ParseBlockedFrameLegacy(b, versionBigEndian) + f, err := parseBlockedFrameLegacy(b, versionBigEndian) Expect(err).ToNot(HaveOccurred()) Expect(f).To(BeAssignableToTypeOf(&StreamBlockedFrame{})) frame := f.(*StreamBlockedFrame) @@ -21,7 +21,7 @@ var _ = Describe("legacy BLOCKED Frame", func() { It("accepts sample frame for the connection", func() { b := bytes.NewReader([]byte{0x5, 0x0, 0x0, 0x0, 0x0}) - f, err := ParseBlockedFrameLegacy(b, versionBigEndian) + f, err := parseBlockedFrameLegacy(b, versionBigEndian) Expect(err).ToNot(HaveOccurred()) Expect(f).To(BeAssignableToTypeOf(&BlockedFrame{})) }) @@ -29,10 +29,10 @@ var _ = Describe("legacy BLOCKED Frame", func() { It("errors on EOFs", func() { data := []byte{0x5, 0xef, 0xbe, 0xad, 0xde} - _, err := ParseBlockedFrameLegacy(bytes.NewReader(data), protocol.VersionWhatever) + _, err := parseBlockedFrameLegacy(bytes.NewReader(data), protocol.VersionWhatever) Expect(err).NotTo(HaveOccurred()) for i := range data { - _, err := ParseBlockedFrameLegacy(bytes.NewReader(data[0:i]), protocol.VersionWhatever) + _, err := parseBlockedFrameLegacy(bytes.NewReader(data[0:i]), protocol.VersionWhatever) Expect(err).To(HaveOccurred()) } }) diff --git a/internal/wire/blocked_frame_test.go b/internal/wire/blocked_frame_test.go index 302a7ed9b..ef67f4c3a 100644 --- a/internal/wire/blocked_frame_test.go +++ b/internal/wire/blocked_frame_test.go @@ -17,7 +17,7 @@ var _ = Describe("BLOCKED frame", func() { data := []byte{0x08} data = append(data, encodeVarInt(0x12345678)...) b := bytes.NewReader(data) - frame, err := ParseBlockedFrame(b, versionIETFFrames) + frame, err := parseBlockedFrame(b, versionIETFFrames) Expect(err).ToNot(HaveOccurred()) Expect(frame.Offset).To(Equal(protocol.ByteCount(0x12345678))) Expect(b.Len()).To(BeZero()) @@ -26,10 +26,10 @@ var _ = Describe("BLOCKED frame", func() { It("errors on EOFs", func() { data := []byte{0x08} data = append(data, encodeVarInt(0x12345678)...) - _, err := ParseBlockedFrame(bytes.NewReader(data), versionIETFFrames) + _, err := parseBlockedFrame(bytes.NewReader(data), versionIETFFrames) Expect(err).ToNot(HaveOccurred()) for i := range data { - _, err := ParseBlockedFrame(bytes.NewReader(data[:i]), versionIETFFrames) + _, err := parseBlockedFrame(bytes.NewReader(data[:i]), versionIETFFrames) Expect(err).To(MatchError(io.EOF)) } }) diff --git a/internal/wire/connection_close_frame.go b/internal/wire/connection_close_frame.go index e2f5b403c..667ded744 100644 --- a/internal/wire/connection_close_frame.go +++ b/internal/wire/connection_close_frame.go @@ -17,8 +17,8 @@ type ConnectionCloseFrame struct { ReasonPhrase string } -// ParseConnectionCloseFrame reads a CONNECTION_CLOSE frame -func ParseConnectionCloseFrame(r *bytes.Reader, version protocol.VersionNumber) (*ConnectionCloseFrame, error) { +// parseConnectionCloseFrame reads a CONNECTION_CLOSE frame +func parseConnectionCloseFrame(r *bytes.Reader, version protocol.VersionNumber) (*ConnectionCloseFrame, error) { if _, err := r.ReadByte(); err != nil { // read the TypeByte return nil, err } diff --git a/internal/wire/connection_close_frame_test.go b/internal/wire/connection_close_frame_test.go index 3da348e96..c43095da4 100644 --- a/internal/wire/connection_close_frame_test.go +++ b/internal/wire/connection_close_frame_test.go @@ -20,7 +20,7 @@ var _ = Describe("CONNECTION_CLOSE Frame", func() { 'N', 'o', ' ', 'r', 'e', 'c', 'e', 'n', 't', ' ', 'n', 'e', 't', 'w', 'o', 'r', 'k', ' ', 'a', 'c', 't', 'i', 'v', 'i', 't', 'y', '.', }...) b := bytes.NewReader(data) - frame, err := ParseConnectionCloseFrame(b, versionIETFFrames) + frame, err := parseConnectionCloseFrame(b, versionIETFFrames) Expect(err).ToNot(HaveOccurred()) Expect(frame.ErrorCode).To(Equal(qerr.ErrorCode(0x19))) Expect(frame.ReasonPhrase).To(Equal("No recent network activity.")) @@ -31,7 +31,7 @@ var _ = Describe("CONNECTION_CLOSE Frame", func() { data := []byte{0x2, 0xca, 0xfe} data = append(data, encodeVarInt(0xffff)...) // reason phrase length b := bytes.NewReader(data) - _, err := ParseConnectionCloseFrame(b, versionIETFFrames) + _, err := parseConnectionCloseFrame(b, versionIETFFrames) Expect(err).To(MatchError(io.EOF)) }) @@ -41,10 +41,10 @@ var _ = Describe("CONNECTION_CLOSE Frame", func() { data = append(data, []byte{ 'N', 'o', ' ', 'r', 'e', 'c', 'e', 'n', 't', ' ', 'n', 'e', 't', 'w', 'o', 'r', 'k', ' ', 'a', 'c', 't', 'i', 'v', 'i', 't', 'y', '.', }...) - _, err := ParseConnectionCloseFrame(bytes.NewReader(data), versionIETFFrames) + _, err := parseConnectionCloseFrame(bytes.NewReader(data), versionIETFFrames) Expect(err).NotTo(HaveOccurred()) for i := range data { - _, err := ParseConnectionCloseFrame(bytes.NewReader(data[0:i]), versionIETFFrames) + _, err := parseConnectionCloseFrame(bytes.NewReader(data[0:i]), versionIETFFrames) Expect(err).To(HaveOccurred()) } }) @@ -53,7 +53,7 @@ var _ = Describe("CONNECTION_CLOSE Frame", func() { data := []byte{0x2, 0xca, 0xfe} data = append(data, encodeVarInt(0)...) b := bytes.NewReader(data) - frame, err := ParseConnectionCloseFrame(b, versionIETFFrames) + frame, err := parseConnectionCloseFrame(b, versionIETFFrames) Expect(err).ToNot(HaveOccurred()) Expect(frame.ReasonPhrase).To(BeEmpty()) Expect(b.Len()).To(BeZero()) @@ -67,7 +67,7 @@ var _ = Describe("CONNECTION_CLOSE Frame", func() { 0x0, 0x1b, // reason phrase length 'N', 'o', ' ', 'r', 'e', 'c', 'e', 'n', 't', ' ', 'n', 'e', 't', 'w', 'o', 'r', 'k', ' ', 'a', 'c', 't', 'i', 'v', 'i', 't', 'y', '.', }) - frame, err := ParseConnectionCloseFrame(b, versionBigEndian) + frame, err := parseConnectionCloseFrame(b, versionBigEndian) Expect(err).ToNot(HaveOccurred()) Expect(frame.ErrorCode).To(Equal(qerr.ErrorCode(0x19))) Expect(frame.ReasonPhrase).To(Equal("No recent network activity.")) @@ -79,7 +79,7 @@ var _ = Describe("CONNECTION_CLOSE Frame", func() { 0xad, 0xfb, 0xca, 0xde, // error code 0xff, 0x0, // reason phrase length }) - _, err := ParseConnectionCloseFrame(b, versionBigEndian) + _, err := parseConnectionCloseFrame(b, versionBigEndian) Expect(err).To(MatchError(io.EOF)) }) @@ -89,10 +89,10 @@ var _ = Describe("CONNECTION_CLOSE Frame", func() { 0x0, 0x1b, // reason phrase length 'N', 'o', ' ', 'r', 'e', 'c', 'e', 'n', 't', ' ', 'n', 'e', 't', 'w', 'o', 'r', 'k', ' ', 'a', 'c', 't', 'i', 'v', 'i', 't', 'y', '.', } - _, err := ParseConnectionCloseFrame(bytes.NewReader(data), versionBigEndian) + _, err := parseConnectionCloseFrame(bytes.NewReader(data), versionBigEndian) Expect(err).NotTo(HaveOccurred()) for i := range data { - _, err := ParseConnectionCloseFrame(bytes.NewReader(data[0:i]), versionBigEndian) + _, err := parseConnectionCloseFrame(bytes.NewReader(data[0:i]), versionBigEndian) Expect(err).To(HaveOccurred()) } }) @@ -102,7 +102,7 @@ var _ = Describe("CONNECTION_CLOSE Frame", func() { 0xad, 0xfb, 0xca, 0xde, // error code 0x0, 0x0, // reason phrase length }) - frame, err := ParseConnectionCloseFrame(b, versionBigEndian) + frame, err := parseConnectionCloseFrame(b, versionBigEndian) Expect(err).ToNot(HaveOccurred()) Expect(frame.ReasonPhrase).To(BeEmpty()) Expect(b.Len()).To(BeZero()) diff --git a/internal/wire/frame_parser.go b/internal/wire/frame_parser.go index 9745a9ba6..6911446f9 100644 --- a/internal/wire/frame_parser.go +++ b/internal/wire/frame_parser.go @@ -30,7 +30,7 @@ func parseIETFFrame(r *bytes.Reader, typeByte byte, v protocol.VersionNumber) (F var frame Frame var err error if typeByte&0xf8 == 0x10 { - frame, err = ParseStreamFrame(r, v) + frame, err = parseStreamFrame(r, v) if err != nil { err = qerr.Error(qerr.InvalidStreamData, err.Error()) } @@ -39,54 +39,54 @@ func parseIETFFrame(r *bytes.Reader, typeByte byte, v protocol.VersionNumber) (F // TODO: implement all IETF QUIC frame types switch typeByte { case 0x1: - frame, err = ParseRstStreamFrame(r, v) + frame, err = parseRstStreamFrame(r, v) if err != nil { err = qerr.Error(qerr.InvalidRstStreamData, err.Error()) } case 0x2: - frame, err = ParseConnectionCloseFrame(r, v) + frame, err = parseConnectionCloseFrame(r, v) if err != nil { err = qerr.Error(qerr.InvalidConnectionCloseData, err.Error()) } case 0x4: - frame, err = ParseMaxDataFrame(r, v) + frame, err = parseMaxDataFrame(r, v) if err != nil { err = qerr.Error(qerr.InvalidWindowUpdateData, err.Error()) } case 0x5: - frame, err = ParseMaxStreamDataFrame(r, v) + frame, err = parseMaxStreamDataFrame(r, v) if err != nil { err = qerr.Error(qerr.InvalidWindowUpdateData, err.Error()) } case 0x6: - frame, err = ParseMaxStreamIDFrame(r, v) + frame, err = parseMaxStreamIDFrame(r, v) if err != nil { err = qerr.Error(qerr.InvalidFrameData, err.Error()) } case 0x7: - frame, err = ParsePingFrame(r, v) + frame, err = parsePingFrame(r, v) case 0x8: - frame, err = ParseBlockedFrame(r, v) + frame, err = parseBlockedFrame(r, v) if err != nil { err = qerr.Error(qerr.InvalidBlockedData, err.Error()) } case 0x9: - frame, err = ParseStreamBlockedFrame(r, v) + frame, err = parseStreamBlockedFrame(r, v) if err != nil { err = qerr.Error(qerr.InvalidBlockedData, err.Error()) } case 0xa: - frame, err = ParseStreamIDBlockedFrame(r, v) + frame, err = parseStreamIDBlockedFrame(r, v) if err != nil { err = qerr.Error(qerr.InvalidFrameData, err.Error()) } case 0xc: - frame, err = ParseStopSendingFrame(r, v) + frame, err = parseStopSendingFrame(r, v) if err != nil { err = qerr.Error(qerr.InvalidFrameData, err.Error()) } case 0xe: - frame, err = ParseAckFrame(r, v) + frame, err = parseAckFrame(r, v) if err != nil { err = qerr.Error(qerr.InvalidAckData, err.Error()) } @@ -100,13 +100,13 @@ func parseGQUICFrame(r *bytes.Reader, typeByte byte, hdr *Header, v protocol.Ver var frame Frame var err error if typeByte&0x80 == 0x80 { - frame, err = ParseStreamFrame(r, v) + frame, err = parseStreamFrame(r, v) if err != nil { err = qerr.Error(qerr.InvalidStreamData, err.Error()) } return frame, err } else if typeByte&0xc0 == 0x40 { - frame, err = ParseAckFrame(r, v) + frame, err = parseAckFrame(r, v) if err != nil { err = qerr.Error(qerr.InvalidAckData, err.Error()) } @@ -114,37 +114,37 @@ func parseGQUICFrame(r *bytes.Reader, typeByte byte, hdr *Header, v protocol.Ver } switch typeByte { case 0x1: - frame, err = ParseRstStreamFrame(r, v) + frame, err = parseRstStreamFrame(r, v) if err != nil { err = qerr.Error(qerr.InvalidRstStreamData, err.Error()) } case 0x2: - frame, err = ParseConnectionCloseFrame(r, v) + frame, err = parseConnectionCloseFrame(r, v) if err != nil { err = qerr.Error(qerr.InvalidConnectionCloseData, err.Error()) } case 0x3: - frame, err = ParseGoawayFrame(r, v) + frame, err = parseGoawayFrame(r, v) if err != nil { err = qerr.Error(qerr.InvalidGoawayData, err.Error()) } case 0x4: - frame, err = ParseWindowUpdateFrame(r, v) + frame, err = parseWindowUpdateFrame(r, v) if err != nil { err = qerr.Error(qerr.InvalidWindowUpdateData, err.Error()) } case 0x5: - frame, err = ParseBlockedFrameLegacy(r, v) + frame, err = parseBlockedFrameLegacy(r, v) if err != nil { err = qerr.Error(qerr.InvalidBlockedData, err.Error()) } case 0x6: - frame, err = ParseStopWaitingFrame(r, hdr.PacketNumber, hdr.PacketNumberLen, v) + frame, err = parseStopWaitingFrame(r, hdr.PacketNumber, hdr.PacketNumberLen, v) if err != nil { err = qerr.Error(qerr.InvalidStopWaitingData, err.Error()) } case 0x7: - frame, err = ParsePingFrame(r, v) + frame, err = parsePingFrame(r, v) default: err = qerr.Error(qerr.InvalidFrameData, fmt.Sprintf("unknown type byte 0x%x", typeByte)) } diff --git a/internal/wire/goaway_frame.go b/internal/wire/goaway_frame.go index 8a91e5023..86bf2b439 100644 --- a/internal/wire/goaway_frame.go +++ b/internal/wire/goaway_frame.go @@ -16,8 +16,8 @@ type GoawayFrame struct { ReasonPhrase string } -// ParseGoawayFrame parses a GOAWAY frame -func ParseGoawayFrame(r *bytes.Reader, _ protocol.VersionNumber) (*GoawayFrame, error) { +// parseGoawayFrame parses a GOAWAY frame +func parseGoawayFrame(r *bytes.Reader, _ protocol.VersionNumber) (*GoawayFrame, error) { frame := &GoawayFrame{} if _, err := r.ReadByte(); err != nil { diff --git a/internal/wire/goaway_frame_test.go b/internal/wire/goaway_frame_test.go index 1db5fa454..611276491 100644 --- a/internal/wire/goaway_frame_test.go +++ b/internal/wire/goaway_frame_test.go @@ -20,7 +20,7 @@ var _ = Describe("GoawayFrame", func() { 0x0, 0x3, // reason phrase length 'f', 'o', 'o', }) - frame, err := ParseGoawayFrame(b, versionBigEndian) + frame, err := parseGoawayFrame(b, versionBigEndian) Expect(frame).To(Equal(&GoawayFrame{ ErrorCode: 0x1337, LastGoodStream: 0x1234, @@ -37,10 +37,10 @@ var _ = Describe("GoawayFrame", func() { 0x0, 0x3, // reason phrase length 'f', 'o', 'o', } - _, err := ParseGoawayFrame(bytes.NewReader(data), versionBigEndian) + _, err := parseGoawayFrame(bytes.NewReader(data), versionBigEndian) Expect(err).NotTo(HaveOccurred()) for i := range data { - _, err := ParseGoawayFrame(bytes.NewReader(data[0:i]), versionBigEndian) + _, err := parseGoawayFrame(bytes.NewReader(data[0:i]), versionBigEndian) Expect(err).To(HaveOccurred()) } }) @@ -52,7 +52,7 @@ var _ = Describe("GoawayFrame", func() { 0x2, 0x0, 0x0, 0x0, // last good stream id 0xff, 0xff, // reason phrase length }) - _, err := ParseGoawayFrame(b, protocol.VersionWhatever) + _, err := parseGoawayFrame(b, protocol.VersionWhatever) Expect(err).To(MatchError(qerr.Error(qerr.InvalidGoawayData, "reason phrase too long"))) }) }) diff --git a/internal/wire/max_data_frame.go b/internal/wire/max_data_frame.go index 8ba4fc09a..0bca27da8 100644 --- a/internal/wire/max_data_frame.go +++ b/internal/wire/max_data_frame.go @@ -12,8 +12,8 @@ type MaxDataFrame struct { ByteOffset protocol.ByteCount } -// ParseMaxDataFrame parses a MAX_DATA frame -func ParseMaxDataFrame(r *bytes.Reader, version protocol.VersionNumber) (*MaxDataFrame, error) { +// parseMaxDataFrame parses a MAX_DATA frame +func parseMaxDataFrame(r *bytes.Reader, version protocol.VersionNumber) (*MaxDataFrame, error) { // read the TypeByte if _, err := r.ReadByte(); err != nil { return nil, err diff --git a/internal/wire/max_data_frame_test.go b/internal/wire/max_data_frame_test.go index d4ddd63cd..a56d26165 100644 --- a/internal/wire/max_data_frame_test.go +++ b/internal/wire/max_data_frame_test.go @@ -15,7 +15,7 @@ var _ = Describe("MAX_DATA frame", func() { data := []byte{0x4} data = append(data, encodeVarInt(0xdecafbad123456)...) // byte offset b := bytes.NewReader(data) - frame, err := ParseMaxDataFrame(b, versionBigEndian) + frame, err := parseMaxDataFrame(b, versionBigEndian) Expect(err).ToNot(HaveOccurred()) Expect(frame.ByteOffset).To(Equal(protocol.ByteCount(0xdecafbad123456))) Expect(b.Len()).To(BeZero()) @@ -24,10 +24,10 @@ var _ = Describe("MAX_DATA frame", func() { It("errors on EOFs", func() { data := []byte{0x4} data = append(data, encodeVarInt(0xdecafbad1234567)...) // byte offset - _, err := ParseMaxDataFrame(bytes.NewReader(data), versionIETFFrames) + _, err := parseMaxDataFrame(bytes.NewReader(data), versionIETFFrames) Expect(err).NotTo(HaveOccurred()) for i := range data { - _, err := ParseMaxDataFrame(bytes.NewReader(data[0:i]), versionIETFFrames) + _, err := parseMaxDataFrame(bytes.NewReader(data[0:i]), versionIETFFrames) Expect(err).To(HaveOccurred()) } }) diff --git a/internal/wire/max_stream_data_frame.go b/internal/wire/max_stream_data_frame.go index e88f245b5..6d8be236d 100644 --- a/internal/wire/max_stream_data_frame.go +++ b/internal/wire/max_stream_data_frame.go @@ -13,8 +13,8 @@ type MaxStreamDataFrame struct { ByteOffset protocol.ByteCount } -// ParseMaxStreamDataFrame parses a MAX_STREAM_DATA frame -func ParseMaxStreamDataFrame(r *bytes.Reader, version protocol.VersionNumber) (*MaxStreamDataFrame, error) { +// parseMaxStreamDataFrame parses a MAX_STREAM_DATA frame +func parseMaxStreamDataFrame(r *bytes.Reader, version protocol.VersionNumber) (*MaxStreamDataFrame, error) { frame := &MaxStreamDataFrame{} // read the TypeByte diff --git a/internal/wire/max_stream_data_frame_test.go b/internal/wire/max_stream_data_frame_test.go index aca7b4984..06f7c2456 100644 --- a/internal/wire/max_stream_data_frame_test.go +++ b/internal/wire/max_stream_data_frame_test.go @@ -16,7 +16,7 @@ var _ = Describe("MAX_STREAM_DATA frame", func() { data = append(data, encodeVarInt(0xdeadbeef)...) // Stream ID data = append(data, encodeVarInt(0x12345678)...) // Offset b := bytes.NewReader(data) - frame, err := ParseMaxStreamDataFrame(b, versionIETFFrames) + frame, err := parseMaxStreamDataFrame(b, versionIETFFrames) Expect(err).ToNot(HaveOccurred()) Expect(frame.StreamID).To(Equal(protocol.StreamID(0xdeadbeef))) Expect(frame.ByteOffset).To(Equal(protocol.ByteCount(0x12345678))) @@ -27,10 +27,10 @@ var _ = Describe("MAX_STREAM_DATA frame", func() { data := []byte{0x5} data = append(data, encodeVarInt(0xdeadbeef)...) // Stream ID data = append(data, encodeVarInt(0x12345678)...) // Offset - _, err := ParseMaxStreamDataFrame(bytes.NewReader(data), versionIETFFrames) + _, err := parseMaxStreamDataFrame(bytes.NewReader(data), versionIETFFrames) Expect(err).NotTo(HaveOccurred()) for i := range data { - _, err := ParseMaxStreamDataFrame(bytes.NewReader(data[0:i]), versionIETFFrames) + _, err := parseMaxStreamDataFrame(bytes.NewReader(data[0:i]), versionIETFFrames) Expect(err).To(HaveOccurred()) } }) diff --git a/internal/wire/max_stream_id_frame.go b/internal/wire/max_stream_id_frame.go index 31e51ae3d..9f5424daa 100644 --- a/internal/wire/max_stream_id_frame.go +++ b/internal/wire/max_stream_id_frame.go @@ -12,8 +12,8 @@ type MaxStreamIDFrame struct { StreamID protocol.StreamID } -// ParseMaxStreamIDFrame parses a MAX_STREAM_ID frame -func ParseMaxStreamIDFrame(r *bytes.Reader, _ protocol.VersionNumber) (*MaxStreamIDFrame, error) { +// parseMaxStreamIDFrame parses a MAX_STREAM_ID frame +func parseMaxStreamIDFrame(r *bytes.Reader, _ protocol.VersionNumber) (*MaxStreamIDFrame, error) { // read the Type byte if _, err := r.ReadByte(); err != nil { return nil, err diff --git a/internal/wire/max_stream_id_frame_test.go b/internal/wire/max_stream_id_frame_test.go index 7bbfd9604..66a27e7ba 100644 --- a/internal/wire/max_stream_id_frame_test.go +++ b/internal/wire/max_stream_id_frame_test.go @@ -15,7 +15,7 @@ var _ = Describe("MAX_STREAM_ID frame", func() { data := []byte{0x6} data = append(data, encodeVarInt(0xdecafbad)...) b := bytes.NewReader(data) - f, err := ParseMaxStreamIDFrame(b, protocol.VersionWhatever) + f, err := parseMaxStreamIDFrame(b, protocol.VersionWhatever) Expect(err).ToNot(HaveOccurred()) Expect(f.StreamID).To(Equal(protocol.StreamID(0xdecafbad))) Expect(b.Len()).To(BeZero()) @@ -24,10 +24,10 @@ var _ = Describe("MAX_STREAM_ID frame", func() { It("errors on EOFs", func() { data := []byte{0x06} data = append(data, encodeVarInt(0xdeadbeefcafe13)...) - _, err := ParseMaxStreamIDFrame(bytes.NewReader(data), protocol.VersionWhatever) + _, err := parseMaxStreamIDFrame(bytes.NewReader(data), protocol.VersionWhatever) Expect(err).NotTo(HaveOccurred()) for i := range data { - _, err := ParseMaxStreamIDFrame(bytes.NewReader(data[0:i]), protocol.VersionWhatever) + _, err := parseMaxStreamIDFrame(bytes.NewReader(data[0:i]), protocol.VersionWhatever) Expect(err).To(HaveOccurred()) } }) diff --git a/internal/wire/ping_frame.go b/internal/wire/ping_frame.go index ac4fd7d25..bc1dedac0 100644 --- a/internal/wire/ping_frame.go +++ b/internal/wire/ping_frame.go @@ -9,8 +9,8 @@ import ( // A PingFrame is a ping frame type PingFrame struct{} -// ParsePingFrame parses a Ping frame -func ParsePingFrame(r *bytes.Reader, version protocol.VersionNumber) (*PingFrame, error) { +// parsePingFrame parses a Ping frame +func parsePingFrame(r *bytes.Reader, version protocol.VersionNumber) (*PingFrame, error) { frame := &PingFrame{} _, err := r.ReadByte() diff --git a/internal/wire/ping_frame_test.go b/internal/wire/ping_frame_test.go index d12fc144d..54c7c6c16 100644 --- a/internal/wire/ping_frame_test.go +++ b/internal/wire/ping_frame_test.go @@ -12,13 +12,13 @@ var _ = Describe("PingFrame", func() { Context("when parsing", func() { It("accepts sample frame", func() { b := bytes.NewReader([]byte{0x07}) - _, err := ParsePingFrame(b, protocol.VersionWhatever) + _, err := parsePingFrame(b, protocol.VersionWhatever) Expect(err).ToNot(HaveOccurred()) Expect(b.Len()).To(BeZero()) }) It("errors on EOFs", func() { - _, err := ParsePingFrame(bytes.NewReader(nil), protocol.VersionWhatever) + _, err := parsePingFrame(bytes.NewReader(nil), protocol.VersionWhatever) Expect(err).To(HaveOccurred()) }) }) diff --git a/internal/wire/rst_stream_frame.go b/internal/wire/rst_stream_frame.go index ea25f381d..209422c28 100644 --- a/internal/wire/rst_stream_frame.go +++ b/internal/wire/rst_stream_frame.go @@ -16,8 +16,8 @@ type RstStreamFrame struct { ByteOffset protocol.ByteCount } -// ParseRstStreamFrame parses a RST_STREAM frame -func ParseRstStreamFrame(r *bytes.Reader, version protocol.VersionNumber) (*RstStreamFrame, error) { +// parseRstStreamFrame parses a RST_STREAM frame +func parseRstStreamFrame(r *bytes.Reader, version protocol.VersionNumber) (*RstStreamFrame, error) { if _, err := r.ReadByte(); err != nil { // read the TypeByte return nil, err } diff --git a/internal/wire/rst_stream_frame_test.go b/internal/wire/rst_stream_frame_test.go index fb4887ae3..f39be0f7b 100644 --- a/internal/wire/rst_stream_frame_test.go +++ b/internal/wire/rst_stream_frame_test.go @@ -18,7 +18,7 @@ var _ = Describe("RST_STREAM frame", func() { data = append(data, []byte{0x13, 0x37}...) // error code data = append(data, encodeVarInt(0x987654321)...) // byte offset b := bytes.NewReader(data) - frame, err := ParseRstStreamFrame(b, versionIETFFrames) + frame, err := parseRstStreamFrame(b, versionIETFFrames) Expect(err).ToNot(HaveOccurred()) Expect(frame.StreamID).To(Equal(protocol.StreamID(0xdeadbeef))) Expect(frame.ByteOffset).To(Equal(protocol.ByteCount(0x987654321))) @@ -30,10 +30,10 @@ var _ = Describe("RST_STREAM frame", func() { data = append(data, encodeVarInt(0xdeadbeef)...) // stream ID data = append(data, []byte{0x13, 0x37}...) // error code data = append(data, encodeVarInt(0x987654321)...) // byte offset - _, err := ParseRstStreamFrame(bytes.NewReader(data), versionIETFFrames) + _, err := parseRstStreamFrame(bytes.NewReader(data), versionIETFFrames) Expect(err).NotTo(HaveOccurred()) for i := range data { - _, err := ParseRstStreamFrame(bytes.NewReader(data[0:i]), versionIETFFrames) + _, err := parseRstStreamFrame(bytes.NewReader(data[0:i]), versionIETFFrames) Expect(err).To(HaveOccurred()) } }) @@ -46,7 +46,7 @@ var _ = Describe("RST_STREAM frame", func() { 0x88, 0x77, 0x66, 0x55, 0x44, 0x33, 0x22, 0x11, // byte offset 0x0, 0x0, 0xca, 0xfe, // error code }) - frame, err := ParseRstStreamFrame(b, versionBigEndian) + frame, err := parseRstStreamFrame(b, versionBigEndian) Expect(err).ToNot(HaveOccurred()) Expect(frame.StreamID).To(Equal(protocol.StreamID(0xdeadbeef))) Expect(frame.ByteOffset).To(Equal(protocol.ByteCount(0x8877665544332211))) @@ -59,10 +59,10 @@ var _ = Describe("RST_STREAM frame", func() { 0x33, 0x22, 0x11, 0xad, 0xfb, 0xca, 0xde, 0x34, // byte offset 0x12, 0x37, 0x13, // error code } - _, err := ParseRstStreamFrame(bytes.NewReader(data), versionBigEndian) + _, err := parseRstStreamFrame(bytes.NewReader(data), versionBigEndian) Expect(err).NotTo(HaveOccurred()) for i := range data { - _, err := ParseRstStreamFrame(bytes.NewReader(data[0:i]), versionBigEndian) + _, err := parseRstStreamFrame(bytes.NewReader(data[0:i]), versionBigEndian) Expect(err).To(HaveOccurred()) } }) diff --git a/internal/wire/stop_sending_frame.go b/internal/wire/stop_sending_frame.go index 2a33756bd..b5e698047 100644 --- a/internal/wire/stop_sending_frame.go +++ b/internal/wire/stop_sending_frame.go @@ -13,8 +13,8 @@ type StopSendingFrame struct { ErrorCode protocol.ApplicationErrorCode } -// ParseStopSendingFrame parses a STOP_SENDING frame -func ParseStopSendingFrame(r *bytes.Reader, _ protocol.VersionNumber) (*StopSendingFrame, error) { +// parseStopSendingFrame parses a STOP_SENDING frame +func parseStopSendingFrame(r *bytes.Reader, _ protocol.VersionNumber) (*StopSendingFrame, error) { if _, err := r.ReadByte(); err != nil { // read the TypeByte return nil, err } diff --git a/internal/wire/stop_sending_frame_test.go b/internal/wire/stop_sending_frame_test.go index 28baf6bc2..2f93487ac 100644 --- a/internal/wire/stop_sending_frame_test.go +++ b/internal/wire/stop_sending_frame_test.go @@ -17,7 +17,7 @@ var _ = Describe("STOP_SENDING frame", func() { data = append(data, encodeVarInt(0xdecafbad)...) // stream ID data = append(data, []byte{0x13, 0x37}...) // error code b := bytes.NewReader(data) - frame, err := ParseStopSendingFrame(b, versionIETFFrames) + frame, err := parseStopSendingFrame(b, versionIETFFrames) Expect(err).ToNot(HaveOccurred()) Expect(frame.StreamID).To(Equal(protocol.StreamID(0xdecafbad))) Expect(frame.ErrorCode).To(Equal(protocol.ApplicationErrorCode(0x1337))) @@ -28,10 +28,10 @@ var _ = Describe("STOP_SENDING frame", func() { data := []byte{0x0c} data = append(data, encodeVarInt(0xdecafbad)...) // stream ID data = append(data, []byte{0x13, 0x37}...) // error code - _, err := ParseStopSendingFrame(bytes.NewReader(data), versionIETFFrames) + _, err := parseStopSendingFrame(bytes.NewReader(data), versionIETFFrames) Expect(err).NotTo(HaveOccurred()) for i := range data { - _, err := ParseStopSendingFrame(bytes.NewReader(data[:i]), versionIETFFrames) + _, err := parseStopSendingFrame(bytes.NewReader(data[:i]), versionIETFFrames) Expect(err).To(HaveOccurred()) } }) diff --git a/internal/wire/stop_waiting_frame.go b/internal/wire/stop_waiting_frame.go index 4ee9578e6..b87606ad3 100644 --- a/internal/wire/stop_waiting_frame.go +++ b/internal/wire/stop_waiting_frame.go @@ -56,8 +56,8 @@ func (f *StopWaitingFrame) Length(_ protocol.VersionNumber) protocol.ByteCount { return 1 + protocol.ByteCount(f.PacketNumberLen) } -// ParseStopWaitingFrame parses a StopWaiting frame -func ParseStopWaitingFrame(r *bytes.Reader, packetNumber protocol.PacketNumber, packetNumberLen protocol.PacketNumberLen, _ protocol.VersionNumber) (*StopWaitingFrame, error) { +// parseStopWaitingFrame parses a StopWaiting frame +func parseStopWaitingFrame(r *bytes.Reader, packetNumber protocol.PacketNumber, packetNumberLen protocol.PacketNumberLen, _ protocol.VersionNumber) (*StopWaitingFrame, error) { frame := &StopWaitingFrame{} // read the TypeByte diff --git a/internal/wire/stop_waiting_frame_test.go b/internal/wire/stop_waiting_frame_test.go index f948e013e..7452f06da 100644 --- a/internal/wire/stop_waiting_frame_test.go +++ b/internal/wire/stop_waiting_frame_test.go @@ -13,7 +13,7 @@ var _ = Describe("StopWaitingFrame", func() { Context("in big endian", func() { It("accepts sample frame", func() { b := bytes.NewReader([]byte{0x06, 0x12, 0x34}) - frame, err := ParseStopWaitingFrame(b, 0x1337, 2, versionBigEndian) + frame, err := parseStopWaitingFrame(b, 0x1337, 2, versionBigEndian) Expect(err).ToNot(HaveOccurred()) Expect(frame.LeastUnacked).To(Equal(protocol.PacketNumber(0x1337 - 0x1234))) Expect(b.Len()).To(BeZero()) @@ -22,14 +22,14 @@ var _ = Describe("StopWaitingFrame", func() { It("rejects frames that would have a negative LeastUnacked value", func() { b := bytes.NewReader([]byte{0x06, 0xD}) - _, err := ParseStopWaitingFrame(b, 10, 1, protocol.VersionWhatever) + _, err := parseStopWaitingFrame(b, 10, 1, protocol.VersionWhatever) Expect(err).To(HaveOccurred()) Expect(b.Len()).To(BeZero()) }) It("parses a frame with 0 as LeastUnacked", func() { b := bytes.NewReader([]byte{0x6, 0x8}) - frame, err := ParseStopWaitingFrame(b, 8, 1, protocol.VersionWhatever) + frame, err := parseStopWaitingFrame(b, 8, 1, protocol.VersionWhatever) Expect(err).ToNot(HaveOccurred()) Expect(frame.LeastUnacked).To(Equal(protocol.PacketNumber(0))) Expect(b.Len()).To(BeZero()) @@ -37,16 +37,16 @@ var _ = Describe("StopWaitingFrame", func() { It("rejects frames that underflow LeastUnacked", func() { b := bytes.NewReader([]byte{0x6, 0x9}) - _, err := ParseStopWaitingFrame(b, 8, 1, protocol.VersionWhatever) + _, err := parseStopWaitingFrame(b, 8, 1, protocol.VersionWhatever) Expect(err).To(MatchError("invalid LeastUnackedDelta")) }) It("errors on EOFs", func() { data := []byte{0x06, 0x03} - _, err := ParseStopWaitingFrame(bytes.NewReader(data), 5, 1, protocol.VersionWhatever) + _, err := parseStopWaitingFrame(bytes.NewReader(data), 5, 1, protocol.VersionWhatever) Expect(err).NotTo(HaveOccurred()) for i := range data { - _, err := ParseStopWaitingFrame(bytes.NewReader(data[0:i]), 5, 1, protocol.VersionWhatever) + _, err := parseStopWaitingFrame(bytes.NewReader(data[0:i]), 5, 1, protocol.VersionWhatever) Expect(err).To(HaveOccurred()) } }) @@ -200,7 +200,7 @@ var _ = Describe("StopWaitingFrame", func() { b := &bytes.Buffer{} err := frame.Write(b, versionBigEndian) Expect(err).ToNot(HaveOccurred()) - readframe, err := ParseStopWaitingFrame(bytes.NewReader(b.Bytes()), packetNumber, protocol.PacketNumberLen4, versionBigEndian) + readframe, err := parseStopWaitingFrame(bytes.NewReader(b.Bytes()), packetNumber, protocol.PacketNumberLen4, versionBigEndian) Expect(err).ToNot(HaveOccurred()) Expect(readframe.LeastUnacked).To(Equal(frame.LeastUnacked)) }) diff --git a/internal/wire/stream_blocked_frame.go b/internal/wire/stream_blocked_frame.go index 625698cd1..a083a9f59 100644 --- a/internal/wire/stream_blocked_frame.go +++ b/internal/wire/stream_blocked_frame.go @@ -13,8 +13,8 @@ type StreamBlockedFrame struct { Offset protocol.ByteCount } -// ParseStreamBlockedFrame parses a STREAM_BLOCKED frame -func ParseStreamBlockedFrame(r *bytes.Reader, _ protocol.VersionNumber) (*StreamBlockedFrame, error) { +// parseStreamBlockedFrame parses a STREAM_BLOCKED frame +func parseStreamBlockedFrame(r *bytes.Reader, _ protocol.VersionNumber) (*StreamBlockedFrame, error) { if _, err := r.ReadByte(); err != nil { // read the TypeByte return nil, err } diff --git a/internal/wire/stream_blocked_frame_test.go b/internal/wire/stream_blocked_frame_test.go index 9cbd7563b..d72f4bda5 100644 --- a/internal/wire/stream_blocked_frame_test.go +++ b/internal/wire/stream_blocked_frame_test.go @@ -17,7 +17,7 @@ var _ = Describe("STREAM_BLOCKED frame", func() { data = append(data, encodeVarInt(0xdeadbeef)...) // stream ID data = append(data, encodeVarInt(0xdecafbad)...) // offset b := bytes.NewReader(data) - frame, err := ParseStreamBlockedFrame(b, versionIETFFrames) + frame, err := parseStreamBlockedFrame(b, versionIETFFrames) Expect(err).ToNot(HaveOccurred()) Expect(frame.StreamID).To(Equal(protocol.StreamID(0xdeadbeef))) Expect(frame.Offset).To(Equal(protocol.ByteCount(0xdecafbad))) @@ -28,10 +28,10 @@ var _ = Describe("STREAM_BLOCKED frame", func() { data := []byte{0x9} data = append(data, encodeVarInt(0xdeadbeef)...) data = append(data, encodeVarInt(0xc0010ff)...) - _, err := ParseStreamBlockedFrame(bytes.NewReader(data), versionIETFFrames) + _, err := parseStreamBlockedFrame(bytes.NewReader(data), versionIETFFrames) Expect(err).NotTo(HaveOccurred()) for i := range data { - _, err := ParseStreamBlockedFrame(bytes.NewReader(data[0:i]), versionIETFFrames) + _, err := parseStreamBlockedFrame(bytes.NewReader(data[0:i]), versionIETFFrames) Expect(err).To(HaveOccurred()) } }) diff --git a/internal/wire/stream_frame.go b/internal/wire/stream_frame.go index b87fce227..2b1f7e8ba 100644 --- a/internal/wire/stream_frame.go +++ b/internal/wire/stream_frame.go @@ -19,8 +19,8 @@ type StreamFrame struct { Data []byte } -// ParseStreamFrame reads a STREAM frame -func ParseStreamFrame(r *bytes.Reader, version protocol.VersionNumber) (*StreamFrame, error) { +// parseStreamFrame reads a STREAM frame +func parseStreamFrame(r *bytes.Reader, version protocol.VersionNumber) (*StreamFrame, error) { if !version.UsesIETFFrameFormat() { return parseLegacyStreamFrame(r, version) } diff --git a/internal/wire/stream_frame_legacy_test.go b/internal/wire/stream_frame_legacy_test.go index 7c0922d2f..7927e92aa 100644 --- a/internal/wire/stream_frame_legacy_test.go +++ b/internal/wire/stream_frame_legacy_test.go @@ -20,7 +20,7 @@ var _ = Describe("STREAM frame (for gQUIC)", func() { 'f', 'o', 'o', 'b', 'a', 'r', 'f', 'o', 'o', // additional bytes }) - frame, err := ParseStreamFrame(b, versionBigEndian) + frame, err := parseStreamFrame(b, versionBigEndian) Expect(err).ToNot(HaveOccurred()) Expect(frame.FinBit).To(BeFalse()) Expect(frame.StreamID).To(Equal(protocol.StreamID(1))) @@ -37,7 +37,7 @@ var _ = Describe("STREAM frame (for gQUIC)", func() { 0x0, 0x6, // data length 'f', 'o', 'o', 'b', 'a', 'r', }) - frame, err := ParseStreamFrame(b, versionBigEndian) + frame, err := parseStreamFrame(b, versionBigEndian) Expect(err).ToNot(HaveOccurred()) Expect(frame.FinBit).To(BeFalse()) Expect(frame.StreamID).To(Equal(protocol.StreamID(1))) @@ -54,10 +54,10 @@ var _ = Describe("STREAM frame (for gQUIC)", func() { 0x0, 0x6, // data length, 'f', 'o', 'o', 'b', 'a', 'r', } - _, err := ParseStreamFrame(bytes.NewReader(data), versionBigEndian) + _, err := parseStreamFrame(bytes.NewReader(data), versionBigEndian) Expect(err).NotTo(HaveOccurred()) for i := range data { - _, err := ParseStreamFrame(bytes.NewReader(data[0:i]), versionBigEndian) + _, err := parseStreamFrame(bytes.NewReader(data[0:i]), versionBigEndian) Expect(err).To(HaveOccurred()) } }) @@ -67,7 +67,7 @@ var _ = Describe("STREAM frame (for gQUIC)", func() { 0x1, // stream id 'f', 'o', 'o', 'b', 'a', 'r', }) - frame, err := ParseStreamFrame(b, versionBigEndian) + frame, err := parseStreamFrame(b, versionBigEndian) Expect(err).ToNot(HaveOccurred()) Expect(frame.FinBit).To(BeFalse()) Expect(frame.StreamID).To(Equal(protocol.StreamID(1))) @@ -84,7 +84,7 @@ var _ = Describe("STREAM frame (for gQUIC)", func() { 0, 0, // data length 'f', 'o', 'o', // additional bytes }) - frame, err := ParseStreamFrame(b, versionBigEndian) + frame, err := parseStreamFrame(b, versionBigEndian) Expect(err).ToNot(HaveOccurred()) Expect(frame.FinBit).To(BeTrue()) Expect(frame.DataLenPresent).To(BeTrue()) @@ -97,7 +97,7 @@ var _ = Describe("STREAM frame (for gQUIC)", func() { 0x1, // stream id 'f', 'o', 'o', 'b', 'a', 'r', }) - frame, err := ParseStreamFrame(b, versionBigEndian) + frame, err := parseStreamFrame(b, versionBigEndian) Expect(err).ToNot(HaveOccurred()) Expect(frame.FinBit).To(BeTrue()) Expect(frame.DataLenPresent).To(BeFalse()) @@ -110,13 +110,13 @@ var _ = Describe("STREAM frame (for gQUIC)", func() { 0x1, // stream id 0, 0, // data length }) - _, err := ParseStreamFrame(b, versionBigEndian) + _, err := parseStreamFrame(b, versionBigEndian) Expect(err).To(MatchError(qerr.EmptyStreamFrameNoFin)) }) It("rejects frames to too large dataLen", func() { b := bytes.NewReader([]byte{0xa0, 0x1, 0xff, 0xff}) - _, err := ParseStreamFrame(b, versionBigEndian) + _, err := parseStreamFrame(b, versionBigEndian) Expect(err).To(MatchError(io.EOF)) }) @@ -130,7 +130,7 @@ var _ = Describe("STREAM frame (for gQUIC)", func() { b := &bytes.Buffer{} err := f.Write(b, versionBigEndian) Expect(err).ToNot(HaveOccurred()) - _, err = ParseStreamFrame(bytes.NewReader(b.Bytes()), versionBigEndian) + _, err = parseStreamFrame(bytes.NewReader(b.Bytes()), versionBigEndian) Expect(err).To(MatchError(qerr.Error(qerr.InvalidStreamData, "data overflows maximum offset"))) }) }) @@ -211,7 +211,7 @@ var _ = Describe("STREAM frame (for gQUIC)", func() { err := f.Write(b, versionBigEndian) Expect(err).ToNot(HaveOccurred()) Expect(b.Bytes()[0] & 0x20).To(Equal(uint8(0x20))) - frame, err := ParseStreamFrame(bytes.NewReader(b.Bytes()), versionBigEndian) + frame, err := parseStreamFrame(bytes.NewReader(b.Bytes()), versionBigEndian) Expect(err).ToNot(HaveOccurred()) Expect(frame.DataLenPresent).To(BeTrue()) Expect(frame.DataLen()).To(Equal(protocol.ByteCount(dataLen))) diff --git a/internal/wire/stream_frame_test.go b/internal/wire/stream_frame_test.go index b9050ce3e..206abff9a 100644 --- a/internal/wire/stream_frame_test.go +++ b/internal/wire/stream_frame_test.go @@ -18,7 +18,7 @@ var _ = Describe("STREAM frame (for IETF QUIC)", func() { data = append(data, encodeVarInt(0xdecafbad)...) // offset data = append(data, []byte("foobar")...) r := bytes.NewReader(data) - frame, err := ParseStreamFrame(r, versionIETFFrames) + frame, err := parseStreamFrame(r, versionIETFFrames) Expect(err).ToNot(HaveOccurred()) Expect(frame.StreamID).To(Equal(protocol.StreamID(0x12345))) Expect(frame.Data).To(Equal([]byte("foobar"))) @@ -33,7 +33,7 @@ var _ = Describe("STREAM frame (for IETF QUIC)", func() { data = append(data, encodeVarInt(4)...) // data length data = append(data, []byte("foobar")...) r := bytes.NewReader(data) - frame, err := ParseStreamFrame(r, versionIETFFrames) + frame, err := parseStreamFrame(r, versionIETFFrames) Expect(err).ToNot(HaveOccurred()) Expect(frame.StreamID).To(Equal(protocol.StreamID(0x12345))) Expect(frame.Data).To(Equal([]byte("foob"))) @@ -47,7 +47,7 @@ var _ = Describe("STREAM frame (for IETF QUIC)", func() { data = append(data, encodeVarInt(9)...) // stream ID data = append(data, []byte("foobar")...) r := bytes.NewReader(data) - frame, err := ParseStreamFrame(r, versionIETFFrames) + frame, err := parseStreamFrame(r, versionIETFFrames) Expect(err).ToNot(HaveOccurred()) Expect(frame.StreamID).To(Equal(protocol.StreamID(9))) Expect(frame.Data).To(Equal([]byte("foobar"))) @@ -60,7 +60,7 @@ var _ = Describe("STREAM frame (for IETF QUIC)", func() { data := []byte{0x10} data = append(data, encodeVarInt(0x1337)...) // stream ID r := bytes.NewReader(data) - _, err := ParseStreamFrame(r, versionIETFFrames) + _, err := parseStreamFrame(r, versionIETFFrames) Expect(err).To(MatchError(qerr.EmptyStreamFrameNoFin)) }) @@ -70,7 +70,7 @@ var _ = Describe("STREAM frame (for IETF QUIC)", func() { data = append(data, encodeVarInt(uint64(protocol.MaxByteCount-5))...) // offset data = append(data, []byte("foobar")...) r := bytes.NewReader(data) - _, err := ParseStreamFrame(r, versionIETFFrames) + _, err := parseStreamFrame(r, versionIETFFrames) Expect(err).To(MatchError(qerr.Error(qerr.InvalidStreamData, "data overflows maximum offset"))) }) @@ -80,10 +80,10 @@ var _ = Describe("STREAM frame (for IETF QUIC)", func() { data = append(data, encodeVarInt(0xdecafbad)...) // offset data = append(data, encodeVarInt(6)...) // data length data = append(data, []byte("foobar")...) - _, err := ParseStreamFrame(bytes.NewReader(data), versionIETFFrames) + _, err := parseStreamFrame(bytes.NewReader(data), versionIETFFrames) Expect(err).NotTo(HaveOccurred()) for i := range data { - _, err := ParseStreamFrame(bytes.NewReader(data[0:i]), versionIETFFrames) + _, err := parseStreamFrame(bytes.NewReader(data[0:i]), versionIETFFrames) Expect(err).To(HaveOccurred()) } }) diff --git a/internal/wire/stream_id_blocked_frame.go b/internal/wire/stream_id_blocked_frame.go index 7b390a4d9..6476eb9de 100644 --- a/internal/wire/stream_id_blocked_frame.go +++ b/internal/wire/stream_id_blocked_frame.go @@ -12,8 +12,8 @@ type StreamIDBlockedFrame struct { StreamID protocol.StreamID } -// ParseStreamIDBlockedFrame parses a STREAM_ID_BLOCKED frame -func ParseStreamIDBlockedFrame(r *bytes.Reader, _ protocol.VersionNumber) (*StreamIDBlockedFrame, error) { +// parseStreamIDBlockedFrame parses a STREAM_ID_BLOCKED frame +func parseStreamIDBlockedFrame(r *bytes.Reader, _ protocol.VersionNumber) (*StreamIDBlockedFrame, error) { if _, err := r.ReadByte(); err != nil { return nil, err } diff --git a/internal/wire/stream_id_blocked_frame_test.go b/internal/wire/stream_id_blocked_frame_test.go index aa6d7f13d..7fb1cfb15 100644 --- a/internal/wire/stream_id_blocked_frame_test.go +++ b/internal/wire/stream_id_blocked_frame_test.go @@ -16,7 +16,7 @@ var _ = Describe("STREAM_ID_BLOCKED frame", func() { expected := []byte{0xa} expected = append(expected, encodeVarInt(0xdecafbad)...) b := bytes.NewReader(expected) - frame, err := ParseStreamIDBlockedFrame(b, protocol.VersionWhatever) + frame, err := parseStreamIDBlockedFrame(b, protocol.VersionWhatever) Expect(err).ToNot(HaveOccurred()) Expect(frame.StreamID).To(Equal(protocol.StreamID(0xdecafbad))) Expect(b.Len()).To(BeZero()) @@ -25,10 +25,10 @@ var _ = Describe("STREAM_ID_BLOCKED frame", func() { It("errors on EOFs", func() { data := []byte{0xa} data = append(data, encodeVarInt(0x12345678)...) - _, err := ParseStreamIDBlockedFrame(bytes.NewReader(data), versionIETFFrames) + _, err := parseStreamIDBlockedFrame(bytes.NewReader(data), versionIETFFrames) Expect(err).ToNot(HaveOccurred()) for i := range data { - _, err := ParseStreamIDBlockedFrame(bytes.NewReader(data[:i]), versionIETFFrames) + _, err := parseStreamIDBlockedFrame(bytes.NewReader(data[:i]), versionIETFFrames) Expect(err).To(MatchError(io.EOF)) } }) diff --git a/internal/wire/window_update_frame.go b/internal/wire/window_update_frame.go index 8f7556e75..606e25cf2 100644 --- a/internal/wire/window_update_frame.go +++ b/internal/wire/window_update_frame.go @@ -12,11 +12,11 @@ type windowUpdateFrame struct { ByteOffset protocol.ByteCount } -// ParseWindowUpdateFrame parses a WINDOW_UPDATE frame +// parseWindowUpdateFrame parses a WINDOW_UPDATE frame // The frame returned is // * a MAX_STREAM_DATA frame, if the WINDOW_UPDATE applies to a stream // * a MAX_DATA frame, if the WINDOW_UPDATE applies to the connection -func ParseWindowUpdateFrame(r *bytes.Reader, _ protocol.VersionNumber) (Frame, error) { +func parseWindowUpdateFrame(r *bytes.Reader, _ protocol.VersionNumber) (Frame, error) { if _, err := r.ReadByte(); err != nil { // read the TypeByte return nil, err } diff --git a/internal/wire/window_update_frame_test.go b/internal/wire/window_update_frame_test.go index f1f8eb46d..cc1c08194 100644 --- a/internal/wire/window_update_frame_test.go +++ b/internal/wire/window_update_frame_test.go @@ -16,7 +16,7 @@ var _ = Describe("WINDOW_UPDATE frame", func() { 0xde, 0xad, 0xbe, 0xef, // stream id 0xde, 0xca, 0xfb, 0xad, 0x11, 0x22, 0x33, 0x44, // byte offset }) - f, err := ParseWindowUpdateFrame(b, versionBigEndian) + f, err := parseWindowUpdateFrame(b, versionBigEndian) Expect(err).ToNot(HaveOccurred()) Expect(f).To(BeAssignableToTypeOf(&MaxStreamDataFrame{})) frame := f.(*MaxStreamDataFrame) @@ -29,7 +29,7 @@ var _ = Describe("WINDOW_UPDATE frame", func() { 0x0, 0x0, 0x0, 0x0, // stream id 0xde, 0xca, 0xfb, 0xad, 0x11, 0x22, 0x33, 0x44, // byte offset }) - f, err := ParseWindowUpdateFrame(b, versionBigEndian) + f, err := parseWindowUpdateFrame(b, versionBigEndian) Expect(err).ToNot(HaveOccurred()) Expect(f).To(BeAssignableToTypeOf(&MaxDataFrame{})) frame := f.(*MaxDataFrame) @@ -41,10 +41,10 @@ var _ = Describe("WINDOW_UPDATE frame", func() { 0xef, 0xbe, 0xad, 0xde, // stream id 0x44, 0x33, 0x22, 0x11, 0xad, 0xfb, 0xca, 0xde, // byte offset } - _, err := ParseWindowUpdateFrame(bytes.NewReader(data), versionBigEndian) + _, err := parseWindowUpdateFrame(bytes.NewReader(data), versionBigEndian) Expect(err).NotTo(HaveOccurred()) for i := range data { - _, err := ParseWindowUpdateFrame(bytes.NewReader(data[0:i]), versionBigEndian) + _, err := parseWindowUpdateFrame(bytes.NewReader(data[0:i]), versionBigEndian) Expect(err).To(HaveOccurred()) } }) diff --git a/server_tls_test.go b/server_tls_test.go index 54f94372a..3994294ca 100644 --- a/server_tls_test.go +++ b/server_tls_test.go @@ -148,8 +148,10 @@ var _ = Describe("Stateless TLS handling", func() { // unpack the packet to check that it actually contains a CONNECTION_CLOSE hdr, data = unpackPacket(conn.dataWritten.Bytes()) Expect(hdr.Type).To(Equal(protocol.PacketTypeHandshake)) - ccf, err := wire.ParseConnectionCloseFrame(bytes.NewReader(data), protocol.VersionTLS) + frame, err := wire.ParseNextFrame(bytes.NewReader(data), nil, protocol.VersionTLS) Expect(err).ToNot(HaveOccurred()) + Expect(frame).To(BeAssignableToTypeOf(&wire.ConnectionCloseFrame{})) + ccf := frame.(*wire.ConnectionCloseFrame) Expect(ccf.ErrorCode).To(Equal(qerr.HandshakeFailed)) Expect(ccf.ReasonPhrase).To(Equal(mint.AlertAccessDenied.String())) })