Make HTTP/2 connection and stream windows configurable #2814

Author: Tratcher

src/Kestrel.Core/Http2Limits.cs

@@ -15,6 +15,8 @@ public class Http2Limits
         private int _headerTableSize = (int)Http2PeerSettings.DefaultHeaderTableSize;
         private int _maxFrameSize = (int)Http2PeerSettings.DefaultMaxFrameSize;
         private int _maxRequestHeaderFieldSize = 8192;
+        private int _initialConnectionWindowSize = 1024 * 128; // Larger than the default 64kb, and larger than any one single stream.
+        private int _initialStreamWindowSize = 1024 * 96; // Larger than the default 64kb
 
         /// <summary>
         /// Limits the number of concurrent request streams per HTTP/2 connection. Excess streams will be refused.
@@ -95,5 +97,49 @@ public int MaxRequestHeaderFieldSize
                 _maxRequestHeaderFieldSize = value;
             }
         }
+
+        /// <summary>
+        /// Indicates how much request body data the server is willing to receive and buffer at a time aggregated across all
+        /// requests (streams) per connection. Note requests are also limited by <see cref="InitialStreamWindowSize"/>
+        /// <para>
+        /// Value must be greater than or equal to 65,535 and less than 2^31, defaults to 128 kb.
+        /// </para>
+        /// </summary>
+        public int InitialConnectionWindowSize
+        {
+            get => _initialConnectionWindowSize;
+            set
+            {
+                if (value < Http2PeerSettings.DefaultInitialWindowSize || value > Http2PeerSettings.MaxWindowSize)
+                {
+                    throw new ArgumentOutOfRangeException(nameof(value), value,
+                        CoreStrings.FormatArgumentOutOfRange(Http2PeerSettings.DefaultInitialWindowSize, Http2PeerSettings.MaxWindowSize));
+                }
+
+                _initialConnectionWindowSize = value;
+            }
+        }
+
+        /// <summary>
+        /// Indicates how much request body data the server is willing to receive and buffer at a time per stream.
+        /// Note connections are also limited by <see cref="InitialConnectionWindowSize"/>
+        /// <para>
+        /// Value must be greater than or equal to 65,535 and less than 2^31, defaults to 96 kb.
+        /// </para>
+        /// </summary>
+        public int InitialStreamWindowSize
+        {
+            get => _initialStreamWindowSize;
+            set
+            {
+                if (value < Http2PeerSettings.DefaultInitialWindowSize || value > Http2PeerSettings.MaxWindowSize)
+                {
+                    throw new ArgumentOutOfRangeException(nameof(value), value,
+                        CoreStrings.FormatArgumentOutOfRange(Http2PeerSettings.DefaultInitialWindowSize, Http2PeerSettings.MaxWindowSize));
+                }
+
+                _initialStreamWindowSize = value;
+            }
+        }
     }
 }

src/Kestrel.Core/Internal/Http2/Http2Connection.cs

@@ -63,7 +63,7 @@ private enum PseudoHeaderFields
         private readonly Http2ConnectionContext _context;
         private readonly Http2FrameWriter _frameWriter;
         private readonly HPackDecoder _hpackDecoder;
-        private readonly InputFlowControl _inputFlowControl = new InputFlowControl(Http2PeerSettings.DefaultInitialWindowSize, Http2PeerSettings.DefaultInitialWindowSize / 2);
+        private readonly InputFlowControl _inputFlowControl;
         private readonly OutputFlowControl _outputFlowControl = new OutputFlowControl(Http2PeerSettings.DefaultInitialWindowSize);
 
         private readonly Http2PeerSettings _serverSettings = new Http2PeerSettings();
@@ -96,6 +96,9 @@ public Http2Connection(Http2ConnectionContext context)
             _serverSettings.HeaderTableSize = (uint)http2Limits.HeaderTableSize;
             _hpackDecoder = new HPackDecoder(http2Limits.HeaderTableSize, http2Limits.MaxRequestHeaderFieldSize);
             _serverSettings.MaxHeaderListSize = (uint)httpLimits.MaxRequestHeadersTotalSize;
+            _serverSettings.InitialWindowSize = (uint)http2Limits.InitialStreamWindowSize;
+            var connectionWindow = (uint)http2Limits.InitialConnectionWindowSize;
+            _inputFlowControl = new InputFlowControl(connectionWindow, connectionWindow / 2);
         }
 
         public string ConnectionId => _context.ConnectionId;
@@ -183,6 +186,14 @@ public async Task ProcessRequestsAsync<TContext>(IHttpApplication<TContext> appl
                 if (_state != Http2ConnectionState.Closed)
                 {
                     await _frameWriter.WriteSettingsAsync(_serverSettings.GetNonProtocolDefaults());
+                    // Inform the client that the connection window is larger than the default. It can't be lowered here,
+                    // It can only be lowered by not issuing window updates after data is received.
+                    var connectionWindow = _context.ServiceContext.ServerOptions.Limits.Http2.InitialConnectionWindowSize;
+                    var diff = connectionWindow - (int)Http2PeerSettings.DefaultInitialWindowSize;
+                    if (diff > 0)
+                    {
+                        await _frameWriter.WriteWindowUpdateAsync(0, diff);
+                    }
                 }
 
                 while (_state != Http2ConnectionState.Closed)
@@ -541,6 +552,7 @@ private Task ProcessHeadersFrameAsync<TContext>(IHttpApplication<TContext> appli
                     RemoteEndPoint = _context.RemoteEndPoint,
                     StreamLifetimeHandler = this,
                     ClientPeerSettings = _clientSettings,
+                    ServerPeerSettings = _serverSettings,
                     FrameWriter = _frameWriter,
                     ConnectionInputFlowControl = _inputFlowControl,
                     ConnectionOutputFlowControl = _outputFlowControl,

src/Kestrel.Core/Internal/Http2/Http2Stream.cs

@@ -36,13 +36,13 @@ public Http2Stream(Http2StreamContext context)
                 _context.StreamId,
                 _context.FrameWriter,
                 context.ConnectionInputFlowControl,
-                Http2PeerSettings.DefaultInitialWindowSize,
-                Http2PeerSettings.DefaultInitialWindowSize / 2);
+                _context.ServerPeerSettings.InitialWindowSize,
+                _context.ServerPeerSettings.InitialWindowSize / 2);
 
             _outputFlowControl = new StreamOutputFlowControl(context.ConnectionOutputFlowControl, context.ClientPeerSettings.InitialWindowSize);
             _http2Output = new Http2OutputProducer(context.StreamId, context.FrameWriter, _outputFlowControl, context.TimeoutControl, context.MemoryPool);
 
-            RequestBodyPipe = CreateRequestBodyPipe();
+            RequestBodyPipe = CreateRequestBodyPipe(_context.ServerPeerSettings.InitialWindowSize);
             Output = _http2Output;
         }
 
@@ -446,14 +446,16 @@ private void AbortCore(Exception abortReason)
             _inputFlowControl.Abort();
         }
 
-        private Pipe CreateRequestBodyPipe()
+        private Pipe CreateRequestBodyPipe(uint windowSize)
             => new Pipe(new PipeOptions
             (
                 pool: _context.MemoryPool,
                 readerScheduler: ServiceContext.Scheduler,
                 writerScheduler: PipeScheduler.Inline,
-                pauseWriterThreshold: Http2PeerSettings.DefaultInitialWindowSize,
-                resumeWriterThreshold: Http2PeerSettings.DefaultInitialWindowSize,
+                // Never pause within the window range. Flow control will prevent more data from being added.
+                // See the assert in OnDataAsync.
+                pauseWriterThreshold: windowSize + 1,
+                resumeWriterThreshold: windowSize + 1,
                 useSynchronizationContext: false,
                 minimumSegmentSize: KestrelMemoryPool.MinimumSegmentSize
             ));

src/Kestrel.Core/Internal/Http2/Http2StreamContext.cs

@@ -21,6 +21,7 @@ public class Http2StreamContext : IHttpProtocolContext
         public IPEndPoint LocalEndPoint { get; set; }
         public IHttp2StreamLifetimeHandler StreamLifetimeHandler { get; set; }
         public Http2PeerSettings ClientPeerSettings { get; set; }
+        public Http2PeerSettings ServerPeerSettings { get; set; }
         public Http2FrameWriter FrameWriter { get; set; }
         public InputFlowControl ConnectionInputFlowControl { get; set; }
         public OutputFlowControl ConnectionOutputFlowControl { get; set; }