749 lines
29 KiB
C#
749 lines
29 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.Linq;
|
|
using System.Net;
|
|
using System.Text;
|
|
using System.Threading.Tasks;
|
|
using System.IO;
|
|
using Newtonsoft.Json;
|
|
using System.IO.Compression;
|
|
using System.IO.Pipes;
|
|
|
|
namespace MontoyaTech.Rest.Net
|
|
{
|
|
/// <summary>
|
|
/// A set of extensions to help with HttpListenerResponses.
|
|
/// </summary>
|
|
public static class HttpListenerResponseExtensions
|
|
{
|
|
/// <summary>
|
|
/// Sets the response to have no body.
|
|
/// </summary>
|
|
/// <param name="response"></param>
|
|
/// <returns></returns>
|
|
public static HttpListenerResponse WithNoBody(this HttpListenerResponse response)
|
|
{
|
|
response.ContentLength64 = 0;
|
|
|
|
return response;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Sets the response content type to text and writes the given text to it.
|
|
/// </summary>
|
|
/// <param name="response"></param>
|
|
/// <param name="text"></param>
|
|
/// <returns>This response.</returns>
|
|
public static HttpListenerResponse WithText(this HttpListenerResponse response, string text)
|
|
{
|
|
response.ContentType = "text/plain; charset=utf-8";
|
|
|
|
var bytes = Encoding.UTF8.GetBytes(text);
|
|
|
|
response.ContentLength64 = bytes.Length;
|
|
|
|
response.OutputStream.Write(bytes, 0, bytes.Length);
|
|
|
|
response.OutputStream.Dispose();
|
|
|
|
return response;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Sets the response content type to text and writes the given text compressed to it.
|
|
/// </summary>
|
|
/// <param name="response"></param>
|
|
/// <param name="text"></param>
|
|
/// <returns>This response.</returns>
|
|
public static HttpListenerResponse WithCompressedText(this HttpListenerResponse response, string text)
|
|
{
|
|
response.ContentType = "text/plain; charset=utf-8";
|
|
|
|
response.Headers.Add("Content-Encoding", "gzip");
|
|
|
|
var bytes = Encoding.UTF8.GetBytes(text);
|
|
|
|
using (var memoryStream = new MemoryStream())
|
|
{
|
|
using (var compressedStream = new GZipStream(memoryStream, CompressionMode.Compress, true))
|
|
compressedStream.Write(bytes, 0, bytes.Length);
|
|
|
|
response.ContentLength64 = memoryStream.Length;
|
|
|
|
memoryStream.Seek(0, SeekOrigin.Begin);
|
|
|
|
memoryStream.CopyTo(response.OutputStream);
|
|
|
|
response.OutputStream.Dispose();
|
|
}
|
|
|
|
return response;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Sets the response content type to json and serializes the object as json and writes it.
|
|
/// </summary>
|
|
/// <param name="response"></param>
|
|
/// <param name="obj"></param>
|
|
/// <returns>This response.</returns>
|
|
public static HttpListenerResponse WithJson(this HttpListenerResponse response, object obj)
|
|
{
|
|
response.ContentType = "application/json; charset=utf-8";
|
|
|
|
var bytes = Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(obj));
|
|
|
|
response.ContentLength64 = bytes.Length;
|
|
|
|
response.OutputStream.Write(bytes, 0, bytes.Length);
|
|
|
|
response.OutputStream.Dispose();
|
|
|
|
return response;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Sets the response content type to json and writes the given json compressed to it.
|
|
/// </summary>
|
|
/// <param name="response"></param>
|
|
/// <param name="obj"></param>
|
|
/// <returns>This response.</returns>
|
|
public static HttpListenerResponse WithCompressedJson(this HttpListenerResponse response, object obj)
|
|
{
|
|
response.ContentType = "application/json; charset=utf-8";
|
|
response.Headers.Add("Content-Encoding", "gzip");
|
|
|
|
var bytes = Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(obj));
|
|
|
|
using (var memoryStream = new MemoryStream())
|
|
{
|
|
using (var compressedStream = new GZipStream(memoryStream, CompressionMode.Compress, true))
|
|
compressedStream.Write(bytes, 0, bytes.Length);
|
|
|
|
response.ContentLength64 = memoryStream.Length;
|
|
|
|
memoryStream.Seek(0, SeekOrigin.Begin);
|
|
|
|
memoryStream.CopyTo(response.OutputStream);
|
|
|
|
response.OutputStream.Dispose();
|
|
}
|
|
|
|
return response;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Sets the response content type to a file and writes the given file content to the response.
|
|
/// </summary>
|
|
/// <param name="response"></param>
|
|
/// <param name="filePath">The path of the file to send.</param>
|
|
/// <param name="mimeType">The mime type of the file to send, if null, it will be auto detected if possible.</param>
|
|
/// <returns>This response.</returns>
|
|
public static HttpListenerResponse WithFile(this HttpListenerResponse response, string filePath, string mimeType = null)
|
|
{
|
|
if (string.IsNullOrWhiteSpace(filePath))
|
|
throw new ArgumentException("filePath must not be null or empty");
|
|
|
|
if (string.IsNullOrWhiteSpace(mimeType))
|
|
mimeType = Path.GetExtension(filePath).GetMimeType();
|
|
|
|
response.ContentType = mimeType;
|
|
response.Headers.Add("Content-Deposition", $@"attachment; filename=""{Path.GetFileName(filePath)}""");
|
|
|
|
using (var fileStream = new FileStream(filePath, FileMode.Open, FileAccess.Read))
|
|
{
|
|
response.ContentLength64 = fileStream.Length;
|
|
|
|
fileStream.CopyTo(response.OutputStream);
|
|
|
|
response.OutputStream.Dispose();
|
|
}
|
|
|
|
return response;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Sets the response content type to a file and writes the file content with name to the response.
|
|
/// </summary>
|
|
/// <param name="response"></param>
|
|
/// <param name="filePath"></param>
|
|
/// <param name="content"></param>
|
|
/// <param name="mimeType"></param>
|
|
/// <returns></returns>
|
|
/// <exception cref="ArgumentException"></exception>
|
|
public static HttpListenerResponse WithFile(this HttpListenerResponse response, string filePath, byte[] content, string mimeType = null)
|
|
{
|
|
if (string.IsNullOrWhiteSpace(filePath))
|
|
throw new ArgumentException("filePath must not be null or empty");
|
|
|
|
if (string.IsNullOrWhiteSpace(mimeType))
|
|
mimeType = Path.GetExtension(filePath).GetMimeType();
|
|
|
|
response.ContentType = mimeType;
|
|
response.Headers.Add("Content-Deposition", $@"attachment; filename=""{Path.GetFileName(filePath)}""");
|
|
response.ContentLength64 = content.Length;
|
|
|
|
response.OutputStream.Write(content, 0, content.Length);
|
|
|
|
response.OutputStream.Dispose();
|
|
|
|
return response;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Sets the response content type to a file and compresses the given file content to the response.
|
|
/// </summary>
|
|
/// <param name="response"></param>
|
|
/// <param name="filePath">The path of the file to send.</param>
|
|
/// <param name="mimeType">The mime type of the file to send, if null, it will be auto detected if possible.</param>
|
|
/// <returns>This response.</returns>
|
|
public static HttpListenerResponse WithCompressedFile(this HttpListenerResponse response, string filePath, string mimeType = null)
|
|
{
|
|
if (string.IsNullOrWhiteSpace(filePath))
|
|
throw new ArgumentException("filePath must not be null or empty");
|
|
|
|
if (string.IsNullOrWhiteSpace(mimeType))
|
|
mimeType = Path.GetExtension(filePath).GetMimeType();
|
|
|
|
response.ContentType = mimeType;
|
|
response.Headers.Add("Content-Deposition", $@"attachment; filename=""{Path.GetFileName(filePath)}""");
|
|
response.Headers.Add("Content-Encoding", "gzip");
|
|
|
|
using (var memoryStream = new MemoryStream())
|
|
{
|
|
using (var compressedStream = new GZipStream(memoryStream, CompressionMode.Compress, true))
|
|
using (var fileStream = new FileStream(filePath, FileMode.Open, FileAccess.Read))
|
|
fileStream.CopyTo(compressedStream);
|
|
|
|
response.ContentLength64 = memoryStream.Length;
|
|
|
|
memoryStream.Seek(0, SeekOrigin.Begin);
|
|
|
|
memoryStream.CopyTo(response.OutputStream);
|
|
|
|
response.OutputStream.Dispose();
|
|
}
|
|
|
|
return response;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Sets the response content type to a file and writes the file content with name to the response.
|
|
/// </summary>
|
|
/// <param name="response"></param>
|
|
/// <param name="filePath"></param>
|
|
/// <param name="content"></param>
|
|
/// <param name="mimeType"></param>
|
|
/// <returns></returns>
|
|
/// <exception cref="ArgumentException"></exception>
|
|
public static HttpListenerResponse WithCompressedFile(this HttpListenerResponse response, string filePath, byte[] content, string mimeType = null)
|
|
{
|
|
if (string.IsNullOrWhiteSpace(filePath))
|
|
throw new ArgumentException("filePath must not be null or empty");
|
|
|
|
if (string.IsNullOrWhiteSpace(mimeType))
|
|
mimeType = Path.GetExtension(filePath).GetMimeType();
|
|
|
|
response.ContentType = mimeType;
|
|
response.Headers.Add("Content-Deposition", $@"attachment; filename=""{Path.GetFileName(filePath)}""");
|
|
response.Headers.Add("Content-Encoding", "gzip");
|
|
|
|
using (var memoryStream = new MemoryStream())
|
|
{
|
|
using (var compressedStream = new GZipStream(memoryStream, CompressionMode.Compress, true))
|
|
compressedStream.Write(content, 0, content.Length);
|
|
|
|
response.ContentLength64 = memoryStream.Length;
|
|
|
|
memoryStream.Seek(0, SeekOrigin.Begin);
|
|
|
|
memoryStream.CopyTo(response.OutputStream);
|
|
|
|
response.OutputStream.Dispose();
|
|
}
|
|
|
|
return response;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Sets the response content type to a precompressed file and writes the file contents to the response.
|
|
/// </summary>
|
|
/// <param name="response"></param>
|
|
/// <param name="filePath"></param>
|
|
/// <param name="content"></param>
|
|
/// <param name="mimeType"></param>
|
|
/// <returns></returns>
|
|
/// <exception cref="ArgumentException"></exception>
|
|
public static HttpListenerResponse WithPreCompressedFile(this HttpListenerResponse response, string filePath, byte[] content, string mimeType = null)
|
|
{
|
|
if (string.IsNullOrWhiteSpace(filePath))
|
|
throw new ArgumentException("filePath must not be null or empty");
|
|
|
|
if (string.IsNullOrWhiteSpace(mimeType))
|
|
mimeType = Path.GetExtension(filePath).GetMimeType();
|
|
|
|
response.ContentType = mimeType;
|
|
response.Headers.Add("Content-Deposition", $@"attachment; filename=""{Path.GetFileName(filePath)}""");
|
|
response.Headers.Add("Content-Encoding", "gzip");
|
|
response.ContentLength64 = content.Length;
|
|
|
|
response.OutputStream.Write(content, 0, content.Length);
|
|
|
|
response.OutputStream.Dispose();
|
|
|
|
return response;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Sets the response content type to html and writes the given html to it.
|
|
/// </summary>
|
|
/// <param name="response"></param>
|
|
/// <param name="html"></param>
|
|
/// <returns>This response.</returns>
|
|
public static HttpListenerResponse WithHtml(this HttpListenerResponse response, string html)
|
|
{
|
|
response.ContentType = "text/html; charset=utf-8";
|
|
|
|
var bytes = Encoding.UTF8.GetBytes(html);
|
|
|
|
response.ContentLength64 = bytes.Length;
|
|
|
|
response.OutputStream.Write(bytes, 0, bytes.Length);
|
|
|
|
return response;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Sets the status code for a given response.
|
|
/// </summary>
|
|
/// <param name="response"></param>
|
|
/// <param name="status"></param>
|
|
/// <returns>This response.</returns>
|
|
public static HttpListenerResponse WithStatus(this HttpListenerResponse response, HttpStatusCode status)
|
|
{
|
|
try
|
|
{
|
|
response.StatusCode = (int)status;
|
|
return response;
|
|
}
|
|
catch
|
|
{
|
|
return response;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Sets a cookie for a given response.
|
|
/// </summary>
|
|
/// <param name="response"></param>
|
|
/// <param name="name">The name of the cookie</param>
|
|
/// <param name="value">The value of the cookie</param>
|
|
/// <returns>This response.</returns>
|
|
public static HttpListenerResponse WithCookie(this HttpListenerResponse response, string name, string value)
|
|
{
|
|
response.SetCookie(new Cookie(name, value));
|
|
|
|
return response;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Sets a cookie for a given response.
|
|
/// </summary>
|
|
/// <param name="response"></param>
|
|
/// <param name="name"></param>
|
|
/// <param name="value"></param>
|
|
/// <param name="expires"></param>
|
|
/// <returns>This response.</returns>
|
|
public static HttpListenerResponse WithCookie(this HttpListenerResponse response, string name, string value, DateTime expires)
|
|
{
|
|
response.SetCookie(new Cookie(name, value) { Expires = expires });
|
|
|
|
return response;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Sets a cookie for a given response.
|
|
/// </summary>
|
|
/// <param name="response"></param>
|
|
/// <param name="name"></param>
|
|
/// <param name="value"></param>
|
|
/// <param name="httpOnly"></param>
|
|
/// <returns>This response.</returns>
|
|
public static HttpListenerResponse WithCookie(this HttpListenerResponse response, string name, string value, bool httpOnly)
|
|
{
|
|
response.SetCookie(new Cookie(name, value) { HttpOnly = httpOnly });
|
|
|
|
return response;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Sets a cookie for a given response.
|
|
/// </summary>
|
|
/// <param name="response"></param>
|
|
/// <param name="name"></param>
|
|
/// <param name="value"></param>
|
|
/// <param name="httpOnly"></param>
|
|
/// <param name="secure"></param>
|
|
/// <returns>This response.</returns>
|
|
public static HttpListenerResponse WithCookie(this HttpListenerResponse response, string name, string value, bool httpOnly, bool secure)
|
|
{
|
|
response.SetCookie(new Cookie(name, value) { HttpOnly = httpOnly, Secure = secure });
|
|
|
|
return response;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Sets a cookie for a given response.
|
|
/// </summary>
|
|
/// <param name="response"></param>
|
|
/// <param name="name"></param>
|
|
/// <param name="value"></param>
|
|
/// <param name="httpOnly"></param>
|
|
/// <param name="secure"></param>
|
|
/// <param name="expires"></param>
|
|
/// <returns>This response.</returns>
|
|
public static HttpListenerResponse WithCookie(this HttpListenerResponse response, string name, string value, bool httpOnly, bool secure, DateTime expires)
|
|
{
|
|
response.SetCookie(new Cookie(name, value) { HttpOnly = httpOnly, Secure = secure, Expires = expires });
|
|
|
|
return response;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Sets a cookie for a given response.
|
|
/// </summary>
|
|
/// <param name="response"></param>
|
|
/// <param name="cookie"></param>
|
|
/// <returns>This response.</returns>
|
|
public static HttpListenerResponse WithCookie(this HttpListenerResponse response, Cookie cookie)
|
|
{
|
|
response.SetCookie(cookie);
|
|
|
|
return response;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Sets a header for a given response.
|
|
/// </summary>
|
|
/// <param name="response"></param>
|
|
/// <param name="name"></param>
|
|
/// <param name="value"></param>
|
|
/// <returns>This response.</returns>
|
|
public static HttpListenerResponse WithHeader(this HttpListenerResponse response, string name, string value)
|
|
{
|
|
response.AddHeader(name, value);
|
|
|
|
return response;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Sets the status code for a given response to redirect with the url to redirect to.
|
|
/// </summary>
|
|
/// <param name="response"></param>
|
|
/// <param name="url"></param>
|
|
/// <returns>This response.</returns>
|
|
public static HttpListenerResponse WithRedirect(this HttpListenerResponse response, string url)
|
|
{
|
|
try
|
|
{
|
|
response.StatusCode = (int)HttpStatusCode.Redirect;
|
|
|
|
response.AddHeader("Location", url);
|
|
|
|
return response;
|
|
}
|
|
catch
|
|
{
|
|
return response;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Sets the response to bad request with a text message saying the request was null or empty.
|
|
/// </summary>
|
|
/// <param name="response"></param>
|
|
/// <returns></returns>
|
|
public static HttpListenerResponse BadRequestNull(this HttpListenerResponse response)
|
|
{
|
|
return response.WithStatus(HttpStatusCode.BadRequest).WithText("Request was null or empty.");
|
|
}
|
|
|
|
/// <summary>
|
|
/// Sets the response to a bad request with a text message saying the request was invalid.
|
|
/// </summary>
|
|
/// <param name="response"></param>
|
|
/// <returns></returns>
|
|
public static HttpListenerResponse BadRequestInvalid(this HttpListenerResponse response)
|
|
{
|
|
return response.WithStatus(HttpStatusCode.BadRequest).WithText("Request data was invalid.");
|
|
}
|
|
|
|
/// <summary>
|
|
/// Sets the response to a bad request with a text message saying the request was out of range.
|
|
/// </summary>
|
|
/// <param name="response"></param>
|
|
/// <returns></returns>
|
|
public static HttpListenerResponse BadRequestOutOfRange(this HttpListenerResponse response)
|
|
{
|
|
return response.WithStatus(HttpStatusCode.BadRequest).WithText("Request data was out of range");
|
|
}
|
|
|
|
/// <summary>
|
|
/// Sets the response to a bad request with a text message saying a field in the request was out of range.
|
|
/// </summary>
|
|
/// <param name="response"></param>
|
|
/// <param name="fieldName"></param>
|
|
/// <returns></returns>
|
|
public static HttpListenerResponse BadRequestOutOfRange(this HttpListenerResponse response, string fieldName)
|
|
{
|
|
return response.WithStatus(HttpStatusCode.BadRequest).WithText($"{fieldName} in request is out of range.");
|
|
}
|
|
|
|
/// <summary>
|
|
/// Sets the response to serve a file in the context of a multi page application.
|
|
/// </summary>
|
|
/// <param name="response">The response to modify</param>
|
|
/// <param name="basePath">The base path where to serve files from</param>
|
|
/// <param name="request">The request to serve</param>
|
|
/// <param name="indexFile">The name of the index file, default is index.html</param>
|
|
/// <param name="compress">Whether or not to compress files served. Default is false.</param>
|
|
/// <param name="compressExtensions">A collection of file extensions that should be compressed, example: .jpg, default is null. If and compress is true, all files will be compressed.</param>
|
|
/// <returns>The modified response</returns>
|
|
public static HttpListenerResponse ServeMultiPage(this HttpListenerResponse response, string basePath, HttpListenerRequest request, string indexFile = "index.html", bool compress = false, HashSet<string> compressExtensions = null)
|
|
{
|
|
if (ResolveMultiPagePath(basePath, request.Url.LocalPath, indexFile, out string resolvedPath, out bool isDirectory))
|
|
{
|
|
if (isDirectory)
|
|
{
|
|
return response.WithNoBody().WithStatus(HttpStatusCode.NoContent);
|
|
}
|
|
else
|
|
{
|
|
if (request.HttpMethod.Equals("head", StringComparison.CurrentCultureIgnoreCase))
|
|
{
|
|
return response.WithNoBody().WithStatus(HttpStatusCode.NoContent);
|
|
}
|
|
else
|
|
{
|
|
if (compress && (compressExtensions == null || compressExtensions.Contains(Path.GetExtension(resolvedPath))))
|
|
return response.WithStatus(HttpStatusCode.OK).WithCompressedFile(resolvedPath);
|
|
else
|
|
return response.WithStatus(HttpStatusCode.OK).WithFile(resolvedPath);
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
return response.WithStatus(HttpStatusCode.NotFound);
|
|
}
|
|
}
|
|
|
|
internal static bool ResolveMultiPagePath(string basePath, string requestPath, string indexFile, out string resolvedPath, out bool isDirectory)
|
|
{
|
|
resolvedPath = null;
|
|
|
|
isDirectory = false;
|
|
|
|
//If the requestPath is pointing to nothing change that to the index file.
|
|
if (string.IsNullOrWhiteSpace(requestPath) || requestPath == "/" || requestPath == ".")
|
|
requestPath = indexFile;
|
|
|
|
//Break th erequest path into it's components so we can enfore staying in the base path.
|
|
var components = requestPath.Split(new char[] { '/', '\\' }, StringSplitOptions.RemoveEmptyEntries).ToList();
|
|
|
|
for (int i = 0; i < components.Count; i++)
|
|
{
|
|
if (components[i].Trim() == "..")
|
|
{
|
|
components.RemoveAt(i--);
|
|
|
|
if (i >= 0)
|
|
components.RemoveAt(i--);
|
|
else
|
|
return false; //Trying to jump outside of basePath
|
|
}
|
|
else if (components[i].Trim() == "...")
|
|
{
|
|
components.RemoveAt(i--);
|
|
|
|
if (i >= 0)
|
|
components.RemoveAt(i--);
|
|
else
|
|
return false; //Trying to jump outside of basePath
|
|
|
|
if (i >= 0)
|
|
components.RemoveAt(i--);
|
|
else
|
|
return false; //Trying to jump outside of basePath
|
|
}
|
|
else if (components[i].Trim() == ".")
|
|
{
|
|
components.RemoveAt(i--);
|
|
}
|
|
}
|
|
|
|
if (components.Count == 0)
|
|
return false;
|
|
|
|
var absolutePath = Path.Combine(basePath, components.Separate(Path.DirectorySeparatorChar));
|
|
|
|
if (File.Exists(absolutePath))
|
|
{
|
|
resolvedPath = absolutePath;
|
|
|
|
return true;
|
|
}
|
|
else if (Directory.Exists(absolutePath))
|
|
{
|
|
resolvedPath = absolutePath;
|
|
|
|
isDirectory = true;
|
|
|
|
return true;
|
|
}
|
|
else
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Sets the response to serve a file in the context of a single page application.
|
|
/// </summary>
|
|
/// <param name="response">The response to modify</param>
|
|
/// <param name="basePath">The base path where to serve files from</param>
|
|
/// <param name="request">The request to serve</param>
|
|
/// <param name="indexFile">The name of the index file, default is index.html</param>
|
|
/// <param name="compress">Whether or not to compress files served. Default is false.</param>
|
|
/// <param name="compressExtensions">A collection of file extensions that should be compressed, example: .jpg, default is null. If and compress is true, all files will be compressed.</param>
|
|
/// <returns>The modified response</returns>
|
|
public static HttpListenerResponse ServeSinglePage(this HttpListenerResponse response, string basePath, HttpListenerRequest request, string indexFile = "index.html", bool compress = false, HashSet<string> compressExtensions = null)
|
|
{
|
|
if (ResolveSinglePagePath(basePath, request.Url.LocalPath, indexFile, out string resolvedPath, out bool isDirectory))
|
|
{
|
|
if (isDirectory)
|
|
{
|
|
return response.WithNoBody().WithStatus(HttpStatusCode.NoContent);
|
|
}
|
|
else
|
|
{
|
|
if (request.HttpMethod.Equals("head", StringComparison.CurrentCultureIgnoreCase))
|
|
{
|
|
return response.WithNoBody().WithStatus(HttpStatusCode.NoContent);
|
|
}
|
|
else
|
|
{
|
|
if (compress && (compressExtensions == null || compressExtensions.Contains(Path.GetExtension(resolvedPath))))
|
|
return response.WithStatus(HttpStatusCode.OK).WithCompressedFile(resolvedPath);
|
|
else
|
|
return response.WithStatus(HttpStatusCode.OK).WithFile(resolvedPath);
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
return response.WithStatus(HttpStatusCode.NotFound);
|
|
}
|
|
}
|
|
|
|
internal static bool ResolveSinglePagePath(string basePath, string requestPath, string indexFile, out string resolvedPath, out bool isDirectory)
|
|
{
|
|
resolvedPath = null;
|
|
|
|
isDirectory = false;
|
|
|
|
//If the requestPath is pointing to nothing change that to the index file.
|
|
if (string.IsNullOrWhiteSpace(requestPath) || requestPath == "/" || requestPath == ".")
|
|
requestPath = indexFile;
|
|
|
|
//Break th erequest path into it's components so we can enfore staying in the base path.
|
|
var components = requestPath.Split(new char[] { '/', '\\' }, StringSplitOptions.RemoveEmptyEntries).ToList();
|
|
|
|
for (int i = 0; i < components.Count; i++)
|
|
{
|
|
if (components[i].Trim() == "..")
|
|
{
|
|
components.RemoveAt(i--);
|
|
|
|
if (i >= 0)
|
|
components.RemoveAt(i--);
|
|
else
|
|
return false; //Trying to jump outside of basePath
|
|
}
|
|
else if (components[i].Trim() == "...")
|
|
{
|
|
components.RemoveAt(i--);
|
|
|
|
if (i >= 0)
|
|
components.RemoveAt(i--);
|
|
else
|
|
return false; //Trying to jump outside of basePath
|
|
|
|
if (i >= 0)
|
|
components.RemoveAt(i--);
|
|
else
|
|
return false; //Trying to jump outside of basePath
|
|
}
|
|
else if (components[i].Trim() == ".")
|
|
{
|
|
components.RemoveAt(i--);
|
|
}
|
|
}
|
|
|
|
if (components.Count == 0)
|
|
return false;
|
|
|
|
var absolutePath = Path.Combine(basePath, components.Separate(Path.DirectorySeparatorChar));
|
|
|
|
if (File.Exists(absolutePath))
|
|
{
|
|
resolvedPath = absolutePath;
|
|
|
|
return true;
|
|
}
|
|
else if (Directory.Exists(absolutePath))
|
|
{
|
|
resolvedPath = absolutePath;
|
|
|
|
isDirectory = true;
|
|
|
|
return true;
|
|
}
|
|
else
|
|
{
|
|
//Try to components that don't exist and try again
|
|
while (components.Count > 0)
|
|
{
|
|
string path = Path.Combine(basePath, components[0]);
|
|
|
|
if (File.Exists(path) || Directory.Exists(path))
|
|
break;
|
|
else
|
|
components.RemoveAt(0);
|
|
}
|
|
|
|
if (components.Count == 0)
|
|
return false;
|
|
|
|
absolutePath = Path.Combine(basePath, components.Separate(Path.PathSeparator));
|
|
|
|
if (File.Exists(absolutePath))
|
|
{
|
|
resolvedPath = absolutePath;
|
|
|
|
return true;
|
|
}
|
|
else if (Directory.Exists(absolutePath))
|
|
{
|
|
resolvedPath = absolutePath;
|
|
|
|
isDirectory = true;
|
|
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
}
|