/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * 
 *  Copyright (C) Marco Klein alias WorldRacer, WorldRacer92, WorldRacer_original  *
 *                                                                                 *
 *   This program is free software: you can redistribute it and/or modify          *
 *   it under the terms of the GNU General Public License as published by          *
 *   the Free Software Foundation, either version 3 of the License, or             *
 *   (at your option) any later version.                                           *
 *                                                                                 *
 *   This program is distributed in the hope that it will be useful,               *
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of                *
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the                 *
 *   GNU General Public License for more details.                                  *
 *                                                                                 *
 *   You should have received a copy of the GNU General Public License             *
 *   along with this program.  If not, see <http://www.gnu.org/licenses/>.         *
 * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
 
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
 
namespace devNetworks
{
    /// <summary>
    /// This class represents a client
    /// </summary>
    public class Client
    {
        #region Public Attributes
        /// <summary>
        /// Socket. (TcpClient)
        /// </summary> 
        public System.Net.Sockets.TcpClient Socket
        {
            get { return _Socket; }
            set { _Socket = value; }
        }
        #endregion
 
        #region Private Attributes
 
        // Thread for handling server Messages
        System.Threading.Thread _ClientThread = null;
 
        // Socket to handle with
        private System.Net.Sockets.TcpClient _Socket = null;
 
        // IP-Adress of the endpoint 
        private string _IPAdress = string.Empty;
 
        // Port to connect at the entpoint
        private int _Port = 0;
 
        // Contains whether we are connected or not.
        private bool _Connected = false;
 
        // Bufferlength
        int _BufferLength = 4096;
 
        // Get a client stream for reading and writing.
        //  Stream stream = client.GetStream();
        System.Net.Sockets.NetworkStream _Stream;
 
        // How shall the messages be encoded to?
        System.Text.Encoding _EncodingInstance = System.Text.Encoding.ASCII;
        #endregion
 
        #region Constructor
        /// <summary>
        /// Initializes a Client
        /// </summary>
        /// <param name="IPAdress">IP-Adress of the endpoint</param>
        /// <param name="Port">Port to connect at the entpoint</param>
        /// <param name="ConnectImmediately">Should I connect directly?</param>
        /// <param name="BufferLength">How long shall the received messages be?</param>
        /// <param name="EncodingInstance">How shall the messages be encoded to?</param>        
        public Client(string IPAdress, int Port, System.Text.Encoding EncodingInstance, bool ConnectImmediately = false, int BufferLength = 4096)
        {
            // Save the values
            if (BufferLength > 0)
            {
                _BufferLength = BufferLength;
            }
            else
            {
                _BufferLength = 4096;
            }
            
            _EncodingInstance = EncodingInstance;
            
            // If we shall connect immediately...
            if (ConnectImmediately)
            {
                try
                {
                    // Create a socket which connects immediately
                    _Socket = new System.Net.Sockets.TcpClient(IPAdress, Port);
                    _Connected = _Socket.Connected;
                }
                catch (Exception)
                {
 
                }
            }
            else
            {
                // Else, initialize a new, not connecting socket
                _Socket = new System.Net.Sockets.TcpClient();
                _IPAdress = IPAdress;
                _Port = Port;
            }            
        }
        #endregion
 
        #region Private Methods
        /// <summary>
        /// Worker Function for client listening
        /// </summary>
        private void _ClientThreadFunc()
        {
            // Enter listening loop
            while (true)
            {
                // Give the other threads 1 miliseconds to do their work, else a 100% CPU load is guaranteed.
                System.Threading.Thread.Sleep(1);
 
                // Message Bytes
                Byte[] data = new Byte[_BufferLength];
 
                // String to store the response ASCII representation.
                string responseData = string.Empty;
 
                // Read the first batch of the TcpServer response bytes.
                Int32 bytes = _Stream.Read(data, 0, data.Length);
 
                // Placeholder for writing in the recieved data.
                responseData = _EncodingInstance.GetString(data, 0, bytes);
 
                // Call MessageReceived event, if it has event handlers
                if (MessageRecieved != null)
                {
                    MessageRecieved(this, responseData);
                }
            }
        }
        #endregion
 
        #region Public Methods
        /// <summary>
        /// Sends a message to the Server
        /// </summary>
        /// <param name="Message">Message to send</param>
        public void SendMessage(string Message)
        {
            // Convert string into bytes
            byte[] msg = _EncodingInstance.GetBytes(Message);
 
            // Send the bytes to the stream.
            _Stream.Write(msg, 0, msg.Length);
        }
        /// <summary>
        /// Connect to the endpoint
        /// </summary>
        /// <returns></returns>
        public bool Connect()
        {            
            // If we have an IP
            if (_IPAdress == string.Empty || _Port == 0)
            {
                // If not, return false
                return false;
            }
            else
            {
                // If there was a socket before
                if (Socket != null)
                {
                    // and if it was connected, disconnect it
                    if (!_Socket.Connected)
                        _Socket.Close();
                }
                else
                {
                    // else create a new one.
                    _Socket = new System.Net.Sockets.TcpClient();
                }
 
                // If everything's fine, connect it.
                _Socket.Connect(_IPAdress, _Port);
                
                // If the socket is connected
                if (_Socket.Connected)
                {
                    // Retrieve a stream
                    _Stream = _Socket.GetStream();
 
                    // And start the listening thread
                    _ClientThread = new System.Threading.Thread(new System.Threading.ThreadStart(_ClientThreadFunc));
                    _ClientThread.Start();                    
                }
 
                // Last but not least, return success or fail message
                return _Socket.Connected;
            }
        }        
        #endregion
 
        #region Events
        /// <summary>
        /// Called when the client received a message
        /// </summary>
        /// <param name="sender">This ServerClient</param>
        /// <param name="Message">Received message</param>
        public delegate void MessageRecievedDelegate(object sender, string Message);
 
        /// <summary>
        /// Called when the client received a message
        /// </summary>
        public event MessageRecievedDelegate MessageRecieved;
        #endregion
 
    }
}

/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * 
 *  Copyright (C) Marco Klein alias WorldRacer, WorldRacer92, WorldRacer_original  *
 *                                                                                 *
 *   This program is free software: you can redistribute it and/or modify          *
 *   it under the terms of the GNU General Public License as published by          *
 *   the Free Software Foundation, either version 3 of the License, or             *
 *   (at your option) any later version.                                           *
 *                                                                                 *
 *   This program is distributed in the hope that it will be useful,               *
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of                *
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the                 *
 *   GNU General Public License for more details.                                  *
 *                                                                                 *
 *   You should have received a copy of the GNU General Public License             *
 *   along with this program.  If not, see <http://www.gnu.org/licenses/>.         *
 * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
 
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
 
namespace devNetworks
{
    /// <summary>
    /// This class represents a multi-client server
    /// </summary>
    public class Server
    {
        #region Public Attributes
        /// <summary>
        /// Socket. (TcpClient)
        /// </summary> 
        public System.Net.Sockets.TcpListener Socket
        {
            get { return _Listener; }
            set { _Listener = value; }
        }
        #endregion
 
        #region Private Attributes
        // Listener.
        private System.Net.Sockets.TcpListener _Listener = null;
 
        // List of connected clients.
        private List<ServerClient> _ConnectedClients = new List<ServerClient>();
 
        // Bufferlength
        int _BufferLength = 4096;
 
        // Get a client stream for reading and writing.       
        System.Net.Sockets.NetworkStream _Stream;
 
        // How shall the messages be encoded to?
        System.Text.Encoding _EncodingInstance = System.Text.Encoding.ASCII;
        
        // Thread for handling server Messages
        System.Threading.Thread _ListenThread = null;
 
        #endregion
 
        #region Constructor
        /// <summary>
        /// Initializes a new Multiple-Connection-Server
        /// </summary>
        /// <param name="Port">Port to listen on</param>
        /// <param name="LocalEndPoint">IPAdress to bind</param>
        /// <param name="EncodingInstance">How shall the messages be encoded to?</param>
        public Server(int Port, System.Net.IPAddress LocalEndPoint, Encoding EncodingInstance)
        {
            _EncodingInstance = EncodingInstance;
            _Listener = new System.Net.Sockets.TcpListener(LocalEndPoint, Port);
        }        
        #endregion
 
        #region Private Methods
        /// <summary>
        /// Thread to handle a client
        /// </summary>
        /// <param name="ClientObject">TcpClient. Client to handle</param>
        private void _AddClient(object ClientObject)
        {
            // Perform a blocking call to accept requests.
            // You could also user server.AcceptSocket() here.                
            ServerClient Client = new ServerClient(((System.Net.Sockets.TcpClient)ClientObject), this._EncodingInstance);
            Client.MessageRecieved += new ServerClient.MessageRecievedDelegate(_Client_MessageRecieved);
            _ConnectedClients.Add(Client);
            ClientConnected(this, _ConnectedClients[_ConnectedClients.Count - 1]);            
        }
 
        /// <summary>
        /// Overridable function, for child classes. Here you can define what to do with recieved messages
        /// </summary>
        /// <param name="sender">The Server class</param>
        /// <param name="Message">Received Message</param>
        protected virtual void _Client_MessageRecieved(object sender, string Message)
        {
            
        }
        /// <summary>
        /// Worker function for the listening thread
        /// </summary>
        private void _ListenFunc()
        {
            // Give the other threads 1 miliseconds to do their work, else a 100% CPU load is guaranteed.
            System.Threading.Thread.Sleep(1);
 
            // Start listening
            _Listener.Start();
 
            // Buffer for reading data
            Byte[] bytes = new Byte[256];
           
            // Enter the listening loop
            while (true)
            {
                // Give the other threads 1 miliseconds to do their work, else a 100% CPU load is guaranteed.
                System.Threading.Thread.Sleep(1);
 
                // Start a new thread to handle the client in a asynchronous whay
                (new System.Threading.Thread(new System.Threading.ParameterizedThreadStart(_AddClient))).Start(_Listener.AcceptTcpClient());
            }
        }
        #endregion
 
        #region Public Methods
        /// <summary>
        /// Start Listening for Clients
        /// </summary>
        public void StartListening()
        {
            // If there was already a listening thread...
            if (_ListenThread != null)
            {
                // ...check if listening thread is running. If so, abort it.
                if (_ListenThread.ThreadState == System.Threading.ThreadState.Running)
                    _ListenThread.Abort();
            }
 
            // Create a new listening thread
            _ListenThread = new System.Threading.Thread(new System.Threading.ThreadStart(_ListenFunc));            
        }
 
        public void StopListening()
        {
            // If there was already a listening thread...
            if (_ListenThread != null)
            {
                // ...check if listening thread is running. If so, abort it.
                if (_ListenThread.ThreadState == System.Threading.ThreadState.Running)
                    _ListenThread.Abort();
            }
        }
        #endregion
 
        #region Events
        /// <summary>
        /// Called when a client has connected
        /// </summary>
        /// <param name="sender">The devNetworks.Server object</param>
        /// <param name="Client"></param>
        public delegate void ClientConnectedDelegate(object sender, ServerClient Client);
 
        /// <summary>
        /// Called when a client has connected
        /// </summary>
        public event ClientConnectedDelegate ClientConnected;
        #endregion
    }
}

/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * 
 *  Copyright (C) Marco Klein alias WorldRacer, WorldRacer92, WorldRacer_original  *
 *                                                                                 *
 *   This program is free software: you can redistribute it and/or modify          *
 *   it under the terms of the GNU General Public License as published by          *
 *   the Free Software Foundation, either version 3 of the License, or             *
 *   (at your option) any later version.                                           *
 *                                                                                 *
 *   This program is distributed in the hope that it will be useful,               *
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of                *
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the                 *
 *   GNU General Public License for more details.                                  *
 *                                                                                 *
 *   You should have received a copy of the GNU General Public License             *
 *   along with this program.  If not, see <http://www.gnu.org/licenses/>.         *
 * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
 
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
 
namespace devNetworks
{
    /// <summary>
    /// This class represents a client which has connected to a devNetworks.Server
    /// </summary>
    public class ServerClient
    {
        #region Public Attributes
        /// <summary>
        /// Socket. (TcpClient)
        /// </summary> 
        public System.Net.Sockets.TcpClient Socket
        {
            get { return _Socket; }
            set { _Socket = value; }
        }
        #endregion
 
        #region Private Attributes
        // Socket to handle with
        private System.Net.Sockets.TcpClient _Socket = null;
 
        // Thread for handling server Messages
        System.Threading.Thread _ClientThread = null;
 
        // IP-Adress of the endpoint 
        private string _IPAdress = string.Empty;
 
        // Port to connect at the entpoint
        private int _Port = 0;
 
        // Contains whether we are connected or not.
        private bool _Connected = false;
 
        // Bufferlength
        int _BufferLength = 4096;
 
        // Get a client stream for reading and writing.
        //  Stream stream = client.GetStream();
        System.Net.Sockets.NetworkStream _Stream;
 
        // How shall the messages be encoded to?
        System.Text.Encoding _EncodingInstance = System.Text.Encoding.ASCII;
        #endregion
 
        #region Constructor
        /// <summary>
        /// Initializes a client connected to a devNetworks.Server
        /// </summary>
        /// <param name="Socket">TcpClient</param>
        /// <param name="EncodingInstance">How shall the messages be encoded to?</param>
        public ServerClient(System.Net.Sockets.TcpClient Socket, Encoding EncodingInstance)
        {
            // Save the values
            _EncodingInstance = EncodingInstance;
            _Socket = Socket; 
           
            // Retrieve a stream
            _Stream = _Socket.GetStream();
 
            // Start a listening stream to listen on clients messages
            _ClientThread = new System.Threading.Thread(new System.Threading.ThreadStart(_ClientThreadFunc));
            _ClientThread.Start();
        }        
        #endregion
 
        #region Private Methods
        /// <summary>
        /// Worker Function for client listening
        /// </summary>
        private void _ClientThreadFunc()
        {
            // Enter listening loop
            while (true)
            {
                // Give the other threads 1 miliseconds to do their work, else a 100% CPU load is guaranteed.
                System.Threading.Thread.Sleep(1);
 
                // Message Bytes
                Byte[] data = new Byte[_BufferLength];
 
                // String to store the response ASCII representation.
                string responseData = string.Empty;
 
                // Read the first batch of the TcpServer response bytes.
                Int32 bytes = _Stream.Read(data, 0, data.Length);
 
                // Placeholder for writing in the recieved data.
                responseData = _EncodingInstance.GetString(data, 0, bytes);
 
                // Call MessageReceived event, if it has event handlers
                if (MessageRecieved != null)
                {
                    MessageRecieved(this, responseData);
                }
            }
        }
        #endregion
 
        #region Public Methods
        /// <summary>
        /// Sends a message to the Client
        /// </summary>
        /// <param name="Message">Message to send</param>
        public void SendMessage(string Message)
        {
            // Convert string into bytes
            byte[] msg = _EncodingInstance.GetBytes(Message);
 
            // Send the bytes to the stream.
            _Stream.Write(msg, 0, msg.Length);
        }
        #endregion
 
        #region Events
        /// <summary>
        /// Called when the server received a message
        /// </summary>
        /// <param name="sender">This ServerClient</param>
        /// <param name="Message">Received message</param>
        public delegate void MessageRecievedDelegate(object sender, string Message);
 
        /// <summary>
        /// Called when the server received a message
        /// </summary>
        public event MessageRecievedDelegate MessageRecieved;
        #endregion
    }
}