wip

CypherPotato · CypherPotato · commit 8d66d995945a · 2025-02-27T14:26:02.000-03:00
diff --git a/cadente/Sisk.Cadente/HttpConnection.cs b/cadente/Sisk.Cadente/HttpConnection.cs
@@ -7,7 +7,6 @@
 // File name:   HttpConnection.cs
 // Repository:  https://github.com/sisk-http/core
 
-using System.Buffers;
 using System.Net;
 using Sisk.Cadente.HttpSerializer;
 using Sisk.Cadente.Streams;
@@ -27,7 +26,8 @@ sealed class HttpConnection : IDisposable {
     public readonly int Id = 0;
 #endif
 
-    public const int REQUEST_BUFFER_SIZE = 8192; // buffer dedicated to headers. more than it? return 400.
+    // buffer dedicated to headers.
+    public const int REQUEST_BUFFER_SIZE = 8192;
     public const int RESPONSE_BUFFER_SIZE = 4096;
 
     public HttpConnection ( Stream connectionStream, HttpHost host, IPEndPoint endpoint ) {
@@ -39,78 +39,64 @@ public HttpConnection ( Stream connectionStream, HttpHost host, IPEndPoint endpo
     public async Task<HttpConnectionState> HandleConnectionEvents () {
         bool connectionCloseRequested = false;
 
-        var requestBuffer = ArrayPool<byte>.Shared.Rent ( REQUEST_BUFFER_SIZE );
+        while (this._connectionStream.CanRead && !this.disposedValue) {
 
-        try {
+            HttpRequestReader requestReader = new HttpRequestReader ( this._connectionStream );
+            Stream? responseStream = null;
 
-            while (this._connectionStream.CanRead && !this.disposedValue) {
+            try {
+                if (requestReader.TryReadHttpRequest ( out HttpRequestBase? nextRequest ) == false) {
+                    return HttpConnectionState.ConnectionClosed;
+                }
 
-                HttpRequestReader requestReader = new HttpRequestReader ( this._connectionStream, ref requestBuffer );
-                Stream? responseStream = null;
+                HttpHostContext managedSession = new HttpHostContext ( nextRequest, this._endpoint, this._connectionStream );
+                await this._host.InvokeContextCreated ( managedSession );
 
-                try {
-                    var readRequestState = await requestReader.ReadHttpRequest ();
-                    var nextRequest = readRequestState.Item2;
+                if (!managedSession.KeepAlive || !nextRequest.CanKeepAlive) {
+                    connectionCloseRequested = true;
+                    managedSession.Response.Headers.Set ( new HttpHeader ( HttpHeaderName.Connection, "close" ) );
+                }
 
-                    if (nextRequest is null) {
-                        return readRequestState.Item1 switch {
-                            HttpRequestReadState.StreamZero => HttpConnectionState.ConnectionClosedByStreamRead,
-                            _ => HttpConnectionState.BadRequest
-                        };
-                    }
+                if (managedSession.Response.ResponseStream is Stream { } s) {
+                    responseStream = s;
+                }
+                else {
+                    managedSession.Response.Headers.Set ( new HttpHeader ( HttpHeaderName.ContentLength, "0" ) );
+                }
 
-                    HttpHostContext managedSession = new HttpHostContext ( nextRequest, this._endpoint, this._connectionStream );
-                    this._host.InvokeContextCreated ( managedSession );
+                Stream outputStream = this._connectionStream;
+                if (responseStream is not null) {
 
-                    if (!managedSession.KeepAlive || !nextRequest.CanKeepAlive) {
-                        connectionCloseRequested = true;
-                        managedSession.Response.Headers.Set ( new HttpHeader ( HttpHeaderName.Connection, "close" ) );
-                    }
+                    if (managedSession.Response.SendChunked || !responseStream.CanSeek) {
 
-                    if (managedSession.Response.ResponseStream is Stream { } s) {
-                        responseStream = s;
+                        managedSession.Response.Headers.Set ( new HttpHeader ( HttpHeaderName.TransferEncoding, "chunked" ) );
+                        responseStream = new HttpChunkedStream ( responseStream );
                     }
                     else {
-                        managedSession.Response.Headers.Set ( new HttpHeader ( HttpHeaderName.ContentLength, "0" ) );
-                    }
-
-                    Stream outputStream = this._connectionStream;
-                    if (responseStream is not null) {
-
-                        if (managedSession.Response.SendChunked || !responseStream.CanSeek) {
-
-                            managedSession.Response.Headers.Set ( new HttpHeader ( HttpHeaderName.TransferEncoding, "chunked" ) );
-                            responseStream = new HttpChunkedStream ( responseStream );
-                        }
-                        else {
-                            managedSession.Response.Headers.Set ( new HttpHeader ( HttpHeaderName.ContentLength, responseStream.Length.ToString () ) );
-                        }
+                        managedSession.Response.Headers.Set ( new HttpHeader ( HttpHeaderName.ContentLength, responseStream.Length.ToString () ) );
                     }
+                }
 
-                    if (managedSession.ResponseHeadersAlreadySent == false && !managedSession.WriteHttpResponseHeaders ()) {
-                        return HttpConnectionState.ResponseWriteException;
-                    }
+                if (managedSession.ResponseHeadersAlreadySent == false && !managedSession.WriteHttpResponseHeaders ()) {
+                    return HttpConnectionState.ResponseWriteException;
+                }
 
-                    if (responseStream is not null) {
-                        await responseStream.CopyToAsync ( outputStream );
-                    }
+                if (responseStream is not null) {
+                    await responseStream.CopyToAsync ( outputStream );
+                }
 
-                    this._connectionStream.Flush ();
+                await this._connectionStream.FlushAsync ();
 
-                    if (connectionCloseRequested) {
-                        break;
-                    }
-                }
-                finally {
-                    responseStream?.Dispose ();
+                if (connectionCloseRequested) {
+                    break;
                 }
             }
-
-            return HttpConnectionState.ConnectionClosed;
-        }
-        finally {
-            ArrayPool<byte>.Shared.Return ( requestBuffer );
+            finally {
+                responseStream?.Dispose ();
+            }
         }
+
+        return HttpConnectionState.ConnectionClosed;
     }
 
     private void Dispose ( bool disposing ) {
diff --git a/cadente/Sisk.Cadente/HttpContextHandler.cs b/cadente/Sisk.Cadente/HttpContextHandler.cs
@@ -14,4 +14,4 @@ namespace Sisk.Cadente;
 /// </summary>
 /// <param name="sender">The <see cref="HttpHost"/> which created the <see cref="HttpHostContext"/> object.</param>
 /// <param name="session">The HTTP session associated with the action.</param>
-public delegate void HttpContextHandler ( HttpHost sender, HttpHostContext session );
+public delegate Task HttpContextHandler ( HttpHost sender, HttpHostContext session );
diff --git a/cadente/Sisk.Cadente/HttpHost.cs b/cadente/Sisk.Cadente/HttpHost.cs
@@ -143,8 +143,9 @@ private void Dispose ( bool disposing ) {
     }
 
     [MethodImpl ( MethodImplOptions.AggressiveInlining )]
-    internal void InvokeContextCreated ( HttpHostContext context ) {
-        this.ContextCreated?.Invoke ( this, context );
+    internal async ValueTask InvokeContextCreated ( HttpHostContext context ) {
+        if (ContextCreated != null)
+            await ContextCreated.Invoke ( this, context );
     }
 
     /// <inheritdoc/>
diff --git a/cadente/Sisk.Cadente/HttpHostContext.cs b/cadente/Sisk.Cadente/HttpHostContext.cs
@@ -48,7 +48,13 @@ internal bool WriteHttpResponseHeaders () {
     /// </summary>
     public bool KeepAlive { get; set; } = true;
 
+    /// <summary>
+    /// Gets the remote client endpoint.
+    /// </summary>
+    public IPEndPoint ClientEndpoint { get; }
+
     internal HttpHostContext ( HttpRequestBase baseRequest, IPEndPoint clientEndpoint, Stream connectionStream ) {
+        this.ClientEndpoint = clientEndpoint;
         this._connectionStream = connectionStream;
 
         HttpRequestStream requestStream = new HttpRequestStream ( connectionStream, baseRequest );
diff --git a/cadente/Sisk.Cadente/HttpSerializer/HttpRequestReader.cs b/cadente/Sisk.Cadente/HttpSerializer/HttpRequestReader.cs
@@ -7,15 +7,14 @@
 // File name:   HttpRequestReader.cs
 // Repository:  https://github.com/sisk-http/core
 
-using System.Buffers;
+using System.Diagnostics.CodeAnalysis;
 using System.Text;
 
 namespace Sisk.Cadente.HttpSerializer;
 
 sealed class HttpRequestReader {
 
     Stream _stream;
-    Memory<byte> buffer;
 
     const byte SPACE = (byte) ' ';
     const byte LINE_FEED = (byte) '\n';
@@ -24,40 +23,37 @@ sealed class HttpRequestReader {
     private static ReadOnlySpan<byte> RequestLineDelimiters => [ LINE_FEED, 0 ];
     private static ReadOnlySpan<byte> RequestHeaderLineSpaceDelimiters => [ SPACE, 0 ];
 
-    public HttpRequestReader ( Stream stream, ref byte [] bufferOwnership ) {
+    public HttpRequestReader ( Stream stream ) {
         this._stream = stream;
-        this.buffer = bufferOwnership;
     }
 
-    public async Task<(HttpRequestReadState, HttpRequestBase?)> ReadHttpRequest () {
+    public bool TryReadHttpRequest ( [NotNullWhen ( true )] out HttpRequestBase? request ) {
         try {
-            int read = await this._stream.ReadAsync ( this.buffer );
 
-            if (read == 0) {
-                return (HttpRequestReadState.StreamZero, null);
-            }
+            Span<byte> buffer = stackalloc byte [ HttpConnection.REQUEST_BUFFER_SIZE ];
+            int read = this._stream.Read ( buffer );
 
-            var request = this.ParseHttpRequest ( read );
-            return (HttpRequestReadState.RequestRead, request);
+            request = this.ParseHttpRequest ( buffer [ ..read ] );
+            return request != null;
         }
         catch (Exception ex) {
             Logger.LogInformation ( $"HttpRequestReader finished with exception: {ex.Message}" );
-            return (HttpRequestReadState.StreamError, null);
+            request = null;
+            return false;
         }
     }
 
-    HttpRequestBase? ParseHttpRequest ( int length ) {
+    HttpRequestBase? ParseHttpRequest ( scoped ReadOnlySpan<byte> buffer ) {
 
-        ReadOnlyMemory<byte> bufferPart = this.buffer [ 0..length ];
-        SequenceReader<byte> reader = new SequenceReader<byte> ( new ReadOnlySequence<byte> ( bufferPart ) );
+        SpanReader<byte> reader = new SpanReader<byte> ( buffer );
 
         if (!reader.TryReadToAny ( out ReadOnlySpan<byte> method, RequestHeaderLineSpaceDelimiters, advancePastDelimiter: true )) {
             return null;
         }
         if (!reader.TryReadToAny ( out ReadOnlySpan<byte> path, RequestHeaderLineSpaceDelimiters, advancePastDelimiter: true )) {
             return null;
         }
-        if (!reader.TryReadToAny ( out ReadOnlySpan<byte> protocol, RequestHeaderLineSpaceDelimiters, advancePastDelimiter: true )) {
+        if (!reader.TryReadToAny ( out ReadOnlySpan<byte> protocol, RequestLineDelimiters, advancePastDelimiter: true )) {
             return null;
         }
 
@@ -93,7 +89,7 @@ public HttpRequestReader ( Stream stream, ref byte [] bufferOwnership ) {
         }
 
         return new HttpRequestBase () {
-            BufferedContent = expect100 ? Memory<byte>.Empty : bufferPart [ (int) reader.Consumed.. ],
+            BufferedContent = expect100 ? Memory<byte>.Empty : buffer [ reader.Consumed.. ].ToArray (),
 
             Headers = headers.ToArray (),
             MethodRef = method.ToArray (),
diff --git a/cadente/Sisk.Cadente/HttpSerializer/HttpResponseSerializer.cs b/cadente/Sisk.Cadente/HttpSerializer/HttpResponseSerializer.cs
@@ -15,7 +15,7 @@ namespace Sisk.Cadente.HttpSerializer;
 
 internal static class HttpResponseSerializer {
 
-    static ASCIIEncoding _headerDataEncoding = new ASCIIEncoding ();
+    static Encoding _headerDataEncoding = Encoding.ASCII;
 
     const byte _H = (byte) 'H';
     const byte _T = (byte) 'T';
@@ -32,17 +32,17 @@ internal static class HttpResponseSerializer {
     public static int GetResponseHeadersBytes ( scoped Span<byte> buffer, HttpHostContext.HttpResponse response ) {
 
         // HTTP/1.1
-        buffer [ 0 ] = _H;
-        buffer [ 1 ] = _T;
-        buffer [ 2 ] = _T;
-        buffer [ 3 ] = _P;
-        buffer [ 4 ] = _SLASH;
-        buffer [ 5 ] = _1;
-        buffer [ 6 ] = _DOT;
-        buffer [ 7 ] = _1;
-        buffer [ 8 ] = _SPACE;
-
-        int position = 9;
+        int position = 0;
+
+        buffer [ position++ ] = _H;
+        buffer [ position++ ] = _T;
+        buffer [ position++ ] = _T;
+        buffer [ position++ ] = _P;
+        buffer [ position++ ] = _SLASH;
+        buffer [ position++ ] = _1;
+        buffer [ position++ ] = _DOT;
+        buffer [ position++ ] = _1;
+        buffer [ position++ ] = _SPACE;
 
         int statusCodeCount = _headerDataEncoding.GetBytes ( response.StatusCode.ToString (), buffer [ position.. ] );
         position += statusCodeCount;
diff --git a/cadente/Sisk.Cadente/SpanReader.cs b/cadente/Sisk.Cadente/SpanReader.cs
@@ -0,0 +1,52 @@
+﻿// 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:   SpanReader.cs
+// Repository:  https://github.com/sisk-http/core
+
+using System.Runtime.CompilerServices;
+
+namespace Sisk.Cadente;
+
+ref struct SpanReader<T> where T : IEquatable<T> {
+
+    int readLength = 0;
+
+    public ReadOnlySpan<T> UnreadSpan { get => this.Span [ this.readLength.. ]; }
+    public ReadOnlySpan<T> Span { get; }
+
+    public int Consumed { get => this.readLength; }
+
+    public SpanReader ( in ReadOnlySpan<T> span ) {
+        this.Span = span;
+    }
+
+    public bool TryReadToAny ( out ReadOnlySpan<T> result, scoped ReadOnlySpan<T> delimiters, bool advancePastDelimiter = false ) {
+
+        ReadOnlySpan<T> remaining = this.UnreadSpan;
+
+        int index = delimiters.Length switch {
+            0 => -1,
+            2 => remaining.IndexOfAny ( delimiters [ 0 ], delimiters [ 1 ] ),
+            3 => remaining.IndexOfAny ( delimiters [ 0 ], delimiters [ 1 ], delimiters [ 3 ] ),
+            _ => remaining.IndexOfAny ( delimiters )
+        };
+
+        if (index != -1) {
+            result = remaining.Slice ( 0, index );
+            this.Advance ( index + (advancePastDelimiter ? 1 : 0) );
+            return true;
+        }
+
+        result = default;
+        return false;
+    }
+
+    [MethodImpl ( MethodImplOptions.AggressiveInlining )]
+    public void Advance ( int count ) {
+        this.readLength += count;
+    }
+}
diff --git a/src/Entity/CrossOriginResourceSharingHeaders.cs b/src/Entity/CrossOriginResourceSharingHeaders.cs
@@ -12,6 +12,13 @@ namespace Sisk.Core.Entity {
     /// Provides a class to provide Cross Origin response headers for when communicating with a browser.
     /// </summary>
     public sealed class CrossOriginResourceSharingHeaders {
+
+        /// <summary>
+        /// When applied to the <see cref="AllowOrigin"/> property, the HTTP server automatically applies
+        /// the incoming request Origin header value to the Access-Control-Allow-Origin header.
+        /// </summary>
+        public const string AutoAllowOrigin = "<SISK_AUTO_ALLOW_ORIGIN_NAME>";
+
         /// <summary>
         /// Gets an instance of an empty CrossOriginResourceSharingHeaders.
         /// </summary>
@@ -62,13 +69,38 @@ public sealed class CrossOriginResourceSharingHeaders {
         /// </summary>
         public CrossOriginResourceSharingHeaders () {
             this.ExposeHeaders = Array.Empty<string> ();
-            this.AllowOrigin = null;
             this.AllowOrigins = Array.Empty<string> ();
             this.AllowMethods = Array.Empty<string> ();
             this.AllowHeaders = Array.Empty<string> ();
+            this.AllowOrigin = null;
             this.MaxAge = TimeSpan.Zero;
         }
 
+        /// <summary>
+        /// Initializes a new instance of the <see cref="CrossOriginResourceSharingHeaders"/> class with the specified CORS headers.
+        /// </summary>
+        /// <param name="allowOrigin">The value of the Access-Control-Allow-Origin header.</param>
+        /// <param name="allowOrigins">The values of the Access-Control-Allow-Origin header.</param>
+        /// <param name="allowMethods">The values of the Access-Control-Allow-Methods header.</param>
+        /// <param name="allowHeaders">The values of the Access-Control-Allow-Headers header.</param>
+        /// <param name="exposeHeaders">The values of the Access-Control-Expose-Headers header.</param>
+        /// <param name="maxAge">The value of the Access-Control-Max-Age header.</param>
+        public CrossOriginResourceSharingHeaders (
+            string? allowOrigin = null,
+            string []? allowOrigins = null,
+            string []? allowMethods = null,
+            string []? allowHeaders = null,
+            string []? exposeHeaders = null,
+            TimeSpan? maxAge = null ) {
+
+            this.ExposeHeaders = exposeHeaders ?? Array.Empty<string> ();
+            this.AllowOrigins = allowOrigins ?? Array.Empty<string> ();
+            this.AllowHeaders = allowHeaders ?? Array.Empty<string> ();
+            this.AllowMethods = allowMethods ?? Array.Empty<string> ();
+            this.AllowOrigin = allowOrigin;
+            this.MaxAge = maxAge ?? TimeSpan.Zero;
+        }
+
         /// <summary>
         /// Create an instance of Cross-Origin Resource Sharing that allows any origin, any method and any header in the request.
         /// </summary>
diff --git a/src/Http/Hosting/HttpServerHostContextBuilder.cs b/src/Http/Hosting/HttpServerHostContextBuilder.cs
diff --git a/src/Http/HttpServerConfiguration.cs b/src/Http/HttpServerConfiguration.cs
diff --git a/src/Http/HttpServer__Core.cs b/src/Http/HttpServer__Core.cs

Original file line number	Diff line number	Diff line change
`@@ -143,8 +143,9 @@ private void Dispose ( bool disposing ) {`
`143`	`143`	`}`
`144`	`144`
`145`	`145`	`[MethodImpl ( MethodImplOptions.AggressiveInlining )]`
`146`		`- internal void InvokeContextCreated ( HttpHostContext context ) {`
`147`		`- this.ContextCreated?.Invoke ( this, context );`
	`146`	`+ internal async ValueTask InvokeContextCreated ( HttpHostContext context ) {`
	`147`	`+ if (ContextCreated != null)`
	`148`	`+ await ContextCreated.Invoke ( this, context );`
`148`	`149`	`}`
`149`	`150`
`150`	`151`	`/// <inheritdoc/>`