Merge updated msquic API with datagram support

src/libraries/System.Net.Quic/src/System.Net.Quic.csproj

@@ -15,7 +15,7 @@
     <Compile Include="System\Net\Quic\Implementations\Mock\*.cs" />
     <Compile Include="System\Net\Quic\Implementations\MsQuic\*.cs" />
     <Compile Include="System\Net\Quic\Implementations\MsQuic\Internal\*.cs" />
-    <Compile Include="System\Net\Quic\Interop\*.cs" />
+    <Compile Include="System\Net\Quic\Implementations\MsQuic\Interop\*.cs" />
   </ItemGroup>
   <!-- System.Net common -->
   <ItemGroup Condition="'$(TargetsAnyOS)' != 'true'">

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

@@ -1,126 +1,81 @@
 // 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.Runtime.InteropServices;
 using static System.Net.Quic.Implementations.MsQuic.Internal.MsQuicNativeMethods;
 
 namespace System.Net.Quic.Implementations.MsQuic.Internal
 {
     internal static class MsQuicParameterHelpers
     {
-        internal static unsafe SOCKADDR_INET GetINetParam(MsQuicApi api, IntPtr nativeObject, uint level, uint param)
+        internal static unsafe SOCKADDR_INET GetINetParam(MsQuicApi api, SafeHandle nativeObject, uint level, uint param)
         {
-            byte* ptr = stackalloc byte[sizeof(SOCKADDR_INET)];
-            QuicBuffer buffer = new QuicBuffer
-            {
-                Length = (uint)sizeof(SOCKADDR_INET),
-                Buffer = ptr
-            };
+            SOCKADDR_INET value;
+            uint valueLen = (uint)sizeof(SOCKADDR_INET);
 
-            QuicExceptionHelpers.ThrowIfFailed(
-                api.UnsafeGetParam(nativeObject, level, param, ref buffer),
-                "Could not get SOCKADDR_INET.");
+            uint status = api.GetParamDelegate(nativeObject, level, param, ref valueLen, (byte*)&value);
+            QuicExceptionHelpers.ThrowIfFailed(status, "GetINETParam failed.");
+            Debug.Assert(valueLen == sizeof(SOCKADDR_INET));
 
-            return *(SOCKADDR_INET*)ptr;
+            return value;
         }
 
-        internal static unsafe ushort GetUShortParam(MsQuicApi api, IntPtr nativeObject, uint level, uint param)
+        internal static unsafe ushort GetUShortParam(MsQuicApi api, SafeHandle nativeObject, uint level, uint param)
         {
-            byte* ptr = stackalloc byte[sizeof(ushort)];
-            QuicBuffer buffer = new QuicBuffer()
-            {
-                Length = sizeof(ushort),
-                Buffer = ptr
-            };
+            ushort value;
+            uint valueLen = (uint)sizeof(ushort);
 
-            QuicExceptionHelpers.ThrowIfFailed(
-                api.UnsafeGetParam(nativeObject, level, param, ref buffer),
-                "Could not get ushort.");
+            uint status = api.GetParamDelegate(nativeObject, level, param, ref valueLen, (byte*)&value);
+            QuicExceptionHelpers.ThrowIfFailed(status, "GetUShortParam failed.");
+            Debug.Assert(valueLen == sizeof(ushort));
 
-            return *(ushort*)ptr;
+            return value;
         }
 
-        internal static unsafe void SetUshortParam(MsQuicApi api, IntPtr nativeObject, uint level, uint param, ushort value)
+        internal static unsafe void SetUshortParam(MsQuicApi api, SafeHandle nativeObject, uint level, uint param, ushort value)
         {
-            QuicBuffer buffer = new QuicBuffer()
-            {
-                Length = sizeof(ushort),
-                Buffer = (byte*)&value
-            };
-
             QuicExceptionHelpers.ThrowIfFailed(
-                api.UnsafeSetParam(nativeObject, level, param, buffer),
+                api.SetParamDelegate(nativeObject, level, param, sizeof(ushort), (byte*)&value),
                 "Could not set ushort.");
         }
 
-        internal static unsafe ulong GetULongParam(MsQuicApi api, IntPtr nativeObject, uint level, uint param)
+        internal static unsafe ulong GetULongParam(MsQuicApi api, SafeHandle nativeObject, uint level, uint param)
         {
-            byte* ptr = stackalloc byte[sizeof(ulong)];
-            QuicBuffer buffer = new QuicBuffer()
-            {
-                Length = sizeof(ulong),
-                Buffer = ptr
-            };
+            ulong value;
+            uint valueLen = (uint)sizeof(ulong);
 
-            QuicExceptionHelpers.ThrowIfFailed(
-                api.UnsafeGetParam(nativeObject, level, param, ref buffer),
-                "Could not get ulong.");
+            uint status = api.GetParamDelegate(nativeObject, level, param, ref valueLen, (byte*)&value);
+            QuicExceptionHelpers.ThrowIfFailed(status, "GetULongParam failed.");
+            Debug.Assert(valueLen == sizeof(ulong));
 
-            return *(ulong*)ptr;
+            return value;
         }
 
-        internal static unsafe void SetULongParam(MsQuicApi api, IntPtr nativeObject, uint level, uint param, ulong value)
+        internal static unsafe void SetULongParam(MsQuicApi api, SafeHandle nativeObject, uint level, uint param, ulong value)
         {
-            QuicBuffer buffer = new QuicBuffer()
-            {
-                Length = sizeof(ulong),
-                Buffer = (byte*)&value
-            };
-
             QuicExceptionHelpers.ThrowIfFailed(
-                api.UnsafeSetParam(nativeObject, level, param, buffer),
+                api.SetParamDelegate(nativeObject, level, param, sizeof(ulong), (byte*)&value),
                 "Could not set ulong.");
         }
 
-        internal static unsafe byte GetByteParam(MsQuicApi api, IntPtr nativeObject, uint level, uint param)
+        internal static unsafe byte GetByteParam(MsQuicApi api, SafeHandle nativeObject, uint level, uint param)
         {
-            byte* ptr = stackalloc byte[sizeof(byte)];
-            QuicBuffer buffer = new QuicBuffer()
-            {
-                Length = sizeof(byte),
-                Buffer = ptr
-            };
+            byte value;
+            uint valueLen = (uint)sizeof(byte);
 
-            QuicExceptionHelpers.ThrowIfFailed(
-                api.UnsafeGetParam(nativeObject, level, param, ref buffer),
-                "Could not get byte.");
+            uint status = api.GetParamDelegate(nativeObject, level, param, ref valueLen, &value);
+            QuicExceptionHelpers.ThrowIfFailed(status, "GetByteParam failed.");
+            Debug.Assert(valueLen == sizeof(byte));
 
-            return *ptr;
+            return value;
         }
 
-        internal static unsafe void SetByteParam(MsQuicApi api, IntPtr nativeObject, uint level, uint param, byte value)
+        internal static unsafe void SetByteParam(MsQuicApi api, SafeHandle nativeObject, uint level, uint param, byte value)
         {
-            QuicBuffer buffer = new QuicBuffer()
-            {
-                Length = sizeof(byte),
-                Buffer = &value
-            };
-
             QuicExceptionHelpers.ThrowIfFailed(
-                api.UnsafeSetParam(nativeObject, level, param, buffer),
-                "Could not set byte.");
-        }
-
-        internal static unsafe void SetSecurityConfig(MsQuicApi api, IntPtr nativeObject, uint level, uint param, IntPtr value)
-        {
-            QuicBuffer buffer = new QuicBuffer()
-            {
-                Length = (uint)sizeof(void*),
-                Buffer = (byte*)&value
-            };
-
-            QuicExceptionHelpers.ThrowIfFailed(
-                api.UnsafeSetParam(nativeObject, level, param, buffer),
-                "Could not set security configuration.");
+                api.SetParamDelegate(nativeObject, level, param, sizeof(byte), &value),
+                "Could not set ulong.");
         }
     }
 }