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

create a logger interface and use it everywhere

Browse Source
This commit is contained in:
Marten Seemann
2018-03-28 07:30:36 +07:00
parent 1e9b3f0bb2
commit 948eef3e42
52 changed files with 411 additions and 281 deletions
Download Patch File Download Diff File Expand all files Collapse all files

53
session.go
View File

@@ -136,6 +136,8 @@ type session struct {
// keepAlivePingSent stores whether a Ping frame was sent to the peer or not
// it is reset as soon as we receive a packet from the peer
keepAlivePingSent bool
logger utils.Logger
}
var _ Session = &session{}
@@ -149,6 +151,7 @@ func newSession(
scfg *handshake.ServerConfig,
tlsConf *tls.Config,
config *Config,
logger utils.Logger,
) (packetHandler, error) {
paramsChan := make(chan handshake.TransportParameters)
handshakeEvent := make(chan struct{}, 1)
@@ -160,6 +163,7 @@ func newSession(
config: config,
handshakeEvent: handshakeEvent,
paramsChan: paramsChan,
logger: logger,
}
s.preSetup()
transportParams := &handshake.TransportParameters{
@@ -184,6 +188,7 @@ func newSession(
s.config.AcceptCookie,
paramsChan,
handshakeEvent,
s.logger,
)
if err != nil {
return nil, err
@@ -215,6 +220,7 @@ var newClientSession = func(
config *Config,
initialVersion protocol.VersionNumber,
negotiatedVersions []protocol.VersionNumber, // needed for validation of the GQUIC version negotiation
logger utils.Logger,
) (packetHandler, error) {
paramsChan := make(chan handshake.TransportParameters)
handshakeEvent := make(chan struct{}, 1)
@@ -226,6 +232,7 @@ var newClientSession = func(
config: config,
handshakeEvent: handshakeEvent,
paramsChan: paramsChan,
logger: logger,
}
s.preSetup()
transportParams := &handshake.TransportParameters{
@@ -246,6 +253,7 @@ var newClientSession = func(
handshakeEvent,
initialVersion,
negotiatedVersions,
s.logger,
)
if err != nil {
return nil, err
@@ -278,6 +286,7 @@ func newTLSServerSession(
nullAEAD crypto.AEAD,
peerParams *handshake.TransportParameters,
v protocol.VersionNumber,
logger utils.Logger,
) (packetHandler, error) {
handshakeEvent := make(chan struct{}, 1)
s := &session{
@@ -287,6 +296,7 @@ func newTLSServerSession(
perspective: protocol.PerspectiveServer,
version: v,
handshakeEvent: handshakeEvent,
logger: logger,
}
s.preSetup()
cs := handshake.NewCryptoSetupTLSServer(
@@ -328,6 +338,7 @@ var newTLSClientSession = func(
tls handshake.MintTLS,
paramsChan <-chan handshake.TransportParameters,
initialPacketNumber protocol.PacketNumber,
logger utils.Logger,
) (packetHandler, error) {
handshakeEvent := make(chan struct{}, 1)
s := &session{
@@ -338,6 +349,7 @@ var newTLSClientSession = func(
version: v,
handshakeEvent: handshakeEvent,
paramsChan: paramsChan,
logger: logger,
}
s.preSetup()
tls.SetCryptoStream(s.cryptoStream)
@@ -371,11 +383,12 @@ var newTLSClientSession = func(
func (s *session) preSetup() {
s.rttStats = &congestion.RTTStats{}
s.sentPacketHandler = ackhandler.NewSentPacketHandler(s.rttStats)
s.sentPacketHandler = ackhandler.NewSentPacketHandler(s.rttStats, s.logger)
s.connFlowController = flowcontrol.NewConnectionFlowController(
protocol.ReceiveConnectionFlowControlWindow,
protocol.ByteCount(s.config.MaxReceiveConnectionFlowControlWindow),
s.rttStats,
s.logger,
)
s.cryptoStream = s.newCryptoStream()
}
@@ -575,13 +588,13 @@ func (s *session) handlePacketImpl(p *receivedPacket) error {
)
packet, err := s.unpacker.Unpack(hdr.Raw, hdr, data)
if utils.Debug() {
if s.logger.Debug() {
if err != nil {
utils.Debugf("<- Reading packet 0x%x (%d bytes) for connection %x", hdr.PacketNumber, len(data)+len(hdr.Raw), hdr.ConnectionID)
s.logger.Debugf("<- Reading packet 0x%x (%d bytes) for connection %x", hdr.PacketNumber, len(data)+len(hdr.Raw), hdr.ConnectionID)
} else {
utils.Debugf("<- Reading packet 0x%x (%d bytes) for connection %x, %s", hdr.PacketNumber, len(data)+len(hdr.Raw), hdr.ConnectionID, packet.encryptionLevel)
s.logger.Debugf("<- Reading packet 0x%x (%d bytes) for connection %x, %s", hdr.PacketNumber, len(data)+len(hdr.Raw), hdr.ConnectionID, packet.encryptionLevel)
}
hdr.Log()
hdr.Log(s.logger)
}
// if the decryption failed, this might be a packet sent by an attacker
if err != nil {
@@ -616,7 +629,7 @@ func (s *session) handlePacketImpl(p *receivedPacket) error {
func (s *session) handleFrames(fs []wire.Frame, encLevel protocol.EncryptionLevel) error {
for _, ff := range fs {
var err error
wire.LogFrame(ff, false)
wire.LogFrame(s.logger, ff, false)
switch frame := ff.(type) {
case *wire.StreamFrame:
err = s.handleStreamFrame(frame, encLevel)
@@ -779,9 +792,9 @@ func (s *session) handleCloseError(closeErr closeError) error {
}
// Don't log 'normal' reasons
if quicErr.ErrorCode == qerr.PeerGoingAway || quicErr.ErrorCode == qerr.NetworkIdleTimeout {
utils.Infof("Closing connection %x", s.connectionID)
s.logger.Infof("Closing connection %x", s.connectionID)
} else {
utils.Errorf("Closing session with error: %s", closeErr.err.Error())
s.logger.Errorf("Closing session with error: %s", closeErr.err.Error())
}
s.cryptoStream.closeForShutdown(quicErr)
@@ -907,16 +920,16 @@ func (s *session) maybeSendRetransmission() (bool, error) {
// An Initial might have been retransmitted multiple times before we receive a response.
// As soon as we receive one response, we don't need to send any more Initials.
if s.receivedFirstPacket && retransmitPacket.PacketType == protocol.PacketTypeInitial {
utils.Debugf("Skipping retransmission of packet %d. Already received a response to an Initial.", retransmitPacket.PacketNumber)
s.logger.Debugf("Skipping retransmission of packet %d. Already received a response to an Initial.", retransmitPacket.PacketNumber)
continue
}
break
}
if retransmitPacket.EncryptionLevel != protocol.EncryptionForwardSecure {
utils.Debugf("\tDequeueing handshake retransmission for packet 0x%x", retransmitPacket.PacketNumber)
s.logger.Debugf("\tDequeueing handshake retransmission for packet 0x%x", retransmitPacket.PacketNumber)
} else {
utils.Debugf("\tDequeueing retransmission for packet 0x%x", retransmitPacket.PacketNumber)
s.logger.Debugf("\tDequeueing retransmission for packet 0x%x", retransmitPacket.PacketNumber)
}
if s.version.UsesStopWaitingFrames() {
@@ -987,14 +1000,14 @@ func (s *session) sendConnectionClose(quicErr *qerr.QuicError) error {
}
func (s *session) logPacket(packet *packedPacket) {
if !utils.Debug() {
if !s.logger.Debug() {
// We don't need to allocate the slices for calling the format functions
return
}
utils.Debugf("-> Sending packet 0x%x (%d bytes) for connection %x, %s", packet.header.PacketNumber, len(packet.raw), s.connectionID, packet.encryptionLevel)
packet.header.Log()
s.logger.Debugf("-> Sending packet 0x%x (%d bytes) for connection %x, %s", packet.header.PacketNumber, len(packet.raw), s.connectionID, packet.encryptionLevel)
packet.header.Log(s.logger)
for _, frame := range packet.frames {
wire.LogFrame(frame, true)
wire.LogFrame(s.logger, frame, true)
}
}
@@ -1057,6 +1070,7 @@ func (s *session) newFlowController(id protocol.StreamID) flowcontrol.StreamFlow
protocol.ByteCount(s.config.MaxReceiveStreamFlowControlWindow),
initialSendWindow,
s.rttStats,
s.logger,
)
}
@@ -1070,12 +1084,13 @@ func (s *session) newCryptoStream() cryptoStreamI {
protocol.ByteCount(s.config.MaxReceiveStreamFlowControlWindow),
0,
s.rttStats,
s.logger,
)
return newCryptoStream(s, flowController, s.version)
}
func (s *session) sendPublicReset(rejectedPacketNumber protocol.PacketNumber) error {
utils.Infof("Sending public reset for connection %x, packet number %d", s.connectionID, rejectedPacketNumber)
s.logger.Infof("Sending public reset for connection %x, packet number %d", s.connectionID, rejectedPacketNumber)
return s.conn.Write(wire.WritePublicReset(s.connectionID, rejectedPacketNumber, 0))
}
@@ -1089,7 +1104,7 @@ func (s *session) scheduleSending() {
func (s *session) tryQueueingUndecryptablePacket(p *receivedPacket) {
if s.handshakeComplete {
utils.Debugf("Received undecryptable packet from %s after the handshake: %#v, %d bytes data", p.remoteAddr.String(), p.header, len(p.data))
s.logger.Debugf("Received undecryptable packet from %s after the handshake: %#v, %d bytes data", p.remoteAddr.String(), p.header, len(p.data))
return
}
if len(s.undecryptablePackets)+1 > protocol.MaxUndecryptablePackets {
@@ -1098,10 +1113,10 @@ func (s *session) tryQueueingUndecryptablePacket(p *receivedPacket) {
s.receivedTooManyUndecrytablePacketsTime = time.Now()
s.maybeResetTimer()
}
utils.Infof("Dropping undecrytable packet 0x%x (undecryptable packet queue full)", p.header.PacketNumber)
s.logger.Infof("Dropping undecrytable packet 0x%x (undecryptable packet queue full)", p.header.PacketNumber)
return
}
utils.Infof("Queueing packet 0x%x for later decryption", p.header.PacketNumber)
s.logger.Infof("Queueing packet 0x%x for later decryption", p.header.PacketNumber)
s.undecryptablePackets = append(s.undecryptablePackets, p)
}