358 lines
12 KiB
C#
358 lines
12 KiB
C#
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;
|
|
|
|
namespace Tesses.WebServer
|
|
{
|
|
public static class Extensions
|
|
{
|
|
const string BYTES_RANGE_HEADER = "Range";
|
|
|
|
private 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);
|
|
}
|
|
public static async Task SendFileAsync(this ServerContext ctx, string file)
|
|
{
|
|
using (var strm = File.OpenRead(file))
|
|
{
|
|
await ctx.SendStreamAsync( strm, MimeTypesMap.GetMimeType(file));
|
|
}
|
|
}
|
|
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);
|
|
}
|
|
public static async Task SendJsonAsync(this ServerContext ctx,object value)
|
|
{
|
|
await ctx.SendTextAsync(JsonConvert.SerializeObject(value), "application/json");
|
|
}
|
|
public static async Task SendTextAsync(this ServerContext ctx, string data, string content_type = "text/html")
|
|
{
|
|
await ctx.SendBytesAsync(Encoding.UTF8.GetBytes(data), content_type);
|
|
}
|
|
public static async Task SendBytesAsync(this ServerContext ctx, byte[] array, string content_type = "application/octet-stream")
|
|
{
|
|
using (var ms = new MemoryStream(array))
|
|
{
|
|
await ctx.SendStreamAsync( ms, content_type);
|
|
}
|
|
}
|
|
public static async Task SendStreamAsync(this ServerContext ctx, Stream strm, string content_type = "application/octet-stream")
|
|
{
|
|
//ctx.StatusCode = 200;
|
|
int start = 0, end = (int)strm.Length - 1;
|
|
if (ctx.RequestHeaders.ContainsKey(BYTES_RANGE_HEADER))
|
|
{
|
|
if (ctx.RequestHeaders[BYTES_RANGE_HEADER].Count > 1)
|
|
{
|
|
throw new NotSupportedException("Multiple 'Range' headers are not supported.");
|
|
}
|
|
var range = ctx.RequestHeaders[BYTES_RANGE_HEADER][0].Replace("bytes=", String.Empty)
|
|
.Split(new string[] { "-" }, StringSplitOptions.RemoveEmptyEntries)
|
|
.Select(x => Int32.Parse(x))
|
|
.ToArray();
|
|
|
|
start = (range.Length > 0) ? range[0] : 0;
|
|
end = (range.Length > 1) ? range[1] : (int)(strm.Length - 1);
|
|
|
|
|
|
var hdrs = ctx.ResponseHeaders;
|
|
hdrs.Add("Accept-Ranges", "bytes");
|
|
hdrs.Add("Content-Range", "bytes " + start + "-" + end + "/" + strm.Length);
|
|
ctx.StatusCode = 206;
|
|
|
|
|
|
}
|
|
ctx.ResponseHeaders.Add("Content-Length", (end - start + 1).ToString());
|
|
ctx.ResponseHeaders.Add("Content-Type", content_type);
|
|
|
|
await WriteHeadersAsync(ctx);
|
|
if (!ctx.Method.Equals("HEAD",StringComparison.Ordinal))
|
|
{
|
|
try
|
|
{
|
|
strm.Position = start;
|
|
strm.CopyTo(ctx.NetworkStream, Math.Min(8 * 1024 * 1024, end - start + 1));
|
|
}
|
|
finally
|
|
{
|
|
strm.Close();
|
|
ctx.NetworkStream.Close();
|
|
}
|
|
}
|
|
}
|
|
|
|
public static T2 GetFirst<T1,T2>(this Dictionary<T1,List<T2>> args,T1 key)
|
|
{
|
|
return args[key][0];
|
|
}
|
|
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);
|
|
}
|
|
}
|
|
|
|
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);
|
|
|
|
}
|
|
}
|
|
|
|
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);
|
|
}
|
|
}
|
|
public class NotFoundServer : Server
|
|
{
|
|
public NotFoundServer(string html)
|
|
{
|
|
_html = html;
|
|
}
|
|
public NotFoundServer()
|
|
{
|
|
_html = "<html><head><title>File {url} not found</title></head><body><h1>404 Not Found</h1><h4>{url}</h4></body></html>";
|
|
}
|
|
string _html;
|
|
public override async Task GetAsync(ServerContext ctx)
|
|
{
|
|
ctx.StatusCode = 404;
|
|
await ctx.SendTextAsync( _html.Replace("{url}", WebUtility.HtmlEncode(ctx.UrlPath)));
|
|
}
|
|
}
|
|
|
|
public class StaticServer : Server
|
|
{
|
|
string _path;
|
|
IServer _server;
|
|
public StaticServer(string path)
|
|
{
|
|
_path = path;
|
|
_server = new NotFoundServer();
|
|
_defaultFileNames = new string[] {"index.html","index.htm","default.html","default.htm" };
|
|
}
|
|
string[] _defaultFileNames;
|
|
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);
|
|
}
|
|
}
|
|
|
|
}
|
|
public abstract class Server : IServer
|
|
{
|
|
public abstract Task GetAsync(ServerContext ctx);
|
|
public virtual async Task PostAsync(ServerContext ctx)
|
|
{
|
|
ctx.StatusCode = (int)HttpStatusCode.MethodNotAllowed;
|
|
await ctx.SendTextAsync("Method Not Supported");
|
|
}
|
|
}
|
|
|
|
public interface IServer
|
|
{
|
|
Task GetAsync(ServerContext ctx);
|
|
Task PostAsync(ServerContext ctx);
|
|
}
|
|
|
|
public sealed class HttpServerListener
|
|
{
|
|
IServer _server;
|
|
TcpListener _listener;
|
|
public HttpServerListener(IPEndPoint endPoint,IServer server)
|
|
{
|
|
_listener = new TcpListener(endPoint);
|
|
_server = server;
|
|
}
|
|
|
|
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);
|
|
}
|
|
}
|
|
}
|
|
|
|
private string ReadHeaders(NetworkStream 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<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;
|
|
}
|
|
private async Task CommunicateHostAsync(TcpClient clt)
|
|
{
|
|
//<METHOD> <PATH> HTTP/1.1\r\n
|
|
//HEADER1\r\n
|
|
//HEADER2\r\n
|
|
//......
|
|
//HEADERN\r\n
|
|
//\r\n
|
|
//OPTIONAL REQUEST BODY
|
|
|
|
//RESPONSE
|
|
|
|
using (NetworkStream strm = clt.GetStream())
|
|
{
|
|
|
|
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
|
|
{
|
|
switch (method)
|
|
{
|
|
case "HEAD":
|
|
case "GET":
|
|
string path = request[1];
|
|
string ver = request[2];
|
|
ctx = new ServerContext(method,strm, path, headers);
|
|
await _server.GetAsync(ctx);
|
|
break;
|
|
case "POST":
|
|
break;
|
|
}
|
|
}catch(Exception ex)
|
|
{
|
|
try
|
|
{
|
|
await ctx.SendExceptionAsync(ex);
|
|
}catch(Exception ex2)
|
|
{
|
|
_ = ex2;
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
//protected abstract Task<IResult> Get(string url,Dictionary<string,string> headers);
|
|
|
|
//protected abstract Task GetAsync(ServerContext ctx);
|
|
}
|
|
}
|