diff --git a/conn_id_generator.go b/conn_id_generator.go index 33f977b8d..245716501 100644 --- a/conn_id_generator.go +++ b/conn_id_generator.go @@ -69,7 +69,7 @@ func (m *connIDGenerator) SetMaxActiveConnIDs(limit uint64) error { func (m *connIDGenerator) Retire(seq uint64) error { if seq > m.highestSeq { - return qerr.Error(qerr.ProtocolViolation, fmt.Sprintf("tried to retire connection ID %d. Highest issued: %d", seq, m.highestSeq)) + return qerr.NewError(qerr.ProtocolViolation, fmt.Sprintf("tried to retire connection ID %d. Highest issued: %d", seq, m.highestSeq)) } connID, ok := m.activeSrcConnIDs[seq] // We might already have deleted this connection ID, if this is a duplicate frame. diff --git a/crypto_stream.go b/crypto_stream.go index 683ab0b1b..cb5361088 100644 --- a/crypto_stream.go +++ b/crypto_stream.go @@ -40,12 +40,12 @@ func newCryptoStream() cryptoStream { func (s *cryptoStreamImpl) HandleCryptoFrame(f *wire.CryptoFrame) error { highestOffset := f.Offset + protocol.ByteCount(len(f.Data)) if maxOffset := highestOffset; maxOffset > protocol.MaxCryptoStreamOffset { - return qerr.Error(qerr.CryptoBufferExceeded, fmt.Sprintf("received invalid offset %d on crypto stream, maximum allowed %d", maxOffset, protocol.MaxCryptoStreamOffset)) + return qerr.NewError(qerr.CryptoBufferExceeded, fmt.Sprintf("received invalid offset %d on crypto stream, maximum allowed %d", maxOffset, protocol.MaxCryptoStreamOffset)) } if s.finished { if highestOffset > s.highestOffset { // reject crypto data received after this stream was already finished - return qerr.Error(qerr.ProtocolViolation, "received crypto data after change of encryption level") + return qerr.NewError(qerr.ProtocolViolation, "received crypto data after change of encryption level") } // ignore data with a smaller offset than the highest received // could e.g. be a retransmission diff --git a/internal/ackhandler/sent_packet_handler.go b/internal/ackhandler/sent_packet_handler.go index 6a7ba505d..9ef5c9e4c 100644 --- a/internal/ackhandler/sent_packet_handler.go +++ b/internal/ackhandler/sent_packet_handler.go @@ -229,13 +229,13 @@ func (h *sentPacketHandler) ReceivedAck(ack *wire.AckFrame, encLevel protocol.En largestAcked := ack.LargestAcked() if largestAcked > pnSpace.largestSent { - return qerr.Error(qerr.ProtocolViolation, "Received ACK for an unsent packet") + return qerr.NewError(qerr.ProtocolViolation, "Received ACK for an unsent packet") } pnSpace.largestAcked = utils.MaxPacketNumber(pnSpace.largestAcked, largestAcked) if !pnSpace.pns.Validate(ack) { - return qerr.Error(qerr.ProtocolViolation, "Received an ACK for a skipped packet number") + return qerr.NewError(qerr.ProtocolViolation, "Received an ACK for a skipped packet number") } // Servers complete address validation when a protected packet is received. diff --git a/internal/flowcontrol/connection_flow_controller.go b/internal/flowcontrol/connection_flow_controller.go index 1393335b0..8b9d51ecb 100644 --- a/internal/flowcontrol/connection_flow_controller.go +++ b/internal/flowcontrol/connection_flow_controller.go @@ -49,7 +49,7 @@ func (c *connectionFlowController) IncrementHighestReceived(increment protocol.B c.highestReceived += increment if c.checkFlowControlViolation() { - return qerr.Error(qerr.FlowControlError, fmt.Sprintf("Received %d bytes for the connection, allowed %d bytes", c.highestReceived, c.receiveWindow)) + return qerr.NewError(qerr.FlowControlError, fmt.Sprintf("Received %d bytes for the connection, allowed %d bytes", c.highestReceived, c.receiveWindow)) } return nil } diff --git a/internal/flowcontrol/stream_flow_controller.go b/internal/flowcontrol/stream_flow_controller.go index bb22337df..5a11929f4 100644 --- a/internal/flowcontrol/stream_flow_controller.go +++ b/internal/flowcontrol/stream_flow_controller.go @@ -58,11 +58,11 @@ func (c *streamFlowController) UpdateHighestReceived(offset protocol.ByteCount, if c.receivedFinalOffset { // If we receive another final offset, check that it's the same. if final && offset != c.highestReceived { - return qerr.Error(qerr.FinalSizeError, fmt.Sprintf("Received inconsistent final offset for stream %d (old: %#x, new: %#x bytes)", c.streamID, c.highestReceived, offset)) + return qerr.NewError(qerr.FinalSizeError, fmt.Sprintf("Received inconsistent final offset for stream %d (old: %#x, new: %#x bytes)", c.streamID, c.highestReceived, offset)) } // Check that the offset is below the final offset. if offset > c.highestReceived { - return qerr.Error(qerr.FinalSizeError, fmt.Sprintf("Received offset %#x for stream %d. Final offset was already received at %#x", offset, c.streamID, c.highestReceived)) + return qerr.NewError(qerr.FinalSizeError, fmt.Sprintf("Received offset %#x for stream %d. Final offset was already received at %#x", offset, c.streamID, c.highestReceived)) } } @@ -76,7 +76,7 @@ func (c *streamFlowController) UpdateHighestReceived(offset protocol.ByteCount, // This can happen due to reordering. if offset <= c.highestReceived { if final { - return qerr.Error(qerr.FinalSizeError, fmt.Sprintf("Received final offset %#x for stream %d, but already received offset %#x before", offset, c.streamID, c.highestReceived)) + return qerr.NewError(qerr.FinalSizeError, fmt.Sprintf("Received final offset %#x for stream %d, but already received offset %#x before", offset, c.streamID, c.highestReceived)) } return nil } @@ -84,7 +84,7 @@ func (c *streamFlowController) UpdateHighestReceived(offset protocol.ByteCount, increment := offset - c.highestReceived c.highestReceived = offset if c.checkFlowControlViolation() { - return qerr.Error(qerr.FlowControlError, fmt.Sprintf("Received %#x bytes on stream %d, allowed %#x bytes", offset, c.streamID, c.receiveWindow)) + return qerr.NewError(qerr.FlowControlError, fmt.Sprintf("Received %#x bytes on stream %d, allowed %#x bytes", offset, c.streamID, c.receiveWindow)) } return c.connection.IncrementHighestReceived(increment) } diff --git a/internal/handshake/crypto_setup.go b/internal/handshake/crypto_setup.go index 4bd70e857..0ae4f238a 100644 --- a/internal/handshake/crypto_setup.go +++ b/internal/handshake/crypto_setup.go @@ -281,7 +281,7 @@ func (h *cryptoSetup) RunHandshake() { } func (h *cryptoSetup) onError(alert uint8, message string) { - h.runner.OnError(qerr.CryptoError(alert, message)) + h.runner.OnError(qerr.NewCryptoError(alert, message)) } // Close closes the crypto setup. @@ -451,7 +451,7 @@ func (h *cryptoSetup) handleMessageForClient(msgType messageType) bool { func (h *cryptoSetup) handleTransportParameters(data []byte) { var tp wire.TransportParameters if err := tp.Unmarshal(data, h.perspective.Opposite()); err != nil { - h.runner.OnError(qerr.Error(qerr.TransportParameterError, err.Error())) + h.runner.OnError(qerr.NewError(qerr.TransportParameterError, err.Error())) } h.peerParams = &tp h.runner.OnReceivedParams(h.peerParams) diff --git a/internal/handshake/updatable_aead.go b/internal/handshake/updatable_aead.go index 96a9f27ea..2c4a33036 100644 --- a/internal/handshake/updatable_aead.go +++ b/internal/handshake/updatable_aead.go @@ -160,7 +160,7 @@ func (a *updatableAEAD) Open(dst, src []byte, rcvTime time.Time, pn protocol.Pac // This can only occur when the first packet received has key phase 1. // This is an error, since the key phase starts at 0, // and peers are only allowed to update keys after the handshake is confirmed. - return nil, qerr.Error(qerr.ProtocolViolation, "wrong initial keyphase") + return nil, qerr.NewError(qerr.ProtocolViolation, "wrong initial keyphase") } if a.prevRcvAEAD == nil { return nil, ErrKeysDropped @@ -179,7 +179,7 @@ func (a *updatableAEAD) Open(dst, src []byte, rcvTime time.Time, pn protocol.Pac } // Opening succeeded. Check if the peer was allowed to update. if a.firstSentWithCurrentKey == protocol.InvalidPacketNumber { - return nil, qerr.Error(qerr.ProtocolViolation, "keys updated too quickly") + return nil, qerr.NewError(qerr.ProtocolViolation, "keys updated too quickly") } a.rollKeys(rcvTime) a.logger.Debugf("Peer updated keys to %s", a.keyPhase) diff --git a/internal/qerr/error_codes.go b/internal/qerr/error_codes.go index 1ce8b3afc..7fee9c486 100644 --- a/internal/qerr/error_codes.go +++ b/internal/qerr/error_codes.go @@ -23,6 +23,7 @@ const ( ConnectionIDLimitError ErrorCode = 0x9 ProtocolViolation ErrorCode = 0xa InvalidToken ErrorCode = 0xb + ApplicationError ErrorCode = 0xc CryptoBufferExceeded ErrorCode = 0xd ) @@ -72,6 +73,8 @@ func (e ErrorCode) String() string { return "PROTOCOL_VIOLATION" case InvalidToken: return "INVALID_TOKEN" + case ApplicationError: + return "APPLICATION_ERROR" case CryptoBufferExceeded: return "CRYPTO_BUFFER_EXCEEDED" default: diff --git a/internal/qerr/quic_error.go b/internal/qerr/quic_error.go index 139cf6d9b..18a26fdbc 100644 --- a/internal/qerr/quic_error.go +++ b/internal/qerr/quic_error.go @@ -16,20 +16,16 @@ type QuicError struct { var _ net.Error = &QuicError{} -// UserCanceledError is used if the application closes the connection -// before the handshake completes. -var UserCanceledError = &QuicError{ErrorCode: 0x15a} - -// Error creates a new QuicError instance -func Error(errorCode ErrorCode, errorMessage string) *QuicError { +// NewError creates a new QuicError instance +func NewError(errorCode ErrorCode, errorMessage string) *QuicError { return &QuicError{ ErrorCode: errorCode, ErrorMessage: errorMessage, } } -// ErrorWithFrameType creates a new QuicError instance for a specific frame type -func ErrorWithFrameType(errorCode ErrorCode, frameType uint64, errorMessage string) *QuicError { +// NewErrorWithFrameType creates a new QuicError instance for a specific frame type +func NewErrorWithFrameType(errorCode ErrorCode, frameType uint64, errorMessage string) *QuicError { return &QuicError{ ErrorCode: errorCode, FrameType: frameType, @@ -37,24 +33,24 @@ func ErrorWithFrameType(errorCode ErrorCode, frameType uint64, errorMessage stri } } -// TimeoutError creates a new QuicError instance for a timeout error -func TimeoutError(errorMessage string) *QuicError { +// NewTimeoutError creates a new QuicError instance for a timeout error +func NewTimeoutError(errorMessage string) *QuicError { return &QuicError{ ErrorMessage: errorMessage, isTimeout: true, } } -// CryptoError create a new QuicError instance for a crypto error -func CryptoError(tlsAlert uint8, errorMessage string) *QuicError { +// NewCryptoError create a new QuicError instance for a crypto error +func NewCryptoError(tlsAlert uint8, errorMessage string) *QuicError { return &QuicError{ ErrorCode: 0x100 + ErrorCode(tlsAlert), ErrorMessage: errorMessage, } } -// ApplicationError creates a new QuicError instance for an application error -func ApplicationError(errorCode ErrorCode, errorMessage string) *QuicError { +// NewApplicationError creates a new QuicError instance for an application error +func NewApplicationError(errorCode ErrorCode, errorMessage string) *QuicError { return &QuicError{ ErrorCode: errorCode, ErrorMessage: errorMessage, @@ -110,7 +106,7 @@ func ToQuicError(err error) *QuicError { case *QuicError: return e case ErrorCode: - return Error(e, "") + return NewError(e, "") } - return Error(InternalError, err.Error()) + return NewError(InternalError, err.Error()) } diff --git a/internal/qerr/quic_error_test.go b/internal/qerr/quic_error_test.go index 162ff2adc..4f5d6408d 100644 --- a/internal/qerr/quic_error_test.go +++ b/internal/qerr/quic_error_test.go @@ -9,47 +9,47 @@ import ( var _ = Describe("QUIC Transport Errors", func() { It("has a string representation", func() { - err := Error(FlowControlError, "foobar") + err := NewError(FlowControlError, "foobar") Expect(err.Timeout()).To(BeFalse()) Expect(err.IsApplicationError()).To(BeFalse()) Expect(err.Error()).To(Equal("FLOW_CONTROL_ERROR: foobar")) }) It("has a string representation for empty error phrases", func() { - err := Error(FlowControlError, "") + err := NewError(FlowControlError, "") Expect(err.Error()).To(Equal("FLOW_CONTROL_ERROR")) }) It("includes the frame type, for errors without a message", func() { - err := ErrorWithFrameType(FlowControlError, 0x1337, "") + err := NewErrorWithFrameType(FlowControlError, 0x1337, "") Expect(err.Error()).To(Equal("FLOW_CONTROL_ERROR (frame type: 0x1337)")) }) It("includes the frame type, for errors with a message", func() { - err := ErrorWithFrameType(FlowControlError, 0x1337, "foobar") + err := NewErrorWithFrameType(FlowControlError, 0x1337, "foobar") Expect(err.Error()).To(Equal("FLOW_CONTROL_ERROR (frame type: 0x1337): foobar")) }) It("has a string representation for timeout errors", func() { - err := TimeoutError("foobar") + err := NewTimeoutError("foobar") Expect(err.Timeout()).To(BeTrue()) Expect(err.Error()).To(Equal("NO_ERROR: foobar")) }) Context("crypto errors", func() { It("has a string representation for errors with a message", func() { - err := CryptoError(42, "foobar") + err := NewCryptoError(42, "foobar") Expect(err.Error()).To(Equal("CRYPTO_ERROR: foobar")) }) It("has a string representation for errors without a message", func() { - err := CryptoError(42, "") + err := NewCryptoError(42, "") Expect(err.Error()).To(Equal("CRYPTO_ERROR: tls: bad certificate")) }) It("says if an error is a crypto error", func() { - Expect(Error(FlowControlError, "").IsCryptoError()).To(BeFalse()) - err := CryptoError(42, "") + Expect(NewError(FlowControlError, "").IsCryptoError()).To(BeFalse()) + err := NewCryptoError(42, "") Expect(err.IsCryptoError()).To(BeTrue()) Expect(err.IsApplicationError()).To(BeFalse()) @@ -58,13 +58,13 @@ var _ = Describe("QUIC Transport Errors", func() { Context("application errors", func() { It("has a string representation for errors with a message", func() { - err := ApplicationError(0x42, "foobar") + err := NewApplicationError(0x42, "foobar") Expect(err.IsApplicationError()).To(BeTrue()) Expect(err.Error()).To(Equal("Application error 0x42: foobar")) }) It("has a string representation for errors without a message", func() { - err := ApplicationError(0x42, "") + err := NewApplicationError(0x42, "") Expect(err.Error()).To(Equal("Application error 0x42")) }) }) @@ -83,17 +83,17 @@ var _ = Describe("QUIC Transport Errors", func() { Context("ToQuicError", func() { It("leaves QuicError unchanged", func() { - err := Error(TransportParameterError, "foo") + err := NewError(TransportParameterError, "foo") Expect(ToQuicError(err)).To(Equal(err)) }) It("wraps ErrorCode properly", func() { var err error = FinalSizeError - Expect(ToQuicError(err)).To(Equal(Error(FinalSizeError, ""))) + Expect(ToQuicError(err)).To(Equal(NewError(FinalSizeError, ""))) }) It("changes default errors to InternalError", func() { - Expect(ToQuicError(io.EOF)).To(Equal(Error(InternalError, "EOF"))) + Expect(ToQuicError(io.EOF)).To(Equal(NewError(InternalError, "EOF"))) }) }) }) diff --git a/internal/wire/frame_parser.go b/internal/wire/frame_parser.go index 47196f52a..9659883dd 100644 --- a/internal/wire/frame_parser.go +++ b/internal/wire/frame_parser.go @@ -33,7 +33,7 @@ func (p *frameParser) ParseNext(r *bytes.Reader, encLevel protocol.EncryptionLev f, err := p.parseFrame(r, typeByte, encLevel) if err != nil { - return nil, qerr.ErrorWithFrameType(qerr.FrameEncodingError, uint64(typeByte), err.Error()) + return nil, qerr.NewErrorWithFrameType(qerr.FrameEncodingError, uint64(typeByte), err.Error()) } return f, nil } diff --git a/internal/wire/stream_frame.go b/internal/wire/stream_frame.go index 47fb2a1e6..defb63375 100644 --- a/internal/wire/stream_frame.go +++ b/internal/wire/stream_frame.go @@ -79,7 +79,7 @@ func parseStreamFrame(r *bytes.Reader, _ protocol.VersionNumber) (*StreamFrame, } } if frame.Offset+frame.DataLen() > protocol.MaxByteCount { - return nil, qerr.Error(qerr.FrameEncodingError, "stream data overflows maximum offset") + return nil, qerr.NewError(qerr.FrameEncodingError, "stream data overflows maximum offset") } return frame, nil } diff --git a/internal/wire/transport_parameters.go b/internal/wire/transport_parameters.go index df5c02fee..782890c21 100644 --- a/internal/wire/transport_parameters.go +++ b/internal/wire/transport_parameters.go @@ -81,7 +81,7 @@ type TransportParameters struct { // Unmarshal the transport parameters func (p *TransportParameters) Unmarshal(data []byte, sentBy protocol.Perspective) error { if err := p.unmarshal(data, sentBy); err != nil { - return qerr.Error(qerr.TransportParameterError, err.Error()) + return qerr.NewError(qerr.TransportParameterError, err.Error()) } return nil } diff --git a/packet_packer.go b/packet_packer.go index 9877f0569..1ac9dd5dd 100644 --- a/packet_packer.go +++ b/packet_packer.go @@ -216,7 +216,7 @@ func (p *packetPacker) PackConnectionClose(quicErr *qerr.QuicError) (*coalescedP if encLevel == protocol.EncryptionInitial || encLevel == protocol.EncryptionHandshake { // don't send application errors in Initial or Handshake packets if quicErr.IsApplicationError() { - quicErrToSend = qerr.UserCanceledError + quicErrToSend = qerr.NewError(qerr.ApplicationError, "") reasonPhrase = "" } } diff --git a/packet_packer_test.go b/packet_packer_test.go index 4639d5e7b..16cd0754d 100644 --- a/packet_packer_test.go +++ b/packet_packer_test.go @@ -283,7 +283,7 @@ var _ = Describe("Packet packer", func() { sealingManager.EXPECT().GetInitialSealer().Return(nil, handshake.ErrKeysDropped) sealingManager.EXPECT().GetHandshakeSealer().Return(getSealer(), nil) sealingManager.EXPECT().Get1RTTSealer().Return(nil, handshake.ErrKeysNotYetAvailable) - quicErr := qerr.CryptoError(0x42, "crypto error") + quicErr := qerr.NewCryptoError(0x42, "crypto error") quicErr.FrameType = 0x1234 p, err := packer.PackConnectionClose(quicErr) Expect(err).ToNot(HaveOccurred()) @@ -305,7 +305,7 @@ var _ = Describe("Packet packer", func() { sealingManager.EXPECT().GetHandshakeSealer().Return(nil, handshake.ErrKeysDropped) sealingManager.EXPECT().Get1RTTSealer().Return(getSealer(), nil) // expect no framer.PopStreamFrames - p, err := packer.PackConnectionClose(qerr.Error(qerr.CryptoBufferExceeded, "test error")) + p, err := packer.PackConnectionClose(qerr.NewError(qerr.CryptoBufferExceeded, "test error")) Expect(err).ToNot(HaveOccurred()) Expect(p.packets).To(HaveLen(1)) Expect(p.packets[0].header.IsLongHeader).To(BeFalse()) @@ -327,7 +327,7 @@ var _ = Describe("Packet packer", func() { sealingManager.EXPECT().GetInitialSealer().Return(getSealer(), nil) sealingManager.EXPECT().GetHandshakeSealer().Return(getSealer(), nil) sealingManager.EXPECT().Get1RTTSealer().Return(getSealer(), nil) - p, err := packer.PackConnectionClose(qerr.ApplicationError(0x1337, "test error")) + p, err := packer.PackConnectionClose(qerr.NewApplicationError(0x1337, "test error")) Expect(err).ToNot(HaveOccurred()) Expect(p.packets).To(HaveLen(3)) Expect(p.packets[0].header.Type).To(Equal(protocol.PacketTypeInitial)) @@ -336,7 +336,7 @@ var _ = Describe("Packet packer", func() { Expect(p.packets[0].frames[0].Frame).To(BeAssignableToTypeOf(&wire.ConnectionCloseFrame{})) ccf := p.packets[0].frames[0].Frame.(*wire.ConnectionCloseFrame) Expect(ccf.IsApplicationError).To(BeFalse()) - Expect(ccf.ErrorCode).To(Equal(qerr.UserCanceledError.ErrorCode)) + Expect(ccf.ErrorCode).To(Equal(qerr.ApplicationError)) Expect(ccf.ReasonPhrase).To(BeEmpty()) Expect(p.packets[1].header.Type).To(Equal(protocol.PacketTypeHandshake)) Expect(p.packets[1].header.PacketNumber).To(Equal(protocol.PacketNumber(2))) @@ -344,7 +344,7 @@ var _ = Describe("Packet packer", func() { Expect(p.packets[1].frames[0].Frame).To(BeAssignableToTypeOf(&wire.ConnectionCloseFrame{})) ccf = p.packets[1].frames[0].Frame.(*wire.ConnectionCloseFrame) Expect(ccf.IsApplicationError).To(BeFalse()) - Expect(ccf.ErrorCode).To(Equal(qerr.UserCanceledError.ErrorCode)) + Expect(ccf.ErrorCode).To(Equal(qerr.ApplicationError)) Expect(ccf.ReasonPhrase).To(BeEmpty()) Expect(p.packets[2].header.IsLongHeader).To(BeFalse()) Expect(p.packets[2].header.PacketNumber).To(Equal(protocol.PacketNumber(3))) @@ -366,7 +366,7 @@ var _ = Describe("Packet packer", func() { sealingManager.EXPECT().GetHandshakeSealer().Return(getSealer(), nil) sealingManager.EXPECT().Get0RTTSealer().Return(nil, handshake.ErrKeysDropped) sealingManager.EXPECT().Get1RTTSealer().Return(getSealer(), nil) - p, err := packer.PackConnectionClose(qerr.ApplicationError(0x1337, "test error")) + p, err := packer.PackConnectionClose(qerr.NewApplicationError(0x1337, "test error")) Expect(err).ToNot(HaveOccurred()) Expect(p.packets).To(HaveLen(2)) Expect(p.buffer.Len()).To(BeNumerically("<", protocol.MinInitialPacketSize)) @@ -376,7 +376,7 @@ var _ = Describe("Packet packer", func() { Expect(p.packets[0].frames[0].Frame).To(BeAssignableToTypeOf(&wire.ConnectionCloseFrame{})) ccf := p.packets[0].frames[0].Frame.(*wire.ConnectionCloseFrame) Expect(ccf.IsApplicationError).To(BeFalse()) - Expect(ccf.ErrorCode).To(Equal(qerr.UserCanceledError.ErrorCode)) + Expect(ccf.ErrorCode).To(Equal(qerr.ApplicationError)) Expect(ccf.ReasonPhrase).To(BeEmpty()) Expect(p.packets[1].header.IsLongHeader).To(BeFalse()) Expect(p.packets[1].header.PacketNumber).To(Equal(protocol.PacketNumber(2))) @@ -398,7 +398,7 @@ var _ = Describe("Packet packer", func() { sealingManager.EXPECT().GetHandshakeSealer().Return(nil, handshake.ErrKeysNotYetAvailable) sealingManager.EXPECT().Get0RTTSealer().Return(getSealer(), nil) sealingManager.EXPECT().Get1RTTSealer().Return(nil, handshake.ErrKeysNotYetAvailable) - p, err := packer.PackConnectionClose(qerr.ApplicationError(0x1337, "test error")) + p, err := packer.PackConnectionClose(qerr.NewApplicationError(0x1337, "test error")) Expect(err).ToNot(HaveOccurred()) Expect(p.packets).To(HaveLen(2)) Expect(p.buffer.Len()).To(BeEquivalentTo(protocol.MinInitialPacketSize)) @@ -408,7 +408,7 @@ var _ = Describe("Packet packer", func() { Expect(p.packets[0].frames[0].Frame).To(BeAssignableToTypeOf(&wire.ConnectionCloseFrame{})) ccf := p.packets[0].frames[0].Frame.(*wire.ConnectionCloseFrame) Expect(ccf.IsApplicationError).To(BeFalse()) - Expect(ccf.ErrorCode).To(Equal(qerr.UserCanceledError.ErrorCode)) + Expect(ccf.ErrorCode).To(Equal(qerr.ApplicationError)) Expect(ccf.ReasonPhrase).To(BeEmpty()) Expect(p.packets[1].header.Type).To(Equal(protocol.PacketType0RTT)) Expect(p.packets[1].header.PacketNumber).To(Equal(protocol.PacketNumber(2))) diff --git a/session.go b/session.go index d5d056948..adc1dd566 100644 --- a/session.go +++ b/session.go @@ -572,10 +572,10 @@ runLoop: s.framer.QueueControlFrame(&wire.PingFrame{}) s.keepAlivePingSent = true } else if !s.handshakeComplete && now.Sub(s.sessionCreationTime) >= s.config.HandshakeTimeout { - s.destroyImpl(qerr.TimeoutError("Handshake did not complete in time")) + s.destroyImpl(qerr.NewTimeoutError("Handshake did not complete in time")) continue } else if s.handshakeComplete && now.Sub(s.idleTimeoutStartTime()) >= s.idleTimeout { - s.destroyImpl(qerr.TimeoutError("No recent network activity")) + s.destroyImpl(qerr.NewTimeoutError("No recent network activity")) continue } else if !pacingDeadline.IsZero() && now.Before(pacingDeadline) { // If we get to this point before the pacing deadline, we should wait until that deadline. @@ -586,11 +586,11 @@ runLoop: } if !s.handshakeComplete && now.Sub(s.sessionCreationTime) >= s.config.HandshakeTimeout { - s.destroyImpl(qerr.TimeoutError("Handshake did not complete in time")) + s.destroyImpl(qerr.NewTimeoutError("Handshake did not complete in time")) continue } if s.handshakeComplete && now.Sub(s.idleTimeoutStartTime()) >= s.idleTimeout { - s.destroyImpl(qerr.TimeoutError("No recent network activity")) + s.destroyImpl(qerr.NewTimeoutError("No recent network activity")) continue } @@ -780,7 +780,7 @@ func (s *session) handleSinglePacket(p *receivedPacket, hdr *wire.Header) bool / wasQueued = true s.tryQueueingUndecryptablePacket(p, hdr) case wire.ErrInvalidReservedBits: - s.closeLocal(qerr.Error(qerr.ProtocolViolation, err.Error())) + s.closeLocal(qerr.NewError(qerr.ProtocolViolation, err.Error())) default: // This might be a packet injected by an attacker. // Drop it. @@ -852,7 +852,7 @@ func (s *session) handleRetryPacket(hdr *wire.Header, data []byte) bool /* was t func (s *session) handleUnpackedPacket(packet *unpackedPacket, rcvTime time.Time) error { if len(packet.data) == 0 { - return qerr.Error(qerr.ProtocolViolation, "empty packet") + return qerr.NewError(qerr.ProtocolViolation, "empty packet") } // The server can change the source connection ID with the first Handshake packet. @@ -971,9 +971,9 @@ func (s *session) handlePacket(p *receivedPacket) { func (s *session) handleConnectionCloseFrame(frame *wire.ConnectionCloseFrame) { var e error if frame.IsApplicationError { - e = qerr.ApplicationError(frame.ErrorCode, frame.ReasonPhrase) + e = qerr.NewApplicationError(frame.ErrorCode, frame.ReasonPhrase) } else { - e = qerr.Error(frame.ErrorCode, frame.ReasonPhrase) + e = qerr.NewError(frame.ErrorCode, frame.ReasonPhrase) } s.closeRemote(e) } @@ -1054,7 +1054,7 @@ func (s *session) handlePathChallengeFrame(frame *wire.PathChallengeFrame) { func (s *session) handleNewTokenFrame(frame *wire.NewTokenFrame) error { if s.perspective == protocol.PerspectiveServer { - return qerr.Error(qerr.ProtocolViolation, "Received NEW_TOKEN frame from the client.") + return qerr.NewError(qerr.ProtocolViolation, "Received NEW_TOKEN frame from the client.") } if s.config.TokenStore != nil { s.config.TokenStore.Put(s.tokenStoreKey, &ClientToken{data: frame.Token}) @@ -1072,7 +1072,7 @@ func (s *session) handleRetireConnectionIDFrame(f *wire.RetireConnectionIDFrame) func (s *session) handleHandshakeDoneFrame() error { if s.perspective == protocol.PerspectiveServer { - return qerr.Error(qerr.ProtocolViolation, "received a HANDSHAKE_DONE frame") + return qerr.NewError(qerr.ProtocolViolation, "received a HANDSHAKE_DONE frame") } s.cryptoStreamHandler.DropHandshakeKeys() return nil @@ -1140,14 +1140,14 @@ func (s *session) shutdown() { } func (s *session) CloseWithError(code protocol.ApplicationErrorCode, desc string) error { - s.closeLocal(qerr.ApplicationError(qerr.ErrorCode(code), desc)) + s.closeLocal(qerr.NewApplicationError(qerr.ErrorCode(code), desc)) <-s.ctx.Done() return nil } func (s *session) handleCloseError(closeErr closeError) { if closeErr.err == nil { - closeErr.err = qerr.ApplicationError(0, "") + closeErr.err = qerr.NewApplicationError(0, "") } var quicErr *qerr.QuicError @@ -1190,7 +1190,7 @@ func (s *session) dropEncryptionLevel(encLevel protocol.EncryptionLevel) { func (s *session) processTransportParameters(params *wire.TransportParameters) { // check the Retry token if s.perspective == protocol.PerspectiveClient && !params.OriginalConnectionID.Equal(s.origDestConnID) { - s.closeLocal(qerr.Error(qerr.TransportParameterError, fmt.Sprintf("expected original_connection_id to equal %s, is %s", s.origDestConnID, params.OriginalConnectionID))) + s.closeLocal(qerr.NewError(qerr.TransportParameterError, fmt.Sprintf("expected original_connection_id to equal %s, is %s", s.origDestConnID, params.OriginalConnectionID))) return } diff --git a/session_test.go b/session_test.go index 0ceadfdbf..4870456f4 100644 --- a/session_test.go +++ b/session_test.go @@ -318,7 +318,7 @@ var _ = Describe("Session", func() { }) It("handles CONNECTION_CLOSE frames, with a transport error code", func() { - testErr := qerr.Error(qerr.StreamLimitError, "foobar") + testErr := qerr.NewError(qerr.StreamLimitError, "foobar") streamManager.EXPECT().CloseWithError(testErr) sessionRunner.EXPECT().ReplaceWithClosed(srcConnID, gomock.Any()).Do(func(_ protocol.ConnectionID, s packetHandler) { Expect(s).To(BeAssignableToTypeOf(&closedRemoteSession{})) @@ -342,7 +342,7 @@ var _ = Describe("Session", func() { }) It("handles CONNECTION_CLOSE frames, with an application error code", func() { - testErr := qerr.ApplicationError(0x1337, "foobar") + testErr := qerr.NewApplicationError(0x1337, "foobar") streamManager.EXPECT().CloseWithError(testErr) sessionRunner.EXPECT().ReplaceWithClosed(srcConnID, gomock.Any()).Do(func(_ protocol.ConnectionID, s packetHandler) { Expect(s).To(BeAssignableToTypeOf(&closedRemoteSession{})) @@ -401,7 +401,7 @@ var _ = Describe("Session", func() { It("shuts down without error", func() { sess.handshakeComplete = true - streamManager.EXPECT().CloseWithError(qerr.ApplicationError(0, "")) + streamManager.EXPECT().CloseWithError(qerr.NewApplicationError(0, "")) expectReplaceWithClosed() cryptoSetup.EXPECT().Close() buffer := getPacketBuffer() @@ -430,7 +430,7 @@ var _ = Describe("Session", func() { }) It("closes with an error", func() { - streamManager.EXPECT().CloseWithError(qerr.ApplicationError(0x1337, "test error")) + streamManager.EXPECT().CloseWithError(qerr.NewApplicationError(0x1337, "test error")) expectReplaceWithClosed() cryptoSetup.EXPECT().Close() packer.EXPECT().PackConnectionClose(gomock.Any()).DoAndReturn(func(quicErr *qerr.QuicError) (*coalescedPacket, error) { @@ -446,7 +446,7 @@ var _ = Describe("Session", func() { }) It("includes the frame type in transport-level close frames", func() { - testErr := qerr.ErrorWithFrameType(0x1337, 0x42, "test error") + testErr := qerr.NewErrorWithFrameType(0x1337, 0x42, "test error") streamManager.EXPECT().CloseWithError(testErr) expectReplaceWithClosed() cryptoSetup.EXPECT().Close() @@ -1411,7 +1411,7 @@ var _ = Describe("Session", func() { defer GinkgoRecover() cryptoSetup.EXPECT().RunHandshake().MaxTimes(1) err := sess.run() - Expect(err).To(MatchError(qerr.ApplicationError(0x1337, testErr.Error()))) + Expect(err).To(MatchError(qerr.NewApplicationError(0x1337, testErr.Error()))) close(done) }() streamManager.EXPECT().CloseWithError(gomock.Any()) diff --git a/streams_map.go b/streams_map.go index 095ac6da0..ce9b2bdbf 100644 --- a/streams_map.go +++ b/streams_map.go @@ -153,7 +153,7 @@ func (m *streamsMap) DeleteStream(id protocol.StreamID) error { func (m *streamsMap) GetOrOpenReceiveStream(id protocol.StreamID) (receiveStreamI, error) { str, err := m.getOrOpenReceiveStream(id) if err != nil { - return nil, qerr.Error(qerr.StreamStateError, err.Error()) + return nil, qerr.NewError(qerr.StreamStateError, err.Error()) } return str, nil } @@ -184,7 +184,7 @@ func (m *streamsMap) getOrOpenReceiveStream(id protocol.StreamID) (receiveStream func (m *streamsMap) GetOrOpenSendStream(id protocol.StreamID) (sendStreamI, error) { str, err := m.getOrOpenSendStream(id) if err != nil { - return nil, qerr.Error(qerr.StreamStateError, err.Error()) + return nil, qerr.NewError(qerr.StreamStateError, err.Error()) } return str, nil }