forked from quic-go/quic-go
move frame parsing to the wire package
This commit is contained in:
Marten Seemann
152
internal/wire/frame_parser.go
Normal file
152
internal/wire/frame_parser.go
Normal file
@@ -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
|
||||
}
|
||||
323
internal/wire/frame_parser_test.go
Normal file
323
internal/wire/frame_parser_test.go
Normal file
@@ -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))
|
||||
}
|
||||
})
|
||||
})
|
||||
})
|
||||
Reference in New Issue
Block a user