/* $NetBSD: t_fileactions.c,v 1.11 2025/07/12 16:25:29 gutteridge Exp $ */

/*-
 * Copyright (c) 2012 The NetBSD Foundation, Inc.
 * All rights reserved.
 *
 * This code is derived from software contributed to The NetBSD Foundation
 * by Charles Zhang <charles@NetBSD.org> and
 * Martin Husemann <martin@NetBSD.org>.
 *
 * 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. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
 * ``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 FOUNDATION OR CONTRIBUTORS
 * 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/cdefs.h>
__RCSID("$NetBSD: t_fileactions.c,v 1.11 2025/07/12 16:25:29 gutteridge Exp $");

#include <sys/stat.h>
#include <sys/wait.h>

#include <atf-c.h>
#include <errno.h>
#include <fcntl.h>
#include <spawn.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>

#include "fa_spawn_utils.h"
#include "h_macros.h"

#define TESTFILE	"./the_input_data"
#define CHECKFILE	"./the_output_data"
#define TESTCONTENT	"marry has a little lamb"

static void
make_testfile(const char *restrict file)
{
	FILE *f;
	ssize_t written;

	REQUIRE_LIBC(f = fopen(file, "w"), NULL);
	RL(written = fwrite(TESTCONTENT, 1, strlen(TESTCONTENT), f));
	REQUIRE_LIBC(fclose(f), EOF);
	ATF_REQUIRE((size_t)written == strlen(TESTCONTENT));
}

ATF_TC(t_spawn_openmode);
ATF_TC_HEAD(t_spawn_openmode, tc)
{
	atf_tc_set_md_var(tc, "descr",
	    "Test the proper handling of 'mode' for 'open' fileactions");
	atf_tc_set_md_var(tc, "require.progs", "/bin/cat");
}
ATF_TC_BODY(t_spawn_openmode, tc)
{
	int status;
	pid_t pid;
	size_t insize, outsize;
	char * const args[2] = { __UNCONST("cat"), NULL };
	posix_spawn_file_actions_t fa;

	/*
	 * try a "cat < testfile > checkfile"
	 */
	make_testfile(TESTFILE);

	RZ(posix_spawn_file_actions_init(&fa));
	RZ(posix_spawn_file_actions_addopen(&fa, fileno(stdin),
		TESTFILE, O_RDONLY, 0));
	RZ(posix_spawn_file_actions_addopen(&fa, fileno(stdout),
		CHECKFILE, O_WRONLY|O_CREAT, 0600));
	RZ(posix_spawn(&pid, "/bin/cat", &fa, NULL, args, NULL));
	RZ(posix_spawn_file_actions_destroy(&fa));

	/* ok, wait for the child to finish */
	RL(waitpid(pid, &status, 0));
	ATF_REQUIRE_MSG((WIFEXITED(status) &&
		WEXITSTATUS(status) == EXIT_SUCCESS),
	    "status=0x%x", status);

	/* now check that input and output have the same size */
	insize = filesize(TESTFILE);
	outsize = filesize(CHECKFILE);
	ATF_CHECK_MSG(insize == strlen(TESTCONTENT),
	    "insize=%zu strlen(TESTCONTENT)=%zu", insize, strlen(TESTCONTENT));
	ATF_CHECK_MSG(insize == outsize,
	    "insize=%zu outsize=%zu", insize, outsize);

	/*
	 * try a "cat < testfile >> checkfile"
	 */
	make_testfile(TESTFILE);
	make_testfile(CHECKFILE);

	RZ(posix_spawn_file_actions_init(&fa));
	RZ(posix_spawn_file_actions_addopen(&fa, fileno(stdin),
		TESTFILE, O_RDONLY, 0));
	RZ(posix_spawn_file_actions_addopen(&fa, fileno(stdout),
		CHECKFILE, O_WRONLY|O_APPEND, 0));
	RZ(posix_spawn(&pid, "/bin/cat", &fa, NULL, args, NULL));
	RZ(posix_spawn_file_actions_destroy(&fa));

	/* ok, wait for the child to finish */
	RL(waitpid(pid, &status, 0));
	ATF_REQUIRE_MSG((WIFEXITED(status) &&
		WEXITSTATUS(status) == EXIT_SUCCESS),
	    "status=0x%x", status);

	/* now check that output is twice as long as input */
	insize = filesize(TESTFILE);
	outsize = filesize(CHECKFILE);
	ATF_CHECK_MSG(insize == strlen(TESTCONTENT),
	    "insize=%zu strlen(TESTCONTENT)=%zu", insize, strlen(TESTCONTENT));
	ATF_CHECK_MSG(insize*2 == outsize,
	    "insize*2=%zu outsize=%zu", insize*2, outsize);

	/*
	 * try a "cat < testfile  > checkfile" with input and output swapped
	 */
	make_testfile(TESTFILE);
	empty_outfile(CHECKFILE);

	RZ(posix_spawn_file_actions_init(&fa));
	RZ(posix_spawn_file_actions_addopen(&fa, fileno(stdout),
		TESTFILE, O_RDONLY, 0));
	RZ(posix_spawn_file_actions_addopen(&fa, fileno(stdin),
		CHECKFILE, O_WRONLY, 0));
	RZ(posix_spawn(&pid, "/bin/cat", &fa, NULL, args, NULL));
	RZ(posix_spawn_file_actions_destroy(&fa));

	/* ok, wait for the child to finish */
	RL(waitpid(pid, &status, 0));
	ATF_REQUIRE_MSG((WIFEXITED(status) &&
		WEXITSTATUS(status) == EXIT_FAILURE),
	    "status=0x%x", status);

	/* now check that input and output are still the same size */
	insize = filesize(TESTFILE);
	outsize = filesize(CHECKFILE);
	ATF_CHECK_MSG(insize == strlen(TESTCONTENT),
	    "insize=%zu strlen(TESTCONTENT)=%zu", insize, strlen(TESTCONTENT));
	ATF_CHECK_MSG(outsize == 0,
	    "outsize=%zu", outsize);
}

ATF_TC(t_spawn_reopen);
ATF_TC_HEAD(t_spawn_reopen, tc)
{
	atf_tc_set_md_var(tc, "descr",
	    "an open filehandle can be replaced by a 'open' fileaction");
	atf_tc_set_md_var(tc, "require.progs", "/bin/cat");
}
ATF_TC_BODY(t_spawn_reopen, tc)
{
	int status;
	pid_t pid;
	char * const args[2] = { __UNCONST("cat"), NULL };
	posix_spawn_file_actions_t fa;

	/*
	 * make sure stdin is open in the parent
	 */
	REQUIRE_LIBC(freopen("/dev/zero", "r", stdin), NULL);
	/*
	 * now request an open for this fd again in the child
	 */
	RZ(posix_spawn_file_actions_init(&fa));
	RZ(posix_spawn_file_actions_addopen(&fa, fileno(stdin),
		"/dev/null", O_RDONLY, 0));
	RZ(posix_spawn(&pid, "/bin/cat", &fa, NULL, args, NULL));
	RZ(posix_spawn_file_actions_destroy(&fa));

	RL(waitpid(pid, &status, 0));
	ATF_REQUIRE_MSG((WIFEXITED(status) &&
		WEXITSTATUS(status) == EXIT_SUCCESS),
	    "status=0x%x", status);
}

ATF_TC(t_spawn_open_nonexistent);
ATF_TC_HEAD(t_spawn_open_nonexistent, tc)
{
	atf_tc_set_md_var(tc, "descr",
	    "posix_spawn fails when a file to open does not exist");
	atf_tc_set_md_var(tc, "require.progs", "/bin/cat");
}
ATF_TC_BODY(t_spawn_open_nonexistent, tc)
{
	int err, status;
	pid_t pid;
	char * const args[2] = { __UNCONST("cat"), NULL };
	posix_spawn_file_actions_t fa;

	RZ(posix_spawn_file_actions_init(&fa));
	RZ(posix_spawn_file_actions_addopen(&fa, STDIN_FILENO,
		"./non/ex/ist/ent", O_RDONLY, 0));
	err = posix_spawn(&pid, "/bin/cat", &fa, NULL, args, NULL);
	if (err == 0) {
		/*
		 * The child has been created - it should fail and
		 * return exit code 127
		 */
		waitpid(pid, &status, 0);
		ATF_REQUIRE(WIFEXITED(status) && WEXITSTATUS(status) == 127);
	} else {
		/*
		 * The error has been noticed early enough, no child has
		 * been run
		 */
		ATF_REQUIRE_MSG(err == ENOENT, "err=%d (%s)",
		    err, strerror(err));
	}
	RZ(posix_spawn_file_actions_destroy(&fa));
}

ATF_TC(t_spawn_open_nonexistent_diag);
ATF_TC_HEAD(t_spawn_open_nonexistent_diag, tc)
{
	atf_tc_set_md_var(tc, "descr",
	    "posix_spawn fails when a file to open does not exist "
	    "and delivers proper diagnostic");
	atf_tc_set_md_var(tc, "require.progs", "/bin/cat");
}
ATF_TC_BODY(t_spawn_open_nonexistent_diag, tc)
{
	int err;
	pid_t pid;
	char * const args[2] = { __UNCONST("cat"), NULL };
	posix_spawnattr_t attr;
	posix_spawn_file_actions_t fa;

	RZ(posix_spawnattr_init(&attr));
	/*
	 * POSIX_SPAWN_RETURNERROR is a NetBSD specific flag that
	 * will cause a "proper" return value from posix_spawn(2)
	 * instead of a (potential) success there and a 127 exit
	 * status from the child process (c.f. the non-diag variant
	 * of this test).
	 */
	RZ(posix_spawnattr_setflags(&attr, POSIX_SPAWN_RETURNERROR));
	RZ(posix_spawn_file_actions_init(&fa));
	RZ(posix_spawn_file_actions_addopen(&fa, STDIN_FILENO,
		"./non/ex/ist/ent", O_RDONLY, 0));
	err = posix_spawn(&pid, "/bin/cat", &fa, &attr, args, NULL);
	ATF_REQUIRE_MSG(err == ENOENT, "err=%d (%s)", err, strerror(err));
	RZ(posix_spawn_file_actions_destroy(&fa));
	RZ(posix_spawnattr_destroy(&attr));
}

ATF_TC(t_spawn_fileactions);
ATF_TC_HEAD(t_spawn_fileactions, tc)
{
	atf_tc_set_md_var(tc, "descr",
	    "Tests various complex fileactions");
}
ATF_TC_BODY(t_spawn_fileactions, tc)
{
	int fd1, fd2, fd3, status;
	pid_t pid;
	char * const args[2] = { __UNCONST("h_fileactions"), NULL };
	char helper[FILENAME_MAX];
	posix_spawn_file_actions_t fa;

	RZ(posix_spawn_file_actions_init(&fa));

	RL(closefrom(fileno(stderr) + 1));

	RL(fd1 = open("/dev/null", O_RDONLY));
	ATF_REQUIRE(fd1 == 3);

	RL(fd2 = open("/dev/null", O_WRONLY, O_CLOEXEC));
	ATF_REQUIRE(fd2 == 4);

	RL(fd3 = open("/dev/null", O_WRONLY));
	ATF_REQUIRE(fd3 == 5);

	RZ(posix_spawn_file_actions_addclose(&fa, fd1));
	RZ(posix_spawn_file_actions_addopen(&fa, 6, "/dev/null", O_RDWR, 0));
	RZ(posix_spawn_file_actions_adddup2(&fa, 1, 7));

	snprintf(helper, sizeof helper, "%s/h_fileactions",
	    atf_tc_get_config_var(tc, "srcdir"));
	RZ(posix_spawn(&pid, helper, &fa, NULL, args, NULL));
	RZ(posix_spawn_file_actions_destroy(&fa));

	RL(waitpid(pid, &status, 0));
	ATF_REQUIRE_MSG((WIFEXITED(status) &&
		WEXITSTATUS(status) == EXIT_SUCCESS),
	    "status=0x%x", status);
}

ATF_TC(t_spawn_close_already_closed);
ATF_TC_HEAD(t_spawn_close_already_closed, tc)
{
	atf_tc_set_md_var(tc, "descr",
	    "file actions closing closed descriptors are allowed (PR 59523)");
	atf_tc_set_md_var(tc, "require.progs", "/bin/ls");
}

ATF_TC_BODY(t_spawn_close_already_closed, tc)
{
	int status, fd;
	pid_t pid;
	char * const args[2] = { __UNCONST("ls"), NULL };
	posix_spawn_file_actions_t fa;

	/* get a free file descriptor number */
	fd = open("/dev/null", O_RDONLY);
	ATF_REQUIRE(fd >= 0);
	close(fd);

	RZ(posix_spawn_file_actions_init(&fa));
	// known closed fd
	RZ(posix_spawn_file_actions_addclose(&fa, fd));
	// a random fd we know nothing about (cross fingers!)
	RZ(posix_spawn_file_actions_addclose(&fa, fd+1));
	// high fd probably not ever been allocated, likely to trigger
	// a fd_getfile() failure in the kernel, which is another
	// path that originally caused the fallout in PR 59523
	RZ(posix_spawn_file_actions_addclose(&fa, 560));
	// redirect output to /dev/null to not garble atf test results
	RZ(posix_spawn_file_actions_addopen(&fa, STDOUT_FILENO, "/dev/null",
	    O_WRONLY, 0));
	RZ(posix_spawn(&pid, "/bin/ls", &fa, NULL, args, NULL));
	RZ(posix_spawn_file_actions_destroy(&fa));

	/* ok, wait for the child to finish */
	RL(waitpid(pid, &status, 0));
	ATF_REQUIRE_MSG((WIFEXITED(status) &&
		WEXITSTATUS(status) == EXIT_SUCCESS),
	    "status=0x%x", status);
}

ATF_TC(t_spawn_close_already_closed_wait);
ATF_TC_HEAD(t_spawn_close_already_closed_wait, tc)
{
	atf_tc_set_md_var(tc, "descr",
	    "file actions closing closed descriptors are allowed, "
	    "with parent process waiting (PR 59523)");
	atf_tc_set_md_var(tc, "require.progs", "/bin/ls");
}

ATF_TC_BODY(t_spawn_close_already_closed_wait, tc)
{
	int status, fd;
	pid_t pid;
	char * const args[2] = { __UNCONST("ls"), NULL };
	posix_spawn_file_actions_t fa;
	posix_spawnattr_t attr;

	/* get a free file descriptor number */
	fd = open("/dev/null", O_RDONLY);
	ATF_REQUIRE(fd >= 0);
	close(fd);
	RZ(posix_spawn_file_actions_init(&fa));
	// known closed fd
	RZ(posix_spawn_file_actions_addclose(&fa, fd));
	// a random fd we know nothing about (cross fingers!)
	RZ(posix_spawn_file_actions_addclose(&fa, fd+1));
	// high fd probably not ever been allocated, likely to trigger
	// a fd_getfile() failure in the kernel, which is another
	// path that originally caused the fallout in PR 59523
	RZ(posix_spawn_file_actions_addclose(&fa, 560));
	// redirect output to /dev/null to not garble atf test results
	RZ(posix_spawn_file_actions_addopen(&fa, STDOUT_FILENO, "/dev/null",
	    O_WRONLY, 0));

	RZ(posix_spawnattr_init(&attr));
	RZ(posix_spawnattr_setflags(&attr, POSIX_SPAWN_SETPGROUP));

	RZ(posix_spawn(&pid, "/bin/ls", &fa, &attr, args, NULL));
	RZ(posix_spawn_file_actions_destroy(&fa));

	/* ok, wait for the child to finish */
	RL(waitpid(pid, &status, 0));
	ATF_REQUIRE_MSG((WIFEXITED(status) &&
		WEXITSTATUS(status) == EXIT_SUCCESS),
	    "status=0x%x", status);
}

ATF_TC(t_spawn_empty_fileactions);
ATF_TC_HEAD(t_spawn_empty_fileactions, tc)
{
	atf_tc_set_md_var(tc, "descr",
	    "posix_spawn with empty fileactions (PR kern/46038)");
	atf_tc_set_md_var(tc, "require.progs", "/bin/cat");
}
ATF_TC_BODY(t_spawn_empty_fileactions, tc)
{
	int status;
	pid_t pid;
	char * const args[2] = { __UNCONST("cat"), NULL };
	posix_spawn_file_actions_t fa;
	size_t insize, outsize;

	/*
	 * try a "cat < testfile > checkfile", but set up stdin/stdout
	 * already in the parent and pass empty file actions to the child.
	 */
	make_testfile(TESTFILE);

	REQUIRE_LIBC(freopen(TESTFILE, "r", stdin), NULL);
	REQUIRE_LIBC(freopen(CHECKFILE, "w", stdout), NULL);

	RZ(posix_spawn_file_actions_init(&fa));
	RZ(posix_spawn(&pid, "/bin/cat", &fa, NULL, args, NULL));
	RZ(posix_spawn_file_actions_destroy(&fa));

	/* ok, wait for the child to finish */
	RL(waitpid(pid, &status, 0));
	ATF_REQUIRE_MSG((WIFEXITED(status) &&
		WEXITSTATUS(status) == EXIT_SUCCESS),
	    "status=0x%x", status);

	/* now check that input and output have the same size */
	insize = filesize(TESTFILE);
	outsize = filesize(CHECKFILE);
	ATF_CHECK_MSG(insize == strlen(TESTCONTENT),
	    "insize=%zu strlen(TESTCONTENT)=%zu", insize, strlen(TESTCONTENT));
	ATF_CHECK_MSG(insize == outsize,
	    "insize=%zu outsize=%zu", insize, outsize);
}

ATF_TP_ADD_TCS(tp)
{

	ATF_TP_ADD_TC(tp, t_spawn_fileactions);
	ATF_TP_ADD_TC(tp, t_spawn_open_nonexistent);
	ATF_TP_ADD_TC(tp, t_spawn_open_nonexistent_diag);
	ATF_TP_ADD_TC(tp, t_spawn_reopen);
	ATF_TP_ADD_TC(tp, t_spawn_openmode);
	ATF_TP_ADD_TC(tp, t_spawn_empty_fileactions);
	ATF_TP_ADD_TC(tp, t_spawn_close_already_closed);
	ATF_TP_ADD_TC(tp, t_spawn_close_already_closed_wait);

	return atf_no_error();
}