Layout

Libraries/Esiur/Net/Http/EpOverHttp.cs

@@ -0,0 +1,37 @@
+using Esiur.Core;
+using Esiur.Net.Packets;
+using Esiur.Protocol;
+using Esiur.Resource;
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace Esiur.Net.Http;
+public class EpOverHttp : HttpFilter
+{
+    [Attribute]
+    EntryPoint EntryPoint { get; set; }
+
+    public override AsyncReply<bool> Execute(HttpConnection sender)
+    {
+        if (sender.Request.URL != "EP")
+            return new AsyncReply<bool>(false);
+
+        EpPacketRequest action = (EpPacketRequest)Convert.ToByte(sender.Request.Query["a"]);
+
+        if (action == EpPacketRequest.Query)
+        {
+            EntryPoint.Query(sender.Request.Query["l"], null).Then(x =>
+            {
+
+            });
+        }
+
+        return new AsyncReply<bool>(true);
+    }
+
+    public override AsyncReply<bool> Trigger(ResourceTrigger trigger)
+    {
+        return new AsyncReply<bool>(true);
+    }
+}

Libraries/Esiur/Net/Http/EpOvwerWebsocket.cs

@@ -0,0 +1,80 @@
+/*
+ 
+Copyright (c) 2017 Ahmed Kh. Zamil
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+
+
+*/
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using Esiur.Resource;
+using Esiur.Net.Sockets;
+using Esiur.Core;
+using Esiur.Protocol;
+
+namespace Esiur.Net.Http;
+public class EpOvwerWebsocket : HttpFilter
+{
+    [Attribute]
+    public EpServer Server
+    {
+        get;
+        set;
+    }
+
+    public override AsyncReply<bool> Execute(HttpConnection sender)
+    {
+
+        if (sender.IsWebsocketRequest())
+        {
+            if (Server == null)
+                return new AsyncReply<bool>(false);
+
+            var tcpSocket = sender.Unassign();
+
+            if (tcpSocket == null)
+                return new AsyncReply<bool>(false);
+
+            var httpServer = sender.Parent;
+            var wsSocket = new WSocket(tcpSocket);
+            httpServer.Remove(sender);
+
+            var EPConnection = new EpConnection();
+
+            Server.Add(EPConnection);
+            EPConnection.Assign(wsSocket);
+            wsSocket.Begin();
+
+            return new AsyncReply<bool>(true);
+        }
+
+        return new AsyncReply<bool>(false);
+
+    }
+
+    public override AsyncReply<bool> Trigger(ResourceTrigger trigger)
+    {
+        return new AsyncReply<bool>(true);
+    }
+}
+

Libraries/Esiur/Net/Http/HttpConnection.cs

@@ -0,0 +1,452 @@
+/*
+ 
+Copyright (c) 2017 Ahmed Kh. Zamil
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+
+*/
+
+using System;
+using System.Diagnostics;
+using System.IO;
+using System.Net.Sockets;
+using System.Text;
+using System.Threading;
+using System.Net;
+using System.Collections;
+using System.Collections.Generic;
+using Esiur.Net.Sockets;
+using Esiur.Data;
+using Esiur.Misc;
+using System.Security.Cryptography;
+using Esiur.Core;
+using Esiur.Net.Packets.WebSocket;
+using Esiur.Net.Packets.Http;
+
+namespace Esiur.Net.Http;
+public class HttpConnection : NetworkConnection
+{
+
+
+
+    public bool WSMode { get; internal set; }
+    public HttpServer Server { get; internal set; }
+
+    public WebsocketPacket WSRequest { get; set; }
+    public HttpRequestPacket Request { get; set; }
+    public HttpResponsePacket Response { get; } = new HttpResponsePacket();
+
+    HttpSession session;
+
+    public KeyList<string, object> Variables { get; } = new KeyList<string, object>();
+
+
+
+    internal long Parse(byte[] data)
+    {
+        if (WSMode)
+        {
+            // now parse WS protocol
+            WebsocketPacket ws = new WebsocketPacket();
+
+            var pSize = ws.Parse(data, 0, (uint)data.Length);
+
+
+            if (pSize > 0)
+            {
+                WSRequest = ws;
+                return 0;
+            }
+            else
+            {
+                return pSize;
+            }
+        }
+        else
+        {
+            var rp = new HttpRequestPacket();
+            var pSize = rp.Parse(data, 0, (uint)data.Length);
+            if (pSize > 0)
+            {
+                Request = rp;
+                return 0;
+            }
+            else
+            {
+                return pSize;
+            }
+        }
+    }
+
+
+    public void Flush()
+    {
+        // close the connection
+        if (Request.Headers["connection"].ToLower() != "keep-alive" & IsConnected)
+            Close();
+    }
+
+    public bool Upgrade()
+    {
+        var ok = Upgrade(Request, Response);
+
+        if (ok)
+        {
+            WSMode = true;
+            Send();
+        }
+
+        return ok;
+    }
+
+    public static bool Upgrade(HttpRequestPacket request, HttpResponsePacket response)
+    {
+        if (IsWebsocketRequest(request))
+        {
+            string magicString = "258EAFA5-E914-47DA-95CA-C5AB0DC85B11";
+            string ret = request.Headers["Sec-WebSocket-Key"] + magicString;
+            // Compute the SHA1 hash
+            SHA1 sha = SHA1.Create();
+            byte[] sha1Hash = sha.ComputeHash(Encoding.UTF8.GetBytes(ret));
+            response.Headers["Upgrade"] = request.Headers["Upgrade"];
+            response.Headers["Connection"] = request.Headers["Connection"];// "Upgrade";
+            response.Headers["Sec-WebSocket-Accept"] = Convert.ToBase64String(sha1Hash);
+
+            if (request.Headers.ContainsKey("Sec-WebSocket-Protocol"))
+                response.Headers["Sec-WebSocket-Protocol"] = request.Headers["Sec-WebSocket-Protocol"];
+
+
+            response.Number = HttpResponseCode.Switching;
+            response.Text = "Switching Protocols";
+
+            return true;
+        }
+
+        return false;
+    }
+
+    public HttpServer Parent
+    {
+        get
+        {
+            return Server;
+        }
+    }
+
+    public void Send(WebsocketPacket packet)
+    {
+        if (packet.Data != null)
+            base.Send(packet.Data);
+    }
+
+    public override void Send(string data)
+    {
+        Response.Message = Encoding.UTF8.GetBytes(data);
+        Send();
+    }
+
+    public override void Send(byte[] msg, int offset, int length)
+    {
+        Response.Message = DC.Clip(msg, (uint)offset, (uint)length);
+        Send();
+    }
+
+    public override void Send(byte[] message)
+    {
+        Response.Message = message;
+        Send();
+    }
+
+    public void Send(HttpComposeOption Options = HttpComposeOption.AllCalculateLength)
+    {
+        if (Response.Handled)
+            return;
+
+
+        try
+        {
+            Response.Compose(Options);
+            base.Send(Response.Data);
+
+            // Refresh the current session
+            if (session != null)
+                session.Refresh();
+
+        }
+        catch
+        {
+            try
+            {
+                Close();
+            }
+            finally { }
+        }
+        finally
+        {
+
+        }
+    }
+
+
+    public void CreateNewSession()
+    {
+        if (session == null)
+        {
+            // Create a new one
+            session = Server.CreateSession(Global.GenerateCode(12), 60 * 20);
+
+            HttpCookie cookie = new HttpCookie("SID", session.Id);
+            cookie.Expires = DateTime.MaxValue;
+            cookie.Path = "/";
+            cookie.HttpOnly = true;
+
+            Response.Cookies.Add(cookie);
+        }
+    }
+
+
+    public bool IsWebsocketRequest()
+    {
+        return IsWebsocketRequest(this.Request);
+    }
+
+    public static bool IsWebsocketRequest(HttpRequestPacket request)
+    {
+        if (request.Headers.ContainsKey("connection")
+            && request.Headers["connection"].ToLower().Contains("upgrade")
+            && request.Headers.ContainsKey("upgrade")
+            && request.Headers["upgrade"].ToLower() == "websocket"
+            && request.Headers.ContainsKey("Sec-WebSocket-Version")
+            && request.Headers["Sec-WebSocket-Version"] == "13"
+            && request.Headers.ContainsKey("Sec-WebSocket-Key"))
+        //&& Request.Headers.ContainsKey("Sec-WebSocket-Protocol"))
+        {
+            return true;
+        }
+        else
+        {
+            return false;
+        }
+    }
+
+    protected override void DataReceived(NetworkBuffer data)
+    {
+
+        byte[] msg = data.Read();
+
+        var BL = Parse(msg);
+
+        if (BL == 0)
+        {
+            if (Request.Method == Packets.Http.HttpMethod.UNKNOWN)
+            {
+                Close();
+                return;
+            }
+            if (Request.URL == "")
+            {
+                Close();
+                return;
+            }
+        }
+        else if (BL == -1)
+        {
+            data.HoldForNextWrite(msg);
+            return;
+        }
+        else if (BL < 0)
+        {
+            data.HoldFor(msg, (uint)(msg.Length - BL));
+            return;
+        }
+        else if (BL > 0)
+        {
+            if (BL > Server.MaxPost)
+            {
+                Send(
+                    "<html><body>POST method content is larger than "
+                    + Server.MaxPost
+                    + " bytes.</body></html>");
+
+                Close();
+            }
+            else
+            {
+                data.HoldFor(msg, (uint)(msg.Length + BL));
+            }
+            return;
+        }
+        else if (BL < 0) // for security
+        {
+            Close();
+            return;
+        }
+
+
+
+        if (IsWebsocketRequest(Request) & !WSMode)
+        {
+            Upgrade();
+            //return;
+        }
+
+
+        //return;
+
+        try
+        {
+            if (!Server.Execute(this))
+            {
+                Response.Number = HttpResponseCode.InternalServerError;
+                Send("Bad Request");
+                Close();
+            }
+        }
+        catch (Exception ex)
+        {
+            if (ex.Message != "Thread was being aborted.")
+            {
+
+                Global.Log("HTTPServer", LogType.Error, ex.ToString());
+
+                //Console.WriteLine(ex.ToString());
+                //EventLog.WriteEntry("HttpServer", ex.ToString(), EventLogEntryType.Error);
+                Send(Error500(ex.Message));
+            }
+
+        }
+    }
+
+    private string Error500(string msg)
+    {
+        return "<html><head><title>500 Internal Server Error</title></head><br>\r\n"
+                 + "<body><br>\r\n"
+                 + "<b>500</b> Internal Server Error<br>" + msg + "\r\n"
+                 + "</body><br>\r\n"
+                 + "</html><br>\r\n";
+    }
+
+    public async AsyncReply<bool> SendFile(string filename)
+    {
+        if (Response.Handled == true)
+            return false;
+
+
+        try
+        {
+
+            //HTTP/1.1 200 OK
+            //Server: Microsoft-IIS/5.0
+            //Content-Location: http://127.0.0.1/index.html
+            //Date: Wed, 10 Dec 2003 19:10:25 GMT
+            //Content-Type: text/html
+            //Accept-Ranges: bytes
+            //Last-Modified: Mon, 22 Sep 2003 22:36:56 GMT
+            //Content-Length: 1957
+
+            if (!File.Exists(filename))
+            {
+                Response.Number = HttpResponseCode.NotFound;
+                Send("File Not Found");
+                return true;
+            }
+
+
+            var fileEditTime = File.GetLastWriteTime(filename).ToUniversalTime();
+            if (Request.Headers.ContainsKey("if-modified-since"))
+            {
+                try
+                {
+                    var ims = DateTime.Parse(Request.Headers["if-modified-since"]);
+                    if ((fileEditTime - ims).TotalSeconds < 2)
+                    {
+                        Response.Number = HttpResponseCode.NotModified;
+                        Response.Headers.Clear();
+                        //Response.Text = "Not Modified";
+                        Send(HttpComposeOption.SpecifiedHeadersOnly);
+                        return true;
+                    }
+                }
+                catch
+                {
+                    return false;
+                }
+            }
+
+
+
+            Response.Number = HttpResponseCode.OK;
+            // Fri, 30 Oct 2007 14:19:41 GMT
+            Response.Headers["Last-Modified"] = fileEditTime.ToString("ddd, dd MMM yyyy HH:mm:ss");
+            FileInfo fi = new FileInfo(filename);
+            Response.Headers["Content-Length"] = fi.Length.ToString();
+            Send(HttpComposeOption.SpecifiedHeadersOnly);
+
+            //var fd = File.ReadAllBytes(filename);
+
+            //base.Send(fd);
+
+
+            using (var fs = new FileStream(filename, FileMode.Open, FileAccess.Read, FileShare.Read))
+            {
+
+                var buffer = new byte[60000];
+
+
+                while (true)
+                {
+                    var n = fs.Read(buffer, 0, 60000);
+
+                    if (n <= 0)
+                        break;
+
+                    //Thread.Sleep(50);
+                    await base.SendAsync(buffer, 0, n);
+
+                }
+            }
+
+            return true;
+
+        }
+        catch
+        {
+            try
+            {
+                Close();
+            }
+            finally
+            {
+
+            }
+
+            return false;
+        }
+    }
+
+    protected override void Connected()
+    {
+        // do nothing
+    }
+
+    protected override void Disconnected()
+    {
+        // do nothing
+    }
+}

Libraries/Esiur/Net/Http/HttpFilter.cs

@@ -0,0 +1,79 @@
+/*
+ 
+Copyright (c) 2017 Ahmed Kh. Zamil
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+
+*/
+
+using System;
+using System.Diagnostics;
+using System.IO;
+using System.Net.Sockets;
+using System.Text;
+using System.Threading;
+using System.Net;
+using System.Collections;
+using System.Collections.Generic;
+using Esiur.Data;
+using Esiur.Core;
+using Esiur.Resource;
+
+namespace Esiur.Net.Http;
+
+public abstract class HttpFilter : IResource
+{
+    public Instance Instance
+    {
+        get;
+        set;
+    }
+
+    public event DestroyedEvent OnDestroy;
+    public abstract AsyncReply<bool> Trigger(ResourceTrigger trigger);
+
+    /*
+    public virtual void SessionModified(HTTPSession session, string key, object oldValue, object newValue)
+    {
+
+    }
+
+    public virtual void SessionExpired(HTTPSession session)
+    {
+
+    }
+    */
+
+    public abstract AsyncReply<bool> Execute(HttpConnection sender);
+
+    public virtual void ClientConnected(HttpConnection HTTP)
+    {
+        //return false;
+    }
+
+    public virtual void ClientDisconnected(HttpConnection HTTP)
+    {
+        //return false;
+    }
+
+    public void Destroy()
+    {
+        OnDestroy?.Invoke(this);
+    }
+}

Libraries/Esiur/Net/Http/HttpServer.cs

@@ -0,0 +1,394 @@
+/*
+ 
+Copyright (c) 2017 Ahmed Kh. Zamil
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+
+*/
+
+using System;
+using System.Diagnostics;
+using System.IO;
+using System.Net.Sockets;
+using System.Text;
+using System.Threading;
+using System.Net;
+using System.Collections;
+using System.Collections.Generic;
+using Esiur.Net.Sockets;
+using Esiur.Data;
+using Esiur.Misc;
+using Esiur.Core;
+using System.Security.Cryptography.X509Certificates;
+using Esiur.Resource;
+using System.Text.RegularExpressions;
+using System.Linq;
+using System.Reflection;
+using Esiur.Net.Packets.Http;
+
+namespace Esiur.Net.Http;
+public class HttpServer : NetworkServer<HttpConnection>, IResource
+{
+    Dictionary<string, HttpSession> sessions = new Dictionary<string, HttpSession>();
+    HttpFilter[] filters = new HttpFilter[0];
+
+    Dictionary<Packets.Http.HttpMethod, List<RouteInfo>> routes = new()
+    {
+        [Packets.Http.HttpMethod.GET] = new List<RouteInfo>(),
+        [Packets.Http.HttpMethod.POST] = new List<RouteInfo>(),
+        [Packets.Http.HttpMethod.HEAD] = new List<RouteInfo>(),
+        [Packets.Http.HttpMethod.OPTIONS] = new List<RouteInfo>(),
+        [Packets.Http.HttpMethod.UNKNOWN] = new List<RouteInfo>(),
+        [Packets.Http.HttpMethod.DELETE] = new List<RouteInfo>(),
+        [Packets.Http.HttpMethod.TRACE] = new List<RouteInfo>(),
+        [Packets.Http.HttpMethod.CONNECT] = new List<RouteInfo>(),
+        [Packets.Http.HttpMethod.PUT] = new List<RouteInfo>()
+    };
+
+    //List<RouteInfo> GetRoutes = new List<RouteInfo>();
+    //List<RouteInfo> PostRoutes = new List<RouteInfo>();
+
+
+    class RouteInfo
+    {
+        public Delegate Handler;
+        public Regex Pattern;
+        Dictionary<string, ParameterInfo> ParameterIndex = new();
+        int? SenderIndex;
+        //bool HasSender;
+        int ArgumentsCount;
+
+        public RouteInfo(Delegate handler, Regex pattern)
+        {
+
+            Pattern = pattern;
+            Handler = handler;
+
+            var ps = handler.Method.GetParameters();
+
+            ArgumentsCount = ps.Length;
+
+            var last = ps.LastOrDefault();
+
+            if (last != null && last.ParameterType == typeof(HttpConnection))
+            {
+
+                SenderIndex = ps.Length - 1;
+                for (var i = 0; i < ps.Length - 1; i++)
+                    ParameterIndex[ps[i].Name] = ps[i];
+            }
+            else
+            {
+                for (var i = 0; i < ps.Length; i++)
+                    ParameterIndex[ps[i].Name] = ps[i];
+            }
+        }
+
+
+        public bool Invoke(HttpConnection sender)
+        {
+            var match = Pattern.Match(sender.Request.URL);
+
+            if (!match.Success)
+                return false;
+
+            var args = new object[ArgumentsCount];
+
+            foreach (var kv in ParameterIndex)
+            {
+                var g = match.Groups[kv.Key];
+                args[kv.Value.Position] = RuntimeCaster.Cast(g.Value, kv.Value.ParameterType);
+            }
+
+            if (SenderIndex != null)
+                args[(int)SenderIndex] = sender;
+
+            var rt = Handler.DynamicInvoke(args);
+
+            if (rt is bool)
+                return (bool)rt;
+
+            return true;
+        }
+    }
+
+
+
+
+
+
+    public Instance Instance
+    {
+        get;
+        set;
+    }
+
+    [Attribute]
+    public virtual string IP
+    {
+        get;
+        set;
+    }
+
+    [Attribute]
+    public virtual ushort Port
+    {
+        get;
+        set;
+    }
+
+ 
+    [Attribute]
+    public virtual uint MaxPost
+    {
+        get;
+        set;
+    }
+
+    [Attribute]
+    public virtual bool SSL
+    {
+        get;
+        set;
+    }
+
+    [Attribute]
+    public virtual string Certificate
+    {
+        get;
+        set;
+    }
+
+
+    public HttpSession CreateSession(string id, int timeout)
+    {
+        var s = new HttpSession();
+
+        s.Set(id, timeout);
+
+
+        sessions.Add(id, s);
+
+        return s;
+    }
+
+    public static string MakeCookie(string Item, string Value, DateTime Expires, string Domain, string Path, bool HttpOnly)
+    {
+
+        //Set-Cookie: ckGeneric=CookieBody; expires=Sun, 30-Dec-2001 21:00:00 GMT; domain=.com.au; path=/
+        //Set-Cookie: SessionID=another; expires=Fri, 29 Jun 2006 20:47:11 UTC; path=/
+        string Cookie = Item + "=" + Value;
+
+        if (Expires.Ticks != 0)
+        {
+            Cookie += "; expires=" + Expires.ToUniversalTime().ToString("ddd, dd MMM yyyy HH:mm:ss") + " GMT";
+        }
+        if (Domain != null)
+        {
+            Cookie += "; domain=" + Domain;
+        }
+        if (Path != null)
+        {
+            Cookie += "; path=" + Path;
+        }
+        if (HttpOnly)
+        {
+            Cookie += "; HttpOnly";
+        }
+        return Cookie;
+    }
+
+    protected override void ClientDisconnected(HttpConnection connection)
+    {
+        foreach (var filter in filters)
+            filter.ClientDisconnected(connection);
+    }
+
+
+
+    internal bool Execute(HttpConnection sender)
+    {
+        if (!sender.WSMode)
+            foreach (var route in routes[sender.Request.Method])
+                if (route.Invoke(sender))
+                    return true;
+
+
+        foreach (var resource in filters)
+            if (resource.Execute(sender).Wait(30000))
+                return true;
+
+
+
+        return false;
+    }
+
+    
+    public void MapGet(string pattern, Delegate handler)
+    {
+        var regex = Global.GetRouteRegex(pattern);
+        var list = routes[Packets.Http.HttpMethod.GET];
+        list.Add(new RouteInfo(handler, regex));
+    }
+
+    public void MapPost(string pattern, Delegate handler)
+    {
+        var regex = Global.GetRouteRegex(pattern);
+        var list = routes[Packets.Http.HttpMethod.POST];
+        list.Add(new RouteInfo(handler, regex));
+    }
+
+    /*
+    protected override void SessionEnded(NetworkSession session)
+    {
+        // verify wether there are no active connections related to the session
+
+        foreach (HTTPConnection c in Connections)//.Values)
+        {
+            if (c.Session == session)
+            {
+                session.Refresh();
+                return;
+            }
+        }
+
+        foreach (Instance instance in Instance.Children)
+        {
+            var f = (HTTPFilter)instance.Resource;
+            f.SessionExpired((HTTPSession)session);
+        }
+
+        base.SessionEnded((HTTPSession)session);
+        //Sessions.Remove(Session.ID);
+        //Session.Dispose();
+    }
+    */
+
+    /*
+    public int TTL
+    {
+        get
+        {
+            return Timeout;// mTimeout;
+        }
+    }
+     */
+
+
+    public async AsyncReply<bool> Trigger(ResourceTrigger trigger)
+    {
+
+        if (trigger == ResourceTrigger.Initialize)
+        {
+            //var ip = (IPAddress)Instance.Attributes["ip"];
+            //var port = (int)Instance.Attributes["port"];
+            //var ssl = (bool)Instance.Attributes["ssl"];
+            //var cert = (string)Instance.Attributes["certificate"];
+
+            //if (ip == null) ip = IPAddress.Any;
+
+            Sockets.ISocket listener;
+            IPAddress ipAdd;
+
+            if (IP == null)
+                ipAdd = IPAddress.Any;
+            else
+                ipAdd = IPAddress.Parse(IP);
+
+            if (SSL)
+                listener = new SSLSocket(new IPEndPoint(ipAdd, Port), new X509Certificate2(Certificate));
+            else
+                listener = new TCPSocket(new IPEndPoint(ipAdd, Port));
+
+            Start(listener);
+        }
+        else if (trigger == ResourceTrigger.Terminate)
+        {
+            Stop();
+        }
+        else if (trigger == ResourceTrigger.SystemReload)
+        {
+            await Trigger(ResourceTrigger.Terminate);
+            await Trigger(ResourceTrigger.Initialize);
+        }
+        else if (trigger == ResourceTrigger.SystemInitialized)
+        {
+            filters = await Instance.Children<HttpFilter>();
+        }
+
+        return true;
+
+    }
+
+
+    public override void Add(HttpConnection connection)
+    {
+        connection.Server = this;
+        base.Add(connection);
+    }
+
+    public override void Remove(HttpConnection connection)
+    {
+        connection.Server = null;
+        base.Remove(connection);
+    }
+
+    protected override void ClientConnected(HttpConnection connection)
+    {
+        //if (filters.Length == 0 && routes.)
+        //{
+        //    connection.Close();
+        //    return;
+        //}
+
+        foreach (var resource in filters)
+        {
+            resource.ClientConnected(connection);
+        }
+    }
+
+
+    /*
+    public int LocalPort
+    {
+        get 
+        {
+            return cServer.LocalPort;
+        }
+    }
+     */
+
+    /* 
+    public HTTPServer(int Port)
+    {
+        cServer = new TServer();
+        cServer.LocalPort = Port;
+        cServer.StartServer();
+        cServer.ClientConnected += new TServer.eClientConnected(ClientConnected);
+        cServer.ClientDisConnected += new TServer.eClientDisConnected(ClientDisConnected);
+        cServer.ClientIsSwitching += new TServer.eClientIsSwitching(ClientIsSwitching);
+        cServer.DataReceived += new TServer.eDataReceived(DataReceived);
+
+    }*/
+
+    //~HTTPServer()
+    //{
+    //    cServer.StopServer();
+    //}
+}

Libraries/Esiur/Net/Http/HttpSession.cs

@@ -0,0 +1,128 @@
+/*
+ 
+Copyright (c) 2017 Ahmed Kh. Zamil
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+
+*/
+
+using System;
+using System.Diagnostics;
+using System.IO;
+using System.Net.Sockets;
+using System.Text;
+using System.Threading;
+using System.Net;
+using System.Collections;
+using System.Collections.Generic;
+using Esiur.Data;
+using Esiur.Misc;
+using Esiur.Core;
+
+namespace Esiur.Net.Http;
+public class HttpSession : IDestructible //<T> where T : TClient
+{
+    public delegate void SessionModifiedEvent(HttpSession session, string key, object oldValue, object newValue);
+    public delegate void SessionEndedEvent(HttpSession session);
+
+    private string id;
+    private Timer timer;
+    private int timeout;
+    DateTime creation;
+    DateTime lastAction;
+
+    private KeyList<string, object> variables;
+
+    public event SessionEndedEvent OnEnd;
+    public event SessionModifiedEvent OnModify;
+    public event DestroyedEvent OnDestroy;
+
+    public KeyList<string, object> Variables
+    {
+        get { return variables; }
+    }
+
+    public HttpSession()
+    {
+        variables = new KeyList<string, object>();
+        variables.OnModified += new KeyList<string, object>.Modified(VariablesModified);
+        creation = DateTime.Now;
+    }
+
+    internal void Set(string id, int timeout)
+    {
+        //modified = sessionModifiedEvent;
+        //ended = sessionEndEvent;
+        this.id = id;
+
+        if (this.timeout != 0)
+        {
+            this.timeout = timeout;
+            timer = new Timer(OnSessionEndTimerCallback, null, TimeSpan.FromSeconds(timeout), TimeSpan.FromSeconds(0));
+            creation = DateTime.Now;
+        }
+    }
+
+    private void OnSessionEndTimerCallback(object o)
+    {
+        OnEnd?.Invoke(this);
+    }
+
+    void VariablesModified(string key, object oldValue, object newValue, KeyList<string, object> sender)
+    {
+        OnModify?.Invoke(this, key, oldValue, newValue);
+    }
+
+    public void Destroy()
+    {
+        OnDestroy?.Invoke(this);
+        timer.Dispose();
+        timer = null;
+    }
+
+    internal void Refresh()
+    {
+        lastAction = DateTime.Now;
+        timer.Change(TimeSpan.FromSeconds(timeout), TimeSpan.FromSeconds(0));
+    }
+
+    public int Timeout // Seconds
+    {
+        get
+        {
+            return timeout;
+        }
+        set
+        {
+            timeout = value;
+            Refresh();
+        }
+    }
+
+    public string Id
+    {
+        get { return id; }
+    }
+
+    public DateTime LastAction
+    {
+        get { return lastAction; }
+    }
+}
+