gr1ffon/quic-go
1
0
Fork 0
forked from quic-go/quic-go
Code Pull Requests Activity

Merge pull request #1263 from lucas-clemente/frame-parsing

Browse Source 
move frame parsing to the wire package
This commit is contained in:
Marten Seemann
2018-03-26 13:16:28 +02:00
committed by GitHub
parent 9fa739409e be066e825c
commit 00833c0840
39 changed files with 678 additions and 705 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
internal/wire/ack_frame.go
View File

@@ -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)
}

108
internal/wire/ack_frame_legacy_test.go
View File

@@ -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))

24
internal/wire/ack_frame_test.go
View File

@@ -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())

4
internal/wire/blocked_frame.go
View File

@@ -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
}

4
internal/wire/blocked_frame_legacy.go
View File

@@ -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
}

8
internal/wire/blocked_frame_legacy_test.go
View File

@@ -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())
}
})

6
internal/wire/blocked_frame_test.go
View File

@@ -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))
}
})

4
internal/wire/connection_close_frame.go
View File

@@ -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
}

20
internal/wire/connection_close_frame_test.go
View File

@@ -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())

152
internal/wire/frame_parser.go Normal file
View 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
View 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))
}
})
})
})

4
internal/wire/goaway_frame.go
View File

@@ -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 {

8
internal/wire/goaway_frame_test.go
View File

@@ -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")))
})
})

4
internal/wire/max_data_frame.go
View File

@@ -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

6
internal/wire/max_data_frame_test.go
View File

@@ -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())
}
})

4
internal/wire/max_stream_data_frame.go
View File

@@ -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

6
internal/wire/max_stream_data_frame_test.go
View File

@@ -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())
}
})

4
internal/wire/max_stream_id_frame.go
View File

@@ -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

6
internal/wire/max_stream_id_frame_test.go
View File

@@ -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())
}
})

4
internal/wire/ping_frame.go
View File

@@ -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()

4
internal/wire/ping_frame_test.go
View File

@@ -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())
})
})

4
internal/wire/rst_stream_frame.go
View File

@@ -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
}

12
internal/wire/rst_stream_frame_test.go
View File

@@ -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())
}
})

4
internal/wire/stop_sending_frame.go
View File

@@ -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
}

6
internal/wire/stop_sending_frame_test.go
View File

@@ -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())
}
})

4
internal/wire/stop_waiting_frame.go
View File

@@ -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

14
internal/wire/stop_waiting_frame_test.go
View File

@@ -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))
})

4
internal/wire/stream_blocked_frame.go
View File

@@ -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
}

6
internal/wire/stream_blocked_frame_test.go
View File

@@ -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())
}
})

4
internal/wire/stream_frame.go
View File

@@ -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)
}

22
internal/wire/stream_frame_legacy_test.go
View File

@@ -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)))

14
internal/wire/stream_frame_test.go
View File

@@ -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())
}
})

4
internal/wire/stream_id_blocked_frame.go
View File

@@ -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
}

6
internal/wire/stream_id_blocked_frame_test.go
View File

@@ -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))
}
})

4
internal/wire/window_update_frame.go
View File

@@ -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
}

8
internal/wire/window_update_frame_test.go
View File

@@ -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())
}
})

149
packet_unpacker.go
View File

@@ -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
}

407
packet_unpacker_test.go
View File

@@ -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")))
})
})
})

4
server_tls_test.go
View File

@@ -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()))
})