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);