More compression

BrennanConroy · BrennanConroy · commit cb6d83a4c7a5 · 2021-05-11T16:04:54.000-07:00
diff --git a/src/Http/Headers/src/HeaderNames.cs b/src/Http/Headers/src/HeaderNames.cs
@@ -225,6 +225,9 @@ public static class HeaderNames
         /// <summary>Gets the <c>Sec-WebSocket-Version</c> HTTP header name.</summary>
         public static readonly string SecWebSocketVersion = "Sec-WebSocket-Version";
 
+        /// <summary>Gets the <c>Sec-WebSocket-Extensions</c> HTTP header name.</summary>
+        public static readonly string SecWebSocketExtensions = "Sec-WebSocket-Extensions";
+
         /// <summary>Gets the <c>Server</c> HTTP header name.</summary>
         public static readonly string Server = "Server";
 
diff --git a/src/Http/Headers/src/PublicAPI.Unshipped.txt b/src/Http/Headers/src/PublicAPI.Unshipped.txt
@@ -5,6 +5,7 @@ Microsoft.Net.Http.Headers.RangeConditionHeaderValue.RangeConditionHeaderValue(M
 static readonly Microsoft.Net.Http.Headers.HeaderNames.Baggage -> string!
 static readonly Microsoft.Net.Http.Headers.HeaderNames.Link -> string!
 static readonly Microsoft.Net.Http.Headers.HeaderNames.ProxyConnection -> string!
+static readonly Microsoft.Net.Http.Headers.HeaderNames.SecWebSocketExtensions -> string!
 static readonly Microsoft.Net.Http.Headers.HeaderNames.XContentTypeOptions -> string!
 static readonly Microsoft.Net.Http.Headers.HeaderNames.XPoweredBy -> string!
 static readonly Microsoft.Net.Http.Headers.HeaderNames.XUACompatible -> string!
diff --git a/src/Http/Http.Abstractions/src/PublicAPI.Unshipped.txt b/src/Http/Http.Abstractions/src/PublicAPI.Unshipped.txt
@@ -23,3 +23,4 @@ abstract Microsoft.AspNetCore.Http.HttpRequest.ContentType.get -> string?
 static Microsoft.AspNetCore.Builder.UseExtensions.Use(this Microsoft.AspNetCore.Builder.IApplicationBuilder! app, System.Func<Microsoft.AspNetCore.Http.HttpContext!, Microsoft.AspNetCore.Http.RequestDelegate!, System.Threading.Tasks.Task!>! middleware) -> Microsoft.AspNetCore.Builder.IApplicationBuilder!
 static Microsoft.AspNetCore.Builder.UseMiddlewareExtensions.UseMiddleware(this Microsoft.AspNetCore.Builder.IApplicationBuilder! app, System.Type! middleware, params object?[]! args) -> Microsoft.AspNetCore.Builder.IApplicationBuilder!
 static Microsoft.AspNetCore.Builder.UseMiddlewareExtensions.UseMiddleware<TMiddleware>(this Microsoft.AspNetCore.Builder.IApplicationBuilder! app, params object?[]! args) -> Microsoft.AspNetCore.Builder.IApplicationBuilder!
+virtual Microsoft.AspNetCore.Http.WebSocketManager.AcceptWebSocketAsync(Microsoft.AspNetCore.Http.WebSocketAcceptContext! acceptContext) -> System.Threading.Tasks.Task<System.Net.WebSockets.WebSocket!>!
diff --git a/src/Http/Http.Abstractions/src/WebSocketManager.cs b/src/Http/Http.Abstractions/src/WebSocketManager.cs
@@ -1,14 +1,15 @@
 // 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.Collections.Generic;
 using System.Net.WebSockets;
 using System.Threading.Tasks;
 
 namespace Microsoft.AspNetCore.Http
 {
     /// <summary>
-    /// Manages the establishment of WebSocket connections for a specific HTTP request. 
+    /// Manages the establishment of WebSocket connections for a specific HTTP request.
     /// </summary>
     public abstract class WebSocketManager
     {
@@ -37,5 +38,12 @@ public virtual Task<WebSocket> AcceptWebSocketAsync()
         /// <param name="subProtocol">The sub-protocol to use.</param>
         /// <returns>A task representing the completion of the transition.</returns>
         public abstract Task<WebSocket> AcceptWebSocketAsync(string? subProtocol);
+
+        /// <summary>
+        ///
+        /// </summary>
+        /// <param name="acceptContext"></param>
+        /// <returns></returns>
+        public virtual Task<WebSocket> AcceptWebSocketAsync(WebSocketAcceptContext acceptContext) => throw new NotImplementedException();
     }
 }
diff --git a/src/Http/Http.Features/src/IHeaderDictionary.Keyed.cs b/src/Http/Http.Features/src/IHeaderDictionary.Keyed.cs
@@ -202,6 +202,9 @@ public partial interface IHeaderDictionary
         /// <summary>Gets or sets the <c>Sec-WebSocket-Version</c> HTTP header.</summary>
         StringValues SecWebSocketVersion { get => this[HeaderNames.SecWebSocketVersion]; set => this[HeaderNames.SecWebSocketVersion] = value; }
 
+        /// <summary>Gets or sets the <c>Sec-WebSocket-Extensions</c> HTTP header.</summary>
+        StringValues SecWebSocketExtensions { get => this[HeaderNames.SecWebSocketExtensions]; set => this[HeaderNames.SecWebSocketExtensions] = value; }
+
         /// <summary>Gets or sets the <c>Server</c> HTTP header.</summary>
         StringValues Server { get => this[HeaderNames.Server]; set => this[HeaderNames.Server] = value; }
 
diff --git a/src/Http/Http.Features/src/PublicAPI.Unshipped.txt b/src/Http/Http.Features/src/PublicAPI.Unshipped.txt
@@ -161,6 +161,8 @@ Microsoft.AspNetCore.Http.IHeaderDictionary.RetryAfter.get -> Microsoft.Extensio
 Microsoft.AspNetCore.Http.IHeaderDictionary.RetryAfter.set -> void
 Microsoft.AspNetCore.Http.IHeaderDictionary.SecWebSocketAccept.get -> Microsoft.Extensions.Primitives.StringValues
 Microsoft.AspNetCore.Http.IHeaderDictionary.SecWebSocketAccept.set -> void
+Microsoft.AspNetCore.Http.IHeaderDictionary.SecWebSocketExtensions.get -> Microsoft.Extensions.Primitives.StringValues
+Microsoft.AspNetCore.Http.IHeaderDictionary.SecWebSocketExtensions.set -> void
 Microsoft.AspNetCore.Http.IHeaderDictionary.SecWebSocketKey.get -> Microsoft.Extensions.Primitives.StringValues
 Microsoft.AspNetCore.Http.IHeaderDictionary.SecWebSocketKey.set -> void
 Microsoft.AspNetCore.Http.IHeaderDictionary.SecWebSocketProtocol.get -> Microsoft.Extensions.Primitives.StringValues
diff --git a/src/Http/Http/src/Internal/DefaultWebSocketManager.cs b/src/Http/Http/src/Internal/DefaultWebSocketManager.cs
@@ -61,12 +61,17 @@ public override IList<string> WebSocketRequestedProtocols
         }
 
         public override Task<WebSocket> AcceptWebSocketAsync(string? subProtocol)
+        {
+            return AcceptWebSocketAsync(new WebSocketAcceptContext() { SubProtocol = subProtocol });
+        }
+
+        public override Task<WebSocket> AcceptWebSocketAsync(WebSocketAcceptContext acceptContext)
         {
             if (WebSocketFeature == null)
             {
                 throw new NotSupportedException("WebSockets are not supported");
             }
-            return WebSocketFeature.AcceptAsync(new WebSocketAcceptContext() { SubProtocol = subProtocol });
+            return WebSocketFeature.AcceptAsync(acceptContext);
         }
 
         struct FeatureInterfaces
diff --git a/src/Middleware/WebSockets/src/ExtendedWebSocketAcceptContext.cs b/src/Middleware/WebSockets/src/ExtendedWebSocketAcceptContext.cs
@@ -2,6 +2,7 @@
 // Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
 
 using System;
+using System.Net.WebSockets;
 using Microsoft.AspNetCore.Http;
 
 namespace Microsoft.AspNetCore.WebSockets
@@ -24,5 +25,10 @@ public class ExtendedWebSocketAcceptContext : WebSocketAcceptContext
         /// The interval to send pong frames. This is a heart-beat that keeps the connection alive.
         /// </summary>
         public TimeSpan? KeepAliveInterval { get; set; }
+
+        /// <summary>
+        ///
+        /// </summary>
+        public WebSocketCreationOptions? WebSocketOptions { get; set; }
     }
 }
diff --git a/src/Middleware/WebSockets/src/HandshakeHelpers.cs b/src/Middleware/WebSockets/src/HandshakeHelpers.cs
@@ -2,6 +2,9 @@
 // Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
 
 using System;
+using System.Diagnostics.CodeAnalysis;
+using System.Globalization;
+using System.Net.WebSockets;
 using System.Security.Cryptography;
 using System.Text;
 using Microsoft.AspNetCore.Http;
@@ -72,5 +75,89 @@ public static string CreateResponseKey(string requestKey)
 
             return Convert.ToBase64String(hashedBytes);
         }
+
+        public static bool ParseDeflateOptions(ReadOnlySpan<char> extension, WebSocketDeflateOptions options, [NotNullWhen(true)] out string? response)
+        {
+            response = null;
+            var builder = new StringBuilder(WebSocketDeflateConstants.MaxExtensionLength);
+            builder.Append(WebSocketDeflateConstants.Extension);
+
+            while (true)
+            {
+                int end = extension.IndexOf(';');
+                ReadOnlySpan<char> value = (end >= 0 ? extension[..end] : extension).Trim();
+
+                if (value.Length > 0)
+                {
+                    if (value.SequenceEqual(WebSocketDeflateConstants.ClientNoContextTakeover))
+                    {
+                        // REVIEW: If someone specifies true for server options, do we allow client to override this?
+                        options.ClientContextTakeover = false;
+                        builder.Append("; ").Append(WebSocketDeflateConstants.ClientNoContextTakeover);
+                    }
+                    else if (value.SequenceEqual(WebSocketDeflateConstants.ServerNoContextTakeover))
+                    {
+                        options.ServerContextTakeover = false;
+                        builder.Append("; ").Append(WebSocketDeflateConstants.ServerNoContextTakeover);
+                    }
+                    else if (value.StartsWith(WebSocketDeflateConstants.ClientMaxWindowBits))
+                    {
+                        var clientMaxWindowBits = ParseWindowBits(value, WebSocketDeflateConstants.ClientMaxWindowBits);
+                        if (clientMaxWindowBits > options.ClientMaxWindowBits)
+                        {
+                            return false;
+                        }
+                        // if client didn't send a value for ClientMaxWindowBits use the value the server set
+                        options.ClientMaxWindowBits = clientMaxWindowBits ?? options.ClientMaxWindowBits;
+                        builder.Append("; ").Append(WebSocketDeflateConstants.ClientMaxWindowBits).Append('=')
+                            .Append(options.ClientMaxWindowBits.ToString(CultureInfo.InvariantCulture));
+                    }
+                    else if (value.StartsWith(WebSocketDeflateConstants.ServerMaxWindowBits))
+                    {
+                        var serverMaxWindowBits = ParseWindowBits(value, WebSocketDeflateConstants.ServerMaxWindowBits);
+                        if (serverMaxWindowBits > options.ServerMaxWindowBits)
+                        {
+                            return false;
+                        }
+                        // if client didn't send a value for ServerMaxWindowBits use the value the server set
+                        options.ServerMaxWindowBits = serverMaxWindowBits ?? options.ServerMaxWindowBits;
+
+                        builder.Append("; ")
+                            .Append(WebSocketDeflateConstants.ServerMaxWindowBits).Append('=')
+                            .Append(options.ServerMaxWindowBits.ToString(CultureInfo.InvariantCulture));
+                    }
+
+                    static int? ParseWindowBits(ReadOnlySpan<char> value, string propertyName)
+                    {
+                        var startIndex = value.IndexOf('=');
+
+                        // parameters can be sent without a value by the client, we'll use the values set by the app developer or the default of 15
+                        if (startIndex < 0)
+                        {
+                            return null;
+                        }
+
+                        if (!int.TryParse(value[(startIndex + 1)..], NumberStyles.Integer, CultureInfo.InvariantCulture, out int windowBits) ||
+                            windowBits < 9 ||
+                            windowBits > 15)
+                        {
+                            throw new WebSocketException(WebSocketError.HeaderError, $"invalid {propertyName} used: {value[(startIndex + 1)..].ToString()}");
+                        }
+
+                        return windowBits;
+                    }
+                }
+
+                if (end < 0)
+                {
+                    break;
+                }
+                extension = extension[(end + 1)..];
+            }
+
+            response = builder.ToString();
+
+            return true;
+        }
     }
 }
diff --git a/src/Middleware/WebSockets/src/PublicAPI.Unshipped.txt b/src/Middleware/WebSockets/src/PublicAPI.Unshipped.txt
@@ -1,5 +1,7 @@
 #nullable enable
 Microsoft.AspNetCore.Builder.WebSocketOptions.AllowedOrigins.get -> System.Collections.Generic.IList<string!>!
+Microsoft.AspNetCore.WebSockets.ExtendedWebSocketAcceptContext.WebSocketOptions.get -> System.Net.WebSockets.WebSocketCreationOptions?
+Microsoft.AspNetCore.WebSockets.ExtendedWebSocketAcceptContext.WebSocketOptions.set -> void
 Microsoft.AspNetCore.WebSockets.WebSocketMiddleware.Invoke(Microsoft.AspNetCore.Http.HttpContext! context) -> System.Threading.Tasks.Task!
 ~Microsoft.AspNetCore.WebSockets.WebSocketMiddleware.WebSocketMiddleware(Microsoft.AspNetCore.Http.RequestDelegate! next, Microsoft.Extensions.Options.IOptions<Microsoft.AspNetCore.Builder.WebSocketOptions!>! options, Microsoft.Extensions.Logging.ILoggerFactory! loggerFactory) -> void
 override Microsoft.AspNetCore.WebSockets.ExtendedWebSocketAcceptContext.SubProtocol.get -> string?
diff --git a/src/Middleware/WebSockets/src/WebSocketDeflateConstants.cs b/src/Middleware/WebSockets/src/WebSocketDeflateConstants.cs
@@ -0,0 +1,23 @@
+// 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.
+
+namespace Microsoft.AspNetCore.WebSockets
+{
+    internal static class WebSocketDeflateConstants
+    {
+        /// <summary>
+        /// The maximum length that this extension can have, assuming that we're not using extra white space.
+        /// <para />
+        /// "permessage-deflate; client_max_window_bits=15; client_no_context_takeover; server_max_window_bits=15; server_no_context_takeover"
+        /// </summary>
+        public const int MaxExtensionLength = 128;
+
+        public const string Extension = "permessage-deflate";
+
+        public const string ClientMaxWindowBits = "client_max_window_bits";
+        public const string ClientNoContextTakeover = "client_no_context_takeover";
+
+        public const string ServerMaxWindowBits = "server_max_window_bits";
+        public const string ServerNoContextTakeover = "server_no_context_takeover";
+    }
+}
diff --git a/src/Middleware/WebSockets/src/WebSocketMiddleware.cs b/src/Middleware/WebSockets/src/WebSocketMiddleware.cs
diff --git a/src/Middleware/WebSockets/test/UnitTests/WebSocketCompressionMiddlewareTests.cs b/src/Middleware/WebSockets/test/UnitTests/WebSocketCompressionMiddlewareTests.cs
diff --git a/src/Middleware/WebSockets/test/UnitTests/WebSocketMiddlewareTests.cs b/src/Middleware/WebSockets/test/UnitTests/WebSocketMiddlewareTests.cs

Original file line number	Diff line number	Diff line change
`@@ -61,12 +61,17 @@ public override IList<string> WebSocketRequestedProtocols`
`61`	`61`	`}`
`62`	`62`
`63`	`63`	`public override Task<WebSocket> AcceptWebSocketAsync(string? subProtocol)`
	`64`	`+ {`
	`65`	`+ return AcceptWebSocketAsync(new WebSocketAcceptContext() { SubProtocol = subProtocol });`
	`66`	`+ }`
	`67`	`+`
	`68`	`+ public override Task<WebSocket> AcceptWebSocketAsync(WebSocketAcceptContext acceptContext)`
`64`	`69`	`{`
`65`	`70`	`if (WebSocketFeature == null)`
`66`	`71`	`{`
`67`	`72`	`throw new NotSupportedException("WebSockets are not supported");`
`68`	`73`	`}`
`69`		`- return WebSocketFeature.AcceptAsync(new WebSocketAcceptContext() { SubProtocol = subProtocol });`
	`74`	`+ return WebSocketFeature.AcceptAsync(acceptContext);`
`70`	`75`	`}`
`71`	`76`
`72`	`77`	`struct FeatureInterfaces`