mirror of
https://github.com/refraction-networking/uquic.git
synced 2025-04-03 04:07:35 +03:00
separate long and short header packets in the coalescedPacket
This commit is contained in:
Marten Seemann
parent
124e597cf9
commit
518fd1c877
4 changed files with 326 additions and 274 deletions
|
|
@ -193,8 +193,10 @@ var _ = Describe("Packet packer", func() {
|
|||
p, err := packer.PackCoalescedPacket(false)
|
||||
Expect(err).ToNot(HaveOccurred())
|
||||
Expect(p).ToNot(BeNil())
|
||||
Expect(p.packets).To(HaveLen(1))
|
||||
Expect(p.packets[0].frames).To(Equal([]ackhandler.Frame{{Frame: f}}))
|
||||
Expect(p.longHdrPackets).To(BeEmpty())
|
||||
Expect(p.shortHdrPacket).ToNot(BeNil())
|
||||
Expect(p.shortHdrPacket.Frames).To(HaveLen(1))
|
||||
Expect(p.shortHdrPacket.Frames[0].Frame).To(Equal(f))
|
||||
hdrRawEncrypted := append([]byte{}, hdrRaw...)
|
||||
hdrRawEncrypted[0] ^= 0xff
|
||||
hdrRawEncrypted[len(hdrRaw)-2] ^= 0xff
|
||||
|
|
@ -241,10 +243,10 @@ var _ = Describe("Packet packer", func() {
|
|||
p, err := packer.PackCoalescedPacket(true)
|
||||
Expect(err).NotTo(HaveOccurred())
|
||||
Expect(p).ToNot(BeNil())
|
||||
Expect(p.packets).To(HaveLen(1))
|
||||
Expect(p.packets[0].EncryptionLevel()).To(Equal(protocol.EncryptionInitial))
|
||||
Expect(p.packets[0].ack).To(Equal(ack))
|
||||
Expect(p.packets[0].frames).To(BeEmpty())
|
||||
Expect(p.longHdrPackets).To(HaveLen(1))
|
||||
Expect(p.longHdrPackets[0].EncryptionLevel()).To(Equal(protocol.EncryptionInitial))
|
||||
Expect(p.longHdrPackets[0].ack).To(Equal(ack))
|
||||
Expect(p.longHdrPackets[0].frames).To(BeEmpty())
|
||||
Expect(p.buffer.Len()).To(BeEquivalentTo(packer.maxPacketSize))
|
||||
parsePacket(p.buffer.Data)
|
||||
})
|
||||
|
|
@ -258,10 +260,10 @@ var _ = Describe("Packet packer", func() {
|
|||
p, err := packer.PackCoalescedPacket(true)
|
||||
Expect(err).NotTo(HaveOccurred())
|
||||
Expect(p).ToNot(BeNil())
|
||||
Expect(p.packets).To(HaveLen(1))
|
||||
Expect(p.packets[0].EncryptionLevel()).To(Equal(protocol.EncryptionInitial))
|
||||
Expect(p.packets[0].ack).To(Equal(ack))
|
||||
Expect(p.packets[0].frames).To(BeEmpty())
|
||||
Expect(p.longHdrPackets).To(HaveLen(1))
|
||||
Expect(p.longHdrPackets[0].EncryptionLevel()).To(Equal(protocol.EncryptionInitial))
|
||||
Expect(p.longHdrPackets[0].ack).To(Equal(ack))
|
||||
Expect(p.longHdrPackets[0].frames).To(BeEmpty())
|
||||
Expect(p.buffer.Len()).To(BeNumerically("<", 100))
|
||||
parsePacket(p.buffer.Data)
|
||||
})
|
||||
|
|
@ -278,10 +280,10 @@ var _ = Describe("Packet packer", func() {
|
|||
p, err := packer.PackCoalescedPacket(true)
|
||||
Expect(err).NotTo(HaveOccurred())
|
||||
Expect(p).ToNot(BeNil())
|
||||
Expect(p.packets).To(HaveLen(1))
|
||||
Expect(p.packets[0].EncryptionLevel()).To(Equal(protocol.Encryption1RTT))
|
||||
Expect(p.packets[0].ack).To(Equal(ack))
|
||||
Expect(p.packets[0].frames).To(BeEmpty())
|
||||
Expect(p.longHdrPackets).To(BeEmpty())
|
||||
Expect(p.shortHdrPacket).ToNot(BeNil())
|
||||
Expect(p.shortHdrPacket.Ack).To(Equal(ack))
|
||||
Expect(p.shortHdrPacket.Frames).To(BeEmpty())
|
||||
parsePacket(p.buffer.Data)
|
||||
})
|
||||
|
||||
|
|
@ -330,10 +332,10 @@ var _ = Describe("Packet packer", func() {
|
|||
p, err := packer.PackCoalescedPacket(false)
|
||||
Expect(p).ToNot(BeNil())
|
||||
Expect(err).ToNot(HaveOccurred())
|
||||
Expect(p.packets).To(HaveLen(1))
|
||||
Expect(p.packets[0].header.Type).To(Equal(protocol.PacketType0RTT))
|
||||
Expect(p.packets[0].EncryptionLevel()).To(Equal(protocol.Encryption0RTT))
|
||||
Expect(p.packets[0].frames).To(Equal([]ackhandler.Frame{cf}))
|
||||
Expect(p.longHdrPackets).To(HaveLen(1))
|
||||
Expect(p.longHdrPackets[0].header.Type).To(Equal(protocol.PacketType0RTT))
|
||||
Expect(p.longHdrPackets[0].EncryptionLevel()).To(Equal(protocol.Encryption0RTT))
|
||||
Expect(p.longHdrPackets[0].frames).To(Equal([]ackhandler.Frame{cf}))
|
||||
})
|
||||
})
|
||||
|
||||
|
|
@ -348,11 +350,11 @@ var _ = Describe("Packet packer", func() {
|
|||
quicErr.FrameType = 0x1234
|
||||
p, err := packer.PackConnectionClose(quicErr)
|
||||
Expect(err).ToNot(HaveOccurred())
|
||||
Expect(p.packets).To(HaveLen(1))
|
||||
Expect(p.packets[0].header.Type).To(Equal(protocol.PacketTypeHandshake))
|
||||
Expect(p.packets[0].frames).To(HaveLen(1))
|
||||
Expect(p.packets[0].frames[0].Frame).To(BeAssignableToTypeOf(&wire.ConnectionCloseFrame{}))
|
||||
ccf := p.packets[0].frames[0].Frame.(*wire.ConnectionCloseFrame)
|
||||
Expect(p.longHdrPackets).To(HaveLen(1))
|
||||
Expect(p.longHdrPackets[0].header.Type).To(Equal(protocol.PacketTypeHandshake))
|
||||
Expect(p.longHdrPackets[0].frames).To(HaveLen(1))
|
||||
Expect(p.longHdrPackets[0].frames[0].Frame).To(BeAssignableToTypeOf(&wire.ConnectionCloseFrame{}))
|
||||
ccf := p.longHdrPackets[0].frames[0].Frame.(*wire.ConnectionCloseFrame)
|
||||
Expect(ccf.IsApplicationError).To(BeFalse())
|
||||
Expect(ccf.ErrorCode).To(BeEquivalentTo(0x100 + 0x42))
|
||||
Expect(ccf.FrameType).To(BeEquivalentTo(0x1234))
|
||||
|
|
@ -371,11 +373,10 @@ var _ = Describe("Packet packer", func() {
|
|||
ErrorMessage: "test error",
|
||||
})
|
||||
Expect(err).ToNot(HaveOccurred())
|
||||
Expect(p.packets).To(HaveLen(1))
|
||||
Expect(p.packets[0].header.IsLongHeader).To(BeFalse())
|
||||
Expect(p.packets[0].frames).To(HaveLen(1))
|
||||
Expect(p.packets[0].frames[0].Frame).To(BeAssignableToTypeOf(&wire.ConnectionCloseFrame{}))
|
||||
ccf := p.packets[0].frames[0].Frame.(*wire.ConnectionCloseFrame)
|
||||
Expect(p.longHdrPackets).To(BeEmpty())
|
||||
Expect(p.shortHdrPacket.Frames).To(HaveLen(1))
|
||||
Expect(p.shortHdrPacket.Frames[0].Frame).To(BeAssignableToTypeOf(&wire.ConnectionCloseFrame{}))
|
||||
ccf := p.shortHdrPacket.Frames[0].Frame.(*wire.ConnectionCloseFrame)
|
||||
Expect(ccf.IsApplicationError).To(BeFalse())
|
||||
Expect(ccf.ErrorCode).To(BeEquivalentTo(qerr.CryptoBufferExceeded))
|
||||
Expect(ccf.ReasonPhrase).To(Equal("test error"))
|
||||
|
|
@ -396,28 +397,28 @@ var _ = Describe("Packet packer", func() {
|
|||
ErrorMessage: "test error",
|
||||
})
|
||||
Expect(err).ToNot(HaveOccurred())
|
||||
Expect(p.packets).To(HaveLen(3))
|
||||
Expect(p.packets[0].header.Type).To(Equal(protocol.PacketTypeInitial))
|
||||
Expect(p.packets[0].header.PacketNumber).To(Equal(protocol.PacketNumber(1)))
|
||||
Expect(p.packets[0].frames).To(HaveLen(1))
|
||||
Expect(p.packets[0].frames[0].Frame).To(BeAssignableToTypeOf(&wire.ConnectionCloseFrame{}))
|
||||
ccf := p.packets[0].frames[0].Frame.(*wire.ConnectionCloseFrame)
|
||||
Expect(p.longHdrPackets).To(HaveLen(2))
|
||||
Expect(p.longHdrPackets[0].header.Type).To(Equal(protocol.PacketTypeInitial))
|
||||
Expect(p.longHdrPackets[0].header.PacketNumber).To(Equal(protocol.PacketNumber(1)))
|
||||
Expect(p.longHdrPackets[0].frames).To(HaveLen(1))
|
||||
Expect(p.longHdrPackets[0].frames[0].Frame).To(BeAssignableToTypeOf(&wire.ConnectionCloseFrame{}))
|
||||
ccf := p.longHdrPackets[0].frames[0].Frame.(*wire.ConnectionCloseFrame)
|
||||
Expect(ccf.IsApplicationError).To(BeFalse())
|
||||
Expect(ccf.ErrorCode).To(BeEquivalentTo(qerr.ApplicationErrorErrorCode))
|
||||
Expect(ccf.ReasonPhrase).To(BeEmpty())
|
||||
Expect(p.packets[1].header.Type).To(Equal(protocol.PacketTypeHandshake))
|
||||
Expect(p.packets[1].header.PacketNumber).To(Equal(protocol.PacketNumber(2)))
|
||||
Expect(p.packets[1].frames).To(HaveLen(1))
|
||||
Expect(p.packets[1].frames[0].Frame).To(BeAssignableToTypeOf(&wire.ConnectionCloseFrame{}))
|
||||
ccf = p.packets[1].frames[0].Frame.(*wire.ConnectionCloseFrame)
|
||||
Expect(p.longHdrPackets[1].header.Type).To(Equal(protocol.PacketTypeHandshake))
|
||||
Expect(p.longHdrPackets[1].header.PacketNumber).To(Equal(protocol.PacketNumber(2)))
|
||||
Expect(p.longHdrPackets[1].frames).To(HaveLen(1))
|
||||
Expect(p.longHdrPackets[1].frames[0].Frame).To(BeAssignableToTypeOf(&wire.ConnectionCloseFrame{}))
|
||||
ccf = p.longHdrPackets[1].frames[0].Frame.(*wire.ConnectionCloseFrame)
|
||||
Expect(ccf.IsApplicationError).To(BeFalse())
|
||||
Expect(ccf.ErrorCode).To(BeEquivalentTo(qerr.ApplicationErrorErrorCode))
|
||||
Expect(ccf.ReasonPhrase).To(BeEmpty())
|
||||
Expect(p.packets[2].header.IsLongHeader).To(BeFalse())
|
||||
Expect(p.packets[2].header.PacketNumber).To(Equal(protocol.PacketNumber(3)))
|
||||
Expect(p.packets[2].frames).To(HaveLen(1))
|
||||
Expect(p.packets[2].frames[0].Frame).To(BeAssignableToTypeOf(&wire.ConnectionCloseFrame{}))
|
||||
ccf = p.packets[2].frames[0].Frame.(*wire.ConnectionCloseFrame)
|
||||
Expect(p.shortHdrPacket).ToNot(BeNil())
|
||||
Expect(p.shortHdrPacket.PacketNumber).To(Equal(protocol.PacketNumber(3)))
|
||||
Expect(p.shortHdrPacket.Frames).To(HaveLen(1))
|
||||
Expect(p.shortHdrPacket.Frames[0].Frame).To(BeAssignableToTypeOf(&wire.ConnectionCloseFrame{}))
|
||||
ccf = p.shortHdrPacket.Frames[0].Frame.(*wire.ConnectionCloseFrame)
|
||||
Expect(ccf.IsApplicationError).To(BeTrue())
|
||||
Expect(ccf.ErrorCode).To(BeEquivalentTo(0x1337))
|
||||
Expect(ccf.ReasonPhrase).To(Equal("test error"))
|
||||
|
|
@ -438,21 +439,21 @@ var _ = Describe("Packet packer", func() {
|
|||
ErrorMessage: "test error",
|
||||
})
|
||||
Expect(err).ToNot(HaveOccurred())
|
||||
Expect(p.packets).To(HaveLen(2))
|
||||
Expect(p.longHdrPackets).To(HaveLen(1))
|
||||
Expect(p.buffer.Len()).To(BeNumerically("<", protocol.MinInitialPacketSize))
|
||||
Expect(p.packets[0].header.Type).To(Equal(protocol.PacketTypeHandshake))
|
||||
Expect(p.packets[0].header.PacketNumber).To(Equal(protocol.PacketNumber(1)))
|
||||
Expect(p.packets[0].frames).To(HaveLen(1))
|
||||
Expect(p.packets[0].frames[0].Frame).To(BeAssignableToTypeOf(&wire.ConnectionCloseFrame{}))
|
||||
ccf := p.packets[0].frames[0].Frame.(*wire.ConnectionCloseFrame)
|
||||
Expect(p.longHdrPackets[0].header.Type).To(Equal(protocol.PacketTypeHandshake))
|
||||
Expect(p.longHdrPackets[0].header.PacketNumber).To(Equal(protocol.PacketNumber(1)))
|
||||
Expect(p.longHdrPackets[0].frames).To(HaveLen(1))
|
||||
Expect(p.longHdrPackets[0].frames[0].Frame).To(BeAssignableToTypeOf(&wire.ConnectionCloseFrame{}))
|
||||
ccf := p.longHdrPackets[0].frames[0].Frame.(*wire.ConnectionCloseFrame)
|
||||
Expect(ccf.IsApplicationError).To(BeFalse())
|
||||
Expect(ccf.ErrorCode).To(BeEquivalentTo(qerr.ApplicationErrorErrorCode))
|
||||
Expect(ccf.ReasonPhrase).To(BeEmpty())
|
||||
Expect(p.packets[1].header.IsLongHeader).To(BeFalse())
|
||||
Expect(p.packets[1].header.PacketNumber).To(Equal(protocol.PacketNumber(2)))
|
||||
Expect(p.packets[1].frames).To(HaveLen(1))
|
||||
Expect(p.packets[1].frames[0].Frame).To(BeAssignableToTypeOf(&wire.ConnectionCloseFrame{}))
|
||||
ccf = p.packets[1].frames[0].Frame.(*wire.ConnectionCloseFrame)
|
||||
Expect(p.shortHdrPacket).ToNot(BeNil())
|
||||
Expect(p.shortHdrPacket.PacketNumber).To(Equal(protocol.PacketNumber(2)))
|
||||
Expect(p.shortHdrPacket.Frames).To(HaveLen(1))
|
||||
Expect(p.shortHdrPacket.Frames[0].Frame).To(BeAssignableToTypeOf(&wire.ConnectionCloseFrame{}))
|
||||
ccf = p.shortHdrPacket.Frames[0].Frame.(*wire.ConnectionCloseFrame)
|
||||
Expect(ccf.IsApplicationError).To(BeTrue())
|
||||
Expect(ccf.ErrorCode).To(BeEquivalentTo(0x1337))
|
||||
Expect(ccf.ReasonPhrase).To(Equal("test error"))
|
||||
|
|
@ -473,22 +474,22 @@ var _ = Describe("Packet packer", func() {
|
|||
ErrorMessage: "test error",
|
||||
})
|
||||
Expect(err).ToNot(HaveOccurred())
|
||||
Expect(p.packets).To(HaveLen(2))
|
||||
Expect(p.longHdrPackets).To(HaveLen(2))
|
||||
Expect(p.buffer.Len()).To(BeNumerically(">=", protocol.MinInitialPacketSize))
|
||||
Expect(p.buffer.Len()).To(BeEquivalentTo(maxPacketSize))
|
||||
Expect(p.packets[0].header.Type).To(Equal(protocol.PacketTypeInitial))
|
||||
Expect(p.packets[0].header.PacketNumber).To(Equal(protocol.PacketNumber(1)))
|
||||
Expect(p.packets[0].frames).To(HaveLen(1))
|
||||
Expect(p.packets[0].frames[0].Frame).To(BeAssignableToTypeOf(&wire.ConnectionCloseFrame{}))
|
||||
ccf := p.packets[0].frames[0].Frame.(*wire.ConnectionCloseFrame)
|
||||
Expect(p.longHdrPackets[0].header.Type).To(Equal(protocol.PacketTypeInitial))
|
||||
Expect(p.longHdrPackets[0].header.PacketNumber).To(Equal(protocol.PacketNumber(1)))
|
||||
Expect(p.longHdrPackets[0].frames).To(HaveLen(1))
|
||||
Expect(p.longHdrPackets[0].frames[0].Frame).To(BeAssignableToTypeOf(&wire.ConnectionCloseFrame{}))
|
||||
ccf := p.longHdrPackets[0].frames[0].Frame.(*wire.ConnectionCloseFrame)
|
||||
Expect(ccf.IsApplicationError).To(BeFalse())
|
||||
Expect(ccf.ErrorCode).To(BeEquivalentTo(qerr.ApplicationErrorErrorCode))
|
||||
Expect(ccf.ReasonPhrase).To(BeEmpty())
|
||||
Expect(p.packets[1].header.Type).To(Equal(protocol.PacketType0RTT))
|
||||
Expect(p.packets[1].header.PacketNumber).To(Equal(protocol.PacketNumber(2)))
|
||||
Expect(p.packets[1].frames).To(HaveLen(1))
|
||||
Expect(p.packets[1].frames[0].Frame).To(BeAssignableToTypeOf(&wire.ConnectionCloseFrame{}))
|
||||
ccf = p.packets[1].frames[0].Frame.(*wire.ConnectionCloseFrame)
|
||||
Expect(p.longHdrPackets[1].header.Type).To(Equal(protocol.PacketType0RTT))
|
||||
Expect(p.longHdrPackets[1].header.PacketNumber).To(Equal(protocol.PacketNumber(2)))
|
||||
Expect(p.longHdrPackets[1].frames).To(HaveLen(1))
|
||||
Expect(p.longHdrPackets[1].frames[0].Frame).To(BeAssignableToTypeOf(&wire.ConnectionCloseFrame{}))
|
||||
ccf = p.longHdrPackets[1].frames[0].Frame.(*wire.ConnectionCloseFrame)
|
||||
Expect(ccf.IsApplicationError).To(BeTrue())
|
||||
Expect(ccf.ErrorCode).To(BeEquivalentTo(0x1337))
|
||||
Expect(ccf.ReasonPhrase).To(Equal("test error"))
|
||||
|
|
@ -657,7 +658,7 @@ var _ = Describe("Packet packer", func() {
|
|||
packet, err := packer.PackCoalescedPacket(false)
|
||||
Expect(err).ToNot(HaveOccurred())
|
||||
Expect(packet).ToNot(BeNil())
|
||||
Expect(packet.packets).To(HaveLen(1))
|
||||
Expect(packet.longHdrPackets).To(HaveLen(1))
|
||||
// cut off the tag that the mock sealer added
|
||||
// packet.buffer.Data = packet.buffer.Data[:packet.buffer.Len()-protocol.ByteCount(sealer.Overhead())]
|
||||
hdr, _, _, err := wire.ParsePacket(packet.buffer.Data, packer.getDestConnID().Len())
|
||||
|
|
@ -978,10 +979,10 @@ var _ = Describe("Packet packer", func() {
|
|||
Expect(err).ToNot(HaveOccurred())
|
||||
Expect(p.buffer.Len()).To(BeNumerically(">=", protocol.MinInitialPacketSize))
|
||||
Expect(p.buffer.Len()).To(BeEquivalentTo(maxPacketSize))
|
||||
Expect(p.packets).To(HaveLen(1))
|
||||
Expect(p.packets[0].EncryptionLevel()).To(Equal(protocol.EncryptionInitial))
|
||||
Expect(p.packets[0].frames).To(HaveLen(1))
|
||||
Expect(p.packets[0].frames[0].Frame.(*wire.CryptoFrame).Data).To(Equal([]byte("initial")))
|
||||
Expect(p.longHdrPackets).To(HaveLen(1))
|
||||
Expect(p.longHdrPackets[0].EncryptionLevel()).To(Equal(protocol.EncryptionInitial))
|
||||
Expect(p.longHdrPackets[0].frames).To(HaveLen(1))
|
||||
Expect(p.longHdrPackets[0].frames[0].Frame.(*wire.CryptoFrame).Data).To(Equal([]byte("initial")))
|
||||
hdrs := parsePacket(p.buffer.Data)
|
||||
Expect(hdrs).To(HaveLen(1))
|
||||
Expect(hdrs[0].Type).To(Equal(protocol.PacketTypeInitial))
|
||||
|
|
@ -1005,9 +1006,9 @@ var _ = Describe("Packet packer", func() {
|
|||
})
|
||||
p, err := packer.PackCoalescedPacket(false)
|
||||
Expect(err).ToNot(HaveOccurred())
|
||||
Expect(p.packets).To(HaveLen(1))
|
||||
Expect(p.packets[0].frames).To(HaveLen(1))
|
||||
Expect(p.packets[0].header.IsLongHeader).To(BeTrue())
|
||||
Expect(p.longHdrPackets).To(HaveLen(1))
|
||||
Expect(p.longHdrPackets[0].frames).To(HaveLen(1))
|
||||
Expect(p.longHdrPackets[0].header.IsLongHeader).To(BeTrue())
|
||||
Expect(p.buffer.Len()).To(BeEquivalentTo(packer.maxPacketSize))
|
||||
parsePacket(p.buffer.Data)
|
||||
})
|
||||
|
|
@ -1033,13 +1034,14 @@ var _ = Describe("Packet packer", func() {
|
|||
p, err := packer.PackCoalescedPacket(false)
|
||||
Expect(err).ToNot(HaveOccurred())
|
||||
Expect(p.buffer.Len()).To(BeEquivalentTo(packer.maxPacketSize))
|
||||
Expect(p.packets).To(HaveLen(2))
|
||||
Expect(p.packets[0].EncryptionLevel()).To(Equal(protocol.EncryptionInitial))
|
||||
Expect(p.packets[0].frames).To(HaveLen(1))
|
||||
Expect(p.packets[0].frames[0].Frame.(*wire.CryptoFrame).Data).To(Equal([]byte("initial")))
|
||||
Expect(p.packets[1].EncryptionLevel()).To(Equal(protocol.EncryptionHandshake))
|
||||
Expect(p.packets[1].frames).To(HaveLen(1))
|
||||
Expect(p.packets[1].frames[0].Frame.(*wire.CryptoFrame).Data).To(Equal([]byte("handshake")))
|
||||
Expect(p.longHdrPackets).To(HaveLen(2))
|
||||
Expect(p.shortHdrPacket).To(BeNil())
|
||||
Expect(p.longHdrPackets[0].EncryptionLevel()).To(Equal(protocol.EncryptionInitial))
|
||||
Expect(p.longHdrPackets[0].frames).To(HaveLen(1))
|
||||
Expect(p.longHdrPackets[0].frames[0].Frame.(*wire.CryptoFrame).Data).To(Equal([]byte("initial")))
|
||||
Expect(p.longHdrPackets[1].EncryptionLevel()).To(Equal(protocol.EncryptionHandshake))
|
||||
Expect(p.longHdrPackets[1].frames).To(HaveLen(1))
|
||||
Expect(p.longHdrPackets[1].frames[0].Frame.(*wire.CryptoFrame).Data).To(Equal([]byte("handshake")))
|
||||
hdrs := parsePacket(p.buffer.Data)
|
||||
Expect(hdrs).To(HaveLen(2))
|
||||
Expect(hdrs[0].Type).To(Equal(protocol.PacketTypeInitial))
|
||||
|
|
@ -1065,13 +1067,14 @@ var _ = Describe("Packet packer", func() {
|
|||
p, err := packer.PackCoalescedPacket(false)
|
||||
Expect(err).ToNot(HaveOccurred())
|
||||
Expect(p.buffer.Len()).To(BeEquivalentTo(packer.maxPacketSize))
|
||||
Expect(p.packets).To(HaveLen(2))
|
||||
Expect(p.packets[0].EncryptionLevel()).To(Equal(protocol.EncryptionInitial))
|
||||
Expect(p.packets[0].frames).To(HaveLen(1))
|
||||
Expect(p.packets[0].frames[0].Frame.(*wire.CryptoFrame).Data).To(Equal([]byte("initial")))
|
||||
Expect(p.packets[1].EncryptionLevel()).To(Equal(protocol.EncryptionHandshake))
|
||||
Expect(p.packets[1].frames).To(HaveLen(1))
|
||||
Expect(p.packets[1].frames[0].Frame).To(BeAssignableToTypeOf(&wire.PingFrame{}))
|
||||
Expect(p.longHdrPackets).To(HaveLen(2))
|
||||
Expect(p.shortHdrPacket).To(BeNil())
|
||||
Expect(p.longHdrPackets[0].EncryptionLevel()).To(Equal(protocol.EncryptionInitial))
|
||||
Expect(p.longHdrPackets[0].frames).To(HaveLen(1))
|
||||
Expect(p.longHdrPackets[0].frames[0].Frame.(*wire.CryptoFrame).Data).To(Equal([]byte("initial")))
|
||||
Expect(p.longHdrPackets[1].EncryptionLevel()).To(Equal(protocol.EncryptionHandshake))
|
||||
Expect(p.longHdrPackets[1].frames).To(HaveLen(1))
|
||||
Expect(p.longHdrPackets[1].frames[0].Frame).To(BeAssignableToTypeOf(&wire.PingFrame{}))
|
||||
hdrs := parsePacket(p.buffer.Data)
|
||||
Expect(hdrs).To(HaveLen(2))
|
||||
Expect(hdrs[0].Type).To(Equal(protocol.PacketTypeInitial))
|
||||
|
|
@ -1094,13 +1097,13 @@ var _ = Describe("Packet packer", func() {
|
|||
p, err := packer.PackCoalescedPacket(false)
|
||||
Expect(err).ToNot(HaveOccurred())
|
||||
Expect(p.buffer.Len()).To(BeEquivalentTo(packer.maxPacketSize))
|
||||
Expect(p.packets).To(HaveLen(2))
|
||||
Expect(p.packets[0].EncryptionLevel()).To(Equal(protocol.EncryptionInitial))
|
||||
Expect(p.packets[0].frames).To(HaveLen(1))
|
||||
Expect(p.packets[0].frames[0].Frame).To(BeAssignableToTypeOf(&wire.PingFrame{}))
|
||||
Expect(p.packets[1].EncryptionLevel()).To(Equal(protocol.EncryptionHandshake))
|
||||
Expect(p.packets[1].frames).To(HaveLen(1))
|
||||
Expect(p.packets[1].frames[0].Frame).To(BeAssignableToTypeOf(&wire.PingFrame{}))
|
||||
Expect(p.longHdrPackets).To(HaveLen(2))
|
||||
Expect(p.longHdrPackets[0].EncryptionLevel()).To(Equal(protocol.EncryptionInitial))
|
||||
Expect(p.longHdrPackets[0].frames).To(HaveLen(1))
|
||||
Expect(p.longHdrPackets[0].frames[0].Frame).To(BeAssignableToTypeOf(&wire.PingFrame{}))
|
||||
Expect(p.longHdrPackets[1].EncryptionLevel()).To(Equal(protocol.EncryptionHandshake))
|
||||
Expect(p.longHdrPackets[1].frames).To(HaveLen(1))
|
||||
Expect(p.longHdrPackets[1].frames[0].Frame).To(BeAssignableToTypeOf(&wire.PingFrame{}))
|
||||
hdrs := parsePacket(p.buffer.Data)
|
||||
Expect(hdrs).To(HaveLen(2))
|
||||
Expect(hdrs[0].Type).To(Equal(protocol.PacketTypeInitial))
|
||||
|
|
@ -1127,13 +1130,13 @@ var _ = Describe("Packet packer", func() {
|
|||
p, err := packer.PackCoalescedPacket(false)
|
||||
Expect(err).ToNot(HaveOccurred())
|
||||
Expect(p.buffer.Len()).To(BeEquivalentTo(packer.maxPacketSize))
|
||||
Expect(p.packets).To(HaveLen(2))
|
||||
Expect(p.packets[0].EncryptionLevel()).To(Equal(protocol.EncryptionInitial))
|
||||
Expect(p.packets[0].frames).To(HaveLen(1))
|
||||
Expect(p.packets[0].frames[0].Frame.(*wire.CryptoFrame).Data).To(Equal([]byte("initial")))
|
||||
Expect(p.packets[1].EncryptionLevel()).To(Equal(protocol.Encryption1RTT))
|
||||
Expect(p.packets[1].frames).To(HaveLen(1))
|
||||
Expect(p.packets[1].frames[0].Frame).To(BeAssignableToTypeOf(&wire.PingFrame{}))
|
||||
Expect(p.longHdrPackets).To(HaveLen(1))
|
||||
Expect(p.longHdrPackets[0].EncryptionLevel()).To(Equal(protocol.EncryptionInitial))
|
||||
Expect(p.longHdrPackets[0].frames).To(HaveLen(1))
|
||||
Expect(p.longHdrPackets[0].frames[0].Frame.(*wire.CryptoFrame).Data).To(Equal([]byte("initial")))
|
||||
Expect(p.shortHdrPacket).ToNot(BeNil())
|
||||
Expect(p.shortHdrPacket.Frames).To(HaveLen(1))
|
||||
Expect(p.shortHdrPacket.Frames[0].Frame).To(BeAssignableToTypeOf(&wire.PingFrame{}))
|
||||
hdrs := parsePacket(p.buffer.Data)
|
||||
Expect(hdrs).To(HaveLen(2))
|
||||
Expect(hdrs[0].Type).To(Equal(protocol.PacketTypeInitial))
|
||||
|
|
@ -1163,13 +1166,13 @@ var _ = Describe("Packet packer", func() {
|
|||
Expect(err).ToNot(HaveOccurred())
|
||||
Expect(p.buffer.Len()).To(BeNumerically(">=", protocol.MinInitialPacketSize))
|
||||
Expect(p.buffer.Len()).To(BeEquivalentTo(maxPacketSize))
|
||||
Expect(p.packets).To(HaveLen(2))
|
||||
Expect(p.packets[0].EncryptionLevel()).To(Equal(protocol.EncryptionInitial))
|
||||
Expect(p.packets[0].frames).To(HaveLen(1))
|
||||
Expect(p.packets[0].frames[0].Frame.(*wire.CryptoFrame).Data).To(Equal([]byte("initial")))
|
||||
Expect(p.packets[1].EncryptionLevel()).To(Equal(protocol.Encryption0RTT))
|
||||
Expect(p.packets[1].frames).To(HaveLen(1))
|
||||
Expect(p.packets[1].frames[0].Frame.(*wire.StreamFrame).Data).To(Equal([]byte("foobar")))
|
||||
Expect(p.longHdrPackets).To(HaveLen(2))
|
||||
Expect(p.longHdrPackets[0].EncryptionLevel()).To(Equal(protocol.EncryptionInitial))
|
||||
Expect(p.longHdrPackets[0].frames).To(HaveLen(1))
|
||||
Expect(p.longHdrPackets[0].frames[0].Frame.(*wire.CryptoFrame).Data).To(Equal([]byte("initial")))
|
||||
Expect(p.longHdrPackets[1].EncryptionLevel()).To(Equal(protocol.Encryption0RTT))
|
||||
Expect(p.longHdrPackets[1].frames).To(HaveLen(1))
|
||||
Expect(p.longHdrPackets[1].frames[0].Frame.(*wire.StreamFrame).Data).To(Equal([]byte("foobar")))
|
||||
hdrs := parsePacket(p.buffer.Data)
|
||||
Expect(hdrs).To(HaveLen(2))
|
||||
Expect(hdrs[0].Type).To(Equal(protocol.PacketTypeInitial))
|
||||
|
|
@ -1196,13 +1199,13 @@ var _ = Describe("Packet packer", func() {
|
|||
p, err := packer.PackCoalescedPacket(false)
|
||||
Expect(err).ToNot(HaveOccurred())
|
||||
Expect(p.buffer.Len()).To(BeNumerically("<", 100))
|
||||
Expect(p.packets).To(HaveLen(2))
|
||||
Expect(p.packets[0].EncryptionLevel()).To(Equal(protocol.EncryptionHandshake))
|
||||
Expect(p.packets[0].frames).To(HaveLen(1))
|
||||
Expect(p.packets[0].frames[0].Frame.(*wire.CryptoFrame).Data).To(Equal([]byte("handshake")))
|
||||
Expect(p.packets[1].EncryptionLevel()).To(Equal(protocol.Encryption1RTT))
|
||||
Expect(p.packets[1].frames).To(HaveLen(1))
|
||||
Expect(p.packets[1].frames[0].Frame.(*wire.StreamFrame).Data).To(Equal([]byte("foobar")))
|
||||
Expect(p.longHdrPackets).To(HaveLen(1))
|
||||
Expect(p.longHdrPackets[0].EncryptionLevel()).To(Equal(protocol.EncryptionHandshake))
|
||||
Expect(p.longHdrPackets[0].frames).To(HaveLen(1))
|
||||
Expect(p.longHdrPackets[0].frames[0].Frame.(*wire.CryptoFrame).Data).To(Equal([]byte("handshake")))
|
||||
Expect(p.shortHdrPacket).ToNot(BeNil())
|
||||
Expect(p.shortHdrPacket.Frames).To(HaveLen(1))
|
||||
Expect(p.shortHdrPacket.Frames[0].Frame.(*wire.StreamFrame).Data).To(Equal([]byte("foobar")))
|
||||
hdr, _, rest, err := wire.ParsePacket(p.buffer.Data, 0)
|
||||
Expect(err).ToNot(HaveOccurred())
|
||||
Expect(hdr.Type).To(Equal(protocol.PacketTypeHandshake))
|
||||
|
|
@ -1229,8 +1232,9 @@ var _ = Describe("Packet packer", func() {
|
|||
})
|
||||
p, err := packer.PackCoalescedPacket(false)
|
||||
Expect(err).ToNot(HaveOccurred())
|
||||
Expect(p.packets).To(HaveLen(1))
|
||||
Expect(p.packets[0].EncryptionLevel()).To(Equal(protocol.EncryptionHandshake))
|
||||
Expect(p.longHdrPackets).To(HaveLen(1))
|
||||
Expect(p.shortHdrPacket).To(BeNil())
|
||||
Expect(p.longHdrPackets[0].EncryptionLevel()).To(Equal(protocol.EncryptionHandshake))
|
||||
Expect(len(p.buffer.Data)).To(BeEquivalentTo(maxPacketSize - protocol.MinCoalescedPacketSize))
|
||||
parsePacket(p.buffer.Data)
|
||||
})
|
||||
|
|
@ -1248,7 +1252,8 @@ var _ = Describe("Packet packer", func() {
|
|||
packet, err := packer.PackCoalescedPacket(false)
|
||||
Expect(err).ToNot(HaveOccurred())
|
||||
Expect(packet).ToNot(BeNil())
|
||||
Expect(packet.packets).To(HaveLen(1))
|
||||
Expect(packet.longHdrPackets).To(HaveLen(1))
|
||||
Expect(packet.shortHdrPacket).To(BeNil())
|
||||
// cut off the tag that the mock sealer added
|
||||
// packet.buffer.Data = packet.buffer.Data[:packet.buffer.Len()-protocol.ByteCount(sealer.Overhead())]
|
||||
hdr, _, _, err := wire.ParsePacket(packet.buffer.Data, packer.getDestConnID().Len())
|
||||
|
|
@ -1287,10 +1292,10 @@ var _ = Describe("Packet packer", func() {
|
|||
initialStream.EXPECT().HasData()
|
||||
p, err := packer.PackCoalescedPacket(false)
|
||||
Expect(err).ToNot(HaveOccurred())
|
||||
Expect(p.packets).To(HaveLen(1))
|
||||
Expect(p.packets[0].EncryptionLevel()).To(Equal(protocol.EncryptionInitial))
|
||||
Expect(p.packets[0].frames).To(Equal([]ackhandler.Frame{{Frame: f}}))
|
||||
Expect(p.packets[0].header.IsLongHeader).To(BeTrue())
|
||||
Expect(p.longHdrPackets).To(HaveLen(1))
|
||||
Expect(p.longHdrPackets[0].EncryptionLevel()).To(Equal(protocol.EncryptionInitial))
|
||||
Expect(p.longHdrPackets[0].frames).To(Equal([]ackhandler.Frame{{Frame: f}}))
|
||||
Expect(p.longHdrPackets[0].header.IsLongHeader).To(BeTrue())
|
||||
})
|
||||
|
||||
It("sends an Initial packet containing only an ACK", func() {
|
||||
|
|
@ -1304,8 +1309,8 @@ var _ = Describe("Packet packer", func() {
|
|||
pnManager.EXPECT().PopPacketNumber(protocol.EncryptionInitial).Return(protocol.PacketNumber(0x42))
|
||||
p, err := packer.PackCoalescedPacket(false)
|
||||
Expect(err).ToNot(HaveOccurred())
|
||||
Expect(p.packets).To(HaveLen(1))
|
||||
Expect(p.packets[0].ack).To(Equal(ack))
|
||||
Expect(p.longHdrPackets).To(HaveLen(1))
|
||||
Expect(p.longHdrPackets[0].ack).To(Equal(ack))
|
||||
})
|
||||
|
||||
It("doesn't pack anything if there's nothing to send at Initial and Handshake keys are not yet available", func() {
|
||||
|
|
@ -1332,8 +1337,8 @@ var _ = Describe("Packet packer", func() {
|
|||
pnManager.EXPECT().PopPacketNumber(protocol.EncryptionHandshake).Return(protocol.PacketNumber(0x42))
|
||||
p, err := packer.PackCoalescedPacket(false)
|
||||
Expect(err).ToNot(HaveOccurred())
|
||||
Expect(p.packets).To(HaveLen(1))
|
||||
Expect(p.packets[0].ack).To(Equal(ack))
|
||||
Expect(p.longHdrPackets).To(HaveLen(1))
|
||||
Expect(p.longHdrPackets[0].ack).To(Equal(ack))
|
||||
})
|
||||
|
||||
for _, pers := range []protocol.Perspective{protocol.PerspectiveServer, protocol.PerspectiveClient} {
|
||||
|
|
@ -1357,10 +1362,10 @@ var _ = Describe("Packet packer", func() {
|
|||
Expect(err).ToNot(HaveOccurred())
|
||||
Expect(p.buffer.Len()).To(BeNumerically(">=", protocol.MinInitialPacketSize))
|
||||
Expect(p.buffer.Len()).To(BeEquivalentTo(maxPacketSize))
|
||||
Expect(p.packets).To(HaveLen(1))
|
||||
Expect(p.packets[0].header.Token).To(Equal(token))
|
||||
Expect(p.packets[0].frames).To(HaveLen(1))
|
||||
cf := p.packets[0].frames[0].Frame.(*wire.CryptoFrame)
|
||||
Expect(p.longHdrPackets).To(HaveLen(1))
|
||||
Expect(p.longHdrPackets[0].header.Token).To(Equal(token))
|
||||
Expect(p.longHdrPackets[0].frames).To(HaveLen(1))
|
||||
cf := p.longHdrPackets[0].frames[0].Frame.(*wire.CryptoFrame)
|
||||
Expect(cf.Data).To(Equal([]byte("foobar")))
|
||||
})
|
||||
}
|
||||
|
|
@ -1381,9 +1386,9 @@ var _ = Describe("Packet packer", func() {
|
|||
packer.perspective = protocol.PerspectiveClient
|
||||
p, err := packer.PackCoalescedPacket(false)
|
||||
Expect(err).ToNot(HaveOccurred())
|
||||
Expect(p.packets).To(HaveLen(1))
|
||||
Expect(p.packets[0].ack).To(Equal(ack))
|
||||
Expect(p.packets[0].frames).To(HaveLen(1))
|
||||
Expect(p.longHdrPackets).To(HaveLen(1))
|
||||
Expect(p.longHdrPackets[0].ack).To(Equal(ack))
|
||||
Expect(p.longHdrPackets[0].frames).To(HaveLen(1))
|
||||
Expect(p.buffer.Len()).To(BeEquivalentTo(maxPacketSize))
|
||||
})
|
||||
})
|
||||
|
|
@ -1405,8 +1410,8 @@ var _ = Describe("Packet packer", func() {
|
|||
p, err := packer.MaybePackProbePacket(protocol.EncryptionInitial)
|
||||
Expect(err).ToNot(HaveOccurred())
|
||||
Expect(p).ToNot(BeNil())
|
||||
Expect(p.packets).To(HaveLen(1))
|
||||
packet := p.packets[0]
|
||||
Expect(p.longHdrPackets).To(HaveLen(1))
|
||||
packet := p.longHdrPackets[0]
|
||||
Expect(packet.EncryptionLevel()).To(Equal(protocol.EncryptionInitial))
|
||||
Expect(p.buffer.Len()).To(BeNumerically(">=", protocol.MinInitialPacketSize))
|
||||
Expect(p.buffer.Len()).To(BeEquivalentTo(maxPacketSize))
|
||||
|
|
@ -1428,8 +1433,8 @@ var _ = Describe("Packet packer", func() {
|
|||
Expect(err).ToNot(HaveOccurred())
|
||||
Expect(err).ToNot(HaveOccurred())
|
||||
Expect(p).ToNot(BeNil())
|
||||
Expect(p.packets).To(HaveLen(1))
|
||||
packet := p.packets[0]
|
||||
Expect(p.longHdrPackets).To(HaveLen(1))
|
||||
packet := p.longHdrPackets[0]
|
||||
Expect(packet.EncryptionLevel()).To(Equal(protocol.EncryptionInitial))
|
||||
Expect(p.buffer.Len()).To(BeNumerically(">=", protocol.MinInitialPacketSize))
|
||||
Expect(p.buffer.Len()).To(BeEquivalentTo(maxPacketSize))
|
||||
|
|
@ -1452,8 +1457,8 @@ var _ = Describe("Packet packer", func() {
|
|||
Expect(err).ToNot(HaveOccurred())
|
||||
Expect(err).ToNot(HaveOccurred())
|
||||
Expect(p).ToNot(BeNil())
|
||||
Expect(p.packets).To(HaveLen(1))
|
||||
packet := p.packets[0]
|
||||
Expect(p.longHdrPackets).To(HaveLen(1))
|
||||
packet := p.longHdrPackets[0]
|
||||
Expect(packet.EncryptionLevel()).To(Equal(protocol.EncryptionHandshake))
|
||||
Expect(packet.frames).To(HaveLen(1))
|
||||
Expect(packet.frames[0].Frame).To(Equal(f))
|
||||
|
|
@ -1473,8 +1478,8 @@ var _ = Describe("Packet packer", func() {
|
|||
Expect(err).ToNot(HaveOccurred())
|
||||
Expect(err).ToNot(HaveOccurred())
|
||||
Expect(p).ToNot(BeNil())
|
||||
Expect(p.packets).To(HaveLen(1))
|
||||
packet := p.packets[0]
|
||||
Expect(p.longHdrPackets).To(HaveLen(1))
|
||||
packet := p.longHdrPackets[0]
|
||||
Expect(packet.EncryptionLevel()).To(Equal(protocol.EncryptionHandshake))
|
||||
Expect(packet.frames).To(HaveLen(1))
|
||||
Expect(packet.frames[0].Frame).To(BeAssignableToTypeOf(&wire.CryptoFrame{}))
|
||||
|
|
@ -1496,11 +1501,11 @@ var _ = Describe("Packet packer", func() {
|
|||
p, err := packer.MaybePackProbePacket(protocol.Encryption1RTT)
|
||||
Expect(err).ToNot(HaveOccurred())
|
||||
Expect(p).ToNot(BeNil())
|
||||
Expect(p.packets).To(HaveLen(1))
|
||||
packet := p.packets[0]
|
||||
Expect(packet.EncryptionLevel()).To(Equal(protocol.Encryption1RTT))
|
||||
Expect(packet.frames).To(HaveLen(1))
|
||||
Expect(packet.frames[0].Frame).To(Equal(f))
|
||||
Expect(p.longHdrPackets).To(BeEmpty())
|
||||
Expect(p.shortHdrPacket).ToNot(BeNil())
|
||||
packet := p.shortHdrPacket
|
||||
Expect(packet.Frames).To(HaveLen(1))
|
||||
Expect(packet.Frames[0].Frame).To(Equal(f))
|
||||
})
|
||||
|
||||
It("packs a full size 1-RTT probe packet", func() {
|
||||
|
|
@ -1521,12 +1526,12 @@ var _ = Describe("Packet packer", func() {
|
|||
p, err := packer.MaybePackProbePacket(protocol.Encryption1RTT)
|
||||
Expect(err).ToNot(HaveOccurred())
|
||||
Expect(p).ToNot(BeNil())
|
||||
Expect(p.packets).To(HaveLen(1))
|
||||
packet := p.packets[0]
|
||||
Expect(packet.EncryptionLevel()).To(Equal(protocol.Encryption1RTT))
|
||||
Expect(packet.frames).To(HaveLen(1))
|
||||
Expect(packet.frames[0].Frame).To(BeAssignableToTypeOf(&wire.StreamFrame{}))
|
||||
Expect(packet.length).To(Equal(maxPacketSize))
|
||||
Expect(p.longHdrPackets).To(BeEmpty())
|
||||
Expect(p.shortHdrPacket).ToNot(BeNil())
|
||||
packet := p.shortHdrPacket
|
||||
Expect(packet.Frames).To(HaveLen(1))
|
||||
Expect(packet.Frames[0].Frame).To(BeAssignableToTypeOf(&wire.StreamFrame{}))
|
||||
Expect(packet.Length).To(Equal(maxPacketSize))
|
||||
})
|
||||
|
||||
It("returns nil if there's no probe data to send", func() {
|
||||
|
|
@ -1557,10 +1562,10 @@ var _ = Describe("Packet packer", func() {
|
|||
})
|
||||
})
|
||||
|
||||
var _ = Describe("Converting to AckHandler packets", func() {
|
||||
var _ = Describe("Converting to ackhandler.Packet", func() {
|
||||
It("convert a packet", func() {
|
||||
packet := &packetContents{
|
||||
header: &wire.ExtendedHeader{Header: wire.Header{}},
|
||||
packet := &longHeaderPacket{
|
||||
header: &wire.ExtendedHeader{Header: wire.Header{IsLongHeader: true, Type: protocol.PacketTypeInitial}},
|
||||
frames: []ackhandler.Frame{{Frame: &wire.MaxDataFrame{}}, {Frame: &wire.PingFrame{}}},
|
||||
ack: &wire.AckFrame{AckRanges: []wire.AckRange{{Largest: 100, Smallest: 80}}},
|
||||
length: 42,
|
||||
|
|
@ -1574,27 +1579,19 @@ var _ = Describe("Converting to AckHandler packets", func() {
|
|||
})
|
||||
|
||||
It("sets the LargestAcked to invalid, if the packet doesn't have an ACK frame", func() {
|
||||
packet := &packetContents{
|
||||
header: &wire.ExtendedHeader{Header: wire.Header{}},
|
||||
packet := &longHeaderPacket{
|
||||
header: &wire.ExtendedHeader{Header: wire.Header{IsLongHeader: true, Type: protocol.PacketTypeHandshake}},
|
||||
frames: []ackhandler.Frame{{Frame: &wire.MaxDataFrame{}}, {Frame: &wire.PingFrame{}}},
|
||||
}
|
||||
p := packet.ToAckHandlerPacket(time.Now(), nil)
|
||||
Expect(p.LargestAcked).To(Equal(protocol.InvalidPacketNumber))
|
||||
})
|
||||
|
||||
It("marks MTU probe packets", func() {
|
||||
packet := &packetContents{
|
||||
header: &wire.ExtendedHeader{Header: wire.Header{}},
|
||||
isMTUProbePacket: true,
|
||||
}
|
||||
Expect(packet.ToAckHandlerPacket(time.Now(), nil).IsPathMTUProbePacket).To(BeTrue())
|
||||
})
|
||||
|
||||
DescribeTable(
|
||||
"doesn't overwrite the OnLost callback, if it is set",
|
||||
func(hdr wire.Header) {
|
||||
var pingLost bool
|
||||
packet := &packetContents{
|
||||
packet := &longHeaderPacket{
|
||||
header: &wire.ExtendedHeader{Header: hdr},
|
||||
frames: []ackhandler.Frame{
|
||||
{Frame: &wire.MaxDataFrame{}},
|
||||
|
|
@ -1610,6 +1607,5 @@ var _ = Describe("Converting to AckHandler packets", func() {
|
|||
Entry(protocol.EncryptionInitial.String(), wire.Header{IsLongHeader: true, Type: protocol.PacketTypeInitial}),
|
||||
Entry(protocol.EncryptionHandshake.String(), wire.Header{IsLongHeader: true, Type: protocol.PacketTypeHandshake}),
|
||||
Entry(protocol.Encryption0RTT.String(), wire.Header{IsLongHeader: true, Type: protocol.PacketType0RTT}),
|
||||
Entry(protocol.Encryption1RTT.String(), wire.Header{}),
|
||||
)
|
||||
})
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue