C#

oraanupi wrote:

i tested it works

using System;
using System.Threading;								// Sleeping
using System.Net;									// Used to local machine info
using System.Net.Sockets;							// Socket namespace
using System.Collections;							// Access to the Array list
using System.IO;
using System.Configuration;
using System.Data;
using System.Data.SqlClient;
namespace ChatServer
{
	/// <summary>
	/// Main class from which all objects are created
	/// </summary>
	class AppMain
	{
		// Attributes
		private ArrayList	m_aryClients = new ArrayList();	// List of Client Connections
		public  clsMaster  objmaster  = new clsMaster();
		/// <summary>
		/// Application starts here. Create an instance of this class and use it
		/// as the main object.
		/// </summary>
		/// <param name="args"></param>
		/// 
		static void Main(string[] args)
		{
			AppMain app = new AppMain();
			// Welcome and Start listening
			Console.WriteLine( "*** Data Collector Server Started {0} *** ", DateTime.Now.ToString( "G" ) );

/*
			//
			// Method 1
			//
			string strport =System.Configuration.ConfigurationSettings.AppSettings["IPPort"] ;
			Socket client;
			 int nPortListen =Convert.ToInt16 (strport);
			try
			{
				TcpListener listener = new TcpListener(nPortListen );
				Console.WriteLine( "Listening as {0}", listener.LocalEndpoint );
				listener.Start();
				do
				{
					byte [] m_byBuff = new byte[127];
					if( listener.Pending() )
					{
						client = listener.AcceptSocket();
						// Get current date and time.
						DateTime now = DateTime.Now;
						String strDateLine = "Welcome " + now.ToString("G") + "\n\r";

						// Convert to byte array and send.
//						Byte[] byteDateLine = System.Text.Encoding.ASCII.GetBytes( strDateLine.ToCharArray() );
//						client.Send( byteDateLine, byteDateLine.Length, 0 );
					}
					else
					{
						Thread.Sleep( 100 );
					}
				} while( true );	// Don't use this. 

				//Console.WriteLine ("OK that does it! Screw you guys I'm going home..." );
				//listener.Stop();
			}
			catch( Exception ex )
			{
				Console.WriteLine ( ex.Message );
			}
*/			


			//
			// Method 2 
			//
			string strport =System.Configuration.ConfigurationSettings.AppSettings["IPPort"] ;
			int nPortListen = Convert.ToInt32(strport);
			// Determine the IPAddress of this machine
			IPAddress [] aryLocalAddr = null;
			String strHostName = "";
			try
			{
				// NOTE: DNS lookups are nice and all but quite time consuming.
				strHostName = Dns.GetHostName();
				IPHostEntry ipEntry = Dns.GetHostByName( strHostName );
				aryLocalAddr = ipEntry.AddressList;
			}
			catch( Exception ex )
			{
				Console.WriteLine ("Error trying to get local address {0} ", ex.Message );
			}
	
			// Verify we got an IP address. Tell the user if we did
			if( aryLocalAddr == null || aryLocalAddr.Length < 1 )
			{
				Console.WriteLine( "Unable to get local address" );
				return;
			}
			Console.WriteLine( "Listening on : [{0}] {1}:{2}", strHostName, aryLocalAddr[0], nPortListen );

			// Create the listener socket in this machines IP address
			Socket listener = new Socket( AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp );
			listener.Bind( new IPEndPoint( aryLocalAddr[0], nPortListen ) );
			//listener.Bind( new IPEndPoint( IPAddress.Loopback, 399 ) );	// For use with localhost 127.0.0.1
			listener.Listen(10 );

			// Setup a callback to be notified of connection requests
			listener.BeginAccept( new AsyncCallback( app.OnConnectRequest ), listener );

			Console.WriteLine ("Press Enter to exit" );
			Console.ReadLine();
			Console.WriteLine ("OK that does it! Screw you guys I'm going home..." );

			// Clean up before we go home
			listener.Close();
			GC.Collect();
			GC.WaitForPendingFinalizers();		
		}


		/// <summary>
		/// Callback used when a client requests a connection. 
		/// Accpet the connection, adding it to our list and setup to 
		/// accept more connections.
		/// </summary>
		/// <param name="ar"></param>
		public void OnConnectRequest( IAsyncResult ar )
		{
			Socket listener = (Socket)ar.AsyncState;
			NewConnection(listener.EndAccept(ar));
			listener.BeginAccept( new AsyncCallback( OnConnectRequest ), listener );
		}

		/// <summary>
		/// Add the given connection to our list of clients
		/// Note we have a new friend
		/// Send a welcome to the new client
		/// Setup a callback to recieve data
		/// </summary>
		/// <param name="sockClient">Connection to keep</param>
		//public void NewConnection( TcpListener listener )
        

		public void NewConnection( Socket sockClient )
		{
			// Program blocks on Accept() until a client connects.
			//SocketChatClient client = new SocketChatClient( listener.AcceptSocket() );
			SocketChatClient client = new SocketChatClient( sockClient );
			m_aryClients.Add( client );
			Console.WriteLine( "Client {0}, joined", client.Sock.RemoteEndPoint );
 
			// Get current date and time.
			DateTime now = DateTime.Now;
			String strDateLine = "Welcome " + now.ToString("G") + "\n\r";

			// Convert to byte array and send.
			Byte[] byteDateLine = System.Text.Encoding.ASCII.GetBytes( strDateLine.ToCharArray() );
			client.Sock.Send( byteDateLine, byteDateLine.Length, 0 );
//
			client.SetupRecieveCallback( this );
		}
        

		/// <summary>
		/// Get the new data and send it out to all other connections. 
		/// Note: If not data was recieved the connection has probably 
		/// died.
		/// </summary>
		/// <param name="ar"></param>
		public void OnRecievedData( IAsyncResult ar )
        {
            SocketChatClient client = (SocketChatClient)ar.AsyncState;
            byte[] aryRet = client.GetRecievedData(ar);

            // If no data was recieved then the connection is probably dead
            if (aryRet.Length < 1)
            {
                Console.WriteLine("Client {0}, disconnected", client.Sock.RemoteEndPoint);
                client.Sock.Close();
                m_aryClients.Remove(client);
                return;
            }
            // Commented for database collection
            if(System.Text.Encoding.ASCII.GetString(aryRet )!="")
            {
                string strvalue=System.Text.Encoding.ASCII.GetString(aryRet );
                char[] sep = {';'};
                Array a = strvalue.Split(sep);

                TextWriter tw = new StreamWriter("d://date.txt");
                string path = "d://date.txt";
                StreamWriter sw = new StreamWriter(Path);
                string bufferOne = "trans_logging";  
                string buffertwo = "trans_logging";
                string bufferthree = "drc_dateTime";
                sw.WriteLine(bufferOne);
                sw.WriteLine(buffertwo);
                sw.WriteLine(bufferthree);

                try
                {
                    objmaster.Insert("trans_logging", "trans_logging", "dateTime", System.Text.Encoding.ASCII.GetString(aryRet), DateTime.Now.ToString("MM/dd/yyyy hh:mm:ss tt"));
                    tw.WriteLine(objmaster);

                
                }



                catch (Exception ex)
                {
                    Console.Write(ex.Message);
                }
            }

            // up to here

            //			// Send the recieved data to all clients (including sender for echo)
            //			foreach( SocketChatClient clientSend in m_aryClients )
            //			{
            //				try
            //				{
            //					clientSend.Sock.Send( aryRet );
            //				}
            //				catch
            //				{
            //					// If the send fails the close the connection
            //					Console.WriteLine( "Send to client {0} failed", client.Sock.RemoteEndPoint );
            //					clientSend.Sock.Close();
            //					m_aryClients.Remove( client );
            //					return;
            //				}
            //			}
            client.SetupRecieveCallback(this);
        }
	}

	/// <summary>
	/// Class holding information and buffers for the Client socket connection
	/// </summary>
	internal class SocketChatClient
	{
		private Socket m_sock;						// Connection to the client
		private byte[] m_byBuff = new byte[1000];		// Receive data buffer
		public  clsMaster  objmaster  = new clsMaster();
		/// <summary>
		/// Constructor
		/// </summary>
		/// <param name="sock">client socket conneciton this object represents</param>
		public SocketChatClient( Socket sock )
		{
			m_sock = sock;
		}

		// Readonly access
		public Socket Sock
		{
			get{ return m_sock; }
		}

		/// <summary>
		/// Setup the callback for recieved data and loss of conneciton
		/// </summary>
		/// <param name="app"></param>
		public void SetupRecieveCallback( AppMain app )
		{
			try
			{
				AsyncCallback recieveData = new AsyncCallback(app.OnRecievedData);
				m_sock.BeginReceive( m_byBuff, 0, m_byBuff.Length, SocketFlags.None, recieveData, this );
			}
			catch( Exception ex )
			{
				Console.WriteLine( "Recieve callback setup failed! {0}", ex.Message );
			}
		}

		/// <summary>
		/// Data has been recieved so we shall put it in an array and
		/// return it.
		/// </summary>
		/// <param name="ar"></param>
		/// <returns>Array of bytes containing the received data</returns>
		public byte [] GetRecievedData( IAsyncResult ar )
		{
            int nBytesRec = 0;
			try
			{
				nBytesRec = m_sock.EndReceive( ar );
				
				//Console.WriteLine(name);
			}
			catch{}
			byte [] byReturn = new byte[nBytesRec];
			Array.Copy( m_byBuff, byReturn, nBytesRec );
			
			/*
			// Check for any remaining data and display it
			// This will improve performance for large packets 
			// but adds nothing to readability and is not essential
			int nToBeRead = m_sock.Available;
			if( nToBeRead > 0 )
			{
				byte [] byData = new byte[nToBeRead];
				m_sock.Receive( byData );
				// Append byData to byReturn here
			}
			*/
			// comment below line after successful completion
			//*&Console.WriteLine(System.Text.Encoding.ASCII.GetString(byReturn ));

            Console.WriteLine("Received Data {0}", System.Text.Encoding.ASCII.GetString(byReturn));



			return byReturn;
		}
		
	}

}