WIP: WebSocket Compression

src/libraries/System.IO.Compression/src/System.IO.Compression.csproj

@@ -1,4 +1,4 @@
-<Project Sdk="Microsoft.NET.Sdk">
+<Project Sdk="Microsoft.NET.Sdk">
   <PropertyGroup>
     <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
     <TargetFrameworks>$(NetCoreAppCurrent)-windows;$(NetCoreAppCurrent)-Unix;$(NetCoreAppCurrent)-Browser</TargetFrameworks>
@@ -25,8 +25,8 @@
     <Compile Include="System\IO\Compression\DeflateZLib\DeflateStream.cs" />
     <Compile Include="System\IO\Compression\DeflateZLib\Inflater.cs" />
     <Compile Include="System\IO\Compression\DeflateZLib\ZLibException.cs" />
-    <Compile Include="System\IO\Compression\DeflateZLib\ZLibNative.cs" />
-    <Compile Include="System\IO\Compression\DeflateZLib\ZLibNative.ZStream.cs" />
+    <Compile Include="$(CommonPath)System\IO\Compression\ZLibNative.cs" LinkBase="System\IO\Compression" />
+    <Compile Include="$(CommonPath)System\IO\Compression\ZLibNative.ZStream.cs" LinkBase="System\IO\Compression" />
     <Compile Include="System\IO\Compression\CompressionLevel.cs" />
     <Compile Include="System\IO\Compression\CompressionMode.cs" />
     <Compile Include="System\IO\Compression\Crc32Helper.ZLib.cs" />

src/libraries/System.Net.WebSockets.Client/ref/System.Net.WebSockets.Client.cs

@@ -36,6 +36,8 @@ internal ClientWebSocketOptions() { }
         [System.Runtime.Versioning.UnsupportedOSPlatformAttribute("browser")]
         public System.TimeSpan KeepAliveInterval { get { throw null; } set { } }
         [System.Runtime.Versioning.UnsupportedOSPlatformAttribute("browser")]
+        public WebSocketDeflateOptions? DeflateOptions { get { throw null; } set { } }
+        [System.Runtime.Versioning.UnsupportedOSPlatformAttribute("browser")]
         public System.Net.IWebProxy? Proxy { get { throw null; } set { } }
         [System.Runtime.Versioning.UnsupportedOSPlatformAttribute("browser")]
         public System.Net.Security.RemoteCertificateValidationCallback? RemoteCertificateValidationCallback { get { throw null; } set { } }

src/libraries/System.Net.WebSockets.Client/src/Resources/Strings.resx

@@ -1,16 +1,17 @@
-<root>
-  <!--
-    Microsoft ResX Schema
-
+<?xml version="1.0" encoding="utf-8"?>
+<root>
+  <!-- 
+    Microsoft ResX Schema 
+
     Version 2.0
-
-    The primary goals of this format is to allow a simple XML format
-    that is mostly human readable. The generation and parsing of the
-    various data types are done through the TypeConverter classes
+    
+    The primary goals of this format is to allow a simple XML format 
+    that is mostly human readable. The generation and parsing of the 
+    various data types are done through the TypeConverter classes 
     associated with the data types.
-
+    
     Example:
-
+    
     ... ado.net/XML headers & schema ...
     <resheader name="resmimetype">text/microsoft-resx</resheader>
     <resheader name="version">2.0</resheader>
@@ -25,36 +26,36 @@
         <value>[base64 mime encoded string representing a byte array form of the .NET Framework object]</value>
         <comment>This is a comment</comment>
     </data>
-
-    There are any number of "resheader" rows that contain simple
+                
+    There are any number of "resheader" rows that contain simple 
     name/value pairs.
-
-    Each data row contains a name, and value. The row also contains a
-    type or mimetype. Type corresponds to a .NET class that support
-    text/value conversion through the TypeConverter architecture.
-    Classes that don't support this are serialized and stored with the
+    
+    Each data row contains a name, and value. The row also contains a 
+    type or mimetype. Type corresponds to a .NET class that support 
+    text/value conversion through the TypeConverter architecture. 
+    Classes that don't support this are serialized and stored with the 
     mimetype set.
-
-    The mimetype is used for serialized objects, and tells the
-    ResXResourceReader how to depersist the object. This is currently not
+    
+    The mimetype is used for serialized objects, and tells the 
+    ResXResourceReader how to depersist the object. This is currently not 
     extensible. For a given mimetype the value must be set accordingly:
-
-    Note - application/x-microsoft.net.object.binary.base64 is the format
-    that the ResXResourceWriter will generate, however the reader can
+    
+    Note - application/x-microsoft.net.object.binary.base64 is the format 
+    that the ResXResourceWriter will generate, however the reader can 
     read any of the formats listed below.
-
+    
     mimetype: application/x-microsoft.net.object.binary.base64
-    value   : The object must be serialized with
+    value   : The object must be serialized with 
             : System.Runtime.Serialization.Formatters.Binary.BinaryFormatter
             : and then encoded with base64 encoding.
-
+    
     mimetype: application/x-microsoft.net.object.soap.base64
-    value   : The object must be serialized with
+    value   : The object must be serialized with 
             : System.Runtime.Serialization.Formatters.Soap.SoapFormatter
             : and then encoded with base64 encoding.
 
     mimetype: application/x-microsoft.net.object.bytearray.base64
-    value   : The object must be serialized into a byte array
+    value   : The object must be serialized into a byte array 
             : using a System.ComponentModel.TypeConverter
             : and then encoded with base64 encoding.
     -->
@@ -193,8 +194,11 @@
   </data>
   <data name="net_WebSockets_Connection_Aborted" xml:space="preserve">
     <value>Connection was aborted.</value>
-  </data>  
+  </data>
   <data name="net_WebSockets_Invalid_Binary_Type" xml:space="preserve">
     <value>WebSocket binary type '{0}' not supported.</value>
-  </data>   
-</root>
+  </data>
+  <data name="net_WebSockets_WindowBitsNegotiationFailure" xml:space="preserve">
+    <value>The WebSocket failed to negotiate max {0} window bits. The client requested {1} but the server responded with {2}.</value>
+  </data>
+</root>

src/libraries/System.Net.WebSockets.Client/src/System/Net/WebSockets/BrowserWebSockets/ClientWebSocketOptions.cs

@@ -100,6 +100,13 @@ public TimeSpan KeepAliveInterval
             set => throw new PlatformNotSupportedException();
         }
 
+        [UnsupportedOSPlatform("browser")]
+        public WebSocketDeflateOptions? DeflateOptions
+        {
+            get => throw new PlatformNotSupportedException();
+            set => throw new PlatformNotSupportedException();
+        }
+
         [UnsupportedOSPlatform("browser")]
         public void SetBuffer(int receiveBufferSize, int sendBufferSize)
         {

src/libraries/System.Net.WebSockets.Client/src/System/Net/WebSockets/ClientWebSocketOptions.cs

@@ -148,6 +148,9 @@ public TimeSpan KeepAliveInterval
             }
         }
 
+        [UnsupportedOSPlatform("browser")]
+        public WebSocketDeflateOptions? DeflateOptions { get; set; }
+
         internal int ReceiveBufferSize => _receiveBufferSize;
         internal ArraySegment<byte>? Buffer => _buffer;
 

src/libraries/System.Net.WebSockets.Client/src/System/Net/WebSockets/WebSocketHandle.Managed.cs

@@ -4,6 +4,7 @@
 using System.Collections.Generic;
 using System.Diagnostics;
 using System.Diagnostics.CodeAnalysis;
+using System.Globalization;
 using System.IO;
 using System.Net.Http;
 using System.Net.Http.Headers;
@@ -175,6 +176,21 @@ public async Task ConnectAsync(Uri uri, CancellationToken cancellationToken, Cli
                     }
                 }
 
+                // Because deflate options are negotiated we need a new object
+                WebSocketDeflateOptions? deflateOptions = null;
+
+                if (options.DeflateOptions is not null && response.Headers.TryGetValues(HttpKnownHeaderNames.SecWebSocketExtensions, out var extensions))
+                {
+                    foreach (var extension in extensions)
+                    {
+                        if (extension.StartsWith("permessage-deflate"))
+                        {
+                            deflateOptions = ParseDeflateOptions(extension, options.DeflateOptions);
+                            break;
+                        }
+                    }
+                }
+
                 if (response.Content is null)
                 {
                     throw new WebSocketException(WebSocketError.ConnectionClosedPrematurely);
@@ -184,11 +200,13 @@ public async Task ConnectAsync(Uri uri, CancellationToken cancellationToken, Cli
                 Stream connectedStream = response.Content.ReadAsStream();
                 Debug.Assert(connectedStream.CanWrite);
                 Debug.Assert(connectedStream.CanRead);
-                WebSocket = WebSocket.CreateFromStream(
-                    connectedStream,
-                    isServer: false,
-                    subprotocol,
-                    options.KeepAliveInterval);
+                WebSocket = WebSocket.CreateFromStream(connectedStream, new WebSocketCreationOptions
+                {
+                    IsServer = false,
+                    SubProtocol = subprotocol,
+                    KeepAliveInterval = options.KeepAliveInterval,
+                    DeflateOptions = deflateOptions,
+                });
             }
             catch (Exception exc)
             {
@@ -218,6 +236,47 @@ public async Task ConnectAsync(Uri uri, CancellationToken cancellationToken, Cli
             }
         }
 
+        private static WebSocketDeflateOptions ParseDeflateOptions(string extensions, WebSocketDeflateOptions original)
+        {
+            var options = new WebSocketDeflateOptions();
+
+            foreach (var value in extensions.Split(';', StringSplitOptions.RemoveEmptyEntries | StringSplitOptions.TrimEntries))
+            {
+                if (value == "client_no_context_takeover")
+                {
+                    options.ClientContextTakeover = false;
+                }
+                else if (value == "server_no_context_takeover")
+                {
+                    options.ServerContextTakeover = false;
+                }
+                else if (value.StartsWith("client_max_window_bits="))
+                {
+                    options.ClientMaxWindowBits = int.Parse(value.Substring("client_max_window_bits=".Length),
+                                                            NumberFormatInfo.InvariantInfo);
+                }
+                else if (value.StartsWith("server_max_window_bits="))
+                {
+                    options.ServerMaxWindowBits = int.Parse(value.Substring("server_max_window_bits=".Length),
+                                                            NumberFormatInfo.InvariantInfo);
+                }
+            }
+
+            if (options.ClientMaxWindowBits > original.ClientMaxWindowBits)
+            {
+                throw new WebSocketException(string.Format(SR.net_WebSockets_WindowBitsNegotiationFailure,
+                    "client", original.ClientMaxWindowBits, options.ClientMaxWindowBits));
+            }
+
+            if (options.ServerMaxWindowBits > original.ServerMaxWindowBits)
+            {
+                throw new WebSocketException(string.Format(SR.net_WebSockets_WindowBitsNegotiationFailure,
+                    "server", original.ServerMaxWindowBits, options.ServerMaxWindowBits));
+            }
+
+            return options;
+        }
+
         /// <summary>Adds the necessary headers for the web socket request.</summary>
         /// <param name="request">The request to which the headers should be added.</param>
         /// <param name="secKey">The generated security key to send in the Sec-WebSocket-Key header.</param>
@@ -232,6 +291,41 @@ private static void AddWebSocketHeaders(HttpRequestMessage request, string secKe
             {
                 request.Headers.TryAddWithoutValidation(HttpKnownHeaderNames.SecWebSocketProtocol, string.Join(", ", options.RequestedSubProtocols));
             }
+            if (options.DeflateOptions is not null)
+            {
+                request.Headers.TryAddWithoutValidation(HttpKnownHeaderNames.SecWebSocketExtensions, string.Join("; ", GetDeflateOptions(options.DeflateOptions)));
+
+                static IEnumerable<string> GetDeflateOptions(WebSocketDeflateOptions options)
+                {
+                    yield return "permessage-deflate";
+
+                    if (options.ClientMaxWindowBits != 15)
+                    {
+                        yield return "client_max_window_bits=" + options.ClientMaxWindowBits;
+                    }
+                    else
+                    {
+                        // Advertise that we support this option
+                        yield return "client_max_window_bits";
+                    }
+
+                    if (options.ServerMaxWindowBits != 15)
+                    {
+                        yield return "server_max_window_bits=" + options.ServerMaxWindowBits;
+                    }
+                    else
+                    {
+                        // Advertise that we support this option
+                        yield return "server_max_window_bits";
+                    }
+
+                    if (!options.ServerContextTakeover)
+                        yield return "server_no_context_takeover";
+
+                    if (!options.ClientContextTakeover)
+                        yield return "client_no_context_takeover";
+                }
+            }
         }
 
         /// <summary>

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

@@ -31,6 +31,8 @@ protected WebSocket() { }
         public static System.Net.WebSockets.WebSocket CreateClientWebSocket(System.IO.Stream innerStream, string? subProtocol, int receiveBufferSize, int sendBufferSize, System.TimeSpan keepAliveInterval, bool useZeroMaskingKey, System.ArraySegment<byte> internalBuffer) { throw null; }
         [System.Runtime.Versioning.UnsupportedOSPlatform("browser")]
         public static System.Net.WebSockets.WebSocket CreateFromStream(System.IO.Stream stream, bool isServer, string? subProtocol, System.TimeSpan keepAliveInterval) { throw null; }
+        [System.Runtime.Versioning.UnsupportedOSPlatform("browser")]
+        public static System.Net.WebSockets.WebSocket CreateFromStream(System.IO.Stream stream, WebSocketCreationOptions options) { throw null; }
         public static System.ArraySegment<byte> CreateServerBuffer(int receiveBufferSize) { throw null; }
         public abstract void Dispose();
         [System.ComponentModel.EditorBrowsableAttribute(System.ComponentModel.EditorBrowsableState.Never)]
@@ -133,4 +135,20 @@ public enum WebSocketState
         Closed = 5,
         Aborted = 6,
     }
+
+    public sealed class WebSocketCreationOptions
+    {
+        public bool IsServer { get; set; }
+        public string? SubProtocol { get; set; }
+        public TimeSpan KeepAliveInterval { get; set; }
+        public WebSocketDeflateOptions? DeflateOptions { get; set; }
+    }
+
+    public sealed class WebSocketDeflateOptions
+    {
+        public int ClientMaxWindowBits { get; set; }
+        public bool ClientContextTakeover { get; set; }
+        public int ServerMaxWindowBits { get; set; }
+        public bool ServerContextTakeover { get; set; }
+    }
 }