code/Net/Socket.cs

Go to the documentation of this file.

/*
using System;
using System.Collections.Generic;
using System.Text;
using System.Windows.Forms;
using System.Net;
using System.Runtime.InteropServices;
using System.Collections;
using System.Data;
using System.Diagnostics;
*/

namespace Sylloge
{
    public static partial class Net
    {
        public const string IP_ADDRESS_UNDEFINED = "0.0.0.0";

        public abstract class Socket : System.IDisposable
        {
            public enum KeepAliveType
            {
                NONE,
                CUSTOM,
                TCP
            }

            #region Events

            public delegate void DelegateDataReceived(byte[] data);
            public event DelegateDataReceived DataReceived;

            public delegate void DelegateSocketError(System.Exception ex);
            public event DelegateSocketError SocketError;

            public delegate void DelegateConnectionCloseError(System.Exception ex);
            public event DelegateConnectionCloseError ConnectionCloseError;

            protected void OnDataReceived(byte[] data)
            {
                if (DataReceived != null) { DataReceived(data); }
            }

            protected void OnSocketError(System.Exception ex)
            {
                if (SocketError != null) { SocketError(ex); }
            }

            protected void OnConnectionCloseError(System.Exception ex)
            {
                if (ConnectionCloseError != null) { ConnectionCloseError(ex); }
            }

            #endregion

            #region Local Attributes

            protected System.IAsyncResult m_AsyncResult { get; private set; }
            protected System.Windows.Forms.Timer m_KeepAlive { get; set; }
            protected System.Threading.Thread m_ListenThread { get; set; }
            protected byte[] m_Msg { get; set; }
            protected KeepAliveType m_KeepAliveType { get; set; }

            public bool IsClosing { get; protected set; }
            public bool IsConnected { get; protected set; }
            public bool IsLocalHost { get; protected set; }
            public string IpAddress { get; set; }
            public bool IsRunning { get; protected set; }
            public int Port { get; set; }
            public System.Net.Sockets.Socket Handle { get; protected set; }
            public System.Net.Sockets.NetworkStream Stream { get; protected set; }

            #endregion

            #region Class Methods

            public Socket()
            {
                this.Initialize();
            }

            public Socket(string ipAddress, int port)
            {
                this.Initialize();
                this.IpAddress = IpAddress;
                this.Port = port;
            }

            ~Socket()
            {
                if (this.IsConnected) { this.Close(); }
            }

            public virtual Sylloge.Net.Socket Copy()
            {
                System.Runtime.Serialization.Formatters.Binary.BinaryFormatter val =
                    new System.Runtime.Serialization.Formatters.Binary.BinaryFormatter();
                System.IO.MemoryStream s = new System.IO.MemoryStream();
                val.Serialize(s, this);
                Sylloge.Net.Socket res = (Sylloge.Net.Socket)val.Deserialize(s);
                res.Close();
                return res;
            }

            protected void Configure(KeepAliveType type, byte[] msg, int msInterval)
            {
                this.m_KeepAliveType = type;
                if (this.m_KeepAliveType == KeepAliveType.CUSTOM) {
                    if (msg != null && msg.Length > 0) {
                        this.m_Msg = new byte[msg.Length];
                        System.Buffer.BlockCopy(msg, 0, this.m_Msg, 0, msg.Length);
                    }
                }
            }

            public void Dispose()
            {
                if (this.IsConnected) { this.Close(); }
            }

            public void Flush()
            {
                this.Stream.Flush();
            }

            public void Initialize()
            {
                this.IpAddress = "0.0.0.0";
                this.Port = 0;
                this.IsClosing = false;
                this.IsConnected = false;
                this.IsRunning = false;
                this.IsLocalHost = false;
            }

            public string IpAndPortString
            {
                get
                {
                    string Value = (this.IpAddress + ":" + this.Port.ToString());
                    if (this.IsLocalHost) { Value = "Local Machine"; }
                    return Value;
                }
            }

            public void Shutdown()
            {
                this.IsRunning = false;
                if (this.IsClosing) { return; }
                this.IsClosing = true;
                if (this.IsLocalHost) { return; }
                if (this.m_KeepAlive != null) { this.m_KeepAlive.Enabled = false; }
                if (this.Handle != null) {
                    try {
                        this.Handle.Shutdown(System.Net.Sockets.SocketShutdown.Both);
                        this.Handle.Disconnect(true);
                        this.Handle.Close();
                    } catch (System.Exception ex) {
                        this.OnConnectionCloseError(ex);
                    }
                }
                this.IsConnected = false;
                if (this.Stream != null) {
                    try {
                        this.Stream.Close();
                    } catch (System.Exception ex) {
                        this.OnConnectionCloseError(ex);
                    }
                }
                if (this.m_ListenThread != null) {
                    try {
                        this.m_ListenThread.Abort();
                    } catch (System.Threading.ThreadAbortException threadEx) {
                        System.Console.WriteLine("Thread abort exception: " + threadEx.Message);
                    } catch (System.Exception ex) {
                        this.OnConnectionCloseError(ex);
                    }
                }
                this.m_KeepAlive = null;
                this.m_ListenThread = null;
            }

            public override string ToString()
            {
                return this.IpAndPortString;
            }

            #endregion

            #region Virtual Methods

            public abstract void Close();

            public abstract void Connect(Socket.KeepAliveType type = KeepAliveType.NONE, byte[] msg = null, int msInterval = 0);

            public abstract void Listen();

            public abstract void Send(byte[] data);

            #endregion
        }

        public class TcpSocket : Sylloge.Net.Socket
        {
            public System.Net.Sockets.TcpClient Client { get; protected set; }
            public System.Net.Sockets.TcpListener Listener { get; protected set; }

            public TcpSocket()
            {
            }

            public TcpSocket(string ipAddress, int port)
            {
                this.IpAddress = IpAddress;
                this.Port = port;
            }

            public override Sylloge.Net.Socket Copy()
            {
                System.Runtime.Serialization.Formatters.Binary.BinaryFormatter val =
                    new System.Runtime.Serialization.Formatters.Binary.BinaryFormatter();
                System.IO.MemoryStream s = new System.IO.MemoryStream();
                val.Serialize(s, this);
                Sylloge.Net.Socket res = (Sylloge.Net.Socket)val.Deserialize(s);
                res.Close();
                return res;
            }

            public override void Close()
            {
                if (this.Listener != null) {
                    try {
                        this.Listener.Stop();
                    } catch (System.Exception ex) {
                        this.OnConnectionCloseError(ex);
                    }
                }
                this.Shutdown();
                if (this.Client != null) {
                    try {
                        this.Client.Close();
                    } catch (System.Exception ex) {
                        this.OnConnectionCloseError(ex);
                    }
                }
                this.Listener = null;
                this.Client = null;
            }

            public override void Connect(Socket.KeepAliveType type = KeepAliveType.NONE, byte[] msg = null, int msInterval = 0)
            {
                this.IsClosing = false;
                try {
                    System.Net.IPAddress ipa = new System.Net.IPAddress(0);
                    System.Net.IPAddress.TryParse(this.IpAddress, out ipa);
                    try {
                        this.Client = new System.Net.Sockets.TcpClient();
                        this.Handle = this.Client.Client;
                        this.Client.Connect(ipa, this.Port);
                        this.Stream = this.Client.GetStream();
                    } catch (System.Exception ex) {
                        this.OnSocketError(ex);
                        return;
                    }
                } catch (System.Exception ex) {
                    this.OnSocketError(ex);
                    return;
                }
                this.IsConnected = true;
                this.Configure(type, msg, msInterval);
                switch (type) {
                    case KeepAliveType.CUSTOM:
                        this.m_KeepAlive = new System.Windows.Forms.Timer();
                        this.m_KeepAlive.Tick += new System.EventHandler(this.TcpKeepAlive_Tick);
                        this.m_KeepAlive.Interval = msInterval;
                        this.m_KeepAlive.Enabled = true;
                        break;
                    case KeepAliveType.TCP:
                        this.Client.Client.SetSocketOption(System.Net.Sockets.SocketOptionLevel.Tcp, System.Net.Sockets.SocketOptionName.KeepAlive, true);
                        break;
                }
            }

            public override void Listen()
            {
                this.IsClosing = false;
                if (this.IsLocalHost) { return; }
                try {
                    System.Net.IPAddress IPAddress = new System.Net.IPAddress(0);
                    System.Net.IPAddress.TryParse(this.IpAddress, out IPAddress);
                    try {
                        this.Listener = new System.Net.Sockets.TcpListener(IPAddress, this.Port);
                        this.Client = new System.Net.Sockets.TcpClient();
                        this.Handle = this.Client.Client;
                        this.Listener.Start();
                        this.Client = this.Listener.AcceptTcpClient();
                        System.Threading.ThreadStart ListenThreadStart = new System.Threading.ThreadStart(this.TcpListenerThread);
                        this.m_ListenThread = new System.Threading.Thread(ListenThreadStart);
                        this.IsRunning = true;
                        this.m_ListenThread.Start();
                        this.IsConnected = true;
                    } catch (System.Exception ex) {
                        this.OnSocketError(ex);
                    }
                } catch (System.Exception ex) {
                    this.OnSocketError(ex);
                }
            }

            private void TcpListenerThread()
            {
                try {
                    byte[] ReceievedBytes = null;
                    do {
                        System.Windows.Forms.Application.DoEvents();
                        this.Stream = this.Client.GetStream();
                        ReceievedBytes = new byte[this.Client.ReceiveBufferSize];
                        this.Stream.Read(ReceievedBytes, 0, this.Client.ReceiveBufferSize);
                        this.OnDataReceived(ReceievedBytes);
                    } while (this.IsRunning);
                } catch (System.Threading.ThreadAbortException threadEx) {
                    System.Console.WriteLine("Thread aborting: " + threadEx.Message);
                } catch (System.Exception ex) {
                    this.OnSocketError(ex);
                }
                this.IsConnected = false;
            }

            public override void Send(byte[] data)
            {
                try {
                    this.Stream.Write(data, 0, data.Length);
                    this.Stream.Flush();
                } catch (System.Exception ex) {
                    System.Console.WriteLine("Error sending data: " + ex.Message);
                    this.OnSocketError(ex);
                }
            }

            private void TcpKeepAlive_Tick(object sender, System.EventArgs e)
            {
                if (this.IsConnected && this.Client.Connected && this.Stream != null) {
                    try {
                        this.Stream.Write(this.m_Msg, 0, this.m_Msg.Length); // send null bytes to keep alive
                    } catch (System.Exception ex) {
                        this.OnSocketError(ex);
                    }
                }
            }

            public override string ToString()
            {
                return this.IpAndPortString;
            }
        }

        public class UdpSocket : Sylloge.Net.Socket
        {
            public System.Net.Sockets.UdpClient Client { get; protected set; }

            public UdpSocket()
            {
            }

            public UdpSocket(string ipAddress, int port)
            {
                this.IpAddress = IpAddress;
                this.Port = port;
            }

            public override Sylloge.Net.Socket Copy()
            {
                System.Runtime.Serialization.Formatters.Binary.BinaryFormatter val =
                    new System.Runtime.Serialization.Formatters.Binary.BinaryFormatter();
                System.IO.MemoryStream s = new System.IO.MemoryStream();
                val.Serialize(s, this);
                Sylloge.Net.Socket res = (Sylloge.Net.Socket)val.Deserialize(s);
                res.Close();
                return res;
            }

            public override void Close()
            {
                this.Shutdown();
                if (this.Client != null) {
                    try {
                        this.Client.Close();
                    } catch (System.Exception ex) {
                        this.OnConnectionCloseError(ex);
                    }
                }
                this.Client = null;
            }

            public override void Connect(Socket.KeepAliveType type = KeepAliveType.NONE, byte[] msg = null, int msInterval = 0)
            {
                this.IsClosing = false;
                System.Net.Sockets.UdpClient x = new System.Net.Sockets.UdpClient();
                try {
                    System.Net.IPAddress ipad = new System.Net.IPAddress(0);
                    System.Net.IPAddress.TryParse(this.IpAddress, out ipad);
                    try {
                        this.Client = new System.Net.Sockets.UdpClient();
                        this.Handle = this.Client.Client;
                        this.Client.Connect(ipad, this.Port);
                        // TODO: verify this!!!
                        this.IsConnected = (this.Client.Client.Connected && this.Client.Client.IsBound);
                        //this.IsConnected = true;
                    } catch (System.Exception ex) {
                        this.OnSocketError(ex);
                    }
                } catch (System.Exception ex) {
                    this.OnSocketError(ex);
                }
                switch (type) {
                    case KeepAliveType.CUSTOM:
                        this.m_KeepAlive = new System.Windows.Forms.Timer();
                        this.m_KeepAlive.Tick += new System.EventHandler(this.UdpKeepAlive_Tick);
                        this.m_KeepAlive.Interval = msInterval;
                        this.m_KeepAlive.Enabled = true;
                        break;
                    case KeepAliveType.TCP:
                        throw new System.ArgumentException("Cannot specify TCP keep alive type for UDP socket");
                        //break;
                }
                this.Configure(type, msg, msInterval);
            }

            public override void Listen()
            {
                this.IsClosing = false;
                if (this.IsLocalHost) { return; }
                try {
                    try {
                        this.Client = new System.Net.Sockets.UdpClient(this.Port, System.Net.Sockets.AddressFamily.InterNetwork);
                        this.Handle = this.Client.Client;
                        System.Threading.ThreadStart ListenThreadStart = new System.Threading.ThreadStart(this.UdpListenerThread);
                        this.m_ListenThread = new System.Threading.Thread(ListenThreadStart);
                        this.IsRunning = true;
                        this.m_ListenThread.Start();
                        this.IsConnected = true;
                    } catch (System.Exception ex) {
                        this.OnSocketError(ex);
                    }
                } catch (System.Exception ex) {
                    this.OnSocketError(ex);
                }
            }

            private void UdpListenerThread()
            {
                try {
                    byte[] ReceievedBytes = null;
                    System.Net.IPAddress ipad = new System.Net.IPAddress(0);
                    System.Net.IPAddress.TryParse(this.IpAddress, out ipad);
                    System.Net.IPEndPoint udpep = new System.Net.IPEndPoint(ipad, this.Port);
                    do {
                        System.Windows.Forms.Application.DoEvents();
                        ReceievedBytes = this.Client.Receive(ref udpep);
                        this.OnDataReceived(ReceievedBytes);
                        System.Windows.Forms.Application.DoEvents();
                    } while (this.IsRunning);
                } catch (System.Threading.ThreadAbortException threadEx) {
                    System.Console.WriteLine("Thread aborting: " + threadEx.Message);
                } catch (System.Exception ex) {
                    this.OnSocketError(ex);
                }
                this.IsConnected = false;
            }

            public override void Send(byte[] data)
            {
                try {
                    this.Client.Send(data, data.Length);
                } catch (System.Exception ex) {
                    System.Console.WriteLine("Error sending data: " + ex.Message);
                    this.OnSocketError(ex);
                }
            }

            private void UdpKeepAlive_Tick(object sender, System.EventArgs e)
            {
                if (this.IsConnected && this.Client != null && this.Client.Client.Connected) {
                    try {
                        this.Client.Client.Send((new byte[] { 0x01 }));
                    } catch (System.Exception ex) {
                        this.OnSocketError(ex);
                    }
                }
            }

            public override string ToString()
            {
                return this.IpAndPortString;
            }
        }
    }
}