VerifyCredentialsAsync(string path, string userName, string password, CancellationToken cancellationToken);
+
+ private static (string UserName, string Password) GetCredentials(IHttpRequest request)
+ {
+ var authHeader = request.Headers[HttpHeaderNames.Authorization];
+
+ if (authHeader == null)
+ return default;
+
+ if (!authHeader.StartsWith("basic ", StringComparison.OrdinalIgnoreCase))
+ return default;
+
+ string credentials;
+ try
+ {
+ credentials = WebServer.DefaultEncoding.GetString(Convert.FromBase64String(authHeader.Substring(6).Trim()));
+ }
+ catch (FormatException)
+ {
+ return default;
+ }
+
+ var separatorPos = credentials.IndexOf(':');
+ return separatorPos < 0
+ ? (credentials, string.Empty)
+ : (credentials.Substring(0, separatorPos), credentials.Substring(separatorPos + 1));
+ }
+ }
+}
\ No newline at end of file
diff --git a/Vendor/EmbedIO-3.5.2/Authentication/BasicAuthenticationModuleExtensions.cs b/Vendor/EmbedIO-3.5.2/Authentication/BasicAuthenticationModuleExtensions.cs
new file mode 100644
index 0000000..448ecec
--- /dev/null
+++ b/Vendor/EmbedIO-3.5.2/Authentication/BasicAuthenticationModuleExtensions.cs
@@ -0,0 +1,34 @@
+using System;
+
+namespace EmbedIO.Authentication
+{
+ ///
+ /// Provides extension methods for .
+ ///
+ public static class BasicAuthenticationModuleExtensions
+ {
+ ///
+ /// Adds a username and password to the Accounts dictionary.
+ ///
+ /// The on which this method is called.
+ /// The user name.
+ /// The password.
+ /// , with the user name and password added.
+ /// is .
+ /// is .
+ ///
+ /// The Accounts dictionary already contains
+ /// the maximum number of elements (MaxValue).
+ ///
+ ///
+ /// If a account already exists,
+ /// its password is replaced with .
+ ///
+ public static BasicAuthenticationModule WithAccount(this BasicAuthenticationModule @this, string userName, string password)
+ {
+ @this.Accounts.AddOrUpdate(userName, password, (_, __) => password);
+
+ return @this;
+ }
+ }
+}
\ No newline at end of file
diff --git a/Vendor/EmbedIO-3.5.2/CompressionMethod.cs b/Vendor/EmbedIO-3.5.2/CompressionMethod.cs
new file mode 100644
index 0000000..82f21cf
--- /dev/null
+++ b/Vendor/EmbedIO-3.5.2/CompressionMethod.cs
@@ -0,0 +1,29 @@
+namespace EmbedIO
+{
+ ///
+ /// Specifies the compression method used to compress a message on
+ /// the WebSocket connection.
+ ///
+ ///
+ /// The compression methods that can be used are defined in
+ ///
+ /// Compression Extensions for WebSocket.
+ ///
+ public enum CompressionMethod : byte
+ {
+ ///
+ /// Specifies no compression.
+ ///
+ None,
+
+ ///
+ /// Specifies "Deflate" compression.
+ ///
+ Deflate,
+
+ ///
+ /// Specifies GZip compression.
+ ///
+ Gzip,
+ }
+}
\ No newline at end of file
diff --git a/Vendor/EmbedIO-3.5.2/CompressionMethodNames.cs b/Vendor/EmbedIO-3.5.2/CompressionMethodNames.cs
new file mode 100644
index 0000000..3511b96
--- /dev/null
+++ b/Vendor/EmbedIO-3.5.2/CompressionMethodNames.cs
@@ -0,0 +1,27 @@
+namespace EmbedIO
+{
+ ///
+ /// Exposes constants for possible values of the Content-Encoding HTTP header.
+ ///
+ ///
+ public static class CompressionMethodNames
+ {
+ ///
+ /// Specifies no compression.
+ ///
+ ///
+ public const string None = "identity";
+
+ ///
+ /// Specifies the "Deflate" compression method.
+ ///
+ ///
+ public const string Deflate = "deflate";
+
+ ///
+ /// Specifies the GZip compression method.
+ ///
+ ///
+ public const string Gzip = "gzip";
+ }
+}
\ No newline at end of file
diff --git a/Vendor/EmbedIO-3.5.2/Cors/CorsModule.cs b/Vendor/EmbedIO-3.5.2/Cors/CorsModule.cs
new file mode 100644
index 0000000..ee9bafd
--- /dev/null
+++ b/Vendor/EmbedIO-3.5.2/Cors/CorsModule.cs
@@ -0,0 +1,130 @@
+using System;
+using System.Linq;
+using System.Threading.Tasks;
+using EmbedIO.Utilities;
+
+namespace EmbedIO.Cors
+{
+ ///
+ /// Cross-origin resource sharing (CORS) control Module.
+ /// CORS is a mechanism that allows restricted resources (e.g. fonts)
+ /// on a web page to be requested from another domain outside the domain from which the resource originated.
+ ///
+ public class CorsModule : WebModuleBase
+ {
+ ///
+ /// A string meaning "All" in CORS headers.
+ ///
+ public const string All = "*";
+
+ private readonly string _origins;
+ private readonly string _headers;
+ private readonly string _methods;
+ private readonly string[] _validOrigins;
+ private readonly string[] _validMethods;
+
+ ///
+ /// Initializes a new instance of the class.
+ ///
+ /// The base route.
+ /// The valid origins. The default is (*).
+ /// The valid headers. The default is (*).
+ /// The valid methods. The default is (*).
+ ///
+ /// origins
+ /// or
+ /// headers
+ /// or
+ /// methods
+ ///
+ public CorsModule(
+ string baseRoute,
+ string origins = All,
+ string headers = All,
+ string methods = All)
+ : base(baseRoute)
+ {
+ _origins = origins ?? throw new ArgumentNullException(nameof(origins));
+ _headers = headers ?? throw new ArgumentNullException(nameof(headers));
+ _methods = methods ?? throw new ArgumentNullException(nameof(methods));
+
+ _validOrigins =
+ origins.ToLowerInvariant()
+ .SplitByComma(StringSplitOptions.RemoveEmptyEntries)
+ .Select(x => x.Trim())
+ .ToArray();
+ _validMethods =
+ methods.ToLowerInvariant()
+ .SplitByComma(StringSplitOptions.RemoveEmptyEntries)
+ .Select(x => x.Trim())
+ .ToArray();
+ }
+
+ ///
+ public override bool IsFinalHandler => false;
+
+ ///
+ protected override Task OnRequestAsync(IHttpContext context)
+ {
+ var isOptions = context.Request.HttpVerb == HttpVerbs.Options;
+
+ // If we allow all we don't need to filter
+ if (_origins == All && _headers == All && _methods == All)
+ {
+ context.Response.Headers.Set(HttpHeaderNames.AccessControlAllowOrigin, All);
+
+ if (isOptions)
+ {
+ ValidateHttpOptions(context);
+ context.SetHandled();
+ }
+
+ return Task.CompletedTask;
+ }
+
+ var currentOrigin = context.Request.Headers[HttpHeaderNames.Origin];
+
+ if (string.IsNullOrWhiteSpace(currentOrigin) && context.Request.IsLocal)
+ return Task.CompletedTask;
+
+ if (_origins == All)
+ return Task.CompletedTask;
+
+ if (_validOrigins.Contains(currentOrigin))
+ {
+ context.Response.Headers.Set(HttpHeaderNames.AccessControlAllowOrigin, currentOrigin);
+
+ if (isOptions)
+ {
+ ValidateHttpOptions(context);
+ context.SetHandled();
+ }
+ }
+
+ return Task.CompletedTask;
+ }
+
+ private void ValidateHttpOptions(IHttpContext context)
+ {
+ var requestHeadersHeader = context.Request.Headers[HttpHeaderNames.AccessControlRequestHeaders];
+ if (!string.IsNullOrWhiteSpace(requestHeadersHeader))
+ {
+ // TODO: Remove unwanted headers from request
+ context.Response.Headers.Set(HttpHeaderNames.AccessControlAllowHeaders, requestHeadersHeader);
+ }
+
+ var requestMethodHeader = context.Request.Headers[HttpHeaderNames.AccessControlRequestMethod];
+ if (string.IsNullOrWhiteSpace(requestMethodHeader))
+ return;
+
+ var currentMethods = requestMethodHeader.ToLowerInvariant()
+ .SplitByComma(StringSplitOptions.RemoveEmptyEntries)
+ .Select(x => x.Trim());
+
+ if (_methods != All && !currentMethods.Any(_validMethods.Contains))
+ throw HttpException.BadRequest();
+
+ context.Response.Headers.Set(HttpHeaderNames.AccessControlAllowMethods, requestMethodHeader);
+ }
+ }
+}
\ No newline at end of file
diff --git a/Vendor/EmbedIO-3.5.2/EmbedIOInternalErrorException.cs b/Vendor/EmbedIO-3.5.2/EmbedIOInternalErrorException.cs
new file mode 100644
index 0000000..4d800b8
--- /dev/null
+++ b/Vendor/EmbedIO-3.5.2/EmbedIOInternalErrorException.cs
@@ -0,0 +1,64 @@
+using System;
+using System.Runtime.Serialization;
+
+/*
+ * NOTE TO CONTRIBUTORS:
+ *
+ * Never use this exception directly.
+ * Use the methods in EmbedIO.Internal.SelfCheck instead.
+ */
+
+namespace EmbedIO
+{
+#pragma warning disable SA1642 // Constructor summary documentation should begin with standard text
+ ///
+ /// The exception that is thrown by EmbedIO's internal diagnostic checks to signal a condition
+ /// most probably caused by an error in EmbedIO.
+ /// This API supports the EmbedIO infrastructure and is not intended to be used directly from your code.
+ ///
+ [Serializable]
+ public class EmbedIOInternalErrorException : Exception
+ {
+ ///
+ /// Initializes a new instance of the class.
+ /// This API supports the EmbedIO infrastructure and is not intended to be used directly from your code.
+ ///
+ public EmbedIOInternalErrorException()
+ {
+ }
+
+ ///
+ /// Initializes a new instance of the class.
+ /// This API supports the EmbedIO infrastructure and is not intended to be used directly from your code.
+ ///
+ /// The message that describes the error.
+ public EmbedIOInternalErrorException(string message)
+ : base(message)
+ {
+ }
+
+ ///
+ /// Initializes a new instance of the class.
+ /// This API supports the EmbedIO infrastructure and is not intended to be used directly from your code.
+ ///
+ /// The error message that explains the reason for the exception.
+ /// The exception that is the cause of the current exception,
+ /// or if no inner exception is specified.
+ public EmbedIOInternalErrorException(string message, Exception? innerException)
+ : base(message, innerException)
+ {
+ }
+
+ ///
+ /// Initializes a new instance of the class.
+ /// This API supports the EmbedIO infrastructure and is not intended to be used directly from your code.
+ ///
+ /// The that holds the serialized object data about the exception being thrown.
+ /// The that contains contextual information about the source or destination.
+ protected EmbedIOInternalErrorException(SerializationInfo info, StreamingContext context)
+ : base(info, context)
+ {
+ }
+ }
+#pragma warning restore SA1642
+}
\ No newline at end of file
diff --git a/Vendor/EmbedIO-3.5.2/ExceptionHandler.cs b/Vendor/EmbedIO-3.5.2/ExceptionHandler.cs
new file mode 100644
index 0000000..6355889
--- /dev/null
+++ b/Vendor/EmbedIO-3.5.2/ExceptionHandler.cs
@@ -0,0 +1,165 @@
+using System;
+using System.Net;
+using System.Runtime.ExceptionServices;
+using System.Threading.Tasks;
+using System.Web;
+using System.Web.Util;
+using Swan.Logging;
+
+namespace EmbedIO
+{
+ ///
+ /// Provides standard handlers for unhandled exceptions at both module and server level.
+ ///
+ ///
+ ///
+ public static class ExceptionHandler
+ {
+ ///
+ /// The name of the response header used by the
+ /// handler to transmit the type of the exception to the client.
+ ///
+ public const string ExceptionTypeHeaderName = "X-Exception-Type";
+
+ ///
+ /// The name of the response header used by the
+ /// handler to transmit the message of the exception to the client.
+ ///
+ public const string ExceptionMessageHeaderName = "X-Exception-Message";
+
+ ///
+ /// Gets or sets the contact information to include in exception responses.
+ ///
+ public static string? ContactInformation { get; set; }
+
+ ///
+ /// Gets or sets a value indicating whether to include stack traces
+ /// in exception responses.
+ ///
+ public static bool IncludeStackTraces { get; set; }
+
+ ///
+ /// Gets the default handler used by .
+ /// This is the same as .
+ ///
+ public static ExceptionHandlerCallback Default { get; } = HtmlResponse;
+
+ ///
+ /// Sends an empty 500 Internal Server Error response.
+ ///
+ /// An interface representing the context of the request.
+ /// The unhandled exception.
+ /// A representing the ongoing operation.
+#pragma warning disable CA1801 // Unused parameter
+ public static Task EmptyResponse(IHttpContext context, Exception exception)
+#pragma warning restore CA1801
+ {
+ context.Response.SetEmptyResponse((int)HttpStatusCode.InternalServerError);
+ return Task.CompletedTask;
+ }
+
+ ///
+ /// Sends an empty 500 Internal Server Error response,
+ /// with the following additional headers:
+ ///
+ ///
+ /// Header
+ /// Value
+ ///
+ /// -
+ /// X-Exception-Type
+ /// The name (without namespace) of the type of exception that was thrown.
+ ///
+ /// -
+ /// X-Exception-Message
+ /// The Message property of the exception.
+ ///
+ ///
+ /// The aforementioned header names are available as the and
+ /// properties, respectively.
+ ///
+ /// An interface representing the context of the request.
+ /// The unhandled exception.
+ /// A representing the ongoing operation.
+ public static Task EmptyResponseWithHeaders(IHttpContext context, Exception exception)
+ {
+ context.Response.SetEmptyResponse((int)HttpStatusCode.InternalServerError);
+ context.Response.Headers[ExceptionTypeHeaderName] = Uri.EscapeDataString(exception.GetType().Name);
+ context.Response.Headers[ExceptionMessageHeaderName] = Uri.EscapeDataString(exception.Message);
+ return Task.CompletedTask;
+ }
+
+ ///
+ /// Sends a 500 Internal Server Error response with a HTML payload
+ /// briefly describing the error, including contact information and/or a stack trace
+ /// if specified via the and
+ /// properties, respectively.
+ ///
+ /// An interface representing the context of the request.
+ /// The unhandled exception.
+ /// A representing the ongoing operation.
+ public static Task HtmlResponse(IHttpContext context, Exception exception)
+ => context.SendStandardHtmlAsync(
+ (int)HttpStatusCode.InternalServerError,
+ text =>
+ {
+ text.Write("The server has encountered an error and was not able to process your request.
");
+ text.Write("Please contact the server administrator");
+
+ if (!string.IsNullOrEmpty(ContactInformation))
+ text.Write(" ({0})", WebUtility.HtmlEncode(ContactInformation));
+
+ text.Write(", informing them of the time this error occurred and the action(s) you performed that resulted in this error.
");
+ text.Write("The following information may help them in finding out what happened and restoring full functionality.
");
+ text.Write(
+ "Exception type: {0}
Message: {1}",
+ WebUtility.HtmlEncode(exception.GetType().FullName ?? ""),
+ WebUtility.HtmlEncode(exception.Message));
+
+ if (IncludeStackTraces)
+ {
+ text.Write(
+ "
Stack trace:
{0}",
+ WebUtility.HtmlEncode(exception.StackTrace));
+ }
+ });
+
+ internal static async Task Handle(string logSource, IHttpContext context, Exception exception, ExceptionHandlerCallback? handler, HttpExceptionHandlerCallback? httpHandler)
+ {
+ if (handler == null)
+ {
+ ExceptionDispatchInfo.Capture(exception).Throw();
+ return;
+ }
+
+ exception.Log(logSource, $"[{context.Id}] Unhandled exception.");
+
+ try
+ {
+ context.Response.SetEmptyResponse((int)HttpStatusCode.InternalServerError);
+ context.Response.DisableCaching();
+ await handler(context, exception)
+ .ConfigureAwait(false);
+ }
+ catch (OperationCanceledException) when (context.CancellationToken.IsCancellationRequested)
+ {
+ throw;
+ }
+ catch (HttpListenerException)
+ {
+ throw;
+ }
+ catch (Exception httpException) when (httpException is IHttpException httpException1)
+ {
+ if (httpHandler == null)
+ throw;
+
+ await httpHandler(context, httpException1).ConfigureAwait(false);
+ }
+ catch (Exception exception2)
+ {
+ exception2.Log(logSource, $"[{context.Id}] Unhandled exception while handling exception.");
+ }
+ }
+ }
+}
diff --git a/Vendor/EmbedIO-3.5.2/ExceptionHandlerCallback.cs b/Vendor/EmbedIO-3.5.2/ExceptionHandlerCallback.cs
new file mode 100644
index 0000000..406dda2
--- /dev/null
+++ b/Vendor/EmbedIO-3.5.2/ExceptionHandlerCallback.cs
@@ -0,0 +1,22 @@
+using System;
+using System.Net;
+using System.Threading.Tasks;
+
+namespace EmbedIO
+{
+ ///
+ /// A callback used to provide information about an unhandled exception occurred while processing a request.
+ ///
+ /// An interface representing the context of the request.
+ /// The unhandled exception.
+ /// A representing the ongoing operation.
+ ///
+ /// When this delegate is called, the response's status code has already been set to
+ /// .
+ /// Any exception thrown by a handler (even a HTTP exception) will go unhandled: the web server
+ /// will not crash, but processing of the request will be aborted, and the response will be flushed as-is.
+ /// In other words, it is not a good ides to throw HttpException.NotFound() (or similar)
+ /// from a handler.
+ ///
+ public delegate Task ExceptionHandlerCallback(IHttpContext context, Exception exception);
+}
\ No newline at end of file
diff --git a/Vendor/EmbedIO-3.5.2/Files/DirectoryLister.cs b/Vendor/EmbedIO-3.5.2/Files/DirectoryLister.cs
new file mode 100644
index 0000000..d99ee89
--- /dev/null
+++ b/Vendor/EmbedIO-3.5.2/Files/DirectoryLister.cs
@@ -0,0 +1,20 @@
+using EmbedIO.Files.Internal;
+
+namespace EmbedIO.Files
+{
+ ///
+ /// Provides standard directory listers for .
+ ///
+ ///
+ public static class DirectoryLister
+ {
+ ///
+ /// Gets an interface
+ /// that produces a HTML listing of a directory.
+ /// The output of the returned directory lister
+ /// is the same as a directory listing obtained
+ /// by EmbedIO version 2.
+ ///
+ public static IDirectoryLister Html => HtmlDirectoryLister.Instance;
+ }
+}
\ No newline at end of file
diff --git a/Vendor/EmbedIO-3.5.2/Files/FileCache.Section.cs b/Vendor/EmbedIO-3.5.2/Files/FileCache.Section.cs
new file mode 100644
index 0000000..e133f14
--- /dev/null
+++ b/Vendor/EmbedIO-3.5.2/Files/FileCache.Section.cs
@@ -0,0 +1,185 @@
+using System;
+using System.Collections.Generic;
+using EmbedIO.Files.Internal;
+
+namespace EmbedIO.Files
+{
+ public sealed partial class FileCache
+ {
+ internal class Section
+ {
+ private readonly object _syncRoot = new object();
+ private readonly Dictionary _items = new Dictionary(StringComparer.Ordinal);
+ private long _totalSize;
+ private string? _oldestKey;
+ private string? _newestKey;
+
+ public void Clear()
+ {
+ lock (_syncRoot)
+ {
+ ClearCore();
+ }
+ }
+
+ public void Add(string path, FileCacheItem item)
+ {
+ lock (_syncRoot)
+ {
+ AddItemCore(path, item);
+ }
+ }
+
+ public void Remove(string path)
+ {
+ lock (_syncRoot)
+ {
+ RemoveItemCore(path);
+ }
+ }
+
+ public bool TryGet(string path, out FileCacheItem item)
+ {
+ lock (_syncRoot)
+ {
+ if (!_items.TryGetValue(path, out item))
+ return false;
+
+ RefreshItemCore(path, item);
+ return true;
+ }
+ }
+
+ internal long GetLeastRecentUseTime()
+ {
+ lock (_syncRoot)
+ {
+ return _oldestKey == null ? long.MaxValue : _items[_oldestKey].LastUsedAt;
+ }
+ }
+
+ // Removes least recently used item.
+ // Returns size of removed item.
+ internal long RemoveLeastRecentItem()
+ {
+ lock (_syncRoot)
+ {
+ return RemoveLeastRecentItemCore();
+ }
+ }
+
+ internal long GetTotalSize()
+ {
+ lock (_syncRoot)
+ {
+ return _totalSize;
+ }
+ }
+
+ internal void UpdateTotalSize(long delta)
+ {
+ lock (_syncRoot)
+ {
+ _totalSize += delta;
+ }
+ }
+
+ private void ClearCore()
+ {
+ _items.Clear();
+ _totalSize = 0;
+ _oldestKey = null;
+ _newestKey = null;
+ }
+
+ // Adds an item as most recently used.
+ private void AddItemCore(string path, FileCacheItem item)
+ {
+ item.PreviousKey = _newestKey;
+ item.NextKey = null;
+ item.LastUsedAt = TimeBase.ElapsedTicks;
+
+ if (_newestKey != null)
+ _items[_newestKey].NextKey = path;
+
+ _newestKey = path;
+
+ _items[path] = item;
+ _totalSize += item.SizeInCache;
+ }
+
+ // Removes an item.
+ private void RemoveItemCore(string path)
+ {
+ if (!_items.TryGetValue(path, out var item))
+ return;
+
+ if (_oldestKey == path)
+ _oldestKey = item.NextKey;
+
+ if (_newestKey == path)
+ _newestKey = item.PreviousKey;
+
+ if (item.PreviousKey != null)
+ _items[item.PreviousKey].NextKey = item.NextKey;
+
+ if (item.NextKey != null)
+ _items[item.NextKey].PreviousKey = item.PreviousKey;
+
+ item.PreviousKey = null;
+ item.NextKey = null;
+
+ _items.Remove(path);
+ _totalSize -= item.SizeInCache;
+ }
+
+ // Removes the least recently used item.
+ // returns size of removed item.
+ private long RemoveLeastRecentItemCore()
+ {
+ var path = _oldestKey;
+ if (path == null)
+ return 0;
+
+ var item = _items[path];
+
+ if ((_oldestKey = item.NextKey) != null)
+ _items[_oldestKey].PreviousKey = null;
+
+ if (_newestKey == path)
+ _newestKey = null;
+
+ item.PreviousKey = null;
+ item.NextKey = null;
+
+ _items.Remove(path);
+ _totalSize -= item.SizeInCache;
+ return item.SizeInCache;
+ }
+
+ // Moves an item to most recently used.
+ private void RefreshItemCore(string path, FileCacheItem item)
+ {
+ item.LastUsedAt = TimeBase.ElapsedTicks;
+
+ if (_newestKey == path)
+ return;
+
+ if (_oldestKey == path)
+ _oldestKey = item.NextKey;
+
+ if (item.PreviousKey != null)
+ _items[item.PreviousKey].NextKey = item.NextKey;
+
+ if (item.NextKey != null)
+ _items[item.NextKey].PreviousKey = item.PreviousKey;
+
+ item.PreviousKey = _newestKey;
+ item.NextKey = null;
+
+ _items[_newestKey!].NextKey = path;
+ _newestKey = path;
+ }
+ }
+ }
+}
\ No newline at end of file
diff --git a/Vendor/EmbedIO-3.5.2/Files/FileCache.cs b/Vendor/EmbedIO-3.5.2/Files/FileCache.cs
new file mode 100644
index 0000000..accf545
--- /dev/null
+++ b/Vendor/EmbedIO-3.5.2/Files/FileCache.cs
@@ -0,0 +1,178 @@
+using System;
+using System.Collections.Concurrent;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using EmbedIO.Internal;
+using Swan.Threading;
+using Swan.Logging;
+
+namespace EmbedIO.Files
+{
+#pragma warning disable CA1001 // Type owns disposable field '_cleaner' but is not disposable - _cleaner has its own dispose semantics.
+ ///
+ /// A cache where one or more instances of can store hashes and file contents.
+ ///
+ public sealed partial class FileCache
+#pragma warning restore CA1001
+ {
+ ///
+ /// The default value for the property.
+ ///
+ public const int DefaultMaxSizeKb = 10240;
+
+ ///
+ /// The default value for the property.
+ ///
+ public const int DefaultMaxFileSizeKb = 200;
+
+ private static readonly Stopwatch TimeBase = Stopwatch.StartNew();
+
+ private static readonly object DefaultSyncRoot = new object();
+ private static FileCache? _defaultInstance;
+
+ private readonly ConcurrentDictionary _sections = new ConcurrentDictionary(StringComparer.Ordinal);
+ private int _sectionCount; // Because ConcurrentDictionary<,>.Count is locking.
+ private int _maxSizeKb = DefaultMaxSizeKb;
+ private int _maxFileSizeKb = DefaultMaxFileSizeKb;
+ private PeriodicTask? _cleaner;
+
+ ///
+ /// Gets the default instance used by .
+ ///
+ public static FileCache Default
+ {
+ get
+ {
+ if (_defaultInstance != null)
+ return _defaultInstance;
+
+ lock (DefaultSyncRoot)
+ {
+ if (_defaultInstance == null)
+ _defaultInstance = new FileCache();
+ }
+
+ return _defaultInstance;
+ }
+ }
+
+ ///
+ /// Gets or sets the maximum total size of cached data in kilobytes (1 kilobyte = 1024 bytes).
+ /// The default value for this property is stored in the constant field.
+ /// Setting this property to a value less lower han 1 has the same effect as setting it to 1.
+ ///
+ public int MaxSizeKb
+ {
+ get => _maxSizeKb;
+ set => _maxSizeKb = Math.Max(value, 1);
+ }
+
+ ///
+ /// Gets or sets the maximum size of a single cached file in kilobytes (1 kilobyte = 1024 bytes).
+ /// A single file's contents may be present in a cache more than once, if the file
+ /// is requested with different Accept-Encoding request headers. This property acts as a threshold
+ /// for the uncompressed size of a file.
+ /// The default value for this property is stored in the constant field.
+ /// Setting this property to a value lower than 0 has the same effect as setting it to 0, in fact
+ /// completely disabling the caching of file contents for this cache.
+ /// This property cannot be set to a value higher than 2097151; in other words, it is not possible
+ /// to cache files bigger than two Gigabytes (1 Gigabyte = 1048576 kilobytes) minus 1 kilobyte.
+ ///
+ public int MaxFileSizeKb
+ {
+ get => _maxFileSizeKb;
+ set => _maxFileSizeKb = Math.Min(Math.Max(value, 0), 2097151);
+ }
+
+ // Cast as IDictionary because we WANT an exception to be thrown if the name exists.
+ // It would mean that something is very, very wrong.
+ internal Section AddSection(string name)
+ {
+ var section = new Section();
+ (_sections as IDictionary).Add(name, section);
+
+ if (Interlocked.Increment(ref _sectionCount) == 1)
+ _cleaner = new PeriodicTask(TimeSpan.FromMinutes(1), CheckMaxSize);
+
+ return section;
+ }
+
+ internal void RemoveSection(string name)
+ {
+ _sections.TryRemove(name, out _);
+
+ if (Interlocked.Decrement(ref _sectionCount) == 0)
+ {
+ _cleaner?.Dispose();
+ _cleaner = null;
+ }
+ }
+
+ private async Task CheckMaxSize(CancellationToken cancellationToken)
+ {
+ var timeKeeper = new TimeKeeper();
+ var maxSizeKb = _maxSizeKb;
+ var initialSizeKb = ComputeTotalSize() / 1024L;
+
+ if (initialSizeKb <= maxSizeKb)
+ {
+ $"Total size = {initialSizeKb}/{_maxSizeKb}kb, not purging.".Debug(nameof(FileCache));
+ return;
+ }
+
+ $"Total size = {initialSizeKb}/{_maxSizeKb}kb, purging...".Debug(nameof(FileCache));
+
+ var removedCount = 0;
+ var removedSize = 0L;
+ var totalSizeKb = initialSizeKb;
+ var threshold = 973L * maxSizeKb / 1024L; // About 95% of maximum allowed size
+ while (totalSizeKb > threshold)
+ {
+ if (cancellationToken.IsCancellationRequested)
+ return;
+
+ var section = GetSectionWithLeastRecentItem();
+ if (section == null)
+ return;
+
+ removedSize += section.RemoveLeastRecentItem();
+ removedCount++;
+
+ await Task.Yield();
+
+ totalSizeKb = ComputeTotalSize() / 1024L;
+ }
+
+ $"Purge completed in {timeKeeper.ElapsedTime}ms: removed {removedCount} items ({removedSize / 1024L}kb). Total size is now {totalSizeKb}kb."
+ .Debug(nameof(FileCache));
+ }
+
+ // Enumerate key / value pairs because the Keys and Values property
+ // of ConcurrentDictionary<,> have snapshot semantics,
+ // while GetEnumerator enumerates without locking.
+ private long ComputeTotalSize()
+ => _sections.Sum(pair => pair.Value.GetTotalSize());
+
+ private Section? GetSectionWithLeastRecentItem()
+ {
+ Section? result = null;
+ var earliestTime = long.MaxValue;
+ foreach (var pair in _sections)
+ {
+ var section = pair.Value;
+ var time = section.GetLeastRecentUseTime();
+
+ if (time < earliestTime)
+ {
+ result = section;
+ earliestTime = time;
+ }
+ }
+
+ return result;
+ }
+ }
+}
\ No newline at end of file
diff --git a/Vendor/EmbedIO-3.5.2/Files/FileModule.cs b/Vendor/EmbedIO-3.5.2/Files/FileModule.cs
new file mode 100644
index 0000000..5dccd56
--- /dev/null
+++ b/Vendor/EmbedIO-3.5.2/Files/FileModule.cs
@@ -0,0 +1,635 @@
+using System;
+using System.Collections.Concurrent;
+using System.IO;
+using System.Net;
+using System.Threading;
+using System.Threading.Tasks;
+using EmbedIO.Files.Internal;
+using EmbedIO.Internal;
+using EmbedIO.Utilities;
+
+namespace EmbedIO.Files
+{
+ ///
+ /// A module serving files and directory listings from an .
+ ///
+ ///
+ public class FileModule : WebModuleBase, IDisposable, IMimeTypeCustomizer
+ {
+ ///
+ /// Default value for .
+ ///
+ public const string DefaultDocumentName = "index.html";
+
+ private readonly string _cacheSectionName = UniqueIdGenerator.GetNext();
+ private readonly MimeTypeCustomizer _mimeTypeCustomizer = new MimeTypeCustomizer();
+ private readonly ConcurrentDictionary? _mappingCache;
+
+ private FileCache _cache = FileCache.Default;
+ private bool _contentCaching = true;
+ private string? _defaultDocument = DefaultDocumentName;
+ private string? _defaultExtension;
+ private IDirectoryLister? _directoryLister;
+ private FileRequestHandlerCallback _onMappingFailed = FileRequestHandler.ThrowNotFound;
+ private FileRequestHandlerCallback _onDirectoryNotListable = FileRequestHandler.ThrowUnauthorized;
+ private FileRequestHandlerCallback _onMethodNotAllowed = FileRequestHandler.ThrowMethodNotAllowed;
+
+ private FileCache.Section? _cacheSection;
+
+ ///
+ /// Initializes a new instance of the class,
+ /// using the specified cache.
+ ///
+ /// The base route.
+ /// An interface that provides access
+ /// to actual files and directories.
+ /// is .
+ public FileModule(string baseRoute, IFileProvider provider)
+ : base(baseRoute)
+ {
+ Provider = Validate.NotNull(nameof(provider), provider);
+ _mappingCache = Provider.IsImmutable
+ ? new ConcurrentDictionary()
+ : null;
+ }
+
+ ///
+ /// Finalizes an instance of the class.
+ ///
+ ~FileModule()
+ {
+ Dispose(false);
+ }
+
+ ///
+ public override bool IsFinalHandler => true;
+
+ ///
+ /// Gets the interface that provides access
+ /// to actual files and directories served by this module.
+ ///
+ public IFileProvider Provider { get; }
+
+ ///
+ /// Gets or sets the used by this module to store hashes and,
+ /// optionally, file contents and rendered directory listings.
+ ///
+ /// The module's configuration is locked.
+ /// This property is being set to .
+ public FileCache Cache
+ {
+ get => _cache;
+ set
+ {
+ EnsureConfigurationNotLocked();
+ _cache = Validate.NotNull(nameof(value), value);
+ }
+ }
+
+ ///
+ /// Gets or sets a value indicating whether this module caches the contents of files
+ /// and directory listings.
+ /// Note that the actual representations of files are stored in ;
+ /// thus, for example, if a file is always requested with an Accept-Encoding of gzip,
+ /// only the gzipped contents of the file will be cached.
+ ///
+ /// The module's configuration is locked.
+ public bool ContentCaching
+ {
+ get => _contentCaching;
+ set
+ {
+ EnsureConfigurationNotLocked();
+ _contentCaching = value;
+ }
+ }
+
+ ///
+ /// Gets or sets the name of the default document served, if it exists, instead of a directory listing
+ /// when the path of a requested URL maps to a directory.
+ /// The default value for this property is the constant.
+ ///
+ /// The module's configuration is locked.
+ public string? DefaultDocument
+ {
+ get => _defaultDocument;
+ set
+ {
+ EnsureConfigurationNotLocked();
+ _defaultDocument = string.IsNullOrEmpty(value) ? null : value;
+ }
+ }
+
+ ///
+ /// Gets or sets the default extension appended to requested URL paths that do not map
+ /// to any file or directory. Defaults to .
+ ///
+ /// The module's configuration is locked.
+ /// This property is being set to a non-,
+ /// non-empty string that does not start with a period (.).
+ public string? DefaultExtension
+ {
+ get => _defaultExtension;
+ set
+ {
+ EnsureConfigurationNotLocked();
+
+ if (string.IsNullOrEmpty(value))
+ {
+ _defaultExtension = null;
+ }
+ else if (value![0] != '.')
+ {
+ throw new ArgumentException("Default extension does not start with a period.", nameof(value));
+ }
+ else
+ {
+ _defaultExtension = value;
+ }
+ }
+ }
+
+ ///
+ /// Gets or sets the interface used to generate
+ /// directory listing in this module.
+ /// A value of (the default) disables the generation
+ /// of directory listings.
+ ///
+ /// The module's configuration is locked.
+ public IDirectoryLister? DirectoryLister
+ {
+ get => _directoryLister;
+ set
+ {
+ EnsureConfigurationNotLocked();
+ _directoryLister = value;
+ }
+ }
+
+ ///
+ /// Gets or sets a that is called whenever
+ /// the requested URL path could not be mapped to any file or directory.
+ /// The default is .
+ ///
+ /// The module's configuration is locked.
+ /// This property is being set to .
+ ///
+ public FileRequestHandlerCallback OnMappingFailed
+ {
+ get => _onMappingFailed;
+ set
+ {
+ EnsureConfigurationNotLocked();
+ _onMappingFailed = Validate.NotNull(nameof(value), value);
+ }
+ }
+
+ ///
+ /// Gets or sets a that is called whenever
+ /// the requested URL path has been mapped to a directory, but directory listing has been
+ /// disabled by setting to .
+ /// The default is .
+ ///
+ /// The module's configuration is locked.
+ /// This property is being set to .
+ ///
+ public FileRequestHandlerCallback OnDirectoryNotListable
+ {
+ get => _onDirectoryNotListable;
+ set
+ {
+ EnsureConfigurationNotLocked();
+ _onDirectoryNotListable = Validate.NotNull(nameof(value), value);
+ }
+ }
+
+ ///
+ /// Gets or sets a that is called whenever
+ /// the requested URL path has been mapped to a file or directory, but the request's
+ /// HTTP method is neither GET nor HEAD.
+ /// The default is .
+ ///
+ /// The module's configuration is locked.
+ /// This property is being set to .
+ ///
+ public FileRequestHandlerCallback OnMethodNotAllowed
+ {
+ get => _onMethodNotAllowed;
+ set
+ {
+ EnsureConfigurationNotLocked();
+ _onMethodNotAllowed = Validate.NotNull(nameof(value), value);
+ }
+ }
+
+ ///
+ public void Dispose()
+ {
+ Dispose(true);
+ GC.SuppressFinalize(this);
+ }
+
+ string IMimeTypeProvider.GetMimeType(string extension)
+ => _mimeTypeCustomizer.GetMimeType(extension);
+
+ bool IMimeTypeProvider.TryDetermineCompression(string mimeType, out bool preferCompression)
+ => _mimeTypeCustomizer.TryDetermineCompression(mimeType, out preferCompression);
+
+ ///
+ public void AddCustomMimeType(string extension, string mimeType)
+ => _mimeTypeCustomizer.AddCustomMimeType(extension, mimeType);
+
+ ///
+ public void PreferCompression(string mimeType, bool preferCompression)
+ => _mimeTypeCustomizer.PreferCompression(mimeType, preferCompression);
+
+ ///
+ /// Clears the part of used by this module.
+ ///
+ public void ClearCache()
+ {
+ _mappingCache?.Clear();
+ _cacheSection?.Clear();
+ }
+
+ ///
+ /// Releases unmanaged and - optionally - managed resources.
+ ///
+ /// to release both managed and unmanaged resources;
+ /// to release only unmanaged resources.
+ protected virtual void Dispose(bool disposing)
+ {
+ if (!disposing)
+ return;
+
+ if (_cacheSection != null)
+ Provider.ResourceChanged -= _cacheSection.Remove;
+
+ if (Provider is IDisposable disposableProvider)
+ disposableProvider.Dispose();
+
+ if (_cacheSection != null)
+ Cache.RemoveSection(_cacheSectionName);
+ }
+
+ ///
+ protected override void OnBeforeLockConfiguration()
+ {
+ base.OnBeforeLockConfiguration();
+
+ _mimeTypeCustomizer.Lock();
+ }
+
+ ///
+ protected override void OnStart(CancellationToken cancellationToken)
+ {
+ base.OnStart(cancellationToken);
+
+ _cacheSection = Cache.AddSection(_cacheSectionName);
+ Provider.ResourceChanged += _cacheSection.Remove;
+ Provider.Start(cancellationToken);
+ }
+
+ ///
+ protected override async Task OnRequestAsync(IHttpContext context)
+ {
+ MappedResourceInfo? info;
+
+ var path = context.RequestedPath;
+
+ // Map the URL path to a mapped resource.
+ // DefaultDocument and DefaultExtension are handled here.
+ // Use the mapping cache if it exists.
+ if (_mappingCache == null)
+ {
+ info = MapUrlPath(path, context);
+ }
+ else if (!_mappingCache.TryGetValue(path, out info))
+ {
+ info = MapUrlPath(path, context);
+ if (info != null)
+ _ = _mappingCache.AddOrUpdate(path, info, (_, __) => info);
+ }
+
+ if (info == null)
+ {
+ // If mapping failed, send a "404 Not Found" response, or whatever OnMappingFailed chooses to do.
+ // For example, it may return a default resource (think a folder of images and an imageNotFound.jpg),
+ // or redirect the request.
+ await OnMappingFailed(context, null).ConfigureAwait(false);
+ }
+ else if (!IsHttpMethodAllowed(context.Request, out var sendResponseBody))
+ {
+ // If there is a mapped resource, check that the HTTP method is either GET or HEAD.
+ // Otherwise, send a "405 Method Not Allowed" response, or whatever OnMethodNotAllowed chooses to do.
+ await OnMethodNotAllowed(context, info).ConfigureAwait(false);
+ }
+ else if (info.IsDirectory && DirectoryLister == null)
+ {
+ // If a directory listing was requested, but there is no DirectoryLister,
+ // send a "403 Unauthorized" response, or whatever OnDirectoryNotListable chooses to do.
+ // For example, one could prefer to send "404 Not Found" instead.
+ await OnDirectoryNotListable(context, info).ConfigureAwait(false);
+ }
+ else
+ {
+ await HandleResource(context, info, sendResponseBody).ConfigureAwait(false);
+ }
+ }
+
+ // Tells whether a request's HTTP method is suitable for processing by FileModule
+ // and, if so, whether a response body must be sent.
+ private static bool IsHttpMethodAllowed(IHttpRequest request, out bool sendResponseBody)
+ {
+ switch (request.HttpVerb)
+ {
+ case HttpVerbs.Head:
+ sendResponseBody = false;
+ return true;
+ case HttpVerbs.Get:
+ sendResponseBody = true;
+ return true;
+ default:
+ sendResponseBody = default;
+ return false;
+ }
+ }
+
+ // Prepares response headers for a "200 OK" or "304 Not Modified" response.
+ // RFC7232, Section 4.1
+ private static void PreparePositiveResponse(IHttpResponse response, MappedResourceInfo info, string contentType, string entityTag, Action setCompression)
+ {
+ setCompression(response);
+ response.ContentType = contentType;
+ response.Headers.Set(HttpHeaderNames.ETag, entityTag);
+ response.Headers.Set(HttpHeaderNames.LastModified, HttpDate.Format(info.LastModifiedUtc));
+ response.Headers.Set(HttpHeaderNames.CacheControl, "max-age=0, must-revalidate");
+ response.Headers.Set(HttpHeaderNames.AcceptRanges, "bytes");
+ }
+
+ // Attempts to map a module-relative URL path to a mapped resource,
+ // handling DefaultDocument and DefaultExtension.
+ // Returns null if not found.
+ // Directories mus be returned regardless of directory listing being enabled.
+ private MappedResourceInfo? MapUrlPath(string urlPath, IMimeTypeProvider mimeTypeProvider)
+ {
+ var result = Provider.MapUrlPath(urlPath, mimeTypeProvider);
+
+ // If urlPath maps to a file, no further searching is needed.
+ if (result?.IsFile ?? false)
+ return result;
+
+ // Look for a default document.
+ // Don't append an additional slash if the URL path is "/".
+ // The default document, if found, must be a file, not a directory.
+ if (DefaultDocument != null)
+ {
+ var defaultDocumentPath = urlPath + (urlPath.Length > 1 ? "/" : string.Empty) + DefaultDocument;
+ var defaultDocumentResult = Provider.MapUrlPath(defaultDocumentPath, mimeTypeProvider);
+ if (defaultDocumentResult?.IsFile ?? false)
+ return defaultDocumentResult;
+ }
+
+ // Try to apply default extension (but not if the URL path is "/",
+ // i.e. the only normalized, non-base URL path that ends in a slash).
+ // When the default extension is applied, the result must be a file.
+ if (DefaultExtension != null && urlPath.Length > 1)
+ {
+ var defaultExtensionResult = Provider.MapUrlPath(urlPath + DefaultExtension, mimeTypeProvider);
+ if (defaultExtensionResult?.IsFile ?? false)
+ return defaultExtensionResult;
+ }
+
+ return result;
+ }
+
+ private async Task HandleResource(IHttpContext context, MappedResourceInfo info, bool sendResponseBody)
+ {
+ // Try to extract resource information from cache.
+ var cachingThreshold = 1024L * Cache.MaxFileSizeKb;
+ if (!_cacheSection!.TryGet(info.Path, out var cacheItem))
+ {
+ // Resource information not yet cached
+ cacheItem = new FileCacheItem(_cacheSection, info.LastModifiedUtc, info.Length);
+ _cacheSection.Add(info.Path, cacheItem);
+ }
+ else if (!Provider.IsImmutable)
+ {
+ // Check whether the resource has changed.
+ // If so, discard the cache item and create a new one.
+ if (cacheItem.LastModifiedUtc != info.LastModifiedUtc || cacheItem.Length != info.Length)
+ {
+ _cacheSection.Remove(info.Path);
+ cacheItem = new FileCacheItem(_cacheSection, info.LastModifiedUtc, info.Length);
+ _cacheSection.Add(info.Path, cacheItem);
+ }
+ }
+
+ /*
+ * Now we have a cacheItem for the resource.
+ * It may have been just created, or it may or may not have a cached content,
+ * depending upon the value of the ContentCaching property,
+ * the size of the resource, and the value of the
+ * MaxFileSizeKb of our Cache.
+ */
+
+ // If the content type is not a valid MIME type, assume the default.
+ var contentType = info.ContentType ?? DirectoryLister?.ContentType ?? MimeType.Default;
+ var mimeType = MimeType.StripParameters(contentType);
+ if (!MimeType.IsMimeType(mimeType, false))
+ contentType = mimeType = MimeType.Default;
+
+ // Next we're going to apply proactive negotiation
+ // to determine whether we agree with the client upon the compression
+ // (or lack of it) to use for the resource.
+ //
+ // The combination of partial responses and entity compression
+ // is not really standardized and could lead to a world of pain.
+ // Thus, if there is a Range header in the request, try to negotiate for no compression.
+ // Later, if there is compression anyway, we will ignore the Range header.
+ if (!context.TryDetermineCompression(mimeType, out var preferCompression))
+ preferCompression = true;
+ preferCompression &= context.Request.Headers.Get(HttpHeaderNames.Range) == null;
+ if (!context.Request.TryNegotiateContentEncoding(preferCompression, out var compressionMethod, out var setCompressionInResponse))
+ {
+ // If negotiation failed, the returned callback will do the right thing.
+ setCompressionInResponse(context.Response);
+ return;
+ }
+
+ var entityTag = info.GetEntityTag(compressionMethod);
+
+ // Send a "304 Not Modified" response if applicable.
+ //
+ // RFC7232, Section 3.3: "A recipient MUST ignore If-Modified-Since
+ // if the request contains an If-None-Match header field."
+ if (context.Request.CheckIfNoneMatch(entityTag, out var ifNoneMatchExists)
+ || (!ifNoneMatchExists && context.Request.CheckIfModifiedSince(info.LastModifiedUtc, out _)))
+ {
+ context.Response.StatusCode = (int)HttpStatusCode.NotModified;
+ PreparePositiveResponse(context.Response, info, contentType, entityTag, setCompressionInResponse);
+ return;
+ }
+
+ /*
+ * At this point we know the response is "200 OK",
+ * unless the request is a range request.
+ *
+ * RFC7233, Section 3.1: "The Range header field is evaluated after evaluating the precondition
+ * header fields defined in RFC7232, and only if the result in absence
+ * of the Range header field would be a 200 (OK) response. In other
+ * words, Range is ignored when a conditional GET would result in a 304
+ * (Not Modified) response."
+ */
+
+ // Before evaluating ranges, we must know the content length.
+ // This is easy for files, as it is stored in info.Length.
+ // Directories always have info.Length == 0; therefore,
+ // unless the directory listing is cached, we must generate it now
+ // (and cache it while we're there, if applicable).
+ var content = cacheItem.GetContent(compressionMethod);
+ if (info.IsDirectory && content == null)
+ {
+ long uncompressedLength;
+ (content, uncompressedLength) = await GenerateDirectoryListingAsync(context, info, compressionMethod)
+ .ConfigureAwait(false);
+ if (ContentCaching && uncompressedLength <= cachingThreshold)
+ _ = cacheItem.SetContent(compressionMethod, content);
+ }
+
+ var contentLength = content?.Length ?? info.Length;
+
+ // Ignore range request is compression is enabled
+ // (or should I say forced, since negotiation has tried not to use it).
+ var partialStart = 0L;
+ var partialUpperBound = contentLength - 1;
+ var isPartial = compressionMethod == CompressionMethod.None
+ && context.Request.IsRangeRequest(contentLength, entityTag, info.LastModifiedUtc, out partialStart, out partialUpperBound);
+ var responseContentLength = contentLength;
+
+ if (isPartial)
+ {
+ // Prepare a "206 Partial Content" response.
+ responseContentLength = partialUpperBound - partialStart + 1;
+ context.Response.StatusCode = (int)HttpStatusCode.PartialContent;
+ PreparePositiveResponse(context.Response, info, contentType, entityTag, setCompressionInResponse);
+ context.Response.Headers.Set(HttpHeaderNames.ContentRange, $"bytes {partialStart}-{partialUpperBound}/{contentLength}");
+ }
+ else
+ {
+ // Prepare a "200 OK" response.
+ PreparePositiveResponse(context.Response, info, contentType, entityTag, setCompressionInResponse);
+ }
+
+ // If it's a HEAD request, we're done.
+ if (!sendResponseBody)
+ return;
+
+ // If content must be sent AND cached, first read it and store it.
+ // If the requested resource is a directory, we have already listed it by now,
+ // so it must be a file for content to be null.
+ if (content == null && ContentCaching && contentLength <= cachingThreshold)
+ {
+ using (var memoryStream = new MemoryStream())
+ {
+ using (var compressor = new CompressionStream(memoryStream, compressionMethod))
+ {
+ using var source = Provider.OpenFile(info.Path);
+ await source.CopyToAsync(compressor, WebServer.StreamCopyBufferSize, context.CancellationToken)
+ .ConfigureAwait(false);
+ }
+
+ content = memoryStream.ToArray();
+ responseContentLength = content.Length;
+ }
+
+ _ = cacheItem.SetContent(compressionMethod, content);
+ }
+
+ // Transfer cached content if present.
+ if (content != null)
+ {
+ context.Response.ContentLength64 = responseContentLength;
+ var offset = isPartial ? (int) partialStart : 0;
+ await context.Response.OutputStream.WriteAsync(content, offset, (int)responseContentLength, context.CancellationToken)
+ .ConfigureAwait(false);
+
+ return;
+ }
+
+ // Read and transfer content without caching.
+ using (var source = Provider.OpenFile(info.Path))
+ {
+ context.Response.SendChunked = true;
+
+ if (isPartial)
+ {
+ var buffer = new byte[WebServer.StreamCopyBufferSize];
+ if (source.CanSeek)
+ {
+ source.Position = partialStart;
+ }
+ else
+ {
+ var skipLength = (int)partialStart;
+ while (skipLength > 0)
+ {
+ var read = await source.ReadAsync(buffer, 0, Math.Min(skipLength, buffer.Length), context.CancellationToken)
+ .ConfigureAwait(false);
+
+ skipLength -= read;
+ }
+ }
+
+ var transferSize = responseContentLength;
+ while (transferSize >= WebServer.StreamCopyBufferSize)
+ {
+ var read = await source.ReadAsync(buffer, 0, WebServer.StreamCopyBufferSize, context.CancellationToken)
+ .ConfigureAwait(false);
+
+ await context.Response.OutputStream.WriteAsync(buffer, 0, read, context.CancellationToken)
+ .ConfigureAwait(false);
+
+ transferSize -= read;
+ }
+
+ if (transferSize > 0)
+ {
+ var read = await source.ReadAsync(buffer, 0, (int)transferSize, context.CancellationToken)
+ .ConfigureAwait(false);
+
+ await context.Response.OutputStream.WriteAsync(buffer, 0, read, context.CancellationToken)
+ .ConfigureAwait(false);
+ }
+ }
+ else
+ {
+ using var compressor = new CompressionStream(context.Response.OutputStream, compressionMethod);
+ await source.CopyToAsync(compressor, WebServer.StreamCopyBufferSize, context.CancellationToken)
+ .ConfigureAwait(false);
+ }
+ }
+ }
+
+ // Uses DirectoryLister to generate a directory listing asynchronously.
+ // Returns a tuple of the generated content and its *uncompressed* length
+ // (useful to decide whether it can be cached).
+ private async Task<(byte[], long)> GenerateDirectoryListingAsync(
+ IHttpContext context,
+ MappedResourceInfo info,
+ CompressionMethod compressionMethod)
+ {
+ using var memoryStream = new MemoryStream();
+ using var stream = new CompressionStream(memoryStream, compressionMethod);
+
+ await DirectoryLister!.ListDirectoryAsync(
+ info,
+ context.Request.Url.AbsolutePath,
+ Provider.GetDirectoryEntries(info.Path, context),
+ stream,
+ context.CancellationToken).ConfigureAwait(false);
+
+ return (memoryStream.ToArray(), stream.UncompressedLength);
+ }
+ }
+}
\ No newline at end of file
diff --git a/Vendor/EmbedIO-3.5.2/Files/FileModuleExtensions.cs b/Vendor/EmbedIO-3.5.2/Files/FileModuleExtensions.cs
new file mode 100644
index 0000000..b315747
--- /dev/null
+++ b/Vendor/EmbedIO-3.5.2/Files/FileModuleExtensions.cs
@@ -0,0 +1,282 @@
+using System;
+
+namespace EmbedIO.Files
+{
+ ///
+ /// Provides extension methods for and derived classes.
+ ///
+ public static class FileModuleExtensions
+ {
+ ///
+ /// Sets the used by a module to store hashes and,
+ /// optionally, file contents and rendered directory listings.
+ ///
+ /// The type of the module on which this method is called.
+ /// The module on which this method is called.
+ /// An instance of .
+ /// with its Cache property
+ /// set to .
+ /// is .
+ /// The configuration of is locked.
+ /// is .
+ ///
+ public static TModule WithCache(this TModule @this, FileCache value)
+ where TModule : FileModule
+ {
+ @this.Cache = value;
+ return @this;
+ }
+
+ ///
+ /// Sets a value indicating whether a module caches the contents of files
+ /// and directory listings.
+ ///
+ /// The type of the module on which this method is called.
+ /// The module on which this method is called.
+ /// to enable caching of contents;
+ /// to disable it.
+ /// with its ContentCaching property
+ /// set to .
+ /// is .
+ /// The configuration of is locked.
+ ///
+ public static TModule WithContentCaching(this TModule @this, bool value)
+ where TModule : FileModule
+ {
+ @this.ContentCaching = value;
+ return @this;
+ }
+
+ ///
+ /// Enables caching of file contents and directory listings on a module.
+ ///
+ /// The type of the module on which this method is called.
+ /// The module on which this method is called.
+ /// with its ContentCaching property
+ /// set to .
+ /// is .
+ /// The configuration of is locked.
+ ///
+ public static TModule WithContentCaching(this TModule @this)
+ where TModule : FileModule
+ {
+ @this.ContentCaching = true;
+ return @this;
+ }
+
+ ///
+ /// Enables caching of file contents and directory listings on a module.
+ ///
+ /// The type of the module on which this method is called.
+ /// The module on which this method is called.
+ /// sets the maximum size of a single cached file in kilobytes
+ /// sets the maximum total size of cached data in kilobytes
+ /// with its ContentCaching property
+ /// set to .
+ /// is .
+ /// The configuration of is locked.
+ ///
+ public static TModule WithContentCaching(this TModule @this, int maxFileSizeKb, int maxSizeKb)
+ where TModule : FileModule
+ {
+ @this.ContentCaching = true;
+ @this.Cache.MaxFileSizeKb = maxFileSizeKb;
+ @this.Cache.MaxSizeKb = maxSizeKb;
+ return @this;
+ }
+
+ ///
+ /// Disables caching of file contents and directory listings on a module.
+ ///
+ /// The type of the module on which this method is called.
+ /// The module on which this method is called.
+ /// with its ContentCaching property
+ /// set to .
+ /// is .
+ /// The configuration of is locked.
+ ///
+ public static TModule WithoutContentCaching(this TModule @this)
+ where TModule : FileModule
+ {
+ @this.ContentCaching = false;
+ return @this;
+ }
+
+ ///
+ /// Sets the name of the default document served, if it exists, instead of a directory listing
+ /// when the path of a requested URL maps to a directory.
+ ///
+ /// The type of the module on which this method is called.
+ /// The module on which this method is called.
+ /// The name of the default document.
+ /// with its DefaultDocument property
+ /// set to .
+ /// is .
+ /// The configuration of is locked.
+ ///
+ public static TModule WithDefaultDocument(this TModule @this, string value)
+ where TModule : FileModule
+ {
+ @this.DefaultDocument = value;
+ return @this;
+ }
+
+ ///
+ /// Sets the name of the default document to .
+ ///
+ /// The type of the module on which this method is called.
+ /// The module on which this method is called.
+ /// with its DefaultDocument property
+ /// set to .
+ /// is .
+ /// The configuration of is locked.
+ ///
+ public static TModule WithoutDefaultDocument(this TModule @this)
+ where TModule : FileModule
+ {
+ @this.DefaultDocument = null;
+ return @this;
+ }
+
+ ///
+ /// Sets the default extension appended to requested URL paths that do not map
+ /// to any file or directory.
+ ///
+ /// The type of the module on which this method is called.
+ /// The module on which this method is called.
+ /// The default extension.
+ /// with its DefaultExtension property
+ /// set to .
+ /// is .
+ /// The configuration of is locked.
+ /// is a non-,
+ /// non-empty string that does not start with a period (.).
+ ///
+ public static TModule WithDefaultExtension(this TModule @this, string value)
+ where TModule : FileModule
+ {
+ @this.DefaultExtension = value;
+ return @this;
+ }
+
+ ///
+ /// Sets the default extension to .
+ ///
+ /// The type of the module on which this method is called.
+ /// The module on which this method is called.
+ /// with its DefaultExtension property
+ /// set to .
+ /// is .
+ /// The configuration of is locked.
+ ///
+ public static TModule WithoutDefaultExtension(this TModule @this)
+ where TModule : FileModule
+ {
+ @this.DefaultExtension = null;
+ return @this;
+ }
+
+ ///
+ /// Sets the interface used to generate
+ /// directory listing in a module.
+ ///
+ /// The type of the module on which this method is called.
+ /// The module on which this method is called.
+ /// An interface, or
+ /// to disable the generation of directory listings.
+ /// with its DirectoryLister property
+ /// set to .
+ /// is .
+ /// The configuration of is locked.
+ ///
+ public static TModule WithDirectoryLister(this TModule @this, IDirectoryLister value)
+ where TModule : FileModule
+ {
+ @this.DirectoryLister = value;
+ return @this;
+ }
+
+ ///
+ /// Sets a module's DirectoryLister property
+ /// to , disabling the generation of directory listings.
+ ///
+ /// The type of the module on which this method is called.
+ /// The module on which this method is called.
+ /// with its DirectoryLister property
+ /// set to .
+ /// is .
+ /// The configuration of is locked.
+ ///
+ public static TModule WithoutDirectoryLister(this TModule @this)
+ where TModule : FileModule
+ {
+ @this.DirectoryLister = null;
+ return @this;
+ }
+
+ ///
+ /// Sets a that is called by a module whenever
+ /// the requested URL path could not be mapped to any file or directory.
+ ///
+ /// The type of the module on which this method is called.
+ /// The module on which this method is called.
+ /// The method to call.
+ /// with its OnMappingFailed property
+ /// set to .
+ /// is .
+ /// The configuration of is locked.
+ /// is .
+ ///
+ ///
+ public static TModule HandleMappingFailed(this TModule @this, FileRequestHandlerCallback callback)
+ where TModule : FileModule
+ {
+ @this.OnMappingFailed = callback;
+ return @this;
+ }
+
+ ///
+ /// Sets a that is called by a module whenever
+ /// the requested URL path has been mapped to a directory, but directory listing has been
+ /// disabled.
+ ///
+ /// The type of the module on which this method is called.
+ /// The module on which this method is called.
+ /// The method to call.
+ /// with its OnDirectoryNotListable property
+ /// set to .
+ /// is .
+ /// The configuration of is locked.
+ /// is .
+ ///
+ ///
+ public static TModule HandleDirectoryNotListable(this TModule @this, FileRequestHandlerCallback callback)
+ where TModule : FileModule
+ {
+ @this.OnDirectoryNotListable = callback;
+ return @this;
+ }
+
+ ///
+ /// Sets a that is called by a module whenever
+ /// the requested URL path has been mapped to a file or directory, but the request's
+ /// HTTP method is neither GET nor HEAD.
+ ///
+ /// The type of the module on which this method is called.
+ /// The module on which this method is called.
+ /// The method to call.
+ /// with its OnMethodNotAllowed property
+ /// set to .
+ /// is .
+ /// The configuration of is locked.
+ /// is .
+ ///
+ ///
+ public static TModule HandleMethodNotAllowed(this TModule @this, FileRequestHandlerCallback callback)
+ where TModule : FileModule
+ {
+ @this.OnMethodNotAllowed = callback;
+ return @this;
+ }
+ }
+}
diff --git a/Vendor/EmbedIO-3.5.2/Files/FileRequestHandler.cs b/Vendor/EmbedIO-3.5.2/Files/FileRequestHandler.cs
new file mode 100644
index 0000000..805917c
--- /dev/null
+++ b/Vendor/EmbedIO-3.5.2/Files/FileRequestHandler.cs
@@ -0,0 +1,53 @@
+using System.Threading.Tasks;
+
+namespace EmbedIO.Files
+{
+ ///
+ /// Provides standard handler callbacks for .
+ ///
+ ///
+ public static class FileRequestHandler
+ {
+#pragma warning disable CA1801 // Unused parameters - Must respect FileRequestHandlerCallback signature.
+ ///
+ /// Unconditionally passes a request down the module chain.
+ ///
+ /// An interface representing the context of the request.
+ /// If the requested path has been successfully mapped to a resource (file or directory), the result of the mapping;
+ /// otherwise, .
+ /// This method never returns; it throws an exception instead.
+ public static Task PassThrough(IHttpContext context, MappedResourceInfo? info)
+ => throw RequestHandler.PassThrough();
+
+ ///
+ /// Unconditionally sends a 403 Unauthorized response.
+ ///
+ /// An interface representing the context of the request.
+ /// If the requested path has been successfully mapped to a resource (file or directory), the result of the mapping;
+ /// otherwise, .
+ /// This method never returns; it throws a instead.
+ public static Task ThrowUnauthorized(IHttpContext context, MappedResourceInfo? info)
+ => throw HttpException.Unauthorized();
+
+ ///
+ /// Unconditionally sends a 404 Not Found response.
+ ///
+ /// An interface representing the context of the request.
+ /// If the requested path has been successfully mapped to a resource (file or directory), the result of the mapping;
+ /// otherwise, .
+ /// This method never returns; it throws a instead.
+ public static Task ThrowNotFound(IHttpContext context, MappedResourceInfo? info)
+ => throw HttpException.NotFound();
+
+ ///
+ /// Unconditionally sends a 405 Method Not Allowed response.
+ ///
+ /// An interface representing the context of the request.
+ /// If the requested path has been successfully mapped to a resource (file or directory), the result of the mapping;
+ /// otherwise, .
+ /// This method never returns; it throws a instead.
+ public static Task ThrowMethodNotAllowed(IHttpContext context, MappedResourceInfo? info)
+ => throw HttpException.MethodNotAllowed();
+#pragma warning restore CA1801
+ }
+}
\ No newline at end of file
diff --git a/Vendor/EmbedIO-3.5.2/Files/FileRequestHandlerCallback.cs b/Vendor/EmbedIO-3.5.2/Files/FileRequestHandlerCallback.cs
new file mode 100644
index 0000000..0340e14
--- /dev/null
+++ b/Vendor/EmbedIO-3.5.2/Files/FileRequestHandlerCallback.cs
@@ -0,0 +1,13 @@
+using System.Threading.Tasks;
+
+namespace EmbedIO.Files
+{
+ ///
+ /// A callback used to handle a request in .
+ ///
+ /// An interface representing the context of the request.
+ /// If the requested path has been successfully mapped to a resource (file or directory), the result of the mapping;
+ /// otherwise, .
+ /// A representing the ongoing operation.
+ public delegate Task FileRequestHandlerCallback(IHttpContext context, MappedResourceInfo? info);
+}
\ No newline at end of file
diff --git a/Vendor/EmbedIO-3.5.2/Files/FileSystemProvider.cs b/Vendor/EmbedIO-3.5.2/Files/FileSystemProvider.cs
new file mode 100644
index 0000000..26f8f21
--- /dev/null
+++ b/Vendor/EmbedIO-3.5.2/Files/FileSystemProvider.cs
@@ -0,0 +1,202 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Runtime.InteropServices;
+using System.Threading;
+using EmbedIO.Utilities;
+
+namespace EmbedIO.Files
+{
+ ///
+ /// Provides access to the local file system to a .
+ ///
+ ///
+ public class FileSystemProvider : IDisposable, IFileProvider
+ {
+ private readonly FileSystemWatcher? _watcher;
+
+ ///
+ /// Initializes a new instance of the class.
+ ///
+ ///
+ /// OSX doesn't support , the parameter will be always .
+ ///
+ /// The file system path.
+ /// if files and directories in
+ /// are not expected to change during a web server's
+ /// lifetime; otherwise.
+ /// is .
+ /// is not a valid local path.
+ ///
+ public FileSystemProvider(string fileSystemPath, bool isImmutable)
+ {
+ FileSystemPath = Validate.LocalPath(nameof(fileSystemPath), fileSystemPath, true);
+ IsImmutable = isImmutable || RuntimeInformation.IsOSPlatform(OSPlatform.OSX);
+
+ try
+ {
+ if (!IsImmutable)
+ _watcher = new FileSystemWatcher(FileSystemPath);
+ }
+ catch (PlatformNotSupportedException)
+ {
+ IsImmutable = true;
+ }
+ }
+
+ ///
+ /// Finalizes an instance of the class.
+ ///
+ ~FileSystemProvider()
+ {
+ Dispose(false);
+ }
+
+ ///
+ public event Action? ResourceChanged;
+
+ ///
+ /// Gets the file system path from which files are retrieved.
+ ///
+ public string FileSystemPath { get; }
+
+ ///
+ public bool IsImmutable { get; }
+
+ ///
+ public void Dispose()
+ {
+ Dispose(true);
+ GC.SuppressFinalize(this);
+ }
+
+ ///
+ public void Start(CancellationToken cancellationToken)
+ {
+ if (_watcher != null)
+ {
+ _watcher.Changed += Watcher_ChangedOrDeleted;
+ _watcher.Deleted += Watcher_ChangedOrDeleted;
+ _watcher.Renamed += Watcher_Renamed;
+ _watcher.EnableRaisingEvents = true;
+ }
+ }
+
+ ///
+ public MappedResourceInfo? MapUrlPath(string urlPath, IMimeTypeProvider mimeTypeProvider)
+ {
+ urlPath = urlPath.Substring(1); // Drop the initial slash
+ string localPath;
+
+ // Disable CA1031 as there's little we can do if IsPathRooted or GetFullPath fails.
+#pragma warning disable CA1031
+ try
+ {
+ // Unescape the url before continue
+ urlPath = Uri.UnescapeDataString(urlPath);
+
+ // Bail out early if the path is a rooted path,
+ // as Path.Combine would ignore our base path.
+ // See https://docs.microsoft.com/en-us/dotnet/api/system.io.path.combine
+ // (particularly the Remarks section).
+ //
+ // Under Windows, a relative URL path may be a full filesystem path
+ // (e.g. "D:\foo\bar" or "\\192.168.0.1\Shared\MyDocuments\BankAccounts.docx").
+ // Under Unix-like operating systems we have no such problems, as relativeUrlPath
+ // can never start with a slash; however, loading one more class from Swan
+ // just to check the OS type would probably outweigh calling IsPathRooted.
+ if (Path.IsPathRooted(urlPath))
+ return null;
+
+ // Convert the relative URL path to a relative filesystem path
+ // (practically a no-op under Unix-like operating systems)
+ // and combine it with our base local path to obtain a full path.
+ localPath = Path.Combine(FileSystemPath, urlPath.Replace('/', Path.DirectorySeparatorChar));
+
+ // Use GetFullPath as an additional safety check
+ // for relative paths that contain a rooted path
+ // (e.g. "valid/path/C:\Windows\System.ini")
+ localPath = Path.GetFullPath(localPath);
+ }
+ catch
+ {
+ // Both IsPathRooted and GetFullPath throw exceptions
+ // if a path contains invalid characters or is otherwise invalid;
+ // bail out in this case too, as the path would not exist on disk anyway.
+ return null;
+ }
+#pragma warning restore CA1031
+
+ // As a final precaution, check that the resulting local path
+ // is inside the folder intended to be served.
+ if (!localPath.StartsWith(FileSystemPath, StringComparison.Ordinal))
+ return null;
+
+ if (File.Exists(localPath))
+ return GetMappedFileInfo(mimeTypeProvider, localPath);
+
+ if (Directory.Exists(localPath))
+ return GetMappedDirectoryInfo(localPath);
+
+ return null;
+ }
+
+ ///
+ public Stream OpenFile(string path) => new FileStream(path, FileMode.Open, FileAccess.Read, FileShare.ReadWrite);
+
+ ///
+ public IEnumerable GetDirectoryEntries(string path, IMimeTypeProvider mimeTypeProvider)
+ => new DirectoryInfo(path).EnumerateFileSystemInfos()
+ .Select(fsi => GetMappedResourceInfo(mimeTypeProvider, fsi));
+
+ ///
+ /// Releases unmanaged and - optionally - managed resources.
+ ///
+ /// to release both managed and unmanaged resources;
+ /// to release only unmanaged resources.
+ protected virtual void Dispose(bool disposing)
+ {
+ ResourceChanged = null; // Release references to listeners
+
+ if (_watcher != null)
+ {
+ _watcher.EnableRaisingEvents = false;
+ _watcher.Changed -= Watcher_ChangedOrDeleted;
+ _watcher.Deleted -= Watcher_ChangedOrDeleted;
+ _watcher.Renamed -= Watcher_Renamed;
+
+ if (disposing)
+ _watcher.Dispose();
+ }
+ }
+
+ private static MappedResourceInfo GetMappedFileInfo(IMimeTypeProvider mimeTypeProvider, string localPath)
+ => GetMappedFileInfo(mimeTypeProvider, new FileInfo(localPath));
+
+ private static MappedResourceInfo GetMappedFileInfo(IMimeTypeProvider mimeTypeProvider, FileInfo info)
+ => MappedResourceInfo.ForFile(
+ info.FullName,
+ info.Name,
+ info.LastWriteTimeUtc,
+ info.Length,
+ mimeTypeProvider.GetMimeType(info.Extension));
+
+ private static MappedResourceInfo GetMappedDirectoryInfo(string localPath)
+ => GetMappedDirectoryInfo(new DirectoryInfo(localPath));
+
+ private static MappedResourceInfo GetMappedDirectoryInfo(DirectoryInfo info)
+ => MappedResourceInfo.ForDirectory(info.FullName, info.Name, info.LastWriteTimeUtc);
+
+ private static MappedResourceInfo GetMappedResourceInfo(IMimeTypeProvider mimeTypeProvider, FileSystemInfo info)
+ => info is DirectoryInfo directoryInfo
+ ? GetMappedDirectoryInfo(directoryInfo)
+ : GetMappedFileInfo(mimeTypeProvider, (FileInfo) info);
+
+ private void Watcher_ChangedOrDeleted(object sender, FileSystemEventArgs e)
+ => ResourceChanged?.Invoke(e.FullPath);
+
+ private void Watcher_Renamed(object sender, RenamedEventArgs e)
+ => ResourceChanged?.Invoke(e.OldFullPath);
+ }
+}
diff --git a/Vendor/EmbedIO-3.5.2/Files/IDirectoryLister.cs b/Vendor/EmbedIO-3.5.2/Files/IDirectoryLister.cs
new file mode 100644
index 0000000..0a2ba9a
--- /dev/null
+++ b/Vendor/EmbedIO-3.5.2/Files/IDirectoryLister.cs
@@ -0,0 +1,35 @@
+using System.Collections.Generic;
+using System.IO;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace EmbedIO.Files
+{
+ ///
+ /// Represents an object that can render a directory listing to a stream.
+ ///
+ public interface IDirectoryLister
+ {
+ ///
+ /// Gets the MIME type of generated directory listings.
+ ///
+ string ContentType { get; }
+
+ ///
+ /// Asynchronously generate a directory listing.
+ ///
+ /// A containing information about
+ /// the directory which is to be listed.
+ /// The absolute URL path that was mapped to .
+ /// An enumeration of the entries in the directory represented by .
+ /// A to which the directory listing must be written.
+ /// A used to cancel the operation.
+ /// A representing the ongoing operation.
+ Task ListDirectoryAsync(
+ MappedResourceInfo info,
+ string absoluteUrlPath,
+ IEnumerable entries,
+ Stream stream,
+ CancellationToken cancellationToken);
+ }
+}
\ No newline at end of file
diff --git a/Vendor/EmbedIO-3.5.2/Files/IFileProvider.cs b/Vendor/EmbedIO-3.5.2/Files/IFileProvider.cs
new file mode 100644
index 0000000..048265c
--- /dev/null
+++ b/Vendor/EmbedIO-3.5.2/Files/IFileProvider.cs
@@ -0,0 +1,61 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Threading;
+
+namespace EmbedIO.Files
+{
+ ///
+ /// Represents an object that can provide files and/or directories to be served by a .
+ ///
+ public interface IFileProvider
+ {
+ ///
+ /// Occurs when a file or directory provided by this instance is modified or removed.
+ /// The event's parameter is the provider-specific path of the resource that changed.
+ ///
+ event Action ResourceChanged;
+
+ ///
+ /// Gets a value indicating whether the files and directories provided by this instance
+ /// will never change.
+ ///
+ bool IsImmutable { get; }
+
+ ///
+ /// Signals a file provider that the web server is starting.
+ ///
+ /// A used to stop the web server.
+ void Start(CancellationToken cancellationToken);
+
+ ///
+ /// Maps a URL path to a provider-specific path.
+ ///
+ /// The URL path.
+ /// An interface to use
+ /// for determining the MIME type of a file.
+ /// A provider-specific path identifying a file or directory,
+ /// or if this instance cannot provide a resource associated
+ /// to .
+ MappedResourceInfo? MapUrlPath(string urlPath, IMimeTypeProvider mimeTypeProvider);
+
+ ///
+ /// Opens a file for reading.
+ ///
+ /// The provider-specific path for the file.
+ ///
+ /// A readable of the file's contents.
+ ///
+ Stream OpenFile(string path);
+
+ ///
+ /// Returns an enumeration of the entries of a directory.
+ ///
+ /// The provider-specific path for the directory.
+ /// An interface to use
+ /// for determining the MIME type of files.
+ /// An enumeration of objects identifying the entries
+ /// in the directory identified by .
+ IEnumerable GetDirectoryEntries(string path, IMimeTypeProvider mimeTypeProvider);
+ }
+}
\ No newline at end of file
diff --git a/Vendor/EmbedIO-3.5.2/Files/Internal/Base64Utility.cs b/Vendor/EmbedIO-3.5.2/Files/Internal/Base64Utility.cs
new file mode 100644
index 0000000..19d1579
--- /dev/null
+++ b/Vendor/EmbedIO-3.5.2/Files/Internal/Base64Utility.cs
@@ -0,0 +1,12 @@
+using System;
+
+namespace EmbedIO.Files.Internal
+{
+ internal static class Base64Utility
+ {
+ // long is 8 bytes
+ // base64 of 8 bytes is 12 chars, but the last one is padding
+ public static string LongToBase64(long value)
+ => Convert.ToBase64String(BitConverter.GetBytes(value)).Substring(0, 11);
+ }
+}
\ No newline at end of file
diff --git a/Vendor/EmbedIO-3.5.2/Files/Internal/EntityTag.cs b/Vendor/EmbedIO-3.5.2/Files/Internal/EntityTag.cs
new file mode 100644
index 0000000..288d594
--- /dev/null
+++ b/Vendor/EmbedIO-3.5.2/Files/Internal/EntityTag.cs
@@ -0,0 +1,28 @@
+using System;
+using System.Text;
+
+namespace EmbedIO.Files.Internal
+{
+ internal static class EntityTag
+ {
+ public static string Compute(DateTime lastModifiedUtc, long length, CompressionMethod compressionMethod)
+ {
+ var sb = new StringBuilder()
+ .Append('"')
+ .Append(Base64Utility.LongToBase64(lastModifiedUtc.Ticks))
+ .Append(Base64Utility.LongToBase64(length));
+
+ switch (compressionMethod)
+ {
+ case CompressionMethod.Deflate:
+ sb.Append('-').Append(CompressionMethodNames.Deflate);
+ break;
+ case CompressionMethod.Gzip:
+ sb.Append('-').Append(CompressionMethodNames.Gzip);
+ break;
+ }
+
+ return sb.Append('"').ToString();
+ }
+ }
+}
\ No newline at end of file
diff --git a/Vendor/EmbedIO-3.5.2/Files/Internal/FileCacheItem.cs b/Vendor/EmbedIO-3.5.2/Files/Internal/FileCacheItem.cs
new file mode 100644
index 0000000..78aa18e
--- /dev/null
+++ b/Vendor/EmbedIO-3.5.2/Files/Internal/FileCacheItem.cs
@@ -0,0 +1,164 @@
+using System;
+using EmbedIO.Internal;
+
+namespace EmbedIO.Files.Internal
+{
+ internal sealed class FileCacheItem
+ {
+#pragma warning disable SA1401 // Field should be private - performance is a stronger concern here.
+ // These fields create a sort of linked list of items
+ // inside the cache's dictionary.
+ // Their purpose is to keep track of items
+ // in order from least to most recently used.
+ internal string? PreviousKey;
+ internal string? NextKey;
+ internal long LastUsedAt;
+#pragma warning restore SA1401
+
+ // Size of a pointer in bytes
+ private static readonly long SizeOfPointer = Environment.Is64BitProcess ? 8 : 4;
+
+ // Size of a WeakReference in bytes
+ private static readonly long SizeOfWeakReference = Environment.Is64BitProcess ? 16 : 32;
+
+ // Educated guess about the size of an Item in memory (see comments on constructor).
+ // 3 * SizeOfPointer + total size of fields, rounded up to a multiple of 16.
+ //
+ // Computed as follows:
+ //
+ // * for 32-bit:
+ // - initialize count to 3 (number of "hidden" pointers that compose the object header)
+ // - for every field / auto property, in order of declaration:
+ // - increment count by 1 for reference types, 2 for long and DateTime
+ // (as of time of writing there are no fields of other types here)
+ // - increment again by 1 if this field "weighs" 1 and the next one "weighs" 2
+ // (padding for field alignment)
+ // - multiply count by 4 (size of a pointer)
+ // - if the result is not a multiple of 16, round it up to next multiple of 16
+ //
+ // * for 64-bit:
+ // - initialize count to 3 (number of "hidden" pointers that compose the object header)
+ // - for every field / auto property, in order of declaration, increment count by 1
+ // (at the time of writing there are no fields here that need padding on 64-bit)
+ // - multiply count by 8 (size of a pointer)
+ // - if the result is not a multiple of 16, round it up to next multiple of 16
+ private static readonly long SizeOfItem = Environment.Is64BitProcess ? 96 : 128;
+
+ private readonly object _syncRoot = new object();
+
+ // Used to update total size of section.
+ // Weak reference avoids circularity.
+ private readonly WeakReference _section;
+
+ // There are only 3 possible compression methods,
+ // hence a dictionary (or two dictionaries) would be overkill.
+ private byte[]? _uncompressedContent;
+ private byte[]? _gzippedContent;
+ private byte[]? _deflatedContent;
+
+ internal FileCacheItem(FileCache.Section section, DateTime lastModifiedUtc, long length)
+ {
+ _section = new WeakReference(section);
+
+ LastModifiedUtc = lastModifiedUtc;
+ Length = length;
+
+ // There is no way to know the actual size of an object at runtime.
+ // This method makes some educated guesses, based on the following
+ // article (among others):
+ // https://codingsight.com/precise-computation-of-clr-object-size/
+ // PreviousKey and NextKey values aren't counted in
+ // because they are just references to existing strings.
+ SizeInCache = SizeOfItem + SizeOfWeakReference;
+ }
+
+ public DateTime LastModifiedUtc { get; }
+
+ public long Length { get; }
+
+ // This is the (approximate) in-memory size of this object.
+ // It is NOT the length of the cache resource!
+ public long SizeInCache { get; private set; }
+
+ public byte[]? GetContent(CompressionMethod compressionMethod)
+ {
+ // If there are both entity tag and content, use them.
+ switch (compressionMethod)
+ {
+ case CompressionMethod.Deflate:
+ if (_deflatedContent != null) return _deflatedContent;
+ break;
+ case CompressionMethod.Gzip:
+ if (_gzippedContent != null) return _gzippedContent;
+ break;
+ default:
+ if (_uncompressedContent != null) return _uncompressedContent;
+ break;
+ }
+
+ // Try to convert existing content, if any.
+ byte[]? content;
+ if (_uncompressedContent != null)
+ {
+ content = CompressionUtility.ConvertCompression(_uncompressedContent, CompressionMethod.None, compressionMethod);
+ }
+ else if (_gzippedContent != null)
+ {
+ content = CompressionUtility.ConvertCompression(_gzippedContent, CompressionMethod.Gzip, compressionMethod);
+ }
+ else if (_deflatedContent != null)
+ {
+ content = CompressionUtility.ConvertCompression(_deflatedContent, CompressionMethod.Deflate, compressionMethod);
+ }
+ else
+ {
+ // No content whatsoever.
+ return null;
+ }
+
+ return SetContent(compressionMethod, content);
+ }
+
+ public byte[]? SetContent(CompressionMethod compressionMethod, byte[]? content)
+ {
+ // This is the bare minimum locking we need
+ // to ensure we don't mess sizes up.
+ byte[]? oldContent;
+ lock (_syncRoot)
+ {
+ switch (compressionMethod)
+ {
+ case CompressionMethod.Deflate:
+ oldContent = _deflatedContent;
+ _deflatedContent = content;
+ break;
+ case CompressionMethod.Gzip:
+ oldContent = _gzippedContent;
+ _gzippedContent = content;
+ break;
+ default:
+ oldContent = _uncompressedContent;
+ _uncompressedContent = content;
+ break;
+ }
+ }
+
+ var sizeDelta = GetSizeOf(content) - GetSizeOf(oldContent);
+ SizeInCache += sizeDelta;
+ if (_section.TryGetTarget(out var section))
+ section.UpdateTotalSize(sizeDelta);
+
+ return content;
+ }
+
+ // Round up to a multiple of 16
+ private static long RoundUpTo16(long n)
+ {
+ var remainder = n % 16;
+ return remainder > 0 ? n + (16 - remainder) : n;
+ }
+
+ // The size of a byte array is 3 * SizeOfPointer + 1 (size of byte) * Length
+ private static long GetSizeOf(byte[]? arr) => arr == null ? 0 : RoundUpTo16(3 * SizeOfPointer) + arr.Length;
+ }
+}
\ No newline at end of file
diff --git a/Vendor/EmbedIO-3.5.2/Files/Internal/HtmlDirectoryLister.cs b/Vendor/EmbedIO-3.5.2/Files/Internal/HtmlDirectoryLister.cs
new file mode 100644
index 0000000..f85eebf
--- /dev/null
+++ b/Vendor/EmbedIO-3.5.2/Files/Internal/HtmlDirectoryLister.cs
@@ -0,0 +1,73 @@
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.IO;
+using System.Linq;
+using System.Net;
+using System.Threading;
+using System.Threading.Tasks;
+using EmbedIO.Utilities;
+using Swan;
+
+namespace EmbedIO.Files.Internal
+{
+ internal class HtmlDirectoryLister : IDirectoryLister
+ {
+ private static readonly Lazy LazyInstance = new Lazy(() => new HtmlDirectoryLister());
+
+ private HtmlDirectoryLister()
+ {
+ }
+
+ public static IDirectoryLister Instance => LazyInstance.Value;
+
+ public string ContentType { get; } = MimeType.Html + "; encoding=" + WebServer.DefaultEncoding.WebName;
+
+ public async Task ListDirectoryAsync(
+ MappedResourceInfo info,
+ string absoluteUrlPath,
+ IEnumerable entries,
+ Stream stream,
+ CancellationToken cancellationToken)
+ {
+ const int MaxEntryLength = 50;
+ const int SizeIndent = -20; // Negative for right alignment
+
+ if (!info.IsDirectory)
+ throw SelfCheck.Failure($"{nameof(HtmlDirectoryLister)}.{nameof(ListDirectoryAsync)} invoked with a file, not a directory.");
+
+ var encodedPath = WebUtility.HtmlEncode(absoluteUrlPath);
+ using var text = new StreamWriter(stream, WebServer.DefaultEncoding);
+ text.Write("Index of ");
+ text.Write(encodedPath);
+ text.Write("Index of ");
+ text.Write(encodedPath);
+ text.Write("
");
+
+ if (encodedPath.Length > 1)
+ text.Write("../\n");
+
+ entries = entries.ToArray();
+
+ foreach (var directory in entries.Where(m => m.IsDirectory).OrderBy(e => e.Name))
+ {
+ text.Write($"{WebUtility.HtmlEncode(directory.Name)}");
+ text.Write(new string(' ', Math.Max(1, MaxEntryLength - directory.Name.Length + 1)));
+ text.Write(HttpDate.Format(directory.LastModifiedUtc));
+ text.Write('\n');
+ await Task.Yield();
+ }
+
+ foreach (var file in entries.Where(m => m.IsFile).OrderBy(e => e.Name))
+ {
+ text.Write($"{WebUtility.HtmlEncode(file.Name)}");
+ text.Write(new string(' ', Math.Max(1, MaxEntryLength - file.Name.Length + 1)));
+ text.Write(HttpDate.Format(file.LastModifiedUtc));
+ text.Write($" {file.Length.ToString("#,###", CultureInfo.InvariantCulture),SizeIndent}\n");
+ await Task.Yield();
+ }
+
+ text.Write("
");
+ }
+ }
+}
\ No newline at end of file
diff --git a/Vendor/EmbedIO-3.5.2/Files/Internal/MappedResourceInfoExtensions.cs b/Vendor/EmbedIO-3.5.2/Files/Internal/MappedResourceInfoExtensions.cs
new file mode 100644
index 0000000..4d780d4
--- /dev/null
+++ b/Vendor/EmbedIO-3.5.2/Files/Internal/MappedResourceInfoExtensions.cs
@@ -0,0 +1,8 @@
+namespace EmbedIO.Files.Internal
+{
+ internal static class MappedResourceInfoExtensions
+ {
+ public static string GetEntityTag(this MappedResourceInfo @this, CompressionMethod compressionMethod)
+ => EntityTag.Compute(@this.LastModifiedUtc, @this.Length, compressionMethod);
+ }
+}
\ No newline at end of file
diff --git a/Vendor/EmbedIO-3.5.2/Files/MappedResourceInfo.cs b/Vendor/EmbedIO-3.5.2/Files/MappedResourceInfo.cs
new file mode 100644
index 0000000..914bc7a
--- /dev/null
+++ b/Vendor/EmbedIO-3.5.2/Files/MappedResourceInfo.cs
@@ -0,0 +1,80 @@
+using System;
+
+namespace EmbedIO.Files
+{
+ ///
+ /// Contains information about a resource served via an .
+ ///
+ public sealed class MappedResourceInfo
+ {
+ private MappedResourceInfo(string path, string name, DateTime lastModifiedUtc, long length, string? contentType)
+ {
+ Path = path;
+ Name = name;
+ LastModifiedUtc = lastModifiedUtc;
+ Length = length;
+ ContentType = contentType;
+ }
+
+ ///
+ /// Gets a value indicating whether this instance represents a directory.
+ ///
+ public bool IsDirectory => ContentType == null;
+
+ ///
+ /// Gets a value indicating whether this instance represents a file.
+ ///
+ public bool IsFile => ContentType != null;
+
+ ///
+ /// Gets a unique, provider-specific path for the resource.
+ ///
+ public string Path { get; }
+
+ ///
+ /// Gets the name of the resource, as it would appear in a directory listing.
+ ///
+ public string Name { get; }
+
+ ///
+ /// Gets the UTC date and time of the last modification made to the resource.
+ ///
+ public DateTime LastModifiedUtc { get; }
+
+ ///
+ /// If is , gets the length of the file, expressed in bytes.
+ /// If is , this property is always zero.
+ ///
+ public long Length { get; }
+
+ ///
+ /// If is , gets a MIME type describing the kind of contents of the file.
+ /// If is , this property is always .
+ ///
+ public string? ContentType { get; }
+
+ ///
+ /// Creates and returns a new instance of the class,
+ /// representing a file.
+ ///
+ /// A unique, provider-specific path for the file.
+ /// The name of the file, as it would appear in a directory listing.
+ /// The UTC date and time of the last modification made to the file.
+ /// The length of the file, expressed in bytes.
+ /// A MIME type describing the kind of contents of the file.
+ /// A newly-constructed instance of .
+ public static MappedResourceInfo ForFile(string path, string name, DateTime lastModifiedUtc, long size, string contentType)
+ => new MappedResourceInfo(path, name, lastModifiedUtc, size, contentType ?? MimeType.Default);
+
+ ///
+ /// Creates and returns a new instance of the class,
+ /// representing a directory.
+ ///
+ /// A unique, provider-specific path for the directory.
+ /// The name of the directory, as it would appear in a directory listing.
+ /// The UTC date and time of the last modification made to the directory.
+ /// A newly-constructed instance of .
+ public static MappedResourceInfo ForDirectory(string path, string name, DateTime lastModifiedUtc)
+ => new MappedResourceInfo(path, name, lastModifiedUtc, 0, null);
+ }
+}
\ No newline at end of file
diff --git a/Vendor/EmbedIO-3.5.2/Files/ResourceFileProvider.cs b/Vendor/EmbedIO-3.5.2/Files/ResourceFileProvider.cs
new file mode 100644
index 0000000..21e850a
--- /dev/null
+++ b/Vendor/EmbedIO-3.5.2/Files/ResourceFileProvider.cs
@@ -0,0 +1,94 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Reflection;
+using System.Threading;
+using EmbedIO.Utilities;
+
+namespace EmbedIO.Files
+{
+ ///
+ /// Provides access to embedded resources to a .
+ ///
+ ///
+ public class ResourceFileProvider : IFileProvider
+ {
+ private readonly DateTime _fileTime = DateTime.UtcNow;
+
+ ///
+ /// Initializes a new instance of the class.
+ ///
+ /// The assembly where served files are contained as embedded resources.
+ /// A string to prepend to provider-specific paths
+ /// to form the name of a manifest resource in .
+ /// is .
+ public ResourceFileProvider(Assembly assembly, string pathPrefix)
+ {
+ Assembly = Validate.NotNull(nameof(assembly), assembly);
+ PathPrefix = pathPrefix ?? string.Empty;
+ }
+
+ ///
+ public event Action ResourceChanged
+ {
+ add { }
+ remove { }
+ }
+
+ ///
+ /// Gets the assembly where served files are contained as embedded resources.
+ ///
+ public Assembly Assembly { get; }
+
+ ///
+ /// Gets a string that is prepended to provider-specific paths to form the name of a manifest resource in .
+ ///
+ public string PathPrefix { get; }
+
+ ///
+ public bool IsImmutable => true;
+
+ ///
+ public void Start(CancellationToken cancellationToken)
+ {
+ }
+
+ ///
+ public MappedResourceInfo? MapUrlPath(string urlPath, IMimeTypeProvider mimeTypeProvider)
+ {
+ var resourceName = PathPrefix + urlPath.Replace('/', '.');
+
+ long size;
+ try
+ {
+ using var stream = Assembly.GetManifestResourceStream(resourceName);
+ if (stream == null || stream == Stream.Null)
+ return null;
+
+ size = stream.Length;
+ }
+ catch (FileNotFoundException)
+ {
+ return null;
+ }
+
+ var lastSlashPos = urlPath.LastIndexOf('/');
+ var name = urlPath.Substring(lastSlashPos + 1);
+
+ return MappedResourceInfo.ForFile(
+ resourceName,
+ name,
+ _fileTime,
+ size,
+ mimeTypeProvider.GetMimeType(Path.GetExtension(name)));
+ }
+
+ ///
+ public Stream OpenFile(string path) => Assembly.GetManifestResourceStream(path);
+
+ ///
+ public IEnumerable GetDirectoryEntries(string path, IMimeTypeProvider mimeTypeProvider)
+ => Enumerable.Empty();
+ }
+}
\ No newline at end of file
diff --git a/Vendor/EmbedIO-3.5.2/Files/ZipFileProvider.cs b/Vendor/EmbedIO-3.5.2/Files/ZipFileProvider.cs
new file mode 100644
index 0000000..5a9c82d
--- /dev/null
+++ b/Vendor/EmbedIO-3.5.2/Files/ZipFileProvider.cs
@@ -0,0 +1,110 @@
+using EmbedIO.Utilities;
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.IO.Compression;
+using System.Linq;
+using System.Threading;
+
+namespace EmbedIO.Files
+{
+ ///
+ /// Provides access to files contained in a .zip file to a .
+ ///
+ ///
+ public class ZipFileProvider : IDisposable, IFileProvider
+ {
+ private readonly ZipArchive _zipArchive;
+
+ ///
+ /// Initializes a new instance of the class.
+ ///
+ /// The zip file path.
+ public ZipFileProvider(string zipFilePath)
+ : this(new FileStream(Validate.LocalPath(nameof(zipFilePath), zipFilePath, true), FileMode.Open))
+ {
+ }
+
+ ///
+ /// Initializes a new instance of the class.
+ ///
+ /// The stream that contains the archive.
+ /// to leave the stream open after the web server
+ /// is disposed; otherwise, .
+ public ZipFileProvider(Stream stream, bool leaveOpen = false)
+ {
+ _zipArchive = new ZipArchive(stream, ZipArchiveMode.Read, leaveOpen);
+ }
+
+ ///
+ /// Finalizes an instance of the class.
+ ///
+ ~ZipFileProvider()
+ {
+ Dispose(false);
+ }
+
+ ///
+ public event Action ResourceChanged
+ {
+ add { }
+ remove { }
+ }
+
+ ///
+ public bool IsImmutable => true;
+
+ ///
+ public void Dispose()
+ {
+ Dispose(true);
+ GC.SuppressFinalize(this);
+ }
+
+ ///
+ public void Start(CancellationToken cancellationToken)
+ {
+ }
+
+ ///
+ public MappedResourceInfo? MapUrlPath(string urlPath, IMimeTypeProvider mimeTypeProvider)
+ {
+ if (urlPath.Length == 1)
+ return null;
+
+ urlPath = Uri.UnescapeDataString(urlPath);
+
+ var entry = _zipArchive.GetEntry(urlPath.Substring(1));
+ if (entry == null)
+ return null;
+
+ return MappedResourceInfo.ForFile(
+ entry.FullName,
+ entry.Name,
+ entry.LastWriteTime.DateTime,
+ entry.Length,
+ mimeTypeProvider.GetMimeType(Path.GetExtension(entry.Name)));
+ }
+
+ ///
+ public Stream OpenFile(string path)
+ => _zipArchive.GetEntry(path)?.Open() ?? throw new FileNotFoundException($"\"{path}\" cannot be found in Zip archive.");
+
+ ///
+ public IEnumerable GetDirectoryEntries(string path, IMimeTypeProvider mimeTypeProvider)
+ => Enumerable.Empty();
+
+ ///
+ /// Releases unmanaged and - optionally - managed resources.
+ ///
+ /// to release both managed and unmanaged resources;
+ /// to release only unmanaged resources.
+ protected virtual void Dispose(bool disposing)
+ {
+ if (!disposing)
+ return;
+
+ _zipArchive.Dispose();
+ }
+ }
+}
\ No newline at end of file
diff --git a/Vendor/EmbedIO-3.5.2/HttpContextExtensions-Items.cs b/Vendor/EmbedIO-3.5.2/HttpContextExtensions-Items.cs
new file mode 100644
index 0000000..d82f88f
--- /dev/null
+++ b/Vendor/EmbedIO-3.5.2/HttpContextExtensions-Items.cs
@@ -0,0 +1,47 @@
+using System;
+
+namespace EmbedIO
+{
+ partial class HttpContextExtensions
+ {
+ /// Gets the item associated with the specified key.
+ /// The desired type of the item.
+ /// The on which this method is called.
+ /// The key whose value to get from the Items dictionary.
+ ///
+ /// When this method returns, the item associated with the specified key,
+ /// if the key is found in Items
+ /// and the associated value is of type ;
+ /// otherwise, the default value for .
+ /// This parameter is passed uninitialized.
+ ///
+ /// if the item is found and is of type ;
+ /// otherwise, .
+ /// is .
+ /// is .
+ public static bool TryGetItem(this IHttpContext @this, object key, out T value)
+ {
+ if (@this.Items.TryGetValue(key, out var item) && item is T typedItem)
+ {
+ value = typedItem;
+ return true;
+ }
+
+#pragma warning disable CS8653 // value is non-nullable - We are returning false, so value is undefined.
+ value = default;
+#pragma warning restore CS8653
+ return false;
+ }
+
+ /// Gets the item associated with the specified key.
+ /// The desired type of the item.
+ /// The on which this method is called.
+ /// The key whose value to get from the Items dictionary.
+ /// The item associated with the specified key,
+ /// if the key is found in Items
+ /// and the associated value is of type ;
+ /// otherwise, the default value for .
+ public static T GetItem(this IHttpContext @this, object key)
+ => @this.Items.TryGetValue(key, out var item) && item is T typedItem ? typedItem : default;
+ }
+}
\ No newline at end of file
diff --git a/Vendor/EmbedIO-3.5.2/HttpContextExtensions-Redirect.cs b/Vendor/EmbedIO-3.5.2/HttpContextExtensions-Redirect.cs
new file mode 100644
index 0000000..5cc7ff9
--- /dev/null
+++ b/Vendor/EmbedIO-3.5.2/HttpContextExtensions-Redirect.cs
@@ -0,0 +1,33 @@
+using System;
+using System.Net;
+using EmbedIO.Utilities;
+
+namespace EmbedIO
+{
+ partial class HttpContextExtensions
+ {
+ ///
+ /// Sets a redirection status code and adds a Location header to the response.
+ ///
+ /// The interface on which this method is called.
+ /// The URL to which the user agent should be redirected.
+ /// The status code to set on the response.
+ /// is .
+ /// is .
+ ///
+ /// is not a valid relative or absolute URL..
+ /// - or -
+ /// is not a redirection (3xx) status code.
+ ///
+ public static void Redirect(this IHttpContext @this, string location, int statusCode = (int)HttpStatusCode.Found)
+ {
+ location = Validate.Url(nameof(location), location, @this.Request.Url);
+
+ if (statusCode < 300 || statusCode > 399)
+ throw new ArgumentException("Redirect status code is not valid.", nameof(statusCode));
+
+ @this.Response.SetEmptyResponse(statusCode);
+ @this.Response.Headers[HttpHeaderNames.Location] = location;
+ }
+ }
+}
\ No newline at end of file
diff --git a/Vendor/EmbedIO-3.5.2/HttpContextExtensions-RequestStream.cs b/Vendor/EmbedIO-3.5.2/HttpContextExtensions-RequestStream.cs
new file mode 100644
index 0000000..9f9158e
--- /dev/null
+++ b/Vendor/EmbedIO-3.5.2/HttpContextExtensions-RequestStream.cs
@@ -0,0 +1,61 @@
+using System.IO;
+using System.IO.Compression;
+using System.Text;
+using Swan.Logging;
+
+namespace EmbedIO
+{
+ partial class HttpContextExtensions
+ {
+ ///
+ /// Wraps the request input stream and returns a that can be used directly.
+ /// Decompression of compressed request bodies is implemented if specified in the web server's options.
+ ///
+ /// The on which this method is called.
+ ///
+ /// A that can be used to write response data.
+ /// This stream MUST be disposed when finished writing.
+ ///
+ ///
+ ///
+ public static Stream OpenRequestStream(this IHttpContext @this)
+ {
+ var stream = @this.Request.InputStream;
+
+ var encoding = @this.Request.Headers[HttpHeaderNames.ContentEncoding]?.Trim();
+ switch (encoding)
+ {
+ case CompressionMethodNames.Gzip:
+ if (@this.SupportCompressedRequests)
+ return new GZipStream(stream, CompressionMode.Decompress);
+ break;
+ case CompressionMethodNames.Deflate:
+ if (@this.SupportCompressedRequests)
+ return new DeflateStream(stream, CompressionMode.Decompress);
+ break;
+ case CompressionMethodNames.None:
+ case null:
+ return stream;
+ }
+
+ $"[{@this.Id}] Unsupported request content encoding \"{encoding}\", sending 400 Bad Request..."
+ .Warn(nameof(OpenRequestStream));
+
+ throw HttpException.BadRequest($"Unsupported content encoding \"{encoding}\"");
+ }
+
+ ///
+ /// Wraps the request input stream and returns a that can be used directly.
+ /// Decompression of compressed request bodies is implemented if specified in the web server's options.
+ ///
+ /// The on which this method is called.
+ ///
+ /// A that can be used to read the request body as text.
+ /// This reader MUST be disposed when finished reading.
+ ///
+ ///
+ ///
+ public static TextReader OpenRequestText(this IHttpContext @this)
+ => new StreamReader(OpenRequestStream(@this), @this.Request.ContentEncoding);
+ }
+}
\ No newline at end of file
diff --git a/Vendor/EmbedIO-3.5.2/HttpContextExtensions-Requests.cs b/Vendor/EmbedIO-3.5.2/HttpContextExtensions-Requests.cs
new file mode 100644
index 0000000..f3948ee
--- /dev/null
+++ b/Vendor/EmbedIO-3.5.2/HttpContextExtensions-Requests.cs
@@ -0,0 +1,175 @@
+using System;
+using System.Collections.Specialized;
+using System.IO;
+using System.Threading.Tasks;
+using EmbedIO.Utilities;
+using Swan;
+
+namespace EmbedIO
+{
+ partial class HttpContextExtensions
+ {
+ private static readonly object FormDataKey = new object();
+ private static readonly object QueryDataKey = new object();
+
+ ///
+ /// Asynchronously retrieves the request body as an array of s.
+ ///
+ /// The on which this method is called.
+ /// A Task, representing the ongoing operation,
+ /// whose result will be an array of s containing the request body.
+ /// is .
+ public static async Task GetRequestBodyAsByteArrayAsync(this IHttpContext @this)
+ {
+ using var buffer = new MemoryStream();
+ using var stream = @this.OpenRequestStream();
+ await stream.CopyToAsync(buffer, WebServer.StreamCopyBufferSize, @this.CancellationToken).ConfigureAwait(false);
+ return buffer.ToArray();
+ }
+
+ ///
+ /// Asynchronously buffers the request body into a read-only .
+ ///
+ /// The on which this method is called.
+ /// A Task, representing the ongoing operation,
+ /// whose result will be a read-only containing the request body.
+ /// is .
+ public static async Task GetRequestBodyAsMemoryStreamAsync(this IHttpContext @this)
+ => new MemoryStream(
+ await GetRequestBodyAsByteArrayAsync(@this).ConfigureAwait(false),
+ false);
+
+ ///
+ /// Asynchronously retrieves the request body as a string.
+ ///
+ /// The on which this method is called.
+ /// A Task, representing the ongoing operation,
+ /// whose result will be a representation of the request body.
+ /// is .
+ public static async Task GetRequestBodyAsStringAsync(this IHttpContext @this)
+ {
+ using var reader = @this.OpenRequestText();
+ return await reader.ReadToEndAsync().ConfigureAwait(false);
+ }
+
+ ///
+ /// Asynchronously deserializes a request body, using the default request deserializer.
+ /// As of EmbedIO version 3.0, the default response serializer has the same behavior of JSON
+ /// request parsing methods of version 2.
+ ///
+ /// The expected type of the deserialized data.
+ /// The on which this method is called.
+ /// A Task, representing the ongoing operation,
+ /// whose result will be the deserialized data.
+ /// is .
+ public static Task GetRequestDataAsync(this IHttpContext @this)
+ => RequestDeserializer.Default(@this);
+
+ ///
+ /// Asynchronously deserializes a request body, using the specified request deserializer.
+ ///
+ /// The expected type of the deserialized data.
+ /// The on which this method is called.
+ /// A used to deserialize the request body.
+ /// A Task, representing the ongoing operation,
+ /// whose result will be the deserialized data.
+ /// is .
+ /// is .
+ public static Task GetRequestDataAsync(this IHttpContext @this,RequestDeserializerCallback deserializer)
+ => Validate.NotNull(nameof(deserializer), deserializer)(@this);
+
+ ///
+ /// Asynchronously parses a request body in application/x-www-form-urlencoded format.
+ ///
+ /// The on which this method is called.
+ /// A Task, representing the ongoing operation,
+ /// whose result will be a read-only of form field names and values.
+ /// is .
+ ///
+ /// This method may safely be called more than once for the same :
+ /// it will return the same collection instead of trying to parse the request body again.
+ ///
+ public static async Task GetRequestFormDataAsync(this IHttpContext @this)
+ {
+ if (!@this.Items.TryGetValue(FormDataKey, out var previousResult))
+ {
+ NameValueCollection result;
+ try
+ {
+ using var reader = @this.OpenRequestText();
+ result = UrlEncodedDataParser.Parse(await reader.ReadToEndAsync().ConfigureAwait(false), false);
+ }
+ catch (Exception e)
+ {
+ @this.Items[FormDataKey] = e;
+ throw;
+ }
+
+ @this.Items[FormDataKey] = result;
+ return result;
+ }
+
+ switch (previousResult)
+ {
+ case NameValueCollection collection:
+ return collection;
+
+ case Exception exception:
+ throw exception.RethrowPreservingStackTrace();
+
+ case null:
+ throw SelfCheck.Failure($"Previous result of {nameof(HttpContextExtensions)}.{nameof(GetRequestFormDataAsync)} is null.");
+
+ default:
+ throw SelfCheck.Failure($"Previous result of {nameof(HttpContextExtensions)}.{nameof(GetRequestFormDataAsync)} is of unexpected type {previousResult.GetType().FullName}");
+ }
+ }
+
+ ///
+ /// Parses a request URL query. Note that this is different from getting the property,
+ /// in that fields without an equal sign are treated as if they have an empty value, instead of their keys being grouped
+ /// as values of the null key.
+ ///
+ /// The on which this method is called.
+ /// A read-only .
+ /// is .
+ ///
+ /// This method may safely be called more than once for the same :
+ /// it will return the same collection instead of trying to parse the request body again.
+ ///
+ public static NameValueCollection GetRequestQueryData(this IHttpContext @this)
+ {
+ if (!@this.Items.TryGetValue(QueryDataKey, out var previousResult))
+ {
+ NameValueCollection result;
+ try
+ {
+ result = UrlEncodedDataParser.Parse(@this.Request.Url.Query, false);
+ }
+ catch (Exception e)
+ {
+ @this.Items[FormDataKey] = e;
+ throw;
+ }
+
+ @this.Items[FormDataKey] = result;
+ return result;
+ }
+
+ switch (previousResult)
+ {
+ case NameValueCollection collection:
+ return collection;
+
+ case Exception exception:
+ throw exception.RethrowPreservingStackTrace();
+
+ case null:
+ throw SelfCheck.Failure($"Previous result of {nameof(HttpContextExtensions)}.{nameof(GetRequestQueryData)} is null.");
+
+ default:
+ throw SelfCheck.Failure($"Previous result of {nameof(HttpContextExtensions)}.{nameof(GetRequestQueryData)} is of unexpected type {previousResult.GetType().FullName}");
+ }
+ }
+ }
+}
\ No newline at end of file
diff --git a/Vendor/EmbedIO-3.5.2/HttpContextExtensions-ResponseStream.cs b/Vendor/EmbedIO-3.5.2/HttpContextExtensions-ResponseStream.cs
new file mode 100644
index 0000000..59dd4be
--- /dev/null
+++ b/Vendor/EmbedIO-3.5.2/HttpContextExtensions-ResponseStream.cs
@@ -0,0 +1,68 @@
+using System.IO;
+using System.IO.Compression;
+using System.Text;
+using EmbedIO.Internal;
+
+namespace EmbedIO
+{
+ partial class HttpContextExtensions
+ {
+ ///
+ /// Wraps the response output stream and returns a that can be used directly.
+ /// Optional buffering is applied, so that the response may be sent as one instead of using chunked transfer.
+ /// Proactive negotiation is performed to select the best compression method supported by the client.
+ ///
+ /// The on which this method is called.
+ /// If set to , sent data is collected
+ /// in a and sent all at once when the returned
+ /// is disposed; if set to (the default), chunked transfer will be used.
+ /// if sending compressed data is preferred over
+ /// sending non-compressed data; otherwise, .
+ ///
+ /// A that can be used to write response data.
+ /// This stream MUST be disposed when finished writing.
+ ///
+ ///
+ public static Stream OpenResponseStream(this IHttpContext @this, bool buffered = false, bool preferCompression = true)
+ {
+ // No need to check whether negotiation is successful;
+ // the returned callback will throw HttpNotAcceptableException if it was not.
+ _ = @this.Request.TryNegotiateContentEncoding(preferCompression, out var compressionMethod, out var prepareResponse);
+ prepareResponse(@this.Response);
+ var stream = buffered ? new BufferingResponseStream(@this.Response) : @this.Response.OutputStream;
+
+ return compressionMethod switch {
+ CompressionMethod.Gzip => new GZipStream(stream, CompressionMode.Compress),
+ CompressionMethod.Deflate => new DeflateStream(stream, CompressionMode.Compress),
+ _ => stream
+ };
+ }
+
+ ///
+ /// Wraps the response output stream and returns a that can be used directly.
+ /// Optional buffering is applied, so that the response may be sent as one instead of using chunked transfer.
+ /// Proactive negotiation is performed to select the best compression method supported by the client.
+ ///
+ /// The on which this method is called.
+ ///
+ /// The to use to convert text to data bytes.
+ /// If (the default), (UTF-8 without a byte order mark) is used.
+ ///
+ /// If set to , sent data is collected
+ /// in a and sent all at once when the returned
+ /// is disposed; if set to (the default), chunked transfer will be used.
+ /// if sending compressed data is preferred over
+ /// sending non-compressed data; otherwise, .
+ ///
+ /// A that can be used to write response data.
+ /// This writer MUST be disposed when finished writing.
+ ///
+ ///
+ public static TextWriter OpenResponseText(this IHttpContext @this, Encoding? encoding = null, bool buffered = false, bool preferCompression = true)
+ {
+ encoding ??= WebServer.DefaultEncoding;
+ @this.Response.ContentEncoding = encoding;
+ return new StreamWriter(OpenResponseStream(@this, buffered, preferCompression), encoding);
+ }
+ }
+}
\ No newline at end of file
diff --git a/Vendor/EmbedIO-3.5.2/HttpContextExtensions-Responses.cs b/Vendor/EmbedIO-3.5.2/HttpContextExtensions-Responses.cs
new file mode 100644
index 0000000..3447ad4
--- /dev/null
+++ b/Vendor/EmbedIO-3.5.2/HttpContextExtensions-Responses.cs
@@ -0,0 +1,124 @@
+using System;
+using System.IO;
+using System.Net;
+using System.Text;
+using System.Threading.Tasks;
+using EmbedIO.Utilities;
+
+namespace EmbedIO
+{
+ partial class HttpContextExtensions
+ {
+ private const string StandardHtmlHeaderFormat = "{0} - {1}{0} - {1}
";
+ private const string StandardHtmlFooter = "";
+
+ ///
+ /// Asynchronously sends a string as response.
+ ///
+ /// The interface on which this method is called.
+ /// The response content.
+ /// The MIME type of the content. If , the content type will not be set.
+ /// The to use.
+ /// A representing the ongoing operation.
+ /// is .
+ ///
+ /// is .
+ /// - or -
+ /// is .
+ ///
+ public static async Task SendStringAsync(
+ this IHttpContext @this,
+ string content,
+ string contentType,
+ Encoding encoding)
+ {
+ content = Validate.NotNull(nameof(content), content);
+ encoding = Validate.NotNull(nameof(encoding), encoding);
+
+ if (contentType != null)
+ {
+ @this.Response.ContentType = contentType;
+ @this.Response.ContentEncoding = encoding;
+ }
+
+ using var text = @this.OpenResponseText(encoding);
+ await text.WriteAsync(content).ConfigureAwait(false);
+ }
+
+ ///
+ /// Asynchronously sends a standard HTML response for the specified status code.
+ ///
+ /// The interface on which this method is called.
+ /// The HTTP status code of the response.
+ /// A representing the ongoing operation.
+ /// is .
+ /// There is no standard status description for .
+ ///
+ public static Task SendStandardHtmlAsync(this IHttpContext @this, int statusCode)
+ => SendStandardHtmlAsync(@this, statusCode, null);
+
+ ///
+ /// Asynchronously sends a standard HTML response for the specified status code.
+ ///
+ /// The interface on which this method is called.
+ /// The HTTP status code of the response.
+ /// A callback function that may write additional HTML code
+ /// to a representing the response output.
+ /// If not , the callback is called immediately before closing the HTML body tag.
+ /// A representing the ongoing operation.
+ /// is .
+ /// There is no standard status description for .
+ ///
+ public static Task SendStandardHtmlAsync(
+ this IHttpContext @this,
+ int statusCode,
+ Action? writeAdditionalHtml)
+ {
+ if (!HttpStatusDescription.TryGet(statusCode, out var statusDescription))
+ throw new ArgumentException("Status code has no standard description.", nameof(statusCode));
+
+ @this.Response.StatusCode = statusCode;
+ @this.Response.StatusDescription = statusDescription;
+ @this.Response.ContentType = MimeType.Html;
+ @this.Response.ContentEncoding = WebServer.DefaultEncoding;
+ using (var text = @this.OpenResponseText(WebServer.DefaultEncoding))
+ {
+ text.Write(StandardHtmlHeaderFormat, statusCode, statusDescription, WebServer.DefaultEncoding.WebName);
+ writeAdditionalHtml?.Invoke(text);
+ text.Write(StandardHtmlFooter);
+ }
+
+ return Task.CompletedTask;
+ }
+
+ ///
+ /// Asynchronously sends serialized data as a response, using the default response serializer.
+ /// As of EmbedIO version 3.0, the default response serializer has the same behavior of JSON
+ /// response methods of version 2.
+ ///
+ /// The interface on which this method is called.
+ /// The data to serialize.
+ /// A representing the ongoing operation.
+ /// is .
+ ///
+ ///
+ public static Task SendDataAsync(this IHttpContext @this, object data)
+ => ResponseSerializer.Default(@this, data);
+
+ ///
+ /// Asynchronously sends serialized data as a response, using the specified response serializer.
+ /// As of EmbedIO version 3.0, the default response serializer has the same behavior of JSON
+ /// response methods of version 2.
+ ///
+ /// The interface on which this method is called.
+ /// A used to prepare the response.
+ /// The data to serialize.
+ /// A representing the ongoing operation.
+ /// is .
+ /// is .
+ ///
+ ///
+ public static Task SendDataAsync(this IHttpContext @this, ResponseSerializerCallback serializer, object data)
+ => Validate.NotNull(nameof(serializer), serializer)(@this, data);
+ }
+}
\ No newline at end of file
diff --git a/Vendor/EmbedIO-3.5.2/HttpContextExtensions.cs b/Vendor/EmbedIO-3.5.2/HttpContextExtensions.cs
new file mode 100644
index 0000000..46da20c
--- /dev/null
+++ b/Vendor/EmbedIO-3.5.2/HttpContextExtensions.cs
@@ -0,0 +1,30 @@
+using System;
+using EmbedIO.Utilities;
+using Swan;
+
+namespace EmbedIO
+{
+ ///
+ /// Provides extension methods for types implementing .
+ ///
+ public static partial class HttpContextExtensions
+ {
+ ///
+ /// Gets the underlying interface of an .
+ /// This API mainly supports the EmbedIO infrastructure; it is not intended to be used directly from your code,
+ /// unless to fulfill very specific needs in the development of plug-ins (modules, etc.) for EmbedIO.
+ ///
+ /// The interface on which this method is called.
+ /// The underlying interface representing
+ /// the HTTP context implementation.
+ ///
+ /// is .
+ ///
+ ///
+ /// does not implement .
+ ///
+ public static IHttpContextImpl GetImplementation(this IHttpContext @this)
+ => Validate.NotNull(nameof(@this), @this) as IHttpContextImpl
+ ?? throw SelfCheck.Failure($"{@this.GetType().FullName} does not implement {nameof(IHttpContextImpl)}.");
+ }
+}
\ No newline at end of file
diff --git a/Vendor/EmbedIO-3.5.2/HttpException-Shortcuts.cs b/Vendor/EmbedIO-3.5.2/HttpException-Shortcuts.cs
new file mode 100644
index 0000000..7c8c50b
--- /dev/null
+++ b/Vendor/EmbedIO-3.5.2/HttpException-Shortcuts.cs
@@ -0,0 +1,158 @@
+using System;
+using System.Net;
+
+namespace EmbedIO
+{
+ partial class HttpException
+ {
+ ///
+ /// Returns a new instance of that, when thrown,
+ /// will break the request handling control flow and send a 500 Internal Server Error
+ /// response to the client.
+ ///
+ /// A message to include in the response.
+ /// The data object to include in the response.
+ ///
+ /// A newly-created .
+ ///
+ public static HttpException InternalServerError(string? message = null, object? data = null)
+ => new HttpException(HttpStatusCode.InternalServerError, message, data);
+
+ ///
+ /// Returns a new instance of that, when thrown,
+ /// will break the request handling control flow and send a 401 Unauthorized
+ /// response to the client.
+ ///
+ /// A message to include in the response.
+ /// The data object to include in the response.
+ ///
+ /// A newly-created .
+ ///
+ public static HttpException Unauthorized(string? message = null, object? data = null)
+ => new HttpException(HttpStatusCode.Unauthorized, message, data);
+
+ ///
+ /// Returns a new instance of that, when thrown,
+ /// will break the request handling control flow and send a 403 Forbidden
+ /// response to the client.
+ ///
+ /// A message to include in the response.
+ /// The data object to include in the response.
+ /// A newly-created .
+ public static HttpException Forbidden(string? message = null, object? data = null)
+ => new HttpException(HttpStatusCode.Forbidden, message, data);
+
+ ///
+ /// Returns a new instance of that, when thrown,
+ /// will break the request handling control flow and send a 400 Bad Request
+ /// response to the client.
+ ///
+ /// A message to include in the response.
+ /// The data object to include in the response.
+ /// A newly-created .
+ public static HttpException BadRequest(string? message = null, object? data = null)
+ => new HttpException(HttpStatusCode.BadRequest, message, data);
+
+ ///
+ /// Returns a new instance of that, when thrown,
+ /// will break the request handling control flow and send a 404 Not Found
+ /// response to the client.
+ ///
+ /// A message to include in the response.
+ /// The data object to include in the response.
+ /// A newly-created .
+ public static HttpException NotFound(string? message = null, object? data = null)
+ => new HttpException(HttpStatusCode.NotFound, message, data);
+
+ ///
+ /// Returns a new instance of that, when thrown,
+ /// will break the request handling control flow and send a 405 Method Not Allowed
+ /// response to the client.
+ ///
+ /// A message to include in the response.
+ /// The data object to include in the response.
+ /// A newly-created .
+ public static HttpException MethodNotAllowed(string? message = null, object? data = null)
+ => new HttpException(HttpStatusCode.MethodNotAllowed, message, data);
+
+ ///
+ /// Returns a new instance of that, when thrown,
+ /// will break the request handling control flow and send a 406 Not Acceptable
+ /// response to the client.
+ ///
+ /// A newly-created .
+ ///
+ public static HttpNotAcceptableException NotAcceptable() => new HttpNotAcceptableException();
+
+ ///
+ /// Returns a new instance of that, when thrown,
+ /// will break the request handling control flow and send a 406 Not Acceptable
+ /// response to the client.
+ ///
+ /// A value, or a comma-separated list of values, to set the response's Vary header to.
+ /// A newly-created .
+ ///
+ public static HttpNotAcceptableException NotAcceptable(string vary) => new HttpNotAcceptableException(vary);
+
+ ///
+ /// Returns a new instance of that, when thrown,
+ /// will break the request handling control flow and send a 416 Range Not Satisfiable
+ /// response to the client.
+ ///
+ /// A newly-created .
+ ///
+ public static HttpRangeNotSatisfiableException RangeNotSatisfiable() => new HttpRangeNotSatisfiableException();
+
+ ///
+ /// Returns a new instance of that, when thrown,
+ /// will break the request handling control flow and send a 416 Range Not Satisfiable
+ /// response to the client.
+ ///
+ /// The total length of the requested resource, expressed in bytes,
+ /// or to omit the Content-Range header in the response.
+ /// A newly-created .
+ ///
+ public static HttpRangeNotSatisfiableException RangeNotSatisfiable(long? contentLength)
+ => new HttpRangeNotSatisfiableException(contentLength);
+
+ ///
+ /// Returns a new instance of that, when thrown,
+ /// will break the request handling control flow and redirect the client
+ /// to the specified location, using response status code 302.
+ ///
+ /// The redirection target.
+ ///
+ /// A newly-created .
+ ///
+ public static HttpRedirectException Redirect(string location)
+ => new HttpRedirectException(location);
+
+ ///
+ /// Returns a new instance of that, when thrown,
+ /// will break the request handling control flow and redirect the client
+ /// to the specified location, using the specified response status code.
+ ///
+ /// The redirection target.
+ /// The status code to set on the response, in the range from 300 to 399.
+ ///
+ /// A newly-created .
+ ///
+ /// is not in the 300-399 range.
+ public static HttpRedirectException Redirect(string location, int statusCode)
+ => new HttpRedirectException(location, statusCode);
+
+ ///
+ /// Returns a new instance of that, when thrown,
+ /// will break the request handling control flow and redirect the client
+ /// to the specified location, using the specified response status code.
+ ///
+ /// The redirection target.
+ /// One of the redirection status codes, to be set on the response.
+ ///
+ /// A newly-created .
+ ///
+ /// is not a redirection status code.
+ public static HttpRedirectException Redirect(string location, HttpStatusCode statusCode)
+ => new HttpRedirectException(location, statusCode);
+ }
+}
diff --git a/Vendor/EmbedIO-3.5.2/HttpException.cs b/Vendor/EmbedIO-3.5.2/HttpException.cs
new file mode 100644
index 0000000..be3e635
--- /dev/null
+++ b/Vendor/EmbedIO-3.5.2/HttpException.cs
@@ -0,0 +1,105 @@
+using System;
+using System.Net;
+
+namespace EmbedIO
+{
+ ///
+ /// When thrown, breaks the request handling control flow
+ /// and sends an error response to the client.
+ ///
+#pragma warning disable CA1032 // Implement standard exception constructors - they have no meaning here.
+ public partial class HttpException : Exception, IHttpException
+#pragma warning restore CA1032
+ {
+ ///
+ /// Initializes a new instance of the class,
+ /// with no message to include in the response.
+ ///
+ /// The status code to set on the response.
+ public HttpException(int statusCode)
+ {
+ StatusCode = statusCode;
+ }
+
+ ///
+ /// Initializes a new instance of the class,
+ /// with no message to include in the response.
+ ///
+ /// The status code to set on the response.
+ public HttpException(HttpStatusCode statusCode)
+ : this((int)statusCode)
+ {
+ }
+
+ ///
+ /// Initializes a new instance of the class,
+ /// with a message to include in the response.
+ ///
+ /// The status code to set on the response.
+ /// A message to include in the response as plain text.
+ public HttpException(int statusCode, string? message)
+ : base(message)
+ {
+ StatusCode = statusCode;
+ HttpExceptionMessage = message;
+ }
+
+ ///
+ /// Initializes a new instance of the class,
+ /// with a message to include in the response.
+ ///
+ /// The status code to set on the response.
+ /// A message to include in the response as plain text.
+ public HttpException(HttpStatusCode statusCode, string? message)
+ : this((int)statusCode, message)
+ {
+ }
+
+ ///
+ /// Initializes a new instance of the class,
+ /// with a message and a data object to include in the response.
+ ///
+ /// The status code to set on the response.
+ /// A message to include in the response as plain text.
+ /// The data object to include in the response.
+ public HttpException(int statusCode, string? message, object? data)
+ : this(statusCode, message)
+ {
+ DataObject = data;
+ }
+
+ ///
+ /// Initializes a new instance of the class,
+ /// with a message and a data object to include in the response.
+ ///
+ /// The status code to set on the response.
+ /// A message to include in the response as plain text.
+ /// The data object to include in the response.
+ public HttpException(HttpStatusCode statusCode, string? message, object? data)
+ : this((int)statusCode, message, data)
+ {
+ }
+
+ ///
+ public int StatusCode { get; }
+
+ ///
+ public object? DataObject { get; }
+
+ ///
+ string? IHttpException.Message => HttpExceptionMessage;
+
+ // This property is necessary because when an exception with a null Message is thrown
+ // the CLR provides a standard message. We want null to remain null in IHttpException.
+ private string? HttpExceptionMessage { get; }
+
+ ///
+ ///
+ /// This method does nothing; there is no need to call
+ /// base.PrepareResponse in overrides of this method.
+ ///
+ public virtual void PrepareResponse(IHttpContext context)
+ {
+ }
+ }
+}
\ No newline at end of file
diff --git a/Vendor/EmbedIO-3.5.2/HttpExceptionHandler.cs b/Vendor/EmbedIO-3.5.2/HttpExceptionHandler.cs
new file mode 100644
index 0000000..b72efa8
--- /dev/null
+++ b/Vendor/EmbedIO-3.5.2/HttpExceptionHandler.cs
@@ -0,0 +1,153 @@
+using System;
+using System.Net;
+using System.Runtime.ExceptionServices;
+using System.Net.Http;
+using System.Threading.Tasks;
+using System.Web;
+using EmbedIO.Utilities;
+using Swan.Logging;
+
+namespace EmbedIO
+{
+ ///
+ /// Provides standard handlers for HTTP exceptions at both module and server level.
+ ///
+ ///
+ /// Where applicable, HTTP exception handlers defined in this class
+ /// use the and
+ /// properties to customize
+ /// their behavior.
+ ///
+ ///
+ ///
+ public static class HttpExceptionHandler
+ {
+ ///
+ /// Gets the default handler used by .
+ /// This is the same as .
+ ///
+ public static HttpExceptionHandlerCallback Default { get; } = HtmlResponse;
+
+ ///
+ /// Sends an empty response.
+ ///
+ /// An interface representing the context of the request.
+ /// The HTTP exception.
+ /// A representing the ongoing operation.
+#pragma warning disable CA1801 // Unused parameter
+ public static Task EmptyResponse(IHttpContext context, IHttpException httpException)
+#pragma warning restore CA1801
+ => Task.CompletedTask;
+
+ ///
+ /// Sends a HTTP exception's Message property
+ /// as a plain text response.
+ /// This handler does not use the DataObject property.
+ ///
+ /// An interface representing the context of the request.
+ /// The HTTP exception.
+ /// A representing the ongoing operation.
+ public static Task PlainTextResponse(IHttpContext context, IHttpException httpException)
+ => context.SendStringAsync(httpException.Message ?? string.Empty, MimeType.PlainText, WebServer.DefaultEncoding);
+
+ ///
+ /// Sends a response with a HTML payload
+ /// briefly describing the error, including contact information and/or a stack trace
+ /// if specified via the
+ /// and properties, respectively.
+ /// This handler does not use the DataObject property.
+ ///
+ /// An interface representing the context of the request.
+ /// The HTTP exception.
+ /// A representing the ongoing operation.
+ public static Task HtmlResponse(IHttpContext context, IHttpException httpException)
+ => context.SendStandardHtmlAsync(
+ httpException.StatusCode,
+ text => {
+ text.Write(
+ "Exception type: {0}
Message: {1}",
+ WebUtility.HtmlEncode(httpException.GetType().FullName ?? ""),
+ WebUtility.HtmlEncode(httpException.Message));
+
+ text.Write("
If this error is completely unexpected to you, and you think you should not seeing this page, please contact the server administrator");
+
+ if (!string.IsNullOrEmpty(ExceptionHandler.ContactInformation))
+ text.Write(" ({0})", WebUtility.HtmlEncode(ExceptionHandler.ContactInformation));
+
+ text.Write(", informing them of the time this error occurred and the action(s) you performed that resulted in this error.
");
+
+ if (ExceptionHandler.IncludeStackTraces)
+ {
+ text.Write(
+ "
Stack trace:
{0}",
+ WebUtility.HtmlEncode(httpException.StackTrace));
+ }
+ });
+
+ ///
+ /// Gets a that will serialize a HTTP exception's
+ /// DataObject property and send it as a JSON response.
+ ///
+ /// A used to serialize data and send it to the client.
+ /// A .
+ /// is .
+ public static HttpExceptionHandlerCallback DataResponse(ResponseSerializerCallback serializerCallback)
+ {
+ Validate.NotNull(nameof(serializerCallback), serializerCallback);
+
+ return (context, httpException) => serializerCallback(context, httpException.DataObject);
+ }
+
+ ///
+ /// Gets a that will serialize a HTTP exception's
+ /// Message and DataObject properties
+ /// and send them as a JSON response.
+ /// The response will be a JSON object with a message property and a data property.
+ ///
+ /// A used to serialize data and send it to the client.
+ /// A .
+ /// is .
+ public static HttpExceptionHandlerCallback FullDataResponse(ResponseSerializerCallback serializerCallback)
+ {
+ Validate.NotNull(nameof(serializerCallback), serializerCallback);
+
+ return (context, httpException) => serializerCallback(context, new
+ {
+ message = httpException.Message,
+ data = httpException.DataObject,
+ });
+ }
+
+ internal static async Task Handle(string logSource, IHttpContext context, Exception exception, HttpExceptionHandlerCallback? handler)
+ {
+ if (handler == null || !(exception is IHttpException httpException))
+ {
+ ExceptionDispatchInfo.Capture(exception).Throw();
+ return;
+ }
+
+ exception.Log(logSource, $"[{context.Id}] HTTP exception {httpException.StatusCode}");
+
+ try
+ {
+ context.Response.SetEmptyResponse(httpException.StatusCode);
+ context.Response.DisableCaching();
+ httpException.PrepareResponse(context);
+ await handler(context, httpException)
+ .ConfigureAwait(false);
+ }
+ catch (OperationCanceledException) when (context.CancellationToken.IsCancellationRequested)
+ {
+ throw;
+ }
+ catch (HttpListenerException)
+ {
+ throw;
+ }
+ catch (Exception exception2)
+ {
+ exception2.Log(logSource, $"[{context.Id}] Unhandled exception while handling HTTP exception {httpException.StatusCode}");
+ }
+ }
+ }
+}
\ No newline at end of file
diff --git a/Vendor/EmbedIO-3.5.2/HttpExceptionHandlerCallback.cs b/Vendor/EmbedIO-3.5.2/HttpExceptionHandlerCallback.cs
new file mode 100644
index 0000000..488f6d7
--- /dev/null
+++ b/Vendor/EmbedIO-3.5.2/HttpExceptionHandlerCallback.cs
@@ -0,0 +1,21 @@
+using System.Threading.Tasks;
+
+namespace EmbedIO
+{
+ ///
+ /// A callback used to build the contents of the response for an .
+ ///
+ /// An interface representing the context of the request.
+ /// An interface.
+ /// A representing the ongoing operation.
+ ///
+ /// When this delegate is called, the response's status code has already been set and the
+ /// method has already been called. The only thing left to do is preparing the response's content, according
+ /// to the property.
+ /// Any exception thrown by a handler (even a HTTP exception) will go unhandled: the web server
+ /// will not crash, but processing of the request will be aborted, and the response will be flushed as-is.
+ /// In other words, it is not a good ides to throw HttpException.NotFound() (or similar)
+ /// from a handler.
+ ///
+ public delegate Task HttpExceptionHandlerCallback(IHttpContext context, IHttpException httpException);
+}
\ No newline at end of file
diff --git a/Vendor/EmbedIO-3.5.2/HttpHeaderNames.cs b/Vendor/EmbedIO-3.5.2/HttpHeaderNames.cs
new file mode 100644
index 0000000..a29846f
--- /dev/null
+++ b/Vendor/EmbedIO-3.5.2/HttpHeaderNames.cs
@@ -0,0 +1,449 @@
+namespace EmbedIO
+{
+ ///
+ /// Exposes known HTTP header names.
+ ///
+ ///
+ /// The constants in this class have been extracted from a list of known HTTP header names.
+ /// The presence of a header name in this class is not a guarantee that EmbedIO supports,
+ /// or even recognizes, it. Refer to the documentation for each module for information about supported
+ /// headers.
+ ///
+ public static class HttpHeaderNames
+ {
+ // The .NET Core sources were taken as reference for this list of constants.
+ // See https://github.com/dotnet/corefx/blob/master/src/Common/src/System/Net/HttpKnownHeaderNames.cs
+ // However, not all constants come from there, so be careful not to copy-paste indiscriminately.
+
+ ///
+ /// The Accept HTTP header.
+ ///
+ public const string Accept = "Accept";
+
+ ///
+ /// The Accept-Charset HTTP header.
+ ///
+ public const string AcceptCharset = "Accept-Charset";
+
+ ///
+ /// The Accept-Encoding HTTP header.
+ ///
+ public const string AcceptEncoding = "Accept-Encoding";
+
+ ///
+ /// The Accept-Language HTTP header.
+ ///
+ public const string AcceptLanguage = "Accept-Language";
+
+ ///
+ /// The Accept-Patch HTTP header.
+ ///
+ public const string AcceptPatch = "Accept-Patch";
+
+ ///
+ /// The Accept-Ranges HTTP header.
+ ///
+ public const string AcceptRanges = "Accept-Ranges";
+
+ ///
+ /// The Access-Control-Allow-Credentials HTTP header.
+ ///
+ public const string AccessControlAllowCredentials = "Access-Control-Allow-Credentials";
+
+ ///
+ /// The Access-Control-Allow-Headers HTTP header.
+ ///
+ public const string AccessControlAllowHeaders = "Access-Control-Allow-Headers";
+
+ ///
+ /// The Access-Control-Allow-Methods HTTP header.
+ ///
+ public const string AccessControlAllowMethods = "Access-Control-Allow-Methods";
+
+ ///
+ /// The Access-Control-Allow-Origin HTTP header.
+ ///
+ public const string AccessControlAllowOrigin = "Access-Control-Allow-Origin";
+
+ ///
+ /// The Access-Control-Expose-Headers HTTP header.
+ ///
+ public const string AccessControlExposeHeaders = "Access-Control-Expose-Headers";
+
+ ///
+ /// The Access-Control-Max-Age HTTP header.
+ ///
+ public const string AccessControlMaxAge = "Access-Control-Max-Age";
+
+ ///
+ /// The Access-Control-Request-Headers HTTP header.
+ ///
+ public const string AccessControlRequestHeaders = "Access-Control-Request-Headers";
+
+ ///
+ /// The Access-Control-Request-Method HTTP header.
+ ///
+ public const string AccessControlRequestMethod = "Access-Control-Request-Method";
+
+ ///
+ /// The Age HTTP header.
+ ///
+ public const string Age = "Age";
+
+ ///
+ /// The Allow HTTP header.
+ ///
+ public const string Allow = "Allow";
+
+ ///
+ /// The Alt-Svc HTTP header.
+ ///
+ public const string AltSvc = "Alt-Svc";
+
+ ///
+ /// The Authorization HTTP header.
+ ///
+ public const string Authorization = "Authorization";
+
+ ///
+ /// The Cache-Control HTTP header.
+ ///
+ public const string CacheControl = "Cache-Control";
+
+ ///
+ /// The Connection HTTP header.
+ ///
+ public const string Connection = "Connection";
+
+ ///
+ /// The Content-Disposition HTTP header.
+ ///
+ public const string ContentDisposition = "Content-Disposition";
+
+ ///
+ /// The Content-Encoding HTTP header.
+ ///
+ public const string ContentEncoding = "Content-Encoding";
+
+ ///
+ /// The Content-Language HTTP header.
+ ///
+ public const string ContentLanguage = "Content-Language";
+
+ ///
+ /// The Content-Length HTTP header.
+ ///
+ public const string ContentLength = "Content-Length";
+
+ ///
+ /// The Content-Location HTTP header.
+ ///
+ public const string ContentLocation = "Content-Location";
+
+ ///
+ /// The Content-MD5 HTTP header.
+ ///
+ public const string ContentMD5 = "Content-MD5";
+
+ ///
+ /// The Content-Range HTTP header.
+ ///
+ public const string ContentRange = "Content-Range";
+
+ ///
+ /// The Content-Security-Policy HTTP header.
+ ///
+ public const string ContentSecurityPolicy = "Content-Security-Policy";
+
+ ///
+ /// The Content-Type HTTP header.
+ ///
+ public const string ContentType = "Content-Type";
+
+ ///
+ /// The Cookie HTTP header.
+ ///
+ public const string Cookie = "Cookie";
+
+ ///
+ /// The Cookie2 HTTP header.
+ ///
+ public const string Cookie2 = "Cookie2";
+
+ ///
+ /// The Date HTTP header.
+ ///
+ public const string Date = "Date";
+
+ ///
+ /// The ETag HTTP header.
+ ///
+ public const string ETag = "ETag";
+
+ ///
+ /// The Expect HTTP header.
+ ///
+ public const string Expect = "Expect";
+
+ ///
+ /// The Expires HTTP header.
+ ///
+ public const string Expires = "Expires";
+
+ ///
+ /// The From HTTP header.
+ ///
+ public const string From = "From";
+
+ ///
+ /// The Host HTTP header.
+ ///
+ public const string Host = "Host";
+
+ ///
+ /// The If-Match HTTP header.
+ ///
+ public const string IfMatch = "If-Match";
+
+ ///
+ /// The If-Modified-Since HTTP header.
+ ///
+ public const string IfModifiedSince = "If-Modified-Since";
+
+ ///
+ /// The If-None-Match HTTP header.
+ ///
+ public const string IfNoneMatch = "If-None-Match";
+
+ ///
+ /// The If-Range HTTP header.
+ ///
+ public const string IfRange = "If-Range";
+
+ ///
+ /// The If-Unmodified-Since HTTP header.
+ ///
+ public const string IfUnmodifiedSince = "If-Unmodified-Since";
+
+ ///
+ /// The Keep-Alive HTTP header.
+ ///
+ public const string KeepAlive = "Keep-Alive";
+
+ ///
+ /// The Last-Modified HTTP header.
+ ///
+ public const string LastModified = "Last-Modified";
+
+ ///
+ /// The Link HTTP header.
+ ///
+ public const string Link = "Link";
+
+ ///
+ /// The Location HTTP header.
+ ///
+ public const string Location = "Location";
+
+ ///
+ /// The Max-Forwards HTTP header.
+ ///
+ public const string MaxForwards = "Max-Forwards";
+
+ ///
+ /// The Origin HTTP header.
+ ///
+ public const string Origin = "Origin";
+
+ ///
+ /// The P3P HTTP header.
+ ///
+ public const string P3P = "P3P";
+
+ ///
+ /// The Pragma HTTP header.
+ ///
+ public const string Pragma = "Pragma";
+
+ ///
+ /// The Proxy-Authenticate HTTP header.
+ ///
+ public const string ProxyAuthenticate = "Proxy-Authenticate";
+
+ ///
+ /// The Proxy-Authorization HTTP header.
+ ///
+ public const string ProxyAuthorization = "Proxy-Authorization";
+
+ ///
+ /// The Proxy-Connection HTTP header.
+ ///
+ public const string ProxyConnection = "Proxy-Connection";
+
+ ///
+ /// The Public-Key-Pins HTTP header.
+ ///
+ public const string PublicKeyPins = "Public-Key-Pins";
+
+ ///
+ /// The Range HTTP header.
+ ///
+ public const string Range = "Range";
+
+ ///
+ /// The Referer HTTP header.
+ ///
+ ///
+ /// The incorrect spelling ("Referer" instead of "Referrer") is intentional
+ /// and has historical reasons.
+ /// See the "Etymology" section of the Wikipedia article
+ /// on this header for more information.
+ ///
+ public const string Referer = "Referer";
+
+ ///
+ /// The Retry-After HTTP header.
+ ///
+ public const string RetryAfter = "Retry-After";
+
+ ///
+ /// The Sec-WebSocket-Accept HTTP header.
+ ///
+ public const string SecWebSocketAccept = "Sec-WebSocket-Accept";
+
+ ///
+ /// The Sec-WebSocket-Extensions HTTP header.
+ ///
+ public const string SecWebSocketExtensions = "Sec-WebSocket-Extensions";
+
+ ///
+ /// The Sec-WebSocket-Key HTTP header.
+ ///
+ public const string SecWebSocketKey = "Sec-WebSocket-Key";
+
+ ///
+ /// The Sec-WebSocket-Protocol HTTP header.
+ ///
+ public const string SecWebSocketProtocol = "Sec-WebSocket-Protocol";
+
+ ///
+ /// The Sec-WebSocket-Version HTTP header.
+ ///
+ public const string SecWebSocketVersion = "Sec-WebSocket-Version";
+
+ ///
+ /// The Server HTTP header.
+ ///
+ public const string Server = "Server";
+
+ ///
+ /// The Set-Cookie HTTP header.
+ ///
+ public const string SetCookie = "Set-Cookie";
+
+ ///
+ /// The Set-Cookie2 HTTP header.
+ ///
+ public const string SetCookie2 = "Set-Cookie2";
+
+ ///
+ /// The Strict-Transport-Security HTTP header.
+ ///
+ public const string StrictTransportSecurity = "Strict-Transport-Security";
+
+ ///
+ /// The TE HTTP header.
+ ///
+ public const string TE = "TE";
+
+ ///
+ /// The TSV HTTP header.
+ ///
+ public const string TSV = "TSV";
+
+ ///
+ /// The Trailer HTTP header.
+ ///
+ public const string Trailer = "Trailer";
+
+ ///
+ /// The Transfer-Encoding HTTP header.
+ ///
+ public const string TransferEncoding = "Transfer-Encoding";
+
+ ///
+ /// The Upgrade HTTP header.
+ ///
+ public const string Upgrade = "Upgrade";
+
+ ///
+ /// The Upgrade-Insecure-Requests HTTP header.
+ ///
+ public const string UpgradeInsecureRequests = "Upgrade-Insecure-Requests";
+
+ ///
+ /// The User-Agent HTTP header.
+ ///
+ public const string UserAgent = "User-Agent";
+
+ ///
+ /// The Vary HTTP header.
+ ///
+ public const string Vary = "Vary";
+
+ ///
+ /// The Via HTTP header.
+ ///
+ public const string Via = "Via";
+
+ ///
+ /// The WWW-Authenticate HTTP header.
+ ///
+ public const string WWWAuthenticate = "WWW-Authenticate";
+
+ ///
+ /// The Warning HTTP header.
+ ///
+ public const string Warning = "Warning";
+
+ ///
+ /// The X-AspNet-Version HTTP header.
+ ///
+ public const string XAspNetVersion = "X-AspNet-Version";
+
+ ///
+ /// The X-Content-Duration HTTP header.
+ ///
+ public const string XContentDuration = "X-Content-Duration";
+
+ ///
+ /// The X-Content-Type-Options HTTP header.
+ ///
+ public const string XContentTypeOptions = "X-Content-Type-Options";
+
+ ///
+ /// The X-Frame-Options HTTP header.
+ ///
+ public const string XFrameOptions = "X-Frame-Options";
+
+ ///
+ /// The X-MSEdge-Ref HTTP header.
+ ///
+ public const string XMSEdgeRef = "X-MSEdge-Ref";
+
+ ///
+ /// The X-Powered-By HTTP header.
+ ///
+ public const string XPoweredBy = "X-Powered-By";
+
+ ///
+ /// The X-Request-ID HTTP header.
+ ///
+ public const string XRequestID = "X-Request-ID";
+
+ ///
+ /// The X-UA-Compatible HTTP header.
+ ///
+ public const string XUACompatible = "X-UA-Compatible";
+ }
+}
\ No newline at end of file
diff --git a/Vendor/EmbedIO-3.5.2/HttpListenerMode.cs b/Vendor/EmbedIO-3.5.2/HttpListenerMode.cs
new file mode 100644
index 0000000..3e10107
--- /dev/null
+++ b/Vendor/EmbedIO-3.5.2/HttpListenerMode.cs
@@ -0,0 +1,20 @@
+namespace EmbedIO
+{
+ ///
+ /// Defines the HTTP listeners available for use in a .
+ ///
+ public enum HttpListenerMode
+ {
+ ///
+ /// Use EmbedIO's internal HTTP listener implementation,
+ /// based on Mono's System.Net.HttpListener.
+ ///
+ EmbedIO,
+
+ ///
+ /// Use the class
+ /// provided by the .NET runtime in use.
+ ///
+ Microsoft,
+ }
+}
\ No newline at end of file
diff --git a/Vendor/EmbedIO-3.5.2/HttpNotAcceptableException.cs b/Vendor/EmbedIO-3.5.2/HttpNotAcceptableException.cs
new file mode 100644
index 0000000..f84f47e
--- /dev/null
+++ b/Vendor/EmbedIO-3.5.2/HttpNotAcceptableException.cs
@@ -0,0 +1,55 @@
+using System.Net;
+
+namespace EmbedIO
+{
+ ///
+ /// When thrown, breaks the request handling control flow
+ /// and sends a redirection response to the client.
+ ///
+#pragma warning disable CA1032 // Implement standard exception constructors - they have no meaning here.
+ public class HttpNotAcceptableException : HttpException
+#pragma warning restore CA1032
+ {
+ ///
+ /// Initializes a new instance of the class,
+ /// without specifying a value for the response's Vary header.
+ ///
+ public HttpNotAcceptableException()
+ : this(null)
+ {
+ }
+
+ ///
+ /// Initializes a new instance of the class.
+ ///
+ ///
+ /// A value, or a comma-separated list of values, to set the response's Vary header to.
+ /// Although not specified in RFC7231,
+ /// this may help the client to understand why the request has been rejected.
+ /// If this parameter is or the empty string, the response's Vary header
+ /// is not set.
+ ///
+ public HttpNotAcceptableException(string? vary)
+ : base((int)HttpStatusCode.NotAcceptable)
+ {
+ Vary = string.IsNullOrEmpty(vary) ? null : vary;
+ }
+
+ ///
+ /// Gets the value, or comma-separated list of values, to be set
+ /// on the response's Vary header.
+ ///
+ ///
+ /// If the empty string has been passed to the
+ /// constructor, the value of this property is .
+ ///
+ public string? Vary { get; }
+
+ ///
+ public override void PrepareResponse(IHttpContext context)
+ {
+ if (Vary != null)
+ context.Response.Headers.Add(HttpHeaderNames.Vary, Vary);
+ }
+ }
+}
\ No newline at end of file
diff --git a/Vendor/EmbedIO-3.5.2/HttpRangeNotSatisfiableException.cs b/Vendor/EmbedIO-3.5.2/HttpRangeNotSatisfiableException.cs
new file mode 100644
index 0000000..8397e1b
--- /dev/null
+++ b/Vendor/EmbedIO-3.5.2/HttpRangeNotSatisfiableException.cs
@@ -0,0 +1,50 @@
+using System.Net;
+
+namespace EmbedIO
+{
+ ///
+ /// When thrown, breaks the request handling control flow
+ /// and sends a redirection response to the client.
+ ///
+#pragma warning disable CA1032 // Implement standard exception constructors - they have no meaning here.
+ public class HttpRangeNotSatisfiableException : HttpException
+#pragma warning restore CA1032
+ {
+ ///
+ /// Initializes a new instance of the class.
+ /// without specifying a value for the response's Content-Range header.
+ ///
+ public HttpRangeNotSatisfiableException()
+ : this(null)
+ {
+ }
+
+ ///
+ /// Initializes a new instance of the class.
+ ///
+ /// The total length of the requested resource, expressed in bytes,
+ /// or to omit the Content-Range header in the response.
+ public HttpRangeNotSatisfiableException(long? contentLength)
+ : base((int)HttpStatusCode.RequestedRangeNotSatisfiable)
+ {
+ ContentLength = contentLength;
+ }
+
+ ///
+ /// Gets the total content length to be specified
+ /// on the response's Content-Range header.
+ ///
+ public long? ContentLength { get; }
+
+ ///
+ public override void PrepareResponse(IHttpContext context)
+ {
+ // RFC 7233, Section 3.1: "When this status code is generated in response
+ // to a byte-range request, the sender
+ // SHOULD generate a Content-Range header field specifying
+ // the current length of the selected representation."
+ if (ContentLength.HasValue)
+ context.Response.Headers.Set(HttpHeaderNames.ContentRange, $"bytes */{ContentLength.Value}");
+ }
+ }
+}
\ No newline at end of file
diff --git a/Vendor/EmbedIO-3.5.2/HttpRedirectException.cs b/Vendor/EmbedIO-3.5.2/HttpRedirectException.cs
new file mode 100644
index 0000000..22b6801
--- /dev/null
+++ b/Vendor/EmbedIO-3.5.2/HttpRedirectException.cs
@@ -0,0 +1,54 @@
+using System;
+using System.Net;
+
+namespace EmbedIO
+{
+ ///
+ /// When thrown, breaks the request handling control flow
+ /// and sends a redirection response to the client.
+ ///
+#pragma warning disable CA1032 // Implement standard exception constructors - they have no meaning here.
+ public class HttpRedirectException : HttpException
+#pragma warning restore CA1032
+ {
+ ///
+ /// Initializes a new instance of the class.
+ ///
+ /// The redirection target.
+ ///
+ /// The status code to set on the response, in the range from 300 to 399.
+ /// By default, status code 302 (Found) is used.
+ ///
+ /// is not in the 300-399 range.
+ public HttpRedirectException(string location, int statusCode = (int)HttpStatusCode.Found)
+ : base(statusCode)
+ {
+ if (statusCode < 300 || statusCode > 399)
+ throw new ArgumentException("Redirect status code is not valid.", nameof(statusCode));
+
+ Location = location;
+ }
+
+ ///
+ /// Initializes a new instance of the class.
+ ///
+ /// The redirection target.
+ /// One of the redirection status codes, to be set on the response.
+ /// is not a redirection status code.
+ public HttpRedirectException(string location, HttpStatusCode statusCode)
+ : this(location, (int)statusCode)
+ {
+ }
+
+ ///
+ /// Gets the URL where the client will be redirected.
+ ///
+ public string Location { get; }
+
+ ///
+ public override void PrepareResponse(IHttpContext context)
+ {
+ context.Redirect(Location, StatusCode);
+ }
+ }
+}
\ No newline at end of file
diff --git a/Vendor/EmbedIO-3.5.2/HttpRequestExtensions.cs b/Vendor/EmbedIO-3.5.2/HttpRequestExtensions.cs
new file mode 100644
index 0000000..70e55aa
--- /dev/null
+++ b/Vendor/EmbedIO-3.5.2/HttpRequestExtensions.cs
@@ -0,0 +1,262 @@
+using System;
+using System.Globalization;
+using System.Linq;
+using System.Net;
+using System.Net.Http.Headers;
+using EmbedIO.Utilities;
+
+namespace EmbedIO
+{
+ ///
+ /// Provides extension methods for types implementing .
+ ///
+ public static class HttpRequestExtensions
+ {
+ ///
+ /// Returns a string representing the remote IP address and port of an interface.
+ /// This method can be called even on a interface, or one that has no
+ /// remote end point, or no remote address; it will always return a non-,
+ /// non-empty string.
+ ///
+ /// The on which this method is called.
+ ///
+ /// If is , or its RemoteEndPoint
+ /// is , the string "<null>; otherwise, the remote end point's
+ /// Address (or the string "<???>" if it is )
+ /// followed by a colon and the Port number.
+ ///
+ public static string SafeGetRemoteEndpointStr(this IHttpRequest @this)
+ {
+ var endPoint = @this?.RemoteEndPoint;
+ return endPoint == null
+ ? ""
+ : $"{endPoint.Address?.ToString() ?? ""}:{endPoint.Port.ToString(CultureInfo.InvariantCulture)}";
+ }
+
+ ///
+ /// Attempts to proactively negotiate a compression method for a response,
+ /// based on a request's Accept-Encoding header (or lack of it).
+ ///
+ /// The on which this method is called.
+ /// if sending compressed data is preferred over
+ /// sending non-compressed data; otherwise, .
+ /// When this method returns, the compression method to use for the response,
+ /// if content negotiation is successful. This parameter is passed uninitialized.
+ /// When this method returns, a callback that prepares data in an
+ /// according to the result of content negotiation. This parameter is passed uninitialized.
+ /// if content negotiation is successful;
+ /// otherwise, .
+ ///
+ /// If this method returns , the callback
+ /// will set appropriate response headers to reflect the results of content negotiation.
+ /// If this method returns , the callback
+ /// will throw a to send a 406 Not Acceptable response
+ /// with the Vary header set to Accept-Encoding,
+ /// so that the client may know the reason why the request has been rejected.
+ /// If has noAccept-Encoding header, this method
+ /// always returns and sets
+ /// to .
+ ///
+ ///
+ public static bool TryNegotiateContentEncoding(
+ this IHttpRequest @this,
+ bool preferCompression,
+ out CompressionMethod compressionMethod,
+ out Action prepareResponse)
+ {
+ var acceptedEncodings = new QValueList(true, @this.Headers.GetValues(HttpHeaderNames.AcceptEncoding));
+ if (!acceptedEncodings.TryNegotiateContentEncoding(preferCompression, out compressionMethod, out var compressionMethodName))
+ {
+ prepareResponse = r => throw HttpException.NotAcceptable(HttpHeaderNames.AcceptEncoding);
+ return false;
+ }
+
+ prepareResponse = r => {
+ r.Headers.Add(HttpHeaderNames.Vary, HttpHeaderNames.AcceptEncoding);
+ r.Headers.Set(HttpHeaderNames.ContentEncoding, compressionMethodName);
+ };
+ return true;
+ }
+
+ ///
+ /// Checks whether an If-None-Match header exists in a request
+ /// and, if so, whether it contains a given entity tag.
+ /// See RFC7232, Section 3.2
+ /// for a normative reference; however, see the Remarks section for more information
+ /// about the RFC compliance of this method.
+ ///
+ /// The on which this method is called.
+ /// The entity tag.
+ /// When this method returns, a value that indicates whether an
+ /// If-None-Match header is present in , regardless of the method's
+ /// return value. This parameter is passed uninitialized.
+ /// if an If-None-Match header is present in
+ /// and one of the entity tags listed in it is equal to ;
+ /// otherwise.
+ ///
+ /// RFC7232, Section 3.2
+ /// states that a weak comparison function (as defined in
+ /// RFC7232, Section 2.3.2)
+ /// must be used for If-None-Match. That would mean parsing every entity tag, at least minimally,
+ /// to determine whether it is a "weak" or "strong" tag. Since EmbedIO currently generates only
+ /// "strong" tags, this method uses the default string comparer instead.
+ /// The behavior of this method is thus not, strictly speaking, RFC7232-compliant;
+ /// it works, though, with entity tags generated by EmbedIO.
+ ///
+ public static bool CheckIfNoneMatch(this IHttpRequest @this, string entityTag, out bool headerExists)
+ {
+ var values = @this.Headers.GetValues(HttpHeaderNames.IfNoneMatch);
+ if (values == null)
+ {
+ headerExists = false;
+ return false;
+ }
+
+ headerExists = true;
+ return values.Select(t => t.Trim()).Contains(entityTag);
+ }
+
+ // Check whether the If-Modified-Since request header exists
+ // and specifies a date and time more recent than or equal to
+ // the date and time of last modification of the requested resource.
+ // RFC7232, Section 3.3
+
+ ///
+ /// Checks whether an If-Modified-Since header exists in a request
+ /// and, if so, whether its value is a date and time more recent or equal to
+ /// a given .
+ /// See RFC7232, Section 3.3
+ /// for a normative reference.
+ ///
+ /// The on which this method is called.
+ /// A date and time value, in Coordinated Universal Time,
+ /// expressing the last time a resource was modified.
+ /// When this method returns, a value that indicates whether an
+ /// If-Modified-Since header is present in , regardless of the method's
+ /// return value. This parameter is passed uninitialized.
+ /// if an If-Modified-Since header is present in
+ /// and its value is a date and time more recent or equal to ;
+ /// otherwise.
+ public static bool CheckIfModifiedSince(this IHttpRequest @this, DateTime lastModifiedUtc, out bool headerExists)
+ {
+ var value = @this.Headers.Get(HttpHeaderNames.IfModifiedSince);
+ if (value == null)
+ {
+ headerExists = false;
+ return false;
+ }
+
+ headerExists = true;
+ return HttpDate.TryParse(value, out var dateTime)
+ && dateTime.UtcDateTime >= lastModifiedUtc;
+ }
+
+ // Checks the Range request header to tell whether to send
+ // a "206 Partial Content" response.
+
+ ///
+ /// Checks whether a Range header exists in a request
+ /// and, if so, determines whether it is possible to send a 206 Partial Content response.
+ /// See RFC7233
+ /// for a normative reference; however, see the Remarks section for more information
+ /// about the RFC compliance of this method.
+ ///
+ /// The on which this method is called.
+ /// The total length, in bytes, of the response entity, i.e.
+ /// what would be sent in a 200 OK response.
+ /// An entity tag representing the response entity. This value is checked against
+ /// the If-Range header, if it is present.
+ /// The date and time value, in Coordinated Universal Time,
+ /// expressing the last modification time of the resource entity. This value is checked against
+ /// the If-Range header, if it is present.
+ /// When this method returns , the start of the requested byte range.
+ /// This parameter is passed uninitialized.
+ ///
+ /// When this method returns , the upper bound of the requested byte range.
+ /// This parameter is passed uninitialized.
+ /// Note that the upper bound of a range is NOT the sum of the range's start and length;
+ /// for example, a range expressed as bytes=0-99 has a start of 0, an upper bound of 99,
+ /// and a length of 100 bytes.
+ ///
+ ///
+ /// This method returns if the following conditions are satisfied:
+ ///
+ /// - >the request's HTTP method is GET;
+ /// - >a Range header is present in the request;
+ /// - >either no If-Range header is present in the request, or it
+ /// specifies an entity tag equal to , or a UTC date and time
+ /// equal to ;
+ /// - >the Range header specifies exactly one range;
+ /// - >the specified range is entirely contained in the range from 0 to - 1.
+ ///
+ /// If the last condition is not satisfied, i.e. the specified range start and/or upper bound
+ /// are out of the range from 0 to - 1, this method does not return;
+ /// it throws a instead.
+ /// If any of the other conditions are not satisfied, this method returns .
+ ///
+ ///
+ /// According to RFC7233, Section 3.1,
+ /// there are several conditions under which a server may ignore or reject a range request; therefore,
+ /// clients are (or should be) prepared to receive a 200 OK response with the whole response
+ /// entity instead of the requested range(s). For this reason, until the generation of
+ /// multipart/byteranges responses is implemented in EmbedIO, this method will ignore
+ /// range requests specifying more than one range, even if this behavior is not, strictly speaking,
+ /// RFC7233-compliant.
+ /// To make clients aware that range requests are accepted for a resource, every 200 OK
+ /// (or 304 Not Modified) response for the same resource should include an Accept-Ranges
+ /// header with the string bytes as value.
+ ///
+ public static bool IsRangeRequest(this IHttpRequest @this, long contentLength, string entityTag, DateTime lastModifiedUtc, out long start, out long upperBound)
+ {
+ start = 0;
+ upperBound = contentLength - 1;
+
+ // RFC7233, Section 3.1:
+ // "A server MUST ignore a Range header field received with a request method other than GET."
+ if (@this.HttpVerb != HttpVerbs.Get)
+ return false;
+
+ // No Range header, no partial content.
+ var rangeHeader = @this.Headers.Get(HttpHeaderNames.Range);
+ if (rangeHeader == null)
+ return false;
+
+ // Ignore the Range header if there is no If-Range header
+ // or if the If-Range header specifies a non-matching validator.
+ // RFC7233, Section 3.2: "If the validator given in the If-Range header field matches the
+ // current validator for the selected representation of the target
+ // resource, then the server SHOULD process the Range header field as
+ // requested.If the validator does not match, the server MUST ignore
+ // the Range header field.Note that this comparison by exact match,
+ // including when the validator is an HTTP-date, differs from the
+ // "earlier than or equal to" comparison used when evaluating an
+ // If-Unmodified-Since conditional."
+ var ifRange = @this.Headers.Get(HttpHeaderNames.IfRange)?.Trim();
+ if (ifRange != null && ifRange != entityTag)
+ {
+ if (!HttpDate.TryParse(ifRange, out var rangeDate))
+ return false;
+
+ if (rangeDate.UtcDateTime != lastModifiedUtc)
+ return false;
+ }
+
+ // Ignore the Range request header if it cannot be parsed successfully.
+ if (!RangeHeaderValue.TryParse(rangeHeader, out var range))
+ return false;
+
+ // EmbedIO does not support multipart/byteranges responses (yet),
+ // thus ignore range requests that specify one range.
+ if (range.Ranges.Count != 1)
+ return false;
+
+ var firstRange = range.Ranges.First();
+ start = firstRange.From ?? 0L;
+ upperBound = firstRange.To ?? contentLength - 1;
+ if (start >= contentLength || upperBound < start || upperBound >= contentLength)
+ throw HttpException.RangeNotSatisfiable(contentLength);
+
+ return true;
+ }
+ }
+}
\ No newline at end of file
diff --git a/Vendor/EmbedIO-3.5.2/HttpResponseExtensions.cs b/Vendor/EmbedIO-3.5.2/HttpResponseExtensions.cs
new file mode 100644
index 0000000..ad4c6c4
--- /dev/null
+++ b/Vendor/EmbedIO-3.5.2/HttpResponseExtensions.cs
@@ -0,0 +1,43 @@
+using System;
+using EmbedIO.Utilities;
+
+namespace EmbedIO
+{
+ ///
+ /// Provides extension methods for types implementing .
+ ///
+ public static class HttpResponseExtensions
+ {
+ ///
+ /// Sets the necessary headers to disable caching of a response on the client side.
+ ///
+ /// The interface on which this method is called.
+ /// is .
+ public static void DisableCaching(this IHttpResponse @this)
+ {
+ var headers = @this.Headers;
+ headers.Set(HttpHeaderNames.Expires, "Sat, 26 Jul 1997 05:00:00 GMT");
+ headers.Set(HttpHeaderNames.LastModified, HttpDate.Format(DateTime.UtcNow));
+ headers.Set(HttpHeaderNames.CacheControl, "no-store, no-cache, must-revalidate");
+ headers.Add(HttpHeaderNames.Pragma, "no-cache");
+ }
+
+ ///
+ /// Prepares a standard response without a body for the specified status code.
+ ///
+ /// The interface on which this method is called.
+ /// The HTTP status code of the response.
+ /// is .
+ /// There is no standard status description for .
+ public static void SetEmptyResponse(this IHttpResponse @this, int statusCode)
+ {
+ if (!HttpStatusDescription.TryGet(statusCode, out var statusDescription))
+ throw new ArgumentException("Status code has no standard description.", nameof(statusCode));
+
+ @this.StatusCode = statusCode;
+ @this.StatusDescription = statusDescription;
+ @this.ContentType = MimeType.Default;
+ @this.ContentEncoding = null;
+ }
+ }
+}
\ No newline at end of file
diff --git a/Vendor/EmbedIO-3.5.2/HttpStatusDescription.cs b/Vendor/EmbedIO-3.5.2/HttpStatusDescription.cs
new file mode 100644
index 0000000..a724005
--- /dev/null
+++ b/Vendor/EmbedIO-3.5.2/HttpStatusDescription.cs
@@ -0,0 +1,146 @@
+using System.Collections.Generic;
+using System.Net;
+
+namespace EmbedIO
+{
+ ///
+ /// Provides standard HTTP status descriptions.
+ /// Data contained in this class comes from the following sources:
+ ///
+ /// - RFC7231 Section 6 (HTTP/1.1 Semantics and Content)
+ /// - RFC6585 (Additional HTTP Status Codes)
+ /// - RFC2774 Section 7 (An HTTP Extension Framework)
+ /// - RFC7540 Section 9.1.2 (HTTP/2)
+ /// - RFC4918 Section 11 (WebDAV)
+ /// - RFC5842 Section 7 (Binding Extensions to WebDAV)
+ /// - RFC7538 Section 3 (HTTP Status Code 308)
+ /// - RFC3229 Section 10.4.1 (Delta encoding in HTTP)
+ /// - RFC8297 Section 2 (Early Hints)
+ /// - RFC7725 Section 3 (HTTP-status-451)
+ /// - RFC2295 Section 8.1 (Transparent Content Negotiation)
+ ///
+ ///
+ public static class HttpStatusDescription
+ {
+ private static readonly IReadOnlyDictionary Dictionary = new Dictionary {
+ { 100, "Continue" },
+ { 101, "Switching Protocols" },
+ { 102, "Processing" },
+ { 103, "Early Hints" },
+ { 200, "OK" },
+ { 201, "Created" },
+ { 202, "Accepted" },
+ { 203, "Non-Authoritative Information" },
+ { 204, "No Content" },
+ { 205, "Reset Content" },
+ { 206, "Partial Content" },
+ { 207, "Multi-Status" },
+ { 208, "Already Reported" },
+ { 226, "IM Used" },
+ { 300, "Multiple Choices" },
+ { 301, "Moved Permanently" },
+ { 302, "Found" },
+ { 303, "See Other" },
+ { 304, "Not Modified" },
+ { 305, "Use Proxy" },
+ { 307, "Temporary Redirect" },
+ { 308, "Permanent Redirect" },
+ { 400, "Bad Request" },
+ { 401, "Unauthorized" },
+ { 402, "Payment Required" },
+ { 403, "Forbidden" },
+ { 404, "Not Found" },
+ { 405, "Method Not Allowed" },
+ { 406, "Not Acceptable" },
+ { 407, "Proxy Authentication Required" },
+ { 408, "Request Timeout" },
+ { 409, "Conflict" },
+ { 410, "Gone" },
+ { 411, "Length Required" },
+ { 412, "Precondition Failed" },
+ { 413, "Request Entity Too Large" },
+ { 414, "Request-Uri Too Long" },
+ { 415, "Unsupported Media Type" },
+ { 416, "Requested Range Not Satisfiable" },
+ { 417, "Expectation Failed" },
+ { 421, "Misdirected Request" },
+ { 422, "Unprocessable Entity" },
+ { 423, "Locked" },
+ { 424, "Failed Dependency" },
+ { 426, "Upgrade Required" },
+ { 428, "Precondition Required" },
+ { 429, "Too Many Requests" },
+ { 431, "Request Header Fields Too Large" },
+ { 451, "Unavailable For Legal Reasons" },
+ { 500, "Internal Server Error" },
+ { 501, "Not Implemented" },
+ { 502, "Bad Gateway" },
+ { 503, "Service Unavailable" },
+ { 504, "Gateway Timeout" },
+ { 505, "Http Version Not Supported" },
+ { 506, "Variant Also Negotiates" },
+ { 507, "Insufficient Storage" },
+ { 508, "Loop Detected" },
+ { 510, "Not Extended" },
+ { 511, "Network Authentication Required" },
+ };
+
+ ///
+ /// Attempts to get the standard status description for a .
+ ///
+ /// The HTTP status code for which the standard description
+ /// is to be retrieved.
+ /// When this method returns, the standard HTTP status description
+ /// for the specified if it was found, or
+ /// if it was not found. This parameter is passed uninitialized.
+ /// if the specified was found
+ /// in the list of HTTP status codes for which the standard description is known;
+ /// otherwise, .
+ ///
+ ///
+ public static bool TryGet(HttpStatusCode code, out string description) => Dictionary.TryGetValue((int)code, out description);
+
+ ///
+ /// Attempts to get the standard status description for a HTTP status code
+ /// specified as an .
+ ///
+ /// The HTTP status code for which the standard description
+ /// is to be retrieved.
+ /// When this method returns, the standard HTTP status description
+ /// for the specified if it was found, or
+ /// if it was not found. This parameter is passed uninitialized.
+ /// if the specified was found
+ /// in the list of HTTP status codes for which the standard description is known;
+ /// otherwise, .
+ ///
+ ///
+ public static bool TryGet(int code, out string description) => Dictionary.TryGetValue(code, out description);
+
+ ///
+ /// Returns the standard status description for a .
+ ///
+ /// The HTTP status code for which the standard description
+ /// is to be retrieved.
+ /// The standard HTTP status description for the specified
+ /// if it was found, or if it was not found.
+ public static string Get(HttpStatusCode code)
+ {
+ Dictionary.TryGetValue((int)code, out var description);
+ return description;
+ }
+
+ ///
+ /// Returns the standard status description for a HTTP status code
+ /// specified as an .
+ ///
+ /// The HTTP status code for which the standard description
+ /// is to be retrieved.
+ /// The standard HTTP status description for the specified
+ /// if it was found, or if it was not found.
+ public static string Get(int code)
+ {
+ Dictionary.TryGetValue(code, out var description);
+ return description;
+ }
+ }
+}
\ No newline at end of file
diff --git a/Vendor/EmbedIO-3.5.2/HttpVerbs.cs b/Vendor/EmbedIO-3.5.2/HttpVerbs.cs
new file mode 100644
index 0000000..765b01e
--- /dev/null
+++ b/Vendor/EmbedIO-3.5.2/HttpVerbs.cs
@@ -0,0 +1,48 @@
+namespace EmbedIO
+{
+ ///
+ /// Enumerates the different HTTP Verbs.
+ ///
+ public enum HttpVerbs
+ {
+ ///
+ /// Wildcard Method
+ ///
+ Any,
+
+ ///
+ /// DELETE Method
+ ///
+ Delete,
+
+ ///
+ /// GET Method
+ ///
+ Get,
+
+ ///
+ /// HEAD method
+ ///
+ Head,
+
+ ///
+ /// OPTIONS method
+ ///
+ Options,
+
+ ///
+ /// PATCH method
+ ///
+ Patch,
+
+ ///
+ /// POST method
+ ///
+ Post,
+
+ ///
+ /// PUT method
+ ///
+ Put,
+ }
+}
\ No newline at end of file
diff --git a/Vendor/EmbedIO-3.5.2/ICookieCollection.cs b/Vendor/EmbedIO-3.5.2/ICookieCollection.cs
new file mode 100644
index 0000000..48f4f8f
--- /dev/null
+++ b/Vendor/EmbedIO-3.5.2/ICookieCollection.cs
@@ -0,0 +1,49 @@
+using System.Net;
+using System.Collections;
+using System.Collections.Generic;
+
+namespace EmbedIO
+{
+ ///
+ /// Interface for Cookie Collection.
+ ///
+ ///
+#pragma warning disable CA1010 // Should implement ICollection - not possible when wrapping System.Net.CookieCollection.
+ public interface ICookieCollection : IEnumerable, ICollection
+#pragma warning restore CA1010
+ {
+ ///
+ /// Gets the with the specified name.
+ ///
+ ///
+ /// The .
+ ///
+ /// The name.
+ /// The cookie matching the specified name.
+ Cookie? this[string name] { get; }
+
+ ///
+ /// Determines whether this contains the specified .
+ ///
+ /// The cookie to find in the .
+ ///
+ /// if this contains the specified ;
+ /// otherwise, .
+ ///
+ bool Contains(Cookie cookie);
+
+ ///
+ /// Copies the elements of this to a array
+ /// starting at the specified index of the target array.
+ ///
+ /// The target array to which the will be copied.
+ /// The zero-based index in the target where copying begins.
+ void CopyTo(Cookie[] array, int index);
+
+ ///
+ /// Adds the specified cookie.
+ ///
+ /// The cookie.
+ void Add(Cookie cookie);
+ }
+}
\ No newline at end of file
diff --git a/Vendor/EmbedIO-3.5.2/IHttpContext.cs b/Vendor/EmbedIO-3.5.2/IHttpContext.cs
new file mode 100644
index 0000000..bed7695
--- /dev/null
+++ b/Vendor/EmbedIO-3.5.2/IHttpContext.cs
@@ -0,0 +1,128 @@
+using System;
+using System.Collections.Generic;
+using System.Net;
+using System.Security.Principal;
+using System.Threading;
+using System.Threading.Tasks;
+using EmbedIO.Routing;
+using EmbedIO.Sessions;
+
+namespace EmbedIO
+{
+ ///
+ /// Represents the context of a HTTP(s) request being handled by a web server.
+ ///
+ public interface IHttpContext : IMimeTypeProvider
+ {
+ ///
+ /// Gets a unique identifier for a HTTP context.
+ ///
+ string Id { get; }
+
+ ///
+ /// Gets a used to stop processing of this context.
+ ///
+ CancellationToken CancellationToken { get; }
+
+ ///
+ /// Gets the server IP address and port number to which the request is directed.
+ ///
+ IPEndPoint LocalEndPoint { get; }
+
+ ///
+ /// Gets the client IP address and port number from which the request originated.
+ ///
+ IPEndPoint RemoteEndPoint { get; }
+
+ ///
+ /// Gets the HTTP request.
+ ///
+ IHttpRequest Request { get; }
+
+ ///
+ /// Gets the route matched by the requested URL path.
+ ///
+ RouteMatch Route { get; }
+
+ ///
+ /// Gets the requested path, relative to the innermost module's base path.
+ ///
+ ///
+ /// This property derives from the path specified in the requested URL, stripped of the
+ /// BaseRoute of the handling module.
+ /// This property is in itself a valid URL path, including an initial
+ /// slash (/) character.
+ ///
+ string RequestedPath { get; }
+
+ ///
+ /// Gets the HTTP response object.
+ ///
+ IHttpResponse Response { get; }
+
+ ///
+ /// Gets the user.
+ ///
+ IPrincipal User { get; }
+
+ ///
+ /// Gets the session proxy associated with this context.
+ ///
+ ISessionProxy Session { get; }
+
+ ///
+ /// Gets a value indicating whether compressed request bodies are supported.
+ ///
+ ///
+ bool SupportCompressedRequests { get; }
+
+ ///
+ /// Gets the dictionary of data to pass trough the EmbedIO pipeline.
+ ///
+ IDictionary Items { get; }
+
+ ///
+ /// Gets the elapsed time, expressed in milliseconds, since the creation of this context.
+ ///
+ long Age { get; }
+
+ ///
+ /// Gets a value indicating whether this
+ /// has been completely handled, so that no further processing is required.
+ /// When a HTTP context is created, this property is ;
+ /// as soon as it is set to , the context is not
+ /// passed to any further module's handler for processing.
+ /// Once it becomes , this property is guaranteed
+ /// to never become again.
+ ///
+ ///
+ /// When a module's IsFinalHandler property is
+ /// , this property is set to after the
+ /// returned by the module's HandleRequestAsync method
+ /// is completed.
+ ///
+ ///
+ ///
+ bool IsHandled { get; }
+
+ ///
+ /// Marks this context as handled, so that it will not be
+ /// processed by any further module.
+ ///
+ ///
+ /// Calling this method from the
+ /// or of a module whose
+ /// property is
+ /// is redundant and has no effect.
+ ///
+ ///
+ ///
+ void SetHandled();
+
+ ///
+ /// Registers a callback to be called when processing is finished on a context.
+ ///
+ /// The callback.
+ void OnClose(Action callback);
+ }
+}
\ No newline at end of file
diff --git a/Vendor/EmbedIO-3.5.2/IHttpContextHandler.cs b/Vendor/EmbedIO-3.5.2/IHttpContextHandler.cs
new file mode 100644
index 0000000..ed0f311
--- /dev/null
+++ b/Vendor/EmbedIO-3.5.2/IHttpContextHandler.cs
@@ -0,0 +1,20 @@
+using System.Threading.Tasks;
+
+namespace EmbedIO
+{
+ ///
+ /// Represents an object that can handle a HTTP context.
+ /// This API supports the EmbedIO infrastructure and is not intended to be used directly from your code.
+ ///
+ public interface IHttpContextHandler
+ {
+ ///
+ /// Asynchronously handles a HTTP context, generating a suitable response
+ /// for an incoming request.
+ /// This API supports the EmbedIO infrastructure and is not intended to be used directly from your code.
+ ///
+ /// The HTTP context.
+ /// A representing the ongoing operation.
+ Task HandleContextAsync(IHttpContextImpl context);
+ }
+}
\ No newline at end of file
diff --git a/Vendor/EmbedIO-3.5.2/IHttpContextImpl.cs b/Vendor/EmbedIO-3.5.2/IHttpContextImpl.cs
new file mode 100644
index 0000000..de061bb
--- /dev/null
+++ b/Vendor/EmbedIO-3.5.2/IHttpContextImpl.cs
@@ -0,0 +1,88 @@
+using System;
+using System.Collections.Generic;
+using System.Security.Principal;
+using System.Threading;
+using System.Threading.Tasks;
+using EmbedIO.Routing;
+using EmbedIO.Sessions;
+using EmbedIO.Utilities;
+using EmbedIO.WebSockets;
+
+namespace EmbedIO
+{
+ ///
+ /// Represents a HTTP context implementation, i.e. a HTTP context as seen internally by EmbedIO.
+ /// This API mainly supports the EmbedIO infrastructure; it is not intended to be used directly from your code,
+ /// unless to address specific needs in the implementation of EmbedIO plug-ins (e.g. modules).
+ ///
+ ///
+ public interface IHttpContextImpl : IHttpContext
+ {
+ ///
+ /// Gets or sets a used to stop processing of this context.
+ /// This API supports the EmbedIO infrastructure and is not intended to be used directly from your code.
+ ///
+ new CancellationToken CancellationToken { get; set; }
+
+ ///
+ /// Gets or sets the route matched by the requested URL path.
+ ///
+ new RouteMatch Route { get; set; }
+
+ ///
+ /// Gets or sets the session proxy associated with this context.
+ /// This API supports the EmbedIO infrastructure and is not intended to be used directly from your code.
+ ///
+ ///
+ /// An interface.
+ ///
+ new ISessionProxy Session { get; set; }
+
+ ///
+ /// Gets or sets the user.
+ /// This API supports the EmbedIO infrastructure and is not intended to be used directly from your code.
+ ///
+ new IPrincipal User { get; set; }
+
+ ///
+ /// Gets or sets a value indicating whether compressed request bodies are supported.
+ /// This API supports the EmbedIO infrastructure and is not intended to be used directly from your code.
+ ///
+ ///
+ new bool SupportCompressedRequests { get; set; }
+
+ ///
+ /// Gets the MIME type providers.
+ /// This API supports the EmbedIO infrastructure and is not intended to be used directly from your code.
+ ///
+ MimeTypeProviderStack MimeTypeProviders { get; }
+
+ ///
+ /// Flushes and closes the response stream, then calls any registered close callbacks.
+ /// This API supports the EmbedIO infrastructure and is not intended to be used directly from your code.
+ ///
+ ///
+ void Close();
+
+ ///
+ /// Asynchronously handles a WebSockets opening handshake
+ /// and returns a newly-created interface.
+ /// This API supports the EmbedIO infrastructure and is not intended to be used directly from your code.
+ ///
+ /// The requested WebSocket sub-protocols.
+ /// The accepted WebSocket sub-protocol,
+ /// or the empty string is no sub-protocol has been agreed upon.
+ /// Size of the receive buffer.
+ /// The keep-alive interval.
+ /// A used to stop the server.
+ ///
+ /// An interface.
+ ///
+ Task AcceptWebSocketAsync(
+ IEnumerable requestedProtocols,
+ string acceptedProtocol,
+ int receiveBufferSize,
+ TimeSpan keepAliveInterval,
+ CancellationToken cancellationToken);
+ }
+}
\ No newline at end of file
diff --git a/Vendor/EmbedIO-3.5.2/IHttpException.cs b/Vendor/EmbedIO-3.5.2/IHttpException.cs
new file mode 100644
index 0000000..0349a16
--- /dev/null
+++ b/Vendor/EmbedIO-3.5.2/IHttpException.cs
@@ -0,0 +1,58 @@
+using System;
+
+namespace EmbedIO
+{
+ ///
+ /// Represents an exception that results in a particular
+ /// HTTP response to be sent to the client.
+ /// This interface is meant to be implemented
+ /// by classes derived from .
+ /// Either as message or a data object can be attached to
+ /// the exception; which one, if any, is sent to the client
+ /// will depend upon the handler used to send the response.
+ ///
+ ///
+ ///
+ public interface IHttpException
+ {
+ ///
+ /// Gets the response status code for a HTTP exception.
+ ///
+ int StatusCode { get; }
+
+ ///
+ /// Gets the stack trace of a HTTP exception.
+ ///
+ string StackTrace { get; }
+
+ ///
+ /// Gets a message that can be included in the response triggered
+ /// by a HTTP exception.
+ /// Whether the message is actually sent to the client will depend
+ /// upon the handler used to send the response.
+ ///
+ ///
+ /// Do not rely on to implement
+ /// this property if you want to support messages,
+ /// because a default message will be supplied by the CLR at throw time
+ /// when is .
+ ///
+ string? Message { get; }
+
+ ///
+ /// Gets an object that can be serialized and included
+ /// in the response triggered by a HTTP exception.
+ /// Whether the object is actually sent to the client will depend
+ /// upon the handler used to send the response.
+ ///
+ object? DataObject { get; }
+
+ ///
+ /// Sets necessary headers, as required by the nature
+ /// of the HTTP exception (e.g. Location for
+ /// ).
+ ///
+ /// The HTTP context of the response.
+ void PrepareResponse(IHttpContext context);
+ }
+}
\ No newline at end of file
diff --git a/Vendor/EmbedIO-3.5.2/IHttpListener.cs b/Vendor/EmbedIO-3.5.2/IHttpListener.cs
new file mode 100644
index 0000000..3ec376c
--- /dev/null
+++ b/Vendor/EmbedIO-3.5.2/IHttpListener.cs
@@ -0,0 +1,72 @@
+using System;
+using System.Collections.Generic;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace EmbedIO
+{
+ ///
+ /// Interface to create a HTTP Listener.
+ ///
+ public interface IHttpListener : IDisposable
+ {
+ ///
+ /// Gets or sets a value indicating whether the listener should ignore write exceptions. By default the flag is set on.
+ ///
+ ///
+ /// true if [ignore write exceptions]; otherwise, false.
+ ///
+ bool IgnoreWriteExceptions { get; set; }
+
+ ///
+ /// Gets the prefixes.
+ ///
+ ///
+ /// The prefixes.
+ ///
+ List Prefixes { get; }
+
+ ///
+ /// Gets a value indicating whether this instance is listening.
+ ///
+ ///
+ /// true if this instance is listening; otherwise, false.
+ ///
+ bool IsListening { get; }
+
+ ///
+ /// Gets or sets the name.
+ ///
+ ///
+ /// The name.
+ ///
+ string Name { get; }
+
+ ///
+ /// Starts this listener.
+ ///
+ void Start();
+
+ ///
+ /// Stops this listener.
+ ///
+#pragma warning disable CA1716 // Rename method to avoid conflict with (VB) keyword - It is consistent with Microsoft's HttpListener
+ void Stop();
+#pragma warning restore CA1716
+
+ ///
+ /// Adds the prefix.
+ ///
+ /// The URL prefix.
+ void AddPrefix(string urlPrefix);
+
+ ///
+ /// Gets the HTTP context asynchronous.
+ ///
+ /// The cancellation token.
+ ///
+ /// A task that represents the time delay for the HTTP Context.
+ ///
+ Task GetContextAsync(CancellationToken cancellationToken);
+ }
+}
diff --git a/Vendor/EmbedIO-3.5.2/IHttpMessage.cs b/Vendor/EmbedIO-3.5.2/IHttpMessage.cs
new file mode 100644
index 0000000..61a5dde
--- /dev/null
+++ b/Vendor/EmbedIO-3.5.2/IHttpMessage.cs
@@ -0,0 +1,26 @@
+using System;
+
+namespace EmbedIO
+{
+ ///
+ /// Represents a HTTP request or response.
+ ///
+ public interface IHttpMessage
+ {
+ ///
+ /// Gets the cookies.
+ ///
+ ///
+ /// The cookies.
+ ///
+ ICookieCollection Cookies { get; }
+
+ ///
+ /// Gets or sets the protocol version.
+ ///
+ ///
+ /// The protocol version.
+ ///
+ Version ProtocolVersion { get; }
+ }
+}
\ No newline at end of file
diff --git a/Vendor/EmbedIO-3.5.2/IHttpRequest.cs b/Vendor/EmbedIO-3.5.2/IHttpRequest.cs
new file mode 100644
index 0000000..c4d6097
--- /dev/null
+++ b/Vendor/EmbedIO-3.5.2/IHttpRequest.cs
@@ -0,0 +1,115 @@
+using System;
+using System.Collections.Specialized;
+using System.IO;
+using System.Net;
+using System.Text;
+
+namespace EmbedIO
+{
+ ///
+ ///
+ /// Interface to create a HTTP Request.
+ ///
+ public interface IHttpRequest : IHttpMessage
+ {
+ ///
+ /// Gets the request headers.
+ ///
+ NameValueCollection Headers { get; }
+
+ ///
+ /// Gets a value indicating whether [keep alive].
+ ///
+ bool KeepAlive { get; }
+
+ ///
+ /// Gets the raw URL.
+ ///
+ string RawUrl { get; }
+
+ ///
+ /// Gets the query string.
+ ///
+ NameValueCollection QueryString { get; }
+
+ ///
+ /// Gets the HTTP method.
+ ///
+ string HttpMethod { get; }
+
+ ///
+ /// Gets a constant representing the HTTP method of the request.
+ ///
+ HttpVerbs HttpVerb { get; }
+
+ ///
+ /// Gets the URL.
+ ///
+ Uri Url { get; }
+
+ ///
+ /// Gets a value indicating whether this instance has entity body.
+ ///
+ bool HasEntityBody { get; }
+
+ ///
+ /// Gets the input stream.
+ ///
+ Stream InputStream { get; }
+
+ ///
+ /// Gets the content encoding.
+ ///
+ Encoding ContentEncoding { get; }
+
+ ///
+ /// Gets the remote end point.
+ ///
+ IPEndPoint RemoteEndPoint { get; }
+
+ ///
+ /// Gets a value indicating whether this instance is local.
+ ///
+ bool IsLocal { get; }
+
+ ///
+ /// Gets a value indicating whether this request has been received over a SSL connection.
+ ///
+ bool IsSecureConnection { get; }
+
+ ///
+ /// Gets the user agent.
+ ///
+ string UserAgent { get; }
+
+ ///
+ /// Gets a value indicating whether this instance is web socket request.
+ ///
+ bool IsWebSocketRequest { get; }
+
+ ///
+ /// Gets the local end point.
+ ///
+ IPEndPoint LocalEndPoint { get; }
+
+ ///
+ /// Gets the type of the content.
+ ///
+ string? ContentType { get; }
+
+ ///
+ /// Gets the content length.
+ ///
+ long ContentLength64 { get; }
+
+ ///
+ /// Gets a value indicating whether this instance is authenticated.
+ ///
+ bool IsAuthenticated { get; }
+
+ ///
+ /// Gets the URL referrer.
+ ///
+ Uri? UrlReferrer { get; }
+ }
+}
\ No newline at end of file
diff --git a/Vendor/EmbedIO-3.5.2/IHttpResponse.cs b/Vendor/EmbedIO-3.5.2/IHttpResponse.cs
new file mode 100644
index 0000000..48d8b21
--- /dev/null
+++ b/Vendor/EmbedIO-3.5.2/IHttpResponse.cs
@@ -0,0 +1,69 @@
+using System.IO;
+using System.Net;
+using System.Text;
+
+namespace EmbedIO
+{
+ ///
+ ///
+ /// Interface to create a HTTP Response.
+ ///
+ public interface IHttpResponse : IHttpMessage
+ {
+ ///
+ /// Gets the response headers.
+ ///
+ WebHeaderCollection Headers { get; }
+
+ ///
+ /// Gets or sets the status code.
+ ///
+ int StatusCode { get; set; }
+
+ ///
+ /// Gets or sets the content length.
+ ///
+ long ContentLength64 { get; set; }
+
+ ///
+ /// Gets or sets the type of the content.
+ ///
+ string ContentType { get; set; }
+
+ ///
+ /// Gets the output stream.
+ ///
+ Stream OutputStream { get; }
+
+ ///
+ /// Gets or sets the content encoding.
+ ///
+ Encoding? ContentEncoding { get; set; }
+
+ ///
+ /// Gets or sets a value indicating whether [keep alive].
+ ///
+ bool KeepAlive { get; set; }
+
+ ///
+ /// Gets or sets a value indicating whether the response uses chunked transfer encoding.
+ ///
+ bool SendChunked { get; set; }
+
+ ///
+ /// Gets or sets a text description of the HTTP status code.
+ ///
+ string StatusDescription { get; set; }
+
+ ///
+ /// Sets the cookie.
+ ///
+ /// The session cookie.
+ void SetCookie(Cookie cookie);
+
+ ///
+ /// Closes this instance and dispose the resources.
+ ///
+ void Close();
+ }
+}
\ No newline at end of file
diff --git a/Vendor/EmbedIO-3.5.2/IMimeTypeCustomizer.cs b/Vendor/EmbedIO-3.5.2/IMimeTypeCustomizer.cs
new file mode 100644
index 0000000..ff9c70c
--- /dev/null
+++ b/Vendor/EmbedIO-3.5.2/IMimeTypeCustomizer.cs
@@ -0,0 +1,45 @@
+using System;
+
+namespace EmbedIO
+{
+ ///
+ /// Represents an object that can set information about specific MIME types and media ranges,
+ /// to be later retrieved via an interface.
+ ///
+ ///
+ public interface IMimeTypeCustomizer : IMimeTypeProvider
+ {
+ ///
+ /// Adds a custom association between a file extension and a MIME type.
+ ///
+ /// The file extension to associate to .
+ /// The MIME type to associate to .
+ /// The object implementing
+ /// has its configuration locked.
+ ///
+ /// is .
+ /// - or -
+ /// is .
+ ///
+ ///
+ /// is the empty string.
+ /// - or -
+ /// is not a valid MIME type.
+ ///
+ void AddCustomMimeType(string extension, string mimeType);
+
+ ///
+ /// Indicates whether to prefer compression when negotiating content encoding
+ /// for a response with the specified content type, or whose content type is in
+ /// the specified media range.
+ ///
+ /// The MIME type or media range.
+ /// to prefer compression;
+ /// otherwise, .
+ /// The object implementing
+ /// has its configuration locked.
+ /// is .
+ /// is not a valid MIME type or media range.
+ void PreferCompression(string mimeType, bool preferCompression);
+ }
+}
\ No newline at end of file
diff --git a/Vendor/EmbedIO-3.5.2/IMimeTypeProvider.cs b/Vendor/EmbedIO-3.5.2/IMimeTypeProvider.cs
new file mode 100644
index 0000000..6d9458d
--- /dev/null
+++ b/Vendor/EmbedIO-3.5.2/IMimeTypeProvider.cs
@@ -0,0 +1,31 @@
+using System;
+
+namespace EmbedIO
+{
+ ///
+ /// Represents an object that contains information on specific MIME types and media ranges.
+ ///
+ public interface IMimeTypeProvider
+ {
+ ///
+ /// Gets the MIME type associated to a file extension.
+ ///
+ /// The file extension for which a corresponding MIME type is wanted.
+ /// The MIME type corresponding to , if one is found;
+ /// otherwise, .
+ /// is .
+ string GetMimeType(string extension);
+
+ ///
+ /// Attempts to determine whether compression should be preferred
+ /// when negotiating content encoding for a response with the specified content type.
+ ///
+ /// The MIME type to check.
+ /// When this method returns ,
+ /// a value indicating whether compression should be preferred.
+ /// This parameter is passed uninitialized.
+ /// if a value is found for ;
+ /// otherwise, .
+ bool TryDetermineCompression(string mimeType, out bool preferCompression);
+ }
+}
\ No newline at end of file
diff --git a/Vendor/EmbedIO-3.5.2/IWebModule.cs b/Vendor/EmbedIO-3.5.2/IWebModule.cs
new file mode 100644
index 0000000..594f101
--- /dev/null
+++ b/Vendor/EmbedIO-3.5.2/IWebModule.cs
@@ -0,0 +1,81 @@
+using System.Threading;
+using System.Threading.Tasks;
+using EmbedIO.Routing;
+
+namespace EmbedIO
+{
+ ///
+ /// Represents a module.
+ ///
+ public interface IWebModule
+ {
+ ///
+ /// Gets the base route of a module.
+ ///
+ ///
+ /// The base route.
+ ///
+ ///
+ /// A base route is either "/" (the root path),
+ /// or a prefix starting and ending with a '/' character.
+ ///
+ string BaseRoute { get; }
+
+ ///
+ /// Gets a value indicating whether processing of a request should stop
+ /// after a module has handled it.
+ ///
+ ///
+ /// If this property is , a HTTP context's
+ /// method will be automatically called
+ /// immediately after after the returned by
+ /// is completed. This will prevent
+ /// the context from being passed further along to other modules.
+ ///
+ ///
+ ///
+ bool IsFinalHandler { get; }
+
+ ///
+ /// Gets or sets a callback that is called every time an unhandled exception
+ /// occurs during the processing of a request.
+ /// If this property is (the default),
+ /// the exception will be handled by the web server, or by the containing
+ /// .
+ ///
+ ///
+ ExceptionHandlerCallback? OnUnhandledException { get; set; }
+
+ ///
+ /// Gets or sets a callback that is called every time a HTTP exception
+ /// is thrown during the processing of a request.
+ /// If this property is (the default),
+ /// the exception will be handled by the web server, or by the containing
+ /// .
+ ///
+ ///
+ HttpExceptionHandlerCallback? OnHttpException { get; set; }
+
+ ///
+ /// Signals a module that the web server is starting.
+ ///
+ /// A used to stop the web server.
+ void Start(CancellationToken cancellationToken);
+
+ ///
+ /// Matches the specified URL path against a module's ,
+ /// extracting values for the route's parameters and a sub-path.
+ ///
+ /// The URL path to match.
+ /// If the match is successful, a object;
+ /// otherwise, .
+ RouteMatch MatchUrlPath(string urlPath);
+
+ ///
+ /// Handles a request from a client.
+ ///
+ /// The context of the request being handled.
+ /// A representing the ongoing operation.
+ Task HandleRequestAsync(IHttpContext context);
+ }
+}
\ No newline at end of file
diff --git a/Vendor/EmbedIO-3.5.2/IWebModuleContainer.cs b/Vendor/EmbedIO-3.5.2/IWebModuleContainer.cs
new file mode 100644
index 0000000..9e84235
--- /dev/null
+++ b/Vendor/EmbedIO-3.5.2/IWebModuleContainer.cs
@@ -0,0 +1,19 @@
+using System;
+using EmbedIO.Utilities;
+
+namespace EmbedIO
+{
+ ///
+ /// Represents an object that contains a collection of interfaces.
+ ///
+ public interface IWebModuleContainer : IDisposable
+ {
+ ///
+ /// Gets the modules.
+ ///
+ ///
+ /// The modules.
+ ///
+ IComponentCollection Modules { get; }
+ }
+}
diff --git a/Vendor/EmbedIO-3.5.2/IWebServer.cs b/Vendor/EmbedIO-3.5.2/IWebServer.cs
new file mode 100644
index 0000000..6bf0288
--- /dev/null
+++ b/Vendor/EmbedIO-3.5.2/IWebServer.cs
@@ -0,0 +1,68 @@
+using System;
+using System.Threading;
+using System.Threading.Tasks;
+using EmbedIO.Sessions;
+
+namespace EmbedIO
+{
+ ///
+ /// Represents a web server.
+ /// The basic usage of a web server is as follows:
+ ///
+ /// - add modules to the Modules collection;
+ /// - set a if needed;
+ /// - call to respond to incoming requests.
+ ///
+ ///
+ public interface IWebServer : IWebModuleContainer, IMimeTypeCustomizer
+ {
+ ///
+ /// Occurs when the property changes.
+ ///
+ event WebServerStateChangedEventHandler StateChanged;
+
+ ///
+ /// Gets or sets a callback that is called every time an unhandled exception
+ /// occurs during the processing of a request.
+ /// This property can never be .
+ /// If it is still
+ ///
+ ///
+ ExceptionHandlerCallback OnUnhandledException { get; set; }
+
+ ///
+ /// Gets or sets a callback that is called every time a HTTP exception
+ /// is thrown during the processing of a request.
+ /// This property can never be .
+ ///
+ ///
+ HttpExceptionHandlerCallback OnHttpException { get; set; }
+
+ ///
+ /// Gets or sets the registered session ID manager, if any.
+ /// A session ID manager is an implementation of .
+ /// Note that this property can only be set before starting the web server.
+ ///
+ ///
+ /// The session manager, or if no session manager is present.
+ ///
+ /// This property is being set and the web server has already been started.
+ ISessionManager? SessionManager { get; set; }
+
+ ///
+ /// Gets the state of the web server.
+ ///
+ /// The state.
+ ///
+ WebServerState State { get; }
+
+ ///
+ /// Starts the listener and the registered modules.
+ ///
+ /// The cancellation token; when cancelled, the server cancels all pending requests and stops.
+ ///
+ /// Returns the task that the HTTP listener is running inside of, so that it can be waited upon after it's been canceled.
+ ///
+ Task RunAsync(CancellationToken cancellationToken = default);
+ }
+}
\ No newline at end of file
diff --git a/Vendor/EmbedIO-3.5.2/Internal/BufferingResponseStream.cs b/Vendor/EmbedIO-3.5.2/Internal/BufferingResponseStream.cs
new file mode 100644
index 0000000..3323c6a
--- /dev/null
+++ b/Vendor/EmbedIO-3.5.2/Internal/BufferingResponseStream.cs
@@ -0,0 +1,87 @@
+using System;
+using System.IO;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace EmbedIO.Internal
+{
+ // Wraps a response's output stream, buffering all data
+ // in a MemoryStream.
+ // When disposed, sets the response's ContentLength and copies all data
+ // to the output stream.
+ internal class BufferingResponseStream : Stream
+ {
+ private readonly IHttpResponse _response;
+ private readonly MemoryStream _buffer;
+
+ public BufferingResponseStream(IHttpResponse response)
+ {
+ _response = response;
+ _buffer = new MemoryStream();
+ }
+
+ public override bool CanRead => false;
+
+ public override bool CanSeek => false;
+
+ public override bool CanWrite => true;
+
+ public override long Length => _buffer.Length;
+
+ public override long Position
+ {
+ get => _buffer.Position;
+ set => throw SeekingNotSupported();
+ }
+
+ public override void Flush() => _buffer.Flush();
+
+ public override Task FlushAsync(CancellationToken cancellationToken) => _buffer.FlushAsync(cancellationToken);
+
+ public override int Read(byte[] buffer, int offset, int count) => throw ReadingNotSupported();
+
+ public override int ReadByte() => throw ReadingNotSupported();
+
+ public override IAsyncResult BeginRead(byte[] buffer, int offset, int count, AsyncCallback callback, object state)
+ => throw ReadingNotSupported();
+
+ public override int EndRead(IAsyncResult asyncResult) => throw ReadingNotSupported();
+
+ public override Task ReadAsync(byte[] buffer, int offset, int count, CancellationToken cancellationToken) => throw ReadingNotSupported();
+
+ public override Task CopyToAsync(Stream destination, int bufferSize, CancellationToken cancellationToken)
+ => throw ReadingNotSupported();
+
+ public override long Seek(long offset, SeekOrigin origin) => throw SeekingNotSupported();
+
+ public override void SetLength(long value) => throw SeekingNotSupported();
+
+ public override void Write(byte[] buffer, int offset, int count) => _buffer.Write(buffer, offset, count);
+
+ public override void WriteByte(byte value) => _buffer.WriteByte(value);
+
+ public override IAsyncResult BeginWrite(byte[] buffer, int offset, int count, AsyncCallback callback, object state)
+ => _buffer.BeginWrite(buffer, offset, count, callback, state);
+
+ public override void EndWrite(IAsyncResult asyncResult) => _buffer.EndWrite(asyncResult);
+
+ public override Task WriteAsync(byte[] buffer, int offset, int count, CancellationToken cancellationToken)
+ => _buffer.WriteAsync(buffer, offset, count, cancellationToken);
+
+ protected override void Dispose(bool disposing)
+ {
+ _response.ContentLength64 = _buffer.Length;
+ _buffer.Position = 0;
+ _buffer.CopyTo(_response.OutputStream);
+
+ if (disposing)
+ {
+ _buffer.Dispose();
+ }
+ }
+
+ private static Exception ReadingNotSupported() => new NotSupportedException("This stream does not support reading.");
+
+ private static Exception SeekingNotSupported() => new NotSupportedException("This stream does not support seeking.");
+ }
+}
\ No newline at end of file
diff --git a/Vendor/EmbedIO-3.5.2/Internal/CompressionStream.cs b/Vendor/EmbedIO-3.5.2/Internal/CompressionStream.cs
new file mode 100644
index 0000000..b777566
--- /dev/null
+++ b/Vendor/EmbedIO-3.5.2/Internal/CompressionStream.cs
@@ -0,0 +1,121 @@
+using System;
+using System.IO;
+using System.IO.Compression;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace EmbedIO.Internal
+{
+ internal class CompressionStream : Stream
+ {
+ private readonly Stream _target;
+ private readonly bool _leaveOpen;
+
+ public CompressionStream(Stream target, CompressionMethod compressionMethod)
+ {
+ switch (compressionMethod)
+ {
+ case CompressionMethod.Deflate:
+ _target = new DeflateStream(target, CompressionMode.Compress, true);
+ _leaveOpen = false;
+ break;
+ case CompressionMethod.Gzip:
+ _target = new GZipStream(target, CompressionMode.Compress, true);
+ _leaveOpen = false;
+ break;
+ default:
+ _target = target;
+ _leaveOpen = true;
+ break;
+ }
+
+ UncompressedLength = 0;
+ }
+
+ public long UncompressedLength { get; private set; }
+
+ public override bool CanRead => false;
+
+ public override bool CanSeek => false;
+
+ public override bool CanWrite => true;
+
+ public override long Length => throw SeekingNotSupported();
+
+ public override long Position
+ {
+ get => throw SeekingNotSupported();
+ set => throw SeekingNotSupported();
+ }
+
+ public override void Flush() => _target.Flush();
+
+ public override Task FlushAsync(CancellationToken cancellationToken) => _target.FlushAsync(cancellationToken);
+
+ public override int Read(byte[] buffer, int offset, int count) => throw ReadingNotSupported();
+
+ public override int ReadByte() => throw ReadingNotSupported();
+
+ public override IAsyncResult BeginRead(byte[] buffer, int offset, int count, AsyncCallback callback, object state)
+ => throw ReadingNotSupported();
+
+ public override int EndRead(IAsyncResult asyncResult) => throw ReadingNotSupported();
+
+ public override Task ReadAsync(byte[] buffer, int offset, int count, CancellationToken cancellationToken) => throw ReadingNotSupported();
+
+ public override Task CopyToAsync(Stream destination, int bufferSize, CancellationToken cancellationToken)
+ => throw ReadingNotSupported();
+
+ public override long Seek(long offset, SeekOrigin origin) => throw SeekingNotSupported();
+
+ public override void SetLength(long value) => throw SeekingNotSupported();
+
+ public override void Write(byte[] buffer, int offset, int count)
+ {
+ _target.Write(buffer, offset, count);
+ UncompressedLength += count;
+ }
+
+ public override void WriteByte(byte value)
+ {
+ _target.WriteByte(value);
+ UncompressedLength++;
+ }
+
+ public override IAsyncResult BeginWrite(byte[] buffer, int offset, int count, AsyncCallback callback, object state)
+ => _target.BeginWrite(
+ buffer,
+ offset,
+ count,
+ ar => {
+ UncompressedLength += count;
+ callback(ar);
+ },
+ state);
+
+ public override void EndWrite(IAsyncResult asyncResult)
+ {
+ _target.EndWrite(asyncResult);
+ }
+
+ public override async Task WriteAsync(byte[] buffer, int offset, int count, CancellationToken cancellationToken)
+ {
+ await _target.WriteAsync(buffer, offset, count, cancellationToken).ConfigureAwait(false);
+ UncompressedLength += count;
+ }
+
+ protected override void Dispose(bool disposing)
+ {
+ if (disposing && !_leaveOpen)
+ {
+ _target.Dispose();
+ }
+
+ base.Dispose(disposing);
+ }
+
+ private static Exception ReadingNotSupported() => new NotSupportedException("This stream does not support reading.");
+
+ private static Exception SeekingNotSupported() => new NotSupportedException("This stream does not support seeking.");
+ }
+}
\ No newline at end of file
diff --git a/Vendor/EmbedIO-3.5.2/Internal/CompressionUtility.cs b/Vendor/EmbedIO-3.5.2/Internal/CompressionUtility.cs
new file mode 100644
index 0000000..58fe4ab
--- /dev/null
+++ b/Vendor/EmbedIO-3.5.2/Internal/CompressionUtility.cs
@@ -0,0 +1,82 @@
+using System.IO;
+using System.IO.Compression;
+
+namespace EmbedIO.Internal
+{
+ internal static class CompressionUtility
+ {
+ public static byte[]? ConvertCompression(byte[] source, CompressionMethod sourceMethod, CompressionMethod targetMethod)
+ {
+ if (source == null)
+ return null;
+
+ if (sourceMethod == targetMethod)
+ return source;
+
+ switch (sourceMethod)
+ {
+ case CompressionMethod.Deflate:
+ using (var sourceStream = new MemoryStream(source, false))
+ {
+ using var decompressionStream = new DeflateStream(sourceStream, CompressionMode.Decompress, true);
+ using var targetStream = new MemoryStream();
+ if (targetMethod == CompressionMethod.Gzip)
+ {
+ using var compressionStream = new GZipStream(targetStream, CompressionMode.Compress, true);
+ decompressionStream.CopyTo(compressionStream);
+ }
+ else
+ {
+ decompressionStream.CopyTo(targetStream);
+ }
+
+ return targetStream.ToArray();
+ }
+
+ case CompressionMethod.Gzip:
+ using (var sourceStream = new MemoryStream(source, false))
+ {
+ using var decompressionStream = new GZipStream(sourceStream, CompressionMode.Decompress, true);
+ using var targetStream = new MemoryStream();
+ if (targetMethod == CompressionMethod.Deflate)
+ {
+ using var compressionStream = new DeflateStream(targetStream, CompressionMode.Compress, true);
+ decompressionStream.CopyToAsync(compressionStream);
+ }
+ else
+ {
+ decompressionStream.CopyTo(targetStream);
+ }
+
+ return targetStream.ToArray();
+ }
+
+ default:
+ using (var sourceStream = new MemoryStream(source, false))
+ {
+ using var targetStream = new MemoryStream();
+ switch (targetMethod)
+ {
+ case CompressionMethod.Deflate:
+ using (var compressionStream = new DeflateStream(targetStream, CompressionMode.Compress, true))
+ sourceStream.CopyTo(compressionStream);
+
+ break;
+
+ case CompressionMethod.Gzip:
+ using (var compressionStream = new GZipStream(targetStream, CompressionMode.Compress, true))
+ sourceStream.CopyTo(compressionStream);
+
+ break;
+
+ default:
+ // Just in case. Consider all other values as None.
+ return source;
+ }
+
+ return targetStream.ToArray();
+ }
+ }
+ }
+ }
+}
\ No newline at end of file
diff --git a/Vendor/EmbedIO-3.5.2/Internal/DummyWebModuleContainer.cs b/Vendor/EmbedIO-3.5.2/Internal/DummyWebModuleContainer.cs
new file mode 100644
index 0000000..1ee1079
--- /dev/null
+++ b/Vendor/EmbedIO-3.5.2/Internal/DummyWebModuleContainer.cs
@@ -0,0 +1,27 @@
+using System.Collections.Concurrent;
+using System.Runtime.CompilerServices;
+using EmbedIO.Utilities;
+using Swan;
+
+namespace EmbedIO.Internal
+{
+ internal sealed class DummyWebModuleContainer : IWebModuleContainer
+ {
+ public static readonly IWebModuleContainer Instance = new DummyWebModuleContainer();
+
+ private DummyWebModuleContainer()
+ {
+ }
+
+ public IComponentCollection Modules => throw UnexpectedCall();
+
+ public ConcurrentDictionary SharedItems => throw UnexpectedCall();
+
+ public void Dispose()
+ {
+ }
+
+ private InternalErrorException UnexpectedCall([CallerMemberName] string member = "")
+ => SelfCheck.Failure($"Unexpected call to {nameof(DummyWebModuleContainer)}.{member}.");
+ }
+}
\ No newline at end of file
diff --git a/Vendor/EmbedIO-3.5.2/Internal/LockableNameValueCollection.cs b/Vendor/EmbedIO-3.5.2/Internal/LockableNameValueCollection.cs
new file mode 100644
index 0000000..75853f7
--- /dev/null
+++ b/Vendor/EmbedIO-3.5.2/Internal/LockableNameValueCollection.cs
@@ -0,0 +1,9 @@
+using System.Collections.Specialized;
+
+namespace EmbedIO.Internal
+{
+ internal sealed class LockableNameValueCollection : NameValueCollection
+ {
+ public void MakeReadOnly() => IsReadOnly = true;
+ }
+}
\ No newline at end of file
diff --git a/Vendor/EmbedIO-3.5.2/Internal/MimeTypeCustomizer.cs b/Vendor/EmbedIO-3.5.2/Internal/MimeTypeCustomizer.cs
new file mode 100644
index 0000000..1d39224
--- /dev/null
+++ b/Vendor/EmbedIO-3.5.2/Internal/MimeTypeCustomizer.cs
@@ -0,0 +1,63 @@
+using System.Collections.Generic;
+using EmbedIO.Utilities;
+using Swan.Configuration;
+
+namespace EmbedIO.Internal
+{
+ internal sealed class MimeTypeCustomizer : ConfiguredObject, IMimeTypeCustomizer
+ {
+ private readonly Dictionary _customMimeTypes = new Dictionary();
+ private readonly Dictionary<(string, string), bool> _data = new Dictionary<(string, string), bool>();
+
+ private bool? _defaultPreferCompression;
+
+ public string GetMimeType(string extension)
+ {
+ _customMimeTypes.TryGetValue(Validate.NotNull(nameof(extension), extension), out var result);
+ return result;
+ }
+
+ public bool TryDetermineCompression(string mimeType, out bool preferCompression)
+ {
+ var (type, subtype) = MimeType.UnsafeSplit(
+ Validate.MimeType(nameof(mimeType), mimeType, false));
+
+ if (_data.TryGetValue((type, subtype), out preferCompression))
+ return true;
+
+ if (_data.TryGetValue((type, "*"), out preferCompression))
+ return true;
+
+ if (!_defaultPreferCompression.HasValue)
+ return false;
+
+ preferCompression = _defaultPreferCompression.Value;
+ return true;
+ }
+
+ public void AddCustomMimeType(string extension, string mimeType)
+ {
+ EnsureConfigurationNotLocked();
+ _customMimeTypes[Validate.NotNullOrEmpty(nameof(extension), extension)]
+ = Validate.MimeType(nameof(mimeType), mimeType, false);
+ }
+
+ public void PreferCompression(string mimeType, bool preferCompression)
+ {
+ EnsureConfigurationNotLocked();
+ var (type, subtype) = MimeType.UnsafeSplit(
+ Validate.MimeType(nameof(mimeType), mimeType, true));
+
+ if (type == "*")
+ {
+ _defaultPreferCompression = preferCompression;
+ }
+ else
+ {
+ _data[(type, subtype)] = preferCompression;
+ }
+ }
+
+ public void Lock() => LockConfiguration();
+ }
+}
\ No newline at end of file
diff --git a/Vendor/EmbedIO-3.5.2/Internal/RequestHandlerPassThroughException.cs b/Vendor/EmbedIO-3.5.2/Internal/RequestHandlerPassThroughException.cs
new file mode 100644
index 0000000..c7be352
--- /dev/null
+++ b/Vendor/EmbedIO-3.5.2/Internal/RequestHandlerPassThroughException.cs
@@ -0,0 +1,15 @@
+using System;
+
+namespace EmbedIO.Internal
+{
+// This exception is only created and handled internally,
+// so it doesn't need all the standard the bells and whistles.
+#pragma warning disable CA1032 // Add standard exception constructors
+#pragma warning disable CA1064 // Exceptions should be public
+
+ internal class RequestHandlerPassThroughException : Exception
+ {
+ }
+#pragma warning restore CA1032
+#pragma warning restore CA1064
+}
\ No newline at end of file
diff --git a/Vendor/EmbedIO-3.5.2/Internal/TimeKeeper.cs b/Vendor/EmbedIO-3.5.2/Internal/TimeKeeper.cs
new file mode 100644
index 0000000..03e9051
--- /dev/null
+++ b/Vendor/EmbedIO-3.5.2/Internal/TimeKeeper.cs
@@ -0,0 +1,27 @@
+using System.Diagnostics;
+
+namespace EmbedIO.Internal
+{
+ ///
+ /// Represents a wrapper around Stopwatch.
+ ///
+ public sealed class TimeKeeper
+ {
+ private static readonly Stopwatch Stopwatch = Stopwatch.StartNew();
+
+ private readonly long _start;
+
+ ///
+ /// Initializes a new instance of the class.
+ ///
+ public TimeKeeper()
+ {
+ _start = Stopwatch.ElapsedMilliseconds;
+ }
+
+ ///
+ /// Gets the elapsed time since the class was initialized.
+ ///
+ public long ElapsedTime => Stopwatch.ElapsedMilliseconds - _start;
+ }
+}
\ No newline at end of file
diff --git a/Vendor/EmbedIO-3.5.2/Internal/UriUtility.cs b/Vendor/EmbedIO-3.5.2/Internal/UriUtility.cs
new file mode 100644
index 0000000..585ba42
--- /dev/null
+++ b/Vendor/EmbedIO-3.5.2/Internal/UriUtility.cs
@@ -0,0 +1,47 @@
+using System;
+
+namespace EmbedIO.Internal
+{
+ internal static class UriUtility
+ {
+ public static Uri StringToUri(string str)
+ {
+ _ = Uri.TryCreate(str, CanBeAbsoluteUrl(str) ? UriKind.Absolute : UriKind.Relative, out var result);
+ return result;
+ }
+
+ public static Uri? StringToAbsoluteUri(string str)
+ {
+ if (!CanBeAbsoluteUrl(str))
+ {
+ return null;
+ }
+
+ _ = Uri.TryCreate(str, UriKind.Absolute, out var result);
+ return result;
+ }
+
+ // Returns true if string starts with "http:", "https:", "ws:", or "wss:"
+ private static bool CanBeAbsoluteUrl(string str)
+ => !string.IsNullOrEmpty(str)
+ && str[0] switch {
+ 'h' => str.Length >= 5
+ && str[1] == 't'
+ && str[2] == 't'
+ && str[3] == 'p'
+ && str[4] switch {
+ ':' => true,
+ 's' => str.Length >= 6 && str[5] == ':',
+ _ => false
+ },
+ 'w' => str.Length >= 3
+ && str[1] == 's'
+ && str[2] switch {
+ ':' => true,
+ 's' => str.Length >= 4 && str[3] == ':',
+ _ => false
+ },
+ _ => false
+ };
+ }
+}
\ No newline at end of file
diff --git a/Vendor/EmbedIO-3.5.2/Internal/WebModuleCollection.cs b/Vendor/EmbedIO-3.5.2/Internal/WebModuleCollection.cs
new file mode 100644
index 0000000..093fed3
--- /dev/null
+++ b/Vendor/EmbedIO-3.5.2/Internal/WebModuleCollection.cs
@@ -0,0 +1,46 @@
+using System.Threading;
+using System.Threading.Tasks;
+using EmbedIO.Utilities;
+using Swan.Logging;
+
+namespace EmbedIO.Internal
+{
+ internal sealed class WebModuleCollection : DisposableComponentCollection
+ {
+ private readonly string _logSource;
+
+ internal WebModuleCollection(string logSource)
+ {
+ _logSource = logSource;
+ }
+
+ internal void StartAll(CancellationToken cancellationToken)
+ {
+ foreach (var (name, module) in WithSafeNames)
+ {
+ $"Starting module {name}...".Debug(_logSource);
+ module.Start(cancellationToken);
+ }
+ }
+
+ internal async Task DispatchRequestAsync(IHttpContext context)
+ {
+ if (context.IsHandled)
+ return;
+
+ var requestedPath = context.RequestedPath;
+ foreach (var (name, module) in WithSafeNames)
+ {
+ var routeMatch = module.MatchUrlPath(requestedPath);
+ if (routeMatch == null)
+ continue;
+
+ $"[{context.Id}] Processing with {name}.".Debug(_logSource);
+ context.GetImplementation().Route = routeMatch;
+ await module.HandleRequestAsync(context).ConfigureAwait(false);
+ if (context.IsHandled)
+ break;
+ }
+ }
+ }
+}
\ No newline at end of file
diff --git a/Vendor/EmbedIO-3.5.2/MimeType.Associations.cs b/Vendor/EmbedIO-3.5.2/MimeType.Associations.cs
new file mode 100644
index 0000000..b78133f
--- /dev/null
+++ b/Vendor/EmbedIO-3.5.2/MimeType.Associations.cs
@@ -0,0 +1,648 @@
+using System;
+using System.Collections.Generic;
+
+namespace EmbedIO
+{
+ partial class MimeType
+ {
+ // -------------------------------------------------------------------------------------------------
+ //
+ // IMPORTANT NOTE TO CONTRIBUTORS
+ // ==============================
+ //
+ // When you update the MIME type list, remember to:
+ //
+ // * update the date in XML docs below;
+ //
+ // * check the LICENSE file to see if copyright year and/or license conditions have changed;
+ //
+ // * if the URL for the LICENSE file has changed, update EmbedIO's LICENSE file too.
+ //
+ // -------------------------------------------------------------------------------------------------
+
+ ///
+ /// Associates file extensions to MIME types.
+ ///
+ ///
+ /// The list of MIME types has been copied from
+ /// Samuel Neff's MIME Type Map
+ /// on April 26th, 2019.
+ /// Copyright (c) 2014 Samuel Neff. Redistributed under MIT license.
+ ///
+ public static IReadOnlyDictionary Associations { get; } = new Dictionary(StringComparer.OrdinalIgnoreCase)
+ {
+ {".323", "text/h323"},
+ {".3g2", "video/3gpp2"},
+ {".3gp", "video/3gpp"},
+ {".3gp2", "video/3gpp2"},
+ {".3gpp", "video/3gpp"},
+ {".7z", "application/x-7z-compressed"},
+ {".aa", "audio/audible"},
+ {".AAC", "audio/aac"},
+ {".aaf", "application/octet-stream"},
+ {".aax", "audio/vnd.audible.aax"},
+ {".ac3", "audio/ac3"},
+ {".aca", "application/octet-stream"},
+ {".accda", "application/msaccess.addin"},
+ {".accdb", "application/msaccess"},
+ {".accdc", "application/msaccess.cab"},
+ {".accde", "application/msaccess"},
+ {".accdr", "application/msaccess.runtime"},
+ {".accdt", "application/msaccess"},
+ {".accdw", "application/msaccess.webapplication"},
+ {".accft", "application/msaccess.ftemplate"},
+ {".acx", "application/internet-property-stream"},
+ {".AddIn", "text/xml"},
+ {".ade", "application/msaccess"},
+ {".adobebridge", "application/x-bridge-url"},
+ {".adp", "application/msaccess"},
+ {".ADT", "audio/vnd.dlna.adts"},
+ {".ADTS", "audio/aac"},
+ {".afm", "application/octet-stream"},
+ {".ai", "application/postscript"},
+ {".aif", "audio/aiff"},
+ {".aifc", "audio/aiff"},
+ {".aiff", "audio/aiff"},
+ {".air", "application/vnd.adobe.air-application-installer-package+zip"},
+ {".amc", "application/mpeg"},
+ {".anx", "application/annodex"},
+ {".apk", "application/vnd.android.package-archive" },
+ {".application", "application/x-ms-application"},
+ {".art", "image/x-jg"},
+ {".asa", "application/xml"},
+ {".asax", "application/xml"},
+ {".ascx", "application/xml"},
+ {".asd", "application/octet-stream"},
+ {".asf", "video/x-ms-asf"},
+ {".ashx", "application/xml"},
+ {".asi", "application/octet-stream"},
+ {".asm", "text/plain"},
+ {".asmx", "application/xml"},
+ {".aspx", "application/xml"},
+ {".asr", "video/x-ms-asf"},
+ {".asx", "video/x-ms-asf"},
+ {".atom", "application/atom+xml"},
+ {".au", "audio/basic"},
+ {".avi", "video/x-msvideo"},
+ {".axa", "audio/annodex"},
+ {".axs", "application/olescript"},
+ {".axv", "video/annodex"},
+ {".bas", "text/plain"},
+ {".bcpio", "application/x-bcpio"},
+ {".bin", "application/octet-stream"},
+ {".bmp", "image/bmp"},
+ {".c", "text/plain"},
+ {".cab", "application/octet-stream"},
+ {".caf", "audio/x-caf"},
+ {".calx", "application/vnd.ms-office.calx"},
+ {".cat", "application/vnd.ms-pki.seccat"},
+ {".cc", "text/plain"},
+ {".cd", "text/plain"},
+ {".cdda", "audio/aiff"},
+ {".cdf", "application/x-cdf"},
+ {".cer", "application/x-x509-ca-cert"},
+ {".cfg", "text/plain"},
+ {".chm", "application/octet-stream"},
+ {".class", "application/x-java-applet"},
+ {".clp", "application/x-msclip"},
+ {".cmd", "text/plain"},
+ {".cmx", "image/x-cmx"},
+ {".cnf", "text/plain"},
+ {".cod", "image/cis-cod"},
+ {".config", "application/xml"},
+ {".contact", "text/x-ms-contact"},
+ {".coverage", "application/xml"},
+ {".cpio", "application/x-cpio"},
+ {".cpp", "text/plain"},
+ {".crd", "application/x-mscardfile"},
+ {".crl", "application/pkix-crl"},
+ {".crt", "application/x-x509-ca-cert"},
+ {".cs", "text/plain"},
+ {".csdproj", "text/plain"},
+ {".csh", "application/x-csh"},
+ {".csproj", "text/plain"},
+ {".css", "text/css"},
+ {".csv", "text/csv"},
+ {".cur", "application/octet-stream"},
+ {".cxx", "text/plain"},
+ {".dat", "application/octet-stream"},
+ {".datasource", "application/xml"},
+ {".dbproj", "text/plain"},
+ {".dcr", "application/x-director"},
+ {".def", "text/plain"},
+ {".deploy", "application/octet-stream"},
+ {".der", "application/x-x509-ca-cert"},
+ {".dgml", "application/xml"},
+ {".dib", "image/bmp"},
+ {".dif", "video/x-dv"},
+ {".dir", "application/x-director"},
+ {".disco", "text/xml"},
+ {".divx", "video/divx"},
+ {".dll", "application/x-msdownload"},
+ {".dll.config", "text/xml"},
+ {".dlm", "text/dlm"},
+ {".doc", "application/msword"},
+ {".docm", "application/vnd.ms-word.document.macroEnabled.12"},
+ {".docx", "application/vnd.openxmlformats-officedocument.wordprocessingml.document"},
+ {".dot", "application/msword"},
+ {".dotm", "application/vnd.ms-word.template.macroEnabled.12"},
+ {".dotx", "application/vnd.openxmlformats-officedocument.wordprocessingml.template"},
+ {".dsp", "application/octet-stream"},
+ {".dsw", "text/plain"},
+ {".dtd", "text/xml"},
+ {".dtsConfig", "text/xml"},
+ {".dv", "video/x-dv"},
+ {".dvi", "application/x-dvi"},
+ {".dwf", "drawing/x-dwf"},
+ {".dwg", "application/acad"},
+ {".dwp", "application/octet-stream"},
+ {".dxf", "application/x-dxf" },
+ {".dxr", "application/x-director"},
+ {".eml", "message/rfc822"},
+ {".emz", "application/octet-stream"},
+ {".eot", "application/vnd.ms-fontobject"},
+ {".eps", "application/postscript"},
+ {".es", "application/ecmascript"},
+ {".etl", "application/etl"},
+ {".etx", "text/x-setext"},
+ {".evy", "application/envoy"},
+ {".exe", "application/octet-stream"},
+ {".exe.config", "text/xml"},
+ {".fdf", "application/vnd.fdf"},
+ {".fif", "application/fractals"},
+ {".filters", "application/xml"},
+ {".fla", "application/octet-stream"},
+ {".flac", "audio/flac"},
+ {".flr", "x-world/x-vrml"},
+ {".flv", "video/x-flv"},
+ {".fsscript", "application/fsharp-script"},
+ {".fsx", "application/fsharp-script"},
+ {".generictest", "application/xml"},
+ {".gif", "image/gif"},
+ {".gpx", "application/gpx+xml"},
+ {".group", "text/x-ms-group"},
+ {".gsm", "audio/x-gsm"},
+ {".gtar", "application/x-gtar"},
+ {".gz", "application/x-gzip"},
+ {".h", "text/plain"},
+ {".hdf", "application/x-hdf"},
+ {".hdml", "text/x-hdml"},
+ {".hhc", "application/x-oleobject"},
+ {".hhk", "application/octet-stream"},
+ {".hhp", "application/octet-stream"},
+ {".hlp", "application/winhlp"},
+ {".hpp", "text/plain"},
+ {".hqx", "application/mac-binhex40"},
+ {".hta", "application/hta"},
+ {".htc", "text/x-component"},
+ {".htm", "text/html"},
+ {".html", "text/html"},
+ {".htt", "text/webviewhtml"},
+ {".hxa", "application/xml"},
+ {".hxc", "application/xml"},
+ {".hxd", "application/octet-stream"},
+ {".hxe", "application/xml"},
+ {".hxf", "application/xml"},
+ {".hxh", "application/octet-stream"},
+ {".hxi", "application/octet-stream"},
+ {".hxk", "application/xml"},
+ {".hxq", "application/octet-stream"},
+ {".hxr", "application/octet-stream"},
+ {".hxs", "application/octet-stream"},
+ {".hxt", "text/html"},
+ {".hxv", "application/xml"},
+ {".hxw", "application/octet-stream"},
+ {".hxx", "text/plain"},
+ {".i", "text/plain"},
+ {".ico", "image/x-icon"},
+ {".ics", "application/octet-stream"},
+ {".idl", "text/plain"},
+ {".ief", "image/ief"},
+ {".iii", "application/x-iphone"},
+ {".inc", "text/plain"},
+ {".inf", "application/octet-stream"},
+ {".ini", "text/plain"},
+ {".inl", "text/plain"},
+ {".ins", "application/x-internet-signup"},
+ {".ipa", "application/x-itunes-ipa"},
+ {".ipg", "application/x-itunes-ipg"},
+ {".ipproj", "text/plain"},
+ {".ipsw", "application/x-itunes-ipsw"},
+ {".iqy", "text/x-ms-iqy"},
+ {".isp", "application/x-internet-signup"},
+ {".ite", "application/x-itunes-ite"},
+ {".itlp", "application/x-itunes-itlp"},
+ {".itms", "application/x-itunes-itms"},
+ {".itpc", "application/x-itunes-itpc"},
+ {".IVF", "video/x-ivf"},
+ {".jar", "application/java-archive"},
+ {".java", "application/octet-stream"},
+ {".jck", "application/liquidmotion"},
+ {".jcz", "application/liquidmotion"},
+ {".jfif", "image/pjpeg"},
+ {".jnlp", "application/x-java-jnlp-file"},
+ {".jpb", "application/octet-stream"},
+ {".jpe", "image/jpeg"},
+ {".jpeg", "image/jpeg"},
+ {".jpg", "image/jpeg"},
+ {".js", "application/javascript"},
+ {".json", "application/json"},
+ {".jsx", "text/jscript"},
+ {".jsxbin", "text/plain"},
+ {".latex", "application/x-latex"},
+ {".library-ms", "application/windows-library+xml"},
+ {".lit", "application/x-ms-reader"},
+ {".loadtest", "application/xml"},
+ {".lpk", "application/octet-stream"},
+ {".lsf", "video/x-la-asf"},
+ {".lst", "text/plain"},
+ {".lsx", "video/x-la-asf"},
+ {".lzh", "application/octet-stream"},
+ {".m13", "application/x-msmediaview"},
+ {".m14", "application/x-msmediaview"},
+ {".m1v", "video/mpeg"},
+ {".m2t", "video/vnd.dlna.mpeg-tts"},
+ {".m2ts", "video/vnd.dlna.mpeg-tts"},
+ {".m2v", "video/mpeg"},
+ {".m3u", "audio/x-mpegurl"},
+ {".m3u8", "audio/x-mpegurl"},
+ {".m4a", "audio/m4a"},
+ {".m4b", "audio/m4b"},
+ {".m4p", "audio/m4p"},
+ {".m4r", "audio/x-m4r"},
+ {".m4v", "video/x-m4v"},
+ {".mac", "image/x-macpaint"},
+ {".mak", "text/plain"},
+ {".man", "application/x-troff-man"},
+ {".manifest", "application/x-ms-manifest"},
+ {".map", "text/plain"},
+ {".master", "application/xml"},
+ {".mbox", "application/mbox"},
+ {".mda", "application/msaccess"},
+ {".mdb", "application/x-msaccess"},
+ {".mde", "application/msaccess"},
+ {".mdp", "application/octet-stream"},
+ {".me", "application/x-troff-me"},
+ {".mfp", "application/x-shockwave-flash"},
+ {".mht", "message/rfc822"},
+ {".mhtml", "message/rfc822"},
+ {".mid", "audio/mid"},
+ {".midi", "audio/mid"},
+ {".mix", "application/octet-stream"},
+ {".mk", "text/plain"},
+ {".mk3d", "video/x-matroska-3d"},
+ {".mka", "audio/x-matroska"},
+ {".mkv", "video/x-matroska"},
+ {".mmf", "application/x-smaf"},
+ {".mno", "text/xml"},
+ {".mny", "application/x-msmoney"},
+ {".mod", "video/mpeg"},
+ {".mov", "video/quicktime"},
+ {".movie", "video/x-sgi-movie"},
+ {".mp2", "video/mpeg"},
+ {".mp2v", "video/mpeg"},
+ {".mp3", "audio/mpeg"},
+ {".mp4", "video/mp4"},
+ {".mp4v", "video/mp4"},
+ {".mpa", "video/mpeg"},
+ {".mpe", "video/mpeg"},
+ {".mpeg", "video/mpeg"},
+ {".mpf", "application/vnd.ms-mediapackage"},
+ {".mpg", "video/mpeg"},
+ {".mpp", "application/vnd.ms-project"},
+ {".mpv2", "video/mpeg"},
+ {".mqv", "video/quicktime"},
+ {".ms", "application/x-troff-ms"},
+ {".msg", "application/vnd.ms-outlook"},
+ {".msi", "application/octet-stream"},
+ {".mso", "application/octet-stream"},
+ {".mts", "video/vnd.dlna.mpeg-tts"},
+ {".mtx", "application/xml"},
+ {".mvb", "application/x-msmediaview"},
+ {".mvc", "application/x-miva-compiled"},
+ {".mxp", "application/x-mmxp"},
+ {".nc", "application/x-netcdf"},
+ {".nsc", "video/x-ms-asf"},
+ {".nws", "message/rfc822"},
+ {".ocx", "application/octet-stream"},
+ {".oda", "application/oda"},
+ {".odb", "application/vnd.oasis.opendocument.database"},
+ {".odc", "application/vnd.oasis.opendocument.chart"},
+ {".odf", "application/vnd.oasis.opendocument.formula"},
+ {".odg", "application/vnd.oasis.opendocument.graphics"},
+ {".odh", "text/plain"},
+ {".odi", "application/vnd.oasis.opendocument.image"},
+ {".odl", "text/plain"},
+ {".odm", "application/vnd.oasis.opendocument.text-master"},
+ {".odp", "application/vnd.oasis.opendocument.presentation"},
+ {".ods", "application/vnd.oasis.opendocument.spreadsheet"},
+ {".odt", "application/vnd.oasis.opendocument.text"},
+ {".oga", "audio/ogg"},
+ {".ogg", "audio/ogg"},
+ {".ogv", "video/ogg"},
+ {".ogx", "application/ogg"},
+ {".one", "application/onenote"},
+ {".onea", "application/onenote"},
+ {".onepkg", "application/onenote"},
+ {".onetmp", "application/onenote"},
+ {".onetoc", "application/onenote"},
+ {".onetoc2", "application/onenote"},
+ {".opus", "audio/ogg"},
+ {".orderedtest", "application/xml"},
+ {".osdx", "application/opensearchdescription+xml"},
+ {".otf", "application/font-sfnt"},
+ {".otg", "application/vnd.oasis.opendocument.graphics-template"},
+ {".oth", "application/vnd.oasis.opendocument.text-web"},
+ {".otp", "application/vnd.oasis.opendocument.presentation-template"},
+ {".ots", "application/vnd.oasis.opendocument.spreadsheet-template"},
+ {".ott", "application/vnd.oasis.opendocument.text-template"},
+ {".oxt", "application/vnd.openofficeorg.extension"},
+ {".p10", "application/pkcs10"},
+ {".p12", "application/x-pkcs12"},
+ {".p7b", "application/x-pkcs7-certificates"},
+ {".p7c", "application/pkcs7-mime"},
+ {".p7m", "application/pkcs7-mime"},
+ {".p7r", "application/x-pkcs7-certreqresp"},
+ {".p7s", "application/pkcs7-signature"},
+ {".pbm", "image/x-portable-bitmap"},
+ {".pcast", "application/x-podcast"},
+ {".pct", "image/pict"},
+ {".pcx", "application/octet-stream"},
+ {".pcz", "application/octet-stream"},
+ {".pdf", "application/pdf"},
+ {".pfb", "application/octet-stream"},
+ {".pfm", "application/octet-stream"},
+ {".pfx", "application/x-pkcs12"},
+ {".pgm", "image/x-portable-graymap"},
+ {".pic", "image/pict"},
+ {".pict", "image/pict"},
+ {".pkgdef", "text/plain"},
+ {".pkgundef", "text/plain"},
+ {".pko", "application/vnd.ms-pki.pko"},
+ {".pls", "audio/scpls"},
+ {".pma", "application/x-perfmon"},
+ {".pmc", "application/x-perfmon"},
+ {".pml", "application/x-perfmon"},
+ {".pmr", "application/x-perfmon"},
+ {".pmw", "application/x-perfmon"},
+ {".png", "image/png"},
+ {".pnm", "image/x-portable-anymap"},
+ {".pnt", "image/x-macpaint"},
+ {".pntg", "image/x-macpaint"},
+ {".pnz", "image/png"},
+ {".pot", "application/vnd.ms-powerpoint"},
+ {".potm", "application/vnd.ms-powerpoint.template.macroEnabled.12"},
+ {".potx", "application/vnd.openxmlformats-officedocument.presentationml.template"},
+ {".ppa", "application/vnd.ms-powerpoint"},
+ {".ppam", "application/vnd.ms-powerpoint.addin.macroEnabled.12"},
+ {".ppm", "image/x-portable-pixmap"},
+ {".pps", "application/vnd.ms-powerpoint"},
+ {".ppsm", "application/vnd.ms-powerpoint.slideshow.macroEnabled.12"},
+ {".ppsx", "application/vnd.openxmlformats-officedocument.presentationml.slideshow"},
+ {".ppt", "application/vnd.ms-powerpoint"},
+ {".pptm", "application/vnd.ms-powerpoint.presentation.macroEnabled.12"},
+ {".pptx", "application/vnd.openxmlformats-officedocument.presentationml.presentation"},
+ {".prf", "application/pics-rules"},
+ {".prm", "application/octet-stream"},
+ {".prx", "application/octet-stream"},
+ {".ps", "application/postscript"},
+ {".psc1", "application/PowerShell"},
+ {".psd", "application/octet-stream"},
+ {".psess", "application/xml"},
+ {".psm", "application/octet-stream"},
+ {".psp", "application/octet-stream"},
+ {".pst", "application/vnd.ms-outlook"},
+ {".pub", "application/x-mspublisher"},
+ {".pwz", "application/vnd.ms-powerpoint"},
+ {".qht", "text/x-html-insertion"},
+ {".qhtm", "text/x-html-insertion"},
+ {".qt", "video/quicktime"},
+ {".qti", "image/x-quicktime"},
+ {".qtif", "image/x-quicktime"},
+ {".qtl", "application/x-quicktimeplayer"},
+ {".qxd", "application/octet-stream"},
+ {".ra", "audio/x-pn-realaudio"},
+ {".ram", "audio/x-pn-realaudio"},
+ {".rar", "application/x-rar-compressed"},
+ {".ras", "image/x-cmu-raster"},
+ {".rat", "application/rat-file"},
+ {".rc", "text/plain"},
+ {".rc2", "text/plain"},
+ {".rct", "text/plain"},
+ {".rdlc", "application/xml"},
+ {".reg", "text/plain"},
+ {".resx", "application/xml"},
+ {".rf", "image/vnd.rn-realflash"},
+ {".rgb", "image/x-rgb"},
+ {".rgs", "text/plain"},
+ {".rm", "application/vnd.rn-realmedia"},
+ {".rmi", "audio/mid"},
+ {".rmp", "application/vnd.rn-rn_music_package"},
+ {".roff", "application/x-troff"},
+ {".rpm", "audio/x-pn-realaudio-plugin"},
+ {".rqy", "text/x-ms-rqy"},
+ {".rtf", "application/rtf"},
+ {".rtx", "text/richtext"},
+ {".rvt", "application/octet-stream" },
+ {".ruleset", "application/xml"},
+ {".s", "text/plain"},
+ {".safariextz", "application/x-safari-safariextz"},
+ {".scd", "application/x-msschedule"},
+ {".scr", "text/plain"},
+ {".sct", "text/scriptlet"},
+ {".sd2", "audio/x-sd2"},
+ {".sdp", "application/sdp"},
+ {".sea", "application/octet-stream"},
+ {".searchConnector-ms", "application/windows-search-connector+xml"},
+ {".setpay", "application/set-payment-initiation"},
+ {".setreg", "application/set-registration-initiation"},
+ {".settings", "application/xml"},
+ {".sgimb", "application/x-sgimb"},
+ {".sgml", "text/sgml"},
+ {".sh", "application/x-sh"},
+ {".shar", "application/x-shar"},
+ {".shtml", "text/html"},
+ {".sit", "application/x-stuffit"},
+ {".sitemap", "application/xml"},
+ {".skin", "application/xml"},
+ {".skp", "application/x-koan" },
+ {".sldm", "application/vnd.ms-powerpoint.slide.macroEnabled.12"},
+ {".sldx", "application/vnd.openxmlformats-officedocument.presentationml.slide"},
+ {".slk", "application/vnd.ms-excel"},
+ {".sln", "text/plain"},
+ {".slupkg-ms", "application/x-ms-license"},
+ {".smd", "audio/x-smd"},
+ {".smi", "application/octet-stream"},
+ {".smx", "audio/x-smd"},
+ {".smz", "audio/x-smd"},
+ {".snd", "audio/basic"},
+ {".snippet", "application/xml"},
+ {".snp", "application/octet-stream"},
+ {".sol", "text/plain"},
+ {".sor", "text/plain"},
+ {".spc", "application/x-pkcs7-certificates"},
+ {".spl", "application/futuresplash"},
+ {".spx", "audio/ogg"},
+ {".src", "application/x-wais-source"},
+ {".srf", "text/plain"},
+ {".SSISDeploymentManifest", "text/xml"},
+ {".ssm", "application/streamingmedia"},
+ {".sst", "application/vnd.ms-pki.certstore"},
+ {".stl", "application/vnd.ms-pki.stl"},
+ {".sv4cpio", "application/x-sv4cpio"},
+ {".sv4crc", "application/x-sv4crc"},
+ {".svc", "application/xml"},
+ {".svg", "image/svg+xml"},
+ {".swf", "application/x-shockwave-flash"},
+ {".step", "application/step"},
+ {".stp", "application/step"},
+ {".t", "application/x-troff"},
+ {".tar", "application/x-tar"},
+ {".tcl", "application/x-tcl"},
+ {".testrunconfig", "application/xml"},
+ {".testsettings", "application/xml"},
+ {".tex", "application/x-tex"},
+ {".texi", "application/x-texinfo"},
+ {".texinfo", "application/x-texinfo"},
+ {".tgz", "application/x-compressed"},
+ {".thmx", "application/vnd.ms-officetheme"},
+ {".thn", "application/octet-stream"},
+ {".tif", "image/tiff"},
+ {".tiff", "image/tiff"},
+ {".tlh", "text/plain"},
+ {".tli", "text/plain"},
+ {".toc", "application/octet-stream"},
+ {".tr", "application/x-troff"},
+ {".trm", "application/x-msterminal"},
+ {".trx", "application/xml"},
+ {".ts", "video/vnd.dlna.mpeg-tts"},
+ {".tsv", "text/tab-separated-values"},
+ {".ttf", "application/font-sfnt"},
+ {".tts", "video/vnd.dlna.mpeg-tts"},
+ {".txt", "text/plain"},
+ {".u32", "application/octet-stream"},
+ {".uls", "text/iuls"},
+ {".user", "text/plain"},
+ {".ustar", "application/x-ustar"},
+ {".vb", "text/plain"},
+ {".vbdproj", "text/plain"},
+ {".vbk", "video/mpeg"},
+ {".vbproj", "text/plain"},
+ {".vbs", "text/vbscript"},
+ {".vcf", "text/x-vcard"},
+ {".vcproj", "application/xml"},
+ {".vcs", "text/plain"},
+ {".vcxproj", "application/xml"},
+ {".vddproj", "text/plain"},
+ {".vdp", "text/plain"},
+ {".vdproj", "text/plain"},
+ {".vdx", "application/vnd.ms-visio.viewer"},
+ {".vml", "text/xml"},
+ {".vscontent", "application/xml"},
+ {".vsct", "text/xml"},
+ {".vsd", "application/vnd.visio"},
+ {".vsi", "application/ms-vsi"},
+ {".vsix", "application/vsix"},
+ {".vsixlangpack", "text/xml"},
+ {".vsixmanifest", "text/xml"},
+ {".vsmdi", "application/xml"},
+ {".vspscc", "text/plain"},
+ {".vss", "application/vnd.visio"},
+ {".vsscc", "text/plain"},
+ {".vssettings", "text/xml"},
+ {".vssscc", "text/plain"},
+ {".vst", "application/vnd.visio"},
+ {".vstemplate", "text/xml"},
+ {".vsto", "application/x-ms-vsto"},
+ {".vsw", "application/vnd.visio"},
+ {".vsx", "application/vnd.visio"},
+ {".vtt", "text/vtt"},
+ {".vtx", "application/vnd.visio"},
+ {".wasm", "application/wasm"},
+ {".wav", "audio/wav"},
+ {".wave", "audio/wav"},
+ {".wax", "audio/x-ms-wax"},
+ {".wbk", "application/msword"},
+ {".wbmp", "image/vnd.wap.wbmp"},
+ {".wcm", "application/vnd.ms-works"},
+ {".wdb", "application/vnd.ms-works"},
+ {".wdp", "image/vnd.ms-photo"},
+ {".webarchive", "application/x-safari-webarchive"},
+ {".webm", "video/webm"},
+ {".webp", "image/webp"}, /* https://en.wikipedia.org/wiki/WebP */
+ {".webtest", "application/xml"},
+ {".wiq", "application/xml"},
+ {".wiz", "application/msword"},
+ {".wks", "application/vnd.ms-works"},
+ {".WLMP", "application/wlmoviemaker"},
+ {".wlpginstall", "application/x-wlpg-detect"},
+ {".wlpginstall3", "application/x-wlpg3-detect"},
+ {".wm", "video/x-ms-wm"},
+ {".wma", "audio/x-ms-wma"},
+ {".wmd", "application/x-ms-wmd"},
+ {".wmf", "application/x-msmetafile"},
+ {".wml", "text/vnd.wap.wml"},
+ {".wmlc", "application/vnd.wap.wmlc"},
+ {".wmls", "text/vnd.wap.wmlscript"},
+ {".wmlsc", "application/vnd.wap.wmlscriptc"},
+ {".wmp", "video/x-ms-wmp"},
+ {".wmv", "video/x-ms-wmv"},
+ {".wmx", "video/x-ms-wmx"},
+ {".wmz", "application/x-ms-wmz"},
+ {".woff", "application/font-woff"},
+ {".woff2", "application/font-woff2"},
+ {".wpl", "application/vnd.ms-wpl"},
+ {".wps", "application/vnd.ms-works"},
+ {".wri", "application/x-mswrite"},
+ {".wrl", "x-world/x-vrml"},
+ {".wrz", "x-world/x-vrml"},
+ {".wsc", "text/scriptlet"},
+ {".wsdl", "text/xml"},
+ {".wvx", "video/x-ms-wvx"},
+ {".x", "application/directx"},
+ {".xaf", "x-world/x-vrml"},
+ {".xaml", "application/xaml+xml"},
+ {".xap", "application/x-silverlight-app"},
+ {".xbap", "application/x-ms-xbap"},
+ {".xbm", "image/x-xbitmap"},
+ {".xdr", "text/plain"},
+ {".xht", "application/xhtml+xml"},
+ {".xhtml", "application/xhtml+xml"},
+ {".xla", "application/vnd.ms-excel"},
+ {".xlam", "application/vnd.ms-excel.addin.macroEnabled.12"},
+ {".xlc", "application/vnd.ms-excel"},
+ {".xld", "application/vnd.ms-excel"},
+ {".xlk", "application/vnd.ms-excel"},
+ {".xll", "application/vnd.ms-excel"},
+ {".xlm", "application/vnd.ms-excel"},
+ {".xls", "application/vnd.ms-excel"},
+ {".xlsb", "application/vnd.ms-excel.sheet.binary.macroEnabled.12"},
+ {".xlsm", "application/vnd.ms-excel.sheet.macroEnabled.12"},
+ {".xlsx", "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet"},
+ {".xlt", "application/vnd.ms-excel"},
+ {".xltm", "application/vnd.ms-excel.template.macroEnabled.12"},
+ {".xltx", "application/vnd.openxmlformats-officedocument.spreadsheetml.template"},
+ {".xlw", "application/vnd.ms-excel"},
+ {".xml", "text/xml"},
+ {".xmp", "application/octet-stream" },
+ {".xmta", "application/xml"},
+ {".xof", "x-world/x-vrml"},
+ {".XOML", "text/plain"},
+ {".xpm", "image/x-xpixmap"},
+ {".xps", "application/vnd.ms-xpsdocument"},
+ {".xrm-ms", "text/xml"},
+ {".xsc", "application/xml"},
+ {".xsd", "text/xml"},
+ {".xsf", "text/xml"},
+ {".xsl", "text/xml"},
+ {".xslt", "text/xml"},
+ {".xsn", "application/octet-stream"},
+ {".xss", "application/xml"},
+ {".xspf", "application/xspf+xml"},
+ {".xtp", "application/octet-stream"},
+ {".xwd", "image/x-xwindowdump"},
+ {".z", "application/x-compress"},
+ {".zip", "application/zip"},
+ };
+ }
+}
\ No newline at end of file
diff --git a/Vendor/EmbedIO-3.5.2/MimeType.cs b/Vendor/EmbedIO-3.5.2/MimeType.cs
new file mode 100644
index 0000000..071407c
--- /dev/null
+++ b/Vendor/EmbedIO-3.5.2/MimeType.cs
@@ -0,0 +1,174 @@
+using System;
+using EmbedIO.Utilities;
+
+namespace EmbedIO
+{
+ ///
+ /// Provides constants for commonly-used MIME types and association between file extensions and MIME types.
+ ///
+ ///
+ public static partial class MimeType
+ {
+ ///
+ /// The default MIME type for data whose type is unknown,
+ /// i.e. application/octet-stream.
+ ///
+ public const string Default = "application/octet-stream";
+
+ ///
+ /// The MIME type for plain text, i.e. text/plain.
+ ///
+ public const string PlainText = "text/plain";
+
+ ///
+ /// The MIME type for HTML, i.e. text/html.
+ ///
+ public const string Html = "text/html";
+
+ ///
+ /// The MIME type for JSON, i.e. application/json.
+ ///
+ public const string Json = "application/json";
+
+ ///
+ /// The MIME type for URL-encoded HTML forms,
+ /// i.e. application/x-www-form-urlencoded.
+ ///
+ internal const string UrlEncodedForm = "application/x-www-form-urlencoded";
+
+ ///
+ /// Strips parameters, if present (e.g. ; encoding=UTF-8), from a MIME type.
+ ///
+ /// The MIME type.
+ /// without parameters.
+ ///
+ /// This method does not validate : if it is not
+ /// a valid MIME type or media range, it is just returned unchanged.
+ ///
+ public static string StripParameters(string value)
+ {
+ if (string.IsNullOrEmpty(value))
+ return value;
+
+ var semicolonPos = value.IndexOf(';');
+ return semicolonPos < 0
+ ? value
+ : value.Substring(0, semicolonPos).TrimEnd();
+ }
+
+ ///
+ /// Determines whether the specified string is a valid MIME type or media range.
+ ///
+ /// The value.
+ /// If set to , both media ranges
+ /// (e.g. "text/*", "*/*") and specific MIME types (e.g. "text/html")
+ /// are considered valid; if set to , only specific MIME types
+ /// are considered valid.
+ /// if is valid,
+ /// according to the value of ;
+ /// otherwise, .
+ public static bool IsMimeType(string value, bool acceptMediaRange)
+ {
+ if (string.IsNullOrEmpty(value))
+ return false;
+
+ var slashPos = value.IndexOf('/');
+ if (slashPos < 0)
+ return false;
+
+ var isWildcardSubtype = false;
+ var subtype = value.Substring(slashPos + 1);
+ if (subtype == "*")
+ {
+ if (!acceptMediaRange)
+ return false;
+
+ isWildcardSubtype = true;
+ }
+ else if (!Validate.IsRfc2616Token(subtype))
+ {
+ return false;
+ }
+
+ var type = value.Substring(0, slashPos);
+ return type == "*"
+ ? acceptMediaRange && isWildcardSubtype
+ : Validate.IsRfc2616Token(type);
+ }
+
+ ///
+ /// Splits the specified MIME type or media range into type and subtype.
+ ///
+ /// The MIME type or media range to split.
+ /// A tuple of type and subtype.
+ /// is .
+ /// is not a valid
+ /// MIME type or media range.
+ public static (string type, string subtype) Split(string mimeType)
+ => UnsafeSplit(Validate.MimeType(nameof(mimeType), mimeType, true));
+
+ ///
+ /// Matches the specified MIME type to a media range.
+ ///
+ /// The MIME type to match.
+ /// The media range.
+ /// if is either
+ /// the same as , or has the same type and a subtype
+ /// of "*", or is "*/*".
+ ///
+ /// is .
+ /// - or -
+ /// is .
+ ///
+ ///
+ /// is not a valid MIME type.
+ /// - or -
+ /// is not a valid MIME media range.
+ ///
+ public static bool IsInRange(string mimeType, string mediaRange)
+ => UnsafeIsInRange(
+ Validate.MimeType(nameof(mimeType), mimeType, false),
+ Validate.MimeType(nameof(mediaRange), mediaRange, true));
+
+ internal static (string type, string subtype) UnsafeSplit(string mimeType)
+ {
+ var slashPos = mimeType.IndexOf('/');
+ return (mimeType.Substring(0, slashPos), mimeType.Substring(slashPos + 1));
+ }
+
+ internal static bool UnsafeIsInRange(string mimeType, string mediaRange)
+ {
+ // A validated media range that starts with '*' can only be '*/*'
+ if (mediaRange[0] == '*')
+ return true;
+
+ var typeSlashPos = mimeType.IndexOf('/');
+ var rangeSlashPos = mediaRange.IndexOf('/');
+
+ if (typeSlashPos != rangeSlashPos)
+ return false;
+
+ for (var i = 0; i < typeSlashPos; i++)
+ {
+ if (mimeType[i] != mediaRange[i])
+ return false;
+ }
+
+ // A validated token has at least 1 character,
+ // thus there must be at least 1 character after a slash.
+ if (mediaRange[rangeSlashPos + 1] == '*')
+ return true;
+
+ if (mimeType.Length != mediaRange.Length)
+ return false;
+
+ for (var i = typeSlashPos + 1; i < mimeType.Length; i++)
+ {
+ if (mimeType[i] != mediaRange[i])
+ return false;
+ }
+
+ return true;
+ }
+ }
+}
\ No newline at end of file
diff --git a/Vendor/EmbedIO-3.5.2/MimeTypeCustomizerExtensions.cs b/Vendor/EmbedIO-3.5.2/MimeTypeCustomizerExtensions.cs
new file mode 100644
index 0000000..1c8121d
--- /dev/null
+++ b/Vendor/EmbedIO-3.5.2/MimeTypeCustomizerExtensions.cs
@@ -0,0 +1,99 @@
+using System;
+
+namespace EmbedIO
+{
+ ///
+ /// Provides extension methods for types implementing .
+ ///
+ public static class MimeTypeCustomizerExtensions
+ {
+ ///
+ /// Adds a custom association between a file extension and a MIME type.
+ ///
+ /// The type of the object to which this method is applied.
+ /// The object to which this method is applied.
+ /// The file extension to associate to .
+ /// The MIME type to associate to .
+ /// with the custom association added.
+ /// is .
+ /// has its configuration locked.
+ ///
+ /// is .
+ /// - or -
+ /// is .
+ ///
+ ///
+ /// is the empty string.
+ /// - or -
+ /// is not a valid MIME type.
+ ///
+ public static T WithCustomMimeType(this T @this, string extension, string mimeType)
+ where T : IMimeTypeCustomizer
+ {
+ @this.AddCustomMimeType(extension, mimeType);
+ return @this;
+ }
+
+ ///
+ /// Indicates whether to prefer compression when negotiating content encoding
+ /// for a response with the specified content type, or whose content type is in
+ /// the specified media range.
+ ///
+ /// The type of the object to which this method is applied.
+ /// The object to which this method is applied.
+ /// The MIME type or media range.
+ /// to prefer compression;
+ /// otherwise, .
+ /// with the specified preference added.
+ /// is .
+ /// has its configuration locked.
+ /// is .
+ /// is not a valid MIME type or media range.
+ public static T PreferCompressionFor(this T @this, string mimeType, bool preferCompression)
+ where T : IMimeTypeCustomizer
+ {
+ @this.PreferCompression(mimeType, preferCompression);
+ return @this;
+ }
+
+ ///
+ /// Indicates that compression should be preferred when negotiating content encoding
+ /// for a response with the specified content type, or whose content type is in
+ /// the specified media range.
+ ///
+ /// The type of the object to which this method is applied.
+ /// The object to which this method is applied.
+ /// The MIME type or media range.
+ /// with the specified preference added.
+ /// is .
+ /// has its configuration locked.
+ /// is .
+ /// is not a valid MIME type or media range.
+ public static T PreferCompressionFor(this T @this, string mimeType)
+ where T : IMimeTypeCustomizer
+ {
+ @this.PreferCompression(mimeType, true);
+ return @this;
+ }
+
+ ///
+ /// Indicates that no compression should be preferred when negotiating content encoding
+ /// for a response with the specified content type, or whose content type is in
+ /// the specified media range.
+ ///
+ /// The type of the object to which this method is applied.
+ /// The object to which this method is applied.
+ /// The MIME type or media range.
+ /// with the specified preference added.
+ /// is .
+ /// has its configuration locked.
+ /// is .
+ /// is not a valid MIME type or media range.
+ public static T PreferNoCompressionFor(this T @this, string mimeType)
+ where T : IMimeTypeCustomizer
+ {
+ @this.PreferCompression(mimeType, false);
+ return @this;
+ }
+ }
+}
\ No newline at end of file
diff --git a/Vendor/EmbedIO-3.5.2/ModuleGroup.cs b/Vendor/EmbedIO-3.5.2/ModuleGroup.cs
new file mode 100644
index 0000000..ad4db32
--- /dev/null
+++ b/Vendor/EmbedIO-3.5.2/ModuleGroup.cs
@@ -0,0 +1,111 @@
+using System;
+using System.Collections.Concurrent;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using EmbedIO.Internal;
+using EmbedIO.Utilities;
+
+namespace EmbedIO
+{
+ ///
+ /// Groups modules under a common base URL path.
+ /// The BaseRoute property
+ /// of modules contained in a ModuleGroup is relative to the
+ /// ModuleGroup's BaseRoute property.
+ /// For example, given the following code:
+ /// new ModuleGroup("/download")
+ /// .WithStaticFilesAt("/docs", "/var/my/documents");
+ /// files contained in the /var/my/documents folder will be
+ /// available to clients under the /download/docs/ URL.
+ ///
+ ///
+ ///
+ ///
+ public class ModuleGroup : WebModuleBase, IDisposable, IWebModuleContainer, IMimeTypeCustomizer
+ {
+ private readonly WebModuleCollection _modules;
+ private readonly MimeTypeCustomizer _mimeTypeCustomizer = new MimeTypeCustomizer();
+
+ ///
+ /// Initializes a new instance of the class.
+ ///
+ /// The base route served by this module.
+ /// The value to set the property to.
+ /// See the help for the property for more information.
+ ///
+ ///
+ public ModuleGroup(string baseRoute, bool isFinalHandler)
+ : base(baseRoute)
+ {
+ IsFinalHandler = isFinalHandler;
+ _modules = new WebModuleCollection(nameof(ModuleGroup));
+ }
+
+ ///
+ /// Finalizes an instance of the class.
+ ///
+ ~ModuleGroup()
+ {
+ Dispose(false);
+ }
+
+ ///
+ public sealed override bool IsFinalHandler { get; }
+
+ ///
+ public IComponentCollection Modules => _modules;
+
+ ///
+ public void Dispose()
+ {
+ Dispose(true);
+ GC.SuppressFinalize(this);
+ }
+
+ string IMimeTypeProvider.GetMimeType(string extension)
+ => _mimeTypeCustomizer.GetMimeType(extension);
+
+ bool IMimeTypeProvider.TryDetermineCompression(string mimeType, out bool preferCompression)
+ => _mimeTypeCustomizer.TryDetermineCompression(mimeType, out preferCompression);
+
+ ///
+ public void AddCustomMimeType(string extension, string mimeType)
+ => _mimeTypeCustomizer.AddCustomMimeType(extension, mimeType);
+
+ ///
+ public void PreferCompression(string mimeType, bool preferCompression)
+ => _mimeTypeCustomizer.PreferCompression(mimeType, preferCompression);
+
+ ///
+ protected override Task OnRequestAsync(IHttpContext context)
+ => _modules.DispatchRequestAsync(context);
+
+ ///
+ /// Releases unmanaged and - optionally - managed resources.
+ ///
+ /// to release both managed and unmanaged resources;
+ /// to release only unmanaged resources.
+ protected virtual void Dispose(bool disposing)
+ {
+ if (!disposing)
+ return;
+
+ _modules.Dispose();
+ }
+
+ ///
+ protected override void OnBeforeLockConfiguration()
+ {
+ base.OnBeforeLockConfiguration();
+
+ _mimeTypeCustomizer.Lock();
+ }
+
+ ///
+ protected override void OnStart(CancellationToken cancellationToken)
+ {
+ _modules.StartAll(cancellationToken);
+ }
+ }
+}
diff --git a/Vendor/EmbedIO-3.5.2/Net/CookieList.cs b/Vendor/EmbedIO-3.5.2/Net/CookieList.cs
new file mode 100644
index 0000000..75bf4a4
--- /dev/null
+++ b/Vendor/EmbedIO-3.5.2/Net/CookieList.cs
@@ -0,0 +1,243 @@
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Globalization;
+using System.Linq;
+using System.Net;
+using System.Text;
+using EmbedIO.Internal;
+using EmbedIO.Net.Internal;
+using EmbedIO.Utilities;
+
+namespace EmbedIO.Net
+{
+ ///
+ /// Provides a collection container for instances of .
+ /// This class is meant to be used internally by EmbedIO; you don't need to
+ /// use this class directly.
+ ///
+#pragma warning disable CA1710 // Rename class to end in 'Collection' - it ends in 'List', i.e. 'Indexed Collection'.
+ public sealed class CookieList : List, ICookieCollection
+#pragma warning restore CA1710
+ {
+ ///
+ public bool IsSynchronized => false;
+
+ ///
+ public Cookie? this[string name]
+ {
+ get
+ {
+ if (name == null)
+ throw new ArgumentNullException(nameof(name));
+
+ if (Count == 0)
+ return null;
+
+ var list = new List(this);
+
+ list.Sort(CompareCookieWithinSorted);
+
+ return list.FirstOrDefault(cookie => cookie.Name.Equals(name, StringComparison.OrdinalIgnoreCase));
+ }
+ }
+
+ /// Creates a by parsing
+ /// the value of one or more Cookie or Set-Cookie headers.
+ /// The value, or comma-separated list of values,
+ /// of the header or headers.
+ /// A newly-created instance of .
+ public static CookieList Parse(string headerValue)
+ {
+ var cookies = new CookieList();
+
+ Cookie? cookie = null;
+ var pairs = SplitCookieHeaderValue(headerValue);
+
+ for (var i = 0; i < pairs.Length; i++)
+ {
+ var pair = pairs[i].Trim();
+ if (pair.Length == 0)
+ continue;
+
+ if (pair.StartsWith("version", StringComparison.OrdinalIgnoreCase) && cookie != null)
+ {
+ cookie.Version = int.Parse(GetValue(pair, true), CultureInfo.InvariantCulture);
+ }
+ else if (pair.StartsWith("expires", StringComparison.OrdinalIgnoreCase) && cookie != null)
+ {
+ var buff = new StringBuilder(GetValue(pair), 32);
+ if (i < pairs.Length - 1)
+ buff.AppendFormat(CultureInfo.InvariantCulture, ", {0}", pairs[++i].Trim());
+
+ if (!HttpDate.TryParse(buff.ToString(), out var expires))
+ expires = DateTimeOffset.Now;
+
+ if (cookie.Expires == DateTime.MinValue)
+ cookie.Expires = expires.LocalDateTime;
+ }
+ else if (pair.StartsWith("max-age", StringComparison.OrdinalIgnoreCase) && cookie != null)
+ {
+ var max = int.Parse(GetValue(pair, true), CultureInfo.InvariantCulture);
+
+ cookie.Expires = DateTime.Now.AddSeconds(max);
+ }
+ else if (pair.StartsWith("path", StringComparison.OrdinalIgnoreCase) && cookie != null)
+ {
+ cookie.Path = GetValue(pair);
+ }
+ else if (pair.StartsWith("domain", StringComparison.OrdinalIgnoreCase) && cookie != null)
+ {
+ cookie.Domain = GetValue(pair);
+ }
+ else if (pair.StartsWith("port", StringComparison.OrdinalIgnoreCase) && cookie != null)
+ {
+ cookie.Port = pair.Equals("port", StringComparison.OrdinalIgnoreCase)
+ ? "\"\""
+ : GetValue(pair);
+ }
+ else if (pair.StartsWith("comment", StringComparison.OrdinalIgnoreCase) && cookie != null)
+ {
+ cookie.Comment = WebUtility.UrlDecode(GetValue(pair));
+ }
+ else if (pair.StartsWith("commenturl", StringComparison.OrdinalIgnoreCase) && cookie != null)
+ {
+ cookie.CommentUri = UriUtility.StringToUri(GetValue(pair, true));
+ }
+ else if (pair.StartsWith("discard", StringComparison.OrdinalIgnoreCase) && cookie != null)
+ {
+ cookie.Discard = true;
+ }
+ else if (pair.StartsWith("secure", StringComparison.OrdinalIgnoreCase) && cookie != null)
+ {
+ cookie.Secure = true;
+ }
+ else if (pair.StartsWith("httponly", StringComparison.OrdinalIgnoreCase) && cookie != null)
+ {
+ cookie.HttpOnly = true;
+ }
+ else
+ {
+ if (cookie != null)
+ cookies.Add(cookie);
+
+ cookie = ParseCookie(pair);
+ }
+ }
+
+ if (cookie != null)
+ cookies.Add(cookie);
+
+ return cookies;
+ }
+
+ ///
+ public new void Add(Cookie cookie)
+ {
+ if (cookie == null)
+ throw new ArgumentNullException(nameof(cookie));
+
+ var pos = SearchCookie(cookie);
+ if (pos == -1)
+ {
+ base.Add(cookie);
+ return;
+ }
+
+ this[pos] = cookie;
+ }
+
+ ///
+ public void CopyTo(Array array, int index)
+ {
+ if (array == null)
+ throw new ArgumentNullException(nameof(array));
+
+ if (index < 0)
+ throw new ArgumentOutOfRangeException(nameof(index), "Less than zero.");
+
+ if (array.Rank > 1)
+ throw new ArgumentException("Multidimensional.", nameof(array));
+
+ if (array.Length - index < Count)
+ {
+ throw new ArgumentException(
+ "The number of elements in this collection is greater than the available space of the destination array.");
+ }
+
+ if (array.GetType().GetElementType()?.IsAssignableFrom(typeof(Cookie)) != true)
+ {
+ throw new InvalidCastException(
+ "The elements in this collection cannot be cast automatically to the type of the destination array.");
+ }
+
+ ((IList) this).CopyTo(array, index);
+ }
+
+ private static string? GetValue(string nameAndValue, bool unquote = false)
+ {
+ var idx = nameAndValue.IndexOf('=');
+
+ if (idx < 0 || idx == nameAndValue.Length - 1)
+ return null;
+
+ var val = nameAndValue.Substring(idx + 1).Trim();
+ return unquote ? val.Unquote() : val;
+ }
+
+ private static string[] SplitCookieHeaderValue(string value) => value.SplitHeaderValue(true).ToArray();
+
+ private static int CompareCookieWithinSorted(Cookie x, Cookie y)
+ {
+ var ret = x.Version - y.Version;
+ return ret != 0
+ ? ret
+ : (ret = string.Compare(x.Name, y.Name, StringComparison.Ordinal)) != 0
+ ? ret
+ : y.Path.Length - x.Path.Length;
+ }
+
+ private static Cookie ParseCookie(string pair)
+ {
+ string name;
+ var val = string.Empty;
+
+ var pos = pair.IndexOf('=');
+ if (pos == -1)
+ {
+ name = pair;
+ }
+ else if (pos == pair.Length - 1)
+ {
+ name = pair.Substring(0, pos).TrimEnd(' ');
+ }
+ else
+ {
+ name = pair.Substring(0, pos).TrimEnd(' ');
+ val = pair.Substring(pos + 1).TrimStart(' ');
+ }
+
+ return new Cookie(name, val);
+ }
+
+ private int SearchCookie(Cookie cookie)
+ {
+ var name = cookie.Name;
+ var path = cookie.Path;
+ var domain = cookie.Domain;
+ var ver = cookie.Version;
+
+ for (var i = Count - 1; i >= 0; i--)
+ {
+ var c = this[i];
+ if (c.Name.Equals(name, StringComparison.OrdinalIgnoreCase) &&
+ c.Path.Equals(path, StringComparison.OrdinalIgnoreCase) &&
+ c.Domain.Equals(domain, StringComparison.OrdinalIgnoreCase) &&
+ c.Version == ver)
+ return i;
+ }
+
+ return -1;
+ }
+ }
+}
\ No newline at end of file
diff --git a/Vendor/EmbedIO-3.5.2/Net/EndPointManager.cs b/Vendor/EmbedIO-3.5.2/Net/EndPointManager.cs
new file mode 100644
index 0000000..2103312
--- /dev/null
+++ b/Vendor/EmbedIO-3.5.2/Net/EndPointManager.cs
@@ -0,0 +1,141 @@
+using System;
+using System.Collections.Concurrent;
+using System.Collections.Generic;
+using System.Net;
+using System.Net.Sockets;
+using EmbedIO.Net.Internal;
+using Swan.Logging;
+
+namespace EmbedIO.Net
+{
+ ///
+ /// Represents the EndPoint Manager.
+ ///
+ public static class EndPointManager
+ {
+ private static readonly ConcurrentDictionary> IPToEndpoints = new ();
+
+ ///
+ /// Gets or sets a value indicating whether [use IPv6]. By default, this flag is set.
+ ///
+ ///
+ /// true if [use IPv6]; otherwise, false.
+ ///
+ public static bool UseIpv6 { get; set; } = true;
+
+ internal static void AddListener(HttpListener listener)
+ {
+ var added = new List();
+
+ try
+ {
+ foreach (var prefix in listener.Prefixes)
+ {
+ AddPrefix(prefix, listener);
+ added.Add(prefix);
+ }
+ }
+ catch (Exception ex)
+ {
+ ex.Log(nameof(AddListener));
+
+ foreach (var prefix in added)
+ {
+ RemovePrefix(prefix, listener);
+ }
+
+ throw;
+ }
+ }
+
+ internal static void RemoveEndPoint(EndPointListener epl, IPEndPoint ep)
+ {
+ if (IPToEndpoints.TryGetValue(ep.Address, out var p))
+ {
+ if (p.TryRemove(ep.Port, out _) && p.Count == 0)
+ {
+ _ = IPToEndpoints.TryRemove(ep.Address, out _);
+ }
+ }
+
+ epl.Dispose();
+ }
+
+ internal static void RemoveListener(HttpListener listener)
+ {
+ foreach (var prefix in listener.Prefixes)
+ {
+ RemovePrefix(prefix, listener);
+ }
+ }
+
+ internal static void AddPrefix(string p, HttpListener listener)
+ {
+ var lp = new ListenerPrefix(p);
+
+ if (!lp.IsValid())
+ {
+ throw new HttpListenerException(400, "Invalid path.");
+ }
+
+ // listens on all the interfaces if host name cannot be parsed by IPAddress.
+ var epl = GetEpListener(lp.Host, lp.Port, listener, lp.Secure);
+ epl.AddPrefix(lp, listener);
+ }
+
+ private static EndPointListener GetEpListener(string host, int port, HttpListener listener, bool secure = false)
+ {
+ var address = ResolveAddress(host);
+
+ var p = IPToEndpoints.GetOrAdd(address, x => new ConcurrentDictionary());
+ return p.GetOrAdd(port, x => new EndPointListener(listener, address, x, secure));
+ }
+
+ private static IPAddress ResolveAddress(string host)
+ {
+ if (host == "*" || host == "+" || host == "0.0.0.0")
+ {
+ return UseIpv6 ? IPAddress.IPv6Any : IPAddress.Any;
+ }
+
+ if (IPAddress.TryParse(host, out var address))
+ {
+ return address;
+ }
+
+ try
+ {
+ var hostEntry = new IPHostEntry {
+ HostName = host,
+ AddressList = Dns.GetHostAddresses(host),
+ };
+
+ return hostEntry.AddressList[0];
+ }
+ catch
+ {
+ return UseIpv6 ? IPAddress.IPv6Any : IPAddress.Any;
+ }
+ }
+
+ private static void RemovePrefix(string prefix, HttpListener listener)
+ {
+ try
+ {
+ var lp = new ListenerPrefix(prefix);
+
+ if (!lp.IsValid())
+ {
+ return;
+ }
+
+ var epl = GetEpListener(lp.Host, lp.Port, listener, lp.Secure);
+ epl.RemovePrefix(lp);
+ }
+ catch (SocketException)
+ {
+ // ignored
+ }
+ }
+ }
+}
\ No newline at end of file
diff --git a/Vendor/EmbedIO-3.5.2/Net/HttpListener.cs b/Vendor/EmbedIO-3.5.2/Net/HttpListener.cs
new file mode 100644
index 0000000..2f96ffb
--- /dev/null
+++ b/Vendor/EmbedIO-3.5.2/Net/HttpListener.cs
@@ -0,0 +1,161 @@
+using System;
+using System.Collections.Concurrent;
+using System.Collections.Generic;
+using System.Linq;
+using System.Security.Cryptography.X509Certificates;
+using System.Threading;
+using System.Threading.Tasks;
+using EmbedIO.Net.Internal;
+
+namespace EmbedIO.Net
+{
+ ///
+ /// The EmbedIO implementation of the standard HTTP Listener class.
+ ///
+ /// Based on MONO HttpListener class.
+ ///
+ ///
+ public sealed class HttpListener : IHttpListener
+ {
+ private readonly SemaphoreSlim _ctxQueueSem = new (0);
+ private readonly ConcurrentDictionary _ctxQueue;
+ private readonly ConcurrentDictionary _connections;
+ private readonly HttpListenerPrefixCollection _prefixes;
+ private bool _disposed;
+
+ ///
+ /// Initializes a new instance of the class.
+ ///
+ /// The certificate.
+ public HttpListener(X509Certificate? certificate = null)
+ {
+ Certificate = certificate;
+
+ _prefixes = new HttpListenerPrefixCollection(this);
+ _connections = new ConcurrentDictionary();
+ _ctxQueue = new ConcurrentDictionary();
+ }
+
+ ///
+ public bool IgnoreWriteExceptions { get; set; } = true;
+
+ ///
+ public bool IsListening { get; private set; }
+
+ ///
+ public string Name { get; } = "Unosquare HTTP Listener";
+
+ ///
+ public List Prefixes => _prefixes.ToList();
+
+ ///
+ /// Gets the certificate.
+ ///
+ ///
+ /// The certificate.
+ ///
+ internal X509Certificate? Certificate { get; }
+
+ ///
+ public void Start()
+ {
+ if (IsListening)
+ {
+ return;
+ }
+
+ EndPointManager.AddListener(this);
+ IsListening = true;
+ }
+
+ ///
+ public void Stop()
+ {
+ IsListening = false;
+ Close(false);
+ }
+
+ ///
+ public void AddPrefix(string urlPrefix) => _prefixes.Add(urlPrefix);
+
+ ///
+ public void Dispose()
+ {
+ if (_disposed)
+ {
+ return;
+ }
+
+ Close(true);
+ _ctxQueueSem.Dispose();
+ _disposed = true;
+ }
+
+ ///
+ public async Task GetContextAsync(CancellationToken cancellationToken)
+ {
+ while (true)
+ {
+ await _ctxQueueSem.WaitAsync(cancellationToken).ConfigureAwait(false);
+
+ foreach (var key in _ctxQueue.Keys)
+ {
+ if (_ctxQueue.TryRemove(key, out var context))
+ {
+ return context;
+ }
+
+ break;
+ }
+ }
+ }
+
+ internal void RegisterContext(HttpListenerContext context)
+ {
+ if (!_ctxQueue.TryAdd(context.Id, context))
+ {
+ throw new InvalidOperationException("Unable to register context");
+ }
+
+ _ = _ctxQueueSem.Release();
+ }
+
+ internal void UnregisterContext(HttpListenerContext context) => _ctxQueue.TryRemove(context.Id, out _);
+
+ internal void AddConnection(HttpConnection cnc) => _connections[cnc] = cnc;
+
+ internal void RemoveConnection(HttpConnection cnc) => _connections.TryRemove(cnc, out _);
+
+ private void Close(bool closeExisting)
+ {
+ EndPointManager.RemoveListener(this);
+
+ var keys = _connections.Keys;
+ var connections = new HttpConnection[keys.Count];
+ keys.CopyTo(connections, 0);
+ _connections.Clear();
+ var list = new List(connections);
+
+ for (var i = list.Count - 1; i >= 0; i--)
+ {
+ list[i].Close(true);
+ }
+
+ if (!closeExisting)
+ {
+ return;
+ }
+
+ while (!_ctxQueue.IsEmpty)
+ {
+ foreach (var key in _ctxQueue.Keys.ToArray())
+ {
+ if (_ctxQueue.TryGetValue(key, out var context))
+ {
+ context.Connection.Close(true);
+ }
+ }
+ }
+ }
+ }
+}
\ No newline at end of file
diff --git a/Vendor/EmbedIO-3.5.2/Net/Internal/EndPointListener.cs b/Vendor/EmbedIO-3.5.2/Net/Internal/EndPointListener.cs
new file mode 100644
index 0000000..caab9c7
--- /dev/null
+++ b/Vendor/EmbedIO-3.5.2/Net/Internal/EndPointListener.cs
@@ -0,0 +1,429 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Net;
+using System.Net.Sockets;
+using System.Threading;
+
+namespace EmbedIO.Net.Internal
+{
+ internal sealed class EndPointListener : IDisposable
+ {
+ private readonly Dictionary _unregistered;
+ private readonly IPEndPoint _endpoint;
+ private readonly Socket _sock;
+ private Dictionary _prefixes;
+ private List? _unhandled; // unhandled; host = '*'
+ private List? _all; // all; host = '+
+
+ public EndPointListener(HttpListener listener, IPAddress address, int port, bool secure)
+ {
+ Listener = listener;
+ Secure = secure;
+ _endpoint = new IPEndPoint(address, port);
+ _sock = new Socket(address.AddressFamily, SocketType.Stream, ProtocolType.Tcp);
+
+ if (address.AddressFamily == AddressFamily.InterNetworkV6 && EndPointManager.UseIpv6)
+ {
+ _sock.SetSocketOption(SocketOptionLevel.IPv6, SocketOptionName.IPv6Only, false);
+ }
+
+ _sock.Bind(_endpoint);
+ _sock.Listen(500);
+ var args = new SocketAsyncEventArgs { UserToken = this };
+ args.Completed += OnAccept;
+ Socket? dummy = null;
+ Accept(_sock, args, ref dummy);
+ _prefixes = new Dictionary();
+ _unregistered = new Dictionary();
+ }
+
+ internal HttpListener Listener { get; }
+
+ internal bool Secure { get; }
+
+ public bool BindContext(HttpListenerContext context)
+ {
+ var req = context.Request;
+ var listener = SearchListener(req.Url, out var prefix);
+
+ if (listener == null)
+ {
+ return false;
+ }
+
+ context.Listener = listener;
+ context.Connection.Prefix = prefix;
+ return true;
+ }
+
+ public void UnbindContext(HttpListenerContext context) => context.Listener.UnregisterContext(context);
+
+ public void Dispose()
+ {
+ _sock.Dispose();
+ List connections;
+
+ lock (_unregistered)
+ {
+ // Clone the list because RemoveConnection can be called from Close
+ connections = new List(_unregistered.Keys);
+ _unregistered.Clear();
+ }
+
+ foreach (var c in connections)
+ {
+ c.Dispose();
+ }
+ }
+
+ public void AddPrefix(ListenerPrefix prefix, HttpListener listener)
+ {
+ List? current;
+ List future;
+
+ if (prefix.Host == "*")
+ {
+ do
+ {
+ current = _unhandled;
+
+ // TODO: Should we clone the items?
+ future = current?.ToList() ?? new List();
+ prefix.Listener = listener;
+ AddSpecial(future, prefix);
+ }
+ while (Interlocked.CompareExchange(ref _unhandled, future, current) != current);
+
+ return;
+ }
+
+ if (prefix.Host == "+")
+ {
+ do
+ {
+ current = _all;
+ future = current?.ToList() ?? new List();
+ prefix.Listener = listener;
+ AddSpecial(future, prefix);
+ }
+ while (Interlocked.CompareExchange(ref _all, future, current) != current);
+ return;
+ }
+
+ Dictionary prefs, p2;
+
+ do
+ {
+ prefs = _prefixes;
+ if (prefs.ContainsKey(prefix))
+ {
+ if (prefs[prefix] != listener)
+ {
+ throw new HttpListenerException(400, $"There is another listener for {prefix}");
+ }
+
+ return;
+ }
+
+ p2 = prefs.ToDictionary(x => x.Key, x => x.Value);
+ p2[prefix] = listener;
+ }
+ while (Interlocked.CompareExchange(ref _prefixes, p2, prefs) != prefs);
+ }
+
+ public void RemovePrefix(ListenerPrefix prefix)
+ {
+ List? current;
+ List future;
+
+ if (prefix.Host == "*")
+ {
+ do
+ {
+ current = _unhandled;
+ future = current?.ToList() ?? new List();
+ if (!RemoveSpecial(future, prefix))
+ {
+ break; // Prefix not found
+ }
+ }
+ while (Interlocked.CompareExchange(ref _unhandled, future, current) != current);
+
+ CheckIfRemove();
+ return;
+ }
+
+ if (prefix.Host == "+")
+ {
+ do
+ {
+ current = _all;
+ future = current?.ToList() ?? new List();
+ if (!RemoveSpecial(future, prefix))
+ {
+ break; // Prefix not found
+ }
+ }
+ while (Interlocked.CompareExchange(ref _all, future, current) != current);
+
+ CheckIfRemove();
+ return;
+ }
+
+ Dictionary prefs, p2;
+
+ do
+ {
+ prefs = _prefixes;
+ var prefixKey = _prefixes.Keys.FirstOrDefault(p => p.Path == prefix.Path);
+
+ if (prefixKey is null)
+ {
+ break;
+ }
+
+ p2 = prefs.ToDictionary(x => x.Key, x => x.Value);
+ _ = p2.Remove(prefixKey);
+ }
+ while (Interlocked.CompareExchange(ref _prefixes, p2, prefs) != prefs);
+
+ CheckIfRemove();
+ }
+
+ internal void RemoveConnection(HttpConnection conn)
+ {
+ lock (_unregistered)
+ {
+ _ = _unregistered.Remove(conn);
+ }
+ }
+
+ private static void Accept(Socket socket, SocketAsyncEventArgs e, ref Socket? accepted)
+ {
+ e.AcceptSocket = null;
+ bool acceptPending;
+
+ try
+ {
+ acceptPending = socket.AcceptAsync(e);
+ }
+ catch
+ {
+ try
+ {
+ accepted?.Dispose();
+ }
+ catch
+ {
+ // ignored
+ }
+
+ accepted = null;
+ return;
+ }
+
+ if (!acceptPending)
+ {
+ ProcessAccept(e);
+ }
+ }
+
+ private static void ProcessAccept(SocketAsyncEventArgs args)
+ {
+ Socket? accepted = null;
+ if (args.SocketError == SocketError.Success)
+ {
+ accepted = args.AcceptSocket;
+ }
+
+ var epl = (EndPointListener)args.UserToken;
+
+ Accept(epl._sock, args, ref accepted);
+ if (accepted == null)
+ {
+ return;
+ }
+
+ if (epl.Secure && epl.Listener.Certificate == null)
+ {
+ accepted.Dispose();
+ return;
+ }
+
+ HttpConnection conn;
+ try
+ {
+ conn = new HttpConnection(accepted, epl);
+ }
+ catch
+ {
+ return;
+ }
+
+ lock (epl._unregistered)
+ {
+ epl._unregistered[conn] = conn;
+ }
+
+ _ = conn.BeginReadRequest();
+ }
+
+ private static void OnAccept(object sender, SocketAsyncEventArgs e) => ProcessAccept(e);
+
+ private static HttpListener? MatchFromList(string path, List? list, out ListenerPrefix? prefix)
+ {
+ prefix = null;
+ if (list == null)
+ {
+ return null;
+ }
+
+ HttpListener? bestMatch = null;
+ var bestLength = -1;
+
+ foreach (var p in list)
+ {
+ if (p.Path.Length < bestLength || !path.StartsWith(p.Path, StringComparison.Ordinal))
+ {
+ continue;
+ }
+
+ bestLength = p.Path.Length;
+ bestMatch = p.Listener;
+ prefix = p;
+ }
+
+ return bestMatch;
+ }
+
+ private static void AddSpecial(ICollection coll, ListenerPrefix prefix)
+ {
+ if (coll == null)
+ {
+ return;
+ }
+
+ if (coll.Any(p => p.Path == prefix.Path))
+ {
+ throw new HttpListenerException(400, "Prefix already in use.");
+ }
+
+ coll.Add(prefix);
+ }
+
+ private static bool RemoveSpecial(IList coll, ListenerPrefix prefix)
+ {
+ if (coll == null)
+ {
+ return false;
+ }
+
+ var c = coll.Count;
+ for (var i = 0; i < c; i++)
+ {
+ if (coll[i].Path != prefix.Path)
+ {
+ continue;
+ }
+
+ coll.RemoveAt(i);
+ return true;
+ }
+
+ return false;
+ }
+
+ private HttpListener? SearchListener(Uri uri, out ListenerPrefix? prefix)
+ {
+ prefix = null;
+ if (uri == null)
+ {
+ return null;
+ }
+
+ var host = uri.Host;
+ var port = uri.Port;
+ var path = WebUtility.UrlDecode(uri.AbsolutePath);
+ var pathSlash = path[path.Length - 1] == '/' ? path : path + "/";
+
+ HttpListener? bestMatch = null;
+ var bestLength = -1;
+
+ if (!string.IsNullOrEmpty(host))
+ {
+ var result = _prefixes;
+
+ foreach (var p in result.Keys)
+ {
+ if (p.Path.Length < bestLength)
+ {
+ continue;
+ }
+
+ if (p.Host != host || p.Port != port)
+ {
+ continue;
+ }
+
+ if (!path.StartsWith(p.Path, StringComparison.Ordinal) && !pathSlash.StartsWith(p.Path, StringComparison.Ordinal))
+ {
+ continue;
+ }
+
+ bestLength = p.Path.Length;
+ bestMatch = result[p];
+ prefix = p;
+ }
+
+ if (bestLength != -1)
+ {
+ return bestMatch;
+ }
+ }
+
+ var list = _unhandled;
+ bestMatch = MatchFromList(path, list, out prefix);
+ if (path != pathSlash && bestMatch == null)
+ {
+ bestMatch = MatchFromList(pathSlash, list, out prefix);
+ }
+
+ if (bestMatch != null)
+ {
+ return bestMatch;
+ }
+
+ list = _all;
+ bestMatch = MatchFromList(path, list, out prefix);
+ if (path != pathSlash && bestMatch == null)
+ {
+ bestMatch = MatchFromList(pathSlash, list, out prefix);
+ }
+
+ return bestMatch;
+ }
+
+ private void CheckIfRemove()
+ {
+ if (_prefixes.Count > 0)
+ {
+ return;
+ }
+
+ var list = _unhandled;
+ if (list != null && list.Count > 0)
+ {
+ return;
+ }
+
+ list = _all;
+ if (list != null && list.Count > 0)
+ {
+ return;
+ }
+
+ EndPointManager.RemoveEndPoint(this, _endpoint);
+ }
+ }
+}
\ No newline at end of file
diff --git a/Vendor/EmbedIO-3.5.2/Net/Internal/HeaderUtility.cs b/Vendor/EmbedIO-3.5.2/Net/Internal/HeaderUtility.cs
new file mode 100644
index 0000000..6e24e11
--- /dev/null
+++ b/Vendor/EmbedIO-3.5.2/Net/Internal/HeaderUtility.cs
@@ -0,0 +1,23 @@
+using System;
+using System.Linq;
+
+namespace EmbedIO.Net.Internal
+{
+ internal static class HeaderUtility
+ {
+ public static string? GetCharset(string? contentType)
+ => contentType?
+ .Split(';')
+ .Select(p => p.Trim())
+ .Where(part => part.StartsWith("charset", StringComparison.OrdinalIgnoreCase))
+ .Select(GetAttributeValue)
+ .FirstOrDefault();
+
+ public static string? GetAttributeValue(string nameAndValue)
+ {
+ var idx = nameAndValue.IndexOf('=');
+
+ return idx < 0 || idx == nameAndValue.Length - 1 ? null : nameAndValue.Substring(idx + 1).Trim().Unquote();
+ }
+ }
+}
\ No newline at end of file
diff --git a/Vendor/EmbedIO-3.5.2/Net/Internal/HttpConnection.InputState.cs b/Vendor/EmbedIO-3.5.2/Net/Internal/HttpConnection.InputState.cs
new file mode 100644
index 0000000..57bc2c5
--- /dev/null
+++ b/Vendor/EmbedIO-3.5.2/Net/Internal/HttpConnection.InputState.cs
@@ -0,0 +1,11 @@
+namespace EmbedIO.Net.Internal
+{
+ partial class HttpConnection
+ {
+ private enum InputState
+ {
+ RequestLine,
+ Headers,
+ }
+ }
+}
\ No newline at end of file
diff --git a/Vendor/EmbedIO-3.5.2/Net/Internal/HttpConnection.LineState.cs b/Vendor/EmbedIO-3.5.2/Net/Internal/HttpConnection.LineState.cs
new file mode 100644
index 0000000..4a3feca
--- /dev/null
+++ b/Vendor/EmbedIO-3.5.2/Net/Internal/HttpConnection.LineState.cs
@@ -0,0 +1,12 @@
+namespace EmbedIO.Net.Internal
+{
+ partial class HttpConnection
+ {
+ private enum LineState
+ {
+ None,
+ Cr,
+ Lf,
+ }
+ }
+}
\ No newline at end of file
diff --git a/Vendor/EmbedIO-3.5.2/Net/Internal/HttpConnection.cs b/Vendor/EmbedIO-3.5.2/Net/Internal/HttpConnection.cs
new file mode 100644
index 0000000..230a46d
--- /dev/null
+++ b/Vendor/EmbedIO-3.5.2/Net/Internal/HttpConnection.cs
@@ -0,0 +1,416 @@
+using System;
+using System.IO;
+using System.Net;
+using System.Net.Security;
+using System.Net.Sockets;
+using System.Security.Cryptography.X509Certificates;
+using System.Text;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace EmbedIO.Net.Internal
+{
+ internal sealed partial class HttpConnection : IDisposable
+ {
+ private const int BufferSize = 8192;
+
+ private readonly Timer _timer;
+ private readonly EndPointListener _epl;
+ private Socket? _sock;
+ private MemoryStream? _ms;
+ private byte[]? _buffer;
+ private HttpListenerContext _context;
+ private StringBuilder? _currentLine;
+ private RequestStream? _iStream;
+ private ResponseStream? _oStream;
+ private bool _contextBound;
+ private int _sTimeout = 90000; // 90k ms for first request, 15k ms from then on
+ private HttpListener? _lastListener;
+ private InputState _inputState = InputState.RequestLine;
+ private LineState _lineState = LineState.None;
+ private int _position;
+ private string? _errorMessage;
+
+ public HttpConnection(Socket sock, EndPointListener epl)
+ {
+ _sock = sock;
+ _epl = epl;
+ IsSecure = epl.Secure;
+ LocalEndPoint = (IPEndPoint) sock.LocalEndPoint;
+ RemoteEndPoint = (IPEndPoint) sock.RemoteEndPoint;
+
+ Stream = new NetworkStream(sock, false);
+ if (IsSecure)
+ {
+ var sslStream = new SslStream(Stream, true);
+
+ try
+ {
+ sslStream.AuthenticateAsServer(epl.Listener.Certificate);
+ }
+ catch
+ {
+ CloseSocket();
+ throw;
+ }
+
+ Stream = sslStream;
+ }
+
+ _timer = new Timer(OnTimeout, null, Timeout.Infinite, Timeout.Infinite);
+ _context = null!; // Silence warning about uninitialized field - _context will be initialized by the Init method
+ Init();
+ }
+
+ public int Reuses { get; private set; }
+
+ public Stream Stream { get; }
+
+ public IPEndPoint LocalEndPoint { get; }
+
+ public IPEndPoint RemoteEndPoint { get; }
+
+ public bool IsSecure { get; }
+
+ public ListenerPrefix? Prefix { get; set; }
+
+ public void Dispose()
+ {
+ Close(true);
+
+ _timer.Dispose();
+ _sock?.Dispose();
+ _ms?.Dispose();
+ _iStream?.Dispose();
+ _oStream?.Dispose();
+ Stream?.Dispose();
+ _lastListener?.Dispose();
+ }
+
+ public async Task BeginReadRequest()
+ {
+ _buffer ??= new byte[BufferSize];
+
+ try
+ {
+ if (Reuses == 1)
+ {
+ _sTimeout = 15000;
+ }
+
+ _ = _timer.Change(_sTimeout, Timeout.Infinite);
+
+ var data = await Stream.ReadAsync(_buffer, 0, BufferSize).ConfigureAwait(false);
+ await OnReadInternal(data).ConfigureAwait(false);
+ }
+ catch
+ {
+ _ = _timer.Change(Timeout.Infinite, Timeout.Infinite);
+ CloseSocket();
+ Unbind();
+ }
+ }
+
+ public RequestStream GetRequestStream(long contentLength)
+ {
+ if (_iStream == null)
+ {
+ var buffer = _ms.ToArray();
+ var length = (int) _ms.Length;
+ _ms = null;
+
+ _iStream = new RequestStream(Stream, buffer, _position, length - _position, contentLength);
+ }
+
+ return _iStream;
+ }
+
+ public ResponseStream GetResponseStream() => _oStream ??= new ResponseStream(Stream, _context.HttpListenerResponse, _context.Listener?.IgnoreWriteExceptions ?? true);
+
+ internal void SetError(string message) => _errorMessage = message;
+
+ internal void ForceClose() => Close(true);
+
+ internal void Close(bool forceClose = false)
+ {
+ if (_sock != null)
+ {
+ _oStream?.Dispose();
+ _oStream = null;
+ }
+
+ if (_sock == null)
+ {
+ return;
+ }
+
+ forceClose = forceClose
+ || !_context.Request.KeepAlive
+ || _context.Response.Headers["connection"] == "close";
+
+ if (!forceClose)
+ {
+ if (_context.HttpListenerRequest.FlushInput())
+ {
+ Reuses++;
+ Unbind();
+ Init();
+ _ = BeginReadRequest();
+ return;
+ }
+ }
+
+ using (var s = _sock)
+ {
+ _sock = null;
+ try
+ {
+ s?.Shutdown(SocketShutdown.Both);
+ }
+ catch
+ {
+ // ignored
+ }
+ }
+
+ Unbind();
+ RemoveConnection();
+ }
+
+ private void Init()
+ {
+ _contextBound = false;
+ _iStream = null;
+ _oStream = null;
+ Prefix = null;
+ _ms = new MemoryStream();
+ _position = 0;
+ _inputState = InputState.RequestLine;
+ _lineState = LineState.None;
+ _context = new HttpListenerContext(this);
+ }
+
+ private void OnTimeout(object unused)
+ {
+ CloseSocket();
+ Unbind();
+ }
+
+ private async Task OnReadInternal(int offset)
+ {
+ _ = _timer.Change(Timeout.Infinite, Timeout.Infinite);
+
+ // Continue reading until full header is received.
+ // Especially important for multipart requests when the second part of the header arrives after a tiny delay
+ // because the web browser has to measure the content length first.
+ while (true)
+ {
+ try
+ {
+ await _ms.WriteAsync(_buffer, 0, offset).ConfigureAwait(false);
+ if (_ms.Length > 32768)
+ {
+ Close(true);
+ return;
+ }
+ }
+ catch
+ {
+ CloseSocket();
+ Unbind();
+ return;
+ }
+
+ if (offset == 0)
+ {
+ CloseSocket();
+ Unbind();
+ return;
+ }
+
+ if (ProcessInput(_ms))
+ {
+ if (_errorMessage is null)
+ {
+ _context.HttpListenerRequest.FinishInitialization();
+ }
+
+ if (_errorMessage != null || !_epl.BindContext(_context))
+ {
+ Close(true);
+ return;
+ }
+
+ var listener = _context.Listener;
+ if (_lastListener != listener)
+ {
+ RemoveConnection();
+ listener.AddConnection(this);
+ _lastListener = listener;
+ }
+
+ _contextBound = true;
+ listener.RegisterContext(_context);
+ return;
+ }
+
+ offset = await Stream.ReadAsync(_buffer, 0, BufferSize).ConfigureAwait(false);
+ }
+ }
+
+ private void RemoveConnection()
+ {
+ if (_lastListener != null)
+ {
+ _lastListener.RemoveConnection(this);
+ }
+ else
+ {
+ _epl.RemoveConnection(this);
+ }
+ }
+
+ // true -> done processing
+ // false -> need more input
+ private bool ProcessInput(MemoryStream ms)
+ {
+ var buffer = ms.ToArray();
+ var len = (int)ms.Length;
+ var used = 0;
+
+ while (true)
+ {
+ if (_errorMessage != null)
+ {
+ return true;
+ }
+
+ if (_position >= len)
+ {
+ break;
+ }
+
+ string? line;
+ try
+ {
+ line = ReadLine(buffer, _position, len - _position, out used);
+ _position += used;
+ }
+ catch
+ {
+ _errorMessage = "Bad request";
+ return true;
+ }
+
+ if (line == null)
+ {
+ break;
+ }
+
+ if (string.IsNullOrEmpty(line))
+ {
+ if (_inputState == InputState.RequestLine)
+ {
+ continue;
+ }
+
+ _currentLine = null;
+
+ return true;
+ }
+
+ if (_inputState == InputState.RequestLine)
+ {
+ _context.HttpListenerRequest.SetRequestLine(line);
+ _inputState = InputState.Headers;
+ }
+ else
+ {
+ try
+ {
+ _context.HttpListenerRequest.AddHeader(line);
+ }
+ catch (Exception e)
+ {
+ _errorMessage = e.Message;
+ return true;
+ }
+ }
+ }
+
+ if (used == len)
+ {
+ ms.SetLength(0);
+ _position = 0;
+ }
+
+ return false;
+ }
+
+ private string? ReadLine(byte[] buffer, int offset, int len, out int used)
+ {
+ _currentLine ??= new StringBuilder(128);
+
+ var last = offset + len;
+ used = 0;
+ for (var i = offset; i < last && _lineState != LineState.Lf; i++)
+ {
+ used++;
+ var b = buffer[i];
+
+ switch (b)
+ {
+ case 13:
+ _lineState = LineState.Cr;
+ break;
+ case 10:
+ _lineState = LineState.Lf;
+ break;
+ default:
+ _ = _currentLine.Append((char)b);
+ break;
+ }
+ }
+
+ if (_lineState != LineState.Lf)
+ {
+ return null;
+ }
+
+ _lineState = LineState.None;
+ var result = _currentLine.ToString();
+ _currentLine.Length = 0;
+ return result;
+ }
+
+ private void Unbind()
+ {
+ if (!_contextBound)
+ {
+ return;
+ }
+
+ _epl.UnbindContext(_context);
+ _contextBound = false;
+ }
+
+ private void CloseSocket()
+ {
+ if (_sock == null)
+ {
+ return;
+ }
+
+ try
+ {
+ _sock.Dispose();
+ }
+ finally
+ {
+ _sock = null;
+ }
+
+ RemoveConnection();
+ }
+ }
+}
\ No newline at end of file
diff --git a/Vendor/EmbedIO-3.5.2/Net/Internal/HttpListenerContext.cs b/Vendor/EmbedIO-3.5.2/Net/Internal/HttpListenerContext.cs
new file mode 100644
index 0000000..134493c
--- /dev/null
+++ b/Vendor/EmbedIO-3.5.2/Net/Internal/HttpListenerContext.cs
@@ -0,0 +1,129 @@
+using System;
+using System.Collections.Generic;
+using System.Net;
+using System.Security.Principal;
+using System.Threading;
+using System.Threading.Tasks;
+using EmbedIO.Authentication;
+using EmbedIO.Internal;
+using EmbedIO.Routing;
+using EmbedIO.Sessions;
+using EmbedIO.Utilities;
+using EmbedIO.WebSockets;
+using EmbedIO.WebSockets.Internal;
+using Swan.Logging;
+
+namespace EmbedIO.Net.Internal
+{
+ // Provides access to the request and response objects used by the HttpListener class.
+ internal sealed class HttpListenerContext : IHttpContextImpl
+ {
+ private readonly Lazy> _items = new (() => new Dictionary(), true);
+
+ private readonly TimeKeeper _ageKeeper = new ();
+
+ private readonly Stack> _closeCallbacks = new ();
+
+ private bool _closed;
+
+ internal HttpListenerContext(HttpConnection cnc)
+ {
+ Connection = cnc;
+ HttpListenerRequest = new HttpListenerRequest(this);
+ User = Auth.NoUser;
+ HttpListenerResponse = new HttpListenerResponse(this);
+ Id = UniqueIdGenerator.GetNext();
+ LocalEndPoint = Request.LocalEndPoint;
+ RemoteEndPoint = Request.RemoteEndPoint;
+ Route = RouteMatch.None;
+ Session = SessionProxy.None;
+ }
+
+ public string Id { get; }
+
+ public CancellationToken CancellationToken { get; set; }
+
+ public long Age => _ageKeeper.ElapsedTime;
+
+ public IPEndPoint LocalEndPoint { get; }
+
+ public IPEndPoint RemoteEndPoint { get; }
+
+ public IHttpRequest Request => HttpListenerRequest;
+
+ public RouteMatch Route { get; set; }
+
+ public string RequestedPath => Route.SubPath ?? string.Empty; // It will never be empty, because modules are matched via base routes - this is just to silence a warning.
+
+ public IHttpResponse Response => HttpListenerResponse;
+
+ public IPrincipal User { get; set; }
+
+ public ISessionProxy Session { get; set; }
+
+ public bool SupportCompressedRequests { get; set; }
+
+ public IDictionary Items => _items.Value;
+
+ public bool IsHandled { get; private set; }
+
+ public MimeTypeProviderStack MimeTypeProviders { get; } = new MimeTypeProviderStack();
+
+ internal HttpListenerRequest HttpListenerRequest { get; }
+
+ internal HttpListenerResponse HttpListenerResponse { get; }
+
+ internal HttpListener? Listener { get; set; }
+
+ internal HttpConnection Connection { get; }
+
+ public void SetHandled() => IsHandled = true;
+
+ public void OnClose(Action callback)
+ {
+ if (_closed)
+ {
+ throw new InvalidOperationException("HTTP context has already been closed.");
+ }
+
+ _closeCallbacks.Push(Validate.NotNull(nameof(callback), callback));
+ }
+
+ public void Close()
+ {
+ _closed = true;
+
+ // Always close the response stream no matter what.
+ Response.Close();
+
+ foreach (var callback in _closeCallbacks)
+ {
+ try
+ {
+ callback(this);
+ }
+ catch (Exception e)
+ {
+ e.Log("HTTP context", $"[{Id}] Exception thrown by a HTTP context close callback.");
+ }
+ }
+ }
+
+ public async Task AcceptWebSocketAsync(
+ IEnumerable requestedProtocols,
+ string acceptedProtocol,
+ int receiveBufferSize,
+ TimeSpan keepAliveInterval,
+ CancellationToken cancellationToken)
+ {
+ var webSocket = await WebSocket.AcceptAsync(this, acceptedProtocol).ConfigureAwait(false);
+ return new WebSocketContext(this, WebSocket.SupportedVersion, requestedProtocols, acceptedProtocol, webSocket, cancellationToken);
+ }
+
+ public string GetMimeType(string extension)
+ => MimeTypeProviders.GetMimeType(extension);
+
+ public bool TryDetermineCompression(string mimeType, out bool preferCompression)
+ => MimeTypeProviders.TryDetermineCompression(mimeType, out preferCompression);
+ }
+}
\ No newline at end of file
diff --git a/Vendor/EmbedIO-3.5.2/Net/Internal/HttpListenerPrefixCollection.cs b/Vendor/EmbedIO-3.5.2/Net/Internal/HttpListenerPrefixCollection.cs
new file mode 100644
index 0000000..6248b6f
--- /dev/null
+++ b/Vendor/EmbedIO-3.5.2/Net/Internal/HttpListenerPrefixCollection.cs
@@ -0,0 +1,30 @@
+using System.Collections.Generic;
+
+namespace EmbedIO.Net.Internal
+{
+ internal class HttpListenerPrefixCollection : List
+ {
+ private readonly HttpListener _listener;
+
+ internal HttpListenerPrefixCollection(HttpListener listener)
+ {
+ _listener = listener;
+ }
+
+ public new void Add(string uriPrefix)
+ {
+ ListenerPrefix.CheckUri(uriPrefix);
+ if (Contains(uriPrefix))
+ {
+ return;
+ }
+
+ base.Add(uriPrefix);
+
+ if (_listener.IsListening)
+ {
+ EndPointManager.AddPrefix(uriPrefix, _listener);
+ }
+ }
+ }
+}
\ No newline at end of file
diff --git a/Vendor/EmbedIO-3.5.2/Net/Internal/HttpListenerRequest.cs b/Vendor/EmbedIO-3.5.2/Net/Internal/HttpListenerRequest.cs
new file mode 100644
index 0000000..548f44d
--- /dev/null
+++ b/Vendor/EmbedIO-3.5.2/Net/Internal/HttpListenerRequest.cs
@@ -0,0 +1,497 @@
+using System;
+using System.Collections.Specialized;
+using System.Globalization;
+using System.IO;
+using System.Linq;
+using System.Net;
+using System.Security.Cryptography.X509Certificates;
+using System.Text;
+using EmbedIO.Internal;
+using EmbedIO.Utilities;
+
+namespace EmbedIO.Net.Internal
+{
+ ///
+ /// Represents an HTTP Listener Request.
+ ///
+ internal sealed partial class HttpListenerRequest : IHttpRequest
+ {
+ private static readonly byte[] HttpStatus100 = WebServer.DefaultEncoding.GetBytes("HTTP/1.1 100 Continue\r\n\r\n");
+ private static readonly char[] Separators = { ' ' };
+
+ private readonly HttpConnection _connection;
+ private CookieList? _cookies;
+ private Stream? _inputStream;
+ private bool _kaSet;
+ private bool _keepAlive;
+
+ internal HttpListenerRequest(HttpListenerContext context)
+ {
+ _connection = context.Connection;
+ }
+
+ ///
+ /// Gets the MIME accept types.
+ ///
+ ///
+ /// The accept types.
+ ///
+ public string[] AcceptTypes { get; private set; } = Array.Empty();
+
+ ///
+ public Encoding ContentEncoding
+ {
+ get
+ {
+ if (!HasEntityBody || ContentType == null)
+ {
+ return WebServer.DefaultEncoding;
+ }
+
+ var charSet = HeaderUtility.GetCharset(ContentType);
+ if (string.IsNullOrEmpty(charSet))
+ {
+ return WebServer.DefaultEncoding;
+ }
+
+ try
+ {
+ return Encoding.GetEncoding(charSet);
+ }
+ catch (ArgumentException)
+ {
+ return WebServer.DefaultEncoding;
+ }
+ }
+ }
+
+ ///
+ public long ContentLength64 => long.TryParse(Headers[HttpHeaderNames.ContentLength], out var val) ? val : 0;
+
+ ///
+ public string ContentType => Headers[HttpHeaderNames.ContentType];
+
+ ///
+ public ICookieCollection Cookies => _cookies ??= new CookieList();
+
+ ///
+ public bool HasEntityBody => ContentLength64 > 0;
+
+ ///
+ public NameValueCollection Headers { get; } = new ();
+
+ ///
+ public string HttpMethod { get; private set; } = string.Empty;
+
+ ///
+ public HttpVerbs HttpVerb { get; private set; }
+
+ ///
+ public Stream InputStream => _inputStream ??= ContentLength64 > 0 ? _connection.GetRequestStream(ContentLength64) : Stream.Null;
+
+ ///
+ public bool IsAuthenticated => false;
+
+ ///
+ public bool IsLocal => LocalEndPoint.Address?.Equals(RemoteEndPoint.Address) ?? true;
+
+ ///
+ public bool IsSecureConnection => _connection.IsSecure;
+
+ ///
+ public bool KeepAlive
+ {
+ get
+ {
+ if (!_kaSet)
+ {
+ var cnc = Headers.GetValues(HttpHeaderNames.Connection);
+ _keepAlive = ProtocolVersion < HttpVersion.Version11
+ ? cnc != null && cnc.Length == 1 && string.Compare(cnc[0], "keep-alive", StringComparison.OrdinalIgnoreCase) == 0
+ : cnc == null || cnc.All(s => string.Compare(s, "close", StringComparison.OrdinalIgnoreCase) != 0);
+
+ _kaSet = true;
+ }
+
+ return _keepAlive;
+ }
+ }
+
+ ///
+ public IPEndPoint LocalEndPoint => _connection.LocalEndPoint;
+
+ ///
+ public Version ProtocolVersion { get; private set; } = HttpVersion.Version11;
+
+ ///
+ public NameValueCollection QueryString { get; } = new ();
+
+ ///
+ public string RawUrl { get; private set; } = string.Empty;
+
+ ///
+ public IPEndPoint RemoteEndPoint => _connection.RemoteEndPoint;
+
+ ///
+ public Uri Url { get; private set; } = WebServer.NullUri;
+
+ ///
+ public Uri? UrlReferrer { get; private set; }
+
+ ///
+ public string UserAgent => Headers[HttpHeaderNames.UserAgent];
+
+ public string UserHostAddress => LocalEndPoint.ToString();
+
+ public string UserHostName => Headers[HttpHeaderNames.Host];
+
+ public string[] UserLanguages { get; private set; } = Array.Empty();
+
+ ///
+ public bool IsWebSocketRequest
+ => HttpVerb == HttpVerbs.Get
+ && ProtocolVersion >= HttpVersion.Version11
+ && Headers.Contains(HttpHeaderNames.Upgrade, "websocket")
+ && Headers.Contains(HttpHeaderNames.Connection, "Upgrade");
+
+ internal void SetRequestLine(string req)
+ {
+ const string forbiddenMethodChars = "\"(),/:;<=>?@[\\]{}";
+
+ var parts = req.Split(Separators, 3);
+ if (parts.Length != 3)
+ {
+ _connection.SetError("Invalid request line (parts).");
+ return;
+ }
+
+ HttpMethod = parts[0];
+ foreach (var c in HttpMethod)
+ {
+ // See https://tools.ietf.org/html/rfc7230#section-3.2.6
+ // for the list of allowed characters
+ if (c < 32 || c >= 127 || forbiddenMethodChars.IndexOf(c) >= 0)
+ {
+ _connection.SetError("(Invalid verb)");
+ return;
+ }
+ }
+
+ HttpVerb = IsKnownHttpMethod(HttpMethod, out var verb) ? verb : HttpVerbs.Any;
+
+ RawUrl = parts[1];
+ if (parts[2].Length != 8 || !parts[2].StartsWith("HTTP/", StringComparison.Ordinal))
+ {
+ _connection.SetError("Invalid request line (missing HTTP version).");
+ return;
+ }
+
+ try
+ {
+ ProtocolVersion = new Version(parts[2].Substring(5));
+
+ if (ProtocolVersion.Major < 1)
+ {
+ throw new InvalidOperationException();
+ }
+ }
+ catch
+ {
+ _connection.SetError("Invalid request line (could not parse HTTP version).");
+ }
+ }
+
+ internal void FinishInitialization()
+ {
+ var host = UserHostName;
+ if (ProtocolVersion > HttpVersion.Version10 && string.IsNullOrEmpty(host))
+ {
+ _connection.SetError("Invalid host name");
+ return;
+ }
+
+ var rawUri = UriUtility.StringToAbsoluteUri(RawUrl.ToLowerInvariant());
+ var path = rawUri?.PathAndQuery ?? RawUrl;
+
+ if (string.IsNullOrEmpty(host))
+ {
+ host = rawUri?.Host ?? UserHostAddress;
+ }
+
+ var colonPos = host.LastIndexOf(':');
+ var closedSquareBracketPos = host.LastIndexOf(']');
+ if (colonPos >= 0 && closedSquareBracketPos < colonPos)
+ {
+ host = host.Substring(0, colonPos);
+ }
+
+ // var baseUri = $"{(IsSecureConnection ? "https" : "http")}://{host}:{LocalEndPoint.Port}";
+ var baseUri = $"http://{host}:{LocalEndPoint.Port}";
+
+ if (!Uri.TryCreate(baseUri + path, UriKind.Absolute, out var url))
+ {
+ _connection.SetError(WebUtility.HtmlEncode($"Invalid url: {baseUri}{path}"));
+ return;
+ }
+
+ Url = url;
+ InitializeQueryString(Url.Query);
+
+ if (ContentLength64 == 0 && (HttpVerb == HttpVerbs.Post || HttpVerb == HttpVerbs.Put))
+ {
+ return;
+ }
+
+ if (string.Compare(Headers["Expect"], "100-continue", StringComparison.OrdinalIgnoreCase) == 0)
+ {
+ _connection.GetResponseStream().InternalWrite(HttpStatus100, 0, HttpStatus100.Length);
+ }
+ }
+
+ internal void AddHeader(string header)
+ {
+ var colon = header.IndexOf(':');
+ if (colon == -1 || colon == 0)
+ {
+ _connection.SetError("Bad Request");
+ return;
+ }
+
+ var name = header.Substring(0, colon).Trim();
+ var val = header.Substring(colon + 1).Trim();
+
+ Headers.Set(name, val);
+
+ switch (name.ToLowerInvariant())
+ {
+ case "accept-language":
+ UserLanguages = val.SplitByComma(); // yes, only split with a ','
+ break;
+ case "accept":
+ AcceptTypes = val.SplitByComma(); // yes, only split with a ','
+ break;
+ case "content-length":
+ Headers[HttpHeaderNames.ContentLength] = val.Trim();
+
+ if (ContentLength64 < 0)
+ {
+ _connection.SetError("Invalid Content-Length.");
+ }
+
+ break;
+ case "referer":
+ try
+ {
+ UrlReferrer = new Uri(val);
+ }
+ catch
+ {
+ UrlReferrer = null;
+ }
+
+ break;
+ case "cookie":
+ ParseCookies(val);
+
+ break;
+ }
+ }
+
+ // returns true is the stream could be reused.
+ internal bool FlushInput()
+ {
+ if (!HasEntityBody)
+ {
+ return true;
+ }
+
+ var length = 2048;
+ if (ContentLength64 > 0)
+ {
+ length = (int)Math.Min(ContentLength64, length);
+ }
+
+ var bytes = new byte[length];
+
+ while (true)
+ {
+ try
+ {
+ if (InputStream.Read(bytes, 0, length) <= 0)
+ {
+ return true;
+ }
+ }
+ catch (ObjectDisposedException)
+ {
+ _inputStream = null;
+ return true;
+ }
+ catch
+ {
+ return false;
+ }
+ }
+ }
+
+ // Optimized for the following list of methods:
+ // "DELETE", "GET", "HEAD", "OPTIONS", "PATCH", "POST", "PUT"
+ // ***NOTE***: The verb parameter is NOT VALID upon exit if false is returned.
+ private static bool IsKnownHttpMethod(string method, out HttpVerbs verb)
+ {
+ switch (method.Length)
+ {
+ case 3:
+ switch (method[0])
+ {
+ case 'G':
+ verb = HttpVerbs.Get;
+ return method[1] == 'E' && method[2] == 'T';
+
+ case 'P':
+ verb = HttpVerbs.Put;
+ return method[1] == 'U' && method[2] == 'T';
+
+ default:
+ verb = HttpVerbs.Any;
+ return false;
+ }
+
+ case 4:
+ switch (method[0])
+ {
+ case 'H':
+ verb = HttpVerbs.Head;
+ return method[1] == 'E' && method[2] == 'A' && method[3] == 'D';
+
+ case 'P':
+ verb = HttpVerbs.Post;
+ return method[1] == 'O' && method[2] == 'S' && method[3] == 'T';
+
+ default:
+ verb = HttpVerbs.Any;
+ return false;
+ }
+
+ case 5:
+ verb = HttpVerbs.Patch;
+ return method[0] == 'P'
+ && method[1] == 'A'
+ && method[2] == 'T'
+ && method[3] == 'C'
+ && method[4] == 'H';
+
+ case 6:
+ verb = HttpVerbs.Delete;
+ return method[0] == 'D'
+ && method[1] == 'E'
+ && method[2] == 'L'
+ && method[3] == 'E'
+ && method[4] == 'T'
+ && method[5] == 'E';
+
+ case 7:
+ verb = HttpVerbs.Options;
+ return method[0] == 'O'
+ && method[1] == 'P'
+ && method[2] == 'T'
+ && method[3] == 'I'
+ && method[4] == 'O'
+ && method[5] == 'N'
+ && method[6] == 'S';
+
+ default:
+ verb = HttpVerbs.Any;
+ return false;
+ }
+ }
+
+ private void ParseCookies(string val)
+ {
+ _cookies ??= new CookieList();
+
+ var cookieStrings = val.SplitByAny(';', ',')
+ .Where(x => !string.IsNullOrEmpty(x));
+ Cookie? current = null;
+ var version = 0;
+
+ foreach (var str in cookieStrings)
+ {
+ if (str.StartsWith("$Version", StringComparison.Ordinal))
+ {
+ version = int.Parse(str.Substring(str.IndexOf('=') + 1).Unquote(), CultureInfo.InvariantCulture);
+ }
+ else if (str.StartsWith("$Path", StringComparison.Ordinal) && current != null)
+ {
+ current.Path = str.Substring(str.IndexOf('=') + 1).Trim();
+ }
+ else if (str.StartsWith("$Domain", StringComparison.Ordinal) && current != null)
+ {
+ current.Domain = str.Substring(str.IndexOf('=') + 1).Trim();
+ }
+ else if (str.StartsWith("$Port", StringComparison.Ordinal) && current != null)
+ {
+ current.Port = str.Substring(str.IndexOf('=') + 1).Trim();
+ }
+ else
+ {
+ if (current != null)
+ {
+ _cookies.Add(current);
+ }
+
+ current = new Cookie();
+ var idx = str.IndexOf('=');
+ if (idx > 0)
+ {
+ current.Name = str.Substring(0, idx).Trim();
+ current.Value = str.Substring(idx + 1).Trim();
+ }
+ else
+ {
+ current.Name = str.Trim();
+ current.Value = string.Empty;
+ }
+
+ current.Version = version;
+ }
+ }
+
+ if (current != null)
+ {
+ _cookies.Add(current);
+ }
+ }
+
+ private void InitializeQueryString(string query)
+ {
+ if (string.IsNullOrEmpty(query))
+ {
+ return;
+ }
+
+ if (query[0] == '?')
+ {
+ query = query.Substring(1);
+ }
+
+ var components = query.Split('&');
+
+ foreach (var kv in components)
+ {
+ var pos = kv.IndexOf('=');
+ if (pos == -1)
+ {
+ QueryString.Add(null, WebUtility.UrlDecode(kv));
+ }
+ else
+ {
+ var key = WebUtility.UrlDecode(kv.Substring(0, pos));
+ var val = WebUtility.UrlDecode(kv.Substring(pos + 1));
+
+ QueryString.Add(key, val);
+ }
+ }
+ }
+ }
+}
\ No newline at end of file
diff --git a/Vendor/EmbedIO-3.5.2/Net/Internal/HttpListenerResponse.cs b/Vendor/EmbedIO-3.5.2/Net/Internal/HttpListenerResponse.cs
new file mode 100644
index 0000000..be8703a
--- /dev/null
+++ b/Vendor/EmbedIO-3.5.2/Net/Internal/HttpListenerResponse.cs
@@ -0,0 +1,411 @@
+using System;
+using System.Globalization;
+using System.IO;
+using System.Linq;
+using System.Net;
+using System.Text;
+using EmbedIO.Utilities;
+
+namespace EmbedIO.Net.Internal
+{
+ ///
+ /// Represents an HTTP Listener's response.
+ ///
+ ///
+ internal sealed class HttpListenerResponse : IHttpResponse, IDisposable
+ {
+ private readonly HttpConnection _connection;
+ private readonly HttpListenerRequest _request;
+ private readonly string _id;
+ private bool _disposed;
+ private string _contentType = MimeType.Html; // Same default value as Microsoft's implementation
+ private CookieList? _cookies;
+ private bool _keepAlive;
+ private ResponseStream? _outputStream;
+ private int _statusCode = 200;
+ private bool _chunked;
+
+ internal HttpListenerResponse(HttpListenerContext context)
+ {
+ _request = context.HttpListenerRequest;
+ _connection = context.Connection;
+ _id = context.Id;
+ _keepAlive = context.Request.KeepAlive;
+ }
+
+ ///
+ public Encoding? ContentEncoding { get; set; } = WebServer.DefaultEncoding;
+
+ ///
+ /// This instance has been disposed.
+ /// This property is being set and headers were already sent.
+ public long ContentLength64
+ {
+ get => Headers.ContainsKey(HttpHeaderNames.ContentLength) && long.TryParse(Headers[HttpHeaderNames.ContentLength], out var val) ? val : 0;
+
+ set
+ {
+ EnsureCanChangeHeaders();
+ if (value < 0)
+ {
+ throw new ArgumentOutOfRangeException(nameof(value), "Must be >= 0");
+ }
+
+ Headers[HttpHeaderNames.ContentLength] = value.ToString(CultureInfo.InvariantCulture);
+ }
+ }
+
+ ///
+ /// This instance has been disposed.
+ /// This property is being set and headers were already sent.
+ /// This property is being set to .
+ /// This property is being set to the empty string.
+ public string ContentType
+ {
+ get => _contentType;
+
+ set
+ {
+ EnsureCanChangeHeaders();
+ _contentType = Validate.NotNullOrEmpty(nameof(value), value);
+ }
+ }
+
+ ///
+ public ICookieCollection Cookies => CookieCollection;
+
+ ///
+ public WebHeaderCollection Headers { get; } = new WebHeaderCollection();
+
+ ///
+ public bool KeepAlive
+ {
+ get => _keepAlive;
+
+ set
+ {
+ EnsureCanChangeHeaders();
+ _keepAlive = value;
+ }
+ }
+
+ ///
+ public Stream OutputStream => _outputStream ??= _connection.GetResponseStream();
+
+ ///
+ public Version ProtocolVersion => _request.ProtocolVersion;
+
+ ///
+ /// This instance has been disposed.
+ /// This property is being set and headers were already sent.
+ public bool SendChunked
+ {
+ get => _chunked;
+
+ set
+ {
+ EnsureCanChangeHeaders();
+ _chunked = value;
+ }
+ }
+
+ ///
+ /// This instance has been disposed.
+ /// This property is being set and headers were already sent.
+ public int StatusCode
+ {
+ get => _statusCode;
+
+ set
+ {
+ EnsureCanChangeHeaders();
+ if (value < 100 || value > 999)
+ {
+ throw new ArgumentOutOfRangeException(nameof(StatusCode), "StatusCode must be between 100 and 999.");
+ }
+
+ _statusCode = value;
+ StatusDescription = HttpListenerResponseHelper.GetStatusDescription(value);
+ }
+ }
+
+ ///
+ public string StatusDescription { get; set; } = "OK";
+
+ internal CookieList CookieCollection
+ {
+ get => _cookies ??= new CookieList();
+ set => _cookies = value;
+ }
+
+ internal bool HeadersSent { get; set; }
+
+ void IDisposable.Dispose() => Close(true);
+
+ public void Close()
+ {
+ if (!_disposed)
+ {
+ Close(false);
+ }
+ }
+
+ ///
+ public void SetCookie(Cookie cookie)
+ {
+ if (cookie == null)
+ {
+ throw new ArgumentNullException(nameof(cookie));
+ }
+
+ if (_cookies != null)
+ {
+ if (_cookies.Any(c => cookie.Name == c.Name && cookie.Domain == c.Domain && cookie.Path == c.Path))
+ {
+ throw new ArgumentException("The cookie already exists.");
+ }
+ }
+ else
+ {
+ _cookies = new CookieList();
+ }
+
+ _cookies.Add(cookie);
+ }
+
+ internal MemoryStream SendHeaders(bool closing)
+ {
+ if (_contentType != null)
+ {
+ var contentTypeValue = _contentType.IndexOf("charset=", StringComparison.Ordinal) == -1 && ContentEncoding is not null
+ ? $"{_contentType}; charset={ContentEncoding.WebName}"
+ : _contentType;
+
+ Headers.Add(HttpHeaderNames.ContentType, contentTypeValue);
+ }
+
+ if (Headers[HttpHeaderNames.Server] == null)
+ {
+ Headers.Add(HttpHeaderNames.Server, WebServer.Signature);
+ }
+
+ if (Headers[HttpHeaderNames.Date] == null)
+ {
+ Headers.Add(HttpHeaderNames.Date, HttpDate.Format(DateTime.UtcNow));
+ }
+
+ // HTTP did not support chunked transfer encoding before version 1.1;
+ // besides, there's no point in setting transfer encoding at all without a request body.
+ if (closing || ProtocolVersion < HttpVersion.Version11)
+ {
+ _chunked = false;
+ }
+
+ // Was content length set to a valid value, AND chunked encoding not set?
+ // Note that this does not mean that a response body _will_ be sent
+ // as this could be the response to a HEAD request.
+ var haveContentLength = !_chunked
+ && Headers.ContainsKey(HttpHeaderNames.ContentLength)
+ && long.TryParse(Headers[HttpHeaderNames.ContentLength], NumberStyles.None, CultureInfo.InvariantCulture, out var contentLength)
+ && contentLength >= 0L;
+
+ if (!haveContentLength)
+ {
+ // Content length could have been set to an invalid value (e.g. "-1")
+ // so we must either force it to 0, or remove the header completely.
+ if (closing)
+ {
+ // Content length was not explicitly set to a valid value,
+ // and there is no request body.
+ Headers[HttpHeaderNames.ContentLength] = "0";
+ }
+ else
+ {
+ // Content length was not explicitly set to a valid value,
+ // and we're going to send a request body.
+ // - Remove possibly invalid Content-Length header
+ // - Enable chunked transfer encoding for HTTP 1.1
+ Headers.Remove(HttpHeaderNames.ContentLength);
+ if (ProtocolVersion >= HttpVersion.Version11)
+ {
+ _chunked = true;
+ }
+ }
+ }
+
+ if (_chunked)
+ {
+ Headers.Add(HttpHeaderNames.TransferEncoding, "chunked");
+ }
+
+ //// Apache forces closing the connection for these status codes:
+ //// HttpStatusCode.BadRequest 400
+ //// HttpStatusCode.RequestTimeout 408
+ //// HttpStatusCode.LengthRequired 411
+ //// HttpStatusCode.RequestEntityTooLarge 413
+ //// HttpStatusCode.RequestUriTooLong 414
+ //// HttpStatusCode.InternalServerError 500
+ //// HttpStatusCode.ServiceUnavailable 503
+ var reuses = _connection.Reuses;
+ var keepAlive = _statusCode switch {
+ 400 => false,
+ 408 => false,
+ 411 => false,
+ 413 => false,
+ 414 => false,
+ 500 => false,
+ 503 => false,
+ _ => _keepAlive && reuses < 100
+ };
+
+ _keepAlive = keepAlive;
+ if (keepAlive)
+ {
+ Headers.Add(HttpHeaderNames.Connection, "keep-alive");
+ if (ProtocolVersion >= HttpVersion.Version11)
+ {
+ Headers.Add(HttpHeaderNames.KeepAlive, $"timeout=15,max={100 - reuses}");
+ }
+ }
+ else
+ {
+ Headers.Add(HttpHeaderNames.Connection, "close");
+ }
+
+ return WriteHeaders();
+ }
+
+ private static void AppendSetCookieHeader(StringBuilder sb, Cookie cookie)
+ {
+ if (cookie.Name.Length == 0)
+ {
+ return;
+ }
+
+ _ = sb.Append("Set-Cookie: ");
+
+ if (cookie.Version > 0)
+ {
+ _ = sb.Append("Version=").Append(cookie.Version).Append("; ");
+ }
+
+ _ = sb
+ .Append(cookie.Name)
+ .Append('=')
+ .Append(cookie.Value);
+
+ if (cookie.Expires != DateTime.MinValue)
+ {
+ _ = sb
+ .Append("; Expires=")
+ .Append(HttpDate.Format(cookie.Expires));
+ }
+
+ if (!string.IsNullOrEmpty(cookie.Path))
+ {
+ _ = sb.Append("; Path=").Append(QuotedString(cookie, cookie.Path));
+ }
+
+ if (!string.IsNullOrEmpty(cookie.Domain))
+ {
+ _ = sb.Append("; Domain=").Append(QuotedString(cookie, cookie.Domain));
+ }
+
+ if (!string.IsNullOrEmpty(cookie.Port))
+ {
+ _ = sb.Append("; Port=").Append(cookie.Port);
+ }
+
+ if (cookie.Secure)
+ {
+ _ = sb.Append("; Secure");
+ }
+
+ if (cookie.HttpOnly)
+ {
+ _ = sb.Append("; HttpOnly");
+ }
+
+ _ = sb.Append("\r\n");
+ }
+
+ private static string QuotedString(Cookie cookie, string value)
+ => cookie.Version == 0 || value.IsToken() ? value : "\"" + value.Replace("\"", "\\\"") + "\"";
+
+ private void Close(bool force)
+ {
+ _disposed = true;
+
+ _connection.Close(force);
+ }
+
+ private string GetHeaderData()
+ {
+ var sb = new StringBuilder()
+ .Append("HTTP/")
+ .Append(ProtocolVersion)
+ .Append(' ')
+ .Append(_statusCode)
+ .Append(' ')
+ .Append(StatusDescription)
+ .Append("\r\n");
+
+ foreach (var key in Headers.AllKeys.Where(x => x != "Set-Cookie"))
+ {
+ _ = sb
+ .Append(key)
+ .Append(": ")
+ .Append(Headers[key])
+ .Append("\r\n");
+ }
+
+ if (_cookies != null)
+ {
+ foreach (var cookie in _cookies)
+ {
+ AppendSetCookieHeader(sb, cookie);
+ }
+ }
+
+ if (Headers.ContainsKey(HttpHeaderNames.SetCookie))
+ {
+ foreach (var cookie in CookieList.Parse(Headers[HttpHeaderNames.SetCookie]))
+ {
+ AppendSetCookieHeader(sb, cookie);
+ }
+ }
+
+ return sb.Append("\r\n").ToString();
+ }
+
+ private MemoryStream WriteHeaders()
+ {
+ var stream = new MemoryStream();
+ var data = WebServer.DefaultEncoding.GetBytes(GetHeaderData());
+ var preamble = WebServer.DefaultEncoding.GetPreamble();
+ stream.Write(preamble, 0, preamble.Length);
+ stream.Write(data, 0, data.Length);
+
+ _outputStream ??= _connection.GetResponseStream();
+
+ // Assumes that the ms was at position 0
+ stream.Position = preamble.Length;
+ HeadersSent = true;
+
+ return stream;
+ }
+
+ private void EnsureCanChangeHeaders()
+ {
+ if (_disposed)
+ {
+ throw new ObjectDisposedException(_id);
+ }
+
+ if (HeadersSent)
+ {
+ throw new InvalidOperationException("Header values cannot be changed after headers are sent.");
+ }
+ }
+ }
+}
\ No newline at end of file
diff --git a/Vendor/EmbedIO-3.5.2/Net/Internal/HttpListenerResponseHelper.cs b/Vendor/EmbedIO-3.5.2/Net/Internal/HttpListenerResponseHelper.cs
new file mode 100644
index 0000000..944a1b6
--- /dev/null
+++ b/Vendor/EmbedIO-3.5.2/Net/Internal/HttpListenerResponseHelper.cs
@@ -0,0 +1,55 @@
+namespace EmbedIO.Net.Internal
+{
+ internal static class HttpListenerResponseHelper
+ {
+ internal static string GetStatusDescription(int code) => code switch {
+ 100 => "Continue",
+ 101 => "Switching Protocols",
+ 102 => "Processing",
+ 200 => "OK",
+ 201 => "Created",
+ 202 => "Accepted",
+ 203 => "Non-Authoritative Information",
+ 204 => "No Content",
+ 205 => "Reset Content",
+ 206 => "Partial Content",
+ 207 => "Multi-Status",
+ 300 => "Multiple Choices",
+ 301 => "Moved Permanently",
+ 302 => "Found",
+ 303 => "See Other",
+ 304 => "Not Modified",
+ 305 => "Use Proxy",
+ 307 => "Temporary Redirect",
+ 400 => "Bad Request",
+ 401 => "Unauthorized",
+ 402 => "Payment Required",
+ 403 => "Forbidden",
+ 404 => "Not Found",
+ 405 => "Method Not Allowed",
+ 406 => "Not Acceptable",
+ 407 => "Proxy Authentication Required",
+ 408 => "Request Timeout",
+ 409 => "Conflict",
+ 410 => "Gone",
+ 411 => "Length Required",
+ 412 => "Precondition Failed",
+ 413 => "Request Entity Too Large",
+ 414 => "Request-Uri Too Long",
+ 415 => "Unsupported Media Type",
+ 416 => "Requested Range Not Satisfiable",
+ 417 => "Expectation Failed",
+ 422 => "Unprocessable Entity",
+ 423 => "Locked",
+ 424 => "Failed Dependency",
+ 500 => "Internal Server Error",
+ 501 => "Not Implemented",
+ 502 => "Bad Gateway",
+ 503 => "Service Unavailable",
+ 504 => "Gateway Timeout",
+ 505 => "Http Version Not Supported",
+ 507 => "Insufficient Storage",
+ _ => string.Empty
+ };
+ }
+}
\ No newline at end of file
diff --git a/Vendor/EmbedIO-3.5.2/Net/Internal/ListenerPrefix.cs b/Vendor/EmbedIO-3.5.2/Net/Internal/ListenerPrefix.cs
new file mode 100644
index 0000000..7bd2f1e
--- /dev/null
+++ b/Vendor/EmbedIO-3.5.2/Net/Internal/ListenerPrefix.cs
@@ -0,0 +1,35 @@
+using System;
+
+namespace EmbedIO.Net.Internal
+{
+ internal sealed class ListenerPrefix
+ {
+ public ListenerPrefix(string uri)
+ {
+ var parsedUri = ListenerUri.Parse(uri);
+ Secure = parsedUri.Secure;
+ Host = parsedUri.Host;
+ Port = parsedUri.Port;
+ Path = parsedUri.Path;
+ }
+
+ public HttpListener? Listener { get; set; }
+
+ public bool Secure { get; }
+
+ public string Host { get; }
+
+ public int Port { get; }
+
+ public string Path { get; }
+
+ public static void CheckUri(string uri)
+ {
+ _ = ListenerUri.Parse(uri);
+ }
+
+ public bool IsValid() => Path.IndexOf('%') == -1 && Path.IndexOf("//", StringComparison.Ordinal) == -1;
+
+ public override string ToString() => $"{Host}:{Port} ({(Secure ? "Secure" : "Insecure")}";
+ }
+}
\ No newline at end of file
diff --git a/Vendor/EmbedIO-3.5.2/Net/Internal/ListenerUri.cs b/Vendor/EmbedIO-3.5.2/Net/Internal/ListenerUri.cs
new file mode 100644
index 0000000..e89080d
--- /dev/null
+++ b/Vendor/EmbedIO-3.5.2/Net/Internal/ListenerUri.cs
@@ -0,0 +1,91 @@
+using System;
+
+namespace EmbedIO.Net.Internal
+{
+ internal class ListenerUri
+ {
+ private ListenerUri(bool secure,
+ string host,
+ int port,
+ string path)
+ {
+ Secure = secure;
+ Host = host;
+ Port = port;
+ Path = path;
+ }
+
+ public bool Secure { get; private set; }
+
+ public string Host { get; private set; }
+
+ public int Port { get; private set; }
+
+ public string Path { get; private set; }
+
+ public static ListenerUri Parse(string uri)
+ {
+ bool secure;
+ int port;
+ int parsingPosition;
+ if (uri.StartsWith("http://"))
+ {
+ secure = false;
+ port = 80;
+ parsingPosition = "http://".Length;
+ }
+ else if (uri.StartsWith("https://"))
+ {
+ secure = true;
+ port = 443;
+ parsingPosition = "https://".Length;
+ }
+ else
+ {
+ throw new Exception("Only 'http' and 'https' schemes are supported.");
+ }
+
+ var startOfPath = uri.IndexOf('/', parsingPosition);
+ if (startOfPath == -1)
+ {
+ throw new ArgumentException("Path should end in '/'.");
+ }
+
+ var hostWithPort = uri.Substring(parsingPosition, startOfPath - parsingPosition);
+
+ var startOfPortWithColon = hostWithPort.LastIndexOf(':');
+ if (startOfPortWithColon > -1)
+ {
+ startOfPortWithColon += parsingPosition;
+ }
+
+ var endOfIpV6 = hostWithPort.LastIndexOf(']');
+ if (endOfIpV6 > -1)
+ {
+ endOfIpV6 += parsingPosition;
+ }
+
+ if (endOfIpV6 > startOfPortWithColon)
+ {
+ startOfPortWithColon = -1;
+ }
+
+ if (startOfPortWithColon != -1 && startOfPortWithColon < startOfPath)
+ {
+ if (!int.TryParse(uri.Substring(startOfPortWithColon + 1, startOfPath - startOfPortWithColon - 1), out port) || port <= 0 || port >= 65535)
+ {
+ throw new ArgumentException("Invalid port.");
+ }
+ }
+
+ var host = uri.Substring(parsingPosition, (startOfPortWithColon == -1 ? startOfPath : startOfPortWithColon) - parsingPosition);
+ var path = uri.Substring(startOfPath);
+ if (!path.EndsWith("/"))
+ {
+ throw new ArgumentException("Path should end in '/'.");
+ }
+
+ return new ListenerUri(secure, host, port, path);
+ }
+ }
+}
\ No newline at end of file
diff --git a/Vendor/EmbedIO-3.5.2/Net/Internal/NetExtensions.cs b/Vendor/EmbedIO-3.5.2/Net/Internal/NetExtensions.cs
new file mode 100644
index 0000000..4d80bd0
--- /dev/null
+++ b/Vendor/EmbedIO-3.5.2/Net/Internal/NetExtensions.cs
@@ -0,0 +1,44 @@
+using System;
+using System.Linq;
+using Swan;
+
+namespace EmbedIO.Net.Internal
+{
+ ///
+ /// Represents some System.NET custom extensions.
+ ///
+ internal static class NetExtensions
+ {
+ internal static byte[] ToByteArray(this ushort value, Endianness order)
+ {
+ var bytes = BitConverter.GetBytes(value);
+ if (!order.IsHostOrder())
+ {
+ Array.Reverse(bytes);
+ }
+
+ return bytes;
+ }
+
+ internal static byte[] ToByteArray(this ulong value, Endianness order)
+ {
+ var bytes = BitConverter.GetBytes(value);
+ if (!order.IsHostOrder())
+ {
+ Array.Reverse(bytes);
+ }
+
+ return bytes;
+ }
+
+ internal static byte[] ToHostOrder(this byte[] source, Endianness sourceOrder)
+ => source.Length < 1 ? source
+ : sourceOrder.IsHostOrder() ? source
+ : source.Reverse().ToArray();
+
+ // true: !(true ^ true) or !(false ^ false)
+ // false: !(true ^ false) or !(false ^ true)
+ private static bool IsHostOrder(this Endianness order)
+ => !(BitConverter.IsLittleEndian ^ (order == Endianness.Little));
+ }
+}
\ No newline at end of file
diff --git a/Vendor/EmbedIO-3.5.2/Net/Internal/RequestStream.cs b/Vendor/EmbedIO-3.5.2/Net/Internal/RequestStream.cs
new file mode 100644
index 0000000..9e7fbd6
--- /dev/null
+++ b/Vendor/EmbedIO-3.5.2/Net/Internal/RequestStream.cs
@@ -0,0 +1,143 @@
+using System;
+using System.IO;
+using System.Runtime.InteropServices;
+
+namespace EmbedIO.Net.Internal
+{
+ internal class RequestStream : Stream
+ {
+ private readonly Stream _stream;
+ private readonly byte[] _buffer;
+ private int _offset;
+ private int _length;
+ private long _remainingBody;
+
+ internal RequestStream(Stream stream, byte[] buffer, int offset, int length, long contentLength = -1)
+ {
+ _stream = stream;
+ _buffer = buffer;
+ _offset = offset;
+ _length = length;
+ _remainingBody = contentLength;
+ }
+
+ public override bool CanRead => true;
+
+ public override bool CanSeek => false;
+
+ public override bool CanWrite => false;
+
+ public override long Length => throw new NotSupportedException();
+
+ public override long Position
+ {
+ get => throw new NotSupportedException();
+ set => throw new NotSupportedException();
+ }
+
+ public override void Flush()
+ {
+ }
+
+ public override int Read([In, Out] byte[] buffer, int offset, int count)
+ {
+ // Call FillFromBuffer to check for buffer boundaries even when remaining_body is 0
+ var nread = FillFromBuffer(buffer, offset, count);
+
+ if (nread == -1)
+ {
+ // No more bytes available (Content-Length)
+ return 0;
+ }
+
+ if (nread > 0)
+ {
+ return nread;
+ }
+
+ nread = _stream.Read(buffer, offset, count);
+
+ if (nread > 0 && _remainingBody > 0)
+ {
+ _remainingBody -= nread;
+ }
+
+ return nread;
+ }
+
+ public override long Seek(long offset, SeekOrigin origin) => throw new NotSupportedException();
+
+ public override void SetLength(long value) => throw new NotSupportedException();
+
+ public override void Write(byte[] buffer, int offset, int count) => throw new NotSupportedException();
+
+ // Returns 0 if we can keep reading from the base stream,
+ // > 0 if we read something from the buffer.
+ // -1 if we had a content length set and we finished reading that many bytes.
+ private int FillFromBuffer(byte[] buffer, int off, int count)
+ {
+ if (buffer == null)
+ {
+ throw new ArgumentNullException(nameof(buffer));
+ }
+
+ if (off < 0)
+ {
+ throw new ArgumentOutOfRangeException(nameof(off), "< 0");
+ }
+
+ if (count < 0)
+ {
+ throw new ArgumentOutOfRangeException(nameof(count), "< 0");
+ }
+
+ var len = buffer.Length;
+
+ if (off > len)
+ {
+ throw new ArgumentException("destination offset is beyond array size");
+ }
+
+ if (off > len - count)
+ {
+ throw new ArgumentException("Reading would overrun buffer");
+ }
+
+ if (_remainingBody == 0)
+ {
+ return -1;
+ }
+
+ if (_length == 0)
+ {
+ return 0;
+ }
+
+ var size = Math.Min(_length, count);
+ if (_remainingBody > 0)
+ {
+ size = (int) Math.Min(size, _remainingBody);
+ }
+
+ if (_offset > _buffer.Length - size)
+ {
+ size = Math.Min(size, _buffer.Length - _offset);
+ }
+
+ if (size == 0)
+ {
+ return 0;
+ }
+
+ Buffer.BlockCopy(_buffer, _offset, buffer, off, size);
+ _offset += size;
+ _length -= size;
+ if (_remainingBody > 0)
+ {
+ _remainingBody -= size;
+ }
+
+ return size;
+ }
+ }
+}
\ No newline at end of file
diff --git a/Vendor/EmbedIO-3.5.2/Net/Internal/ResponseStream.cs b/Vendor/EmbedIO-3.5.2/Net/Internal/ResponseStream.cs
new file mode 100644
index 0000000..884d305
--- /dev/null
+++ b/Vendor/EmbedIO-3.5.2/Net/Internal/ResponseStream.cs
@@ -0,0 +1,190 @@
+using System;
+using System.IO;
+using System.Runtime.InteropServices;
+using System.Text;
+
+namespace EmbedIO.Net.Internal
+{
+ internal class ResponseStream : Stream
+ {
+ private static readonly byte[] CrLf = { 13, 10 };
+ private readonly object _headersSyncRoot = new ();
+
+ private readonly Stream _stream;
+ private readonly HttpListenerResponse _response;
+ private readonly bool _ignoreErrors;
+ private bool _disposed;
+ private bool _trailerSent;
+
+ internal ResponseStream(Stream stream, HttpListenerResponse response, bool ignoreErrors)
+ {
+ _response = response;
+ _ignoreErrors = ignoreErrors;
+ _stream = stream;
+ }
+
+ ///
+ public override bool CanRead => false;
+
+ ///
+ public override bool CanSeek => false;
+
+ ///
+ public override bool CanWrite => true;
+
+ ///
+ public override long Length => throw new NotSupportedException();
+
+ ///
+ public override long Position
+ {
+ get => throw new NotSupportedException();
+ set => throw new NotSupportedException();
+ }
+
+ ///
+ public override void Flush()
+ {
+ }
+
+ ///
+ public override void Write(byte[] buffer, int offset, int count)
+ {
+ if (_disposed)
+ {
+ throw new ObjectDisposedException(nameof(ResponseStream));
+ }
+
+ byte[] bytes;
+ var ms = GetHeaders(false);
+ var chunked = _response.SendChunked;
+
+ if (ms != null)
+ {
+ var start = ms.Position; // After the possible preamble for the encoding
+ ms.Position = ms.Length;
+ if (chunked)
+ {
+ bytes = GetChunkSizeBytes(count, false);
+ ms.Write(bytes, 0, bytes.Length);
+ }
+
+ var newCount = Math.Min(count, 16384 - (int)ms.Position + (int)start);
+ ms.Write(buffer, offset, newCount);
+ count -= newCount;
+ offset += newCount;
+ InternalWrite(ms.ToArray(), (int)start, (int)(ms.Length - start));
+ ms.SetLength(0);
+ ms.Capacity = 0; // 'dispose' the buffer in ms.
+ }
+ else if (chunked)
+ {
+ bytes = GetChunkSizeBytes(count, false);
+ InternalWrite(bytes, 0, bytes.Length);
+ }
+
+ if (count > 0)
+ {
+ InternalWrite(buffer, offset, count);
+ }
+
+ if (chunked)
+ {
+ InternalWrite(CrLf, 0, 2);
+ }
+ }
+
+ ///
+ public override int Read([In, Out] byte[] buffer, int offset, int count) => throw new NotSupportedException();
+
+ ///
+ public override long Seek(long offset, SeekOrigin origin) => throw new NotSupportedException();
+
+ ///
+ public override void SetLength(long value) => throw new NotSupportedException();
+
+ internal void InternalWrite(byte[] buffer, int offset, int count)
+ {
+ if (_ignoreErrors)
+ {
+ try
+ {
+ _stream.Write(buffer, offset, count);
+ }
+ catch
+ {
+ // ignored
+ }
+ }
+ else
+ {
+ _stream.Write(buffer, offset, count);
+ }
+ }
+
+ protected override void Dispose(bool disposing)
+ {
+ if (_disposed)
+ {
+ return;
+ }
+
+ _disposed = true;
+
+ if (!disposing)
+ {
+ return;
+ }
+
+ using var ms = GetHeaders(true);
+ var chunked = _response.SendChunked;
+
+ if (_stream.CanWrite)
+ {
+ try
+ {
+ byte[] bytes;
+ if (ms != null)
+ {
+ var start = ms.Position;
+ if (chunked && !_trailerSent)
+ {
+ bytes = GetChunkSizeBytes(0, true);
+ ms.Position = ms.Length;
+ ms.Write(bytes, 0, bytes.Length);
+ }
+
+ InternalWrite(ms.ToArray(), (int)start, (int)(ms.Length - start));
+ _trailerSent = true;
+ }
+ else if (chunked && !_trailerSent)
+ {
+ bytes = GetChunkSizeBytes(0, true);
+ InternalWrite(bytes, 0, bytes.Length);
+ _trailerSent = true;
+ }
+ }
+ catch (ObjectDisposedException)
+ {
+ // Ignored
+ }
+ catch (IOException)
+ {
+ // Ignore error due to connection reset by peer
+ }
+ }
+
+ _response.Close();
+ }
+
+ private static byte[] GetChunkSizeBytes(int size, bool final) => WebServer.DefaultEncoding.GetBytes($"{size:x}\r\n{(final ? "\r\n" : string.Empty)}");
+
+ private MemoryStream? GetHeaders(bool closing)
+ {
+ lock (_headersSyncRoot)
+ {
+ return _response.HeadersSent ? null : _response.SendHeaders(closing);
+ }
+ }
+ }
+}
\ No newline at end of file
diff --git a/Vendor/EmbedIO-3.5.2/Net/Internal/StringExtensions.cs b/Vendor/EmbedIO-3.5.2/Net/Internal/StringExtensions.cs
new file mode 100644
index 0000000..fab8333
--- /dev/null
+++ b/Vendor/EmbedIO-3.5.2/Net/Internal/StringExtensions.cs
@@ -0,0 +1,77 @@
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace EmbedIO.Net.Internal
+{
+ internal static class StringExtensions
+ {
+ private const string TokenSpecialChars = "()<>@,;:\\\"/[]?={} \t";
+
+ internal static bool IsToken(this string @this)
+ => @this.All(c => c >= 0x20 && c < 0x7f && TokenSpecialChars.IndexOf(c) < 0);
+
+ internal static IEnumerable SplitHeaderValue(this string @this, bool useCookieSeparators)
+ {
+ var len = @this.Length;
+
+ var buff = new StringBuilder(32);
+ var escaped = false;
+ var quoted = false;
+
+ for (var i = 0; i < len; i++)
+ {
+ var c = @this[i];
+
+ if (c == '"')
+ {
+ if (escaped)
+ {
+ escaped = false;
+ }
+ else
+ {
+ quoted = !quoted;
+ }
+ }
+ else if (c == '\\')
+ {
+ if (i < len - 1 && @this[i + 1] == '"')
+ {
+ escaped = true;
+ }
+ }
+ else if (c == ',' || (useCookieSeparators && c == ';'))
+ {
+ if (!quoted)
+ {
+ yield return buff.ToString();
+ buff.Length = 0;
+
+ continue;
+ }
+ }
+
+ _ = buff.Append(c);
+ }
+
+ if (buff.Length > 0)
+ {
+ yield return buff.ToString();
+ }
+ }
+
+ internal static string Unquote(this string str)
+ {
+ var start = str.IndexOf('\"');
+ var end = str.LastIndexOf('\"');
+
+ if (start >= 0 && end >= 0)
+ {
+ str = str.Substring(start + 1, end - 1);
+ }
+
+ return str.Trim();
+ }
+ }
+}
\ No newline at end of file
diff --git a/Vendor/EmbedIO-3.5.2/Net/Internal/SystemCookieCollection.cs b/Vendor/EmbedIO-3.5.2/Net/Internal/SystemCookieCollection.cs
new file mode 100644
index 0000000..b792aef
--- /dev/null
+++ b/Vendor/EmbedIO-3.5.2/Net/Internal/SystemCookieCollection.cs
@@ -0,0 +1,56 @@
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Linq;
+using System.Net;
+
+namespace EmbedIO.Net.Internal
+{
+ ///
+ /// Represents a wrapper for System.Net.CookieCollection.
+ ///
+ ///
+ internal sealed class SystemCookieCollection : ICookieCollection
+ {
+ private readonly CookieCollection _collection;
+
+ ///
+ /// Initializes a new instance of the class.
+ ///
+ /// The cookie collection.
+ public SystemCookieCollection(CookieCollection collection)
+ {
+ _collection = collection;
+ }
+
+ ///
+ public int Count => _collection.Count;
+
+ ///
+ public bool IsSynchronized => _collection.IsSynchronized;
+
+ ///
+ public object SyncRoot => _collection.SyncRoot;
+
+ ///
+ public Cookie? this[string name] => _collection[name];
+
+ ///
+ IEnumerator IEnumerable.GetEnumerator() => _collection.OfType().GetEnumerator();
+
+ ///
+ public IEnumerator GetEnumerator() => _collection.GetEnumerator();
+
+ ///
+ public void CopyTo(Array array, int index) => _collection.CopyTo(array, index);
+
+ ///
+ public void CopyTo(Cookie[] array, int index) => _collection.CopyTo(array, index);
+
+ ///
+ public void Add(Cookie cookie) => _collection.Add(cookie);
+
+ ///
+ public bool Contains(Cookie cookie) => _collection.OfType().Contains(cookie);
+ }
+}
\ No newline at end of file
diff --git a/Vendor/EmbedIO-3.5.2/Net/Internal/SystemHttpContext.cs b/Vendor/EmbedIO-3.5.2/Net/Internal/SystemHttpContext.cs
new file mode 100644
index 0000000..4ebd097
--- /dev/null
+++ b/Vendor/EmbedIO-3.5.2/Net/Internal/SystemHttpContext.cs
@@ -0,0 +1,125 @@
+using System;
+using System.Collections.Generic;
+using System.Net;
+using System.Security.Principal;
+using System.Threading;
+using System.Threading.Tasks;
+using EmbedIO.Authentication;
+using EmbedIO.Internal;
+using EmbedIO.Routing;
+using EmbedIO.Sessions;
+using EmbedIO.Utilities;
+using EmbedIO.WebSockets;
+using EmbedIO.WebSockets.Internal;
+using Swan.Logging;
+
+namespace EmbedIO.Net.Internal
+{
+ internal sealed class SystemHttpContext : IHttpContextImpl
+ {
+ private readonly System.Net.HttpListenerContext _context;
+
+ private readonly TimeKeeper _ageKeeper = new ();
+
+ private readonly Stack> _closeCallbacks = new ();
+
+ private bool _closed;
+
+ public SystemHttpContext(System.Net.HttpListenerContext context)
+ {
+ _context = context;
+
+ Request = new SystemHttpRequest(_context);
+ User = _context.User ?? Auth.NoUser;
+ Response = new SystemHttpResponse(_context);
+ Id = UniqueIdGenerator.GetNext();
+ LocalEndPoint = Request.LocalEndPoint;
+ RemoteEndPoint = Request.RemoteEndPoint;
+ Route = RouteMatch.None;
+ Session = SessionProxy.None;
+ }
+
+ public string Id { get; }
+
+ public CancellationToken CancellationToken { get; set; }
+
+ public long Age => _ageKeeper.ElapsedTime;
+
+ public IPEndPoint LocalEndPoint { get; }
+
+ public IPEndPoint RemoteEndPoint { get; }
+
+ public IHttpRequest Request { get; }
+
+ public RouteMatch Route { get; set; }
+
+ public string RequestedPath => Route.SubPath ?? string.Empty; // It will never be empty, because modules are matched via base routes - this is just to silence a warning.
+
+ public IHttpResponse Response { get; }
+
+ public IPrincipal User { get; set; }
+
+ public ISessionProxy Session { get; set; }
+
+ public bool SupportCompressedRequests { get; set; }
+
+ public IDictionary Items { get; } = new Dictionary();
+
+ public bool IsHandled { get; private set; }
+
+ public MimeTypeProviderStack MimeTypeProviders { get; } = new MimeTypeProviderStack();
+
+ public void SetHandled() => IsHandled = true;
+
+ public void OnClose(Action callback)
+ {
+ if (_closed)
+ {
+ throw new InvalidOperationException("HTTP context has already been closed.");
+ }
+
+ _closeCallbacks.Push(Validate.NotNull(nameof(callback), callback));
+ }
+
+ public async Task AcceptWebSocketAsync(
+ IEnumerable requestedProtocols,
+ string acceptedProtocol,
+ int receiveBufferSize,
+ TimeSpan keepAliveInterval,
+ CancellationToken cancellationToken)
+ {
+ var context = await _context.AcceptWebSocketAsync(
+ acceptedProtocol.NullIfEmpty(), // Empty string would throw; use null to signify "no subprotocol" here.
+ receiveBufferSize,
+ keepAliveInterval)
+ .ConfigureAwait(false);
+ return new WebSocketContext(this, context.SecWebSocketVersion, requestedProtocols, acceptedProtocol, new SystemWebSocket(context.WebSocket), cancellationToken);
+ }
+
+ public void Close()
+ {
+ _closed = true;
+
+ // Always close the response stream no matter what.
+ Response.Close();
+
+ foreach (var callback in _closeCallbacks)
+ {
+ try
+ {
+ callback(this);
+ }
+ catch (Exception e)
+ {
+ e.Log("HTTP context", "[Id] Exception thrown by a HTTP context close callback.");
+ }
+ }
+ }
+
+ public string GetMimeType(string extension)
+ => MimeTypeProviders.GetMimeType(extension);
+
+ public bool TryDetermineCompression(string mimeType, out bool preferCompression)
+ => MimeTypeProviders.TryDetermineCompression(mimeType, out preferCompression);
+ }
+}
\ No newline at end of file
diff --git a/Vendor/EmbedIO-3.5.2/Net/Internal/SystemHttpListener.cs b/Vendor/EmbedIO-3.5.2/Net/Internal/SystemHttpListener.cs
new file mode 100644
index 0000000..5d14883
--- /dev/null
+++ b/Vendor/EmbedIO-3.5.2/Net/Internal/SystemHttpListener.cs
@@ -0,0 +1,71 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace EmbedIO.Net.Internal
+{
+ ///
+ /// Represents a wrapper for Microsoft HTTP Listener.
+ ///
+ internal class SystemHttpListener : IHttpListener
+ {
+ private readonly System.Net.HttpListener _httpListener;
+
+ public SystemHttpListener(System.Net.HttpListener httpListener)
+ {
+ _httpListener = httpListener;
+ }
+
+ ///
+ public bool IgnoreWriteExceptions
+ {
+ get => _httpListener.IgnoreWriteExceptions;
+ set => _httpListener.IgnoreWriteExceptions = value;
+ }
+
+ ///
+ public List Prefixes => _httpListener.Prefixes.ToList();
+
+ ///
+ public bool IsListening => _httpListener.IsListening;
+
+ ///
+ public string Name { get; } = "Microsoft HTTP Listener";
+
+ ///
+ public void Start() => _httpListener.Start();
+
+ ///
+ public void Stop() => _httpListener.Stop();
+
+ ///
+ public void AddPrefix(string urlPrefix) => _httpListener.Prefixes.Add(urlPrefix);
+
+ ///
+ public async Task GetContextAsync(CancellationToken cancellationToken)
+ {
+ // System.Net.HttpListener.GetContextAsync may throw ObjectDisposedException
+ // when stopping a WebServer. This has been observed on Mono 5.20.1.19
+ // on Raspberry Pi, but the fact remains that the method does not take
+ // a CancellationToken as parameter, and WebServerBase<>.RunAsync counts on it.
+ System.Net.HttpListenerContext context;
+ try
+ {
+ context = await _httpListener.GetContextAsync().ConfigureAwait(false);
+ }
+ catch (Exception e) when (cancellationToken.IsCancellationRequested)
+ {
+ throw new OperationCanceledException(
+ "Probable cancellation detected by catching an exception in System.Net.HttpListener.GetContextAsync",
+ e,
+ cancellationToken);
+ }
+
+ return new SystemHttpContext(context);
+ }
+
+ void IDisposable.Dispose() => ((IDisposable)_httpListener)?.Dispose();
+ }
+}
\ No newline at end of file
diff --git a/Vendor/EmbedIO-3.5.2/Net/Internal/SystemHttpRequest.cs b/Vendor/EmbedIO-3.5.2/Net/Internal/SystemHttpRequest.cs
new file mode 100644
index 0000000..c266a35
--- /dev/null
+++ b/Vendor/EmbedIO-3.5.2/Net/Internal/SystemHttpRequest.cs
@@ -0,0 +1,121 @@
+using System;
+using System.Collections.Specialized;
+using System.IO;
+using System.Net;
+using System.Text;
+
+namespace EmbedIO.Net.Internal
+{
+ ///
+ /// Represents a wrapper for HttpListenerContext.Request.
+ ///
+ ///
+ public class SystemHttpRequest : IHttpRequest
+ {
+ private readonly System.Net.HttpListenerRequest _request;
+
+ ///
+ /// Initializes a new instance of the class.
+ ///
+ /// The context.
+ public SystemHttpRequest(System.Net.HttpListenerContext context)
+ {
+ _request = context.Request;
+ _ = Enum.TryParse(_request.HttpMethod.Trim(), true, out var verb);
+ HttpVerb = verb;
+ Cookies = new SystemCookieCollection(_request.Cookies);
+ LocalEndPoint = _request.LocalEndPoint!;
+ RemoteEndPoint = _request.RemoteEndPoint!;
+ }
+
+ ///
+ public NameValueCollection Headers => _request.Headers;
+
+ ///
+ public Version ProtocolVersion => _request.ProtocolVersion;
+
+ ///
+ public bool KeepAlive => _request.KeepAlive;
+
+ ///
+ public ICookieCollection Cookies { get; }
+
+ ///
+ public string RawUrl => _request.RawUrl;
+
+ ///
+ public NameValueCollection QueryString => _request.QueryString;
+
+ ///
+ public string HttpMethod => _request.HttpMethod;
+
+ ///
+ public HttpVerbs HttpVerb { get; }
+
+ ///
+ public Uri Url => _request.Url;
+
+ ///
+ public bool HasEntityBody => _request.HasEntityBody;
+
+ ///
+ public Stream InputStream => _request.InputStream;
+
+ ///
+ public Encoding ContentEncoding
+ {
+ get
+ {
+ if (!_request.HasEntityBody || _request.ContentType == null)
+ {
+ return WebServer.DefaultEncoding;
+ }
+
+ var charSet = HeaderUtility.GetCharset(ContentType);
+ if (string.IsNullOrEmpty(charSet))
+ {
+ return WebServer.DefaultEncoding;
+ }
+
+ try
+ {
+ return Encoding.GetEncoding(charSet);
+ }
+ catch (ArgumentException)
+ {
+ return WebServer.DefaultEncoding;
+ }
+ }
+ }
+
+ ///
+ public IPEndPoint RemoteEndPoint { get; }
+
+ ///
+ public bool IsSecureConnection => _request.IsSecureConnection;
+
+ ///
+ public bool IsLocal => _request.IsLocal;
+
+ ///
+ public string UserAgent => _request.UserAgent;
+
+ ///
+ public bool IsWebSocketRequest => _request.IsWebSocketRequest;
+
+ ///
+ public IPEndPoint LocalEndPoint { get; }
+
+ ///
+ public string ContentType => _request.ContentType;
+
+ ///
+ public long ContentLength64 => _request.ContentLength64;
+
+ ///
+ public bool IsAuthenticated => _request.IsAuthenticated;
+
+ ///
+ public Uri? UrlReferrer => _request.UrlReferrer;
+ }
+}
\ No newline at end of file
diff --git a/Vendor/EmbedIO-3.5.2/Net/Internal/SystemHttpResponse.cs b/Vendor/EmbedIO-3.5.2/Net/Internal/SystemHttpResponse.cs
new file mode 100644
index 0000000..a3496f6
--- /dev/null
+++ b/Vendor/EmbedIO-3.5.2/Net/Internal/SystemHttpResponse.cs
@@ -0,0 +1,97 @@
+using System;
+using System.IO;
+using System.Net;
+using System.Text;
+
+namespace EmbedIO.Net.Internal
+{
+ ///
+ /// Represents a wrapper for HttpListenerContext.Response.
+ ///
+ ///
+ public class SystemHttpResponse : IHttpResponse
+ {
+ private readonly System.Net.HttpListenerResponse _response;
+
+ ///
+ /// Initializes a new instance of the class.
+ ///
+ /// The context.
+ public SystemHttpResponse(System.Net.HttpListenerContext context)
+ {
+ _response = context.Response;
+ Cookies = new SystemCookieCollection(_response.Cookies);
+ }
+
+ ///
+ public WebHeaderCollection Headers => _response.Headers;
+
+ ///
+ public int StatusCode
+ {
+ get => _response.StatusCode;
+ set => _response.StatusCode = value;
+ }
+
+ ///
+ public long ContentLength64
+ {
+ get => _response.ContentLength64;
+ set => _response.ContentLength64 = value;
+ }
+
+ ///
+ public string ContentType
+ {
+ get => _response.ContentType;
+ set => _response.ContentType = value;
+ }
+
+ ///
+ public Stream OutputStream => _response.OutputStream;
+
+ ///
+ public ICookieCollection Cookies { get; }
+
+ ///
+ public Encoding? ContentEncoding
+ {
+ get => _response.ContentEncoding;
+ set => _response.ContentEncoding = value;
+ }
+
+ ///
+ public bool KeepAlive
+ {
+ get => _response.KeepAlive;
+ set => _response.KeepAlive = value;
+ }
+
+ ///
+ public bool SendChunked
+ {
+ get => _response.SendChunked;
+ set => _response.SendChunked = value;
+ }
+
+ ///
+ public Version ProtocolVersion
+ {
+ get => _response.ProtocolVersion;
+ set => _response.ProtocolVersion = value;
+ }
+
+ ///
+ public string StatusDescription
+ {
+ get => _response.StatusDescription;
+ set => _response.StatusDescription = value;
+ }
+
+ ///
+ public void SetCookie(Cookie cookie) => _response.SetCookie(cookie);
+
+ ///
+ public void Close() => _response.OutputStream?.Dispose();
+ }
+}
\ No newline at end of file
diff --git a/Vendor/EmbedIO-3.5.2/Net/Internal/WebSocketHandshakeResponse.cs b/Vendor/EmbedIO-3.5.2/Net/Internal/WebSocketHandshakeResponse.cs
new file mode 100644
index 0000000..a5dee52
--- /dev/null
+++ b/Vendor/EmbedIO-3.5.2/Net/Internal/WebSocketHandshakeResponse.cs
@@ -0,0 +1,53 @@
+using System;
+using System.Collections.Specialized;
+using System.Globalization;
+using System.Net;
+using System.Text;
+
+namespace EmbedIO.Net.Internal
+{
+ internal class WebSocketHandshakeResponse
+ {
+ private const int HandshakeStatusCode = (int)HttpStatusCode.SwitchingProtocols;
+
+ internal WebSocketHandshakeResponse(IHttpContext context)
+ {
+ ProtocolVersion = HttpVersion.Version11;
+ Headers = context.Response.Headers;
+ Headers.Clear(); // Use only headers mentioned in RFC6455 - scrap all the rest.
+ StatusCode = HandshakeStatusCode;
+ Reason = HttpListenerResponseHelper.GetStatusDescription(HandshakeStatusCode);
+
+ Headers[HttpHeaderNames.Upgrade] = "websocket";
+ Headers[HttpHeaderNames.Connection] = "Upgrade";
+
+ foreach (var cookie in context.Request.Cookies)
+ {
+ Headers.Add("Set-Cookie", cookie.ToString());
+ }
+ }
+
+ public string Reason { get; }
+
+ public int StatusCode { get; }
+
+ public NameValueCollection Headers { get; }
+
+ public Version ProtocolVersion { get; }
+
+ public override string ToString()
+ {
+ var output = new StringBuilder(64)
+ .AppendFormat(CultureInfo.InvariantCulture, "HTTP/{0} {1} {2}\r\n", ProtocolVersion, StatusCode, Reason);
+
+ foreach (var key in Headers.AllKeys)
+ {
+ _ = output.AppendFormat(CultureInfo.InvariantCulture, "{0}: {1}\r\n", key, Headers[key]);
+ }
+
+ _ = output.Append("\r\n");
+
+ return output.ToString();
+ }
+ }
+}
\ No newline at end of file
diff --git a/Vendor/EmbedIO-3.5.2/RequestDeserializer.cs b/Vendor/EmbedIO-3.5.2/RequestDeserializer.cs
new file mode 100644
index 0000000..dc97545
--- /dev/null
+++ b/Vendor/EmbedIO-3.5.2/RequestDeserializer.cs
@@ -0,0 +1,64 @@
+using System;
+using System.Threading.Tasks;
+using Swan.Formatters;
+using Swan.Logging;
+
+namespace EmbedIO
+{
+ ///
+ /// Provides standard request deserialization callbacks.
+ ///
+ public static class RequestDeserializer
+ {
+ ///
+ /// The default request deserializer used by EmbedIO.
+ /// Equivalent to .
+ ///
+ /// The expected type of the deserialized data.
+ /// The whose request body is to be deserialized.
+ /// A Task, representing the ongoing operation,
+ /// whose result will be the deserialized data.
+ public static Task Default(IHttpContext context) => Json(context);
+
+ ///
+ /// Asynchronously deserializes a request body in JSON format.
+ ///
+ /// The expected type of the deserialized data.
+ /// The whose request body is to be deserialized.
+ /// A Task, representing the ongoing operation,
+ /// whose result will be the deserialized data.
+ public static Task Json(IHttpContext context) => JsonInternal(context, default);
+
+ ///
+ /// Returns a RequestDeserializerCallback
+ /// that will deserialize an HTTP request body in JSON format, using the specified property name casing.
+ ///
+ /// The expected type of the deserialized data.
+ /// The to use.
+ /// A that can be used to deserialize
+ /// a JSON request body.
+ public static RequestDeserializerCallback Json(JsonSerializerCase jsonSerializerCase)
+ => context => JsonInternal(context, jsonSerializerCase);
+
+ private static async Task JsonInternal(IHttpContext context, JsonSerializerCase jsonSerializerCase)
+ {
+ string body;
+ using (var reader = context.OpenRequestText())
+ {
+ body = await reader.ReadToEndAsync().ConfigureAwait(false);
+ }
+
+ try
+ {
+ return Swan.Formatters.Json.Deserialize(body, jsonSerializerCase);
+ }
+ catch (FormatException)
+ {
+ $"[{context.Id}] Cannot convert JSON request body to {typeof(TData).Name}, sending 400 Bad Request..."
+ .Warn($"{nameof(RequestDeserializer)}.{nameof(Json)}");
+
+ throw HttpException.BadRequest("Incorrect request data format.");
+ }
+ }
+ }
+}
\ No newline at end of file
diff --git a/Vendor/EmbedIO-3.5.2/RequestDeserializerCallback`1.cs b/Vendor/EmbedIO-3.5.2/RequestDeserializerCallback`1.cs
new file mode 100644
index 0000000..74ea808
--- /dev/null
+++ b/Vendor/EmbedIO-3.5.2/RequestDeserializerCallback`1.cs
@@ -0,0 +1,13 @@
+using System.Threading.Tasks;
+
+namespace EmbedIO
+{
+ ///
+ /// A callback used to deserialize an HTTP request body.
+ ///
+ /// The expected type of the deserialized data.
+ /// The whose request body is to be deserialized.
+ /// A Task, representing the ongoing operation,
+ /// whose result will be the deserialized data.
+ public delegate Task RequestDeserializerCallback(IHttpContext context);
+}
\ No newline at end of file
diff --git a/Vendor/EmbedIO-3.5.2/RequestHandler.cs b/Vendor/EmbedIO-3.5.2/RequestHandler.cs
new file mode 100644
index 0000000..4258b53
--- /dev/null
+++ b/Vendor/EmbedIO-3.5.2/RequestHandler.cs
@@ -0,0 +1,61 @@
+using System;
+using EmbedIO.Internal;
+
+namespace EmbedIO
+{
+ ///
+ /// Provides standard request handler callbacks.
+ ///
+ ///
+ public static class RequestHandler
+ {
+ ///
+ /// Returns an exception object that, when thrown from a module's
+ /// HandleRequestAsync method, will cause the HTTP context
+ /// to be passed down along the module chain, regardless of the value of the module's
+ /// IsFinalHandler property.
+ ///
+ /// A newly-created .
+ public static Exception PassThrough() => new RequestHandlerPassThroughException();
+
+ ///
+ /// Returns a that unconditionally sends a 401 Unauthorized response.
+ ///
+ /// A message to include in the response.
+ /// A .
+ public static RequestHandlerCallback ThrowUnauthorized(string? message = null)
+ => _ => throw HttpException.Unauthorized(message);
+
+ ///
+ /// Returns a that unconditionally sends a 403 Forbidden response.
+ ///
+ /// A message to include in the response.
+ /// A .
+ public static RequestHandlerCallback ThrowForbidden(string? message = null)
+ => _ => throw HttpException.Forbidden(message);
+
+ ///
+ /// Returns a that unconditionally sends a 400 Bad Request response.
+ ///
+ /// A message to include in the response.
+ /// A .
+ public static RequestHandlerCallback ThrowBadRequest(string? message = null)
+ => _ => throw HttpException.BadRequest(message);
+
+ ///
+ /// Returns a that unconditionally sends a 404 Not Found response.
+ ///
+ /// A message to include in the response.
+ /// A .
+ public static RequestHandlerCallback ThrowNotFound(string? message = null)
+ => _ => throw HttpException.NotFound(message);
+
+ ///
+ /// Returns a that unconditionally sends a 405 Method Not Allowed response.
+ ///
+ /// A message to include in the response.
+ /// A .
+ public static RequestHandlerCallback ThrowMethodNotAllowed(string? message = null)
+ => _ => throw HttpException.MethodNotAllowed(message);
+ }
+}
\ No newline at end of file
diff --git a/Vendor/EmbedIO-3.5.2/RequestHandlerCallback.cs b/Vendor/EmbedIO-3.5.2/RequestHandlerCallback.cs
new file mode 100644
index 0000000..6e95234
--- /dev/null
+++ b/Vendor/EmbedIO-3.5.2/RequestHandlerCallback.cs
@@ -0,0 +1,11 @@
+using System.Threading.Tasks;
+
+namespace EmbedIO
+{
+ ///
+ /// A callback used to handle a request.
+ ///
+ /// An interface representing the context of the request.
+ /// A representing the ongoing operation.
+ public delegate Task RequestHandlerCallback(IHttpContext context);
+}
\ No newline at end of file
diff --git a/Vendor/EmbedIO-3.5.2/ResponseSerializer.cs b/Vendor/EmbedIO-3.5.2/ResponseSerializer.cs
new file mode 100644
index 0000000..311d4ad
--- /dev/null
+++ b/Vendor/EmbedIO-3.5.2/ResponseSerializer.cs
@@ -0,0 +1,181 @@
+using EmbedIO.Utilities;
+using Swan.Formatters;
+using System;
+using System.Threading.Tasks;
+
+namespace EmbedIO
+{
+ ///
+ /// Provides standard response serializer callbacks.
+ ///
+ ///
+ public static class ResponseSerializer
+ {
+ ///
+ /// The default response serializer callback used by EmbedIO.
+ /// Equivalent to Json.
+ ///
+ public static readonly ResponseSerializerCallback Default = Json;
+
+ private static readonly ResponseSerializerCallback ChunkedEncodingBaseSerializer = GetBaseSerializer(false);
+ private static readonly ResponseSerializerCallback BufferingBaseSerializer = GetBaseSerializer(true);
+
+ ///
+ /// Serializes data in JSON format to a HTTP response,
+ /// using the utility class.
+ ///
+ /// The HTTP context of the request.
+ /// The data to serialize.
+ /// A representing the ongoing operation.
+ public static async Task Json(IHttpContext context, object? data)
+ {
+ context.Response.ContentType = MimeType.Json;
+ context.Response.ContentEncoding = WebServer.Utf8NoBomEncoding;
+ await ChunkedEncodingBaseSerializer(context, Swan.Formatters.Json.Serialize(data)).ConfigureAwait(false);
+ }
+
+ ///
+ /// Serializes data in JSON format with the specified
+ /// to a HTTP response, using the utility class.
+ ///
+ /// The JSON serializer case.
+ /// A that can be used to serialize
+ /// data to a HTTP response.
+ public static ResponseSerializerCallback Json(JsonSerializerCase jsonSerializerCase)
+ => async (context, data) => {
+ context.Response.ContentType = MimeType.Json;
+ context.Response.ContentEncoding = WebServer.Utf8NoBomEncoding;
+ await ChunkedEncodingBaseSerializer(context, Swan.Formatters.Json.Serialize(data, jsonSerializerCase))
+ .ConfigureAwait(false);
+ };
+
+ ///
+ /// Serializes data in JSON format with the specified
+ /// to a HTTP response, using the utility class.
+ ///
+ /// The JSON serializer options.
+ /// A that can be used to serialize
+ /// data to a HTTP response.
+ ///
+ /// is .
+ ///
+ public static ResponseSerializerCallback Json(SerializerOptions serializerOptions)
+ {
+ _ = Validate.NotNull(nameof(serializerOptions), serializerOptions);
+
+ return async (context, data) => {
+ context.Response.ContentType = MimeType.Json;
+ context.Response.ContentEncoding = WebServer.Utf8NoBomEncoding;
+ await ChunkedEncodingBaseSerializer(context, Swan.Formatters.Json.Serialize(data, serializerOptions))
+ .ConfigureAwait(false);
+ };
+ }
+
+ ///
+ /// Serializes data in JSON format to a HTTP response, using the utility class.
+ ///
+ /// to write the response body to a memory buffer first,
+ /// then send it all together with a Content-Length header; to use chunked
+ /// transfer encoding.
+ /// A that can be used to serialize
+ /// data to a HTTP response.
+ public static ResponseSerializerCallback Json(bool bufferResponse)
+ => async (context, data) => {
+ context.Response.ContentType = MimeType.Json;
+ context.Response.ContentEncoding = WebServer.Utf8NoBomEncoding;
+ var baseSerializer = None(bufferResponse);
+ await baseSerializer(context, Swan.Formatters.Json.Serialize(data))
+ .ConfigureAwait(false);
+ };
+
+ ///
+ /// Serializes data in JSON format with the specified
+ /// to a HTTP response, using the utility class.
+ ///
+ /// to write the response body to a memory buffer first,
+ /// then send it all together with a Content-Length header; to use chunked
+ /// transfer encoding.
+ /// The JSON serializer case.
+ /// A that can be used to serialize
+ /// data to a HTTP response.
+ public static ResponseSerializerCallback Json(bool bufferResponse, JsonSerializerCase jsonSerializerCase)
+ => async (context, data) => {
+ context.Response.ContentType = MimeType.Json;
+ context.Response.ContentEncoding = WebServer.Utf8NoBomEncoding;
+ var baseSerializer = None(bufferResponse);
+ await baseSerializer(context, Swan.Formatters.Json.Serialize(data, jsonSerializerCase))
+ .ConfigureAwait(false);
+ };
+
+ ///
+ /// Serializes data in JSON format with the specified
+ /// to a HTTP response, using the utility class.
+ ///
+ /// to write the response body to a memory buffer first,
+ /// then send it all together with a Content-Length header; to use chunked
+ /// transfer encoding.
+ /// The JSON serializer options.
+ /// A that can be used to serialize
+ /// data to a HTTP response.
+ ///
+ /// is .
+ ///
+ public static ResponseSerializerCallback Json(bool bufferResponse, SerializerOptions serializerOptions)
+ {
+ _ = Validate.NotNull(nameof(serializerOptions), serializerOptions);
+
+ return async (context, data) => {
+ context.Response.ContentType = MimeType.Json;
+ context.Response.ContentEncoding = WebServer.Utf8NoBomEncoding;
+ var baseSerializer = None(bufferResponse);
+ await baseSerializer(context, Swan.Formatters.Json.Serialize(data, serializerOptions))
+ .ConfigureAwait(false);
+ };
+ }
+
+ ///
+ /// Sends data in a HTTP response without serialization.
+ ///
+ /// to write the response body to a memory buffer first,
+ /// then send it all together with a Content-Length header; to use chunked
+ /// transfer encoding.
+ /// A that can be used to serialize data to a HTTP response.
+ ///
+ /// s and one-dimensional arrays of s
+ /// are sent to the client unchanged; every other type is converted to a string.
+ /// The ContentType set on the response is used to negotiate
+ /// a compression method, according to request headers.
+ /// Strings (and other types converted to strings) are sent with the encoding specified by .
+ ///
+ public static ResponseSerializerCallback None(bool bufferResponse)
+ => bufferResponse ? BufferingBaseSerializer : ChunkedEncodingBaseSerializer;
+
+ private static ResponseSerializerCallback GetBaseSerializer(bool bufferResponse)
+ => async (context, data) => {
+ if (data is null)
+ {
+ return;
+ }
+
+ var isBinaryResponse = data is byte[];
+
+ if (!context.TryDetermineCompression(context.Response.ContentType, out var preferCompression))
+ {
+ preferCompression = true;
+ }
+
+ if (isBinaryResponse)
+ {
+ var responseBytes = (byte[])data;
+ using var stream = context.OpenResponseStream(bufferResponse, preferCompression);
+ await stream.WriteAsync(responseBytes, 0, responseBytes.Length).ConfigureAwait(false);
+ }
+ else
+ {
+ var responseString = data is string stringData ? stringData : data.ToString() ?? string.Empty;
+ using var text = context.OpenResponseText(context.Response.ContentEncoding, bufferResponse, preferCompression);
+ await text.WriteAsync(responseString).ConfigureAwait(false);
+ }
+ };
+ }
+}
\ No newline at end of file
diff --git a/Vendor/EmbedIO-3.5.2/ResponseSerializerCallback.cs b/Vendor/EmbedIO-3.5.2/ResponseSerializerCallback.cs
new file mode 100644
index 0000000..f84cca1
--- /dev/null
+++ b/Vendor/EmbedIO-3.5.2/ResponseSerializerCallback.cs
@@ -0,0 +1,12 @@
+using System.Threading.Tasks;
+
+namespace EmbedIO
+{
+ ///
+ /// A callback used to serialize data to a HTTP response.
+ ///
+ /// The HTTP context of the request.
+ /// The data to serialize.
+ /// A representing the ongoing operation.
+ public delegate Task ResponseSerializerCallback(IHttpContext context, object? data);
+}
\ No newline at end of file
diff --git a/Vendor/EmbedIO-3.5.2/Routing/BaseRouteAttribute.cs b/Vendor/EmbedIO-3.5.2/Routing/BaseRouteAttribute.cs
new file mode 100644
index 0000000..df449fb
--- /dev/null
+++ b/Vendor/EmbedIO-3.5.2/Routing/BaseRouteAttribute.cs
@@ -0,0 +1,31 @@
+using System;
+
+namespace EmbedIO.Routing
+{
+ ///
+ /// Decorate methods within controllers with this attribute in order to make them callable from the Web API Module
+ /// Method Must match the WebServerModule.
+ ///
+ [AttributeUsage(AttributeTargets.Method, AllowMultiple = true, Inherited = true)]
+ public class BaseRouteAttribute : RouteAttribute
+ {
+ ///
+ /// Initializes a new instance of the class.
+ ///
+ /// The verb.
+ /// The route.
+ /// is .
+ ///
+ /// is empty.
+ /// - or -
+ /// does not start with a slash (/) character.
+ /// - or -
+ /// does not comply with route syntax.
+ ///
+ ///
+ public BaseRouteAttribute(HttpVerbs verb, string route)
+ : base(verb, route, true)
+ {
+ }
+ }
+}
\ No newline at end of file
diff --git a/Vendor/EmbedIO-3.5.2/Routing/Route.cs b/Vendor/EmbedIO-3.5.2/Routing/Route.cs
new file mode 100644
index 0000000..f02fdf2
--- /dev/null
+++ b/Vendor/EmbedIO-3.5.2/Routing/Route.cs
@@ -0,0 +1,310 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Text.RegularExpressions;
+using EmbedIO.WebApi;
+
+namespace EmbedIO.Routing
+{
+ ///
+ /// Provides utility methods to work with routes.
+ ///
+ ///
+ ///
+ ///
+ public static class Route
+ {
+ // Characters in ValidParameterNameChars MUST be in ascending ordinal order!
+ private static readonly char[] ValidParameterNameChars =
+ "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ_abcdefghijklmnopqrstuvwxyz".ToCharArray();
+
+ ///
+ /// Determines whether a string is a valid route parameter name.
+ /// To be considered a valid route parameter name, the specified string:
+ ///
+ /// - must not be ;
+ /// - must not be the empty string;
+ /// - must consist entirely of decimal digits, upper- or lower-case
+ /// letters of the English alphabet, or underscore ('_') characters;
+ /// - must not start with a decimal digit.
+ ///
+ ///
+ /// The value.
+ /// if is a valid route parameter;
+ /// otherwise, .
+ public static bool IsValidParameterName(string value)
+ => !string.IsNullOrEmpty(value)
+ && value[0] > '9'
+ && !value.Any(c => c < '0' || c > 'z' || Array.BinarySearch(ValidParameterNameChars, c) < 0);
+
+ ///
+ /// Determines whether a string is a valid route.
+ /// To be considered a valid route, the specified string:
+ ///
+ /// - must not be ;
+ /// - must not be the empty string;
+ /// - must start with a slash ('/') character;
+ /// - if a base route, must end with a slash ('/') character;
+ /// - if not a base route, must not end with a slash ('/') character,
+ /// unless it is the only character in the string;
+ /// - must not contain consecutive runs of two or more slash ('/') characters;
+ /// - may contain one or more parameter specifications.
+ ///
+ /// Each parameter specification must be enclosed in curly brackets ('{'
+ /// and '}'. No whitespace is allowed inside a parameter specification.
+ /// Two parameter specifications must be separated by literal text.
+ /// A parameter specification consists of a valid parameter name, optionally
+ /// followed by a '?' character to signify that it will also match an empty string.
+ /// If '?' is not present, a parameter by default will NOT match an empty string.
+ /// See for the definition of a valid parameter name.
+ /// To include a literal open curly bracket in the route, it must be doubled ("{{").
+ /// A literal closed curly bracket ('}') may be included in the route as-is.
+ /// A segment of a base route cannot consist only of an optional parameter.
+ ///
+ /// The route to check.
+ /// if checking for a base route;
+ /// otherwise, .
+ /// if is a valid route;
+ /// otherwise, .
+ public static bool IsValid(string route, bool isBaseRoute) => ValidateInternal(nameof(route), route, isBaseRoute) == null;
+
+ // Check the validity of a route by parsing it without storing the results.
+ // Returns: ArgumentNullException, ArgumentException, null if OK
+ internal static Exception? ValidateInternal(string argumentName, string value, bool isBaseRoute) => ParseInternal(value, isBaseRoute, null) switch {
+ ArgumentNullException _ => new ArgumentNullException(argumentName),
+ FormatException formatException => new ArgumentException(formatException.Message, argumentName),
+ Exception exception => exception,
+ _ => null
+ };
+
+ // Validate and parse a route, constructing a Regex pattern.
+ // setResult will be called at the end with the isBaseRoute flag, parameter names and the constructed pattern.
+ // Returns: ArgumentNullException, FormatException, null if OK
+ internal static Exception? ParseInternal(string route, bool isBaseRoute, Action, string>? setResult)
+ {
+ if (route == null)
+ return new ArgumentNullException(nameof(route));
+
+ if (route.Length == 0)
+ return new FormatException("Route is empty.");
+
+ if (route[0] != '/')
+ return new FormatException("Route does not start with a slash.");
+
+ /*
+ * Regex options set at start of pattern:
+ * IgnoreCase : no
+ * Multiline : no
+ * Singleline : yes
+ * ExplicitCapture : yes
+ * IgnorePatternWhitespace : no
+ * See https://docs.microsoft.com/en-us/dotnet/standard/base-types/regular-expression-options
+ * See https://docs.microsoft.com/en-us/dotnet/standard/base-types/grouping-constructs-in-regular-expressions#group_options
+ */
+ const string InitialRegexOptions = "(?sn-imx)";
+
+ // If setResult is null we don't need the StringBuilder.
+ var sb = setResult == null ? null : new StringBuilder("^");
+
+ var parameterNames = new List();
+ if (route.Length == 1)
+ {
+ // If the route consists of a single slash, only a single slash will match.
+ sb?.Append(isBaseRoute ? "/" : "/$");
+ }
+ else
+ {
+ // First of all divide the route in segments.
+ // Segments are separated by slashes.
+ // The route is not necessarily normalized, so there could be runs of consecutive slashes.
+ var segmentCount = 0;
+ var optionalSegmentCount = 0;
+ foreach (var segment in GetSegments(route))
+ {
+ segmentCount++;
+
+ // Parse the segment, looking alternately for a '{', that opens a parameter specification,
+ // then for a '}', that closes it.
+ // Characters outside parameter specifications are Regex-escaped and added to the pattern.
+ // A parameter specification consists of a parameter name, optionally followed by '?'
+ // to indicate that an empty parameter will match.
+ // The default is to NOT match empty parameters, consistently with ASP.NET and EmbedIO version 2.
+ // More syntax rules:
+ // - There cannot be two parameters without literal text in between.
+ // - If a segment consists ONLY of an OPTIONAL parameter, then the slash preceding it is optional too.
+ var inParameterSpec = false;
+ var afterParameter = false;
+ for (var position = 0; ;)
+ {
+ if (inParameterSpec)
+ {
+ // Look for end of spec, bail out if not found.
+ var closePosition = segment.IndexOf('}', position);
+ if (closePosition < 0)
+ return new FormatException("Route syntax error: unclosed parameter specification.");
+
+ // Parameter spec cannot be empty.
+ if (closePosition == position)
+ return new FormatException("Route syntax error: empty parameter specification.");
+
+ // Check the last character:
+ // {name} means empty parameter does not match
+ // {name?} means empty parameter matches
+ // If '?'is found, the parameter name ends before it
+ var nameEndPosition = closePosition;
+ var allowEmpty = false;
+ if (segment[closePosition - 1] == '?')
+ {
+ allowEmpty = true;
+ nameEndPosition--;
+ }
+
+ // Bail out if only '?' is found inside the spec.
+ if (nameEndPosition == position)
+ return new FormatException("Route syntax error: missing parameter name.");
+
+ // Extract the parameter name.
+ var parameterName = segment.Substring(position, nameEndPosition - position);
+
+ // Ensure that the parameter name contains only valid characters.
+ if (!IsValidParameterName(parameterName))
+ return new FormatException("Route syntax error: parameter name contains one or more invalid characters.");
+
+ // Ensure that the parameter name is not a duplicate.
+ if (parameterNames.Contains(parameterName))
+ return new FormatException("Route syntax error: duplicate parameter name.");
+
+ // The spec is valid, so add the parameter to the list.
+ parameterNames.Add(parameterName);
+
+ // Append a capturing group with the same name to the pattern.
+ // Parameters must be made of non-slash characters ("[^/]")
+ // and must match non-greedily ("*?" if optional, "+?" if non optional).
+ // Position will be 1 at the start, not 0, because we've skipped the opening '{'.
+ if (allowEmpty && position == 1 && closePosition == segment.Length - 1)
+ {
+ if (isBaseRoute)
+ return new FormatException("No segment of a base route can be optional.");
+
+ // If the segment consists only of an optional parameter,
+ // then the slash preceding the segment is optional as well.
+ // In this case the parameter must match only is not empty,
+ // because it's (slash + parameter) that is optional.
+ sb?.Append("(/(?<").Append(parameterName).Append(">[^/]+?))?");
+ optionalSegmentCount++;
+ }
+ else
+ {
+ // If at the start of a segment, don't forget the slash!
+ // Position will be 1 at the start, not 0, because we've skipped the opening '{'.
+ if (position == 1)
+ sb?.Append('/');
+
+ sb?.Append("(?<").Append(parameterName).Append(">[^/]").Append(allowEmpty ? '*' : '+').Append("?)");
+ }
+
+ // Go on with parsing.
+ position = closePosition + 1;
+ inParameterSpec = false;
+ afterParameter = true;
+ }
+ else
+ {
+ // Look for start of parameter spec.
+ var openPosition = segment.IndexOf('{', position);
+ if (openPosition < 0)
+ {
+ // If at the start of a segment, don't forget the slash.
+ if (position == 0)
+ sb?.Append('/');
+
+ // No more parameter specs: escape the remainder of the string
+ // and add it to the pattern.
+ sb?.Append(Regex.Escape(segment.Substring(position)));
+ break;
+ }
+
+ var nextPosition = openPosition + 1;
+ if (nextPosition < segment.Length && segment[nextPosition] == '{')
+ {
+ // If another identical char follows, treat the two as a single literal char.
+ // If at the start of a segment, don't forget the slash!
+ if (position == 0)
+ sb?.Append('/');
+
+ sb?.Append(@"\\{");
+ }
+ else if (afterParameter && openPosition == position)
+ {
+ // If a parameter immediately follows another parameter,
+ // with no literal text in between, it's a syntax error.
+ return new FormatException("Route syntax error: parameters must be separated by literal text.");
+ }
+ else
+ {
+ // If at the start of a segment, don't forget the slash,
+ // but only if there actually is some literal text.
+ // Otherwise let the parameter spec parsing code deal with the slash,
+ // because we don't know whether this is an optional segment yet.
+ if (position == 0 && openPosition > 0)
+ sb?.Append('/');
+
+ // Escape the part of the pattern outside the parameter spec
+ // and add it to the pattern.
+ sb?.Append(Regex.Escape(segment.Substring(position, openPosition - position)));
+ inParameterSpec = true;
+ }
+
+ // Go on parsing.
+ position = nextPosition;
+ afterParameter = false;
+ }
+ }
+ }
+
+ // Close the pattern
+ sb?.Append(isBaseRoute ? "(/|$)" : "$");
+
+ // If all segments are optional segments, "/" must match too.
+ if (optionalSegmentCount == segmentCount)
+ sb?.Insert(0, "(/$)|(").Append(')');
+ }
+
+ // Pass the results to the callback if needed.
+ setResult?.Invoke(isBaseRoute, parameterNames, InitialRegexOptions + sb);
+
+ // Everything's fine, thus no exception.
+ return null;
+ }
+
+ // Enumerate the segments of a route, ignoring consecutive slashes.
+ private static IEnumerable GetSegments(string route)
+ {
+ var length = route.Length;
+ var position = 0;
+ for (; ; )
+ {
+ while (route[position] == '/')
+ {
+ position++;
+ if (position >= length)
+ break;
+ }
+
+ if (position >= length)
+ break;
+
+ var slashPosition = route.IndexOf('/', position);
+ if (slashPosition < 0)
+ {
+ yield return route.Substring(position);
+ break;
+ }
+
+ yield return route.Substring(position, slashPosition - position);
+ position = slashPosition;
+ }
+ }
+ }
+}
\ No newline at end of file
diff --git a/Vendor/EmbedIO-3.5.2/Routing/RouteAttribute.cs b/Vendor/EmbedIO-3.5.2/Routing/RouteAttribute.cs
new file mode 100644
index 0000000..3705fd7
--- /dev/null
+++ b/Vendor/EmbedIO-3.5.2/Routing/RouteAttribute.cs
@@ -0,0 +1,54 @@
+using System;
+
+namespace EmbedIO.Routing
+{
+ ///
+ /// Decorate methods within controllers with this attribute in order to make them callable from the Web API Module
+ /// Method Must match the WebServerModule.
+ ///
+ [AttributeUsage(AttributeTargets.Method, AllowMultiple = true, Inherited = true)]
+ public class RouteAttribute : Attribute
+ {
+ ///
+ /// Initializes a new instance of the class.
+ ///
+ /// if this attribute represents a base route;
+ /// (the default) if it represents a terminal (non-base) route.
+ /// The verb.
+ /// The route.
+ /// is .
+ ///
+ /// is empty.
+ /// - or -
+ /// does not start with a slash (/) character.
+ /// - or -
+ /// does not comply with route syntax.
+ ///
+ ///
+ public RouteAttribute(HttpVerbs verb, string route, bool isBaseRoute = false)
+ {
+ Matcher = RouteMatcher.Parse(route, isBaseRoute);
+ Verb = verb;
+ }
+
+ ///
+ /// Gets the HTTP verb handled by a method with this attribute.
+ ///
+ public HttpVerbs Verb { get; }
+
+ ///
+ /// Gets a that will match URLs against this attribute's data.
+ ///
+ public RouteMatcher Matcher { get; }
+
+ ///
+ /// Gets the route handled by a method with this attribute.
+ ///
+ public string Route => Matcher.Route;
+
+ ///
+ /// Gets a value indicating whether this attribute represents a base route.
+ ///
+ public bool IsBaseRoute => Matcher.IsBaseRoute;
+ }
+}
\ No newline at end of file
diff --git a/Vendor/EmbedIO-3.5.2/Routing/RouteHandlerCallback.cs b/Vendor/EmbedIO-3.5.2/Routing/RouteHandlerCallback.cs
new file mode 100644
index 0000000..bd5076b
--- /dev/null
+++ b/Vendor/EmbedIO-3.5.2/Routing/RouteHandlerCallback.cs
@@ -0,0 +1,13 @@
+using System.Threading.Tasks;
+
+namespace EmbedIO.Routing
+{
+ ///
+ /// Base class for callbacks used to handle routed requests.
+ ///
+ /// An interface representing the context of the request.
+ /// The matched route.
+ /// A representing the ongoing operation.
+ ///
+ public delegate Task RouteHandlerCallback(IHttpContext context, RouteMatch route);
+}
\ No newline at end of file
diff --git a/Vendor/EmbedIO-3.5.2/Routing/RouteMatch.cs b/Vendor/EmbedIO-3.5.2/Routing/RouteMatch.cs
new file mode 100644
index 0000000..38e3d49
--- /dev/null
+++ b/Vendor/EmbedIO-3.5.2/Routing/RouteMatch.cs
@@ -0,0 +1,199 @@
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Linq;
+using EmbedIO.Utilities;
+
+namespace EmbedIO.Routing
+{
+ ///
+ /// Represents a route resolved by a .
+ /// This class may be used both as a dictionary of route parameter names and values,
+ /// and a list of the values.
+ /// Because of its double nature, this class cannot be enumerated directly. However,
+ /// you may use the property to iterate over name / value pairs, and the
+ /// property to iterate over values.
+ /// When enumerated in a non-generic fashion via the interface,
+ /// this class iterates over name / value pairs.
+ ///
+#pragma warning disable CA1710 // Rename class to end in "Collection"
+ public sealed class RouteMatch : IReadOnlyList, IReadOnlyDictionary
+#pragma warning restore CA1710
+ {
+ private static readonly IReadOnlyList EmptyStringList = Array.Empty();
+
+ private readonly IReadOnlyList _values;
+
+ internal RouteMatch(string path, IReadOnlyList names, IReadOnlyList values, string? subPath)
+ {
+ Path = path;
+ Names = names;
+ _values = values;
+ SubPath = subPath;
+ }
+
+ ///
+ /// Gets a instance that represents no match at all.
+ ///
+ ///
+ /// The instance returned by this property
+ /// has the following specifications:
+ ///
+ /// - its Path property is the empty string;
+ /// - it has no parameters;
+ /// - its SubPath property is .
+ ///
+ /// This instance is only useful to initialize
+ /// a non-nullable property of type , provided that it is subsequently
+ /// set to a meaningful value before being used.
+ ///
+ public static RouteMatch None { get; } = new RouteMatch(
+ string.Empty,
+ Array.Empty(),
+ Array.Empty(),
+ null);
+
+ ///
+ /// Gets the URL path that was successfully matched against the route.
+ ///
+ public string Path { get; }
+
+ ///
+ /// For a base route, gets the part of that follows the matched route;
+ /// for a non-base route, this property is always .
+ ///
+ public string? SubPath { get; }
+
+ ///
+ /// Gets a list of the names of the route's parameters.
+ ///
+ public IReadOnlyList Names { get; }
+
+ ///
+ public int Count => _values.Count;
+
+ ///
+ public IEnumerable Keys => Names;
+
+ ///
+ public IEnumerable Values => _values;
+
+ ///
+ /// Gets an interface that can be used
+ /// to iterate over name / value pairs.
+ ///
+ public IEnumerable> Pairs => this;
+
+ ///
+ public string this[int index] => _values[index];
+
+ ///
+ public string this[string key]
+ {
+ get
+ {
+ var count = Names.Count;
+ for (var i = 0; i < count; i++)
+ {
+ if (Names[i] == key)
+ {
+ return _values[i];
+ }
+ }
+
+ throw new KeyNotFoundException("The parameter name was not found.");
+ }
+ }
+
+ ///
+ /// Returns a object equal to the one
+ /// that would result by matching the specified URL path against a
+ /// base route of "/".
+ ///
+ /// The URL path to match.
+ /// A newly-constructed .
+ ///
+ /// This method assumes that
+ /// is a valid, non-base URL path or route. Otherwise, the behavior of this method
+ /// is unspecified.
+ /// Ensure that you validate before
+ /// calling this method, using either
+ /// or .
+ ///
+ public static RouteMatch UnsafeFromRoot(string urlPath)
+ => new RouteMatch(urlPath, EmptyStringList, EmptyStringList, urlPath);
+
+ ///
+ /// Returns a object equal to the one
+ /// that would result by matching the specified URL path against
+ /// the specified parameterless base route.
+ ///
+ /// The base route to match against.
+ /// The URL path to match.
+ /// A newly-constructed .
+ ///
+ /// This method assumes that is a
+ /// valid base URL path, and
+ /// is a valid, non-base URL path or route. Otherwise, the behavior of this method
+ /// is unspecified.
+ /// Ensure that you validate both parameters before
+ /// calling this method, using either
+ /// or .
+ ///
+ public static RouteMatch? UnsafeFromBasePath(string baseUrlPath, string urlPath)
+ {
+ var subPath = UrlPath.UnsafeStripPrefix(urlPath, baseUrlPath);
+ return subPath == null ? null : new RouteMatch(urlPath, EmptyStringList, EmptyStringList, "/" + subPath);
+ }
+
+ ///
+ public bool ContainsKey(string key) => Names.Any(n => n == key);
+
+ ///
+ public bool TryGetValue(string key, out string? value)
+ {
+ var count = Names.Count;
+ for (var i = 0; i < count; i++)
+ {
+ if (Names[i] == key)
+ {
+ value = _values[i];
+ return true;
+ }
+ }
+
+ value = null;
+ return false;
+ }
+
+ ///
+ /// Returns the index of the parameter with the specified name.
+ ///
+ /// The parameter name.
+ /// The index of the parameter, or -1 if none of the
+ /// route parameters have the specified name.
+ public int IndexOf(string name)
+ {
+ var count = Names.Count;
+ for (var i = 0; i < count; i++)
+ {
+ if (Names[i] == name)
+ {
+ return i;
+ }
+ }
+
+ return -1;
+ }
+
+ ///
+ IEnumerator> IEnumerable>.GetEnumerator()
+ => Names.Zip(_values, (n, v) => new KeyValuePair(n, v)).GetEnumerator();
+
+ ///
+ IEnumerator IEnumerable.GetEnumerator() => _values.GetEnumerator();
+
+ ///
+ IEnumerator IEnumerable.GetEnumerator() => Pairs.GetEnumerator();
+ }
+}
\ No newline at end of file
diff --git a/Vendor/EmbedIO-3.5.2/Routing/RouteMatcher.cs b/Vendor/EmbedIO-3.5.2/Routing/RouteMatcher.cs
new file mode 100644
index 0000000..d66ec96
--- /dev/null
+++ b/Vendor/EmbedIO-3.5.2/Routing/RouteMatcher.cs
@@ -0,0 +1,183 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Net;
+using System.Text.RegularExpressions;
+using EmbedIO.Utilities;
+using Swan;
+
+namespace EmbedIO.Routing
+{
+ ///
+ /// Matches URL paths against a route.
+ ///
+ public sealed class RouteMatcher : IEquatable
+ {
+ private static readonly object SyncRoot = new object();
+ private static readonly Dictionary<(bool, string), RouteMatcher> Cache = new Dictionary<(bool, string), RouteMatcher>();
+
+ private readonly Regex _regex;
+
+ private RouteMatcher(bool isBaseRoute, string route, string pattern, IReadOnlyList parameterNames)
+ {
+ IsBaseRoute = isBaseRoute;
+ Route = route;
+ ParameterNames = parameterNames;
+ _regex = new Regex(pattern, RegexOptions.Compiled | RegexOptions.CultureInvariant);
+ }
+
+ ///
+ /// Gets a value indicating whether the property
+ /// is a base route.
+ ///
+ public bool IsBaseRoute { get; }
+
+ ///
+ /// Gets the route this instance matches URL paths against.
+ ///
+ public string Route { get; }
+
+ ///
+ /// Gets the names of the route's parameters.
+ ///
+ public IReadOnlyList ParameterNames { get; }
+
+ ///
+ /// Constructs an instance of by parsing the specified route.
+ /// If the same route was previously parsed and the method has not been called since,
+ /// this method obtains an instance from a static cache.
+ ///
+ /// The route to parse.
+ /// if the route to parse
+ /// is a base route; otherwise, .
+ /// A newly-constructed instance of
+ /// that will match URL paths against .
+ /// is .
+ /// is not a valid route.
+ ///
+ ///
+ public static RouteMatcher Parse(string route, bool isBaseRoute)
+ {
+ var exception = TryParseInternal(route, isBaseRoute, out var result);
+ if (exception != null)
+ throw exception;
+
+ return result!;
+ }
+
+ ///
+ /// Attempts to obtain an instance of by parsing the specified route.
+ /// If the same route was previously parsed and the method has not been called since,
+ /// this method obtains an instance from a static cache.
+ ///
+ /// The route to parse.
+ /// if the route to parse
+ /// is a base route; otherwise, .
+ /// When this method returns , a newly-constructed instance of
+ /// that will match URL paths against ; otherwise, .
+ /// This parameter is passed uninitialized.
+ /// if parsing was successful; otherwise, .
+ ///
+ ///
+ public static bool TryParse(string route, bool isBaseRoute, out RouteMatcher? result)
+ => TryParseInternal(route, isBaseRoute, out result) == null;
+
+ ///
+ /// Clears 's internal instance cache.
+ ///
+ ///
+ ///
+ public static void ClearCache()
+ {
+ lock (SyncRoot)
+ {
+ Cache.Clear();
+ }
+ }
+
+ ///
+ /// Returns a hash code for this instance.
+ ///
+ /// A hash code for this instance, suitable for use in hashing algorithms
+ /// and data structures like a hash table.
+ public override int GetHashCode() => CompositeHashCode.Using(Route, IsBaseRoute);
+
+ ///
+ /// Determines whether the specified is equal to this instance.
+ ///
+ /// The to compare with this instance.
+ /// if is equal to this instance;
+ /// otherwise, .
+ public override bool Equals(object? obj) => obj is RouteMatcher other && Equals(other);
+
+ ///
+ /// Indicates whether this instance is equal to another instance of .
+ ///
+ /// A to compare with this instance.
+ /// if this instance is equal to ;
+ /// otherwise, .
+ public bool Equals(RouteMatcher? other)
+ => other != null
+ && other.Route == Route
+ && other.IsBaseRoute == IsBaseRoute;
+
+ ///
+ /// Matches the specified URL path against
+ /// and extracts values for the route's parameters.
+ ///
+ /// The URL path to match.
+ /// If the match is successful, a object;
+ /// otherwise, .
+ public RouteMatch? Match(string path)
+ {
+ if (path == null)
+ return null;
+
+ // Optimize for parameterless base routes
+ if (IsBaseRoute)
+ {
+ if (Route.Length == 1)
+ return RouteMatch.UnsafeFromRoot(path);
+
+ if (ParameterNames.Count == 0)
+ return RouteMatch.UnsafeFromBasePath(Route, path);
+ }
+
+ var match = _regex.Match(path);
+ if (!match.Success)
+ return null;
+
+ return new RouteMatch(
+ path,
+ ParameterNames,
+ match.Groups.Cast().Skip(1).Select(g => WebUtility.UrlDecode(g.Value)).ToArray(),
+ IsBaseRoute ? "/" + path.Substring(match.Groups[0].Length) : null);
+ }
+
+ private static Exception? TryParseInternal(string route, bool isBaseRoute, out RouteMatcher? result)
+ {
+ lock (SyncRoot)
+ {
+ string? pattern = null;
+ var parameterNames = new List();
+ var exception = Routing.Route.ParseInternal(route, isBaseRoute, (_, n, p) => {
+ parameterNames.AddRange(n);
+ pattern = p;
+ });
+ if (exception != null)
+ {
+ result = null;
+ return exception;
+ }
+
+ route = UrlPath.UnsafeNormalize(route, isBaseRoute);
+ if (Cache.TryGetValue((isBaseRoute, route), out result))
+ return null;
+
+ result = new RouteMatcher(isBaseRoute, route, pattern!, parameterNames);
+ Cache.Add((isBaseRoute, route), result);
+ return null;
+ }
+ }
+ }
+}
\ No newline at end of file
diff --git a/Vendor/EmbedIO-3.5.2/Routing/RouteResolutionResult.cs b/Vendor/EmbedIO-3.5.2/Routing/RouteResolutionResult.cs
new file mode 100644
index 0000000..198d059
--- /dev/null
+++ b/Vendor/EmbedIO-3.5.2/Routing/RouteResolutionResult.cs
@@ -0,0 +1,35 @@
+namespace EmbedIO.Routing
+{
+ ///
+ /// Represents the outcome of resolving a context and a path against a route.
+ ///
+ public enum RouteResolutionResult
+ {
+ /* DO NOT reorder members!
+ * RouteNotMatched < NoHandlerSelected < NoHandlerSuccessful < Success
+ *
+ * See comments in RouteResolverBase<,>.ResolveAsync for further explanation.
+ */
+
+ ///
+ /// The route didn't match.
+ ///
+ RouteNotMatched,
+
+ ///
+ /// The route did match, but no registered handler was suitable for the context.
+ ///
+ NoHandlerSelected,
+
+ ///
+ /// The route matched and one or more suitable handlers were found,
+ /// but none of them returned .
+ ///
+ NoHandlerSuccessful,
+
+ ///
+ /// The route has been resolved.
+ ///
+ Success,
+ }
+}
\ No newline at end of file
diff --git a/Vendor/EmbedIO-3.5.2/Routing/RouteResolverBase`1.cs b/Vendor/EmbedIO-3.5.2/Routing/RouteResolverBase`1.cs
new file mode 100644
index 0000000..1556324
--- /dev/null
+++ b/Vendor/EmbedIO-3.5.2/Routing/RouteResolverBase`1.cs
@@ -0,0 +1,166 @@
+using System;
+using System.Collections.Generic;
+using System.Threading.Tasks;
+using EmbedIO.Internal;
+using EmbedIO.Utilities;
+using Swan.Configuration;
+
+namespace EmbedIO.Routing
+{
+ ///
+ /// Implements the logic for resolving the requested path of a HTTP context against a route,
+ /// possibly handling different contexts via different handlers.
+ ///
+ /// The type of the data used to select a suitable handler
+ /// for the context.
+ ///
+ public abstract class RouteResolverBase : ConfiguredObject
+ {
+ private readonly List<(TData data, RouteHandlerCallback handler)> _dataHandlerPairs
+ = new List<(TData data, RouteHandlerCallback handler)>();
+
+ ///
+ /// Initializes a new instance of the class.
+ ///
+ /// The to match URL paths against.
+ ///
+ /// is .
+ ///
+ protected RouteResolverBase(RouteMatcher matcher)
+ {
+ Matcher = Validate.NotNull(nameof(matcher), matcher);
+ }
+
+ ///
+ /// Gets the used to match routes.
+ ///
+ public RouteMatcher Matcher { get; }
+
+ ///
+ /// Gets the route this resolver matches URL paths against.
+ ///
+ public string Route => Matcher.Route;
+
+ ///
+ /// Gets a value indicating whether is a base route.
+ ///
+ public bool IsBaseRoute => Matcher.IsBaseRoute;
+
+ ///
+ /// Associates some data to a handler.
+ /// The method calls
+ /// to extract data from the context; then, for each registered data / handler pair,
+ /// is called to determine whether
+ /// should be called.
+ ///
+ /// Data used to determine which contexts are
+ /// suitable to be handled by .
+ /// A callback used to handle matching contexts.
+ /// is .
+ ///
+ ///
+ ///
+ ///
+ public void Add(TData data, RouteHandlerCallback handler)
+ {
+ EnsureConfigurationNotLocked();
+
+ handler = Validate.NotNull(nameof(handler), handler);
+ _dataHandlerPairs.Add((data, handler));
+ }
+
+ ///
+ /// Associates some data to a synchronous handler.
+ /// The method calls
+ /// to extract data from the context; then, for each registered data / handler pair,
+ /// is called to determine whether
+ /// should be called.
+ ///
+ /// Data used to determine which contexts are
+ /// suitable to be handled by .
+ /// A callback used to handle matching contexts.
+ /// is .
+ ///
+ ///
+ ///
+ ///
+ public void Add(TData data, SyncRouteHandlerCallback handler)
+ {
+ EnsureConfigurationNotLocked();
+
+ handler = Validate.NotNull(nameof(handler), handler);
+ _dataHandlerPairs.Add((data, (ctx, route) => {
+ handler(ctx, route);
+ return Task.CompletedTask;
+ }));
+ }
+
+ ///
+ /// Locks this instance, preventing further handler additions.
+ ///
+ public void Lock() => LockConfiguration();
+
+ ///
+ /// Asynchronously matches a URL path against ;
+ /// if the match is successful, tries to handle the specified
+ /// using handlers selected according to data extracted from the context.
+ /// Registered data / handler pairs are tried in the same order they were added.
+ ///
+ /// The context to handle.
+ /// A , representing the ongoing operation,
+ /// that will return a result in the form of one of the constants.
+ ///
+ ///
+ ///
+ ///
+ public async Task ResolveAsync(IHttpContext context)
+ {
+ LockConfiguration();
+
+ var match = Matcher.Match(context.RequestedPath);
+ if (match == null)
+ return RouteResolutionResult.RouteNotMatched;
+
+ var contextData = GetContextData(context);
+ var result = RouteResolutionResult.NoHandlerSelected;
+ foreach (var (data, handler) in _dataHandlerPairs)
+ {
+ if (!MatchContextData(contextData, data))
+ continue;
+
+ try
+ {
+ await handler(context, match).ConfigureAwait(false);
+ return RouteResolutionResult.Success;
+ }
+ catch (RequestHandlerPassThroughException)
+ {
+ result = RouteResolutionResult.NoHandlerSuccessful;
+ }
+ }
+
+ return result;
+ }
+
+ ///
+ /// Called by to extract data from a context.
+ /// The extracted data are then used to select which handlers are suitable
+ /// to handle the context.
+ ///
+ /// The HTTP context to extract data from.
+ /// The extracted data.
+ ///
+ ///
+ protected abstract TData GetContextData(IHttpContext context);
+
+ ///
+ /// Called by to match data extracted from a context
+ /// against data associated with a handler.
+ ///
+ /// The data extracted from the context.
+ /// The data associated with the handler.
+ /// if the handler should be called to handle the context;
+ /// otherwise, .
+ protected abstract bool MatchContextData(TData contextData, TData handlerData);
+ }
+}
\ No newline at end of file
diff --git a/Vendor/EmbedIO-3.5.2/Routing/RouteResolverCollectionBase`2.cs b/Vendor/EmbedIO-3.5.2/Routing/RouteResolverCollectionBase`2.cs
new file mode 100644
index 0000000..7795ff5
--- /dev/null
+++ b/Vendor/EmbedIO-3.5.2/Routing/RouteResolverCollectionBase`2.cs
@@ -0,0 +1,150 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+using EmbedIO.Internal;
+using EmbedIO.Utilities;
+using Swan;
+using Swan.Collections;
+using Swan.Configuration;
+
+namespace EmbedIO.Routing
+{
+ ///
+ /// Implements the logic for resolving a context and a URL path against a list of routes,
+ /// possibly handling different HTTP methods via different handlers.
+ ///
+ /// The type of the data used to select a suitable handler
+ /// for a context.
+ /// The type of the route resolver.
+ ///
+ public abstract class RouteResolverCollectionBase : ConfiguredObject
+ where TResolver : RouteResolverBase
+ {
+ private readonly List _resolvers = new List();
+
+ ///
+ /// Associates some data and a route to a handler.
+ ///
+ /// Data used to determine which contexts are
+ /// suitable to be handled by .
+ /// The to match URL paths against.
+ /// A callback used to handle matching contexts.
+ ///
+ /// is .
+ /// - or -
+ /// is .
+ ///
+ /// The method
+ /// returned .
+ ///
+ ///
+ ///
+ public void Add(TData data, RouteMatcher matcher, RouteHandlerCallback handler)
+ {
+ matcher = Validate.NotNull(nameof(matcher), matcher);
+ handler = Validate.NotNull(nameof(handler), handler);
+ GetResolver(matcher).Add(data, handler);
+ }
+
+ ///
+ /// Associates some data and a route to a synchronous handler.
+ ///
+ /// Data used to determine which contexts are
+ /// suitable to be handled by .
+ /// The to match URL paths against.
+ /// A callback used to handle matching contexts.
+ ///
+ /// is .
+ /// - or -
+ /// is .
+ ///
+ /// The method
+ /// returned .
+ ///
+ ///
+ ///
+ public void Add(TData data, RouteMatcher matcher, SyncRouteHandlerCallback handler)
+ {
+ matcher = Validate.NotNull(nameof(matcher), matcher);
+ handler = Validate.NotNull(nameof(handler), handler);
+ GetResolver(matcher).Add(data, handler);
+ }
+
+ ///
+ /// Asynchronously matches a URL path against ;
+ /// if the match is successful, tries to handle the specified
+ /// using handlers selected according to data extracted from the context.
+ /// Registered resolvers are tried in the same order they were added by calling
+ /// .
+ ///
+ /// The context to handle.
+ /// A , representing the ongoing operation,
+ /// that will return a result in the form of one of the constants.
+ ///
+ public async Task ResolveAsync(IHttpContext context)
+ {
+ var result = RouteResolutionResult.RouteNotMatched;
+ foreach (var resolver in _resolvers)
+ {
+ var resolverResult = await resolver.ResolveAsync(context).ConfigureAwait(false);
+ OnResolverCalled(context, resolver, resolverResult);
+ if (resolverResult == RouteResolutionResult.Success)
+ return RouteResolutionResult.Success;
+
+ // This is why RouteResolutionResult constants must not be reordered.
+ if (resolverResult > result)
+ result = resolverResult;
+ }
+
+ return result;
+ }
+
+ ///
+ /// Locks this collection, preventing further additions.
+ ///
+ public void Lock() => LockConfiguration();
+
+ ///
+ protected override void OnBeforeLockConfiguration()
+ {
+ foreach (var resolver in _resolvers)
+ resolver.Lock();
+ }
+
+ ///
+ /// Called by
+ /// and to create an instance
+ /// of that can resolve the specified route.
+ /// If this method returns , an
+ /// is thrown by the calling method.
+ ///
+ /// The to match URL paths against.
+ /// A newly-constructed instance of .
+ protected abstract TResolver CreateResolver(RouteMatcher matcher);
+
+ ///
+ /// Called by when a resolver's
+ /// ResolveAsync method has been called
+ /// to resolve a context.
+ /// This callback method may be used e.g. for logging or testing.
+ ///
+ /// The context to handle.
+ /// The resolver just called.
+ /// The result returned by .ResolveAsync.
+ protected virtual void OnResolverCalled(IHttpContext context, TResolver resolver, RouteResolutionResult result)
+ {
+ }
+
+ private TResolver GetResolver(RouteMatcher matcher)
+ {
+ var resolver = _resolvers.FirstOrDefault(r => r.Matcher.Equals(matcher));
+ if (resolver != null)
+ return resolver;
+
+ resolver = CreateResolver(matcher);
+ _resolvers.Add(resolver ?? throw SelfCheck.Failure($"{nameof(CreateResolver)} returned null."));
+ return resolver;
+ }
+ }
+}
diff --git a/Vendor/EmbedIO-3.5.2/Routing/RouteVerbResolver.cs b/Vendor/EmbedIO-3.5.2/Routing/RouteVerbResolver.cs
new file mode 100644
index 0000000..82e7b5a
--- /dev/null
+++ b/Vendor/EmbedIO-3.5.2/Routing/RouteVerbResolver.cs
@@ -0,0 +1,30 @@
+using System;
+
+namespace EmbedIO.Routing
+{
+ ///
+ /// Handles a HTTP request by matching it against a route,
+ /// possibly handling different HTTP methods via different handlers.
+ ///
+ public sealed class RouteVerbResolver : RouteResolverBase
+ {
+ ///
+ /// Initializes a new instance of the class.
+ ///
+ /// The to match URL paths against.
+ ///
+ /// is .
+ ///
+ public RouteVerbResolver(RouteMatcher matcher)
+ : base(matcher)
+ {
+ }
+
+ ///
+ protected override HttpVerbs GetContextData(IHttpContext context) => context.Request.HttpVerb;
+
+ ///
+ protected override bool MatchContextData(HttpVerbs contextVerb, HttpVerbs handlerVerb)
+ => handlerVerb == HttpVerbs.Any || contextVerb == handlerVerb;
+ }
+}
\ No newline at end of file
diff --git a/Vendor/EmbedIO-3.5.2/Routing/RouteVerbResolverCollection.cs b/Vendor/EmbedIO-3.5.2/Routing/RouteVerbResolverCollection.cs
new file mode 100644
index 0000000..d3f97f2
--- /dev/null
+++ b/Vendor/EmbedIO-3.5.2/Routing/RouteVerbResolverCollection.cs
@@ -0,0 +1,140 @@
+using System;
+using System.Linq;
+using System.Linq.Expressions;
+using System.Reflection;
+using System.Threading.Tasks;
+using EmbedIO.Utilities;
+using Swan.Logging;
+
+namespace EmbedIO.Routing
+{
+ ///
+ /// Handles a HTTP request by matching it against a list of routes,
+ /// possibly handling different HTTP methods via different handlers.
+ ///
+ ///
+ ///
+ public sealed class RouteVerbResolverCollection : RouteResolverCollectionBase
+ {
+ private readonly string _logSource;
+
+ internal RouteVerbResolverCollection(string logSource)
+ {
+ _logSource = logSource;
+ }
+
+ ///
+ /// Adds handlers, associating them with HTTP method / route pairs by means
+ /// of Route attributes.
+ /// A compatible handler is a static or instance method that takes 2
+ /// parameters having the following types, in order:
+ ///
+ ///
+ /// The return type of a compatible handler may be either
+ /// or .
+ /// A compatible handler, in order to be added to a ,
+ /// must have one or more Route attributes.
+ /// The same handler will be added once for each such attribute, either declared on the handler,
+ /// or inherited (if the handler is a virtual method).
+ /// This method behaves according to the type of the
+ /// parameter:
+ ///
+ /// - if is a , all public static methods of
+ /// the type (either declared on the same type or inherited) that are compatible handlers will be added
+ /// to the collection;
+ /// - if is an , all public static methods of
+ /// each exported type of the assembly (either declared on the same type or inherited) that are compatible handlers will be added
+ /// to the collection;
+ /// - if is a referring to a compatible handler,
+ /// it will be added to the collection;
+ /// - if is a whose Method
+ /// refers to a compatible handler, that method will be added to the collection;
+ /// - if is none of the above, all public instance methods of
+ /// its type (either declared on the same type or inherited) that are compatible handlers will be bound to
+ /// and added to the collection.
+ ///
+ ///
+ /// Where to look for compatible handlers. See the Summary section for more information.
+ ///
+ /// The number of handlers that were added to the collection.
+ /// Note that methods with multiple Route attributes
+ /// will count as one for each attribute.
+ ///
+ /// is .
+ public int AddFrom(object target) => Validate.NotNull(nameof(target), target) switch {
+ Type type => AddFrom(null, type),
+ Assembly assembly => assembly.GetExportedTypes().Sum(t => AddFrom(null, t)),
+ MethodInfo method => method.IsStatic ? Add(null, method) : 0,
+ Delegate callback => Add(callback.Target, callback.Method),
+ _ => AddFrom(target, target.GetType())
+ };
+
+ ///
+ protected override RouteVerbResolver CreateResolver(RouteMatcher matcher) => new RouteVerbResolver(matcher);
+
+ ///
+ protected override void OnResolverCalled(IHttpContext context, RouteVerbResolver resolver, RouteResolutionResult result)
+ => $"[{context.Id}] Route {resolver.Route} : {result}".Trace(_logSource);
+
+ private static bool IsHandlerCompatibleMethod(MethodInfo method, out bool isSynchronous)
+ {
+ isSynchronous = false;
+ var returnType = method.ReturnType;
+ if (returnType == typeof(void))
+ {
+ isSynchronous = true;
+ }
+ else if (returnType != typeof(Task))
+ {
+ return false;
+ }
+
+ var parameters = method.GetParameters();
+ return parameters.Length == 2
+ && parameters[0].ParameterType.IsAssignableFrom(typeof(IHttpContext))
+ && parameters[1].ParameterType.IsAssignableFrom(typeof(RouteMatch));
+ }
+
+ // Call Add with all suitable methods of a Type, return sum of results.
+ private int AddFrom(object? target, Type type)
+ => type.GetMethods(target == null
+ ? BindingFlags.Public | BindingFlags.Static
+ : BindingFlags.Public | BindingFlags.Instance)
+ .Where(method => method.IsPublic
+ && !method.IsAbstract
+ && !method.ContainsGenericParameters)
+ .Sum(m => Add(target, m));
+
+ private int Add(object? target, MethodInfo method)
+ {
+ if (!IsHandlerCompatibleMethod(method, out var isSynchronous))
+ return 0;
+
+ var attributes = method.GetCustomAttributes(true).OfType().ToArray();
+ if (attributes.Length == 0)
+ return 0;
+
+ var parameters = new[] {
+ Expression.Parameter(typeof(IHttpContext), "context"),
+ Expression.Parameter(typeof(RouteMatch), "route"),
+ };
+
+ Expression body = Expression.Call(Expression.Constant(target), method, parameters.Cast());
+ if (isSynchronous)
+ {
+ // Convert void to Task by evaluating Task.CompletedTask
+ body = Expression.Block(typeof(Task), body, Expression.Constant(Task.CompletedTask));
+ }
+
+ var handler = Expression.Lambda(body, parameters).Compile();
+ foreach (var attribute in attributes)
+ {
+ Add(attribute.Verb, attribute.Matcher, handler);
+ }
+
+ return attributes.Length;
+ }
+ }
+}
\ No newline at end of file
diff --git a/Vendor/EmbedIO-3.5.2/Routing/RoutingModule.cs b/Vendor/EmbedIO-3.5.2/Routing/RoutingModule.cs
new file mode 100644
index 0000000..2875677
--- /dev/null
+++ b/Vendor/EmbedIO-3.5.2/Routing/RoutingModule.cs
@@ -0,0 +1,62 @@
+using System;
+
+namespace EmbedIO.Routing
+{
+ ///
+ /// A module that handles requests by resolving route / method pairs associated with handlers.
+ ///
+ ///
+ public class RoutingModule : RoutingModuleBase
+ {
+ ///
+ ///
+ /// Initializes a new instance of the class.
+ ///
+ public RoutingModule(string baseRoute)
+ : base(baseRoute)
+ {
+ }
+
+ ///
+ /// Associates a HTTP method and a route to a handler.
+ ///
+ /// A constant representing the HTTP method
+ /// to associate with , or
+ /// if can handle all HTTP methods.
+ /// The used to match URL paths.
+ /// A callback used to handle matching contexts.
+ ///
+ /// is .
+ /// - or -
+ /// is .
+ ///
+ public void Add(HttpVerbs verb, RouteMatcher matcher, RouteHandlerCallback handler)
+ => AddHandler(verb, matcher, handler);
+
+ ///
+ /// Associates a HTTP method and a route to a synchronous handler.
+ ///
+ /// A constant representing the HTTP method
+ /// to associate with , or
+ /// if can handle all HTTP methods.
+ /// The used to match URL paths.
+ /// A callback used to handle matching contexts.
+ ///
+ /// is .
+ /// - or -
+ /// is .
+ ///
+ public void Add(HttpVerbs verb, RouteMatcher matcher, SyncRouteHandlerCallback handler)
+ => AddHandler(verb, matcher, handler);
+
+ ///
+ /// Adds handlers, associating them with HTTP method / route pairs by means
+ /// of Route attributes.
+ /// See for further information.
+ ///
+ /// Where to look for compatible handlers.
+ /// The number of handlers that were added.
+ /// is .
+ public int AddFrom(object target) => AddHandlersFrom(target);
+ }
+}
\ No newline at end of file
diff --git a/Vendor/EmbedIO-3.5.2/Routing/RoutingModuleBase.cs b/Vendor/EmbedIO-3.5.2/Routing/RoutingModuleBase.cs
new file mode 100644
index 0000000..56e9cc9
--- /dev/null
+++ b/Vendor/EmbedIO-3.5.2/Routing/RoutingModuleBase.cs
@@ -0,0 +1,317 @@
+using System;
+using System.Threading.Tasks;
+using Swan;
+
+namespace EmbedIO.Routing
+{
+ ///
+ /// Base class for modules that handle requests by resolving route / method pairs associated with handlers.
+ ///
+ ///
+ public abstract class RoutingModuleBase : WebModuleBase
+ {
+ private readonly RouteVerbResolverCollection _resolvers = new RouteVerbResolverCollection(nameof(RoutingModuleBase));
+
+ ///
+ ///
+ /// Initializes a new instance of the class.
+ ///
+ protected RoutingModuleBase(string baseRoute)
+ : base(baseRoute)
+ {
+ }
+
+ ///
+ public override bool IsFinalHandler => true;
+
+ ///
+ protected override async Task OnRequestAsync(IHttpContext context)
+ {
+ var result = await _resolvers.ResolveAsync(context).ConfigureAwait(false);
+ switch (result)
+ {
+ case RouteResolutionResult.RouteNotMatched:
+ case RouteResolutionResult.NoHandlerSuccessful:
+ await OnPathNotFoundAsync(context).ConfigureAwait(false);
+ break;
+ case RouteResolutionResult.NoHandlerSelected:
+ await OnMethodNotAllowedAsync(context).ConfigureAwait(false);
+ break;
+ case RouteResolutionResult.Success:
+ return;
+ default:
+ throw SelfCheck.Failure($"Internal error: unknown route resolution result {result}.");
+ }
+ }
+
+ ///
+ /// Associates a HTTP method and a route to a handler.
+ ///
+ /// A constant representing the HTTP method
+ /// to associate with , or
+ /// if can handle all HTTP methods.
+ /// The used to match URL paths.
+ /// A callback used to handle matching contexts.
+ ///
+ /// is .
+ /// - or -
+ /// is .
+ ///
+ protected void AddHandler(HttpVerbs verb, RouteMatcher matcher, RouteHandlerCallback handler)
+ => _resolvers.Add(verb, matcher, handler);
+
+ ///
+ /// Associates a HTTP method and a route to a synchronous handler.
+ ///
+ /// A constant representing the HTTP method
+ /// to associate with , or
+ /// if can handle all HTTP methods.
+ /// The used to match URL paths.
+ /// A callback used to handle matching contexts.
+ ///
+ /// is .
+ /// - or -
+ /// is .
+ ///
+ protected void AddHandler(HttpVerbs verb, RouteMatcher matcher, SyncRouteHandlerCallback handler)
+ => _resolvers.Add(verb, matcher, handler);
+
+ ///
+ /// Adds handlers, associating them with HTTP method / route pairs by means
+ /// of Route attributes.
+ /// See for further information.
+ ///
+ /// Where to look for compatible handlers.
+ /// The number of handlers that were added.
+ /// is .
+ protected int AddHandlersFrom(object target)
+ => _resolvers.AddFrom(target);
+
+ ///
+ /// Associates all requests matching a route to a handler.
+ ///
+ /// The used to match URL paths.
+ /// A callback used to handle matching contexts.
+ ///
+ /// is .
+ /// - or -
+ /// is .
+ ///
+ protected void OnAny(RouteMatcher matcher, RouteHandlerCallback handler)
+ => _resolvers.Add(HttpVerbs.Any, matcher, handler);
+
+ ///
+ /// Associates all requests matching a route to a synchronous handler.
+ ///
+ /// The used to match URL paths.
+ /// A callback used to handle matching contexts.
+ ///
+ /// is .
+ /// - or -
+ /// is .
+ ///
+ protected void OnAny(RouteMatcher matcher, SyncRouteHandlerCallback handler)
+ => _resolvers.Add(HttpVerbs.Any, matcher, handler);
+
+ ///
+ /// Associates DELETE requests matching a route to a handler.
+ ///
+ /// The used to match URL paths.
+ /// A callback used to handle matching contexts.
+ ///
+ /// is .
+ /// - or -
+ /// is .
+ ///
+ protected void OnDelete(RouteMatcher matcher, RouteHandlerCallback handler)
+ => _resolvers.Add(HttpVerbs.Delete, matcher, handler);
+
+ ///
+ /// Associates DELETE requests matching a route to a synchronous handler.
+ ///
+ /// The used to match URL paths.
+ /// A callback used to handle matching contexts.
+ ///
+ /// is .
+ /// - or -
+ /// is .
+ ///
+ protected void OnDelete(RouteMatcher matcher, SyncRouteHandlerCallback handler)
+ => _resolvers.Add(HttpVerbs.Delete, matcher, handler);
+
+ ///
+ /// Associates GET requests matching a route to a handler.
+ ///
+ /// The used to match URL paths.
+ /// A callback used to handle matching contexts.
+ ///
+ /// is .
+ /// - or -
+ /// is .
+ ///
+ protected void OnGet(RouteMatcher matcher, RouteHandlerCallback handler)
+ => _resolvers.Add(HttpVerbs.Get, matcher, handler);
+
+ ///
+ /// Associates GET requests matching a route to a synchronous handler.
+ ///
+ /// The used to match URL paths.
+ /// A callback used to handle matching contexts.
+ ///
+ /// is .
+ /// - or -
+ /// is .
+ ///
+ protected void OnGet(RouteMatcher matcher, SyncRouteHandlerCallback handler)
+ => _resolvers.Add(HttpVerbs.Get, matcher, handler);
+
+ ///
+ /// Associates HEAD requests matching a route to a handler.
+ ///
+ /// The used to match URL paths.
+ /// A callback used to handle matching contexts.
+ ///
+ /// is .
+ /// - or -
+ /// is .
+ ///
+ protected void OnHead(RouteMatcher matcher, RouteHandlerCallback handler)
+ => _resolvers.Add(HttpVerbs.Head, matcher, handler);
+
+ ///
+ /// Associates HEAD requests matching a route to a synchronous handler.
+ ///
+ /// The used to match URL paths.
+ /// A callback used to handle matching contexts.
+ ///
+ /// is .
+ /// - or -
+ /// is .
+ ///
+ protected void OnHead(RouteMatcher matcher, SyncRouteHandlerCallback handler)
+ => _resolvers.Add(HttpVerbs.Head, matcher, handler);
+
+ ///
+ /// Associates OPTIONS requests matching a route to a handler.
+ ///
+ /// The used to match URL paths.
+ /// A callback used to handle matching contexts.
+ ///
+ /// is .
+ /// - or -
+ /// is .
+ ///
+ protected void OnOptions(RouteMatcher matcher, RouteHandlerCallback handler)
+ => _resolvers.Add(HttpVerbs.Options, matcher, handler);
+
+ ///
+ /// Associates OPTIONS requests matching a route to a synchronous handler.
+ ///
+ /// The used to match URL paths.
+ /// A callback used to handle matching contexts.
+ ///
+ /// is .
+ /// - or -
+ /// is .
+ ///
+ protected void OnOptions(RouteMatcher matcher, SyncRouteHandlerCallback handler)
+ => _resolvers.Add(HttpVerbs.Options, matcher, handler);
+
+ ///
+ /// Associates PATCH requests matching a route to a handler.
+ ///
+ /// The used to match URL paths.
+ /// A callback used to handle matching contexts.
+ ///
+ /// is .
+ /// - or -
+ /// is .
+ ///
+ protected void OnPatch(RouteMatcher matcher, RouteHandlerCallback handler)
+ => _resolvers.Add(HttpVerbs.Patch, matcher, handler);
+
+ ///
+ /// Associates PATCH requests matching a route to a synchronous handler.
+ ///
+ /// The used to match URL paths.
+ /// A callback used to handle matching contexts.
+ ///
+ /// is .
+ /// - or -
+ /// is .
+ ///
+ protected void OnPatch(RouteMatcher matcher, SyncRouteHandlerCallback handler)
+ => _resolvers.Add(HttpVerbs.Patch, matcher, handler);
+
+ ///
+ /// Associates POST requests matching a route to a handler.
+ ///
+ /// The used to match URL paths.
+ /// A callback used to handle matching contexts.
+ ///
+ /// is .
+ /// - or -
+ /// is .
+ ///
+ protected void OnPost(RouteMatcher matcher, RouteHandlerCallback handler)
+ => _resolvers.Add(HttpVerbs.Post, matcher, handler);
+
+ ///
+ /// Associates POST requests matching a route to a synchronous handler.
+ ///
+ /// The used to match URL paths.
+ /// A callback used to handle matching contexts.
+ ///
+ /// is .
+ /// - or -
+ /// is .
+ ///
+ protected void OnPost(RouteMatcher matcher, SyncRouteHandlerCallback handler)
+ => _resolvers.Add(HttpVerbs.Post, matcher, handler);
+
+ ///
+ /// Associates PUT requests matching a route to a handler.
+ ///
+ /// The used to match URL paths.
+ /// A callback used to handle matching contexts.
+ ///
+ /// is .
+ /// - or -
+ /// is .
+ ///
+ protected void OnPut(RouteMatcher matcher, RouteHandlerCallback handler)
+ => _resolvers.Add(HttpVerbs.Put, matcher, handler);
+
+ ///
+ /// Associates PUT requests matching a route to a synchronous handler.
+ ///
+ /// The used to match URL paths.
+ /// A callback used to handle matching contexts.
+ ///
+ /// is .
+ /// - or -
+ /// is .
+ ///
+ protected void OnPut(RouteMatcher matcher, SyncRouteHandlerCallback handler)
+ => _resolvers.Add(HttpVerbs.Put, matcher, handler);
+
+ ///
+ /// Called when no route is matched for the requested URL path.
+ /// The default behavior is to send an empty 404 Not Found response.
+ ///
+ /// The context of the request being handled.
+ /// A representing the ongoing operation.
+ protected virtual Task OnPathNotFoundAsync(IHttpContext context)
+ => throw HttpException.NotFound();
+
+ ///
+ /// Called when at least one route is matched for the requested URL path,
+ /// but none of them is associated with the HTTP method of the request.
+ /// The default behavior is to send an empty 405 Method Not Allowed response.
+ ///
+ /// The context of the request being handled.
+ /// A representing the ongoing operation.
+ protected virtual Task OnMethodNotAllowedAsync(IHttpContext context)
+ => throw HttpException.MethodNotAllowed();
+ }
+}
\ No newline at end of file
diff --git a/Vendor/EmbedIO-3.5.2/Routing/RoutingModuleExtensions-AddHandlerFromBaseOrTerminalRoute.cs b/Vendor/EmbedIO-3.5.2/Routing/RoutingModuleExtensions-AddHandlerFromBaseOrTerminalRoute.cs
new file mode 100644
index 0000000..321a738
--- /dev/null
+++ b/Vendor/EmbedIO-3.5.2/Routing/RoutingModuleExtensions-AddHandlerFromBaseOrTerminalRoute.cs
@@ -0,0 +1,429 @@
+using System;
+
+namespace EmbedIO.Routing
+{
+ partial class RoutingModuleExtensions
+ {
+ ///
+ /// Adds a handler to a .
+ ///
+ /// The on which this method is called.
+ /// A constant representing the HTTP method
+ /// to associate with , or
+ /// if can handle all HTTP methods.
+ /// The route to match URL paths against.
+ /// if
+ /// is a base route; if
+ /// is a terminal (non-base) route.
+ /// A callback used to handle matching contexts.
+ /// with the handler added.
+ /// is .
+ ///
+ /// is .
+ /// - or -
+ /// is .
+ ///
+ /// is not a valid route.
+ ///
+ public static RoutingModule Handle(this RoutingModule @this, HttpVerbs verb, string route, bool isBaseRoute, RouteHandlerCallback handler)
+ {
+ @this.Add(verb, RouteMatcher.Parse(route, isBaseRoute), handler);
+ return @this;
+ }
+
+ ///
+ /// Adds a synchronous handler to a .
+ ///
+ /// The on which this method is called.
+ /// A constant representing the HTTP method
+ /// to associate with , or
+ /// if can handle all HTTP methods.
+ /// The route to match URL paths against.
+ /// if
+ /// is a base route; if
+ /// is a terminal (non-base) route.
+ /// A callback used to handle matching contexts.
+ /// with the handler added.
+ /// is .
+ ///
+ /// is .
+ /// - or -
+ /// is .
+ ///
+ /// is not a valid route.
+ ///
+ public static RoutingModule Handle(this RoutingModule @this, HttpVerbs verb, string route, bool isBaseRoute, SyncRouteHandlerCallback handler)
+ {
+ @this.Add(verb, RouteMatcher.Parse(route, isBaseRoute), handler);
+ return @this;
+ }
+
+ ///
+ /// Associates all requests matching a route to a handler.
+ ///
+ /// The on which this method is called.
+ /// The route to match URL paths against.
+ /// if
+ /// is a base route; if
+ /// is a terminal (non-base) route.
+ /// A callback used to handle matching contexts.
+ /// with the handler added.
+ /// is .
+ ///
+ /// is .
+ /// - or -
+ /// is .
+ ///
+ /// is not a valid route.
+ public static RoutingModule OnAny(this RoutingModule @this, string route, bool isBaseRoute, RouteHandlerCallback handler)
+ {
+ @this.Add(HttpVerbs.Any, RouteMatcher.Parse(route, isBaseRoute), handler);
+ return @this;
+ }
+
+ ///
+ /// Associates all requests matching a route to a synchronous handler.
+ ///
+ /// The on which this method is called.
+ /// The route to match URL paths against.
+ /// if
+ /// is a base route; if
+ /// is a terminal (non-base) route.
+ /// A callback used to handle matching contexts.
+ /// with the handler added.
+ /// is .
+ ///
+ /// is .
+ /// - or -
+ /// is .
+ ///
+ /// is not a valid route.
+ public static RoutingModule OnAny(this RoutingModule @this, string route, bool isBaseRoute, SyncRouteHandlerCallback handler)
+ {
+ @this.Add(HttpVerbs.Any, RouteMatcher.Parse(route, isBaseRoute), handler);
+ return @this;
+ }
+
+ ///
+ /// Associates DELETE requests matching a route to a handler.
+ ///
+ /// The on which this method is called.
+ /// The route to match URL paths against.
+ /// if
+ /// is a base route; if
+ /// is a terminal (non-base) route.
+ /// A callback used to handle matching contexts.
+ /// with the handler added.
+ /// is .
+ ///
+ /// is .
+ /// - or -
+ /// is .
+ ///
+ /// is not a valid route.
+ public static RoutingModule OnDelete(this RoutingModule @this, string route, bool isBaseRoute, RouteHandlerCallback handler)
+ {
+ @this.Add(HttpVerbs.Delete, RouteMatcher.Parse(route, isBaseRoute), handler);
+ return @this;
+ }
+
+ ///
+ /// Associates DELETE requests matching a route to a synchronous handler.
+ ///
+ /// The on which this method is called.
+ /// The route to match URL paths against.
+ /// if
+ /// is a base route; if
+ /// is a terminal (non-base) route.
+ /// A callback used to handle matching contexts.
+ /// with the handler added.
+ /// is .
+ ///
+ /// is .
+ /// - or -
+ /// is .
+ ///
+ /// is not a valid route.
+ public static RoutingModule OnDelete(this RoutingModule @this, string route, bool isBaseRoute, SyncRouteHandlerCallback handler)
+ {
+ @this.Add(HttpVerbs.Delete, RouteMatcher.Parse(route, isBaseRoute), handler);
+ return @this;
+ }
+
+ ///
+ /// Associates GET requests matching a route to a handler.
+ ///
+ /// The on which this method is called.
+ /// The route to match URL paths against.
+ /// if
+ /// is a base route; if
+ /// is a terminal (non-base) route.
+ /// A callback used to handle matching contexts.
+ /// with the handler added.
+ /// is .
+ ///
+ /// is .
+ /// - or -
+ /// is .
+ ///
+ /// is not a valid route.
+ public static RoutingModule OnGet(this RoutingModule @this, string route, bool isBaseRoute, RouteHandlerCallback handler)
+ {
+ @this.Add(HttpVerbs.Get, RouteMatcher.Parse(route, isBaseRoute), handler);
+ return @this;
+ }
+
+ ///
+ /// Associates GET requests matching a route to a synchronous handler.
+ ///
+ /// The on which this method is called.
+ /// The route to match URL paths against.
+ /// if
+ /// is a base route; if
+ /// is a terminal (non-base) route.
+ /// A callback used to handle matching contexts.
+ /// with the handler added.
+ /// is .
+ ///
+ /// is .
+ /// - or -
+ /// is .
+ ///
+ /// is not a valid route.
+ public static RoutingModule OnGet(this RoutingModule @this, string route, bool isBaseRoute, SyncRouteHandlerCallback handler)
+ {
+ @this.Add(HttpVerbs.Get, RouteMatcher.Parse(route, isBaseRoute), handler);
+ return @this;
+ }
+
+ ///
+ /// Associates HEAD requests matching a route to a handler.
+ ///
+ /// The on which this method is called.
+ /// The route to match URL paths against.
+ /// if
+ /// is a base route; if
+ /// is a terminal (non-base) route.
+ /// A callback used to handle matching contexts.
+ /// with the handler added.
+ /// is .
+ ///
+ /// is .
+ /// - or -
+ /// is .
+ ///
+ /// is not a valid route.
+ public static RoutingModule OnHead(this RoutingModule @this, string route, bool isBaseRoute, RouteHandlerCallback handler)
+ {
+ @this.Add(HttpVerbs.Head, RouteMatcher.Parse(route, isBaseRoute), handler);
+ return @this;
+ }
+
+ ///
+ /// Associates HEAD requests matching a route to a synchronous handler.
+ ///
+ /// The on which this method is called.
+ /// The route to match URL paths against.
+ /// if
+ /// is a base route; if
+ /// is a terminal (non-base) route.
+ /// A callback used to handle matching contexts.
+ /// with the handler added.
+ /// is .
+ ///
+ /// is .
+ /// - or -
+ /// is .
+ ///
+ /// is not a valid route.
+ public static RoutingModule OnHead(this RoutingModule @this, string route, bool isBaseRoute, SyncRouteHandlerCallback handler)
+ {
+ @this.Add(HttpVerbs.Head, RouteMatcher.Parse(route, isBaseRoute), handler);
+ return @this;
+ }
+
+ ///
+ /// Associates OPTIONS requests matching a route to a handler.
+ ///
+ /// The on which this method is called.
+ /// The route to match URL paths against.
+ /// if
+ /// is a base route; if
+ /// is a terminal (non-base) route.
+ /// A callback used to handle matching contexts.
+ /// with the handler added.
+ /// is .
+ ///
+ /// is .
+ /// - or -
+ /// is .
+ ///
+ /// is not a valid route.
+ public static RoutingModule OnOptions(this RoutingModule @this, string route, bool isBaseRoute, RouteHandlerCallback handler)
+ {
+ @this.Add(HttpVerbs.Options, RouteMatcher.Parse(route, isBaseRoute), handler);
+ return @this;
+ }
+
+ ///
+ /// Associates OPTIONS requests matching a route to a synchronous handler.
+ ///
+ /// The on which this method is called.
+ /// The route to match URL paths against.
+ /// if
+ /// is a base route; if
+ /// is a terminal (non-base) route.
+ /// A callback used to handle matching contexts.
+ /// with the handler added.
+ /// is .
+ ///
+ /// is .
+ /// - or -
+ /// is .
+ ///
+ /// is not a valid route.
+ public static RoutingModule OnOptions(this RoutingModule @this, string route, bool isBaseRoute, SyncRouteHandlerCallback handler)
+ {
+ @this.Add(HttpVerbs.Options, RouteMatcher.Parse(route, isBaseRoute), handler);
+ return @this;
+ }
+
+ ///
+ /// Associates PATCH requests matching a route to a handler.
+ ///
+ /// The on which this method is called.
+ /// The route to match URL paths against.
+ /// if
+ /// is a base route; if
+ /// is a terminal (non-base) route.
+ /// A callback used to handle matching contexts.
+ /// with the handler added.
+ /// is .
+ ///
+ /// is .
+ /// - or -
+ /// is .
+ ///
+ /// is not a valid route.
+ public static RoutingModule OnPatch(this RoutingModule @this, string route, bool isBaseRoute, RouteHandlerCallback handler)
+ {
+ @this.Add(HttpVerbs.Patch, RouteMatcher.Parse(route, isBaseRoute), handler);
+ return @this;
+ }
+
+ ///
+ /// Associates PATCH requests matching a route to a synchronous handler.
+ ///
+ /// The on which this method is called.
+ /// The route to match URL paths against.
+ /// if
+ /// is a base route; if
+ /// is a terminal (non-base) route.
+ /// A callback used to handle matching contexts.
+ /// with the handler added.
+ /// is .
+ ///
+ /// is .
+ /// - or -
+ /// is .
+ ///
+ /// is not a valid route.
+ public static RoutingModule OnPatch(this RoutingModule @this, string route, bool isBaseRoute, SyncRouteHandlerCallback handler)
+ {
+ @this.Add(HttpVerbs.Patch, RouteMatcher.Parse(route, isBaseRoute), handler);
+ return @this;
+ }
+
+ ///
+ /// Associates POST requests matching a route to a handler.
+ ///
+ /// The on which this method is called.
+ /// The route to match URL paths against.
+ /// if
+ /// is a base route; if
+ /// is a terminal (non-base) route.
+ /// A callback used to handle matching contexts.
+ /// with the handler added.
+ /// is .
+ ///
+ /// is .
+ /// - or -
+ /// is .
+ ///
+ /// is not a valid route.
+ public static RoutingModule OnPost(this RoutingModule @this, string route, bool isBaseRoute, RouteHandlerCallback handler)
+ {
+ @this.Add(HttpVerbs.Post, RouteMatcher.Parse(route, isBaseRoute), handler);
+ return @this;
+ }
+
+ ///
+ /// Associates POST requests matching a route to a synchronous handler.
+ ///
+ /// The on which this method is called.
+ /// The route to match URL paths against.
+ /// if
+ /// is a base route; if
+ /// is a terminal (non-base) route.
+ /// A callback used to handle matching contexts.
+ /// with the handler added.
+ /// is .
+ ///
+ /// is .
+ /// - or -
+ /// is .
+ ///
+ /// is not a valid route.
+ public static RoutingModule OnPost(this RoutingModule @this, string route, bool isBaseRoute, SyncRouteHandlerCallback handler)
+ {
+ @this.Add(HttpVerbs.Post, RouteMatcher.Parse(route, isBaseRoute), handler);
+ return @this;
+ }
+
+ ///
+ /// Associates PUT requests matching a route to a handler.
+ ///
+ /// The on which this method is called.
+ /// The route to match URL paths against.
+ /// if
+ /// is a base route; if
+ /// is a terminal (non-base) route.
+ /// A callback used to handle matching contexts.
+ /// with the handler added.
+ /// is .
+ ///
+ /// is .
+ /// - or -
+ /// is .
+ ///
+ /// is not a valid route.
+ public static RoutingModule OnPut(this RoutingModule @this, string route, bool isBaseRoute, RouteHandlerCallback handler)
+ {
+ @this.Add(HttpVerbs.Put, RouteMatcher.Parse(route, isBaseRoute), handler);
+ return @this;
+ }
+
+ ///
+ /// Associates PUT requests matching a route to a synchronous handler.
+ ///
+ /// The on which this method is called.
+ /// The route to match URL paths against.
+ /// if
+ /// is a base route; if
+ /// is a terminal (non-base) route.
+ /// A callback used to handle matching contexts.
+ /// with the handler added.
+ /// is .
+ ///
+ /// is .
+ /// - or -
+ /// is .
+ ///
+ /// is not a valid route.
+ public static RoutingModule OnPut(this RoutingModule @this, string route, bool isBaseRoute, SyncRouteHandlerCallback handler)
+ {
+ @this.Add(HttpVerbs.Put, RouteMatcher.Parse(route, isBaseRoute), handler);
+ return @this;
+ }
+ }
+}
\ No newline at end of file
diff --git a/Vendor/EmbedIO-3.5.2/Routing/RoutingModuleExtensions-AddHandlerFromRouteMatcher.cs b/Vendor/EmbedIO-3.5.2/Routing/RoutingModuleExtensions-AddHandlerFromRouteMatcher.cs
new file mode 100644
index 0000000..fb0e255
--- /dev/null
+++ b/Vendor/EmbedIO-3.5.2/Routing/RoutingModuleExtensions-AddHandlerFromRouteMatcher.cs
@@ -0,0 +1,357 @@
+using System;
+
+namespace EmbedIO.Routing
+{
+ partial class RoutingModuleExtensions
+ {
+ ///
+ /// Adds a handler to a .
+ ///
+ /// The on which this method is called.
+ /// A constant representing the HTTP method
+ /// to associate with , or
+ /// if can handle all HTTP methods.
+ /// The used to match URL paths.
+ /// A callback used to handle matching contexts.
+ /// with the handler added.
+ /// is .
+ ///
+ /// is .
+ /// - or -
+ /// is .
+ ///
+ ///
+ public static RoutingModule Handle(this RoutingModule @this, HttpVerbs verb, RouteMatcher matcher, RouteHandlerCallback handler)
+ {
+ @this.Add(verb, matcher, handler);
+ return @this;
+ }
+
+ ///
+ /// Adds a synchronous handler to a .
+ ///
+ /// The on which this method is called.
+ /// A constant representing the HTTP method
+ /// to associate with , or
+ /// if can handle all HTTP methods.
+ /// The used to match URL paths.
+ /// A callback used to handle matching contexts.
+ /// with the handler added.
+ /// is .
+ ///
+ /// is .
+ /// - or -
+ /// is .
+ ///
+ ///
+ public static RoutingModule Handle(this RoutingModule @this, HttpVerbs verb, RouteMatcher matcher, SyncRouteHandlerCallback handler)
+ {
+ @this.Add(verb, matcher, handler);
+ return @this;
+ }
+
+ ///
+ /// Associates all requests matching a route to a handler.
+ ///
+ /// The on which this method is called.
+ /// The used to match URL paths.
+ /// A callback used to handle matching contexts.
+ /// with the handler added.
+ /// is .
+ ///
+ /// is .
+ /// - or -
+ /// is .
+ ///
+ public static RoutingModule OnAny(this RoutingModule @this, RouteMatcher matcher, RouteHandlerCallback handler)
+ {
+ @this.Add(HttpVerbs.Any, matcher, handler);
+ return @this;
+ }
+
+ ///
+ /// Associates all requests matching a route to a synchronous handler.
+ ///
+ /// The on which this method is called.
+ /// The used to match URL paths.
+ /// A callback used to handle matching contexts.
+ /// with the handler added.
+ /// is .
+ ///
+ /// is .
+ /// - or -
+ /// is .
+ ///
+ public static RoutingModule OnAny(this RoutingModule @this, RouteMatcher matcher, SyncRouteHandlerCallback handler)
+ {
+ @this.Add(HttpVerbs.Any, matcher, handler);
+ return @this;
+ }
+
+ ///
+ /// Associates DELETE requests matching a route to a handler.
+ ///
+ /// The on which this method is called.
+ /// The used to match URL paths.
+ /// A callback used to handle matching contexts.
+ /// with the handler added.
+ /// is .
+ ///
+ /// is .
+ /// - or -
+ /// is .
+ ///
+ public static RoutingModule OnDelete(this RoutingModule @this, RouteMatcher matcher, RouteHandlerCallback handler)
+ {
+ @this.Add(HttpVerbs.Delete, matcher, handler);
+ return @this;
+ }
+
+ ///
+ /// Associates DELETE requests matching a route to a synchronous handler.
+ ///
+ /// The on which this method is called.
+ /// The used to match URL paths.
+ /// A callback used to handle matching contexts.
+ /// with the handler added.
+ /// is .
+ ///
+ /// is .
+ /// - or -
+ /// is .
+ ///
+ public static RoutingModule OnDelete(this RoutingModule @this, RouteMatcher matcher, SyncRouteHandlerCallback handler)
+ {
+ @this.Add(HttpVerbs.Delete, matcher, handler);
+ return @this;
+ }
+
+ ///
+ /// Associates GET requests matching a route to a handler.
+ ///
+ /// The on which this method is called.
+ /// The used to match URL paths.
+ /// A callback used to handle matching contexts.
+ /// with the handler added.
+ /// is .
+ ///
+ /// is .
+ /// - or -
+ /// is .
+ ///
+ public static RoutingModule OnGet(this RoutingModule @this, RouteMatcher matcher, RouteHandlerCallback handler)
+ {
+ @this.Add(HttpVerbs.Get, matcher, handler);
+ return @this;
+ }
+
+ ///
+ /// Associates GET requests matching a route to a synchronous handler.
+ ///
+ /// The on which this method is called.
+ /// The used to match URL paths.
+ /// A callback used to handle matching contexts.
+ /// with the handler added.
+ /// is .
+ ///
+ /// is .
+ /// - or -
+ /// is .
+ ///
+ public static RoutingModule OnGet(this RoutingModule @this, RouteMatcher matcher, SyncRouteHandlerCallback handler)
+ {
+ @this.Add(HttpVerbs.Get, matcher, handler);
+ return @this;
+ }
+
+ ///
+ /// Associates HEAD requests matching a route to a handler.
+ ///
+ /// The on which this method is called.
+ /// The used to match URL paths.
+ /// A callback used to handle matching contexts.
+ /// with the handler added.
+ /// is .
+ ///
+ /// is .
+ /// - or -
+ /// is .
+ ///
+ public static RoutingModule OnHead(this RoutingModule @this, RouteMatcher matcher, RouteHandlerCallback handler)
+ {
+ @this.Add(HttpVerbs.Head, matcher, handler);
+ return @this;
+ }
+
+ ///
+ /// Associates HEAD requests matching a route to a synchronous handler.
+ ///
+ /// The on which this method is called.
+ /// The used to match URL paths.
+ /// A callback used to handle matching contexts.
+ /// with the handler added.
+ /// is .
+ ///
+ /// is .
+ /// - or -
+ /// is .
+ ///
+ public static RoutingModule OnHead(this RoutingModule @this, RouteMatcher matcher, SyncRouteHandlerCallback handler)
+ {
+ @this.Add(HttpVerbs.Head, matcher, handler);
+ return @this;
+ }
+
+ ///
+ /// Associates OPTIONS requests matching a route to a handler.
+ ///
+ /// The on which this method is called.
+ /// The used to match URL paths.
+ /// A callback used to handle matching contexts.
+ /// with the handler added.
+ /// is .
+ ///
+ /// is .
+ /// - or -
+ /// is .
+ ///
+ public static RoutingModule OnOptions(this RoutingModule @this, RouteMatcher matcher, RouteHandlerCallback handler)
+ {
+ @this.Add(HttpVerbs.Options, matcher, handler);
+ return @this;
+ }
+
+ ///
+ /// Associates OPTIONS requests matching a route to a synchronous handler.
+ ///
+ /// The on which this method is called.
+ /// The used to match URL paths.
+ /// A callback used to handle matching contexts.
+ /// with the handler added.
+ /// is .
+ ///
+ /// is .
+ /// - or -
+ /// is .
+ ///
+ public static RoutingModule OnOptions(this RoutingModule @this, RouteMatcher matcher, SyncRouteHandlerCallback handler)
+ {
+ @this.Add(HttpVerbs.Options, matcher, handler);
+ return @this;
+ }
+
+ ///
+ /// Associates PATCH requests matching a route to a handler.
+ ///
+ /// The on which this method is called.
+ /// The used to match URL paths.
+ /// A callback used to handle matching contexts.
+ /// with the handler added.
+ /// is .
+ ///
+ /// is .
+ /// - or -
+ /// is .
+ ///
+ public static RoutingModule OnPatch(this RoutingModule @this, RouteMatcher matcher, RouteHandlerCallback handler)
+ {
+ @this.Add(HttpVerbs.Patch, matcher, handler);
+ return @this;
+ }
+
+ ///
+ /// Associates PATCH requests matching a route to a synchronous handler.
+ ///
+ /// The on which this method is called.
+ /// The used to match URL paths.
+ /// A callback used to handle matching contexts.
+ /// with the handler added.
+ /// is .
+ ///
+ /// is .
+ /// - or -
+ /// is .
+ ///
+ public static RoutingModule OnPatch(this RoutingModule @this, RouteMatcher matcher, SyncRouteHandlerCallback handler)
+ {
+ @this.Add(HttpVerbs.Patch, matcher, handler);
+ return @this;
+ }
+
+ ///
+ /// Associates POST requests matching a route to a handler.
+ ///
+ /// The on which this method is called.
+ /// The used to match URL paths.
+ /// A callback used to handle matching contexts.
+ /// with the handler added.
+ /// is .
+ ///
+ /// is .
+ /// - or -
+ /// is .
+ ///
+ public static RoutingModule OnPost(this RoutingModule @this, RouteMatcher matcher, RouteHandlerCallback handler)
+ {
+ @this.Add(HttpVerbs.Post, matcher, handler);
+ return @this;
+ }
+
+ ///
+ /// Associates POST requests matching a route to a synchronous handler.
+ ///
+ /// The on which this method is called.
+ /// The used to match URL paths.
+ /// A callback used to handle matching contexts.
+ /// with the handler added.
+ /// is .
+ ///
+ /// is .
+ /// - or -
+ /// is .
+ ///
+ public static RoutingModule OnPost(this RoutingModule @this, RouteMatcher matcher, SyncRouteHandlerCallback handler)
+ {
+ @this.Add(HttpVerbs.Post, matcher, handler);
+ return @this;
+ }
+
+ ///
+ /// Associates PUT requests matching a route to a handler.
+ ///
+ /// The on which this method is called.
+ /// The used to match URL paths.
+ /// A callback used to handle matching contexts.
+ /// with the handler added.
+ /// is .
+ ///
+ /// is .
+ /// - or -
+ /// is .
+ ///
+ public static RoutingModule OnPut(this RoutingModule @this, RouteMatcher matcher, RouteHandlerCallback handler)
+ {
+ @this.Add(HttpVerbs.Put, matcher, handler);
+ return @this;
+ }
+
+ ///
+ /// Associates PUT requests matching a route to a synchronous handler.
+ ///
+ /// The on which this method is called.
+ /// The used to match URL paths.
+ /// A callback used to handle matching contexts.
+ /// with the handler added.
+ /// is .
+ ///
+ /// is .
+ /// - or -
+ /// is .
+ ///
+ public static RoutingModule OnPut(this RoutingModule @this, RouteMatcher matcher, SyncRouteHandlerCallback handler)
+ {
+ @this.Add(HttpVerbs.Put, matcher, handler);
+ return @this;
+ }
+ }
+}
\ No newline at end of file
diff --git a/Vendor/EmbedIO-3.5.2/Routing/RoutingModuleExtensions-AddHandlerFromTerminalRoute.cs b/Vendor/EmbedIO-3.5.2/Routing/RoutingModuleExtensions-AddHandlerFromTerminalRoute.cs
new file mode 100644
index 0000000..4e34ae7
--- /dev/null
+++ b/Vendor/EmbedIO-3.5.2/Routing/RoutingModuleExtensions-AddHandlerFromTerminalRoute.cs
@@ -0,0 +1,375 @@
+using System;
+
+namespace EmbedIO.Routing
+{
+ partial class RoutingModuleExtensions
+ {
+ ///
+ /// Adds a handler to a .
+ ///
+ /// The on which this method is called.
+ /// A constant representing the HTTP method
+ /// to associate with , or
+ /// if can handle all HTTP methods.
+ /// The route to match URL paths against.
+ /// A callback used to handle matching contexts.
+ /// with the handler added.
+ /// is .
+ ///
+ /// is .
+ /// - or -
+ /// is .
+ ///
+ /// is not a valid route.
+ ///
+ public static RoutingModule Handle(this RoutingModule @this, HttpVerbs verb, string route, RouteHandlerCallback handler)
+ {
+ @this.Add(verb, RouteMatcher.Parse(route, false), handler);
+ return @this;
+ }
+
+ ///
+ /// Adds a synchronous handler to a .
+ ///
+ /// The on which this method is called.
+ /// A constant representing the HTTP method
+ /// to associate with , or
+ /// if can handle all HTTP methods.
+ /// The route to match URL paths against.
+ /// A callback used to handle matching contexts.
+ /// with the handler added.
+ /// is .
+ ///
+ /// is .
+ /// - or -
+ /// is .
+ ///
+ /// is not a valid route.
+ ///
+ public static RoutingModule Handle(this RoutingModule @this, HttpVerbs verb, string route, SyncRouteHandlerCallback handler)
+ {
+ @this.Add(verb, RouteMatcher.Parse(route, false), handler);
+ return @this;
+ }
+
+ ///
+ /// Associates all requests matching a route to a handler.
+ ///
+ /// The on which this method is called.
+ /// The route to match URL paths against.
+ /// A callback used to handle matching contexts.
+ /// with the handler added.
+ /// is .
+ ///
+ /// is .
+ /// - or -
+ /// is .
+ ///
+ /// is not a valid route.
+ public static RoutingModule OnAny(this RoutingModule @this, string route, RouteHandlerCallback handler)
+ {
+ @this.Add(HttpVerbs.Any, RouteMatcher.Parse(route, false), handler);
+ return @this;
+ }
+
+ ///
+ /// Associates all requests matching a route to a synchronous handler.
+ ///
+ /// The on which this method is called.
+ /// The route to match URL paths against.
+ /// A callback used to handle matching contexts.
+ /// with the handler added.
+ /// is .
+ ///
+ /// is .
+ /// - or -
+ /// is .
+ ///
+ /// is not a valid route.
+ public static RoutingModule OnAny(this RoutingModule @this, string route, SyncRouteHandlerCallback handler)
+ {
+ @this.Add(HttpVerbs.Any, RouteMatcher.Parse(route, false), handler);
+ return @this;
+ }
+
+ ///
+ /// Associates DELETE requests matching a route to a handler.
+ ///
+ /// The on which this method is called.
+ /// The route to match URL paths against.
+ /// A callback used to handle matching contexts.
+ /// with the handler added.
+ /// is .
+ ///
+ /// is .
+ /// - or -
+ /// is .
+ ///
+ /// is not a valid route.
+ public static RoutingModule OnDelete(this RoutingModule @this, string route, RouteHandlerCallback handler)
+ {
+ @this.Add(HttpVerbs.Delete, RouteMatcher.Parse(route, false), handler);
+ return @this;
+ }
+
+ ///
+ /// Associates DELETE requests matching a route to a synchronous handler.
+ ///
+ /// The on which this method is called.
+ /// The route to match URL paths against.
+ /// A callback used to handle matching contexts.
+ /// with the handler added.
+ /// is .
+ ///
+ /// is .
+ /// - or -
+ /// is .
+ ///
+ /// is not a valid route.
+ public static RoutingModule OnDelete(this RoutingModule @this, string route, SyncRouteHandlerCallback handler)
+ {
+ @this.Add(HttpVerbs.Delete, RouteMatcher.Parse(route, false), handler);
+ return @this;
+ }
+
+ ///
+ /// Associates GET requests matching a route to a handler.
+ ///
+ /// The on which this method is called.
+ /// The route to match URL paths against.
+ /// A callback used to handle matching contexts.
+ /// with the handler added.
+ /// is .
+ ///
+ /// is .
+ /// - or -
+ /// is .
+ ///
+ /// is not a valid route.
+ public static RoutingModule OnGet(this RoutingModule @this, string route, RouteHandlerCallback handler)
+ {
+ @this.Add(HttpVerbs.Get, RouteMatcher.Parse(route, false), handler);
+ return @this;
+ }
+
+ ///
+ /// Associates GET requests matching a route to a synchronous handler.
+ ///
+ /// The on which this method is called.
+ /// The route to match URL paths against.
+ /// A callback used to handle matching contexts.
+ /// with the handler added.
+ /// is .
+ ///
+ /// is .
+ /// - or -
+ /// is .
+ ///
+ /// is not a valid route.
+ public static RoutingModule OnGet(this RoutingModule @this, string route, SyncRouteHandlerCallback handler)
+ {
+ @this.Add(HttpVerbs.Get, RouteMatcher.Parse(route, false), handler);
+ return @this;
+ }
+
+ ///
+ /// Associates HEAD requests matching a route to a handler.
+ ///
+ /// The on which this method is called.
+ /// The route to match URL paths against.
+ /// A callback used to handle matching contexts.
+ /// with the handler added.
+ /// is .
+ ///
+ /// is .
+ /// - or -
+ /// is .
+ ///
+ /// is not a valid route.
+ public static RoutingModule OnHead(this RoutingModule @this, string route, RouteHandlerCallback handler)
+ {
+ @this.Add(HttpVerbs.Head, RouteMatcher.Parse(route, false), handler);
+ return @this;
+ }
+
+ ///
+ /// Associates HEAD requests matching a route to a synchronous handler.
+ ///
+ /// The on which this method is called.
+ /// The route to match URL paths against.
+ /// A callback used to handle matching contexts.
+ /// with the handler added.
+ /// is .
+ ///
+ /// is .
+ /// - or -
+ /// is .
+ ///
+ /// is not a valid route.
+ public static RoutingModule OnHead(this RoutingModule @this, string route, SyncRouteHandlerCallback handler)
+ {
+ @this.Add(HttpVerbs.Head, RouteMatcher.Parse(route, false), handler);
+ return @this;
+ }
+
+ ///
+ /// Associates OPTIONS requests matching a route to a handler.
+ ///
+ /// The on which this method is called.
+ /// The route to match URL paths against.
+ /// A callback used to handle matching contexts.
+ /// with the handler added.
+ /// is .
+ ///
+ /// is .
+ /// - or -
+ /// is .
+ ///
+ /// is not a valid route.
+ public static RoutingModule OnOptions(this RoutingModule @this, string route, RouteHandlerCallback handler)
+ {
+ @this.Add(HttpVerbs.Options, RouteMatcher.Parse(route, false), handler);
+ return @this;
+ }
+
+ ///
+ /// Associates OPTIONS requests matching a route to a synchronous handler.
+ ///
+ /// The on which this method is called.
+ /// The route to match URL paths against.
+ /// A callback used to handle matching contexts.
+ /// with the handler added.
+ /// is .
+ ///
+ /// is .
+ /// - or -
+ /// is .
+ ///
+ /// is not a valid route.
+ public static RoutingModule OnOptions(this RoutingModule @this, string route, SyncRouteHandlerCallback handler)
+ {
+ @this.Add(HttpVerbs.Options, RouteMatcher.Parse(route, false), handler);
+ return @this;
+ }
+
+ ///
+ /// Associates PATCH requests matching a route to a handler.
+ ///
+ /// The on which this method is called.
+ /// The route to match URL paths against.
+ /// A callback used to handle matching contexts.
+ /// with the handler added.
+ /// is .
+ ///
+ /// is .
+ /// - or -
+ /// is .
+ ///
+ /// is not a valid route.
+ public static RoutingModule OnPatch(this RoutingModule @this, string route, RouteHandlerCallback handler)
+ {
+ @this.Add(HttpVerbs.Patch, RouteMatcher.Parse(route, false), handler);
+ return @this;
+ }
+
+ ///
+ /// Associates PATCH requests matching a route to a synchronous handler.
+ ///
+ /// The on which this method is called.
+ /// The route to match URL paths against.
+ /// A callback used to handle matching contexts.
+ /// with the handler added.
+ /// is .
+ ///
+ /// is .
+ /// - or -
+ /// is .
+ ///
+ /// is not a valid route.
+ public static RoutingModule OnPatch(this RoutingModule @this, string route, SyncRouteHandlerCallback handler)
+ {
+ @this.Add(HttpVerbs.Patch, RouteMatcher.Parse(route, false), handler);
+ return @this;
+ }
+
+ ///
+ /// Associates POST requests matching a route to a handler.
+ ///
+ /// The on which this method is called.
+ /// The route to match URL paths against.
+ /// A callback used to handle matching contexts.
+ /// with the handler added.
+ /// is .
+ ///
+ /// is .
+ /// - or -
+ /// is .
+ ///
+ /// is not a valid route.
+ public static RoutingModule OnPost(this RoutingModule @this, string route, RouteHandlerCallback handler)
+ {
+ @this.Add(HttpVerbs.Post, RouteMatcher.Parse(route, false), handler);
+ return @this;
+ }
+
+ ///
+ /// Associates POST requests matching a route to a synchronous handler.
+ ///
+ /// The on which this method is called.
+ /// The route to match URL paths against.
+ /// A callback used to handle matching contexts.
+ /// with the handler added.
+ /// is .
+ ///
+ /// is .
+ /// - or -
+ /// is .
+ ///
+ /// is not a valid route.
+ public static RoutingModule OnPost(this RoutingModule @this, string route, SyncRouteHandlerCallback handler)
+ {
+ @this.Add(HttpVerbs.Post, RouteMatcher.Parse(route, false), handler);
+ return @this;
+ }
+
+ ///
+ /// Associates PUT requests matching a route to a handler.
+ ///
+ /// The on which this method is called.
+ /// The route to match URL paths against.
+ /// A callback used to handle matching contexts.
+ /// with the handler added.
+ /// is .
+ ///
+ /// is .
+ /// - or -
+ /// is .
+ ///
+ /// is not a valid route.
+ public static RoutingModule OnPut(this RoutingModule @this, string route, RouteHandlerCallback handler)
+ {
+ @this.Add(HttpVerbs.Put, RouteMatcher.Parse(route, false), handler);
+ return @this;
+ }
+
+ ///
+ /// Associates PUT requests matching a route to a synchronous handler.
+ ///
+ /// The on which this method is called.
+ /// The route to match URL paths against.
+ /// A callback used to handle matching contexts.
+ /// with the handler added.
+ /// is .
+ ///
+ /// is .
+ /// - or -
+ /// is .
+ ///
+ /// is not a valid route.
+ public static RoutingModule OnPut(this RoutingModule @this, string route, SyncRouteHandlerCallback handler)
+ {
+ @this.Add(HttpVerbs.Put, RouteMatcher.Parse(route, false), handler);
+ return @this;
+ }
+ }
+}
\ No newline at end of file
diff --git a/Vendor/EmbedIO-3.5.2/Routing/RoutingModuleExtensions.cs b/Vendor/EmbedIO-3.5.2/Routing/RoutingModuleExtensions.cs
new file mode 100644
index 0000000..8be3263
--- /dev/null
+++ b/Vendor/EmbedIO-3.5.2/Routing/RoutingModuleExtensions.cs
@@ -0,0 +1,26 @@
+using System;
+
+namespace EmbedIO.Routing
+{
+ ///
+ /// Provides extension methods for .
+ ///
+ public static partial class RoutingModuleExtensions
+ {
+ ///
+ /// Adds handlers, associating them with HTTP method / route pairs by means
+ /// of Route attributes.
+ /// See for further information.
+ ///
+ /// The on which this method is called.
+ /// Where to look for compatible handlers.
+ /// with handlers added.
+ /// is .
+ /// is .
+ public static RoutingModule WithHandlersFrom(this RoutingModule @this, object target)
+ {
+ @this.AddFrom(target);
+ return @this;
+ }
+ }
+}
\ No newline at end of file
diff --git a/Vendor/EmbedIO-3.5.2/Routing/SyncRouteHandlerCallback.cs b/Vendor/EmbedIO-3.5.2/Routing/SyncRouteHandlerCallback.cs
new file mode 100644
index 0000000..c858b9f
--- /dev/null
+++ b/Vendor/EmbedIO-3.5.2/Routing/SyncRouteHandlerCallback.cs
@@ -0,0 +1,10 @@
+namespace EmbedIO.Routing
+{
+ ///
+ /// Base class for callbacks used to handle routed requests synchronously.
+ ///
+ /// An interface representing the context of the request.
+ /// The matched route.
+ ///
+ public delegate void SyncRouteHandlerCallback(IHttpContext context, RouteMatch route);
+}
\ No newline at end of file
diff --git a/Vendor/EmbedIO-3.5.2/Security/BanInfo.cs b/Vendor/EmbedIO-3.5.2/Security/BanInfo.cs
new file mode 100644
index 0000000..83a6269
--- /dev/null
+++ b/Vendor/EmbedIO-3.5.2/Security/BanInfo.cs
@@ -0,0 +1,25 @@
+using System.Net;
+
+namespace EmbedIO.Security
+{
+ ///
+ /// Contains information about the ban of an IP address.
+ ///
+ public class BanInfo
+ {
+ ///
+ /// Gets or sets the banned IP address.
+ ///
+ public IPAddress IPAddress { get; set; }
+
+ ///
+ /// Gets or sets the expiration time of the ban.
+ ///
+ public long ExpiresAt { get; set; }
+
+ ///
+ /// Gets or sets a value indicating whether this instance was explicitly banned.
+ ///
+ public bool IsExplicit { get; set; }
+ }
+}
diff --git a/Vendor/EmbedIO-3.5.2/Security/IIPBanningCriterion.cs b/Vendor/EmbedIO-3.5.2/Security/IIPBanningCriterion.cs
new file mode 100644
index 0000000..7a13ee1
--- /dev/null
+++ b/Vendor/EmbedIO-3.5.2/Security/IIPBanningCriterion.cs
@@ -0,0 +1,30 @@
+using System;
+using System.Net;
+using System.Threading.Tasks;
+
+namespace EmbedIO.Security
+{
+ ///
+ /// Represents a criterion for .
+ ///
+ public interface IIPBanningCriterion : IDisposable
+ {
+ ///
+ /// Validates the IP address should be banned or not.
+ ///
+ /// The address.
+ /// true if the IP Address should be banned, otherwise false.
+ Task ValidateIPAddress(IPAddress address);
+
+ ///
+ /// Clears the data generated by an IP address.
+ ///
+ /// The address.
+ void ClearIPAddress(IPAddress address);
+
+ ///
+ /// Purges the data of the Criterion.
+ ///
+ void PurgeData();
+ }
+}
diff --git a/Vendor/EmbedIO-3.5.2/Security/IPBanningConfiguration.cs b/Vendor/EmbedIO-3.5.2/Security/IPBanningConfiguration.cs
new file mode 100644
index 0000000..a91b89f
--- /dev/null
+++ b/Vendor/EmbedIO-3.5.2/Security/IPBanningConfiguration.cs
@@ -0,0 +1,188 @@
+using EmbedIO.Utilities;
+using Swan.Configuration;
+using System;
+using System.Collections.Concurrent;
+using System.Collections.Generic;
+using System.Linq;
+using System.Net;
+using System.Threading.Tasks;
+
+namespace EmbedIO.Security
+{
+ ///
+ /// Represents a configuration object for .
+ ///
+ ///
+ public class IPBanningConfiguration : ConfiguredObject, IDisposable
+ {
+ private readonly List _criterions = new List();
+ private readonly ConcurrentDictionary _blacklistDictionary = new ConcurrentDictionary();
+ private readonly ConcurrentBag _whiteListBag = new ConcurrentBag();
+ private readonly int _banTime;
+ private bool _disposed;
+
+ internal IPBanningConfiguration(int banTime)
+ {
+ _banTime = banTime;
+ }
+
+ ///