/*
 * This file and its contents are supplied under the terms of the
 * Common Development and Distribution License ("CDDL"), version 1.0.
 * You may only use this file in accordance with the terms of version
 * 1.0 of the CDDL.
 *
 * A full copy of the text of the CDDL should have accompanied this
 * source.  A copy of the CDDL is also available via the Internet at
 * http://www.illumos.org/license/CDDL.
 */

/*
 * Copyright 2015 Garrett D'Amore <garrett@damore.org>
 * Copyright 2024 Oxide Computer Company
 */

/*
 * This program tests that fexecve works properly.
 */

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <fcntl.h>
#include <err.h>
#include <errno.h>
#include <unistd.h>
#include <note.h>
#include <sys/execx.h>
#include <sys/utsname.h>
#include <sys/wait.h>
#include "test_common.h"

int extra_debug = 0;

struct utsname un;

static void
forkit(char *msg, const char *expect, void (*postfn)(void))
{
	int fd;
	FILE *f;
	pid_t pid;
	char *ptr = NULL, *p;
	size_t cap = 0;
	int wstat;
	int rv;
	test_t t;
	char fname[32];

	(void) strcpy(fname, "/tmp/testXXXXXX");
	t = test_start(msg);

	fd = mkstemp(fname);
	if (fd < 0) {
		test_failed(t, "mkstemp failed: %s", strerror(errno));
		return;
	}

	/* don't leave it in the filesystem */
	(void) unlink(fname);

	pid = fork();
	switch (pid) {
	case -1:
		test_failed(t, "fork failed: %s", strerror(errno));
		return;
	case 0:
		if (dup2(fd, 1) < 0) {
			test_failed(t, "dup2 failed: %s", strerror(errno));
			exit(9);
		}
		postfn();
		exit(0);
	default:
		break;
	}

	/* parent */
	f = fdopen(fd, "r");
	if (f == NULL) {
		(void) close(fd);
		test_failed(t, "fdopen failed: %s", strerror(errno));
		(void) wait(NULL);
		return;
	}
	if (waitpid(pid, &wstat, 0) < 0) {
		test_failed(t, "wait failed: %s", strerror(errno));
		(void) fclose(f);
		return;
	}
	if (!WIFEXITED(wstat) || WEXITSTATUS(wstat) != 0) {
		test_failed(t, "child failed: %#x", wstat);
		(void) fclose(f);
		return;
	}
	(void) lseek(fd, 0, SEEK_SET);
	if ((rv = getline(&ptr, &cap, f)) < 1) {
		test_failed(t, "child gave no data: %d", rv);
		(void) fclose(f);
		return;
	}
	(void) fclose(f);

	if ((p = strchr(ptr, '\n')) != NULL)
		*p = '\0';
	if (extra_debug)
		printf("Child output: [%s]\n", ptr);
	if (strcmp(ptr, expect) != 0) {
		test_failed(t, "[%s] != [%s]", ptr, expect);
		return;
	}

	(void) free(ptr);
	test_passed(t);
}

static void
case_badf(void)
{
	int fd = -1;
	int rv;
	char *args[] = { "uname", NULL };
	char *env[] = { NULL };

	rv = fexecve(fd, args, env);
	if (rv != -1) {
		(void) printf("rv is not -1\n");
		(void) exit(0);
	}
	if (errno != EBADF) {
		(void) printf("err %d(%s) != EBADF\n", errno, strerror(errno));
		(void) exit(0);
	}
	(void) printf("GOOD\n");
	(void) exit(0);
}

static void
case_bad_highf(void)
{
	int fd = 55;
	int rv;
	char *args[] = { "uname", NULL };
	char *env[] = { NULL };

	closefrom(3);
	rv = fexecve(fd, args, env);
	if (rv != -1) {
		(void) printf("rv is not -1\n");
		(void) exit(0);
	}
	if (errno != EBADF) {
		(void) printf("err %d(%s) != EBADF\n", errno, strerror(errno));
		(void) exit(0);
	}
	(void) printf("GOOD\n");
	(void) exit(0);
}

static void
case_notexec(void)
{
	int fd;
	int rv;
	char *args[] = { "uname", NULL };
	char *env[] = { NULL };

	fd = open("/usr/bin/uname", O_RDONLY);

	rv = fexecve(fd, args, env);
	if (rv != -1) {
		(void) printf("rv is not -1\n");
		(void) exit(0);
	}
	(void) printf("FAILURE\n");
	(void) exit(0);
}

static void
case_cloexec(void)
{
	int fd;
	int rv;
	char *args[] = { "ls", "-C", "/proc/self/fd", NULL };
	char *env[] = { NULL };

	/*
	 * We set things up so that this process has only stdin, stdout and
	 * stderr, then `ls` will open a file descriptor for the directory
	 * being listed. If we have more than that then the descriptor we're
	 * about to open has leaked through to the new process despite the
	 * O_CLOEXEC.
	 */
	closefrom(3);
	fd = open("/usr/bin/ls", O_RDONLY | O_EXEC | O_CLOEXEC);

	rv = fexecve(fd, args, env);
	if (rv != -1) {
		(void) printf("rv is not -1\n");
		(void) exit(0);
	}
	(void) printf("FAILURE\n");
	(void) exit(0);
}

static void
case_uname(void)
{
	int fd;
	char *args[] = { "uname", NULL };
	char *env[] = { NULL };

	fd = open("/usr/bin/uname", O_EXEC);
	if (fd < 0) {
		(void) printf("failed to open /usr/bin/uname: %s",
		    strerror(errno));
		(void) exit(0);
	}

	(void) fexecve(fd, args, env);
	(void) printf("EXEC FAILED: %s\n", strerror(errno));
	(void) exit(0);
}

static void
case_uname_r(void)
{
	int fd;
	char *args[] = { "uname", "-r", NULL };
	char *env[] = { NULL };

	fd = open("/usr/bin/uname", O_EXEC);
	if (fd < 0) {
		(void) printf("failed to open /usr/bin/uname: %s",
		    strerror(errno));
		(void) exit(0);
	}

	(void) fexecve(fd, args, env);
	(void) printf("EXEC FAILED: %s\n", strerror(errno));
	(void) exit(0);
}

static void
case_execvex_bad_flags(void)
{
	int fd = -1;
	int rv;
	char *args[] = { "uname", NULL };
	char *env[] = { NULL };

	rv = execvex(fd, args, env, 0x1005);
	if (rv != -1) {
		(void) printf("rv is not -1\n");
		(void) exit(0);
	}
	if (errno != EINVAL) {
		(void) printf("err %d(%s) != EINVAL\n", errno, strerror(errno));
		(void) exit(0);
	}
	(void) printf("GOOD\n");
	(void) exit(0);
}

static void
test_fexecve_badf(void)
{
	forkit("fexecve (bad FD)", "GOOD", case_badf);
}

static void
test_fexecve_bad_highf(void)
{
	forkit("fexecve (bad FD)", "GOOD", case_bad_highf);
}

static void
test_fexecve_notexec(void)
{
	forkit("fexecve (not O_EXEC)", un.sysname, case_notexec);
}

static void
test_fexecve_cloexec(void)
{
	forkit("fexecve (O_CLOEXEC)", "0  1  2  3", case_cloexec);
}

static void
test_fexecve_uname(void)
{
	forkit("fexecve (uname)", un.sysname, case_uname);
}

static void
test_fexecve_uname_r(void)
{
	forkit("fexecve (uname)", un.release, case_uname_r);
}

static void
test_execvex_bad_flags(void)
{
	forkit("execvex (bad flags)", "GOOD", case_execvex_bad_flags);
}

int
main(int argc, char **argv)
{
	int optc;

	(void) uname(&un);

	while ((optc = getopt(argc, argv, "dfD")) != EOF) {
		switch (optc) {
		case 'd':
			test_set_debug();
			break;
		case 'f':
			test_set_force();
			break;
		case 'D':
			test_set_debug();
			extra_debug++;
			break;
		default:
			(void) fprintf(stderr, "Usage: %s [-dfD]\n", argv[0]);
			exit(1);
		}
	}

	test_fexecve_badf();
	test_fexecve_bad_highf();
	test_fexecve_notexec();
	test_fexecve_cloexec();
	test_fexecve_uname();
	test_fexecve_uname_r();
	test_execvex_bad_flags();

	exit(0);
}