Rename

Esiur/Net/DataLink/PacketFilter.cs

@@ -0,0 +1,56 @@
+/*
+ 
+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 Esiur.Core;
+using Esiur.Data;
+using Esiur.Net.Packets;
+using Esiur.Resource;
+
+namespace Esiur.Net.DataLink
+{
+    public abstract class PacketFilter : IResource
+    {
+
+        public Instance Instance
+        {
+            get;
+            set;
+        }
+
+        public event DestroyedEvent OnDestroy;
+
+        public abstract AsyncReply<bool> Trigger(ResourceTrigger trigger);
+
+        public abstract bool Execute(Packet packet);
+
+        public void Destroy()
+        {
+
+        }
+    }
+}

Esiur/Net/DataLink/PacketServer.cs

@@ -0,0 +1,123 @@
+/*
+ 
+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 Esiur.Core;
+using Esiur.Data;
+using System.Runtime.InteropServices;
+using Esiur.Net.Packets;
+using Esiur.Resource;
+
+namespace Esiur.Net.DataLink
+{
+    public class PacketServer:IResource
+    {
+        List<PacketSource> sources = new List<PacketSource>();
+        List<PacketFilter> filters = new List<PacketFilter>();
+
+        
+        [Storable]
+        public string Mode
+        {
+            get;
+            set;
+        }
+
+        public Instance Instance
+        {
+            get;
+            set;
+        }
+
+        public List<PacketSource> Sources
+        {
+            get
+            {
+                return sources;
+            }
+        }
+
+        public event DestroyedEvent OnDestroy;
+
+        public void Destroy()
+        {
+            throw new NotImplementedException();
+        }
+
+        public AsyncReply<bool> Trigger(ResourceTrigger trigger)
+        {
+            if (trigger == ResourceTrigger.Initialize)
+            {
+                /*
+                foreach (var resource in Instance.Children<IResource>())
+                {
+
+                    if (resource is PacketFilter)
+                    {
+                        filters.Add(resource as PacketFilter);
+                    }
+                    else if (resource is PacketSource)
+                    {
+                        sources.Add(resource as PacketSource);
+                    }
+                }
+                */
+                foreach (var src in sources)
+                {
+                    src.OnNewPacket += PacketReceived;
+                    src.Open();
+                }
+            }
+            else if (trigger == ResourceTrigger.Terminate)
+            {
+    //            foreach (var src in sources)
+      //              src.Close();
+            }
+            else if (trigger == ResourceTrigger.SystemReload)
+            {
+                foreach (var src in sources)
+                {
+                    src.Close();
+                    src.Open();
+                }
+            }
+
+            return new AsyncReply<bool>( true);
+        }        
+
+        void PacketReceived(Packet Packet)
+        {
+            foreach (var f in filters)
+            {                
+                if (f.Execute(Packet))
+                {
+                    break;
+                }
+            }
+        }
+    }
+}

Esiur/Net/DataLink/PacketSource.cs

@@ -0,0 +1,95 @@
+/*
+ 
+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 Esiur.Net.Packets;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using Esiur.Core;
+using Esiur.Resource;
+
+namespace Esiur.Net.DataLink
+{
+    public abstract class PacketSource: IResource
+    {
+        public delegate void NewPacket(Packet Packet);
+        public abstract event NewPacket OnNewPacket;
+        public event DestroyedEvent OnDestroy;
+
+        public Instance Instance
+        {
+            get;
+            set;
+        }
+
+
+        public abstract AsyncReply<bool> Trigger(ResourceTrigger trigger);
+
+
+        public abstract bool RawMode
+        {
+            set;
+            get;
+        }
+
+        //public PacketSource(PacketServer Server, bool RawMode)
+        //{
+        //  this.RawMode = RawMode;
+        //}
+
+
+        public abstract bool Open();
+
+        public abstract bool Close();
+
+
+        public abstract bool Write(Packet packet);
+
+        public void Destroy()
+        {
+            throw new NotImplementedException();
+        }
+
+        /*
+        public virtual string TypeName
+        {
+            get
+            {
+                return "Raw";
+            }
+        }
+        */
+
+        public abstract byte[] Address
+        {
+            get;
+        }
+
+        public abstract string DeviceId
+        {
+            get;
+        }
+    }
+}

Esiur/Net/HTTP/HTTPConnection.cs

@@ -0,0 +1,437 @@
+/*
+ 
+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.Net.Packets;
+using Esiur.Misc;
+using System.Security.Cryptography;
+using Esiur.Core;
+
+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()
+        {
+            if (IsWebsocketRequest())
+            {
+                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 = HTTPResponsePacket.ResponseCode.Switching;
+                Response.Text = "Switching Protocols";
+                WSMode = true;
+
+                Send();
+
+                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(HTTPResponsePacket.ComposeOptions Options = HTTPResponsePacket.ComposeOptions.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);
+
+                HTTPResponsePacket.HTTPCookie cookie = new HTTPResponsePacket.HTTPCookie("SID", session.Id);
+                cookie.Expires = DateTime.MaxValue;
+                cookie.Path = "/";
+                cookie.HttpOnly = true;
+
+                Response.Cookies.Add(cookie);
+            }
+        }
+
+
+        public bool IsWebsocketRequest()
+        {
+            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 == HTTPRequestPacket.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() & !WSMode)
+            {
+                Upgrade();
+                //return;
+            }
+
+
+            //return;
+
+            try
+            {
+                if (!Server.Execute(this))
+                {
+                    Response.Number = HTTPResponsePacket.ResponseCode.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 = HTTPResponsePacket.ResponseCode.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 = HTTPResponsePacket.ResponseCode.NotModified;
+                            Response.Headers.Clear();
+                            //Response.Text = "Not Modified";
+                            Send(HTTPResponsePacket.ComposeOptions.SpecifiedHeadersOnly);
+                            return true;
+                        }
+                    }
+                    catch
+                    {
+                        return false;
+                    }
+                }
+
+
+
+                Response.Number = HTTPResponsePacket.ResponseCode.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(HTTPResponsePacket.ComposeOptions.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 Disconencted()
+        {
+            // do nothing
+        }
+    }
+}

Esiur/Net/HTTP/HTTPFilter.cs

@@ -0,0 +1,82 @@
+/*
+ 
+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()
+        {
+            throw new NotImplementedException();
+        }
+    }
+}

Esiur/Net/HTTP/HTTPServer.cs

@@ -0,0 +1,300 @@
+/*
+ 
+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 Esiur.Net.Packets;
+using System.Security.Cryptography.X509Certificates;
+using Esiur.Resource;
+
+namespace Esiur.Net.HTTP
+{
+    public class HTTPServer : NetworkServer<HTTPConnection>, IResource
+    {
+        Dictionary<string, HTTPSession> sessions= new Dictionary<string, HTTPSession>();
+        HTTPFilter[] filters = new HTTPFilter[0];
+
+        public Instance Instance
+        {
+            get;
+            set;
+        }
+
+        [Attribute]
+        public virtual string IP
+        {
+            get;
+            set;
+        }
+
+        [Attribute]
+        public virtual ushort Port
+        {
+            get;
+            set;
+        }
+
+        //[Attribute]
+        //public virtual uint Timeout
+        //{
+        //    get;
+        //    set;
+        //}
+
+        //[Attribute]
+        //public virtual uint Clock
+        //{
+        //    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)
+        {
+            foreach (var resource in filters)
+                if (resource.Execute(sender).Wait(30000))
+                    return true;
+            return false;
+        }
+
+
+
+
+        /*
+        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)
+            {
+                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();
+        //}
+    }
+}

Esiur/Net/HTTP/HTTPSession.cs

@@ -0,0 +1,130 @@
+/*
+ 
+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; }
+        }
+    }
+
+}

Esiur/Net/HTTP/IIPoHTTP.cs

@@ -0,0 +1,39 @@
+using Esiur.Core;
+using Esiur.Net.IIP;
+using Esiur.Net.Packets;
+using Esiur.Resource;
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace Esiur.Net.HTTP
+{
+    public class IIPoHTTP : HTTPFilter
+    {
+        [Attribute]
+        EntryPoint EntryPoint { get; set; }
+
+        public override AsyncReply<bool> Execute(HTTPConnection sender)
+        {
+            if (sender.Request.URL != "iip")
+                return new AsyncReply<bool>(false);
+
+            IIPPacket.IIPPacketAction action = (IIPPacket.IIPPacketAction)Convert.ToByte(sender.Request.Query["a"]);
+
+            if (action == IIPPacket.IIPPacketAction.QueryLink)
+            {
+                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);
+        }
+    }
+}

Esiur/Net/HTTP/IIPoWS.cs

@@ -0,0 +1,125 @@
+/*
+ 
+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.IIP;
+using Esiur.Net.Sockets;
+using Esiur.Core;
+
+namespace Esiur.Net.HTTP
+{
+    public class IIPoWS: HTTPFilter
+    {
+        [Attribute]
+        public DistributedServer 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 WSSocket(tcpSocket);
+                httpServer.Remove(sender);
+
+                var iipConnection = new DistributedConnection();
+
+                Server.Add(iipConnection);
+                iipConnection.Assign(wsSocket);
+                wsSocket.Begin();
+
+                return new AsyncReply<bool>(true);
+            }
+
+            return new AsyncReply<bool>( false);
+
+            /*
+            if (sender.Request.Filename.StartsWith("/iip/"))
+            {
+                // find the service
+                var path = sender.Request.Filename.Substring(5);// sender.Request.Query["path"];
+
+
+                Warehouse.Get(path).Then((r) =>
+                {
+                    if (r is DistributedServer)
+                    {
+                        var httpServer = sender.Parent;
+                        var iipServer = r as DistributedServer;
+                        var tcpSocket = sender.Unassign();
+                        if (tcpSocket == null)
+                            return;
+
+                        var wsSocket = new WSSocket(tcpSocket);
+                        httpServer.RemoveConnection(sender);
+
+                        //httpServer.Connections.Remove(sender);
+                        var iipConnection = new DistributedConnection();
+  //                      iipConnection.OnReady += IipConnection_OnReady;
+//                        iipConnection.Server = iipServer;
+    //                    iipConnection.Assign(wsSocket);
+
+                        iipServer.AddConnection(iipConnection);
+                        iipConnection.Assign(wsSocket);
+                        wsSocket.Begin();
+                    }
+                });
+
+                return true;
+            }
+
+            return false;
+            */
+        }
+
+        private void IipConnection_OnReady(DistributedConnection sender)
+        {
+            Warehouse.Put(sender, sender.RemoteUsername, null, sender.Server);
+        }
+
+        public override AsyncReply<bool> Trigger(ResourceTrigger trigger)
+        {
+            return new AsyncReply<bool>(true);
+        }
+    }
+    
+}
+ 

Esiur/Net/IIP/DistributedPropertyContext.cs

@@ -0,0 +1,27 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace Esiur.Net.IIP
+{
+    public class DistributedPropertyContext
+    {
+        public object Value { get; private set; }
+        public DistributedConnection Connection { get; private set; }
+        public Func<DistributedConnection, object> Method { get; private set; }
+
+        public DistributedPropertyContext(DistributedConnection connection, object value)
+        {
+            this.Value = value;
+            this.Connection = connection;
+        }
+
+        public DistributedPropertyContext(Func<DistributedConnection, object> method)
+        {
+            this.Method = method;
+        }
+
+        public static implicit operator DistributedPropertyContext(Func<DistributedConnection, object> method)
+                                        => new DistributedPropertyContext(method);
+    }
+}

Esiur/Net/IIP/DistributedResource.cs

@@ -0,0 +1,464 @@
+/*
+ 
+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.Text;
+using System.Reflection;
+using System.IO;
+using System.Collections;
+using System.ComponentModel;
+using Esiur.Misc;
+using Esiur.Data;
+using System.Dynamic;
+using System.Security.Cryptography;
+using Esiur.Core;
+using System.Runtime.CompilerServices;
+using System.Reflection.Emit;
+using System.Linq;
+using System.Linq.Expressions;
+using System.Threading.Tasks;
+using Esiur.Resource;
+using Esiur.Resource.Template;
+
+namespace Esiur.Net.IIP
+{
+    
+    //[System.Runtime.InteropServices.ComVisible(true)]
+    public class DistributedResource : DynamicObject, IResource
+    {
+
+        /// <summary>
+        /// Raised when the distributed resource is destroyed.
+        /// </summary>
+        public event DestroyedEvent OnDestroy;
+        public event Instance.ResourceModifiedEvent OnModified;
+        uint instanceId;
+        DistributedConnection connection;
+
+
+        bool attached = false;
+        bool destroyed = false;
+        bool suspended = false;
+
+        //Structure properties = new Structure();
+
+        string link;
+        //ulong age;
+        //ulong[] ages;
+        object[] properties;
+        internal List<DistributedResource> parents = new List<DistributedResource>();
+        internal List<DistributedResource> children = new List<DistributedResource>();
+
+        DistributedResourceEvent[] events;
+
+        
+
+        /// <summary>
+        /// Resource template for the remotely located resource.
+        /// </summary>
+        //public ResourceTemplate Template
+        //{
+        //    get { return template; }
+        //}
+
+
+        /// <summary>
+        /// Connection responsible for the distributed resource.
+        /// </summary>
+        public DistributedConnection Connection
+        {
+            get { return connection; }
+        }
+
+        /// <summary>
+        /// Resource link
+        /// </summary>
+        public string Link
+        {
+            get { return link; }
+        }
+
+        /// <summary>
+        /// Instance Id given by the other end.
+        /// </summary>
+        public uint Id
+        {
+            get {  return instanceId; }
+        }
+
+        /// <summary>
+        /// IDestructible interface.
+        /// </summary>
+        public void Destroy()
+        {
+            destroyed = true;
+            attached = false;
+            connection.SendDetachRequest(instanceId);
+            OnDestroy?.Invoke(this);
+        }
+
+        /// <summary>
+        /// Suspend resource
+        /// </summary>
+
+        internal void Suspend()
+        {
+            suspended = true;
+            attached = false;
+        }
+
+
+        /// <summary>
+        /// Resource is attached when all its properties are received.
+        /// </summary>
+        internal bool Attached => attached;
+
+        internal bool Suspended => suspended;
+    
+
+       // public DistributedResourceStack Stack
+        //{
+       //     get { return stack; }
+        //}
+
+            /// <summary>
+            /// Create a new distributed resource.
+            /// </summary>
+            /// <param name="connection">Connection responsible for the distributed resource.</param>
+            /// <param name="template">Resource template.</param>
+            /// <param name="instanceId">Instance Id given by the other end.</param>
+            /// <param name="age">Resource age.</param>
+        public DistributedResource(DistributedConnection connection, uint instanceId, ulong age, string link)
+        {
+            this.link = link;
+            this.connection = connection;
+            this.instanceId = instanceId;
+
+            //this.Instance.Template = template;
+            //this.Instance.Age = age;
+            //this.template = template;
+            //this.age = age;
+
+        }
+
+        /// <summary>
+        /// Export all properties with ResourceProperty attributed as bytes array.
+        /// </summary>
+        /// <returns></returns>
+        internal PropertyValue[] _Serialize()
+        {
+
+            var props = new PropertyValue[properties.Length];
+
+
+            for (byte i = 0; i < properties.Length; i++)
+                props[i] = new PropertyValue(properties[i], Instance.GetAge(i), Instance.GetModificationDate(i));
+
+            return props;
+        }
+
+        internal bool _Attach(PropertyValue[] properties)
+        {
+            if (attached)
+                return false;
+            else
+            {
+                suspended = false;
+
+                this.properties = new object[properties.Length];
+
+                this.events = new DistributedResourceEvent[Instance.Template.Events.Length];
+
+                for (byte i = 0; i < properties.Length; i++)
+                {
+                    Instance.SetAge(i, properties[i].Age);
+                    Instance.SetModificationDate(i, properties[i].Date);
+                    this.properties[i] = properties[i].Value;
+                }
+
+                // trigger holded events/property updates.
+                //foreach (var r in afterAttachmentTriggers)
+                //    r.Key.Trigger(r.Value);
+
+                //afterAttachmentTriggers.Clear();
+
+                attached = true;
+
+            }
+           return true;
+        }
+
+        internal void _EmitEventByIndex(byte index, object[] args)
+        {
+            var et = Instance.Template.GetEventTemplateByIndex(index);
+            events[index]?.Invoke(this, args);
+            Instance.EmitResourceEvent(et.Name, args);
+        }
+
+        public AsyncReply<object> _InvokeByNamedArguments(byte index, Structure namedArgs)
+        {
+            if (destroyed)
+                throw new Exception("Trying to access destroyed object");
+
+            if (suspended)
+                throw new Exception("Trying to access suspended object");
+
+            if (index >= Instance.Template.Functions.Length)
+                throw new Exception("Function index is incorrect");
+
+
+            return connection.SendInvokeByNamedArguments(instanceId, index, namedArgs);
+        }
+
+        public AsyncReply<object> _InvokeByArrayArguments(byte index, object[] args)
+        {
+            if (destroyed)
+                throw new Exception("Trying to access destroyed object");
+
+            if (suspended)
+                throw new Exception("Trying to access suspended object");
+
+            if (index >= Instance.Template.Functions.Length)
+                throw new Exception("Function index is incorrect");
+
+
+            return connection.SendInvokeByArrayArguments(instanceId, index, args);
+        }
+
+ 
+        public override bool TryInvokeMember(InvokeMemberBinder binder, object[] args, out object result)
+        {
+            var ft = Instance.Template.GetFunctionTemplateByName(binder.Name);
+
+            var reply = new AsyncReply<object>();
+
+            if (attached && ft!=null)
+            {
+                if (args.Length == 1)
+                {
+                    // Detect anonymous types
+                    var type = args[0].GetType();
+                    if (Codec.IsAnonymous(type))
+                    {
+                        var namedArgs = new Structure();
+
+                        var pi = type.GetTypeInfo().GetProperties();
+                        foreach (var p in pi)
+                            namedArgs[p.Name] = p.GetValue(args[0]);
+                        result = _InvokeByNamedArguments(ft.Index, namedArgs);
+                    }
+                    else
+                    {
+                        result = _InvokeByArrayArguments(ft.Index, args);
+                    }
+                    
+                }
+                else
+                {
+                    result = _InvokeByArrayArguments(ft.Index, args);
+                }
+                return true;
+            }
+            else
+            {
+                result = null;
+                return false;
+            }
+        }
+
+        /// <summary>
+        /// Get a property value.
+        /// </summary>
+        /// <param name="index">Zero-based property index.</param>
+        /// <returns>Value</returns>
+        internal object _Get(byte index)
+        {
+            if (index >= properties.Length)
+                return null;
+            return properties[index];
+        }
+
+        public override bool TryGetMember(GetMemberBinder binder, out object result)
+        {
+            if (destroyed)
+                throw new Exception("Trying to access destroyed object");
+
+
+            result = null;
+
+            if (!attached)
+                return false;
+
+            var pt = Instance.Template.GetPropertyTemplateByName(binder.Name);
+
+            if (pt != null)
+            {
+                result = properties[pt.Index];
+                return true;
+            }
+            else
+            {
+                var et = Instance.Template.GetEventTemplateByName(binder.Name);
+                if (et == null)
+                    return false;
+
+                result = events[et.Index];
+
+                return true;
+            }
+        }
+
+
+        internal void _UpdatePropertyByIndex(byte index, object value)
+        {
+            var pt = Instance.Template.GetPropertyTemplateByIndex(index);
+            properties[index] = value;
+            Instance.EmitModification(pt, value);
+        }
+
+        /// <summary>
+        /// Set property value.
+        /// </summary>
+        /// <param name="index">Zero-based property index.</param>
+        /// <param name="value">Value</param>
+        /// <returns>Indicator when the property is set.</returns>
+        internal AsyncReply<object> _Set(byte index, object value)
+        {
+            if (index >= properties.Length)
+                return null;
+
+            var reply = new AsyncReply<object>();
+
+            var parameters = Codec.Compose(value, connection);
+            connection.SendRequest(Packets.IIPPacket.IIPPacketAction.SetProperty)
+                        .AddUInt32(instanceId)
+                        .AddUInt8(index)
+                        .AddUInt8Array(parameters)
+                        .Done()
+                        .Then((res) =>
+                        {
+                            // not really needed, server will always send property modified, 
+                            // this only happens if the programmer forgot to emit in property setter
+                            properties[index] = value;
+                            reply.Trigger(null);
+                        });
+
+            return reply;
+        }
+
+        public override bool TrySetMember(SetMemberBinder binder, object value)
+        {
+            if (destroyed)
+                throw new Exception("Trying to access destroyed object");
+
+            if (suspended)
+                throw new Exception("Trying to access suspended object");
+
+            if (!attached)
+                return false;
+
+            var pt = Instance.Template.GetPropertyTemplateByName(binder.Name);
+ 
+            if (pt != null)
+            {
+                _Set(pt.Index, value);
+                return true;
+            }
+            else
+            {
+                var et = Instance.Template.GetEventTemplateByName(binder.Name);
+                if (et == null)
+                    return false;
+
+                events[et.Index] = (DistributedResourceEvent)value;
+
+                return true;
+            }
+
+         }
+
+        /*
+              public async void InvokeMethod(byte index, object[] arguments, DistributedConnection sender)
+              {
+                  // get function parameters
+                  Type t = this.GetType();
+
+                  MethodInfo mi = t.GetMethod(GetFunctionName(index), BindingFlags.DeclaredOnly |
+                                                          BindingFlags.Public |
+                                                          BindingFlags.Instance | BindingFlags.InvokeMethod);
+                  if (mi != null)
+                  {
+                      try
+                      {
+                          var res = await invokeMethod(mi, arguments, sender);
+                          object rt = Codec.Compose(res);
+                          sender.SendParams((byte)0x80, instanceId, index, rt);
+                      }
+                      catch(Exception ex)
+                      {
+                          var msg = ex.InnerException != null ? ex.InnerException.Message : ex.Message;
+                          sender.SendParams((byte)0x8E, instanceId, index, Codec.Compose(msg));
+                      }
+                  }
+              }
+              */
+
+
+   
+            /// <summary>
+            /// Resource interface.
+            /// </summary>
+        public Instance Instance
+        {
+            get;
+            set;
+        }
+
+        /// <summary>
+        /// Create a new instance of distributed resource.
+        /// </summary>
+        public DistributedResource()
+        {
+            //stack = new DistributedResourceStack(this);
+            //this.Instance.ResourceModified += this.OnModified;
+
+        }
+
+        /// <summary>
+        /// Resource interface.
+        /// </summary>
+        /// <param name="trigger"></param>
+        /// <returns></returns>
+        public AsyncReply<bool> Trigger(ResourceTrigger trigger)
+        {
+
+            if (trigger == ResourceTrigger.Initialize)
+                this.Instance.ResourceModified += this.OnModified;
+
+            // do nothing.
+            return new AsyncReply<bool>(true);
+        }
+    }
+}

Esiur/Net/IIP/DistributedResourceEvent.cs

@@ -0,0 +1,34 @@
+/*
+ 
+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;
+
+namespace Esiur.Net.IIP
+{
+    public delegate void DistributedResourceEvent(DistributedResource sender, params object[] arguments);
+}

Esiur/Net/IIP/DistributedResourceQueueItem.cs

@@ -0,0 +1,73 @@
+/*
+ 
+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;
+
+namespace Esiur.Net.IIP
+{
+    public class DistributedResourceQueueItem
+    {
+        public enum DistributedResourceQueueItemType
+        {
+            Propery,
+            Event
+        }
+
+        DistributedResourceQueueItemType type;
+        byte index;
+        object value;
+        DistributedResource resource;
+
+        public DistributedResourceQueueItem(DistributedResource resource, DistributedResourceQueueItemType type, object value, byte index)
+        {
+            this.resource = resource;
+            this.index = index;
+            this.type = type;
+            this.value = value;
+        }
+
+        public DistributedResource Resource
+        {
+            get { return resource; }
+        }
+        public DistributedResourceQueueItemType Type
+        {
+            get { return type; }
+        }
+
+        public byte Index
+        {
+            get { return index; }
+        }
+
+        public object Value
+        {
+            get { return value; }
+        }
+    }
+}

Esiur/Net/IIP/DistributedServer.cs

@@ -0,0 +1,169 @@
+/*
+ 
+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 Esiur.Net.Sockets;
+using Esiur.Misc;
+using System.Threading;
+using Esiur.Data;
+using Esiur.Core;
+using System.Net;
+using Esiur.Resource;
+using Esiur.Security.Membership;
+
+namespace Esiur.Net.IIP
+{
+    public class DistributedServer : NetworkServer<DistributedConnection>, IResource
+    {
+        [Attribute]
+        public string IP
+        {
+            get;
+            set;
+        }
+
+        [Attribute]
+        public IMembership Membership
+        {
+            get;
+            set;
+        }
+
+        [Attribute]
+        public EntryPoint EntryPoint
+        {
+            get;
+            set;
+        }
+
+        [Attribute]
+        public ushort Port
+        {
+            get;
+            set;
+        }
+
+       
+
+        public Instance Instance
+        {
+            get;
+            set;
+        }
+
+        public AsyncReply<bool> Trigger(ResourceTrigger trigger)
+        {
+            if (trigger == ResourceTrigger.Initialize)
+            {
+                TCPSocket listener;
+
+                if (IP != null)
+                    listener = new TCPSocket(new IPEndPoint(IPAddress.Parse(IP), Port));
+                else
+                    listener = new TCPSocket(new IPEndPoint(IPAddress.Any, Port));
+
+                Start(listener);
+            }
+            else if (trigger == ResourceTrigger.Terminate)
+            {
+                Stop();
+            }
+            else if (trigger == ResourceTrigger.SystemReload)
+            {
+                Trigger(ResourceTrigger.Terminate);
+                Trigger(ResourceTrigger.Initialize);
+            }
+
+            return new AsyncReply<bool>(true);
+        }
+
+
+
+        //protected override void DataReceived(DistributedConnection sender, NetworkBuffer data)
+        //{
+        //    //throw new NotImplementedException();
+ 
+        //}
+
+ 
+
+        //protected override void ClientConnected(DistributedConnection sender)
+        //{
+        //    //Console.WriteLine("DistributedConnection Client Connected");
+        //}
+
+        //private void ConnectionReadyEventReceiver(DistributedConnection sender)
+        //{
+        //    sender.OnReady -= ConnectionReadyEventReceiver;
+        //    Warehouse.Put(sender, sender.LocalUsername, null, this);
+        //}
+
+        
+        //public override void RemoveConnection(DistributedConnection connection)
+        //{
+        //    connection.OnReady -= Sender_OnReady;
+        //    //connection.Server = null;
+        //    base.RemoveConnection(connection);
+        //}
+
+        //public override void AddConnection(DistributedConnection connection)
+        //{
+        //    connection.OnReady += Sender_OnReady;
+        //    connection.Server = this;
+        //    base.AddConnection(connection);
+        //}
+
+
+
+        protected override void ClientConnected(DistributedConnection connection)
+        {
+            //connection.OnReady += ConnectionReadyEventReceiver;
+        }
+
+        public override void Add(DistributedConnection connection)
+        {
+            connection.Server = this;
+            base.Add(connection);
+        }
+
+        public override void Remove(DistributedConnection connection)
+        {
+            connection.Server = null;
+            base.Remove(connection);
+        }
+
+        protected override void ClientDisconnected(DistributedConnection connection)
+        {
+            //connection.OnReady -= ConnectionReadyEventReceiver;
+            //Warehouse.Remove(connection);
+
+
+        }
+
+        
+    }
+}

Esiur/Net/IIP/DistributedSession.cs

@@ -0,0 +1,38 @@
+/*
+ 
+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.Text;
+using Esiur.Net.Sockets;
+using Esiur.Security.Authority;
+
+namespace Esiur.Net.IIP
+{
+    public class DistributedSession : NetworkSession
+    {
+        Source Source { get; }
+        Authentication Authentication;
+    }
+}

Esiur/Net/IIP/EntryPoint.cs

@@ -0,0 +1,40 @@
+/*
+ 
+Copyright (c) 2019 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.Text;
+using Esiur.Core;
+using Esiur.Data;
+using Esiur.Resource;
+using Esiur.Resource.Template;
+
+namespace Esiur.Net.IIP
+{
+    public abstract class EntryPoint : Esiur.Resource.Resource
+    {
+
+        public abstract AsyncReply<IResource[]> Query(string path, DistributedConnection sender);
+        protected abstract override bool Create();
+    }
+}

Esiur/Net/INetworkReceiver.cs

@@ -0,0 +1,15 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace Esiur.Net
+{
+    public interface INetworkReceiver<T>
+    {
+        void NetworkClose(T sender);
+        void NetworkReceive(T sender, NetworkBuffer buffer);
+        //void NetworkError(T sender);
+
+        void NetworkConnect(T sender);
+    }
+}

Esiur/Net/NetworkBuffer.cs

@@ -0,0 +1,208 @@
+/*
+ 
+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 Esiur.Data;
+using Esiur.Misc;
+
+namespace Esiur.Net
+{
+    public class NetworkBuffer
+    {
+        byte[] data;
+
+        uint neededDataLength = 0;
+        //bool trim;
+
+        object syncLock = new object();
+
+        //public object SyncLock
+        //{
+          //  get { return syncLock; }
+        //}
+
+        public NetworkBuffer()
+        {
+            data = new byte[0];
+        }
+
+        public bool Protected
+        {
+            get
+            {
+                return neededDataLength > data.Length;
+            }
+        }
+
+        public uint Available
+        {
+            get
+            {
+                return (uint)data.Length;
+            }
+        }
+
+
+        //public void HoldForAtLeast(byte[] src, uint offset, uint size, uint needed)
+        //{
+        //    HoldFor(src, offset, size, needed);
+        //    //trim = false;
+        //}
+
+        //public void HoldForAtLeast(byte[] src, uint needed)
+        //{
+        //    HoldForAtLeast(src, 0, (uint)src.Length, needed);
+        //}
+
+        public void HoldForNextWrite(byte[] src)
+        {
+            //HoldForAtLeast(src, (uint)src.Length + 1);
+            HoldFor(src, (uint)src.Length + 1);
+        }
+
+        public void HoldForNextWrite(byte[] src, uint offset, uint size)
+        {
+            //HoldForAtLeast(src, offset, size, size + 1);
+            HoldFor(src, offset, size, size + 1);
+        }
+
+
+        public void HoldFor(byte[] src, uint offset, uint size, uint needed)
+        {
+            lock (syncLock)
+            {
+                if (size >= needed)
+                    throw new Exception("Size >= Needed !");
+
+                //trim = true;
+                data = DC.Combine(src, offset, size, data, 0, (uint)data.Length);
+                neededDataLength = needed;
+
+                // Console.WriteLine("Hold StackTrace: '{0}'", Environment.StackTrace);
+
+                //Console.WriteLine("Holded {0} {1} {2} {3} - {4}", offset, size, needed, data.Length, GetHashCode());
+            }
+        }
+
+        public void HoldFor(byte[] src, uint needed)
+        {
+            HoldFor(src, 0, (uint)src.Length, needed);
+        }
+
+        public bool Protect(byte[] data, uint offset, uint needed)//, bool exact = false)
+        {
+            uint dataLength = (uint)data.Length - offset;
+
+            // protection
+            if (dataLength < needed)
+            {
+                //if (exact)
+                //    HoldFor(data, offset, dataLength, needed);
+                //else
+                //HoldForAtLeast(data, offset, dataLength, needed);
+                HoldFor(data, offset, dataLength, needed);
+                return true;
+            }
+            else
+                return false;
+        }
+
+        public void Write(byte[] src)
+        {
+            Write(src, 0, (uint)src.Length);
+        }
+
+        public void Write(byte[] src, uint offset, uint length)
+        {
+            //if (data.Length > 0)
+              //  Console.WriteLine();
+
+            lock(syncLock)
+                DC.Append(ref data, src, offset, length);
+        }
+
+        public bool CanRead
+        {
+            get
+            {
+                if (data.Length == 0)
+                    return false;
+                if (data.Length < neededDataLength)
+                    return false;
+
+                return true;
+            }
+        }
+
+        public byte[] Read()
+        {
+            lock (syncLock)
+            {
+                if (data.Length == 0)
+                    return null;
+
+                byte[] rt = null;
+
+                if (neededDataLength == 0)
+                {
+                    rt = data;
+                    data = new byte[0];
+                }
+                else
+                {
+                    //Console.WriteLine("P STATE:" + data.Length + " " + neededDataLength);
+
+                    if (data.Length >= neededDataLength)
+                    {
+                        //Console.WriteLine("data.Length >= neededDataLength " + data.Length + " >= " + neededDataLength + " " + trim);
+
+                        //if (trim)
+                        //{
+                        //  rt = DC.Clip(data, 0, neededDataLength);
+                        //  data = DC.Clip(data, neededDataLength, (uint)data.Length - neededDataLength);
+                        //}
+                        //else
+                        //{
+                        // return all data
+                        rt = data;
+                        data = new byte[0];
+                        //}
+
+                        neededDataLength = 0;
+                        return rt;
+                    }
+                    else
+                    {
+                        return null;
+                    }
+                }
+
+                return rt;
+           }
+        }
+    }
+}

Esiur/Net/NetworkConnection.cs

@@ -0,0 +1,367 @@
+/*
+ 
+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.IO;
+using System.Net.Sockets;
+using System.Text;
+using System.Threading;
+using System.Net;
+using System.Collections;
+using System.Collections.Generic;
+using Esiur.Misc;
+using Esiur.Core;
+using Esiur.Data;
+using Esiur.Net.Sockets;
+using Esiur.Resource;
+
+namespace Esiur.Net
+{
+    public abstract class NetworkConnection: IDestructible, INetworkReceiver<ISocket>// <TS>: IResource where TS : NetworkSession
+    {
+        private Sockets.ISocket sock;
+        //        private bool connected;
+
+        private DateTime lastAction;
+
+        //public delegate void DataReceivedEvent(NetworkConnection sender, NetworkBuffer data);
+        //public delegate void ConnectionClosedEvent(NetworkConnection sender);
+        public delegate void NetworkConnectionEvent(NetworkConnection connection);
+
+        public event NetworkConnectionEvent OnConnect;
+        //public event DataReceivedEvent OnDataReceived;
+        public event NetworkConnectionEvent OnClose;
+
+            
+        public event DestroyedEvent OnDestroy;
+        //object receivingLock = new object();
+
+        //object sendLock = new object();
+
+        bool processing = false;
+
+       // public INetworkReceiver<NetworkConnection> Receiver { get; set; }
+
+        public virtual void Destroy()
+        {
+            // remove references
+            //sock.OnClose -= Socket_OnClose;
+            //sock.OnConnect -= Socket_OnConnect;
+            //sock.OnReceive -= Socket_OnReceive;
+            sock.Destroy();
+            //Receiver = null;
+            Close();
+            sock = null;
+
+            OnClose = null;
+            OnConnect = null;
+            //OnDataReceived = null;
+            OnDestroy?.Invoke(this);
+            OnDestroy = null;
+        }
+
+        public ISocket Socket
+        {
+            get
+            {
+                return sock;
+            }
+        }
+
+        public virtual void Assign(ISocket socket)
+        {
+            lastAction = DateTime.Now;
+            sock = socket;
+            sock.Receiver = this;
+
+            //socket.OnReceive += Socket_OnReceive;
+            //socket.OnClose += Socket_OnClose;
+            //socket.OnConnect += Socket_OnConnect;
+        }
+
+        //private void Socket_OnConnect()
+        //{
+        //    OnConnect?.Invoke(this);
+        //}
+
+        //private void Socket_OnClose()
+        //{
+        //    ConnectionClosed();
+        //    OnClose?.Invoke(this);
+        //}
+
+        //protected virtual void ConnectionClosed()
+        //{
+
+        //}
+
+        //private void Socket_OnReceive(NetworkBuffer buffer)
+        //{
+        //}
+
+        public ISocket Unassign()
+        {
+            if (sock != null)
+            {
+                // connected = false;
+                //sock.OnClose -= Socket_OnClose;
+                //sock.OnConnect -= Socket_OnConnect;
+                //sock.OnReceive -= Socket_OnReceive;
+                sock.Receiver = null;
+
+                var rt = sock;
+                sock = null;
+
+                return rt;
+            }
+            else
+                return null;
+        }
+
+        //protected virtual void DataReceived(NetworkBuffer data)
+        //{
+        //    if (OnDataReceived != null)
+        //    {
+        //        try
+        //        {
+        //            OnDataReceived?.Invoke(this, data);
+        //        }
+        //        catch (Exception ex)
+        //        {
+        //            Global.Log("NetworkConenction:DataReceived", LogType.Error, ex.ToString());
+        //        }
+        //    }
+        //}
+
+        public void Close()
+        {
+            //if (!connected)
+            //  return;
+
+
+            try
+            {
+                if (sock != null)
+                    sock.Close();
+            }
+            catch (Exception ex)
+            {
+                Global.Log("NetworkConenction:Close", LogType.Error, ex.ToString());
+
+            }
+
+            //finally
+            //{
+            //connected = false;
+            //}
+
+        }
+
+        public DateTime LastAction
+        {
+            get { return lastAction; }
+        }
+
+        public IPEndPoint RemoteEndPoint
+        {
+            get
+            {
+                if (sock != null)
+                    return (IPEndPoint)sock.RemoteEndPoint;
+                else
+                    return null;
+            }
+        }
+
+        public IPEndPoint LocalEndPoint
+        {
+            get
+            {
+                if (sock != null)
+                    return (IPEndPoint)sock.LocalEndPoint;
+                else
+                    return null;
+            }
+        }
+
+
+        public bool IsConnected
+        {
+            get
+            {
+                return sock.State == SocketState.Established;
+            }
+        }
+
+
+        /*
+        public void CloseAndWait()
+        {
+            try
+            {
+                if (!connected)
+                    return;
+
+                    if (sock != null)
+                        sock.Close();
+
+                    while (connected)
+                    {
+                        Thread.Sleep(100);
+                    }
+            }
+            finally
+            {
+                
+            }
+        }
+        */
+
+        public virtual AsyncReply<bool> SendAsync(byte[] message, int offset, int length)
+        {
+            try
+            {
+                lastAction = DateTime.Now;
+                return sock.SendAsync(message, offset, length);
+            }
+            catch
+            {
+                return new AsyncReply<bool>(false);
+            }
+        }
+
+        public virtual void Send(byte[] msg)
+        {
+            try
+            {                
+                sock?.Send(msg);       
+                lastAction = DateTime.Now;
+            }
+            catch
+            {
+
+            }
+        }
+
+        public virtual void Send(byte[] msg, int offset, int length)
+        {
+            try
+            {
+                sock.Send(msg, offset, length);
+                lastAction = DateTime.Now;
+            }
+            catch
+            {
+
+            }
+        }
+
+        public virtual void Send(string data)
+        {
+            Send(Encoding.UTF8.GetBytes(data));
+        }
+
+        public  void NetworkClose(ISocket socket)
+        {
+            Disconencted();
+            OnClose?.Invoke(this);
+        }
+
+        public void NetworkConnect(ISocket socket)
+        {
+            Connected();
+            OnConnect?.Invoke(this);
+        }
+
+        //{
+        //ConnectionClosed();
+        //OnClose?.Invoke(this);
+
+        //Receiver?.NetworkClose(this);
+        //}
+
+        //public void NetworkConenct(ISocket sender)
+        //{
+        //    OnConnect?.Invoke(this);
+        //}
+
+        protected abstract void DataReceived(NetworkBuffer buffer);
+        protected abstract void Connected();
+        protected abstract void Disconencted();
+
+        public void NetworkReceive(ISocket sender, NetworkBuffer buffer)
+        {
+            try
+            {
+                // Unassigned ?
+                if (sock == null)
+                    return;
+
+                // Closed ?
+                if (sock.State == SocketState.Closed)// || sock.State == SocketState.Terminated) // || !connected)
+                    return;
+
+                lastAction = DateTime.Now;
+
+                if (!processing)
+                {
+                    processing = true;
+
+                    try
+                    {
+                        //lock(buffer.SyncLock)
+                        while (buffer.Available > 0 && !buffer.Protected)
+                        {
+                            //Receiver?.NetworkReceive(this, buffer);
+                            DataReceived(buffer);
+                        }
+                    }
+                    catch
+                    {
+
+                    }
+
+                    processing = false;
+                }
+
+            }
+            catch (Exception ex)
+            {
+                Global.Log("NetworkConnection", LogType.Warning, ex.ToString());
+            }
+        }
+
+
+        //{
+          //  Receiver?.NetworkError(this);
+            //throw new NotImplementedException();
+        //}
+
+        //public void NetworkConnect(ISocket sender)
+        //{
+          //  Receiver?.NetworkConnect(this);
+            //throw new NotImplementedException();
+        //}
+    }
+}

Esiur/Net/NetworkServer.cs

@@ -0,0 +1,311 @@
+/*
+ 
+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.Threading;
+using System.Collections.Generic;
+using Esiur.Data;
+using Esiur.Misc;
+using Esiur.Core;
+using Esiur.Net.Sockets;
+using Esiur.Resource;
+using System.Threading.Tasks;
+using System.Diagnostics;
+
+namespace Esiur.Net
+{
+
+    public abstract class NetworkServer<TConnection> : IDestructible where TConnection : NetworkConnection, new()
+    {
+        //private bool isRunning;
+        private Sockets.ISocket listener;
+        public AutoList<TConnection, NetworkServer<TConnection>> Connections { get; private set; }
+
+        private Thread thread;
+
+        //protected abstract void DataReceived(TConnection sender, NetworkBuffer data);
+        //protected abstract void ClientConnected(TConnection sender);
+        //protected abstract void ClientDisconnected(TConnection sender);
+
+
+        private Timer timer;
+        //public KeyList<string, TSession> Sessions = new KeyList<string, TSession>();
+
+        public event DestroyedEvent OnDestroy;
+
+        //public AutoList<TConnection, NetworkServer<TConnection>> Connections => connections;
+
+        private void MinuteThread(object state)
+        {
+            List<TConnection> ToBeClosed = null;
+
+
+            lock (Connections.SyncRoot)
+            {
+                foreach (TConnection c in Connections)
+                {
+                    if (DateTime.Now.Subtract(c.LastAction).TotalSeconds >= Timeout)
+                    {
+                        if (ToBeClosed == null)
+                            ToBeClosed = new List<TConnection>();
+                        ToBeClosed.Add(c);
+                    }
+                }
+            }
+
+            if (ToBeClosed != null)
+            {
+                //Console.WriteLine("Term: " + ToBeClosed.Count + " " + this.listener.LocalEndPoint.ToString());
+                foreach (TConnection c in ToBeClosed)
+                    c.Close();// CloseAndWait();
+
+                ToBeClosed.Clear();
+                ToBeClosed = null;
+            }
+        }
+
+        public void Start(Sockets.ISocket socket)//, uint timeout, uint clock)
+        {
+            if (listener != null)
+                return;
+
+
+            Connections = new AutoList<TConnection, NetworkServer<TConnection>>(this);
+
+
+            if (Timeout > 0 & Clock > 0)
+            {
+                timer = new Timer(MinuteThread, null, TimeSpan.FromMinutes(0), TimeSpan.FromSeconds(Clock));
+            }
+
+
+            listener = socket;
+
+            // Start accepting
+            //var r = listener.Accept();
+            //r.Then(NewConnection);
+            //r.timeout?.Dispose();
+
+            //var rt = listener.Accept().Then()
+            thread = new Thread(new ThreadStart(() =>
+            {
+                while (true)
+                {
+                    try
+                    {
+                        var s = listener.Accept();
+
+                        if (s == null)
+                        {
+                            Console.Write("sock == null");
+                            return;
+                        }
+
+                        var c = new TConnection();
+                        //c.OnClose += ClientDisconnectedEventReceiver;
+                        c.Assign(s);
+                        Add(c);
+                        //Connections.Add(c);
+                        
+                        try
+                        {
+                            //ClientConnected(c);
+                            ClientConnected(c);
+                            //NetworkConnect(c);
+                        }
+                        catch
+                        {
+                            // something wrong with the child.
+                        }
+
+                        s.Begin();
+
+                        // Accept more
+                        //listener.Accept().Then(NewConnection);
+
+                    }
+                    catch (Exception ex)
+                    {
+                        Console.WriteLine(ex);
+                    }
+                }
+            }));
+
+            thread.Start();
+
+        }
+
+
+        [Attribute]
+        public uint Timeout
+        {
+            get;
+            set;
+        }
+
+
+        [Attribute]
+        public uint Clock
+        {
+            get;
+            set;
+        }
+
+
+        public void Stop()
+        {
+            var port = 0;
+
+            try
+            {
+                if (listener != null)
+                {
+                    port = listener.LocalEndPoint.Port;
+                    listener.Close();
+                }
+
+                // wait until the listener stops
+                //while (isRunning)
+                //{
+                //  Thread.Sleep(100);
+                //}
+
+                //Console.WriteLine("Listener stopped");
+
+                var cons = Connections.ToArray();
+
+                //lock (connections.SyncRoot)
+                //{
+                foreach (TConnection con in cons)
+                    con.Close();
+                //}
+
+                //Console.WriteLine("Sockets Closed");
+
+                //while (connections.Count > 0)
+                //{
+                //    Console.WriteLine("Waiting... " + connections.Count);  
+                //    Thread.Sleep(1000);
+                //}
+
+            }
+            finally
+            {
+                Console.WriteLine("Server@{0} is down", port);
+            }
+        }
+
+
+        public virtual void Remove(TConnection connection)
+        {
+            //connection.OnDataReceived -= OnDataReceived;
+            //connection.OnConnect -= OnClientConnect;
+            connection.OnClose -= ClientDisconnectedEventReceiver;
+            Connections.Remove(connection);
+        }
+
+        public virtual void Add(TConnection connection)
+        {
+            //connection.OnDataReceived += OnDataReceived;
+            //connection.OnConnect += OnClientConnect;
+            connection.OnClose += ClientDisconnectedEventReceiver;// OnClientClose;
+            Connections.Add(connection);
+        }
+
+
+        public bool IsRunning
+        {
+            get
+            {
+                return listener.State == SocketState.Listening;
+                //isRunning; 
+            }
+        }
+
+        //public void OnDataReceived(ISocket sender, NetworkBuffer data)
+        //{
+        //    DataReceived((TConnection)sender, data);
+        //}
+
+        //public void OnClientConnect(ISocket sender)
+        //{
+        //    if (sender == null)
+        //        return;
+
+        //    if (sender.RemoteEndPoint == null || sender.LocalEndPoint == null)
+        //    { }
+        //    //Console.WriteLine("NULL");
+        //    else
+        //        Global.Log("Connections", LogType.Debug, sender.RemoteEndPoint.Address.ToString()
+        //            + "->" + sender.LocalEndPoint.Port + " at " + DateTime.UtcNow.ToString("d")
+        //            + " " + DateTime.UtcNow.ToString("d"), false);
+
+        //    // Console.WriteLine("Connected " + sender.RemoteEndPoint.ToString());
+        //    ClientConnected((TConnection)sender);
+        //}
+
+        //public void OnClientClose(ISocket sender)
+        //{
+        //}
+
+
+        public void Destroy()
+        {
+            Stop();
+            OnDestroy?.Invoke(this);
+        }
+
+        private void ClientDisconnectedEventReceiver(NetworkConnection connection)
+        {
+            try
+            {
+                var con = connection as TConnection;
+                con.Destroy();
+                //                con.OnClose -= ClientDisconnectedEventReceiver;
+
+                Remove(con);
+
+                //Connections.Remove(con);
+                ClientDisconnected(con);
+                //RemoveConnection((TConnection)sender);
+                //connections.Remove(sender)
+                //ClientDisconnected((TConnection)sender);
+            }
+            catch (Exception ex)
+            {
+                Global.Log("NetworkServer:OnClientDisconnect", LogType.Error, ex.ToString());
+            }
+        }
+
+        protected abstract void ClientDisconnected(TConnection connection);
+        protected abstract void ClientConnected(TConnection connection);
+
+        ~NetworkServer()
+        {
+            Stop();
+            listener = null;
+        }
+    }
+
+}

Esiur/Net/NetworkSession.cs

@@ -0,0 +1,130 @@
+/*
+ 
+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
+{
+    public class NetworkSession:IDestructible //<T> where T : TClient
+    {
+        public delegate void SessionModifiedEvent(NetworkSession session, string key, object oldValue, object newValue);
+        public delegate void SessionEndedEvent(NetworkSession 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 NetworkSession()
+        {
+            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; }
+        }
+    }
+
+}

Esiur/Net/Packets/HTTPRequestPacket.cs

@@ -0,0 +1,313 @@
+
+/*
+ 
+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 Esiur.Misc;
+using Esiur.Data;
+using System.Net;
+
+namespace Esiur.Net.Packets
+{
+    public class HTTPRequestPacket : Packet
+    {
+
+        public enum HTTPMethod:byte
+        {
+            GET,
+            POST,
+            HEAD,
+            PUT,
+            DELETE,
+            OPTIONS,
+            TRACE,
+            CONNECT,
+            UNKNOWN
+        }
+
+        public StringKeyList Query;
+        public HTTPMethod Method;
+        public StringKeyList Headers;
+
+        public bool WSMode;
+
+        public string Version;
+        public StringKeyList Cookies; // String
+        public string URL; /// With query
+        public string Filename; /// Without query
+        //public byte[] PostContents;
+        public KeyList<string, object> PostForms;
+        public byte[] Message;
+
+
+        private HTTPMethod getMethod(string method)
+        {
+            switch (method.ToLower())
+            {
+                case "get":
+                    return HTTPMethod.GET;
+                case "post":
+                    return HTTPMethod.POST;
+                case "head":
+                    return HTTPMethod.HEAD;
+                case "put":
+                    return HTTPMethod.PUT;
+                case "delete":
+                    return HTTPMethod.DELETE;
+                case "options":
+                    return HTTPMethod.OPTIONS;
+                case "trace":
+                    return HTTPMethod.TRACE;
+                case "connect":
+                    return HTTPMethod.CONNECT;
+                default:
+                    return HTTPMethod.UNKNOWN;
+            }
+        }
+
+        public override string ToString()
+        {
+            return "HTTPRequestPacket"
+                + "\n\tVersion: " + Version
+                + "\n\tMethod: " + Method
+                + "\n\tURL: " + URL
+                + "\n\tMessage: " + (Message != null ? Message.Length.ToString() : "NULL");
+        }
+
+        public override long Parse(byte[] data, uint offset, uint ends)
+        {
+            string[] sMethod = null;
+            string[] sLines = null;
+            
+            uint headerSize = 0;
+
+            for (uint i = offset; i < ends - 3; i++)
+            {
+                if (data[i] == '\r' && data[i + 1] == '\n'
+                    && data[i + 2] == '\r' && data[i + 3] == '\n')
+                {
+                    sLines = Encoding.ASCII.GetString(data, (int)offset,(int)( i - offset)).Split(new string[] { "\r\n" },
+                        StringSplitOptions.None);
+
+                    headerSize = i + 4;
+                    break;
+                }
+            }
+
+            if (headerSize == 0)
+                return -1;
+
+            Cookies = new StringKeyList();
+            PostForms = new KeyList<string, object>();
+            Query = new StringKeyList();
+            Headers = new StringKeyList();
+
+            sMethod = sLines[0].Split(' ');
+            Method = getMethod(sMethod[0].Trim());
+
+            if (sMethod.Length == 3)
+            {
+                sMethod[1] = WebUtility.UrlDecode(sMethod[1]);
+                if (sMethod[1].Length >= 7)
+                {
+                    if (sMethod[1].StartsWith("http://"))
+                    {
+                        sMethod[1] = sMethod[1].Substring(sMethod[1].IndexOf("/", 7));
+                    }
+                }
+
+                URL = sMethod[1].Trim();
+
+                if (URL.IndexOf("?", 0) != -1)
+                {
+                    Filename = URL.Split(new char[] { '?' }, 2)[0];
+                }
+                else
+                {
+                    Filename = URL;
+                }
+
+                if (Filename.IndexOf("%", 0) != -1)
+                {
+                    Filename = WebUtility.UrlDecode(Filename);
+                }
+
+                Version = sMethod[2].Trim();
+            }
+
+            // Read all headers
+
+            for (int i = 1; i < sLines.Length; i++)
+            {
+                if (sLines[i] == String.Empty)
+                {
+                    // Invalid header
+                    return 0;
+                }
+
+                if (sLines[i].IndexOf(':') == -1)
+                {
+                    // Invalid header
+                    return 0;
+                }
+
+                string[] header = sLines[i].Split(new char[] { ':' }, 2);
+
+                header[0] = header[0].ToLower();
+                Headers[header[0]] = header[1].Trim();
+
+                if (header[0] == "cookie")
+                {
+                    string[] cookies = header[1].Split(';');
+
+                    foreach (string cookie in cookies)
+                    {
+                        if (cookie.IndexOf('=') != -1)
+                        {
+                            string[] splitCookie = cookie.Split('=');
+                            splitCookie[0] = splitCookie[0].Trim();
+                            splitCookie[1] = splitCookie[1].Trim();
+                            if (!(Cookies.ContainsKey(splitCookie[0].Trim())))
+                                Cookies.Add(splitCookie[0], splitCookie[1]);
+                        }
+                        else
+                        {
+                            if (!(Cookies.ContainsKey(cookie.Trim())))
+                            {
+                                Cookies.Add(cookie.Trim(), String.Empty);
+                            }
+                        }
+                    }
+                }
+            }
+
+            // Query String
+            if (URL.IndexOf("?", 0) != -1)
+            {
+                string[] SQ = URL.Split(new char[] { '?' }, 2)[1].Split('&');
+                foreach (string S in SQ)
+                {
+                    if (S.IndexOf("=", 0) != -1)
+                    {
+                        string[] qp = S.Split(new char[] { '=' }, 2);
+
+                        if (!Query.ContainsKey(WebUtility.UrlDecode(qp[0])))
+                        {
+                            Query.Add(WebUtility.UrlDecode(qp[0]), WebUtility.UrlDecode(qp[1]));
+                        }
+                    }
+                    else
+                    {
+                        if (!(Query.ContainsKey(WebUtility.UrlDecode(S))))
+                        {
+                            Query.Add(WebUtility.UrlDecode(S), null);
+                        }
+                    }
+                }
+            }
+
+            // Post Content-Length
+            if (Method == HTTPMethod.POST)
+            {
+                try
+                {
+
+                    uint postSize = uint.Parse((string)Headers["content-length"]);
+
+                    // check limit
+                    if (postSize > data.Length - headerSize)
+                        return -(postSize - (data.Length - headerSize));
+                    
+
+                    if (
+                        Headers["content-type"] == null
+                        || Headers["content-type"] == ""
+                        ||  Headers["content-type"].StartsWith("application/x-www-form-urlencoded"))
+                    {
+                        string[] PostVars = null;
+                        PostVars = Encoding.UTF8.GetString(data, (int)headerSize, (int)postSize).Split('&');
+                        for (int J = 0; J < PostVars.Length; J++)
+                        {
+                            if (PostVars[J].IndexOf("=") != -1)
+                            {
+                                string key = WebUtility.HtmlDecode(
+                                    WebUtility.UrlDecode(PostVars[J].Split(new char[] { '=' }, 2)[0]));
+                                if (PostForms.Contains(key))
+                                    PostForms[key] = WebUtility.HtmlDecode(
+                                        WebUtility.UrlDecode(PostVars[J].Split(new char[] { '=' }, 2)[1]));
+                                else
+                                    PostForms.Add(key, WebUtility.HtmlDecode(
+                                        WebUtility.UrlDecode(PostVars[J].Split(new char[] { '=' }, 2)[1])));
+                            }
+                            else
+                                if (PostForms.Contains("unknown"))
+                                    PostForms["unknown"] = PostForms["unknown"]
+                                        + "&" + WebUtility.HtmlDecode(WebUtility.UrlDecode(PostVars[J]));
+                                else
+                                    PostForms.Add("unknown", WebUtility.HtmlDecode(WebUtility.UrlDecode(PostVars[J])));
+                        }
+                    }
+                    else if (Headers["content-type"].StartsWith("multipart/form-data"))
+                    {
+                        int st = 1;
+                        int ed = 0;
+                        string strBoundry = "--" + Headers["content-type"].Substring(
+                            Headers["content-type"].IndexOf("boundary=", 0) + 9);
+
+                        string[] sc = Encoding.UTF8.GetString(data, (int)headerSize, (int)postSize).Split(
+                                                    new string[] { strBoundry }, StringSplitOptions.None);
+
+
+                        for (int j = 1; j < sc.Length - 1; j++)
+                        {
+                            string[] ps = sc[j].Split(new string[] { "\r\n\r\n" }, 2, StringSplitOptions.None);
+                            ps[1] = ps[1].Substring(0, ps[1].Length - 2); // remove the empty line
+                            st = ps[0].IndexOf("name=", 0) + 6;
+                            ed = ps[0].IndexOf("\"", st);
+                            PostForms.Add(ps[0].Substring(st, ed - st), ps[1]);
+                        }
+                    }
+                    else
+                    {
+                        //PostForms.Add(Headers["content-type"], Encoding.Default.GetString( ));
+                        Message = DC.Clip(data, headerSize, postSize);
+                    }
+
+                    return headerSize + postSize;
+
+                }
+                catch
+                {
+                    return 0;
+                }
+            }
+
+            return headerSize;
+        }
+    }
+}
+

Esiur/Net/Packets/HTTPResponsePacket.cs

@@ -0,0 +1,304 @@
+/*
+ 
+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 Esiur.Misc;
+using Esiur.Data;
+ 
+namespace Esiur.Net.Packets
+{
+    public class HTTPResponsePacket : Packet
+    {
+
+        public enum ComposeOptions : int
+        {
+            AllCalculateLength,
+            AllDontCalculateLength,
+            SpecifiedHeadersOnly,
+            DataOnly
+        }
+
+        public enum ResponseCode : int
+        {
+            Switching= 101,
+            OK = 200,
+            Created = 201,
+            Accepted = 202,
+            NoContent = 204,
+            MovedPermanently = 301,
+            Found = 302,
+            SeeOther = 303,
+            NotModified = 304,
+            TemporaryRedirect = 307,
+            BadRequest = 400,
+            Unauthorized = 401,
+            Forbidden = 403,
+            NotFound = 404,
+            MethodNotAllowed = 405,
+            NotAcceptable = 406,
+            PreconditionFailed = 412,
+            UnsupportedMediaType = 415,
+            InternalServerError = 500,
+            NotImplemented = 501,
+        }
+
+        public struct HTTPCookie
+        {
+            public string Name;
+            public string Value;
+            public DateTime Expires;
+            public string Path;
+            public bool HttpOnly;
+            public string Domain;
+            
+            public HTTPCookie(string name, string value)
+            {
+                this.Name = name;
+                this.Value = value;
+                this.Path = null;
+                this.Expires = DateTime.MinValue;
+                this.HttpOnly = false;
+                this.Domain = null;
+            }
+
+            public HTTPCookie(string name, string value, DateTime expires)
+            {
+                this.Name = name;
+                this.Value = value;
+                this.Expires = expires;
+                this.HttpOnly = false;
+                this.Domain = null;
+                this.Path = null;
+            }
+
+            public override string ToString()
+            {
+                //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=/
+                var cookie = Name + "=" + 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;
+            }
+        }
+
+        public StringKeyList Headers = new StringKeyList(true);
+        public string Version = "HTTP/1.1";
+
+        public byte[] Message;
+        public ResponseCode Number;
+        public string Text;
+
+        public List<HTTPCookie> Cookies = new List<HTTPCookie>();
+        public bool Handled;
+
+        public override string ToString()
+        {
+            return "HTTPResponsePacket"
+                + "\n\tVersion: " + Version
+                //+ "\n\tMethod: " + Method
+                //+ "\n\tURL: " + URL
+                + "\n\tMessage: " + (Message != null ? Message.Length.ToString() : "NULL");
+        }
+
+        private string MakeHeader(ComposeOptions options)
+        {
+            string header = $"{Version} {(int)Number} {Text}\r\nServer: Esiur {Global.Version}\r\nDate: {DateTime.Now.ToUniversalTime().ToString("r")}\r\n";
+
+            if (options == ComposeOptions.AllCalculateLength) 
+                Headers["Content-Length"] = Message?.Length.ToString() ?? "0";
+
+            foreach (var kv in Headers)
+                header += kv.Key + ": " + kv.Value + "\r\n";
+            
+
+            // Set-Cookie: ckGeneric=CookieBody; expires=Sun, 30-Dec-2007 21:00:00 GMT; path=/
+            // Set-Cookie: ASPSESSIONIDQABBDSQA=IPDPMMMALDGFLMICEJIOCIPM; path=/
+            
+            foreach (var Cookie in Cookies)
+                header += "Set-Cookie: " + Cookie.ToString() + "\r\n";
+
+
+            header += "\r\n";
+
+            return header;
+        }
+
+
+        public bool Compose(ComposeOptions options)
+        {
+            List<byte> msg = new List<byte>();
+
+            if (options != ComposeOptions.DataOnly)
+            {
+                msg.AddRange(Encoding.UTF8.GetBytes(MakeHeader(options)));
+            }
+
+            if (options != ComposeOptions.SpecifiedHeadersOnly)
+            {
+                if (Message != null)
+                   msg.AddRange(Message);
+            }
+            
+            Data = msg.ToArray();
+
+            return true;
+        }
+
+        public override bool Compose()
+        {
+            return Compose(ComposeOptions.AllDontCalculateLength);
+        }
+
+        public override long Parse(byte[] data, uint offset, uint ends)
+        {
+            string[] sMethod = null;
+            string[] sLines = null;
+
+            uint headerSize = 0;
+
+            for (uint i = offset; i < ends - 3; i++)
+            {
+                if (data[i] == '\r' && data[i + 1] == '\n'
+                    && data[i + 2] == '\r' && data[i + 3] == '\n')
+                {
+                    sLines = Encoding.ASCII.GetString(data, (int)offset, (int)(i - offset)).Split(new string[] { "\r\n" },
+                        StringSplitOptions.None);
+
+                    headerSize = i + 4;
+                    break;
+                }
+            }
+
+            if (headerSize == 0)
+                return -1;
+
+            //Cookies = new DStringDictionary();
+            //Headers = new DStringDictionary(true);
+
+            sMethod = sLines[0].Split(' ');
+
+            if (sMethod.Length == 3)
+            {
+                Version = sMethod[0].Trim();
+                Number = (ResponseCode)(Convert.ToInt32(sMethod[1].Trim()));
+                Text = sMethod[2];
+            }
+
+            // Read all headers
+
+            for (int i = 1; i < sLines.Length; i++)
+            {
+                if (sLines[i] == String.Empty)
+                {
+                    // Invalid header
+                    return 0;
+                }
+
+                if (sLines[i].IndexOf(':') == -1)
+                {
+                    // Invalid header
+                    return 0;
+                }
+
+                string[] header = sLines[i].Split(new char[] { ':' }, 2);
+
+                header[0] = header[0].ToLower();
+                Headers[header[0]] = header[1].Trim();
+
+                //Set-Cookie: NAME=VALUE; expires=DATE;
+
+                if (header[0] == "set-cookie")
+                {
+                    string[] cookie = header[1].Split(';');
+
+                    if (cookie.Length >= 1)
+                    {
+                        string[] splitCookie = cookie[0].Split('=');
+                        HTTPCookie c = new HTTPCookie(splitCookie[0], splitCookie[1]);
+
+                        for (int j = 1; j < cookie.Length; j++)
+                        {
+                            splitCookie = cookie[j].Split('=');
+                            switch (splitCookie[0].ToLower())
+                            {
+                                case "domain":
+                                    c.Domain = splitCookie[1];
+                                    break;
+                                case "path":
+                                    c.Path = splitCookie[1];
+                                    break;
+                                case "httponly":
+                                    c.HttpOnly = true;
+                                    break;
+                                case "expires":
+                                    // Wed, 13-Jan-2021 22:23:01 GMT
+                                    c.Expires = DateTime.Parse(splitCookie[1]);
+                                    break;
+                            }
+                        }
+
+                    }
+
+                }
+            }
+
+            // Content-Length
+
+            try
+            {
+
+                uint contentLength = uint.Parse((string)Headers["content-length"]);
+
+                // check limit
+                if (contentLength > data.Length - headerSize)
+                {
+                    return contentLength - (data.Length - headerSize);
+                }
+
+                Message = DC.Clip(data, offset, contentLength);
+
+                return headerSize + contentLength;
+
+            }
+            catch
+            {
+                return 0;
+            }
+        }
+    }
+}

Esiur/Net/Packets/IIPAuthPacket.cs

@@ -0,0 +1,412 @@
+/*
+ 
+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 Esiur.Data;
+using Esiur.Security.Authority;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Security.Cryptography;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace Esiur.Net.Packets
+{
+    class IIPAuthPacket : Packet
+    {
+        public enum IIPAuthPacketCommand : byte
+        {
+            Action = 0,
+            Declare,
+            Acknowledge,
+            Error,
+        }
+
+        public enum IIPAuthPacketAction : byte
+        {
+            // Authenticate
+            AuthenticateHash,
+
+
+            //Challenge,
+            //CertificateRequest,
+            //CertificateReply,
+            //EstablishRequest,
+            //EstablishReply
+
+            NewConnection = 0x20,
+            ResumeConnection,
+
+            ConnectionEstablished = 0x28
+        }
+
+
+
+
+        public IIPAuthPacketCommand Command
+        {
+            get;
+            set;
+        }
+        public IIPAuthPacketAction Action
+        {
+            get;
+            set;
+        }
+
+        public byte ErrorCode { get; set; }
+        public string ErrorMessage { get; set; }
+
+        public AuthenticationMethod LocalMethod
+        {
+            get;
+            set;
+        }
+
+        public byte[] SourceInfo
+        {
+            get;
+            set;
+        }
+
+        public byte[] Hash
+        {
+            get;
+            set;
+        }
+
+        public byte[] SessionId
+        {
+            get;
+            set;
+        }
+
+        public AuthenticationMethod RemoteMethod
+        {
+            get;
+            set;
+        }
+
+        public string Domain
+        {
+            get;
+            set;
+        }
+
+        public long CertificateId
+        {
+            get; set;
+        }
+
+        public string LocalUsername
+        {
+            get;
+            set;
+        }
+
+        public string RemoteUsername
+        {
+            get;
+            set;
+        }
+
+        public byte[] LocalPassword
+        {
+            get;
+            set;
+        }
+        public byte[] RemotePassword
+        {
+            get;
+            set;
+        }
+
+        public byte[] LocalToken
+        {
+            get;
+            set;
+        }
+
+        public byte[] RemoteToken
+        {
+            get;
+            set;
+        }
+
+        public byte[] AsymetricEncryptionKey
+        {
+            get;
+            set;
+        }
+
+        public byte[] LocalNonce
+        {
+            get;
+            set;
+        }
+
+        public byte[] RemoteNonce
+        {
+            get;
+            set;
+        }
+
+        public ulong RemoteTokenIndex { get; set; }
+
+        private uint dataLengthNeeded;
+
+        bool NotEnough(uint offset, uint ends, uint needed)
+        {
+            if (offset + needed > ends)
+            {
+                dataLengthNeeded = needed - (ends - offset);
+                return true;
+            }
+            else
+                return false;
+        }
+
+        public override string ToString()
+        {
+            return Command.ToString() + " " + Action.ToString();
+        }
+
+        public override long Parse(byte[] data, uint offset, uint ends)
+        {
+            var oOffset = offset;
+
+            if (NotEnough(offset, ends, 1))
+                return -dataLengthNeeded;
+
+            Command = (IIPAuthPacketCommand)(data[offset] >> 6);
+
+            if (Command == IIPAuthPacketCommand.Action)
+            {
+                Action = (IIPAuthPacketAction)(data[offset++] & 0x3f);
+
+                if (Action == IIPAuthPacketAction.AuthenticateHash)
+                {
+                    if (NotEnough(offset, ends, 32))
+                        return -dataLengthNeeded;
+
+                    Hash = data.Clip(offset, 32);
+
+                    //var hash = new byte[32];
+                    //Buffer.BlockCopy(data, (int)offset, hash, 0, 32);
+                    //Hash = hash;
+
+                    offset += 32;
+                }
+                else if (Action == IIPAuthPacketAction.NewConnection)
+                {
+                    if (NotEnough(offset, ends, 2))
+                        return -dataLengthNeeded;
+
+                    var length = data.GetUInt16(offset);
+
+                    offset += 2;
+
+                    if (NotEnough(offset, ends, length))
+                        return -dataLengthNeeded;
+
+                    SourceInfo = data.Clip(offset, length);
+
+                    //var sourceInfo = new byte[length];
+                    //Buffer.BlockCopy(data, (int)offset, sourceInfo, 0, length);
+                    //SourceInfo = sourceInfo;
+
+                    offset += 32;
+                }
+                else if (Action == IIPAuthPacketAction.ResumeConnection
+                     || Action == IIPAuthPacketAction.ConnectionEstablished)
+                {
+                    //var sessionId = new byte[32];
+
+                    if (NotEnough(offset, ends, 32))
+                        return -dataLengthNeeded;
+
+                    SessionId = data.Clip(offset, 32);
+
+                    //Buffer.BlockCopy(data, (int)offset, sessionId, 0, 32);
+                    //SessionId = sessionId;
+
+                    offset += 32;
+                }
+            }
+            else if (Command == IIPAuthPacketCommand.Declare)
+            {
+                RemoteMethod = (AuthenticationMethod)((data[offset] >> 4) & 0x3);
+                LocalMethod = (AuthenticationMethod)((data[offset] >> 2) & 0x3);
+                var encrypt = ((data[offset++] & 0x2) == 0x2);
+
+
+                if (NotEnough(offset, ends, 1))
+                    return -dataLengthNeeded;
+
+                var domainLength = data[offset++];
+                if (NotEnough(offset, ends, domainLength))
+                    return -dataLengthNeeded;
+
+                var domain = data.GetString(offset, domainLength);
+
+                Domain = domain;
+
+                offset += domainLength;
+
+
+                if (RemoteMethod == AuthenticationMethod.Credentials)
+                {
+                    if (LocalMethod == AuthenticationMethod.None)
+                    {
+                        if (NotEnough(offset, ends, 33))
+                            return -dataLengthNeeded;
+
+                        //var remoteNonce = new byte[32];
+                        //Buffer.BlockCopy(data, (int)offset, remoteNonce, 0, 32);
+                        //RemoteNonce = remoteNonce;
+
+                        RemoteNonce = data.Clip(offset, 32);
+
+                        offset += 32;
+
+                        var length = data[offset++];
+
+                        if (NotEnough(offset, ends, length))
+                            return -dataLengthNeeded;
+
+                        RemoteUsername = data.GetString(offset, length);
+
+
+                        offset += length;
+                    }
+                }
+                else if (RemoteMethod == AuthenticationMethod.Token)
+                {
+                    if (LocalMethod == AuthenticationMethod.None)
+                    {
+                        if (NotEnough(offset, ends, 37))
+                            return -dataLengthNeeded;
+
+                        RemoteNonce = data.Clip(offset, 32);
+
+                        offset += 32;
+
+                        RemoteTokenIndex = data.GetUInt64(offset);
+                        offset += 8;
+                    }
+                }
+
+                if (encrypt)
+                {
+                    if (NotEnough(offset, ends, 2))
+                        return -dataLengthNeeded;
+
+                    var keyLength = data.GetUInt16(offset);
+
+                    offset += 2;
+
+                    if (NotEnough(offset, ends, keyLength))
+                        return -dataLengthNeeded;
+
+                    //var key = new byte[keyLength];
+                    //Buffer.BlockCopy(data, (int)offset, key, 0, keyLength);
+                    //AsymetricEncryptionKey = key;
+
+                    AsymetricEncryptionKey = data.Clip(offset, keyLength);
+
+                    offset += keyLength;
+                }
+            }
+            else if (Command == IIPAuthPacketCommand.Acknowledge)
+            {
+                RemoteMethod = (AuthenticationMethod)((data[offset] >> 4) & 0x3);
+                LocalMethod = (AuthenticationMethod)((data[offset] >> 2) & 0x3);
+                var encrypt = ((data[offset++] & 0x2) == 0x2);
+
+                if (NotEnough(offset, ends, 1))
+                    return -dataLengthNeeded;
+
+
+                if (RemoteMethod == AuthenticationMethod.Credentials
+                    || RemoteMethod == AuthenticationMethod.Token)
+                {
+                    if (LocalMethod == AuthenticationMethod.None)
+                    {
+                        if (NotEnough(offset, ends, 32))
+                            return -dataLengthNeeded;
+
+                        RemoteNonce = data.Clip(offset, 32);
+                        offset += 32;
+
+                    }
+                }
+
+                if (encrypt)
+                {
+                    if (NotEnough(offset, ends, 2))
+                        return -dataLengthNeeded;
+
+                    var keyLength = data.GetUInt16(offset);
+
+                    offset += 2;
+
+                    if (NotEnough(offset, ends, keyLength))
+                        return -dataLengthNeeded;
+
+                    //var key = new byte[keyLength];
+                    //Buffer.BlockCopy(data, (int)offset, key, 0, keyLength);
+                    //AsymetricEncryptionKey = key;
+
+                    AsymetricEncryptionKey = data.Clip(offset, keyLength);
+
+                    offset += keyLength;
+                }
+            }
+            else if (Command == IIPAuthPacketCommand.Error)
+            {
+                if (NotEnough(offset, ends, 4))
+                    return -dataLengthNeeded;
+
+                offset++;
+                ErrorCode = data[offset++];
+
+
+                var cl = data.GetUInt16(offset);
+                offset += 2;
+
+                if (NotEnough(offset, ends, cl))
+                    return -dataLengthNeeded;
+
+                ErrorMessage = data.GetString(offset, cl);
+                offset += cl;
+
+            }
+
+
+            return offset - oOffset;
+
+        }
+
+    }
+}

Esiur/Net/Packets/IIPPacket.cs

@@ -0,0 +1,823 @@
+/*
+ 
+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 Esiur.Data;
+using Esiur.Core;
+using Esiur.Misc;
+using Esiur.Net.Packets;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace Esiur.Net.Packets
+{
+    class IIPPacket : Packet
+    {
+
+        public override string ToString()
+        {
+            var rt = Command.ToString();
+
+            if (Command == IIPPacketCommand.Event)
+            {
+                rt += " " + Event.ToString();
+                //if (Event == IIPPacketEvent.AttributesUpdated)
+                //  rt += 
+            }
+            else if (Command == IIPPacketCommand.Request)
+            {
+                rt += " " + Action.ToString();
+                if (Action == IIPPacketAction.AttachResource)
+                {
+                    rt += " CID: " + CallbackId + " RID: " + ResourceId;
+                }
+            }
+            else if (Command == IIPPacketCommand.Reply)
+                rt += " " + Action.ToString();
+            else if (Command == IIPPacketCommand.Report)
+                rt += " " + Report.ToString();
+
+            return rt;
+        }
+
+        public enum IIPPacketCommand : byte
+        {
+            Event = 0,
+            Request,
+            Reply,
+            Report,
+        }
+
+        public enum IIPPacketEvent : byte
+        {
+            // Event Manage
+            ResourceReassigned = 0,
+            ResourceDestroyed,
+            ChildAdded,
+            ChildRemoved,
+            Renamed,
+            // Event Invoke
+            PropertyUpdated = 0x10,
+            EventOccurred,
+
+            // Attribute
+            AttributesUpdated = 0x18
+        }
+
+        public enum IIPPacketAction : byte
+        {
+            // Request Manage
+            AttachResource = 0,
+            ReattachResource,
+            DetachResource,
+            CreateResource,
+            DeleteResource,
+            AddChild,
+            RemoveChild,
+            RenameResource,
+
+            // Request Inquire
+            TemplateFromClassName = 0x8,
+            TemplateFromClassId,
+            TemplateFromResourceId,
+            QueryLink,
+            ResourceHistory,
+            ResourceChildren,
+            ResourceParents,
+
+            // Request Invoke
+            InvokeFunctionArrayArguments = 0x10,
+            GetProperty,
+            GetPropertyIfModified,
+            SetProperty,
+            InvokeFunctionNamedArguments,
+
+            // Request Attribute
+            GetAllAttributes = 0x18,
+            UpdateAllAttributes,
+            ClearAllAttributes,
+            GetAttributes,
+            UpdateAttributes,
+            ClearAttributes
+        }
+
+        public enum IIPPacketReport : byte
+        {
+            ManagementError,
+            ExecutionError,
+            ProgressReport = 0x8,
+            ChunkStream = 0x9
+        }
+
+
+        public IIPPacketReport Report
+        {
+            get;
+            set;
+        }
+
+        public IIPPacketCommand Command
+        {
+            get;
+            set;
+        }
+        public IIPPacketAction Action
+        {
+            get;
+            set;
+        }
+
+        public IIPPacketEvent Event
+        {
+            get;
+            set;
+        }
+
+        public IIPPacketCommand PreviousCommand
+        {
+            get;
+            set;
+        }
+        public IIPPacketAction PreviousAction
+        {
+            get;
+            set;
+        }
+
+        public IIPPacketEvent PreviousEvent
+        {
+            get;
+            set;
+        }
+
+
+        public uint ResourceId { get; set; }
+        public uint NewResourceId { get; set; }
+        //public uint ParentId { get; set; }
+        public uint ChildId { get; set; }
+        public uint StoreId { get; set; }
+
+        public ulong ResourceAge { get; set; }
+        public byte[] Content { get; set; }
+        public ushort ErrorCode { get; set; }
+        public string ErrorMessage { get; set; }
+        public string ClassName { get; set; }
+        public string ResourceLink { get; set; }
+        public Guid ClassId { get; set; }
+        public byte MethodIndex { get; set; }
+        public string MethodName { get; set; }
+        public uint CallbackId { get; set; }
+        public int ProgressValue { get; set; }
+        public int ProgressMax { get; set; }
+        public DateTime FromDate { get; set; }
+        public DateTime ToDate { get; set; }
+        public ulong FromAge { get; set; }
+        public ulong ToAge { get; set; }
+
+        private uint dataLengthNeeded;
+        private uint originalOffset;
+
+        public override bool Compose()
+        {
+            return base.Compose();
+        }
+
+        bool NotEnough(uint offset, uint ends, uint needed)
+        {
+            if (offset + needed > ends)
+            {
+                dataLengthNeeded = needed - (ends - offset);
+                //dataLengthNeeded = needed - (ends - originalOffset);
+
+                return true;
+            }
+            else
+                return false;
+        }
+
+        public override long Parse(byte[] data, uint offset, uint ends)
+        {
+            originalOffset = offset;
+
+            if (NotEnough(offset, ends, 1))
+                return -dataLengthNeeded;
+
+            PreviousCommand = Command;
+
+            Command = (IIPPacketCommand)(data[offset] >> 6);
+
+            if (Command == IIPPacketCommand.Event)
+            {
+                Event = (IIPPacketEvent)(data[offset++] & 0x3f);
+
+                if (NotEnough(offset, ends, 4))
+                    return -dataLengthNeeded;
+
+                ResourceId = data.GetUInt32(offset);
+                offset += 4;
+            }
+            else if (Command == IIPPacketCommand.Report)
+            {
+                Report = (IIPPacketReport)(data[offset++] & 0x3f);
+
+                if (NotEnough(offset, ends, 4))
+                    return -dataLengthNeeded;
+
+                CallbackId = data.GetUInt32(offset);
+                offset += 4;
+            }
+            else
+            {
+                PreviousAction = Action;
+                Action = (IIPPacketAction)(data[offset++] & 0x3f);
+
+                if (NotEnough(offset, ends, 4))
+                    return -dataLengthNeeded;
+
+                CallbackId = data.GetUInt32(offset);
+                offset += 4;
+            }
+
+            if (Command == IIPPacketCommand.Event)
+            {
+                if (Event == IIPPacketEvent.ResourceReassigned)
+                {
+                    if (NotEnough(offset, ends, 4))
+                        return -dataLengthNeeded;
+
+                    NewResourceId = data.GetUInt32(offset);
+                    offset += 4;
+
+                }
+                else if (Event == IIPPacketEvent.ResourceDestroyed)
+                {
+                    // nothing to parse
+                }
+                else if (Event == IIPPacketEvent.ChildAdded
+                        || Event == IIPPacketEvent.ChildRemoved)
+                {
+                    if (NotEnough(offset, ends, 4))
+                        return -dataLengthNeeded;
+
+                    ChildId = data.GetUInt32(offset);
+                    offset += 4;
+                }
+                else if (Event == IIPPacketEvent.Renamed)
+                {
+                    if (NotEnough(offset, ends, 2))
+                        return -dataLengthNeeded;
+
+                    var cl = data.GetUInt16(offset);
+                    offset += 2;
+
+                    if (NotEnough(offset, ends, cl))
+                        return -dataLengthNeeded;
+
+                    Content = data.Clip(offset, cl);
+
+                    offset += cl;
+                }
+                else if (Event == IIPPacketEvent.PropertyUpdated)
+                {
+                    if (NotEnough(offset, ends, 2))
+                        return -dataLengthNeeded;
+
+                    MethodIndex = data[offset++];
+
+                    var dt = (DataType)data[offset++];
+                    var size = dt.Size();// Codec.SizeOf(dt);
+
+                    if (size < 0)
+                    {
+                        if (NotEnough(offset, ends, 4))
+                            return -dataLengthNeeded;
+
+                        var cl = data.GetUInt32(offset);
+                        offset += 4;
+
+                        if (NotEnough(offset, ends, cl))
+                            return -dataLengthNeeded;
+
+                        Content = data.Clip(offset - 5, cl + 5);
+                        offset += cl;
+                    }
+                    else
+                    {
+                        if (NotEnough(offset, ends, (uint)size))
+                            return -dataLengthNeeded;
+
+                        Content = data.Clip(offset - 1, (uint)size + 1);
+                        offset += (uint)size;
+                    }
+                }
+                else if (Event == IIPPacketEvent.EventOccurred)
+                {
+                    if (NotEnough(offset, ends, 5))
+                        return -dataLengthNeeded;
+
+                    MethodIndex = data[offset++];
+
+                    var cl = data.GetUInt32(offset);
+                    offset += 4;
+
+                    if (NotEnough(offset, ends, cl))
+                        return -dataLengthNeeded;
+
+                    Content = data.Clip(offset, cl);
+                    offset += cl;
+
+                }
+                // Attribute
+                else if (Event == IIPPacketEvent.AttributesUpdated)
+                {
+                    if (NotEnough(offset, ends, 4))
+                        return -dataLengthNeeded;
+
+                    var cl = data.GetUInt32(offset);
+                    offset += 4;
+
+                    if (NotEnough(offset, ends, cl))
+                        return -dataLengthNeeded;
+
+                    Content = data.Clip(offset, cl);
+
+                    offset += cl;
+                }
+            }
+            else if (Command == IIPPacketCommand.Request)
+            {
+                if (Action == IIPPacketAction.AttachResource)
+                {
+                    if (NotEnough(offset, ends, 4))
+                        return -dataLengthNeeded;
+
+                    ResourceId = data.GetUInt32(offset);
+                    offset += 4;
+                }
+                else if (Action == IIPPacketAction.ReattachResource)
+                {
+                    if (NotEnough(offset, ends, 12))
+                        return -dataLengthNeeded;
+
+                    ResourceId = data.GetUInt32(offset);
+                    offset += 4;
+
+                    ResourceAge = data.GetUInt64(offset);
+                    offset += 8;
+
+                }
+                else if (Action == IIPPacketAction.DetachResource)
+                {
+                    if (NotEnough(offset, ends, 4))
+                        return -dataLengthNeeded;
+
+                    ResourceId = data.GetUInt32(offset);
+                    offset += 4;
+
+                }
+                else if (Action == IIPPacketAction.CreateResource)
+                {
+                    if (NotEnough(offset, ends, 12))
+                        return -dataLengthNeeded;
+
+                    StoreId = data.GetUInt32(offset);
+                    offset += 4;
+                    ResourceId = data.GetUInt32(offset);
+                    offset += 4;
+
+                    var cl = data.GetUInt32(offset);
+                    offset += 4;
+
+                    if (NotEnough(offset, ends, cl))
+                        return -dataLengthNeeded;
+
+                    this.Content = data.Clip(offset, cl);
+                }
+                else if (Action == IIPPacketAction.DeleteResource)
+                {
+                    if (NotEnough(offset, ends, 4))
+                        return -dataLengthNeeded;
+
+                    ResourceId = data.GetUInt32(offset);
+                    offset += 4;
+
+                }
+                else if (Action == IIPPacketAction.AddChild
+                        || Action == IIPPacketAction.RemoveChild)
+                {
+                    if (NotEnough(offset, ends, 8))
+                        return -dataLengthNeeded;
+
+                    ResourceId = data.GetUInt32(offset);
+                    offset += 4;
+                    ChildId = data.GetUInt32(offset);
+                    offset += 4;
+                }
+                else if (Action == IIPPacketAction.RenameResource)
+                {
+                    if (NotEnough(offset, ends, 6))
+                        return -dataLengthNeeded;
+
+                    ResourceId = data.GetUInt32(offset);
+                    offset += 4;
+                    var cl = data.GetUInt16(offset);
+                    offset += 2;
+
+                    if (NotEnough(offset, ends, cl))
+                        return -dataLengthNeeded;
+
+                    Content = data.Clip(offset, cl);
+                    offset += cl;
+                }
+                else if (Action == IIPPacketAction.TemplateFromClassName)
+                {
+                    if (NotEnough(offset, ends, 1))
+                        return -dataLengthNeeded;
+
+                    var cl = data[offset++];
+
+                    if (NotEnough(offset, ends, cl))
+                        return -dataLengthNeeded;
+
+                    ClassName = data.GetString(offset, cl);
+                    offset += cl;
+
+                }
+                else if (Action == IIPPacketAction.TemplateFromClassId)
+                {
+                    if (NotEnough(offset, ends, 16))
+                        return -dataLengthNeeded;
+
+                    ClassId = data.GetGuid(offset);
+                    offset += 16;
+
+                }
+                else if (Action == IIPPacketAction.TemplateFromResourceId)
+                {
+                    if (NotEnough(offset, ends, 4))
+                        return -dataLengthNeeded;
+
+                    ResourceId = data.GetUInt32(offset);
+                    offset += 4;
+                }
+                else if (Action == IIPPacketAction.QueryLink)
+                {
+                    if (NotEnough(offset, ends, 2))
+                        return -dataLengthNeeded;
+
+                    var cl = data.GetUInt16(offset);
+                    offset += 2;
+
+                    if (NotEnough(offset, ends, cl))
+                        return -dataLengthNeeded;
+
+                    ResourceLink = data.GetString(offset, cl);
+                    offset += cl;
+                }
+                else if (Action == IIPPacketAction.ResourceChildren
+                        || Action == IIPPacketAction.ResourceParents)
+                {
+                    if (NotEnough(offset, ends, 4))
+                        return -dataLengthNeeded;
+
+                    ResourceId = data.GetUInt32(offset);
+                    offset += 4;
+                }
+                else if (Action == IIPPacketAction.ResourceHistory)
+                {
+                    if (NotEnough(offset, ends, 20))
+                        return -dataLengthNeeded;
+
+                    ResourceId = data.GetUInt32(offset);
+                    offset += 4;
+
+                    FromDate = data.GetDateTime(offset);
+                    offset += 8;
+
+                    ToDate = data.GetDateTime(offset);
+                    offset += 8;
+
+                }
+                else if (Action == IIPPacketAction.InvokeFunctionArrayArguments
+                       || Action == IIPPacketAction.InvokeFunctionNamedArguments)
+                {
+                    if (NotEnough(offset, ends, 9))
+                        return -dataLengthNeeded;
+
+                    ResourceId = data.GetUInt32(offset);
+                    offset += 4;
+
+                    MethodIndex = data[offset++];
+
+                    var cl = data.GetUInt32(offset);
+                    offset += 4;
+
+                    if (NotEnough(offset, ends, cl))
+                        return -dataLengthNeeded;
+
+                    Content = data.Clip(offset, cl);
+                    offset += cl;
+
+                }
+                else if (Action == IIPPacketAction.GetProperty)
+                {
+                    if (NotEnough(offset, ends, 5))
+                        return -dataLengthNeeded;
+
+                    ResourceId = data.GetUInt32(offset);
+                    offset += 4;
+
+                    MethodIndex = data[offset++];
+
+                }
+                else if (Action == IIPPacketAction.GetPropertyIfModified)
+                {
+                    if (NotEnough(offset, ends, 9))
+                        return -dataLengthNeeded;
+
+                    ResourceId = data.GetUInt32(offset);
+                    offset += 4;
+
+                    MethodIndex = data[offset++];
+
+                    ResourceAge = data.GetUInt64(offset);
+                    offset += 8;
+
+                }
+                else if (Action == IIPPacketAction.SetProperty)
+                {
+                    if (NotEnough(offset, ends, 6))
+                        return -dataLengthNeeded;
+
+                    ResourceId = data.GetUInt32(offset);
+                    offset += 4;
+
+                    MethodIndex = data[offset++];
+
+
+                    var dt = (DataType)data[offset++];
+                    var size = dt.Size();// Codec.SizeOf(dt);
+
+                    if (size < 0)
+                    {
+                        if (NotEnough(offset, ends, 4))
+                            return -dataLengthNeeded;
+
+                        var cl = data.GetUInt32(offset);
+                        offset += 4;
+
+                        if (NotEnough(offset, ends, cl))
+                            return -dataLengthNeeded;
+
+                        Content = data.Clip(offset - 5, cl + 5);
+                        offset += cl;
+                    }
+                    else
+                    {
+                        if (NotEnough(offset, ends, (uint)size))
+                            return -dataLengthNeeded;
+
+                        Content = data.Clip(offset - 1, (uint)size + 1);
+                        offset += (uint)size;
+                    }
+                }
+                // Attributes
+                else if (Action == IIPPacketAction.UpdateAllAttributes
+                        || Action == IIPPacketAction.GetAttributes
+                        || Action == IIPPacketAction.UpdateAttributes
+                        || Action == IIPPacketAction.ClearAttributes)
+                {
+                    if (NotEnough(offset, ends, 8))
+                        return -dataLengthNeeded;
+
+                    ResourceId = data.GetUInt32(offset);
+                    offset += 4;
+                    var cl = data.GetUInt32(offset);
+                    offset += 4;
+
+                    if (NotEnough(offset, ends, cl))
+                        return -dataLengthNeeded;
+
+                    Content = data.Clip(offset, cl);
+                    offset += cl;
+                }
+            }
+            else if (Command == IIPPacketCommand.Reply)
+            {
+                if (Action == IIPPacketAction.AttachResource
+                   || Action == IIPPacketAction.ReattachResource)
+                {
+
+                    if (NotEnough(offset, ends, 26))
+                        return -dataLengthNeeded;
+
+                    ClassId = data.GetGuid(offset);
+                    offset += 16;
+
+                    ResourceAge = data.GetUInt64(offset);
+                    offset += 8;
+
+                    uint cl = data.GetUInt16(offset);
+                    offset += 2;
+
+                    if (NotEnough(offset, ends, cl))
+                        return -dataLengthNeeded;
+
+                    ResourceLink = data.GetString(offset, cl);
+                    offset += cl;
+
+                    if (NotEnough(offset, ends, 4))
+                        return -dataLengthNeeded;
+
+                    cl = data.GetUInt32(offset);
+                    offset += 4;
+
+                    if (NotEnough(offset, ends, cl))
+                        return -dataLengthNeeded;
+
+                    Content = data.Clip(offset, cl);
+                    offset += cl;
+                }
+                else if (Action == IIPPacketAction.DetachResource)
+                {
+                    // nothing to do
+                }
+                else if (Action == IIPPacketAction.CreateResource)
+                {
+                    if (NotEnough(offset, ends, 20))
+                        return -dataLengthNeeded;
+
+                    //ClassId = data.GetGuid(offset);
+                    //offset += 16;
+
+                    ResourceId = data.GetUInt32(offset);
+                    offset += 4;
+
+                }
+                else if (Action == IIPPacketAction.DetachResource)
+                {
+                    // nothing to do
+                }
+                // Inquire
+                else if (Action == IIPPacketAction.TemplateFromClassName
+                        || Action == IIPPacketAction.TemplateFromClassId
+                        || Action == IIPPacketAction.TemplateFromResourceId
+                        || Action == IIPPacketAction.QueryLink
+                        || Action == IIPPacketAction.ResourceChildren
+                        || Action == IIPPacketAction.ResourceParents
+                        || Action == IIPPacketAction.ResourceHistory
+                        // Attribute
+                        || Action == IIPPacketAction.GetAllAttributes
+                        || Action == IIPPacketAction.GetAttributes)
+                {
+                    if (NotEnough(offset, ends, 4))
+                        return -dataLengthNeeded;
+
+                    var cl = data.GetUInt32(offset);
+                    offset += 4;
+
+                    if (NotEnough(offset, ends, cl))
+                        return -dataLengthNeeded;
+
+                    Content = data.Clip(offset, cl);
+                    offset += cl;
+                }
+                else if (Action == IIPPacketAction.InvokeFunctionArrayArguments
+                    || Action == IIPPacketAction.InvokeFunctionNamedArguments
+                    || Action == IIPPacketAction.GetProperty
+                    || Action == IIPPacketAction.GetPropertyIfModified)
+                {
+                    if (NotEnough(offset, ends, 1))
+                        return -dataLengthNeeded;
+
+                    var dt = (DataType)data[offset++];
+                    var size = dt.Size();// Codec.SizeOf(dt);
+
+                    if (size < 0)
+                    {
+                        if (NotEnough(offset, ends, 4))
+                            return -dataLengthNeeded;
+
+                        var cl = data.GetUInt32(offset);
+                        offset += 4;
+
+                        if (NotEnough(offset, ends, cl))
+                            return -dataLengthNeeded;
+
+                        Content = data.Clip(offset - 5, cl + 5);
+                        offset += cl;
+                    }
+                    else
+                    {
+                        if (NotEnough(offset, ends, (uint)size))
+                            return -dataLengthNeeded;
+
+                        Content = data.Clip(offset - 1, (uint)size + 1);
+                        offset += (uint)size;
+                    }
+                }
+                else if (Action == IIPPacketAction.SetProperty)
+                {
+                    // nothing to do
+                }
+            }
+            else if (Command == IIPPacketCommand.Report)
+            {
+                if (Report == IIPPacketReport.ManagementError)
+                {
+                    if (NotEnough(offset, ends, 2))
+                        return -dataLengthNeeded;
+
+                    ErrorCode = data.GetUInt16(offset);
+                    offset += 2;
+                }
+                else if (Report == IIPPacketReport.ExecutionError)
+                {
+                    if (NotEnough(offset, ends, 2))
+                        return -dataLengthNeeded;
+
+                    ErrorCode = data.GetUInt16(offset);
+                    offset += 2;
+
+                    if (NotEnough(offset, ends, 2))
+                        return -dataLengthNeeded;
+
+                    var cl = data.GetUInt16(offset);
+                    offset += 2;
+
+                    if (NotEnough(offset, ends, cl))
+                        return -dataLengthNeeded;
+
+                    ErrorMessage = data.GetString(offset, cl);
+                    offset += cl;
+                }
+                else if (Report == IIPPacketReport.ProgressReport)
+                {
+                    if (NotEnough(offset, ends, 8))
+                        return -dataLengthNeeded;
+
+                    ProgressValue = data.GetInt32(offset);
+                    offset += 4;
+                    ProgressMax = data.GetInt32(offset);
+                    offset += 4;
+                }
+                else if (Report == IIPPacketReport.ChunkStream)
+                {
+                    if (NotEnough(offset, ends, 1))
+                        return -dataLengthNeeded;
+
+                    var dt = (DataType)data[offset++];
+                    var size = dt.Size();// Codec.SizeOf(dt);
+
+                    if (size < 0)
+                    {
+                        if (NotEnough(offset, ends, 4))
+                            return -dataLengthNeeded;
+
+                        var cl = data.GetUInt32(offset);
+                        offset += 4;
+
+                        if (NotEnough(offset, ends, cl))
+                            return -dataLengthNeeded;
+
+                        Content = data.Clip(offset - 5, cl + 5);
+                        offset += cl;
+                    }
+                    else
+                    {
+                        if (NotEnough(offset, ends, (uint)size))
+                            return -dataLengthNeeded;
+
+                        Content = data.Clip(offset - 1, (uint)size + 1);
+                        offset += (uint)size;
+                    }
+                }
+            }
+
+            return offset - originalOffset;
+        }
+    }
+}

Esiur/Net/Packets/IIPPacketAttachInfo.cs

@@ -0,0 +1,22 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace Esiur.Net.Packets
+{
+    struct IIPPacketAttachInfo
+    {
+        public string Link;
+        public ulong Age;
+        public byte[] Content;
+        public Guid ClassId;
+
+        public IIPPacketAttachInfo(Guid classId, ulong age, string link, byte[] content)
+        {
+            ClassId = classId;
+            Age = age;
+            Content = content;
+            Link = link;
+        }
+    }
+}

Esiur/Net/Packets/Packet.cs

@@ -0,0 +1,369 @@
+
+/********************************************************************************\
+* Uruky Project                                                                  *
+*                                                                                *
+* Copyright (C) 2006 Ahmed Zamil - ahmed@dijlh.com 		                         *
+*                                   http://www.dijlh.com                         *
+*                                                                                * 
+* 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.                                                                      *
+*                                                                                * 
+* File: Packet.cs                                                                *
+* Description: Ethernet/ARP/IPv4/TCP/UDP Packet Decoding & Encoding Class        *
+* Compatibility: .Net Framework 2.0 / Mono 1.1.8                                 *
+*                                                                                *
+\********************************************************************************/
+
+
+
+using System;
+using System.Text;
+using Esiur.Misc;
+using Esiur.Net.DataLink;
+using System.Net.NetworkInformation;
+using Esiur.Data;
+
+namespace Esiur.Net.Packets
+{
+    internal static class Functions
+    {
+        public static void AddData(ref byte[] dest, byte[] src)
+        {
+            int I = 0;
+            if (src == null)
+            {
+                return;
+            }
+            if (dest != null)
+            {
+                I = dest.Length;
+                Array.Resize(ref dest, dest.Length + src.Length);
+                //dest = (byte[])Resize(dest, dest.Length + src.Length);
+            }
+            else
+            {
+                dest = new byte[src.Length];
+            }
+            Array.Copy(src, 0, dest, I, src.Length);
+        }
+
+        /*
+        public static Array Resize(Array array, int newSize)
+        {
+            Type myType = Type.GetType(array.GetType().FullName.TrimEnd('[', ']'));
+            Array nA = Array.CreateInstance(myType, newSize);
+            Array.Copy(array, nA, (newSize > array.Length ? array.Length : newSize));
+            return nA;
+        } */
+
+        //Computes the checksum used in IP, ARP..., ie the
+        // "The 16 bit one's complement of the one 's complement sum
+        //of all 16 bit words" as seen in RFCs
+        // Returns a 4 characters hex string
+        // data's lenght must be multiple of 4, else zero padding
+        public static ushort IP_CRC16(byte[] data)
+        {
+            ulong Sum = 0;
+            bool Padding = false;
+            /// * Padding if needed
+            if (data.Length % 2 != 0)
+            {
+                Array.Resize(ref data, data.Length + 1);
+                //data = (byte[])Resize(data, data.Length + 1);
+                Padding = true;
+            }
+            int count = data.Length;
+            ///* add 16-bit words */
+            while (count > 0) //1)
+            {
+                ///*  this is the inner loop  */ 
+                Sum += GetInteger(data[count - 2], data[count - 1]);
+                ///*  Fold 32-bit sum to 16-bit  */ 
+                while (Sum >> 16 != 0)
+                {
+                    Sum = (Sum & 0XFFFF) + (Sum >> 16);
+                }
+                count -= 2;
+            }
+            /// * reverse padding 
+            if (Padding)
+            {
+                Array.Resize(ref data, data.Length - 1);
+                //data = (byte[])Resize(data, data.Length - 1);
+            }
+            ///* Return one's compliment of final sum. 
+            //return (ushort)(ushort.MaxValue - (ushort)Sum);
+            return (ushort)(~Sum);
+        }
+
+        public static ushort GetInteger(byte B1, byte B2)
+        {
+            return BitConverter.ToUInt16(new byte[] { B2, B1 }, 0);
+            //return System.Convert.ToUInt16("&h" + GetHex(B1) + GetHex(B2));
+        }
+
+        public static uint GetLong(byte B1, byte B2, byte B3, byte B4)
+        {
+            return BitConverter.ToUInt32(new byte[] { B4, B3, B2, B1 }, 0);
+            //return System.Convert.ToUInt32("&h" + GetHex(B1) + GetHex(B2) + GetHex(B3) + GetHex(B4));
+        }
+
+        public static string GetHex(byte B)
+        {
+            return (((B < 15) ? 0 + System.Convert.ToString(B, 16).ToUpper() : System.Convert.ToString(B, 16).ToUpper()));
+        }
+
+        public static bool GetBit(uint B, byte Pos)
+        {
+            //return BitConverter.ToBoolean(BitConverter.GetBytes(B), Pos + 1);
+            return (B & (uint)(Math.Pow(2, (Pos - 1)))) == (Math.Pow(2, (Pos - 1)));
+        }
+
+        public static ushort RemoveBit(ushort I, byte Pos)
+        {
+            return (ushort)RemoveBit((uint)I, Pos);
+        }
+
+        public static uint RemoveBit(uint I, byte Pos)
+        {
+            if (GetBit(I, Pos))
+            {
+                return I - (uint)(Math.Pow(2, (Pos - 1)));
+            }
+            else
+            {
+                return I;
+            }
+        }
+
+        public static void SplitInteger(ushort I, ref byte BLeft, ref byte BRight)
+        {
+            byte[] b = BitConverter.GetBytes(I);
+            BLeft = b[1];
+            BRight = b[0];
+            //BLeft = I >> 8;
+            //BRight = (I << 8) >> 8;
+        }
+
+        public static void SplitLong(uint I, ref byte BLeft, ref byte BLeftMiddle, ref byte BRightMiddle, ref byte BRight)
+        {
+            byte[] b = BitConverter.GetBytes(I);
+            BLeft = b[3];
+            BLeftMiddle = b[2];
+            BRightMiddle = b[1];
+            BRight = b[0];
+            //BLeft = I >> 24;
+            //BLeftMiddle = (I << 8) >> 24;
+            //BRightMiddle = (I << 16) >> 24;
+            //BRight = (I << 24) >> 24;
+        }
+
+    }
+
+    public class PosixTime
+    {
+        ulong seconds;
+        ulong microseconds;
+
+        PosixTime(ulong Seconds, ulong Microseconds)
+        {
+            seconds = Seconds;
+            microseconds = Microseconds;
+        }
+
+        public override string ToString()
+        {
+            return seconds + "." + microseconds;
+        }
+    }
+
+    public class Packet
+    {
+        //public EtherServer2.EthernetSource Source;
+
+        public PacketSource Source;
+
+        public DateTime Timestamp;
+
+        public enum PPPType : ushort
+        {
+            IP = 0x0021,                         // Internet Protocol version 4                   [RFC1332]
+            SDTP = 0x0049,                       // Serial Data Transport Protocol (PPP-SDTP)     [RFC1963]
+            IPv6HeaderCompression = 0x004f,      // IPv6 Header Compression
+            IPv6 = 0x0057,                       // Internet Protocol version 6                   [RFC5072]
+            W8021dHelloPacket = 0x0201,          // 802.1d Hello Packets                          [RFC3518]
+            IPv6ControlProtocol = 0x8057,        // IPv6 Control Protocol                         [RFC5072]
+        }
+
+        public enum ProtocolType : ushort
+        {
+            IP = 0x800,                          // IPv4
+            ARP = 0x806,                         // Address Resolution Protocol
+            IPv6 = 0x86DD,                       // IPv6
+            FrameRelayARP = 0x0808,              // Frame Relay ARP          [RFC1701]
+            VINESLoopback = 0x0BAE,              // VINES Loopback           [RFC1701]
+            VINESEcho = 0x0BAF,                  // VINES ECHO               [RFC1701]
+            TransEtherBridging = 0x6558,         // TransEther Bridging      [RFC1701]
+            RawFrameRelay = 0x6559,              // Raw Frame Relay          [RFC1701]
+            IEE8021QVLAN = 0x8100,               // IEEE 802.1Q VLAN-tagged frames (initially Wellfleet)
+            SNMP = 0x814C,                       // SNMP                     [JKR1]
+            TCPIP_Compression = 0x876B,          // TCP/IP Compression       [RFC1144]
+            IPAutonomousSystems = 0x876C,        // IP Autonomous Systems    [RFC1701]
+            SecureData = 0x876D,                 // Secure Data              [RFC1701]
+            PPP = 0x880B,                        // PPP                      [IANA] 
+            MPLS = 0x8847,                       // MPLS                     [RFC5332]
+            MPLS_UpstreamAssignedLabel = 0x8848, // MPLS with upstream-assigned label   [RFC5332]
+            PPPoEDiscoveryStage = 0x8863,        // PPPoE Discovery Stage    [RFC2516]
+            PPPoESessionStage = 0x8864,          // PPPoE Session Stage      [RFC2516]
+        }
+
+
+        /*
+        public static void GetPacketMACAddresses(Packet packet, out byte[] srcMAC, out byte[] dstMAC)
+        {
+
+            // get the node address
+            Packet root = packet.RootPacket;
+            if (root is TZSPPacket)
+            {
+
+                TZSPPacket tp = (TZSPPacket)root;
+                if (tp.Protocol == TZSPPacket.TZSPEncapsulatedProtocol.Ethernet)
+                {
+                    EthernetPacket ep = (EthernetPacket)tp.SubPacket;
+                    srcMAC = ep.SourceMAC;
+                    dstMAC = ep.DestinationMAC;
+                }
+                else if (tp.Protocol == TZSPPacket.TZSPEncapsulatedProtocol.IEEE802_11)
+                {
+                    W802_11Packet wp = (W802_11Packet)tp.SubPacket;
+                    srcMAC = wp.SA;
+                    dstMAC = wp.DA;
+                }
+                else
+                {
+                    srcMAC = null;
+                    dstMAC = null;
+                }
+            }
+            else if (root is EthernetPacket)
+            {
+                EthernetPacket ep = (EthernetPacket)root;
+                srcMAC = ep.SourceMAC;
+                dstMAC = ep.DestinationMAC;
+            }
+            else if (root is W802_11Packet)
+            {
+                W802_11Packet wp = (W802_11Packet)root;
+                srcMAC = wp.SA;
+                dstMAC = wp.DA;
+            }
+            else
+            {
+                srcMAC = null;
+                dstMAC = null;
+            }
+
+        }
+
+        
+        public static void GetPacketAddresses(Packet packet, ref string srcMAC, ref string dstMAC, ref string srcIP, ref string dstIP)
+        {
+
+            if (packet is TCPv4Packet)
+            {
+                if (packet.ParentPacket is IPv4Packet)
+                {
+                    IPv4Packet ip = (IPv4Packet)packet.ParentPacket;
+                    srcIP = ip.SourceIP.ToString();
+                    dstIP = ip.DestinationIP.ToString();
+                }
+            }
+
+            // get the node address
+            Packet root = packet.RootPacket;
+            if (root is TZSPPacket)
+            {
+
+                TZSPPacket tp = (TZSPPacket)root;
+                if (tp.Protocol == TZSPPacket.TZSPEncapsulatedProtocol.Ethernet)
+                {
+                    EthernetPacket ep = (EthernetPacket)tp.SubPacket;
+                    srcMAC = DC.GetPhysicalAddress(ep.SourceMAC, 0).ToString();
+                    dstMAC = DC.GetPhysicalAddress(ep.DestinationMAC, 0).ToString();
+                }
+                else if (tp.Protocol == TZSPPacket.TZSPEncapsulatedProtocol.IEEE802_11)
+                {
+                    W802_11Packet wp = (W802_11Packet)tp.SubPacket;
+                    srcMAC = DC.GetPhysicalAddress(wp.SA, 0).ToString();
+                    dstMAC = DC.GetPhysicalAddress(wp.DA, 0).ToString();
+                }
+            }
+            else if (root is EthernetPacket)
+            {
+                EthernetPacket ep = (EthernetPacket)root;
+                srcMAC = DC.GetPhysicalAddress(ep.SourceMAC, 0).ToString();
+                dstMAC = DC.GetPhysicalAddress(ep.DestinationMAC, 0).ToString();
+            }
+            else if (root is W802_11Packet)
+            {
+                W802_11Packet wp = (W802_11Packet)root;
+                srcMAC = DC.GetPhysicalAddress(wp.SA, 0).ToString();
+                dstMAC = DC.GetPhysicalAddress(wp.DA, 0).ToString();
+            }
+        }
+        */
+
+        PosixTime Timeval;
+        public byte[] Header;
+        public byte[] Preamble;
+        //public byte[] Payload;
+        public byte[] Data;
+
+        public Packet SubPacket;
+        public Packet ParentPacket;
+        public virtual long Parse(byte[] data, uint offset, uint ends) { return 0; }
+        public virtual bool Compose() { return false; }
+
+        public Packet RootPacket
+        {
+            get
+            {
+                Packet root = this;
+                while (root.ParentPacket != null)
+                    root = root.ParentPacket;
+                return root;
+            }
+        }
+
+        public Packet LeafPacket
+        {
+            get
+            {
+                Packet leaf = this;
+                while (leaf.SubPacket != null)
+                    leaf = leaf.SubPacket;
+                return leaf;
+            }
+        }
+    }
+
+}
+/************************************ EOF *************************************/
+
+

Esiur/Net/Packets/WebsocketPacket.cs

@@ -0,0 +1,217 @@
+/*
+ 
+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 Esiur.Misc;
+using Esiur.Data;
+
+namespace Esiur.Net.Packets
+{
+    public class WebsocketPacket : Packet
+    {
+        public enum WSOpcode : byte
+        {
+            ContinuationFrame = 0x0, //  %x0 denotes a continuation frame
+
+            TextFrame = 0x1, // %x1 denotes a text frame
+
+            BinaryFrame = 0x2,            // %x2 denotes a binary frame
+
+            // %x3-7 are reserved for further non-control frames
+
+            ConnectionClose = 0x8,    // %x8 denotes a connection close
+
+            Ping = 0x9, // %x9 denotes a ping
+
+            Pong = 0xA,            // %xA denotes a pong
+
+            //*  %xB-F are reserved for further control frames
+        }
+
+
+        public bool FIN;
+        public bool RSV1;
+        public bool RSV2;
+        public bool RSV3;
+        public WSOpcode Opcode;
+        public bool Mask;
+        public long PayloadLength;
+        //        public UInt32 MaskKey;
+        public byte[] MaskKey;
+
+        public byte[] Message;
+
+        public override string ToString()
+        {
+            return "WebsocketPacket"
+                + "\n\tFIN: " + FIN
+                + "\n\tOpcode: " + Opcode
+                + "\n\tPayload: " + PayloadLength
+                + "\n\tMaskKey: " + MaskKey
+                + "\n\tMessage: " + (Message != null ? Message.Length.ToString() : "NULL");
+        }
+
+        public override bool Compose()
+        {
+            var pkt = new List<byte>();
+            pkt.Add((byte)((FIN ? 0x80 : 0x0) |
+                (RSV1 ? 0x40 : 0x0) |
+                (RSV2 ? 0x20 : 0x0) |
+                (RSV3 ? 0x10 : 0x0) |
+                (byte)Opcode));
+
+            // calculate length
+            if (Message.Length > UInt16.MaxValue)
+            // 4 bytes
+            {
+                pkt.Add((byte)((Mask ? 0x80 : 0x0) | 127));
+                pkt.AddRange(DC.ToBytes((UInt64)Message.LongCount()));
+            }
+            else if (Message.Length > 125)
+            // 2 bytes
+            {
+                pkt.Add((byte)((Mask ? 0x80 : 0x0) | 126));
+                pkt.AddRange(DC.ToBytes((UInt16)Message.Length));
+            }
+            else
+            {
+                pkt.Add((byte)((Mask ? 0x80 : 0x0) | Message.Length));
+            }
+
+            if (Mask)
+            {
+                pkt.AddRange(MaskKey);
+            }
+
+            pkt.AddRange(Message);
+
+            Data = pkt.ToArray();
+
+            return true;
+        }
+
+        public override long Parse(byte[] data, uint offset, uint ends)
+        {
+            try
+            {
+                long needed = 2;
+                var length = (ends - offset);
+                if (length < needed)
+                {
+                    //Console.WriteLine("stage 1 " + needed);
+                    return length - needed;
+                }
+
+                uint oOffset = offset;
+                FIN = ((data[offset] & 0x80) == 0x80);
+                RSV1 = ((data[offset] & 0x40) == 0x40);
+                RSV2 = ((data[offset] & 0x20) == 0x20);
+                RSV3 = ((data[offset] & 0x10) == 0x10);
+                Opcode = (WSOpcode)(data[offset++] & 0xF);
+                Mask = ((data[offset] & 0x80) == 0x80);
+                PayloadLength = (long)(data[offset++] & 0x7F);
+
+                if (Mask)
+                    needed += 4;
+
+                if (PayloadLength == 126)
+                {
+                    needed += 2;
+                    if (length < needed)
+                    {
+                        //Console.WriteLine("stage 2 " + needed);
+                        return length - needed;
+                    }
+                    PayloadLength = DC.GetUInt16(data, offset);
+                    offset += 2;
+                }
+                else if (PayloadLength == 127)
+                {
+                    needed += 8;
+                    if (length < needed)
+                    {
+                        //Console.WriteLine("stage 3 " + needed);
+                        return length - needed;
+                    }
+
+                    PayloadLength = DC.GetInt64(data, offset);
+                    offset += 8;
+                }
+
+                /*
+                if (Mask)
+                {
+                                    MaskKey = new byte[4];
+                    MaskKey[0] = data[offset++];
+                    MaskKey[1] = data[offset++];
+                    MaskKey[2] = data[offset++];
+                    MaskKey[3] = data[offset++];
+
+                    //MaskKey = DC.GetUInt32(data, offset);
+                    //offset += 4;
+                }
+                */
+
+                needed += PayloadLength;
+                if (length < needed)
+                {
+                    //Console.WriteLine("stage 4");
+                    return length - needed;
+                }
+                else
+                {
+
+                    if (Mask)
+                    {
+                        MaskKey = new byte[4];
+                        MaskKey[0] = data[offset++];
+                        MaskKey[1] = data[offset++];
+                        MaskKey[2] = data[offset++];
+                        MaskKey[3] = data[offset++];
+
+                        Message = DC.Clip(data, offset, (uint)PayloadLength);
+
+                        //var aMask = BitConverter.GetBytes(MaskKey);
+                        for (int i = 0; i < Message.Length; i++)
+                            Message[i] = (byte)(Message[i] ^ MaskKey[i % 4]);
+                    }
+                    else
+                        Message = DC.Clip(data, offset, (uint)PayloadLength);
+
+
+                    return (offset - oOffset) + (int)PayloadLength;
+                }
+            }
+            catch (Exception ex)
+            {
+                Console.WriteLine(ex.ToString());
+                Console.WriteLine(offset + "::" + DC.ToHex(data));
+                throw ex;
+            }
+        }
+    }
+}

Esiur/Net/SendList.cs

@@ -0,0 +1,26 @@
+using Esiur.Core;
+using Esiur.Data;
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace Esiur.Net
+{
+    public class SendList : BinaryList
+    {
+        NetworkConnection connection;
+        AsyncReply<object[]> reply;
+
+        public SendList(NetworkConnection connection, AsyncReply<object[]> reply)
+        {
+            this.reply = reply;
+            this.connection = connection;
+        }
+
+        public override AsyncReply<object[]> Done()
+        {
+            connection.Send(this.ToArray());
+            return reply;
+        }
+    }
+}

Esiur/Net/Sockets/ISocket.cs

@@ -0,0 +1,74 @@
+/*
+ 
+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.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 System.Collections.Concurrent;
+using Esiur.Resource;
+using Esiur.Core;
+
+namespace Esiur.Net.Sockets
+{
+    //public delegate void ISocketReceiveEvent(NetworkBuffer buffer);
+    //public delegate void ISocketConnectEvent();
+    //public delegate void ISocketCloseEvent();
+
+    public interface ISocket : IDestructible
+    {
+        SocketState State { get; }
+
+        //event ISocketReceiveEvent OnReceive;
+        //event ISocketConnectEvent OnConnect;
+        //event ISocketCloseEvent OnClose;
+
+        INetworkReceiver<ISocket> Receiver { get; set; }
+
+        AsyncReply<bool> SendAsync(byte[] message, int offset, int length);
+
+        void Send(byte[] message);
+        void Send(byte[] message, int offset, int length);
+        void Close();
+        AsyncReply<bool> Connect(string hostname, ushort port);
+        bool Begin();
+        AsyncReply<bool> BeginAsync();
+        //ISocket Accept();
+        AsyncReply<ISocket> AcceptAsync();
+        ISocket Accept();
+
+        IPEndPoint RemoteEndPoint { get; }
+        IPEndPoint LocalEndPoint { get; }
+
+        void Hold();
+
+        void Unhold();
+    }
+}

Esiur/Net/Sockets/SSLSocket.cs

@@ -0,0 +1,555 @@
+/*
+ 
+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.Net.Sockets;
+using System.Net;
+using Esiur.Misc;
+using Esiur.Core;
+using System.Threading;
+using System.Net.Security;
+using System.Security.Cryptography.X509Certificates;
+using Esiur.Resource;
+using System.Threading.Tasks;
+using Esiur.Data;
+
+namespace Esiur.Net.Sockets
+{
+    public class SSLSocket : ISocket
+    {
+
+        public INetworkReceiver<ISocket> Receiver { get; set; }
+
+        Socket sock;
+        byte[] receiveBuffer;
+
+        bool held;
+
+        //ArraySegment<byte> receiveBufferSegment;
+
+        NetworkBuffer receiveNetworkBuffer = new NetworkBuffer();
+
+        readonly object sendLock = new object();
+
+        Queue<KeyValuePair<AsyncReply<bool>, byte[]>> sendBufferQueue = new Queue<KeyValuePair<AsyncReply<bool>, byte[]>>();// Queue<byte[]>();
+
+        bool asyncSending;
+        bool began = false;
+
+        SocketState state = SocketState.Initial;
+
+        //public event ISocketReceiveEvent OnReceive;
+        //public event ISocketConnectEvent OnConnect;
+        //public event ISocketCloseEvent OnClose;
+        public event DestroyedEvent OnDestroy;
+
+
+        SslStream ssl;
+        X509Certificate2 cert;
+        bool server;
+        string hostname;
+
+
+        public async AsyncReply<bool> Connect(string hostname, ushort port)
+        {
+            var rt = new AsyncReply<bool>();
+
+            this.hostname = hostname;
+            this.server = false;
+
+            state = SocketState.Connecting;
+            await sock.ConnectAsync(hostname, port);
+
+
+            try
+            {
+                await BeginAsync();
+                state = SocketState.Established;
+                //OnConnect?.Invoke();
+                Receiver?.NetworkConnect(this);
+            }
+            catch (Exception ex)
+            {
+                state = SocketState.Closed;// .Terminated;
+                Close();
+                Global.Log(ex);
+            }
+
+            return true;
+        }
+
+        //private void DataSent(Task task)
+        //{
+        //    try
+        //    {
+
+        //        if (sendBufferQueue.Count > 0)
+        //        {
+        //            byte[] data = sendBufferQueue.Dequeue();
+        //            lock (sendLock)
+        //                ssl.WriteAsync(data, 0, data.Length).ContinueWith(DataSent);
+        //        }
+        //        else
+        //        {
+        //            asyncSending = false;
+        //        }
+        //    }
+        //    catch (Exception ex)
+        //    {
+        //        if (state != SocketState.Closed && !sock.Connected)
+        //        {
+        //            state = SocketState.Terminated;
+        //            Close();
+        //        }
+
+        //        asyncSending = false;
+
+        //        Global.Log("SSLSocket", LogType.Error, ex.ToString());
+        //    }
+        //}
+
+
+        private void SendCallback(IAsyncResult ar)
+        {
+            if (ar != null)
+            {
+                try
+                {
+                    ssl.EndWrite(ar);
+
+                    if (ar.AsyncState != null)
+                        ((AsyncReply<bool>)ar.AsyncState).Trigger(true);
+                }
+                catch
+                {
+                    if (state != SocketState.Closed && !sock.Connected)
+                    {
+                        //state = SocketState.Closed;//.Terminated;
+                        Close();
+                    }
+                }
+            }
+
+            lock (sendLock)
+            {
+
+                if (sendBufferQueue.Count > 0)
+                {
+                    var kv = sendBufferQueue.Dequeue();
+
+                    try
+                    {
+                        ssl.BeginWrite(kv.Value, 0, kv.Value.Length, SendCallback, kv.Key);
+                    }
+                    catch (Exception ex)
+                    {
+                        asyncSending = false;
+                        try
+                        {
+                            if (kv.Key != null)
+                                kv.Key.Trigger(false);
+
+                            if (state != SocketState.Closed && !sock.Connected)
+                            {
+                                //state = SocketState.Terminated;
+                                Close();
+                            }
+                        }
+                        catch (Exception ex2)
+                        {
+                            //state = SocketState.Closed;// .Terminated;
+                            Close();
+                        }
+
+                        //Global.Log("TCPSocket", LogType.Error, ex.ToString());
+                    }
+                }
+                else
+                {
+                    asyncSending = false;
+                }
+            }
+        }
+
+        public IPEndPoint LocalEndPoint
+        {
+            get { return (IPEndPoint)sock.LocalEndPoint; }
+        }
+
+        public SSLSocket()
+        {
+            sock = new Socket(AddressFamily.InterNetwork,
+                                 SocketType.Stream,
+                                 ProtocolType.Tcp);
+            receiveBuffer = new byte[sock.ReceiveBufferSize];
+        }
+
+        public SSLSocket(IPEndPoint localEndPoint, X509Certificate2 certificate)
+        {
+            // create the socket
+            sock = new Socket(AddressFamily.InterNetwork,
+                                             SocketType.Stream,
+                                             ProtocolType.Tcp);
+
+            state = SocketState.Listening;
+
+            // bind
+            sock.Bind(localEndPoint);
+
+            // start listening
+            sock.Listen(UInt16.MaxValue);
+
+            cert = certificate;
+        }
+
+        public IPEndPoint RemoteEndPoint
+        {
+            get { return (IPEndPoint)sock.RemoteEndPoint; }
+        }
+
+        public SocketState State
+        {
+            get
+            {
+                return state;
+            }
+        }
+
+
+
+        public SSLSocket(Socket socket, X509Certificate2 certificate, bool authenticateAsServer)
+        {
+            cert = certificate;
+            sock = socket;
+            receiveBuffer = new byte[sock.ReceiveBufferSize];
+
+            ssl = new SslStream(new NetworkStream(sock));
+
+            server = authenticateAsServer;
+
+            if (socket.Connected)
+                state = SocketState.Established;
+        }
+
+
+        public void Close()
+        {
+            if (state != SocketState.Closed)// && state != SocketState.Terminated)
+            {
+                state = SocketState.Closed;
+
+                if (sock.Connected)
+                {
+                    try
+                    {
+                        sock.Shutdown(SocketShutdown.Both);
+                    }
+                    catch
+                    {
+                        //state = SocketState.Terminated;
+                    }
+                }
+
+                Receiver?.NetworkClose(this);
+                //OnClose?.Invoke();
+            }
+        }
+
+
+        public void Send(byte[] message)
+        {
+            Send(message, 0, message.Length);
+        }
+
+
+        public void Send(byte[] message, int offset, int size)
+        {
+
+
+            var msg = message.Clip((uint)offset, (uint)size);
+
+            lock (sendLock)
+            {
+
+                if (!sock.Connected)
+                    return;
+
+                if (asyncSending || held)
+                {
+                    sendBufferQueue.Enqueue(new KeyValuePair<AsyncReply<bool>, byte[]>(null, msg));// message.Clip((uint)offset, (uint)size));
+                }
+                else
+                {
+                    asyncSending = true;
+                    try
+                    {
+                        ssl.BeginWrite(msg, 0, msg.Length, SendCallback, null);
+                    }
+                    catch
+                    {
+                        asyncSending = false;
+                        //state = SocketState.Terminated;
+                        Close();
+                    }
+                }
+            }
+        }
+
+        //public void Send(byte[] message)
+        //{
+        //    Send(message, 0, message.Length);
+        //}
+
+        //public void Send(byte[] message, int offset, int size)
+        //{
+        //    lock (sendLock)
+        //    {
+        //        if (asyncSending)
+        //        {
+        //            sendBufferQueue.Enqueue(message.Clip((uint)offset, (uint)size));
+        //        }
+        //        else
+        //        {
+        //            asyncSending = true;
+        //            ssl.WriteAsync(message, offset, size).ContinueWith(DataSent);
+        //        }
+        //    }
+        //}
+
+
+
+        //private void DataReceived(Task<int> task)
+        //{
+        //    try
+        //    {
+        //        if (state == SocketState.Closed || state == SocketState.Terminated)
+        //            return;
+
+        //        if (task.Result <= 0)
+        //        {
+        //            Close();
+        //            return;
+        //        }
+
+        //        receiveNetworkBuffer.Write(receiveBuffer, 0, (uint)task.Result);
+        //        OnReceive?.Invoke(receiveNetworkBuffer);
+        //        if (state == SocketState.Established)
+        //            ssl.ReadAsync(receiveBuffer, 0, receiveBuffer.Length).ContinueWith(DataReceived);
+        //    }
+        //    catch (Exception ex)
+        //    {
+        //        if (state != SocketState.Closed && !sock.Connected)
+        //        {
+        //            state = SocketState.Terminated;
+        //            Close();
+        //        }
+
+        //        Global.Log("SSLSocket", LogType.Error, ex.ToString());
+        //    }
+        //}
+
+
+        public bool Begin()
+        {
+            if (began)
+                return false;
+
+            began = true;
+
+            if (server)
+                ssl.AuthenticateAsServer(cert);
+            else
+                ssl.AuthenticateAsClient(hostname);
+
+            if (state == SocketState.Established)
+            {
+                ssl.BeginRead(receiveBuffer, 0, receiveBuffer.Length, ReceiveCallback, this);
+                return true;
+            }
+            else
+                return false;
+        }
+
+        public async AsyncReply<bool> BeginAsync()
+        {
+            if (began)
+                return false;
+
+            began = true;
+
+            if (server)
+                await ssl.AuthenticateAsServerAsync(cert);
+            else
+                await ssl.AuthenticateAsClientAsync(hostname);
+
+            if (state == SocketState.Established)
+            {
+                ssl.BeginRead(receiveBuffer, 0, receiveBuffer.Length, ReceiveCallback, this);
+                return true;
+            }
+            else
+                return false;
+        }
+
+        private void ReceiveCallback(IAsyncResult results)
+        {
+            try
+            {
+                if (state != SocketState.Established)
+                    return;
+
+                var bytesReceived = ssl.EndRead(results);
+
+                if (bytesReceived <= 0)
+                {
+                    Close();
+                    return;
+                }
+
+                receiveNetworkBuffer.Write(receiveBuffer, 0, (uint)bytesReceived);
+
+                //OnReceive?.Invoke(receiveNetworkBuffer);
+
+                Receiver?.NetworkReceive(this, receiveNetworkBuffer);
+
+                ssl.BeginRead(receiveBuffer, 0, receiveBuffer.Length, ReceiveCallback, this);
+
+            }
+            catch (Exception ex)
+            {
+                if (state != SocketState.Closed && !sock.Connected)
+                {
+                    //state = SocketState.Terminated;
+                    Close();
+                }
+
+                //Global.Log("SSLSocket", LogType.Error, ex.ToString());
+            }
+        }
+
+        public bool Trigger(ResourceTrigger trigger)
+        {
+            return true;
+        }
+
+        public void Destroy()
+        {
+            Close();
+            Receiver = null;
+            receiveNetworkBuffer = null;
+            OnDestroy?.Invoke(this);
+            OnDestroy = null;
+        }
+
+        public async AsyncReply<ISocket> AcceptAsync()
+        {
+            try
+            {
+                var s = await sock.AcceptAsync();
+                return new SSLSocket(s, cert, true);
+            }
+            catch
+            {
+                state = SocketState.Closed;// Terminated;
+                return null;
+            }
+        }
+
+
+        public void Hold()
+        {
+            held = true;
+        }
+
+        public void Unhold()
+        {
+            try
+            {
+                SendCallback(null);
+            }
+            catch (Exception ex)
+            {
+                Global.Log(ex);
+            }
+            finally
+            {
+                held = false;
+            }
+        }
+
+
+        public AsyncReply<bool> SendAsync(byte[] message, int offset, int length)
+        {
+
+            var msg = message.Clip((uint)offset, (uint)length);
+
+            lock (sendLock)
+            {
+                if (!sock.Connected)
+                    return new AsyncReply<bool>(false);
+
+                var rt = new AsyncReply<bool>();
+
+                if (asyncSending || held)
+                {
+                    sendBufferQueue.Enqueue(new KeyValuePair<AsyncReply<bool>, byte[]>(rt, msg));
+                }
+                else
+                {
+                    asyncSending = true;
+                    try
+                    {
+                        ssl.BeginWrite(msg, 0, msg.Length, SendCallback, rt);// null);
+                    }
+                    catch (Exception ex)
+                    {
+                        rt.TriggerError(ex);
+                        asyncSending = false;
+                        //state = SocketState.Terminated;
+                        Close();
+                    }
+                }
+
+                return rt;
+            }
+        }
+
+
+        public ISocket Accept()
+        {
+            try
+            {
+                return new SSLSocket(sock.Accept(), cert, true);
+            }
+            catch
+            {
+                state = SocketState.Closed;// .Terminated;
+                return null;
+            }
+        }
+    }
+}

Esiur/Net/Sockets/SocketState.cs

@@ -0,0 +1,42 @@
+/*
+ 
+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;
+
+namespace Esiur.Net.Sockets
+{
+    public enum SocketState
+    {
+        Initial,
+        Listening,
+        Connecting,
+        Established,
+        Closed,
+        //Terminated
+    }
+}

Esiur/Net/Sockets/TCPSocket.cs

@@ -0,0 +1,659 @@
+/*
+ 
+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.Net.Sockets;
+using System.Net;
+using Esiur.Misc;
+using Esiur.Core;
+using System.Threading;
+using Esiur.Resource;
+using System.Threading.Tasks;
+using Esiur.Data;
+
+namespace Esiur.Net.Sockets
+{
+    public class TCPSocket : ISocket
+    {
+        public INetworkReceiver<ISocket> Receiver { get; set; }
+
+        Socket sock;
+        byte[] receiveBuffer;
+
+        bool held;
+
+        //ArraySegment<byte> receiveBufferSegment;
+
+        NetworkBuffer receiveNetworkBuffer = new NetworkBuffer();
+
+        readonly object sendLock = new object();
+
+        Queue<KeyValuePair<AsyncReply<bool>, byte[]>> sendBufferQueue = new Queue<KeyValuePair<AsyncReply<bool>, byte[]>>();// Queue<byte[]>();
+
+        bool asyncSending;
+        bool began = false;
+
+
+        SocketState state = SocketState.Initial;
+
+        //public event ISocketReceiveEvent OnReceive;
+        //public event ISocketConnectEvent OnConnect;
+        //public event ISocketCloseEvent OnClose;
+        public event DestroyedEvent OnDestroy;
+
+        //SocketAsyncEventArgs socketArgs = new SocketAsyncEventArgs();
+
+        private AsyncCallback receiveCallback;
+        private AsyncCallback sendCallback;
+
+        public AsyncReply<bool> BeginAsync()
+        {
+            return new AsyncReply<bool>(Begin());
+        }
+
+
+        private AsyncReply<bool> currentReply = null;
+
+        public bool Begin()
+        {
+            if (began)
+                return false;
+
+            began = true;
+            /*
+
+            socketArgs.SetBuffer(receiveBuffer, 0, receiveBuffer.Length);
+            socketArgs.Completed += SocketArgs_Completed;
+
+            if (!sock.ReceiveAsync(socketArgs))
+                SocketArgs_Completed(null, socketArgs);
+                */
+            receiveCallback = new AsyncCallback(ReceiveCallback);
+            sendCallback = new AsyncCallback(SendCallback);
+
+            sock.BeginReceive(receiveBuffer, 0, receiveBuffer.Length, SocketFlags.None, receiveCallback, this);
+            //sock.ReceiveAsync(receiveBufferSegment, SocketFlags.None).ContinueWith(DataReceived);
+            return true;
+        }
+
+        private static void ReceiveCallback(IAsyncResult ar)
+        {
+            var socket = ar.AsyncState as TCPSocket;
+
+            try
+            {
+
+                if (socket.state != SocketState.Established)
+                    return;
+
+                var recCount = socket.sock.EndReceive(ar);
+
+                if (recCount > 0)
+                {
+                    socket.receiveNetworkBuffer.Write(socket.receiveBuffer, 0, (uint)recCount);
+                    socket.Receiver?.NetworkReceive(socket, socket.receiveNetworkBuffer);
+
+                    if (socket.state == SocketState.Established)
+                        socket.sock.BeginReceive(socket.receiveBuffer, 0, socket.receiveBuffer.Length, SocketFlags.None, socket.receiveCallback, socket);
+                }
+                else
+                {
+                    socket.Close();
+                    return;
+                }
+            }
+            catch (Exception ex)
+            {
+                if (socket.state != SocketState.Closed && !socket.sock.Connected)
+                {
+                    //socket.state = SocketState.Terminated;
+                    socket.Close();
+                }
+
+                //Global.Log("TCPSocket", LogType.Error, ex.ToString());
+            }
+        }
+
+
+        public AsyncReply<bool> Connect(string hostname, ushort port)
+        {
+            var rt = new AsyncReply<bool>();
+
+            try
+            {
+                state = SocketState.Connecting;
+                sock.ConnectAsync(hostname, port).ContinueWith((x) =>
+                {
+
+                    if (x.IsFaulted)
+                        rt.TriggerError(x.Exception);
+                    else
+                    {
+
+                        state = SocketState.Established;
+                        //OnConnect?.Invoke();
+                        Receiver?.NetworkConnect(this);
+                        Begin();
+                        rt.Trigger(true);
+                    }
+                });
+            }
+            catch (Exception ex)
+            {
+                rt.TriggerError(ex);
+            }
+
+            return rt;
+        }
+
+
+        //private void DataReceived(Task<int> task)
+        //{
+        //    try
+        //    {
+        //        // SocketError err;
+
+        //        if (state == SocketState.Closed || state == SocketState.Terminated)
+        //            return;
+
+        //        if (task.Result <= 0)
+        //        {
+        //            Close();
+        //            return;
+        //        }
+
+        //        receiveNetworkBuffer.Write(receiveBuffer, 0, (uint)task.Result);
+        //        //OnReceive?.Invoke(receiveNetworkBuffer);
+        //        Receiver?.NetworkReceive(this, receiveNetworkBuffer);
+        //        if (state == SocketState.Established)
+        //            sock.ReceiveAsync(receiveBufferSegment, SocketFlags.None).ContinueWith(DataReceived);
+
+        //    }
+        //    catch (Exception ex)
+        //    {
+        //        if (state != SocketState.Closed && !sock.Connected)
+        //        {
+        //            state = SocketState.Terminated;
+        //            Close();
+        //        }
+
+        //        Global.Log("TCPSocket", LogType.Error, ex.ToString());
+        //    }
+        //}
+
+        //private void SocketArgs_Completed(object sender, SocketAsyncEventArgs e)
+        //{
+        //    try
+        //    {
+        //        if (state != SocketState.Established)
+        //            return;
+
+        //        if (e.BytesTransferred <= 0)
+        //        {
+        //            Close();
+        //            return;
+        //        }
+        //        else if (e.SocketError != SocketError.Success)
+        //        {
+        //            Close();
+        //            return;
+
+        //        }
+
+        //        var recCount = e.BytesTransferred > e.Count ? e.Count : e.BytesTransferred;
+        //        receiveNetworkBuffer.Write(receiveBuffer, 0, (uint)recCount);
+
+        //        //OnReceive?.Invoke(receiveNetworkBuffer);
+        //        Receiver?.NetworkReceive(this, receiveNetworkBuffer);
+
+        //        if (state == SocketState.Established)
+        //            while (!sock.ReceiveAsync(e))
+        //            {
+        //                if (e.SocketError != SocketError.Success)
+        //                {
+        //                    Close();
+        //                    return;
+        //                }
+
+        //                if (State != SocketState.Established)
+        //                    return;
+
+        //                //if (e.BytesTransferred < 0)
+        //                //    Console.WriteLine("BytesTransferred is less than zero");
+
+        //                if (e.BytesTransferred <= 0)
+        //                {
+        //                    Close();
+        //                    return;
+        //                }
+        //                else if (e.SocketError != SocketError.Success)
+        //                {
+        //                    Close();
+        //                    return;
+        //                }
+
+
+        //                //if (e.BytesTransferred > 100000)
+        //                //    Console.WriteLine("BytesTransferred is large " + e.BytesTransferred);
+
+        //                recCount = e.BytesTransferred > e.Count ? e.Count : e.BytesTransferred;
+
+        //                receiveNetworkBuffer.Write(receiveBuffer, 0, (uint)recCount);
+
+        //                //OnReceive?.Invoke(receiveNetworkBuffer);
+        //                Receiver?.NetworkReceive(this, receiveNetworkBuffer);
+        //            }
+
+        //    }
+        //    catch (Exception ex)
+        //    {
+        //        if (state != SocketState.Closed && !sock.Connected)
+        //        {
+        //            state = SocketState.Terminated;
+        //            Close();
+        //        }
+
+        //        Global.Log("TCPSocket", LogType.Error, ex.ToString());
+        //    }
+        //}
+
+        public IPEndPoint LocalEndPoint
+        {
+            get { return (IPEndPoint)sock.LocalEndPoint; }
+        }
+
+        public TCPSocket()
+        {
+            sock = new Socket(AddressFamily.InterNetwork,
+                                 SocketType.Stream,
+                                 ProtocolType.Tcp);
+            receiveBuffer = new byte[sock.ReceiveBufferSize];
+            //receiveBufferSegment = new ArraySegment<byte>(receiveBuffer);
+
+        }
+
+        public TCPSocket(string hostname, ushort port)
+        {
+            // create the socket
+            sock = new Socket(AddressFamily.InterNetwork,
+                                             SocketType.Stream,
+                                             ProtocolType.Tcp);
+
+            receiveBuffer = new byte[sock.ReceiveBufferSize];
+            //receiveBufferSegment = new ArraySegment<byte>(receiveBuffer);
+
+            Connect(hostname, port);
+
+        }
+
+        //private void DataSent(Task<int> task)
+        //{
+        //    try
+        //    {
+        //        lock (sendLock)
+        //        {
+
+        //            if (sendBufferQueue.Count > 0)
+        //            {
+        //                byte[] data = sendBufferQueue.Dequeue();
+        //                //Console.WriteLine(Encoding.UTF8.GetString(data));
+        //                sock.SendAsync(new ArraySegment<byte>(data), SocketFlags.None).ContinueWith(DataSent);
+        //            }
+
+        //            else
+        //            {
+        //                asyncSending = false;
+        //            }
+        //        }
+        //    }
+        //    catch (Exception ex)
+        //    {
+        //        if (state != SocketState.Closed && !sock.Connected)
+        //        {
+        //            state = SocketState.Terminated;
+        //            Close();
+        //        }
+
+        //        asyncSending = false;
+
+        //        Global.Log("TCPSocket", LogType.Error, ex.ToString());
+        //    }
+        //}
+
+        public TCPSocket(IPEndPoint localEndPoint)
+        {
+            // create the socket
+            sock = new Socket(AddressFamily.InterNetwork,
+                                             SocketType.Stream,
+                                             ProtocolType.Tcp);
+
+            receiveBuffer = new byte[sock.ReceiveBufferSize];
+
+            state = SocketState.Listening;
+
+
+            // bind
+            sock.Bind(localEndPoint);
+
+            // start listening
+            sock.Listen(UInt16.MaxValue);
+
+
+        }
+
+
+
+
+        public IPEndPoint RemoteEndPoint
+        {
+            get { return (IPEndPoint)sock.RemoteEndPoint; }
+        }
+
+        public SocketState State
+        {
+            get
+            {
+                return state;
+            }
+        }
+
+
+        public TCPSocket(Socket socket)
+        {
+            sock = socket;
+            receiveBuffer = new byte[sock.ReceiveBufferSize];
+            // receiveBufferSegment = new ArraySegment<byte>(receiveBuffer);
+            if (socket.Connected)
+                state = SocketState.Established;
+        }
+
+        public void Close()
+        {
+            if (state != SocketState.Closed)// && state != SocketState.Terminated)
+            {
+                state = SocketState.Closed;
+
+                if (sock.Connected)
+                {
+                    try
+                    {
+                        sock.Shutdown(SocketShutdown.Both);
+                    }
+                    catch
+                    {
+
+                    }
+                }
+
+                try
+                {
+                    sendBufferQueue?.Clear();
+                    Receiver?.NetworkClose(this);
+                }
+                catch (Exception ex)
+                {
+                    Global.Log(ex);
+                }
+            }
+        }
+
+        public void Send(byte[] message)
+        {
+            Send(message, 0, message.Length);
+        }
+
+        public void Send(byte[] message, int offset, int size)
+        {
+            if (state == SocketState.Closed)// || state == SocketState.Terminated)
+                return;
+
+            var msg = message.Clip((uint)offset, (uint)size);
+
+            lock (sendLock)
+            {
+
+                if (state == SocketState.Closed)// || state == SocketState.Terminated)
+                    return;
+
+                if (!sock.Connected)
+                    return;
+
+                if (asyncSending || held)
+                {
+                    sendBufferQueue.Enqueue(new KeyValuePair<AsyncReply<bool>, byte[]>(null, msg));// message.Clip((uint)offset, (uint)size));
+                }
+                else
+                {
+                    asyncSending = true;
+                    try
+                    {
+                        sock.BeginSend(msg, 0, msg.Length, SocketFlags.None, sendCallback, this);
+                    }
+                    catch
+                    {
+                        asyncSending = false;
+                        //state = SocketState.Closed;//.Terminated;
+                        Close();
+                    }
+                    //sock.SendAsync(new ArraySegment<byte>(msg), SocketFlags.None).ContinueWith(DataSent);
+                }
+            }
+
+        }
+
+        private static void Flush(TCPSocket socket)
+        {
+            lock (socket.sendLock)
+            {
+
+                socket.currentReply?.Trigger(true);
+                socket.currentReply = null;
+
+                if (socket.state == SocketState.Closed) //|| socket.state == SocketState.Terminated)
+                    return;
+
+                if (socket.sendBufferQueue.Count > 0)
+                {
+                    var kv = socket.sendBufferQueue.Dequeue();
+
+                    try
+                    {
+                        socket.currentReply = kv.Key;
+                        socket.sock.BeginSend(kv.Value, 0, kv.Value.Length, SocketFlags.None,
+                                                    socket.sendCallback, socket);
+                    }
+                    catch (Exception ex)
+                    {
+                        socket.asyncSending = false;
+
+                        try
+                        {
+                            kv.Key?.Trigger(false);
+
+                            if (socket.state != SocketState.Closed && !socket.sock.Connected)
+                            {
+                                // socket.state = SocketState.Closed;// Terminated;
+                                socket.Close();
+                            }
+                        }
+                        catch (Exception ex2)
+                        {
+                            socket.Close();
+                            //socket.state = SocketState.Closed;// .Terminated;
+                        }
+
+                        Global.Log("TCPSocket", LogType.Error, ex.ToString());
+                    }
+                }
+                else
+                {
+                    socket.asyncSending = false;
+                }
+            }
+        }
+
+        private static void SendCallback(IAsyncResult ar)
+        {
+
+            try
+            {
+                var socket = (TCPSocket)ar.AsyncState;
+
+                socket.sock?.EndSend(ar);
+                Flush(socket);
+
+            }
+            catch (Exception ex)
+            {
+                Global.Log(ex);
+            }
+        }
+
+        public bool Trigger(ResourceTrigger trigger)
+        {
+            return true;
+        }
+
+        public void Destroy()
+        {
+            Global.Counters["Sck_D_1"]++;
+
+            Close();
+
+            receiveNetworkBuffer = null;
+            receiveCallback = null;
+            sendCallback = null;
+            sock = null;
+            receiveBuffer = null;
+            receiveNetworkBuffer = null;
+            sendBufferQueue = null;
+
+            //socketArgs.Completed -= SocketArgs_Completed;
+            //socketArgs.Dispose();
+            //socketArgs = null;
+            OnDestroy?.Invoke(this);
+            OnDestroy = null;
+
+            Global.Counters["Sck_D_2"]++;
+        }
+
+        public ISocket Accept()
+        {
+            try
+            {
+                var s = sock.Accept();
+                return new TCPSocket(s);
+            }
+            catch
+            {
+                state = SocketState.Closed;// Terminated;
+                return null;
+            }
+        }
+
+        public async AsyncReply<ISocket> AcceptAsync()
+        {
+            try
+            {
+                var s = await sock.AcceptAsync();
+                return new TCPSocket(s);
+            }
+            catch
+            {
+                state = SocketState.Closed;// Terminated;
+                return null;
+            }
+        }
+
+
+        public void Hold()
+        {
+            held = true;
+        }
+
+        public void Unhold()
+        {
+            try
+            {
+                Flush(this);
+                //SendCallback(null);
+            }
+            catch (Exception ex)
+            {
+                Console.WriteLine(ex);
+            }
+            finally
+            {
+                held = false;
+            }
+        }
+
+        public AsyncReply<bool> SendAsync(byte[] message, int offset, int length)
+        {
+
+            if (state == SocketState.Closed)// || state == SocketState.Terminated)
+                return new AsyncReply<bool>(false);
+
+            var msg = message.Clip((uint)offset, (uint)length);
+
+            lock (sendLock)
+            {
+                if (state == SocketState.Closed)// || state == SocketState.Terminated)
+                    return new AsyncReply<bool>(false);
+
+                if (!sock.Connected)
+                    return new AsyncReply<bool>(false);
+
+                var rt = new AsyncReply<bool>();
+
+                if (asyncSending || held)
+                {
+                    sendBufferQueue.Enqueue(new KeyValuePair<AsyncReply<bool>, byte[]>(rt, msg));
+                }
+                else
+                {
+                    asyncSending = true;
+                    try
+                    {
+                        currentReply = rt;
+                        sock.BeginSend(msg, 0, msg.Length, SocketFlags.None, sendCallback, this);// null);
+                    }
+                    catch (Exception ex)
+                    {
+                        rt.TriggerError(ex);
+                        asyncSending = false;
+                        //state = SocketState.Terminated;
+                        Close();
+                    }
+                    //sock.SendAsync(new ArraySegment<byte>(msg), SocketFlags.None).ContinueWith(DataSent);
+                }
+
+                return rt;
+            }
+        }
+    }
+}

Esiur/Net/Sockets/WSSocket.cs

@@ -0,0 +1,363 @@
+/*
+ 
+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.Net.Sockets;
+using System.Net;
+using Esiur.Net.Packets;
+using Esiur.Misc;
+using System.IO;
+using Esiur.Core;
+using Esiur.Resource;
+using Esiur.Data;
+using System.Globalization;
+
+namespace Esiur.Net.Sockets
+{
+    public class WSSocket : ISocket, INetworkReceiver<ISocket>
+    {
+        WebsocketPacket pkt_receive = new WebsocketPacket();
+        WebsocketPacket pkt_send = new WebsocketPacket();
+
+        ISocket sock;
+        NetworkBuffer receiveNetworkBuffer = new NetworkBuffer();
+        NetworkBuffer sendNetworkBuffer = new NetworkBuffer();
+
+        object sendLock = new object();
+        bool held;
+
+        //public event ISocketReceiveEvent OnReceive;
+        //public event ISocketConnectEvent OnConnect;
+        //public event ISocketCloseEvent OnClose;
+        public event DestroyedEvent OnDestroy;
+
+        long totalSent, totalReceived;
+
+        bool processing = false;
+
+        public IPEndPoint LocalEndPoint
+        {
+            get { return (IPEndPoint)sock.LocalEndPoint; }
+        }
+
+        public IPEndPoint RemoteEndPoint
+        {
+            get { return sock.RemoteEndPoint; }
+        }
+
+
+        public SocketState State
+        {
+            get
+            {
+                return sock.State;
+            }
+        }
+
+        public INetworkReceiver<ISocket> Receiver { get; set; }
+
+        public WSSocket(ISocket socket)
+        {
+            pkt_send.FIN = true;
+            pkt_send.Mask = false;
+            pkt_send.Opcode = WebsocketPacket.WSOpcode.BinaryFrame;
+            sock = socket;
+
+            sock.Receiver = this;
+
+            //sock.OnClose += Sock_OnClose;
+            //sock.OnConnect += Sock_OnConnect;
+            //sock.OnReceive += Sock_OnReceive;
+        }
+
+        //private void Sock_OnReceive(NetworkBuffer buffer)
+        //{
+
+        //}
+
+        //private void Sock_OnConnect()
+        //{
+        //    OnConnect?.Invoke();
+        //}
+
+        //private void Sock_OnClose()
+        //{
+        //    OnClose?.Invoke();
+        //}
+
+        public void Send(WebsocketPacket packet)
+        {
+            lock (sendLock)
+                if (packet.Compose())
+                    sock.Send(packet.Data);
+        }
+
+        public void Send(byte[] message)
+        {
+            lock (sendLock)
+            {
+                if (held)
+                {
+                    sendNetworkBuffer.Write(message);
+                }
+                else
+                {
+                    totalSent += message.Length;
+                    //Console.WriteLine("TX " + message.Length +"/"+totalSent);// + " " + DC.ToHex(message, 0, (uint)size));
+
+                    pkt_send.Message = message;
+
+
+                    if (pkt_send.Compose())
+                        sock.Send(pkt_send.Data);
+
+                }
+            }
+        }
+
+
+        public void Send(byte[] message, int offset, int size)
+        {
+            lock (sendLock)
+            {
+                if (held)
+                {
+                    sendNetworkBuffer.Write(message, (uint)offset, (uint)size);
+                }
+                else
+                {
+                    totalSent += size;
+                    //Console.WriteLine("TX " + size + "/"+totalSent);// + " " + DC.ToHex(message, 0, (uint)size));
+
+                    pkt_send.Message = new byte[size];
+                    Buffer.BlockCopy(message, offset, pkt_send.Message, 0, size);
+                    if (pkt_send.Compose())
+                        sock.Send(pkt_send.Data);
+                }
+            }
+        }
+
+
+        public void Close()
+        {
+            sock?.Close();
+        }
+
+        public AsyncReply<bool> Connect(string hostname, ushort port)
+        {
+            throw new NotImplementedException();
+        }
+
+
+        public bool Begin()
+        {
+            return sock.Begin();
+        }
+
+        public bool Trigger(ResourceTrigger trigger)
+        {
+            return true;
+        }
+
+        public void Destroy()
+        {
+            Close();
+            //OnClose = null;
+            //OnConnect = null;
+            //OnReceive = null;
+            receiveNetworkBuffer = null;
+            //sock.OnReceive -= Sock_OnReceive;
+            //sock.OnClose -= Sock_OnClose;
+            //sock.OnConnect -= Sock_OnConnect;
+            sock.Receiver = null;
+            sock = null;
+            OnDestroy?.Invoke(this);
+            OnDestroy = null;
+        }
+
+        public AsyncReply<ISocket> AcceptAsync()
+        {
+            throw new NotImplementedException();
+        }
+
+        public void Hold()
+        {
+            //Console.WriteLine("WS Hold  ");
+            held = true;
+        }
+
+        public void Unhold()
+        {
+            lock (sendLock)
+            {
+                held = false;
+
+                var message = sendNetworkBuffer.Read();
+
+                //Console.WriteLine("WS Unhold {0}", message == null ? 0 : message.Length);
+
+                if (message == null)
+                    return;
+
+                totalSent += message.Length;
+
+                pkt_send.Message = message;
+                if (pkt_send.Compose())
+                    sock.Send(pkt_send.Data);
+
+
+
+            }
+        }
+
+        public AsyncReply<bool> SendAsync(byte[] message, int offset, int length)
+        {
+            throw new NotImplementedException();
+        }
+
+        public ISocket Accept()
+        {
+            throw new NotImplementedException();
+        }
+
+        public AsyncReply<bool> BeginAsync()
+        {
+            return sock.BeginAsync();
+        }
+
+        public void NetworkClose(ISocket sender)
+        {
+            Receiver?.NetworkClose(sender);
+        }
+
+        public void NetworkReceive(ISocket sender, NetworkBuffer buffer)
+        {
+
+            if (sock.State == SocketState.Closed)// || sock.State == SocketState.Terminated)
+                return;
+
+            if (buffer.Protected)
+                return;
+
+            if (processing)
+                return;
+
+
+            var msg = buffer.Read();
+
+            if (msg == null)
+                return;
+
+            var wsPacketLength = pkt_receive.Parse(msg, 0, (uint)msg.Length);
+            //Console.WriteLine("WSP: " + wsPacketLength);
+
+            if (wsPacketLength < 0)
+            {
+                buffer.Protect(msg, 0, (uint)msg.Length + (uint)-wsPacketLength);
+                return;
+            }
+
+            uint offset = 0;
+
+            while (wsPacketLength > 0)
+            {
+                if (pkt_receive.Opcode == WebsocketPacket.WSOpcode.ConnectionClose)
+                {
+                    Close();
+                    return;
+                }
+                else if (pkt_receive.Opcode == WebsocketPacket.WSOpcode.Ping)
+                {
+                    var pkt_pong = new WebsocketPacket();
+
+                    pkt_pong.FIN = true;
+                    pkt_pong.Mask = false;
+                    pkt_pong.Opcode = WebsocketPacket.WSOpcode.Pong;
+                    pkt_pong.Message = pkt_receive.Message;
+                    offset += (uint)wsPacketLength;
+
+                    Send(pkt_pong);
+                }
+                else if (pkt_receive.Opcode == WebsocketPacket.WSOpcode.Pong)
+                {
+                    offset += (uint)wsPacketLength;
+                }
+                else if (pkt_receive.Opcode == WebsocketPacket.WSOpcode.BinaryFrame
+                        || pkt_receive.Opcode == WebsocketPacket.WSOpcode.TextFrame
+                        || pkt_receive.Opcode == WebsocketPacket.WSOpcode.ContinuationFrame)
+                {
+                    totalReceived += pkt_receive.Message.Length;
+                    //Console.WriteLine("RX " + pkt_receive.Message.Length + "/" + totalReceived);// + " " + DC.ToHex(message, 0, (uint)size));
+
+                    receiveNetworkBuffer.Write(pkt_receive.Message);
+                    offset += (uint)wsPacketLength;
+
+                    //Console.WriteLine("WS IN: " + pkt_receive.Opcode.ToString() + " " + pkt_receive.Message.Length + " | " + offset + " " + string.Join(" ", pkt_receive.Message));//  DC.ToHex(pkt_receive.Message));
+
+                }
+                else
+                    Console.WriteLine("Unknown WS opcode:" + pkt_receive.Opcode);
+
+                if (offset == msg.Length)
+                {
+
+                    //OnReceive?.Invoke(receiveNetworkBuffer);
+                    Receiver?.NetworkReceive(this, receiveNetworkBuffer);
+                    return;
+                }
+
+                wsPacketLength = pkt_receive.Parse(msg, offset, (uint)msg.Length);
+            }
+
+            if (wsPacketLength < 0)//(offset < msg.Length) && (offset > 0))
+            {
+                //receiveNetworkBuffer.HoldFor(msg, offset, (uint)(msg.Length - offset), (uint)msg.Length + (uint)-wsPacketLength);
+                // save the incomplete packet to the heldBuffer queue
+
+                buffer.HoldFor(msg, offset, (uint)(msg.Length - offset), (uint)(msg.Length - offset) + (uint)-wsPacketLength);
+
+            }
+
+            //Console.WriteLine("WS IN: " + receiveNetworkBuffer.Available);
+
+            //OnReceive?.Invoke(receiveNetworkBuffer);
+            Receiver?.NetworkReceive(this, receiveNetworkBuffer);
+
+            processing = false;
+
+            if (buffer.Available > 0 && !buffer.Protected)
+                Receiver?.NetworkReceive(this, buffer);
+                //Sock_OnReceive(buffer);
+        }
+
+ 
+        public void NetworkConnect(ISocket sender)
+        {
+            Receiver?.NetworkConnect(this);
+        }
+    }
+}

Esiur/Net/TCP/TCPConnection.cs

@@ -0,0 +1,66 @@
+/*
+ 
+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 Esiur.Net.Sockets;
+using System.Net;
+using System.Collections;
+using Esiur.Misc;
+using Esiur.Data;
+
+namespace Esiur.Net.TCP
+{
+    public class TCPConnection:NetworkConnection    {
+
+        private KeyList<string, object> variables = new KeyList<string, object>();
+
+        public TCPServer Server { get; internal set; }
+
+        public KeyList<string, object> Variables
+        {
+            get
+            {
+                return variables;
+            }
+        }
+
+        protected override void Connected()
+        {
+            // do nothing
+        }
+
+        protected override void DataReceived(NetworkBuffer buffer)
+        {
+            Server?.Execute(this, buffer);
+        }
+
+        protected override void Disconencted()
+        {
+            // do nothing
+        }
+    }
+}

Esiur/Net/TCP/TCPFilter.cs

@@ -0,0 +1,66 @@
+/*
+ 
+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.Collections;
+using Esiur.Data;
+using Esiur.Net.Sockets;
+using Esiur.Core;
+using Esiur.Resource;
+
+namespace Esiur.Net.TCP
+{
+    public abstract class TCPFilter: IResource
+    {
+        public Instance Instance
+        {
+            get;
+            set;
+        }
+
+        public event DestroyedEvent OnDestroy;
+
+        public abstract AsyncReply<bool> Trigger(ResourceTrigger trigger);
+
+        public virtual bool Connected(TCPConnection sender)
+        {
+            return false;
+        }
+
+        public virtual bool Disconnected(TCPConnection sender)
+        {
+            return false;
+        }
+
+        public abstract bool Execute(byte[] msg, NetworkBuffer data, TCPConnection sender);
+
+        public void Destroy()
+        {
+            throw new NotImplementedException();
+        }
+    }
+}

Esiur/Net/TCP/TCPServer.cs

@@ -0,0 +1,156 @@
+/*
+ 
+Copyright (c) 2017-2019 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 Esiur.Net.Sockets;
+using Esiur.Misc;
+using System.Threading;
+using Esiur.Data;
+using Esiur.Core;
+using System.Net;
+using Esiur.Resource;
+
+namespace Esiur.Net.TCP
+{
+    public class TCPServer : NetworkServer<TCPConnection>, IResource
+    {
+
+        [Attribute]
+        public string IP
+        {
+            get;
+            set;
+        }
+        [Attribute]
+        public ushort Port
+        {
+            get;
+            set;
+        }
+        //[Storable]
+        //public uint Timeout
+        //{
+        //    get;
+        //    set;
+        //}
+        //[Attribute]
+        //public uint Clock
+        //{
+        //    get;
+        //    set;
+        //}
+        public Instance Instance { get; set; }
+
+        TCPFilter[] filters = null;
+
+
+        public AsyncReply<bool> Trigger(ResourceTrigger trigger)
+        {
+            if (trigger == ResourceTrigger.Initialize)
+            {
+                TCPSocket listener;
+
+
+                if (IP != null)
+                    listener = new TCPSocket(new IPEndPoint(IPAddress.Parse(IP), Port));
+                else
+                    listener = new TCPSocket(new IPEndPoint(IPAddress.Any, Port));
+
+                Start(listener);
+
+
+            }
+            else if (trigger == ResourceTrigger.Terminate)
+            {
+                Stop();
+            }
+            else if (trigger == ResourceTrigger.SystemReload)
+            {
+                Trigger(ResourceTrigger.Terminate);
+                Trigger(ResourceTrigger.Initialize);
+            }
+            else if (trigger == ResourceTrigger.SystemInitialized)
+            {
+                Instance.Children<TCPFilter>().Then(x => filters = x);
+            }
+
+            return new AsyncReply<bool>(true);
+        }
+
+
+
+
+
+        internal bool Execute(TCPConnection sender, NetworkBuffer data)
+        {
+            var msg = data.Read();
+
+            foreach (var filter in filters)
+            {
+                if (filter.Execute(msg, data, sender))
+                    return true;
+            }
+
+            return false;
+        }
+
+        private void SessionModified(TCPConnection session, string key, object newValue)
+        {
+
+        }
+
+        protected override void ClientDisconnected(TCPConnection connection)
+        {
+            
+            foreach (var filter in filters)
+            {
+                filter.Disconnected(connection);
+            }
+        }
+
+        public override void Add(TCPConnection connection)
+        {
+            connection.Server = this;
+            base.Add(connection);
+        }
+
+        public override void Remove(TCPConnection connection)
+        {
+            connection.Server = null;
+            base.Remove(connection);
+        }
+
+        protected override void ClientConnected(TCPConnection connection)
+        {
+            foreach (var filter in filters)
+            {
+                filter.Connected(connection);
+            }
+        }
+
+     }
+}

Esiur/Net/TCP/TCPSession.cs

@@ -0,0 +1,37 @@
+/*
+ 
+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;
+
+namespace Esiur.Net.TCP
+{
+    public class TCPSession : NetworkSession
+    {
+
+    }
+}

Esiur/Net/UDP/UDPFilter.cs

@@ -0,0 +1,57 @@
+/*
+ 
+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.Collections;
+using System.Net;
+using Esiur.Data;
+using Esiur.Core;
+using Esiur.Resource;
+
+namespace Esiur.Net.UDP
+{
+    public abstract class UDPFilter : IResource
+    {
+        public Instance Instance
+        {
+            get;
+            set;
+        }
+
+
+        public event DestroyedEvent OnDestroy;
+
+        public abstract AsyncReply<bool> Trigger(ResourceTrigger trigger);
+
+        public abstract bool Execute(byte[] data, IPEndPoint sender);
+
+        public void Destroy()
+        {
+            throw new NotImplementedException();
+        }
+    }
+}

Esiur/Net/UDP/UDPServer.cs

@@ -0,0 +1,204 @@
+/*
+ 
+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.Net;
+using System.Net.Sockets;
+using System.Threading;
+using System.Text;
+using System.Collections;
+using Esiur.Data;
+using Esiur.Misc;
+using Esiur.Resource;
+using Esiur.Core;
+
+namespace Esiur.Net.UDP
+{
+
+    /* public class IIPConnection
+    {
+        public EndPoint SenderPoint;
+        public 
+    }*/
+    public class UDPServer : IResource
+    {
+        Thread receiver;
+        UdpClient udp;
+        UDPFilter[] filters = new UDPFilter[0];
+
+        public event DestroyedEvent OnDestroy;
+
+        public Instance Instance
+        {
+            get;
+            set;
+        }
+
+        [Attribute]
+        string IP
+        {
+            get;
+            set;
+        }
+
+        [Attribute]
+        ushort Port
+        {
+            get;
+            set;
+        }
+
+         private void Receiving()
+        {
+            IPEndPoint ep = new IPEndPoint(IPAddress.Any, 0);
+
+
+            while (true)
+            {
+                byte[] b = udp.Receive(ref ep);
+
+                foreach (var child in filters)
+                {
+                    var f = child as UDPFilter;
+
+                    try
+                    {
+                        if (f.Execute(b, ep))
+                        {
+                            break;
+                        }
+                    }
+                    catch (Exception ex)
+                    {
+                        Global.Log("UDPServer", LogType.Error, ex.ToString());
+                        //Console.WriteLine(ex.ToString());
+                    }
+                }
+            }
+        }
+
+        public bool Send(byte[] Data, int Count, IPEndPoint EP)
+        {
+            try
+            {
+                udp.Send(Data, Count, EP);
+                return true;
+            }
+            catch
+            {
+                return false;
+            }
+        }
+        public bool Send(byte[] Data, IPEndPoint EP)
+        {
+            try
+            {
+                udp.Send(Data, Data.Length, EP);
+                return true;
+            }
+            catch
+            {
+                return false;
+            }
+        }
+        public bool Send(byte[] Data, int Count, string Host, int Port)
+        {
+            try
+            {
+                udp.Send(Data, Count, Host, Port);
+                return true;
+            }
+            catch
+            {
+                return false;
+            }
+        }
+        public bool Send(byte[] Data, string Host, int Port)
+        {
+            try
+            {
+                udp.Send(Data, Data.Length, Host, Port);
+                return true;
+            }
+            catch
+            {
+                return false;
+            }
+        }
+        public bool Send(string Data, IPEndPoint EP)
+        {
+            try
+            {
+                udp.Send(Encoding.Default.GetBytes(Data), Data.Length, EP);
+                return true;
+            }
+            catch
+            {
+                return false;
+            }
+        }
+        public bool Send(string Data, string Host, int Port)
+        {
+            try
+            {
+                udp.Send(Encoding.Default.GetBytes(Data), Data.Length, Host, Port);
+                return true;
+            }
+            catch
+            {
+                return false;
+            }
+        }
+
+        public void Destroy()
+        {
+            udp.Close();
+            OnDestroy?.Invoke(this);
+        }
+
+        async AsyncReply<bool> IResource.Trigger(ResourceTrigger trigger)
+        {
+            if (trigger == ResourceTrigger.Initialize)
+            {
+                var address = IP == null ? IPAddress.Any : IPAddress.Parse(IP);
+
+                udp = new UdpClient(new IPEndPoint(address, Port));
+
+                receiver = new Thread(Receiving);
+                receiver.Start();
+            }
+            else if (trigger == ResourceTrigger.Terminate)
+            {
+                if (receiver != null)
+                    receiver.Abort();
+            }
+            else if (trigger == ResourceTrigger.SystemInitialized)
+            {
+                filters = await Instance.Children<UDPFilter>();
+            }
+
+            return true;
+        }
+    }
+}