tesses.webserver/Tesses.WebServer.NetStandard/TessesServer.cs

1942 lines
72 KiB
C#
Raw Normal View History

2022-04-02 18:59:12 +00:00
using System;
using System.Net;
using System.Net.Sockets;
using System.Threading.Tasks;
using System.IO;
using System.Threading;
using System.Text;
using System.Collections.Generic;
using System.Linq;
using HeyRed.Mime;
using Newtonsoft.Json;
using System.Security.Cryptography.X509Certificates;
using System.Net.Security;
2022-04-03 15:36:38 +00:00
using System.Security.Authentication;
using System.Web;
using Tesses.VirtualFilesystem;
2022-04-02 18:59:12 +00:00
namespace Tesses.WebServer
{
internal class SendEventArgs : EventArgs
2022-09-01 05:26:26 +00:00
{
public string Data {get;set;}
}
public class SendEvents
{
internal event EventHandler<SendEventArgs> EventReceived;
public void SendEvent(object data)
{
SendEvent(JsonConvert.SerializeObject(data));
}
public void SendEvent(string e)
{
try{
EventReceived?.Invoke(this,new SendEventArgs(){Data=e});
}catch(Exception ex)
{
_=ex;
}
}
}
2022-04-02 21:15:20 +00:00
public static class Extensions
2022-09-01 05:26:26 +00:00
{
public static async Task WriteAsync(this Stream strm,string text)
{
var data=Encoding.UTF8.GetBytes(text);
await strm.WriteAsync(data,0,data.Length);
await strm.FlushAsync();
}
public static void Write(this Stream strm,string text)
{
var data=Encoding.UTF8.GetBytes(text);
strm.Write(data,0,data.Length);
strm.Flush();
}
public static void ServerSentEvents(this ServerContext ctx,SendEvents evt)
{
bool __connected=true;
ctx.ResponseHeaders.Add("Content-Type","text/event-stream");
ctx.ResponseHeaders.Add("Cache-Control","no-cache");
ctx.WriteHeaders();
try{
EventHandler<SendEventArgs> cb= (sender,e0)=>{
if(__connected)
ctx.NetworkStream.Write($"data: {e0.Data}\n\n");
};
evt.EventReceived += cb;
while(ctx.Connected);
evt.EventReceived -= cb;
__connected=false;
}catch(Exception ex)
{
_=ex;
}
}
2022-04-24 18:56:06 +00:00
/// <summary>
/// Read string from request body
/// </summary>
/// <param name="ctx">ServerContext</param>
/// <returns>the contents of request</returns>
public static async Task<string> ReadStringAsync(this ServerContext ctx)
{
string str = null;
2022-09-01 05:26:26 +00:00
using (var reader = new StreamReader(ctx.GetRequestStream()))
2022-04-24 18:56:06 +00:00
{
str = await reader.ReadToEndAsync();
}
return str;
}
/// <summary>
2022-09-01 05:26:26 +00:00
/// Read string from request body
/// </summary>
/// <param name="ctx">ServerContext</param>
/// <returns>the contents of request</returns>
public static string ReadString(this ServerContext ctx)
{
string str = null;
using (var reader = new StreamReader(ctx.GetRequestStream()))
{
str = reader.ReadToEnd();
}
return str;
}
/// <summary>
2022-04-24 18:56:06 +00:00
/// Read json from request body
/// </summary>
/// <param name="ctx">ServerContext</param>
/// <typeparam name="T">type of object (for scema)</typeparam>
/// <returns>object of type T with deserialized json data</returns>
public static async Task<T> ReadJsonAsync<T>(this ServerContext ctx)
{
var json=await ctx.ReadStringAsync();
return JsonConvert.DeserializeObject<T>(json);
}
/// <summary>
2022-09-01 05:26:26 +00:00
/// Read json from request body
/// </summary>
/// <param name="ctx">ServerContext</param>
/// <typeparam name="T">type of object (for scema)</typeparam>
/// <returns>object of type T with deserialized json data</returns>
public static T ReadJson<T>(this ServerContext ctx)
{
var json= ctx.ReadString();
return JsonConvert.DeserializeObject<T>(json);
}
/// <summary>
2022-04-24 18:56:06 +00:00
/// Read request body to array
/// </summary>
/// <param name="ctx">ServerContext</param>
/// <returns>Request body data</returns>
public static async Task<byte[]> ReadBytesAsync(this ServerContext ctx)
{
MemoryStream strm = new MemoryStream();
await ctx.ReadToStreamAsync(strm);
return strm.ToArray();
2022-09-01 05:26:26 +00:00
}
/// <summary>
/// Read request body to array
/// </summary>
/// <param name="ctx">ServerContext</param>
/// <returns>Request body data</returns>
public static byte[] ReadBytes(this ServerContext ctx)
{
MemoryStream strm = new MemoryStream();
ctx.ReadToStream(strm);
return strm.ToArray();
2022-04-24 18:56:06 +00:00
}
/// <summary>
/// Read request body to stream
/// </summary>
/// <param name="ctx">ServerContext</param>
/// <param name="strm">Stream to write to</param>
public static async Task ReadToStreamAsync(this ServerContext ctx,Stream strm)
{
2022-09-01 05:26:26 +00:00
await ctx.GetRequestStream().CopyToAsync(strm);
}
/// <summary>
/// Read request body to stream
/// </summary>
/// <param name="ctx">ServerContext</param>
/// <param name="strm">Stream to write to</param>
public static void ReadToStream(this ServerContext ctx,Stream strm)
{
ctx.GetRequestStream().CopyTo(strm);
2022-04-24 18:56:06 +00:00
}
/// <summary>
/// Read request body to file
/// </summary>
/// <param name="ctx">ServerContext</param>
/// <param name="filename">name of file to write too, can be without extension</param>
/// <returns>file path with extension unless mimetype header is missing</returns>
public static async Task<string> ReadToFileAsync(this ServerContext ctx,string filename)
{
if(string.IsNullOrWhiteSpace(Path.GetExtension(filename)))
{
string val;
if(ctx.RequestHeaders.TryGetFirst("Content-Type",out val))
{
filename += $".{MimeTypesMap.GetExtension(val)}";
}
}
using(var f = File.Create(filename))
{
2022-09-01 05:26:26 +00:00
await ctx.ReadToStreamAsync(f);
2022-04-24 18:56:06 +00:00
}
return filename;
}
2022-09-01 05:26:26 +00:00
/// <summary>
/// Read request body to file
/// </summary>
/// <param name="ctx">ServerContext</param>
/// <param name="filename">name of file to write too, can be without extension</param>
/// <returns>file path with extension unless mimetype header is missing</returns>
public static string ReadToFile(this ServerContext ctx,string filename)
{
if(string.IsNullOrWhiteSpace(Path.GetExtension(filename)))
{
string val;
if(ctx.RequestHeaders.TryGetFirst("Content-Type",out val))
{
filename += $".{MimeTypesMap.GetExtension(val)}";
}
}
using(var f = File.Create(filename))
{
ctx.ReadToStream(f);
}
return filename;
}
2022-04-24 18:56:06 +00:00
2022-04-23 18:25:45 +00:00
/// <summary>
/// Write headers to stream
/// </summary>
/// <param name="ctx">ServerContext</param>
2022-04-02 21:15:20 +00:00
public static async Task WriteHeadersAsync(this ServerContext ctx)
2022-04-02 18:59:12 +00:00
{
string status_line = $"HTTP/1.1 {ctx.StatusCode} {StatusCodeMap.GetStatusString(ctx.StatusCode)}\r\n";
StringBuilder b = new StringBuilder(status_line);
foreach (var hdr in ctx.ResponseHeaders)
{
foreach (var v in hdr.Value)
{
b.Append($"{hdr.Key}: {v}\r\n");
}
}
b.Append("\r\n");
var data = Encoding.UTF8.GetBytes(b.ToString());
await ctx.NetworkStream.WriteAsync(data, 0, data.Length);
}
2022-04-23 18:25:45 +00:00
/// <summary>
2022-09-01 05:26:26 +00:00
/// Write headers to stream
/// </summary>
/// <param name="ctx">ServerContext</param>
public static void WriteHeaders(this ServerContext ctx)
{
string status_line = $"HTTP/1.1 {ctx.StatusCode} {StatusCodeMap.GetStatusString(ctx.StatusCode)}\r\n";
StringBuilder b = new StringBuilder(status_line);
foreach (var hdr in ctx.ResponseHeaders)
{
foreach (var v in hdr.Value)
{
b.Append($"{hdr.Key}: {v}\r\n");
}
}
b.Append("\r\n");
var data = Encoding.UTF8.GetBytes(b.ToString());
ctx.NetworkStream.Write(data, 0, data.Length);
}
/// <summary>
2022-04-23 18:25:45 +00:00
/// Send file to client (supports range partial content)
/// </summary>
/// <param name="ctx">ServerContext</param>
/// <param name="file">the file to serve</param>
2022-04-02 18:59:12 +00:00
public static async Task SendFileAsync(this ServerContext ctx, string file)
{
using (var strm = File.OpenRead(file))
{
await ctx.SendStreamAsync( strm, MimeTypesMap.GetMimeType(file));
}
2022-09-01 05:26:26 +00:00
}
/// <summary>
/// Send file to client (supports range partial content)
/// </summary>
/// <param name="ctx">ServerContext</param>
/// <param name="file">the file to serve</param>
public static void SendFile(this ServerContext ctx, string file)
{
using (var strm = File.OpenRead(file))
{
ctx.SendStream( strm, MimeTypesMap.GetMimeType(file));
}
2022-04-02 18:59:12 +00:00
}
2022-04-23 18:25:45 +00:00
/// <summary>
/// Send exception to client
/// </summary>
/// <param name="ctx">ServerContext</param>
/// <param name="ex">the Exception</param>
2022-04-02 18:59:12 +00:00
public static async Task SendExceptionAsync(this ServerContext ctx, Exception ex)
{
string name = ex.GetType().FullName;
string j = $"<html><head><title>{WebUtility.HtmlEncode(name)} thrown</title></head><body><h1>{WebUtility.HtmlEncode(name)} thrown</h1><h3>Description: {WebUtility.HtmlEncode(ex.Message)}</h3></body></html>";
ctx.StatusCode = 500;
await ctx.SendTextAsync(j);
}
2022-04-23 18:25:45 +00:00
/// <summary>
2022-09-01 05:26:26 +00:00
/// Send exception to client
/// </summary>
/// <param name="ctx">ServerContext</param>
/// <param name="ex">the Exception</param>
public static void SendException(this ServerContext ctx, Exception ex)
{
string name = ex.GetType().FullName;
string j = $"<html><head><title>{WebUtility.HtmlEncode(name)} thrown</title></head><body><h1>{WebUtility.HtmlEncode(name)} thrown</h1><h3>Description: {WebUtility.HtmlEncode(ex.Message)}</h3></body></html>";
ctx.StatusCode = 500;
ctx.SendText(j);
}
/// <summary>
2022-04-23 18:25:45 +00:00
/// Send object as json to client
/// </summary>
/// <param name="ctx">ServerContext</param>
/// <param name="value">an object to serialize with newtonsoft.json</param>
2022-04-02 18:59:12 +00:00
public static async Task SendJsonAsync(this ServerContext ctx,object value)
{
await ctx.SendTextAsync(JsonConvert.SerializeObject(value), "application/json");
}
2022-04-23 18:25:45 +00:00
/// <summary>
2022-09-01 05:26:26 +00:00
/// Send object as json to client
/// </summary>
/// <param name="ctx">ServerContext</param>
/// <param name="value">an object to serialize with newtonsoft.json</param>
public static void SendJson(this ServerContext ctx,object value)
{
ctx.SendText(JsonConvert.SerializeObject(value), "application/json");
}
/// <summary>
2022-04-23 18:25:45 +00:00
/// Send text to client
/// </summary>
/// <param name="ctx">ServerContext</param>
/// <param name="data">some text</param>
/// <param name="contentType">mime type</param>
2022-04-02 21:15:20 +00:00
public static async Task SendTextAsync(this ServerContext ctx, string data, string contentType = "text/html")
2022-04-02 18:59:12 +00:00
{
2022-04-02 21:15:20 +00:00
await ctx.SendBytesAsync(Encoding.UTF8.GetBytes(data), contentType);
2022-04-02 18:59:12 +00:00
}
2022-04-23 18:25:45 +00:00
/// <summary>
2022-09-01 05:26:26 +00:00
/// Send text to client
/// </summary>
/// <param name="ctx">ServerContext</param>
/// <param name="data">some text</param>
/// <param name="contentType">mime type</param>
public static void SendText(this ServerContext ctx, string data, string contentType = "text/html")
{
ctx.SendBytes(Encoding.UTF8.GetBytes(data), contentType);
}
/// <summary>
2022-04-23 18:25:45 +00:00
/// Send redirect
/// </summary>
/// <param name="ctx">ServerContext</param>
/// <param name="url">Url to redirect to</param>
public static async Task SendRedirectAsync(this ServerContext ctx,string url)
{
ctx.StatusCode = 301;
ctx.ResponseHeaders.Add("Cache-Control","no-cache");
ctx.ResponseHeaders.Add("Location",url);
await ctx.WriteHeadersAsync();
}
/// <summary>
2022-09-01 05:26:26 +00:00
/// Send redirect
/// </summary>
/// <param name="ctx">ServerContext</param>
/// <param name="url">Url to redirect to</param>
public static void SendRedirect(this ServerContext ctx,string url)
{
ctx.StatusCode = 301;
ctx.ResponseHeaders.Add("Cache-Control","no-cache");
ctx.ResponseHeaders.Add("Location",url);
ctx.WriteHeaders();
}
/// <summary>
2022-04-23 18:25:45 +00:00
/// Send byte[] to client
/// </summary>
/// <param name="ctx">ServerContext</param>
/// <param name="array">a byte[] array</param>
/// <param name="contentType">mime type</param>
2022-04-02 21:15:20 +00:00
public static async Task SendBytesAsync(this ServerContext ctx, byte[] array, string contentType = "application/octet-stream")
2022-04-02 18:59:12 +00:00
{
using (var ms = new MemoryStream(array))
{
2022-04-02 21:15:20 +00:00
await ctx.SendStreamAsync( ms, contentType);
2022-04-02 18:59:12 +00:00
}
}
2022-04-23 18:25:45 +00:00
/// <summary>
2022-09-01 05:26:26 +00:00
/// Send byte[] to client
/// </summary>
/// <param name="ctx">ServerContext</param>
/// <param name="array">a byte[] array</param>
/// <param name="contentType">mime type</param>
public static void SendBytes(this ServerContext ctx, byte[] array, string contentType = "application/octet-stream")
{
using (var ms = new MemoryStream(array))
{
ctx.SendStream( ms, contentType);
}
}
/// <summary>
2022-04-23 18:25:45 +00:00
/// Get first item in Dictionary<T1,List<T2>> based on key
/// </summary>
/// <param name="args">the dictionary with list<T2> value</param>
/// <param name="key">some key</param>
/// <typeparam name="T1">key type</typeparam>
/// <typeparam name="T2">value type</typeparam>
/// <returns></returns>
2022-04-02 18:59:12 +00:00
public static T2 GetFirst<T1,T2>(this Dictionary<T1,List<T2>> args,T1 key)
{
return args[key][0];
}
2022-04-23 18:25:45 +00:00
/// <summary>
/// Try to get first item in Dictionary<T1,List<T2>> based on key
/// </summary>
/// <param name="args">the dictionary with list<T2> value</param>
/// <param name="key">the key to check</param>
/// <param name="value">the value returned</param>
/// <typeparam name="T1">key type</typeparam>
/// <typeparam name="T2">value type</typeparam>
/// <returns>true if found else false if not found</returns>
public static bool TryGetFirst<T1,T2>(this Dictionary<T1,List<T2>> args,T1 key,out T2 value)
{
List<T2> ls;
if (args.TryGetValue(key,out ls))
{
if(ls.Count > 0)
{
value = ls[0];
return true;
}
}
value = default(T2);
return false;
}
2022-04-23 18:25:45 +00:00
/// <summary>
/// Add item to the Dictionary<T1,List<T2>> with specified key (will create key in dictionary if not exist)
/// </summary>
/// <param name="list">the dictionary with list<T2> value</param>
/// <param name="key">the key to add or to add to</param>
/// <param name="item">a item</param>
/// <typeparam name="T1">key type</typeparam>
/// <typeparam name="T2">value type</typeparam>
2022-04-02 18:59:12 +00:00
public static void Add<T1,T2>(this Dictionary<T1,List<T2>> list,T1 key,T2 item)
{
if (list.ContainsKey(key))
{
list[key].Add(item);
}
else
{
List<T2> items = new List<T2>();
items.Add(item);
list.Add(key, items);
}
}
2022-04-23 18:25:45 +00:00
/// <summary>
/// Add multiple items to the Dictionary<T1,List<T2>> with specified key (will create key in dictionary if not exist)
/// </summary>
/// <param name="list">the dictionary with list<T2> value</param>
/// <param name="key">the key to add or to add to</param>
/// <param name="items">IEnumerable<T2></param>
/// <typeparam name="T1">key type</typeparam>
/// <typeparam name="T2">value type</typeparam>
2022-04-02 18:59:12 +00:00
public static void AddRange<T1,T2>(this Dictionary<T1,List<T2>> list,T1 key,IEnumerable<T2> items)
{
if (list.ContainsKey(key))
{
list[key].AddRange(items);
}
else
{
List<T2> items2 = new List<T2>();
items2.AddRange(items);
list.Add(key, items2);
}
}
2022-04-23 18:25:45 +00:00
/// <summary>
/// StringBuilder ends with
/// </summary>
/// <param name="sb">string builder</param>
/// <param name="test">text to check</param>
/// <param name="comparison">comparison type</param>
/// <returns>true if sb ends with test, false if it does not</returns>
2022-04-02 18:59:12 +00:00
public static bool EndsWith(this StringBuilder sb, string test,
StringComparison comparison)
{
if (sb.Length < test.Length)
return false;
string end = sb.ToString(sb.Length - test.Length, test.Length);
return end.Equals(test, comparison);
}
}
2022-04-23 18:25:45 +00:00
/// <summary>
/// returns 404 not found page
/// </summary>
public class NotFoundServer : SameServer
2022-04-02 18:59:12 +00:00
{
2022-04-23 18:25:45 +00:00
/// <summary>
/// 404 not found custom html use "{url}" in your html as url
/// </summary>
/// <param name="html">the custom html</param>
public NotFoundServer(string html) : base(html)
2022-04-02 18:59:12 +00:00
{
2022-04-02 18:59:12 +00:00
}
2022-04-23 18:25:45 +00:00
/// <summary>
///404 not found default html
/// </summary>
public NotFoundServer() : base("<html><head><title>File {url} not found</title></head><body><h1>404 Not Found</h1><h4>{url}</h4></body></html>")
2022-04-02 18:59:12 +00:00
{
2022-04-02 18:59:12 +00:00
}
}
public class SameServer : Server
{
/// <summary>
/// html use "{url}" in your html as url
/// </summary>
/// <param name="html">the custom html</param>
/// <param name="statusCode">the status code</param>
public SameServer(string html,int statusCode=404)
{
_html=html;
_statusCode = statusCode;
}
int _statusCode;
2022-04-02 18:59:12 +00:00
string _html;
public override async Task GetAsync(ServerContext ctx)
{
ctx.StatusCode = _statusCode;
2022-04-23 18:25:45 +00:00
await ctx.SendTextAsync( _html.Replace("{url}", WebUtility.HtmlEncode(ctx.OriginalUrlPath)));
2022-04-02 18:59:12 +00:00
}
}
public enum WebServerPathType
2022-04-02 18:59:12 +00:00
{
NotFound=-1,
File=0,
Directory=1
}
public sealed class WebServerPathEntry
{
public WebServerPathEntry(string fname,WebServerPathType type,string url)
{
FileName = fname;
Type =type;
Url = url;
}
public string FileName {get;set;}
public string Url {get;set;}
public WebServerPathType Type {get;set;}
}
public interface IFileHandler
{
IEnumerable<string> ListDirectory(string path);
bool DefaultFileExists(string path,out string name);
WebServerPathEntry GetPath(string path);
Stream CreateFile(string path);
Stream Open(WebServerPathEntry entry);
void CreateDirectory(string dir);
}
public sealed class WebServerStyleFilesystemHandler : IFileHandler
{
string[] _defaultFileNames;
IVirtualFilesystem _fs;
2022-04-23 18:25:45 +00:00
/// <summary>
/// construct with filesystem
2022-04-23 18:25:45 +00:00
/// </summary>
/// <param name="fs">filesystem for root</param>
public WebServerStyleFilesystemHandler(IVirtualFilesystem fs)
2022-04-02 18:59:12 +00:00
{
_defaultFileNames = new string[] {"index.html","index.htm","default.html","default.htm" };
_fs=fs;
}
/// <summary>
/// construct with filesystem, custom filenames
/// </summary>
/// <param name="path">filesystem for root</param>
/// <param name="defaultFileNames">like index.html, index.htm, default.html, default.htm</param>
public WebServerStyleFilesystemHandler(IVirtualFilesystem fs,string[] defaultFileNames)
{
_fs = fs;
_defaultFileNames = defaultFileNames;
2022-04-02 18:59:12 +00:00
}
public void CreateDirectory(string dir)
{
_fs.CreateDirectory(Special.Root / dir);
}
public Stream CreateFile(string name)
{
return _fs.Open(Special.Root / name,FileMode.Create,FileAccess.ReadWrite,FileShare.None);
}
public bool DefaultFileExists(string path, out string name)
{
foreach(var def in _defaultFileNames)
{
var _name = Special.Root / path;
name=_name.Path;
if(_fs.FileExists(_name))
{
return true;
}
}
name = "";
return false;
}
public WebServerPathEntry GetPath(string path)
{
UnixPath someUrl = WebUtility.UrlDecode(path);
if (_fs.DirectoryExists(someUrl))
{
string name;
if(DefaultFileExists(someUrl.Path,out name))
{
return new WebServerPathEntry(name,WebServerPathType.File,path);
}else{
return new WebServerPathEntry(someUrl.Path,WebServerPathType.Directory,path);
}
}
else if (_fs.FileExists(someUrl))
{
return new WebServerPathEntry(someUrl.Path,WebServerPathType.File,path);
}
else
{
return new WebServerPathEntry(someUrl.Path,WebServerPathType.NotFound,path);
}
}
public IEnumerable<string> ListDirectory(string path)
{
foreach(var item in _fs.EnumerateDirectories(Special.Root/path))
{
yield return item.Name + "/";
}
foreach(var item in _fs.EnumerateFiles(Special.Root/path))
{
yield return item.Name;
}
}
public Stream Open(WebServerPathEntry path)
{
return _fs.Open(Special.Root / path.FileName,FileMode.Open,FileAccess.Read,FileShare.Read);
}
}
public sealed class WebServerStyleFileHandler : IFileHandler
{
2022-04-02 18:59:12 +00:00
string[] _defaultFileNames;
string _path;
2022-04-23 18:25:45 +00:00
/// <summary>
/// construct with path
2022-04-23 18:25:45 +00:00
/// </summary>
/// <param name="path">directory for root</param>
public WebServerStyleFileHandler(string path)
{
_defaultFileNames = new string[] {"index.html","index.htm","default.html","default.htm" };
_path=path;
}
/// <summary>
/// construct with path, custom filenames
/// </summary>
/// <param name="path">directory for root</param>
2022-04-23 18:25:45 +00:00
/// <param name="defaultFileNames">like index.html, index.htm, default.html, default.htm</param>
public WebServerStyleFileHandler(string path,string[] defaultFileNames)
2022-04-02 18:59:12 +00:00
{
_path = path;
2022-04-02 18:59:12 +00:00
_defaultFileNames = defaultFileNames;
}
public bool DefaultFileExists(string path,out string name)
2022-04-02 18:59:12 +00:00
{
foreach(var def in _defaultFileNames)
{
name = Path.Combine(path, def);
if(File.Exists(name))
{
return true;
}
}
name = "";
return false;
}
public WebServerPathEntry GetPath(string url)
2022-04-02 18:59:12 +00:00
{
string someUrl = Path.Combine(_path,WebUtility.UrlDecode(url.Substring(1)).Replace('/', Path.DirectorySeparatorChar));
2022-04-03 15:36:38 +00:00
//Console.WriteLine(someUrl);
2022-04-02 18:59:12 +00:00
if (Directory.Exists(someUrl))
{
string name;
if(DefaultFileExists(someUrl,out name))
{
return new WebServerPathEntry(name,WebServerPathType.File,url);
}else{
return new WebServerPathEntry(someUrl,WebServerPathType.Directory,url);
2022-04-02 18:59:12 +00:00
}
}
else if (File.Exists(someUrl))
{
return new WebServerPathEntry(someUrl,WebServerPathType.File,url);
2022-04-02 18:59:12 +00:00
}
else
{
return new WebServerPathEntry(someUrl,WebServerPathType.NotFound,url);
}
}
public IEnumerable<string> ListDirectory(string path)
{
string someUrl = Path.Combine(_path,WebUtility.UrlDecode(path.Substring(1)).Replace('/', Path.DirectorySeparatorChar));
foreach(var item in Directory.GetDirectories(someUrl))
{
yield return $"{Path.GetFileName(item)}/";
2022-04-02 18:59:12 +00:00
}
foreach(var item in Directory.GetFiles(someUrl))
{
yield return Path.GetFileName(item);
}
}
public Stream CreateFile(string entry)
{
string someUrl = Path.Combine(_path,WebUtility.UrlDecode(entry.Substring(1)).Replace('/', Path.DirectorySeparatorChar));
return File.Create(someUrl);
}
public Stream Open(WebServerPathEntry entry)
{
return File.OpenRead(entry.FileName);
}
public void CreateDirectory(string dir)
{
Directory.CreateDirectory(Path.Combine(_path,dir.Substring(1).Replace('/', Path.DirectorySeparatorChar)));
2022-04-02 18:59:12 +00:00
}
}
public class StaticServerFileHandler : EventArgs
{
public string RealPath {get;set;}
public string CurrentHttpPath {get;set;}
public bool HasBeenHandled {get;set;}=false;
2022-04-02 18:59:12 +00:00
public ServerContext Context {get;set;}
public bool Cancel {get;set;}=false;
}
public enum UploadAllowedResponse
{
Yes=0,
NoISentResponse=1,
No=2
2022-04-02 18:59:12 +00:00
}
/// <summary>
/// Serve static files (doesnt allow listing files)
/// </summary>
public class StaticServer : Server
{
public bool AllowUpload {get;set;}=false;
bool allow=false;
public Func<ServerContext,UploadAllowedResponse> AllowedToUpload {get;set;}=DefaultAllowedToUpload;
public static UploadAllowedResponse DefaultAllowedToUpload(ServerContext ctx)
{
return UploadAllowedResponse.Yes;
}
private bool? getEnvVar()
{
string allowListStr=Environment.GetEnvironmentVariable("TESSES_WEBSERVER_ALLOW_LISTING");
if(!string.IsNullOrWhiteSpace(allowListStr))
{
string allowLst = allowListStr.ToLower();
if(allowLst == "1" || allowLst == "true" || allowLst == "on" || allowLst == "yes" || allowLst == "y" || allowLst == "t" || allowLst == "allow" || allowLst=="allowed" || allowLst == "a")
{
return true;
}
if(allowLst == "0" || allowLst == "false" || allowLst == "off" || allowLst == "no" || allowLst == "n" || allowLst == "f" || allowLst == "deny" || allowLst == "denied" || allowLst == "d")
{
return false;
}
}
return null;
}
public bool AllowListingDirectories {get {
bool? var= getEnvVar();
if(!var.HasValue)
{
return allow;
}
return var.Value;
} set {
allow=value;
}}
public EventHandler<StaticServerFileHandler> FileHandler;
IServer _server;
IFileHandler fileHandler;
IServer _forbidden;
/// <summary>
/// construct with filesystem
/// </summary>
/// <param name="path">filesystem for server</param>
public StaticServer(IVirtualFilesystem fs)
{
_server = new NotFoundServer();
fileHandler=new WebServerStyleFilesystemHandler(fs);
_forbidden = new SameServer("<html><head><title>File {url} not accessable</title></head><body><h1>403 Forbidden</h1><h4>{url}</h4></body></html>",403);
}
/// <summary>
/// construct with filesystem, custom filenames, and server for not found
/// </summary>
/// <param name="path">filesystem for server</param>
/// <param name="defaultFileNames">like index.html, index.htm, default.html, default.htm</param>
/// <param name="notfoundserver">404 not found server</param>
public StaticServer(IVirtualFilesystem fs,string[] defaultFileNames,IServer notfoundserver)
{
_server = notfoundserver;
fileHandler=new WebServerStyleFilesystemHandler(fs,defaultFileNames);
_forbidden = new SameServer("<html><head><title>File {url} not accessable</title></head><body><h1>403 Forbidden</h1><h4>{url}</h4></body></html>",403);
}
/// <summary>
/// construct with filesystem, custom filenames, and server for not found
/// </summary>
/// <param name="path">filesystem for server</param>
/// <param name="defaultFileNames">like index.html, index.htm, default.html, default.htm</param>
/// <param name="notfoundserver">404 not found server</param>
/// <param name="allowListing">whether to allow listing directory or not (overridable by environment variable with TESSES_WEBSERVER_ALLOW_LISTING=true|false)
public StaticServer(IVirtualFilesystem fs,string[] defaultFileNames,IServer notfoundserver,bool allowListing)
{
_server = notfoundserver;
fileHandler=new WebServerStyleFilesystemHandler(fs,defaultFileNames);
AllowListingDirectories = allowListing;
_forbidden = new SameServer("<html><head><title>File {url} not accessable</title></head><body><h1>403 Forbidden</h1><h4>{url}</h4></body></html>",403);
}
/// <summary>
/// construct with filesystem, custom filenames, and server for not found, server for forbidden and with option to allow/deny listing directories
/// </summary>
/// <param name="path">filesystem for server</param>
/// <param name="defaultFileNames">like index.html, index.htm, default.html, default.htm</param>
/// <param name="notfoundserver">404 not found server</param>
/// <param name="forbidden">server for forbidden files/denied listing</param>
/// <param name="allowListing">whether to allow listing directory or not (overridable by environment variable with TESSES_WEBSERVER_ALLOW_LISTING=true|false)
public StaticServer(IVirtualFilesystem fs,string[] defaultFileNames,IServer notfoundserver,IServer forbidden,bool allowListing)
{
_server = notfoundserver;
fileHandler= fileHandler=new WebServerStyleFilesystemHandler(fs,defaultFileNames);
AllowListingDirectories = allowListing;
_forbidden=forbidden;
}
/// <summary>
/// construct with filesystem, custom filenames and with option to allow/deny listing directories
/// </summary>
/// <param name="path">filesystem for server</param>
/// <param name="defaultFileNames">like index.html, index.htm, default.html, default.htm</param>
/// <param name="allowListing">whether to allow listing directory or not (overridable by environment variable with TESSES_WEBSERVER_ALLOW_LISTING=true|false)
public StaticServer(IVirtualFilesystem fs,string[] defaultFileNames,bool allowListing)
{
_server = new NotFoundServer();
fileHandler=new WebServerStyleFilesystemHandler(fs,defaultFileNames);
AllowListingDirectories = allowListing;
_forbidden = new SameServer("<html><head><title>File {url} not accessable</title></head><body><h1>403 Forbidden</h1><h4>{url}</h4></body></html>",403);
}
/// <summary>
/// construct with filesystem and with option to allow/deny listing directories
/// </summary>
/// <param name="path">filesystem for server</param>
/// <param name="allowListing">whether to allow listing directory or not (overridable by environment variable with TESSES_WEBSERVER_ALLOW_LISTING=true|false)
public StaticServer(IVirtualFilesystem fs,bool allowListing)
{
_server = new NotFoundServer();
fileHandler=new WebServerStyleFilesystemHandler(fs);
AllowListingDirectories = allowListing;
_forbidden = new SameServer("<html><head><title>File {url} not accessable</title></head><body><h1>403 Forbidden</h1><h4>{url}</h4></body></html>",403);
}
/// <summary>
/// construct with path
/// </summary>
/// <param name="path">directory for server</param>
public StaticServer(string path)
{
_server = new NotFoundServer();
fileHandler=new WebServerStyleFileHandler(path);
_forbidden = new SameServer("<html><head><title>File {url} not accessable</title></head><body><h1>403 Forbidden</h1><h4>{url}</h4></body></html>",403);
}
/// <summary>
/// construct with path, custom filenames, and server for not found
/// </summary>
/// <param name="path">directory for server</param>
/// <param name="defaultFileNames">like index.html, index.htm, default.html, default.htm</param>
/// <param name="notfoundserver">404 not found server</param>
public StaticServer(string path,string[] defaultFileNames,IServer notfoundserver)
{
_server = notfoundserver;
fileHandler=new WebServerStyleFileHandler(path,defaultFileNames);
_forbidden = new SameServer("<html><head><title>File {url} not accessable</title></head><body><h1>403 Forbidden</h1><h4>{url}</h4></body></html>",403);
}
/// <summary>
/// construct with path, custom filenames, and server for not found
/// </summary>
/// <param name="path">directory for server</param>
/// <param name="defaultFileNames">like index.html, index.htm, default.html, default.htm</param>
/// <param name="notfoundserver">404 not found server</param>
/// <param name="allowListing">whether to allow listing directory or not (overridable by environment variable with TESSES_WEBSERVER_ALLOW_LISTING=true|false)
public StaticServer(string path,string[] defaultFileNames,IServer notfoundserver,bool allowListing)
{
_server = notfoundserver;
fileHandler=new WebServerStyleFileHandler(path,defaultFileNames);
AllowListingDirectories = allowListing;
_forbidden = new SameServer("<html><head><title>File {url} not accessable</title></head><body><h1>403 Forbidden</h1><h4>{url}</h4></body></html>",403);
}
/// <summary>
/// construct with path, custom filenames, and server for not found, server for forbidden and with option to allow/deny listing directories
/// </summary>
/// <param name="path">directory for server</param>
/// <param name="defaultFileNames">like index.html, index.htm, default.html, default.htm</param>
/// <param name="notfoundserver">404 not found server</param>
/// <param name="forbidden">server for forbidden files/denied listing</param>
/// <param name="allowListing">whether to allow listing directory or not (overridable by environment variable with TESSES_WEBSERVER_ALLOW_LISTING=true|false)
public StaticServer(string path,string[] defaultFileNames,IServer notfoundserver,IServer forbidden,bool allowListing)
{
_server = notfoundserver;
fileHandler=new WebServerStyleFileHandler(path,defaultFileNames);
AllowListingDirectories = allowListing;
_forbidden=forbidden;
}
/// <summary>
/// construct with path, custom filenames and with option to allow/deny listing directories
/// </summary>
/// <param name="path">directory for server</param>
/// <param name="defaultFileNames">like index.html, index.htm, default.html, default.htm</param>
/// <param name="allowListing">whether to allow listing directory or not (overridable by environment variable with TESSES_WEBSERVER_ALLOW_LISTING=true|false)
public StaticServer(string path,string[] defaultFileNames,bool allowListing)
{
_server = new NotFoundServer();
fileHandler=new WebServerStyleFileHandler(path,defaultFileNames);
AllowListingDirectories = allowListing;
_forbidden = new SameServer("<html><head><title>File {url} not accessable</title></head><body><h1>403 Forbidden</h1><h4>{url}</h4></body></html>",403);
}
/// <summary>
/// construct with path and with option to allow/deny listing directories
/// </summary>
/// <param name="path">directory for server</param>
/// <param name="allowListing">whether to allow listing directory or not (overridable by environment variable with TESSES_WEBSERVER_ALLOW_LISTING=true|false)
public bool RedirectToRootInsteadOfNotFound {get;set;}=false;
public StaticServer(string path,bool allowListing)
{
_server = new NotFoundServer();
fileHandler=new WebServerStyleFileHandler(path);
AllowListingDirectories = allowListing;
_forbidden = new SameServer("<html><head><title>File {url} not accessable</title></head><body><h1>403 Forbidden</h1><h4>{url}</h4></body></html>",403);
}
public bool DefaultFileExists(string path,out string name)
{
return fileHandler.DefaultFileExists(path,out name);
}
public override async Task OtherAsync(ServerContext ctx)
{
if(ctx.Method == "PUT")
{
if(AllowUpload)
{
var res=AllowedToUpload(ctx);
if(res == UploadAllowedResponse.Yes)
{
bool fileExists = fileHandler.GetPath(ctx.UrlPath).Type == WebServerPathType.File;
using(var file = fileHandler.CreateFile(ctx.UrlPath))
{
await ctx.ReadToStreamAsync(file);
}
ctx.StatusCode = fileExists ? 204 : 201;
ctx.ResponseHeaders.Add("Content-Location",ctx.UrlPath);
await ctx.WriteHeadersAsync();
}else if(res == UploadAllowedResponse.No)
{
await _forbidden.GetAsync(ctx);
}
}
}
}
public override async Task PostAsync(ServerContext ctx)
{
var fileEntry = fileHandler.GetPath(ctx.UrlPath);
if(fileEntry.Type == WebServerPathType.Directory)
{
if(AllowUpload)
{
var res=AllowedToUpload(ctx);
if(res == UploadAllowedResponse.Yes)
{
//upload files and dirs
var res0= ctx.ParseBody((fieldName,fileName,ctype)=>{
return fileHandler.CreateFile($"{ctx.UrlPath}/{fileName.TrimStart('/')}");
});
foreach(var item in res0)
{
item.Value.Dispose();
}
List<string> dirs=new List<string>();
if(ctx.QueryParams.TryGetValue("mkdir",out dirs))
{
foreach(var dir in dirs)
{
fileHandler.CreateDirectory($"{ctx.UrlPath}/{dir.TrimStart('/')}");
}
}
}else if(res == UploadAllowedResponse.No)
{
await _forbidden.GetAsync(ctx);
}
}
}
}
public override async Task GetAsync(ServerContext ctx)
{
var fileEntry = fileHandler.GetPath(ctx.UrlPath);
try{
switch(fileEntry.Type)
{
case WebServerPathType.File:
using(var strm = fileHandler.Open(fileEntry))
await ctx.SendStreamAsync(strm,HeyRed.Mime.MimeTypesMap.GetMimeType(fileEntry.FileName));
break;
case WebServerPathType.Directory:
if(AllowListingDirectories)
{
DirectoryLister lister=new DirectoryLister();
lister.FromDirectory(fileHandler,ctx.UrlPath,ctx.OriginalUrlPath);
await lister.GetAsync(ctx);
}
else
{
await _forbidden.GetAsync(ctx);
}
break;
case WebServerPathType.NotFound:
if(RedirectToRootInsteadOfNotFound)
{
var fileEntry2 = fileHandler.GetPath("/");
switch(fileEntry.Type)
{
case WebServerPathType.File:
using(var strm = fileHandler.Open(fileEntry2))
await ctx.SendStreamAsync(strm,HeyRed.Mime.MimeTypesMap.GetMimeType(fileEntry.FileName));
break;
case WebServerPathType.Directory:
if(AllowListingDirectories)
{
DirectoryLister lister=new DirectoryLister();
lister.FromDirectory(fileHandler,"/",ctx.OriginalUrlPath);
await lister.GetAsync(ctx);
}
else
{
await _forbidden.GetAsync(ctx);
}
break;
case WebServerPathType.NotFound:
await _server.GetAsync(ctx);
break;
}
}else{
await _server.GetAsync(ctx);
}
break;
}
}catch(UnauthorizedAccessException ex)
{
_=ex;
await _forbidden.GetAsync(ctx);
}
}
}
public class DirectoryLister : Server
{
public static string GetFileName(string url)
{
if(Path.DirectorySeparatorChar == '/')
{
return Path.GetFileName(url);
}
return Path.GetFileName(url.Replace('/',Path.DirectorySeparatorChar));
}
private static string _getFileNameWithoutQuery(string url)
{
int r = url.IndexOf('?');
if(r > -1)
{
return GetFileName(url.Remove(r).TrimEnd('/')) + (url.EndsWith("/") ? "/" : "");
}
return GetFileName(url.TrimEnd('/')) + (url.EndsWith("/") ? "/" : "");
}
static string defaultText=GetEnumerable("Default","",new string[0]);
string curText=defaultText;
public static string GetEnumerable(string title,string desc,IEnumerable<string> entries)
{
/*if(!this.ln.Path.EndsWith("/"))
{
SendRedirect(this.ln.Path + '/');
return;
}*/
StringBuilder b=new StringBuilder();
b.Append($"<!doctype><html><head><title>{HttpUtility.HtmlEncode(title)}</title></head><body><center><h1>{HttpUtility.HtmlEncode(title)}</h1></center><center>{HttpUtility.HtmlEncode(desc)}</center><hr><a href=\"..\">../</a><br>");
foreach(var entry in entries)
{
//<a href=
b.Append($"<a href=\"{HttpUtility.HtmlAttributeEncode(entry)}\">{HttpUtility.HtmlEncode(_getFileNameWithoutQuery(entry))}</a><br>");
}
b.Append("<hr><br><center><a href=\"https://www.nuget.org/packages/Tesses.WebServer\">Tesses.WebServer</a></center></body></html>");
return b.ToString();
}
public string Title {get;set;}="Directory Listing";
public string Description {get;set;}="";
public void FromEnumerable(string title,string desc,IEnumerable<string> entries)
{
curText = GetEnumerable(title,desc,entries);
}
public void FromDirectory(string title,string desc,string directory,string reqPath)
{
List<string> items=new List<string>();
foreach(var item in Directory.EnumerateDirectories(directory))
{
items.Add(item + "/");
}
foreach(var item in Directory.EnumerateFiles(directory))
{
items.Add(item);
}
FromEnumerable(title,desc,items);
}
public void FromDirectory(string directory,string reqPath)
{
FromDirectory($"Index of {reqPath}","Directory listing",directory,reqPath);
}
public void FromDirectory(IFileHandler handler,string reqPath,string ogPath="/")
{
FromEnumerable($"Index of {ogPath}","Directory listing",handler.ListDirectory(reqPath));
}
public override async Task GetAsync(ServerContext ctx)
{
await ctx.SendTextAsync(curText);
}
}
2022-04-23 18:25:45 +00:00
/// <summary>
/// Server where you can change inner server
/// </summary>
public class ChangeableServer : Server
{
/// <summary>
/// The inner server to change
/// </summary>
public IServer Server {get;set;}
/// <summary>
/// Construct with default value
/// </summary>
public ChangeableServer()
{
Server=null;
}
/// <summary>
/// Construct with server
/// </summary>
/// <param name="svr">the inner server</param>
public ChangeableServer(IServer svr)
{
Server=svr;
}
public override async Task<bool> BeforeAsync(ServerContext ctx)
{
return await Guaranteed(Server).BeforeAsync(ctx);
}
public override async Task GetAsync(ServerContext ctx)
{
await Guaranteed(Server).GetAsync(ctx);
}
public override async Task OptionsAsync(ServerContext ctx)
{
await Guaranteed(Server).OptionsAsync(ctx);
}
public override async Task OtherAsync(ServerContext ctx)
{
await Guaranteed(Server).OtherAsync(ctx);
}
public override async Task PostAsync(ServerContext ctx)
{
await Guaranteed(Server).PostAsync(ctx);
}
}
/// <summary>
/// Abstract class for server
/// </summary>
2022-04-02 18:59:12 +00:00
public abstract class Server : IServer
{
2022-04-23 18:25:45 +00:00
/// <summary>
/// Returns 404 Not found
/// </summary>
public static readonly NotFoundServer ServerNull = new NotFoundServer();
2022-04-23 18:25:45 +00:00
/// <summary>
/// You are guarenteed to have a server
/// </summary>
/// <param name="svr">any server object</param>
/// <returns>if null return ServerNull otherwise return svr</returns>
public IServer Guaranteed(IServer svr)
{
if(svr != null)
{
return svr;
}
return ServerNull;
}
2022-04-23 18:25:45 +00:00
/// <summary>
/// Put cors header
/// </summary>
2022-04-02 21:15:20 +00:00
public bool CorsHeader = true;
2022-04-23 18:25:45 +00:00
/// <summary>
/// Called on GET Request
/// </summary>
/// <param name="ctx">ServerContext</param>
2022-04-02 18:59:12 +00:00
public abstract Task GetAsync(ServerContext ctx);
2022-04-23 18:25:45 +00:00
/// <summary>
/// Called on POST Request
/// </summary>
/// <param name="ctx">ServerContext</param>
2022-04-02 18:59:12 +00:00
public virtual async Task PostAsync(ServerContext ctx)
{
ctx.StatusCode = (int)HttpStatusCode.MethodNotAllowed;
await ctx.SendTextAsync("Method Not Supported");
2022-09-01 05:26:26 +00:00
2022-04-02 21:15:20 +00:00
}
2022-04-23 18:25:45 +00:00
/// <summary>
/// Called on OPTIONS Request
/// </summary>
/// <param name="ctx">ServerContext</param>
2022-04-02 21:15:20 +00:00
public virtual async Task OptionsAsync(ServerContext ctx)
{
await ctx.WriteHeadersAsync();
ctx.NetworkStream.Close();
}
2022-04-23 18:25:45 +00:00
/// <summary>
/// Called on any other Request method
/// </summary>
/// <param name="ctx">ServerContext</param>
2022-04-02 21:15:20 +00:00
public virtual async Task OtherAsync(ServerContext ctx)
{
ctx.StatusCode = (int)HttpStatusCode.MethodNotAllowed;
await ctx.SendTextAsync("Method Not Supported");
}
2022-04-23 18:25:45 +00:00
/// <summary>
/// Called before request was made
/// </summary>
/// <param name="ctx">ServerContext</param>
/// <returns>true to cancel request, false to continue request</returns>
2022-04-02 21:15:20 +00:00
public virtual async Task<bool> BeforeAsync(ServerContext ctx)
{
return await Task.FromResult(false);
}
2022-04-23 18:25:45 +00:00
/// <summary>
/// Add cors header
/// </summary>
/// <param name="ctx">Server Context</param>
public void AddCors(ServerContext ctx)
{
if (CorsHeader)
{
ctx.ResponseHeaders.Add("Access-Control-Allow-Origin", "*");
ctx.ResponseHeaders.Add("Access-Control-Allow-Headers", "Cache-Control, Pragma, Accept, Origin, Authorization, Content-Type, X-Requested-With");
ctx.ResponseHeaders.Add("Access-Control-Allow-Methods", "GET, POST");
ctx.ResponseHeaders.Add("Access-Control-Allow-Credentials", "true");
}
}
2022-04-02 21:15:20 +00:00
}
2022-04-23 18:25:45 +00:00
/// <summary>
/// mount multiple servers at different url paths
/// </summary>
2022-04-02 21:15:20 +00:00
public sealed class MountableServer : Server
{
Dictionary<string, IServer> _servers = new Dictionary<string, IServer>();
public MountableServer(IServer root)
{
_root = root;
}
IServer _root;
private (string Key,IServer Value) GetFromPath(ServerContext ctx)
2022-04-02 21:15:20 +00:00
{
//bool j = false;
foreach(var item in _servers.Reverse())
{
if(ctx.UrlPath.StartsWith(item.Key,StringComparison.Ordinal))
{
return (item.Key,Guaranteed(item.Value));
}
if (ctx.UrlPath == item.Key.TrimEnd('/'))
{
ctx.UrlPath += "/";
return (item.Key,Guaranteed(item.Value));
2022-04-02 21:15:20 +00:00
}
}
//Console.WriteLine("HERE WE ARE");
return ("/",Guaranteed(_root));
2022-04-02 21:15:20 +00:00
}
/// <summary>
/// Mount the specified url and server.
/// Must mount like this
/// /somePath0
/// /somePath0/someSubPath0
/// /somePath0/someSubPath0/someSubSubPath0
/// /somePath0/someSubPath0/someSubSubPath1
/// /somePath0/someSubPath1
/// /somePath0/someSubPath1/someSubSubPath0
/// /somePath0/someSubPath1/someSubSubPath1
/// </summary>
/// <param name="url">URL.</param>
/// <param name="server">Server.</param>
public void Mount(string url,IServer server)
{
_servers.Add(url, server);
}
2022-04-23 18:25:45 +00:00
/// <summary>
/// Unmount a server
/// </summary>
/// <param name="url">Url</param>
2022-04-02 21:15:20 +00:00
public void Unmount(string url)
{
_servers.Remove(url);
}
2022-04-23 18:25:45 +00:00
/// <summary>
/// Unmount all servers
/// </summary>
2022-04-02 21:15:20 +00:00
public void UnmountAll()
{
_servers.Clear();
}
public override async Task GetAsync(ServerContext ctx)
{
var v = GetFromPath(ctx);
string url = '/' + ctx.UrlPath.Substring(v.Key.Length).TrimStart('/');
ctx.UrlPath = url;
await v.Value.GetAsync(ctx);
}
public override async Task PostAsync(ServerContext ctx)
{
var v = GetFromPath(ctx);
string url = '/' + ctx.UrlPath.Substring(v.Key.Length).TrimStart('/');
ctx.UrlPath = url;
await v.Value.PostAsync(ctx);
}
public override async Task<bool> BeforeAsync(ServerContext ctx)
{
var v = GetFromPath(ctx);
string old=ctx.UrlPath;
string url = '/' + ctx.UrlPath.Substring(v.Key.Length).TrimStart('/');
ctx.UrlPath = url;
var res=await v.Value.BeforeAsync(ctx);
ctx.UrlPath = old;
return res;
}
public override async Task OptionsAsync(ServerContext ctx)
{
var v = GetFromPath(ctx);
string url = '/' + ctx.UrlPath.Substring(v.Key.Length).TrimStart('/');
ctx.UrlPath = url;
await v.Value.OptionsAsync(ctx);
}
public override async Task OtherAsync(ServerContext ctx)
{
var v = GetFromPath(ctx);
string url = '/' + ctx.UrlPath.Substring(v.Key.Length).TrimStart('/');
ctx.UrlPath = url;
await v.Value.OtherAsync(ctx);
2022-04-02 18:59:12 +00:00
}
}
2022-04-23 18:25:45 +00:00
/// <summary>
/// Check username and password are correct or if request can be anonymous
/// </summary>
/// <param name="username">Username, can and will be "" on first request for resource</param>
/// <param name="password">Password, can and will be "" on first request for resource</param>
/// <returns>true for authorized, false for unauthorized</returns>
public delegate bool Authenticate(string username, string password);
2022-04-23 18:25:45 +00:00
/// <summary>
/// Check username and password are correct or if request can be anonymous
/// </summary>
/// <param name="context">Server Context</param>
/// <param name="username">Username, can and will be "" on first request for resource</param>
/// <param name="password">Password, can and will be "" on first request for resource</param>
/// <returns>true for authorized, false for unauthorized</returns>
public delegate bool AuthenticateWithContext(ServerContext context,string username,string password);
/// <summary>
/// Protect server with password
/// </summary>
public class BasicAuthServer : Server
{
2022-04-23 18:25:45 +00:00
/// <summary>
/// Construct server for user authorization
/// </summary>
/// <param name="auth">callback for authorization</param>
/// <param name="inner">server to protect</param>
/// <param name="realm">realm parameter in WWW-Auhenticate Header</param>
public BasicAuthServer(Authenticate auth,IServer inner,string realm="SampleRealm")
{
Authenticate = auth;
InnerServer = inner;
Realm = realm;
2022-04-23 18:25:45 +00:00
}
/// <summary>
/// Construct server for user authorization (With ServerContext in callback)
/// </summary>
/// <param name="auth">callback for authorization</param>
/// <param name="inner">server to protect</param>
/// <param name="realm">realm parameter in WWW-Auhenticate Header</param>
public BasicAuthServer(AuthenticateWithContext auth,IServer inner,string realm = "SampleRealm")
{
AuthenticateWithContext=auth;
InnerServer=inner;
Realm = realm;
}
public override async Task<bool> BeforeAsync(ServerContext ctx)
{
if(await Authorize(ctx))
{
return await Guaranteed(InnerServer).BeforeAsync(ctx);
}
return true;
}
public override async Task GetAsync(ServerContext ctx)
{
await Guaranteed(InnerServer).GetAsync(ctx);
}
public override async Task PostAsync(ServerContext ctx)
{
await Guaranteed(InnerServer).PostAsync(ctx);
}
public override async Task OtherAsync(ServerContext ctx)
{
await Guaranteed(InnerServer).OtherAsync(ctx);
}
public override async Task OptionsAsync(ServerContext ctx)
{
await Guaranteed(InnerServer).OptionsAsync(ctx);
}
2022-04-23 18:25:45 +00:00
/// <summary>
/// Server to protect
/// </summary>
public IServer InnerServer { get; set; }
2022-04-23 18:25:45 +00:00
/// <summary>
/// Authentication callback without ServerContext
/// </summary>
public Authenticate Authenticate { get; set; }
2022-04-23 18:25:45 +00:00
/// <summary>
/// Authentication callback with ServerContext
/// </summary>
public AuthenticateWithContext AuthenticateWithContext {get;set;}
/// <summary>
/// Realm parameter in WWW-Authenticate header
/// </summary>
public string Realm { get; set; }
private bool ValidAuth(ServerContext ctx)
{
string auth;
2022-04-23 18:25:45 +00:00
if(Authenticate == null && AuthenticateWithContext == null) return true;
if (ctx.RequestHeaders.TryGetFirst("Authorization", out auth))
{
string[] authorization = auth.Split(' ');
//authorization_basic
if (authorization[0] == "Basic")
{
string[] userPass = Encoding.UTF8.GetString(Convert.FromBase64String(authorization[1])).Split(new char[] { ':' },2);
//return userPass.Equals($"{config.UserName}:{config.Password}", StringComparison.Ordinal);
2022-04-23 18:25:45 +00:00
if(Authenticate != null)
return Authenticate(userPass[0], userPass[1]);
if(AuthenticateWithContext != null)
return AuthenticateWithContext(ctx,userPass[0],userPass[2]);
}
2022-04-23 18:25:45 +00:00
}else{
if(Authenticate != null)
return Authenticate("", "");
if(AuthenticateWithContext != null)
return AuthenticateWithContext(ctx,"","");
}
return false;
}
private async Task<bool> Authorize(ServerContext ctx)
{
2022-04-23 18:25:45 +00:00
if (Authenticate == null && AuthenticateWithContext == null)
return true;
if (ValidAuth(ctx))
return true;
ctx.ResponseHeaders.Add("WWW-Authenticate", $"Basic realm=\"{Realm}\"");
ctx.StatusCode = 401;
await UnauthorizedPage(ctx);
return false;
}
protected virtual async Task UnauthorizedPage(ServerContext ctx)
{
await ctx.SendTextAsync("Unauthorized");
}
}
public class HostDomainServer : Server
{
public HostDomainServer(IServer alt)
{
Default = alt;
Servers = new Dictionary<string, IServer>();
}
public void Clear()
{
Servers.Clear();
}
public void Remove(string fqdn_or_ip)
{
Servers.Remove(fqdn_or_ip);
}
public IServer Default { get; set; }
Dictionary<string, IServer> Servers;
2022-04-02 18:59:12 +00:00
public void AddDomain(string fqdn_or_ip,IServer svr)
{
Servers.Add(fqdn_or_ip, svr);
}
public override async Task<bool> BeforeAsync(ServerContext ctx)
{
return await GetDomain(ctx).BeforeAsync(ctx);
}
public override async Task PostAsync(ServerContext ctx)
{
await GetDomain(ctx).PostAsync(ctx);
}
public override async Task OtherAsync(ServerContext ctx)
{
await GetDomain(ctx).OtherAsync(ctx);
}
public override async Task OptionsAsync(ServerContext ctx)
{
await GetDomain(ctx).OptionsAsync(ctx);
}
public override async Task GetAsync(ServerContext ctx)
{
await GetDomain(ctx).GetAsync(ctx);
}
private IServer GetDomain(ServerContext ctx)
{
string fqdn_or_ip = ctx.Host;
foreach(var item in Servers)
{
if(item.Key.Equals(fqdn_or_ip,StringComparison.Ordinal))
{
return Guaranteed(item.Value);
}
}
return Guaranteed(Default);
}
}
2022-04-02 18:59:12 +00:00
public interface IServer
{
void AddCors(ServerContext ctx);
2022-04-02 21:15:20 +00:00
Task<bool> BeforeAsync(ServerContext ctx);
2022-04-02 18:59:12 +00:00
Task GetAsync(ServerContext ctx);
Task PostAsync(ServerContext ctx);
2022-04-02 21:15:20 +00:00
Task OptionsAsync(ServerContext ctx);
Task OtherAsync(ServerContext ctx);
2022-04-02 18:59:12 +00:00
}
public sealed class HttpServerListener
{
2022-04-23 18:25:45 +00:00
/// <summary>
/// Print urls when running
/// </summary>
/// <value>true if verbose, false if not</value>
2022-04-03 15:36:38 +00:00
public bool PrintUrls {get;set;}
bool https;
X509Certificate cert;
2022-09-01 05:26:26 +00:00
ChangeableServer _server;
2022-04-02 18:59:12 +00:00
TcpListener _listener;
2022-04-03 15:36:38 +00:00
SslProtocols protocols;
2022-09-01 05:26:26 +00:00
public HttpServerListener(int port)
{
_server=new ChangeableServer();
_listener = new TcpListener(new IPEndPoint(IPAddress.Any,port));
https = false;
PrintUrls=false;
}
public HttpServerListener(IPEndPoint endpoint)
{
_server=new ChangeableServer();
_listener = new TcpListener(endpoint);
https = false;
PrintUrls=false;
2022-04-24 18:56:06 +00:00
2022-09-01 05:26:26 +00:00
}
public HttpServerListener(int port,IServer server)
{
_server=new ChangeableServer();
_listener = new TcpListener(new IPEndPoint(IPAddress.Any,port));
_server.Server=server;
https = false;
PrintUrls=false;
}
2022-04-02 18:59:12 +00:00
public HttpServerListener(IPEndPoint endPoint,IServer server)
{
2022-09-01 05:26:26 +00:00
_server=new ChangeableServer();
2022-04-02 18:59:12 +00:00
_listener = new TcpListener(endPoint);
2022-09-01 05:26:26 +00:00
_server.Server=server;
https = false;
2022-04-03 15:36:38 +00:00
PrintUrls=false;
}
public HttpServerListener(IServer server)
{
2022-09-01 05:26:26 +00:00
_server=new ChangeableServer();
_listener = new TcpListener(new IPEndPoint(IPAddress.Any, 3251));
_server.Server = server;
https = false;
PrintUrls=false;
}
public HttpServerListener()
{
_server=new ChangeableServer();
_listener = new TcpListener(new IPEndPoint(IPAddress.Any, 3251));
https = false;
2022-04-03 15:36:38 +00:00
PrintUrls=false;
}
2022-09-01 05:26:26 +00:00
public HttpServerListener(int port,IServer server,X509Certificate cert,SslProtocols protocols=SslProtocols.Default)
{
_server=new ChangeableServer();
_listener = new TcpListener(new IPEndPoint(IPAddress.Any,port));
_server.Server = server;
https = cert != null;
this.cert = cert;
this.protocols=protocols;
PrintUrls=false;
}
2022-04-03 15:36:38 +00:00
public HttpServerListener(IPEndPoint endpoint,IServer server,X509Certificate cert,SslProtocols protocols=SslProtocols.Default)
{
2022-09-01 05:26:26 +00:00
_server=new ChangeableServer();
_listener = new TcpListener(endpoint);
2022-09-01 05:26:26 +00:00
_server.Server = server;
https = cert != null;
this.cert = cert;
2022-04-03 15:36:38 +00:00
this.protocols=protocols;
PrintUrls=false;
2022-04-02 18:59:12 +00:00
}
2022-09-01 05:26:26 +00:00
public void Listen()
{
ListenAsync().Wait();
}
public void Listen(CancellationToken token)
{
ListenAsync(token).Wait();
}
public async Task ListenAsync()
{
await ListenAsync(CancellationToken.None);
}
2022-04-02 18:59:12 +00:00
public async Task ListenAsync(CancellationToken token)
{
2022-09-01 05:26:26 +00:00
2022-04-02 18:59:12 +00:00
_listener.Start();
using (var r = token.Register(() => _listener.Stop())) {
while (!token.IsCancellationRequested)
{
2022-05-03 18:56:14 +00:00
try{
2022-04-02 18:59:12 +00:00
var socket=await _listener.AcceptTcpClientAsync();
Task.Factory.StartNew(async()=>{
try{
2022-09-01 05:26:26 +00:00
await CommunicateHostAsync(socket,()=>{
return socket.Connected;
});
}catch(Exception ex)
{
_=ex;
}
}).Wait(0);
2022-05-03 18:56:14 +00:00
}catch(Exception ex)
{
_=ex;
}
2022-04-02 18:59:12 +00:00
}
}
}
public async Task PushAsync(Stream strm,EndPoint local,EndPoint remote)
2022-09-01 05:26:26 +00:00
{
await PushAsync(strm,local,remote,null);
}
public async Task PushAsync(Stream strm,EndPoint local,EndPoint remote,Func<bool> isConnected)
{
string request_line = "";
string res=ReadHeaders(strm);
var headers=Headers(res,out request_line);
// {Method} {Path} HTTP/1.1
ServerContext ctx=null;
string[] request=request_line.Split(new char[] { ' ' }, 3);
string method = request[0];
try
{
string path = request[1];
string ver = request[2];
2022-09-01 05:26:26 +00:00
ctx = new ServerContext(method, strm, path, headers,isConnected);
ctx.Server =local as IPEndPoint;
ctx.Client = remote as IPEndPoint;
_server.AddCors(ctx);
if(PrintUrls)
{
Console.WriteLine(path);
}
if (!await _server.BeforeAsync(ctx))
{
switch (method)
{
case "HEAD":
case "GET":
await _server.GetAsync(ctx);
break;
case "POST":
await _server.PostAsync(ctx);
break;
case "OPTIONS":
await _server.OptionsAsync(ctx);
break;
default:
await _server.OtherAsync(ctx);
break;
}
}
}catch(Exception ex)
{
try
{
await ctx.SendExceptionAsync(ex);
}catch(Exception ex2)
{
_ = ex2;
}
}
}
public async Task ListenAsync(CancellationToken token,Action<IPEndPoint> endpoint)
{
_listener.Start();
if(endpoint != null)
{
endpoint((IPEndPoint)_listener.LocalEndpoint);
}
using (var r = token.Register(() => _listener.Stop())) {
while (!token.IsCancellationRequested)
{
try{
var socket=await _listener.AcceptTcpClientAsync();
2022-09-01 05:26:26 +00:00
await CommunicateHostAsync(socket,()=>{
return socket.Connected;
}).ConfigureAwait(false);
}catch(Exception ex)
{
_=ex;
}
}
}
}
2022-04-02 18:59:12 +00:00
private string ReadHeaders(Stream strm)
2022-04-02 18:59:12 +00:00
{
StringBuilder s = new StringBuilder();
var decoder = Encoding.UTF8.GetDecoder();
var nextChar = new char[1];
while (!s.EndsWith("\r\n\r\n",StringComparison.Ordinal))
{
int data = strm.ReadByte();
if(data == -1)
{
break;
}
int charCount=decoder.GetChars(new byte[] { (byte)data }, 0, 1, nextChar, 0);
if (charCount == 0) continue;
s.Append(nextChar);
}
return s.ToString();
}
private Dictionary<string,List<string>> Headers(string s,out string req_line)
{
Dictionary<string, List<string>> items = new Dictionary<string, List<string>>();
string[] lines = s.Split(new string[] { "\r\n" }, StringSplitOptions.RemoveEmptyEntries);
req_line = lines[0];
for(int i=1;i<lines.Length;i++)
{
var line_split=lines[i].Split(new[] { ": " },2,StringSplitOptions.None);
if (line_split.Length == 2)
{
items.Add(line_split[0], line_split[1]);
}
}
return items;
}
public Stream GetStream(TcpClient clt)
{
if(https)
{
SslStream sslStream = new SslStream(
clt.GetStream(), false);
try
{
2022-04-03 15:36:38 +00:00
sslStream.AuthenticateAsServer(cert,false,protocols,true);
}
catch (Exception ex)
{
_ = ex;
}
return sslStream;
}
return clt.GetStream();
}
2022-09-01 05:26:26 +00:00
private async Task CommunicateHostAsync(TcpClient clt,Func<bool> isConnected)
2022-04-02 18:59:12 +00:00
{
2022-05-05 17:49:34 +00:00
try{
2022-04-02 18:59:12 +00:00
//<METHOD> <PATH> HTTP/1.1\r\n
//HEADER1\r\n
//HEADER2\r\n
//......
//HEADERN\r\n
//\r\n
//OPTIONAL REQUEST BODY
//RESPONSE
using (Stream strm = GetStream(clt))
2022-04-02 18:59:12 +00:00
{
2022-09-01 05:26:26 +00:00
await PushAsync(strm,clt.Client.LocalEndPoint,clt.Client.RemoteEndPoint,isConnected);
2022-04-02 18:59:12 +00:00
}
2022-05-05 17:49:34 +00:00
}catch(Exception ex)
{
_=ex;
}
2022-04-02 18:59:12 +00:00
}
//protected abstract Task<IResult> Get(string url,Dictionary<string,string> headers);
//protected abstract Task GetAsync(ServerContext ctx);
}
}