/*	$NetBSD: director.c,v 1.29 2021/06/10 07:21:07 mcf Exp $	*/

/*-
 * Copyright 2009 Brett Lymn <blymn@NetBSD.org>
 * Copyright 2021 Roland Illig <rillig@NetBSD.org>
 *
 * All rights reserved.
 *
 * This code has been donated to The NetBSD Foundation by the Author.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. The name of the author may not be used to endorse or promote products
 *    derived from this software without specific prior written permission
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

#include <sys/param.h>
#include <sys/stat.h>
#include <sys/mman.h>
#include <sys/wait.h>
#include <fcntl.h>
#include <unistd.h>
#include <ctype.h>
#include <termios.h>
#include <signal.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <util.h>
#include <err.h>
#include "returns.h"
#include "director.h"

void yyparse(void);
#define DEF_TERMPATH "."
#define DEF_TERM "atf"
#define DEF_SLAVE "./slave"

const char *def_check_path = "./"; /* default check path */

extern size_t nvars;		/* In testlang_conf.y */
saved_data_t  saved_output;	/* In testlang_conf.y */
int to_slave;
int from_slave;
int master;			/* pty to the slave */
int verbose;			/* control verbosity of tests */
int check_file_flag;		/* control check-file generation */
const char *check_path;		/* path to prepend to check files for output
				   validation */
char *cur_file;			/* name of file currently being read */

void init_parse_variables(int);	/* in testlang_parse.y */

/*
 * Handle the slave exiting unexpectedly, try to recover the exit message
 * and print it out.
 *
 * FIXME: Must not use stdio in a signal handler.  This leads to incomplete
 * output in verbose mode, truncating the useful part of the error message.
 */
static void
slave_died(int signo)
{
	char last_words[256];
	size_t count;

	fprintf(stderr, "ERROR: Slave has exited\n");
	if (saved_output.count > 0) {
		fprintf(stderr, "output from slave: ");
		for (count = 0; count < saved_output.count; count ++) {
			unsigned char b = saved_output.data[count];
			if (isprint(b))
				fprintf(stderr, "%c", b);
			else
				fprintf(stderr, "\\x%02x", b);
		}
		fprintf(stderr, "\n");
	}

	if ((count = read(master, &last_words, 255)) > 0) {
		last_words[count] = '\0';
		fprintf(stderr, "slave exited with message \"%s\"\n",
			last_words);
	}

	exit(2);
}


static void
usage(void)
{
	fprintf(stderr, "Usage: %s [-vgf] [-I include-path] [-C check-path] "
	    "[-T terminfo-file] [-s pathtoslave] [-t term] "
	    "commandfile\n", getprogname());
	fprintf(stderr, " where:\n");
	fprintf(stderr, "    -v enables verbose test output\n");
	fprintf(stderr, "    -g generates check-files if they do not exist\n");
	fprintf(stderr, "    -f overwrites check-files with the actual data\n");
	fprintf(stderr, "    -T is a directory containing the terminfo.cdb "
	    "file, or a file holding the terminfo description\n");
	fprintf(stderr, "    -s is the path to the slave executable\n");
	fprintf(stderr, "    -t is value to set TERM to for the test\n");
	fprintf(stderr, "    -C is the directory for check-files\n");
	fprintf(stderr, "    commandfile is a file of test directives\n");
	exit(1);
}


int
main(int argc, char *argv[])
{
	extern char *optarg;
	extern int optind;
	const char *termpath, *term, *slave;
	int ch;
	pid_t slave_pid;
	extern FILE *yyin;
	char *arg1, *arg2;
	struct termios term_attr;
	struct stat st;
	int pipe_to_slave[2], pipe_from_slave[2];

	termpath = term = slave = NULL;
	verbose = 0;
	check_file_flag = 0;

	while ((ch = getopt(argc, argv, "vgfC:s:t:T:")) != -1) {
		switch (ch) {
		case 'C':
			check_path = optarg;
			break;
		case 'T':
			termpath = optarg;
			break;
		case 's':
			slave = optarg;
			break;
		case 't':
			term = optarg;
			break;
		case 'v':
			verbose = 1;
			break;
		case 'g':
			check_file_flag |= GEN_CHECK_FILE;
			break;
		case 'f':
			check_file_flag |= FORCE_GEN;
			break;
		case '?':
		default:
			usage();
			break;
		}
	}

	argc -= optind;
	argv += optind;
	if (argc != 1)
		usage();

	if (termpath == NULL)
		termpath = DEF_TERMPATH;

	if (slave == NULL)
		slave = DEF_SLAVE;

	if (term == NULL)
		term = DEF_TERM;

	if (check_path == NULL)
		check_path = getenv("CHECK_PATH");
	if ((check_path == NULL) || (check_path[0] == '\0')) {
		warnx("$CHECK_PATH not set, defaulting to %s", def_check_path);
		check_path = def_check_path;
	}

	signal(SIGCHLD, slave_died);

	if (setenv("TERM", term, 1) != 0)
		err(2, "Failed to set TERM variable");

	if (unsetenv("ESCDELAY") != 0)
		err(2, "Failed to unset ESCDELAY variable");

	if (stat(termpath, &st) == -1)
		err(1, "Cannot stat %s", termpath);

	if (S_ISDIR(st.st_mode)) {
		char tinfo[MAXPATHLEN];
		int l = snprintf(tinfo, sizeof(tinfo), "%s/%s", termpath,
		    "terminfo.cdb");
		if (stat(tinfo, &st) == -1)
			err(1, "Cannot stat `%s'", tinfo);
		if (l >= 4)
			tinfo[l - 4] = '\0';
		if (setenv("TERMINFO", tinfo, 1) != 0)
			err(1, "Failed to set TERMINFO variable");
	} else {
		int fd;
		char *tinfo;
		if ((fd = open(termpath, O_RDONLY)) == -1)
			err(1, "Cannot open `%s'", termpath);
		if ((tinfo = mmap(NULL, (size_t)st.st_size, PROT_READ, MAP_FILE,
			fd, 0)) == MAP_FAILED)
			err(1, "Cannot map `%s'", termpath);
		if (setenv("TERMINFO", tinfo, 1) != 0)
			err(1, "Failed to set TERMINFO variable");
		close(fd);
		munmap(tinfo, (size_t)st.st_size);
	}

	if (pipe(pipe_to_slave) < 0)
		err(1, "Command pipe creation failed");
	to_slave = pipe_to_slave[1];

	if (pipe(pipe_from_slave) < 0)
		err(1, "Slave pipe creation failed");
	from_slave = pipe_from_slave[0];

	/*
	 * Create default termios settings for later use
	 */
	memset(&term_attr, 0, sizeof(term_attr));
	term_attr.c_iflag = TTYDEF_IFLAG;
	term_attr.c_oflag = TTYDEF_OFLAG;
	term_attr.c_cflag = TTYDEF_CFLAG;
	term_attr.c_lflag = TTYDEF_LFLAG;
	cfsetspeed(&term_attr, TTYDEF_SPEED);
	term_attr.c_cc[VERASE] = '\b';
	term_attr.c_cc[VKILL] = '\025'; /* ^U */

	if ((slave_pid = forkpty(&master, NULL, &term_attr, NULL)) < 0)
		err(1, "Fork of pty for slave failed\n");

	if (slave_pid == 0) {
		/* slave side, just exec the slave process */
		if (asprintf(&arg1, "%d", pipe_to_slave[0]) < 0)
			err(1, "arg1 conversion failed");
		close(pipe_to_slave[1]);

		close(pipe_from_slave[0]);
		if (asprintf(&arg2, "%d", pipe_from_slave[1]) < 0)
			err(1, "arg2 conversion failed");

		if (execl(slave, slave, arg1, arg2, (char *)0) < 0)
			err(1, "Exec of slave %s failed", slave);

		/* NOT REACHED */
	}

	(void)close(pipe_to_slave[0]);
	(void)close(pipe_from_slave[1]);

	fcntl(master, F_SETFL, O_NONBLOCK);

	if ((yyin = fopen(argv[0], "r")) == NULL)
		err(1, "Cannot open command file %s", argv[0]);

	if ((cur_file = strdup(argv[0])) == NULL)
		err(2, "Failed to alloc memory for test file name");

	init_parse_variables(1);

	yyparse();
	fclose(yyin);

	signal(SIGCHLD, SIG_DFL);
	(void)close(to_slave);
	(void)close(from_slave);

	int status;
	(void)waitpid(slave_pid, &status, 0);

	exit(0);
}