diff --git a/client.go b/client.go index b30ab56e8f3..c29a1c2955c 100644 --- a/client.go +++ b/client.go @@ -280,7 +280,7 @@ func newClient( func (c *client) dial(ctx context.Context) error { c.logger.Infof("Starting new connection to %s (%s -> %s), source connection ID %s, destination connection ID %s, version %s", c.tlsConf.ServerName, c.sconn.LocalAddr(), c.sconn.RemoteAddr(), c.srcConnID, c.destConnID, c.version) - c.conn = newClientSession( + c.conn = newClientConnection( c.sconn, c.packetHandlers, c.destConnID, diff --git a/client_test.go b/client_test.go index 24fff649703..c7fbc0d3885 100644 --- a/client_test.go +++ b/client_test.go @@ -31,7 +31,7 @@ var _ = Describe("Client", func() { tracer *mocklogging.MockConnectionTracer config *Config - originalClientSessConstructor func( + originalClientConnConstructor func( conn sendConn, runner connRunner, destConnID protocol.ConnectionID, @@ -51,7 +51,7 @@ var _ = Describe("Client", func() { BeforeEach(func() { tlsConf = &tls.Config{NextProtos: []string{"proto1"}} connID = protocol.ConnectionID{0, 0, 0, 0, 0, 0, 0x13, 0x37} - originalClientSessConstructor = newClientSession + originalClientConnConstructor = newClientConnection tracer = mocklogging.NewMockConnectionTracer(mockCtrl) tr := mocklogging.NewMockTracer(mockCtrl) tr.EXPECT().TracerForConnection(gomock.Any(), protocol.PerspectiveClient, gomock.Any()).Return(tracer).MaxTimes(1) @@ -77,11 +77,11 @@ var _ = Describe("Client", func() { AfterEach(func() { connMuxer = origMultiplexer - newClientSession = originalClientSessConstructor + newClientConnection = originalClientConnConstructor }) AfterEach(func() { - if s, ok := cl.conn.(*session); ok { + if s, ok := cl.conn.(*connection); ok { s.shutdown() } Eventually(areConnsRunning).Should(BeFalse()) @@ -118,7 +118,7 @@ var _ = Describe("Client", func() { mockMultiplexer.EXPECT().AddConn(gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any()).Return(manager, nil) remoteAddrChan := make(chan string, 1) - newClientSession = func( + newClientConnection = func( sconn sendConn, _ connRunner, _ protocol.ConnectionID, @@ -151,7 +151,7 @@ var _ = Describe("Client", func() { mockMultiplexer.EXPECT().AddConn(gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any()).Return(manager, nil) hostnameChan := make(chan string, 1) - newClientSession = func( + newClientConnection = func( _ sendConn, _ connRunner, _ protocol.ConnectionID, @@ -184,7 +184,7 @@ var _ = Describe("Client", func() { mockMultiplexer.EXPECT().AddConn(packetConn, gomock.Any(), gomock.Any(), gomock.Any()).Return(manager, nil) hostnameChan := make(chan string, 1) - newClientSession = func( + newClientConnection = func( _ sendConn, _ connRunner, _ protocol.ConnectionID, @@ -223,7 +223,7 @@ var _ = Describe("Client", func() { mockMultiplexer.EXPECT().AddConn(packetConn, gomock.Any(), gomock.Any(), gomock.Any()).Return(manager, nil) run := make(chan struct{}) - newClientSession = func( + newClientConnection = func( _ sendConn, runner connRunner, _ protocol.ConnectionID, @@ -266,7 +266,7 @@ var _ = Describe("Client", func() { readyChan := make(chan struct{}) done := make(chan struct{}) - newClientSession = func( + newClientConnection = func( _ sendConn, runner connRunner, _ protocol.ConnectionID, @@ -314,7 +314,7 @@ var _ = Describe("Client", func() { mockMultiplexer.EXPECT().AddConn(packetConn, gomock.Any(), gomock.Any(), gomock.Any()).Return(manager, nil) testErr := errors.New("early handshake error") - newClientSession = func( + newClientConnection = func( _ sendConn, _ connRunner, _ protocol.ConnectionID, @@ -357,7 +357,7 @@ var _ = Describe("Client", func() { <-connRunning }) conn.EXPECT().HandshakeComplete().Return(context.Background()) - newClientSession = func( + newClientConnection = func( _ sendConn, _ connRunner, _ protocol.ConnectionID, @@ -409,7 +409,7 @@ var _ = Describe("Client", func() { run := make(chan struct{}) connCreated := make(chan struct{}) conn := NewMockQuicConn(mockCtrl) - newClientSession = func( + newClientConnection = func( connP sendConn, _ connRunner, _ protocol.ConnectionID, @@ -529,7 +529,7 @@ var _ = Describe("Client", func() { var cconn sendConn var version protocol.VersionNumber var conf *Config - newClientSession = func( + newClientConnection = func( connP sendConn, _ connRunner, _ protocol.ConnectionID, @@ -569,7 +569,7 @@ var _ = Describe("Client", func() { mockMultiplexer.EXPECT().AddConn(gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any()).Return(manager, nil) var counter int - newClientSession = func( + newClientConnection = func( _ sendConn, _ connRunner, _ protocol.ConnectionID, diff --git a/conn_id_generator_test.go b/conn_id_generator_test.go index 26efae2cb85..8162b2ff6f8 100644 --- a/conn_id_generator_test.go +++ b/conn_id_generator_test.go @@ -171,7 +171,7 @@ var _ = Describe("Connection ID Generator", func() { } }) - It("replaces with a closed session for all connection IDs", func() { + It("replaces with a closed connection for all connection IDs", func() { Expect(g.SetMaxActiveConnIDs(5)).To(Succeed()) Expect(queuedFrames).To(HaveLen(4)) sess := NewMockPacketHandler(mockCtrl) diff --git a/session.go b/connection.go similarity index 89% rename from session.go rename to connection.go index d0835de49bd..9c25f89eb97 100644 --- a/session.go +++ b/connection.go @@ -124,14 +124,14 @@ type errCloseForRecreating struct { } func (e *errCloseForRecreating) Error() string { - return "closing session in order to recreate it" + return "closing connection in order to recreate it" } var connTracingID uint64 // to be accessed atomically func nextConnTracingID() uint64 { return atomic.AddUint64(&connTracingID, 1) } -// A Connection is a QUIC session -type session struct { +// A Connection is a QUIC connection +type connection struct { // Destination connection ID used during the handshake. // Used to check source connection ID on incoming packets. handshakeDestConnID protocol.ConnectionID @@ -197,8 +197,8 @@ type session struct { versionNegotiated bool receivedFirstPacket bool - idleTimeout time.Duration - sessionCreationTime time.Time + idleTimeout time.Duration + creationTime time.Time // The idle timeout is set based on the max of the time we received the last packet... lastPacketReceivedTime time.Time // ... and the time we sent a new ack-eliciting packet after receiving a packet. @@ -222,13 +222,13 @@ type session struct { } var ( - _ Connection = &session{} - _ EarlyConnection = &session{} - _ streamSender = &session{} + _ Connection = &connection{} + _ EarlyConnection = &connection{} + _ streamSender = &connection{} deadlineSendImmediately = time.Time{}.Add(42 * time.Millisecond) // any value > time.Time{} and before time.Now() is fine ) -var newSession = func( +var newConnection = func( conn sendConn, runner connRunner, origDestConnID protocol.ConnectionID, @@ -246,7 +246,7 @@ var newSession = func( logger utils.Logger, v protocol.VersionNumber, ) quicConn { - s := &session{ + s := &connection{ conn: conn, config: conf, handshakeDestConnID: destConnID, @@ -362,7 +362,7 @@ var newSession = func( } // declare this as a variable, such that we can it mock it in the tests -var newClientSession = func( +var newClientConnection = func( conn sendConn, runner connRunner, destConnID protocol.ConnectionID, @@ -377,7 +377,7 @@ var newClientSession = func( logger utils.Logger, v protocol.VersionNumber, ) quicConn { - s := &session{ + s := &connection{ conn: conn, config: conf, origDestConnID: destConnID, @@ -493,7 +493,7 @@ var newClientSession = func( return s } -func (s *session) preSetup() { +func (s *connection) preSetup() { s.sendQueue = newSendQueue(s.conn) s.retransmissionQueue = newRetransmissionQueue(s.version) s.frameParser = wire.NewFrameParser(s.config.EnableDatagrams, s.version) @@ -521,14 +521,14 @@ func (s *session) preSetup() { s.version, ) s.framer = newFramer(s.streamsMap, s.version) - s.receivedPackets = make(chan *receivedPacket, protocol.MaxSessionUnprocessedPackets) + s.receivedPackets = make(chan *receivedPacket, protocol.MaxConnUnprocessedPackets) s.closeChan = make(chan closeError, 1) s.sendingScheduled = make(chan struct{}, 1) s.handshakeCtx, s.handshakeCtxCancel = context.WithCancel(context.Background()) now := time.Now() s.lastPacketReceivedTime = now - s.sessionCreationTime = now + s.creationTime = now s.windowUpdateQueue = newWindowUpdateQueue(s.streamsMap, s.connFlowController, s.framer.QueueControlFrame) if s.config.EnableDatagrams { @@ -536,8 +536,8 @@ func (s *session) preSetup() { } } -// run the session main loop -func (s *session) run() error { +// run the connection main loop +func (s *connection) run() error { defer s.ctxCancel() s.timer = utils.NewTimer() @@ -589,7 +589,7 @@ runLoop: if processed := s.handlePacketImpl(p); processed { processedUndecryptablePacket = true } - // Don't set timers and send packets if the packet made us close the session. + // Don't set timers and send packets if the packet made us close the connection. select { case closeErr = <-s.closeChan: break runLoop @@ -612,7 +612,7 @@ runLoop: case <-sendQueueAvailable: case firstPacket := <-s.receivedPackets: wasProcessed := s.handlePacketImpl(firstPacket) - // Don't set timers and send packets if the packet made us close the session. + // Don't set timers and send packets if the packet made us close the connection. select { case closeErr = <-s.closeChan: break runLoop @@ -661,11 +661,11 @@ runLoop: } if keepAliveTime := s.nextKeepAliveTime(); !keepAliveTime.IsZero() && !now.Before(keepAliveTime) { - // send a PING frame since there is no activity in the session + // send a PING frame since there is no activity in the connection s.logger.Debugf("Sending a keep-alive PING to keep the connection alive.") s.framer.QueueControlFrame(&wire.PingFrame{}) s.keepAlivePingSent = true - } else if !s.handshakeComplete && now.Sub(s.sessionCreationTime) >= s.config.handshakeTimeout() { + } else if !s.handshakeComplete && now.Sub(s.creationTime) >= s.config.handshakeTimeout() { s.destroyImpl(qerr.ErrHandshakeTimeout) continue } else { @@ -704,24 +704,24 @@ runLoop: return closeErr.err } -// blocks until the early session can be used -func (s *session) earlyConnReady() <-chan struct{} { +// blocks until the early connection can be used +func (s *connection) earlyConnReady() <-chan struct{} { return s.earlyConnReadyChan } -func (s *session) HandshakeComplete() context.Context { +func (s *connection) HandshakeComplete() context.Context { return s.handshakeCtx } -func (s *session) Context() context.Context { +func (s *connection) Context() context.Context { return s.ctx } -func (s *session) supportsDatagrams() bool { +func (s *connection) supportsDatagrams() bool { return s.peerParams.MaxDatagramFrameSize != protocol.InvalidByteCount } -func (s *session) ConnectionState() ConnectionState { +func (s *connection) ConnectionState() ConnectionState { return ConnectionState{ TLS: s.cryptoStreamHandler.ConnectionState(), SupportsDatagrams: s.supportsDatagrams(), @@ -730,18 +730,18 @@ func (s *session) ConnectionState() ConnectionState { // Time when the next keep-alive packet should be sent. // It returns a zero time if no keep-alive should be sent. -func (s *session) nextKeepAliveTime() time.Time { +func (s *connection) nextKeepAliveTime() time.Time { if !s.config.KeepAlive || s.keepAlivePingSent || !s.firstAckElicitingPacketAfterIdleSentTime.IsZero() { return time.Time{} } return s.lastPacketReceivedTime.Add(s.keepAliveInterval) } -func (s *session) maybeResetTimer() { +func (s *connection) maybeResetTimer() { var deadline time.Time if !s.handshakeComplete { deadline = utils.MinTime( - s.sessionCreationTime.Add(s.config.handshakeTimeout()), + s.creationTime.Add(s.config.handshakeTimeout()), s.idleTimeoutStartTime().Add(s.config.HandshakeIdleTimeout), ) } else { @@ -770,11 +770,11 @@ func (s *session) maybeResetTimer() { s.timer.Reset(deadline) } -func (s *session) idleTimeoutStartTime() time.Time { +func (s *connection) idleTimeoutStartTime() time.Time { return utils.MaxTime(s.lastPacketReceivedTime, s.firstAckElicitingPacketAfterIdleSentTime) } -func (s *session) handleHandshakeComplete() { +func (s *connection) handleHandshakeComplete() { s.handshakeComplete = true s.handshakeCompleteChan = nil // prevent this case from ever being selected again defer s.handshakeCtxCancel() @@ -810,7 +810,7 @@ func (s *session) handleHandshakeComplete() { s.queueControlFrame(&wire.HandshakeDoneFrame{}) } -func (s *session) handleHandshakeConfirmed() { +func (s *connection) handleHandshakeConfirmed() { s.handshakeConfirmed = true s.sentPacketHandler.SetHandshakeConfirmed() s.cryptoStreamHandler.SetHandshakeConfirmed() @@ -833,7 +833,7 @@ func (s *session) handleHandshakeConfirmed() { } } -func (s *session) handlePacketImpl(rp *receivedPacket) bool { +func (s *connection) handlePacketImpl(rp *receivedPacket) bool { s.sentPacketHandler.ReceivedBytes(rp.Size()) if wire.IsVersionNegotiationPacket(rp.data) { @@ -901,7 +901,7 @@ func (s *session) handlePacketImpl(rp *receivedPacket) bool { return processed } -func (s *session) handleSinglePacket(p *receivedPacket, hdr *wire.Header) bool /* was the packet successfully processed */ { +func (s *connection) handleSinglePacket(p *receivedPacket, hdr *wire.Header) bool /* was the packet successfully processed */ { var wasQueued bool defer func() { @@ -993,7 +993,7 @@ func (s *session) handleSinglePacket(p *receivedPacket, hdr *wire.Header) bool / return true } -func (s *session) handleRetryPacket(hdr *wire.Header, data []byte) bool /* was this a valid Retry */ { +func (s *connection) handleRetryPacket(hdr *wire.Header, data []byte) bool /* was this a valid Retry */ { if s.perspective == protocol.PerspectiveServer { if s.tracer != nil { s.tracer.DroppedPacket(logging.PacketTypeRetry, protocol.ByteCount(len(data)), logging.PacketDropUnexpectedPacket) @@ -1055,7 +1055,7 @@ func (s *session) handleRetryPacket(hdr *wire.Header, data []byte) bool /* was t return true } -func (s *session) handleVersionNegotiationPacket(p *receivedPacket) { +func (s *connection) handleVersionNegotiationPacket(p *receivedPacket) { if s.perspective == protocol.PerspectiveServer || // servers never receive version negotiation packets s.receivedFirstPacket || s.versionNegotiated { // ignore delayed / duplicated version negotiation packets if s.tracer != nil { @@ -1109,7 +1109,7 @@ func (s *session) handleVersionNegotiationPacket(p *receivedPacket) { }) } -func (s *session) handleUnpackedPacket( +func (s *connection) handleUnpackedPacket( packet *unpackedPacket, ecn protocol.ECN, rcvTime time.Time, @@ -1141,10 +1141,10 @@ func (s *session) handleUnpackedPacket( s.handshakeDestConnID = cid s.connIDManager.ChangeInitialConnID(cid) } - // We create the session as soon as we receive the first packet from the client. + // We create the connection as soon as we receive the first packet from the client. // We do that before authenticating the packet. // That means that if the source connection ID was corrupted, - // we might have create a session with an incorrect source connection ID. + // we might have create a connection with an incorrect source connection ID. // Once we authenticate the first packet, we need to update it. if s.perspective == protocol.PerspectiveServer { if !packet.hdr.SrcConnectionID.Equal(s.handshakeDestConnID) { @@ -1209,7 +1209,7 @@ func (s *session) handleUnpackedPacket( return s.receivedPacketHandler.ReceivedPacket(packet.packetNumber, ecn, packet.encryptionLevel, rcvTime, isAckEliciting) } -func (s *session) handleFrame(f wire.Frame, encLevel protocol.EncryptionLevel, destConnID protocol.ConnectionID) error { +func (s *connection) handleFrame(f wire.Frame, encLevel protocol.EncryptionLevel, destConnID protocol.ConnectionID) error { var err error wire.LogFrame(s.logger, f, false) switch frame := f.(type) { @@ -1257,9 +1257,9 @@ func (s *session) handleFrame(f wire.Frame, encLevel protocol.EncryptionLevel, d } // handlePacket is called by the server with a new packet -func (s *session) handlePacket(p *receivedPacket) { +func (s *connection) handlePacket(p *receivedPacket) { // Discard packets once the amount of queued packets is larger than - // the channel size, protocol.MaxSessionUnprocessedPackets + // the channel size, protocol.MaxConnUnprocessedPackets select { case s.receivedPackets <- p: default: @@ -1269,7 +1269,7 @@ func (s *session) handlePacket(p *receivedPacket) { } } -func (s *session) handleConnectionCloseFrame(frame *wire.ConnectionCloseFrame) { +func (s *connection) handleConnectionCloseFrame(frame *wire.ConnectionCloseFrame) { if frame.IsApplicationError { s.closeRemote(&qerr.ApplicationError{ Remote: true, @@ -1286,7 +1286,7 @@ func (s *session) handleConnectionCloseFrame(frame *wire.ConnectionCloseFrame) { }) } -func (s *session) handleCryptoFrame(frame *wire.CryptoFrame, encLevel protocol.EncryptionLevel) error { +func (s *connection) handleCryptoFrame(frame *wire.CryptoFrame, encLevel protocol.EncryptionLevel) error { encLevelChanged, err := s.cryptoStreamManager.HandleCryptoFrame(frame, encLevel) if err != nil { return err @@ -1299,7 +1299,7 @@ func (s *session) handleCryptoFrame(frame *wire.CryptoFrame, encLevel protocol.E return nil } -func (s *session) handleStreamFrame(frame *wire.StreamFrame) error { +func (s *connection) handleStreamFrame(frame *wire.StreamFrame) error { str, err := s.streamsMap.GetOrOpenReceiveStream(frame.StreamID) if err != nil { return err @@ -1312,11 +1312,11 @@ func (s *session) handleStreamFrame(frame *wire.StreamFrame) error { return str.handleStreamFrame(frame) } -func (s *session) handleMaxDataFrame(frame *wire.MaxDataFrame) { +func (s *connection) handleMaxDataFrame(frame *wire.MaxDataFrame) { s.connFlowController.UpdateSendWindow(frame.MaximumData) } -func (s *session) handleMaxStreamDataFrame(frame *wire.MaxStreamDataFrame) error { +func (s *connection) handleMaxStreamDataFrame(frame *wire.MaxStreamDataFrame) error { str, err := s.streamsMap.GetOrOpenSendStream(frame.StreamID) if err != nil { return err @@ -1329,11 +1329,11 @@ func (s *session) handleMaxStreamDataFrame(frame *wire.MaxStreamDataFrame) error return nil } -func (s *session) handleMaxStreamsFrame(frame *wire.MaxStreamsFrame) { +func (s *connection) handleMaxStreamsFrame(frame *wire.MaxStreamsFrame) { s.streamsMap.HandleMaxStreamsFrame(frame) } -func (s *session) handleResetStreamFrame(frame *wire.ResetStreamFrame) error { +func (s *connection) handleResetStreamFrame(frame *wire.ResetStreamFrame) error { str, err := s.streamsMap.GetOrOpenReceiveStream(frame.StreamID) if err != nil { return err @@ -1345,7 +1345,7 @@ func (s *session) handleResetStreamFrame(frame *wire.ResetStreamFrame) error { return str.handleResetStreamFrame(frame) } -func (s *session) handleStopSendingFrame(frame *wire.StopSendingFrame) error { +func (s *connection) handleStopSendingFrame(frame *wire.StopSendingFrame) error { str, err := s.streamsMap.GetOrOpenSendStream(frame.StreamID) if err != nil { return err @@ -1358,11 +1358,11 @@ func (s *session) handleStopSendingFrame(frame *wire.StopSendingFrame) error { return nil } -func (s *session) handlePathChallengeFrame(frame *wire.PathChallengeFrame) { +func (s *connection) handlePathChallengeFrame(frame *wire.PathChallengeFrame) { s.queueControlFrame(&wire.PathResponseFrame{Data: frame.Data}) } -func (s *session) handleNewTokenFrame(frame *wire.NewTokenFrame) error { +func (s *connection) handleNewTokenFrame(frame *wire.NewTokenFrame) error { if s.perspective == protocol.PerspectiveServer { return &qerr.TransportError{ ErrorCode: qerr.ProtocolViolation, @@ -1375,15 +1375,15 @@ func (s *session) handleNewTokenFrame(frame *wire.NewTokenFrame) error { return nil } -func (s *session) handleNewConnectionIDFrame(f *wire.NewConnectionIDFrame) error { +func (s *connection) handleNewConnectionIDFrame(f *wire.NewConnectionIDFrame) error { return s.connIDManager.Add(f) } -func (s *session) handleRetireConnectionIDFrame(f *wire.RetireConnectionIDFrame, destConnID protocol.ConnectionID) error { +func (s *connection) handleRetireConnectionIDFrame(f *wire.RetireConnectionIDFrame, destConnID protocol.ConnectionID) error { return s.connIDGenerator.Retire(f.SequenceNumber, destConnID) } -func (s *session) handleHandshakeDoneFrame() error { +func (s *connection) handleHandshakeDoneFrame() error { if s.perspective == protocol.PerspectiveServer { return &qerr.TransportError{ ErrorCode: qerr.ProtocolViolation, @@ -1396,7 +1396,7 @@ func (s *session) handleHandshakeDoneFrame() error { return nil } -func (s *session) handleAckFrame(frame *wire.AckFrame, encLevel protocol.EncryptionLevel) error { +func (s *connection) handleAckFrame(frame *wire.AckFrame, encLevel protocol.EncryptionLevel) error { acked1RTTPacket, err := s.sentPacketHandler.ReceivedAck(frame, encLevel, s.lastPacketReceivedTime) if err != nil { return err @@ -1410,7 +1410,7 @@ func (s *session) handleAckFrame(frame *wire.AckFrame, encLevel protocol.Encrypt return s.cryptoStreamHandler.SetLargest1RTTAcked(frame.LargestAcked()) } -func (s *session) handleDatagramFrame(f *wire.DatagramFrame) error { +func (s *connection) handleDatagramFrame(f *wire.DatagramFrame) error { if f.Length(s.version) > protocol.MaxDatagramFrameSize { return &qerr.TransportError{ ErrorCode: qerr.ProtocolViolation, @@ -1421,50 +1421,50 @@ func (s *session) handleDatagramFrame(f *wire.DatagramFrame) error { return nil } -// closeLocal closes the session and send a CONNECTION_CLOSE containing the error -func (s *session) closeLocal(e error) { +// closeLocal closes the connection and send a CONNECTION_CLOSE containing the error +func (s *connection) closeLocal(e error) { s.closeOnce.Do(func() { if e == nil { - s.logger.Infof("Closing session.") + s.logger.Infof("Closing connection.") } else { - s.logger.Errorf("Closing session with error: %s", e) + s.logger.Errorf("Closing connection with error: %s", e) } s.closeChan <- closeError{err: e, immediate: false, remote: false} }) } -// destroy closes the session without sending the error on the wire -func (s *session) destroy(e error) { +// destroy closes the connection without sending the error on the wire +func (s *connection) destroy(e error) { s.destroyImpl(e) <-s.ctx.Done() } -func (s *session) destroyImpl(e error) { +func (s *connection) destroyImpl(e error) { s.closeOnce.Do(func() { if nerr, ok := e.(net.Error); ok && nerr.Timeout() { - s.logger.Errorf("Destroying session: %s", e) + s.logger.Errorf("Destroying connection: %s", e) } else { - s.logger.Errorf("Destroying session with error: %s", e) + s.logger.Errorf("Destroying connection with error: %s", e) } s.closeChan <- closeError{err: e, immediate: true, remote: false} }) } -func (s *session) closeRemote(e error) { +func (s *connection) closeRemote(e error) { s.closeOnce.Do(func() { - s.logger.Errorf("Peer closed session with error: %s", e) + s.logger.Errorf("Peer closed connection with error: %s", e) s.closeChan <- closeError{err: e, immediate: true, remote: true} }) } // Close the connection. It sends a NO_ERROR application error. // It waits until the run loop has stopped before returning -func (s *session) shutdown() { +func (s *connection) shutdown() { s.closeLocal(nil) <-s.ctx.Done() } -func (s *session) CloseWithError(code ApplicationErrorCode, desc string) error { +func (s *connection) CloseWithError(code ApplicationErrorCode, desc string) error { s.closeLocal(&qerr.ApplicationError{ ErrorCode: code, ErrorMessage: desc, @@ -1473,7 +1473,7 @@ func (s *session) CloseWithError(code ApplicationErrorCode, desc string) error { return nil } -func (s *session) handleCloseError(closeErr *closeError) { +func (s *connection) handleCloseError(closeErr *closeError) { e := closeErr.err if e == nil { e = &qerr.ApplicationError{} @@ -1532,7 +1532,7 @@ func (s *session) handleCloseError(closeErr *closeError) { s.connIDGenerator.ReplaceWithClosed(cs) } -func (s *session) dropEncryptionLevel(encLevel protocol.EncryptionLevel) { +func (s *connection) dropEncryptionLevel(encLevel protocol.EncryptionLevel) { s.sentPacketHandler.DropPackets(encLevel) s.receivedPacketHandler.DropPackets(encLevel) if s.tracer != nil { @@ -1550,7 +1550,7 @@ func (s *session) dropEncryptionLevel(encLevel protocol.EncryptionLevel) { } // is called for the client, when restoring transport parameters saved for 0-RTT -func (s *session) restoreTransportParameters(params *wire.TransportParameters) { +func (s *connection) restoreTransportParameters(params *wire.TransportParameters) { if s.logger.Debug() { s.logger.Debugf("Restoring Transport Parameters: %s", params) } @@ -1561,7 +1561,7 @@ func (s *session) restoreTransportParameters(params *wire.TransportParameters) { s.streamsMap.UpdateLimits(params) } -func (s *session) handleTransportParameters(params *wire.TransportParameters) { +func (s *connection) handleTransportParameters(params *wire.TransportParameters) { if err := s.checkTransportParameters(params); err != nil { s.closeLocal(&qerr.TransportError{ ErrorCode: qerr.TransportParameterError, @@ -1573,13 +1573,13 @@ func (s *session) handleTransportParameters(params *wire.TransportParameters) { // During a 0-RTT connection, we are only allowed to use the new transport parameters for 1-RTT packets. if s.perspective == protocol.PerspectiveServer { s.applyTransportParameters() - // On the server side, the early session is ready as soon as we processed + // On the server side, the early connection is ready as soon as we processed // the client's transport parameters. close(s.earlyConnReadyChan) } } -func (s *session) checkTransportParameters(params *wire.TransportParameters) error { +func (s *connection) checkTransportParameters(params *wire.TransportParameters) error { if s.logger.Debug() { s.logger.Debugf("Processed Transport Parameters: %s", params) } @@ -1612,7 +1612,7 @@ func (s *session) checkTransportParameters(params *wire.TransportParameters) err return nil } -func (s *session) applyTransportParameters() { +func (s *connection) applyTransportParameters() { params := s.peerParams // Our local idle timeout will always be > 0. s.idleTimeout = utils.MinNonZeroDuration(s.config.MaxIdleTimeout, params.MaxIdleTimeout) @@ -1633,7 +1633,7 @@ func (s *session) applyTransportParameters() { } } -func (s *session) sendPackets() error { +func (s *connection) sendPackets() error { s.pacingDeadline = time.Time{} var sentPacket bool // only used in for packets sent in send mode SendAny @@ -1699,7 +1699,7 @@ func (s *session) sendPackets() error { } } -func (s *session) maybeSendAckOnlyPacket() error { +func (s *connection) maybeSendAckOnlyPacket() error { packet, err := s.packer.MaybePackAckPacket(s.handshakeConfirmed) if err != nil { return err @@ -1711,7 +1711,7 @@ func (s *session) maybeSendAckOnlyPacket() error { return nil } -func (s *session) sendProbePacket(encLevel protocol.EncryptionLevel) error { +func (s *connection) sendProbePacket(encLevel protocol.EncryptionLevel) error { // Queue probe packets until we actually send out a packet, // or until there are no more packets to queue. var packet *packedPacket @@ -1747,13 +1747,13 @@ func (s *session) sendProbePacket(encLevel protocol.EncryptionLevel) error { } } if packet == nil || packet.packetContents == nil { - return fmt.Errorf("session BUG: couldn't pack %s probe packet", encLevel) + return fmt.Errorf("connection BUG: couldn't pack %s probe packet", encLevel) } s.sendPackedPacket(packet, time.Now()) return nil } -func (s *session) sendPacket() (bool, error) { +func (s *connection) sendPacket() (bool, error) { if isBlocked, offset := s.connFlowController.IsNewlyBlocked(); isBlocked { s.framer.QueueControlFrame(&wire.DataBlockedFrame{MaximumData: offset}) } @@ -1792,7 +1792,7 @@ func (s *session) sendPacket() (bool, error) { return true, nil } -func (s *session) sendPackedPacket(packet *packedPacket, now time.Time) { +func (s *connection) sendPackedPacket(packet *packedPacket, now time.Time) { if s.firstAckElicitingPacketAfterIdleSentTime.IsZero() && packet.IsAckEliciting() { s.firstAckElicitingPacketAfterIdleSentTime = now } @@ -1802,7 +1802,7 @@ func (s *session) sendPackedPacket(packet *packedPacket, now time.Time) { s.sendQueue.Send(packet.buffer) } -func (s *session) sendConnectionClose(e error) ([]byte, error) { +func (s *connection) sendConnectionClose(e error) ([]byte, error) { var packet *coalescedPacket var err error var transportErr *qerr.TransportError @@ -1814,7 +1814,7 @@ func (s *session) sendConnectionClose(e error) ([]byte, error) { } else { packet, err = s.packer.PackConnectionClose(&qerr.TransportError{ ErrorCode: qerr.InternalError, - ErrorMessage: fmt.Sprintf("session BUG: unspecified error type (msg: %s)", e.Error()), + ErrorMessage: fmt.Sprintf("connection BUG: unspecified error type (msg: %s)", e.Error()), }) } if err != nil { @@ -1824,7 +1824,7 @@ func (s *session) sendConnectionClose(e error) ([]byte, error) { return packet.buffer.Data, s.conn.Write(packet.buffer.Data) } -func (s *session) logPacketContents(p *packetContents) { +func (s *connection) logPacketContents(p *packetContents) { // tracing if s.tracer != nil { frames := make([]logging.Frame, 0, len(p.frames)) @@ -1847,7 +1847,7 @@ func (s *session) logPacketContents(p *packetContents) { } } -func (s *session) logCoalescedPacket(packet *coalescedPacket) { +func (s *connection) logCoalescedPacket(packet *coalescedPacket) { if s.logger.Debug() { if len(packet.packets) > 1 { s.logger.Debugf("-> Sending coalesced packet (%d parts, %d bytes) for connection %s", len(packet.packets), packet.buffer.Len(), s.logID) @@ -1860,7 +1860,7 @@ func (s *session) logCoalescedPacket(packet *coalescedPacket) { } } -func (s *session) logPacket(packet *packedPacket) { +func (s *connection) logPacket(packet *packedPacket) { if s.logger.Debug() { s.logger.Debugf("-> Sending packet %d (%d bytes) for connection %s, %s", packet.header.PacketNumber, packet.buffer.Len(), s.logID, packet.EncryptionLevel()) } @@ -1868,32 +1868,32 @@ func (s *session) logPacket(packet *packedPacket) { } // AcceptStream returns the next stream openend by the peer -func (s *session) AcceptStream(ctx context.Context) (Stream, error) { +func (s *connection) AcceptStream(ctx context.Context) (Stream, error) { return s.streamsMap.AcceptStream(ctx) } -func (s *session) AcceptUniStream(ctx context.Context) (ReceiveStream, error) { +func (s *connection) AcceptUniStream(ctx context.Context) (ReceiveStream, error) { return s.streamsMap.AcceptUniStream(ctx) } // OpenStream opens a stream -func (s *session) OpenStream() (Stream, error) { +func (s *connection) OpenStream() (Stream, error) { return s.streamsMap.OpenStream() } -func (s *session) OpenStreamSync(ctx context.Context) (Stream, error) { +func (s *connection) OpenStreamSync(ctx context.Context) (Stream, error) { return s.streamsMap.OpenStreamSync(ctx) } -func (s *session) OpenUniStream() (SendStream, error) { +func (s *connection) OpenUniStream() (SendStream, error) { return s.streamsMap.OpenUniStream() } -func (s *session) OpenUniStreamSync(ctx context.Context) (SendStream, error) { +func (s *connection) OpenUniStreamSync(ctx context.Context) (SendStream, error) { return s.streamsMap.OpenUniStreamSync(ctx) } -func (s *session) newFlowController(id protocol.StreamID) flowcontrol.StreamFlowController { +func (s *connection) newFlowController(id protocol.StreamID) flowcontrol.StreamFlowController { initialSendWindow := s.peerParams.InitialMaxStreamDataUni if id.Type() == protocol.StreamTypeBidi { if id.InitiatedBy() == s.perspective { @@ -1915,14 +1915,14 @@ func (s *session) newFlowController(id protocol.StreamID) flowcontrol.StreamFlow } // scheduleSending signals that we have data for sending -func (s *session) scheduleSending() { +func (s *connection) scheduleSending() { select { case s.sendingScheduled <- struct{}{}: default: } } -func (s *session) tryQueueingUndecryptablePacket(p *receivedPacket, hdr *wire.Header) { +func (s *connection) tryQueueingUndecryptablePacket(p *receivedPacket, hdr *wire.Header) { if s.handshakeComplete { panic("shouldn't queue undecryptable packets after handshake completion") } @@ -1940,33 +1940,33 @@ func (s *session) tryQueueingUndecryptablePacket(p *receivedPacket, hdr *wire.He s.undecryptablePackets = append(s.undecryptablePackets, p) } -func (s *session) queueControlFrame(f wire.Frame) { +func (s *connection) queueControlFrame(f wire.Frame) { s.framer.QueueControlFrame(f) s.scheduleSending() } -func (s *session) onHasStreamWindowUpdate(id protocol.StreamID) { +func (s *connection) onHasStreamWindowUpdate(id protocol.StreamID) { s.windowUpdateQueue.AddStream(id) s.scheduleSending() } -func (s *session) onHasConnectionWindowUpdate() { +func (s *connection) onHasConnectionWindowUpdate() { s.windowUpdateQueue.AddConnection() s.scheduleSending() } -func (s *session) onHasStreamData(id protocol.StreamID) { +func (s *connection) onHasStreamData(id protocol.StreamID) { s.framer.AddActiveStream(id) s.scheduleSending() } -func (s *session) onStreamCompleted(id protocol.StreamID) { +func (s *connection) onStreamCompleted(id protocol.StreamID) { if err := s.streamsMap.DeleteStream(id); err != nil { s.closeLocal(err) } } -func (s *session) SendMessage(p []byte) error { +func (s *connection) SendMessage(p []byte) error { f := &wire.DatagramFrame{DataLenPresent: true} if protocol.ByteCount(len(p)) > f.MaxDataLen(s.peerParams.MaxDatagramFrameSize, s.version) { return errors.New("message too large") @@ -1976,27 +1976,27 @@ func (s *session) SendMessage(p []byte) error { return s.datagramQueue.AddAndWait(f) } -func (s *session) ReceiveMessage() ([]byte, error) { +func (s *connection) ReceiveMessage() ([]byte, error) { return s.datagramQueue.Receive() } -func (s *session) LocalAddr() net.Addr { +func (s *connection) LocalAddr() net.Addr { return s.conn.LocalAddr() } -func (s *session) RemoteAddr() net.Addr { +func (s *connection) RemoteAddr() net.Addr { return s.conn.RemoteAddr() } -func (s *session) getPerspective() protocol.Perspective { +func (s *connection) getPerspective() protocol.Perspective { return s.perspective } -func (s *session) GetVersion() protocol.VersionNumber { +func (s *connection) GetVersion() protocol.VersionNumber { return s.version } -func (s *session) NextConnection() Connection { +func (s *connection) NextConnection() Connection { <-s.HandshakeComplete().Done() s.streamsMap.UseResetMaps() return s diff --git a/session_test.go b/connection_test.go similarity index 85% rename from session_test.go rename to connection_test.go index fa2ac77ec2e..665feed72fa 100644 --- a/session_test.go +++ b/connection_test.go @@ -34,7 +34,7 @@ import ( func areConnsRunning() bool { var b bytes.Buffer pprof.Lookup("goroutine").WriteTo(&b, 1) - return strings.Contains(b.String(), "quic-go.(*session).run") + return strings.Contains(b.String(), "quic-go.(*connection).run") } func areClosedConnsRunning() bool { @@ -45,7 +45,7 @@ func areClosedConnsRunning() bool { var _ = Describe("Connection", func() { var ( - sess *session + conn *connection connRunner *MockConnRunner mconn *MockSendConn streamManager *MockStreamManager @@ -94,7 +94,7 @@ var _ = Describe("Connection", func() { tracer.EXPECT().SentTransportParameters(gomock.Any()) tracer.EXPECT().UpdatedKeyFromTLS(gomock.Any(), gomock.Any()).AnyTimes() tracer.EXPECT().UpdatedCongestionState(gomock.Any()) - sess = newSession( + conn = newConnection( mconn, connRunner, nil, @@ -111,15 +111,15 @@ var _ = Describe("Connection", func() { 1234, utils.DefaultLogger, protocol.VersionTLS, - ).(*session) + ).(*connection) streamManager = NewMockStreamManager(mockCtrl) - sess.streamsMap = streamManager + conn.streamsMap = streamManager packer = NewMockPacker(mockCtrl) - sess.packer = packer + conn.packer = packer cryptoSetup = mocks.NewMockCryptoSetup(mockCtrl) - sess.cryptoStreamHandler = cryptoSetup - sess.handshakeComplete = true - sess.idleTimeout = time.Hour + conn.cryptoStreamHandler = cryptoSetup + conn.handshakeComplete = true + conn.idleTimeout = time.Hour }) AfterEach(func() { @@ -136,7 +136,7 @@ var _ = Describe("Connection", func() { str := NewMockReceiveStreamI(mockCtrl) str.EXPECT().handleStreamFrame(f) streamManager.EXPECT().GetOrOpenReceiveStream(protocol.StreamID(5)).Return(str, nil) - Expect(sess.handleStreamFrame(f)).To(Succeed()) + Expect(conn.handleStreamFrame(f)).To(Succeed()) }) It("returns errors", func() { @@ -148,12 +148,12 @@ var _ = Describe("Connection", func() { str := NewMockReceiveStreamI(mockCtrl) str.EXPECT().handleStreamFrame(f).Return(testErr) streamManager.EXPECT().GetOrOpenReceiveStream(protocol.StreamID(5)).Return(str, nil) - Expect(sess.handleStreamFrame(f)).To(MatchError(testErr)) + Expect(conn.handleStreamFrame(f)).To(MatchError(testErr)) }) It("ignores STREAM frames for closed streams", func() { streamManager.EXPECT().GetOrOpenReceiveStream(protocol.StreamID(5)).Return(nil, nil) // for closed streams, the streamManager returns nil - Expect(sess.handleStreamFrame(&wire.StreamFrame{ + Expect(conn.handleStreamFrame(&wire.StreamFrame{ StreamID: 5, Data: []byte("foobar"), })).To(Succeed()) @@ -165,8 +165,8 @@ var _ = Describe("Connection", func() { f := &wire.AckFrame{AckRanges: []wire.AckRange{{Smallest: 2, Largest: 3}}} sph := mockackhandler.NewMockSentPacketHandler(mockCtrl) sph.EXPECT().ReceivedAck(f, protocol.EncryptionHandshake, gomock.Any()) - sess.sentPacketHandler = sph - err := sess.handleAckFrame(f, protocol.EncryptionHandshake) + conn.sentPacketHandler = sph + err := conn.handleAckFrame(f, protocol.EncryptionHandshake) Expect(err).ToNot(HaveOccurred()) }) }) @@ -181,7 +181,7 @@ var _ = Describe("Connection", func() { str := NewMockReceiveStreamI(mockCtrl) streamManager.EXPECT().GetOrOpenReceiveStream(protocol.StreamID(555)).Return(str, nil) str.EXPECT().handleResetStreamFrame(f) - err := sess.handleResetStreamFrame(f) + err := conn.handleResetStreamFrame(f) Expect(err).ToNot(HaveOccurred()) }) @@ -194,13 +194,13 @@ var _ = Describe("Connection", func() { str := NewMockReceiveStreamI(mockCtrl) streamManager.EXPECT().GetOrOpenReceiveStream(protocol.StreamID(7)).Return(str, nil) str.EXPECT().handleResetStreamFrame(f).Return(testErr) - err := sess.handleResetStreamFrame(f) + err := conn.handleResetStreamFrame(f) Expect(err).To(MatchError(testErr)) }) It("ignores RESET_STREAM frames for closed streams", func() { streamManager.EXPECT().GetOrOpenReceiveStream(protocol.StreamID(3)).Return(nil, nil) - Expect(sess.handleFrame(&wire.ResetStreamFrame{ + Expect(conn.handleFrame(&wire.ResetStreamFrame{ StreamID: 3, ErrorCode: 42, }, protocol.Encryption1RTT, protocol.ConnectionID{})).To(Succeed()) @@ -212,7 +212,7 @@ var _ = Describe("Connection", func() { BeforeEach(func() { connFC = mocks.NewMockConnectionFlowController(mockCtrl) - sess.connFlowController = connFC + conn.connFlowController = connFC }) It("updates the flow control window of a stream", func() { @@ -223,18 +223,18 @@ var _ = Describe("Connection", func() { str := NewMockSendStreamI(mockCtrl) streamManager.EXPECT().GetOrOpenSendStream(protocol.StreamID(12345)).Return(str, nil) str.EXPECT().updateSendWindow(protocol.ByteCount(0x1337)) - Expect(sess.handleMaxStreamDataFrame(f)).To(Succeed()) + Expect(conn.handleMaxStreamDataFrame(f)).To(Succeed()) }) It("updates the flow control window of the connection", func() { offset := protocol.ByteCount(0x800000) connFC.EXPECT().UpdateSendWindow(offset) - sess.handleMaxDataFrame(&wire.MaxDataFrame{MaximumData: offset}) + conn.handleMaxDataFrame(&wire.MaxDataFrame{MaximumData: offset}) }) It("ignores MAX_STREAM_DATA frames for a closed stream", func() { streamManager.EXPECT().GetOrOpenSendStream(protocol.StreamID(10)).Return(nil, nil) - Expect(sess.handleFrame(&wire.MaxStreamDataFrame{ + Expect(conn.handleFrame(&wire.MaxStreamDataFrame{ StreamID: 10, MaximumStreamData: 1337, }, protocol.Encryption1RTT, protocol.ConnectionID{})).To(Succeed()) @@ -248,7 +248,7 @@ var _ = Describe("Connection", func() { MaxStreamNum: 10, } streamManager.EXPECT().HandleMaxStreamsFrame(f) - sess.handleMaxStreamsFrame(f) + conn.handleMaxStreamsFrame(f) }) }) @@ -261,13 +261,13 @@ var _ = Describe("Connection", func() { str := NewMockSendStreamI(mockCtrl) streamManager.EXPECT().GetOrOpenSendStream(protocol.StreamID(5)).Return(str, nil) str.EXPECT().handleStopSendingFrame(f) - err := sess.handleStopSendingFrame(f) + err := conn.handleStopSendingFrame(f) Expect(err).ToNot(HaveOccurred()) }) It("ignores STOP_SENDING frames for a closed stream", func() { streamManager.EXPECT().GetOrOpenSendStream(protocol.StreamID(3)).Return(nil, nil) - Expect(sess.handleFrame(&wire.StopSendingFrame{ + Expect(conn.handleFrame(&wire.StopSendingFrame{ StreamID: 3, ErrorCode: 1337, }, protocol.Encryption1RTT, protocol.ConnectionID{})).To(Succeed()) @@ -275,50 +275,50 @@ var _ = Describe("Connection", func() { }) It("handles NEW_CONNECTION_ID frames", func() { - Expect(sess.handleFrame(&wire.NewConnectionIDFrame{ + Expect(conn.handleFrame(&wire.NewConnectionIDFrame{ SequenceNumber: 10, ConnectionID: protocol.ConnectionID{1, 2, 3, 4}, }, protocol.Encryption1RTT, protocol.ConnectionID{})).To(Succeed()) - Expect(sess.connIDManager.queue.Back().Value.ConnectionID).To(Equal(protocol.ConnectionID{1, 2, 3, 4})) + Expect(conn.connIDManager.queue.Back().Value.ConnectionID).To(Equal(protocol.ConnectionID{1, 2, 3, 4})) }) It("handles PING frames", func() { - err := sess.handleFrame(&wire.PingFrame{}, protocol.Encryption1RTT, protocol.ConnectionID{}) + err := conn.handleFrame(&wire.PingFrame{}, protocol.Encryption1RTT, protocol.ConnectionID{}) Expect(err).NotTo(HaveOccurred()) }) It("rejects PATH_RESPONSE frames", func() { - err := sess.handleFrame(&wire.PathResponseFrame{Data: [8]byte{1, 2, 3, 4, 5, 6, 7, 8}}, protocol.Encryption1RTT, protocol.ConnectionID{}) + err := conn.handleFrame(&wire.PathResponseFrame{Data: [8]byte{1, 2, 3, 4, 5, 6, 7, 8}}, protocol.Encryption1RTT, protocol.ConnectionID{}) Expect(err).To(MatchError("unexpected PATH_RESPONSE frame")) }) It("handles PATH_CHALLENGE frames", func() { data := [8]byte{1, 2, 3, 4, 5, 6, 7, 8} - err := sess.handleFrame(&wire.PathChallengeFrame{Data: data}, protocol.Encryption1RTT, protocol.ConnectionID{}) + err := conn.handleFrame(&wire.PathChallengeFrame{Data: data}, protocol.Encryption1RTT, protocol.ConnectionID{}) Expect(err).ToNot(HaveOccurred()) - frames, _ := sess.framer.AppendControlFrames(nil, 1000) + frames, _ := conn.framer.AppendControlFrames(nil, 1000) Expect(frames).To(Equal([]ackhandler.Frame{{Frame: &wire.PathResponseFrame{Data: data}}})) }) It("rejects NEW_TOKEN frames", func() { - err := sess.handleNewTokenFrame(&wire.NewTokenFrame{}) + err := conn.handleNewTokenFrame(&wire.NewTokenFrame{}) Expect(err).To(HaveOccurred()) Expect(err).To(BeAssignableToTypeOf(&qerr.TransportError{})) Expect(err.(*qerr.TransportError).ErrorCode).To(Equal(qerr.ProtocolViolation)) }) It("handles BLOCKED frames", func() { - err := sess.handleFrame(&wire.DataBlockedFrame{}, protocol.Encryption1RTT, protocol.ConnectionID{}) + err := conn.handleFrame(&wire.DataBlockedFrame{}, protocol.Encryption1RTT, protocol.ConnectionID{}) Expect(err).NotTo(HaveOccurred()) }) It("handles STREAM_BLOCKED frames", func() { - err := sess.handleFrame(&wire.StreamDataBlockedFrame{}, protocol.Encryption1RTT, protocol.ConnectionID{}) + err := conn.handleFrame(&wire.StreamDataBlockedFrame{}, protocol.Encryption1RTT, protocol.ConnectionID{}) Expect(err).NotTo(HaveOccurred()) }) It("handles STREAMS_BLOCKED frames", func() { - err := sess.handleFrame(&wire.StreamsBlockedFrame{}, protocol.Encryption1RTT, protocol.ConnectionID{}) + err := conn.handleFrame(&wire.StreamsBlockedFrame{}, protocol.Encryption1RTT, protocol.ConnectionID{}) Expect(err).NotTo(HaveOccurred()) }) @@ -344,13 +344,13 @@ var _ = Describe("Connection", func() { go func() { defer GinkgoRecover() cryptoSetup.EXPECT().RunHandshake().MaxTimes(1) - Expect(sess.run()).To(MatchError(expectedErr)) + Expect(conn.run()).To(MatchError(expectedErr)) }() - Expect(sess.handleFrame(&wire.ConnectionCloseFrame{ + Expect(conn.handleFrame(&wire.ConnectionCloseFrame{ ErrorCode: uint64(qerr.StreamLimitError), ReasonPhrase: "foobar", }, protocol.Encryption1RTT, protocol.ConnectionID{})).To(Succeed()) - Eventually(sess.Context().Done()).Should(BeClosed()) + Eventually(conn.Context().Done()).Should(BeClosed()) }) It("handles CONNECTION_CLOSE frames, with an application error code", func() { @@ -375,19 +375,19 @@ var _ = Describe("Connection", func() { go func() { defer GinkgoRecover() cryptoSetup.EXPECT().RunHandshake().MaxTimes(1) - Expect(sess.run()).To(MatchError(testErr)) + Expect(conn.run()).To(MatchError(testErr)) }() ccf := &wire.ConnectionCloseFrame{ ErrorCode: 0x1337, ReasonPhrase: "foobar", IsApplicationError: true, } - Expect(sess.handleFrame(ccf, protocol.Encryption1RTT, protocol.ConnectionID{})).To(Succeed()) - Eventually(sess.Context().Done()).Should(BeClosed()) + Expect(conn.handleFrame(ccf, protocol.Encryption1RTT, protocol.ConnectionID{})).To(Succeed()) + Eventually(conn.Context().Done()).Should(BeClosed()) }) It("errors on HANDSHAKE_DONE frames", func() { - Expect(sess.handleHandshakeDoneFrame()).To(MatchError(&qerr.TransportError{ + Expect(conn.handleHandshakeDoneFrame()).To(MatchError(&qerr.TransportError{ ErrorCode: qerr.ProtocolViolation, ErrorMessage: "received a HANDSHAKE_DONE frame", })) @@ -395,8 +395,8 @@ var _ = Describe("Connection", func() { }) It("tells its versions", func() { - sess.version = 4242 - Expect(sess.GetVersion()).To(Equal(protocol.VersionNumber(4242))) + conn.version = 4242 + Expect(conn.GetVersion()).To(Equal(protocol.VersionNumber(4242))) }) Context("closing", func() { @@ -418,18 +418,18 @@ var _ = Describe("Connection", func() { } }) - runSession := func() { + runConn := func() { go func() { defer GinkgoRecover() cryptoSetup.EXPECT().RunHandshake().MaxTimes(1) - runErr <- sess.run() + runErr <- conn.run() }() Eventually(areConnsRunning).Should(BeTrue()) } It("shuts down without error", func() { - sess.handshakeComplete = true - runSession() + conn.handshakeComplete = true + runConn() streamManager.EXPECT().CloseWithError(&qerr.ApplicationError{}) expectReplaceWithClosed() cryptoSetup.EXPECT().Close() @@ -450,13 +450,13 @@ var _ = Describe("Connection", func() { }), tracer.EXPECT().Close(), ) - sess.shutdown() + conn.shutdown() Eventually(areConnsRunning).Should(BeFalse()) - Expect(sess.Context().Done()).To(BeClosed()) + Expect(conn.Context().Done()).To(BeClosed()) }) It("only closes once", func() { - runSession() + runConn() streamManager.EXPECT().CloseWithError(gomock.Any()) expectReplaceWithClosed() cryptoSetup.EXPECT().Close() @@ -464,14 +464,14 @@ var _ = Describe("Connection", func() { mconn.EXPECT().Write(gomock.Any()) tracer.EXPECT().ClosedConnection(gomock.Any()) tracer.EXPECT().Close() - sess.shutdown() - sess.shutdown() + conn.shutdown() + conn.shutdown() Eventually(areConnsRunning).Should(BeFalse()) - Expect(sess.Context().Done()).To(BeClosed()) + Expect(conn.Context().Done()).To(BeClosed()) }) It("closes with an error", func() { - runSession() + runConn() expectedErr := &qerr.ApplicationError{ ErrorCode: 0x1337, ErrorMessage: "test error", @@ -485,13 +485,13 @@ var _ = Describe("Connection", func() { tracer.EXPECT().ClosedConnection(expectedErr), tracer.EXPECT().Close(), ) - sess.CloseWithError(0x1337, "test error") + conn.CloseWithError(0x1337, "test error") Eventually(areConnsRunning).Should(BeFalse()) - Expect(sess.Context().Done()).To(BeClosed()) + Expect(conn.Context().Done()).To(BeClosed()) }) It("includes the frame type in transport-level close frames", func() { - runSession() + runConn() expectedErr := &qerr.TransportError{ ErrorCode: 0x1337, FrameType: 0x42, @@ -506,13 +506,13 @@ var _ = Describe("Connection", func() { tracer.EXPECT().ClosedConnection(expectedErr), tracer.EXPECT().Close(), ) - sess.closeLocal(expectedErr) + conn.closeLocal(expectedErr) Eventually(areConnsRunning).Should(BeFalse()) - Expect(sess.Context().Done()).To(BeClosed()) + Expect(conn.Context().Done()).To(BeClosed()) }) - It("destroys the session", func() { - runSession() + It("destroys the connection", func() { + runConn() testErr := errors.New("close") streamManager.EXPECT().CloseWithError(gomock.Any()) connRunner.EXPECT().Remove(gomock.Any()).AnyTimes() @@ -527,7 +527,7 @@ var _ = Describe("Connection", func() { }), tracer.EXPECT().Close(), ) - sess.destroy(testErr) + conn.destroy(testErr) Eventually(areConnsRunning).Should(BeFalse()) expectedRunErr = &qerr.TransportError{ ErrorCode: qerr.InternalError, @@ -536,7 +536,7 @@ var _ = Describe("Connection", func() { }) It("cancels the context when the run loop exists", func() { - runSession() + runConn() streamManager.EXPECT().CloseWithError(gomock.Any()) expectReplaceWithClosed() cryptoSetup.EXPECT().Close() @@ -544,7 +544,7 @@ var _ = Describe("Connection", func() { returned := make(chan struct{}) go func() { defer GinkgoRecover() - ctx := sess.Context() + ctx := conn.Context() <-ctx.Done() Expect(ctx.Err()).To(MatchError(context.Canceled)) close(returned) @@ -553,15 +553,15 @@ var _ = Describe("Connection", func() { mconn.EXPECT().Write(gomock.Any()) tracer.EXPECT().ClosedConnection(gomock.Any()) tracer.EXPECT().Close() - sess.shutdown() + conn.shutdown() Eventually(returned).Should(BeClosed()) }) It("doesn't send any more packets after receiving a CONNECTION_CLOSE", func() { unpacker := NewMockUnpacker(mockCtrl) - sess.handshakeConfirmed = true - sess.unpacker = unpacker - runSession() + conn.handshakeConfirmed = true + conn.unpacker = unpacker + runConn() cryptoSetup.EXPECT().Close() streamManager.EXPECT().CloseWithError(gomock.Any()) connRunner.EXPECT().ReplaceWithClosed(gomock.Any(), gomock.Any()).AnyTimes() @@ -570,10 +570,10 @@ var _ = Describe("Connection", func() { Header: wire.Header{DestConnectionID: srcConnID}, PacketNumberLen: protocol.PacketNumberLen2, } - Expect(hdr.Write(buf, sess.version)).To(Succeed()) + Expect(hdr.Write(buf, conn.version)).To(Succeed()) unpacker.EXPECT().Unpack(gomock.Any(), gomock.Any(), gomock.Any()).DoAndReturn(func(*wire.Header, time.Time, []byte) (*unpackedPacket, error) { buf := &bytes.Buffer{} - Expect((&wire.ConnectionCloseFrame{ErrorCode: uint64(qerr.StreamLimitError)}).Write(buf, sess.version)).To(Succeed()) + Expect((&wire.ConnectionCloseFrame{ErrorCode: uint64(qerr.StreamLimitError)}).Write(buf, conn.version)).To(Succeed()) return &unpackedPacket{ hdr: hdr, data: buf.Bytes(), @@ -587,21 +587,21 @@ var _ = Describe("Connection", func() { tracer.EXPECT().Close(), ) // don't EXPECT any calls to packer.PackPacket() - sess.handlePacket(&receivedPacket{ + conn.handlePacket(&receivedPacket{ rcvTime: time.Now(), remoteAddr: &net.UDPAddr{}, buffer: getPacketBuffer(), data: buf.Bytes(), }) // Consistently(pack).ShouldNot(Receive()) - Eventually(sess.Context().Done()).Should(BeClosed()) + Eventually(conn.Context().Done()).Should(BeClosed()) }) It("closes when the sendQueue encounters an error", func() { - sess.handshakeConfirmed = true - conn := NewMockSendConn(mockCtrl) - conn.EXPECT().Write(gomock.Any()).Return(io.ErrClosedPipe).AnyTimes() - sess.sendQueue = newSendQueue(conn) + conn.handshakeConfirmed = true + sconn := NewMockSendConn(mockCtrl) + sconn.EXPECT().Write(gomock.Any()).Return(io.ErrClosedPipe).AnyTimes() + conn.sendQueue = newSendQueue(sconn) sph := mockackhandler.NewMockSentPacketHandler(mockCtrl) sph.EXPECT().GetLossDetectionTimeout().Return(time.Now().Add(time.Hour)).AnyTimes() sph.EXPECT().SendMode().Return(ackhandler.SendAny).AnyTimes() @@ -614,19 +614,19 @@ var _ = Describe("Connection", func() { streamManager.EXPECT().CloseWithError(gomock.Any()) connRunner.EXPECT().Remove(gomock.Any()).AnyTimes() cryptoSetup.EXPECT().Close() - sess.sentPacketHandler = sph + conn.sentPacketHandler = sph p := getPacket(1) packer.EXPECT().PackPacket().Return(p, nil) packer.EXPECT().PackPacket().Return(nil, nil).AnyTimes() - runSession() - sess.queueControlFrame(&wire.PingFrame{}) - sess.scheduleSending() - Eventually(sess.Context().Done()).Should(BeClosed()) + runConn() + conn.queueControlFrame(&wire.PingFrame{}) + conn.scheduleSending() + Eventually(conn.Context().Done()).Should(BeClosed()) }) It("closes due to a stateless reset", func() { token := protocol.StatelessResetToken{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16} - runSession() + runConn() gomock.InOrder( tracer.EXPECT().ClosedConnection(gomock.Any()).Do(func(e error) { var srErr *StatelessResetError @@ -638,7 +638,7 @@ var _ = Describe("Connection", func() { streamManager.EXPECT().CloseWithError(gomock.Any()) connRunner.EXPECT().Remove(gomock.Any()).AnyTimes() cryptoSetup.EXPECT().Close() - sess.destroy(&StatelessResetError{Token: token}) + conn.destroy(&StatelessResetError{Token: token}) }) }) @@ -647,12 +647,12 @@ var _ = Describe("Connection", func() { BeforeEach(func() { unpacker = NewMockUnpacker(mockCtrl) - sess.unpacker = unpacker + conn.unpacker = unpacker }) getPacket := func(extHdr *wire.ExtendedHeader, data []byte) *receivedPacket { buf := &bytes.Buffer{} - Expect(extHdr.Write(buf, sess.version)).To(Succeed()) + Expect(extHdr.Write(buf, conn.version)).To(Succeed()) return &receivedPacket{ data: append(buf.Bytes(), data...), buffer: getPacketBuffer(), @@ -666,18 +666,18 @@ var _ = Describe("Connection", func() { Type: protocol.PacketTypeRetry, DestConnectionID: destConnID, SrcConnectionID: srcConnID, - Version: sess.version, + Version: conn.version, Token: []byte("foobar"), }}, make([]byte, 16) /* Retry integrity tag */) tracer.EXPECT().DroppedPacket(logging.PacketTypeRetry, p.Size(), logging.PacketDropUnexpectedPacket) - Expect(sess.handlePacketImpl(p)).To(BeFalse()) + Expect(conn.handlePacketImpl(p)).To(BeFalse()) }) It("drops Version Negotiation packets", func() { - b, err := wire.ComposeVersionNegotiation(srcConnID, destConnID, sess.config.Versions) + b, err := wire.ComposeVersionNegotiation(srcConnID, destConnID, conn.config.Versions) Expect(err).ToNot(HaveOccurred()) tracer.EXPECT().DroppedPacket(logging.PacketTypeVersionNegotiation, protocol.ByteCount(len(b)), logging.PacketDropUnexpectedPacket) - Expect(sess.handlePacketImpl(&receivedPacket{ + Expect(conn.handlePacketImpl(&receivedPacket{ data: b, buffer: getPacketBuffer(), })).To(BeFalse()) @@ -688,13 +688,13 @@ var _ = Describe("Connection", func() { Header: wire.Header{ IsLongHeader: true, Type: protocol.PacketTypeHandshake, - Version: sess.version, + Version: conn.version, }, PacketNumberLen: protocol.PacketNumberLen2, }, nil) p.data[0] ^= 0x40 // unset the QUIC bit tracer.EXPECT().DroppedPacket(logging.PacketTypeNotDetermined, p.Size(), logging.PacketDropHeaderParseError) - Expect(sess.handlePacketImpl(p)).To(BeFalse()) + Expect(conn.handlePacketImpl(p)).To(BeFalse()) }) It("drops packets for which the version is unsupported", func() { @@ -702,12 +702,12 @@ var _ = Describe("Connection", func() { Header: wire.Header{ IsLongHeader: true, Type: protocol.PacketTypeHandshake, - Version: sess.version + 1, + Version: conn.version + 1, }, PacketNumberLen: protocol.PacketNumberLen2, }, nil) tracer.EXPECT().DroppedPacket(logging.PacketTypeNotDetermined, p.Size(), logging.PacketDropUnsupportedVersion) - Expect(sess.handlePacketImpl(p)).To(BeFalse()) + Expect(conn.handlePacketImpl(p)).To(BeFalse()) }) It("drops packets with an unsupported version", func() { @@ -717,19 +717,19 @@ var _ = Describe("Connection", func() { protocol.SupportedVersions = origSupportedVersions }() - protocol.SupportedVersions = append(protocol.SupportedVersions, sess.version+1) + protocol.SupportedVersions = append(protocol.SupportedVersions, conn.version+1) p := getPacket(&wire.ExtendedHeader{ Header: wire.Header{ IsLongHeader: true, Type: protocol.PacketTypeHandshake, DestConnectionID: destConnID, SrcConnectionID: srcConnID, - Version: sess.version + 1, + Version: conn.version + 1, }, PacketNumberLen: protocol.PacketNumberLen2, }, nil) tracer.EXPECT().DroppedPacket(logging.PacketTypeHandshake, p.Size(), logging.PacketDropUnexpectedVersion) - Expect(sess.handlePacketImpl(p)).To(BeFalse()) + Expect(conn.handlePacketImpl(p)).To(BeFalse()) }) It("informs the ReceivedPacketHandler about non-ack-eliciting packets", func() { @@ -752,11 +752,11 @@ var _ = Describe("Connection", func() { rph.EXPECT().IsPotentiallyDuplicate(protocol.PacketNumber(0x1337), protocol.EncryptionInitial), rph.EXPECT().ReceivedPacket(protocol.PacketNumber(0x1337), protocol.ECNCE, protocol.EncryptionInitial, rcvTime, false), ) - sess.receivedPacketHandler = rph + conn.receivedPacketHandler = rph packet.rcvTime = rcvTime tracer.EXPECT().StartedConnection(gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any()) tracer.EXPECT().ReceivedPacket(hdr, protocol.ByteCount(len(packet.data)), []logging.Frame{}) - Expect(sess.handlePacketImpl(packet)).To(BeTrue()) + Expect(conn.handlePacketImpl(packet)).To(BeTrue()) }) It("informs the ReceivedPacketHandler about ack-eliciting packets", func() { @@ -767,7 +767,7 @@ var _ = Describe("Connection", func() { } rcvTime := time.Now().Add(-10 * time.Second) buf := &bytes.Buffer{} - Expect((&wire.PingFrame{}).Write(buf, sess.version)).To(Succeed()) + Expect((&wire.PingFrame{}).Write(buf, conn.version)).To(Succeed()) packet := getPacket(hdr, nil) packet.ecn = protocol.ECT1 unpacker.EXPECT().Unpack(gomock.Any(), rcvTime, gomock.Any()).Return(&unpackedPacket{ @@ -781,11 +781,11 @@ var _ = Describe("Connection", func() { rph.EXPECT().IsPotentiallyDuplicate(protocol.PacketNumber(0x1337), protocol.Encryption1RTT), rph.EXPECT().ReceivedPacket(protocol.PacketNumber(0x1337), protocol.ECT1, protocol.Encryption1RTT, rcvTime, true), ) - sess.receivedPacketHandler = rph + conn.receivedPacketHandler = rph packet.rcvTime = rcvTime tracer.EXPECT().StartedConnection(gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any()) tracer.EXPECT().ReceivedPacket(hdr, protocol.ByteCount(len(packet.data)), []logging.Frame{&logging.PingFrame{}}) - Expect(sess.handlePacketImpl(packet)).To(BeTrue()) + Expect(conn.handlePacketImpl(packet)).To(BeTrue()) }) It("drops duplicate packets", func() { @@ -803,9 +803,9 @@ var _ = Describe("Connection", func() { }, nil) rph := mockackhandler.NewMockReceivedPacketHandler(mockCtrl) rph.EXPECT().IsPotentiallyDuplicate(protocol.PacketNumber(0x1337), protocol.Encryption1RTT).Return(true) - sess.receivedPacketHandler = rph + conn.receivedPacketHandler = rph tracer.EXPECT().DroppedPacket(logging.PacketType1RTT, protocol.ByteCount(len(packet.data)), logging.PacketDropDuplicate) - Expect(sess.handlePacketImpl(packet)).To(BeFalse()) + Expect(conn.handlePacketImpl(packet)).To(BeFalse()) }) It("drops a packet when unpacking fails", func() { @@ -816,7 +816,7 @@ var _ = Describe("Connection", func() { go func() { defer GinkgoRecover() cryptoSetup.EXPECT().RunHandshake().MaxTimes(1) - sess.run() + conn.run() }() expectReplaceWithClosed() p := getPacket(&wire.ExtendedHeader{ @@ -824,25 +824,25 @@ var _ = Describe("Connection", func() { IsLongHeader: true, Type: protocol.PacketTypeHandshake, DestConnectionID: srcConnID, - Version: sess.version, + Version: conn.version, Length: 2 + 6, }, PacketNumber: 0x1337, PacketNumberLen: protocol.PacketNumberLen2, }, []byte("foobar")) tracer.EXPECT().DroppedPacket(logging.PacketTypeHandshake, p.Size(), logging.PacketDropPayloadDecryptError) - sess.handlePacket(p) - Consistently(sess.Context().Done()).ShouldNot(BeClosed()) + conn.handlePacket(p) + Consistently(conn.Context().Done()).ShouldNot(BeClosed()) // make the go routine return tracer.EXPECT().ClosedConnection(gomock.Any()) tracer.EXPECT().Close() mconn.EXPECT().Write(gomock.Any()) - sess.closeLocal(errors.New("close")) - Eventually(sess.Context().Done()).Should(BeClosed()) + conn.closeLocal(errors.New("close")) + Eventually(conn.Context().Done()).Should(BeClosed()) }) It("processes multiple received packets before sending one", func() { - sess.sessionCreationTime = time.Now() + conn.creationTime = time.Now() var pn protocol.PacketNumber unpacker.EXPECT().Unpack(gomock.Any(), gomock.Any(), gomock.Any()).DoAndReturn(func(hdr *wire.Header, rcvTime time.Time, data []byte) (*unpackedPacket, error) { pn++ @@ -859,7 +859,7 @@ var _ = Describe("Connection", func() { packer.EXPECT().PackCoalescedPacket() // only expect a single call for i := 0; i < 3; i++ { - sess.handlePacket(getPacket(&wire.ExtendedHeader{ + conn.handlePacket(getPacket(&wire.ExtendedHeader{ Header: wire.Header{DestConnectionID: srcConnID}, PacketNumber: 0x1337, PacketNumberLen: protocol.PacketNumberLen2, @@ -869,9 +869,9 @@ var _ = Describe("Connection", func() { go func() { defer GinkgoRecover() cryptoSetup.EXPECT().RunHandshake().MaxTimes(1) - sess.run() + conn.run() }() - Consistently(sess.Context().Done()).ShouldNot(BeClosed()) + Consistently(conn.Context().Done()).ShouldNot(BeClosed()) // make the go routine return streamManager.EXPECT().CloseWithError(gomock.Any()) @@ -881,13 +881,13 @@ var _ = Describe("Connection", func() { tracer.EXPECT().ClosedConnection(gomock.Any()) tracer.EXPECT().Close() mconn.EXPECT().Write(gomock.Any()) - sess.closeLocal(errors.New("close")) - Eventually(sess.Context().Done()).Should(BeClosed()) + conn.closeLocal(errors.New("close")) + Eventually(conn.Context().Done()).Should(BeClosed()) }) It("doesn't processes multiple received packets before sending one before handshake completion", func() { - sess.handshakeComplete = false - sess.sessionCreationTime = time.Now() + conn.handshakeComplete = false + conn.creationTime = time.Now() var pn protocol.PacketNumber unpacker.EXPECT().Unpack(gomock.Any(), gomock.Any(), gomock.Any()).DoAndReturn(func(hdr *wire.Header, rcvTime time.Time, data []byte) (*unpackedPacket, error) { pn++ @@ -904,7 +904,7 @@ var _ = Describe("Connection", func() { packer.EXPECT().PackCoalescedPacket().Times(3) // only expect a single call for i := 0; i < 3; i++ { - sess.handlePacket(getPacket(&wire.ExtendedHeader{ + conn.handlePacket(getPacket(&wire.ExtendedHeader{ Header: wire.Header{DestConnectionID: srcConnID}, PacketNumber: 0x1337, PacketNumberLen: protocol.PacketNumberLen2, @@ -914,9 +914,9 @@ var _ = Describe("Connection", func() { go func() { defer GinkgoRecover() cryptoSetup.EXPECT().RunHandshake().MaxTimes(1) - sess.run() + conn.run() }() - Consistently(sess.Context().Done()).ShouldNot(BeClosed()) + Consistently(conn.Context().Done()).ShouldNot(BeClosed()) // make the go routine return streamManager.EXPECT().CloseWithError(gomock.Any()) @@ -926,11 +926,11 @@ var _ = Describe("Connection", func() { tracer.EXPECT().ClosedConnection(gomock.Any()) tracer.EXPECT().Close() mconn.EXPECT().Write(gomock.Any()) - sess.closeLocal(errors.New("close")) - Eventually(sess.Context().Done()).Should(BeClosed()) + conn.closeLocal(errors.New("close")) + Eventually(conn.Context().Done()).Should(BeClosed()) }) - It("closes the session when unpacking fails because the reserved bits were incorrect", func() { + It("closes the connection when unpacking fails because the reserved bits were incorrect", func() { unpacker.EXPECT().Unpack(gomock.Any(), gomock.Any(), gomock.Any()).Return(nil, wire.ErrInvalidReservedBits) streamManager.EXPECT().CloseWithError(gomock.Any()) cryptoSetup.EXPECT().Close() @@ -939,7 +939,7 @@ var _ = Describe("Connection", func() { go func() { defer GinkgoRecover() cryptoSetup.EXPECT().RunHandshake().MaxTimes(1) - err := sess.run() + err := conn.run() Expect(err).To(HaveOccurred()) Expect(err).To(BeAssignableToTypeOf(&qerr.TransportError{})) Expect(err.(*qerr.TransportError).ErrorCode).To(Equal(qerr.ProtocolViolation)) @@ -953,8 +953,8 @@ var _ = Describe("Connection", func() { }, nil) tracer.EXPECT().ClosedConnection(gomock.Any()) tracer.EXPECT().Close() - sess.handlePacket(packet) - Eventually(sess.Context().Done()).Should(BeClosed()) + conn.handlePacket(packet) + Eventually(conn.Context().Done()).Should(BeClosed()) }) It("ignores packets when unpacking the header fails", func() { @@ -966,11 +966,11 @@ var _ = Describe("Connection", func() { go func() { defer GinkgoRecover() cryptoSetup.EXPECT().RunHandshake().MaxTimes(1) - runErr <- sess.run() + runErr <- conn.run() }() expectReplaceWithClosed() tracer.EXPECT().DroppedPacket(logging.PacketType1RTT, gomock.Any(), logging.PacketDropHeaderParseError) - sess.handlePacket(getPacket(&wire.ExtendedHeader{ + conn.handlePacket(getPacket(&wire.ExtendedHeader{ Header: wire.Header{DestConnectionID: srcConnID}, PacketNumberLen: protocol.PacketNumberLen1, }, nil)) @@ -980,11 +980,11 @@ var _ = Describe("Connection", func() { tracer.EXPECT().ClosedConnection(gomock.Any()) tracer.EXPECT().Close() mconn.EXPECT().Write(gomock.Any()) - sess.shutdown() - Eventually(sess.Context().Done()).Should(BeClosed()) + conn.shutdown() + Eventually(conn.Context().Done()).Should(BeClosed()) }) - It("closes the session when unpacking fails because of an error other than a decryption error", func() { + It("closes the connection when unpacking fails because of an error other than a decryption error", func() { unpacker.EXPECT().Unpack(gomock.Any(), gomock.Any(), gomock.Any()).Return(nil, &qerr.TransportError{ErrorCode: qerr.ConnectionIDLimitError}) streamManager.EXPECT().CloseWithError(gomock.Any()) cryptoSetup.EXPECT().Close() @@ -993,7 +993,7 @@ var _ = Describe("Connection", func() { go func() { defer GinkgoRecover() cryptoSetup.EXPECT().RunHandshake().MaxTimes(1) - err := sess.run() + err := conn.run() Expect(err).To(HaveOccurred()) Expect(err).To(BeAssignableToTypeOf(&qerr.TransportError{})) Expect(err.(*qerr.TransportError).ErrorCode).To(Equal(qerr.ConnectionIDLimitError)) @@ -1007,8 +1007,8 @@ var _ = Describe("Connection", func() { }, nil) tracer.EXPECT().ClosedConnection(gomock.Any()) tracer.EXPECT().Close() - sess.handlePacket(packet) - Eventually(sess.Context().Done()).Should(BeClosed()) + conn.handlePacket(packet) + Eventually(conn.Context().Done()).Should(BeClosed()) }) It("rejects packets with empty payload", func() { @@ -1024,7 +1024,7 @@ var _ = Describe("Connection", func() { go func() { defer GinkgoRecover() cryptoSetup.EXPECT().RunHandshake().MaxTimes(1) - Expect(sess.run()).To(MatchError(&qerr.TransportError{ + Expect(conn.run()).To(MatchError(&qerr.TransportError{ ErrorCode: qerr.ProtocolViolation, ErrorMessage: "empty packet", })) @@ -1034,7 +1034,7 @@ var _ = Describe("Connection", func() { mconn.EXPECT().Write(gomock.Any()) tracer.EXPECT().ClosedConnection(gomock.Any()) tracer.EXPECT().Close() - sess.handlePacket(getPacket(&wire.ExtendedHeader{ + conn.handlePacket(getPacket(&wire.ExtendedHeader{ Header: wire.Header{DestConnectionID: srcConnID}, PacketNumberLen: protocol.PacketNumberLen1, }, nil)) @@ -1049,7 +1049,7 @@ var _ = Describe("Connection", func() { DestConnectionID: destConnID, SrcConnectionID: srcConnID, Length: 1, - Version: sess.version, + Version: conn.version, }, PacketNumberLen: protocol.PacketNumberLen1, PacketNumber: 1, @@ -1061,7 +1061,7 @@ var _ = Describe("Connection", func() { DestConnectionID: destConnID, SrcConnectionID: protocol.ConnectionID{0xde, 0xad, 0xbe, 0xef}, Length: 1, - Version: sess.version, + Version: conn.version, }, PacketNumberLen: protocol.PacketNumberLen1, PacketNumber: 2, @@ -1077,15 +1077,15 @@ var _ = Describe("Connection", func() { p1 := getPacket(hdr1, nil) tracer.EXPECT().StartedConnection(gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any()) tracer.EXPECT().ReceivedPacket(gomock.Any(), protocol.ByteCount(len(p1.data)), gomock.Any()) - Expect(sess.handlePacketImpl(p1)).To(BeTrue()) + Expect(conn.handlePacketImpl(p1)).To(BeTrue()) // The next packet has to be ignored, since the source connection ID doesn't match. p2 := getPacket(hdr2, nil) tracer.EXPECT().DroppedPacket(logging.PacketTypeInitial, protocol.ByteCount(len(p2.data)), logging.PacketDropUnknownConnectionID) - Expect(sess.handlePacketImpl(p2)).To(BeFalse()) + Expect(conn.handlePacketImpl(p2)).To(BeFalse()) }) It("queues undecryptable packets", func() { - sess.handshakeComplete = false + conn.handshakeComplete = false hdr := &wire.ExtendedHeader{ Header: wire.Header{ IsLongHeader: true, @@ -1093,7 +1093,7 @@ var _ = Describe("Connection", func() { DestConnectionID: destConnID, SrcConnectionID: srcConnID, Length: 1, - Version: sess.version, + Version: conn.version, }, PacketNumberLen: protocol.PacketNumberLen1, PacketNumber: 1, @@ -1101,8 +1101,8 @@ var _ = Describe("Connection", func() { unpacker.EXPECT().Unpack(gomock.Any(), gomock.Any(), gomock.Any()).Return(nil, handshake.ErrKeysNotYetAvailable) packet := getPacket(hdr, nil) tracer.EXPECT().BufferedPacket(logging.PacketTypeHandshake) - Expect(sess.handlePacketImpl(packet)).To(BeFalse()) - Expect(sess.undecryptablePackets).To(Equal([]*receivedPacket{packet})) + Expect(conn.handlePacketImpl(packet)).To(BeFalse()) + Expect(conn.undecryptablePackets).To(Equal([]*receivedPacket{packet})) }) Context("updating the remote address", func() { @@ -1119,7 +1119,7 @@ var _ = Describe("Connection", func() { packet.remoteAddr = &net.IPAddr{IP: net.IPv4(192, 168, 0, 100)} tracer.EXPECT().StartedConnection(gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any()) tracer.EXPECT().ReceivedPacket(gomock.Any(), protocol.ByteCount(len(packet.data)), gomock.Any()) - Expect(sess.handlePacketImpl(packet)).To(BeTrue()) + Expect(conn.handlePacketImpl(packet)).To(BeTrue()) }) }) @@ -1139,7 +1139,7 @@ var _ = Describe("Connection", func() { }, PacketNumberLen: protocol.PacketNumberLen3, } - hdrLen := hdr.GetLength(sess.version) + hdrLen := hdr.GetLength(conn.version) b := make([]byte, 1) rand.Read(b) packet := getPacket(hdr, bytes.Repeat(b, int(length)-3)) @@ -1157,7 +1157,7 @@ var _ = Describe("Connection", func() { }, nil }) tracer.EXPECT().ReceivedPacket(gomock.Any(), protocol.ByteCount(len(packet.data)), gomock.Any()) - Expect(sess.handlePacketImpl(packet)).To(BeTrue()) + Expect(conn.handlePacketImpl(packet)).To(BeTrue()) }) It("handles coalesced packets", func() { @@ -1186,11 +1186,11 @@ var _ = Describe("Connection", func() { tracer.EXPECT().ReceivedPacket(gomock.Any(), protocol.ByteCount(len(packet2.data)), gomock.Any()), ) packet1.data = append(packet1.data, packet2.data...) - Expect(sess.handlePacketImpl(packet1)).To(BeTrue()) + Expect(conn.handlePacketImpl(packet1)).To(BeTrue()) }) It("works with undecryptable packets", func() { - sess.handshakeComplete = false + conn.handshakeComplete = false hdrLen1, packet1 := getPacketWithLength(srcConnID, 456) hdrLen2, packet2 := getPacketWithLength(srcConnID, 123) gomock.InOrder( @@ -1209,10 +1209,10 @@ var _ = Describe("Connection", func() { tracer.EXPECT().ReceivedPacket(gomock.Any(), protocol.ByteCount(len(packet2.data)), gomock.Any()), ) packet1.data = append(packet1.data, packet2.data...) - Expect(sess.handlePacketImpl(packet1)).To(BeTrue()) + Expect(conn.handlePacketImpl(packet1)).To(BeTrue()) - Expect(sess.undecryptablePackets).To(HaveLen(1)) - Expect(sess.undecryptablePackets[0].data).To(HaveLen(hdrLen1 + 456 - 3)) + Expect(conn.undecryptablePackets).To(HaveLen(1)) + Expect(conn.undecryptablePackets[0].data).To(HaveLen(hdrLen1 + 456 - 3)) }) It("ignores coalesced packet parts if the destination connection IDs don't match", func() { @@ -1234,23 +1234,23 @@ var _ = Describe("Connection", func() { tracer.EXPECT().DroppedPacket(gomock.Any(), protocol.ByteCount(len(packet2.data)), logging.PacketDropUnknownConnectionID), ) packet1.data = append(packet1.data, packet2.data...) - Expect(sess.handlePacketImpl(packet1)).To(BeTrue()) + Expect(conn.handlePacketImpl(packet1)).To(BeTrue()) }) }) }) Context("sending packets", func() { var ( - sessionDone chan struct{} - sender *MockSender + connDone chan struct{} + sender *MockSender ) BeforeEach(func() { sender = NewMockSender(mockCtrl) sender.EXPECT().Run() sender.EXPECT().WouldBlock().AnyTimes() - sess.sendQueue = sender - sessionDone = make(chan struct{}) + conn.sendQueue = sender + connDone = make(chan struct{}) }) AfterEach(func() { @@ -1262,30 +1262,30 @@ var _ = Describe("Connection", func() { tracer.EXPECT().ClosedConnection(gomock.Any()) tracer.EXPECT().Close() sender.EXPECT().Close() - sess.shutdown() - Eventually(sess.Context().Done()).Should(BeClosed()) - Eventually(sessionDone).Should(BeClosed()) + conn.shutdown() + Eventually(conn.Context().Done()).Should(BeClosed()) + Eventually(connDone).Should(BeClosed()) }) - runSession := func() { + runConn := func() { go func() { defer GinkgoRecover() cryptoSetup.EXPECT().RunHandshake().MaxTimes(1) - sess.run() - close(sessionDone) + conn.run() + close(connDone) }() } It("sends packets", func() { - sess.handshakeConfirmed = true + conn.handshakeConfirmed = true sph := mockackhandler.NewMockSentPacketHandler(mockCtrl) sph.EXPECT().TimeUntilSend().AnyTimes() sph.EXPECT().GetLossDetectionTimeout().AnyTimes() sph.EXPECT().SendMode().Return(ackhandler.SendAny).AnyTimes() sph.EXPECT().HasPacingBudget().Return(true).AnyTimes() sph.EXPECT().SentPacket(gomock.Any()) - sess.sentPacketHandler = sph - runSession() + conn.sentPacketHandler = sph + runConn() p := getPacket(1) packer.EXPECT().PackPacket().Return(p, nil) packer.EXPECT().PackPacket().Return(nil, nil).AnyTimes() @@ -1293,16 +1293,16 @@ var _ = Describe("Connection", func() { sender.EXPECT().WouldBlock().AnyTimes() sender.EXPECT().Send(gomock.Any()).Do(func(packet *packetBuffer) { close(sent) }) tracer.EXPECT().SentPacket(p.header, p.buffer.Len(), nil, []logging.Frame{}) - sess.scheduleSending() + conn.scheduleSending() Eventually(sent).Should(BeClosed()) }) It("doesn't send packets if there's nothing to send", func() { - sess.handshakeConfirmed = true - runSession() + conn.handshakeConfirmed = true + runConn() packer.EXPECT().PackPacket().Return(nil, nil).AnyTimes() - sess.receivedPacketHandler.ReceivedPacket(0x035e, protocol.ECNNon, protocol.Encryption1RTT, time.Now(), true) - sess.scheduleSending() + conn.receivedPacketHandler.ReceivedPacket(0x035e, protocol.ECNNon, protocol.Encryption1RTT, time.Now(), true) + conn.scheduleSending() time.Sleep(50 * time.Millisecond) // make sure there are no calls to mconn.Write() }) @@ -1313,35 +1313,35 @@ var _ = Describe("Connection", func() { sph.EXPECT().SendMode().Return(ackhandler.SendAck) done := make(chan struct{}) packer.EXPECT().MaybePackAckPacket(false).Do(func(bool) { close(done) }) - sess.sentPacketHandler = sph - runSession() - sess.scheduleSending() + conn.sentPacketHandler = sph + runConn() + conn.scheduleSending() Eventually(done).Should(BeClosed()) }) It("adds a BLOCKED frame when it is connection-level flow control blocked", func() { - sess.handshakeConfirmed = true + conn.handshakeConfirmed = true sph := mockackhandler.NewMockSentPacketHandler(mockCtrl) sph.EXPECT().TimeUntilSend().AnyTimes() sph.EXPECT().GetLossDetectionTimeout().AnyTimes() sph.EXPECT().SendMode().Return(ackhandler.SendAny).AnyTimes() sph.EXPECT().HasPacingBudget().Return(true).AnyTimes() sph.EXPECT().SentPacket(gomock.Any()) - sess.sentPacketHandler = sph + conn.sentPacketHandler = sph fc := mocks.NewMockConnectionFlowController(mockCtrl) fc.EXPECT().IsNewlyBlocked().Return(true, protocol.ByteCount(1337)) fc.EXPECT().IsNewlyBlocked() p := getPacket(1) packer.EXPECT().PackPacket().Return(p, nil) packer.EXPECT().PackPacket().Return(nil, nil).AnyTimes() - sess.connFlowController = fc - runSession() + conn.connFlowController = fc + runConn() sent := make(chan struct{}) sender.EXPECT().Send(gomock.Any()).Do(func(packet *packetBuffer) { close(sent) }) tracer.EXPECT().SentPacket(p.header, p.length, nil, []logging.Frame{}) - sess.scheduleSending() + conn.scheduleSending() Eventually(sent).Should(BeClosed()) - frames, _ := sess.framer.AppendControlFrames(nil, 1000) + frames, _ := conn.framer.AppendControlFrames(nil, 1000) Expect(frames).To(Equal([]ackhandler.Frame{{Frame: &logging.DataBlockedFrame{MaximumData: 1337}}})) }) @@ -1350,9 +1350,9 @@ var _ = Describe("Connection", func() { sph.EXPECT().GetLossDetectionTimeout().AnyTimes() sph.EXPECT().SendMode().Return(ackhandler.SendNone).AnyTimes() sph.EXPECT().TimeUntilSend().AnyTimes() - sess.sentPacketHandler = sph - runSession() - sess.scheduleSending() + conn.sentPacketHandler = sph + runConn() + conn.scheduleSending() time.Sleep(50 * time.Millisecond) }) @@ -1368,13 +1368,13 @@ var _ = Describe("Connection", func() { switch encLevel { case protocol.EncryptionInitial: sendMode = ackhandler.SendPTOInitial - getFrame = sess.retransmissionQueue.GetInitialFrame + getFrame = conn.retransmissionQueue.GetInitialFrame case protocol.EncryptionHandshake: sendMode = ackhandler.SendPTOHandshake - getFrame = sess.retransmissionQueue.GetHandshakeFrame + getFrame = conn.retransmissionQueue.GetHandshakeFrame case protocol.Encryption1RTT: sendMode = ackhandler.SendPTOAppData - getFrame = sess.retransmissionQueue.GetAppDataFrame + getFrame = conn.retransmissionQueue.GetAppDataFrame } }) @@ -1390,12 +1390,12 @@ var _ = Describe("Connection", func() { sph.EXPECT().SentPacket(gomock.Any()).Do(func(packet *ackhandler.Packet) { Expect(packet.PacketNumber).To(Equal(protocol.PacketNumber(123))) }) - sess.sentPacketHandler = sph - runSession() + conn.sentPacketHandler = sph + runConn() sent := make(chan struct{}) sender.EXPECT().Send(gomock.Any()).Do(func(packet *packetBuffer) { close(sent) }) tracer.EXPECT().SentPacket(p.header, p.length, gomock.Any(), gomock.Any()) - sess.scheduleSending() + conn.scheduleSending() Eventually(sent).Should(BeClosed()) }) @@ -1411,12 +1411,12 @@ var _ = Describe("Connection", func() { sph.EXPECT().SentPacket(gomock.Any()).Do(func(packet *ackhandler.Packet) { Expect(packet.PacketNumber).To(Equal(protocol.PacketNumber(123))) }) - sess.sentPacketHandler = sph - runSession() + conn.sentPacketHandler = sph + runConn() sent := make(chan struct{}) sender.EXPECT().Send(gomock.Any()).Do(func(packet *packetBuffer) { close(sent) }) tracer.EXPECT().SentPacket(p.header, p.length, gomock.Any(), gomock.Any()) - sess.scheduleSending() + conn.scheduleSending() Eventually(sent).Should(BeClosed()) // We're using a mock packet packer in this test. // We therefore need to test separately that the PING was actually queued. @@ -1436,12 +1436,12 @@ var _ = Describe("Connection", func() { tracer.EXPECT().SentPacket(gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any()).AnyTimes() sph = mockackhandler.NewMockSentPacketHandler(mockCtrl) sph.EXPECT().GetLossDetectionTimeout().AnyTimes() - sess.handshakeConfirmed = true - sess.handshakeComplete = true - sess.sentPacketHandler = sph + conn.handshakeConfirmed = true + conn.handshakeComplete = true + conn.sentPacketHandler = sph sender = NewMockSender(mockCtrl) sender.EXPECT().Run() - sess.sendQueue = sender + conn.sendQueue = sender streamManager.EXPECT().CloseWithError(gomock.Any()) }) @@ -1454,8 +1454,8 @@ var _ = Describe("Connection", func() { tracer.EXPECT().ClosedConnection(gomock.Any()) tracer.EXPECT().Close() sender.EXPECT().Close() - sess.shutdown() - Eventually(sess.Context().Done()).Should(BeClosed()) + conn.shutdown() + Eventually(conn.Context().Done()).Should(BeClosed()) }) It("sends multiple packets one by one immediately", func() { @@ -1471,9 +1471,9 @@ var _ = Describe("Connection", func() { go func() { defer GinkgoRecover() cryptoSetup.EXPECT().RunHandshake().MaxTimes(1) - sess.run() + conn.run() }() - sess.scheduleSending() + conn.scheduleSending() time.Sleep(50 * time.Millisecond) // make sure that only 2 packets are sent }) @@ -1488,9 +1488,9 @@ var _ = Describe("Connection", func() { go func() { defer GinkgoRecover() cryptoSetup.EXPECT().RunHandshake().MaxTimes(1) - sess.run() + conn.run() }() - sess.scheduleSending() + conn.scheduleSending() time.Sleep(50 * time.Millisecond) // make sure that only 1 packet is sent }) @@ -1505,9 +1505,9 @@ var _ = Describe("Connection", func() { go func() { defer GinkgoRecover() cryptoSetup.EXPECT().RunHandshake().MaxTimes(1) - sess.run() + conn.run() }() - sess.scheduleSending() + conn.scheduleSending() time.Sleep(50 * time.Millisecond) // make sure that only 1 packet is sent }) @@ -1524,9 +1524,9 @@ var _ = Describe("Connection", func() { go func() { defer GinkgoRecover() cryptoSetup.EXPECT().RunHandshake().MaxTimes(1) - sess.run() + conn.run() }() - sess.scheduleSending() + conn.scheduleSending() time.Sleep(50 * time.Millisecond) // make sure that only 1 packet is sent }) @@ -1551,9 +1551,9 @@ var _ = Describe("Connection", func() { go func() { defer GinkgoRecover() cryptoSetup.EXPECT().RunHandshake().MaxTimes(1) - sess.run() + conn.run() }() - sess.scheduleSending() + conn.scheduleSending() Eventually(written).Should(HaveLen(1)) Consistently(written, pacingDelay/2).Should(HaveLen(1)) Eventually(written, 2*pacingDelay).Should(HaveLen(2)) @@ -1574,9 +1574,9 @@ var _ = Describe("Connection", func() { go func() { defer GinkgoRecover() cryptoSetup.EXPECT().RunHandshake().MaxTimes(1) - sess.run() + conn.run() }() - sess.scheduleSending() + conn.scheduleSending() Eventually(written).Should(HaveLen(3)) }) @@ -1587,9 +1587,9 @@ var _ = Describe("Connection", func() { go func() { defer GinkgoRecover() cryptoSetup.EXPECT().RunHandshake().MaxTimes(1) - sess.run() + conn.run() }() - sess.scheduleSending() + conn.scheduleSending() time.Sleep(scaleDuration(50 * time.Millisecond)) written := make(chan struct{}) @@ -1609,14 +1609,14 @@ var _ = Describe("Connection", func() { go func() { defer GinkgoRecover() cryptoSetup.EXPECT().RunHandshake().MaxTimes(1) - sess.run() + conn.run() }() written := make(chan struct{}) sender.EXPECT().WouldBlock().AnyTimes() sph.EXPECT().SentPacket(gomock.Any()).Do(func(*ackhandler.Packet) { sph.EXPECT().ReceivedBytes(gomock.Any()) - sess.handlePacket(&receivedPacket{buffer: getPacketBuffer()}) + conn.handlePacket(&receivedPacket{buffer: getPacketBuffer()}) }) sph.EXPECT().HasPacingBudget().Return(true).AnyTimes() sph.EXPECT().SendMode().Return(ackhandler.SendAny).AnyTimes() @@ -1624,7 +1624,7 @@ var _ = Describe("Connection", func() { packer.EXPECT().PackPacket().Return(nil, nil) sender.EXPECT().Send(gomock.Any()).DoAndReturn(func(p *packetBuffer) { close(written) }) - sess.scheduleSending() + conn.scheduleSending() time.Sleep(scaleDuration(50 * time.Millisecond)) Eventually(written).Should(BeClosed()) @@ -1642,11 +1642,11 @@ var _ = Describe("Connection", func() { go func() { defer GinkgoRecover() cryptoSetup.EXPECT().RunHandshake().MaxTimes(1) - sess.run() + conn.run() }() available := make(chan struct{}, 1) sender.EXPECT().Available().Return(available) - sess.scheduleSending() + conn.scheduleSending() Eventually(written).Should(Receive()) time.Sleep(scaleDuration(50 * time.Millisecond)) @@ -1675,16 +1675,16 @@ var _ = Describe("Connection", func() { go func() { defer GinkgoRecover() cryptoSetup.EXPECT().RunHandshake().MaxTimes(1) - sess.run() + conn.run() }() - sess.scheduleSending() // no packet will get sent + conn.scheduleSending() // no packet will get sent time.Sleep(50 * time.Millisecond) }) It("sends a Path MTU probe packet", func() { mtuDiscoverer := NewMockMtuDiscoverer(mockCtrl) - sess.mtuDiscoverer = mtuDiscoverer - sess.config.DisablePathMTUDiscovery = false + conn.mtuDiscoverer = mtuDiscoverer + conn.config.DisablePathMTUDiscovery = false sph.EXPECT().SentPacket(gomock.Any()) sph.EXPECT().HasPacingBudget().Return(true).AnyTimes() sph.EXPECT().SendMode().Return(ackhandler.SendAny) @@ -1703,9 +1703,9 @@ var _ = Describe("Connection", func() { go func() { defer GinkgoRecover() cryptoSetup.EXPECT().RunHandshake().MaxTimes(1) - sess.run() + conn.run() }() - sess.scheduleSending() + conn.scheduleSending() Eventually(written).Should(Receive()) }) }) @@ -1717,8 +1717,8 @@ var _ = Describe("Connection", func() { sender = NewMockSender(mockCtrl) sender.EXPECT().WouldBlock().AnyTimes() sender.EXPECT().Run() - sess.sendQueue = sender - sess.handshakeConfirmed = true + conn.sendQueue = sender + conn.handshakeConfirmed = true }) AfterEach(func() { @@ -1731,8 +1731,8 @@ var _ = Describe("Connection", func() { sender.EXPECT().Close() tracer.EXPECT().ClosedConnection(gomock.Any()) tracer.EXPECT().Close() - sess.shutdown() - Eventually(sess.Context().Done()).Should(BeClosed()) + conn.shutdown() + Eventually(conn.Context().Done()).Should(BeClosed()) }) It("sends when scheduleSending is called", func() { @@ -1742,14 +1742,14 @@ var _ = Describe("Connection", func() { sph.EXPECT().SendMode().Return(ackhandler.SendAny).AnyTimes() sph.EXPECT().HasPacingBudget().Return(true).AnyTimes() sph.EXPECT().SentPacket(gomock.Any()) - sess.sentPacketHandler = sph + conn.sentPacketHandler = sph packer.EXPECT().PackPacket().Return(getPacket(1), nil) packer.EXPECT().PackPacket().Return(nil, nil) go func() { defer GinkgoRecover() cryptoSetup.EXPECT().RunHandshake().MaxTimes(1) - sess.run() + conn.run() }() // don't EXPECT any calls to mconn.Write() time.Sleep(50 * time.Millisecond) @@ -1757,7 +1757,7 @@ var _ = Describe("Connection", func() { written := make(chan struct{}) sender.EXPECT().Send(gomock.Any()).Do(func(*packetBuffer) { close(written) }) tracer.EXPECT().SentPacket(gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any()).AnyTimes() - sess.scheduleSending() + conn.scheduleSending() Eventually(written).Should(BeClosed()) }) @@ -1771,12 +1771,12 @@ var _ = Describe("Connection", func() { sph.EXPECT().SentPacket(gomock.Any()).Do(func(p *ackhandler.Packet) { Expect(p.PacketNumber).To(Equal(protocol.PacketNumber(1234))) }) - sess.sentPacketHandler = sph + conn.sentPacketHandler = sph rph := mockackhandler.NewMockReceivedPacketHandler(mockCtrl) rph.EXPECT().GetAlarmTimeout().Return(time.Now().Add(10 * time.Millisecond)) // make the run loop wait rph.EXPECT().GetAlarmTimeout().Return(time.Now().Add(time.Hour)).MaxTimes(1) - sess.receivedPacketHandler = rph + conn.receivedPacketHandler = rph written := make(chan struct{}) sender.EXPECT().Send(gomock.Any()).Do(func(*packetBuffer) { close(written) }) @@ -1784,17 +1784,17 @@ var _ = Describe("Connection", func() { go func() { defer GinkgoRecover() cryptoSetup.EXPECT().RunHandshake().MaxTimes(1) - sess.run() + conn.run() }() Eventually(written).Should(BeClosed()) }) }) It("sends coalesced packets before the handshake is confirmed", func() { - sess.handshakeComplete = false - sess.handshakeConfirmed = false + conn.handshakeComplete = false + conn.handshakeConfirmed = false sph := mockackhandler.NewMockSentPacketHandler(mockCtrl) - sess.sentPacketHandler = sph + conn.sentPacketHandler = sph buffer := getPacketBuffer() buffer.Data = append(buffer.Data, []byte("foobar")...) packer.EXPECT().PackCoalescedPacket().Return(&coalescedPacket{ @@ -1854,10 +1854,10 @@ var _ = Describe("Connection", func() { go func() { defer GinkgoRecover() cryptoSetup.EXPECT().RunHandshake().MaxTimes(1) - sess.run() + conn.run() }() - sess.scheduleSending() + conn.scheduleSending() Eventually(sent).Should(BeClosed()) // make sure the go routine returns @@ -1868,15 +1868,15 @@ var _ = Describe("Connection", func() { mconn.EXPECT().Write(gomock.Any()) tracer.EXPECT().ClosedConnection(gomock.Any()) tracer.EXPECT().Close() - sess.shutdown() - Eventually(sess.Context().Done()).Should(BeClosed()) + conn.shutdown() + Eventually(conn.Context().Done()).Should(BeClosed()) }) It("cancels the HandshakeComplete context when the handshake completes", func() { packer.EXPECT().PackCoalescedPacket().AnyTimes() finishHandshake := make(chan struct{}) sph := mockackhandler.NewMockSentPacketHandler(mockCtrl) - sess.sentPacketHandler = sph + conn.sentPacketHandler = sph sph.EXPECT().GetLossDetectionTimeout().AnyTimes() sph.EXPECT().TimeUntilSend().AnyTimes() sph.EXPECT().SendMode().AnyTimes() @@ -1888,10 +1888,10 @@ var _ = Describe("Connection", func() { cryptoSetup.EXPECT().RunHandshake() cryptoSetup.EXPECT().SetHandshakeConfirmed() cryptoSetup.EXPECT().GetSessionTicket() - close(sess.handshakeCompleteChan) - sess.run() + close(conn.handshakeCompleteChan) + conn.run() }() - handshakeCtx := sess.HandshakeComplete() + handshakeCtx := conn.HandshakeComplete() Consistently(handshakeCtx.Done()).ShouldNot(BeClosed()) close(finishHandshake) Eventually(handshakeCtx.Done()).Should(BeClosed()) @@ -1903,11 +1903,11 @@ var _ = Describe("Connection", func() { mconn.EXPECT().Write(gomock.Any()) tracer.EXPECT().ClosedConnection(gomock.Any()) tracer.EXPECT().Close() - sess.shutdown() - Eventually(sess.Context().Done()).Should(BeClosed()) + conn.shutdown() + Eventually(conn.Context().Done()).Should(BeClosed()) }) - It("sends a session ticket when the handshake completes", func() { + It("sends a connection ticket when the handshake completes", func() { const size = protocol.MaxPostHandshakeCryptoFrameSize * 3 / 2 packer.EXPECT().PackCoalescedPacket().AnyTimes() finishHandshake := make(chan struct{}) @@ -1918,16 +1918,16 @@ var _ = Describe("Connection", func() { cryptoSetup.EXPECT().RunHandshake() cryptoSetup.EXPECT().SetHandshakeConfirmed() cryptoSetup.EXPECT().GetSessionTicket().Return(make([]byte, size), nil) - close(sess.handshakeCompleteChan) - sess.run() + close(conn.handshakeCompleteChan) + conn.run() }() - handshakeCtx := sess.HandshakeComplete() + handshakeCtx := conn.HandshakeComplete() Consistently(handshakeCtx.Done()).ShouldNot(BeClosed()) close(finishHandshake) var frames []ackhandler.Frame Eventually(func() []ackhandler.Frame { - frames, _ = sess.framer.AppendControlFrames(nil, protocol.MaxByteCount) + frames, _ = conn.framer.AppendControlFrames(nil, protocol.MaxByteCount) return frames }).ShouldNot(BeEmpty()) var count int @@ -1936,7 +1936,7 @@ var _ = Describe("Connection", func() { if cf, ok := f.Frame.(*wire.CryptoFrame); ok { count++ s += len(cf.Data) - Expect(f.Length(sess.version)).To(BeNumerically("<=", protocol.MaxPostHandshakeCryptoFrameSize)) + Expect(f.Length(conn.version)).To(BeNumerically("<=", protocol.MaxPostHandshakeCryptoFrameSize)) } } Expect(size).To(BeEquivalentTo(s)) @@ -1948,8 +1948,8 @@ var _ = Describe("Connection", func() { mconn.EXPECT().Write(gomock.Any()) tracer.EXPECT().ClosedConnection(gomock.Any()) tracer.EXPECT().Close() - sess.shutdown() - Eventually(sess.Context().Done()).Should(BeClosed()) + conn.shutdown() + Eventually(conn.Context().Done()).Should(BeClosed()) }) It("doesn't cancel the HandshakeComplete context when the handshake fails", func() { @@ -1963,14 +1963,14 @@ var _ = Describe("Connection", func() { go func() { defer GinkgoRecover() cryptoSetup.EXPECT().RunHandshake() - sess.run() + conn.run() }() - handshakeCtx := sess.HandshakeComplete() + handshakeCtx := conn.HandshakeComplete() Consistently(handshakeCtx.Done()).ShouldNot(BeClosed()) mconn.EXPECT().Write(gomock.Any()) - sess.closeLocal(errors.New("handshake error")) + conn.closeLocal(errors.New("handshake error")) Consistently(handshakeCtx.Done()).ShouldNot(BeClosed()) - Eventually(sess.Context().Done()).Should(BeClosed()) + Eventually(conn.Context().Done()).Should(BeClosed()) }) It("sends a HANDSHAKE_DONE frame when the handshake completes", func() { @@ -1983,11 +1983,11 @@ var _ = Describe("Connection", func() { sph.EXPECT().SentPacket(gomock.Any()) mconn.EXPECT().Write(gomock.Any()) tracer.EXPECT().SentPacket(gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any()) - sess.sentPacketHandler = sph + conn.sentPacketHandler = sph done := make(chan struct{}) connRunner.EXPECT().Retire(clientDestConnID) packer.EXPECT().PackPacket().DoAndReturn(func() (*packedPacket, error) { - frames, _ := sess.framer.AppendControlFrames(nil, protocol.MaxByteCount) + frames, _ := conn.framer.AppendControlFrames(nil, protocol.MaxByteCount) Expect(frames).ToNot(BeEmpty()) Expect(frames[0].Frame).To(BeEquivalentTo(&wire.HandshakeDoneFrame{})) defer close(done) @@ -2005,8 +2005,8 @@ var _ = Describe("Connection", func() { cryptoSetup.EXPECT().SetHandshakeConfirmed() cryptoSetup.EXPECT().GetSessionTicket() mconn.EXPECT().Write(gomock.Any()) - close(sess.handshakeCompleteChan) - sess.run() + close(conn.handshakeCompleteChan) + conn.run() }() Eventually(done).Should(BeClosed()) // make sure the go routine returns @@ -2016,8 +2016,8 @@ var _ = Describe("Connection", func() { cryptoSetup.EXPECT().Close() tracer.EXPECT().ClosedConnection(gomock.Any()) tracer.EXPECT().Close() - sess.shutdown() - Eventually(sess.Context().Done()).Should(BeClosed()) + conn.shutdown() + Eventually(conn.Context().Done()).Should(BeClosed()) }) It("doesn't return a run error when closing", func() { @@ -2025,7 +2025,7 @@ var _ = Describe("Connection", func() { go func() { defer GinkgoRecover() cryptoSetup.EXPECT().RunHandshake().MaxTimes(1) - Expect(sess.run()).To(Succeed()) + Expect(conn.run()).To(Succeed()) close(done) }() streamManager.EXPECT().CloseWithError(gomock.Any()) @@ -2035,17 +2035,17 @@ var _ = Describe("Connection", func() { mconn.EXPECT().Write(gomock.Any()) tracer.EXPECT().ClosedConnection(gomock.Any()) tracer.EXPECT().Close() - sess.shutdown() + conn.shutdown() Eventually(done).Should(BeClosed()) }) - It("passes errors to the session runner", func() { + It("passes errors to the connection runner", func() { testErr := errors.New("handshake error") done := make(chan struct{}) go func() { defer GinkgoRecover() cryptoSetup.EXPECT().RunHandshake().MaxTimes(1) - err := sess.run() + err := conn.run() Expect(err).To(MatchError(&qerr.ApplicationError{ ErrorCode: 0x1337, ErrorMessage: testErr.Error(), @@ -2059,7 +2059,7 @@ var _ = Describe("Connection", func() { mconn.EXPECT().Write(gomock.Any()) tracer.EXPECT().ClosedConnection(gomock.Any()) tracer.EXPECT().Close() - Expect(sess.CloseWithError(0x1337, testErr.Error())).To(Succeed()) + Expect(conn.CloseWithError(0x1337, testErr.Error())).To(Succeed()) Eventually(done).Should(BeClosed()) }) @@ -2077,12 +2077,12 @@ var _ = Describe("Connection", func() { streamManager.EXPECT().UpdateLimits(params) packer.EXPECT().HandleTransportParameters(params) packer.EXPECT().PackCoalescedPacket().MaxTimes(3) - Expect(sess.earlyConnReady()).ToNot(BeClosed()) + Expect(conn.earlyConnReady()).ToNot(BeClosed()) connRunner.EXPECT().GetStatelessResetToken(gomock.Any()).Times(2) - connRunner.EXPECT().Add(gomock.Any(), sess).Times(2) + connRunner.EXPECT().Add(gomock.Any(), conn).Times(2) tracer.EXPECT().ReceivedTransportParameters(params) - sess.handleTransportParameters(params) - Expect(sess.earlyConnReady()).To(BeClosed()) + conn.handleTransportParameters(params) + Expect(conn.earlyConnReady()).To(BeClosed()) }) }) @@ -2091,24 +2091,24 @@ var _ = Describe("Connection", func() { streamManager.EXPECT().UpdateLimits(gomock.Any()) packer.EXPECT().HandleTransportParameters(gomock.Any()) tracer.EXPECT().ReceivedTransportParameters(gomock.Any()) - sess.handleTransportParameters(&wire.TransportParameters{ + conn.handleTransportParameters(&wire.TransportParameters{ MaxIdleTimeout: t, InitialSourceConnectionID: destConnID, }) } - runSession := func() { + runConn := func() { go func() { defer GinkgoRecover() cryptoSetup.EXPECT().RunHandshake().MaxTimes(1) - sess.run() + conn.run() }() } BeforeEach(func() { - sess.config.MaxIdleTimeout = 30 * time.Second - sess.config.KeepAlive = true - sess.receivedPacketHandler.ReceivedPacket(0, protocol.ECNNon, protocol.EncryptionHandshake, time.Now(), true) + conn.config.MaxIdleTimeout = 30 * time.Second + conn.config.KeepAlive = true + conn.receivedPacketHandler.ReceivedPacket(0, protocol.ECNNon, protocol.EncryptionHandshake, time.Now(), true) }) AfterEach(func() { @@ -2120,51 +2120,51 @@ var _ = Describe("Connection", func() { mconn.EXPECT().Write(gomock.Any()) tracer.EXPECT().ClosedConnection(gomock.Any()) tracer.EXPECT().Close() - sess.shutdown() - Eventually(sess.Context().Done()).Should(BeClosed()) + conn.shutdown() + Eventually(conn.Context().Done()).Should(BeClosed()) }) It("sends a PING as a keep-alive after half the idle timeout", func() { setRemoteIdleTimeout(5 * time.Second) - sess.lastPacketReceivedTime = time.Now().Add(-5 * time.Second / 2) + conn.lastPacketReceivedTime = time.Now().Add(-5 * time.Second / 2) sent := make(chan struct{}) packer.EXPECT().PackCoalescedPacket().Do(func() (*packedPacket, error) { close(sent) return nil, nil }) - runSession() + runConn() Eventually(sent).Should(BeClosed()) }) It("sends a PING after a maximum of protocol.MaxKeepAliveInterval", func() { - sess.config.MaxIdleTimeout = time.Hour + conn.config.MaxIdleTimeout = time.Hour setRemoteIdleTimeout(time.Hour) - sess.lastPacketReceivedTime = time.Now().Add(-protocol.MaxKeepAliveInterval).Add(-time.Millisecond) + conn.lastPacketReceivedTime = time.Now().Add(-protocol.MaxKeepAliveInterval).Add(-time.Millisecond) sent := make(chan struct{}) packer.EXPECT().PackCoalescedPacket().Do(func() (*packedPacket, error) { close(sent) return nil, nil }) - runSession() + runConn() Eventually(sent).Should(BeClosed()) }) It("doesn't send a PING packet if keep-alive is disabled", func() { setRemoteIdleTimeout(5 * time.Second) - sess.config.KeepAlive = false - sess.lastPacketReceivedTime = time.Now().Add(-time.Second * 5 / 2) - runSession() + conn.config.KeepAlive = false + conn.lastPacketReceivedTime = time.Now().Add(-time.Second * 5 / 2) + runConn() // don't EXPECT() any calls to mconn.Write() time.Sleep(50 * time.Millisecond) }) It("doesn't send a PING if the handshake isn't completed yet", func() { - sess.config.HandshakeIdleTimeout = time.Hour - sess.handshakeComplete = false + conn.config.HandshakeIdleTimeout = time.Hour + conn.handshakeComplete = false // Needs to be shorter than our idle timeout. // Otherwise we'll try to send a CONNECTION_CLOSE. - sess.lastPacketReceivedTime = time.Now().Add(-20 * time.Second) - runSession() + conn.lastPacketReceivedTime = time.Now().Add(-20 * time.Second) + runConn() // don't EXPECT() any calls to mconn.Write() time.Sleep(50 * time.Millisecond) }) @@ -2177,7 +2177,7 @@ var _ = Describe("Connection", func() { It("times out due to no network activity", func() { connRunner.EXPECT().Remove(gomock.Any()).Times(2) - sess.lastPacketReceivedTime = time.Now().Add(-time.Hour) + conn.lastPacketReceivedTime = time.Now().Add(-time.Hour) done := make(chan struct{}) cryptoSetup.EXPECT().Close() gomock.InOrder( @@ -2189,7 +2189,7 @@ var _ = Describe("Connection", func() { go func() { defer GinkgoRecover() cryptoSetup.EXPECT().RunHandshake().MaxTimes(1) - err := sess.run() + err := conn.run() nerr, ok := err.(net.Error) Expect(ok).To(BeTrue()) Expect(nerr.Timeout()).To(BeTrue()) @@ -2200,8 +2200,8 @@ var _ = Describe("Connection", func() { }) It("times out due to non-completed handshake", func() { - sess.handshakeComplete = false - sess.sessionCreationTime = time.Now().Add(-protocol.DefaultHandshakeTimeout).Add(-time.Second) + conn.handshakeComplete = false + conn.creationTime = time.Now().Add(-protocol.DefaultHandshakeTimeout).Add(-time.Second) connRunner.EXPECT().Remove(gomock.Any()).Times(2) cryptoSetup.EXPECT().Close() gomock.InOrder( @@ -2214,7 +2214,7 @@ var _ = Describe("Connection", func() { go func() { defer GinkgoRecover() cryptoSetup.EXPECT().RunHandshake().MaxTimes(1) - err := sess.run() + err := conn.run() nerr, ok := err.(net.Error) Expect(ok).To(BeTrue()) Expect(nerr.Timeout()).To(BeTrue()) @@ -2225,10 +2225,10 @@ var _ = Describe("Connection", func() { }) It("does not use the idle timeout before the handshake complete", func() { - sess.handshakeComplete = false - sess.config.HandshakeIdleTimeout = 9999 * time.Second - sess.config.MaxIdleTimeout = 9999 * time.Second - sess.lastPacketReceivedTime = time.Now().Add(-time.Minute) + conn.handshakeComplete = false + conn.config.HandshakeIdleTimeout = 9999 * time.Second + conn.config.MaxIdleTimeout = 9999 * time.Second + conn.lastPacketReceivedTime = time.Now().Add(-time.Minute) packer.EXPECT().PackApplicationClose(gomock.Any()).DoAndReturn(func(e *qerr.ApplicationError) (*coalescedPacket, error) { Expect(e.ErrorCode).To(BeZero()) return &coalescedPacket{buffer: getPacketBuffer()}, nil @@ -2242,24 +2242,24 @@ var _ = Describe("Connection", func() { }), tracer.EXPECT().Close(), ) - // 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 connection was created, // and not on the last network activity go func() { defer GinkgoRecover() cryptoSetup.EXPECT().RunHandshake().MaxTimes(1) - sess.run() + conn.run() }() - Consistently(sess.Context().Done()).ShouldNot(BeClosed()) + Consistently(conn.Context().Done()).ShouldNot(BeClosed()) // make the go routine return expectReplaceWithClosed() cryptoSetup.EXPECT().Close() mconn.EXPECT().Write(gomock.Any()) - sess.shutdown() - Eventually(sess.Context().Done()).Should(BeClosed()) + conn.shutdown() + Eventually(conn.Context().Done()).Should(BeClosed()) }) - It("closes the session due to the idle timeout before handshake", func() { - sess.config.HandshakeIdleTimeout = 0 + It("closes the connection due to the idle timeout before handshake", func() { + conn.config.HandshakeIdleTimeout = 0 packer.EXPECT().PackCoalescedPacket().AnyTimes() connRunner.EXPECT().Remove(gomock.Any()).AnyTimes() cryptoSetup.EXPECT().Close() @@ -2270,12 +2270,12 @@ var _ = Describe("Connection", func() { tracer.EXPECT().Close(), ) done := make(chan struct{}) - sess.handshakeComplete = false + conn.handshakeComplete = false go func() { defer GinkgoRecover() cryptoSetup.EXPECT().RunHandshake().MaxTimes(1) cryptoSetup.EXPECT().GetSessionTicket().MaxTimes(1) - err := sess.run() + err := conn.run() nerr, ok := err.(net.Error) Expect(ok).To(BeTrue()) Expect(nerr.Timeout()).To(BeTrue()) @@ -2285,7 +2285,7 @@ var _ = Describe("Connection", func() { Eventually(done).Should(BeClosed()) }) - It("closes the session due to the idle timeout after handshake", func() { + It("closes the connection due to the idle timeout after handshake", func() { packer.EXPECT().PackCoalescedPacket().AnyTimes() gomock.InOrder( connRunner.EXPECT().Retire(clientDestConnID), @@ -2298,15 +2298,15 @@ var _ = Describe("Connection", func() { }), tracer.EXPECT().Close(), ) - sess.idleTimeout = 0 + conn.idleTimeout = 0 done := make(chan struct{}) go func() { defer GinkgoRecover() cryptoSetup.EXPECT().RunHandshake().MaxTimes(1) cryptoSetup.EXPECT().GetSessionTicket().MaxTimes(1) cryptoSetup.EXPECT().SetHandshakeConfirmed().MaxTimes(1) - close(sess.handshakeCompleteChan) - err := sess.run() + close(conn.handshakeCompleteChan) + err := conn.run() nerr, ok := err.(net.Error) Expect(ok).To(BeTrue()) Expect(nerr.Timeout()).To(BeTrue()) @@ -2317,15 +2317,15 @@ var _ = Describe("Connection", func() { }) It("doesn't time out when it just sent a packet", func() { - sess.lastPacketReceivedTime = time.Now().Add(-time.Hour) - sess.firstAckElicitingPacketAfterIdleSentTime = time.Now().Add(-time.Second) - sess.idleTimeout = 30 * time.Second + conn.lastPacketReceivedTime = time.Now().Add(-time.Hour) + conn.firstAckElicitingPacketAfterIdleSentTime = time.Now().Add(-time.Second) + conn.idleTimeout = 30 * time.Second go func() { defer GinkgoRecover() cryptoSetup.EXPECT().RunHandshake().MaxTimes(1) - sess.run() + conn.run() }() - Consistently(sess.Context().Done()).ShouldNot(BeClosed()) + Consistently(conn.Context().Done()).ShouldNot(BeClosed()) // make the go routine return packer.EXPECT().PackApplicationClose(gomock.Any()).Return(&coalescedPacket{buffer: getPacketBuffer()}, nil) expectReplaceWithClosed() @@ -2333,19 +2333,19 @@ var _ = Describe("Connection", func() { mconn.EXPECT().Write(gomock.Any()) tracer.EXPECT().ClosedConnection(gomock.Any()) tracer.EXPECT().Close() - sess.shutdown() - Eventually(sess.Context().Done()).Should(BeClosed()) + conn.shutdown() + Eventually(conn.Context().Done()).Should(BeClosed()) }) }) - It("stores up to MaxSessionUnprocessedPackets packets", func() { + It("stores up to MaxConnUnprocessedPackets packets", func() { done := make(chan struct{}) tracer.EXPECT().DroppedPacket(logging.PacketTypeNotDetermined, logging.ByteCount(6), logging.PacketDropDOSPrevention).Do(func(logging.PacketType, logging.ByteCount, logging.PacketDropReason) { close(done) }) // Nothing here should block - for i := protocol.PacketNumber(0); i < protocol.MaxSessionUnprocessedPackets+1; i++ { - sess.handlePacket(&receivedPacket{data: []byte("foobar")}) + for i := protocol.PacketNumber(0); i < protocol.MaxConnUnprocessedPackets+1; i++ { + conn.handlePacket(&receivedPacket{data: []byte("foobar")}) } Eventually(done).Should(BeClosed()) }) @@ -2354,7 +2354,7 @@ var _ = Describe("Connection", func() { It("opens streams", func() { mstr := NewMockStreamI(mockCtrl) streamManager.EXPECT().OpenStream().Return(mstr, nil) - str, err := sess.OpenStream() + str, err := conn.OpenStream() Expect(err).ToNot(HaveOccurred()) Expect(str).To(Equal(mstr)) }) @@ -2362,7 +2362,7 @@ var _ = Describe("Connection", func() { It("opens streams synchronously", func() { mstr := NewMockStreamI(mockCtrl) streamManager.EXPECT().OpenStreamSync(context.Background()).Return(mstr, nil) - str, err := sess.OpenStreamSync(context.Background()) + str, err := conn.OpenStreamSync(context.Background()) Expect(err).ToNot(HaveOccurred()) Expect(str).To(Equal(mstr)) }) @@ -2370,7 +2370,7 @@ var _ = Describe("Connection", func() { It("opens unidirectional streams", func() { mstr := NewMockSendStreamI(mockCtrl) streamManager.EXPECT().OpenUniStream().Return(mstr, nil) - str, err := sess.OpenUniStream() + str, err := conn.OpenUniStream() Expect(err).ToNot(HaveOccurred()) Expect(str).To(Equal(mstr)) }) @@ -2378,7 +2378,7 @@ var _ = Describe("Connection", func() { It("opens unidirectional streams synchronously", func() { mstr := NewMockSendStreamI(mockCtrl) streamManager.EXPECT().OpenUniStreamSync(context.Background()).Return(mstr, nil) - str, err := sess.OpenUniStreamSync(context.Background()) + str, err := conn.OpenUniStreamSync(context.Background()) Expect(err).ToNot(HaveOccurred()) Expect(str).To(Equal(mstr)) }) @@ -2388,7 +2388,7 @@ var _ = Describe("Connection", func() { defer cancel() mstr := NewMockStreamI(mockCtrl) streamManager.EXPECT().AcceptStream(ctx).Return(mstr, nil) - str, err := sess.AcceptStream(ctx) + str, err := conn.AcceptStream(ctx) Expect(err).ToNot(HaveOccurred()) Expect(str).To(Equal(mstr)) }) @@ -2398,24 +2398,24 @@ var _ = Describe("Connection", func() { defer cancel() mstr := NewMockReceiveStreamI(mockCtrl) streamManager.EXPECT().AcceptUniStream(ctx).Return(mstr, nil) - str, err := sess.AcceptUniStream(ctx) + str, err := conn.AcceptUniStream(ctx) Expect(err).ToNot(HaveOccurred()) Expect(str).To(Equal(mstr)) }) }) It("returns the local address", func() { - Expect(sess.LocalAddr()).To(Equal(localAddr)) + Expect(conn.LocalAddr()).To(Equal(localAddr)) }) It("returns the remote address", func() { - Expect(sess.RemoteAddr()).To(Equal(remoteAddr)) + Expect(conn.RemoteAddr()).To(Equal(remoteAddr)) }) }) var _ = Describe("Client Connection", func() { var ( - sess *session + conn *connection connRunner *MockConnRunner packer *MockPacker mconn *MockSendConn @@ -2429,7 +2429,7 @@ var _ = Describe("Client Connection", func() { getPacket := func(hdr *wire.ExtendedHeader, data []byte) *receivedPacket { buf := &bytes.Buffer{} - Expect(hdr.Write(buf, sess.version)).To(Succeed()) + Expect(hdr.Write(buf, conn.version)).To(Succeed()) return &receivedPacket{ data: append(buf.Bytes(), data...), buffer: getPacketBuffer(), @@ -2463,7 +2463,7 @@ var _ = Describe("Client Connection", func() { tracer.EXPECT().SentTransportParameters(gomock.Any()) tracer.EXPECT().UpdatedKeyFromTLS(gomock.Any(), gomock.Any()).AnyTimes() tracer.EXPECT().UpdatedCongestionState(gomock.Any()) - sess = newClientSession( + conn = newClientConnection( mconn, connRunner, destConnID, @@ -2477,11 +2477,11 @@ var _ = Describe("Client Connection", func() { 1234, utils.DefaultLogger, protocol.VersionTLS, - ).(*session) + ).(*connection) packer = NewMockPacker(mockCtrl) - sess.packer = packer + conn.packer = packer cryptoSetup = mocks.NewMockCryptoSetup(mockCtrl) - sess.cryptoStreamHandler = cryptoSetup + conn.cryptoStreamHandler = cryptoSetup }) It("changes the connection ID when receiving the first packet from the server", func() { @@ -2493,11 +2493,11 @@ var _ = Describe("Client Connection", func() { data: []byte{0}, // one PADDING frame }, nil }) - sess.unpacker = unpacker + conn.unpacker = unpacker go func() { defer GinkgoRecover() cryptoSetup.EXPECT().RunHandshake().MaxTimes(1) - sess.run() + conn.run() }() newConnID := protocol.ConnectionID{1, 3, 3, 7, 1, 3, 3, 7} p := getPacket(&wire.ExtendedHeader{ @@ -2507,12 +2507,12 @@ var _ = Describe("Client Connection", func() { SrcConnectionID: newConnID, DestConnectionID: srcConnID, Length: 2 + 6, - Version: sess.version, + Version: conn.version, }, PacketNumberLen: protocol.PacketNumberLen2, }, []byte("foobar")) tracer.EXPECT().ReceivedPacket(gomock.Any(), p.Size(), []logging.Frame{}) - Expect(sess.handlePacketImpl(p)).To(BeTrue()) + Expect(conn.handlePacketImpl(p)).To(BeTrue()) // make sure the go routine returns packer.EXPECT().PackApplicationClose(gomock.Any()).Return(&coalescedPacket{buffer: getPacketBuffer()}, nil) expectReplaceWithClosed() @@ -2520,20 +2520,20 @@ var _ = Describe("Client Connection", func() { mconn.EXPECT().Write(gomock.Any()) tracer.EXPECT().ClosedConnection(gomock.Any()) tracer.EXPECT().Close() - sess.shutdown() - Eventually(sess.Context().Done()).Should(BeClosed()) + conn.shutdown() + Eventually(conn.Context().Done()).Should(BeClosed()) }) It("continues accepting Long Header packets after using a new connection ID", func() { unpacker := NewMockUnpacker(mockCtrl) - sess.unpacker = unpacker + conn.unpacker = unpacker connRunner.EXPECT().AddResetToken(gomock.Any(), gomock.Any()) - sess.connIDManager.SetHandshakeComplete() - sess.handleNewConnectionIDFrame(&wire.NewConnectionIDFrame{ + conn.connIDManager.SetHandshakeComplete() + conn.handleNewConnectionIDFrame(&wire.NewConnectionIDFrame{ SequenceNumber: 1, ConnectionID: protocol.ConnectionID{1, 2, 3, 4, 5}, }) - Expect(sess.connIDManager.Get()).To(Equal(protocol.ConnectionID{1, 2, 3, 4, 5})) + Expect(conn.connIDManager.Get()).To(Equal(protocol.ConnectionID{1, 2, 3, 4, 5})) // now receive a packet with the original source connection ID unpacker.EXPECT().Unpack(gomock.Any(), gomock.Any(), gomock.Any()).DoAndReturn(func(hdr *wire.Header, _ time.Time, _ []byte) (*unpackedPacket, error) { return &unpackedPacket{ @@ -2549,28 +2549,28 @@ var _ = Describe("Client Connection", func() { SrcConnectionID: destConnID, } tracer.EXPECT().ReceivedPacket(gomock.Any(), gomock.Any(), gomock.Any()) - Expect(sess.handleSinglePacket(&receivedPacket{buffer: getPacketBuffer()}, hdr)).To(BeTrue()) + Expect(conn.handleSinglePacket(&receivedPacket{buffer: getPacketBuffer()}, hdr)).To(BeTrue()) }) It("handles HANDSHAKE_DONE frames", func() { - sess.peerParams = &wire.TransportParameters{} + conn.peerParams = &wire.TransportParameters{} sph := mockackhandler.NewMockSentPacketHandler(mockCtrl) - sess.sentPacketHandler = sph + conn.sentPacketHandler = sph sph.EXPECT().SetHandshakeConfirmed() cryptoSetup.EXPECT().SetHandshakeConfirmed() - Expect(sess.handleHandshakeDoneFrame()).To(Succeed()) + Expect(conn.handleHandshakeDoneFrame()).To(Succeed()) }) It("interprets an ACK for 1-RTT packets as confirmation of the handshake", func() { - sess.peerParams = &wire.TransportParameters{} + conn.peerParams = &wire.TransportParameters{} sph := mockackhandler.NewMockSentPacketHandler(mockCtrl) - sess.sentPacketHandler = sph + conn.sentPacketHandler = sph ack := &wire.AckFrame{AckRanges: []wire.AckRange{{Smallest: 1, Largest: 3}}} sph.EXPECT().ReceivedAck(ack, protocol.Encryption1RTT, gomock.Any()).Return(true, nil) sph.EXPECT().SetHandshakeConfirmed() cryptoSetup.EXPECT().SetLargest1RTTAcked(protocol.PacketNumber(3)) cryptoSetup.EXPECT().SetHandshakeConfirmed() - Expect(sess.handleAckFrame(ack, protocol.Encryption1RTT)).To(Succeed()) + Expect(conn.handleAckFrame(ack, protocol.Encryption1RTT)).To(Succeed()) }) Context("handling tokens", func() { @@ -2586,7 +2586,7 @@ var _ = Describe("Client Connection", func() { It("handles NEW_TOKEN frames", func() { mockTokenStore.EXPECT().Put("server", &ClientToken{data: []byte("foobar")}) - Expect(sess.handleNewTokenFrame(&wire.NewTokenFrame{Token: []byte("foobar")})).To(Succeed()) + Expect(conn.handleNewTokenFrame(&wire.NewTokenFrame{Token: []byte("foobar")})).To(Succeed()) }) }) @@ -2602,15 +2602,15 @@ var _ = Describe("Client Connection", func() { It("closes and returns the right error", func() { sph := mockackhandler.NewMockSentPacketHandler(mockCtrl) - sess.sentPacketHandler = sph + conn.sentPacketHandler = sph sph.EXPECT().ReceivedBytes(gomock.Any()) sph.EXPECT().PeekPacketNumber(protocol.EncryptionInitial).Return(protocol.PacketNumber(128), protocol.PacketNumberLen4) - sess.config.Versions = []protocol.VersionNumber{1234, 4321} + conn.config.Versions = []protocol.VersionNumber{1234, 4321} errChan := make(chan error, 1) go func() { defer GinkgoRecover() cryptoSetup.EXPECT().RunHandshake().MaxTimes(1) - errChan <- sess.run() + errChan <- conn.run() }() connRunner.EXPECT().Remove(srcConnID) tracer.EXPECT().ReceivedVersionNegotiationPacket(gomock.Any(), gomock.Any()).Do(func(hdr *wire.Header, versions []logging.VersionNumber) { @@ -2621,7 +2621,7 @@ var _ = Describe("Client Connection", func() { )) }) cryptoSetup.EXPECT().Close() - Expect(sess.handlePacketImpl(getVNP(4321, 1337))).To(BeFalse()) + Expect(conn.handlePacketImpl(getVNP(4321, 1337))).To(BeFalse()) var err error Eventually(errChan).Should(Receive(&err)) Expect(err).To(HaveOccurred()) @@ -2636,7 +2636,7 @@ var _ = Describe("Client Connection", func() { go func() { defer GinkgoRecover() cryptoSetup.EXPECT().RunHandshake().MaxTimes(1) - errChan <- sess.run() + errChan <- conn.run() }() connRunner.EXPECT().Remove(srcConnID).MaxTimes(1) gomock.InOrder( @@ -2649,7 +2649,7 @@ var _ = Describe("Client Connection", func() { tracer.EXPECT().Close(), ) cryptoSetup.EXPECT().Close() - Expect(sess.handlePacketImpl(getVNP(12345678))).To(BeFalse()) + Expect(conn.handlePacketImpl(getVNP(12345678))).To(BeFalse()) var err error Eventually(errChan).Should(Receive(&err)) Expect(err).To(HaveOccurred()) @@ -2658,16 +2658,16 @@ var _ = Describe("Client Connection", func() { }) It("ignores Version Negotiation packets that offer the current version", func() { - p := getVNP(sess.version) + p := getVNP(conn.version) tracer.EXPECT().DroppedPacket(logging.PacketTypeVersionNegotiation, p.Size(), logging.PacketDropUnexpectedVersion) - Expect(sess.handlePacketImpl(p)).To(BeFalse()) + Expect(conn.handlePacketImpl(p)).To(BeFalse()) }) It("ignores unparseable Version Negotiation packets", func() { - p := getVNP(sess.version) + p := getVNP(conn.version) p.data = p.data[:len(p.data)-2] tracer.EXPECT().DroppedPacket(logging.PacketTypeVersionNegotiation, p.Size(), logging.PacketDropHeaderParseError) - Expect(sess.handlePacketImpl(p)).To(BeFalse()) + Expect(conn.handlePacketImpl(p)).To(BeFalse()) }) }) @@ -2684,20 +2684,20 @@ var _ = Describe("Client Connection", func() { SrcConnectionID: protocol.ConnectionID{0xde, 0xad, 0xbe, 0xef}, DestConnectionID: protocol.ConnectionID{1, 2, 3, 4, 5, 6, 7, 8}, Token: []byte("foobar"), - Version: sess.version, + Version: conn.version, }, } }) getRetryTag := func(hdr *wire.ExtendedHeader) []byte { buf := &bytes.Buffer{} - hdr.Write(buf, sess.version) + hdr.Write(buf, conn.version) return handshake.GetRetryIntegrityTag(buf.Bytes(), origDestConnID, hdr.Version)[:] } It("handles Retry packets", func() { sph := mockackhandler.NewMockSentPacketHandler(mockCtrl) - sess.sentPacketHandler = sph + conn.sentPacketHandler = sph sph.EXPECT().ResetForRetry() sph.EXPECT().ReceivedBytes(gomock.Any()) cryptoSetup.EXPECT().ChangeConnectionID(protocol.ConnectionID{0xde, 0xad, 0xbe, 0xef}) @@ -2707,21 +2707,21 @@ var _ = Describe("Client Connection", func() { Expect(hdr.SrcConnectionID).To(Equal(retryHdr.SrcConnectionID)) Expect(hdr.Token).To(Equal(retryHdr.Token)) }) - Expect(sess.handlePacketImpl(getPacket(retryHdr, getRetryTag(retryHdr)))).To(BeTrue()) + Expect(conn.handlePacketImpl(getPacket(retryHdr, getRetryTag(retryHdr)))).To(BeTrue()) }) It("ignores Retry packets after receiving a regular packet", func() { - sess.receivedFirstPacket = true + conn.receivedFirstPacket = true p := getPacket(retryHdr, getRetryTag(retryHdr)) tracer.EXPECT().DroppedPacket(logging.PacketTypeRetry, p.Size(), logging.PacketDropUnexpectedPacket) - Expect(sess.handlePacketImpl(p)).To(BeFalse()) + Expect(conn.handlePacketImpl(p)).To(BeFalse()) }) It("ignores Retry packets if the server didn't change the connection ID", func() { retryHdr.SrcConnectionID = destConnID p := getPacket(retryHdr, getRetryTag(retryHdr)) tracer.EXPECT().DroppedPacket(logging.PacketTypeRetry, p.Size(), logging.PacketDropUnexpectedPacket) - Expect(sess.handlePacketImpl(p)).To(BeFalse()) + Expect(conn.handlePacketImpl(p)).To(BeFalse()) }) It("ignores Retry packets with the a wrong Integrity tag", func() { @@ -2729,7 +2729,7 @@ var _ = Describe("Client Connection", func() { tag[0]++ p := getPacket(retryHdr, tag) tracer.EXPECT().DroppedPacket(logging.PacketTypeRetry, p.Size(), logging.PacketDropPayloadDecryptError) - Expect(sess.handlePacketImpl(p)).To(BeFalse()) + Expect(conn.handlePacketImpl(p)).To(BeFalse()) }) }) @@ -2745,7 +2745,7 @@ var _ = Describe("Client Connection", func() { go func() { defer GinkgoRecover() cryptoSetup.EXPECT().RunHandshake().MaxTimes(1) - errChan <- sess.run() + errChan <- conn.run() close(errChan) }() }) @@ -2772,8 +2772,8 @@ var _ = Describe("Client Connection", func() { } AfterEach(func() { - sess.shutdown() - Eventually(sess.Context().Done()).Should(BeClosed()) + conn.shutdown() + Eventually(conn.Context().Done()).Should(BeClosed()) Eventually(errChan).Should(BeClosed()) }) @@ -2791,20 +2791,20 @@ var _ = Describe("Client Connection", func() { packer.EXPECT().HandleTransportParameters(gomock.Any()) packer.EXPECT().PackCoalescedPacket().MaxTimes(1) tracer.EXPECT().ReceivedTransportParameters(params) - sess.handleTransportParameters(params) - sess.handleHandshakeComplete() + conn.handleTransportParameters(params) + conn.handleHandshakeComplete() // make sure the connection ID is not retired - cf, _ := sess.framer.AppendControlFrames(nil, protocol.MaxByteCount) + cf, _ := conn.framer.AppendControlFrames(nil, protocol.MaxByteCount) Expect(cf).To(BeEmpty()) - connRunner.EXPECT().AddResetToken(protocol.StatelessResetToken{16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1}, sess) - Expect(sess.connIDManager.Get()).To(Equal(protocol.ConnectionID{1, 2, 3, 4})) + connRunner.EXPECT().AddResetToken(protocol.StatelessResetToken{16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1}, conn) + Expect(conn.connIDManager.Get()).To(Equal(protocol.ConnectionID{1, 2, 3, 4})) // shut down connRunner.EXPECT().RemoveResetToken(protocol.StatelessResetToken{16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1}) expectClose(true) }) It("uses the minimum of the peers' idle timeouts", func() { - sess.config.MaxIdleTimeout = 19 * time.Second + conn.config.MaxIdleTimeout = 19 * time.Second params := &wire.TransportParameters{ OriginalDestinationConnectionID: destConnID, InitialSourceConnectionID: destConnID, @@ -2812,14 +2812,14 @@ var _ = Describe("Client Connection", func() { } packer.EXPECT().HandleTransportParameters(gomock.Any()) tracer.EXPECT().ReceivedTransportParameters(params) - sess.handleTransportParameters(params) - sess.handleHandshakeComplete() - Expect(sess.idleTimeout).To(Equal(18 * time.Second)) + conn.handleTransportParameters(params) + conn.handleHandshakeComplete() + Expect(conn.idleTimeout).To(Equal(18 * time.Second)) expectClose(true) }) It("errors if the transport parameters contain a wrong initial_source_connection_id", func() { - sess.handshakeDestConnID = protocol.ConnectionID{0xde, 0xad, 0xbe, 0xef} + conn.handshakeDestConnID = protocol.ConnectionID{0xde, 0xad, 0xbe, 0xef} params := &wire.TransportParameters{ OriginalDestinationConnectionID: destConnID, InitialSourceConnectionID: protocol.ConnectionID{0xde, 0xca, 0xfb, 0xad}, @@ -2827,7 +2827,7 @@ var _ = Describe("Client Connection", func() { } expectClose(false) tracer.EXPECT().ReceivedTransportParameters(params) - sess.handleTransportParameters(params) + conn.handleTransportParameters(params) Eventually(errChan).Should(Receive(MatchError(&qerr.TransportError{ ErrorCode: qerr.TransportParameterError, ErrorMessage: "expected initial_source_connection_id to equal deadbeef, is decafbad", @@ -2835,7 +2835,7 @@ var _ = Describe("Client Connection", func() { }) It("errors if the transport parameters don't contain the retry_source_connection_id, if a Retry was performed", func() { - sess.retrySrcConnID = &protocol.ConnectionID{0xde, 0xad, 0xbe, 0xef} + conn.retrySrcConnID = &protocol.ConnectionID{0xde, 0xad, 0xbe, 0xef} params := &wire.TransportParameters{ OriginalDestinationConnectionID: destConnID, InitialSourceConnectionID: destConnID, @@ -2843,7 +2843,7 @@ var _ = Describe("Client Connection", func() { } expectClose(false) tracer.EXPECT().ReceivedTransportParameters(params) - sess.handleTransportParameters(params) + conn.handleTransportParameters(params) Eventually(errChan).Should(Receive(MatchError(&qerr.TransportError{ ErrorCode: qerr.TransportParameterError, ErrorMessage: "missing retry_source_connection_id", @@ -2851,7 +2851,7 @@ var _ = Describe("Client Connection", func() { }) It("errors if the transport parameters contain the wrong retry_source_connection_id, if a Retry was performed", func() { - sess.retrySrcConnID = &protocol.ConnectionID{0xde, 0xad, 0xbe, 0xef} + conn.retrySrcConnID = &protocol.ConnectionID{0xde, 0xad, 0xbe, 0xef} params := &wire.TransportParameters{ OriginalDestinationConnectionID: destConnID, InitialSourceConnectionID: destConnID, @@ -2860,7 +2860,7 @@ var _ = Describe("Client Connection", func() { } expectClose(false) tracer.EXPECT().ReceivedTransportParameters(params) - sess.handleTransportParameters(params) + conn.handleTransportParameters(params) Eventually(errChan).Should(Receive(MatchError(&qerr.TransportError{ ErrorCode: qerr.TransportParameterError, ErrorMessage: "expected retry_source_connection_id to equal deadbeef, is deadc0de", @@ -2876,7 +2876,7 @@ var _ = Describe("Client Connection", func() { } expectClose(false) tracer.EXPECT().ReceivedTransportParameters(params) - sess.handleTransportParameters(params) + conn.handleTransportParameters(params) Eventually(errChan).Should(Receive(MatchError(&qerr.TransportError{ ErrorCode: qerr.TransportParameterError, ErrorMessage: "received retry_source_connection_id, although no Retry was performed", @@ -2884,15 +2884,15 @@ var _ = Describe("Client Connection", func() { }) It("errors if the transport parameters contain a wrong original_destination_connection_id", func() { - sess.origDestConnID = protocol.ConnectionID{0xde, 0xad, 0xbe, 0xef} + conn.origDestConnID = protocol.ConnectionID{0xde, 0xad, 0xbe, 0xef} params := &wire.TransportParameters{ OriginalDestinationConnectionID: protocol.ConnectionID{0xde, 0xca, 0xfb, 0xad}, - InitialSourceConnectionID: sess.handshakeDestConnID, + InitialSourceConnectionID: conn.handshakeDestConnID, StatelessResetToken: &protocol.StatelessResetToken{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16}, } expectClose(false) tracer.EXPECT().ReceivedTransportParameters(params) - sess.handleTransportParameters(params) + conn.handleTransportParameters(params) Eventually(errChan).Should(Receive(MatchError(&qerr.TransportError{ ErrorCode: qerr.TransportParameterError, ErrorMessage: "expected original_destination_connection_id to equal deadbeef, is decafbad", @@ -2905,7 +2905,7 @@ var _ = Describe("Client Connection", func() { getPacket := func(extHdr *wire.ExtendedHeader, data []byte) *receivedPacket { buf := &bytes.Buffer{} - Expect(extHdr.Write(buf, sess.version)).To(Succeed()) + Expect(extHdr.Write(buf, conn.version)).To(Succeed()) return &receivedPacket{ data: append(buf.Bytes(), data...), buffer: getPacketBuffer(), @@ -2925,7 +2925,7 @@ var _ = Describe("Client Connection", func() { It("ignores Initial packets with a different source connection ID", func() { // Modified from test "ignores packets with a different source connection ID" unpacker = NewMockUnpacker(mockCtrl) - sess.unpacker = unpacker + conn.unpacker = unpacker hdr1 := &wire.ExtendedHeader{ Header: wire.Header{ @@ -2934,7 +2934,7 @@ var _ = Describe("Client Connection", func() { DestConnectionID: destConnID, SrcConnectionID: srcConnID, Length: 1, - Version: sess.version, + Version: conn.version, }, PacketNumberLen: protocol.PacketNumberLen1, PacketNumber: 1, @@ -2946,7 +2946,7 @@ var _ = Describe("Client Connection", func() { DestConnectionID: destConnID, SrcConnectionID: protocol.ConnectionID{0xde, 0xad, 0xbe, 0xef}, Length: 1, - Version: sess.version, + Version: conn.version, }, PacketNumberLen: protocol.PacketNumberLen1, PacketNumber: 2, @@ -2960,10 +2960,10 @@ var _ = Describe("Client Connection", func() { data: []byte{0}, // one PADDING frame }, nil) tracer.EXPECT().ReceivedPacket(gomock.Any(), gomock.Any(), gomock.Any()) - Expect(sess.handlePacketImpl(getPacket(hdr1, nil))).To(BeTrue()) + Expect(conn.handlePacketImpl(getPacket(hdr1, nil))).To(BeTrue()) // The next packet has to be ignored, since the source connection ID doesn't match. tracer.EXPECT().DroppedPacket(gomock.Any(), gomock.Any(), gomock.Any()) - Expect(sess.handlePacketImpl(getPacket(hdr2, nil))).To(BeFalse()) + Expect(conn.handlePacketImpl(getPacket(hdr2, nil))).To(BeFalse()) }) It("ignores 0-RTT packets", func() { @@ -2973,22 +2973,22 @@ var _ = Describe("Client Connection", func() { Type: protocol.PacketType0RTT, DestConnectionID: srcConnID, Length: 2 + 6, - Version: sess.version, + Version: conn.version, }, PacketNumber: 0x42, PacketNumberLen: protocol.PacketNumberLen2, }, []byte("foobar")) tracer.EXPECT().DroppedPacket(logging.PacketType0RTT, p.Size(), gomock.Any()) - Expect(sess.handlePacketImpl(p)).To(BeFalse()) + Expect(conn.handlePacketImpl(p)).To(BeFalse()) }) // Illustrates that an injected Initial with an ACK frame for an unsent packet causes // the connection to immediately break down It("fails on Initial-level ACK for unsent packet", func() { ack := &wire.AckFrame{AckRanges: []wire.AckRange{{Smallest: 2, Largest: 2}}} - initialPacket := testutils.ComposeInitialPacket(destConnID, srcConnID, sess.version, destConnID, []wire.Frame{ack}) + initialPacket := testutils.ComposeInitialPacket(destConnID, srcConnID, conn.version, destConnID, []wire.Frame{ack}) tracer.EXPECT().ReceivedPacket(gomock.Any(), gomock.Any(), gomock.Any()) - Expect(sess.handlePacketImpl(wrapPacket(initialPacket))).To(BeFalse()) + Expect(conn.handlePacketImpl(wrapPacket(initialPacket))).To(BeFalse()) }) // Illustrates that an injected Initial with a CONNECTION_CLOSE frame causes @@ -2998,16 +2998,16 @@ var _ = Describe("Client Connection", func() { IsApplicationError: true, ReasonPhrase: "mitm attacker", } - initialPacket := testutils.ComposeInitialPacket(destConnID, srcConnID, sess.version, destConnID, []wire.Frame{connCloseFrame}) + initialPacket := testutils.ComposeInitialPacket(destConnID, srcConnID, conn.version, destConnID, []wire.Frame{connCloseFrame}) tracer.EXPECT().ReceivedPacket(gomock.Any(), gomock.Any(), gomock.Any()) - Expect(sess.handlePacketImpl(wrapPacket(initialPacket))).To(BeTrue()) + Expect(conn.handlePacketImpl(wrapPacket(initialPacket))).To(BeTrue()) }) // Illustrates that attacker who injects a Retry packet and changes the connection ID // can cause subsequent real Initial packets to be ignored It("ignores Initial packets which use original source id, after accepting a Retry", func() { sph := mockackhandler.NewMockSentPacketHandler(mockCtrl) - sess.sentPacketHandler = sph + conn.sentPacketHandler = sph sph.EXPECT().ReceivedBytes(gomock.Any()).Times(2) sph.EXPECT().ResetForRetry() newSrcConnID := protocol.ConnectionID{0xde, 0xad, 0xbe, 0xef} @@ -3015,10 +3015,10 @@ var _ = Describe("Client Connection", func() { packer.EXPECT().SetToken([]byte("foobar")) tracer.EXPECT().ReceivedRetry(gomock.Any()) - sess.handlePacketImpl(wrapPacket(testutils.ComposeRetryPacket(newSrcConnID, destConnID, destConnID, []byte("foobar"), sess.version))) - initialPacket := testutils.ComposeInitialPacket(sess.connIDManager.Get(), srcConnID, sess.version, sess.connIDManager.Get(), nil) + conn.handlePacketImpl(wrapPacket(testutils.ComposeRetryPacket(newSrcConnID, destConnID, destConnID, []byte("foobar"), conn.version))) + initialPacket := testutils.ComposeInitialPacket(conn.connIDManager.Get(), srcConnID, conn.version, conn.connIDManager.Get(), nil) tracer.EXPECT().DroppedPacket(gomock.Any(), gomock.Any(), gomock.Any()) - Expect(sess.handlePacketImpl(wrapPacket(initialPacket))).To(BeFalse()) + Expect(conn.handlePacketImpl(wrapPacket(initialPacket))).To(BeFalse()) }) }) }) diff --git a/internal/protocol/params.go b/internal/protocol/params.go index 1955ccdc9f5..5988b93fd16 100644 --- a/internal/protocol/params.go +++ b/internal/protocol/params.go @@ -14,7 +14,7 @@ const InitialPacketSizeIPv6 = 1232 // MaxCongestionWindowPackets is the maximum congestion window in packet. const MaxCongestionWindowPackets = 10000 -// MaxUndecryptablePackets limits the number of undecryptable packets that are queued in the session. +// MaxUndecryptablePackets limits the number of undecryptable packets that are queued in the connection. const MaxUndecryptablePackets = 32 // ConnectionFlowControlMultiplier determines how much larger the connection flow control windows needs to be relative to any stream's flow control window @@ -45,8 +45,8 @@ const DefaultMaxIncomingUniStreams = 100 // MaxServerUnprocessedPackets is the max number of packets stored in the server that are not yet processed. const MaxServerUnprocessedPackets = 1024 -// MaxSessionUnprocessedPackets is the max number of packets stored in each session that are not yet processed. -const MaxSessionUnprocessedPackets = 256 +// MaxConnUnprocessedPackets is the max number of packets stored in each connection that are not yet processed. +const MaxConnUnprocessedPackets = 256 // SkipPacketInitialPeriod is the initial period length used for packet number skipping to prevent an Optimistic ACK attack. // Every time a packet number is skipped, the period is doubled, up to SkipPacketMaxPeriod. @@ -190,6 +190,6 @@ const Max0RTTQueues = 32 // Max0RTTQueueLen is the maximum number of 0-RTT packets that we buffer for each connection. // When a new connection is created, all buffered packets are passed to the connection immediately. -// To avoid blocking, this value has to be smaller than MaxSessionUnprocessedPackets. +// To avoid blocking, this value has to be smaller than MaxConnUnprocessedPackets. // To avoid packets being dropped as undecryptable by the connection, this value has to be smaller than MaxUndecryptablePackets. const Max0RTTQueueLen = 31 diff --git a/internal/protocol/params_test.go b/internal/protocol/params_test.go index b144054a6b4..50a260d2742 100644 --- a/internal/protocol/params_test.go +++ b/internal/protocol/params_test.go @@ -7,7 +7,7 @@ import ( var _ = Describe("Parameters", func() { It("can queue more packets in the session than in the 0-RTT queue", func() { - Expect(MaxSessionUnprocessedPackets).To(BeNumerically(">", Max0RTTQueueLen)) + Expect(MaxConnUnprocessedPackets).To(BeNumerically(">", Max0RTTQueueLen)) Expect(MaxUndecryptablePackets).To(BeNumerically(">", Max0RTTQueueLen)) }) }) diff --git a/mock_conn_runner_test.go b/mock_conn_runner_test.go index 1620b2442c1..607bd027444 100644 --- a/mock_conn_runner_test.go +++ b/mock_conn_runner_test.go @@ -1,5 +1,5 @@ // Code generated by MockGen. DO NOT EDIT. -// Source: session.go +// Source: connection.go // Package quic is a generated GoMock package. package quic diff --git a/mock_stream_getter_test.go b/mock_stream_getter_test.go index 50934898713..d4d08b4a829 100644 --- a/mock_stream_getter_test.go +++ b/mock_stream_getter_test.go @@ -1,5 +1,5 @@ // Code generated by MockGen. DO NOT EDIT. -// Source: session.go +// Source: connection.go // Package quic is a generated GoMock package. package quic diff --git a/mock_stream_manager_test.go b/mock_stream_manager_test.go index 92c31da94a8..9c86e6d1311 100644 --- a/mock_stream_manager_test.go +++ b/mock_stream_manager_test.go @@ -1,5 +1,5 @@ // Code generated by MockGen. DO NOT EDIT. -// Source: session.go +// Source: connection.go // Package quic is a generated GoMock package. package quic diff --git a/mock_unpacker_test.go b/mock_unpacker_test.go index 0703c111f60..22da001b215 100644 --- a/mock_unpacker_test.go +++ b/mock_unpacker_test.go @@ -1,5 +1,5 @@ // Code generated by MockGen. DO NOT EDIT. -// Source: session.go +// Source: connection.go // Package quic is a generated GoMock package. package quic diff --git a/multiplexer.go b/multiplexer.go index 006305af18d..2271b551722 100644 --- a/multiplexer.go +++ b/multiplexer.go @@ -32,7 +32,7 @@ type connManager struct { } // The connMultiplexer listens on multiple net.PacketConns and dispatches -// incoming packets to the session handler. +// incoming packets to the connection handler. type connMultiplexer struct { mutex sync.Mutex diff --git a/packet_handler_map.go b/packet_handler_map.go index 3156016ce8f..23a8585661f 100644 --- a/packet_handler_map.go +++ b/packet_handler_map.go @@ -64,7 +64,7 @@ type packetHandlerMapEntry struct { // The packetHandlerMap stores packetHandlers, identified by connection ID. // It is used: -// * by the server to store sessions +// * by the server to store connections // * when multiplexing outgoing connections to store clients type packetHandlerMap struct { mutex sync.Mutex diff --git a/server.go b/server.go index fa70bf23242..5bf568a61fb 100644 --- a/server.go +++ b/server.go @@ -73,7 +73,7 @@ type baseServer struct { receivedPackets chan *receivedPacket // set as a member, so they can be set in the tests - newSession func( + newConn func( sendConn, connRunner, protocol.ConnectionID, /* original dest connection ID */ @@ -209,7 +209,7 @@ func listen(conn net.PacketConn, tlsConf *tls.Config, config *Config, acceptEarl errorChan: make(chan struct{}), running: make(chan struct{}), receivedPackets: make(chan *receivedPacket, protocol.MaxServerUnprocessedPackets), - newSession: newSession, + newConn: newConnection, logger: utils.DefaultLogger.WithPrefix("server"), acceptEarlyConns: acceptEarly, } @@ -268,9 +268,9 @@ func (s *baseServer) accept(ctx context.Context) (quicConn, error) { select { case <-ctx.Done(): return nil, ctx.Err() - case sess := <-s.connQueue: + case conn := <-s.connQueue: atomic.AddInt32(&s.connQueueLen, -1) - return sess, nil + return conn, nil case <-s.errorChan: return nil, s.serverError } @@ -468,7 +468,7 @@ func (s *baseServer) handleInitialImpl(p *receivedPacket, hdr *wire.Header) erro connID, ) } - conn = s.newSession( + conn = s.newConn( newSendConn(s.conn, p.remoteAddr, p.info), s.connHandler, origDestConnID, @@ -501,19 +501,19 @@ func (s *baseServer) handleInitialImpl(p *receivedPacket, hdr *wire.Header) erro } func (s *baseServer) handleNewConn(conn quicConn) { - sessCtx := conn.Context() + connCtx := conn.Context() if s.acceptEarlyConns { // wait until the early connection is ready (or the handshake fails) select { case <-conn.earlyConnReady(): - case <-sessCtx.Done(): + case <-connCtx.Done(): return } } else { // wait until the handshake is complete (or fails) select { case <-conn.HandshakeComplete().Done(): - case <-sessCtx.Done(): + case <-connCtx.Done(): return } } @@ -522,7 +522,7 @@ func (s *baseServer) handleNewConn(conn quicConn) { select { case s.connQueue <- conn: // blocks until the connection is accepted - case <-sessCtx.Done(): + case <-connCtx.Done(): atomic.AddInt32(&s.connQueueLen, -1) // don't pass connections that were already closed to Accept() } diff --git a/server_test.go b/server_test.go index 3b33109d8d0..b1d4f73c92e 100644 --- a/server_test.go +++ b/server_test.go @@ -324,7 +324,7 @@ var _ = Describe("Server", func() { }) tracer.EXPECT().TracerForConnection(gomock.Any(), protocol.PerspectiveServer, protocol.ConnectionID{0xde, 0xad, 0xc0, 0xde}) conn := NewMockQuicConn(mockCtrl) - serv.newSession = func( + serv.newConn = func( _ sendConn, _ connRunner, origDestConnID protocol.ConnectionID, @@ -603,7 +603,7 @@ var _ = Describe("Server", func() { tracer.EXPECT().TracerForConnection(gomock.Any(), protocol.PerspectiveServer, protocol.ConnectionID{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}) conn := NewMockQuicConn(mockCtrl) - serv.newSession = func( + serv.newConn = func( _ sendConn, _ connRunner, origDestConnID protocol.ConnectionID, @@ -663,7 +663,7 @@ var _ = Describe("Server", func() { serv.config.AcceptToken = func(net.Addr, *Token) bool { return true } acceptConn := make(chan struct{}) var counter uint32 // to be used as an atomic, so we query it in Eventually - serv.newSession = func( + serv.newConn = func( _ sendConn, runner connRunner, _ protocol.ConnectionID, @@ -717,7 +717,7 @@ var _ = Describe("Server", func() { serv.config.AcceptToken = func(_ net.Addr, _ *Token) bool { return true } var createdConn bool conn := NewMockQuicConn(mockCtrl) - serv.newSession = func( + serv.newConn = func( _ sendConn, runner connRunner, _ protocol.ConnectionID, @@ -748,7 +748,7 @@ var _ = Describe("Server", func() { It("rejects new connection attempts if the accept queue is full", func() { serv.config.AcceptToken = func(_ net.Addr, _ *Token) bool { return true } - serv.newSession = func( + serv.newConn = func( _ sendConn, runner connRunner, _ protocol.ConnectionID, @@ -820,7 +820,7 @@ var _ = Describe("Server", func() { ctx, cancel := context.WithCancel(context.Background()) connCreated := make(chan struct{}) conn := NewMockQuicConn(mockCtrl) - serv.newSession = func( + serv.newConn = func( _ sendConn, runner connRunner, _ protocol.ConnectionID, @@ -932,7 +932,7 @@ var _ = Describe("Server", func() { ctx, cancel := context.WithCancel(context.Background()) // handshake context serv.config.AcceptToken = func(_ net.Addr, _ *Token) bool { return true } - serv.newSession = func( + serv.newConn = func( _ sendConn, runner connRunner, _ protocol.ConnectionID, @@ -1006,7 +1006,7 @@ var _ = Describe("Server", func() { ready := make(chan struct{}) serv.config.AcceptToken = func(_ net.Addr, _ *Token) bool { return true } - serv.newSession = func( + serv.newConn = func( _ sendConn, runner connRunner, _ protocol.ConnectionID, @@ -1049,7 +1049,7 @@ var _ = Describe("Server", func() { serv.config.AcceptToken = func(_ net.Addr, _ *Token) bool { return true } senderAddr := &net.UDPAddr{IP: net.IPv4(1, 2, 3, 4), Port: 42} - serv.newSession = func( + serv.newConn = func( _ sendConn, runner connRunner, _ protocol.ConnectionID, @@ -1113,7 +1113,7 @@ var _ = Describe("Server", func() { ctx, cancel := context.WithCancel(context.Background()) connCreated := make(chan struct{}) conn := NewMockQuicConn(mockCtrl) - serv.newSession = func( + serv.newConn = func( _ sendConn, runner connRunner, _ protocol.ConnectionID,