#include <sys/types.h>
#include <unistd.h>
#include <errno.h>
#include <stdbool.h>
#include <stdio.h> // Per sprintf, fprintf
#include <sys/wait.h> // Per wait
#include <string.h> // Per memset
#include <signal.h> // Pels senyals
#include <assert.h> // Pels assert
#include <stdlib.h> // Per l'abort

#include "rfc3164.h"

const char syslog_in_unix[] = "syslog_in_unix";
const char syslog_in_npipe[] = "syslog_in_npipe";
const char syslog_in_udp[] = "syslog_in_udp";

#define TEST_NPIPE "prova_npipe"
#define TEST_UDP 4000
#define TEST_UNIX "prova_unix"

void child_handler(int parameter)
{
	pid_t pid;
	int status;

	do
	{
		pid = waitpid(-1, &status, WNOHANG);
		/* Debug */
		if (WIFEXITED(status))
		{
			fprintf(stderr, "Child %i died fine:%i\n",
				pid, WEXITSTATUS(status));
		} else 
			fprintf(stderr, "Child %i signaled strange.\n",
				pid);
	} while(pid == 0);
}

int run_program(const char * restrict programname,
		const char * restrict parameter1, int comm_pipe[])
{
	int pid;

	pid = fork();
	assert(pid != -1);
	if (pid == 0)
	{
		close(0);
		close(1);
		dup(comm_pipe[0]);
		dup(comm_pipe[1]);
		execl(programname, programname, parameter1, NULL);
		/* Unreachable */
		fprintf(stderr, "Child exec failed(%s %s): %s\n",
			programname, parameter1, strerror(errno));
		abort();
		return 0;
	}
	else
	{
		fprintf(stderr, "Child forked(%s %s): %i\n",
			programname, parameter1, pid);
		return pid;
	}
}

int init_in_unix(const char * restrict socketname, int input_pipe[])
{
	return run_program(syslog_in_unix, socketname, input_pipe);
}

int init_in_udp(unsigned int port, int input_pipe[])
{
	char buffer[20];
	
	snprintf(buffer, 20, "%u", port);

	return run_program(syslog_in_udp, buffer, input_pipe);
}

int init_in_npipe(const char * restrict pipename, int input_pipe[])
{
	return run_program(syslog_in_npipe, pipename, input_pipe);
}

void kernel_loop()
{
	int input_pipe[2];
	char missatge[MESSAGE_LENGTH+1];
	int status;

	pipe(input_pipe);

	init_in_npipe(TEST_NPIPE, input_pipe);
	init_in_udp(TEST_UDP, input_pipe);
	init_in_unix(TEST_UNIX, input_pipe);

	/* We don't want to write to the programs */
	close(input_pipe[1]);

	while(true)
	{
		status = read(input_pipe[0], missatge, MESSAGE_LENGTH);

		if (status > 0)
		{
			/* Add a ZERO */
			missatge[status] = '\0';
			/* The \n is included in the message */
			printf("Received: %s",missatge);
		}
		else if (status == -1 && errno == EINTR)
			continue;
		else
			break;
	}

	if (status == -1)
	{
		printf("Error reading from the main pipe: %s\n", 
			strerror(errno));
	}


}

void install_signal_handlers()
{
	struct sigaction my_action;
	int result;

	my_action.sa_handler = child_handler;
	my_action.sa_flags = SA_NOCLDSTOP;
	memset(&my_action.sa_mask, 0, sizeof(my_action.sa_mask));

	result = sigaction(SIGCHLD, &my_action, NULL);
	assert(result == 0);
}

int main(int argn, char *argv[])
{
	install_signal_handlers();
	kernel_loop();
}