/*      $NetBSD: h_quota2_tests.c,v 1.6 2024/09/08 09:36:52 rillig Exp $        */

/*
 * rump server for advanced quota tests
 * this one includes functions to run against the filesystem before
 * starting to handle rump requests from clients.
 */

#include "../common/h_fsmacros.h"

#include <err.h>
#include <semaphore.h>
#include <sys/types.h>
#include <sys/mount.h>

#include <stdlib.h>
#include <unistd.h>

#include <ufs/ufs/ufsmount.h>
#include <dev/fssvar.h>

#include <rump/rump.h>
#include <rump/rump_syscalls.h>

#include "h_macros.h"

int background = 0;

#define TEST_NONROOT_ID 1

static int
quota_test0(const char *testopts)
{
        static char buf[512];
        int fd;
        int error;
        unsigned int i;
        int chowner = 1;
        for (i =0; testopts && i < strlen(testopts); i++) {
                switch(testopts[i]) {
                case 'C':
                        chowner = 0;
                        break;
                default:
                        errx(1, "test4: unknown option %c", testopts[i]);
                }
        }
        if (chowner)
                rump_sys_chown(".", TEST_NONROOT_ID, TEST_NONROOT_ID);
        rump_sys_chmod(".", 0777);
        if (rump_sys_setegid(TEST_NONROOT_ID) != 0) {
                error = errno;
                warn("rump_sys_setegid");
                return error;
        }
        if (rump_sys_seteuid(TEST_NONROOT_ID) != 0) {
                error = errno;
                warn("rump_sys_seteuid");
                return error;
        }
        fd = rump_sys_open("test_fillup", O_CREAT | O_RDWR, 0644);
        if (fd < 0) {
                error = errno;
                warn("rump_sys_open");
        } else {
                while (rump_sys_write(fd, buf, sizeof(buf)) == sizeof(buf))
                        error = 0;
                error = errno;
        }
        rump_sys_close(fd);
        rump_sys_seteuid(0);
        rump_sys_setegid(0);
        return error;
}

static int
quota_test1(const char *testopts)
{
        static char buf[512];
        int fd;
        int error;
        rump_sys_chown(".", TEST_NONROOT_ID, TEST_NONROOT_ID);
        rump_sys_chmod(".", 0777);
        if (rump_sys_setegid(TEST_NONROOT_ID) != 0) {
                error = errno;
                warn("rump_sys_setegid");
                return error;
        }
        if (rump_sys_seteuid(TEST_NONROOT_ID) != 0) {
                error = errno;
                warn("rump_sys_seteuid");
                return error;
        }
        fd = rump_sys_open("test_fillup", O_CREAT | O_RDWR, 0644);
        if (fd < 0) {
                error = errno;
                warn("rump_sys_open");
        } else {
                /*
                 * write up to the soft limit, wait a bit, and try to
                 * keep on writing
                 */
                int i;

                /* write 2k: with the directory this makes 2.5K */
                for (i = 0; i < 4; i++) {
                        error = rump_sys_write(fd, buf, sizeof(buf));
                        if (error != sizeof(buf))
                                err(1, "write failed early");
                }
                sleep(2);
                /* now try to write an extra .5k */
                if (rump_sys_write(fd, buf, sizeof(buf)) != sizeof(buf))
                        error = errno;
                else
                        error = 0;
        }
        rump_sys_close(fd);
        rump_sys_seteuid(0);
        rump_sys_setegid(0);
        return error;
}

static int
quota_test2(const char *testopts)
{
        static char buf[512];
        int fd;
        int error;
        int i;
        rump_sys_chown(".", TEST_NONROOT_ID, TEST_NONROOT_ID);
        rump_sys_chmod(".", 0777);
        if (rump_sys_setegid(TEST_NONROOT_ID) != 0) {
                error = errno;
                warn("rump_sys_setegid");
                return error;
        }
        if (rump_sys_seteuid(TEST_NONROOT_ID) != 0) {
                error = errno;
                warn("rump_sys_seteuid");
                return error;
        }

        for (i = 0; ; i++) {
                sprintf(buf, "file%d", i);
                fd = rump_sys_open(buf, O_CREAT | O_RDWR, 0644);
                if (fd < 0)
                        break;
                sprintf(buf, "test file no %d", i);
                rump_sys_write(fd, buf, strlen(buf));
                rump_sys_close(fd);
        }
        error = errno;
        
        rump_sys_close(fd);
        rump_sys_seteuid(0);
        rump_sys_setegid(0);
        return error;
}

static int
quota_test3(const char *testopts)
{
        static char buf[512];
        int fd;
        int error;
        int i;
        rump_sys_chown(".", TEST_NONROOT_ID, TEST_NONROOT_ID);
        rump_sys_chmod(".", 0777);
        if (rump_sys_setegid(TEST_NONROOT_ID) != 0) {
                error = errno;
                warn("rump_sys_setegid");
                return error;
        }
        if (rump_sys_seteuid(TEST_NONROOT_ID) != 0) {
                error = errno;
                warn("rump_sys_seteuid");
                return error;
        }

        /*
         * create files one past the soft limit: one less as we already own the
         * root directory
         */
        for (i = 0; i < 4; i++) {
                sprintf(buf, "file%d", i);
                fd = rump_sys_open(buf, O_EXCL| O_CREAT | O_RDWR, 0644);
                if (fd < 0)
                        err(1, "file create failed early");
                sprintf(buf, "test file no %d", i);
                rump_sys_write(fd, buf, strlen(buf));
                rump_sys_close(fd);
        }
        /* now create an extra file after grace time: this should fail */
        sleep(2);
        sprintf(buf, "file%d", i);
        fd = rump_sys_open(buf, O_EXCL| O_CREAT | O_RDWR, 0644);
        if (fd < 0)
                error = errno;
        else
                error = 0;
        
        rump_sys_close(fd);
        rump_sys_seteuid(0);
        rump_sys_setegid(0);
        return error;
}

static int
quota_test4(const char *testopts)
{
        static char buf[512];
        int fd, fssfd;
        struct fss_set fss;
        unsigned int i;
        int unl=0;
        int unconf=0;

        /*
         * take an internal snapshot of the filesystem, and create a new
         * file with some data
         */
        rump_sys_chown(".", 0, 0);
        rump_sys_chmod(".", 0777);

        for (i =0; testopts && i < strlen(testopts); i++) {
                switch(testopts[i]) {
                case 'L':
                        unl++;
                        break;
                case 'C':
                        unconf++;
                        break;
                default:
                        errx(1, "test4: unknown option %c", testopts[i]);
                }
        }

        /* first create the snapshot */

         fd = rump_sys_open(FSTEST_MNTNAME "/le_snap", O_CREAT | O_RDWR, 0777);
         if (fd == -1)
                err(1, "create " FSTEST_MNTNAME "/le_snap");
         rump_sys_close(fd);
         fssfd = rump_sys_open("/dev/rfss0", O_RDWR);
         if (fssfd == -1)
                err(1, "cannot open fss");
        memset(&fss, 0, sizeof(fss));
        fss.fss_mount = __UNCONST("/mnt");
        fss.fss_bstore = __UNCONST(FSTEST_MNTNAME "/le_snap");
        fss.fss_csize = 0;
        if (rump_sys_ioctl(fssfd, FSSIOCSET, &fss) == -1)
                err(1, "create snapshot");
        if (unl) {
                if (rump_sys_unlink(FSTEST_MNTNAME "/le_snap") == -1)
                        err(1, "unlink snapshot");
        }

        /* now create some extra files */

        for (i = 0; i < 4; i++) {
                sprintf(buf, "file%d", i);
                fd = rump_sys_open(buf, O_EXCL| O_CREAT | O_RDWR, 0644);
                if (fd < 0)
                        err(1, "create %s", buf);
                sprintf(buf, "test file no %d", i);
                rump_sys_write(fd, buf, strlen(buf));
                rump_sys_close(fd);
        }
        if (unconf)
                if (rump_sys_ioctl(fssfd, FSSIOCCLR, NULL) == -1)
                        err(1, "unconfigure snapshot");
        return 0;
}

static int
quota_test5(const char *testopts)
{
        static char buf[512];
        int fd;
        int remount = 0;
        int unlnk = 0;
        int log = 0;
        unsigned int i;

        for (i =0; testopts && i < strlen(testopts); i++) {
                switch(testopts[i]) {
                case 'L':
                        log++;
                        break;
                case 'R':
                        remount++;
                        break;
                case 'U':
                        unlnk++;
                        break;
                default:
                        errx(1, "test4: unknown option %c", testopts[i]);
                }
        }
        if (remount) {
                struct ufs_args uargs;
                uargs.fspec = __UNCONST("/diskdev");
                /* remount the fs read/write */
                if (rump_sys_mount(MOUNT_FFS, FSTEST_MNTNAME,
                    MNT_UPDATE | (log ? MNT_LOG : 0),
                    &uargs, sizeof(uargs)) == -1)
                        err(1, "mount ffs rw %s", FSTEST_MNTNAME);
        }

        if (unlnk) {
                /*
                 * open and unlink a file
                 */

                fd = rump_sys_open("unlinked_file",
                    O_EXCL| O_CREAT | O_RDWR, 0644);
                if (fd < 0)
                        err(1, "create %s", "unlinked_file");
                sprintf(buf, "test unlinked_file");
                rump_sys_write(fd, buf, strlen(buf));
                if (rump_sys_unlink("unlinked_file") == -1)
                        err(1, "unlink unlinked_file");
                if (rump_sys_fsync(fd) == -1) 
                        err(1, "fsync unlinked_file");
                rump_sys_reboot(RUMP_RB_NOSYNC, NULL);
                errx(1, "reboot failed");
                return 1;
        }
        return 0;
}

struct quota_test {
        int (*func)(const char *);
        const char *desc;
};

struct quota_test quota_tests[] = {
        { quota_test0, "write up to hard limit"},
        { quota_test1, "write beyond the soft limit after grace time"},
        { quota_test2, "create file up to hard limit"},
        { quota_test3, "create file beyond the soft limit after grace time"},
        { quota_test4, "take a snapshot and add some data"},
        { quota_test5, "open and unlink a file"},
};

static void
usage(void)
{
        unsigned int test;
        fprintf(stderr, "usage: %s [-b] [-l] test# diskimage bindurl\n",
            getprogname());
        fprintf(stderr, "available tests:\n");
        for (test = 0; test < sizeof(quota_tests) / sizeof(quota_tests[0]);
            test++)
                fprintf(stderr, "\t%d: %s\n", test, quota_tests[test].desc);
        exit(1);
}

static void
die(const char *reason, int error)
{

        warnx("%s: %s", reason, strerror(error));
        if (background)
                rump_daemonize_done(error);
        exit(1);
}

static sem_t sigsem;
static void
sigreboot(int sig)
{

        sem_post(&sigsem);
}

int 
main(int argc, char **argv)
{
        int error;
        u_long test;
        char *end;
        struct ufs_args uargs;
        const char *filename;
        const char *serverurl;
        const char *topts = NULL;
        int mntopts = 0;
        int ch;

        while ((ch = getopt(argc, argv, "blo:r")) != -1) {
                switch(ch) {
                case 'b':
                        background = 1;
                        break;
                case 'l':
                        mntopts |= MNT_LOG;
                        break;
                case 'r':
                        mntopts |= MNT_RDONLY;
                        break;
                case 'o':
                        topts = optarg;
                        break;
                default:
                        usage();
                }
        }
        argc -= optind;
        argv += optind;

        if (argc != 3)
                usage();

        filename = argv[1];
        serverurl = argv[2];

        test = strtoul(argv[0], &end, 10);
        if (*end != '\0') {
                usage();
        }
        if (test > sizeof(quota_tests) / sizeof(quota_tests[0])) {
                usage();
        }

        if (background) {
                error = rump_daemonize_begin();
                if (error)
                        errx(1, "rump daemonize: %s", strerror(error));
        }

        error = rump_init();
        if (error)
                die("rump init failed", error);

        if (rump_sys_mkdir(FSTEST_MNTNAME, 0777) == -1)
                err(1, "mount point create");
        rump_pub_etfs_register("/diskdev", filename, RUMP_ETFS_BLK);
        uargs.fspec = __UNCONST("/diskdev");
        if (rump_sys_mount(MOUNT_FFS, FSTEST_MNTNAME, mntopts,
            &uargs, sizeof(uargs)) == -1)
                die("mount ffs", errno);

        if (rump_sys_chdir(FSTEST_MNTNAME) == -1)
                err(1, "cd %s", FSTEST_MNTNAME);
        error = quota_tests[test].func(topts);
        if (error) {
                fprintf(stderr, " test %lu: %s returned %d: %s\n",
                    test, quota_tests[test].desc, error, strerror(error));
        }
        if (rump_sys_chdir("/") == -1)
                err(1, "cd /");

        error = rump_init_server(serverurl);
        if (error)
                die("rump server init failed", error);
        if (background)
                rump_daemonize_done(RUMP_DAEMONIZE_SUCCESS);

        sem_init(&sigsem, 0, 0);
        signal(SIGTERM, sigreboot);
        signal(SIGINT, sigreboot);
        sem_wait(&sigsem);

        rump_sys_reboot(0, NULL);
        /*NOTREACHED*/
        return 0;
}