/*
 * 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 2024 Oxide Computer Company
 */

/*
 * This program is designed to operate alongside pr_target.c. It verifies that
 * we can run a program with libproc and inject various system calls via the
 * agent LWP. It has a contract with pr_target.c to inject operations at the
 * function 'pr_target_hook()'. pr_target.c will then verify that those
 * operations are visible.
 */

#include <stdlib.h>
#include <err.h>
#include <libproc.h>
#include <errno.h>
#include <sys/wait.h>
#include <stdbool.h>
#include <sys/debug.h>
#include <string.h>

#include "pr_target.h"

static uint_t pr_timeout = 5 * 1000; /* 5s in ms */

/*
 * Verify a few things about the state before we inject a bunch of things.
 */
static bool
pr_check_pre(struct ps_prochandle *P)
{
	bool ret = true;
	int fd;
	struct stat st, targ;

	if ((fd = open("/dev/null", O_RDONLY)) < 0) {
		err(EXIT_FAILURE, "TEST FAILED: failed to open /dev/null");
	}

	if (fstat(fd, &st) != 0) {
		err(EXIT_FAILURE, "TEST FAILED: failed to fstat /dev/null");
	}
	VERIFY0(close(fd));

	if (pr_fstat(P, PRT_NULL_FD, &targ) != 0) {
		warn("TEST FAILED: pr_fstat() on target failed");
		ret = false;
	} else {
		(void) printf("TEST PASSED: successfully injected fstat()\n");
	}

	if (st.st_ino != targ.st_ino || st.st_dev != targ.st_dev ||
	    st.st_rdev != targ.st_rdev) {
		warnx("TEST FAILED: pr_fstat() data does not match local "
		    "/dev/null fstat() data");
		ret = false;
	} else {
		(void) printf("TEST PASSED: pr_fstat() data on /dev/null "
		    "matched local data\n");
	}

	if (pr_fstat(P, PRT_ZERO_FD, &targ) == 0) {
		warnx("TEST FAILED: Injected pr_fstat() on fd %u worked "
		    "but expected it not to exist!", PRT_ZERO_FD);
		ret = false;
	} else if (errno != EBADF) {
		int e = errno;
		warnx("TEST FAILED: expected pr_fstat on fd %u to return %s "
		    "but found %s", PRT_ZERO_FD, strerrorname_np(EBADF),
		    strerrorname_np(e));
		ret = false;
	} else {
		(void) printf("TEST PASSED: pr_fstat() on bad fd returned "
		    "EBADF\n");
	}

	return (ret);
}

static bool
pr_inject(struct ps_prochandle *P)
{
	bool ret = true;
	uintptr_t farg0, farg1;
	int fd;

	fd = pr_open(P, "/dev/zero", PRT_ZERO_OFLAG, 0);
	if (fd < 0) {
		warnx("TEST FAILED: failed to open /dev/zero in the target");
		ret = false;
	} else if (fd != PRT_ZERO_FD) {
		warnx("TEST FAILED: pr_open() didn't return FD %u as expected "
		    "but fd %u", PRT_ZERO_FD, fd);
		ret = false;
	} else {
		(void) printf("TEST PASSED: open() successfully injected\n");
	}

	farg0 = PRT_NULL_FD;
	fd = pr_fcntl(P, PRT_NULL_FD, F_DUPFD, (void *)farg0, NULL);
	if (fd < 0) {
		warn("TEST FAILED: failed to inject F_DUPFD fcntl");
		ret = false;
	} else if (fd != PRT_DUP_FD) {
		warnx("TEST FAILED: F_DUPFD didn't return FD %u as expected "
		    "but fd %u", PRT_ZERO_FD, fd);
		ret = false;
	} else {
		(void) printf("TEST PASSED: F_DUPFD successfully injected\n");
	}

	farg0 = PRT_CLOFORK_FD;
	fd = pr_fcntl(P, PRT_NULL_FD, F_DUP2FD_CLOFORK, (void *)farg0, NULL);
	if (fd < 0) {
		warn("TEST FAILED: failed to inject F_DUP2FD_CLOFORK fcntl");
		ret = false;
	} else if (fd != PRT_CLOFORK_FD) {
		warnx("TEST FAILED: F_DUP2FD_CLOFORK didn't return FD %u as "
		    "expected but fd %u", PRT_ZERO_FD, fd);
		ret = false;
	} else {
		(void) printf("TEST PASSED: F_DUP2FD_CLOFORK successfully "
		    "injected\n");
	}

	farg0 = PRT_DUP3_FD;
	farg1 = PRT_DUP3_GETFD;
	fd = pr_fcntl(P, PRT_ZERO_FD, F_DUP3FD, (void *)farg0, (void *)farg1);
	if (fd < 0) {
		warn("TEST FAILED: failed to inject F_DUP3FD fcntl");
		ret = false;
	} else if (fd != PRT_DUP3_FD) {
		warnx("TEST FAILED: F_DUP3FD didn't return FD %u as expected "
		    "but fd %u", PRT_ZERO_FD, fd);
		ret = false;
	} else {
		(void) printf("TEST PASSED: F_DUP3FD successfully injected\n");
	}

	if (pr_close(P, PRT_CLOSE_FD) != 0) {
		warn("TEST FAILED: failed to inject close()");
		ret = false;
	} else {
		(void) printf("TEST PASSED: close() successfully injected\n");
	}

	return (ret);
}

int
main(int argc, char *argv[])
{
	int ret = EXIT_SUCCESS, perr, wstat;
	struct ps_prochandle *P;
	GElf_Sym sym;
	ulong_t bkpt;
	pid_t pid;

	if (argc != 2) {
		errx(EXIT_FAILURE, "missing required program to inject "
		    "against");
	}

	P = Pcreate(argv[1], &argv[1], &perr, NULL, 0);
	if (P == NULL) {
		errx(EXIT_FAILURE, "failed to create %s: %s (0x%x)", argv[1],
		    Pcreate_error(perr), perr);
	}

	(void) Punsetflags(P, PR_RLC);
	if (Psetflags(P, PR_KLC | PR_BPTADJ) != 0) {
		int e = errno;
		Prelease(P, PRELEASE_KILL);
		errc(EXIT_FAILURE, e, "failed to set PR_KLC | PR_BPTADJ flags");
	}

	if (Pxlookup_by_name(P, LM_ID_BASE, PR_OBJ_EXEC, "pr_target_hook", &sym,
	    NULL) != 0) {
		err(EXIT_FAILURE, "failed to find pr_target_hook symbol");
	}

	pid = Ppsinfo(P)->pr_pid;

	if (Pfault(P, FLTBPT, 1) != 0) {
		errx(EXIT_FAILURE, "failed to set the FLTBPT disposition");
	}

	if (Psetbkpt(P, sym.st_value, &bkpt) != 0) {
		err(EXIT_FAILURE, "failed to set breakpoint on pr_target_hook "
		    "(0x%" PRIx64 ")", sym.st_value);
	}

	if (Psetrun(P, 0, 0) != 0) {
		err(EXIT_FAILURE, "failed to resume running our target");
	}

	if (Pwait(P, pr_timeout) != 0) {
		err(EXIT_FAILURE, "%s did not hit our expected breakpoint",
		    argv[1]);
	}

	/*
	 * This is where we actually perform all of our injections and
	 * validations. By hitting the breakpoint the expected fd should exist.
	 */
	if (!pr_check_pre(P)) {
		ret = EXIT_FAILURE;
	}

	if (!pr_inject(P)) {
		ret = EXIT_FAILURE;
	}

	if (Pdelbkpt(P, sym.st_value, bkpt) != 0) {
		err(EXIT_FAILURE, "failed to delete breakpoint");
	}

	if (Psetrun(P, 0, PRCFAULT) != 0) {
		err(EXIT_FAILURE, "failed to resume running our target");
	}

	if (waitpid(pid, &wstat, 0) != pid) {
		err(EXIT_FAILURE, "failed to get our %s's (%" _PRIdID "), "
		    "wait info", argv[1], pid);
	}

	if (WIFEXITED(wstat) == 0) {
		errx(EXIT_FAILURE, "%s didn't actually exit!",
		    argv[1]);
	}

	if (WEXITSTATUS(wstat) != 0) {
		errx(EXIT_FAILURE, "%s failed with 0x%x", argv[1],
		    WEXITSTATUS(wstat));
	} else {
		(void) printf("TEST PASSED: target process self-verification "
		    "passed\n");
	}

	if (ret == EXIT_SUCCESS) {
		(void) printf("All tests passed successfully\n");
	}

	return (ret);
}