expose a VersionNegoationError

errors.go

@@ -1,10 +1,16 @@
 package quic
 
-import "github.com/lucas-clemente/quic-go/internal/qerr"
+import (
+	"github.com/lucas-clemente/quic-go/internal/qerr"
+)
 
 type (
 	TransportError          = qerr.TransportError
 	ApplicationError        = qerr.ApplicationError
+	VersionNegotiationError = qerr.VersionNegotiationError
+)
+
+type (
 	TransportErrorCode   = qerr.TransportErrorCode
 	ApplicationErrorCode = qerr.ApplicationErrorCode
 )

integrationtests/self/mitm_test.go

@@ -371,7 +371,7 @@ var _ = Describe("MITM test", func() {
 					}
 					err := runTest(delayCb)
 					Expect(err).To(HaveOccurred())
-					Expect(err.Error()).To(ContainSubstring("no compatible QUIC version found"))
+					Expect(err).To(MatchError(&quic.VersionNegotiationError{}))
 				})
 
 				// times out, because client doesn't accept subsequent real retry packets from server

internal/qerr/quic_error.go

@@ -2,6 +2,8 @@ package qerr
 
 import (
 	"fmt"
+
+	"github.com/lucas-clemente/quic-go/internal/protocol"
 )
 
 var (
@@ -92,3 +94,18 @@ func (e *HandshakeTimeoutError) Is(target error) bool {
 	_, ok := target.(*HandshakeTimeoutError)
 	return ok
 }
+
+// A VersionNegotiationError occurs when the client and the server can't agree on a QUIC version.
+type VersionNegotiationError struct {
+	Ours   []protocol.VersionNumber
+	Theirs []protocol.VersionNumber
+}
+
+func (e *VersionNegotiationError) Error() string {
+	return fmt.Sprintf("no compatible QUIC version found (we support %s, server offered %s)", e.Ours, e.Theirs)
+}
+
+func (e *VersionNegotiationError) Is(target error) bool {
+	_, ok := target.(*VersionNegotiationError)
+	return ok
+}

internal/qerr/quic_error_test.go

@@ -4,6 +4,7 @@ import (
 	"errors"
 	"net"
 
+	"github.com/lucas-clemente/quic-go/internal/protocol"
 	. "github.com/onsi/ginkgo"
 	. "github.com/onsi/gomega"
 )
@@ -101,4 +102,17 @@ var _ = Describe("QUIC Errors", func() {
 			Expect(errors.Is(err, &IdleTimeoutError{})).To(BeTrue())
 		})
 	})
+
+	Context("Version Negotiation errors", func() {
+		It("is a Version Negotiation error", func() {
+			Expect(errors.Is(&VersionNegotiationError{Ours: []protocol.VersionNumber{2, 3}}, &VersionNegotiationError{})).To(BeTrue())
+		})
+
+		It("has a string representation", func() {
+			Expect((&VersionNegotiationError{
+				Ours:   []protocol.VersionNumber{2, 3},
+				Theirs: []protocol.VersionNumber{4, 5, 6},
+			}).Error()).To(Equal("no compatible QUIC version found (we support [0x2 0x3], server offered [0x4 0x5 0x6])"))
+		})
+	})
 })

session.go

@@ -132,20 +132,6 @@ func (e *errCloseForRecreating) Is(target error) bool {
 	return ok
 }
 
-type errVersionNegotiation struct {
-	ourVersions   []protocol.VersionNumber
-	theirVersions []protocol.VersionNumber
-}
-
-func (e *errVersionNegotiation) Error() string {
-	return fmt.Sprintf("no compatible QUIC version found (we support %s, server offered %s)", e.ourVersions, e.theirVersions)
-}
-
-func (e *errVersionNegotiation) Is(target error) bool {
-	_, ok := target.(*errVersionNegotiation)
-	return ok
-}
-
 var sessionTracingID uint64        // to be accessed atomically
 func nextSessionTracingID() uint64 { return atomic.AddUint64(&sessionTracingID, 1) }
 
@@ -1101,9 +1087,9 @@ func (s *session) handleVersionNegotiationPacket(p *receivedPacket) {
 	}
 	newVersion, ok := protocol.ChooseSupportedVersion(s.config.Versions, supportedVersions)
 	if !ok {
-		s.destroyImpl(&errVersionNegotiation{
-			ourVersions:   s.config.Versions,
-			theirVersions: supportedVersions,
+		s.destroyImpl(&VersionNegotiationError{
+			Ours:   s.config.Versions,
+			Theirs: supportedVersions,
 		})
 		s.logger.Infof("No compatible QUIC version found.")
 		return
@@ -1498,7 +1484,7 @@ func (s *session) handleCloseError(closeErr *closeError) {
 	case errors.Is(e, qerr.ErrIdleTimeout),
 		errors.Is(e, qerr.ErrHandshakeTimeout),
 		errors.Is(e, &statelessResetErr{}),
-		errors.Is(e, &errVersionNegotiation{}),
+		errors.Is(e, &VersionNegotiationError{}),
 		errors.Is(e, &errCloseForRecreating{}),
 		errors.Is(e, &qerr.ApplicationError{}),
 		errors.Is(e, &qerr.TransportError{}):
@@ -1518,7 +1504,7 @@ func (s *session) handleCloseError(closeErr *closeError) {
 	if s.tracer != nil && !errors.Is(e, &errCloseForRecreating{}) {
 		var (
 			resetErr       *statelessResetErr
-			vnErr          *errVersionNegotiation
+			vnErr          *VersionNegotiationError
 			transportErr   *qerr.TransportError
 			applicationErr *qerr.ApplicationError
 		)
@@ -1530,7 +1516,7 @@ func (s *session) handleCloseError(closeErr *closeError) {
 		case errors.As(e, &resetErr):
 			s.tracer.ClosedConnection(logging.NewStatelessResetCloseReason(resetErr.token))
 		case errors.As(e, &vnErr):
-			s.tracer.ClosedConnection(logging.NewVersionNegotiationError(vnErr.theirVersions))
+			s.tracer.ClosedConnection(logging.NewVersionNegotiationError(vnErr.Theirs))
 		case errors.As(e, &applicationErr):
 			s.tracer.ClosedConnection(logging.NewApplicationCloseReason(logging.ApplicationError(applicationErr.ErrorCode), closeErr.remote))
 		case errors.As(e, &transportErr):