/// <summary>
/// Sends headers to disable caching on the client side.
/// </summary>
/// <param name="context">The context.</param>
public static void NoCache(this HttpListenerContext context)
{
context.Response.AddHeader(Headers.Expires, "Mon, 26 Jul 1997 05:00:00 GMT");
context.Response.AddHeader(Headers.LastModified, DateTime.UtcNow.ToString(Strings.BrowserTimeFormat, Strings.StandardCultureInfo));
context.Response.AddHeader(Headers.CacheControl, "no-store, no-cache, must-revalidate");
context.Response.AddHeader(Headers.Pragma, "no-cache");
}
/// <summary>
/// Fixes the session cookie to match the correct value.
/// System.Net.Cookie.Value only supports a single value and we need to pick the one that potentially exists.
/// </summary>
/// <param name="context">The context.</param>
private void FixupSessionCookie(HttpListenerContext context)
{
// get the real "__session" cookie value because sometimes there's more than 1 value and System.Net.Cookie only supports 1 value per cookie
if (context.Request.Headers[Headers.Cookie] == null)
{
return;
}
var cookieItems = context.Request.Headers[Headers.Cookie].Split(Strings.CookieSplitChars, StringSplitOptions.RemoveEmptyEntries);
foreach (var cookieItem in cookieItems)
{
var nameValue = cookieItem.Trim().Split(new[] { '=' }, StringSplitOptions.RemoveEmptyEntries);
if (nameValue.Length == 2 && nameValue[0].Equals(SessionCookieName))
{
var sessionIdValue = nameValue[1].Trim();
if (!_sessions.ContainsKey(sessionIdValue))
{
continue;
}
context.Request.Cookies[SessionCookieName].Value = sessionIdValue;
break;
}
}
}
/// <summary>
/// Outputs async a string response given a string.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="content">The content.</param>
/// <param name="contentType">Type of the content.</param>
/// <param name="cancellationToken">The cancellation token.</param>
/// <param name="encoding">The encoding.</param>
/// <returns>A task for writing the output stream.</returns>
public static async Task <bool> StringResponseAsync(this HttpListenerContext context, string content, string contentType = "application/json", CancellationToken cancellationToken = default, Encoding encoding = null)
{
var buffer = (encoding ?? Encoding.UTF8).GetBytes(content);
context.Response.ContentType = contentType;
await context.Response.OutputStream.WriteAsync(buffer, 0, buffer.Length, cancellationToken);
return(true);
}
/// <inheritdoc />
public SessionInfo GetSession(HttpListenerContext context)
{
lock (_sessionsSyncLock)
{
if (context.Request.Cookies[SessionCookieName] == null)
{
return(null);
}
var cookieValue = context.Request.Cookies[SessionCookieName].Value;
return(this[cookieValue]);
}
}
/// <summary>
/// Sets a response static code of 302 and adds a Location header to the response
/// in order to direct the client to a different URL.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="location">The location.</param>
/// <param name="useAbsoluteUrl">if set to <c>true</c> [use absolute URL].</param>
/// <returns><b>true</b> if the headers were set, otherwise <b>false</b>.</returns>
public static bool Redirect(this HttpListenerContext context, string location, bool useAbsoluteUrl = true)
{
if (useAbsoluteUrl)
{
var hostPath = context.Request.Url.GetComponents(UriComponents.Scheme | UriComponents.StrongAuthority, UriFormat.Unescaped);
location = hostPath + location;
}
context.Response.StatusCode = 302;
context.Response.AddHeader("Location", location);
return(true);
}
/// <summary>
/// Retrieves the request body as a string.
/// Note that once this method returns, the underlying input stream cannot be read again as
/// it is not rewindable for obvious reasons. This functionality is by design.
/// </summary>
/// <param name="context">The context.</param>
/// <returns>
/// The rest of the stream as a string, from the current position to the end.
/// If the current position is at the end of the stream, returns an empty string.
/// </returns>
public static string RequestBody(this HttpListenerContext context)
{
if (context.Request.HasEntityBody == false)
{
return(null);
}
using (var body = context.Request.InputStream) // here we have data
{
using (var reader = new StreamReader(body, context.Request.ContentEncoding))
{
return(reader.ReadToEnd());
}
}
}
/// <summary>
/// Gets the request path for the specified context using a wildcard paths to
/// match.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="wildcardPaths">The wildcard paths.</param>
/// <returns>Path for the specified context.</returns>
public static string RequestWilcardPath(this HttpListenerContext context, IEnumerable <string> wildcardPaths)
{
var path = context.Request.Url.LocalPath.ToLowerInvariant();
var wildcardMatch = wildcardPaths.FirstOrDefault(p => // wildcard at the end
path.StartsWith(p.Substring(0, p.Length - ModuleMap.AnyPath.Length))
// wildcard in the middle so check both start/end
|| path.StartsWith(p.Substring(0, p.IndexOf(ModuleMap.AnyPath, StringComparison.Ordinal))) &&
path.EndsWith(p.Substring(p.IndexOf(ModuleMap.AnyPath, StringComparison.Ordinal) + 1)));
if (string.IsNullOrWhiteSpace(wildcardMatch) == false)
{
path = wildcardMatch;
}
return(path);
}
/// <summary>
/// Outputs async a Json Response given a data object.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="data">The data.</param>
/// <returns>A <c>true</c> value of type ref=JsonResponseAsync".</returns>
public static Task <bool> JsonResponseAsync(this HttpListenerContext context, object data)
{
return(context.JsonResponseAsync(Json.Serialize(data)));
}
/// <summary>
/// Outputs a Json Response given a data object.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="data">The data.</param>
/// <returns>A <c>true</c> value of type ref=JsonResponseAsync".</returns>
public static bool JsonResponse(this HttpListenerContext context, object data)
{
return(context.JsonResponseAsync(data).GetAwaiter().GetResult());
}
/// <summary>
/// Returns dictionary from Request POST data
/// Please note the underlying input stream is not rewindable.
/// </summary>
/// <param name="context">The context to request body as string.</param>
/// <returns>A collection that represents KVPs from request data.</returns>
public static Dictionary <string, object> RequestFormDataDictionary(this HttpListenerContext context)
{
return(RequestFormDataDictionary(context.RequestBody()));
}
/// <summary>
/// Deletes the session object associated to the current context.
/// </summary>
/// <param name="server">The server.</param>
/// <param name="context">The context.</param>
public static void DeleteSession(this WebServer server, HttpListenerContext context)
{
server.SessionModule?.DeleteSession(context);
}
/// <summary>
/// Outputs a HTML Response given a HTML content.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="htmlContent">Content of the HTML.</param>
/// <param name="statusCode">The status code.</param>
/// <param name="cancellationToken">The cancellation token.</param>
/// <returns>A task for writing the output stream.</returns>
public static Task <bool> HtmlResponseAsync(this HttpListenerContext context, string htmlContent, HttpStatusCode statusCode = HttpStatusCode.OK, CancellationToken cancellationToken = default)
{
context.Response.StatusCode = (int)statusCode;
return(context.StringResponseAsync(htmlContent, Responses.HtmlContentType, cancellationToken));
}
/// <summary>
/// Determines whether [has request header] [the specified context].
/// </summary>
/// <param name="context">The context.</param>
/// <param name="headerName">Name of the header.</param>
/// <returns>True if request headers is not a null; otherwise, false.</returns>
public static bool HasRequestHeader(this HttpListenerContext context, string headerName)
{
return(context.Request.Headers[headerName] != null);
}
/// <summary>
/// Retrieves the specified request the header.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="headerName">Name of the header.</param>
/// <returns>Specified request the header when is true; otherwise, empty string. </returns>
public static string RequestHeader(this HttpListenerContext context, string headerName)
{
return(context.Request.Headers[headerName] ?? string.Empty);
}
/// <summary>
/// Determines if a key exists within the Request's query string.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="key">The key.</param>
/// <returns>True if a key exists within the Request's query string; otherwise, false.</returns>
public static bool InQueryString(this HttpListenerContext context, string key)
{
return(context.Request.QueryString.AllKeys.Contains(key));
}
/// <summary>
/// Gets the value for the specified query string key.
/// If the value does not exist it returns null.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="key">The key.</param>
/// <returns>A string that represents the value for the specified query string key.</returns>
public static string QueryString(this HttpListenerContext context, string key)
{
return(context.InQueryString(key) ? context.Request.QueryString[key] : null);
}
/// <summary>
/// Retrieves the Request HTTP Verb (also called Method) of this context.
/// </summary>
/// <param name="context">The context.</param>
/// <returns>HTTP verb result of the conversion of this context.</returns>
public static HttpVerbs RequestVerb(this HttpListenerContext context)
{
Enum.TryParse(context.Request.HttpMethod.ToLowerInvariant().Trim(), true, out HttpVerbs verb);
return(verb);
}
/// <summary>
/// Gets the request path for the specified context case sensitive.
/// </summary>
/// <param name="context">The context.</param>
/// <returns>Path for the specified context.</returns>
public static string RequestPathCaseSensitive(this HttpListenerContext context)
{
return(context.Request.Url.LocalPath);
}
/// <summary>
/// Outputs a Json Response given a Json string.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="json">The JSON.</param>
/// <returns> A <c>true</c> value of type ref=JsonResponseAsync".</returns>
public static bool JsonResponse(this HttpListenerContext context, string json)
{
return(context.JsonResponseAsync(json).GetAwaiter().GetResult());
}
/// <summary>
/// Outputs async a JSON Response given a JSON string.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="json">The JSON.</param>
/// <param name="cancellationToken">The cancellation token.</param>
/// <returns>A task for writing the output stream.</returns>
public static Task <bool> JsonResponseAsync(this HttpListenerContext context, string json, CancellationToken cancellationToken = default)
{
return(context.StringResponseAsync(json, cancellationToken: cancellationToken));
}
/// <inheritdoc />
public void DeleteSession(HttpListenerContext context)
{
DeleteSession(GetSession(context));
}
/// <summary>
/// Outputs a JSON Response given an exception.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="ex">The ex.</param>
/// <param name="statusCode">The status code.</param>
/// <returns>A task for writing the output stream.</returns>
public static Task <bool> JsonExceptionResponseAsync(this HttpListenerContext context, Exception ex, HttpStatusCode statusCode = HttpStatusCode.InternalServerError)
{
context.Response.StatusCode = (int)statusCode;
return(context.JsonResponseAsync(ex));
}
/// <summary>
/// Deletes the session object associated to the current context.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="server">The server.</param>
public static void DeleteSession(this HttpListenerContext context, WebServer server)
{
server.DeleteSession(context);
}
/// <summary>
/// Parses the JSON as a given type from the request body.
/// Please note the underlying input stream is not rewindable.
/// </summary>
/// <typeparam name="T">The type of specified object type.</typeparam>
/// <param name="context">The context.</param>
/// <returns>
/// Parses the json as a given type from the request body.
/// </returns>
public static T ParseJson <T>(this HttpListenerContext context) where T : class
{
return(ParseJson <T>(context.RequestBody()));
}
/// <summary>
/// Gets the session object associated to the current context.
/// Returns null if the LocalSessionWebModule has not been loaded.
/// </summary>
/// <param name="server">The server.</param>
/// <param name="context">The context.</param>
/// <returns>A session info for the given server context.</returns>
public static SessionInfo GetSession(this WebServer server, HttpListenerContext context)
{
return(server.SessionModule?.GetSession(context));
}
/// <summary>
/// Requests the wildcard URL parameters.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="basePath">The base path.</param>
/// <returns>The params from the request.</returns>
public static string[] RequestWildcardUrlParams(this HttpListenerContext context, string basePath)
{
return(RequestWildcardUrlParams(context.RequestPath(), basePath));
}
/// <summary>
/// Gets the request path for the specified context.
/// </summary>
/// <param name="context">The context.</param>
/// <returns>Path for the specified context.</returns>
public static string RequestPath(this HttpListenerContext context)
{
return(context.Request.Url.LocalPath.ToLowerInvariant());
}
/// <summary>
/// Requests the regex URL parameters.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="basePath">The base path.</param>
/// <returns>The params from the request.</returns>
public static Dictionary <string, object> RequestRegexUrlParams(this HttpListenerContext context, string basePath)
{
return(RequestRegexUrlParams(context.RequestPath(), basePath));
}
/// <summary>
/// Gets the session object associated to the current context.
/// Returns null if the LocalSessionWebModule has not been loaded.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="server">The server.</param>
/// <returns>A session object for the given server context.</returns>
public static SessionInfo GetSession(this HttpListenerContext context, WebServer server)
{
return(server.GetSession(context));
}
