clsTCPServer.cs

// C# ClassLib
// http://csharp-classlib.sourceforge.net
//
//
// Copyright (C) 2005 Marcel Joachim Kloubert
// 
// 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 2
// 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, write to the Free Software
// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
//

using System;
using System.Collections;
using System.Net.Sockets;
using System.Timers;

namespace CSharp_ClassLib.Net
{
        public class TCPServer : System.Object
        {
                private System.Net.Sockets.TcpListener m_oTCPListener;
                private System.Int32 m_iMaximumConnections;
                private System.UInt16 m_iPort;
                private System.Net.Sockets.Socket[] m_oConnections;
                private System.Int32 m_iBufferSize;
                
                // timer that checks for connections attempts
                private System.Timers.Timer m_oTimer;
                
                // Socket buffers
                private System.Collections.ArrayList m_oSocketBuffers;
        
        public delegate void AcceptHandler(System.Object sender, System.Net.Sockets.Socket socket);
        public event AcceptHandler OnAccept;
        public delegate void DisconnectHandler(System.Object sender, System.Net.Sockets.Socket socket);
        public event DisconnectHandler OnDisconnect;
        public delegate void ErrorHandler(System.Object sender, System.Exception e);
        public event ErrorHandler OnError;
        public delegate void ReceiveHandler(System.Object sender, System.Net.Sockets.Socket socket, System.Byte[] buffer);
        public event ReceiveHandler OnReceive;
                
                
        public TCPServer()
                {
                this.m_oSocketBuffers = new System.Collections.ArrayList();
                this.MaxConnections = 10;
                this.Port = 23;
                this.BufferSize = 2050;
                this.m_oTimer = null;
                
                return;
                }
        
        public System.Int32 BufferSize
        {
                get { return this.m_iBufferSize; }
                
                set { this.m_iBufferSize = value; }
        }
        
        public System.Int32 MaxConnections
        {
                get { return this.m_iMaximumConnections; }
                
                set
                {
                        System.Int32 i = 0;
                        
                        if (value <= 0)
                                // we need more than 0 max. connections!
                                throw ( new System.ArgumentException(" Invalid number of maximum connections! ", "") );
                        
                        this.m_iMaximumConnections = value;
                        this.m_oConnections = new System.Net.Sockets.Socket[this.m_iMaximumConnections];
                        
                        this.m_oSocketBuffers = new System.Collections.ArrayList();
                        for (i = 0; i < this.m_oConnections.GetLength(0); i++)
                        {
                                 this.m_oConnections[i] = null;
                                 this.m_oSocketBuffers.Add( new System.Byte[this.BufferSize] );
                        }
                }
        }
        
        public System.UInt16 Port
        {
                get { return this.m_iPort; }
                set { this.m_iPort = value; }
        }
        
        public System.Net.Sockets.Socket[] Connections
        {
                get { return m_oConnections; }
        }
        
        public void Start ()
        {
                try
                {                                               
                        this.InitListenSocket();
                        this.m_oTCPListener.Start();
                        
                        // init timer that checks if connections are pending
                        this.m_oTimer = new System.Timers.Timer(125);
                        this.m_oTimer.Elapsed += new System.Timers.ElapsedEventHandler(this.m_oTimer_Elapsed);
                        this.m_oTimer.Enabled = true;
                }
                catch (System.Exception e)
                {
                        this.pOnError(e, null);
                }
        }
        
        public void Stop ()
        {
                try
                {                                                                       
                        this.m_oTCPListener.Stop();
                }
                catch (System.Exception e)
                {
                        this.pOnError(e, null);
                }
        }
        
        private void pOnError (System.Exception e, System.Net.Sockets.Socket socket)
        {
                if ("system.net.sockets.socketexception" == e.GetType().FullName.Trim().ToLower())
                {
                        if (
                            (10053 == ((System.Net.Sockets.SocketException)e).ErrorCode) ||
                            (10054 == ((System.Net.Sockets.SocketException)e).ErrorCode)
                           )
                        {
                                // remote closed connection                                     
                                        this.pOnDisconnect(socket);
                                        
                                return;
                        }
                }
                        
                        if (null != this.OnError)
                        this.OnError(this, e);
                else
                        throw (e);
        }
                
                private void InitListenSocket ()
                {
                this.m_oTCPListener = new System.Net.Sockets.TcpListener(System.Net.IPAddress.Any, this.Port);      
                }
        
                private void m_oTimer_Elapsed (System.Object sender, System.Timers.ElapsedEventArgs e)
                {
                        System.Net.Sockets.Socket s = null;
                        
                        try
                        {
                                if (this.m_oTCPListener.Pending())
                                {
                                        // wating connections
                                        
                                        System.Int32 i = 0;
                                        s = this.m_oTCPListener.AcceptSocket();
                                        System.Boolean boolFoundFreeSocket = false;
                                                                
                                        this.ClearConnections();
                                        // search for free socket
                                        for (i = 0; i < this.Connections.GetLength(0); i++)
                                        {       
                                                if (null == this.Connections[i])
                                                {                                                       
                                                        // found free socket

                                                        if (null != this.OnAccept)
                                                                // invoke the event
                                                        this.OnAccept(this, s);
                                        
                                                        if (s.Connected)                                        
                                                        {
                                                                this.Connections[i] = s;                                                        
                                                                this.Connections[i].BeginReceive((System.Byte[])m_oSocketBuffers[i], 0, this.BufferSize, System.Net.Sockets.SocketFlags.None, new System.AsyncCallback(this.pOnReceive), this.Connections[i]);
                                                        }
                                                        
                                                        boolFoundFreeSocket = true;                                             
                                                        break;
                                                }
                                        }
                                        
                                        if (!boolFoundFreeSocket)
                                                // no more connections!
                                                s.Close();
                                }
                        }
                        catch (System.Exception e2)
                        {
                                this.pOnError(e2, s);
                        }
                        
                return;
                }
                
                private void ClearConnections ()
                {
                        System.Int32 i = 0;
                        
                        for (i = 0; i < this.Connections.GetLength(0); i++)
                        {
                                if (null != this.Connections[i])
                                {
                                        if (!this.Connections[i].Connected)
                                                this.Connections[i] = null;
                                }
                        }
                }
                
                private void pOnReceive ( System.IAsyncResult ar )
                {
                        try
                        {
                                System.Int32 i = 0;
                                System.Int32 iBytesRead = 0;
                                System.Byte[] bBuffer = new System.Byte[0];
                        
                                for (i = 0; i < this.Connections.GetLength(0); i++)
                                {
                                        if ( this.Connections[i].Equals(ar.AsyncState) )
                                        {
                                                // receive data
                                                iBytesRead = this.Connections[i].EndReceive(ar);                                        
                                                if (iBytesRead > 0)
                                                {
                                                        bBuffer = new System.Byte[iBytesRead];
                                                        System.Array.Copy((System.Byte[])m_oSocketBuffers[i], bBuffer, bBuffer.GetLength(0));
                                                        
                                                        if (null != this.OnReceive)
                                                                // invoke event
                                                                this.OnReceive(this, this.Connections[i], bBuffer);
                                                }
                                        
                                                if (null != this.Connections[i])
                                                {
                                                        if (this.Connections[i].Connected)
                                                                // is still connected => list for data
                                                                this.Connections[i].BeginReceive((System.Byte[])m_oSocketBuffers[i], 0, this.BufferSize, System.Net.Sockets.SocketFlags.None, new System.AsyncCallback(this.pOnReceive), this.Connections[i]);
                                                        else
                                                                this.pOnDisconnect(this.Connections[i]);
                                                }
                                                else
                                                        this.pOnDisconnect(this.Connections[i]);
                                        
                                                break;
                                        }
                                }
                        }
                        catch (System.Exception e)
                        {
                                this.pOnError(e, (System.Net.Sockets.Socket)ar.AsyncState);
                        }               
                        
                        return;
                }
                
                private void pOnDisconnect( System.Net.Sockets.Socket socket )
                {
                        if (null != this.OnDisconnect)
                                // invoke the event(s)
                                this.OnDisconnect(this, socket);
                        
                        this.ClearConnections();
                        
                        return;
                }
        }
}

---