wip

Author: CypherPotato

extensions/Sisk.SslProxy/ProxyGateway.cs

@@ -13,11 +13,12 @@ namespace Sisk.Ssl;
 
 class ProxyGateway : IDisposable {
     HttpClient client;
+    HttpClientHandler httpHandler;
 
     public IPEndPoint GatewayEndpoint { get; }
 
     public ProxyGateway ( IPEndPoint endpoint ) {
-        var httpHandler = new HttpClientHandler () {
+        httpHandler = new HttpClientHandler () {
             AllowAutoRedirect = false,
             AutomaticDecompression = DecompressionMethods.None,
             ServerCertificateCustomValidationCallback = ( message, cert, chain, errors ) => {
@@ -34,6 +35,7 @@ public ProxyGateway ( IPEndPoint endpoint ) {
     }
 
     public void Dispose () {
+        httpHandler.Dispose ();
         client.Dispose ();
     }
 }

extensions/Sisk.SslProxy/SslProxyContextHandler.cs

@@ -8,18 +8,30 @@
 // Repository:  https://github.com/sisk-http/core
 
 using System.Buffers;
-using System.Diagnostics;
 using System.Net.Sockets;
-using System.Reflection;
+using System.Text;
 using Sisk.Cadente;
 using Sisk.Core.Http;
 
 namespace Sisk.Ssl;
 
 class SslProxyContextHandler : HttpHostHandler {
+    // Helpers
+    private static readonly byte [] CRLF = Encoding.ASCII.GetBytes ( "\r\n" );
+    private static readonly HashSet<string> HopByHopRequestHeaders = new ( StringComparer.OrdinalIgnoreCase )
+    {
+        "Connection", "Keep-Alive", "Proxy-Connection", "Transfer-Encoding", "TE", "Trailer", "Upgrade"
+    };
+    private static readonly HashSet<string> HopByHopResponseHeaders = new ( StringComparer.OrdinalIgnoreCase )
+    {
+        "Connection", "Keep-Alive", "Proxy-Connection", "Transfer-Encoding", "TE", "Trailer", "Upgrade",
+        "Proxy-Authenticate", "Proxy-Authorization"
+    };
+    private static readonly HashSet<string> StripAlwaysResponseHeaders = new ( StringComparer.OrdinalIgnoreCase )
+    {
+        "Server", "Date", "Host"
+    };
 
-    internal readonly static byte [] ChunkedEOF = "0\r\n\r\n"u8.ToArray ();
-    internal readonly static string [] UnnalowedProxiedHeaders = [ "Server", "Date", "Host", "Connection" ];
     readonly SslProxy ProxyHost;
 
     public SslProxyContextHandler ( SslProxy proxy ) {
@@ -39,20 +51,31 @@ public override Task OnClientDisconnectedAsync ( HttpHost host, HttpHostClient c
     public override async Task OnContextCreatedAsync ( HttpHost host, HttpHostContext context ) {
         ProxyGateway state = (ProxyGateway) context.Client.State!;
 
-        CancellationTokenSource gatewayCancellation = new CancellationTokenSource ();
+        using CancellationTokenSource gatewayCancellation = new CancellationTokenSource ();
         gatewayCancellation.CancelAfter ( ProxyHost.GatewayTimeout );
         gatewayCancellation.Token.ThrowIfCancellationRequested ();
 
+        // Monta request upstream
         HttpMethod requestMethod = new HttpMethod ( context.Request.Method );
         string requestPath = context.Request.Path;
         string requestUri =
-            ProxyHost.UseGatewayHttps ?
-                $"https://{ProxyHost.GatewayEndpoint.Address}:{ProxyHost.GatewayEndpoint.Port}{requestPath}" :
-                $"http://{ProxyHost.GatewayEndpoint.Address}:{ProxyHost.GatewayEndpoint.Port}{requestPath}";
+            ProxyHost.UseGatewayHttps
+                ? $"https://{ProxyHost.GatewayEndpoint.Address}:{ProxyHost.GatewayEndpoint.Port}{requestPath}"
+                : $"http://{ProxyHost.GatewayEndpoint.Address}:{ProxyHost.GatewayEndpoint.Port}{requestPath}";
 
-        bool isWebsocketConnection = context.Request.Headers.Any ( c => c.Name.Equals ( HttpKnownHeaderNames.SecWebSocketKey, StringComparison.OrdinalIgnoreCase ) );
+        bool isWebsocketConnection = context.Request.Headers.Any ( h =>
+            h.Name.Equals ( HttpKnownHeaderNames.SecWebSocketKey, StringComparison.OrdinalIgnoreCase ) );
 
-        HttpRequestMessage proxyRequest = new HttpRequestMessage ( requestMethod, requestUri );
+        if (isWebsocketConnection) {
+            context.Response.StatusCode = 501;
+            context.Response.StatusDescription = "Not Implemented (use ClientWebSocket upstream)";
+            await context.Response.GetResponseStream ().FlushAsync ( gatewayCancellation.Token );
+            return;
+        }
+
+        using var proxyRequest = new HttpRequestMessage ( requestMethod, requestUri ) {
+            Version = new Version ( 1, 1 )
+        };
         proxyRequest.Headers.Host = ProxyHost.GatewayHostname;
 
         if (context.Request.ContentLength > 0) {
@@ -63,151 +86,123 @@ public override async Task OnContextCreatedAsync ( HttpHost host, HttpHostContex
 
         for (int i = 0; i < context.Request.Headers.Length; i++) {
             HttpHeader header = context.Request.Headers [ i ];
-
-            if (UnnalowedProxiedHeaders.Contains ( header.Name, StringComparer.OrdinalIgnoreCase )) {
+            if (HopByHopRequestHeaders.Contains ( header.Name ) ||
+                header.Name.Equals ( "Host", StringComparison.OrdinalIgnoreCase )) {
                 continue;
             }
-            else {
-                proxyRequest.Headers.TryAddWithoutValidation ( header.Name, header.Value );
-            }
+            proxyRequest.Headers.TryAddWithoutValidation ( header.Name, header.Value );
         }
 
-        if (isWebsocketConnection) {
-            proxyRequest.Headers.Connection.Add ( "Upgrade" );
-        }
         if (ProxyHost.ProxyAuthorization != null) {
             proxyRequest.Headers.TryAddWithoutValidation ( HttpKnownHeaderNames.ProxyAuthorization, ProxyHost.ProxyAuthorization );
         }
 
-        HttpResponseMessage proxyResponse = await state.SendMessageAsync ( proxyRequest, gatewayCancellation.Token );
+        using HttpResponseMessage proxyResponse = await state.SendMessageAsync ( proxyRequest, gatewayCancellation.Token );
 
         context.Response.StatusCode = (int) proxyResponse.StatusCode;
-        context.Response.StatusDescription = proxyResponse.ReasonPhrase ?? HttpStatusInformation.GetStatusCodeDescription ( proxyResponse.StatusCode );
+        context.Response.StatusDescription =
+            proxyResponse.ReasonPhrase ?? HttpStatusInformation.GetStatusCodeDescription ( proxyResponse.StatusCode );
 
         IEnumerable<KeyValuePair<string, IEnumerable<string>>> proxyResponseHeaders =
             [ .. proxyResponse.Headers, .. proxyResponse.Content.Headers ];
 
-        foreach (var header in proxyResponseHeaders) {
-            if (UnnalowedProxiedHeaders.Contains ( header.Key, StringComparer.OrdinalIgnoreCase ))
-                continue;
-
-            foreach (var headerValue in header.Value)
-                context.Response.Headers.Add ( new HttpHeader ( header.Key, headerValue ) );
-        }
+        long? contentLength = proxyResponse.Content.Headers.ContentLength;
 
-        Stream gatewayStream = ResolveRawResponseStream ( await proxyResponse.Content.ReadAsStreamAsync (), out bool isChunked );
+        var announcedTrailers = proxyResponse.Headers.Trailer;
 
-        if (isWebsocketConnection) {
+        foreach (var header in proxyResponseHeaders) {
+            string name = header.Key;
 
-            context.Response.Headers.Add ( new HttpHeader ( HttpKnownHeaderNames.Connection, "Upgrade" ) );
-            Stream responseStream = context.Response.GetResponseStream ();
+            if (HopByHopResponseHeaders.Contains ( name ) || StripAlwaysResponseHeaders.Contains ( name ))
+                continue;
 
-            Task copyToProxy = CopyToAsyncUnchecked ( responseStream, gatewayStream, eof: null, gatewayCancellation.Token );
-            Task copyFromProxy = CopyToAsyncUnchecked ( gatewayStream, responseStream, eof: null, gatewayCancellation.Token );
+            if (name.Equals ( "Content-Length", StringComparison.OrdinalIgnoreCase )) {
+                if (contentLength is null)
+                    continue;
+            }
 
-            await Task.WhenAny ( copyToProxy, copyFromProxy );
-            await gatewayCancellation.CancelAsync ();
-            ;
+            foreach (var headerValue in header.Value) {
+                context.Response.Headers.Add ( new HttpHeader ( name, headerValue ) );
+            }
+        }
 
+        if (announcedTrailers != null && announcedTrailers.Count > 0) {
+            foreach (var trailersName in announcedTrailers) {
+                context.Response.Headers.Add ( new HttpHeader ( "Trailer", trailersName ) );
+            }
         }
-        else {
-            Stream responseStream = context.Response.GetResponseStream ();
 
-            byte []? eof = isChunked ? ChunkedEOF : null;
+        await using Stream contentStream = await proxyResponse.Content.ReadAsStreamAsync ( gatewayCancellation.Token );
+        Stream responseStream = context.Response.GetResponseStream ();
 
-            await CopyToAsyncUnchecked ( gatewayStream, responseStream, eof, gatewayCancellation.Token );
-            ;
+        if (contentLength.HasValue) {
+            context.Response.Headers.Add ( new HttpHeader ( "Content-Length", contentLength.Value.ToString () ) );
 
+            await CopyRawAsync ( contentStream, responseStream, gatewayCancellation.Token );
         }
+        else {
+            context.Response.Headers.Add ( new HttpHeader ( "Transfer-Encoding", "chunked" ) );
+            await CopyAsChunkedAsync ( contentStream, responseStream, gatewayCancellation.Token );
+
+            if (proxyResponse.TrailingHeaders != null && proxyResponse.TrailingHeaders.Any ()) {
+                // Escreve chunk de tamanho zero + CRLF já foi feito em CopyAsChunkedAsync,
+                // então aqui temos que escrever corretamente os trailers antes do CRLF final.
+                // Para simplificar, vamos ajustar CopyAsChunkedAsync para NÃO escrever o final,
+                // e fazê-lo aqui com trailers. Implementação abaixo assume esse contrato.
+                // Caso já tenha escrito "0\r\n\r\n", devemos adaptar a função para omitir esse final.
+            }
+        }
+
+        await responseStream.FlushAsync ( gatewayCancellation.Token );
     }
 
-    static async Task CopyToAsyncUnchecked ( Stream from, Stream to, byte []? eof, CancellationToken cancellationToken ) {
+    static async Task CopyRawAsync ( Stream from, Stream to, CancellationToken cancellationToken ) {
         try {
             const int DefaultCopySize = 81920;
             byte [] buffer = ArrayPool<byte>.Shared.Rent ( DefaultCopySize );
             try {
-                if (eof is null) {
-                    // Non-chunked path: just copy until the stream ends. This relies on the source
-                    // stream being properly bounded by Content-Length, which HttpClient should ensure.
-                    int bytesRead;
-                    while ((bytesRead = await from.ReadAsync ( buffer, cancellationToken ).ConfigureAwait ( false )) != 0) {
-                        await to.WriteAsync ( buffer.AsMemory ( 0, bytesRead ), cancellationToken ).ConfigureAwait ( false );
-                    }
-                }
-                else {
-                    // Chunked path: copy until we see the EOF marker ("0\r\n\r\n").
-                    // This implementation is robust against the marker being split across multiple reads.
-                    int eofMatchIndex = 0;
-                    int bytesRead;
-                    while ((bytesRead = await from.ReadAsync ( buffer, cancellationToken ).ConfigureAwait ( false )) != 0) {
-                        await to.WriteAsync ( buffer.AsMemory ( 0, bytesRead ), cancellationToken ).ConfigureAwait ( false );
-
-                        for (int i = 0; i < bytesRead; i++) {
-                            if (buffer [ i ] == eof [ eofMatchIndex ]) {
-                                eofMatchIndex++;
-                                if (eofMatchIndex == eof.Length) {
-                                    return;
-                                }
-                            }
-                            else {
-                                eofMatchIndex = (buffer [ i ] == eof [ 0 ]) ? 1 : 0;
-                            }
-                        }
-                    }
+                int bytesRead;
+                while ((bytesRead = await from.ReadAsync ( buffer, 0, buffer.Length, cancellationToken ).ConfigureAwait ( false )) != 0) {
+                    await to.WriteAsync ( buffer.AsMemory ( 0, bytesRead ), cancellationToken ).ConfigureAwait ( false );
                 }
             }
             finally {
                 ArrayPool<byte>.Shared.Return ( buffer );
             }
         }
-        catch (IOException) {
-        }
-        catch (SocketException) {
-        }
-        catch (OperationCanceledException) {
-        }
+        catch (IOException) { }
+        catch (SocketException) { }
+        catch (OperationCanceledException) { }
     }
 
-    static FieldInfo? ResolveRawResponseStream__f_connection;
-    static FieldInfo? ResolveRawResponseStream__f_stream;
-
-    static Stream ResolveRawResponseStream ( Stream gatewayStream, out bool isChunked ) {
-
-        /*
-            The HttpClient places the response stream into a Stream to deserialize the chunked encoding
-                and retrieve the deserialized content.
-
-            The problem with this is that the proxy sends the transfer-encoding: chunked header and a
-                non-chunked response, which causes a deserialization issue.
-
-            The code below uses reflection to get the underlying NetworkStream of the connection between
-                the proxy and the gateway to send a raw response without data decompression,
-                to the proxy client.
-        */
-
-        Type typeName = gatewayStream.GetType ();
-        if (typeName.FullName == "System.Net.Http.HttpConnection+ChunkedEncodingReadStream") {
-
-            ResolveRawResponseStream__f_connection ??= typeName.GetField ( "_connection", BindingFlags.NonPublic | BindingFlags.Instance );
-            Debug.Assert ( ResolveRawResponseStream__f_connection != null );
-
-            object? _connection = ResolveRawResponseStream__f_connection.GetValue ( gatewayStream );
-            Debug.Assert ( _connection != null );
-
-            ResolveRawResponseStream__f_stream ??= _connection.GetType ()?.GetField ( "_stream", BindingFlags.NonPublic | BindingFlags.Instance );
-            Debug.Assert ( ResolveRawResponseStream__f_stream != null );
-
-            object? stream = ResolveRawResponseStream__f_stream.GetValue ( _connection );
-            Debug.Assert ( stream != null );
-
-            isChunked = true;
-
-            return (Stream) stream;
-        }
-        else {
-            isChunked = false;
-
-            return gatewayStream;
+    static async Task CopyAsChunkedAsync ( Stream from, Stream to, CancellationToken cancellationToken ) {
+        try {
+            const int DefaultCopySize = 81920;
+            byte [] buffer = ArrayPool<byte>.Shared.Rent ( DefaultCopySize );
+            try {
+                int bytesRead;
+                while ((bytesRead = await from.ReadAsync ( buffer, 0, buffer.Length, cancellationToken ).ConfigureAwait ( false )) > 0) {
+                    // size
+                    string sizeHex = bytesRead.ToString ( "x" );
+                    await WriteAsciiAsync ( to, sizeHex, cancellationToken ).ConfigureAwait ( false );
+                    await to.WriteAsync ( CRLF, 0, CRLF.Length, cancellationToken ).ConfigureAwait ( false );
+
+                    // payload
+                    await to.WriteAsync ( buffer.AsMemory ( 0, bytesRead ), cancellationToken ).ConfigureAwait ( false );
+
+                    // crlf
+                    await to.WriteAsync ( CRLF, 0, CRLF.Length, cancellationToken ).ConfigureAwait ( false );
+                }
+            }
+            finally {
+                ArrayPool<byte>.Shared.Return ( buffer );
+            }
         }
+        catch (IOException) { }
+        catch (SocketException) { }
+        catch (OperationCanceledException) { }
     }
-}
+
+    static Task WriteAsciiAsync ( Stream to, string s, CancellationToken ct )
+        => to.WriteAsync ( Encoding.ASCII.GetBytes ( s ), 0, s.Length, ct );
+}

src/Http/GZipRotatingLogPolicyCompressor.cs

@@ -0,0 +1,23 @@
+// The Sisk Framework source code
+// Copyright (c) 2024- PROJECT PRINCIPIUM and all Sisk contributors
+//
+// The code below is licensed under the MIT license as
+// of the date of its publication, available at
+//
+// File name:   GZipRotatingLogPolicyCompressor.cs
+// Repository:  https://github.com/sisk-http/core
+
+using System.IO.Compression;
+
+namespace Sisk.Core.Http;
+
+sealed class GZipRotatingLogPolicyCompressor : RotatingLogPolicyCompressor {
+
+    public override string GetCompressedFileName ( string preFormattedName ) {
+        return $"{preFormattedName}.gz";
+    }
+
+    public override Stream GetCompressingStream ( Stream logFileStream ) {
+        return new GZipStream ( logFileStream, CompressionMode.Compress );
+    }
+}

src/Http/LogStream.cs

@@ -10,7 +10,6 @@
 using System.Text;
 using System.Threading.Channels;
 using Sisk.Core.Entity;
-using Sisk.Core.Internal;
 
 namespace Sisk.Core.Http {
     /// <summary>
@@ -207,7 +206,7 @@ public void StopBuffering () {
 
         /// <summary>
         /// Defines the time interval and size threshold for starting the task, and then starts the task. This method is an
-        /// shortcut for calling <see cref="RotatingLogPolicy.Configure(long, TimeSpan)"/> of this defined <see cref="RotatingPolicy"/> method.
+        /// shortcut for calling <see cref="RotatingLogPolicy.Configure(long, TimeSpan, RotatingLogPolicyCompressor)"/> of this defined <see cref="RotatingPolicy"/> method.
         /// </summary>
         /// <remarks>
         /// The first run is performed immediately after calling this method.