]> git.proxmox.com Git - mirror_iproute2.git/blob - misc/ifstat.c
projects / mirror_iproute2.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
ss: Distinguish between IPv4 and IPv6 wildcard sockets
[mirror_iproute2.git] / misc / ifstat.c
1 /*
2 * ifstat.c handy utility to read net interface statistics
3 *
4 * This program is free software; you can redistribute it and/or
5 * modify it under the terms of the GNU General Public License
6 * as published by the Free Software Foundation; either version
7 * 2 of the License, or (at your option) any later version.
8 *
9 * Authors: Alexey Kuznetsov, <kuznet@ms2.inr.ac.ru>
10 */
11
12 #include <stdio.h>
13 #include <stdlib.h>
14 #include <unistd.h>
15 #include <fcntl.h>
16 #include <string.h>
17 #include <errno.h>
18 #include <time.h>
19 #include <sys/time.h>
20 #include <fnmatch.h>
21 #include <sys/file.h>
22 #include <sys/socket.h>
23 #include <sys/un.h>
24 #include <sys/poll.h>
25 #include <sys/wait.h>
26 #include <sys/stat.h>
27 #include <signal.h>
28 #include <math.h>
29 #include <getopt.h>
30
31 #include <linux/if.h>
32 #include <linux/if_link.h>
33
34 #include "libnetlink.h"
35 #include "json_writer.h"
36 #include "SNAPSHOT.h"
37 #include "utils.h"
38
39 int dump_zeros;
40 int reset_history;
41 int ignore_history;
42 int no_output;
43 int json_output;
44 int no_update;
45 int scan_interval;
46 int time_constant;
47 int show_errors;
48 int pretty;
49 double W;
50 char **patterns;
51 int npatterns;
52 bool is_extended;
53 int filter_type;
54 int sub_type;
55
56 char info_source[128];
57 int source_mismatch;
58
59 #define MAXS (sizeof(struct rtnl_link_stats)/sizeof(__u32))
60 #define NO_SUB_TYPE 0xffff
61
62 struct ifstat_ent {
63 struct ifstat_ent *next;
64 char *name;
65 int ifindex;
66 __u64 val[MAXS];
67 double rate[MAXS];
68 __u32 ival[MAXS];
69 };
70
71 static const char *stats[MAXS] = {
72 "rx_packets",
73 "tx_packets",
74 "rx_bytes",
75 "tx_bytes",
76 "rx_errors",
77 "tx_errors",
78 "rx_dropped",
79 "tx_dropped",
80 "multicast",
81 "collisions",
82 "rx_length_errors",
83 "rx_over_errors",
84 "rx_crc_errors",
85 "rx_frame_errors",
86 "rx_fifo_errors",
87 "rx_missed_errors",
88 "tx_aborted_errors",
89 "tx_carrier_errors",
90 "tx_fifo_errors",
91 "tx_heartbeat_errors",
92 "tx_window_errors",
93 "rx_compressed",
94 "tx_compressed"
95 };
96
97 struct ifstat_ent *kern_db;
98 struct ifstat_ent *hist_db;
99
100 static int match(const char *id)
101 {
102 int i;
103
104 if (npatterns == 0)
105 return 1;
106
107 for (i = 0; i < npatterns; i++) {
108 if (!fnmatch(patterns[i], id, 0))
109 return 1;
110 }
111 return 0;
112 }
113
114 static int get_nlmsg_extended(const struct sockaddr_nl *who,
115 struct nlmsghdr *m, void *arg)
116 {
117 struct if_stats_msg *ifsm = NLMSG_DATA(m);
118 struct rtattr *tb[IFLA_STATS_MAX+1];
119 int len = m->nlmsg_len;
120 struct ifstat_ent *n;
121
122 if (m->nlmsg_type != RTM_NEWSTATS)
123 return 0;
124
125 len -= NLMSG_LENGTH(sizeof(*ifsm));
126 if (len < 0)
127 return -1;
128
129 parse_rtattr(tb, IFLA_STATS_MAX, IFLA_STATS_RTA(ifsm), len);
130 if (tb[filter_type] == NULL)
131 return 0;
132
133 n = malloc(sizeof(*n));
134 if (!n)
135 abort();
136
137 n->ifindex = ifsm->ifindex;
138 n->name = strdup(ll_index_to_name(ifsm->ifindex));
139
140 if (sub_type == NO_SUB_TYPE) {
141 memcpy(&n->val, RTA_DATA(tb[filter_type]), sizeof(n->val));
142 } else {
143 struct rtattr *attr;
144
145 attr = parse_rtattr_one_nested(sub_type, tb[filter_type]);
146 if (attr == NULL) {
147 free(n);
148 return 0;
149 }
150 memcpy(&n->val, RTA_DATA(attr), sizeof(n->val));
151 }
152 memset(&n->rate, 0, sizeof(n->rate));
153 n->next = kern_db;
154 kern_db = n;
155 return 0;
156 }
157
158 static int get_nlmsg(const struct sockaddr_nl *who,
159 struct nlmsghdr *m, void *arg)
160 {
161 struct ifinfomsg *ifi = NLMSG_DATA(m);
162 struct rtattr *tb[IFLA_MAX+1];
163 int len = m->nlmsg_len;
164 struct ifstat_ent *n;
165 int i;
166
167 if (m->nlmsg_type != RTM_NEWLINK)
168 return 0;
169
170 len -= NLMSG_LENGTH(sizeof(*ifi));
171 if (len < 0)
172 return -1;
173
174 if (!(ifi->ifi_flags&IFF_UP))
175 return 0;
176
177 parse_rtattr(tb, IFLA_MAX, IFLA_RTA(ifi), len);
178 if (tb[IFLA_IFNAME] == NULL || tb[IFLA_STATS] == NULL)
179 return 0;
180
181 n = malloc(sizeof(*n));
182 if (!n)
183 abort();
184 n->ifindex = ifi->ifi_index;
185 n->name = strdup(RTA_DATA(tb[IFLA_IFNAME]));
186 memcpy(&n->ival, RTA_DATA(tb[IFLA_STATS]), sizeof(n->ival));
187 memset(&n->rate, 0, sizeof(n->rate));
188 for (i = 0; i < MAXS; i++)
189 n->val[i] = n->ival[i];
190 n->next = kern_db;
191 kern_db = n;
192 return 0;
193 }
194
195 static void load_info(void)
196 {
197 struct ifstat_ent *db, *n;
198 struct rtnl_handle rth;
199 __u32 filter_mask;
200
201 if (rtnl_open(&rth, 0) < 0)
202 exit(1);
203
204 if (is_extended) {
205 ll_init_map(&rth);
206 filter_mask = IFLA_STATS_FILTER_BIT(filter_type);
207 if (rtnl_wilddump_stats_req_filter(&rth, AF_UNSPEC, RTM_GETSTATS,
208 filter_mask) < 0) {
209 perror("Cannot send dump request");
210 exit(1);
211 }
212
213 if (rtnl_dump_filter(&rth, get_nlmsg_extended, NULL) < 0) {
214 fprintf(stderr, "Dump terminated\n");
215 exit(1);
216 }
217 } else {
218 if (rtnl_wilddump_request(&rth, AF_INET, RTM_GETLINK) < 0) {
219 perror("Cannot send dump request");
220 exit(1);
221 }
222
223 if (rtnl_dump_filter(&rth, get_nlmsg, NULL) < 0) {
224 fprintf(stderr, "Dump terminated\n");
225 exit(1);
226 }
227 }
228
229 rtnl_close(&rth);
230
231 db = kern_db;
232 kern_db = NULL;
233
234 while (db) {
235 n = db;
236 db = db->next;
237 n->next = kern_db;
238 kern_db = n;
239 }
240 }
241
242 static void load_raw_table(FILE *fp)
243 {
244 char buf[4096];
245 struct ifstat_ent *db = NULL;
246 struct ifstat_ent *n;
247
248 while (fgets(buf, sizeof(buf), fp) != NULL) {
249 char *p;
250 char *next;
251 int i;
252
253 if (buf[0] == '#') {
254 buf[strlen(buf)-1] = 0;
255 if (info_source[0] && strcmp(info_source, buf+1))
256 source_mismatch = 1;
257 strncpy(info_source, buf+1, sizeof(info_source)-1);
258 continue;
259 }
260 if ((n = malloc(sizeof(*n))) == NULL)
261 abort();
262
263 if (!(p = strchr(buf, ' ')))
264 abort();
265 *p++ = 0;
266
267 if (sscanf(buf, "%d", &n->ifindex) != 1)
268 abort();
269 if (!(next = strchr(p, ' ')))
270 abort();
271 *next++ = 0;
272
273 n->name = strdup(p);
274 p = next;
275
276 for (i = 0; i < MAXS; i++) {
277 unsigned int rate;
278
279 if (!(next = strchr(p, ' ')))
280 abort();
281 *next++ = 0;
282 if (sscanf(p, "%llu", n->val+i) != 1)
283 abort();
284 n->ival[i] = (__u32)n->val[i];
285 p = next;
286 if (!(next = strchr(p, ' ')))
287 abort();
288 *next++ = 0;
289 if (sscanf(p, "%u", &rate) != 1)
290 abort();
291 n->rate[i] = rate;
292 p = next;
293 }
294 n->next = db;
295 db = n;
296 }
297
298 while (db) {
299 n = db;
300 db = db->next;
301 n->next = kern_db;
302 kern_db = n;
303 }
304 }
305
306 static void dump_raw_db(FILE *fp, int to_hist)
307 {
308 json_writer_t *jw = json_output ? jsonw_new(fp) : NULL;
309 struct ifstat_ent *n, *h;
310
311 h = hist_db;
312 if (jw) {
313 jsonw_start_object(jw);
314 jsonw_pretty(jw, pretty);
315 jsonw_name(jw, info_source);
316 jsonw_start_object(jw);
317 } else
318 fprintf(fp, "#%s\n", info_source);
319
320 for (n = kern_db; n; n = n->next) {
321 int i;
322 unsigned long long *vals = n->val;
323 double *rates = n->rate;
324
325 if (!match(n->name)) {
326 struct ifstat_ent *h1;
327
328 if (!to_hist)
329 continue;
330 for (h1 = h; h1; h1 = h1->next) {
331 if (h1->ifindex == n->ifindex) {
332 vals = h1->val;
333 rates = h1->rate;
334 h = h1->next;
335 break;
336 }
337 }
338 }
339
340 if (jw) {
341 jsonw_name(jw, n->name);
342 jsonw_start_object(jw);
343
344 for (i = 0; i < MAXS && stats[i]; i++)
345 jsonw_uint_field(jw, stats[i], vals[i]);
346 jsonw_end_object(jw);
347 } else {
348 fprintf(fp, "%d %s ", n->ifindex, n->name);
349 for (i = 0; i < MAXS; i++)
350 fprintf(fp, "%llu %u ", vals[i],
351 (unsigned int)rates[i]);
352 fprintf(fp, "\n");
353 }
354 }
355 if (jw) {
356 jsonw_end_object(jw);
357
358 jsonw_end_object(jw);
359 jsonw_destroy(&jw);
360 }
361 }
362
363 /* use communication definitions of meg/kilo etc */
364 static const unsigned long long giga = 1000000000ull;
365 static const unsigned long long mega = 1000000;
366 static const unsigned long long kilo = 1000;
367
368 static void format_rate(FILE *fp, const unsigned long long *vals,
369 const double *rates, int i)
370 {
371 char temp[64];
372
373 if (vals[i] > giga)
374 fprintf(fp, "%7lluM ", vals[i]/mega);
375 else if (vals[i] > mega)
376 fprintf(fp, "%7lluK ", vals[i]/kilo);
377 else
378 fprintf(fp, "%8llu ", vals[i]);
379
380 if (rates[i] > mega) {
381 sprintf(temp, "%uM", (unsigned int)(rates[i]/mega));
382 fprintf(fp, "%-6s ", temp);
383 } else if (rates[i] > kilo) {
384 sprintf(temp, "%uK", (unsigned int)(rates[i]/kilo));
385 fprintf(fp, "%-6s ", temp);
386 } else
387 fprintf(fp, "%-6u ", (unsigned int)rates[i]);
388 }
389
390 static void format_pair(FILE *fp, const unsigned long long *vals, int i, int k)
391 {
392 char temp[64];
393
394 if (vals[i] > giga)
395 fprintf(fp, "%7lluM ", vals[i]/mega);
396 else if (vals[i] > mega)
397 fprintf(fp, "%7lluK ", vals[i]/kilo);
398 else
399 fprintf(fp, "%8llu ", vals[i]);
400
401 if (vals[k] > giga) {
402 sprintf(temp, "%uM", (unsigned int)(vals[k]/mega));
403 fprintf(fp, "%-6s ", temp);
404 } else if (vals[k] > mega) {
405 sprintf(temp, "%uK", (unsigned int)(vals[k]/kilo));
406 fprintf(fp, "%-6s ", temp);
407 } else
408 fprintf(fp, "%-6u ", (unsigned int)vals[k]);
409 }
410
411 static void print_head(FILE *fp)
412 {
413 fprintf(fp, "#%s\n", info_source);
414 fprintf(fp, "%-15s ", "Interface");
415
416 fprintf(fp, "%8s/%-6s ", "RX Pkts", "Rate");
417 fprintf(fp, "%8s/%-6s ", "TX Pkts", "Rate");
418 fprintf(fp, "%8s/%-6s ", "RX Data", "Rate");
419 fprintf(fp, "%8s/%-6s\n", "TX Data", "Rate");
420
421 if (!show_errors) {
422 fprintf(fp, "%-15s ", "");
423 fprintf(fp, "%8s/%-6s ", "RX Errs", "Drop");
424 fprintf(fp, "%8s/%-6s ", "TX Errs", "Drop");
425 fprintf(fp, "%8s/%-6s ", "RX Over", "Rate");
426 fprintf(fp, "%8s/%-6s\n", "TX Coll", "Rate");
427 } else {
428 fprintf(fp, "%-15s ", "");
429 fprintf(fp, "%8s/%-6s ", "RX Errs", "Rate");
430 fprintf(fp, "%8s/%-6s ", "RX Drop", "Rate");
431 fprintf(fp, "%8s/%-6s ", "RX Over", "Rate");
432 fprintf(fp, "%8s/%-6s\n", "RX Leng", "Rate");
433
434 fprintf(fp, "%-15s ", "");
435 fprintf(fp, "%8s/%-6s ", "RX Crc", "Rate");
436 fprintf(fp, "%8s/%-6s ", "RX Frm", "Rate");
437 fprintf(fp, "%8s/%-6s ", "RX Fifo", "Rate");
438 fprintf(fp, "%8s/%-6s\n", "RX Miss", "Rate");
439
440 fprintf(fp, "%-15s ", "");
441 fprintf(fp, "%8s/%-6s ", "TX Errs", "Rate");
442 fprintf(fp, "%8s/%-6s ", "TX Drop", "Rate");
443 fprintf(fp, "%8s/%-6s ", "TX Coll", "Rate");
444 fprintf(fp, "%8s/%-6s\n", "TX Carr", "Rate");
445
446 fprintf(fp, "%-15s ", "");
447 fprintf(fp, "%8s/%-6s ", "TX Abrt", "Rate");
448 fprintf(fp, "%8s/%-6s ", "TX Fifo", "Rate");
449 fprintf(fp, "%8s/%-6s ", "TX Hear", "Rate");
450 fprintf(fp, "%8s/%-6s\n", "TX Wind", "Rate");
451 }
452 }
453
454 static void print_one_json(json_writer_t *jw, const struct ifstat_ent *n,
455 const unsigned long long *vals)
456 {
457 int i, m = show_errors ? 20 : 10;
458
459 jsonw_name(jw, n->name);
460 jsonw_start_object(jw);
461
462 for (i = 0; i < m && stats[i]; i++)
463 jsonw_uint_field(jw, stats[i], vals[i]);
464
465 jsonw_end_object(jw);
466 }
467
468 static void print_one_if(FILE *fp, const struct ifstat_ent *n,
469 const unsigned long long *vals)
470 {
471 int i;
472
473 fprintf(fp, "%-15s ", n->name);
474 for (i = 0; i < 4; i++)
475 format_rate(fp, vals, n->rate, i);
476 fprintf(fp, "\n");
477
478 if (!show_errors) {
479 fprintf(fp, "%-15s ", "");
480 format_pair(fp, vals, 4, 6);
481 format_pair(fp, vals, 5, 7);
482 format_rate(fp, vals, n->rate, 11);
483 format_rate(fp, vals, n->rate, 9);
484 fprintf(fp, "\n");
485 } else {
486 fprintf(fp, "%-15s ", "");
487 format_rate(fp, vals, n->rate, 4);
488 format_rate(fp, vals, n->rate, 6);
489 format_rate(fp, vals, n->rate, 11);
490 format_rate(fp, vals, n->rate, 10);
491 fprintf(fp, "\n");
492
493 fprintf(fp, "%-15s ", "");
494 format_rate(fp, vals, n->rate, 12);
495 format_rate(fp, vals, n->rate, 13);
496 format_rate(fp, vals, n->rate, 14);
497 format_rate(fp, vals, n->rate, 15);
498 fprintf(fp, "\n");
499
500 fprintf(fp, "%-15s ", "");
501 format_rate(fp, vals, n->rate, 5);
502 format_rate(fp, vals, n->rate, 7);
503 format_rate(fp, vals, n->rate, 9);
504 format_rate(fp, vals, n->rate, 17);
505 fprintf(fp, "\n");
506
507 fprintf(fp, "%-15s ", "");
508 format_rate(fp, vals, n->rate, 16);
509 format_rate(fp, vals, n->rate, 18);
510 format_rate(fp, vals, n->rate, 19);
511 format_rate(fp, vals, n->rate, 20);
512 fprintf(fp, "\n");
513 }
514 }
515
516 static void dump_kern_db(FILE *fp)
517 {
518 json_writer_t *jw = json_output ? jsonw_new(fp) : NULL;
519 struct ifstat_ent *n;
520
521 if (jw) {
522 jsonw_start_object(jw);
523 jsonw_pretty(jw, pretty);
524 jsonw_name(jw, info_source);
525 jsonw_start_object(jw);
526 } else
527 print_head(fp);
528
529 for (n = kern_db; n; n = n->next) {
530 if (!match(n->name))
531 continue;
532
533 if (jw)
534 print_one_json(jw, n, n->val);
535 else
536 print_one_if(fp, n, n->val);
537 }
538 if (jw) {
539 jsonw_end_object(jw);
540
541 jsonw_end_object(jw);
542 jsonw_destroy(&jw);
543 }
544 }
545
546 static void dump_incr_db(FILE *fp)
547 {
548 struct ifstat_ent *n, *h;
549 json_writer_t *jw = json_output ? jsonw_new(fp) : NULL;
550
551 h = hist_db;
552 if (jw) {
553 jsonw_start_object(jw);
554 jsonw_pretty(jw, pretty);
555 jsonw_name(jw, info_source);
556 jsonw_start_object(jw);
557 } else
558 print_head(fp);
559
560 for (n = kern_db; n; n = n->next) {
561 int i;
562 unsigned long long vals[MAXS];
563 struct ifstat_ent *h1;
564
565 memcpy(vals, n->val, sizeof(vals));
566
567 for (h1 = h; h1; h1 = h1->next) {
568 if (h1->ifindex == n->ifindex) {
569 for (i = 0; i < MAXS; i++)
570 vals[i] -= h1->val[i];
571 h = h1->next;
572 break;
573 }
574 }
575 if (!match(n->name))
576 continue;
577
578 if (jw)
579 print_one_json(jw, n, n->val);
580 else
581 print_one_if(fp, n, vals);
582 }
583
584 if (jw) {
585 jsonw_end_object(jw);
586
587 jsonw_end_object(jw);
588 jsonw_destroy(&jw);
589 }
590 }
591
592 static int children;
593
594 static void sigchild(int signo)
595 {
596 }
597
598 static void update_db(int interval)
599 {
600 struct ifstat_ent *n, *h;
601
602 n = kern_db;
603 kern_db = NULL;
604
605 load_info();
606
607 h = kern_db;
608 kern_db = n;
609
610 for (n = kern_db; n; n = n->next) {
611 struct ifstat_ent *h1;
612
613 for (h1 = h; h1; h1 = h1->next) {
614 if (h1->ifindex == n->ifindex) {
615 int i;
616
617 for (i = 0; i < MAXS; i++) {
618 if ((long)(h1->ival[i] - n->ival[i]) < 0) {
619 memset(n->ival, 0, sizeof(n->ival));
620 break;
621 }
622 }
623 for (i = 0; i < MAXS; i++) {
624 double sample;
625 __u64 incr;
626
627 if (is_extended) {
628 incr = h1->val[i] - n->val[i];
629 n->val[i] = h1->val[i];
630 } else {
631 incr = (__u32) (h1->ival[i] - n->ival[i]);
632 n->val[i] += incr;
633 n->ival[i] = h1->ival[i];
634 }
635
636 sample = (double)(incr*1000)/interval;
637 if (interval >= scan_interval) {
638 n->rate[i] += W*(sample-n->rate[i]);
639 } else if (interval >= 1000) {
640 if (interval >= time_constant) {
641 n->rate[i] = sample;
642 } else {
643 double w = W*(double)interval/scan_interval;
644
645 n->rate[i] += w*(sample-n->rate[i]);
646 }
647 }
648 }
649
650 while (h != h1) {
651 struct ifstat_ent *tmp = h;
652
653 h = h->next;
654 free(tmp->name);
655 free(tmp);
656 };
657 h = h1->next;
658 free(h1->name);
659 free(h1);
660 break;
661 }
662 }
663 }
664 }
665
666 #define T_DIFF(a, b) (((a).tv_sec-(b).tv_sec)*1000 + ((a).tv_usec-(b).tv_usec)/1000)
667
668
669 static void server_loop(int fd)
670 {
671 struct timeval snaptime = { 0 };
672 struct pollfd p;
673
674 p.fd = fd;
675 p.events = p.revents = POLLIN;
676
677 sprintf(info_source, "%d.%lu sampling_interval=%d time_const=%d",
678 getpid(), (unsigned long)random(), scan_interval/1000, time_constant/1000);
679
680 load_info();
681
682 for (;;) {
683 int status;
684 time_t tdiff;
685 struct timeval now;
686
687 gettimeofday(&now, NULL);
688 tdiff = T_DIFF(now, snaptime);
689 if (tdiff >= scan_interval) {
690 update_db(tdiff);
691 snaptime = now;
692 tdiff = 0;
693 }
694
695 if (poll(&p, 1, scan_interval - tdiff) > 0
696 && (p.revents&POLLIN)) {
697 int clnt = accept(fd, NULL, NULL);
698
699 if (clnt >= 0) {
700 pid_t pid;
701
702 if (children >= 5) {
703 close(clnt);
704 } else if ((pid = fork()) != 0) {
705 if (pid > 0)
706 children++;
707 close(clnt);
708 } else {
709 FILE *fp = fdopen(clnt, "w");
710
711 if (fp)
712 dump_raw_db(fp, 0);
713 exit(0);
714 }
715 }
716 }
717 while (children && waitpid(-1, &status, WNOHANG) > 0)
718 children--;
719 }
720 }
721
722 static int verify_forging(int fd)
723 {
724 struct ucred cred;
725 socklen_t olen = sizeof(cred);
726
727 if (getsockopt(fd, SOL_SOCKET, SO_PEERCRED, (void *)&cred, &olen) ||
728 olen < sizeof(cred))
729 return -1;
730 if (cred.uid == getuid() || cred.uid == 0)
731 return 0;
732 return -1;
733 }
734
735 static void xstat_usage(void)
736 {
737 fprintf(stderr,
738 "Usage: ifstat supported xstats:\n"
739 " cpu_hits Counts only packets that went via the CPU.\n");
740 }
741
742 struct extended_stats_options_t {
743 char *name;
744 int id;
745 int sub_type;
746 };
747
748 /* Note: if one xstat name is subset of another, it should be before it in this
749 * list.
750 * Name length must be under 64 chars.
751 */
752 static const struct extended_stats_options_t extended_stats_options[] = {
753 {"cpu_hits", IFLA_STATS_LINK_OFFLOAD_XSTATS, IFLA_OFFLOAD_XSTATS_CPU_HIT},
754 };
755
756 static const char *get_filter_type(const char *name)
757 {
758 int name_len;
759 int i;
760
761 name_len = strlen(name);
762 for (i = 0; i < ARRAY_SIZE(extended_stats_options); i++) {
763 const struct extended_stats_options_t *xstat;
764
765 xstat = &extended_stats_options[i];
766 if (strncmp(name, xstat->name, name_len) == 0) {
767 filter_type = xstat->id;
768 sub_type = xstat->sub_type;
769 return xstat->name;
770 }
771 }
772
773 fprintf(stderr, "invalid ifstat extension %s\n", name);
774 xstat_usage();
775 return NULL;
776 }
777
778 static void usage(void) __attribute__((noreturn));
779
780 static void usage(void)
781 {
782 fprintf(stderr,
783 "Usage: ifstat [OPTION] [ PATTERN [ PATTERN ] ]\n"
784 " -h, --help this message\n"
785 " -a, --ignore ignore history\n"
786 " -d, --scan=SECS sample every statistics every SECS\n"
787 " -e, --errors show errors\n"
788 " -j, --json format output in JSON\n"
789 " -n, --nooutput do history only\n"
790 " -p, --pretty pretty print\n"
791 " -r, --reset reset history\n"
792 " -s, --noupdate don't update history\n"
793 " -t, --interval=SECS report average over the last SECS\n"
794 " -V, --version output version information\n"
795 " -z, --zeros show entries with zero activity\n"
796 " -x, --extended=TYPE show extended stats of TYPE\n");
797
798 exit(-1);
799 }
800
801 static const struct option longopts[] = {
802 { "help", 0, 0, 'h' },
803 { "ignore", 0, 0, 'a' },
804 { "scan", 1, 0, 'd'},
805 { "errors", 0, 0, 'e' },
806 { "nooutput", 0, 0, 'n' },
807 { "json", 0, 0, 'j' },
808 { "reset", 0, 0, 'r' },
809 { "pretty", 0, 0, 'p' },
810 { "noupdate", 0, 0, 's' },
811 { "interval", 1, 0, 't' },
812 { "version", 0, 0, 'V' },
813 { "zeros", 0, 0, 'z' },
814 { "extended", 1, 0, 'x'},
815 { 0 }
816 };
817
818 int main(int argc, char *argv[])
819 {
820 char hist_name[128];
821 struct sockaddr_un sun;
822 FILE *hist_fp = NULL;
823 const char *stats_type = NULL;
824 int ch;
825 int fd;
826
827 is_extended = false;
828 while ((ch = getopt_long(argc, argv, "hjpvVzrnasd:t:ex:",
829 longopts, NULL)) != EOF) {
830 switch (ch) {
831 case 'z':
832 dump_zeros = 1;
833 break;
834 case 'r':
835 reset_history = 1;
836 break;
837 case 'a':
838 ignore_history = 1;
839 break;
840 case 's':
841 no_update = 1;
842 break;
843 case 'n':
844 no_output = 1;
845 break;
846 case 'e':
847 show_errors = 1;
848 break;
849 case 'j':
850 json_output = 1;
851 break;
852 case 'p':
853 pretty = 1;
854 break;
855 case 'd':
856 scan_interval = atoi(optarg) * 1000;
857 if (scan_interval <= 0) {
858 fprintf(stderr, "ifstat: invalid scan interval\n");
859 exit(-1);
860 }
861 break;
862 case 't':
863 time_constant = atoi(optarg);
864 if (time_constant <= 0) {
865 fprintf(stderr, "ifstat: invalid time constant divisor\n");
866 exit(-1);
867 }
868 break;
869 case 'x':
870 stats_type = optarg;
871 is_extended = true;
872 break;
873 case 'v':
874 case 'V':
875 printf("ifstat utility, iproute2-ss%s\n", SNAPSHOT);
876 exit(0);
877 case 'h':
878 case '?':
879 default:
880 usage();
881 }
882 }
883
884 argc -= optind;
885 argv += optind;
886
887 if (stats_type) {
888 stats_type = get_filter_type(stats_type);
889 if (!stats_type)
890 exit(-1);
891 }
892
893 sun.sun_family = AF_UNIX;
894 sun.sun_path[0] = 0;
895 sprintf(sun.sun_path+1, "ifstat%d", getuid());
896
897 if (scan_interval > 0) {
898 if (time_constant == 0)
899 time_constant = 60;
900 time_constant *= 1000;
901 W = 1 - 1/exp(log(10)*(double)scan_interval/time_constant);
902 if ((fd = socket(AF_UNIX, SOCK_STREAM, 0)) < 0) {
903 perror("ifstat: socket");
904 exit(-1);
905 }
906 if (bind(fd, (struct sockaddr *)&sun, 2+1+strlen(sun.sun_path+1)) < 0) {
907 perror("ifstat: bind");
908 exit(-1);
909 }
910 if (listen(fd, 5) < 0) {
911 perror("ifstat: listen");
912 exit(-1);
913 }
914 if (daemon(0, 0)) {
915 perror("ifstat: daemon");
916 exit(-1);
917 }
918 signal(SIGPIPE, SIG_IGN);
919 signal(SIGCHLD, sigchild);
920 server_loop(fd);
921 exit(0);
922 }
923
924 patterns = argv;
925 npatterns = argc;
926
927 if (getenv("IFSTAT_HISTORY"))
928 snprintf(hist_name, sizeof(hist_name),
929 "%s", getenv("IFSTAT_HISTORY"));
930 else
931 if (!stats_type)
932 snprintf(hist_name, sizeof(hist_name),
933 "%s/.ifstat.u%d", P_tmpdir, getuid());
934 else
935 snprintf(hist_name, sizeof(hist_name),
936 "%s/.%s_ifstat.u%d", P_tmpdir, stats_type,
937 getuid());
938
939 if (reset_history)
940 unlink(hist_name);
941
942 if (!ignore_history || !no_update) {
943 struct stat stb;
944
945 fd = open(hist_name, O_RDWR|O_CREAT|O_NOFOLLOW, 0600);
946 if (fd < 0) {
947 perror("ifstat: open history file");
948 exit(-1);
949 }
950 if ((hist_fp = fdopen(fd, "r+")) == NULL) {
951 perror("ifstat: fdopen history file");
952 exit(-1);
953 }
954 if (flock(fileno(hist_fp), LOCK_EX)) {
955 perror("ifstat: flock history file");
956 exit(-1);
957 }
958 if (fstat(fileno(hist_fp), &stb) != 0) {
959 perror("ifstat: fstat history file");
960 exit(-1);
961 }
962 if (stb.st_nlink != 1 || stb.st_uid != getuid()) {
963 fprintf(stderr, "ifstat: something is so wrong with history file, that I prefer not to proceed.\n");
964 exit(-1);
965 }
966 if (!ignore_history) {
967 FILE *tfp;
968 long uptime = -1;
969
970 if ((tfp = fopen("/proc/uptime", "r")) != NULL) {
971 if (fscanf(tfp, "%ld", &uptime) != 1)
972 uptime = -1;
973 fclose(tfp);
974 }
975 if (uptime >= 0 && time(NULL) >= stb.st_mtime+uptime) {
976 fprintf(stderr, "ifstat: history is aged out, resetting\n");
977 if (ftruncate(fileno(hist_fp), 0))
978 perror("ifstat: ftruncate");
979 }
980 }
981
982 load_raw_table(hist_fp);
983
984 hist_db = kern_db;
985 kern_db = NULL;
986 }
987
988 if ((fd = socket(AF_UNIX, SOCK_STREAM, 0)) >= 0 &&
989 (connect(fd, (struct sockaddr *)&sun, 2+1+strlen(sun.sun_path+1)) == 0
990 || (strcpy(sun.sun_path+1, "ifstat0"),
991 connect(fd, (struct sockaddr *)&sun, 2+1+strlen(sun.sun_path+1)) == 0))
992 && verify_forging(fd) == 0) {
993 FILE *sfp = fdopen(fd, "r");
994
995 if (!sfp) {
996 fprintf(stderr, "ifstat: fdopen failed: %s\n",
997 strerror(errno));
998 close(fd);
999 } else {
1000 load_raw_table(sfp);
1001 if (hist_db && source_mismatch) {
1002 fprintf(stderr, "ifstat: history is stale, ignoring it.\n");
1003 hist_db = NULL;
1004 }
1005 fclose(sfp);
1006 }
1007 } else {
1008 if (fd >= 0)
1009 close(fd);
1010 if (hist_db && info_source[0] && strcmp(info_source, "kernel")) {
1011 fprintf(stderr, "ifstat: history is stale, ignoring it.\n");
1012 hist_db = NULL;
1013 info_source[0] = 0;
1014 }
1015 load_info();
1016 if (info_source[0] == 0)
1017 strcpy(info_source, "kernel");
1018 }
1019
1020 if (!no_output) {
1021 if (ignore_history || hist_db == NULL)
1022 dump_kern_db(stdout);
1023 else
1024 dump_incr_db(stdout);
1025 }
1026
1027 if (!no_update) {
1028 if (ftruncate(fileno(hist_fp), 0))
1029 perror("ifstat: ftruncate");
1030 rewind(hist_fp);
1031
1032 json_output = 0;
1033 dump_raw_db(hist_fp, 1);
1034 fclose(hist_fp);
1035 }
1036 exit(0);
1037 }
Upstream mirror of iproute2