feat(http11): add h2c upgrade detection with IProtocolSwitchCapable signaling

Author: st0o0

src/TurboHTTP.Tests/Protocol/Syntax/Http11/Server/Http11UpgradeH2cSpec.cs

@@ -0,0 +1,120 @@
+using System.Text;
+using Akka.Actor;
+using Akka.Event;
+using Servus.Akka.Transport;
+using TurboHTTP.Protocol;
+using TurboHTTP.Protocol.Syntax.Http11.Server;
+using TurboHTTP.Protocol.Syntax.Http2.Server;
+using TurboHTTP.Server;
+using TurboHTTP.Streams.Stages.Server;
+
+namespace TurboHTTP.Tests.Protocol.Syntax.Http11.Server;
+
+public sealed class Http11UpgradeH2cSpec
+{
+    private sealed class FakeOps : IServerStageOperations
+    {
+        public List<HttpRequestMessage> EmittedRequests { get; } = [];
+        public List<ITransportOutbound> EmittedOutbound { get; } = [];
+        public ILoggingAdapter Log { get; } = NoLogger.Instance;
+        public IActorRef StageActor { get; set; } = ActorRefs.Nobody;
+
+        public void OnRequest(HttpRequestMessage request) => EmittedRequests.Add(request);
+        public void OnOutbound(ITransportOutbound item) => EmittedOutbound.Add(item);
+        public void OnScheduleTimer(string name, TimeSpan delay) { }
+        public void OnCancelTimer(string name) { }
+    }
+
+    private sealed class SwitchCapableOps : IServerStageOperations, IProtocolSwitchCapable
+    {
+        private readonly FakeOps _inner = new();
+        public Func<IServerStageOperations, IServerStateMachine>? SwitchFactory { get; private set; }
+
+        public List<HttpRequestMessage> EmittedRequests => _inner.EmittedRequests;
+        public List<ITransportOutbound> EmittedOutbound => _inner.EmittedOutbound;
+        public ILoggingAdapter Log => _inner.Log;
+        public IActorRef StageActor { get => _inner.StageActor; set => _inner.StageActor = value; }
+
+        public void OnRequest(HttpRequestMessage request) => _inner.OnRequest(request);
+        public void OnOutbound(ITransportOutbound item) => _inner.OnOutbound(item);
+        public void OnScheduleTimer(string name, TimeSpan delay) => _inner.OnScheduleTimer(name, delay);
+        public void OnCancelTimer(string name) => _inner.OnCancelTimer(name);
+
+        public void RequestProtocolSwitch(Func<IServerStageOperations, IServerStateMachine> newSmFactory)
+        {
+            SwitchFactory = newSmFactory;
+        }
+    }
+
+    private static TransportData MakeData(string raw)
+    {
+        var data = Encoding.ASCII.GetBytes(raw);
+        var buffer = TransportBuffer.Rent(data.Length);
+        data.CopyTo(buffer.FullMemory.Span);
+        buffer.Length = data.Length;
+        return new TransportData(buffer);
+    }
+
+    [Fact(Timeout = 5000)]
+    [Trait("RFC", "RFC9113-3.2")]
+    public void DecodeClientData_should_trigger_switch_when_upgrade_h2c_with_switchable_ops()
+    {
+        var ops = new SwitchCapableOps();
+        var sm = new Http11ServerStateMachine(new TurboServerOptions(), ops);
+
+        sm.DecodeClientData(MakeData(
+            "GET / HTTP/1.1\r\n" +
+            "Host: localhost\r\n" +
+            "Connection: Upgrade, HTTP2-Settings\r\n" +
+            "Upgrade: h2c\r\n" +
+            "HTTP2-Settings: AAMAAABkAAQBAAAAAAIAAAAA\r\n" +
+            "Content-Length: 0\r\n" +
+            "\r\n"));
+
+        Assert.NotNull(ops.SwitchFactory);
+        var outbound = ops.EmittedOutbound.OfType<TransportData>().ToList();
+        Assert.NotEmpty(outbound);
+        var responseText = Encoding.ASCII.GetString(outbound[0].Buffer.Span);
+        Assert.Contains("101", responseText);
+        Assert.Contains("Upgrade: h2c", responseText);
+    }
+
+    [Fact(Timeout = 5000)]
+    [Trait("RFC", "RFC9113-3.2")]
+    public void DecodeClientData_should_ignore_upgrade_when_ops_not_switchable()
+    {
+        var ops = new FakeOps();
+        var sm = new Http11ServerStateMachine(new TurboServerOptions(), ops);
+
+        sm.DecodeClientData(MakeData(
+            "GET / HTTP/1.1\r\n" +
+            "Host: localhost\r\n" +
+            "Connection: Upgrade, HTTP2-Settings\r\n" +
+            "Upgrade: h2c\r\n" +
+            "HTTP2-Settings: AAMAAABkAAQBAAAAAAIAAAAA\r\n" +
+            "Content-Length: 0\r\n" +
+            "\r\n"));
+
+        Assert.Single(ops.EmittedRequests);
+        Assert.Equal("GET", ops.EmittedRequests[0].Method.Method);
+    }
+
+    [Fact(Timeout = 5000)]
+    [Trait("RFC", "RFC9113-3.2")]
+    public void DecodeClientData_should_ignore_upgrade_without_http2_settings()
+    {
+        var ops = new SwitchCapableOps();
+        var sm = new Http11ServerStateMachine(new TurboServerOptions(), ops);
+
+        sm.DecodeClientData(MakeData(
+            "GET / HTTP/1.1\r\n" +
+            "Host: localhost\r\n" +
+            "Connection: Upgrade\r\n" +
+            "Upgrade: h2c\r\n" +
+            "Content-Length: 0\r\n" +
+            "\r\n"));
+
+        Assert.Null(ops.SwitchFactory);
+        Assert.Single(ops.EmittedRequests);
+    }
+}

src/TurboHTTP/Protocol/Syntax/Http11/Server/Http11ServerStateMachine.cs

@@ -1,6 +1,7 @@
 using Akka.Event;
 using Servus.Akka.Transport;
 using TurboHTTP.Protocol.Syntax.Http11.Options;
+using TurboHTTP.Protocol.Syntax.Http2.Server;
 using TurboHTTP.Server;
 using TurboHTTP.Streams;
 using TurboHTTP.Streams.Stages.Server;
@@ -21,6 +22,7 @@ internal sealed class Http11ServerStateMachine : IServerStateMachine
     private int _pendingResponseCount;
     private bool _outboundBodyPending;
     private bool _requestHeadersTimerActive;
+    private readonly TurboServerOptions _serverOptions;
 
     public bool CanAcceptResponse => !_outboundBodyPending && _pendingResponseCount > 0;
     public bool ShouldComplete { get; private set; }
@@ -29,6 +31,7 @@ public Http11ServerStateMachine(TurboServerOptions options, IServerStageOperatio
     {
         _ops = ops ?? throw new ArgumentNullException(nameof(ops));
         ArgumentNullException.ThrowIfNull(options);
+        _serverOptions = options;
 
         var shared = SharedHttpOptions.Default with
         {
@@ -121,6 +124,12 @@ public void DecodeClientData(ITransportInbound data)
                     ShouldComplete = true;
                 }
 
+                if (TryHandleH2cUpgrade(request))
+                {
+                    _decoder.Reset();
+                    break;
+                }
+
                 _pendingResponseCount++;
                 _ops.OnRequest(request);
                 _decoder.Reset();
@@ -219,6 +228,36 @@ public void OnBodyMessage(object msg)
         }
     }
 
+    private bool TryHandleH2cUpgrade(HttpRequestMessage request)
+    {
+        if (_ops is not IProtocolSwitchCapable switchable)
+        {
+            return false;
+        }
+
+        if (!request.Headers.TryGetValues("Upgrade", out var upgradeValues)
+            || !upgradeValues.Any(v => v.Equals("h2c", StringComparison.OrdinalIgnoreCase)))
+        {
+            return false;
+        }
+
+        if (!request.Headers.TryGetValues("HTTP2-Settings", out _))
+        {
+            return false;
+        }
+
+        var responseBytes = "HTTP/1.1 101 Switching Protocols\r\nConnection: Upgrade\r\nUpgrade: h2c\r\n\r\n"u8;
+        var responseBuffer = TransportBuffer.Rent(responseBytes.Length);
+        responseBytes.CopyTo(responseBuffer.FullMemory.Span);
+        responseBuffer.Length = responseBytes.Length;
+        _ops.OnOutbound(new TransportData(responseBuffer));
+
+        switchable.RequestProtocolSwitch(
+            ops => new Http2ServerStateMachine(_serverOptions, ops));
+
+        return true;
+    }
+
     public void Cleanup()
     {
         _encoder.CancelActiveBody();