1 /*
2 * CDDL HEADER START
3 *
4 * The contents of this file are subject to the terms of the
5 * Common Development and Distribution License (the "License").
6 * You may not use this file except in compliance with the License.
7 *
8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9 * or http://www.opensolaris.org/os/licensing.
10 * See the License for the specific language governing permissions
11 * and limitations under the License.
12 *
13 * When distributing Covered Code, include this CDDL HEADER in each
14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15 * If applicable, add the following below this CDDL HEADER, with the
16 * fields enclosed by brackets "[]" replaced with your own identifying
17 * information: Portions Copyright [yyyy] [name of copyright owner]
18 *
19 * CDDL HEADER END
20 */
21 /*
22 * Copyright 2010 Sun Microsystems, Inc. All rights reserved.
23 * Use is subject to license terms.
24 */
25
26 /*
27 * Copyright 2017 Joyent, Inc.
28 */
29
30 #include <stdio.h>
31 #include <locale.h>
32 #include <stdarg.h>
33 #include <stdlib.h>
34 #include <fcntl.h>
35 #include <string.h>
36 #include <stropts.h>
37 #include <errno.h>
38 #include <strings.h>
39 #include <getopt.h>
40 #include <unistd.h>
41 #include <priv.h>
42 #include <netdb.h>
43 #include <libintl.h>
44 #include <libdlflow.h>
45 #include <libdllink.h>
46 #include <libdlstat.h>
47 #include <sys/types.h>
48 #include <sys/socket.h>
49 #include <netinet/in.h>
50 #include <arpa/inet.h>
51 #include <sys/ethernet.h>
52 #include <inet/ip.h>
53 #include <inet/ip6.h>
54 #include <stddef.h>
55 #include <ofmt.h>
56
57 typedef struct flow_chain_s {
58 char fc_flowname[MAXFLOWNAMELEN];
59 boolean_t fc_visited;
60 flow_stat_t *fc_stat;
61 struct flow_chain_s *fc_next;
62 } flow_chain_t;
63
64 typedef struct show_flow_state {
65 flow_chain_t *fs_flowchain;
66 ofmt_handle_t fs_ofmt;
67 char fs_unit;
68 boolean_t fs_parsable;
69 } show_flow_state_t;
70
71 typedef struct show_history_state_s {
72 boolean_t us_plot;
73 boolean_t us_parsable;
74 boolean_t us_printheader;
75 boolean_t us_first;
76 boolean_t us_showall;
77 ofmt_handle_t us_ofmt;
78 } show_history_state_t;
79
80 static void do_show_history(int, char **);
81
82 static int query_flow_stats(dladm_handle_t, dladm_flow_attr_t *, void *);
83 static int query_link_flow_stats(dladm_handle_t, datalink_id_t, void *);
84
85 static void die(const char *, ...);
86 static void die_optdup(int);
87 static void die_opterr(int, int, const char *);
88 static void die_dlerr(dladm_status_t, const char *, ...);
89 static void warn(const char *, ...);
90
91 /* callback functions for printing output */
92 static ofmt_cb_t print_default_cb, print_flow_stats_cb;
93
94 #define NULL_OFMT {NULL, 0, 0, NULL}
95
96 /*
97 * structures for flowstat (printing live statistics)
98 */
99 typedef enum {
100 FLOW_S_FLOW,
101 FLOW_S_IPKTS,
102 FLOW_S_RBYTES,
103 FLOW_S_IERRORS,
104 FLOW_S_OPKTS,
105 FLOW_S_OBYTES,
106 FLOW_S_OERRORS
107 } flow_s_field_index_t;
108
109 static ofmt_field_t flow_s_fields[] = {
110 /* name, field width, index, callback */
111 { "FLOW", 15, FLOW_S_FLOW, print_flow_stats_cb},
112 { "IPKTS", 8, FLOW_S_IPKTS, print_flow_stats_cb},
113 { "RBYTES", 8, FLOW_S_RBYTES, print_flow_stats_cb},
114 { "IERRS", 8, FLOW_S_IERRORS, print_flow_stats_cb},
115 { "OPKTS", 8, FLOW_S_OPKTS, print_flow_stats_cb},
116 { "OBYTES", 8, FLOW_S_OBYTES, print_flow_stats_cb},
117 { "OERRS", 8, FLOW_S_OERRORS, print_flow_stats_cb},
118 NULL_OFMT}
119 ;
120
121 typedef struct flow_args_s {
122 char *flow_s_flow;
123 flow_stat_t *flow_s_stat;
124 char flow_s_unit;
125 boolean_t flow_s_parsable;
126 } flow_args_t;
127
128 /*
129 * structures for 'flowstat -h'
130 */
131 typedef struct history_fields_buf_s {
132 char history_flow[12];
133 char history_duration[10];
134 char history_ipackets[9];
135 char history_rbytes[10];
136 char history_opackets[9];
137 char history_obytes[10];
138 char history_bandwidth[14];
139 } history_fields_buf_t;
140
141 static ofmt_field_t history_fields[] = {
142 /* name, field width, offset */
143 { "FLOW", 13,
144 offsetof(history_fields_buf_t, history_flow), print_default_cb},
145 { "DURATION", 11,
146 offsetof(history_fields_buf_t, history_duration), print_default_cb},
147 { "IPACKETS", 10,
148 offsetof(history_fields_buf_t, history_ipackets), print_default_cb},
149 { "RBYTES", 11,
150 offsetof(history_fields_buf_t, history_rbytes), print_default_cb},
151 { "OPACKETS", 10,
152 offsetof(history_fields_buf_t, history_opackets), print_default_cb},
153 { "OBYTES", 11,
154 offsetof(history_fields_buf_t, history_obytes), print_default_cb},
155 { "BANDWIDTH", 15,
156 offsetof(history_fields_buf_t, history_bandwidth), print_default_cb},
157 NULL_OFMT}
158 ;
159
160 typedef struct history_l_fields_buf_s {
161 char history_l_flow[12];
162 char history_l_stime[13];
163 char history_l_etime[13];
164 char history_l_rbytes[8];
165 char history_l_obytes[8];
166 char history_l_bandwidth[14];
167 } history_l_fields_buf_t;
168
169 static ofmt_field_t history_l_fields[] = {
170 /* name, field width, offset */
171 { "FLOW", 13,
172 offsetof(history_l_fields_buf_t, history_l_flow), print_default_cb},
173 { "START", 14,
174 offsetof(history_l_fields_buf_t, history_l_stime), print_default_cb},
175 { "END", 14,
176 offsetof(history_l_fields_buf_t, history_l_etime), print_default_cb},
177 { "RBYTES", 9,
178 offsetof(history_l_fields_buf_t, history_l_rbytes), print_default_cb},
179 { "OBYTES", 9,
180 offsetof(history_l_fields_buf_t, history_l_obytes), print_default_cb},
181 { "BANDWIDTH", 15,
182 offsetof(history_l_fields_buf_t, history_l_bandwidth),
183 print_default_cb},
184 NULL_OFMT}
185 ;
186
187 static char *progname;
188
189 /*
190 * Handle to libdladm. Opened in main() before the sub-command
191 * specific function is called.
192 */
193 static dladm_handle_t handle = NULL;
194
195 const char *usage_ermsg = "flowstat [-r | -t] [-i interval] "
196 "[-l link] [flow]\n"
197 " flowstat [-A] [-i interval] [-p] [ -o field[,...]]\n"
198 " [-u R|K|M|G|T|P] [-l link] [flow]\n"
199 " flowstat -h [-a] [-d] [-F format]"
200 " [-s <DD/MM/YYYY,HH:MM:SS>]\n"
201 " [-e <DD/MM/YYYY,HH:MM:SS>] -f <logfile> "
202 "[<flow>]";
203
204 static void
205 usage(void)
206 {
207 (void) fprintf(stderr, "%s\n", gettext(usage_ermsg));
208
209 /* close dladm handle if it was opened */
210 if (handle != NULL)
211 dladm_close(handle);
212
213 exit(1);
214 }
215
216 boolean_t
217 flowstat_unit(char *oarg, char *unit)
218 {
219 if ((strcmp(oarg, "R") == 0) || (strcmp(oarg, "K") == 0) ||
220 (strcmp(oarg, "M") == 0) || (strcmp(oarg, "G") == 0) ||
221 (strcmp(oarg, "T") == 0) || (strcmp(oarg, "P") == 0)) {
222 *unit = oarg[0];
223 return (B_TRUE);
224 }
225
226 return (B_FALSE);
227 }
228
229 void
230 map_to_units(char *buf, uint_t bufsize, double num, char unit,
231 boolean_t parsable)
232 {
233 if (parsable) {
234 (void) snprintf(buf, bufsize, "%.0lf", num);
235 return;
236 }
237
238 if (unit == '\0') {
239 int index;
240
241 for (index = 0; (int)(num/1000) != 0; index++, num /= 1000)
242 ;
243
244 switch (index) {
245 case 0:
246 unit = '\0';
247 break;
248 case 1:
249 unit = 'K';
250 break;
251 case 2:
252 unit = 'M';
253 break;
254 case 3:
255 unit = 'G';
256 break;
257 case 4:
258 unit = 'T';
259 break;
260 case 5:
261 /* Largest unit supported */
262 default:
263 unit = 'P';
264 break;
265 }
266 } else {
267 switch (unit) {
268 case 'R':
269 /* Already raw numbers */
270 unit = '\0';
271 break;
272 case 'K':
273 num /= 1000;
274 break;
275 case 'M':
276 num /= (1000*1000);
277 break;
278 case 'G':
279 num /= (1000*1000*1000);
280 break;
281 case 'T':
282 num /= (1000.0*1000.0*1000.0*1000.0);
283 break;
284 case 'P':
285 /* Largest unit supported */
286 default:
287 num /= (1000.0*1000.0*1000.0*1000.0*1000.0);
288 break;
289 }
290 }
291
292 if (unit == '\0')
293 (void) snprintf(buf, bufsize, " %7.0lf%c", num, unit);
294 else
295 (void) snprintf(buf, bufsize, " %6.2lf%c", num, unit);
296 }
297
298 flow_chain_t *
299 get_flow_prev_stat(const char *flowname, void *arg)
300 {
301 show_flow_state_t *state = arg;
302 flow_chain_t *flow_curr = NULL;
303
304 /* Scan prev flowname list and look for entry matching this entry */
305 for (flow_curr = state->fs_flowchain; flow_curr;
306 flow_curr = flow_curr->fc_next) {
307 if (strcmp(flow_curr->fc_flowname, flowname) == 0)
308 break;
309 }
310
311 /* New flow, add it */
312 if (flow_curr == NULL) {
313 flow_curr = (flow_chain_t *)malloc(sizeof (flow_chain_t));
314 if (flow_curr == NULL)
315 goto done;
316 (void) strncpy(flow_curr->fc_flowname, flowname,
317 MAXFLOWNAMELEN);
318 flow_curr->fc_stat = NULL;
319 flow_curr->fc_next = state->fs_flowchain;
320 state->fs_flowchain = flow_curr;
321 }
322 done:
323 return (flow_curr);
324 }
325
326 /*
327 * Number of flows may change while flowstat -i is executing.
328 * Free memory allocated for flows that are no longer there.
329 * Prepare for next iteration by marking visited = false for
330 * existing stat entries.
331 */
332 static void
333 cleanup_removed_flows(show_flow_state_t *state)
334 {
335 flow_chain_t *fcurr;
336 flow_chain_t *fprev;
337 flow_chain_t *tofree;
338
339 /* Delete all nodes from the list that have fc_visited marked false */
340 fcurr = state->fs_flowchain;
341 while (fcurr != NULL) {
342 if (fcurr->fc_visited) {
343 fcurr->fc_visited = B_FALSE;
344 fprev = fcurr;
345 fcurr = fcurr->fc_next;
346 continue;
347 }
348
349 /* Is it head of the list? */
350 if (fcurr == state->fs_flowchain)
351 state->fs_flowchain = fcurr->fc_next;
352 else
353 fprev->fc_next = fcurr->fc_next;
354
355 /* fprev remains the same */
356 tofree = fcurr;
357 fcurr = fcurr->fc_next;
358
359 /* Free stats memory for the removed flow */
360 dladm_flow_stat_free(tofree->fc_stat);
361 free(tofree);
362 }
363 }
364
365 static boolean_t
366 print_flow_stats_cb(ofmt_arg_t *of_arg, char *buf, uint_t bufsize)
367 {
368 flow_args_t *fargs = of_arg->ofmt_cbarg;
369 flow_stat_t *diff_stats = fargs->flow_s_stat;
370 char unit = fargs->flow_s_unit;
371 boolean_t parsable = fargs->flow_s_parsable;
372
373 switch (of_arg->ofmt_id) {
374 case FLOW_S_FLOW:
375 (void) snprintf(buf, bufsize, "%s", fargs->flow_s_flow);
376 break;
377 case FLOW_S_IPKTS:
378 map_to_units(buf, bufsize, diff_stats->fl_ipackets, unit,
379 parsable);
380 break;
381 case FLOW_S_RBYTES:
382 map_to_units(buf, bufsize, diff_stats->fl_rbytes, unit,
383 parsable);
384 break;
385 case FLOW_S_IERRORS:
386 map_to_units(buf, bufsize, diff_stats->fl_ierrors, unit,
387 parsable);
388 break;
389 case FLOW_S_OPKTS:
390 map_to_units(buf, bufsize, diff_stats->fl_opackets, unit,
391 parsable);
392 break;
393 case FLOW_S_OBYTES:
394 map_to_units(buf, bufsize, diff_stats->fl_obytes, unit,
395 parsable);
396 break;
397 case FLOW_S_OERRORS:
398 map_to_units(buf, bufsize, diff_stats->fl_oerrors, unit,
399 parsable);
400 break;
401 default:
402 die("invalid input");
403 break;
404 }
405 return (B_TRUE);
406 }
407
408 /* ARGSUSED */
409 static int
410 query_flow_stats(dladm_handle_t handle, dladm_flow_attr_t *attr, void *arg)
411 {
412 show_flow_state_t *state = arg;
413 flow_chain_t *flow_node;
414 flow_stat_t *curr_stat;
415 flow_stat_t *prev_stat;
416 flow_stat_t *diff_stat;
417 char *flowname = attr->fa_flowname;
418 flow_args_t fargs;
419
420 /* Get previous stats for the flow */
421 flow_node = get_flow_prev_stat(flowname, arg);
422 if (flow_node == NULL)
423 goto done;
424
425 flow_node->fc_visited = B_TRUE;
426 prev_stat = flow_node->fc_stat;
427
428 /* Query library for current stats */
429 curr_stat = dladm_flow_stat_query(flowname);
430 if (curr_stat == NULL)
431 goto done;
432
433 /* current stats - prev iteration stats */
434 diff_stat = dladm_flow_stat_diff(curr_stat, prev_stat);
435
436 /* Free prev stats */
437 dladm_flow_stat_free(prev_stat);
438
439 /* Prev <- curr stats */
440 flow_node->fc_stat = curr_stat;
441
442 if (diff_stat == NULL)
443 goto done;
444
445 /* Print stats */
446 fargs.flow_s_flow = flowname;
447 fargs.flow_s_stat = diff_stat;
448 fargs.flow_s_unit = state->fs_unit;
449 fargs.flow_s_parsable = state->fs_parsable;
450 ofmt_print(state->fs_ofmt, &fargs);
451
452 /* Free diff stats */
453 dladm_flow_stat_free(diff_stat);
454 done:
455 return (DLADM_WALK_CONTINUE);
456 }
457
458 /*
459 * Wrapper of dladm_walk_flow(query_flow_stats,...) to make it usable for
460 * dladm_walk_datalink_id(). Used for showing flow stats for
461 * all flows on all links.
462 */
463 static int
464 query_link_flow_stats(dladm_handle_t dh, datalink_id_t linkid, void * arg)
465 {
466 if (dladm_walk_flow(query_flow_stats, dh, linkid, arg, B_FALSE)
467 == DLADM_STATUS_OK)
468 return (DLADM_WALK_CONTINUE);
469 else
470 return (DLADM_WALK_TERMINATE);
471 }
472
473 void
474 print_all_stats(name_value_stat_entry_t *stat_entry)
475 {
476 name_value_stat_t *curr_stat;
477
478 printf("%s\n", stat_entry->nve_header);
479
480 for (curr_stat = stat_entry->nve_stats; curr_stat != NULL;
481 curr_stat = curr_stat->nv_nextstat) {
482 printf("\t%15s", curr_stat->nv_statname);
483 printf("\t%15llu\n", curr_stat->nv_statval);
484 }
485 }
486
487 /* ARGSUSED */
488 static int
489 dump_one_flow_stats(dladm_handle_t handle, dladm_flow_attr_t *attr, void *arg)
490 {
491 char *flowname = attr->fa_flowname;
492 void *stat;
493
494 stat = dladm_flow_stat_query_all(flowname);
495 if (stat == NULL)
496 goto done;
497 print_all_stats(stat);
498 dladm_flow_stat_query_all_free(stat);
499
500 done:
501 return (DLADM_WALK_CONTINUE);
502 }
503
504 /*
505 * Wrapper of dladm_walk_flow(query_flow_stats,...) to make it usable for
506 * dladm_walk_datalink_id(). Used for showing flow stats for
507 * all flows on all links.
508 */
509 static int
510 dump_link_flow_stats(dladm_handle_t dh, datalink_id_t linkid, void * arg)
511 {
512 if (dladm_walk_flow(dump_one_flow_stats, dh, linkid, arg, B_FALSE)
513 == DLADM_STATUS_OK)
514 return (DLADM_WALK_CONTINUE);
515 else
516 return (DLADM_WALK_TERMINATE);
517 }
518
519 static void
520 dump_all_flow_stats(dladm_flow_attr_t *attrp, void *arg, datalink_id_t linkid,
521 boolean_t flow_arg)
522 {
523 /* Show stats for named flow */
524 if (flow_arg) {
525 (void) dump_one_flow_stats(handle, attrp, arg);
526
527 /* Show stats for flows on one link */
528 } else if (linkid != DATALINK_INVALID_LINKID) {
529 (void) dladm_walk_flow(dump_one_flow_stats, handle, linkid,
530 arg, B_FALSE);
531
532 /* Show stats for all flows on all links */
533 } else {
534 (void) dladm_walk_datalink_id(dump_link_flow_stats,
535 handle, arg, DATALINK_CLASS_ALL,
536 DATALINK_ANY_MEDIATYPE, DLADM_OPT_ACTIVE);
537 }
538 }
539
540 int
541 main(int argc, char *argv[])
542 {
543 dladm_status_t status;
544 int option;
545 boolean_t r_arg = B_FALSE;
546 boolean_t t_arg = B_FALSE;
547 boolean_t p_arg = B_FALSE;
548 boolean_t i_arg = B_FALSE;
549 boolean_t o_arg = B_FALSE;
550 boolean_t u_arg = B_FALSE;
551 boolean_t A_arg = B_FALSE;
552 boolean_t flow_arg = B_FALSE;
553 datalink_id_t linkid = DATALINK_ALL_LINKID;
554 char linkname[MAXLINKNAMELEN];
555 char flowname[MAXFLOWNAMELEN];
556 uint32_t interval = 0;
557 char unit = '\0';
558 show_flow_state_t state;
559 char *fields_str = NULL;
560 char *o_fields_str = NULL;
561
562 char *total_stat_fields =
563 "flow,ipkts,rbytes,ierrs,opkts,obytes,oerrs";
564 char *rx_stat_fields =
565 "flow,ipkts,rbytes,ierrs";
566 char *tx_stat_fields =
567 "flow,opkts,obytes,oerrs";
568
569 ofmt_handle_t ofmt;
570 ofmt_status_t oferr;
571 uint_t ofmtflags = OFMT_RIGHTJUST;
572
573 dladm_flow_attr_t attr;
574
575 (void) setlocale(LC_ALL, "");
576 #if !defined(TEXT_DOMAIN)
577 #define TEXT_DOMAIN "SYS_TEST"
578 #endif
579 (void) textdomain(TEXT_DOMAIN);
580
581 progname = argv[0];
582
583 /* Open the libdladm handle */
584 if ((status = dladm_open(&handle)) != DLADM_STATUS_OK)
585 die_dlerr(status, "could not open /dev/dld");
586
587 bzero(&state, sizeof (state));
588
589 opterr = 0;
590 while ((option = getopt_long(argc, argv, ":rtApi:o:u:l:h",
591 NULL, NULL)) != -1) {
592 switch (option) {
593 case 'r':
594 if (r_arg)
595 die_optdup(option);
596
597 r_arg = B_TRUE;
598 break;
599 case 't':
600 if (t_arg)
601 die_optdup(option);
602
603 t_arg = B_TRUE;
604 break;
605 case 'A':
606 if (A_arg)
607 die_optdup(option);
608
609 A_arg = B_TRUE;
610 break;
611 case 'p':
612 if (p_arg)
613 die_optdup(option);
614
615 p_arg = B_TRUE;
616 break;
617 case 'i':
618 if (i_arg)
619 die_optdup(option);
620
621 i_arg = B_TRUE;
622 if (!dladm_str2interval(optarg, &interval))
623 die("invalid interval value '%s'", optarg);
624 break;
625 case 'o':
626 o_arg = B_TRUE;
627 o_fields_str = optarg;
628 break;
629 case 'u':
630 if (u_arg)
631 die_optdup(option);
632
633 u_arg = B_TRUE;
634 if (!flowstat_unit(optarg, &unit))
635 die("invalid unit value '%s',"
636 "unit must be R|K|M|G|T|P", optarg);
637 break;
638 case 'l':
639 if (strlcpy(linkname, optarg, MAXLINKNAMELEN)
640 >= MAXLINKNAMELEN)
641 die("link name too long\n");
642 if (dladm_name2info(handle, linkname, &linkid, NULL,
643 NULL, NULL) != DLADM_STATUS_OK)
644 die("invalid link '%s'", linkname);
645 break;
646 case 'h':
647 if (r_arg || t_arg || p_arg || o_arg || u_arg ||
648 i_arg || A_arg) {
649 die("the option -h is not compatible with "
650 "-r, -t, -p, -o, -u, -i, -A");
651 }
652 do_show_history(argc, argv);
653 return (0);
654 break;
655 default:
656 die_opterr(optopt, option, usage_ermsg);
657 break;
658 }
659 }
660
661 if (r_arg && t_arg)
662 die("the option -t and -r are not compatible");
663
664 if (u_arg && p_arg)
665 die("the option -u and -p are not compatible");
666
667 if (p_arg && !o_arg)
668 die("-p requires -o");
669
670 if (p_arg && strcasecmp(o_fields_str, "all") == 0)
671 die("\"-o all\" is invalid with -p");
672
673 if (A_arg &&
674 (r_arg || t_arg || p_arg || o_arg || u_arg || i_arg))
675 die("the option -A is not compatible with "
676 "-r, -t, -p, -o, -u, -i");
677
678 /* get flow name (optional last argument) */
679 if (optind == (argc-1)) {
680 if (strlcpy(flowname, argv[optind], MAXFLOWNAMELEN)
681 >= MAXFLOWNAMELEN)
682 die("flow name too long");
683 flow_arg = B_TRUE;
684 } else if (optind != argc) {
685 usage();
686 }
687
688 if (flow_arg &&
689 dladm_flow_info(handle, flowname, &attr) != DLADM_STATUS_OK)
690 die("invalid flow %s", flowname);
691
692 if (A_arg) {
693 dump_all_flow_stats(&attr, &state, linkid, flow_arg);
694 return (0);
695 }
696
697 state.fs_unit = unit;
698 state.fs_parsable = p_arg;
699
700 if (state.fs_parsable)
701 ofmtflags |= OFMT_PARSABLE;
702
703 if (r_arg)
704 fields_str = rx_stat_fields;
705 else if (t_arg)
706 fields_str = tx_stat_fields;
707 else
708 fields_str = total_stat_fields;
709
710 if (o_arg) {
711 fields_str = (strcasecmp(o_fields_str, "all") == 0) ?
712 fields_str : o_fields_str;
713 }
714
715 oferr = ofmt_open(fields_str, flow_s_fields, ofmtflags, 0, &ofmt);
716 ofmt_check(oferr, state.fs_parsable, ofmt, die, warn);
717 state.fs_ofmt = ofmt;
718
719 for (;;) {
720 /* Show stats for named flow */
721 if (flow_arg) {
722 (void) query_flow_stats(handle, &attr, &state);
723
724 /* Show stats for flows on one link */
725 } else if (linkid != DATALINK_INVALID_LINKID) {
726 (void) dladm_walk_flow(query_flow_stats, handle, linkid,
727 &state, B_FALSE);
728
729 /* Show stats for all flows on all links */
730 } else {
731 (void) dladm_walk_datalink_id(query_link_flow_stats,
732 handle, &state, DATALINK_CLASS_ALL,
733 DATALINK_ANY_MEDIATYPE, DLADM_OPT_ACTIVE);
734 }
735
736 if (interval == 0)
737 break;
738
739 (void) fflush(stdout);
740 cleanup_removed_flows(&state);
741 (void) sleep(interval);
742 }
743 ofmt_close(ofmt);
744
745 dladm_close(handle);
746 return (0);
747 }
748
749 /* ARGSUSED */
750 static int
751 show_history_date(dladm_usage_t *history, void *arg)
752 {
753 show_history_state_t *state = (show_history_state_t *)arg;
754 time_t stime;
755 char timebuf[20];
756 dladm_flow_attr_t attr;
757 dladm_status_t status;
758
759 /*
760 * Only show historical information for existing flows unless '-a'
761 * is specified.
762 */
763 if (!state->us_showall && ((status = dladm_flow_info(handle,
764 history->du_name, &attr)) != DLADM_STATUS_OK)) {
765 return (status);
766 }
767
768 stime = history->du_stime;
769 (void) strftime(timebuf, sizeof (timebuf), "%m/%d/%Y",
770 localtime(&stime));
771 (void) printf("%s\n", timebuf);
772
773 return (DLADM_STATUS_OK);
774 }
775
776 static int
777 show_history_time(dladm_usage_t *history, void *arg)
778 {
779 show_history_state_t *state = (show_history_state_t *)arg;
780 char buf[DLADM_STRSIZE];
781 history_l_fields_buf_t ubuf;
782 time_t time;
783 double bw;
784 dladm_flow_attr_t attr;
785 dladm_status_t status;
786
787 /*
788 * Only show historical information for existing flows unless '-a'
789 * is specified.
790 */
791 if (!state->us_showall && ((status = dladm_flow_info(handle,
792 history->du_name, &attr)) != DLADM_STATUS_OK)) {
793 return (status);
794 }
795
796 if (state->us_plot) {
797 if (!state->us_printheader) {
798 if (state->us_first) {
799 (void) printf("# Time");
800 state->us_first = B_FALSE;
801 }
802 (void) printf(" %s", history->du_name);
803 if (history->du_last) {
804 (void) printf("\n");
805 state->us_first = B_TRUE;
806 state->us_printheader = B_TRUE;
807 }
808 } else {
809 if (state->us_first) {
810 time = history->du_etime;
811 (void) strftime(buf, sizeof (buf), "%T",
812 localtime(&time));
813 state->us_first = B_FALSE;
814 (void) printf("%s", buf);
815 }
816 bw = (double)history->du_bandwidth/1000;
817 (void) printf(" %.2f", bw);
818 if (history->du_last) {
819 (void) printf("\n");
820 state->us_first = B_TRUE;
821 }
822 }
823 return (DLADM_STATUS_OK);
824 }
825
826 bzero(&ubuf, sizeof (ubuf));
827
828 (void) snprintf(ubuf.history_l_flow, sizeof (ubuf.history_l_flow), "%s",
829 history->du_name);
830 time = history->du_stime;
831 (void) strftime(buf, sizeof (buf), "%T", localtime(&time));
832 (void) snprintf(ubuf.history_l_stime, sizeof (ubuf.history_l_stime),
833 "%s", buf);
834 time = history->du_etime;
835 (void) strftime(buf, sizeof (buf), "%T", localtime(&time));
836 (void) snprintf(ubuf.history_l_etime, sizeof (ubuf.history_l_etime),
837 "%s", buf);
838 (void) snprintf(ubuf.history_l_rbytes, sizeof (ubuf.history_l_rbytes),
839 "%llu", history->du_rbytes);
840 (void) snprintf(ubuf.history_l_obytes, sizeof (ubuf.history_l_obytes),
841 "%llu", history->du_obytes);
842 (void) snprintf(ubuf.history_l_bandwidth,
843 sizeof (ubuf.history_l_bandwidth), "%s Mbps",
844 dladm_bw2str(history->du_bandwidth, buf));
845
846 ofmt_print(state->us_ofmt, (void *)&ubuf);
847 return (DLADM_STATUS_OK);
848 }
849
850 static int
851 show_history_res(dladm_usage_t *history, void *arg)
852 {
853 show_history_state_t *state = (show_history_state_t *)arg;
854 char buf[DLADM_STRSIZE];
855 history_fields_buf_t ubuf;
856 dladm_flow_attr_t attr;
857 dladm_status_t status;
858
859 /*
860 * Only show historical information for existing flows unless '-a'
861 * is specified.
862 */
863 if (!state->us_showall && ((status = dladm_flow_info(handle,
864 history->du_name, &attr)) != DLADM_STATUS_OK)) {
865 return (status);
866 }
867
868 bzero(&ubuf, sizeof (ubuf));
869
870 (void) snprintf(ubuf.history_flow, sizeof (ubuf.history_flow), "%s",
871 history->du_name);
872 (void) snprintf(ubuf.history_duration, sizeof (ubuf.history_duration),
873 "%llu", history->du_duration);
874 (void) snprintf(ubuf.history_ipackets, sizeof (ubuf.history_ipackets),
875 "%llu", history->du_ipackets);
876 (void) snprintf(ubuf.history_rbytes, sizeof (ubuf.history_rbytes),
877 "%llu", history->du_rbytes);
878 (void) snprintf(ubuf.history_opackets, sizeof (ubuf.history_opackets),
879 "%llu", history->du_opackets);
880 (void) snprintf(ubuf.history_obytes, sizeof (ubuf.history_obytes),
881 "%llu", history->du_obytes);
882 (void) snprintf(ubuf.history_bandwidth, sizeof (ubuf.history_bandwidth),
883 "%s Mbps", dladm_bw2str(history->du_bandwidth, buf));
884
885 ofmt_print(state->us_ofmt, (void *)&ubuf);
886
887 return (DLADM_STATUS_OK);
888 }
889
890 static boolean_t
891 valid_formatspec(char *formatspec_str)
892 {
893 return (strcmp(formatspec_str, "gnuplot") == 0);
894 }
895
896 /* ARGSUSED */
897 static void
898 do_show_history(int argc, char *argv[])
899 {
900 char *file = NULL;
901 int opt;
902 dladm_status_t status;
903 boolean_t d_arg = B_FALSE;
904 char *stime = NULL;
905 char *etime = NULL;
906 char *resource = NULL;
907 show_history_state_t state;
908 boolean_t o_arg = B_FALSE;
909 boolean_t F_arg = B_FALSE;
910 char *fields_str = NULL;
911 char *formatspec_str = NULL;
912 char *all_fields =
913 "flow,duration,ipackets,rbytes,opackets,obytes,bandwidth";
914 char *all_l_fields =
915 "flow,start,end,rbytes,obytes,bandwidth";
916 ofmt_handle_t ofmt;
917 ofmt_status_t oferr;
918 uint_t ofmtflags = 0;
919
920 bzero(&state, sizeof (show_history_state_t));
921 state.us_parsable = B_FALSE;
922 state.us_printheader = B_FALSE;
923 state.us_plot = B_FALSE;
924 state.us_first = B_TRUE;
925
926 while ((opt = getopt(argc, argv, "das:e:o:f:F:")) != -1) {
927 switch (opt) {
928 case 'd':
929 d_arg = B_TRUE;
930 break;
931 case 'a':
932 state.us_showall = B_TRUE;
933 break;
934 case 'f':
935 file = optarg;
936 break;
937 case 's':
938 stime = optarg;
939 break;
940 case 'e':
941 etime = optarg;
942 break;
943 case 'o':
944 o_arg = B_TRUE;
945 fields_str = optarg;
946 break;
947 case 'F':
948 state.us_plot = F_arg = B_TRUE;
949 formatspec_str = optarg;
950 break;
951 default:
952 die_opterr(optopt, opt, usage_ermsg);
953 }
954 }
955
956 if (file == NULL)
957 die("-h requires a file");
958
959 if (optind == (argc-1)) {
960 dladm_flow_attr_t attr;
961
962 resource = argv[optind];
963 if (!state.us_showall &&
964 dladm_flow_info(handle, resource, &attr) !=
965 DLADM_STATUS_OK) {
966 die("invalid flow: '%s'", resource);
967 }
968 }
969
970 if (state.us_parsable)
971 ofmtflags |= OFMT_PARSABLE;
972 if (resource == NULL && stime == NULL && etime == NULL) {
973 if (!o_arg || (o_arg && strcasecmp(fields_str, "all") == 0))
974 fields_str = all_fields;
975 oferr = ofmt_open(fields_str, history_fields, ofmtflags,
976 0, &ofmt);
977 } else {
978 if (!o_arg || (o_arg && strcasecmp(fields_str, "all") == 0))
979 fields_str = all_l_fields;
980 oferr = ofmt_open(fields_str, history_l_fields, ofmtflags,
981 0, &ofmt);
982 }
983
984 ofmt_check(oferr, state.us_parsable, ofmt, die, warn);
985 state.us_ofmt = ofmt;
986
987 if (F_arg && d_arg)
988 die("incompatible -d and -F options");
989
990 if (F_arg && !valid_formatspec(formatspec_str))
991 die("Format specifier %s not supported", formatspec_str);
992
993 if (d_arg) {
994 /* Print log dates */
995 status = dladm_usage_dates(show_history_date,
996 DLADM_LOGTYPE_FLOW, file, resource, &state);
997 } else if (resource == NULL && stime == NULL && etime == NULL &&
998 !F_arg) {
999 /* Print summary */
1000 status = dladm_usage_summary(show_history_res,
1001 DLADM_LOGTYPE_FLOW, file, &state);
1002 } else if (resource != NULL) {
1003 /* Print log entries for named resource */
1004 status = dladm_walk_usage_res(show_history_time,
1005 DLADM_LOGTYPE_FLOW, file, resource, stime, etime, &state);
1006 } else {
1007 /* Print time and information for each flow */
1008 status = dladm_walk_usage_time(show_history_time,
1009 DLADM_LOGTYPE_FLOW, file, stime, etime, &state);
1010 }
1011
1012 ofmt_close(ofmt);
1013 if (status != DLADM_STATUS_OK)
1014 die_dlerr(status, "-h");
1015 dladm_close(handle);
1016 }
1017
1018 static void
1019 warn(const char *format, ...)
1020 {
1021 va_list alist;
1022
1023 format = gettext(format);
1024 (void) fprintf(stderr, "%s: warning: ", progname);
1025
1026 va_start(alist, format);
1027 (void) vfprintf(stderr, format, alist);
1028 va_end(alist);
1029
1030 (void) putc('\n', stderr);
1031 }
1032
1033 /* PRINTFLIKE1 */
1034 static void
1035 die(const char *format, ...)
1036 {
1037 va_list alist;
1038
1039 format = gettext(format);
1040 (void) fprintf(stderr, "%s: ", progname);
1041
1042 va_start(alist, format);
1043 (void) vfprintf(stderr, format, alist);
1044 va_end(alist);
1045
1046 (void) putc('\n', stderr);
1047
1048 /* close dladm handle if it was opened */
1049 if (handle != NULL)
1050 dladm_close(handle);
1051
1052 exit(EXIT_FAILURE);
1053 }
1054
1055 static void
1056 die_optdup(int opt)
1057 {
1058 die("the option -%c cannot be specified more than once", opt);
1059 }
1060
1061 static void
1062 die_opterr(int opt, int opterr, const char *usage)
1063 {
1064 switch (opterr) {
1065 case ':':
1066 die("option '-%c' requires a value\nusage: %s", opt,
1067 gettext(usage));
1068 break;
1069 case '?':
1070 default:
1071 die("unrecognized option '-%c'\nusage: %s", opt,
1072 gettext(usage));
1073 break;
1074 }
1075 }
1076
1077 /* PRINTFLIKE2 */
1078 static void
1079 die_dlerr(dladm_status_t err, const char *format, ...)
1080 {
1081 va_list alist;
1082 char errmsg[DLADM_STRSIZE];
1083
1084 format = gettext(format);
1085 (void) fprintf(stderr, "%s: ", progname);
1086
1087 va_start(alist, format);
1088 (void) vfprintf(stderr, format, alist);
1089 va_end(alist);
1090 (void) fprintf(stderr, ": %s\n", dladm_status2str(err, errmsg));
1091
1092 /* close dladm handle if it was opened */
1093 if (handle != NULL)
1094 dladm_close(handle);
1095
1096 exit(EXIT_FAILURE);
1097 }
1098
1099
1100 /*
1101 * default output callback function that, when invoked from dladm_print_output,
1102 * prints string which is offset by of_arg->ofmt_id within buf.
1103 */
1104 static boolean_t
1105 print_default_cb(ofmt_arg_t *of_arg, char *buf, uint_t bufsize)
1106 {
1107 char *value;
1108
1109 value = (char *)of_arg->ofmt_cbarg + of_arg->ofmt_id;
1110 (void) strlcpy(buf, value, bufsize);
1111 return (B_TRUE);
1112 }