/*
 * 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 2025 Hans Rosenfeld
 */

#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <stdio.h>
#include <stdlib.h>
#include <strings.h>
#include <unistd.h>
#include <errno.h>
#include <err.h>
#include <limits.h>

static int
fdclose_test(char *ident, FILE *fp, int exp_ret, int exp_fd, int exp_errno)
{
	int fd = INT_MIN;
	int ret = 0;

	errno = 0;
	ret = fdclose(fp, &fd);
	if (ret != exp_ret)
		err(EXIT_FAILURE, "%s unexpected result %d (expected %d)",
		    ident, ret, exp_ret);

	if (fd != exp_fd)
		err(EXIT_FAILURE, "%s unexpected fd %d (expected %d)",
		    ident, fd, exp_fd);

	if (errno != exp_errno)
		errx(EXIT_FAILURE, "%s unexpected errno %s (expected %s)",
		    ident, strerrorname_np(errno), strerrorname_np(exp_errno));

	return (fd);
}

int
main(int argc, char **argv)
{
	int ret = 0;
	char buf[33];
	int fd;
	FILE *devnull;
	FILE *mem;
	struct stat stat;
	ino_t ino;

	/*
	 * Use /dev/null for our first tests. Open it as a file, then fstat it
	 * and get the underlying inode.
	 */
	fd = open("/dev/null", O_WRONLY);
	if (fd == -1)
		err(EXIT_FAILURE, "open(/dev/null)");

	if (fstat(fd, &stat) == -1)
		err(EXIT_FAILURE, "fstat(/dev/null) after open()");

	ino = stat.st_ino;

	/*
	 * Now, fdopen() this to get a FILE to work with. Make sure the FILE
	 * is backed by the right fd.
	 */
	devnull = fdopen(fd, "w");
	if (devnull == NULL)
		err(EXIT_FAILURE, "fdopen(/dev/null)");

	if (fileno(devnull) != fd)
		err(EXIT_FAILURE, "fileno(/dev/null): unexpected fd %d "
		    "(expected %d)", fileno(devnull), fd);

	/*
	 * Verify fdclose() works on a FILE which is already open.
	 */
	fd = fdclose_test("fdclose(/dev/null)", devnull, 0, fd, 0);

	/*
	 * Verify that the underlying file descriptor hasn't changed.
	 */
	if (fileno(devnull) != fd)
		err(EXIT_FAILURE, "fileno(/dev/null): unexpected fd %d "
		    "(expected %d)", fileno(devnull), fd);

	/*
	 * Verify that we can still fstat() the file descriptor, and that the
	 * inode hasn't changed.
	 */
	if (fstat(fd, &stat) == -1)
		err(EXIT_FAILURE, "fstat(/dev/null) after fdclose()");

	if (ino != stat.st_ino)
		errx(EXIT_FAILURE, "/dev/null inode changed after fdclose(): "
		    "%ld (expected %ld)", stat.st_ino, ino);

	/*
	 * Calling fdclose() again on a closed FILE should return EOF without
	 * setting errno. It should also return the file descriptor. This is
	 * decidedly not part of the interface specification, it's only an
	 * implementation detail of fdclose() and fclose_helper().
	 */
	fd = fdclose_test("2nd fdclose(/dev/null)", devnull, EOF, fd, 0);

	/*
	 * Verify the FILE is indeed closed by writing to it, which should
	 * return EOF. This is an illumos-specific implementation detail,
	 * what fputs() or any other stdio function would do on a closed FILE
	 * is undefined behaviour.
	 */
	ret = fputs("Hello World\n", devnull);
	if (ret != EOF)
		errx(1, "unexpected result from fputs(\"Hello World\\n\") "
		    "on closed FILE, ret = %d", ret);

	/*
	 * Verify that the underlying file descriptor is still open for writing,
	 * so this should not fail.
	 */
	ret = write(fd, "Goodbye Cruel World\n", 20);
	if (ret < 0)
		err(1, "write(/dev/null) failed");

	/*
	 * Close /dev/null, we're done with it. Try to fstat() it again, which
	 * now should fail.
	 */
	(void) close(fd);

	ret = fstat(fd, &stat);
	if (ret != -1)
		errx(EXIT_FAILURE, "unexpected result from fstat(/dev/null) "
		    "after close(), ret = %d", ret);

	/*
	 * Verify fdclose() works as expected on a memory stream: The stream is
	 * closed, the fd returned is -1, and errno is ENOTSUP.
	 */
	bzero(buf, sizeof (buf));
	mem = fmemopen(buf, sizeof (buf), "w");
	if (mem == NULL)
		err(1, "fmemopen() failed");

	ret = fputs("Hello World\n", mem);
	if (ret == EOF)
		err(1, "fputs(mem) failed");

	fd = fdclose_test("fdclose(mem)", mem, EOF, -1, ENOTSUP);

	ret = fputs("Goodbye Cruel World\n", mem);
	if (ret != EOF)
		errx(1, "fputs(..., mem) on closed FILE, ret = %d "
		    "(expected EOF)", ret);

	/*
	 * Verify that only the string successfully written into the FILE ended
	 * up in the buffer.
	 */
	if (strcmp(buf, "Hello World\n") != 0)
		errx(1, "mem contents unexpected: %s\n"
		    "expected: %s", buf, "Hello World\n");

	printf("tests passed\n");
	return (0);
}