HTTP2 Dynamic Window (prototype/early draft)

src/libraries/Common/src/Interop/Windows/WinSock/Interop.WSAIoctl.TcpInfo.cs

@@ -0,0 +1,55 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System;
+using System.Net.Sockets;
+using System.Runtime.InteropServices;
+
+internal static partial class Interop
+{
+    internal static partial class Winsock
+    {
+        private const int SioTcpInfo = unchecked((int)3623878695L);
+
+        [DllImport(Interop.Libraries.Ws2_32, SetLastError = true, EntryPoint = "WSAIoctl")]
+        private static extern SocketError WSAIoctl_Blocking(
+            SafeSocketHandle socketHandle,
+            [In] int ioControlCode,
+            [In] ref int inBuffer,
+            [In] int inBufferSize,
+            [Out] out _TCP_INFO_v0 outBuffer,
+            [In] int outBufferSize,
+            [Out] out int bytesTransferred,
+            [In] IntPtr overlapped,
+            [In] IntPtr completionRoutine);
+
+        internal static unsafe SocketError GetTcpInfoV0(SafeSocketHandle socketHandle, out _TCP_INFO_v0 tcpInfo)
+        {
+            int input = 0;
+            return WSAIoctl_Blocking(socketHandle, SioTcpInfo, ref input, sizeof(int), out tcpInfo, sizeof(_TCP_INFO_v0), out _, IntPtr.Zero, IntPtr.Zero);
+        }
+
+        internal struct _TCP_INFO_v0
+        {
+            internal System.Net.NetworkInformation.TcpState State;
+            internal uint Mss;
+            internal ulong ConnectionTimeMs;
+            internal byte TimestampsEnabled;
+            internal uint RttUs;
+            internal uint MinRttUs;
+            internal uint BytesInFlight;
+            internal uint Cwnd;
+            internal uint SndWnd;
+            internal uint RcvWnd;
+            internal uint RcvBuf;
+            internal ulong BytesOut;
+            internal ulong BytesIn;
+            internal uint BytesReordered;
+            internal uint BytesRetrans;
+            internal uint FastRetrans;
+            internal uint DupAcksIn;
+            internal uint TimeoutEpisodes;
+            internal byte SynRetrans;
+        }
+    }
+}

src/libraries/Common/src/System/Net/Http/HttpHandlerDefaults.cs

@@ -28,5 +28,7 @@ internal static partial class HttpHandlerDefaults
         public static readonly TimeSpan DefaultPooledConnectionIdleTimeout = TimeSpan.FromMinutes(1);
         public static readonly TimeSpan DefaultExpect100ContinueTimeout = TimeSpan.FromSeconds(1);
         public static readonly TimeSpan DefaultConnectTimeout = Timeout.InfiniteTimeSpan;
+        public const int DefaultHttp2MaxStreamWindowSize = 16 * 1024 * 1024;
+        public const double DefaultHttp2StreamWindowScaleThresholdMultiplier = 1.0;
     }
 }

src/libraries/Common/tests/System/Net/Http/Http2LoopbackConnection.cs

@@ -25,6 +25,8 @@ public class Http2LoopbackConnection : GenericLoopbackConnection
         private TaskCompletionSource<bool> _ignoredSettingsAckPromise;
         private bool _ignoreWindowUpdates;
         private TaskCompletionSource<PingFrame> _expectPingFrame;
+        private bool _autoProcessPingFrames;
+        private bool _respondToPing;
         private readonly TimeSpan _timeout;
         private int _lastStreamId;
 
@@ -200,9 +202,18 @@ private async Task<Frame> ReadFrameAsync(CancellationToken cancellationToken)
 
             if (_expectPingFrame != null && header.Type == FrameType.Ping)
             {
-                _expectPingFrame.SetResult(PingFrame.ReadFrom(header, data));
-                _expectPingFrame = null;
-                return await ReadFrameAsync(cancellationToken).ConfigureAwait(false);
+                PingFrame pingFrame = PingFrame.ReadFrom(header, data);
+
+                // _expectPingFrame is not intended to work with PING ACK:
+                if (!pingFrame.AckFlag)
+                {
+                    await ProcessExpectedPingFrame(pingFrame);
+                    return await ReadFrameAsync(cancellationToken).ConfigureAwait(false);
+                }
+                else
+                {
+                    return pingFrame;
+                }
             }
 
             // Construct the correct frame type and return it.
@@ -224,11 +235,30 @@ private async Task<Frame> ReadFrameAsync(CancellationToken cancellationToken)
                     return GoAwayFrame.ReadFrom(header, data);
                 case FrameType.Continuation:
                     return ContinuationFrame.ReadFrom(header, data);
+                case FrameType.WindowUpdate:
+                    return WindowUpdateFrame.ReadFrom(header, data);
                 default:
                     return header;
             }
         }
 
+        private async Task ProcessExpectedPingFrame(PingFrame pingFrame)
+        {
+            _expectPingFrame.SetResult(pingFrame);
+            if (_respondToPing && !pingFrame.AckFlag)
+            {
+                await SendPingAckAsync(pingFrame.Data);
+            }
+
+            _expectPingFrame = null;
+            _respondToPing = false;
+
+            if (_autoProcessPingFrames)
+            {
+                _ = ExpectPingFrameAsync(true);
+            }
+        }
+
         // Reset and return underlying networking objects.
         public (Socket, Stream) ResetNetwork()
         {
@@ -263,15 +293,32 @@ public void IgnoreWindowUpdates()
             _ignoreWindowUpdates = true;
         }
 
-        // Set up loopback server to expect PING frames among other frames.
+        // Set up loopback server to expect a (non-ACK) PING frame among other frames.
         // Once PING frame is read in ReadFrameAsync, the returned task is completed.
         // The returned task is canceled in ReadPingAsync if no PING frame has been read so far.
-        public Task<PingFrame> ExpectPingFrameAsync()
+        public Task<PingFrame> ExpectPingFrameAsync(bool respond = false)
         {
             _expectPingFrame ??= new TaskCompletionSource<PingFrame>();
+            _respondToPing = respond;
+
             return _expectPingFrame.Task;
         }
 
+        // Recurring variant of ExpectPingFrame().
+        // Starting from the time of the call, respond to all (non-ACK) PING frames which are received among other frames.
+        public void SetupAutomaticPingResponse()
+        {
+            _autoProcessPingFrames = true;
+            _ = ExpectPingFrameAsync(true);
+        }
+
+        // Tear down automatic PING responses, but still expect (at most one) PING in flight
+        public void TearDownAutomaticPingResponse()
+        {
+            _respondToPing = false;
+            _autoProcessPingFrames = false;
+        }
+
         public async Task ReadRstStreamAsync(int streamId)
         {
             Frame frame = await ReadFrameAsync(_timeout);
@@ -292,6 +339,14 @@ public async Task ReadRstStreamAsync(int streamId)
             }
         }
 
+        // Receive a single PING frame and respond with an ACK
+        public async Task RespondToPingFrameAsync()
+        {
+            PingFrame pingFrame = (PingFrame)await ReadFrameAsync(_timeout);
+            Assert.False(pingFrame.AckFlag, "Unexpected PING ACK");
+            await SendPingAckAsync(pingFrame.Data);
+        }
+
         // Wait for the client to close the connection, e.g. after the HttpClient is disposed.
         public async Task WaitForClientDisconnectAsync(bool ignoreUnexpectedFrames = false)
         {
@@ -720,9 +775,11 @@ public async Task PingPong()
             PingFrame ping = new PingFrame(pingData, FrameFlags.None, 0);
             await WriteFrameAsync(ping).ConfigureAwait(false);
             PingFrame pingAck = (PingFrame)await ReadFrameAsync(_timeout).ConfigureAwait(false);
+
             if (pingAck == null || pingAck.Type != FrameType.Ping || !pingAck.AckFlag)
             {
-                throw new Exception("Expected PING ACK");
+                string faultDetails = pingAck == null ? "" : $" frame.Type:{pingAck.Type} frame.AckFlag: {pingAck.AckFlag}";
+                throw new Exception("Expected PING ACK" + faultDetails);
             }
 
             Assert.Equal(pingData, pingAck.Data);
@@ -732,6 +789,7 @@ public async Task<PingFrame> ReadPingAsync(TimeSpan timeout)
         {
             _expectPingFrame?.TrySetCanceled();
             _expectPingFrame = null;
+            _respondToPing = false;
 
             Frame frame = await ReadFrameAsync(timeout).ConfigureAwait(false);
             Assert.NotNull(frame);

src/libraries/Common/tests/System/Net/Http/HttpClientHandlerTest.cs

@@ -1414,6 +1414,11 @@ await LoopbackServerFactory.CreateClientAndServerAsync(async uri =>
             {
                 await server.AcceptConnectionAsync(async connection =>
                 {
+                    if (connection is Http2LoopbackConnection http2Connection)
+                    {
+                        http2Connection.SetupAutomaticPingResponse(); // Handle RTT PING
+                    }
+
                     // Send unexpected 1xx responses.
                     HttpRequestData requestData = await connection.ReadRequestDataAsync(readBody: false);
                     await connection.SendResponseAsync(responseStatusCode, isFinal: false);
@@ -1463,6 +1468,10 @@ await LoopbackServerFactory.CreateClientAndServerAsync(async uri =>
                 await server.AcceptConnectionAsync(async connection =>
                 {
                     await connection.ReadRequestDataAsync(readBody: false);
+                    if (connection is Http2LoopbackConnection http2Connection)
+                    {
+                        http2Connection.SetupAutomaticPingResponse(); // Respond to RTT PING
+                    }
                     // Send multiple 100-Continue responses.
                     for (int count = 0 ; count < 4; count++)
                     {
@@ -1565,6 +1574,11 @@ await server.AcceptConnectionAsync(async connection =>
 
                     await connection.SendResponseAsync(HttpStatusCode.OK, headers: new HttpHeaderData[] {new HttpHeaderData("Content-Length", $"{ResponseString.Length}")}, isFinal : false);
 
+                    if (connection is Http2LoopbackConnection http2Connection)
+                    {
+                        http2Connection.SetupAutomaticPingResponse(); // Respond to RTT PING
+                    }
+
                     byte[] body = await connection.ReadRequestBodyAsync();
                     Assert.Equal(RequestString, Encoding.ASCII.GetString(body));
 

src/libraries/Common/tests/System/Net/Http/HttpClientHandlerTestBase.cs

@@ -50,6 +50,8 @@ protected static HttpClient CreateHttpClient(HttpMessageHandler handler, string
 #endif
             };
 
+        public const int DefaultInitialWindowSize = 65535;
+
         public static readonly bool[] BoolValues = new[] { true, false };
 
         // For use by remote server tests

src/libraries/System.Net.Http/ref/System.Net.Http.cs

@@ -353,7 +353,7 @@ protected override void SerializeToStream(System.IO.Stream stream, System.Net.Tr
     public sealed partial class SocketsHttpHandler : System.Net.Http.HttpMessageHandler
     {
         public SocketsHttpHandler() { }
-        [System.Runtime.Versioning.UnsupportedOSPlatformGuardAttribute("browser")]
+        public int InitialHttp2StreamWindowSize { get { throw null; } set { } }
         public static bool IsSupported { get { throw null; } }
         public bool AllowAutoRedirect { get { throw null; } set { } }
         public System.Net.DecompressionMethods AutomaticDecompression { get { throw null; } set { } }

src/libraries/System.Net.Http/src/Resources/Strings.resx

@@ -429,6 +429,9 @@
   <data name="net_http_http2_connection_not_established" xml:space="preserve">
     <value>An HTTP/2 connection could not be established because the server did not complete the HTTP/2 handshake.</value>
   </data>
+  <data name="net_http_http2_invalidinitialstreamwindowsize" xml:space="preserve">
+    <value>The initial HTTP/2 stream window size must be between {0} and {1}.</value>
+  </data>
   <data name="net_MethodNotImplementedException" xml:space="preserve">
     <value>This method is not implemented by this class.</value>
   </data>

src/libraries/System.Net.Http/src/System.Net.Http.csproj

@@ -1,4 +1,4 @@
-<Project Sdk="Microsoft.NET.Sdk">
+<Project Sdk="Microsoft.NET.Sdk">
   <PropertyGroup>
     <WindowsRID>win</WindowsRID>
     <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
@@ -62,6 +62,7 @@
     <Compile Include="System\Net\Http\ReadOnlyMemoryContent.cs" />
     <Compile Include="System\Net\Http\RequestRetryType.cs" />
     <Compile Include="System\Net\Http\SocketsHttpHandler\HttpMessageHandlerStage.cs" />
+    <Compile Include="System\Net\Http\SocketsHttpHandler\RuntimeSettingParser.cs" />
     <Compile Include="System\Net\Http\StreamContent.cs" />
     <Compile Include="System\Net\Http\StreamToStreamCopy.cs" />
     <Compile Include="System\Net\Http\StringContent.cs" />
@@ -160,6 +161,7 @@
     <Compile Include="System\Net\Http\SocketsHttpHandler\Http2ProtocolException.cs" />
     <Compile Include="System\Net\Http\SocketsHttpHandler\Http2Stream.cs" />
     <Compile Include="System\Net\Http\SocketsHttpHandler\Http2StreamException.cs" />
+    <Compile Include="System\Net\Http\SocketsHttpHandler\Http2StreamWindowManager.cs" />
     <Compile Include="System\Net\Http\SocketsHttpHandler\Http3Connection.cs" />
     <Compile Include="System\Net\Http\SocketsHttpHandler\Http3ConnectionException.cs" />
     <Compile Include="System\Net\Http\SocketsHttpHandler\Http3ProtocolException.cs" />
@@ -416,6 +418,8 @@
              Link="Common\Interop\Windows\WinHttp\Interop.winhttp_types.cs" />
     <Compile Include="$(CommonPath)\Interop\Windows\WinHttp\Interop.winhttp.cs"
              Link="Common\Interop\Windows\WinHttp\Interop.winhttp.cs" />
+    <Compile Include="$(CommonPath)\Interop\Windows\WinSock\Interop.WSAIoctl.TcpInfo.cs"
+             Link="Common\Interop\Windows\WinSock\Interop.WSAIoctl.TcpInfo.cs" />
     <Compile Include="$(CommonPath)\System\CharArrayHelpers.cs"
              Link="Common\System\CharArrayHelpers.cs" />
     <Compile Include="$(CommonPath)\System\StringExtensions.cs"

src/libraries/System.Net.Http/src/System/Net/Http/BrowserHttpHandler/SocketsHttpHandler.cs

@@ -25,6 +25,12 @@ public bool UseCookies
             set => throw new PlatformNotSupportedException();
         }
 
+        public int InitialHttp2StreamWindowSize
+        {
+            get => throw new PlatformNotSupportedException();
+            set => throw new PlatformNotSupportedException();
+        }
+
         [AllowNull]
         public CookieContainer CookieContainer
         {

src/libraries/System.Net.Http/src/System/Net/Http/DiagnosticsHandler.cs

@@ -276,25 +276,7 @@ private static class Settings
 
             public static readonly bool s_activityPropagationEnabled = GetEnableActivityPropagationValue();
 
-            private static bool GetEnableActivityPropagationValue()
-            {
-                // First check for the AppContext switch, giving it priority over the environment variable.
-                if (AppContext.TryGetSwitch(EnableActivityPropagationAppCtxSettingName, out bool enableActivityPropagation))
-                {
-                    return enableActivityPropagation;
-                }
-
-                // AppContext switch wasn't used. Check the environment variable to determine which handler should be used.
-                string? envVar = Environment.GetEnvironmentVariable(EnableActivityPropagationEnvironmentVariableSettingName);
-                if (envVar != null && (envVar.Equals("false", StringComparison.OrdinalIgnoreCase) || envVar.Equals("0")))
-                {
-                    // Suppress Activity propagation.
-                    return false;
-                }
-
-                // Defaults to enabling Activity propagation.
-                return true;
-            }
+            private static bool GetEnableActivityPropagationValue() => RuntimeSettingParser.QueryRuntimeSettingSwitch(EnableActivityPropagationAppCtxSettingName, EnableActivityPropagationEnvironmentVariableSettingName, true);
 
             public static readonly DiagnosticListener s_diagnosticListener =
                 new DiagnosticListener(DiagnosticsHandlerLoggingStrings.DiagnosticListenerName);