/* ARGSUSED */
static ilb_status_t
ilbadm_list_sg_srv(ilb_handle_t h, ilb_server_data_t *sd, const char *sgname,
void *arg)
{
char ip_str[2*INET6_ADDRSTRLEN + 3] = "";
char port_str[INET6_ADDRSTRLEN];
list_arg_t *larg = (list_arg_t *)arg;
ofmt_status_t oerr;
int oflags = 0;
int ocols = MAXCOLS;
int h_minport, h_maxport;
static ofmt_handle_t oh = (ofmt_handle_t)NULL;
ofmt_field_t *ofp;
if (larg->o_str != NULL) {
if (oh == NULL) {
if (sd->sd_addr.ia_af == AF_INET)
ofp = sgfields_v6;
else
ofp = sgfields_v4;
if (larg->flags & ILBADM_LIST_PARSE)
oflags |= OFMT_PARSABLE;
oerr = ofmt_open(larg->o_str, ofp, oflags, ocols, &oh);
if (oerr != OFMT_SUCCESS) {
char e[80];
ilbadm_err(gettext("ofmt_open failed: %s"),
ofmt_strerror(oh, oerr, e, sizeof (e)));
return (ILB_STATUS_GENERIC);
}
larg->oh = oh;
}
(void) i_list_sg_srv_ofmt((char *)sgname, sd, arg);
return (ILB_STATUS_OK);
}
ip2str(&sd->sd_addr, ip_str, sizeof (ip_str), 0);
h_minport = ntohs(sd->sd_minport);
h_maxport = ntohs(sd->sd_maxport);
if (h_minport == 0)
*port_str = '\0';
else if (h_maxport > h_minport)
(void) sprintf(port_str, ":%d-%d", h_minport, h_maxport);
else
(void) sprintf(port_str, ":%d", h_minport);
(void) printf("%s: id:%s %s%s\n", sgname,
sd->sd_srvID?sd->sd_srvID:"(null)", ip_str, port_str);
return (ILB_STATUS_OK);
}
/*
* Output hc result of a specified rule or all rules.
*/
ilbadm_status_t
ilbadm_show_hc_result(int argc, char *argv[])
{
ilb_handle_t h = ILB_INVALID_HANDLE;
ilb_status_t rclib = ILB_STATUS_OK;
int i;
ofmt_handle_t ofmt_h;
ofmt_status_t ofmt_ret;
/* ilbadm show-hc-result [rule-name] */
if (argc < 1) {
ilbadm_err(gettext("usage: ilbadm show-hc-result"
" [rule-name]"));
return (ILBADM_LIBERR);
}
if ((ofmt_ret = ofmt_open("all", hc_results, 0, SHOW_HC_COLS,
&ofmt_h)) != OFMT_SUCCESS) {
char err_buf[SHOW_HC_COLS];
ilbadm_err(gettext("ofmt_open failed: %s"),
ofmt_strerror(ofmt_h, ofmt_ret, err_buf, SHOW_HC_COLS));
return (ILBADM_LIBERR);
}
rclib = ilb_open(&h);
if (rclib != ILB_STATUS_OK)
goto out;
/* If no rule name is given, show results for all rules. */
if (argc == 1) {
rclib = ilb_walk_hc_srvs(h, ilbadm_print_hc_result, NULL,
ofmt_h);
} else {
for (i = 1; i < argc; i++) {
rclib = ilb_walk_hc_srvs(h, ilbadm_print_hc_result,
argv[i], ofmt_h);
if (rclib != ILB_STATUS_OK)
break;
}
}
out:
ofmt_close(ofmt_h);
if (h != ILB_INVALID_HANDLE)
(void) ilb_close(h);
if (rclib != ILB_STATUS_OK) {
ilbadm_err(ilb_errstr(rclib));
return (ILBADM_LIBERR);
}
return (ILBADM_OK);
}
/* ARGSUSED */
static void
flow_stats(const char *flow, datalink_id_t linkid, uint_t interval,
char *fields_str, show_flow_state_t *state)
{
dladm_flow_attr_t attr;
ofmt_handle_t ofmt;
ofmt_status_t oferr;
uint_t ofmtflags = 0;
oferr = ofmt_open(fields_str, flow_s_fields, ofmtflags, 0, &ofmt);
flowadm_ofmt_check(oferr, state->fs_parsable, ofmt);
state->fs_ofmt = ofmt;
if (flow != NULL &&
dladm_flow_info(handle, flow, &attr) != DLADM_STATUS_OK)
die("invalid flow %s", flow);
/*
* If an interval is specified, continuously show the stats
* for only the first flow.
*/
state->fs_firstonly = (interval != 0);
for (;;) {
state->fs_donefirst = B_FALSE;
/* Show stats for named flow */
if (flow != NULL) {
state->fs_flow = flow;
(void) show_flow_stats(handle, &attr, state);
/* Show all stats on a link */
} else if (linkid != DATALINK_INVALID_LINKID) {
(void) dladm_walk_flow(show_flow_stats, handle, linkid,
state, B_FALSE);
/* Show all stats by datalink */
} else {
(void) dladm_walk_datalink_id(show_link_flow_stats,
handle, state, DATALINK_CLASS_ALL,
DATALINK_ANY_MEDIATYPE, DLADM_OPT_ACTIVE);
}
if (interval == 0)
break;
(void) fflush(stdout);
(void) sleep(interval);
}
ofmt_close(ofmt);
}
/* ARGSUSED */
ilbadm_status_t
ilbadm_show_hc(int argc, char *argv[])
{
ilb_handle_t h = ILB_INVALID_HANDLE;
ilb_status_t rclib;
ofmt_handle_t ofmt_h;
ofmt_status_t ofmt_ret;
if ((ofmt_ret = ofmt_open("all", hc_fields, 0, SHOW_HC_COLS,
&ofmt_h)) != OFMT_SUCCESS) {
char err_buf[SHOW_HC_COLS];
ilbadm_err(gettext("ofmt_open failed: %s"),
ofmt_strerror(ofmt_h, ofmt_ret, err_buf, SHOW_HC_COLS));
return (ILBADM_LIBERR);
}
rclib = ilb_open(&h);
if (rclib != ILB_STATUS_OK)
goto out;
if (argc == 1) {
rclib = ilb_walk_hc(h, ilbadm_print_hc, ofmt_h);
} else {
ilb_hc_info_t hc_info;
int i;
for (i = 1; i < argc; i++) {
rclib = ilb_get_hc_info(h, argv[i], &hc_info);
if (rclib == ILB_STATUS_OK)
ofmt_print(ofmt_h, &hc_info);
else
break;
}
}
out:
ofmt_close(ofmt_h);
if (h != ILB_INVALID_HANDLE)
(void) ilb_close(h);
if (rclib != ILB_STATUS_OK) {
ilbadm_err(ilb_errstr(rclib));
return (ILBADM_LIBERR);
}
return (ILBADM_OK);
}
int
main(int argc, char **argv)
{
int c;
int err;
const char *ofields = NULL;
ofmt_status_t ofmterr;
ofmt_field_t *fields = NULL;
uint_t ofmtflags = 0;
ipmp_handle_t ih;
ipmp_qcontext_t qcontext = IPMP_QCONTEXT_SNAP;
ipmpstat_cbfunc_t *cbfunc;
ipmpstat_walker_t *walker;
char errbuf[OFMT_BUFSIZE];
if ((progname = strrchr(argv[0], '/')) == NULL)
progname = argv[0];
else
progname++;
(void) setlocale(LC_ALL, "");
(void) textdomain(TEXT_DOMAIN);
while ((c = getopt(argc, argv, "nLPo:agipt")) != EOF) {
if (fields != NULL && strchr("agipt", c) != NULL)
die("only one output format may be specified\n");
switch (c) {
case 'n':
opt |= IPMPSTAT_OPT_NUMERIC;
break;
case 'L':
/* Undocumented option: for testing use ONLY */
qcontext = IPMP_QCONTEXT_LIVE;
break;
case 'P':
opt |= IPMPSTAT_OPT_PARSABLE;
ofmtflags |= OFMT_PARSABLE;
break;
case 'o':
ofields = optarg;
break;
case 'a':
walker = walk_addr;
cbfunc = info_output_cbfunc;
fields = addr_fields;
break;
case 'g':
walker = walk_group;
cbfunc = info_output_cbfunc;
fields = group_fields;
break;
case 'i':
walker = walk_if;
cbfunc = info_output_cbfunc;
fields = if_fields;
break;
case 'p':
fields = probe_fields;
break;
case 't':
walker = walk_if;
cbfunc = targinfo_output_cbfunc;
fields = targ_fields;
break;
default:
usage();
break;
}
}
if (argc > optind || fields == NULL)
usage();
/*
* Open a handle to the formatted output engine.
*/
ofmterr = ofmt_open(ofields, fields, ofmtflags, IPMPSTAT_NCOL, &ofmt);
if (ofmterr != OFMT_SUCCESS) {
/*
* If some fields were badly formed in human-friendly mode, we
* emit a warning and continue. Otherwise exit immediately.
*/
(void) ofmt_strerror(ofmt, ofmterr, errbuf, sizeof (errbuf));
if (ofmterr != OFMT_EBADFIELDS || (opt & IPMPSTAT_OPT_PARSABLE))
die("%s\n", errbuf);
else
warn("%s\n", errbuf);
}
/*
* Obtain the window size and monitor changes to the size. This data
* is used to redisplay the output headers when necessary.
*/
(void) sigset(SIGWINCH, sighandler);
if ((err = ipmp_open(&ih)) != IPMP_SUCCESS)
die_ipmperr(err, "cannot create IPMP handle");
if (ipmp_ping_daemon(ih) != IPMP_SUCCESS)
die("cannot contact in.mpathd(1M) -- is IPMP in use?\n");
/*
* If we've been asked to display probes, then call the probe output
* function. Otherwise, snapshot IPMP state (or use live state) and
* invoke the specified walker with the specified callback function.
*/
if (fields == probe_fields) {
probe_output(ih, ofmt);
} else {
if ((err = ipmp_setqcontext(ih, qcontext)) != IPMP_SUCCESS) {
if (qcontext == IPMP_QCONTEXT_SNAP)
die_ipmperr(err, "cannot snapshot IPMP state");
else
die_ipmperr(err, "cannot use live IPMP state");
}
(*walker)(ih, cbfunc, ofmt);
}
ofmt_close(ofmt);
ipmp_close(ih);
return (EXIT_SUCCESS);
}
/* 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);
}
ofmt_check(oferr, state.us_parsable, ofmt, die, warn);
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);
}
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 *zonename = 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");
linkname[0] = '\0';
bzero(&state, sizeof (state));
opterr = 0;
while ((option = getopt_long(argc, argv, ":rtApi:o:u:l:hz:",
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");
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;
case 'z':
zonename = optarg;
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");
if (linkname[0] != '\0') {
if (dladm_zname2info(handle, zonename, linkname, &linkid, NULL,
NULL, NULL) != DLADM_STATUS_OK)
die("invalid link '%s'", linkname);
}
/* 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);
ofmt_check(oferr, state.fs_parsable, ofmt, die, warn);
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);
}
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));
}
static void
do_show_flowprop(int argc, char **argv)
{
int option;
dladm_arg_list_t *proplist = NULL;
show_flowprop_state_t state;
char *fields_str = NULL;
ofmt_handle_t ofmt;
ofmt_status_t oferr;
uint_t ofmtflags = 0;
opterr = 0;
state.fs_propvals = NULL;
state.fs_line = NULL;
state.fs_parsable = B_FALSE;
state.fs_persist = B_FALSE;
state.fs_header = B_TRUE;
state.fs_retstatus = DLADM_STATUS_OK;
state.fs_linkid = DATALINK_INVALID_LINKID;
state.fs_flow = NULL;
while ((option = getopt_long(argc, argv, ":p:cPl:o:",
prop_longopts, NULL)) != -1) {
switch (option) {
case 'p':
if (dladm_parse_flow_props(optarg, &proplist, B_TRUE)
!= DLADM_STATUS_OK)
die("invalid flow properties specified");
break;
case 'c':
state.fs_parsable = B_TRUE;
ofmtflags |= OFMT_PARSABLE;
break;
case 'P':
state.fs_persist = B_TRUE;
break;
case 'l':
if (dladm_name2info(handle, optarg, &state.fs_linkid,
NULL, NULL, NULL) != DLADM_STATUS_OK)
die("invalid link '%s'", optarg);
break;
case 'o':
fields_str = optarg;
break;
default:
die_opterr(optopt, option);
break;
}
}
if (optind == (argc - 1)) {
if (strlen(argv[optind]) >= MAXFLOWNAMELEN)
die("flow name too long");
state.fs_flow = argv[optind];
} else if (optind != argc) {
usage();
}
state.fs_proplist = proplist;
state.fs_status = DLADM_STATUS_OK;
oferr = ofmt_open(fields_str, flowprop_fields, ofmtflags, 0, &ofmt);
flowadm_ofmt_check(oferr, state.fs_parsable, ofmt);
state.fs_ofmt = ofmt;
/* Show properties for one flow */
if (state.fs_flow != NULL) {
show_flowprop_one_flow(&state, state.fs_flow);
/* Show properties for all flows on one link */
} else if (state.fs_linkid != DATALINK_INVALID_LINKID) {
(void) show_flowprop_onelink(handle, state.fs_linkid, &state);
/* Show properties for all flows on all links */
} else {
(void) dladm_walk_datalink_id(show_flowprop_onelink, handle,
&state, DATALINK_CLASS_ALL, DATALINK_ANY_MEDIATYPE,
DLADM_OPT_ACTIVE);
}
dladm_free_props(proplist);
ofmt_close(ofmt);
}
static void
do_show_flow(int argc, char *argv[])
{
char flowname[MAXFLOWNAMELEN];
char linkname[MAXLINKNAMELEN];
datalink_id_t linkid = DATALINK_ALL_LINKID;
int option;
boolean_t s_arg = B_FALSE;
boolean_t S_arg = B_FALSE;
boolean_t i_arg = B_FALSE;
boolean_t l_arg = B_FALSE;
boolean_t o_arg = B_FALSE;
uint32_t interval = 0;
show_flow_state_t state;
char *fields_str = NULL;
ofmt_handle_t ofmt;
ofmt_status_t oferr;
uint_t ofmtflags = 0;
bzero(&state, sizeof (state));
opterr = 0;
while ((option = getopt_long(argc, argv, ":pPsSi:l:o:",
longopts, NULL)) != -1) {
switch (option) {
case 'p':
state.fs_parsable = B_TRUE;
ofmtflags |= OFMT_PARSABLE;
break;
case 'P':
state.fs_persist = B_TRUE;
break;
case 's':
if (s_arg)
die_optdup(option);
s_arg = B_TRUE;
break;
case 'S':
if (S_arg)
die_optdup(option);
S_arg = B_TRUE;
break;
case 'o':
if (o_arg)
die_optdup(option);
o_arg = B_TRUE;
fields_str = optarg;
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 '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);
l_arg = B_TRUE;
break;
default:
die_opterr(optopt, option);
break;
}
}
if (i_arg && !(s_arg || S_arg))
die("the -i option can be used only with -s or -S");
if (s_arg && S_arg)
die("the -s option cannot be used with -S");
/* get flow name (optional last argument */
if (optind == (argc-1)) {
if (strlcpy(flowname, argv[optind], MAXFLOWNAMELEN)
>= MAXFLOWNAMELEN)
die("flow name too long");
state.fs_flow = flowname;
}
if (S_arg) {
dladm_continuous(handle, linkid, state.fs_flow, interval,
FLOW_REPORT);
return;
}
if (s_arg) {
flow_stats(state.fs_flow, linkid, interval, fields_str, &state);
return;
}
oferr = ofmt_open(fields_str, flow_fields, ofmtflags, 0, &ofmt);
flowadm_ofmt_check(oferr, state.fs_parsable, ofmt);
state.fs_ofmt = ofmt;
/* Show attributes of one flow */
if (state.fs_flow != NULL) {
show_one_flow(&state, state.fs_flow);
/* Show attributes of flows on one link */
} else if (l_arg) {
(void) show_flows_onelink(handle, linkid, &state);
/* Show attributes of all flows on all links */
} else {
(void) dladm_walk_datalink_id(show_flows_onelink, handle,
&state, DATALINK_CLASS_ALL, DATALINK_ANY_MEDIATYPE,
DLADM_OPT_ACTIVE);
}
ofmt_close(ofmt);
}
