Creating Servers for handling Multiple clients
                              Fog Edition
			       By FireNet

Client  ---> SYN  --->  Server
Client  <--- SYN/ACK  <--- Server
Client ----> ACK  --->  Server

/*-------------------Echo_client.cpp-------------------*/
#include <windows.h>
#include <winsock.h>
#include <stdio.h>
#include <iostream.h>
#include <conio.h>
#include <signal.h>
#include <stdio.h>
 
//DECLARATIONS
	//error trapping signals
	  #define SIGINT 2
	  #define SIGKILL 9
	  #define SIGQUIT 3
	//SOCKETS
	  SOCKET sock,client;
 
void s_handle(int s)
{
	if(sock)
	   closesocket(sock);
	if(client)
	   closesocket(client);
	WSACleanup();
	cout<<"EXIT SIGNAL :"<<s;
	exit(0);
}
 
 
void s_cl(char *a, int x)
{
	cout<<a;
	s_handle(x+1000);
}
 
void main()
{
	//Declarations
	int res,i=1,port=100;
	char buf[100];
	WSADATA data;
 
	signal(SIGINT,s_handle);
	signal(SIGKILL,s_handle);
	signal(SIGQUIT,s_handle);
 
	cout<<"\t\tEcho Client";
 
 
	sockaddr_in ser;
	sockaddr addr;
 
	ser.sin_family=AF_INET;
	ser.sin_port=htons(port);					//Set the port
	ser.sin_addr.s_addr=inet_addr("127.0.0.1");		//Set the address we want to connect to
 
	memcpy(&addr,&ser,sizeof(SOCKADDR_IN));
 
	res = WSAStartup(MAKEWORD(1,1),&data);		//Start Winsock
	cout<<"\n\nWSAStartup"
		<<"\nVersion: "<<data.wVersion
		<<"\nDescription: "<<data.szDescription
		<<"\nStatus: "<<data.szSystemStatus<<endl;
 
	if(res != 0)
		s_cl("WSAStarup failed",WSAGetLastError());
 
	sock=socket(AF_INET,SOCK_STREAM,IPPROTO_TCP);		//Create the socket
		if(sock==INVALID_SOCKET )
			s_cl("Invalid Socket ",WSAGetLastError());
		else if(sock==SOCKET_ERROR)
			s_cl("Socket Error)",WSAGetLastError());
		else
			cout<<"Socket Established"<<endl;
 
	res=connect(sock,&addr,sizeof(addr));				//Connect to the server
		if(res !=0 )
		{
			s_cl("SERVER UNAVAILABLE",res);
		}
		else
		{
			cout<<"\nConnected to Server: ";
			memcpy(&ser,&addr,sizeof(SOCKADDR));
		}
 
	while(true)
	{
		cout<<"\n>";
		gets(buf);
 
		res =  send(sock,buf,100,0);		//Send Data
 
		if(res==0)
		{	
			//0==other side terminated conn
			printf("\nSERVER terminated connection\n");
			closesocket(client);
			client =0;
			break;
		}
		else if(res==SOCKET_ERROR)
		{	
			//-1 == send error
			printf("Socket error\n");
			s_handle(res);
			break;
		}
 
 
	res=recv(sock,buf,100,0);		//Recive Data
 
	if(res>0)
	{
		cout<<"\nRecieved string:"<<buf;
	}
 
  }	
	WSACleanup();
}
/*-------------------Echo_client.cpp-------------------*/

struct _client
{
	bool con;			//Set true if a client is connected
	sockaddr_in addr;	//Client info like ip address
	SOCKET cs;		//Client socket
	fd_set set;			//used to check if there is data in the socket
	int i;				//any piece of additional info
};

accept(_client *);		//accept client connections
recv(_client *);			//recive data from them
send(_client *);			//send data

MAX_CONS		//Total No of Client allowed
PR_CONS		//No of currently connected clients

/****************SERVER.cpp****************/
void main()
{
	int res,i=1,port=100;
	WSADATA data;
 
	cout<<"\t\tEcho Server (Multiple Client Support)";
 
	sockaddr_in ser;
	sockaddr addr;
	ser.sin_family		=	AF_INET;
	ser.sin_port		=	htons(port);
	ser.sin_addr.s_addr 	= 	INADDR_ANY;
 
	memcpy(&addr,&ser,sizeof(SOCKADDR_IN));	
 
	res = WSAStartup(MAKEWORD(1,1),&data);
	cout<<"\n\nWSAStartup"
		<<"\n Version: "<<data.wVersion
		<<"\n Description: "<<data.szDescription
		<<"\n Status: "<<data.szSystemStatus<<endl;
 
	if(res != 0)
		s_cl("WSAStarup failed",WSAGetLastError());
 
	sock = socket(AF_INET,SOCK_STREAM,IPPROTO_TCP);
		if(sock==INVALID_SOCKET )
			s_cl("Invalid Socket ",WSAGetLastError());
		else if(sock==SOCKET_ERROR)
			s_cl("Socket Error)",WSAGetLastError());
		else
			cout<<"SOCKET Established"<<endl;
 
	setsockopt(sock,SOL_SOCKET,SO_REUSEADDR,(char *)&i,sizeof (i));
 
	res = bind(sock,&addr,sizeof(addr));
	cout<<"Binding socket:"<<res<<endl;
		if(res != 0)
			s_cl("BIND FAILED",WSAGetLastError());
		else
			cout<<"Socket Bound to port : "<<port<<endl;
 
 
	res = listen(sock,5);
	cout<<"Server Listen mode : "<<res<<" Size = "<<m*2<<endl;
 
	unsigned long b=1;
	ioctlsocket(sock,FIONBIO,&b);
/****************SERVER.cpp****************/

while(true)
{
	accept_clients();		//Recive connections
	send_clients();		//Send data to clients
	recv_clients();		//Recive data from clients
}

int accept(_client *x)
{
	x->i = sizeof(sockaddr);
	x->cs = accept(sock,(sockaddr *)&x->addr, &x->i);
 
	if(cs != 0 && cs !=SOCKET_ERROR)
	{
		x->con = true;
		FD_ZERO(&x->set);
		FD_SET(x->cs,&x->set);
		return (true);
	}
	return (false);
}

int send(_client *x,char *buffer,int sz)
{
	x->i = send(x->cs,buffer,sz,0);
	if(x->i == SOCKET_ERROR || x->i == 0)
	{
		disconnect(x);
		return (false);
	}
	else return (true);
}

int recv(_client *x,char *buffer,int sz)
{
	if(FD_ISSET(x->cs,&x->set))
	{
		x->i = recv(x->cs,buffer,sz,0);
		if(x->i == 0)
		{
			disconnect(x);
			return (false);
		}
		return (true)
	}
 
	return (false);
}

while(true)
{
	accept_clients();		//Recive connections
	send_clients();		//Send data to clients
	recv_clients();		//Recive data from clients
}

_client client[MAX_CONS];
 
void accept_clients()
{
	for(int i=0;i<MAX_CONS;i++)
	{
		if(!client[i].con)		//i.e a client has not connected to this slot
		{
			if(accept(client[i]))
			{
				//update server status
				Server_Status(CLIENT_CON);
			}
		}
	}
}
 
Server_Status(int msg)
{
	if(msg == CLIENT_CON)
	{
		PR_CONS++;
		cout<<"\nWow, a client has connected";
	}
	else if(msg == CLIENT_DIS)
	{
		PR_CONS--;
		cout<<"Wee, a client has disconnected";
	}
	else
	{
		//never leave out anything
		cout<<"\n>>>>>>We got an unknown message :"<<msg;
	}
}
 
void disconnect(_client *x) //this is called by the low level funtions
{
	if(x->cs)closesocket(x->cs);
	x->con = false;
	x->i = -1;
	Server_Status(CLIENT_DIS);
}

void chat_message(char *s)
{
	int len = strlen(s);
 
	for(int i=0;i<MAX_CONS;i++)
	{
		if(client[i].con)		//valid slot,i.e a client has parked here
		{
			send(client[i],s,len);
		}
	}
}

#define BF_SZ 100
 
void recv_client()
{
	char buffer[BF_SZ]
 
	for(int i=0;i<MAX_CONS;i++)
	{
		if(client[i].con)		//valid slot,i.e a client has parked here
		{
			if(recv(client[i],buffer,BF_SZ))
			{
				if(buffer[0]=='/')
				{	
					//respond to commands
					if(strcmp(buffer,"/server_bang")==0)
					{
						chat_message("8*8* The Server Goes BANG *8*8");
					}
				}
				else
				{
					chat_message(buffer);
				}
			}
		}
	}
}

			--------------------------------
				     Protocols
				(Basic overview)
			--------------------------------

Eg of a protocol
 
struct chat_protocol
{
	int id;
	char nick[10];
	char msg[100];
};

	send(sock,(char*)&prt_buff,sizeof(chat_protocol),0);
	recv(sock,(char*)&prt_buff,sizeof(chat_protocol),0);

			--------------------------------
				     Security
				   (Concerns)
			--------------------------------

if(check)
{
	perm = 9;
}
else if (check == 222)
{
	perm = 8;
}
else perm = normal;

Name:	Aaron M.(a.k.a FireNet)
E-Mail:	<a href="mailto:xfirenet@hotmail.com">xfirenet@hotmail.com</a>
Website:	<a rel="nofollow" class="t" href="http://www.xlock.ssr.be" target="_blank">www.xlock.ssr.be</a>
                 <a rel="nofollow" class="t" href="http://xlock.hostcubix.com/" target="_blank">http://xlock.hostcubix.com/</a>

/*
 
// COMMENTS //
 
	Author	:	xmen90s -> based on the tutorial of Aaron aka FireNet
				<a href="mailto:xmen90s@yahoo.com">xmen90s@yahoo.com</a>
 
	Date	:	June 10th of 2004
 
	Purpose	:	This server receives input from multiple clients and keeps
				a RAM database of a few pieces of information like screen
				name, character model, and position
				The server then will echo back information to all clients
				instructing them on where to move actors
 
				Essentially I'm working on rebuilding the multiplayer system
				of a game called Dungeon Siege from ground up.
 
	I want to put a special thanks out to Aaron aka FireNet for writing
	the most excellent tutorial I have ever read.  I went from knowing
	cin and cout to writing a full non-blocking multi-client echo server
	in just one and a half weeks because of him.
 
// LINKS //
 
	Remember to link to : wsock32.lib
 
*/
 
// INCLUDE FILES //
 
#include <fstream.h>
#include <iostream.h>
#include <stdio.h>
#include <string.h>
#include <winsock.h>
 
// DEFINITIONS //
 
#define		PORT 4000		// Define the port to connect to
#define		MAX_CLIENTS 10	// Define the maximum number of clients we can receive
#define		BUFFER_SIZE 256 // Define the buffer size of the messages
 
// STRUCTURES //
 
struct _client
{
	bool		connected;
	sockaddr_in	address;
	SOCKET		socket;
	fd_set		socket_data;
	int			address_length;
 
	char		template_name[15];
	char		screen_name[15];
	char		siegepos[45];
};
 
// GLOBAL VARIABLES //
 
sockaddr_in	server_address;
sockaddr	server_socket_address;
SOCKET		server_socket;
 
_client		client[MAX_CLIENTS];
int			clients_connected = 0;
 
// FUNCTION DECLARATIONS //
 
bool	accept_client ( _client *current_client );
int		accept_connections ();
int		disconnect_client ( _client *current_client );
void	echo_message ( char *message );
void	end_server();
void	midcopy ( char* input, char* output, int start_pos, int stop_pos );
int		receive_client ( _client *current_client, char *buffer, int size );
void	receive_data();
int		send_data ( _client *current_client, char *buffer, int size );
void	start_server();
 
// FUNCTION DEFINITIONS //
 
bool accept_client ( _client *current_client )
{
	// Accept incoming connections
	current_client->address_length = sizeof ( sockaddr );
	current_client->socket = accept ( server_socket, ( sockaddr * ) &current_client->address, &current_client->address_length );
 
	if ( current_client->socket == 0 )
	{
		// No data in socket
		return ( FALSE );
	}
	else if ( current_client->socket == SOCKET_ERROR )
	{
		// Socket error
		return ( FALSE );
	}
	else
	{
		// Occupy the client slot
		current_client->connected = TRUE;
		FD_ZERO ( &current_client->socket_data );
		FD_SET ( current_client->socket, &current_client->socket_data );
 
		return ( TRUE );
	}
 
	return ( FALSE );
}
 
int accept_connections()
{
	if ( clients_connected < MAX_CLIENTS )
	{
		for ( int j = 0; j < MAX_CLIENTS; j++ )
		{
			if ( !client[j].connected )
			{
				if ( accept_client ( &client[j] ) )
				{
					// Increment the client count
					clients_connected++;
 
					// Grab the ip address of the client ... just for fun
					char *client_ip_address = inet_ntoa ( client[j].address.sin_addr );
 
					// Output connection
					cout << "ACCEPTING CLIENT to array position [" << j << "] with IP ADDRESS " << client_ip_address << endl;
				}
			}
		}
	}
 
	return ( 1 );
}
 
int disconnect_client ( _client *current_client )
{ // Disconnect a client
	if ( current_client->connected == TRUE )
	{ // Close the socket for the client
		closesocket ( current_client->socket );
	}
 
	// Set the new client state
	current_client->connected = FALSE;
 
	// Clear the address length
	current_client->address_length = -1;
 
	// Decrement the current number of connected clients
	clients_connected--;
 
	// Declare a variable to store the disconnect message into
	char raw_data[BUFFER_SIZE];
 
	// Parse in the client data to send
	sprintf ( raw_data, "~4 %s", current_client->screen_name );
 
	// Echo out the disconnect message so all clients drop this client
	echo_message ( raw_data );
 
	cout << "Disconnecting client[]" << endl;
 
	return ( 1 );
}
 
void echo_message ( char *message )
{
	for ( int j = 0; j < MAX_CLIENTS; j++ )
	{
		if ( client[j].connected )
		{ // Echo the message to all clients
			send_data ( &client[j], message, BUFFER_SIZE );
		}
	}
}
 
void end_server()
{ // Shut down the server by disconnecting all clients and clearing winsock
	// Disconnect all clients
	for ( int j = 0; j < MAX_CLIENTS, j++;) { disconnect_client ( &client[j] ); }
 
	// Close the listening socket for the server
	closesocket ( server_socket );
 
	// Clean up winsock
	WSACleanup();
}
 
void midcopy ( char* input, char* output, int start_pos, int stop_pos )
{
	int index = 0;
 
	for ( int i = start_pos; i < stop_pos; i++ )
	{
		output[index] = input[i];
		index++;
	}
 
	output[index] = 0;
}
 
int receive_client ( _client *current_client, char *buffer, int size )
{
	if ( FD_ISSET ( current_client->socket, &current_client->socket_data ) )
	{
		// Store the return data of what we have sent
		current_client->address_length = recv ( current_client->socket, buffer, size, 0 );
 
		if ( current_client->address_length == 0 )
		{ // Data error on client
			disconnect_client ( current_client );
 
			return ( FALSE );
		}
 
		return ( TRUE );
	}
 
	return ( FALSE );
}
 
void receive_data()
{
	char buffer[BUFFER_SIZE];
 
	for ( int j = 0; j < MAX_CLIENTS; j++ )
	{
		if ( client[j].connected )
		{
			if ( receive_client ( &client[j], buffer, BUFFER_SIZE ) )
			{
				if ( buffer[0] == '~' )
				{ // All data should be buffered by a '~' just because
 
					if ( buffer[1] == '1' ) // Add Client Command
					{
						// Declare the buffer to store new client information into
						char raw_data[BUFFER_SIZE];
 
						// Parse out the 'Add Client' command
						midcopy ( buffer, raw_data, 3, strlen ( buffer ) );
 
						// Store the client information into our RAM client database
						sscanf ( raw_data, "%s %s %s", client[j].template_name, client[j].screen_name, client[j].siegepos );
 
						for ( int k = 0; k < MAX_CLIENTS; k++ )
						{
							if ( ( client[k].connected ) && ( j != k ) )
							{
								// Parse in the client data to send
								sprintf ( raw_data, "~1 %s %s %s", client[k].template_name, client[k].screen_name, client[k].siegepos );
 
								// Send the client data
								send_data ( &client[j], raw_data, BUFFER_SIZE );
							}
						}
					}
					else if ( buffer[1] == '2' ) // Move Client Command
					{
						// Declare the buffer to store new client information into
						char raw_data[BUFFER_SIZE];
 
						// Parse out the 'Move Client' command
						midcopy ( buffer, raw_data, 3, strlen ( buffer ) );
 
						// Update the client information into our RAM client database
						sscanf ( raw_data, "%s %s", client[j].screen_name, client[j].siegepos );
					}
					else if ( buffer[1] == '3' ) // Chat Client Command
					{
						// ECHO THE MESSAGE BACK TO ALL CLIENTS
					}
					else if ( buffer[1] == '4' ) // Remove Client Command
					{
						// Disconnect the current client
						disconnect_client ( &client[j] );
					}
 
					// Display all data received
					// cout << buffer << endl;
 
					// Echo the message to the other clients
					echo_message ( buffer );
 
					// Clear the buffer
					buffer[0] = '/0';
				}
			}
		}
	}
}
 
int send_data ( _client *current_client, char *buffer, int size )
{
	// Store the return information about the sending
	current_client->address_length = send ( current_client->socket, buffer, size, 0 );
 
	if ( ( current_client->address_length == SOCKET_ERROR ) || ( current_client->address_length == 0 ) )
	{ // Check for errors while sending
		disconnect_client ( current_client );
 
		return ( FALSE );
	}
	else return ( TRUE );
}
 
void start_server()
{ // Initialize the server and start listening for clients
	// LOCAL VARIABLES //
	WSADATA wsaData;
	int res, i = 1;
 
	// Set up the address structure
	server_address.sin_family = AF_INET;
	server_address.sin_addr.s_addr = INADDR_ANY;
	server_address.sin_port = htons ( PORT);
 
	// IM GUESSING : Copy over some addresses, conversions of some sort ?
	memcpy ( &server_socket_address, &server_address, sizeof ( SOCKADDR_IN ) );
 
	res = WSAStartup ( MAKEWORD ( 1, 1 ), &wsaData );
 
	// Start winsock
	if ( res != 0 ) 
	{
		cout << "WSADATA ERROR : Error while attempting to initialize winsock." << endl;
	}
 
	// Create a listening socket for the server
	server_socket = socket ( AF_INET, SOCK_STREAM, IPPROTO_TCP );
 
	if ( server_socket == INVALID_SOCKET )
	{
		cout << "SOCKET ERROR : Invalid socket." << endl;
	}
	else if ( server_socket == SOCKET_ERROR )
	{
		cout << "SOCKET ERROR : Socket error." << endl;
	}
	else
	{
		cout << "SOCKET ESTABLISHED" << endl;
	}
 
	// Sets the option to re-use the address the entire run of the program
	setsockopt ( server_socket, SOL_SOCKET, SO_REUSEADDR, ( char * ) &i, sizeof ( i ) );
 
	// Bind the socket to the address
	res = bind ( server_socket, &server_socket_address, sizeof ( server_socket_address ) );
 
	cout << "Binding socket:" << res << endl;
 
	if ( res != 0 )
	{
		cout << "BINDING ERROR : Failed to bind socket to address." << endl;
	}
	else
	{
		cout << "Socket Bound to port : "<< PORT << endl;
	}
 
	// Start listening for connection requests
	res = listen ( server_socket, 8 );
 
	// This makes the server non blocking, hence it won't wait for a response
	unsigned long b = 1;
	ioctlsocket ( server_socket, FIONBIO, &b );
 
	// Clear all clients state
	for ( int j = 0; j < MAX_CLIENTS; j++ ) { client[j].connected = FALSE; }
}
 
////////////////////////////////////////////////////////////////////////////
 
////////////////////////////////////////////////////////////////////////////
 
// MAIN FUNCTION //
 
int main()
{
	cout << "\txmen90s Non-Blocking Multi-Client Echo Server for Dungeon Siege\n" << endl;
 
	// Initialize winsock and start listening
	start_server();
 
	// Loop forever
	bool looping = TRUE;
 
	while ( looping )
	{
		// Accept all incoming client connections
		accept_connections();
 
		// Receive all data from clients
		receive_data();
	}
 
	// Shut down winsock
	end_server();
 
	return 0;
}