Ingoring unknown frames as well resreved frames

Author: ladeak

src/CHttpServer/CHttpServer/Http3/Http3Connection.cs

@@ -257,16 +257,21 @@ private async Task ProcessControlStreamAsync()
                 var buffer = readResult.Buffer;
 
                 if (!VariableLenghtIntegerDecoder.TryRead(buffer.FirstSpan, out ulong frameType, out int bytesRead))
-                    Abort(ErrorCodes.H3FrameError);
+                {
+                    // Not enough data.
+                    _clientControlStreamReader.AdvanceTo(buffer.Start, buffer.End);
+                    continue;
+                }
 
+                long processed = bytesRead;
                 if (!VariableLenghtIntegerDecoder.TryRead(buffer.Slice(bytesRead), out ulong payloadLength, out bytesRead))
                 {
                     // Not enough data.
                     _clientControlStreamReader.AdvanceTo(buffer.Start, buffer.End);
                     continue;
                 }
 
-                long processed = 1 + bytesRead; // 1 for the frame type. Should be always one byte by spec.
+                processed += bytesRead;
                 switch (frameType)
                 {
                     case 0x03: // CANCEL_PUSH
@@ -299,14 +304,19 @@ private async Task ProcessControlStreamAsync()
                         processed += checked((long)payloadLength);
                         break;
                     default:
-                        // Reserved frame types
-                        if ((frameType - 32) % 31 == 0)
+                        if (frameType < 3 || frameType == 5 || frameType == 6 || frameType == 8 || frameType == 9)
+                        {
+                            // HTTP/2 frame types that are not supported in HTTP/3 must return error.
+                            Abort(ErrorCodes.H3FrameUnexpected);
+                            break;
+                        }
+                        else
                         {
+                            // Reserved frame types, and unknown frame types ignored.
                             processed += checked((long)payloadLength);
                             break;
+
                         }
-                        Abort(ErrorCodes.H3FrameUnexpected);
-                        break;
                 }
 
                 _clientControlStreamReader.AdvanceTo(readResult.Buffer.GetPosition(processed));

tests/CHttpServer.Tests/Http3/Http3ConnectionTests.cs

@@ -110,8 +110,15 @@ public async Task ClientAbortsConnection()
         await processing;
     }
 
-    [Fact]
-    public async Task InvalidFrameTypeOnControlStream_Aborts()
+    [Theory]
+    [InlineData(0)]
+    [InlineData(1)]
+    [InlineData(2)]
+    [InlineData(5)]
+    [InlineData(6)]
+    [InlineData(8)]
+    [InlineData(9)]
+    public async Task InvalidFrameTypeOnControlStream_Aborts(int frameType)
     {
         await using var fixture = await QuicConnectionFixture.SetupConnectionAsync(Port, TestContext.Current.CancellationToken);
         Http3Connection sut = CreateHttp3Connection(fixture.ServerConnection);
@@ -125,8 +132,43 @@ public async Task InvalidFrameTypeOnControlStream_Aborts()
         }, TestContext.Current.CancellationToken);
         var clientControlStream = await fixture.ClientConnection.OpenOutboundStreamAsync(QuicStreamType.Unidirectional, TestContext.Current.CancellationToken);
 
-        // StreamType: 0-control, FrameType: 4-Headers, Length: 0
-        byte[] data = [0, 1, 0];
+        // StreamType: 0-control, FrameType: 1-Invalid, Length: 0
+        byte[] data = [0, (byte)frameType, 0];
+        await clientControlStream.WriteAsync(data, TestContext.Current.CancellationToken);
+        await clientControlStream.FlushAsync(TestContext.Current.CancellationToken);
+
+        await readServerControlStream;
+        await processing;
+    }
+
+    [Theory]
+    [InlineData(1 * 31 + 33)]
+    [InlineData(2 * 31 + 33)]
+    [InlineData(0x0f0700)]
+    public async Task UnknownFrameType_OnControlStream_ISgnored(int frameType)
+    {
+        await using var fixture = await QuicConnectionFixture.SetupConnectionAsync(Port, TestContext.Current.CancellationToken);
+        Http3Connection sut = CreateHttp3Connection(fixture.ServerConnection);
+        var processing = sut.ProcessConnectionAsync(new TestBase.TestApplication(_ => Task.CompletedTask))
+            .WaitAsync(TimeSpan.FromSeconds(10), TestContext.Current.CancellationToken);
+        var readServerControlStream = Task.Run(async () =>
+        {
+            var controlStream = await fixture.ClientConnection.AcceptInboundStreamAsync(TestContext.Current.CancellationToken);
+            await AssertReadSettigsAsync(controlStream);
+            await AssertGoAwayAsync(controlStream, 2);
+        }, TestContext.Current.CancellationToken);
+        var clientControlStream = await fixture.ClientConnection.OpenOutboundStreamAsync(QuicStreamType.Unidirectional, TestContext.Current.CancellationToken);
+
+        // StreamType: 0-control, FrameType, Length: 0
+        Span<byte> buffer = stackalloc byte[8];
+        VariableLenghtIntegerDecoder.TryWrite(buffer, frameType, out var length);
+
+        byte[] data = [0, .. buffer[..length], 0];
+        await clientControlStream.WriteAsync(data, TestContext.Current.CancellationToken);
+        await clientControlStream.FlushAsync(TestContext.Current.CancellationToken);
+
+        // Write GOAWAY FrameType: 7, Length: 1, StreamId: 0
+        data = [7, 1, 0];
         await clientControlStream.WriteAsync(data, TestContext.Current.CancellationToken);
         await clientControlStream.FlushAsync(TestContext.Current.CancellationToken);