Make listening on IPv6Any accept IPv4 connections as well

Author: rzikm

src/libraries/System.Net.Http/tests/StressTests/HttpStress/StressServer.cs

@@ -83,16 +83,7 @@ public StressServer(Configuration configuration)
                     {
                         case "+":
                         case "*":
-                            // Workaround for a msquic bug: can't connect via IPv4 when listening on IPv6
-                            // https://github.com/microsoft/msquic/issues/2704
-                            if (configuration.HttpVersion == HttpVersion.Version30)
-                            {
-                                ko.Listen(IPAddress.Any, port, ConfigureListenOptions);
-                            }
-                            else
-                            {
-                                ko.ListenAnyIP(port, ConfigureListenOptions);
-                            }
+                            ko.ListenAnyIP(port, ConfigureListenOptions);
                             break;
                         default:
                             IPAddress iPAddress = Dns.GetHostAddresses(hostname).First();

src/libraries/System.Net.Quic/src/System/Net/Quic/Implementations/MsQuic/Internal/MsQuicAddressHelpers.cs

@@ -1,6 +1,11 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
+using System.Diagnostics;
+using System.Net.Sockets;
+using System.Runtime.InteropServices;
+using Microsoft.Quic;
+
 namespace System.Net.Quic.Implementations.MsQuic.Internal
 {
     internal static class MsQuicAddressHelpers
@@ -11,5 +16,18 @@ internal static unsafe IPEndPoint INetToIPEndPoint(IntPtr pInetAddress)
             Span<byte> addressBytes = new Span<byte>((byte*)pInetAddress, Internals.SocketAddress.IPv6AddressSize);
             return new Internals.SocketAddress(SocketAddressPal.GetAddressFamily(addressBytes), addressBytes).GetIPEndPoint();
         }
+
+        internal static unsafe QuicAddr ToQuicAddr(this IPEndPoint iPEndPoint)
+        {
+            // TODO: is the layout same for SocketAddress.Buffer and QuicAddr?
+            QuicAddr result = default;
+            Span<byte> rawAddress = MemoryMarshal.AsBytes(MemoryMarshal.CreateSpan(ref result, 1));
+
+            Internals.SocketAddress address = IPEndPointExtensions.Serialize(iPEndPoint);
+            Debug.Assert(address.Size <= rawAddress.Length);
+
+            address.Buffer.AsSpan(0, address.Size).CopyTo(rawAddress);
+            return result;
+        }
     }
 }

src/libraries/System.Net.Quic/src/System/Net/Quic/Implementations/MsQuic/Internal/MsQuicParameterHelpers.cs

@@ -4,12 +4,28 @@
 using System.Diagnostics;
 using System.Runtime.InteropServices;
 using System.Net.Sockets;
+using Microsoft.Quic;
 using static Microsoft.Quic.MsQuic;
 
 namespace System.Net.Quic.Implementations.MsQuic.Internal
 {
     internal static class MsQuicParameterHelpers
     {
+        internal static unsafe QuicAddr GetQuicAddrParam(MsQuicApi api, MsQuicSafeHandle nativeObject, uint param)
+        {
+            QuicAddr value = default;
+            uint valueLen = (uint)sizeof(QuicAddr);
+
+            ThrowIfFailure(api.ApiTable->GetParam(
+                nativeObject.QuicHandle,
+                param,
+                &valueLen,
+                (byte*)&value), "GetQuicAddrParam failed");
+            Debug.Assert(valueLen == sizeof(QuicAddr));
+
+            return value;
+        }
+
         internal static unsafe IPEndPoint GetIPEndPointParam(MsQuicApi api, MsQuicSafeHandle nativeObject, uint param)
         {
             // MsQuic always uses storage size as if IPv6 was used

src/libraries/System.Net.Quic/src/System/Net/Quic/Implementations/MsQuic/MsQuicListener.cs

@@ -2,6 +2,7 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 
 using System.Buffers;
+using System.Buffers.Binary;
 using System.Collections.Generic;
 using System.Collections.Concurrent;
 using System.Diagnostics;
@@ -12,7 +13,6 @@
 using System.Threading;
 using System.Threading.Channels;
 using System.Threading.Tasks;
-using System.Net.Sockets;
 using Microsoft.Quic;
 using System.Runtime.CompilerServices;
 using static Microsoft.Quic.MsQuic;
@@ -179,35 +179,41 @@ private unsafe IPEndPoint Start(QuicListenerOptions options)
             List<SslApplicationProtocol> applicationProtocols = options.ServerAuthenticationOptions!.ApplicationProtocols!;
             IPEndPoint listenEndPoint = options.ListenEndPoint!;
 
-            Internals.SocketAddress address = IPEndPointExtensions.Serialize(listenEndPoint);
-
             Debug.Assert(_stateHandle.IsAllocated);
             try
             {
                 Debug.Assert(!Monitor.IsEntered(_state), "!Monitor.IsEntered(_state)");
                 using var msquicBuffers = new MsQuicBuffers();
                 msquicBuffers.Initialize(applicationProtocols, applicationProtocol => applicationProtocol.Protocol);
-                // TODO: is the layout same for SocketAddress.Buffer and QuicAddr?
-                // TODO: maybe add simple extensions/helpers:
-                //       - QuicAddr ToQuicAddr(this IPEndPoint ipEndPoint)
-                //       - IPEndPoint ToIPEndPoint(this ref QuicAddr quicAddress)
-                fixed (byte* paddress = address.Buffer)
+
+                QuicAddr address = listenEndPoint.ToQuicAddr();
+
+                if (listenEndPoint.Address == IPAddress.IPv6Any)
                 {
-                    ThrowIfFailure(MsQuicApi.Api.ApiTable->ListenerStart(
-                        _state.Handle.QuicHandle,
-                        msquicBuffers.Buffers,
-                        (uint)applicationProtocols.Count,
-                        (QuicAddr*)paddress), "ListenerStart failed");
+                    // For IPv6Any, MsQuic would listen only for IPv6 connections. To mimic the behavior of TCP sockets,
+                    // we leave the address family unspecified and let MsQuic handle connections from all IP addresses.
+                    address.Family = QUIC_ADDRESS_FAMILY_UNSPEC;
                 }
+
+                ThrowIfFailure(MsQuicApi.Api.ApiTable->ListenerStart(
+                    _state.Handle.QuicHandle,
+                    msquicBuffers.Buffers,
+                    (uint)applicationProtocols.Count,
+                    &address), "ListenerStart failed");
             }
             catch
             {
                 _stateHandle.Free();
                 throw;
             }
 
+            // return the actual bound address, including a port. Since the address family may be Unspecified,
+            // we cannot use GetIPEndPointParam. We have to manually read the port from the raw QuicAddr structure.
+            // The actual address is unchanged.
             Debug.Assert(!Monitor.IsEntered(_state), "!Monitor.IsEntered(_state)");
-            return MsQuicParameterHelpers.GetIPEndPointParam(MsQuicApi.Api, _state.Handle, QUIC_PARAM_LISTENER_LOCAL_ADDRESS);
+            QuicAddr listenAddr = MsQuicParameterHelpers.GetQuicAddrParam(MsQuicApi.Api, _state.Handle, QUIC_PARAM_LISTENER_LOCAL_ADDRESS);
+            int port = BinaryPrimitives.ReadUInt16BigEndian(MemoryMarshal.AsBytes(MemoryMarshal.CreateSpan(ref listenAddr.Ipv4.sin_port, 1)));
+            return new IPEndPoint(listenEndPoint.Address, port);
         }
 
         private unsafe Task StopAsync()

src/libraries/System.Net.Quic/tests/FunctionalTests/QuicListenerTests.cs

@@ -41,6 +41,21 @@ await Task.Run(async () =>
                 await clientStreamTask;
             }).WaitAsync(TimeSpan.FromSeconds(6));
         }
+
+        [ConditionalFact(nameof(IsMsQuicProvider))]
+        public async Task Listener_IPv6Any_Accepts_IPv4()
+        {
+            await Task.Run(async () =>
+            {
+                using QuicListener listener = CreateQuicListener(new IPEndPoint(IPAddress.IPv6Any, 0));
+
+                using QuicConnection clientConnection = CreateQuicConnection(new IPEndPoint(IPAddress.Loopback, listener.ListenEndPoint.Port));
+                var clientStreamTask = clientConnection.ConnectAsync();
+
+                using QuicConnection serverConnection = await listener.AcceptConnectionAsync();
+                await clientStreamTask;
+            }).WaitAsync(TimeSpan.FromSeconds(6));
+        }
     }
 
     [ConditionalClass(typeof(QuicTestBase<MockProviderFactory>), nameof(QuicTestBase<MockProviderFactory>.IsSupported))]