/*
 * 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 2022 OmniOS Community Edition (OmniOSce) Association.
 */

/*
 * This file exercises the various err(3C)/warn(3C) functions and produces
 * output that is checked by the corresponding err.ksh script.
 */

#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
#include <errno.h>
#include <err.h>
#include <sys/debug.h>

static FILE *stream = stderr;

typedef enum variant {
        VARIANT_ = 0,   /* warn(), err() */
        VARIANT_C,      /* warnc(), errc() */
        VARIANT_X,      /* warnx(), errx() */
        VARIANT_V,      /* vwarn(), verr() */
        VARIANT_VC,     /* vwarnc(), verrc() */
        VARIANT_VX,     /* vwarnx(), verrx() */
} variant_t;

void
usage(void)
{
        (void) fprintf(stderr,
            "usage: err [-e errno] [-x code] [-v variant]\n");
        exit(EXIT_FAILURE);
}

void
callback_func(int code)
{
        (void) fprintf(stream, "CALLBACK %d\n", code);
}

void
xtest(variant_t variant, int errcode, int exitcode, const char *fmt, ...)
{
        va_list va;

        va_start(va, fmt);

        switch (variant) {
        case VARIANT_V:
                errno = errcode;
                if (exitcode != 0)
                        verr(exitcode, fmt, va);
                else
                        vwarn(fmt, va);
                break;
        case VARIANT_VC:
                errno = 0;
                if (exitcode != 0)
                        verrc(exitcode, errcode, fmt, va);
                else
                        vwarnc(errcode, fmt, va);
                break;
        case VARIANT_VX:
                if (exitcode != 0)
                        verrx(exitcode, fmt, va);
                else
                        vwarnx(fmt, va);
                break;
        default:
                errx(EXIT_FAILURE, "Unhandled variant in %s", __func__);
        }

        va_end(va);
}

int
main(int argc, char **argv)
{
        int errcode = 0;
        int exitcode = 0;
        variant_t variant = VARIANT_;
        const char *errstr;
        long long num;
        int ch;

        /*
         * -e   specify errno for the test
         * -v   select variant to test
         * -x   specify exit code for the test
         */
        while ((ch = getopt(argc, argv, "e:v:x:")) != -1) {
                switch (ch) {
                case 'e':
                        num = strtonum(optarg, 0, 127, &errstr);
                        if (errstr != NULL)
                                errx(EXIT_FAILURE, "-x: %s", errstr);
                        errcode = (int)num;
                        break;
                case 'v':
                        num = strtonum(optarg, 0, VARIANT_VX, &errstr);
                        if (errstr != NULL)
                                errx(EXIT_FAILURE, "-v: %s", errstr);
                        switch (num) {
                        case VARIANT_:
                                variant = VARIANT_;
                                break;
                        case VARIANT_C:
                                variant = VARIANT_C;
                                break;
                        case VARIANT_X:
                                variant = VARIANT_X;
                                break;
                        case VARIANT_V:
                                variant = VARIANT_V;
                                break;
                        case VARIANT_VC:
                                variant = VARIANT_VC;
                                break;
                        case VARIANT_VX:
                                variant = VARIANT_VX;
                                break;
                        default:
                                errx(EXIT_FAILURE, "Unknown variant %lld", num);
                        }
                        break;
                case 'x':
                        num = strtonum(optarg, 0, 127, &errstr);
                        if (errstr != NULL)
                                errx(EXIT_FAILURE, "-x: %s", errstr);
                        exitcode = (int)num;
                        break;
                default:
                        usage();
                        break;
                }
        }

        argc -= optind;
        argv += optind;

        if (argc > 0)
                errx(EXIT_FAILURE, "Unexpected argument '%s'.", argv[1]);

        switch (variant) {
        case VARIANT_:
                errno = errcode;
                if (exitcode != 0)
                        err(exitcode, "E/%d/%d", variant, exitcode);
                else
                        warn("W/%d", variant);
                break;
        case VARIANT_C:
                errno = 0;
                if (exitcode != 0)
                        errc(exitcode, errcode, "E/%d/%d", variant, exitcode);
                else
                        warnc(errcode, "W/%d", variant);
                break;
        case VARIANT_X:
                if (exitcode != 0)
                        errx(exitcode, "E/%d/%d", variant, exitcode);
                else
                        warnx("W/%d", variant);
                break;
        case VARIANT_V:
        case VARIANT_VC:
        case VARIANT_VX:
                if (exitcode != 0) {
                        xtest(variant, errcode, exitcode, "E/%d/%d", variant,
                            exitcode);
                } else {
                        xtest(variant, errcode, exitcode, "W/%d", variant);
                }
                break;
        }

        return (0);
}