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

rename the ConnectionParametersManager to ParamsNegotiator

Browse source
This commit is contained in:
Marten Seemann 2017-09-25 19:50:26 +07:00
parent ebb4150e63
commit c95f2054a8
20 changed files with 393 additions and 396 deletions
Download patch file Download diff file Expand all files Collapse all files

10
internal/flowcontrol/flow_control_manager.go
View file

@ -13,7 +13,7 @@ import (
) )
type flowControlManager struct { type flowControlManager struct {
connectionParameters handshake.ConnectionParametersManager connParams handshake.ParamsNegotiator
rttStats *congestion.RTTStats rttStats *congestion.RTTStats
streamFlowController map[protocol.StreamID]*flowController streamFlowController map[protocol.StreamID]*flowController
@ -26,12 +26,12 @@ var _ FlowControlManager = &flowControlManager{}
var errMapAccess = errors.New("Error accessing the flowController map.") var errMapAccess = errors.New("Error accessing the flowController map.")
// NewFlowControlManager creates a new flow control manager // NewFlowControlManager creates a new flow control manager
func NewFlowControlManager(connectionParameters handshake.ConnectionParametersManager, rttStats *congestion.RTTStats) FlowControlManager { func NewFlowControlManager(connParams handshake.ParamsNegotiator, rttStats *congestion.RTTStats) FlowControlManager {
return &flowControlManager{ return &flowControlManager{
connectionParameters: connectionParameters, connParams: connParams,
rttStats: rttStats, rttStats: rttStats,
streamFlowController: make(map[protocol.StreamID]*flowController), streamFlowController: make(map[protocol.StreamID]*flowController),
connFlowController: newFlowController(0, false, connectionParameters, rttStats), connFlowController: newFlowController(0, false, connParams, rttStats),
} }
} }
@ -45,7 +45,7 @@ func (f *flowControlManager) NewStream(streamID protocol.StreamID, contributesTo
return return
} }
f.streamFlowController[streamID] = newFlowController(streamID, contributesToConnection, f.connectionParameters, f.rttStats) f.streamFlowController[streamID] = newFlowController(streamID, contributesToConnection, f.connParams, f.rttStats)
} }
// RemoveStream removes a closed stream from flow control // RemoveStream removes a closed stream from flow control

12
internal/flowcontrol/flow_control_manager_test.go
View file

@ -15,12 +15,12 @@ var _ = Describe("Flow Control Manager", func() {
var fcm *flowControlManager var fcm *flowControlManager
BeforeEach(func() { BeforeEach(func() {
mockCpm := mocks.NewMockConnectionParametersManager(mockCtrl) mockPn := mocks.NewMockParamsNegotiator(mockCtrl)
mockCpm.EXPECT().GetReceiveStreamFlowControlWindow().AnyTimes().Return(protocol.ByteCount(100)) mockPn.EXPECT().GetReceiveStreamFlowControlWindow().AnyTimes().Return(protocol.ByteCount(100))
mockCpm.EXPECT().GetReceiveConnectionFlowControlWindow().AnyTimes().Return(protocol.ByteCount(200)) mockPn.EXPECT().GetReceiveConnectionFlowControlWindow().AnyTimes().Return(protocol.ByteCount(200))
mockCpm.EXPECT().GetMaxReceiveStreamFlowControlWindow().AnyTimes().Return(protocol.MaxByteCount) mockPn.EXPECT().GetMaxReceiveStreamFlowControlWindow().AnyTimes().Return(protocol.MaxByteCount)
mockCpm.EXPECT().GetMaxReceiveConnectionFlowControlWindow().AnyTimes().Return(protocol.MaxByteCount) mockPn.EXPECT().GetMaxReceiveConnectionFlowControlWindow().AnyTimes().Return(protocol.MaxByteCount)
fcm = NewFlowControlManager(mockCpm, &congestion.RTTStats{}).(*flowControlManager) fcm = NewFlowControlManager(mockPn, &congestion.RTTStats{}).(*flowControlManager)
}) })
It("creates a connection level flow controller", func() { It("creates a connection level flow controller", func() {

18
internal/flowcontrol/flow_controller.go
View file

@ -14,7 +14,7 @@ type flowController struct {
streamID protocol.StreamID streamID protocol.StreamID
contributesToConnection bool // does the stream contribute to connection level flow control contributesToConnection bool // does the stream contribute to connection level flow control
connectionParameters handshake.ConnectionParametersManager connParams handshake.ParamsNegotiator
rttStats *congestion.RTTStats rttStats *congestion.RTTStats
bytesSent protocol.ByteCount bytesSent protocol.ByteCount
@ -33,22 +33,22 @@ type flowController struct {
var ErrReceivedSmallerByteOffset = errors.New("Received a smaller byte offset") var ErrReceivedSmallerByteOffset = errors.New("Received a smaller byte offset")
// newFlowController gets a new flow controller // newFlowController gets a new flow controller
func newFlowController(streamID protocol.StreamID, contributesToConnection bool, connectionParameters handshake.ConnectionParametersManager, rttStats *congestion.RTTStats) *flowController { func newFlowController(streamID protocol.StreamID, contributesToConnection bool, connParams handshake.ParamsNegotiator, rttStats *congestion.RTTStats) *flowController {
fc := flowController{ fc := flowController{
streamID: streamID, streamID: streamID,
contributesToConnection: contributesToConnection, contributesToConnection: contributesToConnection,
connectionParameters: connectionParameters, connParams: connParams,
rttStats: rttStats, rttStats: rttStats,
} }
if streamID == 0 { if streamID == 0 {
fc.receiveWindow = connectionParameters.GetReceiveConnectionFlowControlWindow() fc.receiveWindow = connParams.GetReceiveConnectionFlowControlWindow()
fc.receiveWindowIncrement = fc.receiveWindow fc.receiveWindowIncrement = fc.receiveWindow
fc.maxReceiveWindowIncrement = connectionParameters.GetMaxReceiveConnectionFlowControlWindow() fc.maxReceiveWindowIncrement = connParams.GetMaxReceiveConnectionFlowControlWindow()
} else { } else {
fc.receiveWindow = connectionParameters.GetReceiveStreamFlowControlWindow() fc.receiveWindow = connParams.GetReceiveStreamFlowControlWindow()
fc.receiveWindowIncrement = fc.receiveWindow fc.receiveWindowIncrement = fc.receiveWindow
fc.maxReceiveWindowIncrement = connectionParameters.GetMaxReceiveStreamFlowControlWindow() fc.maxReceiveWindowIncrement = connParams.GetMaxReceiveStreamFlowControlWindow()
} }
return &fc return &fc
@ -61,9 +61,9 @@ func (c *flowController) ContributesToConnection() bool {
func (c *flowController) getSendWindow() protocol.ByteCount { func (c *flowController) getSendWindow() protocol.ByteCount {
if c.sendWindow == 0 { if c.sendWindow == 0 {
if c.streamID == 0 { if c.streamID == 0 {
return c.connectionParameters.GetSendConnectionFlowControlWindow() return c.connParams.GetSendConnectionFlowControlWindow()
} }
return c.connectionParameters.GetSendStreamFlowControlWindow() return c.connParams.GetSendStreamFlowControlWindow()
} }
return c.sendWindow return c.sendWindow
} }

46
internal/flowcontrol/flow_controller_test.go
View file

@ -20,57 +20,57 @@ var _ = Describe("Flow controller", func() {
Context("Constructor", func() { Context("Constructor", func() {
var rttStats *congestion.RTTStats var rttStats *congestion.RTTStats
var mockCpm *mocks.MockConnectionParametersManager var mockPn *mocks.MockParamsNegotiator
BeforeEach(func() { BeforeEach(func() {
mockCpm = mocks.NewMockConnectionParametersManager(mockCtrl) mockPn = mocks.NewMockParamsNegotiator(mockCtrl)
mockCpm.EXPECT().GetSendStreamFlowControlWindow().AnyTimes().Return(protocol.ByteCount(1000)) mockPn.EXPECT().GetSendStreamFlowControlWindow().AnyTimes().Return(protocol.ByteCount(1000))
mockCpm.EXPECT().GetReceiveStreamFlowControlWindow().AnyTimes().Return(protocol.ByteCount(2000)) mockPn.EXPECT().GetReceiveStreamFlowControlWindow().AnyTimes().Return(protocol.ByteCount(2000))
mockCpm.EXPECT().GetSendConnectionFlowControlWindow().AnyTimes().Return(protocol.ByteCount(3000)) mockPn.EXPECT().GetSendConnectionFlowControlWindow().AnyTimes().Return(protocol.ByteCount(3000))
mockCpm.EXPECT().GetReceiveConnectionFlowControlWindow().AnyTimes().Return(protocol.ByteCount(4000)) mockPn.EXPECT().GetReceiveConnectionFlowControlWindow().AnyTimes().Return(protocol.ByteCount(4000))
mockCpm.EXPECT().GetMaxReceiveStreamFlowControlWindow().AnyTimes().Return(protocol.ByteCount(8000)) mockPn.EXPECT().GetMaxReceiveStreamFlowControlWindow().AnyTimes().Return(protocol.ByteCount(8000))
mockCpm.EXPECT().GetMaxReceiveConnectionFlowControlWindow().AnyTimes().Return(protocol.ByteCount(9000)) mockPn.EXPECT().GetMaxReceiveConnectionFlowControlWindow().AnyTimes().Return(protocol.ByteCount(9000))
rttStats = &congestion.RTTStats{} rttStats = &congestion.RTTStats{}
}) })
It("reads the stream send and receive windows when acting as stream-level flow controller", func() { It("reads the stream send and receive windows when acting as stream-level flow controller", func() {
fc := newFlowController(5, true, mockCpm, rttStats) fc := newFlowController(5, true, mockPn, rttStats)
Expect(fc.streamID).To(Equal(protocol.StreamID(5))) Expect(fc.streamID).To(Equal(protocol.StreamID(5)))
Expect(fc.receiveWindow).To(Equal(protocol.ByteCount(2000))) Expect(fc.receiveWindow).To(Equal(protocol.ByteCount(2000)))
Expect(fc.maxReceiveWindowIncrement).To(Equal(mockCpm.GetMaxReceiveStreamFlowControlWindow())) Expect(fc.maxReceiveWindowIncrement).To(Equal(mockPn.GetMaxReceiveStreamFlowControlWindow()))
}) })
It("reads the stream send and receive windows when acting as connection-level flow controller", func() { It("reads the stream send and receive windows when acting as connection-level flow controller", func() {
fc := newFlowController(0, false, mockCpm, rttStats) fc := newFlowController(0, false, mockPn, rttStats)
Expect(fc.streamID).To(Equal(protocol.StreamID(0))) Expect(fc.streamID).To(Equal(protocol.StreamID(0)))
Expect(fc.receiveWindow).To(Equal(protocol.ByteCount(4000))) Expect(fc.receiveWindow).To(Equal(protocol.ByteCount(4000)))
Expect(fc.maxReceiveWindowIncrement).To(Equal(mockCpm.GetMaxReceiveConnectionFlowControlWindow())) Expect(fc.maxReceiveWindowIncrement).To(Equal(mockPn.GetMaxReceiveConnectionFlowControlWindow()))
}) })
It("does not set the stream flow control windows for sending", func() { It("does not set the stream flow control windows for sending", func() {
fc := newFlowController(5, true, mockCpm, rttStats) fc := newFlowController(5, true, mockPn, rttStats)
Expect(fc.sendWindow).To(BeZero()) Expect(fc.sendWindow).To(BeZero())
}) })
It("does not set the connection flow control windows for sending", func() { It("does not set the connection flow control windows for sending", func() {
fc := newFlowController(0, false, mockCpm, rttStats) fc := newFlowController(0, false, mockPn, rttStats)
Expect(fc.sendWindow).To(BeZero()) Expect(fc.sendWindow).To(BeZero())
}) })
It("says if it contributes to connection-level flow control", func() { It("says if it contributes to connection-level flow control", func() {
fc := newFlowController(1, false, mockCpm, rttStats) fc := newFlowController(1, false, mockPn, rttStats)
Expect(fc.ContributesToConnection()).To(BeFalse()) Expect(fc.ContributesToConnection()).To(BeFalse())
fc = newFlowController(5, true, mockCpm, rttStats) fc = newFlowController(5, true, mockPn, rttStats)
Expect(fc.ContributesToConnection()).To(BeTrue()) Expect(fc.ContributesToConnection()).To(BeTrue())
}) })
}) })
Context("send flow control", func() { Context("send flow control", func() {
var mockCpm *mocks.MockConnectionParametersManager var mockPn *mocks.MockParamsNegotiator
BeforeEach(func() { BeforeEach(func() {
mockCpm = mocks.NewMockConnectionParametersManager(mockCtrl) mockPn = mocks.NewMockParamsNegotiator(mockCtrl)
controller.connectionParameters = mockCpm controller.connParams = mockPn
}) })
It("adds bytes sent", func() { It("adds bytes sent", func() {
@ -110,10 +110,10 @@ var _ = Describe("Flow controller", func() {
It("asks the ConnectionParametersManager for the stream flow control window size", func() { It("asks the ConnectionParametersManager for the stream flow control window size", func() {
controller.streamID = 5 controller.streamID = 5
mockCpm.EXPECT().GetSendStreamFlowControlWindow().Return(protocol.ByteCount(1000)) mockPn.EXPECT().GetSendStreamFlowControlWindow().Return(protocol.ByteCount(1000))
Expect(controller.getSendWindow()).To(Equal(protocol.ByteCount(1000))) Expect(controller.getSendWindow()).To(Equal(protocol.ByteCount(1000)))
// make sure the value is not cached // make sure the value is not cached
mockCpm.EXPECT().GetSendStreamFlowControlWindow().Return(protocol.ByteCount(2000)) mockPn.EXPECT().GetSendStreamFlowControlWindow().Return(protocol.ByteCount(2000))
Expect(controller.getSendWindow()).To(Equal(protocol.ByteCount(2000))) Expect(controller.getSendWindow()).To(Equal(protocol.ByteCount(2000)))
}) })
@ -125,10 +125,10 @@ var _ = Describe("Flow controller", func() {
It("asks the ConnectionParametersManager for the connection flow control window size", func() { It("asks the ConnectionParametersManager for the connection flow control window size", func() {
controller.streamID = 0 controller.streamID = 0
mockCpm.EXPECT().GetSendConnectionFlowControlWindow().Return(protocol.ByteCount(3000)) mockPn.EXPECT().GetSendConnectionFlowControlWindow().Return(protocol.ByteCount(3000))
Expect(controller.getSendWindow()).To(Equal(protocol.ByteCount(3000))) Expect(controller.getSendWindow()).To(Equal(protocol.ByteCount(3000)))
// make sure the value is not cached // make sure the value is not cached
mockCpm.EXPECT().GetSendConnectionFlowControlWindow().Return(protocol.ByteCount(5000)) mockPn.EXPECT().GetSendConnectionFlowControlWindow().Return(protocol.ByteCount(5000))
Expect(controller.getSendWindow()).To(Equal(protocol.ByteCount(5000))) Expect(controller.getSendWindow()).To(Equal(protocol.ByteCount(5000)))
}) })

14
internal/handshake/crypto_setup_client.go
View file

@ -52,7 +52,7 @@ type cryptoSetupClient struct {
aeadChanged chan<- protocol.EncryptionLevel aeadChanged chan<- protocol.EncryptionLevel
requestConnIDTruncation bool requestConnIDTruncation bool
connectionParameters *gquicConnectionParametersManager params *paramsNegotiatorGQUIC
} }
var _ CryptoSetup = &cryptoSetupClient{} var _ CryptoSetup = &cryptoSetupClient{}
@ -72,14 +72,14 @@ func NewCryptoSetupClient(
params *TransportParameters, params *TransportParameters,
aeadChanged chan<- protocol.EncryptionLevel, aeadChanged chan<- protocol.EncryptionLevel,
negotiatedVersions []protocol.VersionNumber, negotiatedVersions []protocol.VersionNumber,
) (CryptoSetup, ConnectionParametersManager, error) { ) (CryptoSetup, ParamsNegotiator, error) {
cpm := newGQUICConnectionParamatersManager(protocol.PerspectiveClient, version, params) pn := newParamsNegotiatorGQUIC(protocol.PerspectiveClient, version, params)
return &cryptoSetupClient{ return &cryptoSetupClient{
hostname: hostname, hostname: hostname,
connID: connID, connID: connID,
version: version, version: version,
certManager: crypto.NewCertManager(tlsConfig), certManager: crypto.NewCertManager(tlsConfig),
connectionParameters: cpm, params: pn,
requestConnIDTruncation: params.RequestConnectionIDTruncation, requestConnIDTruncation: params.RequestConnectionIDTruncation,
keyDerivation: crypto.DeriveQuicCryptoAESKeys, keyDerivation: crypto.DeriveQuicCryptoAESKeys,
keyExchange: getEphermalKEX, keyExchange: getEphermalKEX,
@ -87,7 +87,7 @@ func NewCryptoSetupClient(
aeadChanged: aeadChanged, aeadChanged: aeadChanged,
negotiatedVersions: negotiatedVersions, negotiatedVersions: negotiatedVersions,
divNonceChan: make(chan []byte), divNonceChan: make(chan []byte),
}, cpm, nil }, pn, nil
} }
func (h *cryptoSetupClient) HandleCryptoStream(stream io.ReadWriter) error { func (h *cryptoSetupClient) HandleCryptoStream(stream io.ReadWriter) error {
@ -264,7 +264,7 @@ func (h *cryptoSetupClient) handleSHLOMessage(cryptoData map[Tag][]byte) error {
return err return err
} }
err = h.connectionParameters.SetFromMap(cryptoData) err = h.params.SetFromMap(cryptoData)
if err != nil { if err != nil {
return qerr.InvalidCryptoMessageParameter return qerr.InvalidCryptoMessageParameter
} }
@ -405,7 +405,7 @@ func (h *cryptoSetupClient) sendCHLO() error {
} }
func (h *cryptoSetupClient) getTags() (map[Tag][]byte, error) { func (h *cryptoSetupClient) getTags() (map[Tag][]byte, error) {
tags, err := h.connectionParameters.GetHelloMap() tags, err := h.params.GetHelloMap()
if err != nil { if err != nil {
return nil, err return nil, err
} }

8
internal/handshake/crypto_setup_client_test.go
View file

@ -440,7 +440,7 @@ var _ = Describe("Client Crypto Setup", func() {
shloMap[TagICSL] = []byte{3, 0, 0, 0} // 3 seconds shloMap[TagICSL] = []byte{3, 0, 0, 0} // 3 seconds
err := cs.handleSHLOMessage(shloMap) err := cs.handleSHLOMessage(shloMap)
Expect(err).ToNot(HaveOccurred()) Expect(err).ToNot(HaveOccurred())
Expect(cs.connectionParameters.GetIdleConnectionStateLifetime()).To(Equal(3 * time.Second)) Expect(cs.params.GetIdleConnectionStateLifetime()).To(Equal(3 * time.Second))
}) })
It("errors if it can't read a connection parameter", func() { It("errors if it can't read a connection parameter", func() {
@ -499,12 +499,12 @@ var _ = Describe("Client Crypto Setup", func() {
}) })
It("adds the tags returned from the connectionParametersManager to the CHLO", func() { It("adds the tags returned from the connectionParametersManager to the CHLO", func() {
cpmTags, err := cs.connectionParameters.GetHelloMap() pnTags, err := cs.params.GetHelloMap()
Expect(err).ToNot(HaveOccurred()) Expect(err).ToNot(HaveOccurred())
Expect(cpmTags).ToNot(BeEmpty()) Expect(pnTags).ToNot(BeEmpty())
tags, err := cs.getTags() tags, err := cs.getTags()
Expect(err).ToNot(HaveOccurred()) Expect(err).ToNot(HaveOccurred())
for t := range cpmTags { for t := range pnTags {
Expect(tags).To(HaveKey(t)) Expect(tags).To(HaveKey(t))
} }
}) })

15
internal/handshake/crypto_setup_server.go
View file

@ -47,7 +47,7 @@ type cryptoSetupServer struct {
cryptoStream io.ReadWriter cryptoStream io.ReadWriter
connectionParameters *gquicConnectionParametersManager params *paramsNegotiatorGQUIC
mutex sync.RWMutex mutex sync.RWMutex
} }
@ -73,13 +73,13 @@ func NewCryptoSetup(
supportedVersions []protocol.VersionNumber, supportedVersions []protocol.VersionNumber,
acceptSTK func(net.Addr, *Cookie) bool, acceptSTK func(net.Addr, *Cookie) bool,
aeadChanged chan<- protocol.EncryptionLevel, aeadChanged chan<- protocol.EncryptionLevel,
) (CryptoSetup, ConnectionParametersManager, error) { ) (CryptoSetup, ParamsNegotiator, error) {
stkGenerator, err := NewCookieGenerator() stkGenerator, err := NewCookieGenerator()
if err != nil { if err != nil {
return nil, nil, err return nil, nil, err
} }
cpm := newGQUICConnectionParamatersManager(protocol.PerspectiveServer, version, params) pn := newParamsNegotiatorGQUIC(protocol.PerspectiveServer, version, params)
return &cryptoSetupServer{ return &cryptoSetupServer{
connID: connID, connID: connID,
remoteAddr: remoteAddr, remoteAddr: remoteAddr,
@ -90,11 +90,11 @@ func NewCryptoSetup(
keyDerivation: crypto.DeriveQuicCryptoAESKeys, keyDerivation: crypto.DeriveQuicCryptoAESKeys,
keyExchange: getEphermalKEX, keyExchange: getEphermalKEX,
nullAEAD: crypto.NewNullAEAD(protocol.PerspectiveServer, version), nullAEAD: crypto.NewNullAEAD(protocol.PerspectiveServer, version),
connectionParameters: cpm, params: pn,
acceptSTKCallback: acceptSTK, acceptSTKCallback: acceptSTK,
sentSHLO: make(chan struct{}), sentSHLO: make(chan struct{}),
aeadChanged: aeadChanged, aeadChanged: aeadChanged,
}, cpm, nil }, pn, nil
} }
// HandleCryptoStream reads and writes messages on the crypto stream // HandleCryptoStream reads and writes messages on the crypto stream
@ -418,12 +418,11 @@ func (h *cryptoSetupServer) handleCHLO(sni string, data []byte, cryptoData map[T
return nil, err return nil, err
} }
err = h.connectionParameters.SetFromMap(cryptoData) if err := h.params.SetFromMap(cryptoData); err != nil {
if err != nil {
return nil, err return nil, err
} }
replyMap, err := h.connectionParameters.GetHelloMap() replyMap, err := h.params.GetHelloMap()
if err != nil { if err != nil {
return nil, err return nil, err
} }

4
internal/handshake/crypto_setup_tls.go
View file

@ -40,7 +40,7 @@ func NewCryptoSetupTLS(
version protocol.VersionNumber, version protocol.VersionNumber,
tlsConfig *tls.Config, tlsConfig *tls.Config,
aeadChanged chan<- protocol.EncryptionLevel, aeadChanged chan<- protocol.EncryptionLevel,
) (CryptoSetup, ConnectionParametersManager, error) { ) (CryptoSetup, ParamsNegotiator, error) {
mintConf, err := tlsToMintConfig(tlsConfig, perspective) mintConf, err := tlsToMintConfig(tlsConfig, perspective)
if err != nil { if err != nil {
return nil, nil, err return nil, nil, err
@ -54,7 +54,7 @@ func NewCryptoSetupTLS(
nullAEAD: crypto.NewNullAEAD(perspective, version), nullAEAD: crypto.NewNullAEAD(perspective, version),
keyDerivation: crypto.DeriveAESKeys, keyDerivation: crypto.DeriveAESKeys,
aeadChanged: aeadChanged, aeadChanged: aeadChanged,
}, newGQUICConnectionParamatersManager(perspective, version, &TransportParameters{IdleTimeout: protocol.DefaultIdleTimeout}), nil }, newParamsNegotiatorGQUIC(perspective, version, &TransportParameters{IdleTimeout: protocol.DefaultIdleTimeout}), nil
} }
func (h *cryptoSetupTLS) HandleCryptoStream(cryptoStream io.ReadWriter) error { func (h *cryptoSetupTLS) HandleCryptoStream(cryptoStream io.ReadWriter) error {

36
internal/handshake/base_connection_parameters_manager.go → internal/handshake/params_negotiator_base.go
View file

@ -8,9 +8,9 @@ import (
"github.com/lucas-clemente/quic-go/internal/utils" "github.com/lucas-clemente/quic-go/internal/utils"
) )
// ConnectionParametersManager negotiates and stores the connection parameters. // The ParamsNegotiator negotiates and stores the connection parameters.
// A ConnectionParametersManager can be used for a server as well as a client. // It can be used for a server as well as a client.
type ConnectionParametersManager interface { type ParamsNegotiator interface {
GetSendStreamFlowControlWindow() protocol.ByteCount GetSendStreamFlowControlWindow() protocol.ByteCount
GetSendConnectionFlowControlWindow() protocol.ByteCount GetSendConnectionFlowControlWindow() protocol.ByteCount
GetReceiveStreamFlowControlWindow() protocol.ByteCount GetReceiveStreamFlowControlWindow() protocol.ByteCount
@ -31,7 +31,7 @@ type ConnectionParametersManager interface {
// For the client: // For the client:
// 1. call GetHelloMap to get the values to send in a CHLO // 1. call GetHelloMap to get the values to send in a CHLO
// 2. call SetFromMap with the values received in the SHLO // 2. call SetFromMap with the values received in the SHLO
type baseConnectionParametersManager struct { type paramsNegotiatorBase struct {
mutex sync.RWMutex mutex sync.RWMutex
version protocol.VersionNumber version protocol.VersionNumber
@ -51,7 +51,7 @@ type baseConnectionParametersManager struct {
maxReceiveConnectionFlowControlWindow protocol.ByteCount maxReceiveConnectionFlowControlWindow protocol.ByteCount
} }
func (h *baseConnectionParametersManager) init(params *TransportParameters) { func (h *paramsNegotiatorBase) init(params *TransportParameters) {
h.sendStreamFlowControlWindow = protocol.InitialStreamFlowControlWindow // can only be changed by the client h.sendStreamFlowControlWindow = protocol.InitialStreamFlowControlWindow // can only be changed by the client
h.sendConnectionFlowControlWindow = protocol.InitialConnectionFlowControlWindow // can only be changed by the client h.sendConnectionFlowControlWindow = protocol.InitialConnectionFlowControlWindow // can only be changed by the client
h.receiveStreamFlowControlWindow = protocol.ReceiveStreamFlowControlWindow h.receiveStreamFlowControlWindow = protocol.ReceiveStreamFlowControlWindow
@ -69,62 +69,62 @@ func (h *baseConnectionParametersManager) init(params *TransportParameters) {
} }
} }
func (h *baseConnectionParametersManager) negotiateMaxStreamsPerConnection(clientValue uint32) uint32 { func (h *paramsNegotiatorBase) negotiateMaxStreamsPerConnection(clientValue uint32) uint32 {
return utils.MinUint32(clientValue, protocol.MaxStreamsPerConnection) return utils.MinUint32(clientValue, protocol.MaxStreamsPerConnection)
} }
func (h *baseConnectionParametersManager) negotiateMaxIncomingDynamicStreamsPerConnection(clientValue uint32) uint32 { func (h *paramsNegotiatorBase) negotiateMaxIncomingDynamicStreamsPerConnection(clientValue uint32) uint32 {
return utils.MinUint32(clientValue, protocol.MaxIncomingDynamicStreamsPerConnection) return utils.MinUint32(clientValue, protocol.MaxIncomingDynamicStreamsPerConnection)
} }
func (h *baseConnectionParametersManager) negotiateIdleConnectionStateLifetime(clientValue time.Duration) time.Duration { func (h *paramsNegotiatorBase) negotiateIdleConnectionStateLifetime(clientValue time.Duration) time.Duration {
return utils.MinDuration(clientValue, h.idleConnectionStateLifetime) return utils.MinDuration(clientValue, h.idleConnectionStateLifetime)
} }
// GetSendStreamFlowControlWindow gets the size of the stream-level flow control window for sending data // GetSendStreamFlowControlWindow gets the size of the stream-level flow control window for sending data
func (h *baseConnectionParametersManager) GetSendStreamFlowControlWindow() protocol.ByteCount { func (h *paramsNegotiatorBase) GetSendStreamFlowControlWindow() protocol.ByteCount {
h.mutex.RLock() h.mutex.RLock()
defer h.mutex.RUnlock() defer h.mutex.RUnlock()
return h.sendStreamFlowControlWindow return h.sendStreamFlowControlWindow
} }
// GetSendConnectionFlowControlWindow gets the size of the stream-level flow control window for sending data // GetSendConnectionFlowControlWindow gets the size of the stream-level flow control window for sending data
func (h *baseConnectionParametersManager) GetSendConnectionFlowControlWindow() protocol.ByteCount { func (h *paramsNegotiatorBase) GetSendConnectionFlowControlWindow() protocol.ByteCount {
h.mutex.RLock() h.mutex.RLock()
defer h.mutex.RUnlock() defer h.mutex.RUnlock()
return h.sendConnectionFlowControlWindow return h.sendConnectionFlowControlWindow
} }
func (h *baseConnectionParametersManager) GetReceiveStreamFlowControlWindow() protocol.ByteCount { func (h *paramsNegotiatorBase) GetReceiveStreamFlowControlWindow() protocol.ByteCount {
h.mutex.RLock() h.mutex.RLock()
defer h.mutex.RUnlock() defer h.mutex.RUnlock()
return h.receiveStreamFlowControlWindow return h.receiveStreamFlowControlWindow
} }
// GetMaxReceiveStreamFlowControlWindow gets the maximum size of the stream-level flow control window for sending data // GetMaxReceiveStreamFlowControlWindow gets the maximum size of the stream-level flow control window for sending data
func (h *baseConnectionParametersManager) GetMaxReceiveStreamFlowControlWindow() protocol.ByteCount { func (h *paramsNegotiatorBase) GetMaxReceiveStreamFlowControlWindow() protocol.ByteCount {
return h.maxReceiveStreamFlowControlWindow return h.maxReceiveStreamFlowControlWindow
} }
// GetReceiveConnectionFlowControlWindow gets the size of the stream-level flow control window for receiving data // GetReceiveConnectionFlowControlWindow gets the size of the stream-level flow control window for receiving data
func (h *baseConnectionParametersManager) GetReceiveConnectionFlowControlWindow() protocol.ByteCount { func (h *paramsNegotiatorBase) GetReceiveConnectionFlowControlWindow() protocol.ByteCount {
h.mutex.RLock() h.mutex.RLock()
defer h.mutex.RUnlock() defer h.mutex.RUnlock()
return h.receiveConnectionFlowControlWindow return h.receiveConnectionFlowControlWindow
} }
func (h *baseConnectionParametersManager) GetMaxReceiveConnectionFlowControlWindow() protocol.ByteCount { func (h *paramsNegotiatorBase) GetMaxReceiveConnectionFlowControlWindow() protocol.ByteCount {
return h.maxReceiveConnectionFlowControlWindow return h.maxReceiveConnectionFlowControlWindow
} }
func (h *baseConnectionParametersManager) GetMaxOutgoingStreams() uint32 { func (h *paramsNegotiatorBase) GetMaxOutgoingStreams() uint32 {
h.mutex.RLock() h.mutex.RLock()
defer h.mutex.RUnlock() defer h.mutex.RUnlock()
return h.maxIncomingDynamicStreamsPerConnection return h.maxIncomingDynamicStreamsPerConnection
} }
func (h *baseConnectionParametersManager) GetMaxIncomingStreams() uint32 { func (h *paramsNegotiatorBase) GetMaxIncomingStreams() uint32 {
h.mutex.RLock() h.mutex.RLock()
defer h.mutex.RUnlock() defer h.mutex.RUnlock()
@ -132,13 +132,13 @@ func (h *baseConnectionParametersManager) GetMaxIncomingStreams() uint32 {
return utils.MaxUint32(uint32(maxStreams)+protocol.MaxStreamsMinimumIncrement, uint32(float64(maxStreams)*protocol.MaxStreamsMultiplier)) return utils.MaxUint32(uint32(maxStreams)+protocol.MaxStreamsMinimumIncrement, uint32(float64(maxStreams)*protocol.MaxStreamsMultiplier))
} }
func (h *baseConnectionParametersManager) GetIdleConnectionStateLifetime() time.Duration { func (h *paramsNegotiatorBase) GetIdleConnectionStateLifetime() time.Duration {
h.mutex.RLock() h.mutex.RLock()
defer h.mutex.RUnlock() defer h.mutex.RUnlock()
return h.idleConnectionStateLifetime return h.idleConnectionStateLifetime
} }
func (h *baseConnectionParametersManager) TruncateConnectionID() bool { func (h *paramsNegotiatorBase) TruncateConnectionID() bool {
if h.perspective == protocol.PerspectiveClient { if h.perspective == protocol.PerspectiveClient {
return false return false
} }

18
internal/handshake/gquic_connection_parameters_manager.go → internal/handshake/params_negotiator_gquic.go
View file

@ -9,21 +9,21 @@ import (
"github.com/lucas-clemente/quic-go/qerr" "github.com/lucas-clemente/quic-go/qerr"
) )
var _ ConnectionParametersManager = &baseConnectionParametersManager{}
// errMalformedTag is returned when the tag value cannot be read // errMalformedTag is returned when the tag value cannot be read
var ( var (
errMalformedTag = qerr.Error(qerr.InvalidCryptoMessageParameter, "malformed Tag value") errMalformedTag = qerr.Error(qerr.InvalidCryptoMessageParameter, "malformed Tag value")
errFlowControlRenegotiationNotSupported = qerr.Error(qerr.InvalidCryptoMessageParameter, "renegotiation of flow control parameters not supported") errFlowControlRenegotiationNotSupported = qerr.Error(qerr.InvalidCryptoMessageParameter, "renegotiation of flow control parameters not supported")
) )
type gquicConnectionParametersManager struct { type paramsNegotiatorGQUIC struct {
baseConnectionParametersManager paramsNegotiatorBase
} }
// newConnectionParamatersManager creates a new connection parameters manager var _ ParamsNegotiator = &paramsNegotiatorGQUIC{}
func newGQUICConnectionParamatersManager(pers protocol.Perspective, v protocol.VersionNumber, params *TransportParameters) *gquicConnectionParametersManager {
h := &gquicConnectionParametersManager{} // newParamsNegotiatorGQUIC creates a new connection parameters manager
func newParamsNegotiatorGQUIC(pers protocol.Perspective, v protocol.VersionNumber, params *TransportParameters) *paramsNegotiatorGQUIC {
h := &paramsNegotiatorGQUIC{}
h.perspective = pers h.perspective = pers
h.version = v h.version = v
h.init(params) h.init(params)
@ -31,7 +31,7 @@ func newGQUICConnectionParamatersManager(pers protocol.Perspective, v protocol.V
} }
// SetFromMap reads all params. // SetFromMap reads all params.
func (h *gquicConnectionParametersManager) SetFromMap(params map[Tag][]byte) error { func (h *paramsNegotiatorGQUIC) SetFromMap(params map[Tag][]byte) error {
h.mutex.Lock() h.mutex.Lock()
defer h.mutex.Unlock() defer h.mutex.Unlock()
@ -94,7 +94,7 @@ func (h *gquicConnectionParametersManager) SetFromMap(params map[Tag][]byte) err
} }
// GetHelloMap gets all parameters needed for the Hello message. // GetHelloMap gets all parameters needed for the Hello message.
func (h *gquicConnectionParametersManager) GetHelloMap() (map[Tag][]byte, error) { func (h *paramsNegotiatorGQUIC) GetHelloMap() (map[Tag][]byte, error) {
sfcw := bytes.NewBuffer([]byte{}) sfcw := bytes.NewBuffer([]byte{})
utils.LittleEndian.WriteUint32(sfcw, uint32(h.GetReceiveStreamFlowControlWindow())) utils.LittleEndian.WriteUint32(sfcw, uint32(h.GetReceiveStreamFlowControlWindow()))
cfcw := bytes.NewBuffer([]byte{}) cfcw := bytes.NewBuffer([]byte{})

134
internal/handshake/gquic_connection_parameters_manager_test.go → internal/handshake/params_negotiator_gquic_test.go
View file

@ -10,9 +10,9 @@ import (
. "github.com/onsi/gomega" . "github.com/onsi/gomega"
) )
var _ = Describe("ConnectionsParameterManager", func() { var _ = Describe("Params Negotiator (for gQUIC)", func() {
var cpm *gquicConnectionParametersManager // a connectionParametersManager for a server var pn *paramsNegotiatorGQUIC // a connectionParametersManager for a server
var cpmClient *gquicConnectionParametersManager var pnClient *paramsNegotiatorGQUIC
const MB = 1 << 20 const MB = 1 << 20
maxReceiveStreamFlowControlWindowServer := protocol.ByteCount(math.Floor(1.1 * MB)) // default is 1 MB maxReceiveStreamFlowControlWindowServer := protocol.ByteCount(math.Floor(1.1 * MB)) // default is 1 MB
maxReceiveConnectionFlowControlWindowServer := protocol.ByteCount(math.Floor(1.5 * MB)) // default is 1.5 MB maxReceiveConnectionFlowControlWindowServer := protocol.ByteCount(math.Floor(1.5 * MB)) // default is 1.5 MB
@ -20,7 +20,7 @@ var _ = Describe("ConnectionsParameterManager", func() {
maxReceiveConnectionFlowControlWindowClient := protocol.ByteCount(math.Floor(13 * MB)) // default is 15 MB maxReceiveConnectionFlowControlWindowClient := protocol.ByteCount(math.Floor(13 * MB)) // default is 15 MB
idleTimeout := 42 * time.Second idleTimeout := 42 * time.Second
BeforeEach(func() { BeforeEach(func() {
cpm = newGQUICConnectionParamatersManager( pn = newParamsNegotiatorGQUIC(
protocol.PerspectiveServer, protocol.PerspectiveServer,
protocol.VersionWhatever, protocol.VersionWhatever,
&TransportParameters{ &TransportParameters{
@ -29,7 +29,7 @@ var _ = Describe("ConnectionsParameterManager", func() {
IdleTimeout: idleTimeout, IdleTimeout: idleTimeout,
}, },
) )
cpmClient = newGQUICConnectionParamatersManager( pnClient = newParamsNegotiatorGQUIC(
protocol.PerspectiveClient, protocol.PerspectiveClient,
protocol.VersionWhatever, protocol.VersionWhatever,
&TransportParameters{ &TransportParameters{
@ -43,11 +43,11 @@ var _ = Describe("ConnectionsParameterManager", func() {
Context("SHLO", func() { Context("SHLO", func() {
BeforeEach(func() { BeforeEach(func() {
// these tests should only use the server connectionParametersManager. Make them panic if they don't // these tests should only use the server connectionParametersManager. Make them panic if they don't
cpmClient = nil pnClient = nil
}) })
It("returns all parameters necessary for the SHLO", func() { It("returns all parameters necessary for the SHLO", func() {
entryMap, err := cpm.GetHelloMap() entryMap, err := pn.GetHelloMap()
Expect(err).ToNot(HaveOccurred()) Expect(err).ToNot(HaveOccurred())
Expect(entryMap).To(HaveKey(TagICSL)) Expect(entryMap).To(HaveKey(TagICSL))
Expect(entryMap).To(HaveKey(TagMSPC)) Expect(entryMap).To(HaveKey(TagMSPC))
@ -55,24 +55,24 @@ var _ = Describe("ConnectionsParameterManager", func() {
}) })
It("sets the stream-level flow control windows in SHLO", func() { It("sets the stream-level flow control windows in SHLO", func() {
cpm.receiveStreamFlowControlWindow = 0xDEADBEEF pn.receiveStreamFlowControlWindow = 0xDEADBEEF
entryMap, err := cpm.GetHelloMap() entryMap, err := pn.GetHelloMap()
Expect(err).ToNot(HaveOccurred()) Expect(err).ToNot(HaveOccurred())
Expect(entryMap).To(HaveKey(TagSFCW)) Expect(entryMap).To(HaveKey(TagSFCW))
Expect(entryMap[TagSFCW]).To(Equal([]byte{0xEF, 0xBE, 0xAD, 0xDE})) Expect(entryMap[TagSFCW]).To(Equal([]byte{0xEF, 0xBE, 0xAD, 0xDE}))
}) })
It("sets the connection-level flow control windows in SHLO", func() { It("sets the connection-level flow control windows in SHLO", func() {
cpm.receiveConnectionFlowControlWindow = 0xDECAFBAD pn.receiveConnectionFlowControlWindow = 0xDECAFBAD
entryMap, err := cpm.GetHelloMap() entryMap, err := pn.GetHelloMap()
Expect(err).ToNot(HaveOccurred()) Expect(err).ToNot(HaveOccurred())
Expect(entryMap).To(HaveKey(TagCFCW)) Expect(entryMap).To(HaveKey(TagCFCW))
Expect(entryMap[TagCFCW]).To(Equal([]byte{0xAD, 0xFB, 0xCA, 0xDE})) Expect(entryMap[TagCFCW]).To(Equal([]byte{0xAD, 0xFB, 0xCA, 0xDE}))
}) })
It("sets the connection-level flow control windows in SHLO", func() { It("sets the connection-level flow control windows in SHLO", func() {
cpm.idleConnectionStateLifetime = 0xDECAFBAD * time.Second pn.idleConnectionStateLifetime = 0xDECAFBAD * time.Second
entryMap, err := cpm.GetHelloMap() entryMap, err := pn.GetHelloMap()
Expect(err).ToNot(HaveOccurred()) Expect(err).ToNot(HaveOccurred())
Expect(entryMap).To(HaveKey(TagICSL)) Expect(entryMap).To(HaveKey(TagICSL))
Expect(entryMap[TagICSL]).To(Equal([]byte{0xAD, 0xFB, 0xCA, 0xDE})) Expect(entryMap[TagICSL]).To(Equal([]byte{0xAD, 0xFB, 0xCA, 0xDE}))
@ -81,17 +81,17 @@ var _ = Describe("ConnectionsParameterManager", func() {
It("sets the negotiated value for maximum streams in the SHLO", func() { It("sets the negotiated value for maximum streams in the SHLO", func() {
val := 50 val := 50
Expect(val).To(BeNumerically("<", protocol.MaxStreamsPerConnection)) Expect(val).To(BeNumerically("<", protocol.MaxStreamsPerConnection))
err := cpm.SetFromMap(map[Tag][]byte{TagMSPC: []byte{byte(val), 0, 0, 0}}) err := pn.SetFromMap(map[Tag][]byte{TagMSPC: []byte{byte(val), 0, 0, 0}})
Expect(err).ToNot(HaveOccurred()) Expect(err).ToNot(HaveOccurred())
entryMap, err := cpm.GetHelloMap() entryMap, err := pn.GetHelloMap()
Expect(err).ToNot(HaveOccurred()) Expect(err).ToNot(HaveOccurred())
Expect(entryMap[TagMSPC]).To(Equal([]byte{byte(val), 0, 0, 0})) Expect(entryMap[TagMSPC]).To(Equal([]byte{byte(val), 0, 0, 0}))
}) })
It("always sends its own value for the maximum incoming dynamic streams in the SHLO", func() { It("always sends its own value for the maximum incoming dynamic streams in the SHLO", func() {
err := cpm.SetFromMap(map[Tag][]byte{TagMIDS: []byte{5, 0, 0, 0}}) err := pn.SetFromMap(map[Tag][]byte{TagMIDS: []byte{5, 0, 0, 0}})
Expect(err).ToNot(HaveOccurred()) Expect(err).ToNot(HaveOccurred())
entryMap, err := cpm.GetHelloMap() entryMap, err := pn.GetHelloMap()
Expect(err).ToNot(HaveOccurred()) Expect(err).ToNot(HaveOccurred())
Expect(entryMap[TagMIDS]).To(Equal([]byte{byte(protocol.MaxIncomingDynamicStreamsPerConnection), 0, 0, 0})) Expect(entryMap[TagMIDS]).To(Equal([]byte{byte(protocol.MaxIncomingDynamicStreamsPerConnection), 0, 0, 0}))
}) })
@ -100,11 +100,11 @@ var _ = Describe("ConnectionsParameterManager", func() {
Context("CHLO", func() { Context("CHLO", func() {
BeforeEach(func() { BeforeEach(func() {
// these tests should only use the client connectionParametersManager. Make them panic if they don't // these tests should only use the client connectionParametersManager. Make them panic if they don't
cpm = nil pn = nil
}) })
It("has the right values", func() { It("has the right values", func() {
entryMap, err := cpmClient.GetHelloMap() entryMap, err := pnClient.GetHelloMap()
Expect(err).ToNot(HaveOccurred()) Expect(err).ToNot(HaveOccurred())
Expect(entryMap).To(HaveKey(TagICSL)) Expect(entryMap).To(HaveKey(TagICSL))
Expect(binary.LittleEndian.Uint32(entryMap[TagICSL])).To(BeEquivalentTo(idleTimeout / time.Second)) Expect(binary.LittleEndian.Uint32(entryMap[TagICSL])).To(BeEquivalentTo(idleTimeout / time.Second))
@ -121,76 +121,76 @@ var _ = Describe("ConnectionsParameterManager", func() {
Context("Truncated connection IDs", func() { Context("Truncated connection IDs", func() {
It("does not send truncated connection IDs if the TCID tag is missing", func() { It("does not send truncated connection IDs if the TCID tag is missing", func() {
Expect(cpm.TruncateConnectionID()).To(BeFalse()) Expect(pn.TruncateConnectionID()).To(BeFalse())
}) })
It("reads the tag for truncated connection IDs", func() { It("reads the tag for truncated connection IDs", func() {
values := map[Tag][]byte{TagTCID: {0, 0, 0, 0}} values := map[Tag][]byte{TagTCID: {0, 0, 0, 0}}
cpm.SetFromMap(values) pn.SetFromMap(values)
Expect(cpm.TruncateConnectionID()).To(BeTrue()) Expect(pn.TruncateConnectionID()).To(BeTrue())
}) })
It("ignores the TCID tag, as a client", func() { It("ignores the TCID tag, as a client", func() {
values := map[Tag][]byte{TagTCID: {0, 0, 0, 0}} values := map[Tag][]byte{TagTCID: {0, 0, 0, 0}}
cpmClient.SetFromMap(values) pnClient.SetFromMap(values)
Expect(cpmClient.TruncateConnectionID()).To(BeFalse()) Expect(pnClient.TruncateConnectionID()).To(BeFalse())
}) })
It("errors when given an invalid value", func() { It("errors when given an invalid value", func() {
values := map[Tag][]byte{TagTCID: {2, 0, 0}} // 1 byte too short values := map[Tag][]byte{TagTCID: {2, 0, 0}} // 1 byte too short
err := cpm.SetFromMap(values) err := pn.SetFromMap(values)
Expect(err).To(MatchError(errMalformedTag)) Expect(err).To(MatchError(errMalformedTag))
}) })
}) })
Context("flow control", func() { Context("flow control", func() {
It("has the correct default flow control windows for sending", func() { It("has the correct default flow control windows for sending", func() {
Expect(cpm.GetSendStreamFlowControlWindow()).To(Equal(protocol.InitialStreamFlowControlWindow)) Expect(pn.GetSendStreamFlowControlWindow()).To(Equal(protocol.InitialStreamFlowControlWindow))
Expect(cpm.GetSendConnectionFlowControlWindow()).To(Equal(protocol.InitialConnectionFlowControlWindow)) Expect(pn.GetSendConnectionFlowControlWindow()).To(Equal(protocol.InitialConnectionFlowControlWindow))
Expect(cpmClient.GetSendStreamFlowControlWindow()).To(Equal(protocol.InitialStreamFlowControlWindow)) Expect(pnClient.GetSendStreamFlowControlWindow()).To(Equal(protocol.InitialStreamFlowControlWindow))
Expect(cpmClient.GetSendConnectionFlowControlWindow()).To(Equal(protocol.InitialConnectionFlowControlWindow)) Expect(pnClient.GetSendConnectionFlowControlWindow()).To(Equal(protocol.InitialConnectionFlowControlWindow))
}) })
It("has the correct default flow control windows for receiving", func() { It("has the correct default flow control windows for receiving", func() {
Expect(cpm.GetReceiveStreamFlowControlWindow()).To(BeEquivalentTo(protocol.ReceiveStreamFlowControlWindow)) Expect(pn.GetReceiveStreamFlowControlWindow()).To(BeEquivalentTo(protocol.ReceiveStreamFlowControlWindow))
Expect(cpm.GetReceiveConnectionFlowControlWindow()).To(BeEquivalentTo(protocol.ReceiveConnectionFlowControlWindow)) Expect(pn.GetReceiveConnectionFlowControlWindow()).To(BeEquivalentTo(protocol.ReceiveConnectionFlowControlWindow))
Expect(cpmClient.GetReceiveStreamFlowControlWindow()).To(BeEquivalentTo(protocol.ReceiveStreamFlowControlWindow)) Expect(pnClient.GetReceiveStreamFlowControlWindow()).To(BeEquivalentTo(protocol.ReceiveStreamFlowControlWindow))
Expect(cpmClient.GetReceiveConnectionFlowControlWindow()).To(BeEquivalentTo(protocol.ReceiveConnectionFlowControlWindow)) Expect(pnClient.GetReceiveConnectionFlowControlWindow()).To(BeEquivalentTo(protocol.ReceiveConnectionFlowControlWindow))
}) })
It("has the correct maximum flow control windows", func() { It("has the correct maximum flow control windows", func() {
Expect(cpm.GetMaxReceiveStreamFlowControlWindow()).To(Equal(maxReceiveStreamFlowControlWindowServer)) Expect(pn.GetMaxReceiveStreamFlowControlWindow()).To(Equal(maxReceiveStreamFlowControlWindowServer))
Expect(cpm.GetMaxReceiveConnectionFlowControlWindow()).To(Equal(maxReceiveConnectionFlowControlWindowServer)) Expect(pn.GetMaxReceiveConnectionFlowControlWindow()).To(Equal(maxReceiveConnectionFlowControlWindowServer))
Expect(cpmClient.GetMaxReceiveStreamFlowControlWindow()).To(Equal(maxReceiveStreamFlowControlWindowClient)) Expect(pnClient.GetMaxReceiveStreamFlowControlWindow()).To(Equal(maxReceiveStreamFlowControlWindowClient))
Expect(cpmClient.GetMaxReceiveConnectionFlowControlWindow()).To(Equal(maxReceiveConnectionFlowControlWindowClient)) Expect(pnClient.GetMaxReceiveConnectionFlowControlWindow()).To(Equal(maxReceiveConnectionFlowControlWindowClient))
}) })
It("sets a new stream-level flow control window for sending", func() { It("sets a new stream-level flow control window for sending", func() {
values := map[Tag][]byte{TagSFCW: {0xDE, 0xAD, 0xBE, 0xEF}} values := map[Tag][]byte{TagSFCW: {0xDE, 0xAD, 0xBE, 0xEF}}
err := cpm.SetFromMap(values) err := pn.SetFromMap(values)
Expect(err).ToNot(HaveOccurred()) Expect(err).ToNot(HaveOccurred())
Expect(cpm.GetSendStreamFlowControlWindow()).To(Equal(protocol.ByteCount(0xEFBEADDE))) Expect(pn.GetSendStreamFlowControlWindow()).To(Equal(protocol.ByteCount(0xEFBEADDE)))
}) })
It("does not change the stream-level flow control window when given an invalid value", func() { It("does not change the stream-level flow control window when given an invalid value", func() {
values := map[Tag][]byte{TagSFCW: {0xDE, 0xAD, 0xBE}} // 1 byte too short values := map[Tag][]byte{TagSFCW: {0xDE, 0xAD, 0xBE}} // 1 byte too short
err := cpm.SetFromMap(values) err := pn.SetFromMap(values)
Expect(err).To(MatchError(errMalformedTag)) Expect(err).To(MatchError(errMalformedTag))
Expect(cpm.GetSendStreamFlowControlWindow()).To(Equal(protocol.InitialStreamFlowControlWindow)) Expect(pn.GetSendStreamFlowControlWindow()).To(Equal(protocol.InitialStreamFlowControlWindow))
}) })
It("sets a new connection-level flow control window for sending", func() { It("sets a new connection-level flow control window for sending", func() {
values := map[Tag][]byte{TagCFCW: {0xDE, 0xAD, 0xBE, 0xEF}} values := map[Tag][]byte{TagCFCW: {0xDE, 0xAD, 0xBE, 0xEF}}
err := cpm.SetFromMap(values) err := pn.SetFromMap(values)
Expect(err).ToNot(HaveOccurred()) Expect(err).ToNot(HaveOccurred())
Expect(cpm.GetSendConnectionFlowControlWindow()).To(Equal(protocol.ByteCount(0xEFBEADDE))) Expect(pn.GetSendConnectionFlowControlWindow()).To(Equal(protocol.ByteCount(0xEFBEADDE)))
}) })
It("does not change the connection-level flow control window when given an invalid value", func() { It("does not change the connection-level flow control window when given an invalid value", func() {
values := map[Tag][]byte{TagCFCW: {0xDE, 0xAD, 0xBE}} // 1 byte too short values := map[Tag][]byte{TagCFCW: {0xDE, 0xAD, 0xBE}} // 1 byte too short
err := cpm.SetFromMap(values) err := pn.SetFromMap(values)
Expect(err).To(MatchError(errMalformedTag)) Expect(err).To(MatchError(errMalformedTag))
Expect(cpm.GetSendStreamFlowControlWindow()).To(Equal(protocol.InitialConnectionFlowControlWindow)) Expect(pn.GetSendStreamFlowControlWindow()).To(Equal(protocol.InitialConnectionFlowControlWindow))
}) })
It("does not allow renegotiation of flow control parameters", func() { It("does not allow renegotiation of flow control parameters", func() {
@ -198,30 +198,30 @@ var _ = Describe("ConnectionsParameterManager", func() {
TagCFCW: {0xDE, 0xAD, 0xBE, 0xEF}, TagCFCW: {0xDE, 0xAD, 0xBE, 0xEF},
TagSFCW: {0xDE, 0xAD, 0xBE, 0xEF}, TagSFCW: {0xDE, 0xAD, 0xBE, 0xEF},
} }
err := cpm.SetFromMap(values) err := pn.SetFromMap(values)
Expect(err).ToNot(HaveOccurred()) Expect(err).ToNot(HaveOccurred())
values = map[Tag][]byte{ values = map[Tag][]byte{
TagCFCW: {0x13, 0x37, 0x13, 0x37}, TagCFCW: {0x13, 0x37, 0x13, 0x37},
TagSFCW: {0x13, 0x37, 0x13, 0x37}, TagSFCW: {0x13, 0x37, 0x13, 0x37},
} }
err = cpm.SetFromMap(values) err = pn.SetFromMap(values)
Expect(err).To(MatchError(errFlowControlRenegotiationNotSupported)) Expect(err).To(MatchError(errFlowControlRenegotiationNotSupported))
Expect(cpm.GetSendStreamFlowControlWindow()).To(Equal(protocol.ByteCount(0xEFBEADDE))) Expect(pn.GetSendStreamFlowControlWindow()).To(Equal(protocol.ByteCount(0xEFBEADDE)))
Expect(cpm.GetSendConnectionFlowControlWindow()).To(Equal(protocol.ByteCount(0xEFBEADDE))) Expect(pn.GetSendConnectionFlowControlWindow()).To(Equal(protocol.ByteCount(0xEFBEADDE)))
}) })
}) })
Context("idle connection state lifetime", func() { Context("idle connection state lifetime", func() {
It("has initial idle connection state lifetime", func() { It("has initial idle connection state lifetime", func() {
Expect(cpm.GetIdleConnectionStateLifetime()).To(Equal(idleTimeout)) Expect(pn.GetIdleConnectionStateLifetime()).To(Equal(idleTimeout))
}) })
It("negotiates correctly when the peer wants a longer lifetime", func() { It("negotiates correctly when the peer wants a longer lifetime", func() {
Expect(cpm.negotiateIdleConnectionStateLifetime(idleTimeout + 10*time.Second)).To(Equal(idleTimeout)) Expect(pn.negotiateIdleConnectionStateLifetime(idleTimeout + 10*time.Second)).To(Equal(idleTimeout))
}) })
It("negotiates correctly when the peer wants a shorter lifetime", func() { It("negotiates correctly when the peer wants a shorter lifetime", func() {
Expect(cpm.negotiateIdleConnectionStateLifetime(idleTimeout - 3*time.Second)).To(Equal(idleTimeout - 3*time.Second)) Expect(pn.negotiateIdleConnectionStateLifetime(idleTimeout - 3*time.Second)).To(Equal(idleTimeout - 3*time.Second))
}) })
It("sets the negotiated lifetime", func() { It("sets the negotiated lifetime", func() {
@ -229,29 +229,29 @@ var _ = Describe("ConnectionsParameterManager", func() {
values := map[Tag][]byte{ values := map[Tag][]byte{
TagICSL: {10, 0, 0, 0}, TagICSL: {10, 0, 0, 0},
} }
err := cpm.SetFromMap(values) err := pn.SetFromMap(values)
Expect(err).ToNot(HaveOccurred()) Expect(err).ToNot(HaveOccurred())
Expect(cpm.GetIdleConnectionStateLifetime()).To(Equal(10 * time.Second)) Expect(pn.GetIdleConnectionStateLifetime()).To(Equal(10 * time.Second))
}) })
It("does not change the idle connection state lifetime when given an invalid value", func() { It("does not change the idle connection state lifetime when given an invalid value", func() {
values := map[Tag][]byte{ values := map[Tag][]byte{
TagSFCW: {0xDE, 0xAD, 0xBE}, // 1 byte too short TagSFCW: {0xDE, 0xAD, 0xBE}, // 1 byte too short
} }
err := cpm.SetFromMap(values) err := pn.SetFromMap(values)
Expect(err).To(MatchError(errMalformedTag)) Expect(err).To(MatchError(errMalformedTag))
Expect(cpm.GetIdleConnectionStateLifetime()).To(Equal(idleTimeout)) Expect(pn.GetIdleConnectionStateLifetime()).To(Equal(idleTimeout))
}) })
It("gets idle connection state lifetime", func() { It("gets idle connection state lifetime", func() {
value := 0xDECAFBAD * time.Second value := 0xDECAFBAD * time.Second
cpm.idleConnectionStateLifetime = value pn.idleConnectionStateLifetime = value
Expect(cpm.GetIdleConnectionStateLifetime()).To(Equal(value)) Expect(pn.GetIdleConnectionStateLifetime()).To(Equal(value))
}) })
It("errors when given an invalid value", func() { It("errors when given an invalid value", func() {
values := map[Tag][]byte{TagICSL: {2, 0, 0}} // 1 byte too short values := map[Tag][]byte{TagICSL: {2, 0, 0}} // 1 byte too short
err := cpm.SetFromMap(values) err := pn.SetFromMap(values)
Expect(err).To(MatchError(errMalformedTag)) Expect(err).To(MatchError(errMalformedTag))
}) })
}) })
@ -259,42 +259,42 @@ var _ = Describe("ConnectionsParameterManager", func() {
Context("max streams per connection", func() { Context("max streams per connection", func() {
It("errors when given an invalid max streams per connection value", func() { It("errors when given an invalid max streams per connection value", func() {
values := map[Tag][]byte{TagMSPC: {2, 0, 0}} // 1 byte too short values := map[Tag][]byte{TagMSPC: {2, 0, 0}} // 1 byte too short
err := cpm.SetFromMap(values) err := pn.SetFromMap(values)
Expect(err).To(MatchError(errMalformedTag)) Expect(err).To(MatchError(errMalformedTag))
}) })
It("errors when given an invalid max dynamic incoming streams per connection value", func() { It("errors when given an invalid max dynamic incoming streams per connection value", func() {
values := map[Tag][]byte{TagMIDS: {2, 0, 0}} // 1 byte too short values := map[Tag][]byte{TagMIDS: {2, 0, 0}} // 1 byte too short
err := cpm.SetFromMap(values) err := pn.SetFromMap(values)
Expect(err).To(MatchError(errMalformedTag)) Expect(err).To(MatchError(errMalformedTag))
}) })
Context("outgoing connections", func() { Context("outgoing connections", func() {
It("sets the negotiated max streams per connection value", func() { It("sets the negotiated max streams per connection value", func() {
// this test only works if the value given here is smaller than protocol.MaxStreamsPerConnection // this test only works if the value given here is smaller than protocol.MaxStreamsPerConnection
err := cpm.SetFromMap(map[Tag][]byte{ err := pn.SetFromMap(map[Tag][]byte{
TagMIDS: {2, 0, 0, 0}, TagMIDS: {2, 0, 0, 0},
TagMSPC: {1, 0, 0, 0}, TagMSPC: {1, 0, 0, 0},
}) })
Expect(err).ToNot(HaveOccurred()) Expect(err).ToNot(HaveOccurred())
Expect(cpm.GetMaxOutgoingStreams()).To(Equal(uint32(2))) Expect(pn.GetMaxOutgoingStreams()).To(Equal(uint32(2)))
}) })
It("uses the the MSPC value, if no MIDS is given", func() { It("uses the the MSPC value, if no MIDS is given", func() {
err := cpm.SetFromMap(map[Tag][]byte{TagMIDS: {3, 0, 0, 0}}) err := pn.SetFromMap(map[Tag][]byte{TagMIDS: {3, 0, 0, 0}})
Expect(err).ToNot(HaveOccurred()) Expect(err).ToNot(HaveOccurred())
Expect(cpm.GetMaxOutgoingStreams()).To(Equal(uint32(3))) Expect(pn.GetMaxOutgoingStreams()).To(Equal(uint32(3)))
}) })
}) })
Context("incoming connections", func() { Context("incoming connections", func() {
It("always uses the constant value, no matter what the client sent", func() { It("always uses the constant value, no matter what the client sent", func() {
err := cpm.SetFromMap(map[Tag][]byte{ err := pn.SetFromMap(map[Tag][]byte{
TagMSPC: {3, 0, 0, 0}, TagMSPC: {3, 0, 0, 0},
TagMIDS: {3, 0, 0, 0}, TagMIDS: {3, 0, 0, 0},
}) })
Expect(err).ToNot(HaveOccurred()) Expect(err).ToNot(HaveOccurred())
Expect(cpm.GetMaxIncomingStreams()).To(BeNumerically(">", protocol.MaxStreamsPerConnection)) Expect(pn.GetMaxIncomingStreams()).To(BeNumerically(">", protocol.MaxStreamsPerConnection))
}) })
}) })
}) })

155
internal/mocks/cpm.go
View file

@ -1,155 +0,0 @@
// Code generated by MockGen. DO NOT EDIT.
// Source: ../handshake/base_connection_parameters_manager.go
package mocks
import (
reflect "reflect"
time "time"
gomock "github.com/golang/mock/gomock"
protocol "github.com/lucas-clemente/quic-go/internal/protocol"
)
// MockConnectionParametersManager is a mock of ConnectionParametersManager interface
type MockConnectionParametersManager struct {
ctrl *gomock.Controller
recorder *MockConnectionParametersManagerMockRecorder
}
// MockConnectionParametersManagerMockRecorder is the mock recorder for MockConnectionParametersManager
type MockConnectionParametersManagerMockRecorder struct {
mock *MockConnectionParametersManager
}
// NewMockConnectionParametersManager creates a new mock instance
func NewMockConnectionParametersManager(ctrl *gomock.Controller) *MockConnectionParametersManager {
mock := &MockConnectionParametersManager{ctrl: ctrl}
mock.recorder = &MockConnectionParametersManagerMockRecorder{mock}
return mock
}
// EXPECT returns an object that allows the caller to indicate expected use
func (_m *MockConnectionParametersManager) EXPECT() *MockConnectionParametersManagerMockRecorder {
return _m.recorder
}
// GetSendStreamFlowControlWindow mocks base method
func (_m *MockConnectionParametersManager) GetSendStreamFlowControlWindow() protocol.ByteCount {
ret := _m.ctrl.Call(_m, "GetSendStreamFlowControlWindow")
ret0, _ := ret[0].(protocol.ByteCount)
return ret0
}
// GetSendStreamFlowControlWindow indicates an expected call of GetSendStreamFlowControlWindow
func (_mr *MockConnectionParametersManagerMockRecorder) GetSendStreamFlowControlWindow() *gomock.Call {
return _mr.mock.ctrl.RecordCallWithMethodType(_mr.mock, "GetSendStreamFlowControlWindow", reflect.TypeOf((*MockConnectionParametersManager)(nil).GetSendStreamFlowControlWindow))
}
// GetSendConnectionFlowControlWindow mocks base method
func (_m *MockConnectionParametersManager) GetSendConnectionFlowControlWindow() protocol.ByteCount {
ret := _m.ctrl.Call(_m, "GetSendConnectionFlowControlWindow")
ret0, _ := ret[0].(protocol.ByteCount)
return ret0
}
// GetSendConnectionFlowControlWindow indicates an expected call of GetSendConnectionFlowControlWindow
func (_mr *MockConnectionParametersManagerMockRecorder) GetSendConnectionFlowControlWindow() *gomock.Call {
return _mr.mock.ctrl.RecordCallWithMethodType(_mr.mock, "GetSendConnectionFlowControlWindow", reflect.TypeOf((*MockConnectionParametersManager)(nil).GetSendConnectionFlowControlWindow))
}
// GetReceiveStreamFlowControlWindow mocks base method
func (_m *MockConnectionParametersManager) GetReceiveStreamFlowControlWindow() protocol.ByteCount {
ret := _m.ctrl.Call(_m, "GetReceiveStreamFlowControlWindow")
ret0, _ := ret[0].(protocol.ByteCount)
return ret0
}
// GetReceiveStreamFlowControlWindow indicates an expected call of GetReceiveStreamFlowControlWindow
func (_mr *MockConnectionParametersManagerMockRecorder) GetReceiveStreamFlowControlWindow() *gomock.Call {
return _mr.mock.ctrl.RecordCallWithMethodType(_mr.mock, "GetReceiveStreamFlowControlWindow", reflect.TypeOf((*MockConnectionParametersManager)(nil).GetReceiveStreamFlowControlWindow))
}
// GetMaxReceiveStreamFlowControlWindow mocks base method
func (_m *MockConnectionParametersManager) GetMaxReceiveStreamFlowControlWindow() protocol.ByteCount {
ret := _m.ctrl.Call(_m, "GetMaxReceiveStreamFlowControlWindow")
ret0, _ := ret[0].(protocol.ByteCount)
return ret0
}
// GetMaxReceiveStreamFlowControlWindow indicates an expected call of GetMaxReceiveStreamFlowControlWindow
func (_mr *MockConnectionParametersManagerMockRecorder) GetMaxReceiveStreamFlowControlWindow() *gomock.Call {
return _mr.mock.ctrl.RecordCallWithMethodType(_mr.mock, "GetMaxReceiveStreamFlowControlWindow", reflect.TypeOf((*MockConnectionParametersManager)(nil).GetMaxReceiveStreamFlowControlWindow))
}
// GetReceiveConnectionFlowControlWindow mocks base method
func (_m *MockConnectionParametersManager) GetReceiveConnectionFlowControlWindow() protocol.ByteCount {
ret := _m.ctrl.Call(_m, "GetReceiveConnectionFlowControlWindow")
ret0, _ := ret[0].(protocol.ByteCount)
return ret0
}
// GetReceiveConnectionFlowControlWindow indicates an expected call of GetReceiveConnectionFlowControlWindow
func (_mr *MockConnectionParametersManagerMockRecorder) GetReceiveConnectionFlowControlWindow() *gomock.Call {
return _mr.mock.ctrl.RecordCallWithMethodType(_mr.mock, "GetReceiveConnectionFlowControlWindow", reflect.TypeOf((*MockConnectionParametersManager)(nil).GetReceiveConnectionFlowControlWindow))
}
// GetMaxReceiveConnectionFlowControlWindow mocks base method
func (_m *MockConnectionParametersManager) GetMaxReceiveConnectionFlowControlWindow() protocol.ByteCount {
ret := _m.ctrl.Call(_m, "GetMaxReceiveConnectionFlowControlWindow")
ret0, _ := ret[0].(protocol.ByteCount)
return ret0
}
// GetMaxReceiveConnectionFlowControlWindow indicates an expected call of GetMaxReceiveConnectionFlowControlWindow
func (_mr *MockConnectionParametersManagerMockRecorder) GetMaxReceiveConnectionFlowControlWindow() *gomock.Call {
return _mr.mock.ctrl.RecordCallWithMethodType(_mr.mock, "GetMaxReceiveConnectionFlowControlWindow", reflect.TypeOf((*MockConnectionParametersManager)(nil).GetMaxReceiveConnectionFlowControlWindow))
}
// GetMaxOutgoingStreams mocks base method
func (_m *MockConnectionParametersManager) GetMaxOutgoingStreams() uint32 {
ret := _m.ctrl.Call(_m, "GetMaxOutgoingStreams")
ret0, _ := ret[0].(uint32)
return ret0
}
// GetMaxOutgoingStreams indicates an expected call of GetMaxOutgoingStreams
func (_mr *MockConnectionParametersManagerMockRecorder) GetMaxOutgoingStreams() *gomock.Call {
return _mr.mock.ctrl.RecordCallWithMethodType(_mr.mock, "GetMaxOutgoingStreams", reflect.TypeOf((*MockConnectionParametersManager)(nil).GetMaxOutgoingStreams))
}
// GetMaxIncomingStreams mocks base method
func (_m *MockConnectionParametersManager) GetMaxIncomingStreams() uint32 {
ret := _m.ctrl.Call(_m, "GetMaxIncomingStreams")
ret0, _ := ret[0].(uint32)
return ret0
}
// GetMaxIncomingStreams indicates an expected call of GetMaxIncomingStreams
func (_mr *MockConnectionParametersManagerMockRecorder) GetMaxIncomingStreams() *gomock.Call {
return _mr.mock.ctrl.RecordCallWithMethodType(_mr.mock, "GetMaxIncomingStreams", reflect.TypeOf((*MockConnectionParametersManager)(nil).GetMaxIncomingStreams))
}
// GetIdleConnectionStateLifetime mocks base method
func (_m *MockConnectionParametersManager) GetIdleConnectionStateLifetime() time.Duration {
ret := _m.ctrl.Call(_m, "GetIdleConnectionStateLifetime")
ret0, _ := ret[0].(time.Duration)
return ret0
}
// GetIdleConnectionStateLifetime indicates an expected call of GetIdleConnectionStateLifetime
func (_mr *MockConnectionParametersManagerMockRecorder) GetIdleConnectionStateLifetime() *gomock.Call {
return _mr.mock.ctrl.RecordCallWithMethodType(_mr.mock, "GetIdleConnectionStateLifetime", reflect.TypeOf((*MockConnectionParametersManager)(nil).GetIdleConnectionStateLifetime))
}
// TruncateConnectionID mocks base method
func (_m *MockConnectionParametersManager) TruncateConnectionID() bool {
ret := _m.ctrl.Call(_m, "TruncateConnectionID")
ret0, _ := ret[0].(bool)
return ret0
}
// TruncateConnectionID indicates an expected call of TruncateConnectionID
func (_mr *MockConnectionParametersManagerMockRecorder) TruncateConnectionID() *gomock.Call {
return _mr.mock.ctrl.RecordCallWithMethodType(_mr.mock, "TruncateConnectionID", reflect.TypeOf((*MockConnectionParametersManager)(nil).TruncateConnectionID))
}

2
internal/mocks/gen.go
View file

@ -4,5 +4,5 @@ package mocks
// so we have to use sed to correct for that // so we have to use sed to correct for that
//go:generate sh -c "mockgen -package mocks_fc -source ../flowcontrol/interface.go | sed \"s/\\[\\]WindowUpdate/[]flowcontrol.WindowUpdate/g\" > mocks_fc/flow_control_manager.go" //go:generate sh -c "mockgen -package mocks_fc -source ../flowcontrol/interface.go | sed \"s/\\[\\]WindowUpdate/[]flowcontrol.WindowUpdate/g\" > mocks_fc/flow_control_manager.go"
//go:generate sh -c "mockgen -package mocks -source ../handshake/base_connection_parameters_manager.go > cpm.go" //go:generate sh -c "mockgen -package mocks -source ../handshake/params_negotiator_base.go > params_negotiator.go"
//go:generate sh -c "goimports -w ." //go:generate sh -c "goimports -w ."

155
internal/mocks/params_negotiator.go Normal file
View file

@ -0,0 +1,155 @@
// Code generated by MockGen. DO NOT EDIT.
// Source: ../handshake/params_negotiator_base.go
package mocks
import (
reflect "reflect"
time "time"
gomock "github.com/golang/mock/gomock"
protocol "github.com/lucas-clemente/quic-go/internal/protocol"
)
// MockParamsNegotiator is a mock of ParamsNegotiator interface
type MockParamsNegotiator struct {
ctrl *gomock.Controller
recorder *MockParamsNegotiatorMockRecorder
}
// MockParamsNegotiatorMockRecorder is the mock recorder for MockParamsNegotiator
type MockParamsNegotiatorMockRecorder struct {
mock *MockParamsNegotiator
}
// NewMockParamsNegotiator creates a new mock instance
func NewMockParamsNegotiator(ctrl *gomock.Controller) *MockParamsNegotiator {
mock := &MockParamsNegotiator{ctrl: ctrl}
mock.recorder = &MockParamsNegotiatorMockRecorder{mock}
return mock
}
// EXPECT returns an object that allows the caller to indicate expected use
func (_m *MockParamsNegotiator) EXPECT() *MockParamsNegotiatorMockRecorder {
return _m.recorder
}
// GetSendStreamFlowControlWindow mocks base method
func (_m *MockParamsNegotiator) GetSendStreamFlowControlWindow() protocol.ByteCount {
ret := _m.ctrl.Call(_m, "GetSendStreamFlowControlWindow")
ret0, _ := ret[0].(protocol.ByteCount)
return ret0
}
// GetSendStreamFlowControlWindow indicates an expected call of GetSendStreamFlowControlWindow
func (_mr *MockParamsNegotiatorMockRecorder) GetSendStreamFlowControlWindow() *gomock.Call {
return _mr.mock.ctrl.RecordCallWithMethodType(_mr.mock, "GetSendStreamFlowControlWindow", reflect.TypeOf((*MockParamsNegotiator)(nil).GetSendStreamFlowControlWindow))
}
// GetSendConnectionFlowControlWindow mocks base method
func (_m *MockParamsNegotiator) GetSendConnectionFlowControlWindow() protocol.ByteCount {
ret := _m.ctrl.Call(_m, "GetSendConnectionFlowControlWindow")
ret0, _ := ret[0].(protocol.ByteCount)
return ret0
}
// GetSendConnectionFlowControlWindow indicates an expected call of GetSendConnectionFlowControlWindow
func (_mr *MockParamsNegotiatorMockRecorder) GetSendConnectionFlowControlWindow() *gomock.Call {
return _mr.mock.ctrl.RecordCallWithMethodType(_mr.mock, "GetSendConnectionFlowControlWindow", reflect.TypeOf((*MockParamsNegotiator)(nil).GetSendConnectionFlowControlWindow))
}
// GetReceiveStreamFlowControlWindow mocks base method
func (_m *MockParamsNegotiator) GetReceiveStreamFlowControlWindow() protocol.ByteCount {
ret := _m.ctrl.Call(_m, "GetReceiveStreamFlowControlWindow")
ret0, _ := ret[0].(protocol.ByteCount)
return ret0
}
// GetReceiveStreamFlowControlWindow indicates an expected call of GetReceiveStreamFlowControlWindow
func (_mr *MockParamsNegotiatorMockRecorder) GetReceiveStreamFlowControlWindow() *gomock.Call {
return _mr.mock.ctrl.RecordCallWithMethodType(_mr.mock, "GetReceiveStreamFlowControlWindow", reflect.TypeOf((*MockParamsNegotiator)(nil).GetReceiveStreamFlowControlWindow))
}
// GetMaxReceiveStreamFlowControlWindow mocks base method
func (_m *MockParamsNegotiator) GetMaxReceiveStreamFlowControlWindow() protocol.ByteCount {
ret := _m.ctrl.Call(_m, "GetMaxReceiveStreamFlowControlWindow")
ret0, _ := ret[0].(protocol.ByteCount)
return ret0
}
// GetMaxReceiveStreamFlowControlWindow indicates an expected call of GetMaxReceiveStreamFlowControlWindow
func (_mr *MockParamsNegotiatorMockRecorder) GetMaxReceiveStreamFlowControlWindow() *gomock.Call {
return _mr.mock.ctrl.RecordCallWithMethodType(_mr.mock, "GetMaxReceiveStreamFlowControlWindow", reflect.TypeOf((*MockParamsNegotiator)(nil).GetMaxReceiveStreamFlowControlWindow))
}
// GetReceiveConnectionFlowControlWindow mocks base method
func (_m *MockParamsNegotiator) GetReceiveConnectionFlowControlWindow() protocol.ByteCount {
ret := _m.ctrl.Call(_m, "GetReceiveConnectionFlowControlWindow")
ret0, _ := ret[0].(protocol.ByteCount)
return ret0
}
// GetReceiveConnectionFlowControlWindow indicates an expected call of GetReceiveConnectionFlowControlWindow
func (_mr *MockParamsNegotiatorMockRecorder) GetReceiveConnectionFlowControlWindow() *gomock.Call {
return _mr.mock.ctrl.RecordCallWithMethodType(_mr.mock, "GetReceiveConnectionFlowControlWindow", reflect.TypeOf((*MockParamsNegotiator)(nil).GetReceiveConnectionFlowControlWindow))
}
// GetMaxReceiveConnectionFlowControlWindow mocks base method
func (_m *MockParamsNegotiator) GetMaxReceiveConnectionFlowControlWindow() protocol.ByteCount {
ret := _m.ctrl.Call(_m, "GetMaxReceiveConnectionFlowControlWindow")
ret0, _ := ret[0].(protocol.ByteCount)
return ret0
}
// GetMaxReceiveConnectionFlowControlWindow indicates an expected call of GetMaxReceiveConnectionFlowControlWindow
func (_mr *MockParamsNegotiatorMockRecorder) GetMaxReceiveConnectionFlowControlWindow() *gomock.Call {
return _mr.mock.ctrl.RecordCallWithMethodType(_mr.mock, "GetMaxReceiveConnectionFlowControlWindow", reflect.TypeOf((*MockParamsNegotiator)(nil).GetMaxReceiveConnectionFlowControlWindow))
}
// GetMaxOutgoingStreams mocks base method
func (_m *MockParamsNegotiator) GetMaxOutgoingStreams() uint32 {
ret := _m.ctrl.Call(_m, "GetMaxOutgoingStreams")
ret0, _ := ret[0].(uint32)
return ret0
}
// GetMaxOutgoingStreams indicates an expected call of GetMaxOutgoingStreams
func (_mr *MockParamsNegotiatorMockRecorder) GetMaxOutgoingStreams() *gomock.Call {
return _mr.mock.ctrl.RecordCallWithMethodType(_mr.mock, "GetMaxOutgoingStreams", reflect.TypeOf((*MockParamsNegotiator)(nil).GetMaxOutgoingStreams))
}
// GetMaxIncomingStreams mocks base method
func (_m *MockParamsNegotiator) GetMaxIncomingStreams() uint32 {
ret := _m.ctrl.Call(_m, "GetMaxIncomingStreams")
ret0, _ := ret[0].(uint32)
return ret0
}
// GetMaxIncomingStreams indicates an expected call of GetMaxIncomingStreams
func (_mr *MockParamsNegotiatorMockRecorder) GetMaxIncomingStreams() *gomock.Call {
return _mr.mock.ctrl.RecordCallWithMethodType(_mr.mock, "GetMaxIncomingStreams", reflect.TypeOf((*MockParamsNegotiator)(nil).GetMaxIncomingStreams))
}
// GetIdleConnectionStateLifetime mocks base method
func (_m *MockParamsNegotiator) GetIdleConnectionStateLifetime() time.Duration {
ret := _m.ctrl.Call(_m, "GetIdleConnectionStateLifetime")
ret0, _ := ret[0].(time.Duration)
return ret0
}
// GetIdleConnectionStateLifetime indicates an expected call of GetIdleConnectionStateLifetime
func (_mr *MockParamsNegotiatorMockRecorder) GetIdleConnectionStateLifetime() *gomock.Call {
return _mr.mock.ctrl.RecordCallWithMethodType(_mr.mock, "GetIdleConnectionStateLifetime", reflect.TypeOf((*MockParamsNegotiator)(nil).GetIdleConnectionStateLifetime))
}
// TruncateConnectionID mocks base method
func (_m *MockParamsNegotiator) TruncateConnectionID() bool {
ret := _m.ctrl.Call(_m, "TruncateConnectionID")
ret0, _ := ret[0].(bool)
return ret0
}
// TruncateConnectionID indicates an expected call of TruncateConnectionID
func (_mr *MockParamsNegotiatorMockRecorder) TruncateConnectionID() *gomock.Call {
return _mr.mock.ctrl.RecordCallWithMethodType(_mr.mock, "TruncateConnectionID", reflect.TypeOf((*MockParamsNegotiator)(nil).TruncateConnectionID))
}

8
packet_packer.go
View file

@ -25,7 +25,7 @@ type packetPacker struct {
cryptoSetup handshake.CryptoSetup cryptoSetup handshake.CryptoSetup
packetNumberGenerator *packetNumberGenerator packetNumberGenerator *packetNumberGenerator
connectionParameters handshake.ConnectionParametersManager connParams handshake.ParamsNegotiator
streamFramer *streamFramer streamFramer *streamFramer
controlFrames []wire.Frame controlFrames []wire.Frame
@ -36,7 +36,7 @@ type packetPacker struct {
func newPacketPacker(connectionID protocol.ConnectionID, func newPacketPacker(connectionID protocol.ConnectionID,
cryptoSetup handshake.CryptoSetup, cryptoSetup handshake.CryptoSetup,
connectionParameters handshake.ConnectionParametersManager, connParams handshake.ParamsNegotiator,
streamFramer *streamFramer, streamFramer *streamFramer,
perspective protocol.Perspective, perspective protocol.Perspective,
version protocol.VersionNumber, version protocol.VersionNumber,
@ -44,7 +44,7 @@ func newPacketPacker(connectionID protocol.ConnectionID,
return &packetPacker{ return &packetPacker{
cryptoSetup: cryptoSetup, cryptoSetup: cryptoSetup,
connectionID: connectionID, connectionID: connectionID,
connectionParameters: connectionParameters, connParams: connParams,
perspective: perspective, perspective: perspective,
version: version, version: version,
streamFramer: streamFramer, streamFramer: streamFramer,
@ -271,7 +271,7 @@ func (p *packetPacker) getPublicHeader(encLevel protocol.EncryptionLevel) *wire.
ConnectionID: p.connectionID, ConnectionID: p.connectionID,
PacketNumber: pnum, PacketNumber: pnum,
PacketNumberLen: packetNumberLen, PacketNumberLen: packetNumberLen,
TruncateConnectionID: p.connectionParameters.TruncateConnectionID(), TruncateConnectionID: p.connParams.TruncateConnectionID(),
} }
if p.perspective == protocol.PerspectiveServer && encLevel == protocol.EncryptionSecure { if p.perspective == protocol.PerspectiveServer && encLevel == protocol.EncryptionSecure {

6
packet_packer_test.go
View file

@ -61,8 +61,8 @@ var _ = Describe("Packet packer", func() {
) )
BeforeEach(func() { BeforeEach(func() {
mockCpm := mocks.NewMockConnectionParametersManager(mockCtrl) mockPn := mocks.NewMockParamsNegotiator(mockCtrl)
mockCpm.EXPECT().TruncateConnectionID().Return(false).AnyTimes() mockPn.EXPECT().TruncateConnectionID().Return(false).AnyTimes()
cryptoStream = &stream{} cryptoStream = &stream{}
@ -73,7 +73,7 @@ var _ = Describe("Packet packer", func() {
packer = &packetPacker{ packer = &packetPacker{
cryptoSetup: &mockCryptoSetup{encLevelSeal: protocol.EncryptionForwardSecure}, cryptoSetup: &mockCryptoSetup{encLevelSeal: protocol.EncryptionForwardSecure},
connectionParameters: mockCpm, connParams: mockPn,
connectionID: 0x1337, connectionID: 0x1337,
packetNumberGenerator: newPacketNumberGenerator(protocol.SkipPacketAveragePeriodLength), packetNumberGenerator: newPacketNumberGenerator(protocol.SkipPacketAveragePeriodLength),
streamFramer: streamFramer, streamFramer: streamFramer,

18
session.go
View file

@ -100,7 +100,7 @@ type session struct {
// it receives at most 3 handshake events: 2 when the encryption level changes, and one error // it receives at most 3 handshake events: 2 when the encryption level changes, and one error
handshakeChan chan<- handshakeEvent handshakeChan chan<- handshakeEvent
connectionParameters handshake.ConnectionParametersManager connParams handshake.ParamsNegotiator
lastRcvdPacketNumber protocol.PacketNumber lastRcvdPacketNumber protocol.PacketNumber
// Used to calculate the next packet number from the truncated wire // Used to calculate the next packet number from the truncated wire
@ -194,7 +194,7 @@ func (s *session) setup(
return s.config.AcceptCookie(clientAddr, cookie) return s.config.AcceptCookie(clientAddr, cookie)
} }
if s.version.UsesTLS() { if s.version.UsesTLS() {
s.cryptoSetup, s.connectionParameters, err = handshake.NewCryptoSetupTLS( s.cryptoSetup, s.connParams, err = handshake.NewCryptoSetupTLS(
"", "",
s.perspective, s.perspective,
s.version, s.version,
@ -202,7 +202,7 @@ func (s *session) setup(
aeadChanged, aeadChanged,
) )
} else { } else {
s.cryptoSetup, s.connectionParameters, err = newCryptoSetup( s.cryptoSetup, s.connParams, err = newCryptoSetup(
s.connectionID, s.connectionID,
s.conn.RemoteAddr(), s.conn.RemoteAddr(),
s.version, s.version,
@ -215,7 +215,7 @@ func (s *session) setup(
} }
} else { } else {
if s.version.UsesTLS() { if s.version.UsesTLS() {
s.cryptoSetup, s.connectionParameters, err = handshake.NewCryptoSetupTLS( s.cryptoSetup, s.connParams, err = handshake.NewCryptoSetupTLS(
hostname, hostname,
s.perspective, s.perspective,
s.version, s.version,
@ -224,7 +224,7 @@ func (s *session) setup(
) )
} else { } else {
transportParams.RequestConnectionIDTruncation = s.config.RequestConnectionIDTruncation transportParams.RequestConnectionIDTruncation = s.config.RequestConnectionIDTruncation
s.cryptoSetup, s.connectionParameters, err = newCryptoSetupClient( s.cryptoSetup, s.connParams, err = newCryptoSetupClient(
hostname, hostname,
s.connectionID, s.connectionID,
s.version, s.version,
@ -239,12 +239,12 @@ func (s *session) setup(
return nil, nil, err return nil, nil, err
} }
s.flowControlManager = flowcontrol.NewFlowControlManager(s.connectionParameters, s.rttStats) s.flowControlManager = flowcontrol.NewFlowControlManager(s.connParams, s.rttStats)
s.streamsMap = newStreamsMap(s.newStream, s.perspective, s.connectionParameters) s.streamsMap = newStreamsMap(s.newStream, s.perspective, s.connParams)
s.streamFramer = newStreamFramer(s.streamsMap, s.flowControlManager) s.streamFramer = newStreamFramer(s.streamsMap, s.flowControlManager)
s.packer = newPacketPacker(s.connectionID, s.packer = newPacketPacker(s.connectionID,
s.cryptoSetup, s.cryptoSetup,
s.connectionParameters, s.connParams,
s.streamFramer, s.streamFramer,
s.perspective, s.perspective,
s.version, s.version,
@ -389,7 +389,7 @@ func (s *session) maybeResetTimer() {
} }
func (s *session) idleTimeout() time.Duration { func (s *session) idleTimeout() time.Duration {
return s.connectionParameters.GetIdleConnectionStateLifetime() return s.connParams.GetIdleConnectionStateLifetime()
} }
func (s *session) handlePacketImpl(p *receivedPacket) error { func (s *session) handlePacketImpl(p *receivedPacket) error {

70
session_test.go
View file

@ -143,36 +143,34 @@ func areSessionsRunning() bool {
return strings.Contains(b.String(), "quic-go.(*session).run") return strings.Contains(b.String(), "quic-go.(*session).run")
} }
type mockConnectionParametersManager struct{} type mockParamsNegotiator struct{}
var _ handshake.ConnectionParametersManager = &mockConnectionParametersManager{} var _ handshake.ParamsNegotiator = &mockParamsNegotiator{}
func (m *mockConnectionParametersManager) GetSendStreamFlowControlWindow() protocol.ByteCount { func (m *mockParamsNegotiator) GetSendStreamFlowControlWindow() protocol.ByteCount {
return protocol.InitialStreamFlowControlWindow return protocol.InitialStreamFlowControlWindow
} }
func (m *mockConnectionParametersManager) GetSendConnectionFlowControlWindow() protocol.ByteCount { func (m *mockParamsNegotiator) GetSendConnectionFlowControlWindow() protocol.ByteCount {
return protocol.InitialConnectionFlowControlWindow return protocol.InitialConnectionFlowControlWindow
} }
func (m *mockConnectionParametersManager) GetReceiveStreamFlowControlWindow() protocol.ByteCount { func (m *mockParamsNegotiator) GetReceiveStreamFlowControlWindow() protocol.ByteCount {
return protocol.ReceiveStreamFlowControlWindow return protocol.ReceiveStreamFlowControlWindow
} }
func (m *mockConnectionParametersManager) GetMaxReceiveStreamFlowControlWindow() protocol.ByteCount { func (m *mockParamsNegotiator) GetMaxReceiveStreamFlowControlWindow() protocol.ByteCount {
return protocol.DefaultMaxReceiveStreamFlowControlWindowServer return protocol.DefaultMaxReceiveStreamFlowControlWindowServer
} }
func (m *mockConnectionParametersManager) GetReceiveConnectionFlowControlWindow() protocol.ByteCount { func (m *mockParamsNegotiator) GetReceiveConnectionFlowControlWindow() protocol.ByteCount {
return protocol.ReceiveConnectionFlowControlWindow return protocol.ReceiveConnectionFlowControlWindow
} }
func (m *mockConnectionParametersManager) GetMaxReceiveConnectionFlowControlWindow() protocol.ByteCount { func (m *mockParamsNegotiator) GetMaxReceiveConnectionFlowControlWindow() protocol.ByteCount {
return protocol.DefaultMaxReceiveConnectionFlowControlWindowServer return protocol.DefaultMaxReceiveConnectionFlowControlWindowServer
} }
func (m *mockConnectionParametersManager) GetMaxOutgoingStreams() uint32 { return 100 } func (m *mockParamsNegotiator) GetMaxOutgoingStreams() uint32 { return 100 }
func (m *mockConnectionParametersManager) GetMaxIncomingStreams() uint32 { return 100 } func (m *mockParamsNegotiator) GetMaxIncomingStreams() uint32 { return 100 }
func (m *mockConnectionParametersManager) GetIdleConnectionStateLifetime() time.Duration { func (m *mockParamsNegotiator) GetIdleConnectionStateLifetime() time.Duration {
return time.Hour return time.Hour
} }
func (m *mockConnectionParametersManager) TruncateConnectionID() bool { return false } func (m *mockParamsNegotiator) TruncateConnectionID() bool { return false }
var _ handshake.ConnectionParametersManager = &mockConnectionParametersManager{}
var _ = Describe("Session", func() { var _ = Describe("Session", func() {
var ( var (
@ -197,9 +195,9 @@ var _ = Describe("Session", func() {
_ []protocol.VersionNumber, _ []protocol.VersionNumber,
_ func(net.Addr, *Cookie) bool, _ func(net.Addr, *Cookie) bool,
aeadChangedP chan<- protocol.EncryptionLevel, aeadChangedP chan<- protocol.EncryptionLevel,
) (handshake.CryptoSetup, handshake.ConnectionParametersManager, error) { ) (handshake.CryptoSetup, handshake.ParamsNegotiator, error) {
aeadChanged = aeadChangedP aeadChanged = aeadChangedP
return cryptoSetup, &mockConnectionParametersManager{}, nil return cryptoSetup, &mockParamsNegotiator{}, nil
} }
mconn = newMockConnection() mconn = newMockConnection()
@ -221,7 +219,7 @@ var _ = Describe("Session", func() {
sess = pSess.(*session) sess = pSess.(*session)
Expect(sess.streamsMap.openStreams).To(BeEmpty()) // the crypto stream is opened in session.run() Expect(sess.streamsMap.openStreams).To(BeEmpty()) // the crypto stream is opened in session.run()
sess.connectionParameters = &mockConnectionParametersManager{} sess.connParams = &mockParamsNegotiator{}
}) })
AfterEach(func() { AfterEach(func() {
@ -247,9 +245,9 @@ var _ = Describe("Session", func() {
_ []protocol.VersionNumber, _ []protocol.VersionNumber,
cookieFunc func(net.Addr, *Cookie) bool, cookieFunc func(net.Addr, *Cookie) bool,
_ chan<- protocol.EncryptionLevel, _ chan<- protocol.EncryptionLevel,
) (handshake.CryptoSetup, handshake.ConnectionParametersManager, error) { ) (handshake.CryptoSetup, handshake.ParamsNegotiator, error) {
cookieVerify = cookieFunc cookieVerify = cookieFunc
return cryptoSetup, &mockConnectionParametersManager{}, nil return cryptoSetup, &mockParamsNegotiator{}, nil
} }
conf := populateServerConfig(&Config{}) conf := populateServerConfig(&Config{})
@ -1559,11 +1557,11 @@ var _ = Describe("Session", func() {
It("does not use ICSL before handshake", func() { It("does not use ICSL before handshake", func() {
defer sess.Close(nil) defer sess.Close(nil)
sess.lastNetworkActivityTime = time.Now().Add(-time.Minute) sess.lastNetworkActivityTime = time.Now().Add(-time.Minute)
mockCpm := mocks.NewMockConnectionParametersManager(mockCtrl) mockPn := mocks.NewMockParamsNegotiator(mockCtrl)
mockCpm.EXPECT().GetIdleConnectionStateLifetime().Return(9999 * time.Second).AnyTimes() mockPn.EXPECT().GetIdleConnectionStateLifetime().Return(9999 * time.Second).AnyTimes()
mockCpm.EXPECT().TruncateConnectionID().Return(false).AnyTimes() mockPn.EXPECT().TruncateConnectionID().Return(false).AnyTimes()
sess.connectionParameters = mockCpm sess.connParams = mockPn
sess.packer.connectionParameters = mockCpm sess.packer.connParams = mockPn
// the handshake timeout is irrelevant here, since it depends on the time the session was created, // the handshake timeout is irrelevant here, since it depends on the time the session was created,
// and not on the last network activity // and not on the last network activity
done := make(chan struct{}) done := make(chan struct{})
@ -1576,12 +1574,12 @@ var _ = Describe("Session", func() {
It("uses ICSL after handshake", func(done Done) { It("uses ICSL after handshake", func(done Done) {
close(aeadChanged) close(aeadChanged)
mockCpm := mocks.NewMockConnectionParametersManager(mockCtrl) mockPn := mocks.NewMockParamsNegotiator(mockCtrl)
mockCpm.EXPECT().GetIdleConnectionStateLifetime().Return(0 * time.Second) mockPn.EXPECT().GetIdleConnectionStateLifetime().Return(0 * time.Second)
mockCpm.EXPECT().TruncateConnectionID().Return(false).AnyTimes() mockPn.EXPECT().TruncateConnectionID().Return(false).AnyTimes()
sess.connectionParameters = mockCpm sess.connParams = mockPn
sess.packer.connectionParameters = mockCpm sess.packer.connParams = mockPn
mockCpm.EXPECT().GetIdleConnectionStateLifetime().Return(0 * time.Second).AnyTimes() mockPn.EXPECT().GetIdleConnectionStateLifetime().Return(0 * time.Second).AnyTimes()
err := sess.run() // Would normally not return err := sess.run() // Would normally not return
Expect(err.(*qerr.QuicError).ErrorCode).To(Equal(qerr.NetworkIdleTimeout)) Expect(err.(*qerr.QuicError).ErrorCode).To(Equal(qerr.NetworkIdleTimeout))
Expect(mconn.written).To(Receive(ContainSubstring("No recent network activity."))) Expect(mconn.written).To(Receive(ContainSubstring("No recent network activity.")))
@ -1630,8 +1628,8 @@ var _ = Describe("Session", func() {
Context("counting streams", func() { Context("counting streams", func() {
It("errors when too many streams are opened", func() { It("errors when too many streams are opened", func() {
mockCpm := mocks.NewMockConnectionParametersManager(mockCtrl) mockPn := mocks.NewMockParamsNegotiator(mockCtrl)
mockCpm.EXPECT().GetMaxIncomingStreams().Return(uint32(10)).AnyTimes() mockPn.EXPECT().GetMaxIncomingStreams().Return(uint32(10)).AnyTimes()
for i := 0; i < 10; i++ { for i := 0; i < 10; i++ {
_, err := sess.GetOrOpenStream(protocol.StreamID(i*2 + 1)) _, err := sess.GetOrOpenStream(protocol.StreamID(i*2 + 1))
Expect(err).NotTo(HaveOccurred()) Expect(err).NotTo(HaveOccurred())
@ -1641,8 +1639,8 @@ var _ = Describe("Session", func() {
}) })
It("does not error when many streams are opened and closed", func() { It("does not error when many streams are opened and closed", func() {
mockCpm := mocks.NewMockConnectionParametersManager(mockCtrl) mockPn := mocks.NewMockParamsNegotiator(mockCtrl)
mockCpm.EXPECT().GetMaxIncomingStreams().Return(uint32(10)).AnyTimes() mockPn.EXPECT().GetMaxIncomingStreams().Return(uint32(10)).AnyTimes()
for i := 2; i <= 1000; i++ { for i := 2; i <= 1000; i++ {
s, err := sess.GetOrOpenStream(protocol.StreamID(i*2 + 1)) s, err := sess.GetOrOpenStream(protocol.StreamID(i*2 + 1))
Expect(err).NotTo(HaveOccurred()) Expect(err).NotTo(HaveOccurred())
@ -1732,9 +1730,9 @@ var _ = Describe("Client Session", func() {
_ *handshake.TransportParameters, _ *handshake.TransportParameters,
aeadChangedP chan<- protocol.EncryptionLevel, aeadChangedP chan<- protocol.EncryptionLevel,
_ []protocol.VersionNumber, _ []protocol.VersionNumber,
) (handshake.CryptoSetup, handshake.ConnectionParametersManager, error) { ) (handshake.CryptoSetup, handshake.ParamsNegotiator, error) {
aeadChanged = aeadChangedP aeadChanged = aeadChangedP
return cryptoSetup, &mockConnectionParametersManager{}, nil return cryptoSetup, &mockParamsNegotiator{}, nil
} }
mconn = newMockConnection() mconn = newMockConnection()

10
streams_map.go
View file

@ -13,8 +13,8 @@ import (
type streamsMap struct { type streamsMap struct {
mutex sync.RWMutex mutex sync.RWMutex
connParams handshake.ParamsNegotiator
perspective protocol.Perspective perspective protocol.Perspective
connectionParameters handshake.ConnectionParametersManager
streams map[protocol.StreamID]*stream streams map[protocol.StreamID]*stream
// needed for round-robin scheduling // needed for round-robin scheduling
@ -42,13 +42,13 @@ var (
errMapAccess = errors.New("streamsMap: Error accessing the streams map") errMapAccess = errors.New("streamsMap: Error accessing the streams map")
) )
func newStreamsMap(newStream newStreamLambda, pers protocol.Perspective, connectionParameters handshake.ConnectionParametersManager) *streamsMap { func newStreamsMap(newStream newStreamLambda, pers protocol.Perspective, connParams handshake.ParamsNegotiator) *streamsMap {
sm := streamsMap{ sm := streamsMap{
perspective: pers, perspective: pers,
streams: map[protocol.StreamID]*stream{}, streams: map[protocol.StreamID]*stream{},
openStreams: make([]protocol.StreamID, 0), openStreams: make([]protocol.StreamID, 0),
newStream: newStream, newStream: newStream,
connectionParameters: connectionParameters, connParams: connParams,
} }
sm.nextStreamOrErrCond.L = &sm.mutex sm.nextStreamOrErrCond.L = &sm.mutex
sm.openStreamOrErrCond.L = &sm.mutex sm.openStreamOrErrCond.L = &sm.mutex
@ -125,7 +125,7 @@ func (m *streamsMap) GetOrOpenStream(id protocol.StreamID) (*stream, error) {
} }
func (m *streamsMap) openRemoteStream(id protocol.StreamID) (*stream, error) { func (m *streamsMap) openRemoteStream(id protocol.StreamID) (*stream, error) {
if m.numIncomingStreams >= m.connectionParameters.GetMaxIncomingStreams() { if m.numIncomingStreams >= m.connParams.GetMaxIncomingStreams() {
return nil, qerr.TooManyOpenStreams return nil, qerr.TooManyOpenStreams
} }
if id+protocol.MaxNewStreamIDDelta < m.highestStreamOpenedByPeer { if id+protocol.MaxNewStreamIDDelta < m.highestStreamOpenedByPeer {
@ -149,7 +149,7 @@ func (m *streamsMap) openRemoteStream(id protocol.StreamID) (*stream, error) {
func (m *streamsMap) openStreamImpl() (*stream, error) { func (m *streamsMap) openStreamImpl() (*stream, error) {
id := m.nextStream id := m.nextStream
if m.numOutgoingStreams >= m.connectionParameters.GetMaxOutgoingStreams() { if m.numOutgoingStreams >= m.connParams.GetMaxOutgoingStreams() {
return nil, qerr.TooManyOpenStreams return nil, qerr.TooManyOpenStreams
} }

10
streams_map_test.go
View file

@ -18,16 +18,16 @@ var _ = Describe("Streams Map", func() {
var ( var (
m *streamsMap m *streamsMap
mockCpm *mocks.MockConnectionParametersManager mockPn *mocks.MockParamsNegotiator
) )
setNewStreamsMap := func(p protocol.Perspective) { setNewStreamsMap := func(p protocol.Perspective) {
mockCpm = mocks.NewMockConnectionParametersManager(mockCtrl) mockPn = mocks.NewMockParamsNegotiator(mockCtrl)
mockCpm.EXPECT().GetMaxOutgoingStreams().AnyTimes().Return(uint32(maxOutgoingStreams)) mockPn.EXPECT().GetMaxOutgoingStreams().AnyTimes().Return(uint32(maxOutgoingStreams))
mockCpm.EXPECT().GetMaxIncomingStreams().AnyTimes().Return(uint32(maxIncomingStreams)) mockPn.EXPECT().GetMaxIncomingStreams().AnyTimes().Return(uint32(maxIncomingStreams))
m = newStreamsMap(nil, p, mockCpm) m = newStreamsMap(nil, p, mockPn)
m.newStream = func(id protocol.StreamID) *stream { m.newStream = func(id protocol.StreamID) *stream {
return newStream(id, nil, nil, nil) return newStream(id, nil, nil, nil)
} }