#include <unistd.h>
#include <stdlib.h>
#include <stdio.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <netdb.h>
#include <errno.h>
#include <signal.h>
#include <math.h>
#include <string.h>

#ifdef _AIX
#include <sys/select.h>
#endif /* _AIX */

#include "socket_signal.h"

#define CLIENT_TIMEOUT (5) 		/* 30 seconds for client */
#define SERVER_TIMEOUT (300)		/* 5 minutes for server */
extern char *optarg;


char Server_name[255];
short Server_port = 8008;

int Server_size = 5;

/*
 * connects to server_name at port
 * 
 * -- server_name can either be DNS name or ascii rep. of ip address
 * -- returns -1 on failure, socket desc on success
 */
int
CallServer(server_name,server_port)
char *server_name;
short server_port;
{

	struct  sockaddr_in     server; /* remote host address          */
	struct  hostent         *hp;    /* host entity                  */
	int sd;
	int err;
	int temp_addr;
	
	/*
	 * first, check to see if the server_name is specified as
	 * and IP address
	 */
	temp_addr = inet_addr(server_name);
	
	/*
	 * if -1, then server name must be a DNS name and not an
	 * ip address
	 */

	if(temp_addr == -1)
	{
		hp = gethostbyname(server_name);

		if (hp == NULL) 
		{
			fprintf(stderr,"Call Server: unknown server name %s\n",
					server_name);
			fflush(stderr);
			return(-1);
		}
	}
	else
	{
		hp = gethostbyaddr((char *)&temp_addr,
				   sizeof(temp_addr),
				   AF_INET);
		
		if(hp == NULL)
		{
			fprintf(stderr,
		"Call Server: unknown ip address %s\n",
			server_name);
			fflush(stderr);
			return(-1);
		}
	}

	memset(&server,0,sizeof(server));
	// bzero((char *)&server, sizeof(server));
	memcpy(&server.sin_addr, hp->h_addr_list[0], hp->h_length);
  	// bcopy(hp->h_addr, (char *)&server.sin_addr, hp->h_length);
  	server.sin_family = hp->h_addrtype;
  	server.sin_port = htons(server_port);

	sd = socket(hp->h_addrtype, SOCK_STREAM, 0);

	if(sd < 0)
	{
		fprintf(stderr,"Call Server: cannot create socket to server\n");
		fflush(stderr);
		return(-1);
	}

	 
	err = Connect(sd, (struct sockaddr *)&server, sizeof(server), 
			CLIENT_TIMEOUT);

	if(err <= 0)
	{
		fprintf(stderr,"CallServer: connect failed\n");
		fflush(stderr);
		return(-1);
	}

	return(sd);
}

void
HangUp(sd)
int sd;
{
	/*
	 * shutdown closes sockets and close shuts file descriptor
	 */
	(void)shutdown(sd,2);
	(void)close(sd);
	
	return;
}

int
CreateServerSocket(short port)
{
	struct sockaddr_in    server;
	int one = 1;
	int sock_opt_len = sizeof(int);
	int server_sock;
	int err;

	server.sin_port = htons(port);
	server.sin_addr.s_addr = INADDR_ANY;
	server.sin_family = AF_INET;
	
	server_sock = socket (AF_INET,SOCK_STREAM,0);
	
	if(server_sock < 0)
	{
		fprintf(stderr,"CreateServerSocket: socket call failed\n");
		fflush(stderr);
		exit(1);
	}
	
	/*
	 * optional -- allows reopen of socket immediately
	 */
	err = setsockopt(server_sock, SOL_SOCKET, SO_REUSEADDR,
			                  (char *)&one, sock_opt_len);
	
	if(err < 0)
	{
		fprintf(stderr,
		"CreateSocketServer: set sock opt REUSE failed\n");
		fflush(stderr);
	}
	
	/*
	 * bind the socket to the local IP address at the port specified
	 */
	err = bind(server_sock,
		   (struct sockaddr *)&server,
		   sizeof(struct sockaddr_in));

	if(err < 0)
	{
		fprintf(stderr, "CreateSocketServer: bind failed\n");
		fflush(stderr);
		close(server_sock);
		return(-1);
	}
	
	/*
	 * tell kernel how many connections to queue (max 5)
	 */
	
	err = listen(server_sock,5);

	if(err < 0)
	{
		fprintf(stderr,"CreateSocketServer: listen failed\n");
		fflush(stderr);
		close(server_sock);
		return(-1);
	}
	
	return(server_sock);

}

int
WaitForClient(int server_sock)
{

	struct sockaddr_in    peeraddr;
	int peeraddr_len;
	int sd;
	
	sd = -1;
	peeraddr_len = sizeof(peeraddr_len);

	sd = Accept(server_sock,
		    (struct sockaddr *)&peeraddr,
		    &peeraddr_len,
		    SERVER_TIMEOUT);

	if(sd <= 0)
	{
		fprintf(stderr, "accept failed\n");
		fflush(stderr);
		return(-1);
	}
	
	/*
	 * notice that server_sock is not the socket on
	 * which the client now spe