/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License (the "License").
 * You may not use this file except in compliance with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */

/*
 * Copyright 2010 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

/*
 * Copyright (c) 2015 by Delphix. All rights reserved.
 * Copyright 2017 Joyent, Inc.
 */

#include <errno.h>
#include <sys/types.h>
#include <stdlib.h>
#include <string.h>
#include <strings.h>
#include <stdio.h>
#include <ofmt.h>
#include <sys/termios.h>
#include <unistd.h>
#include <sys/sysmacros.h>
#include <libintl.h>
#include <assert.h>

/*
 * functions and structures to internally process a comma-separated string
 * of fields selected for output.
 */
typedef struct {
        char    *s_buf;
        const char **s_fields;  /* array of pointers to the fields in s_buf */
        uint_t  s_nfields;      /* the number of fields in s_buf */
        uint_t  s_currfield;    /* the current field being processed */
} split_t;

static void splitfree(split_t *);
static split_t *split_str(const char *, uint_t);
static split_t *split_fields(const ofmt_field_t *, uint_t, uint_t);

/*
 * The state of the output is tracked in a ofmt_state_t structure.
 * Each os_fields[i] entry points at an ofmt_field_t array for
 * the sub-command whose contents are provided by the caller, with
 * os_nfields set to the number of requested fields.
 */
typedef struct ofmt_state_s {
        ofmt_field_t    *os_fields;
        uint_t          os_nfields;
        boolean_t       os_lastfield;
        uint_t          os_overflow;
        struct winsize  os_winsize;
        int             os_nrow;
        uint_t          os_flags;
        uint_t          os_nbad;
        char            **os_badfields;
        int             os_maxnamelen;  /* longest name (f. multiline) */
        char            os_fs;          /* field seperator */
} ofmt_state_t;
/*
 * A B_TRUE return value from the callback function will print out the contents
 * of the output buffer, except when the buffer is returned with the empty
 * string "", in which case the  OFMT_VAL_UNDEF will be printed.
 *
 * If the callback function returns B_FALSE, the "?" string will be emitted.
 */
#define OFMT_VAL_UNDEF          "--"
#define OFMT_VAL_UNKNOWN        "?"

#define OFMT_DEFAULT_FS         ':'

/*
 * The maximum number of rows supported by the OFMT_WRAP option.
 */
#define OFMT_MAX_ROWS           128

static void ofmt_print_field(ofmt_state_t *, ofmt_field_t *, const char *,
    boolean_t);

/*
 * Split `str' into at most `maxfields' fields, Return a pointer to a
 * split_t containing the split fields, or NULL on failure.
 */
static split_t *
split_str(const char *str, uint_t maxfields)
{
        char    *field, *token, *lasts = NULL;
        split_t *sp;

        if (*str == '\0' || maxfields == 0)
                return (NULL);

        sp = calloc(sizeof (split_t), 1);
        if (sp == NULL)
                return (NULL);

        sp->s_buf = strdup(str);
        sp->s_fields = malloc(sizeof (char *) * maxfields);
        if (sp->s_buf == NULL || sp->s_fields == NULL)
                goto fail;

        token = sp->s_buf;
        while ((field = strtok_r(token, ",", &lasts)) != NULL) {
                if (sp->s_nfields == maxfields)
                        goto fail;
                token = NULL;
                sp->s_fields[sp->s_nfields++] = field;
        }
        return (sp);
fail:
        splitfree(sp);
        return (NULL);
}

/*
 * Split `fields' into at most `maxfields' fields. Return a pointer to
 * a split_t containing the split fields, or NULL on failure. Invoked
 * when all fields are implicitly selected at handle creation by
 * passing in a NULL fields_str
 */
static split_t *
split_fields(const ofmt_field_t *template, uint_t maxfields, uint_t maxcols)
{
        split_t *sp;
        uint_t i, cols;

        sp = calloc(sizeof (split_t), 1);
        if (sp == NULL)
                return (NULL);

        sp->s_fields = malloc(sizeof (char *) * maxfields);
        if (sp->s_fields == NULL)
                goto fail;
        cols = 0;
        for (i = 0; i < maxfields; i++) {
                cols += template[i].of_width;
                /*
                 * If all fields are implied without explicitly passing
                 * in a fields_str, build a list of field names, stopping
                 * when we run out of columns.
                 */
                if (maxcols > 0 && cols > maxcols)
                        break;
                sp->s_fields[sp->s_nfields++] = template[i].of_name;
        }
        return (sp);
fail:
        splitfree(sp);
        return (NULL);
}

/*
 * Free the split_t structure pointed to by `sp'.
 */
static void
splitfree(split_t *sp)
{
        if (sp == NULL)
                return;
        free(sp->s_buf);
        free(sp->s_fields);
        free(sp);
}

/*
 * Open a handle to be used for printing formatted output.
 */
ofmt_status_t
ofmt_open(const char *str, const ofmt_field_t *template, uint_t flags,
    uint_t maxcols, ofmt_handle_t *ofmt)
{
        split_t         *sp;
        uint_t          i, j, of_index;
        const ofmt_field_t *ofp;
        ofmt_field_t    *of;
        ofmt_state_t    *os = NULL;
        uint_t          nfields = 0;
        ofmt_status_t   error = OFMT_SUCCESS;
        boolean_t       parsable = (flags & OFMT_PARSABLE);
        boolean_t       wrap = (flags & OFMT_WRAP);
        boolean_t       multiline = (flags & OFMT_MULTILINE);

        *ofmt = NULL;
        if (parsable) {
                if (multiline)
                        return (OFMT_EPARSEMULTI);
                /*
                 * For parsable output mode, the caller always needs
                 * to specify precisely which fields are to be selected,
                 * since the set of fields may change over time.
                 */
                if (str == NULL || str[0] == '\0')
                        return (OFMT_EPARSENONE);
                if (strcasecmp(str, "all") == 0)
                        return (OFMT_EPARSEALL);
                if (wrap)
                        return (OFMT_EPARSEWRAP);
        }
        if (template == NULL)
                return (OFMT_ENOTEMPLATE);
        for (ofp = template; ofp->of_name != NULL; ofp++)
                nfields++;
        /*
         * split str into the columns selected, or construct the
         * full set of columns (equivalent to -o all).
         */
        if (str != NULL && strcasecmp(str, "all") != 0) {
                sp = split_str(str, nfields);
        } else {
                if (parsable || (str != NULL && strcasecmp(str, "all") == 0))
                        maxcols = 0;
                sp = split_fields(template, nfields, maxcols);
        }
        if (sp == NULL)
                goto nomem;

        os = calloc(sizeof (ofmt_state_t) +
            sp->s_nfields * sizeof (ofmt_field_t), 1);
        if (os == NULL)
                goto nomem;
        *ofmt = os;
        os->os_fields = (ofmt_field_t *)&os[1];
        os->os_flags = flags;
        os->os_fs = OFMT_DEFAULT_FS;

        of = os->os_fields;
        of_index = 0;
        /*
         * sp->s_nfields is the number of fields requested in fields_str.
         * nfields is the number of fields in template.
         */
        for (i = 0; i < sp->s_nfields; i++) {
                for (j = 0; j < nfields; j++) {
                        if (strcasecmp(sp->s_fields[i],
                            template[j].of_name) == 0) {
                                break;
                        }
                }
                if (j == nfields) {
                        int nbad = os->os_nbad++;

                        error = OFMT_EBADFIELDS;
                        if (os->os_badfields == NULL) {
                                os->os_badfields = malloc(sp->s_nfields *
                                    sizeof (char *));
                                if (os->os_badfields == NULL)
                                        goto nomem;
                        }
                        os->os_badfields[nbad] = strdup(sp->s_fields[i]);
                        if (os->os_badfields[nbad] == NULL)
                                goto nomem;
                        continue;
                }
                of[of_index].of_name = strdup(template[j].of_name);
                if (of[of_index].of_name == NULL)
                        goto nomem;
                if (multiline) {
                        int n = strlen(of[of_index].of_name);

                        os->os_maxnamelen = MAX(n, os->os_maxnamelen);
                }
                of[of_index].of_width = template[j].of_width;
                of[of_index].of_id = template[j].of_id;
                of[of_index].of_cb = template[j].of_cb;
                of_index++;
        }
        splitfree(sp);
        if (of_index == 0) /* all values in str are bogus */
                return (OFMT_ENOFIELDS);
        os->os_nfields = of_index; /* actual number of fields printed */
        ofmt_update_winsize(*ofmt);
        return (error);
nomem:
        error = OFMT_ENOMEM;
        if (os != NULL)
                ofmt_close(os);
        *ofmt = NULL;
        splitfree(sp);
        return (error);
}

void
ofmt_set_fs(ofmt_handle_t ofmt, char fs)
{
        ((ofmt_state_t *)ofmt)->os_fs = fs;
}

/*
 * free resources associated with the ofmt_handle_t
 */
void
ofmt_close(ofmt_handle_t ofmt)
{
        ofmt_state_t *os = ofmt;
        uint_t i;

        if (os == NULL)
                return;
        for (i = 0; i < os->os_nfields; i++)
                free(os->os_fields[i].of_name);
        for (i = 0; i < os->os_nbad; i++)
                free(os->os_badfields[i]);
        free(os->os_badfields);
        free(os);
}

/*
 * Print the value for the selected field by calling the callback-function
 * registered for the field.
 */
static void
ofmt_print_field(ofmt_state_t *os, ofmt_field_t *ofp, const char *value,
    boolean_t escsep)
{
        uint_t  width = ofp->of_width;
        uint_t  valwidth;
        uint_t  compress;
        boolean_t parsable = (os->os_flags & OFMT_PARSABLE);
        boolean_t multiline = (os->os_flags & OFMT_MULTILINE);
        boolean_t rightjust = (os->os_flags & OFMT_RIGHTJUST);
        char    c;

        /*
         * Parsable fields are separated by os_fs. os_fs and '\' are escaped
         * (prefixed by a) '\'.
         */
        if (parsable) {
                if (os->os_nfields == 1) {
                        (void) printf("%s", value);
                        return;
                }
                while ((c = *value++) != '\0') {
                        if (escsep && ((c == os->os_fs || c == '\\')))
                                (void) putchar('\\');
                        (void) putchar(c);
                }
                if (!os->os_lastfield)
                        (void) putchar(os->os_fs);
        } else if (multiline) {
                if (value[0] == '\0')
                        value = OFMT_VAL_UNDEF;
                (void) printf("%*.*s: %s", os->os_maxnamelen,
                    os->os_maxnamelen, ofp->of_name, value);
                if (!os->os_lastfield)
                        (void) putchar('\n');
        } else {
                if (os->os_lastfield) {
                        if (rightjust)
                                (void) printf("%*s", width, value);
                        else
                                (void) printf("%s", value);
                        os->os_overflow = 0;
                        return;
                }

                valwidth = strlen(value);
                if (valwidth + os->os_overflow >= width) {
                        os->os_overflow += valwidth - width + 1;
                        if (rightjust)
                                (void) printf("%*s ", width, value);
                        else
                                (void) printf("%s ", value);
                        return;
                }

                if (os->os_overflow > 0) {
                        compress = MIN(os->os_overflow, width - valwidth);
                        os->os_overflow -= compress;
                        width -= compress;
                }
                if (rightjust)
                        (void) printf("%*s ", width, value);
                else
                        (void) printf("%-*s", width, value);
        }
}

/*
 * Print enough to fit the field width.
 */
static void
ofmt_fit_width(split_t **spp, uint_t width, char *value, uint_t bufsize)
{
        split_t         *sp = *spp;
        char            *ptr = value, *lim = ptr + bufsize;
        uint_t          i, nextlen;

        if (sp == NULL) {
                sp = split_str(value, OFMT_MAX_ROWS);
                if (sp == NULL)
                        return;

                *spp = sp;
        }
        for (i = sp->s_currfield; i < sp->s_nfields; i++) {
                ptr += snprintf(ptr, lim - ptr, "%s,", sp->s_fields[i]);
                if (i + 1 == sp->s_nfields) {
                        nextlen = 0;
                        if (ptr > value)
                                ptr[-1] = '\0';
                } else {
                        nextlen = strlen(sp->s_fields[i + 1]);
                }

                if (strlen(value) + nextlen > width || ptr >= lim) {
                        i++;
                        break;
                }
        }
        sp->s_currfield = i;
}

/*
 * Print one or more rows of output values for the selected columns.
 */
void
ofmt_print(ofmt_handle_t ofmt, void *arg)
{
        ofmt_state_t *os = ofmt;
        uint_t i;
        char value[1024];
        ofmt_field_t *of;
        boolean_t escsep, more_rows;
        ofmt_arg_t ofarg;
        split_t **sp = NULL;
        boolean_t parsable = (os->os_flags & OFMT_PARSABLE);
        boolean_t multiline = (os->os_flags & OFMT_MULTILINE);
        boolean_t wrap = (os->os_flags & OFMT_WRAP);

        if (wrap) {
                sp = calloc(sizeof (split_t *), os->os_nfields);
                if (sp == NULL)
                        return;
        }

        if ((os->os_nrow++ % os->os_winsize.ws_row) == 0 &&
            !parsable && !multiline) {
                if (!(os->os_flags & OFMT_NOHEADER))
                        ofmt_print_header(os);
                os->os_nrow++;
        }

        if (multiline && os->os_nrow > 1)
                (void) putchar('\n');

        of = os->os_fields;
        escsep = (os->os_nfields > 1);
        more_rows = B_FALSE;
        for (i = 0; i < os->os_nfields; i++) {
                os->os_lastfield = (i + 1 == os->os_nfields);
                value[0] = '\0';
                ofarg.ofmt_id = of[i].of_id;
                ofarg.ofmt_cbarg = arg;

                if ((*of[i].of_cb)(&ofarg, value, sizeof (value))) {
                        if (wrap) {
                                /*
                                 * 'value' will be split at comma boundaries
                                 * and stored into sp[i].
                                 */
                                ofmt_fit_width(&sp[i], of[i].of_width, value,
                                    sizeof (value));
                                if (sp[i] != NULL &&
                                    sp[i]->s_currfield < sp[i]->s_nfields)
                                        more_rows = B_TRUE;
                        }

                        ofmt_print_field(os, &of[i],
                            (*value == '\0' && !parsable) ?
                            OFMT_VAL_UNDEF : value, escsep);
                } else {
                        ofmt_print_field(os, &of[i], OFMT_VAL_UNKNOWN, escsep);
                }
        }
        (void) putchar('\n');

        while (more_rows) {
                more_rows = B_FALSE;
                for (i = 0; i < os->os_nfields; i++) {
                        os->os_lastfield = (i + 1 == os->os_nfields);
                        value[0] = '\0';

                        ofmt_fit_width(&sp[i], of[i].of_width,
                            value, sizeof (value));
                        if (sp[i] != NULL &&
                            sp[i]->s_currfield < sp[i]->s_nfields)
                                more_rows = B_TRUE;

                        ofmt_print_field(os, &of[i], value, escsep);
                }
                (void) putchar('\n');
        }
        (void) fflush(stdout);

        if (sp != NULL) {
                for (i = 0; i < os->os_nfields; i++)
                        splitfree(sp[i]);
                free(sp);
        }
}

/*
 * Print the field headers
 */
void
ofmt_print_header(ofmt_handle_t ofmt)
{
        ofmt_state_t *os = ofmt;
        uint_t i;
        ofmt_field_t *of = os->os_fields;
        boolean_t escsep = (os->os_nfields > 1);

        for (i = 0; i < os->os_nfields; i++) {
                os->os_lastfield = (i + 1 == os->os_nfields);
                ofmt_print_field(os, &of[i], of[i].of_name, escsep);
        }
        (void) putchar('\n');
}

/*
 * Update the current window size.
 */
void
ofmt_update_winsize(ofmt_handle_t ofmt)
{
        ofmt_state_t *os = ofmt;
        struct winsize *winsize = &os->os_winsize;

        if (ioctl(1, TIOCGWINSZ, winsize) == -1 ||
            winsize->ws_col == 0 || winsize->ws_row == 0) {
                winsize->ws_col = 80;
                winsize->ws_row = 24;
        }
}

/*
 * Return error diagnostics using the information in the ofmt_handle_t
 */
char *
ofmt_strerror(ofmt_handle_t ofmt, ofmt_status_t error, char *buf,
    uint_t bufsize)
{
        ofmt_state_t *os = ofmt;
        uint_t i;
        const char *s;
        char ebuf[OFMT_BUFSIZE];
        boolean_t parsable;

        /*
         * ebuf is intended for optional error-specific data to be appended
         * after the internationalized error string for an error code.
         */
        ebuf[0] = '\0';

        switch (error) {
        case OFMT_SUCCESS:
                s = "success";
                break;
        case OFMT_EBADFIELDS:
                /*
                 * Enumerate the singular/plural version of the warning
                 * and error to simplify and improve localization.
                 */
                parsable = (os->os_flags & OFMT_PARSABLE);
                if (!parsable) {
                        if (os->os_nbad > 1)
                                s = "ignoring unknown output fields:";
                        else
                                s = "ignoring unknown output field:";
                } else {
                        if (os->os_nbad > 1)
                                s = "unknown output fields:";
                        else
                                s = "unknown output field:";
                }
                /* set up the bad fields in ebuf */
                for (i = 0; i < os->os_nbad; i++) {
                        (void) strlcat(ebuf, " `", sizeof (ebuf));
                        (void) strlcat(ebuf, os->os_badfields[i],
                            sizeof (ebuf));
                        (void) strlcat(ebuf, "'", sizeof (ebuf));
                }
                break;
        case OFMT_ENOFIELDS:
                s = "no valid output fields";
                break;
        case OFMT_EPARSEMULTI:
                s = "multiline mode incompatible with parsable mode";
                break;
        case OFMT_EPARSEALL:
                s = "output field `all' invalid in parsable mode";
                break;
        case OFMT_EPARSENONE:
                s = "output fields must be specified in parsable mode";
                break;
        case OFMT_EPARSEWRAP:
                s = "parsable mode is incompatible with wrap mode";
                break;
        case OFMT_ENOTEMPLATE:
                s = "no template provided for fields";
                break;
        case OFMT_ENOMEM:
                s = strerror(ENOMEM);
                break;
        default:
                (void) snprintf(buf, bufsize,
                    dgettext(TEXT_DOMAIN, "unknown ofmt error (%d)"),
                    error);
                return (buf);
        }
        (void) snprintf(buf, bufsize, dgettext(TEXT_DOMAIN, s));
        (void) strlcat(buf, ebuf, bufsize);
        return (buf);
}

void
ofmt_check(ofmt_status_t oferr, boolean_t parsable, ofmt_handle_t ofmt,
    void (*die)(const char *, ...), void (*warn)(const char *, ...))
{
        char buf[OFMT_BUFSIZE];

        assert(die != NULL);
        assert(warn != NULL);

        if (oferr == OFMT_SUCCESS)
                return;

        (void) ofmt_strerror(ofmt, oferr, buf, sizeof (buf));

        /*
         * All errors are considered fatal in parsable mode.  OFMT_ENOMEM and
         * OFMT_ENOFIELDS errors are always fatal, regardless of mode. For
         * other errors, we print diagnostics in human-readable mode and
         * processs what we can.
         */
        if (parsable || oferr == OFMT_ENOFIELDS || oferr == OFMT_ENOMEM) {
                ofmt_close(ofmt);
                die(buf);
        } else {
                warn(buf);
        }
}