cleanup

Author: John Luo

src/Kestrel.Core/Http2Limits.cs

@@ -12,7 +12,11 @@ namespace Microsoft.AspNetCore.Server.Kestrel.Core
     public class Http2Limits
     {
         private int _maxStreamsPerConnection = 100;
-        private int _maxFrameSize = Http2PeerSettings.MinAllowedMaxFrameSize;
+        private int _maxFrameSize = MinAllowedMaxFrameSize;
+
+        // These are limits defined by the RFC https://tools.ietf.org/html/rfc7540#section-4.2
+        public const int MinAllowedMaxFrameSize = 16 * 1024;
+        public const int MaxAllowedMaxFrameSize = 16 * 1024 * 1024 - 1;
 
         /// <summary>
         /// Limits the number of concurrent request streams per HTTP/2 connection. Excess streams will be refused.
@@ -44,9 +48,9 @@ public int MaxFrameSize
             get => _maxFrameSize;
             set
             {
-                if (value < Http2PeerSettings.MinAllowedMaxFrameSize || value > Http2PeerSettings.MaxAllowedMaxFrameSize)
+                if (value < MinAllowedMaxFrameSize || value > MaxAllowedMaxFrameSize)
                 {
-                    throw new ArgumentOutOfRangeException(nameof(value), value, CoreStrings.FormatArgumentOutOfRange(Http2PeerSettings.MinAllowedMaxFrameSize, Http2PeerSettings.MaxAllowedMaxFrameSize));
+                    throw new ArgumentOutOfRangeException(nameof(value), value, CoreStrings.FormatArgumentOutOfRange(MinAllowedMaxFrameSize, MaxAllowedMaxFrameSize));
                 }
                 _maxFrameSize = value;
             }

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

@@ -29,11 +29,6 @@ public partial class Http2Frame
         private readonly byte[] _data;
         private readonly uint _maxFrameSize;
 
-        // Internal for testing
-        internal Http2Frame()
-            : this(Http2PeerSettings.MinAllowedMaxFrameSize)
-        { }
-
         public Http2Frame(uint maxFrameSize)
         {
             _maxFrameSize = maxFrameSize;

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

@@ -21,7 +21,7 @@ public class Http2FrameWriter
         // Literal Header Field without Indexing - Indexed Name (Index 8 - :status)
         private static readonly byte[] _continueBytes = new byte[] { 0x08, 0x03, (byte)'1', (byte)'0', (byte)'0' };
 
-        private uint _maxFrameSize = Http2PeerSettings.MinAllowedMaxFrameSize;
+        private uint _maxFrameSize = Http2Limits.MinAllowedMaxFrameSize;
         private Http2Frame _outgoingFrame;
         private readonly object _writeLock = new object();
         private readonly HPackEncoder _hpackEncoder = new HPackEncoder();

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

@@ -12,13 +12,10 @@ public class Http2PeerSettings
         public const bool DefaultEnablePush = true;
         public const uint DefaultMaxConcurrentStreams = uint.MaxValue;
         public const uint DefaultInitialWindowSize = 65535;
-        public const uint DefaultMaxFrameSize = MinAllowedMaxFrameSize;
+        public const uint DefaultMaxFrameSize = Http2Limits.MinAllowedMaxFrameSize;
         public const uint DefaultMaxHeaderListSize = uint.MaxValue;
         public const uint MaxWindowSize = int.MaxValue;
 
-        public const int MinAllowedMaxFrameSize = 16 * 1024;
-        public const int MaxAllowedMaxFrameSize = 16 * 1024 * 1024 - 1;
-
         public uint HeaderTableSize { get; set; } = DefaultHeaderTableSize;
 
         public bool EnablePush { get; set; } = DefaultEnablePush;
@@ -67,11 +64,11 @@ public void Update(IList<Http2PeerSetting> settings)
                         InitialWindowSize = value;
                         break;
                     case Http2SettingsParameter.SETTINGS_MAX_FRAME_SIZE:
-                        if (value <  MinAllowedMaxFrameSize || value > MaxAllowedMaxFrameSize)
+                        if (value < Http2Limits.MinAllowedMaxFrameSize || value > Http2Limits.MaxAllowedMaxFrameSize)
                         {
                             throw new Http2SettingsParameterOutOfRangeException(Http2SettingsParameter.SETTINGS_MAX_FRAME_SIZE,
-                                lowerBound: MinAllowedMaxFrameSize,
-                                upperBound: MaxAllowedMaxFrameSize);
+                                lowerBound: Http2Limits.MinAllowedMaxFrameSize,
+                                upperBound: Http2Limits.MaxAllowedMaxFrameSize);
                         }
 
                         MaxFrameSize = value;

test/Kestrel.InMemory.FunctionalTests/Http2/Http2ConnectionTests.cs

@@ -77,28 +77,28 @@ public class Http2ConnectionTests : Http2TestBase
         private static readonly byte[] _worldBytes = Encoding.ASCII.GetBytes("world");
         private static readonly byte[] _helloWorldBytes = Encoding.ASCII.GetBytes("hello, world");
         private static readonly byte[] _noData = new byte[0];
-        private static readonly byte[] _maxData = Encoding.ASCII.GetBytes(new string('a', Http2PeerSettings.MinAllowedMaxFrameSize));
+        private static readonly byte[] _maxData = Encoding.ASCII.GetBytes(new string('a', Http2Limits.MinAllowedMaxFrameSize));
 
         [Fact]
         public async Task Frame_Received_OverMaxSize_FrameError()
         {
             await InitializeConnectionAsync(_echoApplication);
 
             await StartStreamAsync(1, _browserRequestHeaders, endStream: false);
-            uint length = Http2PeerSettings.MinAllowedMaxFrameSize + 1;
+            uint length = Http2Limits.MinAllowedMaxFrameSize + 1;
             await SendDataAsync(1, new byte[length].AsSpan(), endStream: true);
 
             await WaitForConnectionErrorAsync<Http2ConnectionErrorException>(
                 ignoreNonGoAwayFrames: true,
                 expectedLastStreamId: 1,
                 expectedErrorCode: Http2ErrorCode.FRAME_SIZE_ERROR,
-                expectedErrorMessage: CoreStrings.FormatHttp2ErrorFrameOverLimit(length, Http2PeerSettings.MinAllowedMaxFrameSize));
+                expectedErrorMessage: CoreStrings.FormatHttp2ErrorFrameOverLimit(length, Http2Limits.MinAllowedMaxFrameSize));
         }
 
         [Fact]
         public async Task ServerSettings_ChangesRequestMaxFrameSize()
         {
-            var length = Http2PeerSettings.MinAllowedMaxFrameSize + 10;
+            var length = Http2Limits.MinAllowedMaxFrameSize + 10;
             _connectionContext.ServiceContext.ServerOptions.Limits.Http2.MaxFrameSize = length;
             _connection = new Http2Connection(_connectionContext);
 
@@ -113,11 +113,11 @@ await ExpectAsync(Http2FrameType.HEADERS,
                 withStreamId: 1);
             // The client's settings is still defaulted to Http2PeerSettings.MinAllowedMaxFrameSize so the echo response will come back in two separate frames
             await ExpectAsync(Http2FrameType.DATA,
-                withLength: Http2PeerSettings.MinAllowedMaxFrameSize,
+                withLength: Http2Limits.MinAllowedMaxFrameSize,
                 withFlags: (byte)Http2DataFrameFlags.NONE,
                 withStreamId: 1);
             await ExpectAsync(Http2FrameType.DATA,
-                withLength: length - Http2PeerSettings.MinAllowedMaxFrameSize,
+                withLength: length - Http2Limits.MinAllowedMaxFrameSize,
                 withFlags: (byte)Http2DataFrameFlags.NONE,
                 withStreamId: 1);
             await ExpectAsync(Http2FrameType.DATA,
@@ -2069,7 +2069,7 @@ public async Task SETTINGS_ACK_Received_DoesNotSend_ACK()
         {
             await InitializeConnectionAsync(_noopApplication);
 
-            var frame = new Http2Frame();
+            var frame = new Http2Frame(Http2Limits.MinAllowedMaxFrameSize);
             frame.PrepareSettings(Http2SettingsFrameFlags.ACK);
             await SendAsync(frame.Raw);
 
@@ -2190,7 +2190,7 @@ await WaitForConnectionErrorAsync<Http2ConnectionErrorException>(
         [Fact]
         public async Task SETTINGS_Received_ChangesAllowedResponseMaxFrameSize()
         {
-            var length = Http2PeerSettings.MinAllowedMaxFrameSize + 10;
+            var length = Http2Limits.MinAllowedMaxFrameSize + 10;
             await InitializeConnectionAsync(context =>
             {
                 return context.Response.Body.WriteAsync(new byte[length], 0, length);