Add HTTP/3 connection exception with code

JamesNK · JamesNK · commit ff298ab8beb4 · 2021-03-16T12:54:24.000+13:00
diff --git a/src/Servers/Kestrel/Core/src/CoreStrings.resx b/src/Servers/Kestrel/Core/src/CoreStrings.resx
@@ -654,7 +654,7 @@ For more information on configuring HTTPS see https://go.microsoft.com/fwlink/?l
     <value>An error occurred after the response headers were sent, a reset is being sent.</value>
   </data>
   <data name="Http3StreamErrorDataReceivedBeforeHeaders" xml:space="preserve">
-    <value>The client sent a DATA frame before the HEADERS frame.</value>
+    <value>The client sent a DATA frame to a request stream before the HEADERS frame.</value>
   </data>
   <data name="Http3StreamErrorFrameReceivedAfterTrailers" xml:space="preserve">
     <value>The client sent a {frameType} frame after trailing HEADERS.</value>
@@ -665,4 +665,13 @@ For more information on configuring HTTPS see https://go.microsoft.com/fwlink/?l
   <data name="Http3ErrorUnsupportedFrameOnServer" xml:space="preserve">
     <value>The client sent a {frameType} frame to the server which isn't supported.</value>
   </data>
+  <data name="Http3ErrorUnsupportedFrameOnControlStream" xml:space="preserve">
+    <value>The client sent a {frameType} frame to a control stream which isn't supported.</value>
+  </data>
+  <data name="Http3ErrorControlStreamMultipleSettingsFrames" xml:space="preserve">
+    <value>The client sent a SETTINGS frame to a control stream that already has settings.</value>
+  </data>
+  <data name="Http3ErrorControlStreamFrameReceivedBeforeSettings" xml:space="preserve">
+    <value>The client sent a {frameType} frame to a control stream before the SETTINGS frame.</value>
+  </data>
 </root>
diff --git a/src/Servers/Kestrel/Core/src/Internal/Http3/Http3Connection.cs b/src/Servers/Kestrel/Core/src/Internal/Http3/Http3Connection.cs
@@ -326,9 +326,8 @@ internal async Task InnerProcessStreamsAsync<TContext>(IHttpApplication<TContext
                 Log.RequestProcessingError(_context.ConnectionId, ex);
                 error = ex;
             }
-            catch (Http3ConnectionException ex)
+            catch (Http3ConnectionErrorException ex)
             {
-                // TODO Connection error code?
                 Log.Http3ConnectionError(_context.ConnectionId, ex);
                 error = ex;
             }
diff --git a/src/Servers/Kestrel/Core/src/Internal/Http3/Http3ConnectionErrorException.cs b/src/Servers/Kestrel/Core/src/Internal/Http3/Http3ConnectionErrorException.cs
@@ -0,0 +1,19 @@
+// Copyright (c) .NET Foundation. All rights reserved.
+// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
+
+using System;
+using System.Net.Http;
+
+namespace Microsoft.AspNetCore.Server.Kestrel.Core.Internal.Http3
+{
+    internal class Http3ConnectionErrorException : Exception
+    {
+        public Http3ConnectionErrorException(string message, Http3ErrorCode errorCode)
+            : base($"HTTP/3 stream error ({errorCode}): {message}")
+        {
+            ErrorCode = errorCode;
+        }
+
+        public Http3ErrorCode ErrorCode { get; }
+    }
+}
diff --git a/src/Servers/Kestrel/Core/src/Internal/Http3/Http3ConnectionException.cs b/src/Servers/Kestrel/Core/src/Internal/Http3/Http3ConnectionException.cs
diff --git a/src/Servers/Kestrel/Core/src/Internal/Http3/Http3ControlStream.cs b/src/Servers/Kestrel/Core/src/Internal/Http3/Http3ControlStream.cs
@@ -155,8 +155,8 @@ public async Task ProcessRequestAsync<TContext>(IHttpApplication<TContext> appli
             {
                 if (!_http3Connection.SetInboundControlStream(this))
                 {
-                    // TODO propagate these errors to connection.
-                    throw new Http3ConnectionException("HTTP_STREAM_CREATION_ERROR");
+                    // https://quicwg.org/base-drafts/draft-ietf-quic-http.html#section-6.2.1
+                    throw new Http3ConnectionErrorException("Only one inbound control stream per peer is permitted.", Http3ErrorCode.StreamCreationError);
                 }
 
                 await HandleControlStream();
@@ -165,7 +165,8 @@ public async Task ProcessRequestAsync<TContext>(IHttpApplication<TContext> appli
             {
                 if (!_http3Connection.SetInboundEncoderStream(this))
                 {
-                    throw new Http3ConnectionException("HTTP_STREAM_CREATION_ERROR");
+                    // https://quicwg.org/base-drafts/draft-ietf-quic-qpack.html#section-4.2
+                    throw new Http3ConnectionErrorException("Only one inbound encoder stream per peer is permitted.", Http3ErrorCode.StreamCreationError);
                 }
 
                 await HandleEncodingDecodingTask();
@@ -174,7 +175,8 @@ public async Task ProcessRequestAsync<TContext>(IHttpApplication<TContext> appli
             {
                 if (!_http3Connection.SetInboundDecoderStream(this))
                 {
-                    throw new Http3ConnectionException("HTTP_STREAM_CREATION_ERROR");
+                    // https://quicwg.org/base-drafts/draft-ietf-quic-qpack.html#section-4.2
+                    throw new Http3ConnectionErrorException("Only one inbound decoder stream per peer is permitted.", Http3ErrorCode.StreamCreationError);
                 }
                 await HandleEncodingDecodingTask();
             }
@@ -238,33 +240,32 @@ private async ValueTask HandleEncodingDecodingTask()
 
         private ValueTask ProcessHttp3ControlStream(in ReadOnlySequence<byte> payload)
         {
-            // Two things:
-            // settings must be sent as the first frame of each control stream by each peer
-            // Can't send more than two settings frames.
             switch (_incomingFrame.Type)
             {
                 case Http3FrameType.Data:
                 case Http3FrameType.Headers:
                 case Http3FrameType.PushPromise:
-                    throw new Http3ConnectionException("HTTP_FRAME_UNEXPECTED");
+                    // https://quicwg.org/base-drafts/draft-ietf-quic-http.html#section-7.2
+                    throw new Http3ConnectionErrorException(CoreStrings.FormatHttp3ErrorUnsupportedFrameOnControlStream(_incomingFrame.FormattedType), Http3ErrorCode.UnexpectedFrame);
                 case Http3FrameType.Settings:
                     return ProcessSettingsFrameAsync(payload);
                 case Http3FrameType.GoAway:
-                    return ProcessGoAwayFrameAsync(payload);
+                    return ProcessGoAwayFrameAsync();
                 case Http3FrameType.CancelPush:
                     return ProcessCancelPushFrameAsync();
                 case Http3FrameType.MaxPushId:
                     return ProcessMaxPushIdFrameAsync();
                 default:
-                    return ProcessUnknownFrameAsync();
+                    return ProcessUnknownFrameAsync(_incomingFrame.Type);
             }
         }
 
         private ValueTask ProcessSettingsFrameAsync(ReadOnlySequence<byte> payload)
         {
             if (_haveReceivedSettingsFrame)
             {
-                throw new Http3ConnectionException("H3_SETTINGS_ERROR");
+                // https://quicwg.org/base-drafts/draft-ietf-quic-http.html#name-settings
+                throw new Http3ConnectionErrorException(CoreStrings.Http3ErrorControlStreamMultipleSettingsFrames, Http3ErrorCode.UnexpectedFrame);
             }
 
             _haveReceivedSettingsFrame = true;
@@ -313,39 +314,53 @@ private void ProcessSetting(long id, long value)
             }
         }
 
-        private ValueTask ProcessGoAwayFrameAsync(ReadOnlySequence<byte> payload)
+        private ValueTask ProcessGoAwayFrameAsync()
         {
-             throw new Http3ConnectionException("HTTP_FRAME_UNEXPECTED");
+            EnsureSettingsFrame(Http3FrameType.GoAway);
+
+            // https://quicwg.org/base-drafts/draft-ietf-quic-http.html#name-goaway
+            // PUSH is not implemented so nothing to do.
+
+            // TODO: Double check the connection remains open.
+            return default;
         }
 
         private ValueTask ProcessCancelPushFrameAsync()
         {
-            if (!_haveReceivedSettingsFrame)
-            {
-                throw new Http3ConnectionException("HTTP_FRAME_UNEXPECTED");
-            }
+            EnsureSettingsFrame(Http3FrameType.CancelPush);
+
+            // https://quicwg.org/base-drafts/draft-ietf-quic-http.html#name-cancel_push
+            // PUSH is not implemented so nothing to do.
 
             return default;
         }
 
         private ValueTask ProcessMaxPushIdFrameAsync()
         {
-            if (!_haveReceivedSettingsFrame)
-            {
-                throw new Http3ConnectionException("HTTP_FRAME_UNEXPECTED");
-            }
+            EnsureSettingsFrame(Http3FrameType.MaxPushId);
+
+            // https://quicwg.org/base-drafts/draft-ietf-quic-http.html#name-cancel_push
+            // PUSH is not implemented so nothing to do.
 
             return default;
         }
 
-        private ValueTask ProcessUnknownFrameAsync()
+        private ValueTask ProcessUnknownFrameAsync(Http3FrameType frameType)
+        {
+            EnsureSettingsFrame(frameType);
+
+            // https://quicwg.org/base-drafts/draft-ietf-quic-http.html#section-9
+            // Unknown frames must be explicitly ignored.
+            return default;
+        }
+
+        private void EnsureSettingsFrame(Http3FrameType frameType)
         {
             if (!_haveReceivedSettingsFrame)
             {
-                throw new Http3ConnectionException("HTTP_FRAME_UNEXPECTED");
+                var message = CoreStrings.FormatHttp3ErrorControlStreamFrameReceivedBeforeSettings(Http3Formatting.ToFormattedType(frameType));
+                throw new Http3ConnectionErrorException(message, Http3ErrorCode.MissingSettings);
             }
-
-            return default;
         }
 
         public void StopProcessingNextRequest()
diff --git a/src/Servers/Kestrel/Core/src/Internal/Http3/Http3Stream.cs b/src/Servers/Kestrel/Core/src/Internal/Http3/Http3Stream.cs
@@ -387,6 +387,12 @@ public async Task ProcessRequestAsync<TContext>(IHttpApplication<TContext> appli
                 error = ex;
                 Abort(new ConnectionAbortedException(ex.Message, ex), ex.ErrorCode);
             }
+            catch (Http3ConnectionErrorException ex)
+            {
+                // TODO: Abort overall connection
+                error = ex;
+                Abort(new ConnectionAbortedException(ex.Message, ex), ex.ErrorCode);
+            }
             catch (Exception ex)
             {
                 error = ex;
@@ -450,18 +456,20 @@ private Task ProcessHttp3Stream<TContext>(IHttpApplication<TContext> application
                 case Http3FrameType.CancelPush:
                 case Http3FrameType.GoAway:
                 case Http3FrameType.MaxPushId:
+                    // https://quicwg.org/base-drafts/draft-ietf-quic-http.html#section-7.2.4
                     // These frames need to be on a control stream
-                    throw new Http3StreamErrorException(CoreStrings.FormatHttp3ErrorUnsupportedFrameOnRequestStream(_incomingFrame.FormattedType), Http3ErrorCode.UnexpectedFrame);
+                    throw new Http3ConnectionErrorException(CoreStrings.FormatHttp3ErrorUnsupportedFrameOnRequestStream(_incomingFrame.FormattedType), Http3ErrorCode.UnexpectedFrame);
                 case Http3FrameType.PushPromise:
                     // The server should never receive push promise
-                    throw new Http3StreamErrorException(CoreStrings.FormatHttp3ErrorUnsupportedFrameOnServer(_incomingFrame.FormattedType), Http3ErrorCode.UnexpectedFrame);
+                    throw new Http3ConnectionErrorException(CoreStrings.FormatHttp3ErrorUnsupportedFrameOnServer(_incomingFrame.FormattedType), Http3ErrorCode.UnexpectedFrame);
                 default:
                     return ProcessUnknownFrameAsync();
             }
         }
 
         private Task ProcessUnknownFrameAsync()
         {
+            // https://quicwg.org/base-drafts/draft-ietf-quic-http.html#section-9
             // Unknown frames must be explicitly ignored.
             return Task.CompletedTask;
         }
@@ -472,7 +480,7 @@ private Task ProcessHeadersFrameAsync<TContext>(IHttpApplication<TContext> appli
             // https://quicwg.org/base-drafts/draft-ietf-quic-http.html#section-4.1
             if (_requestHeaderParsingState == RequestHeaderParsingState.Trailers)
             {
-                throw new Http3StreamErrorException(CoreStrings.FormatHttp3StreamErrorFrameReceivedAfterTrailers(Http3Formatting.ToFormattedType(Http3FrameType.Headers)), Http3ErrorCode.UnexpectedFrame);
+                throw new Http3ConnectionErrorException(CoreStrings.FormatHttp3StreamErrorFrameReceivedAfterTrailers(Http3Formatting.ToFormattedType(Http3FrameType.Headers)), Http3ErrorCode.UnexpectedFrame);
             }
 
             if (_requestHeaderParsingState == RequestHeaderParsingState.Headers)
@@ -515,14 +523,15 @@ private Task ProcessDataFrameAsync(in ReadOnlySequence<byte> payload)
             // https://quicwg.org/base-drafts/draft-ietf-quic-http.html#section-4.1
             if (_requestHeaderParsingState == RequestHeaderParsingState.Ready)
             {
-                throw new Http3StreamErrorException(CoreStrings.Http3StreamErrorDataReceivedBeforeHeaders, Http3ErrorCode.UnexpectedFrame);
+                throw new Http3ConnectionErrorException(CoreStrings.Http3StreamErrorDataReceivedBeforeHeaders, Http3ErrorCode.UnexpectedFrame);
             }
 
             // DATA frame after trailing headers is invalid.
             // https://quicwg.org/base-drafts/draft-ietf-quic-http.html#section-4.1
             if (_requestHeaderParsingState == RequestHeaderParsingState.Trailers)
             {
-                throw new Http3StreamErrorException(CoreStrings.FormatHttp3StreamErrorFrameReceivedAfterTrailers(CoreStrings.FormatHttp3StreamErrorFrameReceivedAfterTrailers(Http3Formatting.ToFormattedType(Http3FrameType.Data))), Http3ErrorCode.UnexpectedFrame);
+                var message = CoreStrings.FormatHttp3StreamErrorFrameReceivedAfterTrailers(CoreStrings.FormatHttp3StreamErrorFrameReceivedAfterTrailers(Http3Formatting.ToFormattedType(Http3FrameType.Data)));
+                throw new Http3ConnectionErrorException(message, Http3ErrorCode.UnexpectedFrame);
             }
 
             if (InputRemaining.HasValue)
diff --git a/src/Servers/Kestrel/Core/src/Internal/Http3/Http3StreamErrorException.cs b/src/Servers/Kestrel/Core/src/Internal/Http3/Http3StreamErrorException.cs
@@ -6,7 +6,7 @@
 
 namespace Microsoft.AspNetCore.Server.Kestrel.Core.Internal.Http3
 {
-    class Http3StreamErrorException : Exception
+    internal class Http3StreamErrorException : Exception
     {
         public Http3StreamErrorException(string message, Http3ErrorCode errorCode)
             : base($"HTTP/3 stream error ({errorCode}): {message}")
diff --git a/src/Servers/Kestrel/Core/src/Internal/Infrastructure/IKestrelTrace.cs b/src/Servers/Kestrel/Core/src/Internal/Infrastructure/IKestrelTrace.cs
@@ -81,7 +81,7 @@ internal interface IKestrelTrace : ILogger
 
         void InvalidResponseHeaderRemoved();
 
-        void Http3ConnectionError(string connectionId, Http3ConnectionException ex);
+        void Http3ConnectionError(string connectionId, Http3ConnectionErrorException ex);
 
         void Http3ConnectionClosing(string connectionId);
 
diff --git a/src/Servers/Kestrel/Core/src/Internal/Infrastructure/KestrelTrace.cs b/src/Servers/Kestrel/Core/src/Internal/Infrastructure/KestrelTrace.cs
@@ -329,7 +329,7 @@ public void InvalidResponseHeaderRemoved()
             _invalidResponseHeaderRemoved(_logger, null);
         }
 
-        public void Http3ConnectionError(string connectionId, Http3ConnectionException ex)
+        public void Http3ConnectionError(string connectionId, Http3ConnectionErrorException ex)
         {
             _http3ConnectionError(_logger, connectionId, ex);
         }
diff --git a/src/Servers/Kestrel/perf/Microbenchmarks/Mocks/MockTrace.cs b/src/Servers/Kestrel/perf/Microbenchmarks/Mocks/MockTrace.cs
@@ -60,7 +60,7 @@ public void Http2FrameReceived(string connectionId, Http2Frame frame) { }
         public void Http2FrameSending(string connectionId, Http2Frame frame) { }
         public void Http2MaxConcurrentStreamsReached(string connectionId) { }
         public void InvalidResponseHeaderRemoved() { }
-        public void Http3ConnectionError(string connectionId, Http3ConnectionException ex) { }
+        public void Http3ConnectionError(string connectionId, Http3ConnectionErrorException ex) { }
         public void Http3ConnectionClosing(string connectionId) { }
         public void Http3ConnectionClosed(string connectionId, long highestOpenedStreamId) { }
         public void Http3StreamAbort(string traceIdentifier, Http3ErrorCode error, ConnectionAbortedException abortReason) { }
diff --git a/src/Servers/Kestrel/shared/test/CompositeKestrelTrace.cs b/src/Servers/Kestrel/shared/test/CompositeKestrelTrace.cs
@@ -245,7 +245,7 @@ public void InvalidResponseHeaderRemoved()
             _trace2.InvalidResponseHeaderRemoved();
         }
 
-        public void Http3ConnectionError(string connectionId, Http3ConnectionException ex)
+        public void Http3ConnectionError(string connectionId, Http3ConnectionErrorException ex)
         {
             _trace1.Http3ConnectionError(connectionId, ex);
             _trace2.Http3ConnectionError(connectionId, ex);
diff --git a/src/Servers/Kestrel/test/InMemory.FunctionalTests/Http3/Http3StreamTests.cs b/src/Servers/Kestrel/test/InMemory.FunctionalTests/Http3/Http3StreamTests.cs
@@ -1631,7 +1631,7 @@ public async Task DataBeforeHeaders_UnexpectedFrameError()
 
             await requestStream.WaitForStreamErrorAsync(
                 Http3ErrorCode.UnexpectedFrame,
-                expectedErrorMessage: "The client sent a DATA frame before the HEADERS frame.");
+                expectedErrorMessage: CoreStrings.Http3StreamErrorDataReceivedBeforeHeaders);
         }
 
         [Fact]

Original file line number	Diff line number	Diff line change
`@@ -326,9 +326,8 @@ internal async Task InnerProcessStreamsAsync<TContext>(IHttpApplication<TContext`
`326`	`326`	`Log.RequestProcessingError(_context.ConnectionId, ex);`
`327`	`327`	`error = ex;`
`328`	`328`	`}`
`329`		`- catch (Http3ConnectionException ex)`
	`329`	`+ catch (Http3ConnectionErrorException ex)`
`330`	`330`	`{`
`331`		`- // TODO Connection error code?`
`332`	`331`	`Log.Http3ConnectionError(_context.ConnectionId, ex);`
`333`	`332`	`error = ex;`
`334`	`333`	`}`
Original file line number	Diff line number	Diff line change
`@@ -155,8 +155,8 @@ public async Task ProcessRequestAsync<TContext>(IHttpApplication<TContext> appli`
`155`	`155`	`{`
`156`	`156`	`if (!_http3Connection.SetInboundControlStream(this))`
`157`	`157`	`{`
`158`		`- // TODO propagate these errors to connection.`
`159`		`- throw new Http3ConnectionException("HTTP_STREAM_CREATION_ERROR");`
	`158`	`+ // https://quicwg.org/base-drafts/draft-ietf-quic-http.html#section-6.2.1`
	`159`	`+ throw new Http3ConnectionErrorException("Only one inbound control stream per peer is permitted.", Http3ErrorCode.StreamCreationError);`
`160`	`160`	`}`
`161`	`161`
`162`	`162`	`await HandleControlStream();`
`@@ -165,7 +165,8 @@ public async Task ProcessRequestAsync<TContext>(IHttpApplication<TContext> appli`
`165`	`165`	`{`
`166`	`166`	`if (!_http3Connection.SetInboundEncoderStream(this))`
`167`	`167`	`{`
`168`		`- throw new Http3ConnectionException("HTTP_STREAM_CREATION_ERROR");`
	`168`	`+ // https://quicwg.org/base-drafts/draft-ietf-quic-qpack.html#section-4.2`
	`169`	`+ throw new Http3ConnectionErrorException("Only one inbound encoder stream per peer is permitted.", Http3ErrorCode.StreamCreationError);`
`169`	`170`	`}`
`170`	`171`
`171`	`172`	`await HandleEncodingDecodingTask();`
`@@ -174,7 +175,8 @@ public async Task ProcessRequestAsync<TContext>(IHttpApplication<TContext> appli`
`174`	`175`	`{`
`175`	`176`	`if (!_http3Connection.SetInboundDecoderStream(this))`
`176`	`177`	`{`
`177`		`- throw new Http3ConnectionException("HTTP_STREAM_CREATION_ERROR");`
	`178`	`+ // https://quicwg.org/base-drafts/draft-ietf-quic-qpack.html#section-4.2`
	`179`	`+ throw new Http3ConnectionErrorException("Only one inbound decoder stream per peer is permitted.", Http3ErrorCode.StreamCreationError);`
`178`	`180`	`}`
`179`	`181`	`await HandleEncodingDecodingTask();`
`180`	`182`	`}`
`@@ -238,33 +240,32 @@ private async ValueTask HandleEncodingDecodingTask()`
`238`	`240`
`239`	`241`	`private ValueTask ProcessHttp3ControlStream(in ReadOnlySequence<byte> payload)`
`240`	`242`	`{`
`241`		`- // Two things:`
`242`		`- // settings must be sent as the first frame of each control stream by each peer`
`243`		`- // Can't send more than two settings frames.`
`244`	`243`	`switch (_incomingFrame.Type)`
`245`	`244`	`{`
`246`	`245`	`case Http3FrameType.Data:`
`247`	`246`	`case Http3FrameType.Headers:`
`248`	`247`	`case Http3FrameType.PushPromise:`
`249`		`- throw new Http3ConnectionException("HTTP_FRAME_UNEXPECTED");`
	`248`	`+ // https://quicwg.org/base-drafts/draft-ietf-quic-http.html#section-7.2`
	`249`	`+ throw new Http3ConnectionErrorException(CoreStrings.FormatHttp3ErrorUnsupportedFrameOnControlStream(_incomingFrame.FormattedType), Http3ErrorCode.UnexpectedFrame);`
`250`	`250`	`case Http3FrameType.Settings:`
`251`	`251`	`return ProcessSettingsFrameAsync(payload);`
`252`	`252`	`case Http3FrameType.GoAway:`
`253`		`- return ProcessGoAwayFrameAsync(payload);`
	`253`	`+ return ProcessGoAwayFrameAsync();`
`254`	`254`	`case Http3FrameType.CancelPush:`
`255`	`255`	`return ProcessCancelPushFrameAsync();`
`256`	`256`	`case Http3FrameType.MaxPushId:`
`257`	`257`	`return ProcessMaxPushIdFrameAsync();`
`258`	`258`	`default:`
`259`		`- return ProcessUnknownFrameAsync();`
	`259`	`+ return ProcessUnknownFrameAsync(_incomingFrame.Type);`
`260`	`260`	`}`
`261`	`261`	`}`
`262`	`262`
`263`	`263`	`private ValueTask ProcessSettingsFrameAsync(ReadOnlySequence<byte> payload)`
`264`	`264`	`{`
`265`	`265`	`if (_haveReceivedSettingsFrame)`
`266`	`266`	`{`
`267`		`- throw new Http3ConnectionException("H3_SETTINGS_ERROR");`
	`267`	`+ // https://quicwg.org/base-drafts/draft-ietf-quic-http.html#name-settings`
	`268`	`+ throw new Http3ConnectionErrorException(CoreStrings.Http3ErrorControlStreamMultipleSettingsFrames, Http3ErrorCode.UnexpectedFrame);`
`268`	`269`	`}`
`269`	`270`
`270`	`271`	`_haveReceivedSettingsFrame = true;`
`@@ -313,39 +314,53 @@ private void ProcessSetting(long id, long value)`
`313`	`314`	`}`
`314`	`315`	`}`
`315`	`316`
`316`		`- private ValueTask ProcessGoAwayFrameAsync(ReadOnlySequence<byte> payload)`
	`317`	`+ private ValueTask ProcessGoAwayFrameAsync()`
`317`	`318`	`{`
`318`		`- throw new Http3ConnectionException("HTTP_FRAME_UNEXPECTED");`
	`319`	`+ EnsureSettingsFrame(Http3FrameType.GoAway);`
	`320`	`+`
	`321`	`+ // https://quicwg.org/base-drafts/draft-ietf-quic-http.html#name-goaway`
	`322`	`+ // PUSH is not implemented so nothing to do.`
	`323`	`+`
	`324`	`+ // TODO: Double check the connection remains open.`
	`325`	`+ return default;`
`319`	`326`	`}`
`320`	`327`
`321`	`328`	`private ValueTask ProcessCancelPushFrameAsync()`
`322`	`329`	`{`
`323`		`- if (!_haveReceivedSettingsFrame)`
`324`		`- {`
`325`		`- throw new Http3ConnectionException("HTTP_FRAME_UNEXPECTED");`
`326`		`- }`
	`330`	`+ EnsureSettingsFrame(Http3FrameType.CancelPush);`
	`331`	`+`
	`332`	`+ // https://quicwg.org/base-drafts/draft-ietf-quic-http.html#name-cancel_push`
	`333`	`+ // PUSH is not implemented so nothing to do.`
`327`	`334`
`328`	`335`	`return default;`
`329`	`336`	`}`
`330`	`337`
`331`	`338`	`private ValueTask ProcessMaxPushIdFrameAsync()`
`332`	`339`	`{`
`333`		`- if (!_haveReceivedSettingsFrame)`
`334`		`- {`
`335`		`- throw new Http3ConnectionException("HTTP_FRAME_UNEXPECTED");`
`336`		`- }`
	`340`	`+ EnsureSettingsFrame(Http3FrameType.MaxPushId);`
	`341`	`+`
	`342`	`+ // https://quicwg.org/base-drafts/draft-ietf-quic-http.html#name-cancel_push`
	`343`	`+ // PUSH is not implemented so nothing to do.`
`337`	`344`
`338`	`345`	`return default;`
`339`	`346`	`}`
`340`	`347`
`341`		`- private ValueTask ProcessUnknownFrameAsync()`
	`348`	`+ private ValueTask ProcessUnknownFrameAsync(Http3FrameType frameType)`
	`349`	`+ {`
	`350`	`+ EnsureSettingsFrame(frameType);`
	`351`	`+`
	`352`	`+ // https://quicwg.org/base-drafts/draft-ietf-quic-http.html#section-9`
	`353`	`+ // Unknown frames must be explicitly ignored.`
	`354`	`+ return default;`
	`355`	`+ }`
	`356`	`+`
	`357`	`+ private void EnsureSettingsFrame(Http3FrameType frameType)`
`342`	`358`	`{`
`343`	`359`	`if (!_haveReceivedSettingsFrame)`
`344`	`360`	`{`
`345`		`- throw new Http3ConnectionException("HTTP_FRAME_UNEXPECTED");`
	`361`	`+ var message = CoreStrings.FormatHttp3ErrorControlStreamFrameReceivedBeforeSettings(Http3Formatting.ToFormattedType(frameType));`
	`362`	`+ throw new Http3ConnectionErrorException(message, Http3ErrorCode.MissingSettings);`
`346`	`363`	`}`
`347`		`-`
`348`		`- return default;`
`349`	`364`	`}`
`350`	`365`
`351`	`366`	`public void StopProcessingNextRequest()`
Original file line number	Diff line number	Diff line change
`@@ -387,6 +387,12 @@ public async Task ProcessRequestAsync<TContext>(IHttpApplication<TContext> appli`
`387`	`387`	`error = ex;`
`388`	`388`	`Abort(new ConnectionAbortedException(ex.Message, ex), ex.ErrorCode);`
`389`	`389`	`}`
	`390`	`+ catch (Http3ConnectionErrorException ex)`
	`391`	`+ {`
	`392`	`+ // TODO: Abort overall connection`
	`393`	`+ error = ex;`
	`394`	`+ Abort(new ConnectionAbortedException(ex.Message, ex), ex.ErrorCode);`
	`395`	`+ }`
`390`	`396`	`catch (Exception ex)`
`391`	`397`	`{`
`392`	`398`	`error = ex;`
`@@ -450,18 +456,20 @@ private Task ProcessHttp3Stream<TContext>(IHttpApplication<TContext> application`
`450`	`456`	`case Http3FrameType.CancelPush:`
`451`	`457`	`case Http3FrameType.GoAway:`
`452`	`458`	`case Http3FrameType.MaxPushId:`
	`459`	`+ // https://quicwg.org/base-drafts/draft-ietf-quic-http.html#section-7.2.4`
`453`	`460`	`// These frames need to be on a control stream`
`454`		`- throw new Http3StreamErrorException(CoreStrings.FormatHttp3ErrorUnsupportedFrameOnRequestStream(_incomingFrame.FormattedType), Http3ErrorCode.UnexpectedFrame);`
	`461`	`+ throw new Http3ConnectionErrorException(CoreStrings.FormatHttp3ErrorUnsupportedFrameOnRequestStream(_incomingFrame.FormattedType), Http3ErrorCode.UnexpectedFrame);`
`455`	`462`	`case Http3FrameType.PushPromise:`
`456`	`463`	`// The server should never receive push promise`
`457`		`- throw new Http3StreamErrorException(CoreStrings.FormatHttp3ErrorUnsupportedFrameOnServer(_incomingFrame.FormattedType), Http3ErrorCode.UnexpectedFrame);`
	`464`	`+ throw new Http3ConnectionErrorException(CoreStrings.FormatHttp3ErrorUnsupportedFrameOnServer(_incomingFrame.FormattedType), Http3ErrorCode.UnexpectedFrame);`
`458`	`465`	`default:`
`459`	`466`	`return ProcessUnknownFrameAsync();`
`460`	`467`	`}`
`461`	`468`	`}`
`462`	`469`
`463`	`470`	`private Task ProcessUnknownFrameAsync()`
`464`	`471`	`{`
	`472`	`+ // https://quicwg.org/base-drafts/draft-ietf-quic-http.html#section-9`
`465`	`473`	`// Unknown frames must be explicitly ignored.`
`466`	`474`	`return Task.CompletedTask;`
`467`	`475`	`}`
`@@ -472,7 +480,7 @@ private Task ProcessHeadersFrameAsync<TContext>(IHttpApplication<TContext> appli`
`472`	`480`	`// https://quicwg.org/base-drafts/draft-ietf-quic-http.html#section-4.1`
`473`	`481`	`if (_requestHeaderParsingState == RequestHeaderParsingState.Trailers)`
`474`	`482`	`{`
`475`		`- throw new Http3StreamErrorException(CoreStrings.FormatHttp3StreamErrorFrameReceivedAfterTrailers(Http3Formatting.ToFormattedType(Http3FrameType.Headers)), Http3ErrorCode.UnexpectedFrame);`
	`483`	`+ throw new Http3ConnectionErrorException(CoreStrings.FormatHttp3StreamErrorFrameReceivedAfterTrailers(Http3Formatting.ToFormattedType(Http3FrameType.Headers)), Http3ErrorCode.UnexpectedFrame);`
`476`	`484`	`}`
`477`	`485`
`478`	`486`	`if (_requestHeaderParsingState == RequestHeaderParsingState.Headers)`
`@@ -515,14 +523,15 @@ private Task ProcessDataFrameAsync(in ReadOnlySequence<byte> payload)`
`515`	`523`	`// https://quicwg.org/base-drafts/draft-ietf-quic-http.html#section-4.1`
`516`	`524`	`if (_requestHeaderParsingState == RequestHeaderParsingState.Ready)`
`517`	`525`	`{`
`518`		`- throw new Http3StreamErrorException(CoreStrings.Http3StreamErrorDataReceivedBeforeHeaders, Http3ErrorCode.UnexpectedFrame);`
	`526`	`+ throw new Http3ConnectionErrorException(CoreStrings.Http3StreamErrorDataReceivedBeforeHeaders, Http3ErrorCode.UnexpectedFrame);`
`519`	`527`	`}`
`520`	`528`
`521`	`529`	`// DATA frame after trailing headers is invalid.`
`522`	`530`	`// https://quicwg.org/base-drafts/draft-ietf-quic-http.html#section-4.1`
`523`	`531`	`if (_requestHeaderParsingState == RequestHeaderParsingState.Trailers)`
`524`	`532`	`{`
`525`		`- throw new Http3StreamErrorException(CoreStrings.FormatHttp3StreamErrorFrameReceivedAfterTrailers(CoreStrings.FormatHttp3StreamErrorFrameReceivedAfterTrailers(Http3Formatting.ToFormattedType(Http3FrameType.Data))), Http3ErrorCode.UnexpectedFrame);`
	`533`	`+ var message = CoreStrings.FormatHttp3StreamErrorFrameReceivedAfterTrailers(CoreStrings.FormatHttp3StreamErrorFrameReceivedAfterTrailers(Http3Formatting.ToFormattedType(Http3FrameType.Data)));`
	`534`	`+ throw new Http3ConnectionErrorException(message, Http3ErrorCode.UnexpectedFrame);`
`526`	`535`	`}`
`527`	`536`
`528`	`537`	`if (InputRemaining.HasValue)`
Original file line number	Diff line number	Diff line change
`@@ -6,7 +6,7 @@`
`6`	`6`
`7`	`7`	`namespace Microsoft.AspNetCore.Server.Kestrel.Core.Internal.Http3`
`8`	`8`	`{`
`9`		`- class Http3StreamErrorException : Exception`
	`9`	`+ internal class Http3StreamErrorException : Exception`
`10`	`10`	`{`
`11`	`11`	`public Http3StreamErrorException(string message, Http3ErrorCode errorCode)`
`12`	`12`	`: base($"HTTP/3 stream error ({errorCode}): {message}")`
Original file line number	Diff line number	Diff line change
`@@ -329,7 +329,7 @@ public void InvalidResponseHeaderRemoved()`
`329`	`329`	`_invalidResponseHeaderRemoved(_logger, null);`
`330`	`330`	`}`
`331`	`331`
`332`		`- public void Http3ConnectionError(string connectionId, Http3ConnectionException ex)`
	`332`	`+ public void Http3ConnectionError(string connectionId, Http3ConnectionErrorException ex)`
`333`	`333`	`{`
`334`	`334`	`_http3ConnectionError(_logger, connectionId, ex);`
`335`	`335`	`}`
Original file line number	Diff line number	Diff line change
`@@ -245,7 +245,7 @@ public void InvalidResponseHeaderRemoved()`
`245`	`245`	`_trace2.InvalidResponseHeaderRemoved();`
`246`	`246`	`}`
`247`	`247`
`248`		`- public void Http3ConnectionError(string connectionId, Http3ConnectionException ex)`
	`248`	`+ public void Http3ConnectionError(string connectionId, Http3ConnectionErrorException ex)`
`249`	`249`	`{`
`250`	`250`	`_trace1.Http3ConnectionError(connectionId, ex);`
`251`	`251`	`_trace2.Http3ConnectionError(connectionId, ex);`
Original file line number	Diff line number	Diff line change
`@@ -1631,7 +1631,7 @@ public async Task DataBeforeHeaders_UnexpectedFrameError()`
`1631`	`1631`
`1632`	`1632`	`await requestStream.WaitForStreamErrorAsync(`
`1633`	`1633`	`Http3ErrorCode.UnexpectedFrame,`
`1634`		`- expectedErrorMessage: "The client sent a DATA frame before the HEADERS frame.");`
	`1634`	`+ expectedErrorMessage: CoreStrings.Http3StreamErrorDataReceivedBeforeHeaders);`
`1635`	`1635`	`}`
`1636`	`1636`
`1637`	`1637`	`[Fact]`