/*
 * 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 provides a basic wrapper for tests around the syncfs(3C) operation. As
 * it's difficult to inject I/O failures, we specifically test the following:
 *
 *  - Verify that an invalid fd will result in EBADF
 *  - Use file systems that we know will never support syncfs() and get ENOSYS.
 *    For this we use bootfs, objfs, sockets, and related.
 *  - Attempt to find something that we know will support syncfs() and try to
 *    use it. This last one is the trickiest, we rely on the fact that we know
 *    /var/run will be a tmpfs, but allow additional paths to be specified on
 *    the command line to try.
 */

#include <stdlib.h>
#include <err.h>
#include <unistd.h>
#include <stdbool.h>
#include <errno.h>
#include <string.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <sys/socket.h>
#include <sys/sysmacros.h>
#include <sys/debug.h>
#include <limits.h>
#include <port.h>

typedef struct syncfs_enosys {
	int (*se_open)(const struct syncfs_enosys *);
	const char *se_path;
} syncfs_enosys_t;

static int
syncfs_open_file(const syncfs_enosys_t *test)
{
	int fd = open(test->se_path, O_RDONLY);
	if (fd < 0) {
		err(EXIT_FAILURE, "TEST FAILED: failed to open file %s",
		    test->se_path);
	}

	return (fd);
}

static int
syncfs_open_socket(const syncfs_enosys_t *test)
{
	struct sockaddr_in in;
	int fd = socket(PF_INET, SOCK_STREAM, 0);
	if (fd < 0) {
		err(EXIT_FAILURE, "TEST FAILED: failed to create basic "
		    "socket");
	}

	(void) memset(&in, 0, sizeof (in));
	if (bind(fd, (struct sockaddr *)&in, sizeof (in)) != 0) {
		err(EXIT_FAILURE, "TEST FAILED: failed to bind socket");
	}

	return (fd);
}

static int
syncfs_open_uds(const syncfs_enosys_t *test)
{
	int fd = socket(PF_UNIX, SOCK_STREAM, 0);
	if (fd < 0) {
		err(EXIT_FAILURE, "TEST FAILED: failed to create UDS");
	}

	return (fd);
}

static int
syncfs_open_pipe(const syncfs_enosys_t *test)
{
	int fds[2];

	if (pipe(fds) != 0) {
		err(EXIT_FAILURE, "TEST FAILED: failed to create pipe");
	}

	VERIFY0(close(fds[1]));
	return (fds[0]);
}

static int
syncfs_open_port(const syncfs_enosys_t *test)
{
	int fd = port_create();
	if (fd < 0) {
		err(EXIT_FAILURE, "TEST FAILED: failed to create event port");
	}

	return (fd);
}

static const syncfs_enosys_t syncfs_enosys[] = {
	{ syncfs_open_file, "/system/boot" },
	{ syncfs_open_file, "/system/object" },
	{ syncfs_open_file, "/proc/self/psinfo" },
	{ syncfs_open_file, "/dev/tcp" },
	{ syncfs_open_file, "/dev/null" },
	{ syncfs_open_file, "/dev/net" },
	{ syncfs_open_file, "/etc/dfs/sharetab" },
	{ syncfs_open_socket, "localhost socket" },
	{ syncfs_open_uds, "UDS socket" },
	{ syncfs_open_pipe, "pipe" },
	{ syncfs_open_file, "/var/run/name_service_door" },
	{ syncfs_open_port, "event port" },
};

static const int syncfs_badfs[] = { -1, STDERR_FILENO + 1, INT_MAX - 1,
    0x7777, -0x7777 };

static bool
syncfs_fail(const char *desc, int fd, int exp_err)
{
	int ret = syncfs(fd);
	if (ret != -1) {
		warnx("TEST FAILED: %s: syncfs succeeded, but expected "
		    "failure", desc);
		return (false);
	}

	if (errno != exp_err) {
		warnx("TEST FAILED: %s: syncfs returned %s, expected %s",
		    desc, strerrorname_np(ret), strerrorname_np(exp_err));
		return (false);
	}

	(void) printf("TEST PASSED: %s\n", desc);
	return (true);
}

static bool
syncfs_pass(const char *path)
{
	bool ret = true;
	int fd = open(path, O_RDONLY);
	if (fd < 0) {
		err(EXIT_FAILURE, "failed to open %s", path);
	}

	if (syncfs(fd) != 0) {
		warnx("TEST FAILED: syncfs failed with %s on %s",
		    strerrorname_np(errno), path);
		ret = false;
	} else {
		(void) printf("TEST PASSED: syncfs returned 0 on %s\n", path);
	}

	VERIFY0(close(fd));
	return (ret);
}

int
main(int argc, char *argv[])
{
	int ret = EXIT_SUCCESS;

	closefrom(STDERR_FILENO + 1);

	for (size_t i = 0; i < ARRAY_SIZE(syncfs_badfs); i++) {
		char msg[PATH_MAX];
		(void) snprintf(msg, sizeof (msg), "Invalid file descriptor "
		    "returns EBADF (%zu)", i);
		if (!syncfs_fail(msg, syncfs_badfs[i], EBADF)) {
			ret = EXIT_FAILURE;
		}
	}

	for (size_t i = 0; i < ARRAY_SIZE(syncfs_enosys); i++) {
		char msg[PATH_MAX];
		int fd = syncfs_enosys[i].se_open(&syncfs_enosys[i]);
		(void) snprintf(msg, sizeof (msg), "Unsupported fs returns "
		    "ENOSYS: %s", syncfs_enosys[i].se_path);
		if (!syncfs_fail(msg, fd, ENOSYS)) {
			ret = EXIT_FAILURE;
		}

		VERIFY0(close(fd));
	}

	if (!syncfs_pass("/var/run")) {
		ret = EXIT_FAILURE;
	}

	for (int i = 1; i < argc; i++) {
		if (!syncfs_pass(argv[i])) {
			ret = EXIT_FAILURE;
		}
	}

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

	return (ret);
}