sendQueue: ignore "datagram too large" error

This commit introduces additional platform-dependent checking when the
kernel returns an error. Previously, the session is terminated when
PingFrame sends a discovery packet larger than the limit. With this
commit, the error is checked, and if it is "datagram too large", the
error is ignored.

Additionally, this commit re-enables MTU discovery on Windows unless it
is disabled explicitly by user.

Fixes quic-go#3273 quic-go#3327

conn_windows.go

@@ -13,7 +13,7 @@ import (
 )
 
 const (
-	disablePathMTUDiscovery = true
+	disablePathMTUDiscovery = false
 	IP_DONTFRAGMENT         = 14
 )
 

err_size.go

@@ -0,0 +1,18 @@
+package quic
+
+import (
+	"net"
+	"os"
+	"syscall"
+)
+
+func isMsgSizeErr(err error) bool {
+	if opErr, ok := err.(*net.OpError); ok {
+		if syscallErr, ok := opErr.Err.(*os.SyscallError); ok {
+			if syscallErrno, ok := syscallErr.Err.(syscall.Errno); ok {
+				return assertErrorMsgSize(syscallErrno)
+			}
+		}
+	}
+	return false
+}

err_size_generic.go

@@ -0,0 +1,11 @@
+//go:build !unix && !windows
+// +build !unix,!windows
+
+package quic
+
+import "syscall"
+
+func assertErrorMsgSize(e syscall.Errno) bool {
+	// to be implemented for more specific platforms
+	return false
+}

err_size_unix.go

@@ -0,0 +1,16 @@
+//go:build unix
+// +build unix
+
+package quic
+
+import (
+	"errors"
+	"syscall"
+
+	"golang.org/x/sys/unix"
+)
+
+func assertErrorMsgSize(e syscall.Errno) bool {
+	// https://man7.org/linux/man-pages/man7/udp.7.html
+	return errors.Is(e, unix.EMSGSIZE)
+}

err_size_windows.go

@@ -0,0 +1,16 @@
+//go:build windows
+// +build windows
+
+package quic
+
+import (
+	"errors"
+	"syscall"
+
+	"golang.org/x/sys/windows"
+)
+
+func assertErrorMsgSize(e syscall.Errno) bool {
+	// https://docs.microsoft.com/en-us/troubleshoot/windows-server/networking/wsaemsgsize-error-10040-in-winsock-2
+	return errors.Is(e, windows.WSAEMSGSIZE)
+}

send_queue.go

@@ -64,7 +64,9 @@ func (h *sendQueue) Run() error {
 			shouldClose = true
 		case p := <-h.queue:
 			if err := h.conn.Write(p.Data); err != nil {
-				return err
+				if !isMsgSizeErr(err) {
+					return err
+				}
 			}
 			p.Release()
 			select {

session_test.go

@@ -9,7 +9,6 @@ import (
 	"fmt"
 	"io"
 	"net"
-	"runtime"
 	"runtime/pprof"
 	"strings"
 	"time"
@@ -1682,35 +1681,33 @@ var _ = Describe("Session", func() {
 			time.Sleep(50 * time.Millisecond)
 		})
 
-		if runtime.GOOS != "windows" { // Path MTU Discovery is disabled on Windows
-			It("sends a Path MTU probe packet", func() {
-				mtuDiscoverer := NewMockMtuDiscoverer(mockCtrl)
-				sess.mtuDiscoverer = mtuDiscoverer
-				sess.config.DisablePathMTUDiscovery = false
-				sph.EXPECT().SentPacket(gomock.Any())
-				sph.EXPECT().HasPacingBudget().Return(true).AnyTimes()
-				sph.EXPECT().SendMode().Return(ackhandler.SendAny)
-				sph.EXPECT().SendMode().Return(ackhandler.SendNone)
-				written := make(chan struct{}, 1)
-				sender.EXPECT().WouldBlock().AnyTimes()
-				sender.EXPECT().Send(gomock.Any()).DoAndReturn(func(p *packetBuffer) { written <- struct{}{} })
-				gomock.InOrder(
-					mtuDiscoverer.EXPECT().NextProbeTime(),
-					mtuDiscoverer.EXPECT().ShouldSendProbe(gomock.Any()).Return(true),
-					mtuDiscoverer.EXPECT().NextProbeTime(),
-				)
-				ping := ackhandler.Frame{Frame: &wire.PingFrame{}}
-				mtuDiscoverer.EXPECT().GetPing().Return(ping, protocol.ByteCount(1234))
-				packer.EXPECT().PackMTUProbePacket(ping, protocol.ByteCount(1234)).Return(getPacket(1), nil)
-				go func() {
-					defer GinkgoRecover()
-					cryptoSetup.EXPECT().RunHandshake().MaxTimes(1)
-					sess.run()
-				}()
-				sess.scheduleSending()
-				Eventually(written).Should(Receive())
-			})
-		}
+		It("sends a Path MTU probe packet", func() {
+			mtuDiscoverer := NewMockMtuDiscoverer(mockCtrl)
+			sess.mtuDiscoverer = mtuDiscoverer
+			sess.config.DisablePathMTUDiscovery = false
+			sph.EXPECT().SentPacket(gomock.Any())
+			sph.EXPECT().HasPacingBudget().Return(true).AnyTimes()
+			sph.EXPECT().SendMode().Return(ackhandler.SendAny)
+			sph.EXPECT().SendMode().Return(ackhandler.SendNone)
+			written := make(chan struct{}, 1)
+			sender.EXPECT().WouldBlock().AnyTimes()
+			sender.EXPECT().Send(gomock.Any()).DoAndReturn(func(p *packetBuffer) { written <- struct{}{} })
+			gomock.InOrder(
+				mtuDiscoverer.EXPECT().NextProbeTime(),
+				mtuDiscoverer.EXPECT().ShouldSendProbe(gomock.Any()).Return(true),
+				mtuDiscoverer.EXPECT().NextProbeTime(),
+			)
+			ping := ackhandler.Frame{Frame: &wire.PingFrame{}}
+			mtuDiscoverer.EXPECT().GetPing().Return(ping, protocol.ByteCount(1234))
+			packer.EXPECT().PackMTUProbePacket(ping, protocol.ByteCount(1234)).Return(getPacket(1), nil)
+			go func() {
+				defer GinkgoRecover()
+				cryptoSetup.EXPECT().RunHandshake().MaxTimes(1)
+				sess.run()
+			}()
+			sess.scheduleSending()
+			Eventually(written).Should(Receive())
+		})
 	})
 
 	Context("scheduling sending", func() {