From ebc053dbe074b5b88c73069141eb9472dff2154f Mon Sep 17 00:00:00 2001 From: Marten Seemann Date: Thu, 8 Dec 2016 18:39:14 +0700 Subject: [PATCH] create interface for the ConnectionParametersManager --- benchmark_test.go | 6 +-- flowcontrol/flow_control_manager.go | 12 ++--- flowcontrol/flow_control_manager_test.go | 4 +- flowcontrol/flow_controller.go | 20 +++---- flowcontrol/flow_controller_test.go | 12 ++--- handshake/connection_parameters_manager.go | 52 ++++++++++++------- .../connection_parameters_manager_test.go | 4 +- handshake/crypto_setup.go | 26 +++++----- handshake/crypto_setup_test.go | 2 +- packet_packer.go | 18 +++---- packet_packer_test.go | 8 +-- session.go | 22 ++++---- session_test.go | 8 +-- streams_map.go | 6 +-- streams_map_test.go | 2 +- 15 files changed, 108 insertions(+), 94 deletions(-) diff --git a/benchmark_test.go b/benchmark_test.go index 622b6dc3..07cfa0a3 100644 --- a/benchmark_test.go +++ b/benchmark_test.go @@ -70,7 +70,7 @@ func setAEAD(cs *handshake.CryptoSetup, aead crypto.AEAD) { *(*crypto.AEAD)(unsafe.Pointer(reflect.ValueOf(cs).Elem().FieldByName("forwardSecureAEAD").UnsafeAddr())) = aead } -func setFlowControlParameters(mgr *handshake.ConnectionParametersManager) { +func setFlowControlParameters(mgr handshake.ConnectionParametersManager) { sfcw := make([]byte, 4) cfcw := make([]byte, 4) binary.LittleEndian.PutUint32(sfcw, uint32(protocol.ReceiveStreamFlowControlWindow)) @@ -121,8 +121,8 @@ var _ = Describe("Benchmarks", func() { setAEAD(session1.cryptoSetup, aead) setAEAD(session2.cryptoSetup, aead) - setFlowControlParameters(session1.connectionParametersManager) - setFlowControlParameters(session2.connectionParametersManager) + setFlowControlParameters(session1.connectionParameters) + setFlowControlParameters(session2.connectionParameters) go session1.run() go session2.run() diff --git a/flowcontrol/flow_control_manager.go b/flowcontrol/flow_control_manager.go index 0af52e9c..c69574bc 100644 --- a/flowcontrol/flow_control_manager.go +++ b/flowcontrol/flow_control_manager.go @@ -11,8 +11,8 @@ import ( ) type flowControlManager struct { - connectionParametersManager *handshake.ConnectionParametersManager - rttStats *congestion.RTTStats + connectionParameters handshake.ConnectionParametersManager + rttStats *congestion.RTTStats streamFlowController map[protocol.StreamID]*flowController contributesToConnectionFlowControl map[protocol.StreamID]bool @@ -29,15 +29,15 @@ var ( var errMapAccess = errors.New("Error accessing the flowController map.") // NewFlowControlManager creates a new flow control manager -func NewFlowControlManager(connectionParametersManager *handshake.ConnectionParametersManager, rttStats *congestion.RTTStats) FlowControlManager { +func NewFlowControlManager(connectionParameters handshake.ConnectionParametersManager, rttStats *congestion.RTTStats) FlowControlManager { fcm := flowControlManager{ - connectionParametersManager: connectionParametersManager, + connectionParameters: connectionParameters, rttStats: rttStats, streamFlowController: make(map[protocol.StreamID]*flowController), contributesToConnectionFlowControl: make(map[protocol.StreamID]bool), } // initialize connection level flow controller - fcm.streamFlowController[0] = newFlowController(0, connectionParametersManager, rttStats) + fcm.streamFlowController[0] = newFlowController(0, connectionParameters, rttStats) fcm.contributesToConnectionFlowControl[0] = false return &fcm } @@ -51,7 +51,7 @@ func (f *flowControlManager) NewStream(streamID protocol.StreamID, contributesTo return } - f.streamFlowController[streamID] = newFlowController(streamID, f.connectionParametersManager, f.rttStats) + f.streamFlowController[streamID] = newFlowController(streamID, f.connectionParameters, f.rttStats) f.contributesToConnectionFlowControl[streamID] = contributesToConnectionFlow } diff --git a/flowcontrol/flow_control_manager_test.go b/flowcontrol/flow_control_manager_test.go index 362e5849..d7b8739b 100644 --- a/flowcontrol/flow_control_manager_test.go +++ b/flowcontrol/flow_control_manager_test.go @@ -10,10 +10,10 @@ import ( var _ = Describe("Flow Control Manager", func() { var fcm *flowControlManager - var cpm *handshake.ConnectionParametersManager + var cpm handshake.ConnectionParametersManager BeforeEach(func() { - cpm = &handshake.ConnectionParametersManager{} + cpm = handshake.NewConnectionParamatersManager(protocol.VersionWhatever) setConnectionParametersManagerWindow(cpm, "receiveStreamFlowControlWindow", 0x100) setConnectionParametersManagerWindow(cpm, "receiveConnectionFlowControlWindow", 0x200) fcm = NewFlowControlManager(cpm, &congestion.RTTStats{}).(*flowControlManager) diff --git a/flowcontrol/flow_controller.go b/flowcontrol/flow_controller.go index ea937a89..76b57e43 100644 --- a/flowcontrol/flow_controller.go +++ b/flowcontrol/flow_controller.go @@ -12,8 +12,8 @@ import ( type flowController struct { streamID protocol.StreamID - connectionParametersManager *handshake.ConnectionParametersManager - rttStats *congestion.RTTStats + connectionParameters handshake.ConnectionParametersManager + rttStats *congestion.RTTStats bytesSent protocol.ByteCount sendFlowControlWindow protocol.ByteCount @@ -28,19 +28,19 @@ type flowController struct { } // newFlowController gets a new flow controller -func newFlowController(streamID protocol.StreamID, connectionParametersManager *handshake.ConnectionParametersManager, rttStats *congestion.RTTStats) *flowController { +func newFlowController(streamID protocol.StreamID, connectionParameters handshake.ConnectionParametersManager, rttStats *congestion.RTTStats) *flowController { fc := flowController{ - streamID: streamID, - connectionParametersManager: connectionParametersManager, - rttStats: rttStats, + streamID: streamID, + connectionParameters: connectionParameters, + rttStats: rttStats, } if streamID == 0 { - fc.receiveFlowControlWindow = connectionParametersManager.GetReceiveConnectionFlowControlWindow() + fc.receiveFlowControlWindow = connectionParameters.GetReceiveConnectionFlowControlWindow() fc.receiveFlowControlWindowIncrement = fc.receiveFlowControlWindow fc.maxReceiveFlowControlWindowIncrement = protocol.MaxReceiveConnectionFlowControlWindow } else { - fc.receiveFlowControlWindow = connectionParametersManager.GetReceiveStreamFlowControlWindow() + fc.receiveFlowControlWindow = connectionParameters.GetReceiveStreamFlowControlWindow() fc.receiveFlowControlWindowIncrement = fc.receiveFlowControlWindow fc.maxReceiveFlowControlWindowIncrement = protocol.MaxReceiveStreamFlowControlWindow } @@ -51,9 +51,9 @@ func newFlowController(streamID protocol.StreamID, connectionParametersManager * func (c *flowController) getSendFlowControlWindow() protocol.ByteCount { if c.sendFlowControlWindow == 0 { if c.streamID == 0 { - return c.connectionParametersManager.GetSendConnectionFlowControlWindow() + return c.connectionParameters.GetSendConnectionFlowControlWindow() } - return c.connectionParametersManager.GetSendStreamFlowControlWindow() + return c.connectionParameters.GetSendStreamFlowControlWindow() } return c.sendFlowControlWindow } diff --git a/flowcontrol/flow_controller_test.go b/flowcontrol/flow_controller_test.go index 9c1f8ac5..c4feb849 100644 --- a/flowcontrol/flow_controller_test.go +++ b/flowcontrol/flow_controller_test.go @@ -14,7 +14,7 @@ import ( // set private variables of the ConnectionParametersManager // those are normally read from the server parameter constants in the constructor of the ConnectionParametersManager -func setConnectionParametersManagerWindow(cpm *handshake.ConnectionParametersManager, name string, value protocol.ByteCount) { +func setConnectionParametersManagerWindow(cpm handshake.ConnectionParametersManager, name string, value protocol.ByteCount) { *(*protocol.ByteCount)(unsafe.Pointer(reflect.ValueOf(cpm).Elem().FieldByName(name).UnsafeAddr())) = value } @@ -27,11 +27,11 @@ var _ = Describe("Flow controller", func() { }) Context("Constructor", func() { - var cpm *handshake.ConnectionParametersManager + var cpm handshake.ConnectionParametersManager var rttStats *congestion.RTTStats BeforeEach(func() { - cpm = &handshake.ConnectionParametersManager{} + cpm = handshake.NewConnectionParamatersManager(protocol.VersionWhatever) rttStats = &congestion.RTTStats{} setConnectionParametersManagerWindow(cpm, "sendStreamFlowControlWindow", 1000) setConnectionParametersManagerWindow(cpm, "receiveStreamFlowControlWindow", 2000) @@ -65,13 +65,13 @@ var _ = Describe("Flow controller", func() { }) Context("send flow control", func() { - var cpm *handshake.ConnectionParametersManager + var cpm handshake.ConnectionParametersManager BeforeEach(func() { - cpm = &handshake.ConnectionParametersManager{} + cpm = handshake.NewConnectionParamatersManager(protocol.VersionWhatever) setConnectionParametersManagerWindow(cpm, "sendStreamFlowControlWindow", 1000) setConnectionParametersManagerWindow(cpm, "sendConnectionFlowControlWindow", 3000) - controller.connectionParametersManager = cpm + controller.connectionParameters = cpm }) It("adds bytes sent", func() { diff --git a/handshake/connection_parameters_manager.go b/handshake/connection_parameters_manager.go index 0bca069a..582680be 100644 --- a/handshake/connection_parameters_manager.go +++ b/handshake/connection_parameters_manager.go @@ -11,10 +11,22 @@ import ( "github.com/lucas-clemente/quic-go/utils" ) -// ConnectionParametersManager stores the connection parameters -// Warning: Writes may only be done from the crypto stream, see the comment -// in GetSHLOMap(). -type ConnectionParametersManager struct { +// ConnectionParametersManager negotiates and stores the connection parameters +type ConnectionParametersManager interface { + SetFromMap(map[Tag][]byte) error + GetSHLOMap() map[Tag][]byte + + GetSendStreamFlowControlWindow() protocol.ByteCount + GetSendConnectionFlowControlWindow() protocol.ByteCount + GetReceiveStreamFlowControlWindow() protocol.ByteCount + GetReceiveConnectionFlowControlWindow() protocol.ByteCount + GetMaxOutgoingStreams() uint32 + GetMaxIncomingStreams() uint32 + GetIdleConnectionStateLifetime() time.Duration + TruncateConnectionID() bool +} + +type connectionParametersManager struct { mutex sync.RWMutex version protocol.VersionNumber @@ -32,6 +44,8 @@ type ConnectionParametersManager struct { receiveConnectionFlowControlWindow protocol.ByteCount } +var _ ConnectionParametersManager = &connectionParametersManager{} + var errTagNotInConnectionParameterMap = errors.New("ConnectionParametersManager: Tag not found in ConnectionsParameter map") // ErrMalformedTag is returned when the tag value cannot be read @@ -41,8 +55,8 @@ var ( ) // NewConnectionParamatersManager creates a new connection parameters manager -func NewConnectionParamatersManager(v protocol.VersionNumber) *ConnectionParametersManager { - return &ConnectionParametersManager{ +func NewConnectionParamatersManager(v protocol.VersionNumber) ConnectionParametersManager { + return &connectionParametersManager{ version: v, idleConnectionStateLifetime: protocol.DefaultIdleTimeout, sendStreamFlowControlWindow: protocol.InitialStreamFlowControlWindow, // can only be changed by the client @@ -55,7 +69,7 @@ func NewConnectionParamatersManager(v protocol.VersionNumber) *ConnectionParamet } // SetFromMap reads all params -func (h *ConnectionParametersManager) SetFromMap(params map[Tag][]byte) error { +func (h *connectionParametersManager) SetFromMap(params map[Tag][]byte) error { h.mutex.Lock() defer h.mutex.Unlock() @@ -116,20 +130,20 @@ func (h *ConnectionParametersManager) SetFromMap(params map[Tag][]byte) error { return nil } -func (h *ConnectionParametersManager) negotiateMaxStreamsPerConnection(clientValue uint32) uint32 { +func (h *connectionParametersManager) negotiateMaxStreamsPerConnection(clientValue uint32) uint32 { return utils.MinUint32(clientValue, protocol.MaxStreamsPerConnection) } -func (h *ConnectionParametersManager) negotiateMaxIncomingDynamicStreamsPerConnection(clientValue uint32) uint32 { +func (h *connectionParametersManager) negotiateMaxIncomingDynamicStreamsPerConnection(clientValue uint32) uint32 { return utils.MinUint32(clientValue, protocol.MaxIncomingDynamicStreamsPerConnection) } -func (h *ConnectionParametersManager) negotiateIdleConnectionStateLifetime(clientValue time.Duration) time.Duration { +func (h *connectionParametersManager) negotiateIdleConnectionStateLifetime(clientValue time.Duration) time.Duration { return utils.MinDuration(clientValue, protocol.MaxIdleTimeout) } // GetSHLOMap gets all values (except crypto values) needed for the SHLO -func (h *ConnectionParametersManager) GetSHLOMap() map[Tag][]byte { +func (h *connectionParametersManager) GetSHLOMap() map[Tag][]byte { sfcw := bytes.NewBuffer([]byte{}) utils.WriteUint32(sfcw, uint32(h.GetReceiveStreamFlowControlWindow())) cfcw := bytes.NewBuffer([]byte{}) @@ -156,35 +170,35 @@ func (h *ConnectionParametersManager) GetSHLOMap() map[Tag][]byte { } // GetSendStreamFlowControlWindow gets the size of the stream-level flow control window for sending data -func (h *ConnectionParametersManager) GetSendStreamFlowControlWindow() protocol.ByteCount { +func (h *connectionParametersManager) GetSendStreamFlowControlWindow() protocol.ByteCount { h.mutex.RLock() defer h.mutex.RUnlock() return h.sendStreamFlowControlWindow } // GetSendConnectionFlowControlWindow gets the size of the stream-level flow control window for sending data -func (h *ConnectionParametersManager) GetSendConnectionFlowControlWindow() protocol.ByteCount { +func (h *connectionParametersManager) GetSendConnectionFlowControlWindow() protocol.ByteCount { h.mutex.RLock() defer h.mutex.RUnlock() return h.sendConnectionFlowControlWindow } // GetReceiveStreamFlowControlWindow gets the size of the stream-level flow control window for receiving data -func (h *ConnectionParametersManager) GetReceiveStreamFlowControlWindow() protocol.ByteCount { +func (h *connectionParametersManager) GetReceiveStreamFlowControlWindow() protocol.ByteCount { h.mutex.RLock() defer h.mutex.RUnlock() return h.receiveStreamFlowControlWindow } // GetReceiveConnectionFlowControlWindow gets the size of the stream-level flow control window for receiving data -func (h *ConnectionParametersManager) GetReceiveConnectionFlowControlWindow() protocol.ByteCount { +func (h *connectionParametersManager) GetReceiveConnectionFlowControlWindow() protocol.ByteCount { h.mutex.RLock() defer h.mutex.RUnlock() return h.receiveConnectionFlowControlWindow } // GetMaxOutgoingStreams gets the maximum number of outgoing streams per connection -func (h *ConnectionParametersManager) GetMaxOutgoingStreams() uint32 { +func (h *connectionParametersManager) GetMaxOutgoingStreams() uint32 { h.mutex.RLock() defer h.mutex.RUnlock() @@ -195,7 +209,7 @@ func (h *ConnectionParametersManager) GetMaxOutgoingStreams() uint32 { } // GetMaxIncomingStreams get the maximum number of incoming streams per connection -func (h *ConnectionParametersManager) GetMaxIncomingStreams() uint32 { +func (h *connectionParametersManager) GetMaxIncomingStreams() uint32 { h.mutex.RLock() defer h.mutex.RUnlock() @@ -210,14 +224,14 @@ func (h *ConnectionParametersManager) GetMaxIncomingStreams() uint32 { } // GetIdleConnectionStateLifetime gets the idle timeout -func (h *ConnectionParametersManager) GetIdleConnectionStateLifetime() time.Duration { +func (h *connectionParametersManager) GetIdleConnectionStateLifetime() time.Duration { h.mutex.RLock() defer h.mutex.RUnlock() return h.idleConnectionStateLifetime } // TruncateConnectionID determines if the client requests truncated ConnectionIDs -func (h *ConnectionParametersManager) TruncateConnectionID() bool { +func (h *connectionParametersManager) TruncateConnectionID() bool { h.mutex.RLock() defer h.mutex.RUnlock() return h.truncateConnectionID diff --git a/handshake/connection_parameters_manager_test.go b/handshake/connection_parameters_manager_test.go index 52544d60..8c94f956 100644 --- a/handshake/connection_parameters_manager_test.go +++ b/handshake/connection_parameters_manager_test.go @@ -9,9 +9,9 @@ import ( ) var _ = Describe("ConnectionsParameterManager", func() { - var cpm *ConnectionParametersManager + var cpm *connectionParametersManager BeforeEach(func() { - cpm = NewConnectionParamatersManager(protocol.Version36) + cpm = NewConnectionParamatersManager(protocol.Version36).(*connectionParametersManager) }) Context("SHLO", func() { diff --git a/handshake/crypto_setup.go b/handshake/crypto_setup.go index 56a62909..56b481e2 100644 --- a/handshake/crypto_setup.go +++ b/handshake/crypto_setup.go @@ -38,7 +38,7 @@ type CryptoSetup struct { cryptoStream utils.Stream - connectionParametersManager *ConnectionParametersManager + connectionParameters ConnectionParametersManager mutex sync.RWMutex } @@ -52,19 +52,19 @@ func NewCryptoSetup( version protocol.VersionNumber, scfg *ServerConfig, cryptoStream utils.Stream, - connectionParametersManager *ConnectionParametersManager, + connectionParameters ConnectionParametersManager, aeadChanged chan struct{}, ) (*CryptoSetup, error) { return &CryptoSetup{ - connID: connID, - ip: ip, - version: version, - scfg: scfg, - keyDerivation: crypto.DeriveKeysAESGCM, - keyExchange: getEphermalKEX, - cryptoStream: cryptoStream, - connectionParametersManager: connectionParametersManager, - aeadChanged: aeadChanged, + connID: connID, + ip: ip, + version: version, + scfg: scfg, + keyDerivation: crypto.DeriveKeysAESGCM, + keyExchange: getEphermalKEX, + cryptoStream: cryptoStream, + connectionParameters: connectionParameters, + aeadChanged: aeadChanged, }, nil } @@ -301,12 +301,12 @@ func (h *CryptoSetup) handleCHLO(sni string, data []byte, cryptoData map[Tag][]b return nil, err } - err = h.connectionParametersManager.SetFromMap(cryptoData) + err = h.connectionParameters.SetFromMap(cryptoData) if err != nil { return nil, err } - replyMap := h.connectionParametersManager.GetSHLOMap() + replyMap := h.connectionParameters.GetSHLOMap() // add crypto parameters replyMap[TagPUBS] = ephermalKex.PublicKey() replyMap[TagSNO] = serverNonce diff --git a/handshake/crypto_setup_test.go b/handshake/crypto_setup_test.go index 97c741ec..e6c2bd19 100644 --- a/handshake/crypto_setup_test.go +++ b/handshake/crypto_setup_test.go @@ -138,7 +138,7 @@ var _ = Describe("Crypto setup", func() { scfg *ServerConfig cs *CryptoSetup stream *mockStream - cpm *ConnectionParametersManager + cpm ConnectionParametersManager aeadChanged chan struct{} nonce32 []byte ip net.IP diff --git a/packet_packer.go b/packet_packer.go index e48080b9..dd9c3fa8 100644 --- a/packet_packer.go +++ b/packet_packer.go @@ -23,20 +23,20 @@ type packetPacker struct { packetNumberGenerator *packetNumberGenerator - connectionParametersManager *handshake.ConnectionParametersManager + connectionParameters handshake.ConnectionParametersManager streamFramer *streamFramer controlFrames []frames.Frame } -func newPacketPacker(connectionID protocol.ConnectionID, cryptoSetup *handshake.CryptoSetup, connectionParametersHandler *handshake.ConnectionParametersManager, streamFramer *streamFramer, version protocol.VersionNumber) *packetPacker { +func newPacketPacker(connectionID protocol.ConnectionID, cryptoSetup *handshake.CryptoSetup, connectionParameters handshake.ConnectionParametersManager, streamFramer *streamFramer, version protocol.VersionNumber) *packetPacker { return &packetPacker{ - cryptoSetup: cryptoSetup, - connectionID: connectionID, - connectionParametersManager: connectionParametersHandler, - version: version, - streamFramer: streamFramer, - packetNumberGenerator: newPacketNumberGenerator(protocol.SkipPacketAveragePeriodLength), + cryptoSetup: cryptoSetup, + connectionID: connectionID, + connectionParameters: connectionParameters, + version: version, + streamFramer: streamFramer, + packetNumberGenerator: newPacketNumberGenerator(protocol.SkipPacketAveragePeriodLength), } } @@ -65,7 +65,7 @@ func (p *packetPacker) packPacket(stopWaitingFrame *frames.StopWaitingFrame, con ConnectionID: p.connectionID, PacketNumber: currentPacketNumber, PacketNumberLen: packetNumberLen, - TruncateConnectionID: p.connectionParametersManager.TruncateConnectionID(), + TruncateConnectionID: p.connectionParameters.TruncateConnectionID(), DiversificationNonce: p.cryptoSetup.DiversificationNonce(), } diff --git a/packet_packer_test.go b/packet_packer_test.go index fefd2dd1..8001ca9b 100644 --- a/packet_packer_test.go +++ b/packet_packer_test.go @@ -27,10 +27,10 @@ var _ = Describe("Packet packer", func() { streamFramer = newStreamFramer(newStreamsMap(nil, cpm), fcm) packer = &packetPacker{ - cryptoSetup: &handshake.CryptoSetup{}, - connectionParametersManager: cpm, - packetNumberGenerator: newPacketNumberGenerator(protocol.SkipPacketAveragePeriodLength), - streamFramer: streamFramer, + cryptoSetup: &handshake.CryptoSetup{}, + connectionParameters: cpm, + packetNumberGenerator: newPacketNumberGenerator(protocol.SkipPacketAveragePeriodLength), + streamFramer: streamFramer, } publicHeaderLen = 1 + 8 + 2 // 1 flag byte, 8 connection ID, 2 packet number packer.version = protocol.Version34 diff --git a/session.go b/session.go index ed677d8d..a4b743fc 100644 --- a/session.go +++ b/session.go @@ -77,7 +77,7 @@ type Session struct { delayedAckOriginTime time.Time - connectionParametersManager *handshake.ConnectionParametersManager + connectionParameters handshake.ConnectionParametersManager lastRcvdPacketNumber protocol.PacketNumber // Used to calculate the next packet number from the truncated wire @@ -94,7 +94,7 @@ type Session struct { // newSession makes a new session func newSession(conn connection, v protocol.VersionNumber, connectionID protocol.ConnectionID, sCfg *handshake.ServerConfig, streamCallback StreamCallback, closeCallback closeCallback) (packetHandler, error) { - connectionParametersManager := handshake.NewConnectionParamatersManager(v) + connectionParameters := handshake.NewConnectionParamatersManager(v) var sentPacketHandler ackhandler.SentPacketHandler var receivedPacketHandler ackhandler.ReceivedPacketHandler @@ -103,7 +103,7 @@ func newSession(conn connection, v protocol.VersionNumber, connectionID protocol sentPacketHandler = ackhandler.NewSentPacketHandler(rttStats) receivedPacketHandler = ackhandler.NewReceivedPacketHandler() - flowControlManager := flowcontrol.NewFlowControlManager(connectionParametersManager, rttStats) + flowControlManager := flowcontrol.NewFlowControlManager(connectionParameters, rttStats) now := time.Now() session := &Session{ @@ -114,10 +114,10 @@ func newSession(conn connection, v protocol.VersionNumber, connectionID protocol streamCallback: streamCallback, closeCallback: closeCallback, - connectionParametersManager: connectionParametersManager, - sentPacketHandler: sentPacketHandler, - receivedPacketHandler: receivedPacketHandler, - flowControlManager: flowControlManager, + connectionParameters: connectionParameters, + sentPacketHandler: sentPacketHandler, + receivedPacketHandler: receivedPacketHandler, + flowControlManager: flowControlManager, receivedPackets: make(chan *receivedPacket, protocol.MaxSessionUnprocessedPackets), closeChan: make(chan *qerr.QuicError, 1), @@ -130,17 +130,17 @@ func newSession(conn connection, v protocol.VersionNumber, connectionID protocol sessionCreationTime: now, } - session.streamsMap = newStreamsMap(session.newStream, session.connectionParametersManager) + session.streamsMap = newStreamsMap(session.newStream, session.connectionParameters) cryptoStream, _ := session.GetOrOpenStream(1) var err error - session.cryptoSetup, err = handshake.NewCryptoSetup(connectionID, conn.RemoteAddr().IP, v, sCfg, cryptoStream, session.connectionParametersManager, session.aeadChanged) + session.cryptoSetup, err = handshake.NewCryptoSetup(connectionID, conn.RemoteAddr().IP, v, sCfg, cryptoStream, session.connectionParameters, session.aeadChanged) if err != nil { return nil, err } session.streamFramer = newStreamFramer(session.streamsMap, flowControlManager) - session.packer = newPacketPacker(connectionID, session.cryptoSetup, session.connectionParametersManager, session.streamFramer, v) + session.packer = newPacketPacker(connectionID, session.cryptoSetup, session.connectionParameters, session.streamFramer, v) session.unpacker = &packetUnpacker{aead: session.cryptoSetup, version: v} return session, err @@ -247,7 +247,7 @@ func (s *Session) maybeResetTimer() { func (s *Session) idleTimeout() time.Duration { if s.cryptoSetup.HandshakeComplete() { - return s.connectionParametersManager.GetIdleConnectionStateLifetime() + return s.connectionParameters.GetIdleConnectionStateLifetime() } return protocol.InitialIdleTimeout } diff --git a/session_test.go b/session_test.go index 4aa78a0b..1ee50d15 100644 --- a/session_test.go +++ b/session_test.go @@ -765,10 +765,10 @@ var _ = Describe("Session", func() { It("does not use ICSL before handshake", func(done Done) { session.lastNetworkActivityTime = time.Now().Add(-time.Minute) - session.connectionParametersManager.SetFromMap(map[handshake.Tag][]byte{ + session.connectionParameters.SetFromMap(map[handshake.Tag][]byte{ handshake.TagICSL: {0xff, 0xff, 0xff, 0xff}, }) - session.packer.connectionParametersManager = session.connectionParametersManager + session.packer.connectionParameters = session.connectionParameters session.run() // Would normally not return Expect(conn.written[0]).To(ContainSubstring("No recent network activity.")) close(done) @@ -778,10 +778,10 @@ var _ = Describe("Session", func() { // session.lastNetworkActivityTime = time.Now().Add(-time.Minute) *(*bool)(unsafe.Pointer(reflect.ValueOf(session.cryptoSetup).Elem().FieldByName("receivedForwardSecurePacket").UnsafeAddr())) = true *(*crypto.AEAD)(unsafe.Pointer(reflect.ValueOf(session.cryptoSetup).Elem().FieldByName("forwardSecureAEAD").UnsafeAddr())) = &crypto.NullAEAD{} - session.connectionParametersManager.SetFromMap(map[handshake.Tag][]byte{ + session.connectionParameters.SetFromMap(map[handshake.Tag][]byte{ handshake.TagICSL: {0, 0, 0, 0}, }) - session.packer.connectionParametersManager = session.connectionParametersManager + session.packer.connectionParameters = session.connectionParameters session.run() // Would normally not return Expect(conn.written[0]).To(ContainSubstring("No recent network activity.")) close(done) diff --git a/streams_map.go b/streams_map.go index 14f20837..5541b1a3 100644 --- a/streams_map.go +++ b/streams_map.go @@ -13,7 +13,7 @@ import ( type streamsMap struct { mutex sync.RWMutex - connectionParameters *handshake.ConnectionParametersManager + connectionParameters handshake.ConnectionParametersManager streams map[protocol.StreamID]*stream openStreams []protocol.StreamID @@ -35,12 +35,12 @@ var ( errMapAccess = errors.New("streamsMap: Error accessing the streams map") ) -func newStreamsMap(newStream newStreamLambda, cpm *handshake.ConnectionParametersManager) *streamsMap { +func newStreamsMap(newStream newStreamLambda, connectionParameters handshake.ConnectionParametersManager) *streamsMap { return &streamsMap{ streams: map[protocol.StreamID]*stream{}, openStreams: make([]protocol.StreamID, 0), newStream: newStream, - connectionParameters: cpm, + connectionParameters: connectionParameters, } } diff --git a/streams_map_test.go b/streams_map_test.go index 285201c2..333d5db2 100644 --- a/streams_map_test.go +++ b/streams_map_test.go @@ -12,7 +12,7 @@ import ( var _ = Describe("Streams Map", func() { var ( - cpm *handshake.ConnectionParametersManager + cpm handshake.ConnectionParametersManager m *streamsMap )