From 0c2f562411d9314b4c800ee0fe6a2a2217d62798 Mon Sep 17 00:00:00 2001 From: Marten Seemann Date: Fri, 6 Nov 2020 14:16:11 +0700 Subject: [PATCH] allow an amplification factor of 3.x --- internal/ackhandler/interfaces.go | 1 - internal/ackhandler/sent_packet_handler.go | 11 +-- .../ackhandler/sent_packet_handler_test.go | 32 +++---- .../mocks/ackhandler/sent_packet_handler.go | 14 --- mock_packer_test.go | 8 +- packet_packer.go | 14 ++- packet_packer_test.go | 90 ++++--------------- session.go | 2 +- session_test.go | 23 +++-- 9 files changed, 54 insertions(+), 141 deletions(-) diff --git a/internal/ackhandler/interfaces.go b/internal/ackhandler/interfaces.go index 460a2571..fbca75d3 100644 --- a/internal/ackhandler/interfaces.go +++ b/internal/ackhandler/interfaces.go @@ -34,7 +34,6 @@ type SentPacketHandler interface { // The SendMode determines if and what kind of packets can be sent. SendMode() SendMode - AmplificationWindow() protocol.ByteCount // TimeUntilSend is the time when the next packet should be sent. // It is used for pacing packets. TimeUntilSend() time.Time diff --git a/internal/ackhandler/sent_packet_handler.go b/internal/ackhandler/sent_packet_handler.go index 9f548647..0341ae79 100644 --- a/internal/ackhandler/sent_packet_handler.go +++ b/internal/ackhandler/sent_packet_handler.go @@ -692,7 +692,7 @@ func (h *sentPacketHandler) SendMode() SendMode { numTrackedPackets += h.handshakePackets.history.Len() } - if h.AmplificationWindow() == 0 { + if h.isAmplificationLimited() { h.logger.Debugf("Amplification window limited. Received %d bytes, already sent out %d bytes", h.bytesReceived, h.bytesSent) return SendNone } @@ -733,14 +733,11 @@ func (h *sentPacketHandler) HasPacingBudget() bool { return h.congestion.HasPacingBudget() } -func (h *sentPacketHandler) AmplificationWindow() protocol.ByteCount { +func (h *sentPacketHandler) isAmplificationLimited() bool { if h.peerAddressValidated { - return protocol.MaxByteCount + return false } - if h.bytesSent >= amplificationFactor*h.bytesReceived { - return 0 - } - return amplificationFactor*h.bytesReceived - h.bytesSent + return h.bytesSent >= amplificationFactor*h.bytesReceived } func (h *sentPacketHandler) QueueProbePacket(encLevel protocol.EncryptionLevel) bool { diff --git a/internal/ackhandler/sent_packet_handler_test.go b/internal/ackhandler/sent_packet_handler_test.go index 33814407..55660f16 100644 --- a/internal/ackhandler/sent_packet_handler_test.go +++ b/internal/ackhandler/sent_packet_handler_test.go @@ -512,31 +512,27 @@ var _ = Describe("SentPacketHandler", func() { handler.SendMode() }) - It("returns SendNone if limited by the 3x limit", func() { - handler.ReceivedBytes(100) - cong.EXPECT().OnPacketSent(gomock.Any(), protocol.ByteCount(300), gomock.Any(), protocol.ByteCount(300), true) - handler.SentPacket(&Packet{ - Length: 300, - EncryptionLevel: protocol.EncryptionInitial, - Frames: []Frame{{Frame: &wire.PingFrame{}}}, - SendTime: time.Now(), - }) - cong.EXPECT().CanSend(protocol.ByteCount(300)).Return(true).AnyTimes() - Expect(handler.AmplificationWindow()).To(BeZero()) - Expect(handler.SendMode()).To(Equal(SendNone)) - }) - It("limits the window to 3x the bytes received, to avoid amplification attacks", func() { handler.ReceivedPacket(protocol.EncryptionInitial) // receiving an Initial packet doesn't validate the client's address - cong.EXPECT().OnPacketSent(gomock.Any(), protocol.ByteCount(50), gomock.Any(), protocol.ByteCount(50), true) + handler.ReceivedBytes(200) + cong.EXPECT().OnPacketSent(gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any(), true).Times(2) handler.SentPacket(&Packet{ - Length: 50, + PacketNumber: 1, + Length: 599, EncryptionLevel: protocol.EncryptionInitial, Frames: []Frame{{Frame: &wire.PingFrame{}}}, SendTime: time.Now(), }) - handler.ReceivedBytes(100) - Expect(handler.AmplificationWindow()).To(Equal(protocol.ByteCount(3*100 - 50))) + cong.EXPECT().CanSend(protocol.ByteCount(599)).Return(true) + Expect(handler.SendMode()).To(Equal(SendAny)) + handler.SentPacket(&Packet{ + PacketNumber: 2, + Length: 1, + EncryptionLevel: protocol.EncryptionInitial, + Frames: []Frame{{Frame: &wire.PingFrame{}}}, + SendTime: time.Now(), + }) + Expect(handler.SendMode()).To(Equal(SendNone)) }) It("allows sending of ACKs when congestion limited", func() { diff --git a/internal/mocks/ackhandler/sent_packet_handler.go b/internal/mocks/ackhandler/sent_packet_handler.go index 74928606..4a392cb1 100644 --- a/internal/mocks/ackhandler/sent_packet_handler.go +++ b/internal/mocks/ackhandler/sent_packet_handler.go @@ -38,20 +38,6 @@ func (m *MockSentPacketHandler) EXPECT() *MockSentPacketHandlerMockRecorder { return m.recorder } -// AmplificationWindow mocks base method -func (m *MockSentPacketHandler) AmplificationWindow() protocol.ByteCount { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "AmplificationWindow") - ret0, _ := ret[0].(protocol.ByteCount) - return ret0 -} - -// AmplificationWindow indicates an expected call of AmplificationWindow -func (mr *MockSentPacketHandlerMockRecorder) AmplificationWindow() *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AmplificationWindow", reflect.TypeOf((*MockSentPacketHandler)(nil).AmplificationWindow)) -} - // DropPackets mocks base method func (m *MockSentPacketHandler) DropPackets(arg0 protocol.EncryptionLevel) { m.ctrl.T.Helper() diff --git a/mock_packer_test.go b/mock_packer_test.go index 6f95fb1a..d05be9c0 100644 --- a/mock_packer_test.go +++ b/mock_packer_test.go @@ -79,18 +79,18 @@ func (mr *MockPackerMockRecorder) MaybePackProbePacket(arg0 interface{}) *gomock } // PackCoalescedPacket mocks base method -func (m *MockPacker) PackCoalescedPacket(arg0 protocol.ByteCount) (*coalescedPacket, error) { +func (m *MockPacker) PackCoalescedPacket() (*coalescedPacket, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "PackCoalescedPacket", arg0) + ret := m.ctrl.Call(m, "PackCoalescedPacket") ret0, _ := ret[0].(*coalescedPacket) ret1, _ := ret[1].(error) return ret0, ret1 } // PackCoalescedPacket indicates an expected call of PackCoalescedPacket -func (mr *MockPackerMockRecorder) PackCoalescedPacket(arg0 interface{}) *gomock.Call { +func (mr *MockPackerMockRecorder) PackCoalescedPacket() *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PackCoalescedPacket", reflect.TypeOf((*MockPacker)(nil).PackCoalescedPacket), arg0) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PackCoalescedPacket", reflect.TypeOf((*MockPacker)(nil).PackCoalescedPacket)) } // PackConnectionClose mocks base method diff --git a/packet_packer.go b/packet_packer.go index acc57002..013b9372 100644 --- a/packet_packer.go +++ b/packet_packer.go @@ -17,7 +17,7 @@ import ( ) type packer interface { - PackCoalescedPacket(protocol.ByteCount) (*coalescedPacket, error) + PackCoalescedPacket() (*coalescedPacket, error) PackPacket() (*packedPacket, error) MaybePackProbePacket(protocol.EncryptionLevel) (*packedPacket, error) MaybePackAckPacket(handshakeConfirmed bool) (*packedPacket, error) @@ -331,9 +331,9 @@ func (p *packetPacker) maybePadPacket(firstPacket *packetContents, buffer *packe // PackCoalescedPacket packs a new packet. // 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. -func (p *packetPacker) PackCoalescedPacket(maxPacketSize protocol.ByteCount) (*coalescedPacket, error) { +func (p *packetPacker) PackCoalescedPacket() (*coalescedPacket, error) { buffer := getPacketBuffer() - packet, err := p.packCoalescedPacket(buffer, maxPacketSize) + packet, err := p.packCoalescedPacket(buffer) if err != nil { return nil, err } @@ -347,15 +347,11 @@ func (p *packetPacker) PackCoalescedPacket(maxPacketSize protocol.ByteCount) (*c return packet, nil } -func (p *packetPacker) packCoalescedPacket(buffer *packetBuffer, maxPacketSize protocol.ByteCount) (*coalescedPacket, error) { - maxPacketSize = utils.MinByteCount(maxPacketSize, p.maxPacketSize) +func (p *packetPacker) packCoalescedPacket(buffer *packetBuffer) (*coalescedPacket, error) { + maxPacketSize := p.maxPacketSize if p.perspective == protocol.PerspectiveClient { maxPacketSize = protocol.MinInitialPacketSize } - if maxPacketSize < protocol.MinCoalescedPacketSize { - return nil, nil - } - packet := &coalescedPacket{ buffer: buffer, packets: make([]*packetContents, 0, 3), diff --git a/packet_packer_test.go b/packet_packer_test.go index 31107f85..22e0e14e 100644 --- a/packet_packer_test.go +++ b/packet_packer_test.go @@ -180,7 +180,7 @@ var _ = Describe("Packet packer", func() { expectAppendControlFrames() f := &wire.StreamFrame{Data: []byte{0xde, 0xca, 0xfb, 0xad}} expectAppendStreamFrames(ackhandler.Frame{Frame: f}) - p, err := packer.PackCoalescedPacket(protocol.MaxByteCount) + p, err := packer.PackCoalescedPacket() Expect(err).ToNot(HaveOccurred()) Expect(p).ToNot(BeNil()) Expect(p.packets).To(HaveLen(1)) @@ -286,7 +286,7 @@ var _ = Describe("Packet packer", func() { framer.EXPECT().AppendStreamFrames(gomock.Any(), gomock.Any()).DoAndReturn(func(frames []ackhandler.Frame, _ protocol.ByteCount) ([]ackhandler.Frame, protocol.ByteCount) { return frames, 0 }) - p, err := packer.PackCoalescedPacket(protocol.MaxByteCount) + p, err := packer.PackCoalescedPacket() Expect(p).ToNot(BeNil()) Expect(err).ToNot(HaveOccurred()) Expect(p.packets).To(HaveLen(1)) @@ -553,7 +553,7 @@ var _ = Describe("Packet packer", func() { packer.retransmissionQueue.AddHandshake(&wire.PingFrame{}) handshakeStream.EXPECT().HasData() ackFramer.EXPECT().GetAckFrame(protocol.EncryptionHandshake, false) - packet, err := packer.PackCoalescedPacket(protocol.MaxByteCount) + packet, err := packer.PackCoalescedPacket() Expect(err).ToNot(HaveOccurred()) Expect(packet).ToNot(BeNil()) Expect(packet.packets).To(HaveLen(1)) @@ -812,7 +812,7 @@ var _ = Describe("Packet packer", func() { sealingManager.EXPECT().GetInitialSealer().Return(nil, handshake.ErrKeysDropped) sealingManager.EXPECT().GetHandshakeSealer().Return(getSealer(), nil) sealingManager.EXPECT().Get1RTTSealer().Return(nil, handshake.ErrKeysNotYetAvailable) - p, err := packer.PackCoalescedPacket(protocol.MaxByteCount) + p, err := packer.PackCoalescedPacket() Expect(err).ToNot(HaveOccurred()) Expect(p).ToNot(BeNil()) checkLength(p.buffer.Data) @@ -834,7 +834,7 @@ var _ = Describe("Packet packer", func() { Expect(f.Length(packer.version)).To(Equal(size)) return f }) - p, err := packer.PackCoalescedPacket(protocol.MaxByteCount) + p, err := packer.PackCoalescedPacket() Expect(err).ToNot(HaveOccurred()) Expect(p.packets).To(HaveLen(1)) Expect(p.packets[0].frames).To(HaveLen(1)) @@ -861,7 +861,7 @@ var _ = Describe("Packet packer", func() { handshakeStream.EXPECT().PopCryptoFrame(gomock.Any()).DoAndReturn(func(size protocol.ByteCount) *wire.CryptoFrame { return &wire.CryptoFrame{Offset: 0x1337, Data: []byte("handshake")} }) - p, err := packer.PackCoalescedPacket(protocol.MaxByteCount) + p, err := packer.PackCoalescedPacket() Expect(err).ToNot(HaveOccurred()) Expect(p.buffer.Len()).To(BeEquivalentTo(packer.maxPacketSize)) Expect(p.packets).To(HaveLen(2)) @@ -899,7 +899,7 @@ var _ = Describe("Packet packer", func() { }) expectAppendControlFrames() expectAppendStreamFrames(ackhandler.Frame{Frame: &wire.StreamFrame{Data: []byte("foobar")}}) - p, err := packer.PackCoalescedPacket(protocol.MaxByteCount) + p, err := packer.PackCoalescedPacket() Expect(err).ToNot(HaveOccurred()) Expect(p.buffer.Len()).To(BeNumerically(">=", protocol.MinInitialPacketSize)) Expect(p.buffer.Len()).To(BeEquivalentTo(maxPacketSize)) @@ -936,7 +936,7 @@ var _ = Describe("Packet packer", func() { }) expectAppendControlFrames() expectAppendStreamFrames(ackhandler.Frame{Frame: &wire.StreamFrame{Data: []byte("foobar")}}) - p, err := packer.PackCoalescedPacket(protocol.MaxByteCount) + p, err := packer.PackCoalescedPacket() Expect(err).ToNot(HaveOccurred()) Expect(p.packets).To(HaveLen(2)) Expect(p.packets[0].EncryptionLevel()).To(Equal(protocol.EncryptionHandshake)) @@ -969,7 +969,7 @@ var _ = Describe("Packet packer", func() { Expect(f.Length(packer.version)).To(Equal(s)) return f }) - p, err := packer.PackCoalescedPacket(protocol.MaxByteCount) + p, err := packer.PackCoalescedPacket() Expect(err).ToNot(HaveOccurred()) Expect(p.packets).To(HaveLen(1)) Expect(p.packets[0].EncryptionLevel()).To(Equal(protocol.EncryptionHandshake)) @@ -977,64 +977,6 @@ var _ = Describe("Packet packer", func() { checkLength(p.buffer.Data) }) - It("doesn't pack a coalesced packet if there's not enough space", func() { - p, err := packer.PackCoalescedPacket(protocol.MinCoalescedPacketSize - 1) - Expect(err).ToNot(HaveOccurred()) - Expect(p).To(BeNil()) - }) - - It("packs a small packet", func() { - const size = protocol.MinCoalescedPacketSize + 10 - pnManager.EXPECT().PeekPacketNumber(protocol.EncryptionHandshake).Return(protocol.PacketNumber(0x24), protocol.PacketNumberLen2) - pnManager.EXPECT().PopPacketNumber(protocol.EncryptionHandshake).Return(protocol.PacketNumber(0x24)) - sealingManager.EXPECT().GetInitialSealer().Return(nil, handshake.ErrKeysDropped) - sealingManager.EXPECT().GetHandshakeSealer().Return(getSealer(), nil) - // don't EXPECT any calls to Get1RTTSealer - ackFramer.EXPECT().GetAckFrame(protocol.EncryptionHandshake, false) - handshakeStream.EXPECT().HasData().Return(true).Times(2) - handshakeStream.EXPECT().PopCryptoFrame(gomock.Any()).DoAndReturn(func(s protocol.ByteCount) *wire.CryptoFrame { - f := &wire.CryptoFrame{Offset: 0x1337} - f.Data = bytes.Repeat([]byte{'f'}, int(s-f.Length(packer.version)-1)) - Expect(f.Length(packer.version)).To(Equal(s)) - return f - }) - p, err := packer.PackCoalescedPacket(size) - Expect(err).ToNot(HaveOccurred()) - Expect(p).ToNot(BeNil()) - Expect(len(p.buffer.Data)).To(Equal(size)) - }) - - It("packs a small packet, that includes a 1-RTT packet", func() { - const size = 2 * protocol.MinCoalescedPacketSize - pnManager.EXPECT().PeekPacketNumber(protocol.EncryptionHandshake).Return(protocol.PacketNumber(0x24), protocol.PacketNumberLen2) - pnManager.EXPECT().PopPacketNumber(protocol.EncryptionHandshake).Return(protocol.PacketNumber(0x24)) - pnManager.EXPECT().PeekPacketNumber(protocol.Encryption1RTT).Return(protocol.PacketNumber(0x24), protocol.PacketNumberLen2) - pnManager.EXPECT().PopPacketNumber(protocol.Encryption1RTT).Return(protocol.PacketNumber(0x24)) - sealingManager.EXPECT().GetInitialSealer().Return(nil, handshake.ErrKeysDropped) - sealingManager.EXPECT().GetHandshakeSealer().Return(getSealer(), nil) - oneRTTSealer := getSealer() - sealingManager.EXPECT().Get1RTTSealer().Return(oneRTTSealer, nil) - ackFramer.EXPECT().GetAckFrame(protocol.EncryptionHandshake, false) - framer.EXPECT().HasData().Return(true) - handshakeStream.EXPECT().HasData().Return(true).Times(2) - handshakeStream.EXPECT().PopCryptoFrame(gomock.Any()).Return(&wire.CryptoFrame{ - Offset: 0x1337, - Data: []byte("foobar"), - }) - expectAppendControlFrames() - var appDataSize protocol.ByteCount - framer.EXPECT().AppendStreamFrames(gomock.Any(), gomock.Any()).DoAndReturn(func(frames []ackhandler.Frame, maxSize protocol.ByteCount) ([]ackhandler.Frame, protocol.ByteCount) { - appDataSize = maxSize - f := &wire.StreamFrame{Data: []byte("foobar")} - return append(frames, ackhandler.Frame{Frame: f}), f.Length(packer.version) - }) - p, err := packer.PackCoalescedPacket(size) - Expect(err).ToNot(HaveOccurred()) - Expect(p).ToNot(BeNil()) - Expect(p.packets).To(HaveLen(2)) - Expect(appDataSize).To(Equal(size - p.packets[0].length - p.packets[1].header.GetLength(packer.version) - protocol.ByteCount(oneRTTSealer.Overhead()))) - }) - It("pads if payload length + packet number length is smaller than 4, for Long Header packets", func() { pnManager.EXPECT().PeekPacketNumber(protocol.EncryptionHandshake).Return(protocol.PacketNumber(0x42), protocol.PacketNumberLen1) pnManager.EXPECT().PopPacketNumber(protocol.EncryptionHandshake).Return(protocol.PacketNumber(0x42)) @@ -1045,7 +987,7 @@ var _ = Describe("Packet packer", func() { packer.retransmissionQueue.AddHandshake(&wire.PingFrame{}) handshakeStream.EXPECT().HasData() ackFramer.EXPECT().GetAckFrame(protocol.EncryptionHandshake, false) - packet, err := packer.PackCoalescedPacket(protocol.MaxByteCount) + packet, err := packer.PackCoalescedPacket() Expect(err).ToNot(HaveOccurred()) Expect(packet).ToNot(BeNil()) Expect(packet.packets).To(HaveLen(1)) @@ -1084,7 +1026,7 @@ var _ = Describe("Packet packer", func() { sealingManager.EXPECT().Get1RTTSealer().Return(nil, handshake.ErrKeysNotYetAvailable) ackFramer.EXPECT().GetAckFrame(protocol.EncryptionInitial, false) initialStream.EXPECT().HasData() - p, err := packer.PackCoalescedPacket(protocol.MaxByteCount) + p, err := packer.PackCoalescedPacket() Expect(err).ToNot(HaveOccurred()) Expect(p.packets).To(HaveLen(1)) Expect(p.packets[0].EncryptionLevel()).To(Equal(protocol.EncryptionInitial)) @@ -1101,7 +1043,7 @@ var _ = Describe("Packet packer", func() { sealingManager.EXPECT().Get1RTTSealer().Return(nil, handshake.ErrKeysNotYetAvailable) pnManager.EXPECT().PeekPacketNumber(protocol.EncryptionInitial).Return(protocol.PacketNumber(0x42), protocol.PacketNumberLen2) pnManager.EXPECT().PopPacketNumber(protocol.EncryptionInitial).Return(protocol.PacketNumber(0x42)) - p, err := packer.PackCoalescedPacket(protocol.MaxByteCount) + p, err := packer.PackCoalescedPacket() Expect(err).ToNot(HaveOccurred()) Expect(p.packets).To(HaveLen(1)) Expect(p.packets[0].ack).To(Equal(ack)) @@ -1113,7 +1055,7 @@ var _ = Describe("Packet packer", func() { sealingManager.EXPECT().Get1RTTSealer().Return(nil, handshake.ErrKeysNotYetAvailable) initialStream.EXPECT().HasData() ackFramer.EXPECT().GetAckFrame(protocol.EncryptionInitial, true) - p, err := packer.PackCoalescedPacket(protocol.MaxByteCount) + p, err := packer.PackCoalescedPacket() Expect(err).ToNot(HaveOccurred()) Expect(p).To(BeNil()) }) @@ -1129,7 +1071,7 @@ var _ = Describe("Packet packer", func() { sealingManager.EXPECT().Get1RTTSealer().Return(nil, handshake.ErrKeysNotYetAvailable) pnManager.EXPECT().PeekPacketNumber(protocol.EncryptionHandshake).Return(protocol.PacketNumber(0x42), protocol.PacketNumberLen2) pnManager.EXPECT().PopPacketNumber(protocol.EncryptionHandshake).Return(protocol.PacketNumber(0x42)) - p, err := packer.PackCoalescedPacket(protocol.MaxByteCount) + p, err := packer.PackCoalescedPacket() Expect(err).ToNot(HaveOccurred()) Expect(p.packets).To(HaveLen(1)) Expect(p.packets[0].ack).To(Equal(ack)) @@ -1152,7 +1094,7 @@ var _ = Describe("Packet packer", func() { initialStream.EXPECT().HasData().Return(true).Times(2) initialStream.EXPECT().PopCryptoFrame(gomock.Any()).Return(f) packer.perspective = protocol.PerspectiveClient - p, err := packer.PackCoalescedPacket(protocol.MaxByteCount) + p, err := packer.PackCoalescedPacket() Expect(err).ToNot(HaveOccurred()) Expect(p.buffer.Len()).To(BeNumerically(">=", protocol.MinInitialPacketSize)) Expect(p.buffer.Len()).To(BeEquivalentTo(maxPacketSize)) @@ -1178,7 +1120,7 @@ var _ = Describe("Packet packer", func() { initialStream.EXPECT().PopCryptoFrame(gomock.Any()).Return(f) packer.version = protocol.VersionTLS packer.perspective = protocol.PerspectiveClient - p, err := packer.PackCoalescedPacket(protocol.MaxByteCount) + p, err := packer.PackCoalescedPacket() Expect(err).ToNot(HaveOccurred()) Expect(p.packets).To(HaveLen(1)) Expect(p.packets[0].ack).To(Equal(ack)) diff --git a/session.go b/session.go index 2275c834..f8fb9f6e 100644 --- a/session.go +++ b/session.go @@ -1553,7 +1553,7 @@ func (s *session) sendPacket() (bool, error) { if !s.handshakeConfirmed { now := time.Now() - packet, err := s.packer.PackCoalescedPacket(s.sentPacketHandler.AmplificationWindow()) + packet, err := s.packer.PackCoalescedPacket() if err != nil || packet == nil { return false, err } diff --git a/session_test.go b/session_test.go index 81fdfee0..eaaf87f5 100644 --- a/session_test.go +++ b/session_test.go @@ -623,7 +623,6 @@ var _ = Describe("Session", func() { sph.EXPECT().GetLossDetectionTimeout().Return(time.Now().Add(time.Hour)).AnyTimes() sph.EXPECT().SendMode().Return(ackhandler.SendAny).AnyTimes() sph.EXPECT().HasPacingBudget().Return(true).AnyTimes() - sph.EXPECT().AmplificationWindow().Return(protocol.MaxByteCount).AnyTimes() // only expect a single SentPacket() call sph.EXPECT().SentPacket(gomock.Any()) tracer.EXPECT().SentPacket(gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any()) @@ -1547,12 +1546,10 @@ var _ = Describe("Session", func() { sess.handshakeComplete = false sess.handshakeConfirmed = false sph := mockackhandler.NewMockSentPacketHandler(mockCtrl) - const window protocol.ByteCount = 321 - sph.EXPECT().AmplificationWindow().Return(window).AnyTimes() sess.sentPacketHandler = sph buffer := getPacketBuffer() buffer.Data = append(buffer.Data, []byte("foobar")...) - packer.EXPECT().PackCoalescedPacket(window).Return(&coalescedPacket{ + packer.EXPECT().PackCoalescedPacket().Return(&coalescedPacket{ buffer: buffer, packets: []*packetContents{ { @@ -1577,7 +1574,7 @@ var _ = Describe("Session", func() { }, }, }, nil) - packer.EXPECT().PackCoalescedPacket(window).AnyTimes() + packer.EXPECT().PackCoalescedPacket().AnyTimes() sph.EXPECT().GetLossDetectionTimeout().AnyTimes() sph.EXPECT().SendMode().Return(ackhandler.SendAny).AnyTimes() @@ -1628,7 +1625,7 @@ var _ = Describe("Session", func() { }) It("cancels the HandshakeComplete context when the handshake completes", func() { - packer.EXPECT().PackCoalescedPacket(protocol.MaxByteCount).AnyTimes() + packer.EXPECT().PackCoalescedPacket().AnyTimes() finishHandshake := make(chan struct{}) sph := mockackhandler.NewMockSentPacketHandler(mockCtrl) sess.sentPacketHandler = sph @@ -1664,7 +1661,7 @@ var _ = Describe("Session", func() { It("sends a session ticket when the handshake completes", func() { const size = protocol.MaxPostHandshakeCryptoFrameSize * 3 / 2 - packer.EXPECT().PackCoalescedPacket(protocol.MaxByteCount).AnyTimes() + packer.EXPECT().PackCoalescedPacket().AnyTimes() finishHandshake := make(chan struct{}) sessionRunner.EXPECT().Retire(clientDestConnID) go func() { @@ -1708,7 +1705,7 @@ var _ = Describe("Session", func() { }) It("doesn't cancel the HandshakeComplete context when the handshake fails", func() { - packer.EXPECT().PackCoalescedPacket(protocol.MaxByteCount).AnyTimes() + packer.EXPECT().PackCoalescedPacket().AnyTimes() streamManager.EXPECT().CloseWithError(gomock.Any()) expectReplaceWithClosed() packer.EXPECT().PackConnectionClose(gomock.Any()).Return(&coalescedPacket{buffer: getPacketBuffer()}, nil) @@ -1828,7 +1825,7 @@ var _ = Describe("Session", func() { } streamManager.EXPECT().UpdateLimits(params) packer.EXPECT().HandleTransportParameters(params) - packer.EXPECT().PackCoalescedPacket(protocol.MaxByteCount).MaxTimes(3) + packer.EXPECT().PackCoalescedPacket().MaxTimes(3) Expect(sess.earlySessionReady()).ToNot(BeClosed()) sessionRunner.EXPECT().GetStatelessResetToken(gomock.Any()).Times(2) sessionRunner.EXPECT().Add(gomock.Any(), sess).Times(2) @@ -1880,7 +1877,7 @@ var _ = Describe("Session", func() { setRemoteIdleTimeout(5 * time.Second) sess.lastPacketReceivedTime = time.Now().Add(-5 * time.Second / 2) sent := make(chan struct{}) - packer.EXPECT().PackCoalescedPacket(protocol.MaxByteCount).Do(func(protocol.ByteCount) (*packedPacket, error) { + packer.EXPECT().PackCoalescedPacket().Do(func() (*packedPacket, error) { close(sent) return nil, nil }) @@ -1893,7 +1890,7 @@ var _ = Describe("Session", func() { setRemoteIdleTimeout(time.Hour) sess.lastPacketReceivedTime = time.Now().Add(-protocol.MaxKeepAliveInterval).Add(-time.Millisecond) sent := make(chan struct{}) - packer.EXPECT().PackCoalescedPacket(protocol.MaxByteCount).Do(func(protocol.ByteCount) (*packedPacket, error) { + packer.EXPECT().PackCoalescedPacket().Do(func() (*packedPacket, error) { close(sent) return nil, nil }) @@ -2011,7 +2008,7 @@ var _ = Describe("Session", func() { }) It("closes the session due to the idle timeout after handshake", func() { - packer.EXPECT().PackCoalescedPacket(protocol.MaxByteCount).AnyTimes() + packer.EXPECT().PackCoalescedPacket().AnyTimes() gomock.InOrder( sessionRunner.EXPECT().Retire(clientDestConnID), sessionRunner.EXPECT().Remove(gomock.Any()), @@ -2491,7 +2488,7 @@ var _ = Describe("Client Session", func() { }, } packer.EXPECT().HandleTransportParameters(gomock.Any()) - packer.EXPECT().PackCoalescedPacket(protocol.MaxByteCount).MaxTimes(1) + packer.EXPECT().PackCoalescedPacket().MaxTimes(1) tracer.EXPECT().ReceivedTransportParameters(params) sess.processTransportParameters(params) // make sure the connection ID is not retired