More test

Author: JamesNK

src/Servers/Kestrel/Core/src/CoreStrings.resx

@@ -677,4 +677,7 @@ For more information on configuring HTTPS see https://go.microsoft.com/fwlink/?l
   <data name="Http3ErrorControlStreamReservedSetting" xml:space="preserve">
     <value>The client sent a reserved setting identifier: {identifier}</value>
   </data>
-</root>
+  <data name="Http3ControlStreamErrorMultipleInboundStreams" xml:space="preserve">
+    <value>The client created multiple inbound {streamType} streams for the connection.</value>
+  </data>
+</root>

src/Servers/Kestrel/Core/src/Internal/Http3/Http3ControlStream.cs

@@ -147,45 +147,53 @@ private async ValueTask<long> TryReadStreamIdAsync()
 
         public async Task ProcessRequestAsync<TContext>(IHttpApplication<TContext> application) where TContext : notnull
         {
-            var streamType = await TryReadStreamIdAsync();
-
-            if (streamType == -1)
+            try
             {
-                return;
-            }
+                var streamType = await TryReadStreamIdAsync();
 
-            if (streamType == ControlStream)
-            {
-                if (!_http3Connection.SetInboundControlStream(this))
+                if (streamType == -1)
                 {
-                    // 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);
+                    return;
                 }
 
-                await HandleControlStream();
-            }
-            else if (streamType == EncoderStream)
-            {
-                if (!_http3Connection.SetInboundEncoderStream(this))
+                if (streamType == ControlStream)
                 {
-                    // 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);
+                    if (!_http3Connection.SetInboundControlStream(this))
+                    {
+                        // https://quicwg.org/base-drafts/draft-ietf-quic-http.html#section-6.2.1
+                        throw new Http3ConnectionErrorException(CoreStrings.FormatHttp3ControlStreamErrorMultipleInboundStreams("control"), Http3ErrorCode.StreamCreationError);
+                    }
+
+                    await HandleControlStream();
                 }
+                else if (streamType == EncoderStream)
+                {
+                    if (!_http3Connection.SetInboundEncoderStream(this))
+                    {
+                        // https://quicwg.org/base-drafts/draft-ietf-quic-qpack.html#section-4.2
+                        throw new Http3ConnectionErrorException(CoreStrings.FormatHttp3ControlStreamErrorMultipleInboundStreams("encoder"), Http3ErrorCode.StreamCreationError);
+                    }
 
-                await HandleEncodingDecodingTask();
-            }
-            else if (streamType == DecoderStream)
-            {
-                if (!_http3Connection.SetInboundDecoderStream(this))
+                    await HandleEncodingDecodingTask();
+                }
+                else if (streamType == DecoderStream)
+                {
+                    if (!_http3Connection.SetInboundDecoderStream(this))
+                    {
+                        // https://quicwg.org/base-drafts/draft-ietf-quic-qpack.html#section-4.2
+                        throw new Http3ConnectionErrorException(CoreStrings.FormatHttp3ControlStreamErrorMultipleInboundStreams("decoder"), Http3ErrorCode.StreamCreationError);
+                    }
+                    await HandleEncodingDecodingTask();
+                }
+                else
                 {
-                    // 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);
+                    // TODO Close the control stream as it's unexpected.
                 }
-                await HandleEncodingDecodingTask();
             }
-            else
+            catch (Http3ConnectionErrorException ex)
             {
-                // TODO Close the control stream as it's unexpected.
+                Log.Http3ConnectionError(_http3Connection.ConnectionId, ex);
+                _http3Connection.Abort(new ConnectionAbortedException(ex.Message, ex), ex.ErrorCode);
             }
         }
 

src/Servers/Kestrel/test/InMemory.FunctionalTests/Http3/Http3ConnectionTests.cs

@@ -90,7 +90,25 @@ await WaitForConnectionErrorAsync<Http3ConnectionErrorException>(
                 ignoreNonGoAwayFrames: true,
                 expectedLastStreamId: 0,
                 expectedErrorCode: Http3ErrorCode.SettingsError,
-                expectedErrorMessage: $"HTTP/3 connection error (SettingsError): The client sent a reserved setting identifier: 0x{settingIdentifier.ToString("X", CultureInfo.InvariantCulture)}");
+                expectedErrorMessage: CoreStrings.FormatHttp3ErrorControlStreamReservedSetting($"0x{settingIdentifier.ToString("X", CultureInfo.InvariantCulture)}"));
+        }
+
+        [Theory]
+        [InlineData(0, "control")]
+        [InlineData(2, "encoder")]
+        [InlineData(3, "decoder")]
+        public async Task InboundStreams_CreateMultiple_ConnectionError(int streamId, string name)
+        {
+            await InitializeConnectionAsync(_noopApplication);
+
+            await CreateControlStream(streamId);
+            await CreateControlStream(streamId);
+
+            await WaitForConnectionErrorAsync<Http3ConnectionErrorException>(
+                ignoreNonGoAwayFrames: true,
+                expectedLastStreamId: 0,
+                expectedErrorCode: Http3ErrorCode.StreamCreationError,
+                expectedErrorMessage: CoreStrings.FormatHttp3ControlStreamErrorMultipleInboundStreams(name));
         }
     }
 }

src/Servers/Kestrel/test/InMemory.FunctionalTests/Http3/Http3TestBase.cs

@@ -121,20 +121,27 @@ internal async ValueTask<Http3ControlStream> GetInboundControlStream()
         {
             if (_inboundControlStream == null)
             {
-                var reader = MultiplexedConnectionContext.ToClientAcceptQueue.Reader;
-                while (await reader.WaitToReadAsync())
+                return await CreateNewInboundControlStream();
+            }
+
+            return null;
+        }
+
+        internal async ValueTask<Http3ControlStream> CreateNewInboundControlStream()
+        {
+            var reader = MultiplexedConnectionContext.ToClientAcceptQueue.Reader;
+            while (await reader.WaitToReadAsync())
+            {
+                while (reader.TryRead(out var stream))
                 {
-                    while (reader.TryRead(out var stream))
-                    {
-                        _inboundControlStream = stream;
-                        var streamId = await stream.TryReadStreamIdAsync();
-                        Debug.Assert(streamId == 0, "StreamId sent that was non-zero, which isn't handled by tests");
-                        return _inboundControlStream;
-                    }
+                    _inboundControlStream = stream;
+                    var streamId = await stream.TryReadStreamIdAsync();
+                    Debug.Assert(streamId == 0, "StreamId sent that was non-zero, which isn't handled by tests");
+                    return _inboundControlStream;
                 }
-            }    
-            
-            return null;
+            }
+
+            throw new InvalidOperationException("Should never reach here.");
         }
 
         internal async Task WaitForConnectionErrorAsync<TException>(bool ignoreNonGoAwayFrames, long expectedLastStreamId, Http3ErrorCode expectedErrorCode, params string[] expectedErrorMessage)
@@ -152,7 +159,7 @@ internal async Task WaitForConnectionErrorAsync<TException>(bool ignoreNonGoAway
 
             VerifyGoAway(frame, expectedLastStreamId);
 
-            Assert.Equal((long)expectedErrorCode, MultiplexedConnectionContext.Error);
+            Assert.Equal((Http3ErrorCode)expectedErrorCode, (Http3ErrorCode)MultiplexedConnectionContext.Error);
 
             if (expectedErrorMessage?.Length > 0)
             {
@@ -180,6 +187,8 @@ protected async Task InitializeConnectionAsync(RequestDelegate application)
             // Skip all heartbeat and lifetime notification feature registrations.
             _connectionTask = Connection.ProcessStreamsAsync(new DummyApplication(application));
 
+            await GetInboundControlStream();
+
             await Task.CompletedTask;
         }
 
@@ -189,8 +198,6 @@ internal async ValueTask<Http3RequestStream> InitializeConnectionAndStreamsAsync
 
             OutboundControlStream = await CreateControlStream();
 
-            await GetInboundControlStream();
-
             return await CreateRequestStream();
         }