introduce an ECNCapablePacketConn interface to determine ECN support

client.go

@@ -109,6 +109,8 @@ func dialAddrContext(
 }
 
 // Dial establishes a new QUIC connection to a server using a net.PacketConn.
+// If the PacketConn satisfies the ECNCapablePacketConn interface (as a net.UDPConn does), ECN support will be enabled.
+// In this case, ReadMsgUDP will be used instead of ReadFrom to read packets.
 // The same PacketConn can be used for multiple calls to Dial and Listen,
 // QUIC connection IDs are used for demultiplexing the different connections.
 // The host parameter is used for SNI.

conn.go

@@ -3,11 +3,11 @@ package quic
 import (
 	"io"
 	"net"
+	"syscall"
 	"time"
 
-	"github.com/lucas-clemente/quic-go/internal/utils"
-
 	"github.com/lucas-clemente/quic-go/internal/protocol"
+	"github.com/lucas-clemente/quic-go/internal/utils"
 )
 
 type connection interface {
@@ -17,13 +17,23 @@ type connection interface {
 	io.Closer
 }
 
+// If the PacketConn passed to Dial or Listen satisfies this interface, quic-go will read the ECN bits from the IP header.
+// In this case, ReadMsgUDP() will be used instead of ReadFrom() to read packets.
+type ECNCapablePacketConn interface {
+	net.PacketConn
+	SyscallConn() (syscall.RawConn, error)
+	ReadMsgUDP(b, oob []byte) (n, oobn, flags int, addr *net.UDPAddr, err error)
+}
+
+var _ ECNCapablePacketConn = &net.UDPConn{}
+
 func wrapConn(pc net.PacketConn) (connection, error) {
-	udpConn, ok := pc.(*net.UDPConn)
+	c, ok := pc.(ECNCapablePacketConn)
 	if !ok {
 		utils.DefaultLogger.Infof("PacketConn is not a net.UDPConn. Disabling optimizations possible on UDP connections.")
 		return &basicConn{PacketConn: pc}, nil
 	}
-	return newConn(udpConn)
+	return newConn(c)
 }
 
 type basicConn struct {

conn_ecn.go

@@ -4,7 +4,6 @@ package quic
 
 import (
 	"errors"
-	"net"
 	"syscall"
 	"time"
 
@@ -15,13 +14,13 @@ import (
 const ecnMask uint8 = 0x3
 
 type ecnConn struct {
-	*net.UDPConn
+	ECNCapablePacketConn
 	oobBuffer []byte
 }
 
 var _ connection = &ecnConn{}
 
-func newConn(c *net.UDPConn) (*ecnConn, error) {
+func newConn(c ECNCapablePacketConn) (*ecnConn, error) {
 	rawConn, err := c.SyscallConn()
 	if err != nil {
 		return nil, err
@@ -51,8 +50,8 @@ func newConn(c *net.UDPConn) (*ecnConn, error) {
 		return nil, errors.New("activating ECN failed for both IPv4 and IPv6")
 	}
 	return &ecnConn{
-		UDPConn:   c,
-		oobBuffer: make([]byte, 128),
+		ECNCapablePacketConn: c,
+		oobBuffer:            make([]byte, 128),
 	}, nil
 }
 
@@ -62,7 +61,7 @@ func (c *ecnConn) ReadPacket() (*receivedPacket, error) {
 	// If it does, we only read a truncated packet, which will then end up undecryptable
 	buffer.Data = buffer.Data[:protocol.MaxReceivePacketSize]
 	c.oobBuffer = c.oobBuffer[:cap(c.oobBuffer)]
-	n, oobn, _, addr, err := c.UDPConn.ReadMsgUDP(buffer.Data, c.oobBuffer)
+	n, oobn, _, addr, err := c.ECNCapablePacketConn.ReadMsgUDP(buffer.Data, c.oobBuffer)
 	if err != nil {
 		return nil, err
 	}

conn_windows.go

@@ -4,6 +4,6 @@ package quic
 
 import "net"
 
-func newConn(c *net.UDPConn) (connection, error) {
+func newConn(c net.PacketConn) (connection, error) {
 	return &basicConn{PacketConn: c}, nil
 }

server.go

@@ -148,6 +148,8 @@ func listenAddr(addr string, tlsConf *tls.Config, config *Config, acceptEarly bo
 }
 
 // Listen listens for QUIC connections on a given net.PacketConn.
+// If the PacketConn satisfies the ECNCapablePacketConn interface (as a net.UDPConn does), ECN support will be enabled.
+// In this case, ReadMsgUDP will be used instead of ReadFrom to read packets.
 // A single net.PacketConn only be used for a single call to Listen.
 // The PacketConn can be used for simultaneous calls to Dial.
 // QUIC connection IDs are used for demultiplexing the different connections.