From 9f5bfbe2922c13f791d3c3fdd507ed1f2420f02c Mon Sep 17 00:00:00 2001 From: Marten Seemann Date: Fri, 28 Sep 2018 15:07:59 -0600 Subject: [PATCH] handle the transport parameters in the packet packer --- mock_packer_test.go | 31 +++++++++++-------------------- packet_packer.go | 14 ++++++-------- packet_packer_test.go | 16 ++++++++++++---- session.go | 7 +------ session_test.go | 3 +-- 5 files changed, 31 insertions(+), 40 deletions(-) diff --git a/mock_packer_test.go b/mock_packer_test.go index a9e49a00..10b4dad3 100644 --- a/mock_packer_test.go +++ b/mock_packer_test.go @@ -9,6 +9,7 @@ import ( gomock "github.com/golang/mock/gomock" ackhandler "github.com/lucas-clemente/quic-go/internal/ackhandler" + handshake "github.com/lucas-clemente/quic-go/internal/handshake" protocol "github.com/lucas-clemente/quic-go/internal/protocol" wire "github.com/lucas-clemente/quic-go/internal/wire" ) @@ -46,6 +47,16 @@ func (mr *MockPackerMockRecorder) ChangeDestConnectionID(arg0 interface{}) *gomo return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ChangeDestConnectionID", reflect.TypeOf((*MockPacker)(nil).ChangeDestConnectionID), arg0) } +// HandleTransportParameters mocks base method +func (m *MockPacker) HandleTransportParameters(arg0 *handshake.TransportParameters) { + m.ctrl.Call(m, "HandleTransportParameters", arg0) +} + +// HandleTransportParameters indicates an expected call of HandleTransportParameters +func (mr *MockPackerMockRecorder) HandleTransportParameters(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HandleTransportParameters", reflect.TypeOf((*MockPacker)(nil).HandleTransportParameters), arg0) +} + // MaybePackAckPacket mocks base method func (m *MockPacker) MaybePackAckPacket() (*packedPacket, error) { ret := m.ctrl.Call(m, "MaybePackAckPacket") @@ -107,23 +118,3 @@ func (m *MockPacker) QueueControlFrame(arg0 wire.Frame) { func (mr *MockPackerMockRecorder) QueueControlFrame(arg0 interface{}) *gomock.Call { return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueueControlFrame", reflect.TypeOf((*MockPacker)(nil).QueueControlFrame), arg0) } - -// SetMaxPacketSize mocks base method -func (m *MockPacker) SetMaxPacketSize(arg0 protocol.ByteCount) { - m.ctrl.Call(m, "SetMaxPacketSize", arg0) -} - -// SetMaxPacketSize indicates an expected call of SetMaxPacketSize -func (mr *MockPackerMockRecorder) SetMaxPacketSize(arg0 interface{}) *gomock.Call { - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetMaxPacketSize", reflect.TypeOf((*MockPacker)(nil).SetMaxPacketSize), arg0) -} - -// SetOmitConnectionID mocks base method -func (m *MockPacker) SetOmitConnectionID() { - m.ctrl.Call(m, "SetOmitConnectionID") -} - -// SetOmitConnectionID indicates an expected call of SetOmitConnectionID -func (mr *MockPackerMockRecorder) SetOmitConnectionID() *gomock.Call { - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetOmitConnectionID", reflect.TypeOf((*MockPacker)(nil).SetOmitConnectionID)) -} diff --git a/packet_packer.go b/packet_packer.go index 538bc3e0..938dfe6c 100644 --- a/packet_packer.go +++ b/packet_packer.go @@ -23,9 +23,8 @@ type packer interface { PackRetransmission(packet *ackhandler.Packet) ([]*packedPacket, error) PackConnectionClose(*wire.ConnectionCloseFrame) (*packedPacket, error) - SetOmitConnectionID() + HandleTransportParameters(*handshake.TransportParameters) ChangeDestConnectionID(protocol.ConnectionID) - SetMaxPacketSize(protocol.ByteCount) } type packedPacket struct { @@ -576,14 +575,13 @@ func (p *packetPacker) canSendData(encLevel protocol.EncryptionLevel) bool { return encLevel == protocol.EncryptionForwardSecure } -func (p *packetPacker) SetOmitConnectionID() { - p.omitConnectionID = true -} - func (p *packetPacker) ChangeDestConnectionID(connID protocol.ConnectionID) { p.destConnID = connID } -func (p *packetPacker) SetMaxPacketSize(size protocol.ByteCount) { - p.maxPacketSize = utils.MinByteCount(p.maxPacketSize, size) +func (p *packetPacker) HandleTransportParameters(params *handshake.TransportParameters) { + p.omitConnectionID = params.OmitConnectionID + if params.MaxPacketSize != 0 { + p.maxPacketSize = utils.MinByteCount(p.maxPacketSize, params.MaxPacketSize) + } } diff --git a/packet_packer_test.go b/packet_packer_test.go index df791775..63bc3b42 100644 --- a/packet_packer_test.go +++ b/packet_packer_test.go @@ -186,13 +186,17 @@ var _ = Describe("Packet packer", func() { packer.version = protocol.Version43 ph := packer.getHeader(protocol.EncryptionForwardSecure) Expect(ph.DestConnectionID.Len()).ToNot(BeZero()) - packer.SetOmitConnectionID() + packer.HandleTransportParameters(&handshake.TransportParameters{ + OmitConnectionID: true, + }) ph = packer.getHeader(protocol.EncryptionForwardSecure) Expect(ph.DestConnectionID.Len()).To(BeZero()) }) It("doesn't omit the connection ID for non-forward-secure packets", func() { - packer.SetOmitConnectionID() + packer.HandleTransportParameters(&handshake.TransportParameters{ + OmitConnectionID: true, + }) ph := packer.getHeader(protocol.EncryptionSecure) Expect(ph.DestConnectionID.Len()).ToNot(BeZero()) }) @@ -1053,7 +1057,9 @@ var _ = Describe("Packet packer", func() { Expect(err).ToNot(HaveOccurred()) Expect(p.raw).To(HaveLen(int(maxPacketSize))) // now reduce the maxPacketSize - packer.SetMaxPacketSize(maxPacketSize - 10) + packer.HandleTransportParameters(&handshake.TransportParameters{ + MaxPacketSize: maxPacketSize - 10, + }) p, err = packer.PackPacket() Expect(err).ToNot(HaveOccurred()) Expect(p.raw).To(HaveLen(int(maxPacketSize) - 10)) @@ -1072,7 +1078,9 @@ var _ = Describe("Packet packer", func() { Expect(err).ToNot(HaveOccurred()) Expect(p.raw).To(HaveLen(int(maxPacketSize))) // now try to increase the maxPacketSize - packer.SetMaxPacketSize(maxPacketSize + 10) + packer.HandleTransportParameters(&handshake.TransportParameters{ + MaxPacketSize: maxPacketSize + 10, + }) p, err = packer.PackPacket() Expect(err).ToNot(HaveOccurred()) Expect(p.raw).To(HaveLen(int(maxPacketSize))) diff --git a/session.go b/session.go index b6087cf2..f222b5bd 100644 --- a/session.go +++ b/session.go @@ -914,12 +914,7 @@ func (s *session) handleCloseError(closeErr closeError) error { func (s *session) processTransportParameters(params *handshake.TransportParameters) { s.peerParams = params s.streamsMap.UpdateLimits(params) - if params.OmitConnectionID { - s.packer.SetOmitConnectionID() - } - if params.MaxPacketSize != 0 { - s.packer.SetMaxPacketSize(params.MaxPacketSize) - } + s.packer.HandleTransportParameters(params) s.connFlowController.UpdateSendWindow(params.ConnectionFlowControlWindow) // the crypto stream is the only open stream at this moment // so we don't need to update stream flow control windows diff --git a/session_test.go b/session_test.go index fa6fb390..a5986529 100644 --- a/session_test.go +++ b/session_test.go @@ -1289,8 +1289,7 @@ var _ = Describe("Session", func() { MaxPacketSize: 0x42, } streamManager.EXPECT().UpdateLimits(¶ms) - packer.EXPECT().SetOmitConnectionID() - packer.EXPECT().SetMaxPacketSize(protocol.ByteCount(0x42)) + packer.EXPECT().HandleTransportParameters(¶ms) paramsChan <- params Eventually(func() *handshake.TransportParameters { return sess.peerParams }).Should(Equal(¶ms)) // make the go routine return