Implement HTTP/2 WebSockets

src/libraries/Common/tests/System/Net/Http/Http2Frames.cs

@@ -44,7 +44,8 @@ public enum SettingId : ushort
         MaxConcurrentStreams = 0x3,
         InitialWindowSize = 0x4,
         MaxFrameSize = 0x5,
-        MaxHeaderListSize = 0x6
+        MaxHeaderListSize = 0x6,
+        EnableConnect = 0x8
     }
 
     public class Frame

src/libraries/Common/tests/System/Net/Http/Http2LoopbackServer.cs

@@ -44,6 +44,10 @@ public override Uri Address
                     localEndPoint.Address.ToString();
 
                 string scheme = _options.UseSsl ? "https" : "http";
+                if (_options.WebSocketEndpoint)
+                {
+                    scheme = _options.UseSsl ? "wss" : "ws";
+                }
 
                 _uri = new Uri($"{scheme}://{host}:{localEndPoint.Port}/");
 
@@ -177,6 +181,7 @@ public static async Task CreateClientAndServerAsync(Func<Uri, Task> clientFunc,
 
     public class Http2Options : GenericLoopbackOptions
     {
+        public bool WebSocketEndpoint { get; set; } = false;
         public bool ClientCertificateRequired { get; set; }
 
         public bool EnableTransparentPingResponse { get; set; } = true;

src/libraries/Common/tests/System/Net/Http/HttpClientHandlerTest.cs

@@ -1031,7 +1031,7 @@ await LoopbackServerFactory.CreateClientAndServerAsync(async uri =>
                         Assert.Equal(PlatformDetection.IsBrowser && !enableWasmStreaming, responseStream.CanSeek);
 
                         // Not supported operations
-                        Assert.Throws<NotSupportedException>(() => responseStream.BeginWrite(new byte[1], 0, 1, null, null));
+                        await Assert.ThrowsAsync<NotSupportedException>(async () => await Task.Factory.FromAsync(responseStream.BeginWrite, responseStream.EndWrite, new byte[1], 0, 1, null));
                         if (!responseStream.CanSeek)
                         {
                             Assert.Throws<NotSupportedException>(() => responseStream.Length);

src/libraries/System.Net.Http/ref/System.Net.Http.cs

@@ -231,6 +231,7 @@ public HttpMethod(string method) { }
         public static System.Net.Http.HttpMethod Post { get { throw null; } }
         public static System.Net.Http.HttpMethod Put { get { throw null; } }
         public static System.Net.Http.HttpMethod Trace { get { throw null; } }
+        public static System.Net.Http.HttpMethod Connect { get { throw null; } }
         public bool Equals([System.Diagnostics.CodeAnalysis.NotNullWhen(true)] System.Net.Http.HttpMethod? other) { throw null; }
         public override bool Equals([System.Diagnostics.CodeAnalysis.NotNullWhen(true)] object? obj) { throw null; }
         public override int GetHashCode() { throw null; }
@@ -656,6 +657,7 @@ internal HttpRequestHeaders() { }
         public System.DateTimeOffset? IfUnmodifiedSince { get { throw null; } set { } }
         public int? MaxForwards { get { throw null; } set { } }
         public System.Net.Http.Headers.HttpHeaderValueCollection<System.Net.Http.Headers.NameValueHeaderValue> Pragma { get { throw null; } }
+        public string? Protocol { get { throw null; } set { } }
         public System.Net.Http.Headers.AuthenticationHeaderValue? ProxyAuthorization { get { throw null; } set { } }
         public System.Net.Http.Headers.RangeHeaderValue? Range { get { throw null; } set { } }
         public System.Uri? Referrer { get { throw null; } set { } }

src/libraries/System.Net.Http/src/Resources/Strings.resx

@@ -168,6 +168,9 @@
   <data name="net_http_content_readonly_stream" xml:space="preserve">
     <value>The stream does not support writing.</value>
   </data>
+  <data name="net_http_content_writeonly_stream" xml:space="preserve">
+    <value>The stream does not support reading.</value>
+  </data>
   <data name="net_http_content_invalid_charset" xml:space="preserve">
     <value>The character set provided in ContentType is invalid. Cannot read content as string using an invalid character set.</value>
   </data>
@@ -564,4 +567,7 @@
   <data name="net_http_chunk_too_large" xml:space="preserve">
     <value>The HTTP/1.1 response chunk was too large.</value>
   </data>
-</root>
+    <data name="net_unsupported_extended_connect" xml:space="preserve">
+    <value>Extended CONNECT is not supported.</value>
+  </data>
+</root>

src/libraries/System.Net.Http/src/System/Net/Http/Headers/HttpRequestHeaders.cs

@@ -159,6 +159,7 @@ public int? MaxForwards
             set { SetOrRemoveParsedValue(KnownHeaders.MaxForwards.Descriptor, value); }
         }
 
+        public string? Protocol { get; set; }
 
         public AuthenticationHeaderValue? ProxyAuthorization
         {

src/libraries/System.Net.Http/src/System/Net/Http/HttpMethod.cs

@@ -67,7 +67,7 @@ public static HttpMethod Patch
         // Don't expose CONNECT as static property, since it's used by the transport to connect to a proxy.
         // CONNECT is not used by users directly.
 
-        internal static HttpMethod Connect
+        public static HttpMethod Connect
         {
             get { return s_connectMethod; }
         }

src/libraries/System.Net.Http/src/System/Net/Http/HttpRequestMessage.cs

@@ -168,6 +168,8 @@ public override string ToString()
 
         internal bool WasRedirected() => (_sendStatus & MessageIsRedirect) != 0;
 
+        internal bool IsWebSocketH2Request() => _version.Major == 2 && Method == HttpMethod.Connect && HasHeaders && string.Equals(Headers.Protocol, "websocket", StringComparison.OrdinalIgnoreCase);
+
         #region IDisposable Members
 
         protected virtual void Dispose(bool disposing)

src/libraries/System.Net.Http/src/System/Net/Http/SocketsHttpHandler/Http2Connection.cs

@@ -8,7 +8,6 @@
 using System.IO;
 using System.Net.Http.Headers;
 using System.Net.Http.HPack;
-using System.Net.Security;
 using System.Runtime.CompilerServices;
 using System.Text;
 using System.Threading;
@@ -19,6 +18,9 @@ namespace System.Net.Http
 {
     internal sealed partial class Http2Connection : HttpConnectionBase
     {
+        // Equivalent to the bytes returned from HPackEncoder.EncodeLiteralHeaderFieldWithoutIndexingNewNameToAllocatedArray(":protocol")
+        private static ReadOnlySpan<byte> ProtocolLiteralHeaderBytes => new byte[] { 0x0, 0x9, 0x3a, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x63, 0x6f, 0x6c };
+
         private readonly HttpConnectionPool _pool;
         private readonly Stream _stream;
 
@@ -826,17 +828,33 @@ private void ProcessSettingsFrame(FrameHeader frameHeader, bool initialFrame = f
                             // We don't actually store this value; we always send frames of the minimum size (16K).
                             break;
 
+                        case SettingId.EnableConnect:
+                            if (settingValue == 1)
+                            {
+                                IsConnectEnabled = true;
+                            }
+                            break;
+
                         default:
                             // All others are ignored because we don't care about them.
                             // Note, per RFC, unknown settings IDs should be ignored.
                             break;
                     }
                 }
 
-                if (initialFrame && !maxConcurrentStreamsReceived)
+                if (initialFrame)
                 {
-                    // Set to 'infinite' because MaxConcurrentStreams was not set on the initial SETTINGS frame.
-                    ChangeMaxConcurrentStreams(int.MaxValue);
+                    if (!maxConcurrentStreamsReceived)
+                    {
+                        // Set to 'infinite' because MaxConcurrentStreams was not set on the initial SETTINGS frame.
+                        ChangeMaxConcurrentStreams(int.MaxValue);
+                    }
+
+                    if (_initialSettingsReceived is null)
+                    {
+                        Interlocked.CompareExchange(ref _initialSettingsReceived, s_settingsReceivedSingleton, null);
+                    }
+                    InitialSettingsReceived.TrySetResult(true);
                 }
 
                 _incomingBuffer.Discard(frameHeader.PayloadLength);
@@ -1448,6 +1466,14 @@ private void WriteHeaders(HttpRequestMessage request, ref ArrayBuffer headerBuff
 
             if (request.HasHeaders)
             {
+                if (request.Headers.Protocol != null)
+                {
+                    HttpHeaders.CheckContainsNewLine(request.Headers.Protocol);
+                    WriteBytes(ProtocolLiteralHeaderBytes, ref headerBuffer);
+                    Encoding? protocolEncoding = _pool.Settings._requestHeaderEncodingSelector?.Invoke(":protocol", request);
+                    WriteLiteralHeaderValue(request.Headers.Protocol, protocolEncoding, ref headerBuffer);
+                }
+
                 WriteHeaderCollection(request, request.Headers, ref headerBuffer);
             }
 
@@ -1888,8 +1914,26 @@ private enum SettingId : ushort
             MaxConcurrentStreams = 0x3,
             InitialWindowSize = 0x4,
             MaxFrameSize = 0x5,
-            MaxHeaderListSize = 0x6
+            MaxHeaderListSize = 0x6,
+            EnableConnect = 0x8
+        }
+
+        private static readonly TaskCompletionSourceWithCancellation<bool> s_settingsReceivedSingleton = CreateSuccessfullyCompleted();
+
+        internal TaskCompletionSourceWithCancellation<bool> InitialSettingsReceived =>
+            _initialSettingsReceived ??
+            Interlocked.CompareExchange(ref _initialSettingsReceived, new(), null) ??
+            _initialSettingsReceived;
+
+        private TaskCompletionSourceWithCancellation<bool>? _initialSettingsReceived;
+
+        private static TaskCompletionSourceWithCancellation<bool> CreateSuccessfullyCompleted()
+        {
+            var tcs = new TaskCompletionSourceWithCancellation<bool>();
+            tcs.TrySetResult(true);
+            return tcs;
         }
+        internal bool IsConnectEnabled { get; private set; }
 
         // Note that this is safe to be called concurrently by multiple threads.