/**
 * mds — A micro-display server
 * Copyright © 2014, 2015, 2016, 2017  Mattias Andrée (maandree@kth.se)
 * 
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 * 
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 * 
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
#include "mds-server.h"

#include "globals.h"
#include "interception-condition.h"
#include "client.h"
#include "queued-interception.h"
#include "multicast.h"
#include "interceptors.h"
#include "sending.h"
#include "slavery.h"
#include "receiving.h"

#include <libmdsserver/config.h>
#include <libmdsserver/linked-list.h>
#include <libmdsserver/hash-table.h>
#include <libmdsserver/fd-table.h>
#include <libmdsserver/macros.h>
#include <libmdsserver/util.h>
#include <libmdsserver/hash-help.h>

#include <stdio.h>
#include <limits.h>
#include <unistd.h>
#include <pwd.h>
#include <errno.h>
#include <sys/socket.h>
#include <dirent.h>
#include <inttypes.h>


/**
 * This variable should declared by the actual server implementation.
 * It must be configured before `main` is invoked.
 * 
 * This tells the server-base how to behave
 */
server_characteristics_t server_characteristics = {
	.require_privileges = 0,
	.require_display = 0, /* We will service one ourself. */
	.require_respawn_info = 1,
	.sanity_check_argc = 1,
	.fork_for_safety = 0,
	.danger_is_deadly = 0
};



#define __free(I)\
	if (I >  0) pthread_mutex_destroy(&slave_mutex);\
	if (I >  1) pthread_cond_destroy(&slave_cond);\
	if (I >  2) pthread_mutex_destroy(&modify_mutex);\
	if (I >  3) pthread_cond_destroy(&modify_cond);\
	if (I >= 4) hash_table_destroy(&modify_map, NULL, NULL);\
	if (I >= 5) fd_table_destroy(&client_map, NULL, NULL);\
	if (I >= 6) linked_list_destroy(&client_list)

#define error_if(I, CONDITION)\
	if (CONDITION) { xperror(*argv); __free(I); return 1; }


/**
 * This function will be invoked before `initialise_server` (if not re-exec:ing)
 * or before `unmarshal_server` (if re-exec:ing)
 * 
 * @return  Non-zero on error
 */
int
preinitialise_server(void)
{
	int unparsed_args_ptr = 1;
	char *unparsed_args[ARGC_LIMIT + LIBEXEC_ARGC_EXTRA_LIMIT + 1];
	char *arg;
	int i;
	pid_t pid;

#if (LIBEXEC_ARGC_EXTRA_LIMIT < 3)
# error LIBEXEC_ARGC_EXTRA_LIMIT is too small, need at least 3.
#endif


	/* Parse command line arguments. */
	for (i = 1; i < argc; i++) {
		arg = argv[i];
		if (startswith(arg, "--socket-fd=")) { /* Socket file descriptor. */
			exit_if (socket_fd != -1,
			         eprintf("duplicate declaration of %s.", "--socket-fd"););
			exit_if (strict_atoi(arg += strlen("--socket-fd="), &socket_fd, 0, INT_MAX) < 0,
			         eprintf("invalid value for %s: %s.", "--socket-fd", arg););
		} else if (startswith(arg, "--alarm=")) { /* Schedule an alarm signal for forced abort. */
			alarm((unsigned)min(atou(arg + strlen("--alarm=")), 60)); /* At most 1 minute. */
		} else if (!strequals(arg, "--initial-spawn") && !strequals(arg, "--respawn")) {
				/* Not recognised, it is probably for another server. */
				unparsed_args[unparsed_args_ptr++] = arg;
		}
	}
	unparsed_args[unparsed_args_ptr] = NULL;

	/* Check that mandatory arguments have been specified. */
	exit_if (socket_fd < 0, eprint("missing socket file descriptor argument."););


	/* Run mdsinitrc. */
	if (!is_respawn) {
		pid = fork();
		fail_if (pid == (pid_t)-1);

		if (!pid) { /* Child process exec:s, the parent continues without waiting for it. */
				/* Close all files except stdin, stdout and stderr. */
			close_files(fd > 2 || fd == socket_fd);

			/* Run mdsinitrc. */
			run_initrc(unparsed_args); /* Does not return. */
		}
	}


	/* Create mutex and condition for slave counter. */
	error_if (0, (errno = pthread_mutex_init(&slave_mutex, NULL)));
	error_if (1, (errno = pthread_cond_init(&slave_cond, NULL)));

	/* Create mutex, condition and map for message modification. */
	error_if (2, (errno = pthread_mutex_init(&modify_mutex, NULL)));
	error_if (3, (errno = pthread_cond_init(&modify_cond, NULL)));
	error_if (4, hash_table_create(&modify_map));


	return 0;

fail:
	xperror(*argv);
	return 1;
}


/**
 * This function should initialise the server,
 * and it not invoked after a re-exec.
 * 
 * @return  Non-zero on error
 */
int
initialise_server(void)
{
	/* Create list and table of clients. */
	error_if (5, fd_table_create(&client_map));
	error_if (6, linked_list_create(&client_list, 32));

	return 0;
}


/**
 * This function will be invoked after `initialise_server` (if not re-exec:ing)
 * or after `unmarshal_server` (if re-exec:ing)
 * 
 * @return  Non-zero on error
 */
int __attribute__((const))
postinitialise_server(void)
{
	/* We do not need to initialise anything else. */
	return 0;
}


/**
 * Perform the server's mission
 * 
 * @return  Non-zero on error
 */
int
master_loop(void)
{
	/* Accepting incoming connections and take care of dangers. */
	while (running && !terminating) {
		if (danger) {
			danger = 0;
			with_mutex (slave_mutex, linked_list_pack(&client_list););
		}

		if (accept_connection() == 1)
			break;
	}

	/* Join with all slaves threads. */
	with_mutex (slave_mutex,
	            while (running_slaves > 0)
	                    pthread_cond_wait(&slave_cond, &slave_mutex););
  
	if (!reexecing) {
		/* Release resources. */
		__free(9999);
	}

	return 0;
}


#undef error_if
#undef __free


/**
 * Accept an incoming and start a slave thread for it
 * 
 * @return  Zero normally, 1 if terminating
 */
int
accept_connection(void)
{
	pthread_t slave_thread;
	int client_fd;

	/* Accept connection. */
	client_fd = accept(socket_fd, NULL, NULL);
	if (client_fd >= 0) {
		/* Increase number of running slaves. */
		with_mutex (slave_mutex, running_slaves++;);

		/* Start slave thread. */
		create_slave(&slave_thread, client_fd);
	} else {
		/* Handle errors and shutdown. */
		if (errno == EINTR && terminating) /* Interrupted for termination. */
			return 1;
		else if (errno == ECONNABORTED || errno == EINVAL) /* Closing. */
			running = 0;
		else if (errno != EINTR) /* Error. */
			xperror(*argv);
	}
  return 0;
}


/**
 * Master function for slave threads
 * 
 * @param   data  Input data
 * @return        Output data
 */
void *
slave_loop(void *data)
{
	int slave_fd = (int)(intptr_t)data;
	size_t information_address = fd_table_get(&client_map, (size_t)slave_fd);
	client_t *information = (void *)information_address;
	char *msgbuf = NULL;
	char buf[] = "To: all";
	size_t n;
	int r;


	if (!information) { /* Did not re-exec. */
		/* Initialise the client. */
		fail_if (!(information = initialise_client(slave_fd)));

		/* Register client to receive broadcasts. */
		add_intercept_condition(information, buf, 0, 0, 0);
	}

	/* Store slave thread and create mutexes and conditions. */
	fail_if (client_initialise_threading(information));

	/* Set up traps for especially handled signals. */
	fail_if (trap_signals() < 0);


	/* Fetch messages from the slave. */
	while (!terminating && information->open) {
		/* Send queued multicast messages. */
		send_multicast_queue(information);

		/* Send queued messages. */
		send_reply_queue(information);

		/* Fetch message. */
		r = fetch_message(information);
		if (!r && message_received(information))
			goto terminate;
		else if (r == -2)
			goto done;
		else if (r && errno == EINTR && terminating)
			goto terminate; /* Stop the thread if we are re-exec:ing or terminating the server. */
	}
	/* Stop the thread if we are re-exec:ing or terminating the server. */
	if (terminating)
		goto terminate;


	/* Multicast information about the client closing. */
	n = 2 * 10 + 1 + strlen("Client closed: :\n\n");
	fail_if (xmalloc(msgbuf, n, char));
	snprintf(msgbuf, n,
	         "Client closed: %" PRIu32 ":%" PRIu32 "\n"
	         "\n",
	         (uint32_t)(information->id >> 32),
	         (uint32_t)(information->id >>  0));
	n = strlen(msgbuf);
	queue_message_multicast(msgbuf, n, information);
	msgbuf = NULL;
	send_multicast_queue(information);


terminate: /* This done on success as well. */
	if (reexecing)
		goto reexec;

done:
	/* Close socket and free resources. */
	xclose(slave_fd);
	free(msgbuf);
	if (information) {
		/* Unlist and free client. */
		with_mutex (slave_mutex, linked_list_remove(&client_list, information->list_entry););
		client_destroy(information);
	}

	/* Unmap client and decrease the slave count. */
	with_mutex (slave_mutex,
	            fd_table_remove(&client_map, slave_fd);
	            running_slaves--;
	            pthread_cond_signal(&slave_cond););
	return NULL;


fail:
	xperror(*argv);
	goto done;


reexec:
	/* Tell the master thread that the slave has closed,
	   this is done because re-exec causes a race-condition
	   between the acception of a slave and the execution
	   of the the slave thread. */
	with_mutex (slave_mutex,
	            running_slaves--;
	            pthread_cond_signal(&slave_cond););
	return NULL;
}


/**
 * Compare two queued interceptors by priority
 * 
 * @param   a:const queued_interception_t*  One of the interceptors
 * @param   b:const queued_interception_t*  The other of the two interceptors
 * @return                                  Negative if a before b, positive if a after b, otherwise zero
 */
static int __attribute__((nonnull))
cmp_queued_interception(const void *a, const void *b)
{
	const queued_interception_t *p = b; /* Highest first, so swap them. */
	const queued_interception_t *q = a;
	return p->priority < q->priority ? -1 : p->priority > q->priority;
}


/**
 * Queue a message for multicasting
 * 
 * @param  message  The message
 * @param  length   The length of the message
 * @param  sender   The original sender of the message
 */
void
queue_message_multicast(char *message, size_t length, client_t *sender)
{
	char *msg = message;
	size_t header_count = 0;
	size_t n = length - 1;
	size_t *hashes = NULL;
	char **headers = NULL;
	char **header_values = NULL;
	queued_interception_t *interceptions = NULL;
	size_t interceptions_count = 0;
	multicast_t *multicast = NULL;
	size_t i;
	uint64_t modify_id;
	char modify_id_header[13 + 3 * sizeof(uint64_t)];
	void *new_buf;
	int saved_errno;
	char *end, *colon;

	/* Count the number of headers. */
	for (i = 0; i < n; i++)
		if (message[i] == '\n')
			if (header_count++, message[i + 1] == '\n')
				break;

	if (!header_count)
		return; /* Invalid message. */

	/* Allocate multicast message. */
	fail_if (xmalloc(multicast, 1, multicast_t));
	multicast_initialise(multicast);

	/* Allocate header lists. */
	fail_if (xmalloc(hashes,        header_count, size_t));
	fail_if (xmalloc(headers,       header_count, char *));
	fail_if (xmalloc(header_values, header_count, char *));

	/* Populate header lists. */
	for (i = 0; i < header_count; i++)
		{
			end = strchr(msg, '\n');
			colon = strchr(msg, ':');

			*end = '\0';
			if (xstrdup(header_values[i], msg)) {
				header_count = i;
				fail_if (1);
			}
			*colon = '\0';
			if (xstrdup(headers[i], msg)) {
				saved_errno = errno, free(headers[i]), errno = saved_errno;
				header_count = i;
				fail_if (1);
			}
			*colon = ':';
			*end = '\n';
			hashes[i] = string_hash(headers[i]);

			msg = end + 1;
		}

	/* Get intercepting clients. */
	pthread_mutex_lock(&(slave_mutex));
	interceptions = get_interceptors(sender, hashes, headers, header_values, header_count, &interceptions_count);
	pthread_mutex_unlock(&(slave_mutex));
	fail_if (!interceptions);

	/* Sort interceptors. */
	qsort(interceptions, interceptions_count, sizeof(queued_interception_t), cmp_queued_interception);

	/* Add prefix to message with ‘Modify ID’ header. */
	with_mutex (slave_mutex,
	            modify_id = next_modify_id++;
	            if (!next_modify_id)
	                    next_modify_id = 1;
	           );
	xsnprintf(modify_id_header, "Modify ID: %" PRIu64 "\n", modify_id);
	n = strlen(modify_id_header);
	new_buf = message;
	fail_if (xrealloc(new_buf, n + length, char));
	message = new_buf;
	memmove(message + n, message, length * sizeof(char));
	memcpy(message, modify_id_header, n * sizeof(char));

	/* Store information. */
	multicast->interceptions = interceptions;
	multicast->interceptions_count = interceptions_count;
	multicast->message = message;
	multicast->message_length = length + n;
	multicast->message_prefix = n;
	message = NULL;

#define fail fail_in_mutex
	/* Queue message multicasting. */
	with_mutex (sender->mutex,
	            new_buf = sender->multicasts;
	            fail_if (xrealloc(new_buf, sender->multicasts_count + 1, multicast_t));
	            sender->multicasts = new_buf;
	            sender->multicasts[sender->multicasts_count++] = *multicast;
	            free(multicast);
	            multicast = NULL;
	            errno = 0;
	fail_in_mutex:
	            xperror(*argv);
	           );
#undef fail

done:
	/* Release resources. */
	xfree(headers, header_count);
	xfree(header_values, header_count);
	free(hashes);
	free(message);
	if (multicast)
		multicast_destroy(multicast);
	free(multicast);
	return;

fail:
	xperror(*argv);
	goto done;
}


/**
 * Exec into the mdsinitrc script
 * 
 * @param  args  The arguments to the child process
 */
void
run_initrc(char **args)
{
	char pathname[PATH_MAX];
	struct passwd *pwd;
	char *env, *home, *begin, *end;
	int len;

	args[0] = pathname;

#define __exec(FORMAT, ...)\
	(xsnprintf(pathname, FORMAT, __VA_ARGS__), execv(args[0], args))

	/* Test $XDG_CONFIG_HOME. */
	if ((env = getenv_nonempty("XDG_CONFIG_HOME")))
		__exec("%s/%s", env, INITRC_FILE);

	/* Test $HOME. */
	if ((env = getenv_nonempty("HOME"))) {
		__exec("%s/.config/%s", env, INITRC_FILE);
		__exec("%s/.%s", env, INITRC_FILE);
	}

	/* Test ~. */
	pwd = getpwuid(getuid()); /* Ignore error. */
	if (pwd) {
		home = pwd->pw_dir;
		if (home && *home) {
			__exec("%s/.config/%s", home, INITRC_FILE);
			__exec("%s/.%s", home, INITRC_FILE);
		}
	}

	/* Test $XDG_CONFIG_DIRS. */
	if ((env = getenv_nonempty("XDG_CONFIG_DIRS"))) {
		for (begin = env;;) {
			end = strchrnul(begin, ':');
			len = (int)(end - begin);
			if (len > 0)
				__exec("%.*s/%s", len, begin, INITRC_FILE);
			if (!*end)
				break;
			begin = end + 1;
		}
	}

	/* Test /etc. */
	__exec("%s/%s", SYSCONFDIR, INITRC_FILE);

#undef __exec

	/* Everything failed. */
	eprintf("unable to run %s file, you might as well kill me.", INITRC_FILE);
	/* (‘me’ actually refers to the parant, whence it will to be coming.) */
	exit(0);
}