cmd/vrrpadm/vrrpadm.c

	vrrpadm.c revision 1cb875ae88fb9463b368e725c2444776595895cb
/*
 * 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 2009 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

#include <sys/types.h>
#include <sys/varargs.h>
#include <getopt.h>
#include <stdio.h>
#include <stdlib.h>
#include <strings.h>
#include <errno.h>
#include <locale.h>
#include <libintl.h>
#include <libvrrpadm.h>
#include <ofmt.h>

static vrrp_handle_t    vrrp_vh = NULL;
typedef void cmd_func_t(int, char *[], const char *);

static cmd_func_t do_create, do_delete, do_enable, do_disable,
    do_modify, do_show;

typedef struct {
    char        *c_name;
    cmd_func_t  *c_fn;
    const char  *c_usage;
} cmd_t;

static cmd_t cmds[] = {
    { "create-router",  do_create,
        "-V <vrid> -l <link> -A {inet | inet6} [-p <priority>] "
        "[-i <adv_interval>] [-o <flags>] <router_name>" },
    { "delete-router",  do_delete,  "<router_name>"     },
    { "enable-router",  do_enable,  "<router_name>"     },
    { "disable-router", do_disable, "<router_name>"     },
    { "modify-router",  do_modify,
        "[-p <priority>] [-i <adv_interval>] [-o <flags>] <router_name>" },
    { "show-router",    do_show,
        "[-P | -x] [-o field[,...]] [-p] [<router_name>]"   }
};

static const struct option lopts[] = {
    {"vrid",        required_argument,  0, 'V'},
    {"link",        required_argument,  0, 'l'},
    {"address_family",  required_argument,  0, 'A'},
    {"priority",        required_argument,  0, 'p'},
    {"adv_interval",    required_argument,  0, 'i'},
    {"flags",       required_argument,  0, 'o'},
    { 0, 0, 0, 0 }
};

static const struct option l_show_opts[] = {
    {"peer",    no_argument,        0, 'P'},
    {"parsable",    no_argument,        0, 'p'},
    {"extended",    no_argument,        0, 'x'},
    {"output",  required_argument,  0, 'o'},
    { 0, 0, 0, 0 }
};

static ofmt_cb_t sfunc_vrrp_conf;

/*
 * structures for 'dladm show-link -s' (print statistics)
 */
enum {
    ROUTER_NAME,
    ROUTER_VRID,
    ROUTER_LINK,
    ROUTER_VNIC,
    ROUTER_AF,
    ROUTER_PRIO,
    ROUTER_ADV_INTV,
    ROUTER_MODE,
    ROUTER_STATE,
    ROUTER_PRV_STAT,
    ROUTER_STAT_LAST,
    ROUTER_PEER,
    ROUTER_P_PRIO,
    ROUTER_P_INTV,
    ROUTER_P_ADV_LAST,
    ROUTER_M_DOWN_INTV,
    ROUTER_PRIMARY_IP,
    ROUTER_VIRTUAL_IPS,
    ROUTER_VIP_CNT
};

/*
 * structures for 'vrrpadm show-router'
 */
static const ofmt_field_t show_print_fields[] = {
/* name,    field width,    index,          callback */
{ "NAME",       8,  ROUTER_NAME,        sfunc_vrrp_conf },
{ "VRID",       5,  ROUTER_VRID,        sfunc_vrrp_conf },
{ "LINK",       8,  ROUTER_LINK,        sfunc_vrrp_conf },
{ "VNIC",       8,  ROUTER_VNIC,        sfunc_vrrp_conf },
{ "AF",         5,  ROUTER_AF,      sfunc_vrrp_conf },
{ "PRIO",       5,  ROUTER_PRIO,        sfunc_vrrp_conf },
{ "ADV_INTV",       9,  ROUTER_ADV_INTV,    sfunc_vrrp_conf },
{ "MODE",       6,  ROUTER_MODE,        sfunc_vrrp_conf },
{ "STATE",      6,  ROUTER_STATE,       sfunc_vrrp_conf },
{ "PRV_STAT",       9,  ROUTER_PRV_STAT,    sfunc_vrrp_conf },
{ "STAT_LAST",      10, ROUTER_STAT_LAST,   sfunc_vrrp_conf },
{ "PEER",       20, ROUTER_PEER,        sfunc_vrrp_conf },
{ "P_PRIO",     7,  ROUTER_P_PRIO,      sfunc_vrrp_conf },
{ "P_INTV",     9,  ROUTER_P_INTV,      sfunc_vrrp_conf },
{ "P_ADV_LAST",     11, ROUTER_P_ADV_LAST,  sfunc_vrrp_conf },
{ "M_DOWN_INTV",    12, ROUTER_M_DOWN_INTV, sfunc_vrrp_conf },
{ "PRIMARY_IP",     20, ROUTER_PRIMARY_IP,  sfunc_vrrp_conf },
{ "VIRTUAL_IPS",    40, ROUTER_VIRTUAL_IPS, sfunc_vrrp_conf },
{ "VIP_CNT",        7,  ROUTER_VIP_CNT,     sfunc_vrrp_conf },
{ NULL,         0,  0,          NULL}}
;

static vrrp_err_t do_show_router(const char *, ofmt_handle_t);
static int str2opt(char *opts, uint32_t *, boolean_t *, boolean_t *);
static char *timeval_since_str(int, char *, size_t);

static void usage();
static void warn(const char *, ...);
static void err_exit(const char *, ...);
static void opterr_exit(int, int, const char *);

int
main(int argc, char *argv[])
{
    vrrp_err_t  err;
    int     i;
    cmd_t       *cp;

    (void) setlocale(LC_ALL, "");
    (void) textdomain(TEXT_DOMAIN);

    if (argv[1] == NULL)
        usage();

    if ((err = vrrp_open(&vrrp_vh)) != VRRP_SUCCESS)
        err_exit("operation failed: %s", vrrp_err2str(err));

    for (i = 0; i < sizeof (cmds) / sizeof (cmd_t); i++) {
        cp = &cmds[i];
        if (strcmp(argv[1], cp->c_name) == 0) {
            cp->c_fn(argc - 1, &argv[1], cp->c_usage);
            vrrp_close(vrrp_vh);
            return (EXIT_SUCCESS);
        }
    }

    usage();
    return (EXIT_FAILURE);
}

static void
do_create(int argc, char *argv[], const char *usage)
{
    vrrp_vr_conf_t      conf;
    int         c;
    uint32_t        create_mask = 0, mask;
    char            *endp;
    vrrp_err_t      err;

    /*
     * default value
     */
    bzero(&conf, sizeof (vrrp_vr_conf_t));
    conf.vvc_vrid = VRRP_VRID_NONE;
    conf.vvc_af = AF_UNSPEC;
    conf.vvc_pri = VRRP_PRI_DEFAULT;
    conf.vvc_adver_int = VRRP_MAX_ADVER_INT_DFLT;
    conf.vvc_preempt = B_TRUE;
    conf.vvc_accept = B_TRUE;
    conf.vvc_enabled = B_TRUE;

    while ((c = getopt_long(argc, argv, ":V:l:p:i:o:A:f", lopts,
        NULL)) != EOF) {
        switch (c) {
        case 'l':
            if (strlcpy(conf.vvc_link, optarg,
                sizeof (conf.vvc_link)) >=
                sizeof (conf.vvc_link)) {
                err_exit("invalid data-link name %s", optarg);
            }
            break;
        case 'i':
            if (create_mask & VRRP_CONF_INTERVAL)
                err_exit("duplicate '-i' option");

            create_mask |= VRRP_CONF_INTERVAL;
            conf.vvc_adver_int = (uint32_t)strtol(optarg, &endp, 0);
            if ((*endp) != '\0' ||
                conf.vvc_adver_int < VRRP_MAX_ADVER_INT_MIN ||
                conf.vvc_adver_int > VRRP_MAX_ADVER_INT_MAX ||
                (conf.vvc_adver_int == 0 && errno != 0)) {
                err_exit("invalid advertisement interval");
            }
            break;
        case 'p':
            if (create_mask & VRRP_CONF_PRIORITY)
                err_exit("duplicate '-p' option");

            create_mask |= VRRP_CONF_PRIORITY;
            conf.vvc_pri = strtol(optarg, &endp, 0);
            if ((*endp) != '\0' || conf.vvc_pri < VRRP_PRI_MIN ||
                conf.vvc_pri > VRRP_PRI_OWNER ||
                (conf.vvc_pri == 0 && errno != 0)) {
                err_exit("invalid priority");
            }
            break;
        case 'o':
            mask = 0;
            if (str2opt(optarg, &mask,
                &conf.vvc_preempt, &conf.vvc_accept) != 0) {
                err_exit("invalid options: %s", optarg);
            }
            if (mask & create_mask & VRRP_CONF_PREEMPT)
                err_exit("duplicate '-o preempt' option");
            else if (mask & create_mask & VRRP_CONF_ACCEPT)
                err_exit("duplicate '-o accept' option");
            create_mask |= mask;
            break;
        case 'V':
            if (conf.vvc_vrid != VRRP_VRID_NONE)
                err_exit("duplicate '-V' option");

            conf.vvc_vrid = strtol(optarg, &endp, 0);
            if ((*endp) != '\0' || conf.vvc_vrid < VRRP_VRID_MIN ||
                conf.vvc_vrid > VRRP_VRID_MAX ||
                (conf.vvc_vrid == 0 && errno != 0)) {
                err_exit("invalid VRID");
            }
            break;
        case 'A':
            if (conf.vvc_af != AF_UNSPEC)
                err_exit("duplicate '-A' option");

            if (strcmp(optarg, "inet") == 0)
                conf.vvc_af = AF_INET;
            else if (strcmp(optarg, "inet6") == 0)
                conf.vvc_af = AF_INET6;
            else
                err_exit("invalid address family");
            break;
        default:
            opterr_exit(optopt, c, usage);
        }
    }

    if (argc - optind > 1)
        err_exit("usage: %s", gettext(usage));

    if (optind != argc - 1)
        err_exit("VRRP name not specified");

    if (strlcpy(conf.vvc_name, argv[optind],
        sizeof (conf.vvc_name)) >= sizeof (conf.vvc_name)) {
        err_exit("Invalid router name %s", argv[optind]);
    }

    if (conf.vvc_vrid == VRRP_VRID_NONE)
        err_exit("VRID not specified");

    if (conf.vvc_af == AF_UNSPEC)
        err_exit("address family not specified");

    if (strlen(conf.vvc_link) == 0)
        err_exit("link name not specified");

    if (!conf.vvc_accept && conf.vvc_pri == VRRP_PRI_OWNER)
        err_exit("accept_mode must be true for virtual IP owner");

done:
    if ((err = vrrp_create(vrrp_vh, &conf)) == VRRP_SUCCESS)
        return;

    err_exit("create-router failed: %s", vrrp_err2str(err));
}

static void
do_delete(int argc, char *argv[], const char *use)
{
    vrrp_err_t  err;

    if (argc != 2)
        err_exit("usage: %s", gettext(use));

    if ((err = vrrp_delete(vrrp_vh, argv[1])) != VRRP_SUCCESS)
        err_exit("delete-router failed: %s", vrrp_err2str(err));
}

static void
do_enable(int argc, char *argv[], const char *use)
{
    vrrp_err_t  err;

    if (argc != 2)
        err_exit("usage: %s", gettext(use));

    if ((err = vrrp_enable(vrrp_vh, argv[1])) != VRRP_SUCCESS)
        err_exit("enable-router failed: %s", vrrp_err2str(err));
}

static void
do_disable(int argc, char *argv[], const char *use)
{
    vrrp_err_t  err;

    if (argc != 2)
        err_exit("usage: %s", gettext(use));

    if ((err = vrrp_disable(vrrp_vh, argv[1])) != VRRP_SUCCESS)
        err_exit("disable-router failed: %s", vrrp_err2str(err));
}

static void
do_modify(int argc, char *argv[], const char *use)
{
    vrrp_vr_conf_t  conf;
    vrrp_err_t  err;
    uint32_t    modify_mask = 0, mask;
    char        *endp;
    int     c;

    while ((c = getopt_long(argc, argv, ":i:p:o:", lopts, NULL)) != EOF) {
        switch (c) {
        case 'i':
            if (modify_mask & VRRP_CONF_INTERVAL)
                err_exit("duplicate '-i' option");

            modify_mask |= VRRP_CONF_INTERVAL;
            conf.vvc_adver_int = (uint32_t)strtol(optarg, &endp, 0);
            if ((*endp) != '\0' ||
                conf.vvc_adver_int < VRRP_MAX_ADVER_INT_MIN ||
                conf.vvc_adver_int > VRRP_MAX_ADVER_INT_MAX ||
                (conf.vvc_adver_int == 0 && errno != 0)) {
                err_exit("invalid advertisement interval");
            }
            break;
        case 'o':
            mask = 0;
            if (str2opt(optarg, &mask, &conf.vvc_preempt,
                &conf.vvc_accept) != 0) {
                err_exit("Invalid options");
            }
            if (mask & modify_mask & VRRP_CONF_PREEMPT)
                err_exit("duplicate '-o preempt' option");
            else if (mask & modify_mask & VRRP_CONF_ACCEPT)
                err_exit("duplicate '-o accept' option");
            modify_mask |= mask;
            break;
        case 'p':
            if (modify_mask & VRRP_CONF_PRIORITY)
                err_exit("duplicate '-p' option");

            modify_mask |= VRRP_CONF_PRIORITY;
            conf.vvc_pri = strtol(optarg, &endp, 0);
            if ((*endp) != '\0' || conf.vvc_pri < VRRP_PRI_MIN ||
                conf.vvc_pri > VRRP_PRI_OWNER ||
                (conf.vvc_pri == 0 && errno != 0)) {
                err_exit("invalid priority");
            }
            break;
        default:
            opterr_exit(optopt, c, use);
        }
    }

    if (argc - optind > 1)
        err_exit("usage: %s", gettext(use));

    if (optind != argc - 1)
        err_exit("VRRP name not specified.");

    if (strlcpy(conf.vvc_name, argv[optind], sizeof (conf.vvc_name)) >=
        sizeof (conf.vvc_name)) {
        err_exit("invalid router name %s", argv[optind]);
    }

    if ((modify_mask & VRRP_CONF_ACCEPT) && !conf.vvc_accept &&
        (modify_mask & VRRP_CONF_PRIORITY) &&
        conf.vvc_pri == VRRP_PRI_OWNER) {
        err_exit("accept_mode must be true for virtual IP owner");
    }

    if (modify_mask == 0)
        usage();

    err = vrrp_modify(vrrp_vh, &conf, modify_mask);
    if (err != VRRP_SUCCESS)
        err_exit("modify-router failed: %s", vrrp_err2str(err));
}

/*
 * 'show-router' one VRRP router.
 */
static vrrp_err_t
do_show_router(const char *vn, ofmt_handle_t ofmt)
{
    vrrp_queryinfo_t    *vq;
    vrrp_err_t      err;

    if ((err = vrrp_query(vrrp_vh, vn, &vq)) != VRRP_SUCCESS)
        return (err);

    ofmt_print(ofmt, vq);
    free(vq);
    return (VRRP_SUCCESS);
}

static void
do_show(int argc, char *argv[], const char *use)
{
    int         c;
    char            *fields_str = NULL;
    char            *names = NULL, *router;
    uint32_t        i, in_cnt = 0, out_cnt;
    ofmt_status_t       oferr;
    ofmt_handle_t       ofmt;
    uint_t          ofmt_flags = 0;
    vrrp_err_t      err = VRRP_SUCCESS;
    boolean_t       P_opt, x_opt;

    static char     *dft_fields_str =
        "NAME,VRID,LINK,AF,PRIO,ADV_INTV,MODE,STATE,VNIC";
    static char     *ext_fields_str =
        "NAME,STATE,PRV_STAT,STAT_LAST,VNIC,PRIMARY_IP,VIRTUAL_IPS";
    static char     *peer_fields_str =
        "NAME,PEER,P_PRIO,P_INTV,P_ADV_LAST,M_DOWN_INTV";
    /*
     * If parsable output is requested, add VIP_CNT into the output
     * for extended output. It is not needed for human-readable
     * output as it is obvious from the VIRTUAL_IPS list.
     */
    static char     *ext_parsable_fields_str =
        "NAME,STATE,PRV_STAT,STAT_LAST,VNIC,PRIMARY_IP,VIP_CNT,"
        "VIRTUAL_IPS";

    P_opt = x_opt = B_FALSE;
    fields_str = dft_fields_str;
    while ((c = getopt_long(argc, argv, ":Pxpo:", l_show_opts,
        NULL)) != EOF) {
        switch (c) {
        case 'o':
            fields_str = optarg;
            break;
        case 'p':
            ofmt_flags |= OFMT_PARSABLE;
            break;
        case 'P':
            P_opt = B_TRUE;
            fields_str = peer_fields_str;
            break;
        case 'x':
            x_opt = B_TRUE;
            fields_str = ext_fields_str;
            break;
        default:
            opterr_exit(optopt, c, use);
        }
    }

    if (x_opt && P_opt)
        err_exit("incompatible -P and -x options");

    /*
     * If parsable output is requested, add VIP_CNT into the output
     * for extended output.
     */
    if ((ofmt_flags & OFMT_PARSABLE) && (fields_str == ext_fields_str))
        fields_str = ext_parsable_fields_str;

    if ((oferr = ofmt_open(fields_str, show_print_fields, ofmt_flags,
        0, &ofmt)) != OFMT_SUCCESS) {
        char buf[OFMT_BUFSIZE];

        /*
         * If some fields were badly formed in human-friendly mode, we
         * emit a warning and continue.  Otherwise exit immediately.
         */
        (void) ofmt_strerror(ofmt, oferr, buf, sizeof (buf));
        if (oferr != OFMT_EBADFIELDS || (ofmt_flags & OFMT_PARSABLE)) {
            ofmt_close(ofmt);
            err_exit(buf);
        } else {
            warn(buf);
        }
    }

    /* Show one router */
    if (optind == argc - 1) {
        err = do_show_router(argv[optind], ofmt);
        goto done;
    }

    /*
     * Show all routers. First set in_cnt to 0 to find out the number
     * of vrrp routers.
     */
again:
    if ((in_cnt != 0) && (names = malloc(in_cnt * VRRP_NAME_MAX)) == NULL) {
        err = VRRP_ENOMEM;
        goto done;
    }

    out_cnt = in_cnt;
    if ((err = vrrp_list(vrrp_vh, VRRP_VRID_NONE, NULL, AF_UNSPEC,
        &out_cnt, names)) != VRRP_SUCCESS) {
        free(names);
        goto done;
    }

    /*
     * The VRRP routers has been changed between two vrrp_list()
     * calls, try again.
     */
    if (out_cnt > in_cnt) {
        in_cnt = out_cnt;
        free(names);
        goto again;
    }

    /*
     * Each VRRP router name is separated by '\0`
     */
    router = names;
    for (i = 0; i < in_cnt; i++) {
        (void) do_show_router(router, ofmt);
        router += strlen(router) + 1;
    }

    free(names);

done:
    ofmt_close(ofmt);

    if (err != VRRP_SUCCESS)
        err_exit(vrrp_err2str(err));
}

/*
 * Callback function to print fields of the configuration information.
 */
static boolean_t
sfunc_vrrp_conf(ofmt_arg_t *ofmtarg, char *buf, uint_t bufsize)
{
    vrrp_queryinfo_t    *qinfo = ofmtarg->ofmt_cbarg;
    uint_t          ofmtid = ofmtarg->ofmt_id;
    vrrp_vr_conf_t      *conf = &qinfo->show_vi;
    vrrp_stateinfo_t    *sinfo = &qinfo->show_vs;
    vrrp_peer_t     *peer = &qinfo->show_vp;
    vrrp_timerinfo_t    *tinfo = &qinfo->show_vt;
    vrrp_addrinfo_t     *ainfo = &qinfo->show_va;

    switch (ofmtid) {
    case ROUTER_NAME:
        (void) snprintf(buf, bufsize, "%s", conf->vvc_name);
        break;
    case ROUTER_VRID:
        (void) snprintf(buf, bufsize, "%d", conf->vvc_vrid);
        break;
    case ROUTER_LINK:
        (void) snprintf(buf, bufsize, "%s", conf->vvc_link);
        break;
    case ROUTER_AF:
        (void) snprintf(buf, bufsize, "IPv%d",
            conf->vvc_af == AF_INET ? 4 : 6);
        break;
    case ROUTER_PRIO:
        (void) snprintf(buf, bufsize, "%d", conf->vvc_pri);
        break;
    case ROUTER_ADV_INTV:
        (void) snprintf(buf, bufsize, "%d", conf->vvc_adver_int);
        break;
    case ROUTER_MODE:
        (void) strlcpy(buf, "-----", bufsize);
        if (conf->vvc_enabled)
            buf[0] = 'e';
        if (conf->vvc_pri == VRRP_PRI_OWNER)
            buf[1] = 'o';
        if (conf->vvc_preempt)
            buf[2] = 'p';
        if (conf->vvc_accept)
            buf[3] = 'a';
        break;
    case ROUTER_STATE:
        (void) snprintf(buf, bufsize, "%s",
            vrrp_state2str(sinfo->vs_state));
        break;
    case ROUTER_PRV_STAT:
        (void) snprintf(buf, bufsize, "%s",
            vrrp_state2str(sinfo->vs_prev_state));
        break;
    case ROUTER_STAT_LAST:
        (void) timeval_since_str(tinfo->vt_since_last_tran, buf,
            bufsize);
        break;
    case ROUTER_PEER:
        /* LINTED E_CONSTANT_CONDITION */
        VRRPADDR2STR(conf->vvc_af, &peer->vp_addr,
            buf, bufsize, B_FALSE);
        break;
    case ROUTER_P_PRIO:
        (void) snprintf(buf, bufsize, "%d", peer->vp_prio);
        break;
    case ROUTER_P_INTV:
        (void) snprintf(buf, bufsize, "%d", peer->vp_adver_int);
        break;
    case ROUTER_P_ADV_LAST:
        (void) timeval_since_str(tinfo->vt_since_last_adv, buf,
            bufsize);
        break;
    case ROUTER_M_DOWN_INTV:
        (void) snprintf(buf, bufsize, "%d", tinfo->vt_master_down_intv);
        break;
    case ROUTER_VNIC:
        (void) snprintf(buf, bufsize, "%s",
            strlen(ainfo->va_vnic) == 0 ? "--" : ainfo->va_vnic);
        break;
    case ROUTER_PRIMARY_IP:
        /* LINTED E_CONSTANT_CONDITION */
        VRRPADDR2STR(conf->vvc_af, &ainfo->va_primary,
            buf, bufsize, B_FALSE);
        break;
    case ROUTER_VIRTUAL_IPS: {
        uint32_t i;

        for (i = 0; i < ainfo->va_vipcnt; i++) {
            /* LINTED E_CONSTANT_CONDITION */
            VRRPADDR2STR(conf->vvc_af, &(ainfo->va_vips[i]),
                buf, bufsize, B_TRUE);
            if (i != ainfo->va_vipcnt - 1)
                (void) strlcat(buf, ",", bufsize);
        }
        break;
    }
    case ROUTER_VIP_CNT:
        (void) snprintf(buf, bufsize, "%d", ainfo->va_vipcnt);
        break;
    default:
        return (B_FALSE);
    }

    return (B_TRUE);
}

static void
usage()
{
    int i;
    cmd_t   *cp;

    (void) fprintf(stderr, "%s",
        gettext("usage:  vrrpadm <sub-command> <args> ...\n"));

    for (i = 0; i < sizeof (cmds) / sizeof (cmd_t); i++) {
        cp = &cmds[i];
        if (cp->c_usage != NULL)
            (void) fprintf(stderr, "          %-10s %s\n",
                gettext(cp->c_name), gettext(cp->c_usage));
    }

    vrrp_close(vrrp_vh);
    exit(EXIT_FAILURE);
}

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

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

    va_start(alist, format);
    (void) vfprintf(stderr, format, alist);
    va_end(alist);
    (void) putc('\n', stderr);
}

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

    format = gettext(format);
    va_start(alist, format);
    (void) vfprintf(stderr, format, alist);
    va_end(alist);
    (void) putc('\n', stderr);
    vrrp_close(vrrp_vh);
    exit(EXIT_FAILURE);
}

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

static char *
timeval_since_str(int mill, char *str, size_t len)
{
    int sec, msec, min;

    msec = mill % 1000;
    sec = mill / 1000;
    min = sec > 60 ? sec / 60 : 0;
    sec %= 60;

    if (min > 0)
        (void) snprintf(str, len, "%4dm%2ds", min, sec);
    else
        (void) snprintf(str, len, "%4d.%03ds", sec, msec);

    return (str);
}

/*
 * Parses options string. The values of the two options will be returned
 * by 'preempt' and 'accept', and the mask 'modify_mask' will be updated
 * accordingly.
 *
 * Returns 0 on success, errno on failures.
 *
 * Used by do_create() and do_modify().
 *
 * Note that "opts" could be modified internally in this function.
 */
static int
str2opt(char *opts, uint32_t *modify_mask, boolean_t *preempt,
    boolean_t *accept)
{
    char        *value;
    int     opt;
    uint32_t    mask = 0;
    static enum { o_preempt = 0, o_un_preempt, o_accept, o_no_accept };
    static char *myopts[] = {
        "preempt",
        "un_preempt",
        "accept",
        "no_accept",
        NULL
    };

    while (*opts != '\0') {
        switch ((opt = getsubopt(&opts, myopts, &value))) {
        case o_preempt:
        case o_un_preempt:
            if (mask & VRRP_CONF_PREEMPT)
                return (EINVAL);

            mask |= VRRP_CONF_PREEMPT;
            *preempt = (opt == o_preempt);
            break;
        case o_accept:
        case o_no_accept:
            if (mask & VRRP_CONF_ACCEPT)
                return (EINVAL);

            mask |= VRRP_CONF_ACCEPT;
            *accept = (opt == o_accept);
            break;
        default:
            return (EINVAL);
        }
    }

    *modify_mask |= mask;
    return (0);
}