Client.cs

using MTSC.Client.Handlers;
using MTSC.Exceptions;
using MTSC.Logging;
using System;
using System.Collections;
using System.Collections.Generic;
using System.Net.Security;
using System.Net.Sockets;
using System.Security.Cryptography.X509Certificates;
using System.Text;
using System.Threading;
using System.Threading.Tasks;

namespace MTSC.Client
{
    public class Client
    {
        #region Fields
        string address;
        int port;
        TcpClient tcpClient;
        CancellationTokenSource cancelMonitorToken;
        List<IHandler> handlers = new List<IHandler>();
        List<ILogger> loggers = new List<ILogger>();
        List<IExceptionHandler> exceptionHandlers = new List<IExceptionHandler>();
        Queue<byte[]> messageQueue = new Queue<byte[]>();
        SslStream sslStream = null;
        static Hashtable certificateErrors = new Hashtable();
        bool useSsl = false;
        #endregion
        #region Properties
        public bool Connected
        {
            get
            {
                if (tcpClient != null)
                    return tcpClient.Connected;
                else
                    return false;
            }
        }
        public string Address { get => address; }
        public int Port { get => port; }
        #endregion
        #region Constructors
        public Client(bool useSsl = false)
        {
            this.useSsl = useSsl;
        }
        #endregion
        #region Public Methods
        public void QueueMessage(byte[] message)
        {
            messageQueue.Enqueue(message);
        }
        public void Log(string log)
        {
            foreach (ILogger logger in loggers)
            {
                logger.Log(log);
            }
        }
        public void LogDebug(string debugMessage)
        {
            foreach (ILogger logger in loggers)
            {
                logger.LogDebug(debugMessage);
            }
        }
        public Client SetServerAddress(string address)
        {
            this.address = address;
            return this;
        }
        public Client SetPort(int port)
        {
            this.port = port;
            return this;
        }
        public Client AddHandler(IHandler handler)
        {
            handlers.Add(handler);
            return this;
        }
        public Client AddExceptionHandler(IExceptionHandler handler)
        {
            exceptionHandlers.Add(handler);
            return this;
        }
        public Client AddLogger(ILogger logger)
        {
            loggers.Add(logger);
            return this;
        }
        public RemoteCertificateValidationCallback CertificateValidationCallback { get; set; }
        public bool Connect()
        {
            try
            {
                if (tcpClient != null)
                {
                    cancelMonitorToken?.Cancel();
                    tcpClient.Dispose();
                }
                tcpClient = new TcpClient();
                tcpClient.Connect(address, port);
                if (useSsl)
                {
                    if(this.CertificateValidationCallback == null)
                    {
                        this.CertificateValidationCallback = new RemoteCertificateValidationCallback(ValidateServerCertificate);
                    }
                    sslStream = new SslStream(tcpClient.GetStream(), true, this.CertificateValidationCallback, null);
                    sslStream.AuthenticateAsClient(address);
                }
                foreach(ILogger logger in loggers)
                {
                    logger.Log("Connected to: " + tcpClient.Client.RemoteEndPoint.ToString());
                }
                foreach (IHandler handler in handlers)
                {
                    if (!handler.InitializeConnection(this))
                    {
                        return false;
                    }
                }
                cancelMonitorToken = new CancellationTokenSource();
                Task.Run(new Action(MonitorConnection), cancelMonitorToken.Token);
                return true;
            }
            catch(Exception e)
            {
                LogDebug("Exception: " + e.Message);
                LogDebug("Stacktrace: " + e.StackTrace);
                foreach (IExceptionHandler exceptionHandler in exceptionHandlers)
                {
                    exceptionHandler.HandleException(e);
                }
                return false;
            }
        }
        public Task<bool> ConnectAsync()
        {
            return new Task<bool>(Connect);
        }
        public void Disconnect()
        {
            cancelMonitorToken?.Cancel();
            tcpClient.Dispose();
        }
        #endregion
        #region Private Methods
        private static bool ValidateServerCertificate( object sender, X509Certificate certificate, X509Chain chain, SslPolicyErrors sslPolicyErrors)
        {
            if (sslPolicyErrors == SslPolicyErrors.None)
                return true;

            // Do not allow this client to communicate with unauthenticated servers.
            return true;
        }

        private void MonitorConnection()
        {
            while (true)
            {
                try
                {
                    if(messageQueue.Count > 0)
                    {
                        byte[] messagebytes = messageQueue.Dequeue();
                        Message sendMessage = CommunicationPrimitives.BuildMessage(messagebytes);
                        for(int i = handlers.Count - 1; i >= 0; i--)
                        {
                            IHandler handler = handlers[i];
                            handler.HandleSendMessage(this, ref sendMessage);
                        }
                        CommunicationPrimitives.SendMessage(tcpClient, sendMessage, sslStream);
                    }
                    if (tcpClient.Available > 0)
                    {
                        /*
                         * When a message has been received, process it.
                         */
                        Message message = CommunicationPrimitives.GetMessage(tcpClient, sslStream);
                        LogDebug("Received a message of size: " + message.MessageLength);
                        /*
                         * Preprocess message.
                         */
                        foreach (IHandler handler in handlers)
                        {
                            if (handler.PreHandleReceivedMessage(this, ref message))
                            {
                                break;
                            }
                        }
                        /*
                         * Process the final message structure.
                         */
                        foreach (IHandler handler in handlers)
                        {
                            if (handler.HandleReceivedMessage(this, message))
                            {
                                break;
                            }
                        }
                    }
                    foreach (IHandler handler in handlers)
                    {
                        handler.Tick(this);
                    }
                }
                catch(Exception e)
                {
                    LogDebug("Exception: " + e.Message);
                    LogDebug("Stacktrace: " + e.StackTrace);
                    foreach (IExceptionHandler exceptionHandler in exceptionHandlers)
                    {
                        exceptionHandler.HandleException(e);
                    }
                }
                Thread.Sleep(33);
            }
        }
        #endregion
    }
}