HTTP/3: Use max field section size setting

JamesNK · JamesNK · commit a53e63d52e52 · 2021-06-17T18:11:19.000+12:00
diff --git a/src/Servers/Kestrel/Core/src/Http3Limits.cs b/src/Servers/Kestrel/Core/src/Http3Limits.cs
@@ -11,7 +11,6 @@ namespace Microsoft.AspNetCore.Server.Kestrel.Core
     public class Http3Limits
     {
         private int _headerTableSize;
-        private int _maxRequestHeaderFieldSize = 8192;
 
         /// <summary>
         /// Limits the size of the header compression table, in octets, the QPACK decoder on the server can use.
@@ -33,25 +32,5 @@ internal int HeaderTableSize
                 _headerTableSize = value;
             }
         }
-
-        /// <summary>
-        /// Indicates the size of the maximum allowed size of a request header field sequence. This limit applies to both name and value sequences in their compressed and uncompressed representations.
-        /// <para>
-        /// Value must be greater than 0, defaults to 8192
-        /// </para>
-        /// </summary>
-        public int MaxRequestHeaderFieldSize
-        {
-            get => _maxRequestHeaderFieldSize;
-            set
-            {
-                if (value <= 0)
-                {
-                    throw new ArgumentOutOfRangeException(nameof(value), value, CoreStrings.GreaterThanZeroRequired);
-                }
-
-                _maxRequestHeaderFieldSize = value;
-            }
-        }
     }
 }
diff --git a/src/Servers/Kestrel/Core/src/Internal/Http3/Http3Connection.cs b/src/Servers/Kestrel/Core/src/Internal/Http3/Http3Connection.cs
@@ -39,6 +39,7 @@ internal class Http3Connection : IHttp3StreamLifetimeHandler, IRequestProcessor
         private int _activeRequestCount;
 
         private readonly Http3PeerSettings _serverSettings = new Http3PeerSettings();
+        private readonly Http3PeerSettings _clientSettings = new Http3PeerSettings();
         private readonly StreamCloseAwaitable _streamCompletionAwaitable = new StreamCloseAwaitable();
         private readonly IProtocolErrorCodeFeature _errorCodeFeature;
 
@@ -53,7 +54,7 @@ public Http3Connection(HttpMultiplexedConnectionContext context)
             var httpLimits = context.ServiceContext.ServerOptions.Limits;
 
             _serverSettings.HeaderTableSize = (uint)httpLimits.Http3.HeaderTableSize;
-            _serverSettings.MaxRequestHeaderFieldSize = (uint)httpLimits.Http3.MaxRequestHeaderFieldSize;
+            _serverSettings.MaxRequestHeaderFieldSectionSize = (uint)httpLimits.MaxRequestHeadersTotalSize;
         }
 
         private void UpdateHighestStreamId(long streamId)
@@ -260,6 +261,7 @@ public async Task ProcessRequestsAsync<TContext>(IHttpApplication<TContext> appl
                             streamContext.Transport,
                             _streamLifetimeHandler,
                             streamContext,
+                            _clientSettings,
                             _serverSettings);
                         httpConnectionContext.TimeoutControl = _context.TimeoutControl;
 
@@ -423,6 +425,7 @@ private async ValueTask<Http3ControlStream> CreateNewUnidirectionalStreamAsync<T
                 streamContext.Transport,
                 _streamLifetimeHandler,
                 streamContext,
+                _clientSettings,
                 _serverSettings);
             httpConnectionContext.TimeoutControl = _context.TimeoutControl;
 
@@ -522,6 +525,7 @@ void IHttp3StreamLifetimeHandler.OnInboundControlStreamSetting(Http3SettingType
                 case Http3SettingType.QPackMaxTableCapacity:
                     break;
                 case Http3SettingType.MaxFieldSectionSize:
+                    _clientSettings.MaxRequestHeaderFieldSectionSize = (uint)value;
                     break;
                 case Http3SettingType.QPackBlockedStreams:
                     break;
diff --git a/src/Servers/Kestrel/Core/src/Internal/Http3/Http3ControlStream.cs b/src/Servers/Kestrel/Core/src/Internal/Http3/Http3ControlStream.cs
@@ -42,7 +42,7 @@ public Http3ControlStream(Http3StreamContext context)
         {
             var httpLimits = context.ServiceContext.ServerOptions.Limits;
             _context = context;
-            _serverPeerSettings = context.ServerSettings;
+            _serverPeerSettings = context.ServerPeerSettings;
             _streamIdFeature = context.ConnectionFeatures.Get<IStreamIdFeature>()!;
             _errorCodeFeature = context.ConnectionFeatures.Get<IProtocolErrorCodeFeature>()!;
             _headerType = -1;
@@ -55,7 +55,9 @@ public Http3ControlStream(Http3StreamContext context)
                 context.ConnectionId,
                 context.MemoryPool,
                 context.ServiceContext.Log,
-                _streamIdFeature);
+                _streamIdFeature,
+                context.ClientPeerSettings,
+                this);
         }
 
         private void OnStreamClosed()
@@ -295,15 +297,15 @@ private ValueTask ProcessSettingsFrameAsync(ReadOnlySequence<byte> payload)
 
             while (true)
             {
-                var id = VariableLengthIntegerHelper.GetInteger(payload, out var consumed, out var examinded);
+                var id = VariableLengthIntegerHelper.GetInteger(payload, out var consumed, out _);
                 if (id == -1)
                 {
                     break;
                 }
 
                 payload = payload.Slice(consumed);
 
-                var value = VariableLengthIntegerHelper.GetInteger(payload, out consumed, out examinded);
+                var value = VariableLengthIntegerHelper.GetInteger(payload, out consumed, out _);
                 if (id == -1)
                 {
                     break;
diff --git a/src/Servers/Kestrel/Core/src/Internal/Http3/Http3FrameWriter.cs b/src/Servers/Kestrel/Core/src/Internal/Http3/Http3FrameWriter.cs
@@ -22,7 +22,7 @@ namespace Microsoft.AspNetCore.Server.Kestrel.Core.Internal.Http3
     internal class Http3FrameWriter
     {
         private readonly object _writeLock = new object();
-        private readonly QPackEncoder _qpackEncoder = new QPackEncoder();
+        private readonly QPackEncoder _qpackEncoder;
 
         private readonly PipeWriter _outputWriter;
         private readonly ConnectionContext _connectionContext;
@@ -32,6 +32,7 @@ internal class Http3FrameWriter
         private readonly MemoryPool<byte> _memoryPool;
         private readonly IKestrelTrace _log;
         private readonly IStreamIdFeature _streamIdFeature;
+        private readonly IHttp3Stream _http3Stream;
         private readonly Http3RawFrame _outgoingFrame;
         private readonly TimingPipeFlusher _flusher;
 
@@ -45,7 +46,7 @@ internal class Http3FrameWriter
 
         //private int _unflushedBytes;
 
-        public Http3FrameWriter(PipeWriter output, ConnectionContext connectionContext, ITimeoutControl timeoutControl, MinDataRate? minResponseDataRate, string connectionId, MemoryPool<byte> memoryPool, IKestrelTrace log, IStreamIdFeature streamIdFeature)
+        public Http3FrameWriter(PipeWriter output, ConnectionContext connectionContext, ITimeoutControl timeoutControl, MinDataRate? minResponseDataRate, string connectionId, MemoryPool<byte> memoryPool, IKestrelTrace log, IStreamIdFeature streamIdFeature, Http3PeerSettings clientPeerSettings, IHttp3Stream http3Stream)
         {
             _outputWriter = output;
             _connectionContext = connectionContext;
@@ -55,9 +56,16 @@ public Http3FrameWriter(PipeWriter output, ConnectionContext connectionContext,
             _memoryPool = memoryPool;
             _log = log;
             _streamIdFeature = streamIdFeature;
+            _http3Stream = http3Stream;
             _outgoingFrame = new Http3RawFrame();
             _flusher = new TimingPipeFlusher(_outputWriter, timeoutControl, log);
             _headerEncodingBuffer = new byte[_maxFrameSize];
+            _qpackEncoder = new QPackEncoder();
+
+            // TODO(JamesNK): QPack encoder doesn't react to settings change during a stream
+            _qpackEncoder.MaxTotalHeaderSize = clientPeerSettings.MaxRequestHeaderFieldSectionSize > int.MaxValue
+                ? int.MaxValue
+                : (int)clientPeerSettings.MaxRequestHeaderFieldSectionSize;
         }
 
         public void UpdateMaxFrameSize(uint maxFrameSize)
@@ -273,10 +281,10 @@ public ValueTask<FlushResult> WriteResponseTrailers(HttpResponseTrailers headers
                     var done = _qpackEncoder.BeginEncode(EnumerateHeaders(headers), buffer, out var payloadLength);
                     FinishWritingHeaders(payloadLength, done);
                 }
-                catch (QPackEncodingException)
+                catch (QPackEncodingException ex)
                 {
                     //_log.HPackEncodingError(_connectionId, streamId, hex);
-                    //_http3Stream.Abort(new ConnectionAbortedException(hex.Message, hex));
+                    _http3Stream.Abort(new ConnectionAbortedException(ex.Message, ex), Http3ErrorCode.InternalError);
                 }
 
                 return TimeFlushUnsynchronizedAsync();
@@ -323,11 +331,10 @@ internal void WriteResponseHeaders(int statusCode, IHeaderDictionary headers)
                     var done = _qpackEncoder.BeginEncode(statusCode, EnumerateHeaders(headers), buffer, out var payloadLength);
                     FinishWritingHeaders(payloadLength, done);
                 }
-                catch (QPackEncodingException hex)
+                catch (QPackEncodingException ex)
                 {
-                    // TODO figure out how to abort the stream here.
-                    //_http3Stream.Abort(new ConnectionAbortedException(hex.Message, hex));
-                    throw new InvalidOperationException(hex.Message, hex); // Report the error to the user if this was the first write.
+                    _http3Stream.Abort(new ConnectionAbortedException(ex.Message, ex), Http3ErrorCode.InternalError);
+                    throw new InvalidOperationException(ex.Message, ex); // Report the error to the user if this was the first write.
                 }
             }
         }
diff --git a/src/Servers/Kestrel/Core/src/Internal/Http3/Http3PeerSettings.cs b/src/Servers/Kestrel/Core/src/Internal/Http3/Http3PeerSettings.cs
@@ -12,7 +12,7 @@ internal class Http3PeerSettings
         public const uint DefaultMaxRequestHeaderFieldSize = uint.MaxValue;
 
         public uint HeaderTableSize { get; internal set; } = DefaultHeaderTableSize;
-        public uint MaxRequestHeaderFieldSize { get; internal set; } = DefaultMaxRequestHeaderFieldSize;
+        public uint MaxRequestHeaderFieldSectionSize { get; internal set; } = DefaultMaxRequestHeaderFieldSize;
 
         // Gets the settings that are different from the protocol defaults (as opposed to the server defaults).
         internal List<Http3PeerSetting> GetNonProtocolDefaults()
@@ -26,9 +26,9 @@ internal List<Http3PeerSetting> GetNonProtocolDefaults()
                 list.Add(new Http3PeerSetting(Http3SettingType.QPackMaxTableCapacity, HeaderTableSize));
             }
 
-            if (MaxRequestHeaderFieldSize != DefaultMaxRequestHeaderFieldSize)
+            if (MaxRequestHeaderFieldSectionSize != DefaultMaxRequestHeaderFieldSize)
             {
-                list.Add(new Http3PeerSetting(Http3SettingType.MaxFieldSectionSize, MaxRequestHeaderFieldSize));
+                list.Add(new Http3PeerSetting(Http3SettingType.MaxFieldSectionSize, MaxRequestHeaderFieldSectionSize));
             }
 
             return list;
diff --git a/src/Servers/Kestrel/Core/src/Internal/Http3/Http3Stream.cs b/src/Servers/Kestrel/Core/src/Internal/Http3/Http3Stream.cs
@@ -71,7 +71,9 @@ public Http3Stream(Http3StreamContext context)
                 context.ConnectionId,
                 context.MemoryPool,
                 context.ServiceContext.Log,
-                _streamIdFeature);
+                _streamIdFeature,
+                context.ClientPeerSettings,
+                this);
 
             // ResponseHeaders aren't set, kind of ugly that we need to reset.
             Reset();
@@ -83,7 +85,11 @@ public Http3Stream(Http3StreamContext context)
                 context.ServiceContext.Log);
             RequestBodyPipe = CreateRequestBodyPipe(64 * 1024); // windowSize?
             Output = _http3Output;
-            QPackDecoder = new QPackDecoder(_context.ServiceContext.ServerOptions.Limits.Http3.MaxRequestHeaderFieldSize);
+
+            // TODO(JamesNK): What is the purpose of max header length and why measure in QPackDecoder?
+            // I think the meaning of SETTINGS_MAX_FIELD_SECTION_SIZE may have been misunderstood to apply per
+            // header rather than all headers that make up the section.
+            QPackDecoder = new QPackDecoder(int.MaxValue);
         }
 
         public long? InputRemaining { get; internal set; }
diff --git a/src/Servers/Kestrel/Core/src/Internal/Http3StreamContext.cs b/src/Servers/Kestrel/Core/src/Internal/Http3StreamContext.cs
@@ -24,15 +24,18 @@ public Http3StreamContext(
             IDuplexPipe transport,
             IHttp3StreamLifetimeHandler streamLifetimeHandler,
             ConnectionContext streamContext,
-            Http3PeerSettings settings) : base(connectionId, protocols, connectionContext, serviceContext, connectionFeatures, memoryPool, localEndPoint, remoteEndPoint, transport)
+            Http3PeerSettings clientPeerSettings,
+            Http3PeerSettings serverPeerSettings) : base(connectionId, protocols, connectionContext, serviceContext, connectionFeatures, memoryPool, localEndPoint, remoteEndPoint, transport)
         {
             StreamLifetimeHandler = streamLifetimeHandler;
             StreamContext = streamContext;
-            ServerSettings = settings;
+            ClientPeerSettings = clientPeerSettings;
+            ServerPeerSettings = serverPeerSettings;
         }
 
         public IHttp3StreamLifetimeHandler StreamLifetimeHandler { get; }
         public ConnectionContext StreamContext { get; }
-        public Http3PeerSettings ServerSettings { get; }
+        public Http3PeerSettings ClientPeerSettings { get; }
+        public Http3PeerSettings ServerPeerSettings { get; }
     }
 }
diff --git a/src/Servers/Kestrel/Core/src/PublicAPI.Unshipped.txt b/src/Servers/Kestrel/Core/src/PublicAPI.Unshipped.txt
@@ -95,6 +95,8 @@
 *REMOVED*~static Microsoft.AspNetCore.Hosting.ListenOptionsHttpsExtensions.UseHttps(this Microsoft.AspNetCore.Server.Kestrel.Core.ListenOptions listenOptions, string fileName, string password) -> Microsoft.AspNetCore.Server.Kestrel.Core.ListenOptions
 *REMOVED*~static Microsoft.AspNetCore.Hosting.ListenOptionsHttpsExtensions.UseHttps(this Microsoft.AspNetCore.Server.Kestrel.Core.ListenOptions listenOptions, string fileName, string password, System.Action<Microsoft.AspNetCore.Server.Kestrel.Https.HttpsConnectionAdapterOptions> configureOptions) -> Microsoft.AspNetCore.Server.Kestrel.Core.ListenOptions
 *REMOVED*~static Microsoft.AspNetCore.Server.Kestrel.Https.CertificateLoader.LoadFromStoreCert(string subject, string storeName, System.Security.Cryptography.X509Certificates.StoreLocation storeLocation, bool allowInvalid) -> System.Security.Cryptography.X509Certificates.X509Certificate2
+*REMOVED*Microsoft.AspNetCore.Server.Kestrel.Core.Http3Limits.MaxRequestHeaderFieldSize.get -> int
+*REMOVED*Microsoft.AspNetCore.Server.Kestrel.Core.Http3Limits.MaxRequestHeaderFieldSize.set -> void
 Microsoft.AspNetCore.Server.Kestrel.Https.ClientCertificateMode.DelayCertificate = 3 -> Microsoft.AspNetCore.Server.Kestrel.Https.ClientCertificateMode
 static Microsoft.AspNetCore.Hosting.ListenOptionsHttpsExtensions.UseHttps(this Microsoft.AspNetCore.Server.Kestrel.Core.ListenOptions! listenOptions, Microsoft.AspNetCore.Server.Kestrel.Https.HttpsConnectionAdapterOptions! httpsOptions) -> Microsoft.AspNetCore.Server.Kestrel.Core.ListenOptions!
 static Microsoft.AspNetCore.Hosting.ListenOptionsHttpsExtensions.UseHttps(this Microsoft.AspNetCore.Server.Kestrel.Core.ListenOptions! listenOptions, System.Action<Microsoft.AspNetCore.Server.Kestrel.Https.HttpsConnectionAdapterOptions!>! configureOptions) -> Microsoft.AspNetCore.Server.Kestrel.Core.ListenOptions!
diff --git a/src/Servers/Kestrel/Core/test/Http3FrameWriterTests.cs b/src/Servers/Kestrel/Core/test/Http3FrameWriterTests.cs
@@ -55,17 +55,17 @@ public async Task WriteSettings_OneSettingsWrittenWithKestrelDefaults()
             var pipe = new Pipe(new PipeOptions(_dirtyMemoryPool, PipeScheduler.Inline, PipeScheduler.Inline));
             var frameWriter = CreateFrameWriter(pipe);
 
-            var limits = new Http3Limits();
+            var kestrelLimits = new KestrelServerLimits();
             var settings = new Http3PeerSettings();
-            settings.HeaderTableSize = (uint)limits.HeaderTableSize;
-            settings.MaxRequestHeaderFieldSize = (uint)limits.MaxRequestHeaderFieldSize;
+            settings.HeaderTableSize = (uint)kestrelLimits.Http3.HeaderTableSize;
+            settings.MaxRequestHeaderFieldSectionSize = (uint)kestrelLimits.MaxRequestHeadersTotalSize;
 
             await frameWriter.WriteSettingsAsync(settings.GetNonProtocolDefaults());
 
             // variable length ints make it so the results isn't know without knowing the values 
             var payload = await pipe.Reader.ReadForLengthAsync(5);
 
-            Assert.Equal(new byte[] { 0x04, 0x03, 0x06, 0x60, 0x00 }, payload.ToArray());
+            Assert.Equal(new byte[] { 0x04, 0x05, 0x06, 0x80, 0x00 }, payload.ToArray());
         }
 
         [Fact]
@@ -76,7 +76,7 @@ public async Task WriteSettings_TwoSettingsWritten()
 
             var settings = new Http3PeerSettings();
             settings.HeaderTableSize = 1234;
-            settings.MaxRequestHeaderFieldSize = 567890;
+            settings.MaxRequestHeaderFieldSectionSize = 567890;
 
             await frameWriter.WriteSettingsAsync(settings.GetNonProtocolDefaults());
 
@@ -88,7 +88,7 @@ public async Task WriteSettings_TwoSettingsWritten()
 
         private Http3FrameWriter CreateFrameWriter(Pipe pipe)
         {
-            return new Http3FrameWriter(pipe.Writer, null, null, null, null, _dirtyMemoryPool, null, Mock.Of<IStreamIdFeature>());
+            return new Http3FrameWriter(pipe.Writer, null, null, null, null, _dirtyMemoryPool, null, Mock.Of<IStreamIdFeature>(), new Http3PeerSettings(), null);
         }
     }
 }
diff --git a/src/Servers/Kestrel/shared/test/TestContextFactory.cs b/src/Servers/Kestrel/shared/test/TestContextFactory.cs
@@ -188,7 +188,8 @@ public static Http3StreamContext CreateHttp3StreamContext(
                 transport: transport,
                 streamLifetimeHandler: streamLifetimeHandler,
                 streamContext: null,
-                settings: null
+                clientPeerSettings: new Http3PeerSettings(),
+                serverPeerSettings: null
             );
             context.TimeoutControl = timeoutControl;
 
diff --git a/src/Servers/Kestrel/test/InMemory.FunctionalTests/Http3/Http3ConnectionTests.cs b/src/Servers/Kestrel/test/InMemory.FunctionalTests/Http3/Http3ConnectionTests.cs
@@ -156,5 +156,33 @@ await WaitForConnectionErrorAsync<Http3ConnectionErrorException>(
                 expectedErrorCode: Http3ErrorCode.ClosedCriticalStream,
                 expectedErrorMessage: CoreStrings.Http3ErrorControlStreamClientClosedInbound);
         }
+
+        [Fact]
+        public async Task SETTINGS_MaxFieldSectionSizeSent_ServerReceivesValue()
+        {
+            await InitializeConnectionAsync(_echoApplication);
+
+            var inboundControlStream = await GetInboundControlStream();
+            var incomingSettings = await inboundControlStream.ExpectSettingsAsync();
+
+            var defaultLimits = new KestrelServerLimits();
+            Assert.Collection(incomingSettings,
+                kvp =>
+                {
+                    Assert.Equal((long)Internal.Http3.Http3SettingType.MaxFieldSectionSize, kvp.Key);
+                    Assert.Equal(defaultLimits.MaxRequestHeadersTotalSize, kvp.Value);
+                });
+
+            var outboundcontrolStream = await CreateControlStream();
+            await outboundcontrolStream.SendSettingsAsync(new List<Http3PeerSetting>
+            {
+                new Http3PeerSetting(Internal.Http3.Http3SettingType.MaxFieldSectionSize, 100)
+            });
+
+            var maxFieldSetting = await ServerReceivedSettingsReader.ReadAsync().DefaultTimeout();
+
+            Assert.Equal(Internal.Http3.Http3SettingType.MaxFieldSectionSize, maxFieldSetting.Key);
+            Assert.Equal(100, maxFieldSetting.Value);
+        }
     }
 }
diff --git a/src/Servers/Kestrel/test/InMemory.FunctionalTests/Http3/Http3StreamTests.cs b/src/Servers/Kestrel/test/InMemory.FunctionalTests/Http3/Http3StreamTests.cs
diff --git a/src/Servers/Kestrel/test/InMemory.FunctionalTests/Http3/Http3TestBase.cs b/src/Servers/Kestrel/test/InMemory.FunctionalTests/Http3/Http3TestBase.cs
diff --git a/src/Shared/runtime/Http3/QPack/HeaderField.cs b/src/Shared/runtime/Http3/QPack/HeaderField.cs
diff --git a/src/Shared/runtime/Http3/QPack/QPackEncoder.cs b/src/Shared/runtime/Http3/QPack/QPackEncoder.cs

Original file line number	Diff line number	Diff line change
`@@ -42,7 +42,7 @@ public Http3ControlStream(Http3StreamContext context)`
`42`	`42`	`{`
`43`	`43`	`var httpLimits = context.ServiceContext.ServerOptions.Limits;`
`44`	`44`	`_context = context;`
`45`		`- _serverPeerSettings = context.ServerSettings;`
	`45`	`+ _serverPeerSettings = context.ServerPeerSettings;`
`46`	`46`	`_streamIdFeature = context.ConnectionFeatures.Get<IStreamIdFeature>()!;`
`47`	`47`	`_errorCodeFeature = context.ConnectionFeatures.Get<IProtocolErrorCodeFeature>()!;`
`48`	`48`	`_headerType = -1;`
`@@ -55,7 +55,9 @@ public Http3ControlStream(Http3StreamContext context)`
`55`	`55`	`context.ConnectionId,`
`56`	`56`	`context.MemoryPool,`
`57`	`57`	`context.ServiceContext.Log,`
`58`		`- _streamIdFeature);`
	`58`	`+ _streamIdFeature,`
	`59`	`+ context.ClientPeerSettings,`
	`60`	`+ this);`
`59`	`61`	`}`
`60`	`62`
`61`	`63`	`private void OnStreamClosed()`
`@@ -295,15 +297,15 @@ private ValueTask ProcessSettingsFrameAsync(ReadOnlySequence<byte> payload)`
`295`	`297`
`296`	`298`	`while (true)`
`297`	`299`	`{`
`298`		`- var id = VariableLengthIntegerHelper.GetInteger(payload, out var consumed, out var examinded);`
	`300`	`+ var id = VariableLengthIntegerHelper.GetInteger(payload, out var consumed, out _);`
`299`	`301`	`if (id == -1)`
`300`	`302`	`{`
`301`	`303`	`break;`
`302`	`304`	`}`
`303`	`305`
`304`	`306`	`payload = payload.Slice(consumed);`
`305`	`307`
`306`		`- var value = VariableLengthIntegerHelper.GetInteger(payload, out consumed, out examinded);`
	`308`	`+ var value = VariableLengthIntegerHelper.GetInteger(payload, out consumed, out _);`
`307`	`309`	`if (id == -1)`
`308`	`310`	`{`
`309`	`311`	`break;`
Original file line number	Diff line number	Diff line change
`@@ -12,7 +12,7 @@ internal class Http3PeerSettings`
`12`	`12`	`public const uint DefaultMaxRequestHeaderFieldSize = uint.MaxValue;`
`13`	`13`
`14`	`14`	`public uint HeaderTableSize { get; internal set; } = DefaultHeaderTableSize;`
`15`		`- public uint MaxRequestHeaderFieldSize { get; internal set; } = DefaultMaxRequestHeaderFieldSize;`
	`15`	`+ public uint MaxRequestHeaderFieldSectionSize { get; internal set; } = DefaultMaxRequestHeaderFieldSize;`
`16`	`16`
`17`	`17`	`// Gets the settings that are different from the protocol defaults (as opposed to the server defaults).`
`18`	`18`	`internal List<Http3PeerSetting> GetNonProtocolDefaults()`
`@@ -26,9 +26,9 @@ internal List<Http3PeerSetting> GetNonProtocolDefaults()`
`26`	`26`	`list.Add(new Http3PeerSetting(Http3SettingType.QPackMaxTableCapacity, HeaderTableSize));`
`27`	`27`	`}`
`28`	`28`
`29`		`- if (MaxRequestHeaderFieldSize != DefaultMaxRequestHeaderFieldSize)`
	`29`	`+ if (MaxRequestHeaderFieldSectionSize != DefaultMaxRequestHeaderFieldSize)`
`30`	`30`	`{`
`31`		`- list.Add(new Http3PeerSetting(Http3SettingType.MaxFieldSectionSize, MaxRequestHeaderFieldSize));`
	`31`	`+ list.Add(new Http3PeerSetting(Http3SettingType.MaxFieldSectionSize, MaxRequestHeaderFieldSectionSize));`
`32`	`32`	`}`
`33`	`33`
`34`	`34`	`return list;`
Original file line number	Diff line number	Diff line change
`@@ -24,15 +24,18 @@ public Http3StreamContext(`
`24`	`24`	`IDuplexPipe transport,`
`25`	`25`	`IHttp3StreamLifetimeHandler streamLifetimeHandler,`
`26`	`26`	`ConnectionContext streamContext,`
`27`		`- Http3PeerSettings settings) : base(connectionId, protocols, connectionContext, serviceContext, connectionFeatures, memoryPool, localEndPoint, remoteEndPoint, transport)`
	`27`	`+ Http3PeerSettings clientPeerSettings,`
	`28`	`+ Http3PeerSettings serverPeerSettings) : base(connectionId, protocols, connectionContext, serviceContext, connectionFeatures, memoryPool, localEndPoint, remoteEndPoint, transport)`
`28`	`29`	`{`
`29`	`30`	`StreamLifetimeHandler = streamLifetimeHandler;`
`30`	`31`	`StreamContext = streamContext;`
`31`		`- ServerSettings = settings;`
	`32`	`+ ClientPeerSettings = clientPeerSettings;`
	`33`	`+ ServerPeerSettings = serverPeerSettings;`
`32`	`34`	`}`
`33`	`35`
`34`	`36`	`public IHttp3StreamLifetimeHandler StreamLifetimeHandler { get; }`
`35`	`37`	`public ConnectionContext StreamContext { get; }`
`36`		`- public Http3PeerSettings ServerSettings { get; }`
	`38`	`+ public Http3PeerSettings ClientPeerSettings { get; }`
	`39`	`+ public Http3PeerSettings ServerPeerSettings { get; }`
`37`	`40`	`}`
`38`	`41`	`}`
Original file line number	Diff line number	Diff line change
`@@ -55,17 +55,17 @@ public async Task WriteSettings_OneSettingsWrittenWithKestrelDefaults()`
`55`	`55`	`var pipe = new Pipe(new PipeOptions(_dirtyMemoryPool, PipeScheduler.Inline, PipeScheduler.Inline));`
`56`	`56`	`var frameWriter = CreateFrameWriter(pipe);`
`57`	`57`
`58`		`- var limits = new Http3Limits();`
	`58`	`+ var kestrelLimits = new KestrelServerLimits();`
`59`	`59`	`var settings = new Http3PeerSettings();`
`60`		`- settings.HeaderTableSize = (uint)limits.HeaderTableSize;`
`61`		`- settings.MaxRequestHeaderFieldSize = (uint)limits.MaxRequestHeaderFieldSize;`
	`60`	`+ settings.HeaderTableSize = (uint)kestrelLimits.Http3.HeaderTableSize;`
	`61`	`+ settings.MaxRequestHeaderFieldSectionSize = (uint)kestrelLimits.MaxRequestHeadersTotalSize;`
`62`	`62`
`63`	`63`	`await frameWriter.WriteSettingsAsync(settings.GetNonProtocolDefaults());`
`64`	`64`
`65`	`65`	`// variable length ints make it so the results isn't know without knowing the values`
`66`	`66`	`var payload = await pipe.Reader.ReadForLengthAsync(5);`
`67`	`67`
`68`		`- Assert.Equal(new byte[] { 0x04, 0x03, 0x06, 0x60, 0x00 }, payload.ToArray());`
	`68`	`+ Assert.Equal(new byte[] { 0x04, 0x05, 0x06, 0x80, 0x00 }, payload.ToArray());`
`69`	`69`	`}`
`70`	`70`
`71`	`71`	`[Fact]`
`@@ -76,7 +76,7 @@ public async Task WriteSettings_TwoSettingsWritten()`
`76`	`76`
`77`	`77`	`var settings = new Http3PeerSettings();`
`78`	`78`	`settings.HeaderTableSize = 1234;`
`79`		`- settings.MaxRequestHeaderFieldSize = 567890;`
	`79`	`+ settings.MaxRequestHeaderFieldSectionSize = 567890;`
`80`	`80`
`81`	`81`	`await frameWriter.WriteSettingsAsync(settings.GetNonProtocolDefaults());`
`82`	`82`
`@@ -88,7 +88,7 @@ public async Task WriteSettings_TwoSettingsWritten()`
`88`	`88`
`89`	`89`	`private Http3FrameWriter CreateFrameWriter(Pipe pipe)`
`90`	`90`	`{`
`91`		`- return new Http3FrameWriter(pipe.Writer, null, null, null, null, _dirtyMemoryPool, null, Mock.Of<IStreamIdFeature>());`
	`91`	`+ return new Http3FrameWriter(pipe.Writer, null, null, null, null, _dirtyMemoryPool, null, Mock.Of<IStreamIdFeature>(), new Http3PeerSettings(), null);`
`92`	`92`	`}`
`93`	`93`	`}`
`94`	`94`	`}`