/*
 * 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
 */

/*
 * Verify that FIFOs now track tv_nsec in addition to tv_sec. This is important
 * for both named pipes in the file system created with mknod(2) and anonymous
 * pipes created with pipe(2). As part of this, we go through a series of
 * operations on a pipe:
 *
 * 1) Creating it
 * 2) Writing and reading from it to verify the mtime / atime are increasing.
 * 3) Explicitly setting the time on it.
 *
 * At each point, these should advance and we should be bracketed by calls to
 * getting the real time clock.
 */

#include <err.h>
#include <unistd.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <sys/debug.h>
#include <stdlib.h>
#include <stdbool.h>
#include <inttypes.h>
#include <fcntl.h>

typedef enum {
        CHK_ATIME_GT     = 1 << 0,
        CHK_MTIME_GT     = 1 << 1,
        CHK_CTIME_GT     = 1 << 2,
        CHK_ATIME_LT     = 1 << 3,
        CHK_MTIME_LT     = 1 << 4,
        CHK_CTIME_LT     = 1 << 5
} check_time_t;

#define CHK_ALL_GT      (CHK_ATIME_GT | CHK_MTIME_GT | CHK_CTIME_GT)
#define CHK_ALL_LT      (CHK_ATIME_LT | CHK_MTIME_LT | CHK_CTIME_LT)

static struct timespec now;
static const char *curtype;

static void
update_time(void)
{
        VERIFY0(clock_gettime(CLOCK_REALTIME, &now));
}

static bool
time_gt(const struct timespec *check, const struct timespec *base)
{
        if (check->tv_sec > base->tv_sec) {
                return (true);
        }

        return (check->tv_sec == base->tv_sec &&
            check->tv_nsec > base->tv_nsec);
}

static bool
check_times(const struct stat *st, check_time_t chk, const char *side,
    const char *desc)
{
        bool ret = true;

        if (((chk & CHK_ATIME_GT) != 0) && !time_gt(&st->st_atim, &now)) {
                warnx("TEST FAILED: %s %s side %s atime is in the past!",
                    curtype, side, desc);
                ret = false;
        }

        if (((chk & CHK_MTIME_GT) != 0) && !time_gt(&st->st_mtim, &now)) {
                warnx("TEST FAILED: %s %s side %s mtime is in the past!",
                    curtype, side, desc);
                ret = false;
        }

        if (((chk & CHK_CTIME_GT) != 0) && !time_gt(&st->st_ctim, &now)) {
                warnx("TEST FAILED: %s %s side %s ctime is in the past!",
                    curtype, side, desc);
                ret = false;
        }

        if (((chk & CHK_ATIME_LT) != 0) && !time_gt(&now, &st->st_atim)) {
                warnx("TEST FAILED: %s %s side %s atime erroneously advanced!",
                    curtype, side, desc);
                ret = false;
        }

        if (((chk & CHK_MTIME_LT) != 0) && !time_gt(&now, &st->st_mtim)) {
                warnx("TEST FAILED: %s %s side %s mtime erroneously advanced!",
                    curtype, side, desc);
                ret = false;
        }

        if (((chk & CHK_CTIME_LT) != 0) && !time_gt(&now, &st->st_ctim)) {
                warnx("TEST FAILED: %s %s side %s ctime erroneously advanced!",
                    curtype, side, desc);
                ret = false;
        }


        return (ret);
}

static bool
check_fifos(int wfd, int rfd)
{
        bool ret = true;
        struct stat st;
        const uint32_t val = 0x7777;
        uint32_t data;
        struct timespec update[2];

        VERIFY0(fstat(wfd, &st));
        if (!check_times(&st, CHK_ALL_GT, "write", "creation")) {
                ret = false;
        }

        VERIFY0(fstat(rfd, &st));
        if (!check_times(&st, CHK_ALL_GT, "read", "creation")) {
                ret = false;
        }

        /*
         * Now that we have made progress, write to the write side and confirm
         * that the mtime / ctime have advanced. The read side should also have
         * had the mtime / ctime advance.
         */
        update_time();
        if (write(wfd, &val, sizeof (val)) != sizeof (val)) {
                errx(EXIT_FAILURE, "failed to write value to %s write side",
                    curtype);
        }

        VERIFY0(fstat(wfd, &st));
        if (!check_times(&st, CHK_CTIME_GT | CHK_MTIME_GT | CHK_ATIME_LT,
            "write", "post-write")) {
                ret = false;
        }

        VERIFY0(fstat(rfd, &st));
        if (!check_times(&st, CHK_CTIME_GT | CHK_MTIME_GT | CHK_ATIME_LT,
            "read", "post-write")) {
                ret = false;
        }

        update_time();
        if (read(rfd, &data, sizeof (data)) != sizeof (data)) {
                errx(EXIT_FAILURE, "failed to read data from %s read side",
                    curtype);
        }

        VERIFY0(fstat(rfd, &st));
        if (!check_times(&st, CHK_CTIME_LT | CHK_MTIME_LT | CHK_ATIME_GT,
            "read", "post-read")) {
                ret = false;
        }

        VERIFY0(fstat(wfd, &st));
        if (!check_times(&st, CHK_CTIME_LT | CHK_MTIME_LT | CHK_ATIME_GT,
            "write", "post-read")) {
                ret = false;
        }

        update_time();
        update[0] = now;
        update[1] = now;
        VERIFY0(futimens(wfd, update));

        update_time();
        VERIFY0(fstat(wfd, &st));
        if (!check_times(&st, CHK_ALL_LT, "write", "post-futimens")) {
                ret = false;
        }

        VERIFY0(fstat(rfd, &st));
        if (!check_times(&st, CHK_ALL_LT, "read", "post-futimens")) {
                ret = false;
        }

        return (ret);
}

int
main(void)
{
        int ret = EXIT_SUCCESS;
        int pipes[2];
        char path[1024];

        update_time();
        if (pipe(pipes) != 0) {
                err(EXIT_FAILURE, "failed to create pipes");
        }

        curtype = "pipe(2)";
        if (!check_fifos(pipes[0], pipes[1])) {
                ret = EXIT_FAILURE;
        }

        VERIFY0(close(pipes[0]));
        VERIFY0(close(pipes[1]));

        (void) snprintf(path, sizeof (path), "/tmp/fifo-tvnsec.%" _PRIdID
            ".fifo", getpid());
        if (mkfifo(path, 0666) != 0) {
                err(EXIT_FAILURE, "failed to create fifo");
        }

        /*
         * We have to open the read side before the write side and must make
         * sure that we use a non-blocking open because this is all coming from
         * the same process.
         */
        pipes[1] = open(path, O_RDONLY | O_NONBLOCK);
        if (pipes[1] < 0) {
                err(EXIT_FAILURE, "failed to open %s read-only", path);
        }

        pipes[0] = open(path, O_WRONLY | O_NONBLOCK);
        if (pipes[0] < 0) {
                err(EXIT_FAILURE, "failed to open %s write-only", path);
        }

        curtype = "mkfifo(3C)";
        if (!check_fifos(pipes[0], pipes[1])) {
                ret = EXIT_FAILURE;
        }
        (void) unlink(path);

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

        return (ret);
}