mirrors/uquic
1
0
Fork 0
mirror of https://github.com/refraction-networking/uquic.git synced 2025-04-05 13:17:36 +03:00
Code Issues Projects Releases Packages Wiki Activity

refactor the packet packer to remove the version param from constructor

Browse source
This commit is contained in:
Marten Seemann 2023-01-18 21:35:01 +13:00
parent 56985cbfd1
commit 4bb9f29b55
5 changed files with 267 additions and 325 deletions
Download patch file Download diff file Expand all files Collapse all files

52
connection.go
View file

@ -351,21 +351,7 @@ var newConnection = func(
s.version, s.version,
) )
s.cryptoStreamHandler = cs s.cryptoStreamHandler = cs
s.packer = newPacketPacker( s.packer = newPacketPacker(srcConnID, s.connIDManager.Get, initialStream, handshakeStream, s.sentPacketHandler, s.retransmissionQueue, s.RemoteAddr(), cs, s.framer, s.receivedPacketHandler, s.datagramQueue, s.perspective)
srcConnID,
s.connIDManager.Get,
initialStream,
handshakeStream,
s.sentPacketHandler,
s.retransmissionQueue,
s.RemoteAddr(),
cs,
s.framer,
s.receivedPacketHandler,
s.datagramQueue,
s.perspective,
s.version,
)
s.unpacker = newPacketUnpacker(cs, s.srcConnIDLen) s.unpacker = newPacketUnpacker(cs, s.srcConnIDLen)
s.cryptoStreamManager = newCryptoStreamManager(cs, initialStream, handshakeStream, s.oneRTTStream) s.cryptoStreamManager = newCryptoStreamManager(cs, initialStream, handshakeStream, s.oneRTTStream)
return s return s
@ -477,21 +463,7 @@ var newClientConnection = func(
s.cryptoStreamHandler = cs s.cryptoStreamHandler = cs
s.cryptoStreamManager = newCryptoStreamManager(cs, initialStream, handshakeStream, newCryptoStream()) s.cryptoStreamManager = newCryptoStreamManager(cs, initialStream, handshakeStream, newCryptoStream())
s.unpacker = newPacketUnpacker(cs, s.srcConnIDLen) s.unpacker = newPacketUnpacker(cs, s.srcConnIDLen)
s.packer = newPacketPacker( s.packer = newPacketPacker(srcConnID, s.connIDManager.Get, initialStream, handshakeStream, s.sentPacketHandler, s.retransmissionQueue, s.RemoteAddr(), cs, s.framer, s.receivedPacketHandler, s.datagramQueue, s.perspective)
srcConnID,
s.connIDManager.Get,
initialStream,
handshakeStream,
s.sentPacketHandler,
s.retransmissionQueue,
s.RemoteAddr(),
cs,
s.framer,
s.receivedPacketHandler,
s.datagramQueue,
s.perspective,
s.version,
)
if len(tlsConf.ServerName) > 0 { if len(tlsConf.ServerName) > 0 {
s.tokenStoreKey = tlsConf.ServerName s.tokenStoreKey = tlsConf.ServerName
} else { } else {
@ -1825,7 +1797,7 @@ func (s *connection) sendPackets() error {
func (s *connection) maybeSendAckOnlyPacket() error { func (s *connection) maybeSendAckOnlyPacket() error {
if !s.handshakeConfirmed { if !s.handshakeConfirmed {
packet, err := s.packer.PackCoalescedPacket(true) packet, err := s.packer.PackCoalescedPacket(true, s.version)
if err != nil { if err != nil {
return err return err
} }
@ -1837,7 +1809,7 @@ func (s *connection) maybeSendAckOnlyPacket() error {
} }
now := time.Now() now := time.Now()
p, buffer, err := s.packer.PackPacket(true, now) p, buffer, err := s.packer.PackPacket(true, now, s.version)
if err != nil { if err != nil {
if err == errNothingToPack { if err == errNothingToPack {
return nil return nil
@ -1858,7 +1830,7 @@ func (s *connection) sendProbePacket(encLevel protocol.EncryptionLevel) error {
break break
} }
var err error var err error
packet, err = s.packer.MaybePackProbePacket(encLevel) packet, err = s.packer.MaybePackProbePacket(encLevel, s.version)
if err != nil { if err != nil {
return err return err
} }
@ -1879,7 +1851,7 @@ func (s *connection) sendProbePacket(encLevel protocol.EncryptionLevel) error {
panic("unexpected encryption level") panic("unexpected encryption level")
} }
var err error var err error
packet, err = s.packer.MaybePackProbePacket(encLevel) packet, err = s.packer.MaybePackProbePacket(encLevel, s.version)
if err != nil { if err != nil {
return err return err
} }
@ -1899,7 +1871,7 @@ func (s *connection) sendPacket() (bool, error) {
now := time.Now() now := time.Now()
if !s.handshakeConfirmed { if !s.handshakeConfirmed {
packet, err := s.packer.PackCoalescedPacket(false) packet, err := s.packer.PackCoalescedPacket(false, s.version)
if err != nil || packet == nil { if err != nil || packet == nil {
return false, err return false, err
} }
@ -1908,7 +1880,7 @@ func (s *connection) sendPacket() (bool, error) {
return true, nil return true, nil
} else if !s.config.DisablePathMTUDiscovery && s.mtuDiscoverer.ShouldSendProbe(now) { } else if !s.config.DisablePathMTUDiscovery && s.mtuDiscoverer.ShouldSendProbe(now) {
ping, size := s.mtuDiscoverer.GetPing() ping, size := s.mtuDiscoverer.GetPing()
p, buffer, err := s.packer.PackMTUProbePacket(ping, size, now) p, buffer, err := s.packer.PackMTUProbePacket(ping, size, now, s.version)
if err != nil { if err != nil {
return false, err return false, err
} }
@ -1916,7 +1888,7 @@ func (s *connection) sendPacket() (bool, error) {
s.sendPackedShortHeaderPacket(buffer, p.Packet, now) s.sendPackedShortHeaderPacket(buffer, p.Packet, now)
return true, nil return true, nil
} }
p, buffer, err := s.packer.PackPacket(false, now) p, buffer, err := s.packer.PackPacket(false, now, s.version)
if err != nil { if err != nil {
if err == errNothingToPack { if err == errNothingToPack {
return false, nil return false, nil
@ -1962,14 +1934,14 @@ func (s *connection) sendConnectionClose(e error) ([]byte, error) {
var transportErr *qerr.TransportError var transportErr *qerr.TransportError
var applicationErr *qerr.ApplicationError var applicationErr *qerr.ApplicationError
if errors.As(e, &transportErr) { if errors.As(e, &transportErr) {
packet, err = s.packer.PackConnectionClose(transportErr) packet, err = s.packer.PackConnectionClose(transportErr, s.version)
} else if errors.As(e, &applicationErr) { } else if errors.As(e, &applicationErr) {
packet, err = s.packer.PackApplicationClose(applicationErr) packet, err = s.packer.PackApplicationClose(applicationErr, s.version)
} else { } else {
packet, err = s.packer.PackConnectionClose(&qerr.TransportError{ packet, err = s.packer.PackConnectionClose(&qerr.TransportError{
ErrorCode: qerr.InternalError, ErrorCode: qerr.InternalError,
ErrorMessage: fmt.Sprintf("connection BUG: unspecified error type (msg: %s)", e.Error()), ErrorMessage: fmt.Sprintf("connection BUG: unspecified error type (msg: %s)", e.Error()),
}) }, s.version)
} }
if err != nil { if err != nil {
return nil, err return nil, err

148
connection_test.go
View file

@ -441,7 +441,7 @@ var _ = Describe("Connection", func() {
cryptoSetup.EXPECT().Close() cryptoSetup.EXPECT().Close()
buffer := getPacketBuffer() buffer := getPacketBuffer()
buffer.Data = append(buffer.Data, []byte("connection close")...) buffer.Data = append(buffer.Data, []byte("connection close")...)
packer.EXPECT().PackApplicationClose(gomock.Any()).DoAndReturn(func(e *qerr.ApplicationError) (*coalescedPacket, error) { packer.EXPECT().PackApplicationClose(gomock.Any(), conn.version).DoAndReturn(func(e *qerr.ApplicationError, _ protocol.VersionNumber) (*coalescedPacket, error) {
Expect(e.ErrorCode).To(BeEquivalentTo(qerr.NoError)) Expect(e.ErrorCode).To(BeEquivalentTo(qerr.NoError))
Expect(e.ErrorMessage).To(BeEmpty()) Expect(e.ErrorMessage).To(BeEmpty())
return &coalescedPacket{buffer: buffer}, nil return &coalescedPacket{buffer: buffer}, nil
@ -466,7 +466,7 @@ var _ = Describe("Connection", func() {
streamManager.EXPECT().CloseWithError(gomock.Any()) streamManager.EXPECT().CloseWithError(gomock.Any())
expectReplaceWithClosed() expectReplaceWithClosed()
cryptoSetup.EXPECT().Close() cryptoSetup.EXPECT().Close()
packer.EXPECT().PackApplicationClose(gomock.Any()).Return(&coalescedPacket{buffer: getPacketBuffer()}, nil) packer.EXPECT().PackApplicationClose(gomock.Any(), conn.version).Return(&coalescedPacket{buffer: getPacketBuffer()}, nil)
mconn.EXPECT().Write(gomock.Any()) mconn.EXPECT().Write(gomock.Any())
tracer.EXPECT().ClosedConnection(gomock.Any()) tracer.EXPECT().ClosedConnection(gomock.Any())
tracer.EXPECT().Close() tracer.EXPECT().Close()
@ -485,7 +485,7 @@ var _ = Describe("Connection", func() {
streamManager.EXPECT().CloseWithError(expectedErr) streamManager.EXPECT().CloseWithError(expectedErr)
expectReplaceWithClosed() expectReplaceWithClosed()
cryptoSetup.EXPECT().Close() cryptoSetup.EXPECT().Close()
packer.EXPECT().PackApplicationClose(expectedErr).Return(&coalescedPacket{buffer: getPacketBuffer()}, nil) packer.EXPECT().PackApplicationClose(expectedErr, conn.version).Return(&coalescedPacket{buffer: getPacketBuffer()}, nil)
mconn.EXPECT().Write(gomock.Any()) mconn.EXPECT().Write(gomock.Any())
gomock.InOrder( gomock.InOrder(
tracer.EXPECT().ClosedConnection(expectedErr), tracer.EXPECT().ClosedConnection(expectedErr),
@ -506,7 +506,7 @@ var _ = Describe("Connection", func() {
streamManager.EXPECT().CloseWithError(expectedErr) streamManager.EXPECT().CloseWithError(expectedErr)
expectReplaceWithClosed() expectReplaceWithClosed()
cryptoSetup.EXPECT().Close() cryptoSetup.EXPECT().Close()
packer.EXPECT().PackConnectionClose(expectedErr).Return(&coalescedPacket{buffer: getPacketBuffer()}, nil) packer.EXPECT().PackConnectionClose(expectedErr, conn.version).Return(&coalescedPacket{buffer: getPacketBuffer()}, nil)
mconn.EXPECT().Write(gomock.Any()) mconn.EXPECT().Write(gomock.Any())
gomock.InOrder( gomock.InOrder(
tracer.EXPECT().ClosedConnection(expectedErr), tracer.EXPECT().ClosedConnection(expectedErr),
@ -546,7 +546,7 @@ var _ = Describe("Connection", func() {
streamManager.EXPECT().CloseWithError(gomock.Any()) streamManager.EXPECT().CloseWithError(gomock.Any())
expectReplaceWithClosed() expectReplaceWithClosed()
cryptoSetup.EXPECT().Close() cryptoSetup.EXPECT().Close()
packer.EXPECT().PackApplicationClose(gomock.Any()).Return(&coalescedPacket{buffer: getPacketBuffer()}, nil) packer.EXPECT().PackApplicationClose(gomock.Any(), conn.version).Return(&coalescedPacket{buffer: getPacketBuffer()}, nil)
returned := make(chan struct{}) returned := make(chan struct{})
go func() { go func() {
defer GinkgoRecover() defer GinkgoRecover()
@ -614,8 +614,8 @@ var _ = Describe("Connection", func() {
cryptoSetup.EXPECT().Close() cryptoSetup.EXPECT().Close()
conn.sentPacketHandler = sph conn.sentPacketHandler = sph
p, buffer := getShortHeaderPacket(1) p, buffer := getShortHeaderPacket(1)
packer.EXPECT().PackPacket(false, gomock.Any()).Return(p, buffer, nil) packer.EXPECT().PackPacket(false, gomock.Any(), conn.version).Return(p, buffer, nil)
packer.EXPECT().PackPacket(false, gomock.Any()).Return(shortHeaderPacket{}, nil, errNothingToPack).AnyTimes() packer.EXPECT().PackPacket(false, gomock.Any(), conn.version).Return(shortHeaderPacket{}, nil, errNothingToPack).AnyTimes()
runConn() runConn()
conn.queueControlFrame(&wire.PingFrame{}) conn.queueControlFrame(&wire.PingFrame{})
conn.scheduleSending() conn.scheduleSending()
@ -804,7 +804,7 @@ var _ = Describe("Connection", func() {
unpacker.EXPECT().UnpackLongHeader(gomock.Any(), gomock.Any(), gomock.Any(), conn.version).Return(nil, handshake.ErrDecryptionFailed) unpacker.EXPECT().UnpackLongHeader(gomock.Any(), gomock.Any(), gomock.Any(), conn.version).Return(nil, handshake.ErrDecryptionFailed)
streamManager.EXPECT().CloseWithError(gomock.Any()) streamManager.EXPECT().CloseWithError(gomock.Any())
cryptoSetup.EXPECT().Close() cryptoSetup.EXPECT().Close()
packer.EXPECT().PackConnectionClose(gomock.Any()).Return(&coalescedPacket{buffer: getPacketBuffer()}, nil) packer.EXPECT().PackConnectionClose(gomock.Any(), conn.version).Return(&coalescedPacket{buffer: getPacketBuffer()}, nil)
go func() { go func() {
defer GinkgoRecover() defer GinkgoRecover()
cryptoSetup.EXPECT().RunHandshake().MaxTimes(1) cryptoSetup.EXPECT().RunHandshake().MaxTimes(1)
@ -841,7 +841,7 @@ var _ = Describe("Connection", func() {
}).Times(3) }).Times(3)
tracer.EXPECT().ReceivedShortHeaderPacket(gomock.Any(), gomock.Any(), gomock.Any()).Do(func(hdr *logging.ShortHeader, _ protocol.ByteCount, _ []logging.Frame) { tracer.EXPECT().ReceivedShortHeaderPacket(gomock.Any(), gomock.Any(), gomock.Any()).Do(func(hdr *logging.ShortHeader, _ protocol.ByteCount, _ []logging.Frame) {
}).Times(3) }).Times(3)
packer.EXPECT().PackCoalescedPacket(false) // only expect a single call packer.EXPECT().PackCoalescedPacket(false, conn.version) // only expect a single call
for i := 0; i < 3; i++ { for i := 0; i < 3; i++ {
conn.handlePacket(getShortHeaderPacket(srcConnID, 0x1337+protocol.PacketNumber(i), []byte("foobar"))) conn.handlePacket(getShortHeaderPacket(srcConnID, 0x1337+protocol.PacketNumber(i), []byte("foobar")))
@ -857,7 +857,7 @@ var _ = Describe("Connection", func() {
// make the go routine return // make the go routine return
streamManager.EXPECT().CloseWithError(gomock.Any()) streamManager.EXPECT().CloseWithError(gomock.Any())
cryptoSetup.EXPECT().Close() cryptoSetup.EXPECT().Close()
packer.EXPECT().PackConnectionClose(gomock.Any()).Return(&coalescedPacket{buffer: getPacketBuffer()}, nil) packer.EXPECT().PackConnectionClose(gomock.Any(), conn.version).Return(&coalescedPacket{buffer: getPacketBuffer()}, nil)
expectReplaceWithClosed() expectReplaceWithClosed()
tracer.EXPECT().ClosedConnection(gomock.Any()) tracer.EXPECT().ClosedConnection(gomock.Any())
tracer.EXPECT().Close() tracer.EXPECT().Close()
@ -876,7 +876,7 @@ var _ = Describe("Connection", func() {
}).Times(3) }).Times(3)
tracer.EXPECT().ReceivedShortHeaderPacket(gomock.Any(), gomock.Any(), gomock.Any()).Do(func(hdr *logging.ShortHeader, _ protocol.ByteCount, _ []logging.Frame) { tracer.EXPECT().ReceivedShortHeaderPacket(gomock.Any(), gomock.Any(), gomock.Any()).Do(func(hdr *logging.ShortHeader, _ protocol.ByteCount, _ []logging.Frame) {
}).Times(3) }).Times(3)
packer.EXPECT().PackCoalescedPacket(false).Times(3) // only expect a single call packer.EXPECT().PackCoalescedPacket(false, conn.version).Times(3) // only expect a single call
for i := 0; i < 3; i++ { for i := 0; i < 3; i++ {
conn.handlePacket(getShortHeaderPacket(srcConnID, 0x1337+protocol.PacketNumber(i), []byte("foobar"))) conn.handlePacket(getShortHeaderPacket(srcConnID, 0x1337+protocol.PacketNumber(i), []byte("foobar")))
@ -892,7 +892,7 @@ var _ = Describe("Connection", func() {
// make the go routine return // make the go routine return
streamManager.EXPECT().CloseWithError(gomock.Any()) streamManager.EXPECT().CloseWithError(gomock.Any())
cryptoSetup.EXPECT().Close() cryptoSetup.EXPECT().Close()
packer.EXPECT().PackConnectionClose(gomock.Any()).Return(&coalescedPacket{buffer: getPacketBuffer()}, nil) packer.EXPECT().PackConnectionClose(gomock.Any(), conn.version).Return(&coalescedPacket{buffer: getPacketBuffer()}, nil)
expectReplaceWithClosed() expectReplaceWithClosed()
tracer.EXPECT().ClosedConnection(gomock.Any()) tracer.EXPECT().ClosedConnection(gomock.Any())
tracer.EXPECT().Close() tracer.EXPECT().Close()
@ -905,7 +905,7 @@ var _ = Describe("Connection", func() {
unpacker.EXPECT().UnpackShortHeader(gomock.Any(), gomock.Any()).Return(protocol.PacketNumber(0), protocol.PacketNumberLen(0), protocol.KeyPhaseBit(0), nil, wire.ErrInvalidReservedBits) unpacker.EXPECT().UnpackShortHeader(gomock.Any(), gomock.Any()).Return(protocol.PacketNumber(0), protocol.PacketNumberLen(0), protocol.KeyPhaseBit(0), nil, wire.ErrInvalidReservedBits)
streamManager.EXPECT().CloseWithError(gomock.Any()) streamManager.EXPECT().CloseWithError(gomock.Any())
cryptoSetup.EXPECT().Close() cryptoSetup.EXPECT().Close()
packer.EXPECT().PackConnectionClose(gomock.Any()).Return(&coalescedPacket{buffer: getPacketBuffer()}, nil) packer.EXPECT().PackConnectionClose(gomock.Any(), conn.version).Return(&coalescedPacket{buffer: getPacketBuffer()}, nil)
done := make(chan struct{}) done := make(chan struct{})
go func() { go func() {
defer GinkgoRecover() defer GinkgoRecover()
@ -941,7 +941,7 @@ var _ = Describe("Connection", func() {
conn.handlePacket(getShortHeaderPacket(srcConnID, 0x42, nil)) conn.handlePacket(getShortHeaderPacket(srcConnID, 0x42, nil))
Consistently(runErr).ShouldNot(Receive()) Consistently(runErr).ShouldNot(Receive())
// make the go routine return // make the go routine return
packer.EXPECT().PackApplicationClose(gomock.Any()).Return(&coalescedPacket{buffer: getPacketBuffer()}, nil) packer.EXPECT().PackApplicationClose(gomock.Any(), conn.version).Return(&coalescedPacket{buffer: getPacketBuffer()}, nil)
tracer.EXPECT().ClosedConnection(gomock.Any()) tracer.EXPECT().ClosedConnection(gomock.Any())
tracer.EXPECT().Close() tracer.EXPECT().Close()
mconn.EXPECT().Write(gomock.Any()) mconn.EXPECT().Write(gomock.Any())
@ -953,7 +953,7 @@ var _ = Describe("Connection", func() {
unpacker.EXPECT().UnpackShortHeader(gomock.Any(), gomock.Any()).Return(protocol.PacketNumber(0), protocol.PacketNumberLen(0), protocol.KeyPhaseBit(0), nil, &qerr.TransportError{ErrorCode: qerr.ConnectionIDLimitError}) unpacker.EXPECT().UnpackShortHeader(gomock.Any(), gomock.Any()).Return(protocol.PacketNumber(0), protocol.PacketNumberLen(0), protocol.KeyPhaseBit(0), nil, &qerr.TransportError{ErrorCode: qerr.ConnectionIDLimitError})
streamManager.EXPECT().CloseWithError(gomock.Any()) streamManager.EXPECT().CloseWithError(gomock.Any())
cryptoSetup.EXPECT().Close() cryptoSetup.EXPECT().Close()
packer.EXPECT().PackConnectionClose(gomock.Any()).Return(&coalescedPacket{buffer: getPacketBuffer()}, nil) packer.EXPECT().PackConnectionClose(gomock.Any(), conn.version).Return(&coalescedPacket{buffer: getPacketBuffer()}, nil)
done := make(chan struct{}) done := make(chan struct{})
go func() { go func() {
defer GinkgoRecover() defer GinkgoRecover()
@ -1178,7 +1178,7 @@ var _ = Describe("Connection", func() {
AfterEach(func() { AfterEach(func() {
streamManager.EXPECT().CloseWithError(gomock.Any()) streamManager.EXPECT().CloseWithError(gomock.Any())
packer.EXPECT().PackApplicationClose(gomock.Any()).Return(&coalescedPacket{buffer: getPacketBuffer()}, nil) packer.EXPECT().PackApplicationClose(gomock.Any(), conn.version).Return(&coalescedPacket{buffer: getPacketBuffer()}, nil)
expectReplaceWithClosed() expectReplaceWithClosed()
cryptoSetup.EXPECT().Close() cryptoSetup.EXPECT().Close()
mconn.EXPECT().Write(gomock.Any()) mconn.EXPECT().Write(gomock.Any())
@ -1210,8 +1210,8 @@ var _ = Describe("Connection", func() {
conn.sentPacketHandler = sph conn.sentPacketHandler = sph
runConn() runConn()
p, buffer := getShortHeaderPacket(1) p, buffer := getShortHeaderPacket(1)
packer.EXPECT().PackPacket(false, gomock.Any()).Return(p, buffer, nil) packer.EXPECT().PackPacket(false, gomock.Any(), conn.version).Return(p, buffer, nil)
packer.EXPECT().PackPacket(false, gomock.Any()).Return(shortHeaderPacket{}, nil, errNothingToPack).AnyTimes() packer.EXPECT().PackPacket(false, gomock.Any(), conn.version).Return(shortHeaderPacket{}, nil, errNothingToPack).AnyTimes()
sent := make(chan struct{}) sent := make(chan struct{})
sender.EXPECT().WouldBlock().AnyTimes() sender.EXPECT().WouldBlock().AnyTimes()
sender.EXPECT().Send(gomock.Any()).Do(func(packet *packetBuffer) { close(sent) }) sender.EXPECT().Send(gomock.Any()).Do(func(packet *packetBuffer) { close(sent) })
@ -1228,7 +1228,7 @@ var _ = Describe("Connection", func() {
It("doesn't send packets if there's nothing to send", func() { It("doesn't send packets if there's nothing to send", func() {
conn.handshakeConfirmed = true conn.handshakeConfirmed = true
runConn() runConn()
packer.EXPECT().PackPacket(false, gomock.Any()).Return(shortHeaderPacket{}, nil, errNothingToPack).AnyTimes() packer.EXPECT().PackPacket(false, gomock.Any(), conn.version).Return(shortHeaderPacket{}, nil, errNothingToPack).AnyTimes()
conn.receivedPacketHandler.ReceivedPacket(0x035e, protocol.ECNNon, protocol.Encryption1RTT, time.Now(), true) conn.receivedPacketHandler.ReceivedPacket(0x035e, protocol.ECNNon, protocol.Encryption1RTT, time.Now(), true)
conn.scheduleSending() conn.scheduleSending()
time.Sleep(50 * time.Millisecond) // make sure there are no calls to mconn.Write() time.Sleep(50 * time.Millisecond) // make sure there are no calls to mconn.Write()
@ -1240,7 +1240,7 @@ var _ = Describe("Connection", func() {
sph.EXPECT().GetLossDetectionTimeout().AnyTimes() sph.EXPECT().GetLossDetectionTimeout().AnyTimes()
sph.EXPECT().SendMode().Return(ackhandler.SendAck) sph.EXPECT().SendMode().Return(ackhandler.SendAck)
done := make(chan struct{}) done := make(chan struct{})
packer.EXPECT().PackCoalescedPacket(true).Do(func(bool) { close(done) }) packer.EXPECT().PackCoalescedPacket(true, conn.version).Do(func(bool, protocol.VersionNumber) { close(done) })
conn.sentPacketHandler = sph conn.sentPacketHandler = sph
runConn() runConn()
conn.scheduleSending() conn.scheduleSending()
@ -1260,8 +1260,8 @@ var _ = Describe("Connection", func() {
fc.EXPECT().IsNewlyBlocked().Return(true, protocol.ByteCount(1337)) fc.EXPECT().IsNewlyBlocked().Return(true, protocol.ByteCount(1337))
fc.EXPECT().IsNewlyBlocked() fc.EXPECT().IsNewlyBlocked()
p, buffer := getShortHeaderPacket(1) p, buffer := getShortHeaderPacket(1)
packer.EXPECT().PackPacket(false, gomock.Any()).Return(p, buffer, nil) packer.EXPECT().PackPacket(false, gomock.Any(), conn.version).Return(p, buffer, nil)
packer.EXPECT().PackPacket(false, gomock.Any()).Return(shortHeaderPacket{}, nil, errNothingToPack).AnyTimes() packer.EXPECT().PackPacket(false, gomock.Any(), conn.version).Return(shortHeaderPacket{}, nil, errNothingToPack).AnyTimes()
conn.connFlowController = fc conn.connFlowController = fc
runConn() runConn()
sent := make(chan struct{}) sent := make(chan struct{})
@ -1314,7 +1314,7 @@ var _ = Describe("Connection", func() {
sph.EXPECT().SendMode().Return(ackhandler.SendNone) sph.EXPECT().SendMode().Return(ackhandler.SendNone)
sph.EXPECT().QueueProbePacket(encLevel) sph.EXPECT().QueueProbePacket(encLevel)
p := getCoalescedPacket(123, enc != protocol.Encryption1RTT) p := getCoalescedPacket(123, enc != protocol.Encryption1RTT)
packer.EXPECT().MaybePackProbePacket(encLevel).Return(p, nil) packer.EXPECT().MaybePackProbePacket(encLevel, conn.version).Return(p, nil)
sph.EXPECT().SentPacket(gomock.Any()).Do(func(packet *ackhandler.Packet) { sph.EXPECT().SentPacket(gomock.Any()).Do(func(packet *ackhandler.Packet) {
Expect(packet.PacketNumber).To(Equal(protocol.PacketNumber(123))) Expect(packet.PacketNumber).To(Equal(protocol.PacketNumber(123)))
}) })
@ -1339,7 +1339,7 @@ var _ = Describe("Connection", func() {
sph.EXPECT().SendMode().Return(ackhandler.SendNone) sph.EXPECT().SendMode().Return(ackhandler.SendNone)
sph.EXPECT().QueueProbePacket(encLevel).Return(false) sph.EXPECT().QueueProbePacket(encLevel).Return(false)
p := getCoalescedPacket(123, enc != protocol.Encryption1RTT) p := getCoalescedPacket(123, enc != protocol.Encryption1RTT)
packer.EXPECT().MaybePackProbePacket(encLevel).Return(p, nil) packer.EXPECT().MaybePackProbePacket(encLevel, conn.version).Return(p, nil)
sph.EXPECT().SentPacket(gomock.Any()).Do(func(packet *ackhandler.Packet) { sph.EXPECT().SentPacket(gomock.Any()).Do(func(packet *ackhandler.Packet) {
Expect(packet.PacketNumber).To(Equal(protocol.PacketNumber(123))) Expect(packet.PacketNumber).To(Equal(protocol.PacketNumber(123)))
}) })
@ -1383,7 +1383,7 @@ var _ = Describe("Connection", func() {
AfterEach(func() { AfterEach(func() {
// make the go routine return // make the go routine return
packer.EXPECT().PackApplicationClose(gomock.Any()).Return(&coalescedPacket{buffer: getPacketBuffer()}, nil) packer.EXPECT().PackApplicationClose(gomock.Any(), conn.version).Return(&coalescedPacket{buffer: getPacketBuffer()}, nil)
expectReplaceWithClosed() expectReplaceWithClosed()
cryptoSetup.EXPECT().Close() cryptoSetup.EXPECT().Close()
mconn.EXPECT().Write(gomock.Any()) mconn.EXPECT().Write(gomock.Any())
@ -1401,9 +1401,9 @@ var _ = Describe("Connection", func() {
sph.EXPECT().TimeUntilSend().Return(time.Now().Add(time.Hour)) sph.EXPECT().TimeUntilSend().Return(time.Now().Add(time.Hour))
sph.EXPECT().SendMode().Return(ackhandler.SendAny).Times(3) sph.EXPECT().SendMode().Return(ackhandler.SendAny).Times(3)
p, buffer := getShortHeaderPacket(10) p, buffer := getShortHeaderPacket(10)
packer.EXPECT().PackPacket(false, gomock.Any()).Return(p, buffer, nil) packer.EXPECT().PackPacket(false, gomock.Any(), conn.version).Return(p, buffer, nil)
p, buffer = getShortHeaderPacket(11) p, buffer = getShortHeaderPacket(11)
packer.EXPECT().PackPacket(false, gomock.Any()).Return(p, buffer, nil) packer.EXPECT().PackPacket(false, gomock.Any(), conn.version).Return(p, buffer, nil)
sender.EXPECT().WouldBlock().AnyTimes() sender.EXPECT().WouldBlock().AnyTimes()
sender.EXPECT().Send(gomock.Any()).Times(2) sender.EXPECT().Send(gomock.Any()).Times(2)
go func() { go func() {
@ -1420,8 +1420,8 @@ var _ = Describe("Connection", func() {
sph.EXPECT().HasPacingBudget().Return(true).AnyTimes() sph.EXPECT().HasPacingBudget().Return(true).AnyTimes()
sph.EXPECT().SendMode().Return(ackhandler.SendAny).Times(2) sph.EXPECT().SendMode().Return(ackhandler.SendAny).Times(2)
p, buffer := getShortHeaderPacket(10) p, buffer := getShortHeaderPacket(10)
packer.EXPECT().PackPacket(false, gomock.Any()).Return(p, buffer, nil) packer.EXPECT().PackPacket(false, gomock.Any(), conn.version).Return(p, buffer, nil)
packer.EXPECT().PackPacket(false, gomock.Any()).Return(shortHeaderPacket{}, nil, errNothingToPack) packer.EXPECT().PackPacket(false, gomock.Any(), conn.version).Return(shortHeaderPacket{}, nil, errNothingToPack)
sender.EXPECT().WouldBlock().AnyTimes() sender.EXPECT().WouldBlock().AnyTimes()
sender.EXPECT().Send(gomock.Any()) sender.EXPECT().Send(gomock.Any())
go func() { go func() {
@ -1439,7 +1439,7 @@ var _ = Describe("Connection", func() {
sph.EXPECT().TimeUntilSend().Return(time.Now().Add(time.Hour)) sph.EXPECT().TimeUntilSend().Return(time.Now().Add(time.Hour))
sph.EXPECT().SendMode().Return(ackhandler.SendAny) sph.EXPECT().SendMode().Return(ackhandler.SendAny)
p, buffer := getShortHeaderPacket(10) p, buffer := getShortHeaderPacket(10)
packer.EXPECT().PackPacket(true, gomock.Any()).Return(p, buffer, nil) packer.EXPECT().PackPacket(true, gomock.Any(), conn.version).Return(p, buffer, nil)
sender.EXPECT().WouldBlock().AnyTimes() sender.EXPECT().WouldBlock().AnyTimes()
sender.EXPECT().Send(gomock.Any()) sender.EXPECT().Send(gomock.Any())
@ -1460,7 +1460,7 @@ var _ = Describe("Connection", func() {
sph.EXPECT().SendMode().Return(ackhandler.SendAny) sph.EXPECT().SendMode().Return(ackhandler.SendAny)
sph.EXPECT().SendMode().Return(ackhandler.SendAck) sph.EXPECT().SendMode().Return(ackhandler.SendAck)
p, buffer := getShortHeaderPacket(100) p, buffer := getShortHeaderPacket(100)
packer.EXPECT().PackPacket(false, gomock.Any()).Return(p, buffer, nil) packer.EXPECT().PackPacket(false, gomock.Any(), conn.version).Return(p, buffer, nil)
sender.EXPECT().WouldBlock().AnyTimes() sender.EXPECT().WouldBlock().AnyTimes()
sender.EXPECT().Send(gomock.Any()) sender.EXPECT().Send(gomock.Any())
go func() { go func() {
@ -1479,12 +1479,12 @@ var _ = Describe("Connection", func() {
p2, buffer2 := getShortHeaderPacket(101) p2, buffer2 := getShortHeaderPacket(101)
gomock.InOrder( gomock.InOrder(
sph.EXPECT().HasPacingBudget().Return(true), sph.EXPECT().HasPacingBudget().Return(true),
packer.EXPECT().PackPacket(false, gomock.Any()).Return(p1, buffer1, nil), packer.EXPECT().PackPacket(false, gomock.Any(), conn.version).Return(p1, buffer1, nil),
sph.EXPECT().SentPacket(gomock.Any()), sph.EXPECT().SentPacket(gomock.Any()),
sph.EXPECT().HasPacingBudget(), sph.EXPECT().HasPacingBudget(),
sph.EXPECT().TimeUntilSend().Return(time.Now().Add(pacingDelay)), sph.EXPECT().TimeUntilSend().Return(time.Now().Add(pacingDelay)),
sph.EXPECT().HasPacingBudget().Return(true), sph.EXPECT().HasPacingBudget().Return(true),
packer.EXPECT().PackPacket(false, gomock.Any()).Return(p2, buffer2, nil), packer.EXPECT().PackPacket(false, gomock.Any(), conn.version).Return(p2, buffer2, nil),
sph.EXPECT().SentPacket(gomock.Any()), sph.EXPECT().SentPacket(gomock.Any()),
sph.EXPECT().HasPacingBudget(), sph.EXPECT().HasPacingBudget(),
sph.EXPECT().TimeUntilSend().Return(time.Now().Add(time.Hour)), sph.EXPECT().TimeUntilSend().Return(time.Now().Add(time.Hour)),
@ -1511,7 +1511,7 @@ var _ = Describe("Connection", func() {
sph.EXPECT().SendMode().Return(ackhandler.SendAny).Times(4) sph.EXPECT().SendMode().Return(ackhandler.SendAny).Times(4)
for pn := protocol.PacketNumber(1000); pn < 1003; pn++ { for pn := protocol.PacketNumber(1000); pn < 1003; pn++ {
p, buffer := getShortHeaderPacket(pn) p, buffer := getShortHeaderPacket(pn)
packer.EXPECT().PackPacket(false, gomock.Any()).Return(p, buffer, nil) packer.EXPECT().PackPacket(false, gomock.Any(), conn.version).Return(p, buffer, nil)
} }
written := make(chan struct{}, 3) written := make(chan struct{}, 3)
sender.EXPECT().WouldBlock().AnyTimes() sender.EXPECT().WouldBlock().AnyTimes()
@ -1543,8 +1543,8 @@ var _ = Describe("Connection", func() {
sph.EXPECT().HasPacingBudget().Return(true).AnyTimes() sph.EXPECT().HasPacingBudget().Return(true).AnyTimes()
sph.EXPECT().SendMode().Return(ackhandler.SendAny).AnyTimes() sph.EXPECT().SendMode().Return(ackhandler.SendAny).AnyTimes()
p, buffer := getShortHeaderPacket(1000) p, buffer := getShortHeaderPacket(1000)
packer.EXPECT().PackPacket(false, gomock.Any()).Return(p, buffer, nil) packer.EXPECT().PackPacket(false, gomock.Any(), conn.version).Return(p, buffer, nil)
packer.EXPECT().PackPacket(false, gomock.Any()).Return(shortHeaderPacket{}, nil, errNothingToPack) packer.EXPECT().PackPacket(false, gomock.Any(), conn.version).Return(shortHeaderPacket{}, nil, errNothingToPack)
sender.EXPECT().Send(gomock.Any()).DoAndReturn(func(p *packetBuffer) { close(written) }) sender.EXPECT().Send(gomock.Any()).DoAndReturn(func(p *packetBuffer) { close(written) })
available <- struct{}{} available <- struct{}{}
Eventually(written).Should(BeClosed()) Eventually(written).Should(BeClosed())
@ -1567,8 +1567,8 @@ var _ = Describe("Connection", func() {
sph.EXPECT().HasPacingBudget().Return(true).AnyTimes() sph.EXPECT().HasPacingBudget().Return(true).AnyTimes()
sph.EXPECT().SendMode().Return(ackhandler.SendAny).AnyTimes() sph.EXPECT().SendMode().Return(ackhandler.SendAny).AnyTimes()
p, buffer := getShortHeaderPacket(1000) p, buffer := getShortHeaderPacket(1000)
packer.EXPECT().PackPacket(false, gomock.Any()).Return(p, buffer, nil) packer.EXPECT().PackPacket(false, gomock.Any(), conn.version).Return(p, buffer, nil)
packer.EXPECT().PackPacket(false, gomock.Any()).Return(shortHeaderPacket{}, nil, errNothingToPack) packer.EXPECT().PackPacket(false, gomock.Any(), conn.version).Return(shortHeaderPacket{}, nil, errNothingToPack)
sender.EXPECT().Send(gomock.Any()).DoAndReturn(func(p *packetBuffer) { close(written) }) sender.EXPECT().Send(gomock.Any()).DoAndReturn(func(p *packetBuffer) { close(written) })
conn.scheduleSending() conn.scheduleSending()
@ -1582,7 +1582,7 @@ var _ = Describe("Connection", func() {
sph.EXPECT().HasPacingBudget().Return(true).AnyTimes() sph.EXPECT().HasPacingBudget().Return(true).AnyTimes()
sph.EXPECT().SendMode().Return(ackhandler.SendAny) sph.EXPECT().SendMode().Return(ackhandler.SendAny)
p, buffer := getShortHeaderPacket(1000) p, buffer := getShortHeaderPacket(1000)
packer.EXPECT().PackPacket(false, gomock.Any()).Return(p, buffer, nil) packer.EXPECT().PackPacket(false, gomock.Any(), conn.version).Return(p, buffer, nil)
written := make(chan struct{}, 1) written := make(chan struct{}, 1)
sender.EXPECT().WouldBlock() sender.EXPECT().WouldBlock()
sender.EXPECT().WouldBlock().Return(true).Times(2) sender.EXPECT().WouldBlock().Return(true).Times(2)
@ -1604,8 +1604,8 @@ var _ = Describe("Connection", func() {
sph.EXPECT().SendMode().Return(ackhandler.SendAny).AnyTimes() sph.EXPECT().SendMode().Return(ackhandler.SendAny).AnyTimes()
sender.EXPECT().WouldBlock().AnyTimes() sender.EXPECT().WouldBlock().AnyTimes()
p, buffer = getShortHeaderPacket(1001) p, buffer = getShortHeaderPacket(1001)
packer.EXPECT().PackPacket(false, gomock.Any()).Return(p, buffer, nil) packer.EXPECT().PackPacket(false, gomock.Any(), conn.version).Return(p, buffer, nil)
packer.EXPECT().PackPacket(false, gomock.Any()).Return(shortHeaderPacket{}, nil, errNothingToPack) packer.EXPECT().PackPacket(false, gomock.Any(), conn.version).Return(shortHeaderPacket{}, nil, errNothingToPack)
sender.EXPECT().Send(gomock.Any()).DoAndReturn(func(p *packetBuffer) { written <- struct{}{} }) sender.EXPECT().Send(gomock.Any()).DoAndReturn(func(p *packetBuffer) { written <- struct{}{} })
available <- struct{}{} available <- struct{}{}
Eventually(written).Should(Receive()) Eventually(written).Should(Receive())
@ -1619,7 +1619,7 @@ var _ = Describe("Connection", func() {
sph.EXPECT().HasPacingBudget().Return(true) sph.EXPECT().HasPacingBudget().Return(true)
sph.EXPECT().SendMode().Return(ackhandler.SendAny).AnyTimes() sph.EXPECT().SendMode().Return(ackhandler.SendAny).AnyTimes()
sender.EXPECT().WouldBlock().AnyTimes() sender.EXPECT().WouldBlock().AnyTimes()
packer.EXPECT().PackPacket(false, gomock.Any()).Return(shortHeaderPacket{}, nil, errNothingToPack) packer.EXPECT().PackPacket(false, gomock.Any(), conn.version).Return(shortHeaderPacket{}, nil, errNothingToPack)
// don't EXPECT any calls to mconn.Write() // don't EXPECT any calls to mconn.Write()
go func() { go func() {
defer GinkgoRecover() defer GinkgoRecover()
@ -1645,7 +1645,7 @@ var _ = Describe("Connection", func() {
ping := ackhandler.Frame{Frame: &wire.PingFrame{}} ping := ackhandler.Frame{Frame: &wire.PingFrame{}}
mtuDiscoverer.EXPECT().GetPing().Return(ping, protocol.ByteCount(1234)) mtuDiscoverer.EXPECT().GetPing().Return(ping, protocol.ByteCount(1234))
p, buffer := getShortHeaderPacket(1) p, buffer := getShortHeaderPacket(1)
packer.EXPECT().PackMTUProbePacket(ping, protocol.ByteCount(1234), gomock.Any()).Return(p, buffer, nil) packer.EXPECT().PackMTUProbePacket(ping, protocol.ByteCount(1234), gomock.Any(), conn.version).Return(p, buffer, nil)
go func() { go func() {
defer GinkgoRecover() defer GinkgoRecover()
cryptoSetup.EXPECT().RunHandshake().MaxTimes(1) cryptoSetup.EXPECT().RunHandshake().MaxTimes(1)
@ -1671,7 +1671,7 @@ var _ = Describe("Connection", func() {
// make the go routine return // make the go routine return
expectReplaceWithClosed() expectReplaceWithClosed()
streamManager.EXPECT().CloseWithError(gomock.Any()) streamManager.EXPECT().CloseWithError(gomock.Any())
packer.EXPECT().PackApplicationClose(gomock.Any()).Return(&coalescedPacket{buffer: getPacketBuffer()}, nil) packer.EXPECT().PackApplicationClose(gomock.Any(), conn.version).Return(&coalescedPacket{buffer: getPacketBuffer()}, nil)
cryptoSetup.EXPECT().Close() cryptoSetup.EXPECT().Close()
mconn.EXPECT().Write(gomock.Any()) mconn.EXPECT().Write(gomock.Any())
sender.EXPECT().Close() sender.EXPECT().Close()
@ -1690,8 +1690,8 @@ var _ = Describe("Connection", func() {
sph.EXPECT().SentPacket(gomock.Any()) sph.EXPECT().SentPacket(gomock.Any())
conn.sentPacketHandler = sph conn.sentPacketHandler = sph
p, buffer := getShortHeaderPacket(1) p, buffer := getShortHeaderPacket(1)
packer.EXPECT().PackPacket(false, gomock.Any()).Return(p, buffer, nil) packer.EXPECT().PackPacket(false, gomock.Any(), conn.version).Return(p, buffer, nil)
packer.EXPECT().PackPacket(false, gomock.Any()).Return(shortHeaderPacket{}, nil, errNothingToPack) packer.EXPECT().PackPacket(false, gomock.Any(), conn.version).Return(shortHeaderPacket{}, nil, errNothingToPack)
go func() { go func() {
defer GinkgoRecover() defer GinkgoRecover()
@ -1710,8 +1710,8 @@ var _ = Describe("Connection", func() {
It("sets the timer to the ack timer", func() { It("sets the timer to the ack timer", func() {
p, buffer := getShortHeaderPacket(1234) p, buffer := getShortHeaderPacket(1234)
packer.EXPECT().PackPacket(false, gomock.Any()).Return(p, buffer, nil) packer.EXPECT().PackPacket(false, gomock.Any(), conn.version).Return(p, buffer, nil)
packer.EXPECT().PackPacket(false, gomock.Any()).Return(shortHeaderPacket{}, nil, errNothingToPack) packer.EXPECT().PackPacket(false, gomock.Any(), conn.version).Return(shortHeaderPacket{}, nil, errNothingToPack)
sph := mockackhandler.NewMockSentPacketHandler(mockCtrl) sph := mockackhandler.NewMockSentPacketHandler(mockCtrl)
sph.EXPECT().GetLossDetectionTimeout().AnyTimes() sph.EXPECT().GetLossDetectionTimeout().AnyTimes()
sph.EXPECT().SendMode().Return(ackhandler.SendAny).AnyTimes() sph.EXPECT().SendMode().Return(ackhandler.SendAny).AnyTimes()
@ -1745,7 +1745,7 @@ var _ = Describe("Connection", func() {
conn.sentPacketHandler = sph conn.sentPacketHandler = sph
buffer := getPacketBuffer() buffer := getPacketBuffer()
buffer.Data = append(buffer.Data, []byte("foobar")...) buffer.Data = append(buffer.Data, []byte("foobar")...)
packer.EXPECT().PackCoalescedPacket(false).Return(&coalescedPacket{ packer.EXPECT().PackCoalescedPacket(false, conn.version).Return(&coalescedPacket{
buffer: buffer, buffer: buffer,
longHdrPackets: []*longHeaderPacket{ longHdrPackets: []*longHeaderPacket{
{ {
@ -1764,7 +1764,7 @@ var _ = Describe("Connection", func() {
}, },
}, },
}, nil) }, nil)
packer.EXPECT().PackCoalescedPacket(false).AnyTimes() packer.EXPECT().PackCoalescedPacket(false, conn.version).AnyTimes()
sph.EXPECT().GetLossDetectionTimeout().AnyTimes() sph.EXPECT().GetLossDetectionTimeout().AnyTimes()
sph.EXPECT().SendMode().Return(ackhandler.SendAny).AnyTimes() sph.EXPECT().SendMode().Return(ackhandler.SendAny).AnyTimes()
@ -1805,7 +1805,7 @@ var _ = Describe("Connection", func() {
// make sure the go routine returns // make sure the go routine returns
streamManager.EXPECT().CloseWithError(gomock.Any()) streamManager.EXPECT().CloseWithError(gomock.Any())
expectReplaceWithClosed() expectReplaceWithClosed()
packer.EXPECT().PackApplicationClose(gomock.Any()).Return(&coalescedPacket{buffer: getPacketBuffer()}, nil) packer.EXPECT().PackApplicationClose(gomock.Any(), conn.version).Return(&coalescedPacket{buffer: getPacketBuffer()}, nil)
cryptoSetup.EXPECT().Close() cryptoSetup.EXPECT().Close()
mconn.EXPECT().Write(gomock.Any()) mconn.EXPECT().Write(gomock.Any())
tracer.EXPECT().ClosedConnection(gomock.Any()) tracer.EXPECT().ClosedConnection(gomock.Any())
@ -1815,7 +1815,7 @@ var _ = Describe("Connection", func() {
}) })
It("cancels the HandshakeComplete context when the handshake completes", func() { It("cancels the HandshakeComplete context when the handshake completes", func() {
packer.EXPECT().PackCoalescedPacket(false).AnyTimes() packer.EXPECT().PackCoalescedPacket(false, conn.version).AnyTimes()
finishHandshake := make(chan struct{}) finishHandshake := make(chan struct{})
sph := mockackhandler.NewMockSentPacketHandler(mockCtrl) sph := mockackhandler.NewMockSentPacketHandler(mockCtrl)
conn.sentPacketHandler = sph conn.sentPacketHandler = sph
@ -1840,7 +1840,7 @@ var _ = Describe("Connection", func() {
// make sure the go routine returns // make sure the go routine returns
streamManager.EXPECT().CloseWithError(gomock.Any()) streamManager.EXPECT().CloseWithError(gomock.Any())
expectReplaceWithClosed() expectReplaceWithClosed()
packer.EXPECT().PackApplicationClose(gomock.Any()).Return(&coalescedPacket{buffer: getPacketBuffer()}, nil) packer.EXPECT().PackApplicationClose(gomock.Any(), conn.version).Return(&coalescedPacket{buffer: getPacketBuffer()}, nil)
cryptoSetup.EXPECT().Close() cryptoSetup.EXPECT().Close()
mconn.EXPECT().Write(gomock.Any()) mconn.EXPECT().Write(gomock.Any())
tracer.EXPECT().ClosedConnection(gomock.Any()) tracer.EXPECT().ClosedConnection(gomock.Any())
@ -1851,7 +1851,7 @@ var _ = Describe("Connection", func() {
It("sends a connection ticket when the handshake completes", func() { It("sends a connection ticket when the handshake completes", func() {
const size = protocol.MaxPostHandshakeCryptoFrameSize * 3 / 2 const size = protocol.MaxPostHandshakeCryptoFrameSize * 3 / 2
packer.EXPECT().PackCoalescedPacket(false).AnyTimes() packer.EXPECT().PackCoalescedPacket(false, conn.version).AnyTimes()
finishHandshake := make(chan struct{}) finishHandshake := make(chan struct{})
connRunner.EXPECT().Retire(clientDestConnID) connRunner.EXPECT().Retire(clientDestConnID)
go func() { go func() {
@ -1885,7 +1885,7 @@ var _ = Describe("Connection", func() {
// make sure the go routine returns // make sure the go routine returns
streamManager.EXPECT().CloseWithError(gomock.Any()) streamManager.EXPECT().CloseWithError(gomock.Any())
expectReplaceWithClosed() expectReplaceWithClosed()
packer.EXPECT().PackApplicationClose(gomock.Any()).Return(&coalescedPacket{buffer: getPacketBuffer()}, nil) packer.EXPECT().PackApplicationClose(gomock.Any(), conn.version).Return(&coalescedPacket{buffer: getPacketBuffer()}, nil)
cryptoSetup.EXPECT().Close() cryptoSetup.EXPECT().Close()
mconn.EXPECT().Write(gomock.Any()) mconn.EXPECT().Write(gomock.Any())
tracer.EXPECT().ClosedConnection(gomock.Any()) tracer.EXPECT().ClosedConnection(gomock.Any())
@ -1895,10 +1895,10 @@ var _ = Describe("Connection", func() {
}) })
It("doesn't cancel the HandshakeComplete context when the handshake fails", func() { It("doesn't cancel the HandshakeComplete context when the handshake fails", func() {
packer.EXPECT().PackCoalescedPacket(false).AnyTimes() packer.EXPECT().PackCoalescedPacket(false, conn.version).AnyTimes()
streamManager.EXPECT().CloseWithError(gomock.Any()) streamManager.EXPECT().CloseWithError(gomock.Any())
expectReplaceWithClosed() expectReplaceWithClosed()
packer.EXPECT().PackConnectionClose(gomock.Any()).Return(&coalescedPacket{buffer: getPacketBuffer()}, nil) packer.EXPECT().PackConnectionClose(gomock.Any(), conn.version).Return(&coalescedPacket{buffer: getPacketBuffer()}, nil)
cryptoSetup.EXPECT().Close() cryptoSetup.EXPECT().Close()
tracer.EXPECT().ClosedConnection(gomock.Any()) tracer.EXPECT().ClosedConnection(gomock.Any())
tracer.EXPECT().Close() tracer.EXPECT().Close()
@ -1928,14 +1928,14 @@ var _ = Describe("Connection", func() {
conn.sentPacketHandler = sph conn.sentPacketHandler = sph
done := make(chan struct{}) done := make(chan struct{})
connRunner.EXPECT().Retire(clientDestConnID) connRunner.EXPECT().Retire(clientDestConnID)
packer.EXPECT().PackPacket(false, gomock.Any()).DoAndReturn(func(bool, time.Time) (shortHeaderPacket, *packetBuffer, error) { packer.EXPECT().PackPacket(false, gomock.Any(), conn.version).DoAndReturn(func(bool, time.Time, protocol.VersionNumber) (shortHeaderPacket, *packetBuffer, error) {
frames, _ := conn.framer.AppendControlFrames(nil, protocol.MaxByteCount) frames, _ := conn.framer.AppendControlFrames(nil, protocol.MaxByteCount)
Expect(frames).ToNot(BeEmpty()) Expect(frames).ToNot(BeEmpty())
Expect(frames[0].Frame).To(BeEquivalentTo(&wire.HandshakeDoneFrame{})) Expect(frames[0].Frame).To(BeEquivalentTo(&wire.HandshakeDoneFrame{}))
defer close(done) defer close(done)
return shortHeaderPacket{Packet: &ackhandler.Packet{}}, getPacketBuffer(), nil return shortHeaderPacket{Packet: &ackhandler.Packet{}}, getPacketBuffer(), nil
}) })
packer.EXPECT().PackPacket(false, gomock.Any()).Return(shortHeaderPacket{}, nil, errNothingToPack).AnyTimes() packer.EXPECT().PackPacket(false, gomock.Any(), conn.version).Return(shortHeaderPacket{}, nil, errNothingToPack).AnyTimes()
go func() { go func() {
defer GinkgoRecover() defer GinkgoRecover()
cryptoSetup.EXPECT().RunHandshake() cryptoSetup.EXPECT().RunHandshake()
@ -1949,7 +1949,7 @@ var _ = Describe("Connection", func() {
// make sure the go routine returns // make sure the go routine returns
streamManager.EXPECT().CloseWithError(gomock.Any()) streamManager.EXPECT().CloseWithError(gomock.Any())
expectReplaceWithClosed() expectReplaceWithClosed()
packer.EXPECT().PackApplicationClose(gomock.Any()).Return(&coalescedPacket{buffer: getPacketBuffer()}, nil) packer.EXPECT().PackApplicationClose(gomock.Any(), conn.version).Return(&coalescedPacket{buffer: getPacketBuffer()}, nil)
cryptoSetup.EXPECT().Close() cryptoSetup.EXPECT().Close()
tracer.EXPECT().ClosedConnection(gomock.Any()) tracer.EXPECT().ClosedConnection(gomock.Any())
tracer.EXPECT().Close() tracer.EXPECT().Close()
@ -1967,7 +1967,7 @@ var _ = Describe("Connection", func() {
}() }()
streamManager.EXPECT().CloseWithError(gomock.Any()) streamManager.EXPECT().CloseWithError(gomock.Any())
expectReplaceWithClosed() expectReplaceWithClosed()
packer.EXPECT().PackApplicationClose(gomock.Any()).Return(&coalescedPacket{buffer: getPacketBuffer()}, nil) packer.EXPECT().PackApplicationClose(gomock.Any(), conn.version).Return(&coalescedPacket{buffer: getPacketBuffer()}, nil)
cryptoSetup.EXPECT().Close() cryptoSetup.EXPECT().Close()
mconn.EXPECT().Write(gomock.Any()) mconn.EXPECT().Write(gomock.Any())
tracer.EXPECT().ClosedConnection(gomock.Any()) tracer.EXPECT().ClosedConnection(gomock.Any())
@ -1991,7 +1991,7 @@ var _ = Describe("Connection", func() {
}() }()
streamManager.EXPECT().CloseWithError(gomock.Any()) streamManager.EXPECT().CloseWithError(gomock.Any())
expectReplaceWithClosed() expectReplaceWithClosed()
packer.EXPECT().PackApplicationClose(gomock.Any()).Return(&coalescedPacket{buffer: getPacketBuffer()}, nil) packer.EXPECT().PackApplicationClose(gomock.Any(), conn.version).Return(&coalescedPacket{buffer: getPacketBuffer()}, nil)
cryptoSetup.EXPECT().Close() cryptoSetup.EXPECT().Close()
mconn.EXPECT().Write(gomock.Any()) mconn.EXPECT().Write(gomock.Any())
tracer.EXPECT().ClosedConnection(gomock.Any()) tracer.EXPECT().ClosedConnection(gomock.Any())
@ -2013,7 +2013,7 @@ var _ = Describe("Connection", func() {
} }
streamManager.EXPECT().UpdateLimits(params) streamManager.EXPECT().UpdateLimits(params)
packer.EXPECT().HandleTransportParameters(params) packer.EXPECT().HandleTransportParameters(params)
packer.EXPECT().PackCoalescedPacket(false).MaxTimes(3) packer.EXPECT().PackCoalescedPacket(false, conn.version).MaxTimes(3)
Expect(conn.earlyConnReady()).ToNot(BeClosed()) Expect(conn.earlyConnReady()).ToNot(BeClosed())
connRunner.EXPECT().GetStatelessResetToken(gomock.Any()).Times(2) connRunner.EXPECT().GetStatelessResetToken(gomock.Any()).Times(2)
connRunner.EXPECT().Add(gomock.Any(), conn).Times(2) connRunner.EXPECT().Add(gomock.Any(), conn).Times(2)
@ -2052,7 +2052,7 @@ var _ = Describe("Connection", func() {
// make the go routine return // make the go routine return
expectReplaceWithClosed() expectReplaceWithClosed()
streamManager.EXPECT().CloseWithError(gomock.Any()) streamManager.EXPECT().CloseWithError(gomock.Any())
packer.EXPECT().PackApplicationClose(gomock.Any()).Return(&coalescedPacket{buffer: getPacketBuffer()}, nil) packer.EXPECT().PackApplicationClose(gomock.Any(), conn.version).Return(&coalescedPacket{buffer: getPacketBuffer()}, nil)
cryptoSetup.EXPECT().Close() cryptoSetup.EXPECT().Close()
mconn.EXPECT().Write(gomock.Any()) mconn.EXPECT().Write(gomock.Any())
tracer.EXPECT().ClosedConnection(gomock.Any()) tracer.EXPECT().ClosedConnection(gomock.Any())
@ -2065,7 +2065,7 @@ var _ = Describe("Connection", func() {
setRemoteIdleTimeout(5 * time.Second) setRemoteIdleTimeout(5 * time.Second)
conn.lastPacketReceivedTime = time.Now().Add(-5 * time.Second / 2) conn.lastPacketReceivedTime = time.Now().Add(-5 * time.Second / 2)
sent := make(chan struct{}) sent := make(chan struct{})
packer.EXPECT().PackCoalescedPacket(false).Do(func(bool) (*coalescedPacket, error) { packer.EXPECT().PackCoalescedPacket(false, conn.version).Do(func(bool, protocol.VersionNumber) (*coalescedPacket, error) {
close(sent) close(sent)
return nil, nil return nil, nil
}) })
@ -2078,7 +2078,7 @@ var _ = Describe("Connection", func() {
setRemoteIdleTimeout(time.Hour) setRemoteIdleTimeout(time.Hour)
conn.lastPacketReceivedTime = time.Now().Add(-protocol.MaxKeepAliveInterval).Add(-time.Millisecond) conn.lastPacketReceivedTime = time.Now().Add(-protocol.MaxKeepAliveInterval).Add(-time.Millisecond)
sent := make(chan struct{}) sent := make(chan struct{})
packer.EXPECT().PackCoalescedPacket(false).Do(func(bool) (*coalescedPacket, error) { packer.EXPECT().PackCoalescedPacket(false, conn.version).Do(func(bool, protocol.VersionNumber) (*coalescedPacket, error) {
close(sent) close(sent)
return nil, nil return nil, nil
}) })
@ -2166,7 +2166,7 @@ var _ = Describe("Connection", func() {
conn.config.HandshakeIdleTimeout = 9999 * time.Second conn.config.HandshakeIdleTimeout = 9999 * time.Second
conn.config.MaxIdleTimeout = 9999 * time.Second conn.config.MaxIdleTimeout = 9999 * time.Second
conn.lastPacketReceivedTime = time.Now().Add(-time.Minute) conn.lastPacketReceivedTime = time.Now().Add(-time.Minute)
packer.EXPECT().PackApplicationClose(gomock.Any()).DoAndReturn(func(e *qerr.ApplicationError) (*coalescedPacket, error) { packer.EXPECT().PackApplicationClose(gomock.Any(), conn.version).DoAndReturn(func(e *qerr.ApplicationError, _ protocol.VersionNumber) (*coalescedPacket, error) {
Expect(e.ErrorCode).To(BeZero()) Expect(e.ErrorCode).To(BeZero())
return &coalescedPacket{buffer: getPacketBuffer()}, nil return &coalescedPacket{buffer: getPacketBuffer()}, nil
}) })
@ -2197,7 +2197,7 @@ var _ = Describe("Connection", func() {
It("closes the connection due to the idle timeout before handshake", func() { It("closes the connection due to the idle timeout before handshake", func() {
conn.config.HandshakeIdleTimeout = 0 conn.config.HandshakeIdleTimeout = 0
packer.EXPECT().PackCoalescedPacket(false).AnyTimes() packer.EXPECT().PackCoalescedPacket(false, conn.version).AnyTimes()
connRunner.EXPECT().Remove(gomock.Any()).AnyTimes() connRunner.EXPECT().Remove(gomock.Any()).AnyTimes()
cryptoSetup.EXPECT().Close() cryptoSetup.EXPECT().Close()
gomock.InOrder( gomock.InOrder(
@ -2223,7 +2223,7 @@ var _ = Describe("Connection", func() {
}) })
It("closes the connection due to the idle timeout after handshake", func() { It("closes the connection due to the idle timeout after handshake", func() {
packer.EXPECT().PackCoalescedPacket(false).AnyTimes() packer.EXPECT().PackCoalescedPacket(false, conn.version).AnyTimes()
gomock.InOrder( gomock.InOrder(
connRunner.EXPECT().Retire(clientDestConnID), connRunner.EXPECT().Retire(clientDestConnID),
connRunner.EXPECT().Remove(gomock.Any()), connRunner.EXPECT().Remove(gomock.Any()),
@ -2264,7 +2264,7 @@ var _ = Describe("Connection", func() {
}() }()
Consistently(conn.Context().Done()).ShouldNot(BeClosed()) Consistently(conn.Context().Done()).ShouldNot(BeClosed())
// make the go routine return // make the go routine return
packer.EXPECT().PackApplicationClose(gomock.Any()).Return(&coalescedPacket{buffer: getPacketBuffer()}, nil) packer.EXPECT().PackApplicationClose(gomock.Any(), conn.version).Return(&coalescedPacket{buffer: getPacketBuffer()}, nil)
expectReplaceWithClosed() expectReplaceWithClosed()
cryptoSetup.EXPECT().Close() cryptoSetup.EXPECT().Close()
mconn.EXPECT().Write(gomock.Any()) mconn.EXPECT().Write(gomock.Any())
@ -2448,7 +2448,7 @@ var _ = Describe("Client Connection", func() {
tracer.EXPECT().ReceivedLongHeaderPacket(gomock.Any(), p.Size(), []logging.Frame{}) tracer.EXPECT().ReceivedLongHeaderPacket(gomock.Any(), p.Size(), []logging.Frame{})
Expect(conn.handlePacketImpl(p)).To(BeTrue()) Expect(conn.handlePacketImpl(p)).To(BeTrue())
// make sure the go routine returns // make sure the go routine returns
packer.EXPECT().PackApplicationClose(gomock.Any()).Return(&coalescedPacket{buffer: getPacketBuffer()}, nil) packer.EXPECT().PackApplicationClose(gomock.Any(), conn.version).Return(&coalescedPacket{buffer: getPacketBuffer()}, nil)
expectReplaceWithClosed() expectReplaceWithClosed()
cryptoSetup.EXPECT().Close() cryptoSetup.EXPECT().Close()
mconn.EXPECT().Write(gomock.Any()) mconn.EXPECT().Write(gomock.Any())
@ -2707,9 +2707,9 @@ var _ = Describe("Client Connection", func() {
if !closed { if !closed {
connRunner.EXPECT().ReplaceWithClosed(gomock.Any(), gomock.Any(), gomock.Any()) connRunner.EXPECT().ReplaceWithClosed(gomock.Any(), gomock.Any(), gomock.Any())
if applicationClose { if applicationClose {
packer.EXPECT().PackApplicationClose(gomock.Any()).Return(&coalescedPacket{buffer: getPacketBuffer()}, nil).MaxTimes(1) packer.EXPECT().PackApplicationClose(gomock.Any(), conn.version).Return(&coalescedPacket{buffer: getPacketBuffer()}, nil).MaxTimes(1)
} else { } else {
packer.EXPECT().PackConnectionClose(gomock.Any()).Return(&coalescedPacket{buffer: getPacketBuffer()}, nil).MaxTimes(1) packer.EXPECT().PackConnectionClose(gomock.Any(), conn.version).Return(&coalescedPacket{buffer: getPacketBuffer()}, nil).MaxTimes(1)
} }
cryptoSetup.EXPECT().Close() cryptoSetup.EXPECT().Close()
mconn.EXPECT().Write(gomock.Any()) mconn.EXPECT().Write(gomock.Any())
@ -2739,7 +2739,7 @@ var _ = Describe("Client Connection", func() {
}, },
} }
packer.EXPECT().HandleTransportParameters(gomock.Any()) packer.EXPECT().HandleTransportParameters(gomock.Any())
packer.EXPECT().PackCoalescedPacket(false).MaxTimes(1) packer.EXPECT().PackCoalescedPacket(false, conn.version).MaxTimes(1)
tracer.EXPECT().ReceivedTransportParameters(params) tracer.EXPECT().ReceivedTransportParameters(params)
conn.handleTransportParameters(params) conn.handleTransportParameters(params)
conn.handleHandshakeComplete() conn.handleHandshakeComplete()

48
mock_packer_test.go
View file

@ -51,69 +51,69 @@ func (mr *MockPackerMockRecorder) HandleTransportParameters(arg0 interface{}) *g
} }
// MaybePackProbePacket mocks base method. // MaybePackProbePacket mocks base method.
func (m *MockPacker) MaybePackProbePacket(arg0 protocol.EncryptionLevel) (*coalescedPacket, error) { func (m *MockPacker) MaybePackProbePacket(arg0 protocol.EncryptionLevel, arg1 protocol.VersionNumber) (*coalescedPacket, error) {
m.ctrl.T.Helper() m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "MaybePackProbePacket", arg0) ret := m.ctrl.Call(m, "MaybePackProbePacket", arg0, arg1)
ret0, _ := ret[0].(*coalescedPacket) ret0, _ := ret[0].(*coalescedPacket)
ret1, _ := ret[1].(error) ret1, _ := ret[1].(error)
return ret0, ret1 return ret0, ret1
} }
// MaybePackProbePacket indicates an expected call of MaybePackProbePacket. // MaybePackProbePacket indicates an expected call of MaybePackProbePacket.
func (mr *MockPackerMockRecorder) MaybePackProbePacket(arg0 interface{}) *gomock.Call { func (mr *MockPackerMockRecorder) MaybePackProbePacket(arg0, arg1 interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper() mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MaybePackProbePacket", reflect.TypeOf((*MockPacker)(nil).MaybePackProbePacket), arg0) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MaybePackProbePacket", reflect.TypeOf((*MockPacker)(nil).MaybePackProbePacket), arg0, arg1)
} }
// PackApplicationClose mocks base method. // PackApplicationClose mocks base method.
func (m *MockPacker) PackApplicationClose(arg0 *qerr.ApplicationError) (*coalescedPacket, error) { func (m *MockPacker) PackApplicationClose(arg0 *qerr.ApplicationError, arg1 protocol.VersionNumber) (*coalescedPacket, error) {
m.ctrl.T.Helper() m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "PackApplicationClose", arg0) ret := m.ctrl.Call(m, "PackApplicationClose", arg0, arg1)
ret0, _ := ret[0].(*coalescedPacket) ret0, _ := ret[0].(*coalescedPacket)
ret1, _ := ret[1].(error) ret1, _ := ret[1].(error)
return ret0, ret1 return ret0, ret1
} }
// PackApplicationClose indicates an expected call of PackApplicationClose. // PackApplicationClose indicates an expected call of PackApplicationClose.
func (mr *MockPackerMockRecorder) PackApplicationClose(arg0 interface{}) *gomock.Call { func (mr *MockPackerMockRecorder) PackApplicationClose(arg0, arg1 interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper() mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PackApplicationClose", reflect.TypeOf((*MockPacker)(nil).PackApplicationClose), arg0) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PackApplicationClose", reflect.TypeOf((*MockPacker)(nil).PackApplicationClose), arg0, arg1)
} }
// PackCoalescedPacket mocks base method. // PackCoalescedPacket mocks base method.
func (m *MockPacker) PackCoalescedPacket(onlyAck bool) (*coalescedPacket, error) { func (m *MockPacker) PackCoalescedPacket(onlyAck bool, v protocol.VersionNumber) (*coalescedPacket, error) {
m.ctrl.T.Helper() m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "PackCoalescedPacket", onlyAck) ret := m.ctrl.Call(m, "PackCoalescedPacket", onlyAck, v)
ret0, _ := ret[0].(*coalescedPacket) ret0, _ := ret[0].(*coalescedPacket)
ret1, _ := ret[1].(error) ret1, _ := ret[1].(error)
return ret0, ret1 return ret0, ret1
} }
// PackCoalescedPacket indicates an expected call of PackCoalescedPacket. // PackCoalescedPacket indicates an expected call of PackCoalescedPacket.
func (mr *MockPackerMockRecorder) PackCoalescedPacket(onlyAck interface{}) *gomock.Call { func (mr *MockPackerMockRecorder) PackCoalescedPacket(onlyAck, v interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper() mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PackCoalescedPacket", reflect.TypeOf((*MockPacker)(nil).PackCoalescedPacket), onlyAck) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PackCoalescedPacket", reflect.TypeOf((*MockPacker)(nil).PackCoalescedPacket), onlyAck, v)
} }
// PackConnectionClose mocks base method. // PackConnectionClose mocks base method.
func (m *MockPacker) PackConnectionClose(arg0 *qerr.TransportError) (*coalescedPacket, error) { func (m *MockPacker) PackConnectionClose(arg0 *qerr.TransportError, arg1 protocol.VersionNumber) (*coalescedPacket, error) {
m.ctrl.T.Helper() m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "PackConnectionClose", arg0) ret := m.ctrl.Call(m, "PackConnectionClose", arg0, arg1)
ret0, _ := ret[0].(*coalescedPacket) ret0, _ := ret[0].(*coalescedPacket)
ret1, _ := ret[1].(error) ret1, _ := ret[1].(error)
return ret0, ret1 return ret0, ret1
} }
// PackConnectionClose indicates an expected call of PackConnectionClose. // PackConnectionClose indicates an expected call of PackConnectionClose.
func (mr *MockPackerMockRecorder) PackConnectionClose(arg0 interface{}) *gomock.Call { func (mr *MockPackerMockRecorder) PackConnectionClose(arg0, arg1 interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper() mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PackConnectionClose", reflect.TypeOf((*MockPacker)(nil).PackConnectionClose), arg0) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PackConnectionClose", reflect.TypeOf((*MockPacker)(nil).PackConnectionClose), arg0, arg1)
} }
// PackMTUProbePacket mocks base method. // PackMTUProbePacket mocks base method.
func (m *MockPacker) PackMTUProbePacket(ping ackhandler.Frame, size protocol.ByteCount, now time.Time) (shortHeaderPacket, *packetBuffer, error) { func (m *MockPacker) PackMTUProbePacket(ping ackhandler.Frame, size protocol.ByteCount, now time.Time, v protocol.VersionNumber) (shortHeaderPacket, *packetBuffer, error) {
m.ctrl.T.Helper() m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "PackMTUProbePacket", ping, size, now) ret := m.ctrl.Call(m, "PackMTUProbePacket", ping, size, now, v)
ret0, _ := ret[0].(shortHeaderPacket) ret0, _ := ret[0].(shortHeaderPacket)
ret1, _ := ret[1].(*packetBuffer) ret1, _ := ret[1].(*packetBuffer)
ret2, _ := ret[2].(error) ret2, _ := ret[2].(error)
@ -121,15 +121,15 @@ func (m *MockPacker) PackMTUProbePacket(ping ackhandler.Frame, size protocol.Byt
} }
// PackMTUProbePacket indicates an expected call of PackMTUProbePacket. // PackMTUProbePacket indicates an expected call of PackMTUProbePacket.
func (mr *MockPackerMockRecorder) PackMTUProbePacket(ping, size, now interface{}) *gomock.Call { func (mr *MockPackerMockRecorder) PackMTUProbePacket(ping, size, now, v interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper() mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PackMTUProbePacket", reflect.TypeOf((*MockPacker)(nil).PackMTUProbePacket), ping, size, now) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PackMTUProbePacket", reflect.TypeOf((*MockPacker)(nil).PackMTUProbePacket), ping, size, now, v)
} }
// PackPacket mocks base method. // PackPacket mocks base method.
func (m *MockPacker) PackPacket(onlyAck bool, now time.Time) (shortHeaderPacket, *packetBuffer, error) { func (m *MockPacker) PackPacket(onlyAck bool, now time.Time, v protocol.VersionNumber) (shortHeaderPacket, *packetBuffer, error) {
m.ctrl.T.Helper() m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "PackPacket", onlyAck, now) ret := m.ctrl.Call(m, "PackPacket", onlyAck, now, v)
ret0, _ := ret[0].(shortHeaderPacket) ret0, _ := ret[0].(shortHeaderPacket)
ret1, _ := ret[1].(*packetBuffer) ret1, _ := ret[1].(*packetBuffer)
ret2, _ := ret[2].(error) ret2, _ := ret[2].(error)
@ -137,9 +137,9 @@ func (m *MockPacker) PackPacket(onlyAck bool, now time.Time) (shortHeaderPacket,
} }
// PackPacket indicates an expected call of PackPacket. // PackPacket indicates an expected call of PackPacket.
func (mr *MockPackerMockRecorder) PackPacket(onlyAck, now interface{}) *gomock.Call { func (mr *MockPackerMockRecorder) PackPacket(onlyAck, now, v interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper() mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PackPacket", reflect.TypeOf((*MockPacker)(nil).PackPacket), onlyAck, now) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PackPacket", reflect.TypeOf((*MockPacker)(nil).PackPacket), onlyAck, now, v)
} }
// SetMaxPacketSize mocks base method. // SetMaxPacketSize mocks base method.

172
packet_packer.go
View file

@ -17,14 +17,14 @@ import (
var errNothingToPack = errors.New("nothing to pack") var errNothingToPack = errors.New("nothing to pack")
type packer interface { type packer interface {
PackCoalescedPacket(onlyAck bool) (*coalescedPacket, error) PackCoalescedPacket(onlyAck bool, v protocol.VersionNumber) (*coalescedPacket, error)
PackPacket(onlyAck bool, now time.Time) (shortHeaderPacket, *packetBuffer, error) PackPacket(onlyAck bool, now time.Time, v protocol.VersionNumber) (shortHeaderPacket, *packetBuffer, error)
MaybePackProbePacket(protocol.EncryptionLevel) (*coalescedPacket, error) MaybePackProbePacket(protocol.EncryptionLevel, protocol.VersionNumber) (*coalescedPacket, error)
PackConnectionClose(*qerr.TransportError) (*coalescedPacket, error) PackConnectionClose(*qerr.TransportError, protocol.VersionNumber) (*coalescedPacket, error)
PackApplicationClose(*qerr.ApplicationError) (*coalescedPacket, error) PackApplicationClose(*qerr.ApplicationError, protocol.VersionNumber) (*coalescedPacket, error)
SetMaxPacketSize(protocol.ByteCount) SetMaxPacketSize(protocol.ByteCount)
PackMTUProbePacket(ping ackhandler.Frame, size protocol.ByteCount, now time.Time) (shortHeaderPacket, *packetBuffer, error) PackMTUProbePacket(ping ackhandler.Frame, size protocol.ByteCount, now time.Time, v protocol.VersionNumber) (shortHeaderPacket, *packetBuffer, error)
HandleTransportParameters(*wire.TransportParameters) HandleTransportParameters(*wire.TransportParameters)
SetToken([]byte) SetToken([]byte)
@ -156,7 +156,6 @@ type packetPacker struct {
getDestConnID func() protocol.ConnectionID getDestConnID func() protocol.ConnectionID
perspective protocol.Perspective perspective protocol.Perspective
version protocol.VersionNumber
cryptoSetup sealingManager cryptoSetup sealingManager
initialStream cryptoStream initialStream cryptoStream
@ -176,21 +175,7 @@ type packetPacker struct {
var _ packer = &packetPacker{} var _ packer = &packetPacker{}
func newPacketPacker( func newPacketPacker(srcConnID protocol.ConnectionID, getDestConnID func() protocol.ConnectionID, initialStream cryptoStream, handshakeStream cryptoStream, packetNumberManager packetNumberManager, retransmissionQueue *retransmissionQueue, remoteAddr net.Addr, cryptoSetup sealingManager, framer frameSource, acks ackFrameSource, datagramQueue *datagramQueue, perspective protocol.Perspective) *packetPacker {
srcConnID protocol.ConnectionID,
getDestConnID func() protocol.ConnectionID,
initialStream cryptoStream,
handshakeStream cryptoStream,
packetNumberManager packetNumberManager,
retransmissionQueue *retransmissionQueue,
remoteAddr net.Addr, // only used for determining the max packet size
cryptoSetup sealingManager,
framer frameSource,
acks ackFrameSource,
datagramQueue *datagramQueue,
perspective protocol.Perspective,
version protocol.VersionNumber,
) *packetPacker {
return &packetPacker{ return &packetPacker{
cryptoSetup: cryptoSetup, cryptoSetup: cryptoSetup,
getDestConnID: getDestConnID, getDestConnID: getDestConnID,
@ -200,7 +185,6 @@ func newPacketPacker(
retransmissionQueue: retransmissionQueue, retransmissionQueue: retransmissionQueue,
datagramQueue: datagramQueue, datagramQueue: datagramQueue,
perspective: perspective, perspective: perspective,
version: version,
framer: framer, framer: framer,
acks: acks, acks: acks,
pnManager: packetNumberManager, pnManager: packetNumberManager,
@ -209,18 +193,18 @@ func newPacketPacker(
} }
// PackConnectionClose packs a packet that closes the connection with a transport error. // PackConnectionClose packs a packet that closes the connection with a transport error.
func (p *packetPacker) PackConnectionClose(e *qerr.TransportError) (*coalescedPacket, error) { func (p *packetPacker) PackConnectionClose(e *qerr.TransportError, v protocol.VersionNumber) (*coalescedPacket, error) {
var reason string var reason string
// don't send details of crypto errors // don't send details of crypto errors
if !e.ErrorCode.IsCryptoError() { if !e.ErrorCode.IsCryptoError() {
reason = e.ErrorMessage reason = e.ErrorMessage
} }
return p.packConnectionClose(false, uint64(e.ErrorCode), e.FrameType, reason) return p.packConnectionClose(false, uint64(e.ErrorCode), e.FrameType, reason, v)
} }
// PackApplicationClose packs a packet that closes the connection with an application error. // PackApplicationClose packs a packet that closes the connection with an application error.
func (p *packetPacker) PackApplicationClose(e *qerr.ApplicationError) (*coalescedPacket, error) { func (p *packetPacker) PackApplicationClose(e *qerr.ApplicationError, v protocol.VersionNumber) (*coalescedPacket, error) {
return p.packConnectionClose(true, uint64(e.ErrorCode), 0, e.ErrorMessage) return p.packConnectionClose(true, uint64(e.ErrorCode), 0, e.ErrorMessage, v)
} }
func (p *packetPacker) packConnectionClose( func (p *packetPacker) packConnectionClose(
@ -228,6 +212,7 @@ func (p *packetPacker) packConnectionClose(
errorCode uint64, errorCode uint64,
frameType uint64, frameType uint64,
reason string, reason string,
v protocol.VersionNumber,
) (*coalescedPacket, error) { ) (*coalescedPacket, error) {
var sealers [4]sealer var sealers [4]sealer
var hdrs [3]*wire.ExtendedHeader var hdrs [3]*wire.ExtendedHeader
@ -257,7 +242,7 @@ func (p *packetPacker) packConnectionClose(
} }
pl := payload{ pl := payload{
frames: []*ackhandler.Frame{{Frame: ccf}}, frames: []*ackhandler.Frame{{Frame: ccf}},
length: ccf.Length(p.version), length: ccf.Length(v),
} }
var sealer sealer var sealer sealer
@ -290,9 +275,9 @@ func (p *packetPacker) packConnectionClose(
oneRTTPacketNumber, oneRTTPacketNumberLen = p.pnManager.PeekPacketNumber(protocol.Encryption1RTT) oneRTTPacketNumber, oneRTTPacketNumberLen = p.pnManager.PeekPacketNumber(protocol.Encryption1RTT)
size += p.shortHeaderPacketLength(connID, oneRTTPacketNumberLen, pl) size += p.shortHeaderPacketLength(connID, oneRTTPacketNumberLen, pl)
} else { } else {
hdr = p.getLongHeader(encLevel) hdr = p.getLongHeader(encLevel, v)
hdrs[i] = hdr hdrs[i] = hdr
size += p.longHeaderPacketLength(hdr, pl) + protocol.ByteCount(sealer.Overhead()) size += p.longHeaderPacketLength(hdr, pl, v) + protocol.ByteCount(sealer.Overhead())
numLongHdrPackets++ numLongHdrPackets++
} }
payloads[i] = pl payloads[i] = pl
@ -311,7 +296,7 @@ func (p *packetPacker) packConnectionClose(
paddingLen = p.initialPaddingLen(payloads[i].frames, size) paddingLen = p.initialPaddingLen(payloads[i].frames, size)
} }
if encLevel == protocol.Encryption1RTT { if encLevel == protocol.Encryption1RTT {
ap, ack, err := p.appendShortHeaderPacket(buffer, connID, oneRTTPacketNumber, oneRTTPacketNumberLen, keyPhase, payloads[i], paddingLen, sealers[i], false) ap, ack, err := p.appendShortHeaderPacket(buffer, connID, oneRTTPacketNumber, oneRTTPacketNumberLen, keyPhase, payloads[i], paddingLen, sealers[i], false, v)
if err != nil { if err != nil {
return nil, err return nil, err
} }
@ -323,7 +308,7 @@ func (p *packetPacker) packConnectionClose(
KeyPhase: keyPhase, KeyPhase: keyPhase,
} }
} else { } else {
longHdrPacket, err := p.appendLongHeaderPacket(buffer, hdrs[i], payloads[i], paddingLen, encLevel, sealers[i]) longHdrPacket, err := p.appendLongHeaderPacket(buffer, hdrs[i], payloads[i], paddingLen, encLevel, sealers[i], v)
if err != nil { if err != nil {
return nil, err return nil, err
} }
@ -336,13 +321,13 @@ func (p *packetPacker) packConnectionClose(
// longHeaderPacketLength calculates the length of a serialized long header packet. // longHeaderPacketLength calculates the length of a serialized long header packet.
// It takes into account that packets that have a tiny payload need to be padded, // It takes into account that packets that have a tiny payload need to be padded,
// such that len(payload) + packet number len >= 4 + AEAD overhead // such that len(payload) + packet number len >= 4 + AEAD overhead
func (p *packetPacker) longHeaderPacketLength(hdr *wire.ExtendedHeader, pl payload) protocol.ByteCount { func (p *packetPacker) longHeaderPacketLength(hdr *wire.ExtendedHeader, pl payload, v protocol.VersionNumber) protocol.ByteCount {
var paddingLen protocol.ByteCount var paddingLen protocol.ByteCount
pnLen := protocol.ByteCount(hdr.PacketNumberLen) pnLen := protocol.ByteCount(hdr.PacketNumberLen)
if pl.length < 4-pnLen { if pl.length < 4-pnLen {
paddingLen = 4 - pnLen - pl.length paddingLen = 4 - pnLen - pl.length
} }
return hdr.GetLength(p.version) + pl.length + paddingLen return hdr.GetLength(v) + pl.length + paddingLen
} }
// shortHeaderPacketLength calculates the length of a serialized short header packet. // shortHeaderPacketLength calculates the length of a serialized short header packet.
@ -371,7 +356,7 @@ func (p *packetPacker) initialPaddingLen(frames []*ackhandler.Frame, size protoc
// PackCoalescedPacket packs a new packet. // PackCoalescedPacket packs a new packet.
// It packs an Initial / Handshake if there is data to send in these packet number spaces. // It packs an Initial / Handshake if there is data to send in these packet number spaces.
// It should only be called before the handshake is confirmed. // It should only be called before the handshake is confirmed.
func (p *packetPacker) PackCoalescedPacket(onlyAck bool) (*coalescedPacket, error) { func (p *packetPacker) PackCoalescedPacket(onlyAck bool, v protocol.VersionNumber) (*coalescedPacket, error) {
maxPacketSize := p.maxPacketSize maxPacketSize := p.maxPacketSize
if p.perspective == protocol.PerspectiveClient { if p.perspective == protocol.PerspectiveClient {
maxPacketSize = protocol.MinInitialPacketSize maxPacketSize = protocol.MinInitialPacketSize
@ -389,9 +374,9 @@ func (p *packetPacker) PackCoalescedPacket(onlyAck bool) (*coalescedPacket, erro
} }
var size protocol.ByteCount var size protocol.ByteCount
if initialSealer != nil { if initialSealer != nil {
initialHdr, initialPayload = p.maybeGetCryptoPacket(maxPacketSize-protocol.ByteCount(initialSealer.Overhead()), protocol.EncryptionInitial, onlyAck, true) initialHdr, initialPayload = p.maybeGetCryptoPacket(maxPacketSize-protocol.ByteCount(initialSealer.Overhead()), protocol.EncryptionInitial, onlyAck, true, v)
if initialPayload.length > 0 { if initialPayload.length > 0 {
size += p.longHeaderPacketLength(initialHdr, initialPayload) + protocol.ByteCount(initialSealer.Overhead()) size += p.longHeaderPacketLength(initialHdr, initialPayload, v) + protocol.ByteCount(initialSealer.Overhead())
} }
} }
@ -404,9 +389,9 @@ func (p *packetPacker) PackCoalescedPacket(onlyAck bool) (*coalescedPacket, erro
return nil, err return nil, err
} }
if handshakeSealer != nil { if handshakeSealer != nil {
handshakeHdr, handshakePayload = p.maybeGetCryptoPacket(maxPacketSize-size-protocol.ByteCount(handshakeSealer.Overhead()), protocol.EncryptionHandshake, onlyAck, size == 0) handshakeHdr, handshakePayload = p.maybeGetCryptoPacket(maxPacketSize-size-protocol.ByteCount(handshakeSealer.Overhead()), protocol.EncryptionHandshake, onlyAck, size == 0, v)
if handshakePayload.length > 0 { if handshakePayload.length > 0 {
s := p.longHeaderPacketLength(handshakeHdr, handshakePayload) + protocol.ByteCount(handshakeSealer.Overhead()) s := p.longHeaderPacketLength(handshakeHdr, handshakePayload, v) + protocol.ByteCount(handshakeSealer.Overhead())
size += s size += s
} }
} }
@ -428,7 +413,7 @@ func (p *packetPacker) PackCoalescedPacket(onlyAck bool) (*coalescedPacket, erro
connID = p.getDestConnID() connID = p.getDestConnID()
oneRTTPacketNumber, oneRTTPacketNumberLen = p.pnManager.PeekPacketNumber(protocol.Encryption1RTT) oneRTTPacketNumber, oneRTTPacketNumberLen = p.pnManager.PeekPacketNumber(protocol.Encryption1RTT)
hdrLen := wire.ShortHeaderLen(connID, oneRTTPacketNumberLen) hdrLen := wire.ShortHeaderLen(connID, oneRTTPacketNumberLen)
oneRTTPayload = p.maybeGetShortHeaderPacket(oneRTTSealer, hdrLen, maxPacketSize-size, onlyAck, size == 0) oneRTTPayload = p.maybeGetShortHeaderPacket(oneRTTSealer, hdrLen, maxPacketSize-size, onlyAck, size == 0, v)
if oneRTTPayload.length > 0 { if oneRTTPayload.length > 0 {
size += p.shortHeaderPacketLength(connID, oneRTTPacketNumberLen, oneRTTPayload) + protocol.ByteCount(oneRTTSealer.Overhead()) size += p.shortHeaderPacketLength(connID, oneRTTPacketNumberLen, oneRTTPayload) + protocol.ByteCount(oneRTTSealer.Overhead())
} }
@ -439,9 +424,9 @@ func (p *packetPacker) PackCoalescedPacket(onlyAck bool) (*coalescedPacket, erro
return nil, err return nil, err
} }
if zeroRTTSealer != nil { if zeroRTTSealer != nil {
zeroRTTHdr, zeroRTTPayload = p.maybeGetAppDataPacketFor0RTT(zeroRTTSealer, maxPacketSize-size) zeroRTTHdr, zeroRTTPayload = p.maybeGetAppDataPacketFor0RTT(zeroRTTSealer, maxPacketSize-size, v)
if zeroRTTPayload.length > 0 { if zeroRTTPayload.length > 0 {
size += p.longHeaderPacketLength(zeroRTTHdr, zeroRTTPayload) + protocol.ByteCount(zeroRTTSealer.Overhead()) size += p.longHeaderPacketLength(zeroRTTHdr, zeroRTTPayload, v) + protocol.ByteCount(zeroRTTSealer.Overhead())
} }
} }
} }
@ -458,27 +443,27 @@ func (p *packetPacker) PackCoalescedPacket(onlyAck bool) (*coalescedPacket, erro
} }
if initialPayload.length > 0 { if initialPayload.length > 0 {
padding := p.initialPaddingLen(initialPayload.frames, size) padding := p.initialPaddingLen(initialPayload.frames, size)
cont, err := p.appendLongHeaderPacket(buffer, initialHdr, initialPayload, padding, protocol.EncryptionInitial, initialSealer) cont, err := p.appendLongHeaderPacket(buffer, initialHdr, initialPayload, padding, protocol.EncryptionInitial, initialSealer, v)
if err != nil { if err != nil {
return nil, err return nil, err
} }
packet.longHdrPackets = append(packet.longHdrPackets, cont) packet.longHdrPackets = append(packet.longHdrPackets, cont)
} }
if handshakePayload.length > 0 { if handshakePayload.length > 0 {
cont, err := p.appendLongHeaderPacket(buffer, handshakeHdr, handshakePayload, 0, protocol.EncryptionHandshake, handshakeSealer) cont, err := p.appendLongHeaderPacket(buffer, handshakeHdr, handshakePayload, 0, protocol.EncryptionHandshake, handshakeSealer, v)
if err != nil { if err != nil {
return nil, err return nil, err
} }
packet.longHdrPackets = append(packet.longHdrPackets, cont) packet.longHdrPackets = append(packet.longHdrPackets, cont)
} }
if zeroRTTPayload.length > 0 { if zeroRTTPayload.length > 0 {
longHdrPacket, err := p.appendLongHeaderPacket(buffer, zeroRTTHdr, zeroRTTPayload, 0, protocol.Encryption0RTT, zeroRTTSealer) longHdrPacket, err := p.appendLongHeaderPacket(buffer, zeroRTTHdr, zeroRTTPayload, 0, protocol.Encryption0RTT, zeroRTTSealer, v)
if err != nil { if err != nil {
return nil, err return nil, err
} }
packet.longHdrPackets = append(packet.longHdrPackets, longHdrPacket) packet.longHdrPackets = append(packet.longHdrPackets, longHdrPacket)
} else if oneRTTPayload.length > 0 { } else if oneRTTPayload.length > 0 {
ap, ack, err := p.appendShortHeaderPacket(buffer, connID, oneRTTPacketNumber, oneRTTPacketNumberLen, kp, oneRTTPayload, 0, oneRTTSealer, false) ap, ack, err := p.appendShortHeaderPacket(buffer, connID, oneRTTPacketNumber, oneRTTPacketNumberLen, kp, oneRTTPayload, 0, oneRTTSealer, false, v)
if err != nil { if err != nil {
return nil, err return nil, err
} }
@ -495,7 +480,7 @@ func (p *packetPacker) PackCoalescedPacket(onlyAck bool) (*coalescedPacket, erro
// PackPacket packs a packet in the application data packet number space. // PackPacket packs a packet in the application data packet number space.
// It should be called after the handshake is confirmed. // It should be called after the handshake is confirmed.
func (p *packetPacker) PackPacket(onlyAck bool, now time.Time) (shortHeaderPacket, *packetBuffer, error) { func (p *packetPacker) PackPacket(onlyAck bool, now time.Time, v protocol.VersionNumber) (shortHeaderPacket, *packetBuffer, error) {
sealer, err := p.cryptoSetup.Get1RTTSealer() sealer, err := p.cryptoSetup.Get1RTTSealer()
if err != nil { if err != nil {
return shortHeaderPacket{}, nil, err return shortHeaderPacket{}, nil, err
@ -503,13 +488,13 @@ func (p *packetPacker) PackPacket(onlyAck bool, now time.Time) (shortHeaderPacke
pn, pnLen := p.pnManager.PeekPacketNumber(protocol.Encryption1RTT) pn, pnLen := p.pnManager.PeekPacketNumber(protocol.Encryption1RTT)
connID := p.getDestConnID() connID := p.getDestConnID()
hdrLen := wire.ShortHeaderLen(connID, pnLen) hdrLen := wire.ShortHeaderLen(connID, pnLen)
pl := p.maybeGetShortHeaderPacket(sealer, hdrLen, p.maxPacketSize, onlyAck, true) pl := p.maybeGetShortHeaderPacket(sealer, hdrLen, p.maxPacketSize, onlyAck, true, v)
if pl.length == 0 { if pl.length == 0 {
return shortHeaderPacket{}, nil, errNothingToPack return shortHeaderPacket{}, nil, errNothingToPack
} }
kp := sealer.KeyPhase() kp := sealer.KeyPhase()
buffer := getPacketBuffer() buffer := getPacketBuffer()
ap, ack, err := p.appendShortHeaderPacket(buffer, connID, pn, pnLen, kp, pl, 0, sealer, false) ap, ack, err := p.appendShortHeaderPacket(buffer, connID, pn, pnLen, kp, pl, 0, sealer, false, v)
if err != nil { if err != nil {
return shortHeaderPacket{}, nil, err return shortHeaderPacket{}, nil, err
} }
@ -522,12 +507,12 @@ func (p *packetPacker) PackPacket(onlyAck bool, now time.Time) (shortHeaderPacke
}, buffer, nil }, buffer, nil
} }
func (p *packetPacker) maybeGetCryptoPacket(maxPacketSize protocol.ByteCount, encLevel protocol.EncryptionLevel, onlyAck, ackAllowed bool) (*wire.ExtendedHeader, payload) { func (p *packetPacker) maybeGetCryptoPacket(maxPacketSize protocol.ByteCount, encLevel protocol.EncryptionLevel, onlyAck, ackAllowed bool, v protocol.VersionNumber) (*wire.ExtendedHeader, payload) {
if onlyAck { if onlyAck {
if ack := p.acks.GetAckFrame(encLevel, true); ack != nil { if ack := p.acks.GetAckFrame(encLevel, true); ack != nil {
return p.getLongHeader(encLevel), payload{ return p.getLongHeader(encLevel, v), payload{
ack: ack, ack: ack,
length: ack.Length(p.version), length: ack.Length(v),
} }
} }
return nil, payload{} return nil, payload{}
@ -558,20 +543,20 @@ func (p *packetPacker) maybeGetCryptoPacket(maxPacketSize protocol.ByteCount, en
var pl payload var pl payload
if ack != nil { if ack != nil {
pl.ack = ack pl.ack = ack
pl.length = ack.Length(p.version) pl.length = ack.Length(v)
maxPacketSize -= pl.length maxPacketSize -= pl.length
} }
hdr := p.getLongHeader(encLevel) hdr := p.getLongHeader(encLevel, v)
maxPacketSize -= hdr.GetLength(p.version) maxPacketSize -= hdr.GetLength(v)
if hasRetransmission { if hasRetransmission {
for { for {
var f wire.Frame var f wire.Frame
//nolint:exhaustive // 0-RTT packets can't contain any retransmission.s //nolint:exhaustive // 0-RTT packets can't contain any retransmission.s
switch encLevel { switch encLevel {
case protocol.EncryptionInitial: case protocol.EncryptionInitial:
f = p.retransmissionQueue.GetInitialFrame(maxPacketSize, p.version) f = p.retransmissionQueue.GetInitialFrame(maxPacketSize, v)
case protocol.EncryptionHandshake: case protocol.EncryptionHandshake:
f = p.retransmissionQueue.GetHandshakeFrame(maxPacketSize, p.version) f = p.retransmissionQueue.GetHandshakeFrame(maxPacketSize, v)
} }
if f == nil { if f == nil {
break break
@ -579,35 +564,35 @@ func (p *packetPacker) maybeGetCryptoPacket(maxPacketSize protocol.ByteCount, en
af := ackhandler.GetFrame() af := ackhandler.GetFrame()
af.Frame = f af.Frame = f
pl.frames = append(pl.frames, af) pl.frames = append(pl.frames, af)
frameLen := f.Length(p.version) frameLen := f.Length(v)
pl.length += frameLen pl.length += frameLen
maxPacketSize -= frameLen maxPacketSize -= frameLen
} }
} else if s.HasData() { } else if s.HasData() {
cf := s.PopCryptoFrame(maxPacketSize) cf := s.PopCryptoFrame(maxPacketSize)
pl.frames = []*ackhandler.Frame{{Frame: cf}} pl.frames = []*ackhandler.Frame{{Frame: cf}}
pl.length += cf.Length(p.version) pl.length += cf.Length(v)
} }
return hdr, pl return hdr, pl
} }
func (p *packetPacker) maybeGetAppDataPacketFor0RTT(sealer sealer, maxPacketSize protocol.ByteCount) (*wire.ExtendedHeader, payload) { func (p *packetPacker) maybeGetAppDataPacketFor0RTT(sealer sealer, maxPacketSize protocol.ByteCount, v protocol.VersionNumber) (*wire.ExtendedHeader, payload) {
if p.perspective != protocol.PerspectiveClient { if p.perspective != protocol.PerspectiveClient {
return nil, payload{} return nil, payload{}
} }
hdr := p.getLongHeader(protocol.Encryption0RTT) hdr := p.getLongHeader(protocol.Encryption0RTT, v)
maxPayloadSize := maxPacketSize - hdr.GetLength(p.version) - protocol.ByteCount(sealer.Overhead()) maxPayloadSize := maxPacketSize - hdr.GetLength(v) - protocol.ByteCount(sealer.Overhead())
return hdr, p.maybeGetAppDataPacket(maxPayloadSize, false, false) return hdr, p.maybeGetAppDataPacket(maxPayloadSize, false, false, v)
} }
func (p *packetPacker) maybeGetShortHeaderPacket(sealer handshake.ShortHeaderSealer, hdrLen protocol.ByteCount, maxPacketSize protocol.ByteCount, onlyAck, ackAllowed bool) payload { func (p *packetPacker) maybeGetShortHeaderPacket(sealer handshake.ShortHeaderSealer, hdrLen protocol.ByteCount, maxPacketSize protocol.ByteCount, onlyAck, ackAllowed bool, v protocol.VersionNumber) payload {
maxPayloadSize := maxPacketSize - hdrLen - protocol.ByteCount(sealer.Overhead()) maxPayloadSize := maxPacketSize - hdrLen - protocol.ByteCount(sealer.Overhead())
return p.maybeGetAppDataPacket(maxPayloadSize, onlyAck, ackAllowed) return p.maybeGetAppDataPacket(maxPayloadSize, onlyAck, ackAllowed, v)
} }
func (p *packetPacker) maybeGetAppDataPacket(maxPayloadSize protocol.ByteCount, onlyAck, ackAllowed bool) payload { func (p *packetPacker) maybeGetAppDataPacket(maxPayloadSize protocol.ByteCount, onlyAck, ackAllowed bool, v protocol.VersionNumber) payload {
pl := p.composeNextPacket(maxPayloadSize, onlyAck, ackAllowed) pl := p.composeNextPacket(maxPayloadSize, onlyAck, ackAllowed, v)
// check if we have anything to send // check if we have anything to send
if len(pl.frames) == 0 { if len(pl.frames) == 0 {
@ -622,7 +607,7 @@ func (p *packetPacker) maybeGetAppDataPacket(maxPayloadSize protocol.ByteCount,
af.Frame = ping af.Frame = ping
af.OnLost = func(wire.Frame) {} af.OnLost = func(wire.Frame) {}
pl.frames = append(pl.frames, af) pl.frames = append(pl.frames, af)
pl.length += ping.Length(p.version) pl.length += ping.Length(v)
p.numNonAckElicitingAcks = 0 p.numNonAckElicitingAcks = 0
} else { } else {
p.numNonAckElicitingAcks++ p.numNonAckElicitingAcks++
@ -633,12 +618,12 @@ func (p *packetPacker) maybeGetAppDataPacket(maxPayloadSize protocol.ByteCount,
return pl return pl
} }
func (p *packetPacker) composeNextPacket(maxFrameSize protocol.ByteCount, onlyAck, ackAllowed bool) payload { func (p *packetPacker) composeNextPacket(maxFrameSize protocol.ByteCount, onlyAck, ackAllowed bool, v protocol.VersionNumber) payload {
if onlyAck { if onlyAck {
if ack := p.acks.GetAckFrame(protocol.Encryption1RTT, true); ack != nil { if ack := p.acks.GetAckFrame(protocol.Encryption1RTT, true); ack != nil {
return payload{ return payload{
ack: ack, ack: ack,
length: ack.Length(p.version), length: ack.Length(v),
} }
} }
return payload{} return payload{}
@ -653,14 +638,14 @@ func (p *packetPacker) composeNextPacket(maxFrameSize protocol.ByteCount, onlyAc
if ackAllowed { if ackAllowed {
if ack := p.acks.GetAckFrame(protocol.Encryption1RTT, !hasRetransmission && !hasData); ack != nil { if ack := p.acks.GetAckFrame(protocol.Encryption1RTT, !hasRetransmission && !hasData); ack != nil {
pl.ack = ack pl.ack = ack
pl.length += ack.Length(p.version) pl.length += ack.Length(v)
hasAck = true hasAck = true
} }
} }
if p.datagramQueue != nil { if p.datagramQueue != nil {
if f := p.datagramQueue.Peek(); f != nil { if f := p.datagramQueue.Peek(); f != nil {
size := f.Length(p.version) size := f.Length(v)
if size <= maxFrameSize-pl.length { if size <= maxFrameSize-pl.length {
af := ackhandler.GetFrame() af := ackhandler.GetFrame()
af.Frame = f af.Frame = f
@ -683,14 +668,14 @@ func (p *packetPacker) composeNextPacket(maxFrameSize protocol.ByteCount, onlyAc
if remainingLen < protocol.MinStreamFrameSize { if remainingLen < protocol.MinStreamFrameSize {
break break
} }
f := p.retransmissionQueue.GetAppDataFrame(remainingLen, p.version) f := p.retransmissionQueue.GetAppDataFrame(remainingLen, v)
if f == nil { if f == nil {
break break
} }
af := ackhandler.GetFrame() af := ackhandler.GetFrame()
af.Frame = f af.Frame = f
pl.frames = append(pl.frames, af) pl.frames = append(pl.frames, af)
pl.length += f.Length(p.version) pl.length += f.Length(v)
} }
} }
@ -705,7 +690,7 @@ func (p *packetPacker) composeNextPacket(maxFrameSize protocol.ByteCount, onlyAc
return pl return pl
} }
func (p *packetPacker) MaybePackProbePacket(encLevel protocol.EncryptionLevel) (*coalescedPacket, error) { func (p *packetPacker) MaybePackProbePacket(encLevel protocol.EncryptionLevel, v protocol.VersionNumber) (*coalescedPacket, error) {
if encLevel == protocol.Encryption1RTT { if encLevel == protocol.Encryption1RTT {
s, err := p.cryptoSetup.Get1RTTSealer() s, err := p.cryptoSetup.Get1RTTSealer()
if err != nil { if err != nil {
@ -715,13 +700,13 @@ func (p *packetPacker) MaybePackProbePacket(encLevel protocol.EncryptionLevel) (
connID := p.getDestConnID() connID := p.getDestConnID()
pn, pnLen := p.pnManager.PeekPacketNumber(protocol.Encryption1RTT) pn, pnLen := p.pnManager.PeekPacketNumber(protocol.Encryption1RTT)
hdrLen := wire.ShortHeaderLen(connID, pnLen) hdrLen := wire.ShortHeaderLen(connID, pnLen)
pl := p.maybeGetAppDataPacket(p.maxPacketSize-protocol.ByteCount(s.Overhead())-hdrLen, false, true) pl := p.maybeGetAppDataPacket(p.maxPacketSize-protocol.ByteCount(s.Overhead())-hdrLen, false, true, v)
if pl.length == 0 { if pl.length == 0 {
return nil, nil return nil, nil
} }
buffer := getPacketBuffer() buffer := getPacketBuffer()
packet := &coalescedPacket{buffer: buffer} packet := &coalescedPacket{buffer: buffer}
ap, ack, err := p.appendShortHeaderPacket(buffer, connID, pn, pnLen, kp, pl, 0, s, false) ap, ack, err := p.appendShortHeaderPacket(buffer, connID, pn, pnLen, kp, pl, 0, s, false, v)
if err != nil { if err != nil {
return nil, err return nil, err
} }
@ -746,14 +731,14 @@ func (p *packetPacker) MaybePackProbePacket(encLevel protocol.EncryptionLevel) (
if err != nil { if err != nil {
return nil, err return nil, err
} }
hdr, pl = p.maybeGetCryptoPacket(p.maxPacketSize-protocol.ByteCount(sealer.Overhead()), protocol.EncryptionInitial, false, true) hdr, pl = p.maybeGetCryptoPacket(p.maxPacketSize-protocol.ByteCount(sealer.Overhead()), protocol.EncryptionInitial, false, true, v)
case protocol.EncryptionHandshake: case protocol.EncryptionHandshake:
var err error var err error
sealer, err = p.cryptoSetup.GetHandshakeSealer() sealer, err = p.cryptoSetup.GetHandshakeSealer()
if err != nil { if err != nil {
return nil, err return nil, err
} }
hdr, pl = p.maybeGetCryptoPacket(p.maxPacketSize-protocol.ByteCount(sealer.Overhead()), protocol.EncryptionHandshake, false, true) hdr, pl = p.maybeGetCryptoPacket(p.maxPacketSize-protocol.ByteCount(sealer.Overhead()), protocol.EncryptionHandshake, false, true, v)
default: default:
panic("unknown encryption level") panic("unknown encryption level")
} }
@ -763,13 +748,13 @@ func (p *packetPacker) MaybePackProbePacket(encLevel protocol.EncryptionLevel) (
} }
buffer := getPacketBuffer() buffer := getPacketBuffer()
packet := &coalescedPacket{buffer: buffer} packet := &coalescedPacket{buffer: buffer}
size := p.longHeaderPacketLength(hdr, pl) + protocol.ByteCount(sealer.Overhead()) size := p.longHeaderPacketLength(hdr, pl, v) + protocol.ByteCount(sealer.Overhead())
var padding protocol.ByteCount var padding protocol.ByteCount
if encLevel == protocol.EncryptionInitial { if encLevel == protocol.EncryptionInitial {
padding = p.initialPaddingLen(pl.frames, size) padding = p.initialPaddingLen(pl.frames, size)
} }
longHdrPacket, err := p.appendLongHeaderPacket(buffer, hdr, pl, padding, encLevel, sealer) longHdrPacket, err := p.appendLongHeaderPacket(buffer, hdr, pl, padding, encLevel, sealer, v)
if err != nil { if err != nil {
return nil, err return nil, err
} }
@ -777,10 +762,10 @@ func (p *packetPacker) MaybePackProbePacket(encLevel protocol.EncryptionLevel) (
return packet, nil return packet, nil
} }
func (p *packetPacker) PackMTUProbePacket(ping ackhandler.Frame, size protocol.ByteCount, now time.Time) (shortHeaderPacket, *packetBuffer, error) { func (p *packetPacker) PackMTUProbePacket(ping ackhandler.Frame, size protocol.ByteCount, now time.Time, v protocol.VersionNumber) (shortHeaderPacket, *packetBuffer, error) {
pl := payload{ pl := payload{
frames: []*ackhandler.Frame{&ping}, frames: []*ackhandler.Frame{&ping},
length: ping.Length(p.version), length: ping.Length(v),
} }
buffer := getPacketBuffer() buffer := getPacketBuffer()
s, err := p.cryptoSetup.Get1RTTSealer() s, err := p.cryptoSetup.Get1RTTSealer()
@ -791,7 +776,7 @@ func (p *packetPacker) PackMTUProbePacket(ping ackhandler.Frame, size protocol.B
pn, pnLen := p.pnManager.PeekPacketNumber(protocol.Encryption1RTT) pn, pnLen := p.pnManager.PeekPacketNumber(protocol.Encryption1RTT)
padding := size - p.shortHeaderPacketLength(connID, pnLen, pl) - protocol.ByteCount(s.Overhead()) padding := size - p.shortHeaderPacketLength(connID, pnLen, pl) - protocol.ByteCount(s.Overhead())
kp := s.KeyPhase() kp := s.KeyPhase()
ap, ack, err := p.appendShortHeaderPacket(buffer, connID, pn, pnLen, kp, pl, padding, s, true) ap, ack, err := p.appendShortHeaderPacket(buffer, connID, pn, pnLen, kp, pl, padding, s, true, v)
if err != nil { if err != nil {
return shortHeaderPacket{}, nil, err return shortHeaderPacket{}, nil, err
} }
@ -804,13 +789,13 @@ func (p *packetPacker) PackMTUProbePacket(ping ackhandler.Frame, size protocol.B
}, buffer, nil }, buffer, nil
} }
func (p *packetPacker) getLongHeader(encLevel protocol.EncryptionLevel) *wire.ExtendedHeader { func (p *packetPacker) getLongHeader(encLevel protocol.EncryptionLevel, v protocol.VersionNumber) *wire.ExtendedHeader {
pn, pnLen := p.pnManager.PeekPacketNumber(encLevel) pn, pnLen := p.pnManager.PeekPacketNumber(encLevel)
hdr := &wire.ExtendedHeader{ hdr := &wire.ExtendedHeader{
PacketNumber: pn, PacketNumber: pn,
PacketNumberLen: pnLen, PacketNumberLen: pnLen,
} }
hdr.Version = p.version hdr.Version = v
hdr.SrcConnectionID = p.srcConnID hdr.SrcConnectionID = p.srcConnID
hdr.DestConnectionID = p.getDestConnID() hdr.DestConnectionID = p.getDestConnID()
@ -827,7 +812,7 @@ func (p *packetPacker) getLongHeader(encLevel protocol.EncryptionLevel) *wire.Ex
return hdr return hdr
} }
func (p *packetPacker) appendLongHeaderPacket(buffer *packetBuffer, header *wire.ExtendedHeader, pl payload, padding protocol.ByteCount, encLevel protocol.EncryptionLevel, sealer sealer) (*longHeaderPacket, error) { func (p *packetPacker) appendLongHeaderPacket(buffer *packetBuffer, header *wire.ExtendedHeader, pl payload, padding protocol.ByteCount, encLevel protocol.EncryptionLevel, sealer sealer, v protocol.VersionNumber) (*longHeaderPacket, error) {
var paddingLen protocol.ByteCount var paddingLen protocol.ByteCount
pnLen := protocol.ByteCount(header.PacketNumberLen) pnLen := protocol.ByteCount(header.PacketNumberLen)
if pl.length < 4-pnLen { if pl.length < 4-pnLen {
@ -838,7 +823,7 @@ func (p *packetPacker) appendLongHeaderPacket(buffer *packetBuffer, header *wire
startLen := len(buffer.Data) startLen := len(buffer.Data)
raw := buffer.Data[startLen:] raw := buffer.Data[startLen:]
raw, err := header.Append(raw, p.version) raw, err := header.Append(raw, v)
if err != nil { if err != nil {
return nil, err return nil, err
} }
@ -849,7 +834,7 @@ func (p *packetPacker) appendLongHeaderPacket(buffer *packetBuffer, header *wire
return nil, errors.New("packetPacker BUG: Peeked and Popped packet numbers do not match") return nil, errors.New("packetPacker BUG: Peeked and Popped packet numbers do not match")
} }
raw, err = p.appendPacketPayload(raw, pl, paddingLen) raw, err = p.appendPacketPayload(raw, pl, paddingLen, v)
if err != nil { if err != nil {
return nil, err return nil, err
} }
@ -874,6 +859,7 @@ func (p *packetPacker) appendShortHeaderPacket(
padding protocol.ByteCount, padding protocol.ByteCount,
sealer sealer, sealer sealer,
isMTUProbePacket bool, isMTUProbePacket bool,
v protocol.VersionNumber,
) (*ackhandler.Packet, *wire.AckFrame, error) { ) (*ackhandler.Packet, *wire.AckFrame, error) {
var paddingLen protocol.ByteCount var paddingLen protocol.ByteCount
if pl.length < 4-protocol.ByteCount(pnLen) { if pl.length < 4-protocol.ByteCount(pnLen) {
@ -893,7 +879,7 @@ func (p *packetPacker) appendShortHeaderPacket(
return nil, nil, errors.New("packetPacker BUG: Peeked and Popped packet numbers do not match") return nil, nil, errors.New("packetPacker BUG: Peeked and Popped packet numbers do not match")
} }
raw, err = p.appendPacketPayload(raw, pl, paddingLen) raw, err = p.appendPacketPayload(raw, pl, paddingLen, v)
if err != nil { if err != nil {
return nil, nil, err return nil, nil, err
} }
@ -929,11 +915,11 @@ func (p *packetPacker) appendShortHeaderPacket(
return ap, pl.ack, nil return ap, pl.ack, nil
} }
func (p *packetPacker) appendPacketPayload(raw []byte, pl payload, paddingLen protocol.ByteCount) ([]byte, error) { func (p *packetPacker) appendPacketPayload(raw []byte, pl payload, paddingLen protocol.ByteCount, v protocol.VersionNumber) ([]byte, error) {
payloadOffset := len(raw) payloadOffset := len(raw)
if pl.ack != nil { if pl.ack != nil {
var err error var err error
raw, err = pl.ack.Append(raw, p.version) raw, err = pl.ack.Append(raw, v)
if err != nil { if err != nil {
return nil, err return nil, err
} }
@ -943,7 +929,7 @@ func (p *packetPacker) appendPacketPayload(raw []byte, pl payload, paddingLen pr
} }
for _, frame := range pl.frames { for _, frame := range pl.frames {
var err error var err error
raw, err = frame.Append(raw, p.version) raw, err = frame.Append(raw, v)
if err != nil { if err != nil {
return nil, err return nil, err
} }

172
packet_packer_test.go
View file

@ -66,7 +66,7 @@ var _ = Describe("Packet packer", func() {
appendFrames := func(fs, frames []*ackhandler.Frame) ([]*ackhandler.Frame, protocol.ByteCount) { appendFrames := func(fs, frames []*ackhandler.Frame) ([]*ackhandler.Frame, protocol.ByteCount) {
var length protocol.ByteCount var length protocol.ByteCount
for _, f := range frames { for _, f := range frames {
length += f.Frame.Length(packer.version) length += f.Frame.Length(protocol.Version1)
} }
return append(fs, frames...), length return append(fs, frames...), length
} }
@ -96,22 +96,7 @@ var _ = Describe("Packet packer", func() {
pnManager = mockackhandler.NewMockSentPacketHandler(mockCtrl) pnManager = mockackhandler.NewMockSentPacketHandler(mockCtrl)
datagramQueue = newDatagramQueue(func() {}, utils.DefaultLogger) datagramQueue = newDatagramQueue(func() {}, utils.DefaultLogger)
packer = newPacketPacker( packer = newPacketPacker(protocol.ParseConnectionID([]byte{1, 2, 3, 4, 5, 6, 7, 8}), func() protocol.ConnectionID { return connID }, initialStream, handshakeStream, pnManager, retransmissionQueue, &net.TCPAddr{}, sealingManager, framer, ackFramer, datagramQueue, protocol.PerspectiveServer)
protocol.ParseConnectionID([]byte{1, 2, 3, 4, 5, 6, 7, 8}),
func() protocol.ConnectionID { return connID },
initialStream,
handshakeStream,
pnManager,
retransmissionQueue,
&net.TCPAddr{},
sealingManager,
framer,
ackFramer,
datagramQueue,
protocol.PerspectiveServer,
version,
)
packer.version = version
packer.maxPacketSize = maxPacketSize packer.maxPacketSize = maxPacketSize
}) })
@ -135,10 +120,10 @@ var _ = Describe("Packet packer", func() {
Context("generating a packet header", func() { Context("generating a packet header", func() {
It("uses the Long Header format", func() { It("uses the Long Header format", func() {
pnManager.EXPECT().PeekPacketNumber(protocol.EncryptionHandshake).Return(protocol.PacketNumber(0x42), protocol.PacketNumberLen3) pnManager.EXPECT().PeekPacketNumber(protocol.EncryptionHandshake).Return(protocol.PacketNumber(0x42), protocol.PacketNumberLen3)
h := packer.getLongHeader(protocol.EncryptionHandshake) h := packer.getLongHeader(protocol.EncryptionHandshake, protocol.Version1)
Expect(h.PacketNumber).To(Equal(protocol.PacketNumber(0x42))) Expect(h.PacketNumber).To(Equal(protocol.PacketNumber(0x42)))
Expect(h.PacketNumberLen).To(Equal(protocol.PacketNumberLen3)) Expect(h.PacketNumberLen).To(Equal(protocol.PacketNumberLen3))
Expect(h.Version).To(Equal(packer.version)) Expect(h.Version).To(Equal(protocol.Version1))
}) })
It("sets source and destination connection ID", func() { It("sets source and destination connection ID", func() {
@ -147,7 +132,7 @@ var _ = Describe("Packet packer", func() {
destConnID := protocol.ParseConnectionID([]byte{8, 7, 6, 5, 4, 3, 2, 1}) destConnID := protocol.ParseConnectionID([]byte{8, 7, 6, 5, 4, 3, 2, 1})
packer.srcConnID = srcConnID packer.srcConnID = srcConnID
packer.getDestConnID = func() protocol.ConnectionID { return destConnID } packer.getDestConnID = func() protocol.ConnectionID { return destConnID }
h := packer.getLongHeader(protocol.EncryptionHandshake) h := packer.getLongHeader(protocol.EncryptionHandshake, protocol.Version1)
Expect(h.SrcConnectionID).To(Equal(srcConnID)) Expect(h.SrcConnectionID).To(Equal(srcConnID))
Expect(h.DestConnectionID).To(Equal(destConnID)) Expect(h.DestConnectionID).To(Equal(destConnID))
}) })
@ -184,7 +169,7 @@ var _ = Describe("Packet packer", func() {
expectAppendControlFrames() expectAppendControlFrames()
f := &wire.StreamFrame{Data: []byte{0xde, 0xca, 0xfb, 0xad}} f := &wire.StreamFrame{Data: []byte{0xde, 0xca, 0xfb, 0xad}}
expectAppendStreamFrames(&ackhandler.Frame{Frame: f}) expectAppendStreamFrames(&ackhandler.Frame{Frame: f})
p, err := packer.PackCoalescedPacket(false) p, err := packer.PackCoalescedPacket(false, protocol.Version1)
Expect(err).ToNot(HaveOccurred()) Expect(err).ToNot(HaveOccurred())
Expect(p).ToNot(BeNil()) Expect(p).ToNot(BeNil())
Expect(p.longHdrPackets).To(BeEmpty()) Expect(p.longHdrPackets).To(BeEmpty())
@ -222,7 +207,7 @@ var _ = Describe("Packet packer", func() {
ackFramer.EXPECT().GetAckFrame(protocol.EncryptionInitial, true) ackFramer.EXPECT().GetAckFrame(protocol.EncryptionInitial, true)
ackFramer.EXPECT().GetAckFrame(protocol.EncryptionHandshake, true) ackFramer.EXPECT().GetAckFrame(protocol.EncryptionHandshake, true)
ackFramer.EXPECT().GetAckFrame(protocol.Encryption1RTT, true) ackFramer.EXPECT().GetAckFrame(protocol.Encryption1RTT, true)
p, err := packer.PackCoalescedPacket(true) p, err := packer.PackCoalescedPacket(true, protocol.Version1)
Expect(err).ToNot(HaveOccurred()) Expect(err).ToNot(HaveOccurred())
Expect(p).To(BeNil()) Expect(p).To(BeNil())
}) })
@ -234,7 +219,7 @@ var _ = Describe("Packet packer", func() {
sealingManager.EXPECT().GetInitialSealer().Return(getSealer(), nil) sealingManager.EXPECT().GetInitialSealer().Return(getSealer(), nil)
ack := &wire.AckFrame{AckRanges: []wire.AckRange{{Smallest: 1, Largest: 10}}} ack := &wire.AckFrame{AckRanges: []wire.AckRange{{Smallest: 1, Largest: 10}}}
ackFramer.EXPECT().GetAckFrame(protocol.EncryptionInitial, true).Return(ack) ackFramer.EXPECT().GetAckFrame(protocol.EncryptionInitial, true).Return(ack)
p, err := packer.PackCoalescedPacket(true) p, err := packer.PackCoalescedPacket(true, protocol.Version1)
Expect(err).NotTo(HaveOccurred()) Expect(err).NotTo(HaveOccurred())
Expect(p).ToNot(BeNil()) Expect(p).ToNot(BeNil())
Expect(p.longHdrPackets).To(HaveLen(1)) Expect(p.longHdrPackets).To(HaveLen(1))
@ -251,7 +236,7 @@ var _ = Describe("Packet packer", func() {
sealingManager.EXPECT().GetInitialSealer().Return(getSealer(), nil) sealingManager.EXPECT().GetInitialSealer().Return(getSealer(), nil)
ack := &wire.AckFrame{AckRanges: []wire.AckRange{{Smallest: 1, Largest: 10}}} ack := &wire.AckFrame{AckRanges: []wire.AckRange{{Smallest: 1, Largest: 10}}}
ackFramer.EXPECT().GetAckFrame(protocol.EncryptionInitial, true).Return(ack) ackFramer.EXPECT().GetAckFrame(protocol.EncryptionInitial, true).Return(ack)
p, err := packer.PackCoalescedPacket(true) p, err := packer.PackCoalescedPacket(true, protocol.Version1)
Expect(err).NotTo(HaveOccurred()) Expect(err).NotTo(HaveOccurred())
Expect(p).ToNot(BeNil()) Expect(p).ToNot(BeNil())
Expect(p.longHdrPackets).To(HaveLen(1)) Expect(p.longHdrPackets).To(HaveLen(1))
@ -271,7 +256,7 @@ var _ = Describe("Packet packer", func() {
ack := &wire.AckFrame{AckRanges: []wire.AckRange{{Smallest: 1, Largest: 10}}} ack := &wire.AckFrame{AckRanges: []wire.AckRange{{Smallest: 1, Largest: 10}}}
ackFramer.EXPECT().GetAckFrame(protocol.EncryptionHandshake, true) ackFramer.EXPECT().GetAckFrame(protocol.EncryptionHandshake, true)
ackFramer.EXPECT().GetAckFrame(protocol.Encryption1RTT, true).Return(ack) ackFramer.EXPECT().GetAckFrame(protocol.Encryption1RTT, true).Return(ack)
p, err := packer.PackCoalescedPacket(true) p, err := packer.PackCoalescedPacket(true, protocol.Version1)
Expect(err).NotTo(HaveOccurred()) Expect(err).NotTo(HaveOccurred())
Expect(p).ToNot(BeNil()) Expect(p).ToNot(BeNil())
Expect(p.longHdrPackets).To(BeEmpty()) Expect(p.longHdrPackets).To(BeEmpty())
@ -287,7 +272,7 @@ var _ = Describe("Packet packer", func() {
sealingManager.EXPECT().Get1RTTSealer().Return(getSealer(), nil) sealingManager.EXPECT().Get1RTTSealer().Return(getSealer(), nil)
ack := &wire.AckFrame{AckRanges: []wire.AckRange{{Smallest: 1, Largest: 10}}} ack := &wire.AckFrame{AckRanges: []wire.AckRange{{Smallest: 1, Largest: 10}}}
ackFramer.EXPECT().GetAckFrame(protocol.Encryption1RTT, true).Return(ack) ackFramer.EXPECT().GetAckFrame(protocol.Encryption1RTT, true).Return(ack)
p, buffer, err := packer.PackPacket(true, time.Now()) p, buffer, err := packer.PackPacket(true, time.Now(), protocol.Version1)
Expect(err).NotTo(HaveOccurred()) Expect(err).NotTo(HaveOccurred())
Expect(p).ToNot(BeNil()) Expect(p).ToNot(BeNil())
Expect(p.Ack).To(Equal(ack)) Expect(p.Ack).To(Equal(ack))
@ -317,13 +302,13 @@ var _ = Describe("Packet packer", func() {
framer.EXPECT().HasData().Return(true) framer.EXPECT().HasData().Return(true)
framer.EXPECT().AppendControlFrames(gomock.Any(), gomock.Any()).DoAndReturn(func(frames []*ackhandler.Frame, _ protocol.ByteCount) ([]*ackhandler.Frame, protocol.ByteCount) { framer.EXPECT().AppendControlFrames(gomock.Any(), gomock.Any()).DoAndReturn(func(frames []*ackhandler.Frame, _ protocol.ByteCount) ([]*ackhandler.Frame, protocol.ByteCount) {
Expect(frames).To(BeEmpty()) Expect(frames).To(BeEmpty())
return append(frames, cf), cf.Length(packer.version) return append(frames, cf), cf.Length(protocol.Version1)
}) })
// TODO: check sizes // TODO: check sizes
framer.EXPECT().AppendStreamFrames(gomock.Any(), gomock.Any()).DoAndReturn(func(frames []*ackhandler.Frame, _ protocol.ByteCount) ([]*ackhandler.Frame, protocol.ByteCount) { framer.EXPECT().AppendStreamFrames(gomock.Any(), gomock.Any()).DoAndReturn(func(frames []*ackhandler.Frame, _ protocol.ByteCount) ([]*ackhandler.Frame, protocol.ByteCount) {
return frames, 0 return frames, 0
}) })
p, err := packer.PackCoalescedPacket(false) p, err := packer.PackCoalescedPacket(false, protocol.Version1)
Expect(p).ToNot(BeNil()) Expect(p).ToNot(BeNil())
Expect(err).ToNot(HaveOccurred()) Expect(err).ToNot(HaveOccurred())
Expect(p.longHdrPackets).To(HaveLen(1)) Expect(p.longHdrPackets).To(HaveLen(1))
@ -342,7 +327,7 @@ var _ = Describe("Packet packer", func() {
sealingManager.EXPECT().Get1RTTSealer().Return(nil, handshake.ErrKeysNotYetAvailable) sealingManager.EXPECT().Get1RTTSealer().Return(nil, handshake.ErrKeysNotYetAvailable)
quicErr := qerr.NewLocalCryptoError(0x42, "crypto error") quicErr := qerr.NewLocalCryptoError(0x42, "crypto error")
quicErr.FrameType = 0x1234 quicErr.FrameType = 0x1234
p, err := packer.PackConnectionClose(quicErr) p, err := packer.PackConnectionClose(quicErr, protocol.Version1)
Expect(err).ToNot(HaveOccurred()) Expect(err).ToNot(HaveOccurred())
Expect(p.longHdrPackets).To(HaveLen(1)) Expect(p.longHdrPackets).To(HaveLen(1))
Expect(p.longHdrPackets[0].header.Type).To(Equal(protocol.PacketTypeHandshake)) Expect(p.longHdrPackets[0].header.Type).To(Equal(protocol.PacketTypeHandshake))
@ -365,7 +350,7 @@ var _ = Describe("Packet packer", func() {
p, err := packer.PackConnectionClose(&qerr.TransportError{ p, err := packer.PackConnectionClose(&qerr.TransportError{
ErrorCode: qerr.CryptoBufferExceeded, ErrorCode: qerr.CryptoBufferExceeded,
ErrorMessage: "test error", ErrorMessage: "test error",
}) }, protocol.Version1)
Expect(err).ToNot(HaveOccurred()) Expect(err).ToNot(HaveOccurred())
Expect(p.longHdrPackets).To(BeEmpty()) Expect(p.longHdrPackets).To(BeEmpty())
Expect(p.shortHdrPacket.Frames).To(HaveLen(1)) Expect(p.shortHdrPacket.Frames).To(HaveLen(1))
@ -389,7 +374,7 @@ var _ = Describe("Packet packer", func() {
p, err := packer.PackApplicationClose(&qerr.ApplicationError{ p, err := packer.PackApplicationClose(&qerr.ApplicationError{
ErrorCode: 0x1337, ErrorCode: 0x1337,
ErrorMessage: "test error", ErrorMessage: "test error",
}) }, protocol.Version1)
Expect(err).ToNot(HaveOccurred()) Expect(err).ToNot(HaveOccurred())
Expect(p.longHdrPackets).To(HaveLen(2)) Expect(p.longHdrPackets).To(HaveLen(2))
Expect(p.longHdrPackets[0].header.Type).To(Equal(protocol.PacketTypeInitial)) Expect(p.longHdrPackets[0].header.Type).To(Equal(protocol.PacketTypeInitial))
@ -431,7 +416,7 @@ var _ = Describe("Packet packer", func() {
p, err := packer.PackApplicationClose(&qerr.ApplicationError{ p, err := packer.PackApplicationClose(&qerr.ApplicationError{
ErrorCode: 0x1337, ErrorCode: 0x1337,
ErrorMessage: "test error", ErrorMessage: "test error",
}) }, protocol.Version1)
Expect(err).ToNot(HaveOccurred()) Expect(err).ToNot(HaveOccurred())
Expect(p.longHdrPackets).To(HaveLen(1)) Expect(p.longHdrPackets).To(HaveLen(1))
Expect(p.buffer.Len()).To(BeNumerically("<", protocol.MinInitialPacketSize)) Expect(p.buffer.Len()).To(BeNumerically("<", protocol.MinInitialPacketSize))
@ -466,7 +451,7 @@ var _ = Describe("Packet packer", func() {
p, err := packer.PackApplicationClose(&qerr.ApplicationError{ p, err := packer.PackApplicationClose(&qerr.ApplicationError{
ErrorCode: 0x1337, ErrorCode: 0x1337,
ErrorMessage: "test error", ErrorMessage: "test error",
}) }, protocol.Version1)
Expect(err).ToNot(HaveOccurred()) Expect(err).ToNot(HaveOccurred())
Expect(p.longHdrPackets).To(HaveLen(2)) Expect(p.longHdrPackets).To(HaveLen(2))
Expect(p.buffer.Len()).To(BeNumerically(">=", protocol.MinInitialPacketSize)) Expect(p.buffer.Len()).To(BeNumerically(">=", protocol.MinInitialPacketSize))
@ -502,7 +487,7 @@ var _ = Describe("Packet packer", func() {
sealingManager.EXPECT().Get1RTTSealer().Return(getSealer(), nil) sealingManager.EXPECT().Get1RTTSealer().Return(getSealer(), nil)
ackFramer.EXPECT().GetAckFrame(protocol.Encryption1RTT, true) ackFramer.EXPECT().GetAckFrame(protocol.Encryption1RTT, true)
framer.EXPECT().HasData() framer.EXPECT().HasData()
_, _, err := packer.PackPacket(false, time.Now()) _, _, err := packer.PackPacket(false, time.Now(), protocol.Version1)
Expect(err).To(MatchError(errNothingToPack)) Expect(err).To(MatchError(errNothingToPack))
}) })
@ -518,10 +503,10 @@ var _ = Describe("Packet packer", func() {
Data: []byte{0xde, 0xca, 0xfb, 0xad}, Data: []byte{0xde, 0xca, 0xfb, 0xad},
} }
expectAppendStreamFrames(&ackhandler.Frame{Frame: f}) expectAppendStreamFrames(&ackhandler.Frame{Frame: f})
p, buffer, err := packer.PackPacket(false, time.Now()) p, buffer, err := packer.PackPacket(false, time.Now(), protocol.Version1)
Expect(err).ToNot(HaveOccurred()) Expect(err).ToNot(HaveOccurred())
Expect(p).ToNot(BeNil()) Expect(p).ToNot(BeNil())
b, err := f.Append(nil, packer.version) b, err := f.Append(nil, protocol.Version1)
Expect(err).ToNot(HaveOccurred()) Expect(err).ToNot(HaveOccurred())
Expect(p.Frames).To(HaveLen(1)) Expect(p.Frames).To(HaveLen(1))
Expect(p.Frames[0].Frame.(*wire.StreamFrame).StreamID).To(Equal(f.StreamID)) Expect(p.Frames[0].Frame.(*wire.StreamFrame).StreamID).To(Equal(f.StreamID))
@ -535,7 +520,7 @@ var _ = Describe("Packet packer", func() {
framer.EXPECT().HasData() framer.EXPECT().HasData()
ackFramer.EXPECT().GetAckFrame(protocol.Encryption1RTT, true).Return(ack) ackFramer.EXPECT().GetAckFrame(protocol.Encryption1RTT, true).Return(ack)
sealingManager.EXPECT().Get1RTTSealer().Return(getSealer(), nil) sealingManager.EXPECT().Get1RTTSealer().Return(getSealer(), nil)
p, _, err := packer.PackPacket(false, time.Now()) p, _, err := packer.PackPacket(false, time.Now(), protocol.Version1)
Expect(err).NotTo(HaveOccurred()) Expect(err).NotTo(HaveOccurred())
Expect(p).ToNot(BeNil()) Expect(p).ToNot(BeNil())
Expect(p.Ack).To(Equal(ack)) Expect(p.Ack).To(Equal(ack))
@ -553,7 +538,7 @@ var _ = Describe("Packet packer", func() {
} }
expectAppendControlFrames(frames...) expectAppendControlFrames(frames...)
expectAppendStreamFrames() expectAppendStreamFrames()
p, buffer, err := packer.PackPacket(false, time.Now()) p, buffer, err := packer.PackPacket(false, time.Now(), protocol.Version1)
Expect(p).ToNot(BeNil()) Expect(p).ToNot(BeNil())
Expect(err).ToNot(HaveOccurred()) Expect(err).ToNot(HaveOccurred())
Expect(p.Frames).To(HaveLen(2)) Expect(p.Frames).To(HaveLen(2))
@ -582,7 +567,7 @@ var _ = Describe("Packet packer", func() {
time.Sleep(scaleDuration(20 * time.Millisecond)) time.Sleep(scaleDuration(20 * time.Millisecond))
framer.EXPECT().HasData() framer.EXPECT().HasData()
p, buffer, err := packer.PackPacket(false, time.Now()) p, buffer, err := packer.PackPacket(false, time.Now(), protocol.Version1)
Expect(p).ToNot(BeNil()) Expect(p).ToNot(BeNil())
Expect(err).ToNot(HaveOccurred()) Expect(err).ToNot(HaveOccurred())
Expect(p.Frames).To(HaveLen(1)) Expect(p.Frames).To(HaveLen(1))
@ -610,7 +595,7 @@ var _ = Describe("Packet packer", func() {
time.Sleep(scaleDuration(20 * time.Millisecond)) time.Sleep(scaleDuration(20 * time.Millisecond))
framer.EXPECT().HasData() framer.EXPECT().HasData()
p, buffer, err := packer.PackPacket(false, time.Now()) p, buffer, err := packer.PackPacket(false, time.Now(), protocol.Version1)
Expect(p).ToNot(BeNil()) Expect(p).ToNot(BeNil())
Expect(err).ToNot(HaveOccurred()) Expect(err).ToNot(HaveOccurred())
Expect(p.Ack).ToNot(BeNil()) Expect(p.Ack).ToNot(BeNil())
@ -636,7 +621,7 @@ var _ = Describe("Packet packer", func() {
return fs, 0 return fs, 0
}), }),
) )
_, _, err := packer.PackPacket(false, time.Now()) _, _, err := packer.PackPacket(false, time.Now(), protocol.Version1)
Expect(err).To(MatchError(errNothingToPack)) Expect(err).To(MatchError(errNothingToPack))
}) })
@ -650,7 +635,7 @@ var _ = Describe("Packet packer", func() {
packer.retransmissionQueue.AddHandshake(&wire.PingFrame{}) packer.retransmissionQueue.AddHandshake(&wire.PingFrame{})
handshakeStream.EXPECT().HasData() handshakeStream.EXPECT().HasData()
ackFramer.EXPECT().GetAckFrame(protocol.EncryptionHandshake, false) ackFramer.EXPECT().GetAckFrame(protocol.EncryptionHandshake, false)
packet, err := packer.PackCoalescedPacket(false) packet, err := packer.PackCoalescedPacket(false, protocol.Version1)
Expect(err).ToNot(HaveOccurred()) Expect(err).ToNot(HaveOccurred())
Expect(packet).ToNot(BeNil()) Expect(packet).ToNot(BeNil())
Expect(packet.longHdrPackets).To(HaveLen(1)) Expect(packet.longHdrPackets).To(HaveLen(1))
@ -660,7 +645,7 @@ var _ = Describe("Packet packer", func() {
Expect(err).ToNot(HaveOccurred()) Expect(err).ToNot(HaveOccurred())
data := packet.buffer.Data data := packet.buffer.Data
r := bytes.NewReader(data) r := bytes.NewReader(data)
extHdr, err := hdr.ParseExtended(r, packer.version) extHdr, err := hdr.ParseExtended(r, protocol.Version1)
Expect(err).ToNot(HaveOccurred()) Expect(err).ToNot(HaveOccurred())
Expect(extHdr.PacketNumberLen).To(Equal(protocol.PacketNumberLen1)) Expect(extHdr.PacketNumberLen).To(Equal(protocol.PacketNumberLen1))
Expect(r.Len()).To(Equal(4 - 1 /* packet number length */ + sealer.Overhead())) Expect(r.Len()).To(Equal(4 - 1 /* packet number length */ + sealer.Overhead()))
@ -673,7 +658,7 @@ var _ = Describe("Packet packer", func() {
Expect(secondPayloadByte).To(Equal(byte(0))) Expect(secondPayloadByte).To(Equal(byte(0)))
// ... followed by the PING // ... followed by the PING
frameParser := wire.NewFrameParser(false) frameParser := wire.NewFrameParser(false)
l, frame, err := frameParser.ParseNext(data[len(data)-r.Len():], protocol.Encryption1RTT, packer.version) l, frame, err := frameParser.ParseNext(data[len(data)-r.Len():], protocol.Encryption1RTT, protocol.Version1)
Expect(err).ToNot(HaveOccurred()) Expect(err).ToNot(HaveOccurred())
Expect(frame).To(BeAssignableToTypeOf(&wire.PingFrame{})) Expect(frame).To(BeAssignableToTypeOf(&wire.PingFrame{}))
Expect(r.Len() - l).To(Equal(sealer.Overhead())) Expect(r.Len() - l).To(Equal(sealer.Overhead()))
@ -684,7 +669,7 @@ var _ = Describe("Packet packer", func() {
StreamID: 0x10, // small stream ID, such that only a single byte is consumed StreamID: 0x10, // small stream ID, such that only a single byte is consumed
Fin: true, Fin: true,
} }
Expect(f.Length(packer.version)).To(BeEquivalentTo(2)) Expect(f.Length(protocol.Version1)).To(BeEquivalentTo(2))
pnManager.EXPECT().PeekPacketNumber(protocol.Encryption1RTT).Return(protocol.PacketNumber(0x42), protocol.PacketNumberLen1) pnManager.EXPECT().PeekPacketNumber(protocol.Encryption1RTT).Return(protocol.PacketNumber(0x42), protocol.PacketNumberLen1)
pnManager.EXPECT().PopPacketNumber(protocol.Encryption1RTT).Return(protocol.PacketNumber(0x42)) pnManager.EXPECT().PopPacketNumber(protocol.Encryption1RTT).Return(protocol.PacketNumber(0x42))
sealer := getSealer() sealer := getSealer()
@ -693,7 +678,7 @@ var _ = Describe("Packet packer", func() {
ackFramer.EXPECT().GetAckFrame(protocol.Encryption1RTT, false) ackFramer.EXPECT().GetAckFrame(protocol.Encryption1RTT, false)
expectAppendControlFrames() expectAppendControlFrames()
expectAppendStreamFrames(&ackhandler.Frame{Frame: f}) expectAppendStreamFrames(&ackhandler.Frame{Frame: f})
_, buffer, err := packer.PackPacket(false, time.Now()) _, buffer, err := packer.PackPacket(false, time.Now(), protocol.Version1)
Expect(err).ToNot(HaveOccurred()) Expect(err).ToNot(HaveOccurred())
// cut off the tag that the mock sealer added // cut off the tag that the mock sealer added
buffer.Data = buffer.Data[:buffer.Len()-protocol.ByteCount(sealer.Overhead())] buffer.Data = buffer.Data[:buffer.Len()-protocol.ByteCount(sealer.Overhead())]
@ -709,7 +694,7 @@ var _ = Describe("Packet packer", func() {
Expect(firstPayloadByte).To(Equal(byte(0))) Expect(firstPayloadByte).To(Equal(byte(0)))
// ... followed by the STREAM frame // ... followed by the STREAM frame
frameParser := wire.NewFrameParser(true) frameParser := wire.NewFrameParser(true)
l, frame, err := frameParser.ParseNext(buffer.Data[len(data)-r.Len():], protocol.Encryption1RTT, packer.version) l, frame, err := frameParser.ParseNext(buffer.Data[len(data)-r.Len():], protocol.Encryption1RTT, protocol.Version1)
Expect(err).ToNot(HaveOccurred()) Expect(err).ToNot(HaveOccurred())
Expect(frame).To(BeAssignableToTypeOf(&wire.StreamFrame{})) Expect(frame).To(BeAssignableToTypeOf(&wire.StreamFrame{}))
sf := frame.(*wire.StreamFrame) sf := frame.(*wire.StreamFrame)
@ -742,7 +727,7 @@ var _ = Describe("Packet packer", func() {
ackFramer.EXPECT().GetAckFrame(protocol.Encryption1RTT, false) ackFramer.EXPECT().GetAckFrame(protocol.Encryption1RTT, false)
expectAppendControlFrames() expectAppendControlFrames()
expectAppendStreamFrames(&ackhandler.Frame{Frame: f1}, &ackhandler.Frame{Frame: f2}, &ackhandler.Frame{Frame: f3}) expectAppendStreamFrames(&ackhandler.Frame{Frame: f1}, &ackhandler.Frame{Frame: f2}, &ackhandler.Frame{Frame: f3})
p, _, err := packer.PackPacket(false, time.Now()) p, _, err := packer.PackPacket(false, time.Now(), protocol.Version1)
Expect(p).ToNot(BeNil()) Expect(p).ToNot(BeNil())
Expect(err).ToNot(HaveOccurred()) Expect(err).ToNot(HaveOccurred())
Expect(p.Frames).To(HaveLen(3)) Expect(p.Frames).To(HaveLen(3))
@ -761,7 +746,7 @@ var _ = Describe("Packet packer", func() {
ackFramer.EXPECT().GetAckFrame(protocol.Encryption1RTT, false).Return(&wire.AckFrame{AckRanges: []wire.AckRange{{Smallest: 1, Largest: 1}}}) ackFramer.EXPECT().GetAckFrame(protocol.Encryption1RTT, false).Return(&wire.AckFrame{AckRanges: []wire.AckRange{{Smallest: 1, Largest: 1}}})
expectAppendControlFrames() expectAppendControlFrames()
expectAppendStreamFrames() expectAppendStreamFrames()
p, _, err := packer.PackPacket(false, time.Now()) p, _, err := packer.PackPacket(false, time.Now(), protocol.Version1)
Expect(p).ToNot(BeNil()) Expect(p).ToNot(BeNil())
Expect(err).ToNot(HaveOccurred()) Expect(err).ToNot(HaveOccurred())
Expect(p.Ack).ToNot(BeNil()) Expect(p.Ack).ToNot(BeNil())
@ -778,7 +763,7 @@ var _ = Describe("Packet packer", func() {
ackFramer.EXPECT().GetAckFrame(protocol.Encryption1RTT, false).Return(&wire.AckFrame{AckRanges: []wire.AckRange{{Smallest: 1, Largest: 1}}}) ackFramer.EXPECT().GetAckFrame(protocol.Encryption1RTT, false).Return(&wire.AckFrame{AckRanges: []wire.AckRange{{Smallest: 1, Largest: 1}}})
expectAppendControlFrames() expectAppendControlFrames()
expectAppendStreamFrames() expectAppendStreamFrames()
p, _, err := packer.PackPacket(false, time.Now()) p, _, err := packer.PackPacket(false, time.Now(), protocol.Version1)
Expect(p).ToNot(BeNil()) Expect(p).ToNot(BeNil())
Expect(err).ToNot(HaveOccurred()) Expect(err).ToNot(HaveOccurred())
var hasPing bool var hasPing bool
@ -797,7 +782,7 @@ var _ = Describe("Packet packer", func() {
ackFramer.EXPECT().GetAckFrame(protocol.Encryption1RTT, false).Return(&wire.AckFrame{AckRanges: []wire.AckRange{{Smallest: 1, Largest: 1}}}) ackFramer.EXPECT().GetAckFrame(protocol.Encryption1RTT, false).Return(&wire.AckFrame{AckRanges: []wire.AckRange{{Smallest: 1, Largest: 1}}})
expectAppendControlFrames() expectAppendControlFrames()
expectAppendStreamFrames() expectAppendStreamFrames()
p, _, err = packer.PackPacket(false, time.Now()) p, _, err = packer.PackPacket(false, time.Now(), protocol.Version1)
Expect(p).ToNot(BeNil()) Expect(p).ToNot(BeNil())
Expect(err).ToNot(HaveOccurred()) Expect(err).ToNot(HaveOccurred())
Expect(p.Ack).ToNot(BeNil()) Expect(p.Ack).ToNot(BeNil())
@ -813,7 +798,7 @@ var _ = Describe("Packet packer", func() {
expectAppendControlFrames() expectAppendControlFrames()
expectAppendStreamFrames() expectAppendStreamFrames()
ackFramer.EXPECT().GetAckFrame(protocol.Encryption1RTT, false) ackFramer.EXPECT().GetAckFrame(protocol.Encryption1RTT, false)
_, _, err := packer.PackPacket(false, time.Now()) _, _, err := packer.PackPacket(false, time.Now(), protocol.Version1)
Expect(err).To(MatchError(errNothingToPack)) Expect(err).To(MatchError(errNothingToPack))
// now add some frame to send // now add some frame to send
expectAppendControlFrames() expectAppendControlFrames()
@ -824,7 +809,7 @@ var _ = Describe("Packet packer", func() {
framer.EXPECT().HasData().Return(true) framer.EXPECT().HasData().Return(true)
ack := &wire.AckFrame{AckRanges: []wire.AckRange{{Smallest: 1, Largest: 1}}} ack := &wire.AckFrame{AckRanges: []wire.AckRange{{Smallest: 1, Largest: 1}}}
ackFramer.EXPECT().GetAckFrame(protocol.Encryption1RTT, false).Return(ack) ackFramer.EXPECT().GetAckFrame(protocol.Encryption1RTT, false).Return(ack)
p, _, err := packer.PackPacket(false, time.Now()) p, _, err := packer.PackPacket(false, time.Now(), protocol.Version1)
Expect(err).ToNot(HaveOccurred()) Expect(err).ToNot(HaveOccurred())
Expect(p.Ack).To(Equal(ack)) Expect(p.Ack).To(Equal(ack))
var hasPing bool var hasPing bool
@ -846,7 +831,7 @@ var _ = Describe("Packet packer", func() {
ackFramer.EXPECT().GetAckFrame(protocol.Encryption1RTT, false) ackFramer.EXPECT().GetAckFrame(protocol.Encryption1RTT, false)
expectAppendStreamFrames() expectAppendStreamFrames()
expectAppendControlFrames(&ackhandler.Frame{Frame: &wire.MaxDataFrame{}}) expectAppendControlFrames(&ackhandler.Frame{Frame: &wire.MaxDataFrame{}})
p, _, err := packer.PackPacket(false, time.Now()) p, _, err := packer.PackPacket(false, time.Now(), protocol.Version1)
Expect(err).ToNot(HaveOccurred()) Expect(err).ToNot(HaveOccurred())
Expect(p).ToNot(BeNil()) Expect(p).ToNot(BeNil())
Expect(p.Frames).ToNot(ContainElement(&wire.PingFrame{})) Expect(p.Frames).ToNot(ContainElement(&wire.PingFrame{}))
@ -865,7 +850,7 @@ var _ = Describe("Packet packer", func() {
return nil, 0 return nil, 0
}) })
expectAppendStreamFrames() expectAppendStreamFrames()
_, _, err := packer.PackPacket(false, time.Now()) _, _, err := packer.PackPacket(false, time.Now(), protocol.Version1)
Expect(err).To(MatchError(errNothingToPack)) Expect(err).To(MatchError(errNothingToPack))
// now reduce the maxPacketSize // now reduce the maxPacketSize
packer.HandleTransportParameters(&wire.TransportParameters{ packer.HandleTransportParameters(&wire.TransportParameters{
@ -876,7 +861,7 @@ var _ = Describe("Packet packer", func() {
return nil, 0 return nil, 0
}) })
expectAppendStreamFrames() expectAppendStreamFrames()
_, _, err = packer.PackPacket(false, time.Now()) _, _, err = packer.PackPacket(false, time.Now(), protocol.Version1)
Expect(err).To(MatchError(errNothingToPack)) Expect(err).To(MatchError(errNothingToPack))
}) })
@ -891,7 +876,7 @@ var _ = Describe("Packet packer", func() {
return nil, 0 return nil, 0
}) })
expectAppendStreamFrames() expectAppendStreamFrames()
_, _, err := packer.PackPacket(false, time.Now()) _, _, err := packer.PackPacket(false, time.Now(), protocol.Version1)
Expect(err).To(MatchError(errNothingToPack)) Expect(err).To(MatchError(errNothingToPack))
// now try to increase the maxPacketSize // now try to increase the maxPacketSize
packer.HandleTransportParameters(&wire.TransportParameters{ packer.HandleTransportParameters(&wire.TransportParameters{
@ -902,7 +887,7 @@ var _ = Describe("Packet packer", func() {
return nil, 0 return nil, 0
}) })
expectAppendStreamFrames() expectAppendStreamFrames()
_, _, err = packer.PackPacket(false, time.Now()) _, _, err = packer.PackPacket(false, time.Now(), protocol.Version1)
Expect(err).To(MatchError(errNothingToPack)) Expect(err).To(MatchError(errNothingToPack))
}) })
}) })
@ -919,7 +904,7 @@ var _ = Describe("Packet packer", func() {
return nil, 0 return nil, 0
}) })
expectAppendStreamFrames() expectAppendStreamFrames()
_, _, err := packer.PackPacket(false, time.Now()) _, _, err := packer.PackPacket(false, time.Now(), protocol.Version1)
Expect(err).To(MatchError(errNothingToPack)) Expect(err).To(MatchError(errNothingToPack))
// now reduce the maxPacketSize // now reduce the maxPacketSize
const packetSizeIncrease = 50 const packetSizeIncrease = 50
@ -929,7 +914,7 @@ var _ = Describe("Packet packer", func() {
return nil, 0 return nil, 0
}) })
expectAppendStreamFrames() expectAppendStreamFrames()
_, _, err = packer.PackPacket(false, time.Now()) _, _, err = packer.PackPacket(false, time.Now(), protocol.Version1)
Expect(err).To(MatchError(errNothingToPack)) Expect(err).To(MatchError(errNothingToPack))
}) })
}) })
@ -949,7 +934,7 @@ var _ = Describe("Packet packer", func() {
sealingManager.EXPECT().GetInitialSealer().Return(nil, handshake.ErrKeysDropped) sealingManager.EXPECT().GetInitialSealer().Return(nil, handshake.ErrKeysDropped)
sealingManager.EXPECT().GetHandshakeSealer().Return(getSealer(), nil) sealingManager.EXPECT().GetHandshakeSealer().Return(getSealer(), nil)
sealingManager.EXPECT().Get1RTTSealer().Return(nil, handshake.ErrKeysNotYetAvailable) sealingManager.EXPECT().Get1RTTSealer().Return(nil, handshake.ErrKeysNotYetAvailable)
p, err := packer.PackCoalescedPacket(false) p, err := packer.PackCoalescedPacket(false, protocol.Version1)
Expect(err).ToNot(HaveOccurred()) Expect(err).ToNot(HaveOccurred())
Expect(p).ToNot(BeNil()) Expect(p).ToNot(BeNil())
parsePacket(p.buffer.Data) parsePacket(p.buffer.Data)
@ -968,7 +953,7 @@ var _ = Describe("Packet packer", func() {
initialStream.EXPECT().PopCryptoFrame(gomock.Any()).DoAndReturn(func(size protocol.ByteCount) *wire.CryptoFrame { initialStream.EXPECT().PopCryptoFrame(gomock.Any()).DoAndReturn(func(size protocol.ByteCount) *wire.CryptoFrame {
return &wire.CryptoFrame{Offset: 0x42, Data: []byte("initial")} return &wire.CryptoFrame{Offset: 0x42, Data: []byte("initial")}
}) })
p, err := packer.PackCoalescedPacket(false) p, err := packer.PackCoalescedPacket(false, protocol.Version1)
Expect(err).ToNot(HaveOccurred()) Expect(err).ToNot(HaveOccurred())
Expect(p.buffer.Len()).To(BeNumerically(">=", protocol.MinInitialPacketSize)) Expect(p.buffer.Len()).To(BeNumerically(">=", protocol.MinInitialPacketSize))
Expect(p.buffer.Len()).To(BeEquivalentTo(maxPacketSize)) Expect(p.buffer.Len()).To(BeEquivalentTo(maxPacketSize))
@ -994,11 +979,11 @@ var _ = Describe("Packet packer", func() {
handshakeStream.EXPECT().HasData().Return(true).Times(2) handshakeStream.EXPECT().HasData().Return(true).Times(2)
handshakeStream.EXPECT().PopCryptoFrame(gomock.Any()).DoAndReturn(func(size protocol.ByteCount) *wire.CryptoFrame { handshakeStream.EXPECT().PopCryptoFrame(gomock.Any()).DoAndReturn(func(size protocol.ByteCount) *wire.CryptoFrame {
f = &wire.CryptoFrame{Offset: 0x1337} f = &wire.CryptoFrame{Offset: 0x1337}
f.Data = bytes.Repeat([]byte{'f'}, int(size-f.Length(packer.version)-1)) f.Data = bytes.Repeat([]byte{'f'}, int(size-f.Length(protocol.Version1)-1))
Expect(f.Length(packer.version)).To(Equal(size)) Expect(f.Length(protocol.Version1)).To(Equal(size))
return f return f
}) })
p, err := packer.PackCoalescedPacket(false) p, err := packer.PackCoalescedPacket(false, protocol.Version1)
Expect(err).ToNot(HaveOccurred()) Expect(err).ToNot(HaveOccurred())
Expect(p.longHdrPackets).To(HaveLen(1)) Expect(p.longHdrPackets).To(HaveLen(1))
Expect(p.longHdrPackets[0].frames).To(HaveLen(1)) Expect(p.longHdrPackets[0].frames).To(HaveLen(1))
@ -1024,7 +1009,7 @@ var _ = Describe("Packet packer", func() {
handshakeStream.EXPECT().PopCryptoFrame(gomock.Any()).DoAndReturn(func(size protocol.ByteCount) *wire.CryptoFrame { handshakeStream.EXPECT().PopCryptoFrame(gomock.Any()).DoAndReturn(func(size protocol.ByteCount) *wire.CryptoFrame {
return &wire.CryptoFrame{Offset: 0x1337, Data: []byte("handshake")} return &wire.CryptoFrame{Offset: 0x1337, Data: []byte("handshake")}
}) })
p, err := packer.PackCoalescedPacket(false) p, err := packer.PackCoalescedPacket(false, protocol.Version1)
Expect(err).ToNot(HaveOccurred()) Expect(err).ToNot(HaveOccurred())
Expect(p.buffer.Len()).To(BeEquivalentTo(packer.maxPacketSize)) Expect(p.buffer.Len()).To(BeEquivalentTo(packer.maxPacketSize))
Expect(p.longHdrPackets).To(HaveLen(2)) Expect(p.longHdrPackets).To(HaveLen(2))
@ -1058,7 +1043,7 @@ var _ = Describe("Packet packer", func() {
}) })
handshakeStream.EXPECT().HasData() handshakeStream.EXPECT().HasData()
packer.retransmissionQueue.AddHandshake(&wire.PingFrame{}) packer.retransmissionQueue.AddHandshake(&wire.PingFrame{})
p, err := packer.PackCoalescedPacket(false) p, err := packer.PackCoalescedPacket(false, protocol.Version1)
Expect(err).ToNot(HaveOccurred()) Expect(err).ToNot(HaveOccurred())
Expect(p.buffer.Len()).To(BeEquivalentTo(packer.maxPacketSize)) Expect(p.buffer.Len()).To(BeEquivalentTo(packer.maxPacketSize))
Expect(p.longHdrPackets).To(HaveLen(2)) Expect(p.longHdrPackets).To(HaveLen(2))
@ -1089,7 +1074,7 @@ var _ = Describe("Packet packer", func() {
handshakeStream.EXPECT().HasData() handshakeStream.EXPECT().HasData()
packer.retransmissionQueue.AddInitial(&wire.PingFrame{}) packer.retransmissionQueue.AddInitial(&wire.PingFrame{})
packer.retransmissionQueue.AddHandshake(&wire.PingFrame{}) packer.retransmissionQueue.AddHandshake(&wire.PingFrame{})
p, err := packer.PackCoalescedPacket(false) p, err := packer.PackCoalescedPacket(false, protocol.Version1)
Expect(err).ToNot(HaveOccurred()) Expect(err).ToNot(HaveOccurred())
Expect(p.buffer.Len()).To(BeEquivalentTo(packer.maxPacketSize)) Expect(p.buffer.Len()).To(BeEquivalentTo(packer.maxPacketSize))
Expect(p.longHdrPackets).To(HaveLen(2)) Expect(p.longHdrPackets).To(HaveLen(2))
@ -1123,7 +1108,7 @@ var _ = Describe("Packet packer", func() {
expectAppendStreamFrames() expectAppendStreamFrames()
framer.EXPECT().HasData().Return(true) framer.EXPECT().HasData().Return(true)
packer.retransmissionQueue.AddAppData(&wire.PingFrame{}) packer.retransmissionQueue.AddAppData(&wire.PingFrame{})
p, err := packer.PackCoalescedPacket(false) p, err := packer.PackCoalescedPacket(false, protocol.Version1)
Expect(err).ToNot(HaveOccurred()) Expect(err).ToNot(HaveOccurred())
Expect(p.buffer.Len()).To(BeEquivalentTo(packer.maxPacketSize)) Expect(p.buffer.Len()).To(BeEquivalentTo(packer.maxPacketSize))
Expect(p.longHdrPackets).To(HaveLen(1)) Expect(p.longHdrPackets).To(HaveLen(1))
@ -1159,7 +1144,7 @@ var _ = Describe("Packet packer", func() {
}) })
expectAppendControlFrames() expectAppendControlFrames()
expectAppendStreamFrames(&ackhandler.Frame{Frame: &wire.StreamFrame{Data: []byte("foobar")}}) expectAppendStreamFrames(&ackhandler.Frame{Frame: &wire.StreamFrame{Data: []byte("foobar")}})
p, err := packer.PackCoalescedPacket(false) p, err := packer.PackCoalescedPacket(false, protocol.Version1)
Expect(err).ToNot(HaveOccurred()) Expect(err).ToNot(HaveOccurred())
Expect(p.buffer.Len()).To(BeNumerically(">=", protocol.MinInitialPacketSize)) Expect(p.buffer.Len()).To(BeNumerically(">=", protocol.MinInitialPacketSize))
Expect(p.buffer.Len()).To(BeEquivalentTo(maxPacketSize)) Expect(p.buffer.Len()).To(BeEquivalentTo(maxPacketSize))
@ -1194,7 +1179,7 @@ var _ = Describe("Packet packer", func() {
}) })
expectAppendControlFrames() expectAppendControlFrames()
expectAppendStreamFrames(&ackhandler.Frame{Frame: &wire.StreamFrame{Data: []byte("foobar")}}) expectAppendStreamFrames(&ackhandler.Frame{Frame: &wire.StreamFrame{Data: []byte("foobar")}})
p, err := packer.PackCoalescedPacket(false) p, err := packer.PackCoalescedPacket(false, protocol.Version1)
Expect(err).ToNot(HaveOccurred()) Expect(err).ToNot(HaveOccurred())
Expect(p.buffer.Len()).To(BeNumerically("<", 100)) Expect(p.buffer.Len()).To(BeNumerically("<", 100))
Expect(p.longHdrPackets).To(HaveLen(1)) Expect(p.longHdrPackets).To(HaveLen(1))
@ -1222,11 +1207,11 @@ var _ = Describe("Packet packer", func() {
handshakeStream.EXPECT().PopCryptoFrame(gomock.Any()).DoAndReturn(func(size protocol.ByteCount) *wire.CryptoFrame { handshakeStream.EXPECT().PopCryptoFrame(gomock.Any()).DoAndReturn(func(size protocol.ByteCount) *wire.CryptoFrame {
s := size - protocol.MinCoalescedPacketSize s := size - protocol.MinCoalescedPacketSize
f := &wire.CryptoFrame{Offset: 0x1337} f := &wire.CryptoFrame{Offset: 0x1337}
f.Data = bytes.Repeat([]byte{'f'}, int(s-f.Length(packer.version)-1)) f.Data = bytes.Repeat([]byte{'f'}, int(s-f.Length(protocol.Version1)-1))
Expect(f.Length(packer.version)).To(Equal(s)) Expect(f.Length(protocol.Version1)).To(Equal(s))
return f return f
}) })
p, err := packer.PackCoalescedPacket(false) p, err := packer.PackCoalescedPacket(false, protocol.Version1)
Expect(err).ToNot(HaveOccurred()) Expect(err).ToNot(HaveOccurred())
Expect(p.longHdrPackets).To(HaveLen(1)) Expect(p.longHdrPackets).To(HaveLen(1))
Expect(p.shortHdrPacket).To(BeNil()) Expect(p.shortHdrPacket).To(BeNil())
@ -1245,7 +1230,7 @@ var _ = Describe("Packet packer", func() {
packer.retransmissionQueue.AddHandshake(&wire.PingFrame{}) packer.retransmissionQueue.AddHandshake(&wire.PingFrame{})
handshakeStream.EXPECT().HasData() handshakeStream.EXPECT().HasData()
ackFramer.EXPECT().GetAckFrame(protocol.EncryptionHandshake, false) ackFramer.EXPECT().GetAckFrame(protocol.EncryptionHandshake, false)
packet, err := packer.PackCoalescedPacket(false) packet, err := packer.PackCoalescedPacket(false, protocol.Version1)
Expect(err).ToNot(HaveOccurred()) Expect(err).ToNot(HaveOccurred())
Expect(packet).ToNot(BeNil()) Expect(packet).ToNot(BeNil())
Expect(packet.longHdrPackets).To(HaveLen(1)) Expect(packet.longHdrPackets).To(HaveLen(1))
@ -1256,7 +1241,7 @@ var _ = Describe("Packet packer", func() {
Expect(err).ToNot(HaveOccurred()) Expect(err).ToNot(HaveOccurred())
data := packet.buffer.Data data := packet.buffer.Data
r := bytes.NewReader(data) r := bytes.NewReader(data)
extHdr, err := hdr.ParseExtended(r, packer.version) extHdr, err := hdr.ParseExtended(r, protocol.Version1)
Expect(err).ToNot(HaveOccurred()) Expect(err).ToNot(HaveOccurred())
Expect(extHdr.PacketNumberLen).To(Equal(protocol.PacketNumberLen1)) Expect(extHdr.PacketNumberLen).To(Equal(protocol.PacketNumberLen1))
Expect(r.Len()).To(Equal(4 - 1 /* packet number length */ + sealer.Overhead())) Expect(r.Len()).To(Equal(4 - 1 /* packet number length */ + sealer.Overhead()))
@ -1269,7 +1254,7 @@ var _ = Describe("Packet packer", func() {
Expect(secondPayloadByte).To(Equal(byte(0))) Expect(secondPayloadByte).To(Equal(byte(0)))
// ... followed by the PING // ... followed by the PING
frameParser := wire.NewFrameParser(false) frameParser := wire.NewFrameParser(false)
l, frame, err := frameParser.ParseNext(data[len(data)-r.Len():], protocol.Encryption1RTT, packer.version) l, frame, err := frameParser.ParseNext(data[len(data)-r.Len():], protocol.Encryption1RTT, protocol.Version1)
Expect(err).ToNot(HaveOccurred()) Expect(err).ToNot(HaveOccurred())
Expect(frame).To(BeAssignableToTypeOf(&wire.PingFrame{})) Expect(frame).To(BeAssignableToTypeOf(&wire.PingFrame{}))
Expect(r.Len() - l).To(Equal(sealer.Overhead())) Expect(r.Len() - l).To(Equal(sealer.Overhead()))
@ -1286,7 +1271,7 @@ var _ = Describe("Packet packer", func() {
sealingManager.EXPECT().Get1RTTSealer().Return(nil, handshake.ErrKeysNotYetAvailable) sealingManager.EXPECT().Get1RTTSealer().Return(nil, handshake.ErrKeysNotYetAvailable)
ackFramer.EXPECT().GetAckFrame(protocol.EncryptionInitial, false) ackFramer.EXPECT().GetAckFrame(protocol.EncryptionInitial, false)
initialStream.EXPECT().HasData() initialStream.EXPECT().HasData()
p, err := packer.PackCoalescedPacket(false) p, err := packer.PackCoalescedPacket(false, protocol.Version1)
Expect(err).ToNot(HaveOccurred()) Expect(err).ToNot(HaveOccurred())
Expect(p.longHdrPackets).To(HaveLen(1)) Expect(p.longHdrPackets).To(HaveLen(1))
Expect(p.longHdrPackets[0].EncryptionLevel()).To(Equal(protocol.EncryptionInitial)) Expect(p.longHdrPackets[0].EncryptionLevel()).To(Equal(protocol.EncryptionInitial))
@ -1302,7 +1287,7 @@ var _ = Describe("Packet packer", func() {
sealingManager.EXPECT().Get1RTTSealer().Return(nil, handshake.ErrKeysNotYetAvailable) sealingManager.EXPECT().Get1RTTSealer().Return(nil, handshake.ErrKeysNotYetAvailable)
pnManager.EXPECT().PeekPacketNumber(protocol.EncryptionInitial).Return(protocol.PacketNumber(0x42), protocol.PacketNumberLen2) pnManager.EXPECT().PeekPacketNumber(protocol.EncryptionInitial).Return(protocol.PacketNumber(0x42), protocol.PacketNumberLen2)
pnManager.EXPECT().PopPacketNumber(protocol.EncryptionInitial).Return(protocol.PacketNumber(0x42)) pnManager.EXPECT().PopPacketNumber(protocol.EncryptionInitial).Return(protocol.PacketNumber(0x42))
p, err := packer.PackCoalescedPacket(false) p, err := packer.PackCoalescedPacket(false, protocol.Version1)
Expect(err).ToNot(HaveOccurred()) Expect(err).ToNot(HaveOccurred())
Expect(p.longHdrPackets).To(HaveLen(1)) Expect(p.longHdrPackets).To(HaveLen(1))
Expect(p.longHdrPackets[0].ack).To(Equal(ack)) Expect(p.longHdrPackets[0].ack).To(Equal(ack))
@ -1314,7 +1299,7 @@ var _ = Describe("Packet packer", func() {
sealingManager.EXPECT().Get1RTTSealer().Return(nil, handshake.ErrKeysNotYetAvailable) sealingManager.EXPECT().Get1RTTSealer().Return(nil, handshake.ErrKeysNotYetAvailable)
initialStream.EXPECT().HasData() initialStream.EXPECT().HasData()
ackFramer.EXPECT().GetAckFrame(protocol.EncryptionInitial, true) ackFramer.EXPECT().GetAckFrame(protocol.EncryptionInitial, true)
p, err := packer.PackCoalescedPacket(false) p, err := packer.PackCoalescedPacket(false, protocol.Version1)
Expect(err).ToNot(HaveOccurred()) Expect(err).ToNot(HaveOccurred())
Expect(p).To(BeNil()) Expect(p).To(BeNil())
}) })
@ -1330,7 +1315,7 @@ var _ = Describe("Packet packer", func() {
sealingManager.EXPECT().Get1RTTSealer().Return(nil, handshake.ErrKeysNotYetAvailable) sealingManager.EXPECT().Get1RTTSealer().Return(nil, handshake.ErrKeysNotYetAvailable)
pnManager.EXPECT().PeekPacketNumber(protocol.EncryptionHandshake).Return(protocol.PacketNumber(0x42), protocol.PacketNumberLen2) pnManager.EXPECT().PeekPacketNumber(protocol.EncryptionHandshake).Return(protocol.PacketNumber(0x42), protocol.PacketNumberLen2)
pnManager.EXPECT().PopPacketNumber(protocol.EncryptionHandshake).Return(protocol.PacketNumber(0x42)) pnManager.EXPECT().PopPacketNumber(protocol.EncryptionHandshake).Return(protocol.PacketNumber(0x42))
p, err := packer.PackCoalescedPacket(false) p, err := packer.PackCoalescedPacket(false, protocol.Version1)
Expect(err).ToNot(HaveOccurred()) Expect(err).ToNot(HaveOccurred())
Expect(p.longHdrPackets).To(HaveLen(1)) Expect(p.longHdrPackets).To(HaveLen(1))
Expect(p.longHdrPackets[0].ack).To(Equal(ack)) Expect(p.longHdrPackets[0].ack).To(Equal(ack))
@ -1353,7 +1338,7 @@ var _ = Describe("Packet packer", func() {
initialStream.EXPECT().HasData().Return(true).Times(2) initialStream.EXPECT().HasData().Return(true).Times(2)
initialStream.EXPECT().PopCryptoFrame(gomock.Any()).Return(f) initialStream.EXPECT().PopCryptoFrame(gomock.Any()).Return(f)
packer.perspective = protocol.PerspectiveClient packer.perspective = protocol.PerspectiveClient
p, err := packer.PackCoalescedPacket(false) p, err := packer.PackCoalescedPacket(false, protocol.Version1)
Expect(err).ToNot(HaveOccurred()) Expect(err).ToNot(HaveOccurred())
Expect(p.buffer.Len()).To(BeNumerically(">=", protocol.MinInitialPacketSize)) Expect(p.buffer.Len()).To(BeNumerically(">=", protocol.MinInitialPacketSize))
Expect(p.buffer.Len()).To(BeEquivalentTo(maxPacketSize)) Expect(p.buffer.Len()).To(BeEquivalentTo(maxPacketSize))
@ -1377,9 +1362,8 @@ var _ = Describe("Packet packer", func() {
ackFramer.EXPECT().GetAckFrame(protocol.EncryptionInitial, false).Return(ack) ackFramer.EXPECT().GetAckFrame(protocol.EncryptionInitial, false).Return(ack)
initialStream.EXPECT().HasData().Return(true).Times(2) initialStream.EXPECT().HasData().Return(true).Times(2)
initialStream.EXPECT().PopCryptoFrame(gomock.Any()).Return(f) initialStream.EXPECT().PopCryptoFrame(gomock.Any()).Return(f)
packer.version = protocol.VersionTLS
packer.perspective = protocol.PerspectiveClient packer.perspective = protocol.PerspectiveClient
p, err := packer.PackCoalescedPacket(false) p, err := packer.PackCoalescedPacket(false, protocol.Version1)
Expect(err).ToNot(HaveOccurred()) Expect(err).ToNot(HaveOccurred())
Expect(p.longHdrPackets).To(HaveLen(1)) Expect(p.longHdrPackets).To(HaveLen(1))
Expect(p.longHdrPackets[0].ack).To(Equal(ack)) Expect(p.longHdrPackets[0].ack).To(Equal(ack))
@ -1402,7 +1386,7 @@ var _ = Describe("Packet packer", func() {
pnManager.EXPECT().PeekPacketNumber(protocol.EncryptionInitial).Return(protocol.PacketNumber(0x42), protocol.PacketNumberLen2) pnManager.EXPECT().PeekPacketNumber(protocol.EncryptionInitial).Return(protocol.PacketNumber(0x42), protocol.PacketNumberLen2)
pnManager.EXPECT().PopPacketNumber(protocol.EncryptionInitial).Return(protocol.PacketNumber(0x42)) pnManager.EXPECT().PopPacketNumber(protocol.EncryptionInitial).Return(protocol.PacketNumber(0x42))
p, err := packer.MaybePackProbePacket(protocol.EncryptionInitial) p, err := packer.MaybePackProbePacket(protocol.EncryptionInitial, protocol.Version1)
Expect(err).ToNot(HaveOccurred()) Expect(err).ToNot(HaveOccurred())
Expect(p).ToNot(BeNil()) Expect(p).ToNot(BeNil())
Expect(p.longHdrPackets).To(HaveLen(1)) Expect(p.longHdrPackets).To(HaveLen(1))
@ -1424,7 +1408,7 @@ var _ = Describe("Packet packer", func() {
pnManager.EXPECT().PeekPacketNumber(protocol.EncryptionInitial).Return(protocol.PacketNumber(0x42), protocol.PacketNumberLen1) pnManager.EXPECT().PeekPacketNumber(protocol.EncryptionInitial).Return(protocol.PacketNumber(0x42), protocol.PacketNumberLen1)
pnManager.EXPECT().PopPacketNumber(protocol.EncryptionInitial).Return(protocol.PacketNumber(0x42)) pnManager.EXPECT().PopPacketNumber(protocol.EncryptionInitial).Return(protocol.PacketNumber(0x42))
p, err := packer.MaybePackProbePacket(protocol.EncryptionInitial) p, err := packer.MaybePackProbePacket(protocol.EncryptionInitial, protocol.Version1)
Expect(err).ToNot(HaveOccurred()) Expect(err).ToNot(HaveOccurred())
Expect(err).ToNot(HaveOccurred()) Expect(err).ToNot(HaveOccurred())
Expect(p).ToNot(BeNil()) Expect(p).ToNot(BeNil())
@ -1448,7 +1432,7 @@ var _ = Describe("Packet packer", func() {
pnManager.EXPECT().PeekPacketNumber(protocol.EncryptionHandshake).Return(protocol.PacketNumber(0x42), protocol.PacketNumberLen2) pnManager.EXPECT().PeekPacketNumber(protocol.EncryptionHandshake).Return(protocol.PacketNumber(0x42), protocol.PacketNumberLen2)
pnManager.EXPECT().PopPacketNumber(protocol.EncryptionHandshake).Return(protocol.PacketNumber(0x42)) pnManager.EXPECT().PopPacketNumber(protocol.EncryptionHandshake).Return(protocol.PacketNumber(0x42))
p, err := packer.MaybePackProbePacket(protocol.EncryptionHandshake) p, err := packer.MaybePackProbePacket(protocol.EncryptionHandshake, protocol.Version1)
Expect(err).ToNot(HaveOccurred()) Expect(err).ToNot(HaveOccurred())
Expect(err).ToNot(HaveOccurred()) Expect(err).ToNot(HaveOccurred())
Expect(p).ToNot(BeNil()) Expect(p).ToNot(BeNil())
@ -1469,7 +1453,7 @@ var _ = Describe("Packet packer", func() {
pnManager.EXPECT().PeekPacketNumber(protocol.EncryptionHandshake).Return(protocol.PacketNumber(0x42), protocol.PacketNumberLen2) pnManager.EXPECT().PeekPacketNumber(protocol.EncryptionHandshake).Return(protocol.PacketNumber(0x42), protocol.PacketNumberLen2)
pnManager.EXPECT().PopPacketNumber(protocol.EncryptionHandshake).Return(protocol.PacketNumber(0x42)) pnManager.EXPECT().PopPacketNumber(protocol.EncryptionHandshake).Return(protocol.PacketNumber(0x42))
p, err := packer.MaybePackProbePacket(protocol.EncryptionHandshake) p, err := packer.MaybePackProbePacket(protocol.EncryptionHandshake, protocol.Version1)
Expect(err).ToNot(HaveOccurred()) Expect(err).ToNot(HaveOccurred())
Expect(err).ToNot(HaveOccurred()) Expect(err).ToNot(HaveOccurred())
Expect(p).ToNot(BeNil()) Expect(p).ToNot(BeNil())
@ -1493,7 +1477,7 @@ var _ = Describe("Packet packer", func() {
expectAppendControlFrames() expectAppendControlFrames()
expectAppendStreamFrames(&ackhandler.Frame{Frame: f}) expectAppendStreamFrames(&ackhandler.Frame{Frame: f})
p, err := packer.MaybePackProbePacket(protocol.Encryption1RTT) p, err := packer.MaybePackProbePacket(protocol.Encryption1RTT, protocol.Version1)
Expect(err).ToNot(HaveOccurred()) Expect(err).ToNot(HaveOccurred())
Expect(p).ToNot(BeNil()) Expect(p).ToNot(BeNil())
Expect(p.longHdrPackets).To(BeEmpty()) Expect(p.longHdrPackets).To(BeEmpty())
@ -1513,12 +1497,12 @@ var _ = Describe("Packet packer", func() {
framer.EXPECT().HasData().Return(true) framer.EXPECT().HasData().Return(true)
expectAppendControlFrames() expectAppendControlFrames()
framer.EXPECT().AppendStreamFrames(gomock.Any(), gomock.Any()).DoAndReturn(func(fs []*ackhandler.Frame, maxSize protocol.ByteCount) ([]*ackhandler.Frame, protocol.ByteCount) { framer.EXPECT().AppendStreamFrames(gomock.Any(), gomock.Any()).DoAndReturn(func(fs []*ackhandler.Frame, maxSize protocol.ByteCount) ([]*ackhandler.Frame, protocol.ByteCount) {
sf, split := f.MaybeSplitOffFrame(maxSize, packer.version) sf, split := f.MaybeSplitOffFrame(maxSize, protocol.Version1)
Expect(split).To(BeTrue()) Expect(split).To(BeTrue())
return append(fs, &ackhandler.Frame{Frame: sf}), sf.Length(packer.version) return append(fs, &ackhandler.Frame{Frame: sf}), sf.Length(protocol.Version1)
}) })
p, err := packer.MaybePackProbePacket(protocol.Encryption1RTT) p, err := packer.MaybePackProbePacket(protocol.Encryption1RTT, protocol.Version1)
Expect(err).ToNot(HaveOccurred()) Expect(err).ToNot(HaveOccurred())
Expect(p).ToNot(BeNil()) Expect(p).ToNot(BeNil())
Expect(p.longHdrPackets).To(BeEmpty()) Expect(p.longHdrPackets).To(BeEmpty())
@ -1535,7 +1519,7 @@ var _ = Describe("Packet packer", func() {
ackFramer.EXPECT().GetAckFrame(protocol.Encryption1RTT, true) ackFramer.EXPECT().GetAckFrame(protocol.Encryption1RTT, true)
framer.EXPECT().HasData() framer.EXPECT().HasData()
packet, err := packer.MaybePackProbePacket(protocol.Encryption1RTT) packet, err := packer.MaybePackProbePacket(protocol.Encryption1RTT, protocol.Version1)
Expect(err).ToNot(HaveOccurred()) Expect(err).ToNot(HaveOccurred())
Expect(packet).To(BeNil()) Expect(packet).To(BeNil())
}) })
@ -1546,7 +1530,7 @@ var _ = Describe("Packet packer", func() {
pnManager.EXPECT().PopPacketNumber(protocol.Encryption1RTT).Return(protocol.PacketNumber(0x43)) pnManager.EXPECT().PopPacketNumber(protocol.Encryption1RTT).Return(protocol.PacketNumber(0x43))
ping := ackhandler.Frame{Frame: &wire.PingFrame{}} ping := ackhandler.Frame{Frame: &wire.PingFrame{}}
const probePacketSize = maxPacketSize + 42 const probePacketSize = maxPacketSize + 42
p, buffer, err := packer.PackMTUProbePacket(ping, probePacketSize, time.Now()) p, buffer, err := packer.PackMTUProbePacket(ping, probePacketSize, time.Now(), protocol.Version1)
Expect(err).ToNot(HaveOccurred()) Expect(err).ToNot(HaveOccurred())
Expect(p.Length).To(BeEquivalentTo(probePacketSize)) Expect(p.Length).To(BeEquivalentTo(probePacketSize))
Expect(p.PacketNumber).To(Equal(protocol.PacketNumber(0x43))) Expect(p.PacketNumber).To(Equal(protocol.PacketNumber(0x43)))