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; using System.Security.Authentication; namespace Tesses.WebServer { public static class Extensions { /// /// Read string from request body /// /// ServerContext /// the contents of request public static async Task ReadStringAsync(this ServerContext ctx) { string str = null; using (var reader = new StreamReader(ctx.NetworkStream)) { str = await reader.ReadToEndAsync(); } return str; } /// /// Read json from request body /// /// ServerContext /// type of object (for scema) /// object of type T with deserialized json data public static async Task ReadJsonAsync(this ServerContext ctx) { var json=await ctx.ReadStringAsync(); return JsonConvert.DeserializeObject(json); } /// /// Read request body to array /// /// ServerContext /// Request body data public static async Task ReadBytesAsync(this ServerContext ctx) { MemoryStream strm = new MemoryStream(); await ctx.ReadToStreamAsync(strm); return strm.ToArray(); } /// /// Read request body to stream /// /// ServerContext /// Stream to write to public static async Task ReadToStreamAsync(this ServerContext ctx,Stream strm) { await ctx.NetworkStream.CopyToAsync(strm); } /// /// Read request body to file /// /// ServerContext /// name of file to write too, can be without extension /// file path with extension unless mimetype header is missing public static async Task 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)) { await ctx.NetworkStream.CopyToAsync(f); } return filename; } /// /// Write headers to stream /// /// ServerContext public static async Task WriteHeadersAsync(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()); await ctx.NetworkStream.WriteAsync(data, 0, data.Length); } /// /// Send file to client (supports range partial content) /// /// ServerContext /// the file to serve public static async Task SendFileAsync(this ServerContext ctx, string file) { using (var strm = File.OpenRead(file)) { await ctx.SendStreamAsync( strm, MimeTypesMap.GetMimeType(file)); } } /// /// Send exception to client /// /// ServerContext /// the Exception public static async Task SendExceptionAsync(this ServerContext ctx, Exception ex) { string name = ex.GetType().FullName; string j = $"{WebUtility.HtmlEncode(name)} thrown

{WebUtility.HtmlEncode(name)} thrown

Description: {WebUtility.HtmlEncode(ex.Message)}

"; ctx.StatusCode = 500; await ctx.SendTextAsync(j); } /// /// Send object as json to client /// /// ServerContext /// an object to serialize with newtonsoft.json public static async Task SendJsonAsync(this ServerContext ctx,object value) { await ctx.SendTextAsync(JsonConvert.SerializeObject(value), "application/json"); } /// /// Send text to client /// /// ServerContext /// some text /// mime type public static async Task SendTextAsync(this ServerContext ctx, string data, string contentType = "text/html") { await ctx.SendBytesAsync(Encoding.UTF8.GetBytes(data), contentType); } /// /// Send redirect /// /// ServerContext /// Url to redirect to 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(); } /// /// Send byte[] to client /// /// ServerContext /// a byte[] array /// mime type public static async Task SendBytesAsync(this ServerContext ctx, byte[] array, string contentType = "application/octet-stream") { using (var ms = new MemoryStream(array)) { await ctx.SendStreamAsync( ms, contentType); } } /// /// Get first item in Dictionary> based on key /// /// the dictionary with list value /// some key /// key type /// value type /// public static T2 GetFirst(this Dictionary> args,T1 key) { return args[key][0]; } /// /// Try to get first item in Dictionary> based on key /// /// the dictionary with list value /// the key to check /// the value returned /// key type /// value type /// true if found else false if not found public static bool TryGetFirst(this Dictionary> args,T1 key,out T2 value) { List ls; if (args.TryGetValue(key,out ls)) { if(ls.Count > 0) { value = ls[0]; return true; } } value = default(T2); return false; } /// /// Add item to the Dictionary> with specified key (will create key in dictionary if not exist) /// /// the dictionary with list value /// the key to add or to add to /// a item /// key type /// value type public static void Add(this Dictionary> list,T1 key,T2 item) { if (list.ContainsKey(key)) { list[key].Add(item); } else { List items = new List(); items.Add(item); list.Add(key, items); } } /// /// Add multiple items to the Dictionary> with specified key (will create key in dictionary if not exist) /// /// the dictionary with list value /// the key to add or to add to /// IEnumerable /// key type /// value type public static void AddRange(this Dictionary> list,T1 key,IEnumerable items) { if (list.ContainsKey(key)) { list[key].AddRange(items); } else { List items2 = new List(); items2.AddRange(items); list.Add(key, items2); } } /// /// StringBuilder ends with /// /// string builder /// text to check /// comparison type /// true if sb ends with test, false if it does not 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); } } /// /// returns 404 not found page /// public class NotFoundServer : Server { /// /// 404 not found custom html use "{url}" in your html as url /// /// the custom html public NotFoundServer(string html) { _html = html; } /// ///404 not found default html /// public NotFoundServer() { _html = "File {url} not found

404 Not Found

{url}

"; } string _html; public override async Task GetAsync(ServerContext ctx) { ctx.StatusCode = 404; await ctx.SendTextAsync( _html.Replace("{url}", WebUtility.HtmlEncode(ctx.OriginalUrlPath))); } } /// /// Serve static files (doesnt allow listing files) /// public class StaticServer : Server { string _path; IServer _server; /// /// construct with path /// /// directory for server public StaticServer(string path) { _path = path; _server = new NotFoundServer(); _defaultFileNames = new string[] {"index.html","index.htm","default.html","default.htm" }; } string[] _defaultFileNames; /// /// construct with path, custom filenames, and server for not found /// /// directory for server /// like index.html, index.htm, default.html, default.htm /// 404 not found server public StaticServer(string path,string[] defaultFileNames,IServer notfoundserver) { _path = path; _server = notfoundserver; _defaultFileNames = defaultFileNames; } public bool DefaultFileExists(string path,out string name) { foreach(var def in _defaultFileNames) { name = Path.Combine(path, def); if(File.Exists(name)) { return true; } } name = ""; return false; } public override async Task GetAsync(ServerContext ctx) { string someUrl = Path.Combine(_path,WebUtility.UrlDecode(ctx.UrlPath.Substring(1)).Replace('/', Path.DirectorySeparatorChar)); //Console.WriteLine(someUrl); if (Directory.Exists(someUrl)) { string name; if(DefaultFileExists(someUrl,out name)) { await ctx.SendFileAsync(name); } } else if (File.Exists(someUrl)) { await ctx.SendFileAsync(someUrl); } else { await _server.GetAsync(ctx); } } } /// /// Server where you can change inner server /// public class ChangeableServer : Server { /// /// The inner server to change /// public IServer Server {get;set;} /// /// Construct with default value /// public ChangeableServer() { Server=null; } /// /// Construct with server /// /// the inner server public ChangeableServer(IServer svr) { Server=svr; } public override async Task 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); } } /// /// Abstract class for server /// public abstract class Server : IServer { /// /// Returns 404 Not found /// public static readonly NotFoundServer ServerNull = new NotFoundServer(); /// /// You are guarenteed to have a server /// /// any server object /// if null return ServerNull otherwise return svr public IServer Guaranteed(IServer svr) { if(svr != null) { return svr; } return ServerNull; } /// /// Put cors header /// public bool CorsHeader = true; /// /// Called on GET Request /// /// ServerContext public abstract Task GetAsync(ServerContext ctx); /// /// Called on POST Request /// /// ServerContext public virtual async Task PostAsync(ServerContext ctx) { ctx.StatusCode = (int)HttpStatusCode.MethodNotAllowed; await ctx.SendTextAsync("Method Not Supported"); } /// /// Called on OPTIONS Request /// /// ServerContext public virtual async Task OptionsAsync(ServerContext ctx) { await ctx.WriteHeadersAsync(); ctx.NetworkStream.Close(); } /// /// Called on any other Request method /// /// ServerContext public virtual async Task OtherAsync(ServerContext ctx) { ctx.StatusCode = (int)HttpStatusCode.MethodNotAllowed; await ctx.SendTextAsync("Method Not Supported"); } /// /// Called before request was made /// /// ServerContext /// true to cancel request, false to continue request public virtual async Task BeforeAsync(ServerContext ctx) { return await Task.FromResult(false); } /// /// Add cors header /// /// Server Context 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"); } } } /// /// mount multiple servers at different url paths /// public sealed class MountableServer : Server { Dictionary _servers = new Dictionary(); public MountableServer(IServer root) { _root = root; } IServer _root; private (string Key,IServer Value) GetFromPath(ServerContext ctx) { //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)); } } //Console.WriteLine("HERE WE ARE"); return ("/",Guaranteed(_root)); } /// /// 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 /// /// URL. /// Server. public void Mount(string url,IServer server) { _servers.Add(url, server); } /// /// Unmount a server /// /// Url public void Unmount(string url) { _servers.Remove(url); } /// /// Unmount all servers /// 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 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); } } /// /// Check username and password are correct or if request can be anonymous /// /// Username, can and will be "" on first request for resource /// Password, can and will be "" on first request for resource /// true for authorized, false for unauthorized public delegate bool Authenticate(string username, string password); /// /// Check username and password are correct or if request can be anonymous /// /// Server Context /// Username, can and will be "" on first request for resource /// Password, can and will be "" on first request for resource /// true for authorized, false for unauthorized public delegate bool AuthenticateWithContext(ServerContext context,string username,string password); /// /// Protect server with password /// public class BasicAuthServer : Server { /// /// Construct server for user authorization /// /// callback for authorization /// server to protect /// realm parameter in WWW-Auhenticate Header public BasicAuthServer(Authenticate auth,IServer inner,string realm="SampleRealm") { Authenticate = auth; InnerServer = inner; Realm = realm; } /// /// Construct server for user authorization (With ServerContext in callback) /// /// callback for authorization /// server to protect /// realm parameter in WWW-Auhenticate Header public BasicAuthServer(AuthenticateWithContext auth,IServer inner,string realm = "SampleRealm") { AuthenticateWithContext=auth; InnerServer=inner; Realm = realm; } public override async Task 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); } /// /// Server to protect /// public IServer InnerServer { get; set; } /// /// Authentication callback without ServerContext /// public Authenticate Authenticate { get; set; } /// /// Authentication callback with ServerContext /// public AuthenticateWithContext AuthenticateWithContext {get;set;} /// /// Realm parameter in WWW-Authenticate header /// public string Realm { get; set; } private bool ValidAuth(ServerContext ctx) { string auth; 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); if(Authenticate != null) return Authenticate(userPass[0], userPass[1]); if(AuthenticateWithContext != null) return AuthenticateWithContext(ctx,userPass[0],userPass[2]); } }else{ if(Authenticate != null) return Authenticate("", ""); if(AuthenticateWithContext != null) return AuthenticateWithContext(ctx,"",""); } return false; } private async Task Authorize(ServerContext ctx) { 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(); } public void Clear() { Servers.Clear(); } public void Remove(string fqdn_or_ip) { Servers.Remove(fqdn_or_ip); } public IServer Default { get; set; } Dictionary Servers; public void AddDomain(string fqdn_or_ip,IServer svr) { Servers.Add(fqdn_or_ip, svr); } public override async Task 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); } } public interface IServer { void AddCors(ServerContext ctx); Task BeforeAsync(ServerContext ctx); Task GetAsync(ServerContext ctx); Task PostAsync(ServerContext ctx); Task OptionsAsync(ServerContext ctx); Task OtherAsync(ServerContext ctx); } public sealed class HttpServerListener { /// /// Print urls when running /// /// true if verbose, false if not public bool PrintUrls {get;set;} bool https; X509Certificate cert; IServer _server; TcpListener _listener; SslProtocols protocols; public HttpServerListener(IPEndPoint endPoint,IServer server) { _listener = new TcpListener(endPoint); _server = server; https = false; PrintUrls=false; } public HttpServerListener(IServer server) { _listener = new TcpListener(new IPEndPoint(IPAddress.Any, 3251)); _server = server; https = false; PrintUrls=false; } public HttpServerListener(IPEndPoint endpoint,IServer server,X509Certificate cert,SslProtocols protocols=SslProtocols.Default) { _listener = new TcpListener(endpoint); _server = server; https = cert != null; this.cert = cert; this.protocols=protocols; PrintUrls=false; } public async Task ListenAsync(CancellationToken token) { _listener.Start(); using (var r = token.Register(() => _listener.Stop())) { while (!token.IsCancellationRequested) { var socket=await _listener.AcceptTcpClientAsync(); await CommunicateHostAsync(socket).ConfigureAwait(false); } } } private string ReadHeaders(Stream strm) { 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> Headers(string s,out string req_line) { Dictionary> items = new Dictionary>(); string[] lines = s.Split(new string[] { "\r\n" }, StringSplitOptions.RemoveEmptyEntries); req_line = lines[0]; for(int i=1;i 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)) { 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]; ctx = new ServerContext(method, strm, path, headers); ctx.Server = clt.Client.LocalEndPoint as IPEndPoint; ctx.Client = clt.Client.RemoteEndPoint 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; } } } } //protected abstract Task Get(string url,Dictionary headers); //protected abstract Task GetAsync(ServerContext ctx); } }