/*
 * Copyright (C) 2011  Internet Systems Consortium, Inc. ("ISC")
 *
 * Permission to use, copy, modify, and/or distribute this software for any
 * purpose with or without fee is hereby granted, provided that the above
 * copyright notice and this permission notice appear in all copies.
 *
 * THE SOFTWARE IS PROVIDED "AS IS" AND ISC DISCLAIMS ALL WARRANTIES WITH
 * REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
 * AND FITNESS.  IN NO EVENT SHALL ISC BE LIABLE FOR ANY SPECIAL, DIRECT,
 * INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
 * LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE
 * OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
 * PERFORMANCE OF THIS SOFTWARE.
 */

#include <string.h>
#include <stdlib.h>
#include <stdio.h>
#include <ctype.h>
#include <sys/types.h>
#include <stdarg.h>
#include <unistd.h>
#include <errno.h>
#include "procconf.h"

static char errmsg[256];    /* for returning error descriptions */
static const char* pc_name;
static const char* pc_usage;

#define INTERNAL_ERROR -1
#define USAGE_ERROR -2

/*
 * error: printf-style interface to print an error message or write it into
 * global errmsg.  If a usage message has been given (the indicator that errors
 * should be handled internally), the message is printed to stderr and the
 * program is exited.  If not, it is written into errmsg.
 * Input variables:
 * errtype is the error type.  If USAGE_ERROR, the program's usage is included
 *     in error messages, and the exit status is 2; otherwise the exit status
 *     is 1.
 * format and the remaining arguments are as for printf().
 */
static void
error(const int errtype, const char* format, ...) {
    va_list ap;

    va_start(ap,format);
    if (pc_usage != NULL) { /* error messages should be printed directly */
        fprintf(stderr, "%s: ", pc_name);
        vfprintf(stderr, format, ap);
        putc('\n', stderr);
        if (errtype == USAGE_ERROR) {
            fputs(pc_usage, stderr);
        }
        exit(errtype == USAGE_ERROR ? 2 : 1);
    } else {
        vsnprintf(errmsg, sizeof(errmsg), format, ap);
    }
    va_end(ap);
}

/*
 * Allocate memory, with error checking.
 * On allocation failure, error() is called; see its description.
 * The memory is zeroed before being returned.
 */
static void*
pc_malloc(size_t size) {
    void* ret = calloc(1, size);
    if (ret == NULL) {
        error(INTERNAL_ERROR, "Out of memory");
    }
    return(ret);
}

/*
 * Generate an error message describing an error in the value passed with an
 * option.  This is a front end for error(); see its usage for details.
 * Input variables:
 * expected: A description of what was expected for the value.
 * varDesc: The descriptor for the option.
 * value: The value that was given with the option.
 * detail: If non-null, additional detail to append regardign the problem.
 */
static void
opterror(const char* expected, const char* value, const confvar_t* varDesc,
         const char* detail) {
    if (detail == NULL) {
        detail = "";
    }
    error(USAGE_ERROR,
          "Invalid value given for option -%c: expected %s, got: %s%s",
          varDesc->outind, expected, value, detail);
}

/*
 * Add an option flag or value assignment to the options database.
 * This does all option-type-specific processing, and generates linked lists
 * of option structures.
 *
 * Input variables:
 * value is the string value assigned to the option, for options that take
 *     values.
 * varDesc is the description structure for this option.
 *
 * Output variables:
 * The option data is stored in a malloced confval structure, which is appended
 * to the option list.  The first element of the list is pointed to by first.
 * first should be NULL if the list contains no elements; in this case it is
 * set to point to the new structure.  Otherwise the structure is appended to
 * the element pointed to by last (it is updated to point to that structure).
 * The 'next' element of the new structure is set to NULL; this is the list
 * termination indicator when traversing it.
 *
 * Return value:
 * 0 if option was ignored.
 * 1 if option was processed & added to option chain.
 * On error, a string describing the error is stored in the global errmsg and
 * -1 is returned.
 */
static int
addOptVal(const char* value, const confvar_t* varDesc,
          confval** first, confval** last) {
    const void* addr;           /* address, if any at which to store value */
    confval data;               /* data for this option/value */
    confval *ret_data;          /* allocated structure to add to list */
    int seen = *first != NULL;  /* has this option been seen before? */
    char* ptr;        /* character that terminated processing in strtox() */
    int err;                    /* bad numeric value found? */

    /* if first instance of this option, store result to given addr */
    addr = seen ? NULL : varDesc->addr;
    switch (varDesc->type) {
    case CF_CHAR:
        if (strlen(value) > 1) {    /* length 0 is OK; gives null char */
            opterror("a single character", value, varDesc, NULL);
            return(-1);
        }
        data.value.charval = *value;
        if (addr != NULL) {
            *(char*)addr = *value;
        }
        break;
    case CF_STRING:
    case CF_NE_STRING:
        if (varDesc->type == CF_NE_STRING && *value == '\0') {
            opterror("a non-empty string", value, varDesc, NULL);
            return(-1);
        }
        data.value.string = value;
        if (addr != NULL) {
            *(const char**)addr = value;
        }
        break;
    case CF_INT:
    case CF_NON_NEG_INT:
    case CF_POS_INT:
        /* todo: check for out-of-range result */
        errno = 0;
        data.value.intval = strtol(value, &ptr, 0);
        if (errno == ERANGE) {
            opterror("an integer", value, varDesc,
                     " (out of range)");
            return(-1);
        }
        err = *value == '\0' || *ptr != '\0';
        switch (varDesc->type) {
        case CF_INT:
            if (err) {
                opterror("an integer", value, varDesc, NULL);
                return(-1);
            }
            break;
        case CF_NON_NEG_INT:
            if (err || data.value.intval < 0) {
                opterror("a non-negative integer", value, varDesc,
                         NULL);
                return(-1);
            }
            data.value.nnint = data.value.intval;
            break;
        case CF_POS_INT:
            if (err || data.value.intval <= 0) {
                opterror("a positive integer", value, varDesc, NULL);
                return(-1);
            }
            data.value.nnint = data.value.intval;
            break;
        default:
            /* To avoid complaints from -Wall */
            ;
        }
        if (addr != NULL) {
            *(int*)addr = data.value.intval;
        }
        break;
    case CF_FLOAT:
    case CF_NON_NEG_FLOAT:
    case CF_POS_FLOAT:
        /* todo: check for out-of-range result */
        errno = 0;
        data.value.floatval = strtod(value, &ptr);
        if (errno == ERANGE) {
            opterror("a number", value, varDesc, " (out of range)");
            return(-1);
        }
        err = *value == '\0' || *ptr != '\0';
        switch (varDesc->type) {
        case CF_FLOAT:
            if (err) {
                opterror("a number", value, varDesc, NULL);
                return(-1);
            }
            break;
        case CF_NON_NEG_FLOAT:
            if (err || data.value.floatval < 0) {
                opterror("a non-negative number", value, varDesc,
                         NULL);
                return(-1);
            }
            break;
        case CF_POS_FLOAT:
            if (err || data.value.floatval <= 0) {
                opterror("a positive number", value, varDesc, NULL);
                return(-1);
            }
            break;
        default:
            /* To avoid complaints from -Wall */
            ;
        }
        if (addr != NULL) {
            *(double*)addr = data.value.floatval;
        }
        break;
    case CF_SWITCH:
        data.value.switchval = varDesc->value;
        value = "1";    /* for debugging */
        if (addr != NULL) {
            *(int*)addr = varDesc->value;
        }
        break;
    case CF_ENDLIST:
        /* To avoid complaints from -Wall */
        ;
    }
    data.strval = value;
    data.next = NULL;
    if ((ret_data = (confval*)pc_malloc(sizeof(confval))) == NULL) {
        return(-1);
    }
    *ret_data = data;
    if (seen) {
        (*last)->next = ret_data;
    } else {
        *first = ret_data;
    }
    *last = ret_data;
    return(1);
}

/*
 * Input variables:
 * argc, argv: Command line data.
 * optConf[]: Option description structures.
 *
 * Output variables:
 * See addOptVal().
 * After processing, argc will be the number of non-option arguments and argv
 * will start with the first non-option argument.
 *
 * Return value:
 * On success, the number of options processed.
 * On error, a string describing the error is stored in the global errmsg and
 * -1 is returned.
 */
static int
procCmdLineArgs(int* argc, const char** argv[], const confvar_t optConf[],
                confval** perOptRecordsFirst, confval** perOptRecordsLast) {
    char* p;
    extern char* optarg;    /* For getopt */
    extern int optind;      /* For getopt */
    extern int optopt;      /* For getopt */
    char optstr[514];       /* List of option chars, for getopt */
    unsigned optCharToConf[256];        /* Map option char/num to confvar */
    int optchar;            /* value returned by getopt() */
    int confNum;       /* to iterate over confvars */
    int count = 0;          /* number of options processed */

    p = optstr;
    *(p++) = ':';
    for (confNum = 0; optConf[confNum].type != CF_ENDLIST; confNum++) {
        unsigned outind = optConf[confNum].outind;
        if (outind < 256 && isprint(outind)) {
            *(p++) = (char)outind;
            switch (optConf[confNum].type) {
            case CF_SWITCH:
                break;
            default:
                *(p++) = ':';
                break;
            }
            optCharToConf[outind] = confNum;
        }
    }

    *p = '\0';
    optind = 1;
    while ((optchar = getopt(*argc, *argv, optstr)) != -1)
    {
        int ind;
        int ret;

        if (optchar == '?') {
            error(USAGE_ERROR, "Unknown option character '%c'", optopt);
            return(-1);
        } else if (optchar == ':') {
            error(USAGE_ERROR, "No value given for option -%c", optopt);
            return(-1);
        }
        ind = optCharToConf[optchar];
        switch (ret = addOptVal(optarg, &optConf[ind],
                                &perOptRecordsFirst[ind],
                                &perOptRecordsLast[ind])) {
        case 1:
            count++;
            break;
        case 0:
            break;
        default:
            return(ret);
        }
    }
    *argc -= optind;
    *argv += optind;
    return(count);
}

/*
 * Input variables:
 * argc, argv: Command line data.
 * optConf[]: Option description structures.
 * name: Name of program, for messages.
 * usage: Usage message.  If non-null, on error a message is printed to stderr
 *    and the program exits.
 *
 * Output variables:
 * Option values are stored at the value given by any confvar that has a
 * non-null address. 
 * If confdatda is not null, the processed option values are stored in
 * confdata.
 * A pointer to the start of the values for each option is stored in
 * confdata->optVals[].values at the same offset as the option appears in
 * confdata[].
 * For any option for option characters/indexes that have been used,
 * confdata->map[index] is set to the same data.
 * After processing, argc will have been adjusted to be the number of
 * non-option arguments and argv will have been adjusted to start with the
 * first non-option argument.
 * The malloced data structures returned in confdata are:
 *   optVals
 *   optVals[0].values
 *   If any option characters/indexes are used, map.  If not used, this will be
 *     a null pointer.
 *
 * Return value:
 * On success, NULL.
 * On error, a message describing the problem.
 */
const char*
procOpts(int* argc, const char** argv[], const confvar_t optConf[],
         confdata_t* confdata, const char name[],
         const char usage[]) {
    /*
     * First & last records in the linked lists maintained for each option.
     * These will point to arrays indexed by option number, giving one pointer
     * (each) per option, used to maintain/return the list of values seen for
     * that option (see the description of first & last in addOptVal()
     */
    confval** perOptRecordsFirst;
    confval** perOptRecordsLast;

    /* Number of configuration options given in optConf */
    unsigned numConf;
    unsigned maxOptIndex = 0;   /* The highest option index number seen */
    /* number of option instances + assignments given */
    int numOptsFound;
    int optNum;    /* to iterate through the possible options */
    int i;         /* index into the global list of option value structures */
    confval** valuePointers;    /* global list of value structures */

    pc_name = name;
    pc_usage = usage;
    for (numConf = 0; optConf[numConf].type != CF_ENDLIST; numConf++) {
        unsigned outind = optConf[numConf].outind;

        if ((outind & ~CF_NOTFLAG) > maxOptIndex) {
            maxOptIndex = outind & ~CF_NOTFLAG;
        }
    }
    if (numConf == 0) {
        error(INTERNAL_ERROR, "Empty confvar list");
        return(errmsg);
    }
    if ((perOptRecordsFirst = (confval**)pc_malloc(sizeof(confval*) * numConf))
            == NULL || (perOptRecordsLast =
            (confval**)pc_malloc(sizeof(confval*) * numConf)) == NULL) {
        return(errmsg);
    }

    numOptsFound = procCmdLineArgs(argc, argv, optConf, perOptRecordsFirst,
                                   perOptRecordsLast);
    free(perOptRecordsLast);
    perOptRecordsLast = NULL;

    if (numOptsFound < 0)
    {
        free(perOptRecordsFirst);
        return(errmsg);
    }
    if (confdata == NULL) {
        free(perOptRecordsFirst);
        return NULL;
    }

    /*
     * All options have been read & initial processing done.
     * An array of pointers is now generated for the options.
     */
    if ((valuePointers =
            (confval**)pc_malloc(sizeof(confval*) * numOptsFound)) == NULL ||
            (confdata->optVals =
            (cf_option*)pc_malloc(sizeof(cf_option) * numConf)) == NULL) {
        return(errmsg);
    }
    /* If option characters / indexes are used, allocate a map for them */
    if (maxOptIndex == 0) {
	confdata->map = NULL;
    } else {
        if ((confdata->map = (cf_option**)pc_malloc(sizeof(cf_option) *
             (maxOptIndex+1))) == NULL) {
            return(errmsg);
        }
    }

    /*
     * Store the linked lists of option values into arrays.
     * Pointers to all option instances are stored in valuePointers,
     * with the values for each particular option being contiguous.
     */
    i = 0;
    for (optNum = 0; optNum < numConf; optNum++) {
        unsigned outind = optConf[optNum].outind;
        confval* optval;

        confdata->optVals[optNum].num = 0;
        confdata->optVals[optNum].values = &valuePointers[i];
        if (outind != 0) {
            confdata->map[outind & ~CF_NOTFLAG] = &confdata->optVals[optNum];
        }
        for (optval = perOptRecordsFirst[optNum]; optval != NULL;
                 optval = optval->next) {
            confdata->optVals[optNum].num++;
            valuePointers[i++] = optval;
        }
    }
    free(perOptRecordsFirst);
    return(NULL);
}

/*
 * Free the malloced data stored in confdata elements by ProcOpts()
 */
void
confdataFree(confdata_t *confdata) {
    if (confdata->map != NULL) {
        free(confdata->map);
        confdata->map = NULL;
    }
    free(confdata->optVals[0].values);
    free(confdata->optVals);
    confdata->optVals = NULL;
}