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

void sig_chld(int signo)
{
	pid_t pid;
	int stat;

	// the following code will make sure that we remove
	// ALL terminated child processes
	while ((pid = waitpid(-1, &stat, WNOHANG)) > 0) 
		printf("child %d terminated.\n", (int)pid);
	return ;
}

/* this routine read n bytes 
 * using the function from the textbook, instead of our own
 */
ssize_t 
readn(int fd, void *vptr, size_t n) {
	size_t nleft;
	ssize_t nread;
	char *ptr;

	ptr = vptr;
	nleft = n;
	while (nleft > 0) {
		if ((nread = read(fd, ptr, nleft)) < 0) {
			if (errno == EINTR) {
				nread = 0; // and call read() again
			} else { 
				return (-1);
			}
		} else if (nread == 0) {
			break; // end-of-file
		}
		nleft -= nread;
		ptr += nread;
	}
	return (n - nleft);
}
/* this routine read n bytes */
// int readn (int sock, char *msgp, unsigned msgsize)
// {
// 	int rlen;
// 	int temp;
// 
// 	do {
// 		rlen = read(sock, msgp, msgsize);
// 	} while (rlen == -1 && errno == EINTR);
// 
// 	if (rlen == 0) {
// 		/* connection closed */
// 		return 0;
// 	}
// 
// 
// 	while (rlen <msgsize) {
// 		do {
// 			temp = read(sock, (msgp+rlen), msgsize-rlen);  
// 		} while (temp == -1 && errno == EINTR);
// 		rlen += temp;
// 	}
// 
// 	if (rlen == 0) {
// 		/* connection closed */
// 		return 0;
// 	}
// 
// 	if (rlen < msgsize) {
// 		perror(": read");
// 		_exit(1);
// 	} 
// 
// 	return !0;
// }
// 

int main(int argc, char * argv[])
{
	int sockfd, rec_sock, len;
	struct sockaddr_in addr, recaddr;
	struct sigaction abc;
	char buf[100];

	abc.sa_handler = sig_chld;
	sigemptyset(&abc.sa_mask);
	abc.sa_flags = 0;

	sigaction(SIGCHLD, &abc, NULL);

	if (argc < 2) {
		printf("Usage: a.out port.\n");
		exit(0);
	}

	if ((sockfd = socket(AF_INET, SOCK_STREAM, 0)) < 0) {
		perror(": Can't get socket");
		exit(1);
	}

	addr.sin_addr.s_addr = INADDR_ANY;
	addr.sin_family = AF_INET;
	addr.sin_port = htons((short)atoi(argv[1]));

	if (bind(sockfd, (struct sockaddr *)&addr, sizeof(addr)) < 0) {
		perror(": bind");
		exit(1);
	}


	len = sizeof(addr);
	if (getsockname(sockfd, (struct sockaddr *)&addr, (socklen_t *)&len) < 0)
	{
		perror(": can't get name");
		_exit(1);
	}

	printf("ip = %s, port = %d\n", inet_ntoa(addr.sin_addr), ntohs(addr.sin_port));

	if (listen(sockfd, 5) < 0) {
		perror(": bind");
		exit(1);
	}

	/*  sleep(100); */

	while (1) {
		/* blocking here, if no signal */
		if ((rec_sock = accept(sockfd, (struct sockaddr
							*)(&recaddr), (socklen_t *)&len)) < 0) {
			fprintf(stderr, "here 1\n");
			if (errno == EINTR)
				continue;
			else {
				perror(":accept error");
				exit(1);
			}
		}

		/*
		if (rec_sock < 0) {
			perror(": accept");
			exit(1);
		}
		*/
		/* print the remote socket information */

		printf("remote machine = %s, port = %x, %x.\n", inet_ntoa(recaddr.sin_addr), \
				recaddr.sin_port, ntohs(recaddr.sin_port));

		memset(&recaddr, 0, sizeof(recaddr));
		len = sizeof(addr);
		if (getpeername(rec_sock, (struct sockaddr *)&recaddr,
					(socklen_t *)&len) < 0) {
			perror(": can't get name");
			_exit(1);
		}
		printf("remote machine = %s, port = %d, %d.\n", inet_ntoa(recaddr.sin_addr), \
				recaddr.sin_port, ntohs(recaddr.sin_port));

		if (fork() == 0) {
			int num;
			close(sockfd);

			// reading out the integer value
			readn(rec_sock, (char *)&num, sizeof(num));
			printf("Receiving %d %x\n", num, num);
			// note that we did not send back the integer value

			while ((num = read(rec_sock, buf, 100))) {
				if (num > 0) 
					write(rec_sock, buf, num);
			}
			exit(0);
		} else {
			close(rec_sock);
		}
	}
}