/*
 * 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;
	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);
}