cmd/flowstat/flowstat.c

/*
 * 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.
 */

#include <stdio.h>
#include <locale.h>
#include <stdarg.h>
#include <stdlib.h>
#include <fcntl.h>
#include <string.h>
#include <stropts.h>
#include <errno.h>
#include <strings.h>
#include <getopt.h>
#include <unistd.h>
#include <priv.h>
#include <netdb.h>
#include <libintl.h>
#include <libdlflow.h>
#include <libdllink.h>
#include <libdlstat.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <sys/ethernet.h>
#include <inet/ip.h>
#include <inet/ip6.h>
#include <stddef.h>
#include <ofmt.h>

typedef struct flow_chain_s {
    char            fc_flowname[MAXFLOWNAMELEN];
    boolean_t       fc_visited;
    flow_stat_t     *fc_stat;
    struct flow_chain_s *fc_next;
} flow_chain_t;

typedef struct show_flow_state {
    flow_chain_t    *fs_flowchain;
    ofmt_handle_t   fs_ofmt;
    char        fs_unit;
    boolean_t   fs_parsable;
} show_flow_state_t;

typedef struct show_history_state_s {
    boolean_t   us_plot;
    boolean_t   us_parsable;
    boolean_t   us_printheader;
    boolean_t   us_first;
    boolean_t   us_showall;
    ofmt_handle_t   us_ofmt;
} show_history_state_t;

static void do_show_history(int, char **);

static int  query_flow_stats(dladm_handle_t, dladm_flow_attr_t *, void *);
static int  query_link_flow_stats(dladm_handle_t, datalink_id_t, void *);

static void die(const char *, ...);
static void die_optdup(int);
static void die_opterr(int, int, const char *);
static void die_dlerr(dladm_status_t, const char *, ...);
static void warn(const char *, ...);

/* callback functions for printing output */
static ofmt_cb_t print_default_cb, print_flow_stats_cb;
static void flowstat_ofmt_check(ofmt_status_t, boolean_t, ofmt_handle_t);

#define NULL_OFMT       {NULL, 0, 0, NULL}

/*
 * structures for flowstat (printing live statistics)
 */
typedef enum {
    FLOW_S_FLOW,
    FLOW_S_IPKTS,
    FLOW_S_RBYTES,
    FLOW_S_IERRORS,
    FLOW_S_OPKTS,
    FLOW_S_OBYTES,
    FLOW_S_OERRORS
} flow_s_field_index_t;

static ofmt_field_t flow_s_fields[] = {
/* name,    field width,    index,      callback */
{ "FLOW",   15, FLOW_S_FLOW,    print_flow_stats_cb},
{ "IPKTS",  8,  FLOW_S_IPKTS,   print_flow_stats_cb},
{ "RBYTES", 8,  FLOW_S_RBYTES,  print_flow_stats_cb},
{ "IERRS",  8,  FLOW_S_IERRORS, print_flow_stats_cb},
{ "OPKTS",  8,  FLOW_S_OPKTS,   print_flow_stats_cb},
{ "OBYTES", 8,  FLOW_S_OBYTES,  print_flow_stats_cb},
{ "OERRS",  8,  FLOW_S_OERRORS, print_flow_stats_cb},
NULL_OFMT}
;

typedef struct flow_args_s {
    char        *flow_s_flow;
    flow_stat_t *flow_s_stat;
    char        flow_s_unit;
    boolean_t   flow_s_parsable;
} flow_args_t;

/*
 * structures for 'flowstat -h'
 */
typedef struct  history_fields_buf_s {
    char    history_flow[12];
    char    history_duration[10];
    char    history_ipackets[9];
    char    history_rbytes[10];
    char    history_opackets[9];
    char    history_obytes[10];
    char    history_bandwidth[14];
} history_fields_buf_t;

static ofmt_field_t history_fields[] = {
/* name,    field width,    offset */
{ "FLOW",   13,
    offsetof(history_fields_buf_t, history_flow), print_default_cb},
{ "DURATION",   11,
    offsetof(history_fields_buf_t, history_duration), print_default_cb},
{ "IPACKETS",   10,
    offsetof(history_fields_buf_t, history_ipackets), print_default_cb},
{ "RBYTES", 11,
    offsetof(history_fields_buf_t, history_rbytes), print_default_cb},
{ "OPACKETS",   10,
    offsetof(history_fields_buf_t, history_opackets), print_default_cb},
{ "OBYTES", 11,
    offsetof(history_fields_buf_t, history_obytes), print_default_cb},
{ "BANDWIDTH",  15,
    offsetof(history_fields_buf_t, history_bandwidth), print_default_cb},
NULL_OFMT}
;

typedef struct  history_l_fields_buf_s {
    char    history_l_flow[12];
    char    history_l_stime[13];
    char    history_l_etime[13];
    char    history_l_rbytes[8];
    char    history_l_obytes[8];
    char    history_l_bandwidth[14];
} history_l_fields_buf_t;

static ofmt_field_t history_l_fields[] = {
/* name,    field width,    offset */
{ "FLOW",   13,
    offsetof(history_l_fields_buf_t, history_l_flow), print_default_cb},
{ "START",  14,
    offsetof(history_l_fields_buf_t, history_l_stime), print_default_cb},
{ "END",    14,
    offsetof(history_l_fields_buf_t, history_l_etime), print_default_cb},
{ "RBYTES", 9,
    offsetof(history_l_fields_buf_t, history_l_rbytes), print_default_cb},
{ "OBYTES", 9,
    offsetof(history_l_fields_buf_t, history_l_obytes), print_default_cb},
{ "BANDWIDTH",  15,
    offsetof(history_l_fields_buf_t, history_l_bandwidth),
        print_default_cb},
NULL_OFMT}
;

static char *progname;

/*
 * Handle to libdladm.  Opened in main() before the sub-command
 * specific function is called.
 */
static dladm_handle_t handle = NULL;

const char *usage_ermsg = "flowstat [-r | -t] [-i interval] "
        "[-l link] [flow]\n"
        "       flowstat [-A] [-i interval] [-p] [ -o field[,...]]\n"
        "                [-u R|K|M|G|T|P] [-l link] [flow]\n"
        "       flowstat -h [-a] [-d] [-F format]"
        " [-s <DD/MM/YYYY,HH:MM:SS>]\n"
        "                [-e <DD/MM/YYYY,HH:MM:SS>] -f <logfile> "
        "[<flow>]";

static void
usage(void)
{
    (void) fprintf(stderr, "%s\n", gettext(usage_ermsg));

    /* close dladm handle if it was opened */
    if (handle != NULL)
        dladm_close(handle);

    exit(1);
}

boolean_t
flowstat_unit(char *oarg, char *unit)
{
    if ((strcmp(oarg, "R") == 0) || (strcmp(oarg, "K") == 0) ||
        (strcmp(oarg, "M") == 0) || (strcmp(oarg, "G") == 0) ||
        (strcmp(oarg, "T") == 0) || (strcmp(oarg, "P") == 0)) {
        *unit = oarg[0];
        return (B_TRUE);
    }

    return (B_FALSE);
}

void
map_to_units(char *buf, uint_t bufsize, double num, char unit,
    boolean_t parsable)
{
    if (parsable) {
        (void) snprintf(buf, bufsize, "%.0lf", num);
        return;
    }

    if (unit == '\0') {
        int index;

        for (index = 0; (int)(num/1000) != 0; index++, num /= 1000)
            ;

        switch (index) {
            case 0:
                unit = '\0';
                break;
            case 1:
                unit = 'K';
                break;
            case 2:
                unit = 'M';
                break;
            case 3:
                unit = 'G';
                break;
            case 4:
                unit = 'T';
                break;
            case 5:
                /* Largest unit supported */
            default:
                unit = 'P';
                break;
        }
    } else  {
        switch (unit) {
            case 'R':
                /* Already raw numbers */
                unit = '\0';
                break;
            case 'K':
                num /= 1000;
                break;
            case 'M':
                num /= (1000*1000);
                break;
            case 'G':
                num /= (1000*1000*1000);
                break;
            case 'T':
                num /= (1000.0*1000.0*1000.0*1000.0);
                break;
            case 'P':
                /* Largest unit supported */
            default:
                num /= (1000.0*1000.0*1000.0*1000.0*1000.0);
                break;
        }
    }

    if (unit == '\0')
        (void) snprintf(buf, bufsize, " %7.0lf%c", num, unit);
    else
        (void) snprintf(buf, bufsize, " %6.2lf%c", num, unit);
}

flow_chain_t *
get_flow_prev_stat(const char *flowname, void *arg)
{
    show_flow_state_t   *state = arg;
    flow_chain_t        *flow_curr = NULL;

    /* Scan prev flowname list and look for entry matching this entry */
    for (flow_curr = state->fs_flowchain; flow_curr;
        flow_curr = flow_curr->fc_next) {
        if (strcmp(flow_curr->fc_flowname, flowname) == 0)
            break;
    }

    /* New flow, add it */
    if (flow_curr == NULL) {
        flow_curr = (flow_chain_t *)malloc(sizeof (flow_chain_t));
        if (flow_curr == NULL)
            goto done;
        (void) strncpy(flow_curr->fc_flowname, flowname,
            MAXFLOWNAMELEN);
        flow_curr->fc_stat = NULL;
        flow_curr->fc_next = state->fs_flowchain;
        state->fs_flowchain = flow_curr;
    }
done:
    return (flow_curr);
}

/*
 * Number of flows may change while flowstat -i is executing.
 * Free memory allocated for flows that are no longer there.
 * Prepare for next iteration by marking visited = false for
 * existing stat entries.
 */
static void
cleanup_removed_flows(show_flow_state_t *state)
{
    flow_chain_t    *fcurr;
    flow_chain_t    *fprev;
    flow_chain_t    *tofree;

    /* Delete all nodes from the list that have fc_visited marked false */
    fcurr = state->fs_flowchain;
    while (fcurr != NULL) {
        if (fcurr->fc_visited) {
            fcurr->fc_visited = B_FALSE;
            fprev = fcurr;
            fcurr = fcurr->fc_next;
            continue;
        }

        /* Is it head of the list? */
        if (fcurr == state->fs_flowchain)
            state->fs_flowchain = fcurr->fc_next;
        else
            fprev->fc_next = fcurr->fc_next;

        /* fprev remains the same */
        tofree = fcurr;
        fcurr = fcurr->fc_next;

        /* Free stats memory for the removed flow */
        dladm_flow_stat_free(tofree->fc_stat);
        free(tofree);
    }
}

static boolean_t
print_flow_stats_cb(ofmt_arg_t *of_arg, char *buf, uint_t bufsize)
{
    flow_args_t *fargs = of_arg->ofmt_cbarg;
    flow_stat_t *diff_stats = fargs->flow_s_stat;
    char        unit = fargs->flow_s_unit;
    boolean_t   parsable = fargs->flow_s_parsable;

    switch (of_arg->ofmt_id) {
    case FLOW_S_FLOW:
        (void) snprintf(buf, bufsize, "%s", fargs->flow_s_flow);
        break;
    case FLOW_S_IPKTS:
        map_to_units(buf, bufsize, diff_stats->fl_ipackets, unit,
            parsable);
        break;
    case FLOW_S_RBYTES:
        map_to_units(buf, bufsize, diff_stats->fl_rbytes, unit,
            parsable);
        break;
    case FLOW_S_IERRORS:
        map_to_units(buf, bufsize, diff_stats->fl_ierrors, unit,
            parsable);
        break;
    case FLOW_S_OPKTS:
        map_to_units(buf, bufsize, diff_stats->fl_opackets, unit,
            parsable);
        break;
    case FLOW_S_OBYTES:
        map_to_units(buf, bufsize, diff_stats->fl_obytes, unit,
            parsable);
        break;
    case FLOW_S_OERRORS:
        map_to_units(buf, bufsize, diff_stats->fl_oerrors, unit,
            parsable);
        break;
    default:
        die("invalid input");
        break;
    }
    return (B_TRUE);
}

/* ARGSUSED */
static int
query_flow_stats(dladm_handle_t handle, dladm_flow_attr_t *attr, void *arg)
{
    show_flow_state_t   *state = arg;
    flow_chain_t        *flow_node;
    flow_stat_t     *curr_stat;
    flow_stat_t     *prev_stat;
    flow_stat_t     *diff_stat;
    char            *flowname = attr->fa_flowname;
    flow_args_t     fargs;

    /* Get previous stats for the flow */
    flow_node = get_flow_prev_stat(flowname, arg);
    if (flow_node == NULL)
        goto done;

    flow_node->fc_visited = B_TRUE;
    prev_stat = flow_node->fc_stat;

    /* Query library for current stats */
    curr_stat = dladm_flow_stat_query(flowname);
    if (curr_stat == NULL)
        goto done;

    /* current stats - prev iteration stats */
    diff_stat = dladm_flow_stat_diff(curr_stat, prev_stat);

    /* Free prev stats */
    dladm_flow_stat_free(prev_stat);

    /* Prev <- curr stats */
    flow_node->fc_stat = curr_stat;

    if (diff_stat == NULL)
        goto done;

    /* Print stats */
    fargs.flow_s_flow = flowname;
    fargs.flow_s_stat = diff_stat;
    fargs.flow_s_unit = state->fs_unit;
    fargs.flow_s_parsable = state->fs_parsable;
    ofmt_print(state->fs_ofmt, &fargs);

    /* Free diff stats */
    dladm_flow_stat_free(diff_stat);
done:
    return (DLADM_WALK_CONTINUE);
}

/*
 * Wrapper of dladm_walk_flow(query_flow_stats,...) to make it usable for
 * dladm_walk_datalink_id(). Used for showing flow stats for
 * all flows on all links.
 */
static int
query_link_flow_stats(dladm_handle_t dh, datalink_id_t linkid, void * arg)
{
    if (dladm_walk_flow(query_flow_stats, dh, linkid, arg, B_FALSE)
        == DLADM_STATUS_OK)
        return (DLADM_WALK_CONTINUE);
    else
        return (DLADM_WALK_TERMINATE);
}

void
print_all_stats(name_value_stat_entry_t *stat_entry)
{
    name_value_stat_t   *curr_stat;

    printf("%s\n", stat_entry->nve_header);

    for (curr_stat = stat_entry->nve_stats; curr_stat != NULL;
        curr_stat = curr_stat->nv_nextstat) {
        printf("\t%15s", curr_stat->nv_statname);
        printf("\t%15llu\n", curr_stat->nv_statval);
    }
}

/* ARGSUSED */
static int
dump_one_flow_stats(dladm_handle_t handle, dladm_flow_attr_t *attr, void *arg)
{
    char    *flowname = attr->fa_flowname;
    void    *stat;

    stat = dladm_flow_stat_query_all(flowname);
    if (stat == NULL)
        goto done;
    print_all_stats(stat);
    dladm_flow_stat_query_all_free(stat);

done:
    return (DLADM_WALK_CONTINUE);
}

/*
 * Wrapper of dladm_walk_flow(query_flow_stats,...) to make it usable for
 * dladm_walk_datalink_id(). Used for showing flow stats for
 * all flows on all links.
 */
static int
dump_link_flow_stats(dladm_handle_t dh, datalink_id_t linkid, void * arg)
{
    if (dladm_walk_flow(dump_one_flow_stats, dh, linkid, arg, B_FALSE)
        == DLADM_STATUS_OK)
        return (DLADM_WALK_CONTINUE);
    else
        return (DLADM_WALK_TERMINATE);
}

static void
dump_all_flow_stats(dladm_flow_attr_t *attrp, void *arg, datalink_id_t linkid,
    boolean_t flow_arg)
{
    /* Show stats for named flow */
    if (flow_arg)  {
        (void) dump_one_flow_stats(handle, attrp, arg);

    /* Show stats for flows on one link */
    } else if (linkid != DATALINK_INVALID_LINKID) {
        (void) dladm_walk_flow(dump_one_flow_stats, handle, linkid,
            arg, B_FALSE);

    /* Show stats for all flows on all links */
    } else {
        (void) dladm_walk_datalink_id(dump_link_flow_stats,
            handle, arg, DATALINK_CLASS_ALL,
            DATALINK_ANY_MEDIATYPE, DLADM_OPT_ACTIVE);
    }
}

int
main(int argc, char *argv[])
{
    dladm_status_t      status;
    int         option;
    boolean_t       r_arg = B_FALSE;
    boolean_t       t_arg = B_FALSE;
    boolean_t       p_arg = B_FALSE;
    boolean_t       i_arg = B_FALSE;
    boolean_t       o_arg = B_FALSE;
    boolean_t       u_arg = B_FALSE;
    boolean_t       A_arg = B_FALSE;
    boolean_t       flow_arg = B_FALSE;
    datalink_id_t       linkid = DATALINK_ALL_LINKID;
    char            linkname[MAXLINKNAMELEN];
    char            flowname[MAXFLOWNAMELEN];
    uint32_t        interval = 0;
    char            unit = '\0';
    show_flow_state_t   state;
    char            *fields_str = NULL;
    char            *o_fields_str = NULL;

    char            *total_stat_fields =
        "flow,ipkts,rbytes,ierrs,opkts,obytes,oerrs";
    char            *rx_stat_fields =
        "flow,ipkts,rbytes,ierrs";
    char            *tx_stat_fields =
        "flow,opkts,obytes,oerrs";

    ofmt_handle_t       ofmt;
    ofmt_status_t       oferr;
    uint_t          ofmtflags = OFMT_RIGHTJUST;

    dladm_flow_attr_t   attr;

    (void) setlocale(LC_ALL, "");
#if !defined(TEXT_DOMAIN)
#define TEXT_DOMAIN "SYS_TEST"
#endif
    (void) textdomain(TEXT_DOMAIN);

    progname = argv[0];

    /* Open the libdladm handle */
    if ((status = dladm_open(&handle)) != DLADM_STATUS_OK)
        die_dlerr(status, "could not open /dev/dld");

    bzero(&state, sizeof (state));

    opterr = 0;
    while ((option = getopt_long(argc, argv, ":rtApi:o:u:l:h",
        NULL, NULL)) != -1) {
        switch (option) {
        case 'r':
            if (r_arg)
                die_optdup(option);

            r_arg = B_TRUE;
            break;
        case 't':
            if (t_arg)
                die_optdup(option);

            t_arg = B_TRUE;
            break;
        case 'A':
            if (A_arg)
                die_optdup(option);

            A_arg = B_TRUE;
            break;
        case 'p':
            if (p_arg)
                die_optdup(option);

            p_arg = B_TRUE;
            break;
        case 'i':
            if (i_arg)
                die_optdup(option);

            i_arg = B_TRUE;
            if (!dladm_str2interval(optarg, &interval))
                die("invalid interval value '%s'", optarg);
            break;
        case 'o':
            o_arg = B_TRUE;
            o_fields_str = optarg;
            break;
        case 'u':
            if (u_arg)
                die_optdup(option);

            u_arg = B_TRUE;
            if (!flowstat_unit(optarg, &unit))
                die("invalid unit value '%s',"
                    "unit must be R|K|M|G|T|P", optarg);
            break;
        case 'l':
            if (strlcpy(linkname, optarg, MAXLINKNAMELEN)
                >= MAXLINKNAMELEN)
                die("link name too long\n");
            if (dladm_name2info(handle, linkname, &linkid, NULL,
                NULL, NULL) != DLADM_STATUS_OK)
                die("invalid link '%s'", linkname);
            break;
        case 'h':
            if (r_arg || t_arg || p_arg || o_arg || u_arg ||
                i_arg || A_arg) {
                die("the option -h is not compatible with "
                    "-r, -t, -p, -o, -u, -i, -A");
            }
            do_show_history(argc, argv);
            return (0);
            break;
        default:
            die_opterr(optopt, option, usage_ermsg);
            break;
        }
    }

    if (r_arg && t_arg)
        die("the option -t and -r are not compatible");

    if (u_arg && p_arg)
        die("the option -u and -p are not compatible");

    if (p_arg && !o_arg)
        die("-p requires -o");

    if (p_arg && strcasecmp(o_fields_str, "all") == 0)
        die("\"-o all\" is invalid with -p");

    if (A_arg &&
        (r_arg || t_arg || p_arg || o_arg || u_arg || i_arg))
        die("the option -A is not compatible with "
            "-r, -t, -p, -o, -u, -i");

    /* get flow name (optional last argument) */
    if (optind == (argc-1)) {
        if (strlcpy(flowname, argv[optind], MAXFLOWNAMELEN)
            >= MAXFLOWNAMELEN)
            die("flow name too long");
        flow_arg = B_TRUE;
    } else if (optind != argc) {
        usage();
    }

    if (flow_arg &&
        dladm_flow_info(handle, flowname, &attr) != DLADM_STATUS_OK)
        die("invalid flow %s", flowname);

    if (A_arg) {
        dump_all_flow_stats(&attr, &state, linkid, flow_arg);
        return (0);
    }

    state.fs_unit = unit;
    state.fs_parsable = p_arg;

    if (state.fs_parsable)
        ofmtflags |= OFMT_PARSABLE;

    if (r_arg)
        fields_str = rx_stat_fields;
    else if (t_arg)
        fields_str = tx_stat_fields;
    else
        fields_str = total_stat_fields;

    if (o_arg) {
        fields_str = (strcasecmp(o_fields_str, "all") == 0) ?
            fields_str : o_fields_str;
    }

    oferr = ofmt_open(fields_str, flow_s_fields, ofmtflags, 0, &ofmt);
    flowstat_ofmt_check(oferr, state.fs_parsable, ofmt);
    state.fs_ofmt = ofmt;

    for (;;) {
        /* Show stats for named flow */
        if (flow_arg)  {
            (void) query_flow_stats(handle, &attr, &state);

        /* Show stats for flows on one link */
        } else if (linkid != DATALINK_INVALID_LINKID) {
            (void) dladm_walk_flow(query_flow_stats, handle, linkid,
                &state, B_FALSE);

        /* Show stats for all flows on all links */
        } else {
            (void) dladm_walk_datalink_id(query_link_flow_stats,
                handle, &state, DATALINK_CLASS_ALL,
                DATALINK_ANY_MEDIATYPE, DLADM_OPT_ACTIVE);
        }

        if (interval == 0)
            break;

        (void) fflush(stdout);
        cleanup_removed_flows(&state);
        (void) sleep(interval);
    }
    ofmt_close(ofmt);

    dladm_close(handle);
    return (0);
}

/* ARGSUSED */
static int
show_history_date(dladm_usage_t *history, void *arg)
{
    show_history_state_t    *state = (show_history_state_t *)arg;
    time_t          stime;
    char            timebuf[20];
    dladm_flow_attr_t   attr;
    dladm_status_t      status;

    /*
     * Only show historical information for existing flows unless '-a'
     * is specified.
     */
    if (!state->us_showall && ((status = dladm_flow_info(handle,
        history->du_name, &attr)) != DLADM_STATUS_OK)) {
        return (status);
    }

    stime = history->du_stime;
    (void) strftime(timebuf, sizeof (timebuf), "%m/%d/%Y",
        localtime(&stime));
    (void) printf("%s\n", timebuf);

    return (DLADM_STATUS_OK);
}

static int
show_history_time(dladm_usage_t *history, void *arg)
{
    show_history_state_t    *state = (show_history_state_t *)arg;
    char            buf[DLADM_STRSIZE];
    history_l_fields_buf_t  ubuf;
    time_t          time;
    double          bw;
    dladm_flow_attr_t   attr;
    dladm_status_t      status;

    /*
     * Only show historical information for existing flows unless '-a'
     * is specified.
     */
    if (!state->us_showall && ((status = dladm_flow_info(handle,
        history->du_name, &attr)) != DLADM_STATUS_OK)) {
        return (status);
    }

    if (state->us_plot) {
        if (!state->us_printheader) {
            if (state->us_first) {
                (void) printf("# Time");
                state->us_first = B_FALSE;
            }
            (void) printf(" %s", history->du_name);
            if (history->du_last) {
                (void) printf("\n");
                state->us_first = B_TRUE;
                state->us_printheader = B_TRUE;
            }
        } else {
            if (state->us_first) {
                time = history->du_etime;
                (void) strftime(buf, sizeof (buf), "%T",
                    localtime(&time));
                state->us_first = B_FALSE;
                (void) printf("%s", buf);
            }
            bw = (double)history->du_bandwidth/1000;
            (void) printf(" %.2f", bw);
            if (history->du_last) {
                (void) printf("\n");
                state->us_first = B_TRUE;
            }
        }
        return (DLADM_STATUS_OK);
    }

    bzero(&ubuf, sizeof (ubuf));

    (void) snprintf(ubuf.history_l_flow, sizeof (ubuf.history_l_flow), "%s",
        history->du_name);
    time = history->du_stime;
    (void) strftime(buf, sizeof (buf), "%T", localtime(&time));
    (void) snprintf(ubuf.history_l_stime, sizeof (ubuf.history_l_stime),
        "%s", buf);
    time = history->du_etime;
    (void) strftime(buf, sizeof (buf), "%T", localtime(&time));
    (void) snprintf(ubuf.history_l_etime, sizeof (ubuf.history_l_etime),
        "%s", buf);
    (void) snprintf(ubuf.history_l_rbytes, sizeof (ubuf.history_l_rbytes),
        "%llu", history->du_rbytes);
    (void) snprintf(ubuf.history_l_obytes, sizeof (ubuf.history_l_obytes),
        "%llu", history->du_obytes);
    (void) snprintf(ubuf.history_l_bandwidth,
        sizeof (ubuf.history_l_bandwidth), "%s Mbps",
        dladm_bw2str(history->du_bandwidth, buf));

    ofmt_print(state->us_ofmt, (void *)&ubuf);
    return (DLADM_STATUS_OK);
}

static int
show_history_res(dladm_usage_t *history, void *arg)
{
    show_history_state_t    *state = (show_history_state_t *)arg;
    char            buf[DLADM_STRSIZE];
    history_fields_buf_t    ubuf;
    dladm_flow_attr_t   attr;
    dladm_status_t      status;

    /*
     * Only show historical information for existing flows unless '-a'
     * is specified.
     */
    if (!state->us_showall && ((status = dladm_flow_info(handle,
        history->du_name, &attr)) != DLADM_STATUS_OK)) {
        return (status);
    }

    bzero(&ubuf, sizeof (ubuf));

    (void) snprintf(ubuf.history_flow, sizeof (ubuf.history_flow), "%s",
        history->du_name);
    (void) snprintf(ubuf.history_duration, sizeof (ubuf.history_duration),
        "%llu", history->du_duration);
    (void) snprintf(ubuf.history_ipackets, sizeof (ubuf.history_ipackets),
        "%llu", history->du_ipackets);
    (void) snprintf(ubuf.history_rbytes, sizeof (ubuf.history_rbytes),
        "%llu", history->du_rbytes);
    (void) snprintf(ubuf.history_opackets, sizeof (ubuf.history_opackets),
        "%llu", history->du_opackets);
    (void) snprintf(ubuf.history_obytes, sizeof (ubuf.history_obytes),
        "%llu", history->du_obytes);
    (void) snprintf(ubuf.history_bandwidth, sizeof (ubuf.history_bandwidth),
        "%s Mbps", dladm_bw2str(history->du_bandwidth, buf));

    ofmt_print(state->us_ofmt, (void *)&ubuf);

    return (DLADM_STATUS_OK);
}

static boolean_t
valid_formatspec(char *formatspec_str)
{
    return (strcmp(formatspec_str, "gnuplot") == 0);
}

/* ARGSUSED */
static void
do_show_history(int argc, char *argv[])
{
    char            *file = NULL;
    int         opt;
    dladm_status_t      status;
    boolean_t       d_arg = B_FALSE;
    char            *stime = NULL;
    char            *etime = NULL;
    char            *resource = NULL;
    show_history_state_t    state;
    boolean_t       o_arg = B_FALSE;
    boolean_t       F_arg = B_FALSE;
    char            *fields_str = NULL;
    char            *formatspec_str = NULL;
    char            *all_fields =
        "flow,duration,ipackets,rbytes,opackets,obytes,bandwidth";
    char            *all_l_fields =
        "flow,start,end,rbytes,obytes,bandwidth";
    ofmt_handle_t       ofmt;
    ofmt_status_t       oferr;
    uint_t          ofmtflags = 0;

    bzero(&state, sizeof (show_history_state_t));
    state.us_parsable = B_FALSE;
    state.us_printheader = B_FALSE;
    state.us_plot = B_FALSE;
    state.us_first = B_TRUE;

    while ((opt = getopt(argc, argv, "das:e:o:f:F:")) != -1) {
        switch (opt) {
        case 'd':
            d_arg = B_TRUE;
            break;
        case 'a':
            state.us_showall = B_TRUE;
            break;
        case 'f':
            file = optarg;
            break;
        case 's':
            stime = optarg;
            break;
        case 'e':
            etime = optarg;
            break;
        case 'o':
            o_arg = B_TRUE;
            fields_str = optarg;
            break;
        case 'F':
            state.us_plot = F_arg = B_TRUE;
            formatspec_str = optarg;
            break;
        default:
            die_opterr(optopt, opt, usage_ermsg);
        }
    }

    if (file == NULL)
        die("-h requires a file");

    if (optind == (argc-1)) {
        dladm_flow_attr_t   attr;

        resource = argv[optind];
        if (!state.us_showall &&
            dladm_flow_info(handle, resource, &attr) !=
            DLADM_STATUS_OK) {
            die("invalid flow: '%s'", resource);
        }
    }

    if (state.us_parsable)
        ofmtflags |= OFMT_PARSABLE;
    if (resource == NULL && stime == NULL && etime == NULL) {
        if (!o_arg || (o_arg && strcasecmp(fields_str, "all") == 0))
            fields_str = all_fields;
        oferr = ofmt_open(fields_str, history_fields, ofmtflags,
            0, &ofmt);
    } else {
        if (!o_arg || (o_arg && strcasecmp(fields_str, "all") == 0))
            fields_str = all_l_fields;
        oferr = ofmt_open(fields_str, history_l_fields, ofmtflags,
            0, &ofmt);
    }

    flowstat_ofmt_check(oferr, state.us_parsable, ofmt);
    state.us_ofmt = ofmt;

    if (F_arg && d_arg)
        die("incompatible -d and -F options");

    if (F_arg && !valid_formatspec(formatspec_str))
        die("Format specifier %s not supported", formatspec_str);

    if (d_arg) {
        /* Print log dates */
        status = dladm_usage_dates(show_history_date,
            DLADM_LOGTYPE_FLOW, file, resource, &state);
    } else if (resource == NULL && stime == NULL && etime == NULL &&
        !F_arg) {
        /* Print summary */
        status = dladm_usage_summary(show_history_res,
            DLADM_LOGTYPE_FLOW, file, &state);
    } else if (resource != NULL) {
        /* Print log entries for named resource */
        status = dladm_walk_usage_res(show_history_time,
            DLADM_LOGTYPE_FLOW, file, resource, stime, etime, &state);
    } else {
        /* Print time and information for each flow */
        status = dladm_walk_usage_time(show_history_time,
            DLADM_LOGTYPE_FLOW, file, stime, etime, &state);
    }

    ofmt_close(ofmt);
    if (status != DLADM_STATUS_OK)
        die_dlerr(status, "-h");
    dladm_close(handle);
}

static void
warn(const char *format, ...)
{
    va_list alist;

    format = gettext(format);
    (void) fprintf(stderr, "%s: warning: ", progname);

    va_start(alist, format);
    (void) vfprintf(stderr, format, alist);
    va_end(alist);

    (void) putc('\n', stderr);
}

/* PRINTFLIKE1 */
static void
die(const char *format, ...)
{
    va_list alist;

    format = gettext(format);
    (void) fprintf(stderr, "%s: ", progname);

    va_start(alist, format);
    (void) vfprintf(stderr, format, alist);
    va_end(alist);

    (void) putc('\n', stderr);

    /* close dladm handle if it was opened */
    if (handle != NULL)
        dladm_close(handle);

    exit(EXIT_FAILURE);
}

static void
die_optdup(int opt)
{
    die("the option -%c cannot be specified more than once", opt);
}

static void
die_opterr(int opt, int opterr, const char *usage)
{
    switch (opterr) {
    case ':':
        die("option '-%c' requires a value\nusage: %s", opt,
            gettext(usage));
        break;
    case '?':
    default:
        die("unrecognized option '-%c'\nusage: %s", opt,
            gettext(usage));
        break;
    }
}

/* PRINTFLIKE2 */
static void
die_dlerr(dladm_status_t err, const char *format, ...)
{
    va_list alist;
    char    errmsg[DLADM_STRSIZE];

    format = gettext(format);
    (void) fprintf(stderr, "%s: ", progname);

    va_start(alist, format);
    (void) vfprintf(stderr, format, alist);
    va_end(alist);
    (void) fprintf(stderr, ": %s\n", dladm_status2str(err, errmsg));

    /* close dladm handle if it was opened */
    if (handle != NULL)
        dladm_close(handle);

    exit(EXIT_FAILURE);
}


/*
 * default output callback function that, when invoked from dladm_print_output,
 * prints string which is offset by of_arg->ofmt_id within buf.
 */
static boolean_t
print_default_cb(ofmt_arg_t *of_arg, char *buf, uint_t bufsize)
{
    char *value;

    value = (char *)of_arg->ofmt_cbarg + of_arg->ofmt_id;
    (void) strlcpy(buf, value, bufsize);
    return (B_TRUE);
}

static void
flowstat_ofmt_check(ofmt_status_t oferr, boolean_t parsable,
    ofmt_handle_t ofmt)
{
    char buf[OFMT_BUFSIZE];

    if (oferr == OFMT_SUCCESS)
        return;
    (void) ofmt_strerror(ofmt, oferr, buf, sizeof (buf));
    /*
     * All errors are considered fatal in parsable mode.
     * NOMEM 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) {
        ofmt_close(ofmt);
        die(buf);
    } else {
        warn(buf);
    }
}