/* SPDX-License-Identifier: ISC */
#include <sys/types.h>
#include <sys/wait.h>
#include <unistd.h>
#include <stdlib.h>
#include <dirent.h>
#include <stdio.h>
#include <fcntl.h>
#include <errno.h>
#include <ctype.h>

#include "init.h"

static int setup_env(void)
{
	int status = -1;
	ssize_t ret;
	FILE *fp;

	clearenv();

	fp = fopen(ENVFILE, "r");
	if (fp == NULL) {
		perror(ENVFILE);
		return -1;
	}

	do {
		char *line = NULL;
		size_t n = 0;

		errno = 0;
		ret = getline(&line, &n, fp);

		if (ret < 0) {
			if (errno == 0) {
				status = 0;
			} else {
				perror(ENVFILE);
			}
		} else if (ret > 0 && putenv(line) != 0) {
			perror("putenv");
			ret = -1;
		}

		free(line);
	} while (ret >= 0);

	fclose(fp);
	return status;
}

static int close_all_files(void)
{
	struct dirent *ent;
	int fd, n;
	DIR *dir;

	dir = opendir(PROCFDDIR);

	if (dir == NULL) {
		if (errno != ENOENT) {
			perror(PROCFDDIR);
			return -1;
		}

		n = sysconf(_SC_OPEN_MAX);
		if (n < 0) {
			perror("getting maximum file descriptor count");
			return -1;
		}

		for (fd = STDERR_FILENO + 1; fd < n; ++fd)
			close(fd);
	} else {
		while ((ent = readdir(dir)) != NULL) {
			if (!isdigit(ent->d_name[0]))
				continue;

			fd = atoi(ent->d_name);

			if (fd == STDIN_FILENO || fd == STDOUT_FILENO ||
			    fd == STDERR_FILENO) {
				continue;
			}

			close(fd);
		}

		closedir(dir);
	}

	return 0;
}

static int setup_tty(const char *tty, bool truncate)
{
	int fd;

	if (tty == NULL)
		return 0;

	fd = open(tty, O_RDWR);
	if (fd < 0) {
		perror(tty);
		return -1;
	}

	if (truncate)
		ftruncate(fd, 0);

	setsid();

	dup2(fd, STDIN_FILENO);
	dup2(fd, STDOUT_FILENO);
	dup2(fd, STDERR_FILENO);
	close(fd);
	return 0;
}

static __attribute__((noreturn)) void argv_exec(exec_t *e)
{
	char **argv = alloca(sizeof(char *) * (e->argc + 1)), *ptr;
	int i;

	for (ptr = e->args, i = 0; i < e->argc; ++i, ptr += strlen(ptr) + 1)
		argv[i] = ptr;

	argv[i] = NULL;
	execvp(argv[0], argv);
	perror(argv[0]);
	exit(EXIT_FAILURE);
}

static pid_t current_child;

static void runsvc_sighandler(int signo)
{
	if (current_child != -1)
		kill(current_child, signo);
}

static int run_sequentially(exec_t *list, bool direct_exec_last)
{
	pid_t ret, pid;
	int status;

	current_child = -1;

	for (; list != NULL; list = list->next) {
		if (list->next == NULL && direct_exec_last)
			argv_exec(list);

		pid = fork();

		if (pid == 0)
			argv_exec(list);

		if (pid == -1) {
			perror("fork");
			return EXIT_FAILURE;
		}

		current_child = pid;

		do {
			ret = wait(&status);
		} while (ret != pid);

		current_child = -1;

		if (!WIFEXITED(status))
			return EXIT_FAILURE;

		if (WEXITSTATUS(status) != EXIT_SUCCESS)
			return WEXITSTATUS(status);
	}

	do {
		ret = wait(&status);
	} while (ret != -1 || errno != ECHILD);

	return ret;
}

pid_t runsvc(service_t *svc)
{
	struct sigaction act;
	pid_t pid;
	int ret;

	pid = fork();

	if (pid == -1)
		perror("fork");

	if (pid == 0) {
		cli(NULL);

		memset(&act, 0, sizeof(act));
		act.sa_handler = runsvc_sighandler;
		sigaction(SIGTERM, &act, NULL);
		sigaction(SIGINT, &act, NULL);
		sigaction(SIGHUP, &act, NULL);

		act.sa_handler = SIG_DFL;
		sigaction(SIGUSR1, &act, NULL);
		sigaction(SIGCHLD, &act, NULL);

		if (setup_env())
			exit(EXIT_FAILURE);

		if (close_all_files())
			exit(EXIT_FAILURE);

		if (setup_tty(svc->ctty,
			      (svc->flags & SVC_FLAG_TRUNCATE_OUT) != 0)) {
			exit(EXIT_FAILURE);
		}

		sti(NULL);

		if (svc->flags & SVC_FLAG_SUB_REAPER) {
			prctl(PR_SET_CHILD_SUBREAPER, 1, 0, 0, 0);

			ret = run_sequentially(svc->exec, false);
		} else {
			ret = run_sequentially(svc->exec, true);
		}

		exit(ret);
	}

	return pid;
}