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

rename the constructors for the various qerr.Error flavors

Browse source
This commit is contained in:
Marten Seemann 2020-03-21 10:53:03 +07:00
parent 2f2583beb0
commit 6d61dccc2f
16 changed files with 69 additions and 69 deletions
Download patch file Download diff file Expand all files Collapse all files

2
conn_id_generator.go
View file

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

4
crypto_stream.go
View file

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

4
internal/ackhandler/sent_packet_handler.go
View file

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

2
internal/flowcontrol/connection_flow_controller.go
View file

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

8
internal/flowcontrol/stream_flow_controller.go
View file

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

4
internal/handshake/crypto_setup.go
View file

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

4
internal/handshake/updatable_aead.go
View file

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

24
internal/qerr/quic_error.go
View file

@ -20,16 +20,16 @@ var _ net.Error = &QuicError{}
// 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 +37,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 +110,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())
}

28
internal/qerr/quic_error_test.go
View file

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

2
internal/wire/frame_parser.go
View file

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

2
internal/wire/stream_frame.go
View file

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

2
internal/wire/transport_parameters.go
View file

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

10
packet_packer_test.go
View file

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

26
session.go
View file

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

12
session_test.go
View file

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

4
streams_map.go
View file

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