/*
 * Copyright (c) 2013 Oracle and/or its affiliates. All Rights Reserved.
 * Copyright (c) 2020 Petr Vorel <pvorel@suse.cz>
 *
 * 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 2 of
 * the License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it would 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, write the Free Software Foundation,
 * Inc.,  51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 *
 * Author: Alexey Kodanev <alexey.kodanev@oracle.com>
 */

#include <stdio.h>
#include <errno.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/wait.h>
#include <fcntl.h>
#include <unistd.h>
#include <signal.h>
#include "test.h"
#include "tst_cmd.h"
#include "tst_private.h"

#define OPEN_MODE	(S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH)
#define OPEN_FLAGS	(O_WRONLY | O_APPEND | O_CREAT)

enum cmd_op {
	OP_GE, /* >= */
	OP_GT, /* >  */
	OP_LE, /* <= */
	OP_LT, /* <  */
	OP_EQ, /* == */
	OP_NE, /* != */
};


int tst_cmd_fds_(void (cleanup_fn)(void),
		const char *const argv[],
		int stdout_fd,
		int stderr_fd,
		enum tst_cmd_flags flags)
{
	int rc;

	if (argv == NULL || argv[0] == NULL) {
		tst_brkm(TBROK, cleanup_fn,
			"argument list is empty at %s:%d", __FILE__, __LINE__);
		return -1;
	}

	/*
	 * The tst_sig() install poisoned signal handlers for all signals the
	 * test is not expected to get.
	 *
	 * So we temporarily disable the handler for sigchild we get after our
	 * child exits so that we don't have to disable it in each test that
	 * uses this interface.
	 */
	void *old_handler = signal(SIGCHLD, SIG_DFL);

	char path[PATH_MAX];

	if (tst_get_path(argv[0], path, sizeof(path))) {
		if (flags & TST_CMD_TCONF_ON_MISSING)
			tst_brkm(TCONF, cleanup_fn, "Couldn't find '%s' in $PATH at %s:%d", argv[0],
				 __FILE__, __LINE__);
		else
			return 255;
	}

	pid_t pid = vfork();
	if (pid == -1) {
		tst_brkm(TBROK | TERRNO, cleanup_fn, "vfork failed at %s:%d",
			__FILE__, __LINE__);
		return -1;
	}
	if (!pid) {
		/* redirecting stdout and stderr if needed */
		if (stdout_fd != -1) {
			close(STDOUT_FILENO);
			dup2(stdout_fd, STDOUT_FILENO);
		}

		if (stderr_fd != -1) {
			close(STDERR_FILENO);
			dup2(stderr_fd, STDERR_FILENO);
		}

		execvp(argv[0], (char *const *)argv);
		_exit(254);
	}

	int ret = -1;
	if (waitpid(pid, &ret, 0) != pid) {
		tst_brkm(TBROK | TERRNO, cleanup_fn, "waitpid failed at %s:%d",
			__FILE__, __LINE__);
		return -1;
	}

	signal(SIGCHLD, old_handler);

	if (!WIFEXITED(ret)) {
		tst_brkm(TBROK, cleanup_fn, "failed to exec cmd '%s' at %s:%d",
			argv[0], __FILE__, __LINE__);
		return -1;
	}

	rc = WEXITSTATUS(ret);

	if (!(flags & TST_CMD_PASS_RETVAL) && rc) {
		tst_brkm(TBROK, cleanup_fn,
			 "'%s' exited with a non-zero code %d at %s:%d",
			 argv[0], rc, __FILE__, __LINE__);
		return -1;
	}

	return rc;
}

int tst_cmd_(void (cleanup_fn)(void),
		const char *const argv[],
		const char *stdout_path,
		const char *stderr_path,
		enum tst_cmd_flags flags)
{
	int stdout_fd = -1;
	int stderr_fd = -1;
	int rc;

	if (stdout_path != NULL) {
		stdout_fd = open(stdout_path,
				OPEN_FLAGS, OPEN_MODE);

		if (stdout_fd == -1)
			tst_resm(TWARN | TERRNO,
				"open() on %s failed at %s:%d",
				stdout_path, __FILE__, __LINE__);
	}

	if (stderr_path != NULL) {
		stderr_fd = open(stderr_path,
				OPEN_FLAGS, OPEN_MODE);

		if (stderr_fd == -1)
			tst_resm(TWARN | TERRNO,
				"open() on %s failed at %s:%d",
				stderr_path, __FILE__, __LINE__);
	}

	rc = tst_cmd_fds(cleanup_fn, argv, stdout_fd, stderr_fd, flags);

	if ((stdout_fd != -1) && (close(stdout_fd) == -1))
		tst_resm(TWARN | TERRNO,
			"close() on %s failed at %s:%d",
			stdout_path, __FILE__, __LINE__);

	if ((stderr_fd != -1) && (close(stderr_fd) == -1))
		tst_resm(TWARN | TERRNO,
			"close() on %s failed at %s:%d",
			stderr_path, __FILE__, __LINE__);

	return rc;
}

int tst_system(const char *command)
{
	int ret = 0;

	/*
	 *Temporarily disable SIGCHLD of user defined handler, so the
	 *system(3) function will not cause unexpected SIGCHLD signal
	 *callback function for test cases.
	 */
	void *old_handler = signal(SIGCHLD, SIG_DFL);

	ret = system(command);

	signal(SIGCHLD, old_handler);
	return ret;
}

static int mkfs_ext4_version_parser(void)
{
	FILE *f;
	int rc, major, minor, patch;

	f = popen("mkfs.ext4 -V 2>&1", "r");
	if (!f) {
		tst_resm(TWARN, "Could not run mkfs.ext4 -V 2>&1 cmd");
		return -1;
	}

	rc = fscanf(f, "mke2fs %d.%d.%d", &major, &minor, &patch);
	pclose(f);
	if (rc != 3) {
		tst_resm(TWARN, "Unable to parse mkfs.ext4 version");
		return -1;
	}

	return major * 10000 +  minor * 100 + patch;
}

static int mkfs_ext4_version_table_get(char *version)
{
	int major, minor, patch;
	int len;

	if (sscanf(version, "%u.%u.%u %n", &major, &minor, &patch, &len) != 3) {
		tst_resm(TWARN, "Illegal version(%s), should use format like 1.43.0", version);
		return -1;
	}

	if (len != (int)strlen(version)) {
		tst_resm(TWARN, "Grabage after version");
		return -1;
	}

	return major * 10000 + minor * 100 + patch;
}

static struct version_parser {
	const char *cmd;
	int (*parser)(void);
	int (*table_get)(char *version);
} version_parsers[] = {
	{"mkfs.ext4", mkfs_ext4_version_parser, mkfs_ext4_version_table_get},
	{},
};

void tst_check_cmd(const char *cmd)
{
	struct version_parser *p;
	char *cmd_token, *op_token, *version_token, *next, *str;
	char path[PATH_MAX];
	char parser_cmd[100];
	int ver_parser, ver_get;
	int op_flag = 0;

	strcpy(parser_cmd, cmd);

	cmd_token = strtok_r(parser_cmd, " ", &next);
	op_token = strtok_r(NULL, " ", &next);
	version_token = strtok_r(NULL, " ", &next);
	str = strtok_r(NULL, " ", &next);

	if (tst_get_path(cmd_token, path, sizeof(path)))
		tst_brkm(TCONF, NULL, "Couldn't find '%s' in $PATH", cmd_token);

	if (!op_token)
		return;

	if (!strcmp(op_token, ">="))
		op_flag = OP_GE;
	else if (!strcmp(op_token, ">"))
		op_flag = OP_GT;
	else if (!strcmp(op_token, "<="))
		op_flag = OP_LE;
	else if (!strcmp(op_token, "<"))
		op_flag = OP_LT;
	else if (!strcmp(op_token, "=="))
		op_flag = OP_EQ;
	else if (!strcmp(op_token, "!="))
		op_flag = OP_NE;
	else
		tst_brkm(TCONF, NULL, "Invalid op(%s)", op_token);

	if (!version_token || str) {
		tst_brkm(TCONF, NULL,
			"Illegal format(%s), should use format like mkfs.ext4 >= 1.43.0",
			cmd);
	}

	for (p = &version_parsers[0]; p->cmd; p++) {
		if (!strcmp(p->cmd, cmd_token)) {
			tst_resm(TINFO, "Parsing %s version", p->cmd);
			break;
		}
	}

	if (!p->cmd) {
		tst_brkm(TBROK, NULL, "No version parser for %s implemented!",
			cmd_token);
	}

	ver_parser = p->parser();
	if (ver_parser < 0)
		tst_brkm(TBROK, NULL, "Failed to parse %s version", p->cmd);

	ver_get = p->table_get(version_token);
	if (ver_get < 0)
		tst_brkm(TBROK, NULL, "Failed to get %s version", p->cmd);

	switch (op_flag) {
	case OP_GE:
		if (ver_parser < ver_get) {
			tst_brkm(TCONF, NULL, "%s required >= %d, but got %d, "
				"the version is required in order run the test.",
				cmd, ver_get, ver_parser);
		}
		break;
	case OP_GT:
		if (ver_parser <= ver_get) {
			tst_brkm(TCONF, NULL, "%s required > %d, but got %d, "
				"the version is required in order run the test.",
				cmd, ver_get, ver_parser);
		}
		break;
	case OP_LE:
		if (ver_parser > ver_get) {
			tst_brkm(TCONF, NULL, "%s required <= %d, but got %d, "
				"the version is required in order run the test.",
				cmd, ver_get, ver_parser);
		}
		break;
	case OP_LT:
		if (ver_parser >= ver_get) {
			tst_brkm(TCONF, NULL, "%s required < %d, but got %d, "
				"the version is required in order run the test.",
				cmd, ver_get, ver_parser);
		}
		break;
	case OP_EQ:
		if (ver_parser != ver_get) {
			tst_brkm(TCONF, NULL, "%s required == %d, but got %d, "
				"the version is required in order run the test.",
				cmd, ver_get, ver_parser);
		}
		break;
	case OP_NE:
		if (ver_parser == ver_get) {
			tst_brkm(TCONF, NULL, "%s required != %d, but got %d, "
				"the version is required in order run the test.",
				cmd, ver_get, ver_parser);
		}
		break;
	}
}