#include <stdio.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <netdb.h>
#include <sys/time.h>
#define MAX_CLIENTS 64

struct sockaddr_in servaddr;
int addr_len;
struct sockaddr addr;
struct sockaddr_in *ptr;
int cl_addr_len;
struct sockaddr_in cl_addr;
char in_buf[100], out_buf[100];
char names [10][30];
char message[150];
int num_names = 0;

	typedef struct cl_info
		{
			char cl_id[30];
			int cl_status;
		}cl_info;

	cl_info clients[MAX_CLIENTS];

	int main(int argc, char **argv)
		{
			int newsockfd;
			int sockfd;
			int nbytes;
			int max_fd;
			int fd;
			short func_num;

			fd_set test_set, ready_set;



	sockfd = socket(AF_INET, SOCK_STREAM, 0); 
	servaddr.sin_family - AF_INET;
	servaddr.sin_port = 0;				 /*choose an unused port at random */
	servaddr.sin_addr.s_addr = INADDR_ANY;	 	/* auto fill with my IP address */
	bind(sockfd,(struct sockaddr*) &servaddr, sizeof(servaddr));

	addr_len = sizeof(addr);
	getsockname(sockfd, &addr, &addr_len);
	ptr = (struct sockaddr_in *)&addr;
	printf("\nServer on port# %d\n", ptr->sin_port);

	listen(sockfd, 5);
	max_fd = sockfd; 
	FD_ZERO(&test_set); /*clear the listening socket */

	FD_SET(sockfd, &test_set);

	

	while(1)
		{
			memcpy(&ready_set, &test_set, sizeof(test_set));
			select(max_fd+1, &ready_set, NULL, NULL, NULL);
			
			if(FD_ISSET(sockfd, &ready_set)) /*if listening sock has data its a call from new client */
				{
					/*create a new socket */

					cl_addr_len = sizeof(cl_addr);
					newsockfd = accept(sockfd, (struct sockaddr *)&cl_addr, &cl_addr_len);

					printf("\nA new connection has been made to socket %d\n", newsockfd);
					FD_SET(newsockfd, &test_set); /* add new socket to list */
					if(newsockfd > max_fd)
						max_fd = newsockfd; /*update max_fd with new socket file discriptor */
				} /*end if*/


			for(fd=0; fd <= max_fd; fd++) /*loop through connected socket file discriptors */
{
if((fd !=sockfd) && FD_ISSET(fd, &ready_set))/*bypass listening sock if sock has data*/
if(process_call(fd, max_fd) == 0) /*if socket is closed */
{
printf("\nThe listening socket is now closed\n");
close(newsockfd);
printf("\nClient on socket %d has left the room\n", sockfd);
FD_CLR(fd, &test_set); /*remove socket from list */
/*decrement user count */
} /*end if */
} /* end for loop */
} /*end while loop */
return 0;
} /*end main */
int add_name(int sockfd)
{
int nbytes;
short name_len;
short n_name_len;

printf("\nAdding name .....\n");
nbytes = read(sockfd, (char *)&name_len, sizeof(short));
name_len = ntohs(name_len); /*convert name_len from network to host short */
memset(clients[sockfd].cl_id, 0, 30); /*set all bytes to zero */
nbytes = read(sockfd, clients[sockfd].cl_id, name_len);
num_names ++; /*increment user count */
printf("\n%s has joined the chat room\n", clients[sockfd].cl_id);

/*need to broadcast user has joined plus user id to connected clients here */

} /*end add_name function */
int how_many(int sockfd, int max)
{
int sock;
short user_len;
char username[30];

for(sock = 4; sock <= max; sock++)
{
strcpy(username, clients[sock].cl_id);

user_len = htons(strlen(username));
write(sockfd, (char *)&user_len, sizeof(short));
write(sockfd, username, strlen(username));
send_user_list(sockfd, username);
}
} /*end how_many function */
int send_user_list(int sockfd, char *users)
{
short msg_type;
short user_len;

msg_type = htons(2);
printf("msg_type is : %u\n", msg_type);
write(sockfd, &msg_type, sizeof(short));

user_len = htons(strlen(users));
write(sockfd, (char *)&user_len, sizeof(short));
write(sockfd, users, strlen(users));
}
int find_name(int sockfd, int max)
{
char search_name[30];
int sock;
int found = 0;
short len, name_len;
char sender[30];
short sender_len;
char msg[150];
short msg_len;

memset(search_name, 0, 30); /*set all bytes to zero */
printf("\nReceiving userid......\n");
read(sockfd, (char *)&name_len, sizeof(short));
len = ntohs(name_len);
read(sockfd, search_name, len);
read(sockfd, &msg_len, sizeof(short));
msg_len = ntohs(msg_len);
read(sockfd, msg, msg_len);
msg[msg_len] = '\0';

strcpy(sender, clients[sockfd].cl_id);

for(sock = 4; sock <= max; sock++)
{
printf(" %d is held in max\n", max);
printf("\ncomparing search request for %s with %s username\n",
search_name, clients[sock].cl_id);
if(strcmp(search_name, clients[sock].cl_id) ==0)
{
printf("\nuserid found\n");
found = 1;
send_async_msg(sock, msg,sender);
}/*end if */
} /*end for loop */

if(! found)
{
printf("\nuserid not found\n");
} /*end if */
}/*end find_name function */
int process_call(int newsockfd, int max_fd)
{
int nbytes;
short func_num;

nbytes = read(newsockfd, (char *)&func_num, sizeof(short));
if(nbytes ==0)
return 0;
if (nbytes != sizeof(short))
{
perror("\nUnknown menu option!\n");
exit(1);
} /* end if */

func_num = ntohs(func_num);
switch(func_num)
{
case(1):
add_name(newsockfd);
break;
case(2):
how_many(newsockfd, max_fd);
break;
case(3):
find_name(newsockfd, max_fd);
break;
case(4):
send_global_msg(newsockfd, max_fd);
break;
case(5):
printf("\nShutting down Server...\n");
exit(0);
default:
printf("\nUnknown function number!\n");
break;
} /*end switch */
} /*end process_call function */
int send_async_msg(int sockfd, char * msg, char *sender)
{
short msg_type;
short msg_len;
short sender_len;

msg_type = htons(1);
printf("msg_type is : %u\n", msg_type);
write(sockfd, &msg_type, sizeof(short));
msg_len = htons(strlen(msg));
write(sockfd, (char *)&msg_len, sizeof(short));
write(sockfd, msg, strlen(msg));

sender_len = htons(strlen(sender));
write(sockfd, (char *)&sender_len, sizeof(short));
write(sockfd, sender, strlen(sender));
}/* end of send_async_msg function */
int send_global_msg(int sockfd, int max_fd)
{
int nbytes;
int sock;
short len;
short msg_type;
char msg[150];
char sender[30];
short sender_len;

strcpy(sender, clients[sockfd].cl_id);

msg_type = 1;
memset(in_buf, 0, sizeof(in_buf)); /*set all to zero */
nbytes = read(sockfd, &len, sizeof(short));
len = ntohs(len);
read(sockfd, msg, len);
message[len] = '\0';
for(sock = 4; sock <= max_fd; sock++)
{
send_async_msg(sock, msg, sender);
} /*end for loop */
} /* end of send_global_msg function */