gr1ffon/quic-go
1
0
Fork 0
forked from quic-go/quic-go
Code Pull Requests Activity

create interface for the ConnectionParametersManager

Browse Source
This commit is contained in:
Marten Seemann
2016-12-08 18:39:14 +07:00
parent 5af50c8fd0
commit ebc053dbe0
15 changed files with 108 additions and 94 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
benchmark_test.go
View File

@@ -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()

12
flowcontrol/flow_control_manager.go
View File

@@ -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
}

4
flowcontrol/flow_control_manager_test.go
View File

@@ -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)

20
flowcontrol/flow_controller.go
View File

@@ -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
}

12
flowcontrol/flow_controller_test.go
View File

@@ -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() {

52
handshake/connection_parameters_manager.go
View File

@@ -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

4
handshake/connection_parameters_manager_test.go
View File

@@ -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() {

26
handshake/crypto_setup.go
View File

@@ -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

2
handshake/crypto_setup_test.go
View File

@@ -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

18
packet_packer.go
View File

@@ -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(),
}

8
packet_packer_test.go
View File

@@ -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

22
session.go
View File

@@ -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
}

8
session_test.go
View File

@@ -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)

6
streams_map.go
View File

@@ -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,
}
}

2
streams_map_test.go
View File

@@ -12,7 +12,7 @@ import (
var _ = Describe("Streams Map", func() {
var (
cpm *handshake.ConnectionParametersManager
cpm handshake.ConnectionParametersManager
m *streamsMap
)