/*
 * 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 serves as a target for the pr_inject program to run.
 * pr_target_hook() is used as a place to set a breakpoint and the before and
 * after point for the test. pr_inject will modify a bunch of our state
 * (currently file descriptors) and then we will validate it after we run again.
 */

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

#include "pr_target.h"

/*
 * This is used as a place to set a breakpoint for the target to find us. It is
 * a weak symbol to help avoid compiler optimization.
 */
#pragma weak pr_target_hook
void
pr_target_hook(void)
{
}

static bool
pr_target_check_fd(const char *desc, int fd, int fflag, int fdflags,
    const struct stat *st)
{
	int val;
	bool ret = true;
	struct stat targ;

	val = fcntl(fd, F_GETFL, NULL);
	if (val < 0) {
		warn("TEST FAILED: %s F_GETFL failed", desc);
		ret = false;
	} else if ((val & O_ACCMODE) != fflag) {
		warnx("TEST FAILED: %s: open flags mismatch: found 0x%x, "
		    "expected 0x%x", desc, val & O_ACCMODE, fflag);
		ret = false;
	} else {
		(void) printf("TEST PASSED: %s: injected open flags match "
		    "expected value\n", desc);
	}

	val = fcntl(fd, F_GETFD, NULL);
	if (val < 0) {
		warn("TEST FAILED: %s F_GETFD failed", desc);
		ret = false;
	} else if (val != fdflags) {
		warnx("TEST FAILED: %s: fd flags mismatch: found 0x%x, "
		    "expected 0x%x", desc, val, fdflags);
		ret = false;
	} else {
		(void) printf("TEST PASSED: %s: injected fd flags match "
		    "expected value\n", desc);
	}

	if (fstat(fd, &targ) != 0) {
		warn("TEST FAILED: %s: failed to stat fd", desc);
		ret = false;
	} else if (st->st_ino != targ.st_ino || st->st_dev != targ.st_dev ||
	    st->st_rdev != targ.st_rdev) {
		warnx("TEST FAILED: %s: fstat data does not match "
		    "expectations", desc);
		ret = false;
	} else {
		(void) printf("TEST PASSED: %s: fstat information matched\n",
		    desc);
	}

	return (ret);
}

int
main(void)
{
	int ret = EXIT_SUCCESS;
	struct stat nstat, zstat;
	int fd;

	(void) closefrom(STDERR_FILENO + 1);

	fd = open("/dev/null", PRT_NULL_OFLAG);
	if (fd < 0) {
		errx(EXIT_FAILURE, "TEST FAILED: failed to open /dev/null");
	}
	VERIFY3S(fd, ==, PRT_NULL_FD);

	if (fstat(fd, &nstat) != 0) {
		err(EXIT_FAILURE, "failed to fstat /dev/null");
	}

	fd = open("/dev/zero", O_RDONLY);
	if (fd < 0) {
		errx(EXIT_FAILURE, "TEST FAILED: failed to open /dev/zero");
	}
	VERIFY3S(fd, ==, PRT_CLOSE_FD);

	if (fstat(fd, &zstat) != 0) {
		err(EXIT_FAILURE, "failed to fstat /dev/zero");
	}

	pr_target_hook();

	if (!pr_target_check_fd("normal open", PRT_NULL_FD, PRT_NULL_OFLAG,
	    PRT_NULL_GETFD, &nstat)) {
		ret = EXIT_FAILURE;
	}

	if (!pr_target_check_fd("injected open", PRT_ZERO_FD, PRT_ZERO_OFLAG,
	    PRT_ZERO_GETFD, &zstat)) {
		ret = EXIT_FAILURE;
	}

	if (!pr_target_check_fd("injected F_DUPFD", PRT_DUP_FD, PRT_DUP_OFLAG,
	    PRT_DUP_GETFD, &nstat)) {
		ret = EXIT_FAILURE;
	}

	if (!pr_target_check_fd("injected F_DUP2FD_CLOFORK", PRT_CLOFORK_FD,
	    PRT_CLOFORK_OFLAG, PRT_CLOFORK_GETFD, &nstat)) {
		ret = EXIT_FAILURE;
	}

	if (!pr_target_check_fd("injected F_DUP3FD", PRT_DUP3_FD,
	    PRT_DUP3_OFLAG, PRT_DUP3_GETFD, &zstat)) {
		ret = EXIT_FAILURE;
	}

	/*
	 * The close fd we expect to have been closed already.
	 */
	if (fcntl(PRT_CLOSE_FD, F_GETFD, NULL) != -1) {
		warnx("TEST FAILED: fstat on supposedly closed fd worked");
		ret = false;
	} else if (errno != EBADF) {
		warnx("TEST FAILED: expected EBADF on closed fd, but found %s",
		    strerrorname_np(errno));
		ret = false;
	} else {
		(void) printf("TEST PASSED: injected close successfully closed "
		    "fd\n");
	}

	return (ret);
}