Add project files.

Esiur/Net/Sockets/ISocket.cs

@@ -0,0 +1,39 @@
+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.Engine;
+
+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;
+
+        void Send(byte[] message);
+        void Send(byte[] message, int offset, int size);
+        void Close();
+        bool Connect(string hostname, ushort port);
+        bool Begin();
+        //ISocket Accept();
+        AsyncReply<ISocket> Accept();
+        IPEndPoint RemoteEndPoint { get; }
+        IPEndPoint LocalEndPoint { get; }
+    }
+}

Esiur/Net/Sockets/SSLSocket.cs

@@ -0,0 +1,310 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Net.Sockets;
+using System.Net;
+using Esiur.Misc;
+using Esiur.Engine;
+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
+    {
+        Socket sock;
+        byte[] receiveBuffer;
+ 
+        NetworkBuffer receiveNetworkBuffer = new NetworkBuffer();
+
+        object sendLock = new object();
+
+        Queue<byte[]> sendBufferQueue = new Queue<byte[]>();
+
+        bool asyncSending;
+
+
+        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;
+
+        private void Connected(Task t)
+        {
+            if (server)
+            {
+                ssl.AuthenticateAsServerAsync(cert).ContinueWith(Authenticated);
+            }
+            else
+            {
+                ssl.AuthenticateAsClientAsync(hostname).ContinueWith(Authenticated);
+            }
+        }
+
+        public bool Connect(string hostname, ushort port)
+        {
+            try
+            {
+                this.hostname = hostname;
+                server = false;
+                state = SocketState.Connecting;
+                sock.ConnectAsync(hostname, port).ContinueWith(Connected);
+                return true;
+            }
+            catch
+            {
+                return false;
+            }
+        }
+
+        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());
+            }
+        }
+
+
+ 
+        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;
+
+        }
+
+ 
+        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;
+                }
+            }
+
+            sock.Shutdown(SocketShutdown.Both);
+
+            OnClose?.Invoke();
+        }
+
+        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);
+                }
+            }
+        }
+
+        void Authenticated(Task task)
+        {
+            try
+            {
+                state = SocketState.Established;
+                OnConnect?.Invoke();
+
+                if (!server)
+                    Begin();
+            }
+            catch (Exception ex)
+            {
+                state = SocketState.Terminated;
+                Close();
+                Global.Log(ex);
+            }
+        }
+
+        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);
+                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 (state == SocketState.Established)
+            {
+                ssl.ReadAsync(receiveBuffer, 0, receiveBuffer.Length).ContinueWith(DataReceived);
+                return true;
+            }
+            else
+                return false;
+        }
+
+
+
+        public bool Trigger(ResourceTrigger trigger)
+        {
+            return true;
+        }
+
+        public void Destroy()
+        {
+            Close();
+            OnDestroy?.Invoke(this);
+        }
+
+        public AsyncReply<ISocket> Accept()
+        {
+            var reply = new AsyncReply<ISocket>();
+
+            try
+            {
+                sock.AcceptAsync().ContinueWith((x) =>
+                {
+                    try
+                    {
+                        reply.Trigger(new SSLSocket(x.Result, cert, true));
+                    }
+                    catch
+                    {
+                        reply.Trigger(null);
+                    }
+
+                }, null);
+
+            }
+            catch
+            {
+                state = SocketState.Terminated;
+                return null;
+            }
+
+            return reply;
+        }
+    }
+}

Esiur/Net/Sockets/SocketState.cs

@@ -0,0 +1,18 @@
+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,291 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Net.Sockets;
+using System.Net;
+using Esiur.Misc;
+using Esiur.Engine;
+using System.Threading;
+using Esiur.Resource;
+using System.Threading.Tasks;
+using Esiur.Data;
+
+namespace Esiur.Net.Sockets
+{
+    public class TCPSocket : ISocket
+    {
+        Socket sock;
+        byte[] receiveBuffer;
+
+        ArraySegment<byte> receiveBufferSegment;
+
+        NetworkBuffer receiveNetworkBuffer = new NetworkBuffer();
+
+        object sendLock = new object();
+
+        Queue<byte[]> sendBufferQueue = new Queue<byte[]>();
+
+        bool asyncSending;
+
+
+        SocketState state = SocketState.Initial;
+
+        public event ISocketReceiveEvent OnReceive;
+        public event ISocketConnectEvent OnConnect;
+        public event ISocketCloseEvent OnClose;
+        public event DestroyedEvent OnDestroy;
+
+
+        private void Connected(Task t)
+        {
+            state = SocketState.Established;
+            OnConnect?.Invoke();
+            Begin();
+        }
+
+        public bool Begin()
+        {
+            sock.ReceiveAsync(receiveBufferSegment, SocketFlags.None).ContinueWith(DataReceived);
+            return true;
+        }
+
+        public bool Connect(string hostname, ushort port)
+        {
+            try
+            {
+                state = SocketState.Connecting;
+                sock.ConnectAsync(hostname, port).ContinueWith(Connected);
+                return true;
+            }
+            catch
+            {
+                return false;
+            }
+        }
+
+
+        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);
+                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());
+            }
+        }
+
+
+        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
+            {
+
+                if (sendBufferQueue.Count > 0)
+                {
+                    byte[] data = sendBufferQueue.Dequeue();
+                    lock (sendLock)
+                        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
+                {
+                    state = SocketState.Terminated;
+                }
+
+                sock.Shutdown(SocketShutdown.Both);// Close();
+                OnClose?.Invoke();
+            }
+
+        }
+
+        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;
+                    sock.SendAsync(new ArraySegment<byte>(message, offset, size), SocketFlags.None).ContinueWith(DataSent);
+                }
+            }
+        }
+
+
+
+        public bool Trigger(ResourceTrigger trigger)
+        {
+            return true;
+        }
+
+        public void Destroy()
+        {
+            Close();
+            OnDestroy?.Invoke(this);
+        }
+
+        public AsyncReply<ISocket> Accept()
+        {
+            var reply = new AsyncReply<ISocket>();
+
+            try
+            {
+                sock.AcceptAsync().ContinueWith((x) =>
+                {
+                    try
+                    {
+                        reply.Trigger(new TCPSocket(x.Result));
+                    }
+                    catch
+                    {
+                        reply.Trigger(null);
+                    }
+                });
+            }
+            catch
+            {
+                state = SocketState.Terminated;
+                return null;
+            }
+
+            return reply;
+        }
+    }
+}

Esiur/Net/Sockets/WSSocket.cs

@@ -0,0 +1,220 @@
+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.Engine;
+using Esiur.Resource;
+
+namespace Esiur.Net.Sockets
+{
+    public class WSSocket : ISocket
+    {
+        WebsocketPacket pkt_receive = new WebsocketPacket();
+        WebsocketPacket pkt_send = new WebsocketPacket();
+
+        ISocket sock;
+        NetworkBuffer receiveNetworkBuffer = new NetworkBuffer();
+        object sendLock = new object();
+
+        public event ISocketReceiveEvent OnReceive;
+        public event ISocketConnectEvent OnConnect;
+        public event ISocketCloseEvent OnClose;
+        public event DestroyedEvent OnDestroy;
+
+        long totalSent, totalReceived;
+
+        public IPEndPoint LocalEndPoint
+        {
+            get { return (IPEndPoint)sock.LocalEndPoint; }
+        }
+
+  
+        
+    public IPEndPoint RemoteEndPoint
+    {
+        get { return sock.RemoteEndPoint; }
+    }
+    
+
+        public SocketState State
+        {
+            get
+            {
+                return sock.State;
+            }
+        }
+
+ 
+        public WSSocket(ISocket socket)
+        {
+            pkt_send.FIN = true;
+            pkt_send.Mask = false;
+            pkt_send.Opcode = WebsocketPacket.WSOpcode.BinaryFrame;
+            sock = socket;
+            sock.OnClose += Sock_OnClose;
+            sock.OnConnect += Sock_OnConnect;
+            sock.OnReceive += Sock_OnReceive;
+        }
+
+        private void Sock_OnReceive(NetworkBuffer buffer)
+        {
+
+            if (sock.State == SocketState.Closed || sock.State == SocketState.Terminated)
+                return;
+
+            if (buffer.Protected)
+                return;
+
+            var msg = buffer.Read();
+
+            var wsPacketLength = pkt_receive.Parse(msg, 0, (uint)msg.Length);
+
+            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;
+                }
+                else
+                    Console.WriteLine("Unknown WS opcode:" + pkt_receive.Opcode);
+
+                if (offset == msg.Length)
+                {
+                    OnReceive?.Invoke(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
+
+                receiveNetworkBuffer.HoldFor(msg, offset, (uint)(msg.Length - offset), (uint)(msg.Length - offset) + (uint)-wsPacketLength);
+
+            }
+
+            OnReceive?.Invoke(receiveNetworkBuffer);
+        }
+
+        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)
+            {
+                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)
+            {
+                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 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();
+            OnDestroy?.Invoke(this);
+        }
+
+        public AsyncReply<ISocket> Accept()
+        {
+            throw new NotImplementedException();
+        }
+    }
+}