keeping multiple tcp connections open after one closes

/*****************************************
**		chat_server_main.cpp			**
**										**
**		server for the chat program		**
**		originally started on 5/25/03   **
*****************************************/

#include <stdio.h>
#include <winsock.h>
#include <process.h> 
#include "my_time.h"

#define		NO_FLAGS_SET    0
#define		PORT            6969
#define		MAX_CLIENTS		25
#define		BUFFER			250
#define		NAME_LEN		15
#define		LIST_SIZE		400

/* STRUCTURES */
struct message
{
	char	data[BUFFER];
	char	name[NAME_LEN];
	bool	list_data_flag;
	char	room_array[LIST_SIZE];
};	

struct client_data
{
	SOCKET			client_sock;
	SOCKADDR_IN		client_addr;
};


/* GLOBAL VARIABLES */		
int					num_clients = 0;			//keep track of how many clients connected
CRITICAL_SECTION	critSec;					//used for printf and global variable incrementing
char				room_list[LIST_SIZE];		//list of people in the room
SOCKET				client_list[MAX_CLIENTS];	//handles to the sockets
int					thread_id = 0;


/*  THREAD FUNCTION PROTOTYPES */
void talkToClient(void *cs);
void send_list(void *ptr);


/*  MAIN  */
int main()
{
	WSADATA		wsaData;				
	SOCKET		hListenServSocket;	
	SOCKADDR_IN	serverSockAddr;	
	
	int			addrLen = sizeof(SOCKADDR_IN),	status = 0;	
	DWORD			threadID,	list_threadID;						
	time_freeze	da_time;
	
	InitializeCriticalSection(&critSec);	
	
	// 1. Initialize WSA, the Window Socket API
	if( ( status = WSAStartup ( MAKEWORD(1, 1), &wsaData )) != 0) {return 1;}
	
	// 2. Create a socket
	if ((hListenServSocket = socket (AF_INET, SOCK_STREAM, 0)) == INVALID_SOCKET)
	{
		if ((status = WSACleanup()) == SOCKET_ERROR) printf("Error in creating socket\n");
		return 1 ;
	}
	
	// 3. Initialize server socket info 
	memset(&serverSockAddr, 0, sizeof(serverSockAddr));		//set up server info
	serverSockAddr.sin_family       = AF_INET;				
	serverSockAddr.sin_addr.s_addr  = htonl(INADDR_ANY);	   
	serverSockAddr.sin_port         = htons(PORT);		// host to network 
	
	// 4. Bind the socket with the address
	status = bind (hListenServSocket, (LPSOCKADDR) &serverSockAddr,sizeof(serverSockAddr));
	if (status == SOCKET_ERROR) { printf("Binding error\n"); return 1;}
	
	// 5. Listen for connections
	if ((status = listen ( hListenServSocket, MAX_CLIENTS )) == SOCKET_ERROR) 
	{ printf("Listen error\n"); return 1;}
	
	/* display startup info to the user */
	gimme_time(da_time, true);
	printf("[][][][]***(( Chat server now listening on port %u ))***[][][][]\n",PORT);
	printf("[][][][]***(( Serving a maximum of %u   clients      ))***[][][][]\n",MAX_CLIENTS);
	
	SOCKET		hNewServSocket;			//client socket
	SOCKADDR_IN	clientSockAddr;			// the clients address structure
	client_data	client_handle[MAX_CLIENTS];
	bool			start_list_thread = true;
	
	while(1)
	{
		// 6. Accept connection request when one received
		hNewServSocket = accept (hListenServSocket, (LPSOCKADDR) &clientSockAddr, &addrLen);
		if (hNewServSocket == INVALID_SOCKET) { printf("Accept error\n"); return 1; }
		printf("\nClient accepted, now serving %u clients", num_clients + 1);
		
		// add client to list; setup struct to pass to thread
		client_list[num_clients] = hNewServSocket;
		client_handle[num_clients].client_addr = clientSockAddr;
		client_handle[num_clients].client_sock = hNewServSocket;
		
		if ((threadID = _beginthread (talkToClient, 0, (void *) &client_handle[num_clients])) == -1)
		{ 
			printf("Thread creation error\n");
			status = closesocket(hNewServSocket);
			if (status == SOCKET_ERROR) printf("Socket closing error\n");
		}
		
		if(start_list_thread)
		{
			if ((list_threadID = _beginthread (send_list, 0, NULL)) == -1)
			{ 
				printf("List thread creation error\n");
				status = closesocket(hNewServSocket);
				if (status == SOCKET_ERROR) printf("Socket closing error #%u\n", WSAGetLastError());
			}
			start_list_thread = false;
		}	  
	} /* while */	
	
	return 1;
}

// talkToClient()  - handles each client - recieves their message & broadcasts it to all clients
void talkToClient(void *cs)
{
	bool	exit = false, first_connect = true;
	int		nBytesSent = 0, nBytesRecvd = 0, myID = 0;										
	message   incoming_data, outgoing_data;
	client_data *ptr = (struct client_data *)cs;		
	SOCKET  hNewServSocket = (SOCKET)ptr->client_sock;	
	
	// increment # of threads and clients
	thread_id++;
	num_clients++;
	myID = thread_id;
	
	printf("\nThread %u has started\n", myID);
	
	//initialize data structures
	incoming_data.list_data_flag = false; outgoing_data.list_data_flag = false;
	strcpy(incoming_data.data,""); strcpy(incoming_data.name,""); strcpy(incoming_data.room_array,"");
	strcpy(outgoing_data.data,""); strcpy(outgoing_data.name,""); strcpy(outgoing_data.room_array,"");
	
	// enter teh send recieve/loop	
	while(!exit)	
	{
		// (a) Receive 
		if (((nBytesRecvd = recv(hNewServSocket,(char *) &incoming_data, 
			sizeof incoming_data,NO_FLAGS_SET)) == 0) || (nBytesRecvd == SOCKET_ERROR))
		{
			if(nBytesRecvd == 0){ printf("Gracefully shutting down...\n");}
			else
			{
				EnterCriticalSection(&critSec);
				printf("recv: Thread %u Failed with error #%u\n", myID, WSAGetLastError());
				LeaveCriticalSection(&critSec);
			}
			exit = true;
			break;
		}
		
		// if this is first time connecting, then log the client's info
		if(first_connect)
		{
			
			printf("Client name is %s , client address is %x\n",incoming_data.name , 
				ptr->client_addr.sin_addr);
			
			//add teh client to the room list now that we have their nick name
			strcat(room_list, incoming_data.name); strcat(room_list, "-");
			first_connect = false;
		}
		
		// (b) Process
		strncpy(outgoing_data.name,incoming_data.name,NAME_LEN);
		strncpy(outgoing_data.data,incoming_data.data,BUFFER); 
		outgoing_data.list_data_flag = false;
		strcpy(outgoing_data.room_array, ""); 
		
		// (c) Broadcast message to all of the clients logged in
		for(int y = 0; y < num_clients;y++)
		{
			nBytesSent = send(client_list[y],(char *) &outgoing_data, 
				sizeof(outgoing_data),NO_FLAGS_SET);
			
			if ((nBytesSent == 0) || (nBytesSent == SOCKET_ERROR))
			{
				if(nBytesSent == 0){ printf("Gracefully shutting down...\n");}
				else
				{
					EnterCriticalSection(&critSec);
					printf("send: Thread %u Failed with error #%u\n", myID, WSAGetLastError());
					LeaveCriticalSection(&critSec);	
				}	
				exit = true;
				break;
			}
		}
		
		printf("\nThread %u is broadcasting\n", myID);
	} // while end	 
	
	//remove the client from the client_array
	for(int m = 0; m < num_clients; m++)
	{
		if(client_list[m] == hNewServSocket)
		{
			client_list[m] = client_list[num_clients - 1];
			client_list[num_clients - 1] = NULL;
		}
	}
	
	//decrement the # of clients connected
	num_clients--;
	
	// terminate the connection with the client
	printf("%s has disconnected...Connection being closed\n",incoming_data.name);
	shutdown    ( hNewServSocket, 1);
	closesocket ( hNewServSocket );
	
	printf("Thread %u has ended\n", myID);
}		

/*  send_list this thread sends out the list once every 5 seconds only if the list has changed	**
**  size since the last time.																	*/

void send_list(void *ptr)
{
	char old_room_list[LIST_SIZE]; 
	int bytes_sent = 0;
	message list_out;
	
	strcpy(old_room_list, room_list);						// get a copy of the list
	printf("List thread starting\n");
	
	while(num_clients > 0)		//while we have clients
	{
		Sleep(5000);			// once every 5 seconds
		if((strcmp(old_room_list, room_list)) != 0)			// list is either bigger/smaller
		{
			strcpy(old_room_list, room_list);				// update our copy of the list
			list_out.list_data_flag = true;					// set flag for client 
			strcpy(list_out.room_array,room_list);			// setup the data packet 
			for(int y = 0; y < num_clients; y++)			// send to all clients
			{
				bytes_sent = send(client_list[y], (char *) &list_out,
					sizeof (list_out), NO_FLAGS_SET);
				if ((bytes_sent == 0) || (bytes_sent == SOCKET_ERROR))
				{
					// bytes_sent = 0 indicates  graceful shutdown.
					EnterCriticalSection(&critSec);//mistah Marshall Brain we do
					printf("Failed with error #%u\n", WSAGetLastError());
					LeaveCriticalSection(&critSec);		
				} // end if
			}	//end for
		}	//end if
	}	// end while
	
	printf("List thread ending\n");
}