/*
 * Copyright (c) 2011 Alex Hornung <alex@alexhornung.com>.
 * All rights reserved.
 *
 * 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 COPYRIGHT HOLDERS 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
 * COPYRIGHT HOLDERS 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/resource.h>
#include <sys/time.h>
#include <sys/types.h>
#include <sys/wait.h>

#include <errno.h>
#include <signal.h>
#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>
#include <string.h>
#include <unistd.h>
#include <pwd.h>

#include <err.h>

#include <libprop/proplib.h>

#include "parser.h"
#include "testcase.h"
#include "runlist.h"
#include "config.h"
#include <dfregress.h>

prop_dictionary_t
testcase_from_struct(struct testcase *testcase)
{
        int i, r;
        prop_dictionary_t dict, testcase_dict;
        prop_array_t a;
        char *s;

        testcase_dict = prop_dictionary_create();
        if (testcase_dict == NULL)
                err(1, "could not create testcase dict");
        r = prop_dictionary_set_cstring(testcase_dict, "name", testcase->name);
        if (r == 0)
                err(1, "prop_dictionary operation failed");
        r = prop_dictionary_set_cstring(testcase_dict, "type", testcase->type_str);
        if (r == 0)
                err(1, "prop_dictionary operation failed");

        r = prop_dictionary_set_int32(testcase_dict, "argc",
            (int32_t)testcase->argc);
        if (r == 0)
                err(1, "prop_dictionary operation failed");

        a = prop_array_create_with_capacity(testcase->argc+1);
        if (a == NULL)
                err(1, "prop_array_create for argv failed");

        s = strrchr(testcase->name, '/');
        r = prop_array_set_cstring(a, 0, (s == NULL) ? testcase->name : s+1);
        if (r == 0)
                err(1, "prop_array_set_cstring operation failed");

        for (i = 1; i <= testcase->argc; i++) {
                r = prop_array_set_cstring(a, i, testcase->argv[i-1]);
                if (r == 0)
                        err(1, "prop_array_set_cstring operation failed");
        }

        r = prop_dictionary_set(testcase_dict, "args", a);
        if (r == 0)
                err(1, "prop_dictionary_set \"args\" failed");

        dict = prop_dictionary_create();
        if (dict == NULL)
                err(1, "could not create dict");

        r = prop_dictionary_set_int32(dict, "timeout_in_secs",
            (int32_t)testcase->opts.timeout_in_secs);
        if (r == 0)
                err(1, "prop_dictionary operation failed");

        r = prop_dictionary_set_int32(dict, "rc",
            (int32_t)testcase->opts.rc);
        if (r == 0)
                err(1, "prop_dictionary operation failed");

        r = prop_dictionary_set_uint32(dict, "flags", testcase->opts.flags);
        if (r == 0)
                err(1, "prop_dictionary operation failed");

        if (testcase->opts.pre_cmd != NULL) {
                r = prop_dictionary_set_cstring(dict, "pre_cmd",
                    testcase->opts.pre_cmd);
                if (r == 0)
                        err(1, "prop_dictionary operation failed");
        }

        if (testcase->opts.post_cmd != NULL) {
                r = prop_dictionary_set_cstring(dict, "post_cmd",
                    testcase->opts.post_cmd);
                if (r == 0)
                        err(1, "prop_dictionary operation failed");
        }

        if (testcase->opts.interpreter != NULL) {
                r = prop_dictionary_set_cstring(dict, "interpreter",
                    testcase->opts.interpreter);
                if (r == 0)
                        err(1, "prop_dictionary operation failed");
        }

        r = prop_dictionary_set_uint32(dict, "runas_uid",
            (uint32_t)testcase->opts.runas_uid);
        if (r == 0)
                err(1, "prop_dictionary operation failed");

        r = prop_dictionary_set_cstring(dict, "make_cmd",
            (testcase->opts.make_cmd != NULL) ? testcase->opts.make_cmd : "make");
        if (r == 0)
                err(1, "prop_dictionary operation failed");

        r = prop_dictionary_set(testcase_dict, "opts", dict);
        if (r == 0)
                err(1, "prop_dictionary operation failed");

        return testcase_dict;
}

struct timeval *
testcase_get_timeout(prop_dictionary_t testcase)
{
        static struct timeval tv;
        int32_t val;
        int r;

        r = prop_dictionary_get_int32(prop_dictionary_get(testcase, "opts"),
            "timeout_in_secs", &val);
        if (r == 0)
                err(1, "prop_dictionary operation failed");

        tv.tv_usec = 0;
        tv.tv_sec = (long)val;

        return &tv;
}

int
testcase_get_type(prop_dictionary_t testcase)
{
        const char *type;
        int r;

        r = prop_dictionary_get_cstring_nocopy(testcase, "type", &type);
        if (r == 0)
                err(1, "prop_dictionary operation failed");

        if (strcmp(type, "userland") == 0)
                return TESTCASE_TYPE_USERLAND;
        else if (strcmp(type, "kernel") == 0)
                return TESTCASE_TYPE_KERNEL;
        else if (strcmp(type, "buildonly") == 0)
                return TESTCASE_TYPE_BUILDONLY;

        return 0;
}

const char *
testcase_get_type_desc(prop_dictionary_t testcase)
{
        const char *str;
        int r;

        r = prop_dictionary_get_cstring_nocopy(testcase, "type", &str);
        if (r == 0)
                err(1, "prop_dictionary operation failed");

        return str;
}

const char *
testcase_get_name(prop_dictionary_t testcase)
{
        const char *str;
        int r;

        r = prop_dictionary_get_cstring_nocopy(testcase, "name", &str);
        if (r == 0)
                err(1, "prop_dictionary operation failed");

        return str;
}

int
testcase_get_argc(prop_dictionary_t testcase)
{
        int32_t argc;
        int r;

        r = prop_dictionary_get_int32(testcase, "argc", &argc);
        if (r == 0)
                err(1, "prop_dictionary operation failed for argc");

        return argc;
}

const char **
testcase_get_args(prop_dictionary_t testcase)
{
        /* Sane limit of 63 arguments... who wants more than that? */
        static const char *argv[64];
        unsigned int i, count;
        prop_array_t a;
        int r;

        a = prop_dictionary_get(testcase, "args");
        if (a == NULL)
                err(1, "testcase_get_args NULL array");

        count = prop_array_count(a);

        for (i = 0; i < count; i++) {
                r = prop_array_get_cstring_nocopy(a, i, &argv[i]);
                if (r == 0)
                        err(1, "error building argv");
        }

        argv[i] = NULL;

        return argv;
}

uint32_t
testcase_get_flags(prop_dictionary_t testcase)
{
        uint32_t flags;
        int r;

        r = prop_dictionary_get_uint32(prop_dictionary_get(testcase, "opts"),
            "flags", &flags);
        if (r == 0)
                err(1, "prop_dictionary operation failed");

        return flags;
}

int
testcase_get_precmd_type(prop_dictionary_t testcase)
{
        uint32_t flags = testcase_get_flags(testcase);

        return (flags & (TESTCASE_INT_PRE | TESTCASE_CUSTOM_PRE));
}

int
testcase_get_rc(prop_dictionary_t testcase)
{
        int32_t rc;
        int r;

        r = prop_dictionary_get_int32(prop_dictionary_get(testcase, "opts"),
            "rc", &rc);
        if (r == 0)
                err(1, "prop_dictionary operation failed for rc");

        return rc;
}

int
testcase_get_postcmd_type(prop_dictionary_t testcase)
{
        uint32_t flags = testcase_get_flags(testcase);

        return (flags & (TESTCASE_INT_POST | TESTCASE_CUSTOM_POST));
}

int
testcase_needs_setuid(prop_dictionary_t testcase)
{
        uint32_t flags = testcase_get_flags(testcase);

        return (flags & TESTCASE_RUN_AS);
}

uid_t
testcase_get_runas_uid(prop_dictionary_t testcase)
{
        uint32_t uid = 0;
        int r;

        r = prop_dictionary_get_uint32(
            prop_dictionary_get(testcase, "opts"), "runas_uid", &uid);
        if (r == 0)
                err(1, "prop_dictionary operation failed");

        return (uid_t)uid;
}

const char *
testcase_get_custom_precmd(prop_dictionary_t testcase)
{
        const char *str;
        int r;

        r = prop_dictionary_get_cstring_nocopy(
            prop_dictionary_get(testcase, "opts"), "pre_cmd", &str);
        if (r == 0)
                err(1, "prop_dictionary operation failed");

        return str;
}

const char *
testcase_get_custom_postcmd(prop_dictionary_t testcase)
{
        const char *str;
        int r;

        r = prop_dictionary_get_cstring_nocopy(
            prop_dictionary_get(testcase, "opts"), "pre_cmd", &str);
        if (r == 0)
                err(1, "prop_dictionary operation failed");

        return str;
}

static const char *
_testcase_get_interpreter(prop_dictionary_t testcase, bool fatal)
{
        const char *str;
        int r;

        r = prop_dictionary_get_cstring_nocopy(
            prop_dictionary_get(testcase, "opts"), "interpreter", &str);
        if (r == 0) {
                if (fatal)
                        err(1, "prop_dictionary operation failed for interpreter");
                else
                        return NULL;
        }

        return str;
}

const char *
testcase_get_interpreter(prop_dictionary_t testcase)
{
        return _testcase_get_interpreter(testcase, true);
}

const char *
testcase_get_interpreter_noexit(prop_dictionary_t testcase)
{
        return _testcase_get_interpreter(testcase, false);
}

const char *
testcase_get_make_cmd(prop_dictionary_t testcase)
{
        const char *str;
        int r;

        r = prop_dictionary_get_cstring_nocopy(
            prop_dictionary_get(testcase, "opts"), "make_cmd", &str);
        if (r == 0)
                err(1, "prop_dictionary operation failed");

        return str;
}

prop_dictionary_t
testcase_get_result_dict(prop_dictionary_t testcase)
{
        prop_dictionary_t result_dict;
        int r;

        result_dict = prop_dictionary_get(testcase, "result");
        if (result_dict == NULL) {
                result_dict = prop_dictionary_create();
                if (result_dict == NULL)
                        err(1, "could not allocate new result dict");

                r = prop_dictionary_set(testcase, "result", result_dict);
                if (r == 0)
                        err(1, "prop_dictionary operation failed");
        }

        return result_dict;
}

int
testcase_set_build_buf(prop_dictionary_t testcase, const char *buf)
{
        prop_dictionary_t dict = testcase_get_result_dict(testcase);

        return !prop_dictionary_set_cstring(dict, "build_buf", buf);
}

int
testcase_set_cleanup_buf(prop_dictionary_t testcase, const char *buf)
{
        prop_dictionary_t dict = testcase_get_result_dict(testcase);

        return !prop_dictionary_set_cstring(dict, "cleanup_buf", buf);
}

int
testcase_set_sys_buf(prop_dictionary_t testcase, const char *buf)
{
        prop_dictionary_t dict = testcase_get_result_dict(testcase);

        return !prop_dictionary_set_cstring(dict, "sys_buf", buf);
}

int
testcase_set_precmd_buf(prop_dictionary_t testcase, const char *buf)
{
        prop_dictionary_t dict = testcase_get_result_dict(testcase);

        return !prop_dictionary_set_cstring(dict, "precmd_buf", buf);
}

int
testcase_set_postcmd_buf(prop_dictionary_t testcase, const char *buf)
{
        prop_dictionary_t dict = testcase_get_result_dict(testcase);

        return !prop_dictionary_set_cstring(dict, "postcmd_buf", buf);
}

int
testcase_set_stdout_buf(prop_dictionary_t testcase, const char *buf)
{
        prop_dictionary_t dict = testcase_get_result_dict(testcase);

        return !prop_dictionary_set_cstring(dict, "stdout_buf", buf);
}

int
testcase_set_stderr_buf(prop_dictionary_t testcase, const char *buf)
{
        prop_dictionary_t dict = testcase_get_result_dict(testcase);

        return !prop_dictionary_set_cstring(dict, "stderr_buf", buf);
}

int
testcase_set_result(prop_dictionary_t testcase, int result)
{
        prop_dictionary_t dict = testcase_get_result_dict(testcase);

        return !prop_dictionary_set_int32(dict, "result", result);
}

int
testcase_set_exit_value(prop_dictionary_t testcase, int exitval)
{
        prop_dictionary_t dict = testcase_get_result_dict(testcase);

        return !prop_dictionary_set_int32(dict, "exit_value", exitval);
}

int
testcase_set_signal(prop_dictionary_t testcase, int sig)
{
        prop_dictionary_t dict = testcase_get_result_dict(testcase);

        return !prop_dictionary_set_int32(dict, "signal", sig);
}

const char *
testcase_get_build_buf(prop_dictionary_t testcase)
{
        const char *str = "";

        prop_dictionary_t dict = testcase_get_result_dict(testcase);
        prop_dictionary_get_cstring_nocopy(dict, "build_buf", &str);

        return str;
}

const char *
testcase_get_cleanup_buf(prop_dictionary_t testcase)
{
        const char *str = "";

        prop_dictionary_t dict = testcase_get_result_dict(testcase);
        prop_dictionary_get_cstring_nocopy(dict, "cleanup_buf", &str);

        return str;
}

const char *
testcase_get_sys_buf(prop_dictionary_t testcase)
{
        const char *str = "";

        prop_dictionary_t dict = testcase_get_result_dict(testcase);
        prop_dictionary_get_cstring_nocopy(dict, "sys_buf", &str);

        return str;
}

const char *
testcase_get_precmd_buf(prop_dictionary_t testcase)
{
        const char *str = "";

        prop_dictionary_t dict = testcase_get_result_dict(testcase);
        prop_dictionary_get_cstring_nocopy(dict, "precmd_buf", &str);

        return str;
}

const char *
testcase_get_postcmd_buf(prop_dictionary_t testcase)
{
        const char *str = "";

        prop_dictionary_t dict = testcase_get_result_dict(testcase);
        prop_dictionary_get_cstring_nocopy(dict, "postcmd_buf", &str);

        return str;
}

const char *
testcase_get_stdout_buf(prop_dictionary_t testcase)
{
        const char *str = "";

        prop_dictionary_t dict = testcase_get_result_dict(testcase);
        prop_dictionary_get_cstring_nocopy(dict, "stdout_buf", &str);

        return str;
}

const char *
testcase_get_stderr_buf(prop_dictionary_t testcase)
{
        const char *str = "";

        prop_dictionary_t dict = testcase_get_result_dict(testcase);
        prop_dictionary_get_cstring_nocopy(dict, "stderr_buf", &str);

        return str;
}

int
testcase_get_result(prop_dictionary_t testcase)
{
        int32_t result = RESULT_NOTRUN;

        prop_dictionary_t dict = testcase_get_result_dict(testcase);
        prop_dictionary_get_int32(dict, "result", &result);

        return (int)result;
}

const char *
testcase_get_result_desc(prop_dictionary_t testcase)
{
        int result = testcase_get_result(testcase);

        switch(result) {
        case RESULT_TIMEOUT:    return "TIMEOUT";
        case RESULT_SIGNALLED:  return "SIGNALLED";
        case RESULT_NOTRUN:     return "NOT RUN";
        case RESULT_FAIL:       return "FAIL";
        case RESULT_PASS:       return "PASS";
        case RESULT_PREFAIL:    return "PREFAIL";
        case RESULT_POSTFAIL:   return "POSTFAIL";
        case RESULT_BUILDFAIL:  return "BUILDFAIL";
        default:                return "UNKNOWN";
        }
}

int
testcase_get_exit_value(prop_dictionary_t testcase)
{
        int32_t exitval;
        int r;

        prop_dictionary_t dict = testcase_get_result_dict(testcase);
        r = prop_dictionary_get_int32(dict, "exit_value", &exitval);
        if (r == 0)
                err(1, "prop_dictionary operation failed");

        return (int)exitval;
}

int
testcase_get_signal(prop_dictionary_t testcase)
{
        int32_t sig;
        int r;

        prop_dictionary_t dict = testcase_get_result_dict(testcase);
        r = prop_dictionary_get_int32(dict, "signal", &sig);
        if (r == 0)
                err(1, "prop_dictionary operation failed");

        return (int)sig;
}

int
parse_testcase_option(struct testcase_options *opts, char *option)
{
        struct passwd *pwd;
        char    *parameter, *endptr;
        long    lval;
        int     noparam = 0;

        parameter = strchr(option, '=');
        noparam = (parameter == NULL);
        if (!noparam)
        {
                *parameter = '\0';
                ++parameter;
        }

        if (strcmp(option, "timeout") == 0) {
                if (noparam)
                        syntax_error("The option 'timeout' needs a parameter");
                        /* NOTREACHED */

                lval = strtol(parameter, &endptr, 10);
                if (*endptr != '\0')
                        syntax_error("The option 'timeout' expects an integer "
                            "parameter, not '%s'", parameter);
                        /* NOTREACHED */

                opts->timeout_in_secs = (long int)lval;
        } else if (strcmp(option, "rc") == 0) {
                if (noparam)
                        syntax_error("The option 'timeout' needs a parameter");
                /* NOTREACHED */

                lval = strtol(parameter, &endptr, 10);
                if (*endptr != '\0')
                        syntax_error("The option 'timeout' expects an integer "
                            "parameter, not '%s'", parameter);
                        /* NOTREACHED */

                opts->rc = (int)lval;
        } else if (strcmp(option, "intpre") == 0) {
                opts->flags |= TESTCASE_INT_PRE;
        } else if (strcmp(option, "intpost") == 0) {
                opts->flags |= TESTCASE_INT_POST;
        } else if (strcmp(option, "pre") == 0) {
                if (noparam)
                        syntax_error("The option 'pre' needs a parameter");
                        /* NOTREACHED */

                opts->flags |= TESTCASE_CUSTOM_PRE;
                opts->pre_cmd = strdup(parameter);
        } else if (strcmp(option, "post") == 0) {
                if (noparam)
                        syntax_error("The option 'post' needs a parameter");
                        /* NOTREACHED */

                opts->flags |= TESTCASE_CUSTOM_POST;
                opts->post_cmd = strdup(parameter);
        } else if (strcmp(option, "runas") == 0) {
                if (noparam)
                        syntax_error("The option 'runas' needs a parameter");
                        /* NOTREACHED */

                if ((pwd = getpwnam(parameter))) {
                        opts->runas_uid = pwd->pw_uid;
                        opts->flags |= TESTCASE_RUN_AS;
                } else {
                        syntax_error("invalid user name for 'runas': %s",
                            parameter);
                }
        } else if (strcmp(option, "nobuild") == 0) {
                opts->flags |= TESTCASE_NOBUILD;
        } else if (strcmp(option, "interpreter") == 0) {
                if (noparam)
                        syntax_error("The option 'interpreter' needs a parameter");
                        /* NOTREACHED */
                opts->interpreter = strdup(parameter);
        } else if (strcmp(option, "make") == 0) {
                if (noparam)
                        syntax_error("The option 'make' needs a parameter");
                        /* NOTREACHED */

                opts->make_cmd = strdup(parameter);
        } else if (strcmp(option, "defaults") == 0) {
                /* Valid option, does nothing */
        } else {
                syntax_error("Unknown option: %s", option);
                /* NOTREACHED */
        }

        return 0;
}

void
testcase_entry_parser(void *arg, char **tokens)
{
        prop_array_t runlist;
        prop_dictionary_t testcase_dict;
        struct testcase *testcase;
        char *options[256];
        int i, r, nopts;

        runlist = (prop_array_t)arg;

        testcase = malloc(sizeof(struct testcase));
        if (testcase == NULL)
                err(1, "could not malloc testcase memory");

        bzero(testcase, sizeof(struct testcase));

        entry_check_num_args(tokens, 3);

        testcase->argv = &tokens[3];
        for (testcase->argc = 0; testcase->argv[testcase->argc] != NULL;
             testcase->argc++)
                ;

        nopts = parse_options(tokens[2], options);

        testcase->name = tokens[0];

        if (strcmp(tokens[1], "userland") == 0) {
                testcase->type = TESTCASE_TYPE_USERLAND;
        } else if (strcmp(tokens[1], "kernel") == 0) {
                testcase->type = TESTCASE_TYPE_KERNEL;
        } else if (strcmp(tokens[1], "buildonly") == 0) {
                testcase->type = TESTCASE_TYPE_BUILDONLY;
        } else {
                syntax_error("Unknown type: %s", tokens[1]);
                /* NOTREACHED */
        }

        testcase->type_str = tokens[1];

        config_get_defaults(&testcase->opts);

        for (i = 0; i < nopts; i++)
                parse_testcase_option(&testcase->opts, options[i]);

        if ((testcase->type != TESTCASE_TYPE_USERLAND) &&
            (testcase->opts.flags & (TESTCASE_INT_PRE | TESTCASE_INT_POST)))
                syntax_error("'intpre' and 'intpost' options are only valid "
                    "with testcase type 'userland'");

        if ((testcase->type == TESTCASE_TYPE_BUILDONLY) &&
            (testcase->opts.flags & TESTCASE_NOBUILD))
                syntax_error("'nobuild' option is incompatible with type "
                    "'buildonly'");

        testcase_dict = testcase_from_struct(testcase);
        if (testcase->opts.pre_cmd != NULL)
                free(testcase->opts.pre_cmd);
        if (testcase->opts.post_cmd != NULL)
                free(testcase->opts.post_cmd);
        if (testcase->opts.interpreter != NULL)
                free(testcase->opts.interpreter);
        if (testcase->opts.make_cmd != NULL)
                free(testcase->opts.make_cmd);
        free(testcase);

        r = prop_array_add(runlist, testcase_dict);
        if (r == 0)
                err(1, "prop_array_add failed");
}