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

expose the TransportError and the ApplicationError

Browse source
This commit is contained in:
Marten Seemann 2021-04-25 18:47:04 +07:00
parent f5238bf7b1
commit 42b61729bd
23 changed files with 126 additions and 106 deletions
Download patch file Download diff file Expand all files Collapse all files

30
errors.go Normal file
View file

@ -0,0 +1,30 @@
package quic
import "github.com/lucas-clemente/quic-go/internal/qerr"
type (
TransportError = qerr.TransportError
ApplicationError = qerr.ApplicationError
TransportErrorCode = qerr.TransportErrorCode
ApplicationErrorCode = qerr.ApplicationErrorCode
)
const (
NoError = qerr.NoError
InternalError = qerr.InternalError
ConnectionRefused = qerr.ConnectionRefused
FlowControlError = qerr.FlowControlError
StreamLimitError = qerr.StreamLimitError
StreamStateError = qerr.StreamStateError
FinalSizeError = qerr.FinalSizeError
FrameEncodingError = qerr.FrameEncodingError
TransportParameterError = qerr.TransportParameterError
ConnectionIDLimitError = qerr.ConnectionIDLimitError
ProtocolViolation = qerr.ProtocolViolation
InvalidToken = qerr.InvalidToken
ApplicationErrorErrorCode = qerr.ApplicationErrorErrorCode
CryptoBufferExceeded = qerr.CryptoBufferExceeded
KeyUpdateError = qerr.KeyUpdateError
AEADLimitReached = qerr.AEADLimitReached
NoViablePathError = qerr.NoViablePathError
)

6
fuzzing/frames/cmd/corpus.go
View file

@ -124,17 +124,17 @@ func getFrames() []wire.Frame {
&wire.PingFrame{},
&wire.ResetStreamFrame{
StreamID: protocol.StreamID(getRandomNumber()),
ErrorCode: quic.ErrorCode(getRandomNumber()),
ErrorCode: quic.ApplicationErrorCode(getRandomNumber()),
FinalSize: protocol.ByteCount(getRandomNumber()),
},
&wire.ResetStreamFrame{ // at maximum offset
StreamID: protocol.StreamID(getRandomNumber()),
ErrorCode: quic.ErrorCode(getRandomNumber()),
ErrorCode: quic.ApplicationErrorCode(getRandomNumber()),
FinalSize: protocol.MaxByteCount,
},
&wire.StopSendingFrame{
StreamID: protocol.StreamID(getRandomNumber()),
ErrorCode: quic.ErrorCode(getRandomNumber()),
ErrorCode: quic.ApplicationErrorCode(getRandomNumber()),
},
&wire.CryptoFrame{
Data: getRandomData(100),

2
http3/body.go
View file

@ -93,6 +93,6 @@ func (r *body) requestDone() {
func (r *body) Close() error {
r.requestDone()
// If the EOF was read, CancelRead() is a no-op.
r.str.CancelRead(quic.ErrorCode(errorRequestCanceled))
r.str.CancelRead(quic.ApplicationErrorCode(errorRequestCanceled))
return nil
}

4
http3/body_test.go
View file

@ -173,12 +173,12 @@ var _ = Describe("Body", func() {
})
It("closes responses", func() {
str.EXPECT().CancelRead(quic.ErrorCode(errorRequestCanceled))
str.EXPECT().CancelRead(quic.ApplicationErrorCode(errorRequestCanceled))
Expect(rb.Close()).To(Succeed())
})
It("allows multiple calls to Close", func() {
str.EXPECT().CancelRead(quic.ErrorCode(errorRequestCanceled)).MaxTimes(2)
str.EXPECT().CancelRead(quic.ApplicationErrorCode(errorRequestCanceled)).MaxTimes(2)
Expect(rb.Close()).To(Succeed())
Expect(reqDone).To(BeClosed())
Expect(rb.Close()).To(Succeed())

24
http3/client.go
View file

@ -117,7 +117,7 @@ func (c *client) dial() error {
go func() {
if err := c.setupSession(); err != nil {
c.logger.Debugf("Setting up session failed: %s", err)
c.session.CloseWithError(quic.ErrorCode(errorInternalError), "")
c.session.CloseWithError(quic.ApplicationErrorCode(errorInternalError), "")
}
}()
@ -162,20 +162,20 @@ func (c *client) handleUnidirectionalStreams() {
return
case streamTypePushStream:
// We never increased the Push ID, so we don't expect any push streams.
c.session.CloseWithError(quic.ErrorCode(errorIDError), "")
c.session.CloseWithError(quic.ApplicationErrorCode(errorIDError), "")
return
default:
str.CancelRead(quic.ErrorCode(errorStreamCreationError))
str.CancelRead(quic.ApplicationErrorCode(errorStreamCreationError))
return
}
f, err := parseNextFrame(str)
if err != nil {
c.session.CloseWithError(quic.ErrorCode(errorFrameError), "")
c.session.CloseWithError(quic.ApplicationErrorCode(errorFrameError), "")
return
}
sf, ok := f.(*settingsFrame)
if !ok {
c.session.CloseWithError(quic.ErrorCode(errorMissingSettings), "")
c.session.CloseWithError(quic.ApplicationErrorCode(errorMissingSettings), "")
return
}
if !sf.Datagram {
@ -185,7 +185,7 @@ func (c *client) handleUnidirectionalStreams() {
// we can expect it to have been negotiated both on the transport and on the HTTP/3 layer.
// Note: ConnectionState() will block until the handshake is complete (relevant when using 0-RTT).
if c.opts.EnableDatagram && !c.session.ConnectionState().SupportsDatagrams {
c.session.CloseWithError(quic.ErrorCode(errorSettingsError), "missing QUIC Datagram support")
c.session.CloseWithError(quic.ApplicationErrorCode(errorSettingsError), "missing QUIC Datagram support")
}
}()
}
@ -195,7 +195,7 @@ func (c *client) Close() error {
if c.session == nil {
return nil
}
return c.session.CloseWithError(quic.ErrorCode(errorNoError), "")
return c.session.CloseWithError(quic.ApplicationErrorCode(errorNoError), "")
}
func (c *client) maxHeaderBytes() uint64 {
@ -243,8 +243,8 @@ func (c *client) RoundTrip(req *http.Request) (*http.Response, error) {
go func() {
select {
case <-req.Context().Done():
str.CancelWrite(quic.ErrorCode(errorRequestCanceled))
str.CancelRead(quic.ErrorCode(errorRequestCanceled))
str.CancelWrite(quic.ApplicationErrorCode(errorRequestCanceled))
str.CancelRead(quic.ApplicationErrorCode(errorRequestCanceled))
case <-reqDone:
}
}()
@ -253,14 +253,14 @@ func (c *client) RoundTrip(req *http.Request) (*http.Response, error) {
if rerr.err != nil { // if any error occurred
close(reqDone)
if rerr.streamErr != 0 { // if it was a stream error
str.CancelWrite(quic.ErrorCode(rerr.streamErr))
str.CancelWrite(quic.ApplicationErrorCode(rerr.streamErr))
}
if rerr.connErr != 0 { // if it was a connection error
var reason string
if rerr.err != nil {
reason = rerr.err.Error()
}
c.session.CloseWithError(quic.ErrorCode(rerr.connErr), reason)
c.session.CloseWithError(quic.ApplicationErrorCode(rerr.connErr), reason)
}
}
return rsp, rerr.err
@ -321,7 +321,7 @@ func (c *client) doRequest(
}
}
respBody := newResponseBody(str, reqDone, func() {
c.session.CloseWithError(quic.ErrorCode(errorFrameUnexpected), "")
c.session.CloseWithError(quic.ApplicationErrorCode(errorFrameUnexpected), "")
})
// Rules for when to set Content-Length are defined in https://tools.ietf.org/html/rfc7230#section-3.3.2.

24
http3/client_test.go
View file

@ -267,7 +267,7 @@ var _ = Describe("Client", func() {
str := mockquic.NewMockStream(mockCtrl)
str.EXPECT().Read(gomock.Any()).DoAndReturn(buf.Read).AnyTimes()
done := make(chan struct{})
str.EXPECT().CancelRead(quic.ErrorCode(errorStreamCreationError)).Do(func(code quic.ErrorCode) {
str.EXPECT().CancelRead(quic.ApplicationErrorCode(errorStreamCreationError)).Do(func(code quic.ApplicationErrorCode) {
close(done)
})
@ -297,7 +297,7 @@ var _ = Describe("Client", func() {
return nil, errors.New("test done")
})
done := make(chan struct{})
sess.EXPECT().CloseWithError(gomock.Any(), gomock.Any()).Do(func(code quic.ErrorCode, _ string) {
sess.EXPECT().CloseWithError(gomock.Any(), gomock.Any()).Do(func(code quic.ApplicationErrorCode, _ string) {
defer GinkgoRecover()
Expect(code).To(BeEquivalentTo(errorMissingSettings))
close(done)
@ -323,7 +323,7 @@ var _ = Describe("Client", func() {
return nil, errors.New("test done")
})
done := make(chan struct{})
sess.EXPECT().CloseWithError(gomock.Any(), gomock.Any()).Do(func(code quic.ErrorCode, _ string) {
sess.EXPECT().CloseWithError(gomock.Any(), gomock.Any()).Do(func(code quic.ApplicationErrorCode, _ string) {
defer GinkgoRecover()
Expect(code).To(BeEquivalentTo(errorFrameError))
close(done)
@ -346,7 +346,7 @@ var _ = Describe("Client", func() {
return nil, errors.New("test done")
})
done := make(chan struct{})
sess.EXPECT().CloseWithError(gomock.Any(), gomock.Any()).Do(func(code quic.ErrorCode, _ string) {
sess.EXPECT().CloseWithError(gomock.Any(), gomock.Any()).Do(func(code quic.ApplicationErrorCode, _ string) {
defer GinkgoRecover()
Expect(code).To(BeEquivalentTo(errorIDError))
close(done)
@ -372,7 +372,7 @@ var _ = Describe("Client", func() {
})
sess.EXPECT().ConnectionState().Return(quic.ConnectionState{SupportsDatagrams: false})
done := make(chan struct{})
sess.EXPECT().CloseWithError(gomock.Any(), gomock.Any()).Do(func(code quic.ErrorCode, reason string) {
sess.EXPECT().CloseWithError(gomock.Any(), gomock.Any()).Do(func(code quic.ApplicationErrorCode, reason string) {
defer GinkgoRecover()
Expect(code).To(BeEquivalentTo(errorSettingsError))
Expect(reason).To(Equal("missing QUIC Datagram support"))
@ -546,7 +546,7 @@ var _ = Describe("Client", func() {
request.Body.(*mockBody).readErr = errors.New("testErr")
done := make(chan struct{})
gomock.InOrder(
str.EXPECT().CancelWrite(quic.ErrorCode(errorRequestCanceled)).Do(func(quic.ErrorCode) {
str.EXPECT().CancelWrite(quic.ApplicationErrorCode(errorRequestCanceled)).Do(func(quic.ApplicationErrorCode) {
close(done)
}),
str.EXPECT().CancelWrite(gomock.Any()),
@ -584,7 +584,7 @@ var _ = Describe("Client", func() {
It("closes the connection when the first frame is not a HEADERS frame", func() {
buf := &bytes.Buffer{}
(&dataFrame{Length: 0x42}).Write(buf)
sess.EXPECT().CloseWithError(quic.ErrorCode(errorFrameUnexpected), gomock.Any())
sess.EXPECT().CloseWithError(quic.ApplicationErrorCode(errorFrameUnexpected), gomock.Any())
closed := make(chan struct{})
str.EXPECT().Close().Do(func() { close(closed) })
str.EXPECT().Read(gomock.Any()).DoAndReturn(buf.Read).AnyTimes()
@ -596,7 +596,7 @@ var _ = Describe("Client", func() {
It("cancels the stream when the HEADERS frame is too large", func() {
buf := &bytes.Buffer{}
(&headersFrame{Length: 1338}).Write(buf)
str.EXPECT().CancelWrite(quic.ErrorCode(errorFrameError))
str.EXPECT().CancelWrite(quic.ApplicationErrorCode(errorFrameError))
closed := make(chan struct{})
str.EXPECT().Close().Do(func() { close(closed) })
str.EXPECT().Read(gomock.Any()).DoAndReturn(buf.Read).AnyTimes()
@ -635,8 +635,8 @@ var _ = Describe("Client", func() {
done := make(chan struct{})
canceled := make(chan struct{})
gomock.InOrder(
str.EXPECT().CancelWrite(quic.ErrorCode(errorRequestCanceled)).Do(func(quic.ErrorCode) { close(canceled) }),
str.EXPECT().CancelRead(quic.ErrorCode(errorRequestCanceled)).Do(func(quic.ErrorCode) { close(done) }),
str.EXPECT().CancelWrite(quic.ApplicationErrorCode(errorRequestCanceled)).Do(func(quic.ApplicationErrorCode) { close(canceled) }),
str.EXPECT().CancelRead(quic.ApplicationErrorCode(errorRequestCanceled)).Do(func(quic.ApplicationErrorCode) { close(done) }),
)
str.EXPECT().CancelWrite(gomock.Any()).MaxTimes(1)
str.EXPECT().Read(gomock.Any()).DoAndReturn(func([]byte) (int, error) {
@ -663,8 +663,8 @@ var _ = Describe("Client", func() {
done := make(chan struct{})
str.EXPECT().Write(gomock.Any()).DoAndReturn(buf.Write)
str.EXPECT().Read(gomock.Any()).DoAndReturn(rspBuf.Read).AnyTimes()
str.EXPECT().CancelWrite(quic.ErrorCode(errorRequestCanceled))
str.EXPECT().CancelRead(quic.ErrorCode(errorRequestCanceled)).Do(func(quic.ErrorCode) { close(done) })
str.EXPECT().CancelWrite(quic.ApplicationErrorCode(errorRequestCanceled))
str.EXPECT().CancelRead(quic.ApplicationErrorCode(errorRequestCanceled)).Do(func(quic.ApplicationErrorCode) { close(done) })
_, err := client.RoundTrip(req)
Expect(err).ToNot(HaveOccurred())
cancel()

4
http3/error_codes.go
View file

@ -3,10 +3,10 @@ package http3
import (
"fmt"
quic "github.com/lucas-clemente/quic-go"
"github.com/lucas-clemente/quic-go"
)
type errorCode quic.ErrorCode
type errorCode quic.ApplicationErrorCode
const (
errorNoError errorCode = 0x100

2
http3/request_writer.go
View file

@ -79,7 +79,7 @@ func (w *requestWriter) WriteRequest(str quic.Stream, req *http.Request, gzip bo
if rerr == io.EOF {
break
}
str.CancelWrite(quic.ErrorCode(errorRequestCanceled))
str.CancelWrite(quic.ApplicationErrorCode(errorRequestCanceled))
w.logger.Errorf("Error writing request: %s", rerr)
return
}

6
http3/roundtrip_test.go
View file

@ -10,7 +10,7 @@ import (
"time"
"github.com/golang/mock/gomock"
quic "github.com/lucas-clemente/quic-go"
"github.com/lucas-clemente/quic-go"
mockquic "github.com/lucas-clemente/quic-go/internal/mocks/quic"
. "github.com/onsi/ginkgo"
. "github.com/onsi/gomega"
@ -105,7 +105,7 @@ var _ = Describe("RoundTripper", func() {
<-closed
return nil, errors.New("test done")
}).MaxTimes(1)
session.EXPECT().CloseWithError(gomock.Any(), gomock.Any()).Do(func(quic.ErrorCode, string) { close(closed) })
session.EXPECT().CloseWithError(gomock.Any(), gomock.Any()).Do(func(quic.ApplicationErrorCode, string) { close(closed) })
_, err = rt.RoundTrip(req)
Expect(err).To(MatchError(testErr))
Expect(rt.clients).To(HaveLen(1))
@ -147,7 +147,7 @@ var _ = Describe("RoundTripper", func() {
<-closed
return nil, errors.New("test done")
}).MaxTimes(1)
session.EXPECT().CloseWithError(gomock.Any(), gomock.Any()).Do(func(quic.ErrorCode, string) { close(closed) })
session.EXPECT().CloseWithError(gomock.Any(), gomock.Any()).Do(func(quic.ApplicationErrorCode, string) { close(closed) })
req, err := http.NewRequest("GET", "https://quic.clemente.io/file1.html", nil)
Expect(err).ToNot(HaveOccurred())
_, err = rt.RoundTrip(req)

18
http3/server.go
View file

@ -258,19 +258,19 @@ func (s *Server) handleConn(sess quic.EarlySession) {
}
go func() {
rerr := s.handleRequest(sess, str, decoder, func() {
sess.CloseWithError(quic.ErrorCode(errorFrameUnexpected), "")
sess.CloseWithError(quic.ApplicationErrorCode(errorFrameUnexpected), "")
})
if rerr.err != nil || rerr.streamErr != 0 || rerr.connErr != 0 {
s.logger.Debugf("Handling request failed: %s", err)
if rerr.streamErr != 0 {
str.CancelWrite(quic.ErrorCode(rerr.streamErr))
str.CancelWrite(quic.ApplicationErrorCode(rerr.streamErr))
}
if rerr.connErr != 0 {
var reason string
if rerr.err != nil {
reason = rerr.err.Error()
}
sess.CloseWithError(quic.ErrorCode(rerr.connErr), reason)
sess.CloseWithError(quic.ApplicationErrorCode(rerr.connErr), reason)
}
return
}
@ -301,20 +301,20 @@ func (s *Server) handleUnidirectionalStreams(sess quic.EarlySession) {
// TODO: check that only one stream of each type is opened.
return
case streamTypePushStream: // only the server can push
sess.CloseWithError(quic.ErrorCode(errorStreamCreationError), "")
sess.CloseWithError(quic.ApplicationErrorCode(errorStreamCreationError), "")
return
default:
str.CancelRead(quic.ErrorCode(errorStreamCreationError))
str.CancelRead(quic.ApplicationErrorCode(errorStreamCreationError))
return
}
f, err := parseNextFrame(str)
if err != nil {
sess.CloseWithError(quic.ErrorCode(errorFrameError), "")
sess.CloseWithError(quic.ApplicationErrorCode(errorFrameError), "")
return
}
sf, ok := f.(*settingsFrame)
if !ok {
sess.CloseWithError(quic.ErrorCode(errorMissingSettings), "")
sess.CloseWithError(quic.ApplicationErrorCode(errorMissingSettings), "")
return
}
if !sf.Datagram {
@ -324,7 +324,7 @@ func (s *Server) handleUnidirectionalStreams(sess quic.EarlySession) {
// we can expect it to have been negotiated both on the transport and on the HTTP/3 layer.
// Note: ConnectionState() will block until the handshake is complete (relevant when using 0-RTT).
if s.EnableDatagrams && !sess.ConnectionState().SupportsDatagrams {
sess.CloseWithError(quic.ErrorCode(errorSettingsError), "missing QUIC Datagram support")
sess.CloseWithError(quic.ApplicationErrorCode(errorSettingsError), "missing QUIC Datagram support")
}
}(str)
}
@ -410,7 +410,7 @@ func (s *Server) handleRequest(sess quic.Session, str quic.Stream, decoder *qpac
r.WriteHeader(200)
}
// If the EOF was read by the handler, CancelRead() is a no-op.
str.CancelRead(quic.ErrorCode(errorNoError))
str.CancelRead(quic.ApplicationErrorCode(errorNoError))
}
return requestError{}
}

26
http3/server_test.go
View file

@ -257,7 +257,7 @@ var _ = Describe("Server", func() {
str := mockquic.NewMockStream(mockCtrl)
str.EXPECT().Read(gomock.Any()).DoAndReturn(buf.Read).AnyTimes()
done := make(chan struct{})
str.EXPECT().CancelRead(quic.ErrorCode(errorStreamCreationError)).Do(func(code quic.ErrorCode) {
str.EXPECT().CancelRead(quic.ApplicationErrorCode(errorStreamCreationError)).Do(func(code quic.ApplicationErrorCode) {
close(done)
})
@ -286,7 +286,7 @@ var _ = Describe("Server", func() {
return nil, errors.New("test done")
})
done := make(chan struct{})
sess.EXPECT().CloseWithError(gomock.Any(), gomock.Any()).Do(func(code quic.ErrorCode, _ string) {
sess.EXPECT().CloseWithError(gomock.Any(), gomock.Any()).Do(func(code quic.ApplicationErrorCode, _ string) {
defer GinkgoRecover()
Expect(code).To(BeEquivalentTo(errorMissingSettings))
close(done)
@ -311,7 +311,7 @@ var _ = Describe("Server", func() {
return nil, errors.New("test done")
})
done := make(chan struct{})
sess.EXPECT().CloseWithError(gomock.Any(), gomock.Any()).Do(func(code quic.ErrorCode, _ string) {
sess.EXPECT().CloseWithError(gomock.Any(), gomock.Any()).Do(func(code quic.ApplicationErrorCode, _ string) {
defer GinkgoRecover()
Expect(code).To(BeEquivalentTo(errorFrameError))
close(done)
@ -334,7 +334,7 @@ var _ = Describe("Server", func() {
return nil, errors.New("test done")
})
done := make(chan struct{})
sess.EXPECT().CloseWithError(gomock.Any(), gomock.Any()).Do(func(code quic.ErrorCode, _ string) {
sess.EXPECT().CloseWithError(gomock.Any(), gomock.Any()).Do(func(code quic.ApplicationErrorCode, _ string) {
defer GinkgoRecover()
Expect(code).To(BeEquivalentTo(errorStreamCreationError))
close(done)
@ -359,7 +359,7 @@ var _ = Describe("Server", func() {
})
sess.EXPECT().ConnectionState().Return(quic.ConnectionState{SupportsDatagrams: false})
done := make(chan struct{})
sess.EXPECT().CloseWithError(gomock.Any(), gomock.Any()).Do(func(code quic.ErrorCode, reason string) {
sess.EXPECT().CloseWithError(gomock.Any(), gomock.Any()).Do(func(code quic.ApplicationErrorCode, reason string) {
defer GinkgoRecover()
Expect(code).To(BeEquivalentTo(errorSettingsError))
Expect(reason).To(Equal("missing QUIC Datagram support"))
@ -408,7 +408,7 @@ var _ = Describe("Server", func() {
done := make(chan struct{})
str.EXPECT().Context().Return(reqContext)
str.EXPECT().Write(gomock.Any()).DoAndReturn(responseBuf.Write).AnyTimes()
str.EXPECT().CancelRead(quic.ErrorCode(errorNoError))
str.EXPECT().CancelRead(quic.ApplicationErrorCode(errorNoError))
str.EXPECT().Close().Do(func() { close(done) })
s.handleConn(sess)
@ -431,7 +431,7 @@ var _ = Describe("Server", func() {
setRequest(append(requestData, buf.Bytes()...))
done := make(chan struct{})
str.EXPECT().Write(gomock.Any()).DoAndReturn(responseBuf.Write).AnyTimes()
str.EXPECT().CancelWrite(quic.ErrorCode(errorFrameError)).Do(func(quic.ErrorCode) { close(done) })
str.EXPECT().CancelWrite(quic.ApplicationErrorCode(errorFrameError)).Do(func(quic.ApplicationErrorCode) { close(done) })
s.handleConn(sess)
Eventually(done).Should(BeClosed())
@ -446,7 +446,7 @@ var _ = Describe("Server", func() {
testErr := errors.New("stream reset")
done := make(chan struct{})
str.EXPECT().Read(gomock.Any()).Return(0, testErr)
str.EXPECT().CancelWrite(quic.ErrorCode(errorRequestIncomplete)).Do(func(quic.ErrorCode) { close(done) })
str.EXPECT().CancelWrite(quic.ApplicationErrorCode(errorRequestIncomplete)).Do(func(quic.ApplicationErrorCode) { close(done) })
s.handleConn(sess)
Consistently(handlerCalled).ShouldNot(BeClosed())
@ -466,8 +466,8 @@ var _ = Describe("Server", func() {
}).AnyTimes()
done := make(chan struct{})
sess.EXPECT().CloseWithError(gomock.Any(), gomock.Any()).Do(func(code quic.ErrorCode, _ string) {
Expect(code).To(Equal(quic.ErrorCode(errorFrameUnexpected)))
sess.EXPECT().CloseWithError(gomock.Any(), gomock.Any()).Do(func(code quic.ApplicationErrorCode, _ string) {
Expect(code).To(Equal(quic.ApplicationErrorCode(errorFrameUnexpected)))
close(done)
})
s.handleConn(sess)
@ -491,7 +491,7 @@ var _ = Describe("Server", func() {
return len(p), nil
}).AnyTimes()
done := make(chan struct{})
str.EXPECT().CancelWrite(quic.ErrorCode(errorFrameError)).Do(func(quic.ErrorCode) { close(done) })
str.EXPECT().CancelWrite(quic.ApplicationErrorCode(errorFrameError)).Do(func(quic.ApplicationErrorCode) { close(done) })
s.handleConn(sess)
Eventually(done).Should(BeClosed())
@ -513,7 +513,7 @@ var _ = Describe("Server", func() {
str.EXPECT().Write(gomock.Any()).DoAndReturn(func(p []byte) (int, error) {
return len(p), nil
}).AnyTimes()
str.EXPECT().CancelRead(quic.ErrorCode(errorNoError))
str.EXPECT().CancelRead(quic.ApplicationErrorCode(errorNoError))
serr := s.handleRequest(sess, str, qpackDecoder, nil)
Expect(serr.err).ToNot(HaveOccurred())
@ -536,7 +536,7 @@ var _ = Describe("Server", func() {
str.EXPECT().Write(gomock.Any()).DoAndReturn(func(p []byte) (int, error) {
return len(p), nil
}).AnyTimes()
str.EXPECT().CancelRead(quic.ErrorCode(errorNoError))
str.EXPECT().CancelRead(quic.ApplicationErrorCode(errorNoError))
serr := s.handleRequest(sess, str, qpackDecoder, nil)
Expect(serr.err).ToNot(HaveOccurred())

18
integrationtests/self/cancelation_test.go
View file

@ -11,7 +11,7 @@ import (
"sync/atomic"
"time"
quic "github.com/lucas-clemente/quic-go"
"github.com/lucas-clemente/quic-go"
. "github.com/onsi/ginkgo"
. "github.com/onsi/gomega"
@ -87,7 +87,7 @@ var _ = Describe("Stream Cancelations", func() {
// cancel around 2/3 of the streams
if rand.Int31()%3 != 0 {
atomic.AddInt32(&canceledCounter, 1)
str.CancelRead(quic.ErrorCode(str.StreamID()))
str.CancelRead(quic.ApplicationErrorCode(str.StreamID()))
return
}
data, err := ioutil.ReadAll(str)
@ -133,7 +133,7 @@ var _ = Describe("Stream Cancelations", func() {
length := int(rand.Int31n(int32(len(PRData) - 1)))
data, err := ioutil.ReadAll(io.LimitReader(str, int64(length)))
Expect(err).ToNot(HaveOccurred())
str.CancelRead(quic.ErrorCode(str.StreamID()))
str.CancelRead(quic.ApplicationErrorCode(str.StreamID()))
Expect(data).To(Equal(PRData[:length]))
atomic.AddInt32(&canceledCounter, 1)
return
@ -212,7 +212,7 @@ var _ = Describe("Stream Cancelations", func() {
Expect(err).ToNot(HaveOccurred())
// cancel about 2/3 of the streams
if rand.Int31()%3 != 0 {
str.CancelWrite(quic.ErrorCode(str.StreamID()))
str.CancelWrite(quic.ApplicationErrorCode(str.StreamID()))
atomic.AddInt32(&canceledCounter, 1)
return
}
@ -246,7 +246,7 @@ var _ = Describe("Stream Cancelations", func() {
length := int(rand.Int31n(int32(len(PRData) - 1)))
_, err = str.Write(PRData[:length])
Expect(err).ToNot(HaveOccurred())
str.CancelWrite(quic.ErrorCode(str.StreamID()))
str.CancelWrite(quic.ApplicationErrorCode(str.StreamID()))
atomic.AddInt32(&canceledCounter, 1)
return
}
@ -282,7 +282,7 @@ var _ = Describe("Stream Cancelations", func() {
Expect(err).ToNot(HaveOccurred())
// cancel about half of the streams
if rand.Int31()%2 == 0 {
str.CancelWrite(quic.ErrorCode(str.StreamID()))
str.CancelWrite(quic.ApplicationErrorCode(str.StreamID()))
return
}
if _, err = str.Write(PRData); err != nil {
@ -317,7 +317,7 @@ var _ = Describe("Stream Cancelations", func() {
Expect(err).ToNot(HaveOccurred())
// cancel around half of the streams
if rand.Int31()%2 == 0 {
str.CancelRead(quic.ErrorCode(str.StreamID()))
str.CancelRead(quic.ApplicationErrorCode(str.StreamID()))
return
}
data, err := ioutil.ReadAll(str)
@ -368,7 +368,7 @@ var _ = Describe("Stream Cancelations", func() {
return
}
if length < len(PRData) {
str.CancelWrite(quic.ErrorCode(str.StreamID()))
str.CancelWrite(quic.ApplicationErrorCode(str.StreamID()))
} else if err := str.Close(); err != nil {
Expect(err).To(MatchError(fmt.Sprintf("close called for canceled stream %d", str.StreamID())))
return
@ -410,7 +410,7 @@ var _ = Describe("Stream Cancelations", func() {
}
Expect(data).To(Equal(PRData[:length]))
if length < len(PRData) {
str.CancelRead(quic.ErrorCode(str.StreamID()))
str.CancelRead(quic.ApplicationErrorCode(str.StreamID()))
return
}

3
integrationtests/self/handshake_rtt_test.go
View file

@ -7,7 +7,7 @@ import (
"net"
"time"
quic "github.com/lucas-clemente/quic-go"
"github.com/lucas-clemente/quic-go"
quicproxy "github.com/lucas-clemente/quic-go/integrationtests/tools/proxy"
"github.com/lucas-clemente/quic-go/internal/protocol"
@ -86,7 +86,6 @@ var _ = Describe("Handshake RTT tests", func() {
clientConfig,
)
Expect(err).To(HaveOccurred())
// Expect(err.(qerr.ErrorCode)).To(Equal(qerr.InvalidVersion))
expectDurationInRTTs(1)
})

26
integrationtests/self/handshake_test.go
View file

@ -12,8 +12,8 @@ import (
"github.com/lucas-clemente/quic-go"
"github.com/lucas-clemente/quic-go/integrationtests/tools/israce"
"github.com/lucas-clemente/quic-go/internal/protocol"
"github.com/lucas-clemente/quic-go/internal/qerr"
"github.com/lucas-clemente/quic-go/logging"
. "github.com/onsi/ginkgo"
. "github.com/onsi/gomega"
)
@ -269,7 +269,7 @@ var _ = Describe("Handshake tests", func() {
clientConfig,
)
Expect(err).To(HaveOccurred())
var transportErr *qerr.TransportError
var transportErr *quic.TransportError
Expect(errors.As(err, &transportErr)).To(BeTrue())
Expect(transportErr.ErrorCode.IsCryptoError()).To(BeTrue())
Expect(transportErr.Error()).To(ContainSubstring("x509: certificate is valid for localhost, not foo.bar"))
@ -298,7 +298,7 @@ var _ = Describe("Handshake tests", func() {
Eventually(errChan).Should(Receive(&err))
}
Expect(err).To(HaveOccurred())
var transportErr *qerr.TransportError
var transportErr *quic.TransportError
Expect(errors.As(err, &transportErr)).To(BeTrue())
Expect(transportErr.ErrorCode.IsCryptoError()).To(BeTrue())
Expect(transportErr.Error()).To(ContainSubstring("tls: bad certificate"))
@ -314,7 +314,7 @@ var _ = Describe("Handshake tests", func() {
clientConfig,
)
Expect(err).To(HaveOccurred())
var transportErr *qerr.TransportError
var transportErr *quic.TransportError
Expect(errors.As(err, &transportErr)).To(BeTrue())
Expect(transportErr.ErrorCode.IsCryptoError()).To(BeTrue())
Expect(transportErr.Error()).To(ContainSubstring("x509: certificate is valid for localhost, not foo.bar"))
@ -376,9 +376,9 @@ var _ = Describe("Handshake tests", func() {
_, err := dial()
Expect(err).To(HaveOccurred())
var transportErr *qerr.TransportError
var transportErr *quic.TransportError
Expect(errors.As(err, &transportErr)).To(BeTrue())
Expect(transportErr.ErrorCode).To(Equal(qerr.ConnectionRefused))
Expect(transportErr.ErrorCode).To(Equal(quic.ConnectionRefused))
// now accept one session, freeing one spot in the queue
_, err = server.Accept(context.Background())
@ -392,7 +392,7 @@ var _ = Describe("Handshake tests", func() {
_, err = dial()
Expect(err).To(HaveOccurred())
Expect(errors.As(err, &transportErr)).To(BeTrue())
Expect(transportErr.ErrorCode).To(Equal(qerr.ConnectionRefused))
Expect(transportErr.ErrorCode).To(Equal(quic.ConnectionRefused))
})
It("removes closed connections from the accept queue", func() {
@ -408,9 +408,9 @@ var _ = Describe("Handshake tests", func() {
_, err = dial()
Expect(err).To(HaveOccurred())
var transportErr *qerr.TransportError
var transportErr *quic.TransportError
Expect(errors.As(err, &transportErr)).To(BeTrue())
Expect(transportErr.ErrorCode).To(Equal(qerr.ConnectionRefused))
Expect(transportErr.ErrorCode).To(Equal(quic.ConnectionRefused))
// Now close the one of the session that are waiting to be accepted.
// This should free one spot in the queue.
@ -426,7 +426,7 @@ var _ = Describe("Handshake tests", func() {
_, err = dial()
Expect(err).To(HaveOccurred())
Expect(errors.As(err, &transportErr)).To(BeTrue())
Expect(transportErr.ErrorCode).To(Equal(qerr.ConnectionRefused))
Expect(transportErr.ErrorCode).To(Equal(quic.ConnectionRefused))
})
})
@ -469,7 +469,7 @@ var _ = Describe("Handshake tests", func() {
nil,
)
Expect(err).To(HaveOccurred())
var transportErr *qerr.TransportError
var transportErr *quic.TransportError
Expect(errors.As(err, &transportErr)).To(BeTrue())
Expect(transportErr.ErrorCode.IsCryptoError()).To(BeTrue())
Expect(transportErr.Error()).To(ContainSubstring("no application protocol"))
@ -550,9 +550,9 @@ var _ = Describe("Handshake tests", func() {
nil,
)
Expect(err).To(HaveOccurred())
var transportErr *qerr.TransportError
var transportErr *quic.TransportError
Expect(errors.As(err, &transportErr)).To(BeTrue())
Expect(transportErr.ErrorCode).To(Equal(qerr.InvalidToken))
Expect(transportErr.ErrorCode).To(Equal(quic.InvalidToken))
// Receiving a Retry might lead the client to measure a very small RTT.
// Then, it sometimes would retransmit the ClientHello before receiving the ServerHello.
Expect(len(tokenChan)).To(BeNumerically(">=", 2))

3
integrationtests/self/http_test.go
View file

@ -17,7 +17,6 @@ import (
"github.com/lucas-clemente/quic-go"
"github.com/lucas-clemente/quic-go/http3"
"github.com/lucas-clemente/quic-go/internal/protocol"
"github.com/lucas-clemente/quic-go/internal/qerr"
"github.com/lucas-clemente/quic-go/internal/testdata"
. "github.com/onsi/ginkgo"
@ -27,7 +26,7 @@ import (
type streamCancelError interface {
Canceled() bool
ErrorCode() qerr.ApplicationErrorCode
ErrorCode() quic.ApplicationErrorCode
}
var _ = Describe("HTTP tests", func() {

5
integrationtests/self/mitm_test.go
View file

@ -15,7 +15,6 @@ import (
"github.com/lucas-clemente/quic-go"
quicproxy "github.com/lucas-clemente/quic-go/integrationtests/tools/proxy"
"github.com/lucas-clemente/quic-go/internal/protocol"
"github.com/lucas-clemente/quic-go/internal/qerr"
"github.com/lucas-clemente/quic-go/internal/testutils"
"github.com/lucas-clemente/quic-go/internal/wire"
. "github.com/onsi/ginkgo"
@ -441,9 +440,9 @@ var _ = Describe("MITM test", func() {
}
err := runTest(delayCb)
Expect(err).To(HaveOccurred())
var transportErr *qerr.TransportError
var transportErr *quic.TransportError
Expect(errors.As(err, &transportErr)).To(BeTrue())
Expect(transportErr.ErrorCode).To(Equal(qerr.ProtocolViolation))
Expect(transportErr.ErrorCode).To(Equal(quic.ProtocolViolation))
Expect(transportErr.ErrorMessage).To(ContainSubstring("received ACK for an unsent packet"))
})
})

4
integrationtests/self/timeout_test.go
View file

@ -3,7 +3,6 @@ package self_test
import (
"bytes"
"context"
"errors"
"fmt"
"io"
"io/ioutil"
@ -14,12 +13,11 @@ import (
"sync/atomic"
"time"
"github.com/lucas-clemente/quic-go/internal/qerr"
"github.com/lucas-clemente/quic-go"
quicproxy "github.com/lucas-clemente/quic-go/integrationtests/tools/proxy"
"github.com/lucas-clemente/quic-go/internal/utils"
"github.com/lucas-clemente/quic-go/logging"
. "github.com/onsi/ginkgo"
. "github.com/onsi/gomega"
)

15
interface.go
View file

@ -9,7 +9,6 @@ import (
"github.com/lucas-clemente/quic-go/internal/handshake"
"github.com/lucas-clemente/quic-go/internal/protocol"
"github.com/lucas-clemente/quic-go/internal/qerr"
"github.com/lucas-clemente/quic-go/logging"
)
@ -65,10 +64,6 @@ type TokenStore interface {
Put(key string, token *ClientToken)
}
// An ErrorCode is an application-defined error code.
// Valid values range between 0 and MAX_UINT62.
type ErrorCode = qerr.ApplicationErrorCode
// Err0RTTRejected is the returned from:
// * Open{Uni}Stream{Sync}
// * Accept{Uni}Stream
@ -109,7 +104,7 @@ type ReceiveStream interface {
// It will ask the peer to stop transmitting stream data.
// Read will unblock immediately, and future Read calls will fail.
// When called multiple times or after reading the io.EOF it is a no-op.
CancelRead(ErrorCode)
CancelRead(ApplicationErrorCode)
// SetReadDeadline sets the deadline for future Read calls and
// any currently-blocked Read call.
// A zero value for t means Read will not time out.
@ -138,7 +133,7 @@ type SendStream interface {
// Data already written, but not yet delivered to the peer is not guaranteed to be delivered reliably.
// Write will unblock immediately, and future calls to Write will fail.
// When called multiple times or after closing the stream it is a no-op.
CancelWrite(ErrorCode)
CancelWrite(ApplicationErrorCode)
// The context is canceled as soon as the write-side of the stream is closed.
// This happens when Close() or CancelWrite() is called, or when the peer
// cancels the read-side of their stream.
@ -156,7 +151,7 @@ type SendStream interface {
type StreamError interface {
error
Canceled() bool
ErrorCode() ErrorCode
ErrorCode() ApplicationErrorCode
}
// A Session is a QUIC connection between two peers.
@ -195,9 +190,9 @@ type Session interface {
LocalAddr() net.Addr
// RemoteAddr returns the address of the peer.
RemoteAddr() net.Addr
// Close the connection with an error.
// CloseWithError closes the connection with an error.
// The error string will be sent to the peer.
CloseWithError(ErrorCode, string) error
CloseWithError(ApplicationErrorCode, string) error
// The context is cancelled when the session is closed.
// Warning: This API should not be considered stable and might change soon.
Context() context.Context

2
mock_quic_session_test.go
View file

@ -67,7 +67,7 @@ func (mr *MockQuicSessionMockRecorder) AcceptUniStream(arg0 interface{}) *gomock
}
// CloseWithError mocks base method.
func (m *MockQuicSession) CloseWithError(arg0 ErrorCode, arg1 string) error {
func (m *MockQuicSession) CloseWithError(arg0 ApplicationErrorCode, arg1 string) error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "CloseWithError", arg0, arg1)
ret0, _ := ret[0].(error)

2
mock_receive_stream_internal_test.go
View file

@ -37,7 +37,7 @@ func (m *MockReceiveStreamI) EXPECT() *MockReceiveStreamIMockRecorder {
}
// CancelRead mocks base method.
func (m *MockReceiveStreamI) CancelRead(arg0 ErrorCode) {
func (m *MockReceiveStreamI) CancelRead(arg0 ApplicationErrorCode) {
m.ctrl.T.Helper()
m.ctrl.Call(m, "CancelRead", arg0)
}

2
mock_send_stream_internal_test.go
View file

@ -39,7 +39,7 @@ func (m *MockSendStreamI) EXPECT() *MockSendStreamIMockRecorder {
}
// CancelWrite mocks base method.
func (m *MockSendStreamI) CancelWrite(arg0 ErrorCode) {
func (m *MockSendStreamI) CancelWrite(arg0 ApplicationErrorCode) {
m.ctrl.T.Helper()
m.ctrl.Call(m, "CancelWrite", arg0)
}

4
mock_stream_internal_test.go
View file

@ -39,7 +39,7 @@ func (m *MockStreamI) EXPECT() *MockStreamIMockRecorder {
}
// CancelRead mocks base method.
func (m *MockStreamI) CancelRead(arg0 ErrorCode) {
func (m *MockStreamI) CancelRead(arg0 ApplicationErrorCode) {
m.ctrl.T.Helper()
m.ctrl.Call(m, "CancelRead", arg0)
}
@ -51,7 +51,7 @@ func (mr *MockStreamIMockRecorder) CancelRead(arg0 interface{}) *gomock.Call {
}
// CancelWrite mocks base method.
func (m *MockStreamI) CancelWrite(arg0 ErrorCode) {
func (m *MockStreamI) CancelWrite(arg0 ApplicationErrorCode) {
m.ctrl.T.Helper()
m.ctrl.Call(m, "CancelWrite", arg0)
}

2
session.go
View file

@ -1475,7 +1475,7 @@ func (s *session) shutdown() {
<-s.ctx.Done()
}
func (s *session) CloseWithError(code ErrorCode, desc string) error {
func (s *session) CloseWithError(code ApplicationErrorCode, desc string) error {
s.closeLocal(&qerr.ApplicationError{
ErrorCode: code,
ErrorMessage: desc,