[Csharp-classlib-cvs] main/src/classes clsTCPServer.cs,NONE,1.1

SourceForge Headquarters 1320 Columbia Street Suite 310 San Diego, CA 92101 +1 (858) 422-6466

Update of /cvsroot/csharp-classlib/main/src/classes
In directory sc8-pr-cvs1.sourceforge.net:/tmp/cvs-serv24389/src/classes

Added Files:
	clsTCPServer.cs 
Log Message:
- added TCP Server class

--- NEW FILE: 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
{
	/*! \brief TCP server class
 	 *
 	 *  \author generalpd
 	 * 
 	 *  \date 2005-04-30
 	 * 
 	 *  \bug none
 	 *
 	 *  \todo none
 	 * 
 	 *  \remarks Last changed by: $Author: generalpd $ in revision $Revision: 1.1 $ on $Date: 2005/05/13 05:37:31 $
 	 * 
 	 *  \note 
 	 *  $Log: clsTCPServer.cs,v $
 	 *  Revision 1.1  2005/05/13 05:37:31  generalpd
 	 *  - added TCP Server class
 	 *
 	 *
 	 */
 	 public class TCPServer : System.Object
	{
 	 	/// Listening socket
 	 	private System.Net.Sockets.TcpListener m_oTCPListener;
    	/// Maximum connections
 	 	private System.Int32 m_iMaximumConnections;
    	/// Local port
 	 	private System.UInt16 m_iPort;
    	/// Socket connections
 	 	private System.Net.Sockets.Socket[] m_oConnections;
    	/// Socket connections
 	 	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;
    	
 	 	/// Accept-Event-Handler-Struct
    	public delegate void AcceptHandler(System.Object sender, System.Net.Sockets.Socket socket);
		/// Accept-Event-Handler
    	public event AcceptHandler OnAccept;
 	 	/// Disconnect-Event-Handler-Struct
    	public delegate void DisconnectHandler(System.Object sender);
		/// Disconnect-Event-Handler
    	public event DisconnectHandler OnDisconnect;
    	/// Error-Event-Handler-Struct
    	public delegate void ErrorHandler(System.Object sender, System.Exception e);
    	/// Error-Event-Handler
    	public event ErrorHandler OnError;
    	/// Receive-Event-Handler-Struct
    	public delegate void ReceiveHandler(System.Object sender, System.Net.Sockets.Socket socket, System.Byte[] buffer);
    	/// Receive-Event-Handler
    	public event ReceiveHandler OnReceive;
    	    	
 	 	
    	/*! \fn TCPServer()
     	 *  \brief Inits all necessary stuff
     	 * 
     	 */
    	public TCPServer()
		{
    		this.m_oSocketBuffers = new System.Collections.ArrayList();
    		this.MaxConnections = 10;
    		this.Port = 23;
    		this.BufferSize = 1024;
    		this.m_oTimer = null;
    		
    		return;
		}
    	
 	 	/*! \fn System.Int32 BufferSize
     	 *  \brief Retirns or sets the buffer size
     	 * 
     	 *  \param value The new buffer size
     	 * 
     	 *  \return value The current buffer size
     	 * 
     	 */
    	public System.Int32 BufferSize
    	{
    		get { return this.m_iBufferSize; }
    		
    		set { this.m_iBufferSize = value; }
    	}
    	
 	 	/*! \fn System.Int32 MaxConnections
     	 *  \brief Retirns or sets the maximum connections
     	 * 
     	 *  \param value The new maximum connection count
     	 * 
     	 *  \return value The maximum connection count
     	 * 
     	 */
    	public System.Int32 MaxConnections
    	{
    		get { return this.m_iMaximumConnections; }
    		
    		set
    		{
    			System.Int32 i = 0;
    			
    			this.m_iMaximumConnections = value;    			
    			this.m_oConnections = new System.Net.Sockets.Socket[this.m_iMaximumConnections];
    			
    			// init new sockets
    			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] );
    			}
    		}
    	}
    	
 	 	/*! \fn System.UInt16 Port
     	 *  \brief Retirns or sets the server port
     	 * 
     	 *  \param value The new server port
     	 * 
     	 *  \return value The current server port
     	 * 
     	 */
    	public System.UInt16 Port
    	{
    		get { return this.m_iPort; }
    		set { this.m_iPort = value; }
    	}
    	
 	 	/*! \fn System.Net.Sockets.Socket Connections
     	 *  \brief Returns all socket connections
     	 * 
     	 *  \return Array of all socket connections
     	 * 
     	 */
     	public System.Net.Sockets.Socket[] Connections
    	{
    		get { return m_oConnections; }
    	}
    	
 	 	/*! \fn void Start ()
     	 *  \brief Starts the server
     	 * 
     	 */
     	public void Start ()
    	{
     		try
     		{     			     			
     			this.InitListenSocket();
     			this.m_oTCPListener.Start();
     			
     			// set timer that checks for pending connections
     			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);
     		}
    	}
     	
 	 	/*! \fn void Stop ()
     	 *  \brief Stops the server
     	 * 
     	 */
     	public void Stop ()
    	{
     		try
     		{     			     			
     			this.m_oTCPListener = null;
     			
     			this.MaxConnections = this.MaxConnections;
     		}
     		catch (System.Exception e)
     		{
     			this.pOnError(e);
     		}
    	}
     	
		/*! \fn void pOnError (System.Exception e)
     	 *  \brief Handles especially socket exceptions
     	 *      	 
     	 *  \param e The exception
     	 * 
     	 */
     	private void pOnError (System.Exception e)
     	{
     		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
     				
					if (null != this.OnDisconnect)
						// invoke the event(s)
     					this.OnDisconnect(this);
     				
					this.ClearConnections();
					
     				return;
     			}
     		}
			
			if (null != this.OnError)
     			this.OnError(this, e);
     		else
     			throw (e);
     	}
		
     	/*! \fn private void InitListenSocket ()
     	 *  \brief Inits the listening socket with all stuff
     	 * 
     	 */
		private void InitListenSocket ()
		{
	    	this.m_oTCPListener = new System.Net.Sockets.TcpListener(this.Port);	    
		}
     	
		/*! \fn void m_oTimer_Elapsed (System.Object sender, System.Timers.ElapsedEventArgs e)
     	 *  \brief Invoked by the timer instance
     	 * 
     	 *  \param sender Sender object
     	 *  \param e Elapsed event arguments
     	 * 
     	 */
		private void m_oTimer_Elapsed (System.Object sender, System.Timers.ElapsedEventArgs e)
		{
			try
			{
				if (this.m_oTCPListener.Pending())
				{
					System.Int32 i = 0;
					System.Net.Sockets.Socket s = this.m_oTCPListener.AcceptSocket();
					System.Boolean boolFoundFreeSocket = false;
								
					this.ClearConnections();
					for (i = 0; i < this.Connections.GetLength(0); i++)
					{	
						if (null == this.Connections[i])
						{
							if (null != this.OnAccept)
     							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)
						s.Close();
				}
			}
			catch (System.Exception e2)
			{
				this.pOnError(e2);
			}
			
	    	return;
		}
		
		/*! \fn void ClearConnections ()
     	 *  \brief Sets all not connected sockets to null
     	 * 
     	 */
		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;
				}
			}
		}
		
		/*! \fn void pOnReceive ( System.IAsyncResult ar )
     	 *  \brief Async callback for data receive
     	 *      	 
     	 *  \param ar Async result
     	 * 
     	 */
		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) )
					{
						iBytesRead = this.Connections[i].EndReceive(ar);
						bBuffer = new System.Byte[iBytesRead];
						System.Array.Copy((System.Byte[])m_oSocketBuffers[i], bBuffer, bBuffer.GetLength(0));
					
						if (null != this.OnReceive)
							this.OnReceive(this, this.Connections[i], bBuffer);
					
						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]);
					
						break;
					}
				}
			}
			catch (System.Exception e)
			{
				this.pOnError(e);
			}					
			
			return;
		}
	}
}