?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
man: netsniff-ng: add description paragraph and some options
[netsniff-ng.git] / ifpps.c
blobf52a10b9ad8258c18ea73a3d342a73ef3c04636b
1 /*
2 * netsniff-ng - the packet sniffing beast
3 * Copyright 2009 - 2013 Daniel Borkmann.
4 * Subject to the GPL, version 2.
5 */
6
7 #include <stdio.h>
8 #include <string.h>
9 #include <curses.h>
10 #include <getopt.h>
11 #include <ctype.h>
12 #include <sys/socket.h>
13 #include <sys/fsuid.h>
14 #include <signal.h>
15 #include <stdint.h>
16 #include <stdlib.h>
17 #include <time.h>
18
19 #include "die.h"
20 #include "xmalloc.h"
21 #include "xutils.h"
22 #include "xio.h"
23 #include "built_in.h"
24
25 struct wifi_stat {
26 uint32_t bitrate;
27 int16_t link_qual, link_qual_max;
28 int signal_level /*, noise_level*/;
29 };
30
31 struct ifstat {
32 long long unsigned int rx_bytes, rx_packets, rx_drops, rx_errors;
33 long long unsigned int rx_fifo, rx_frame, rx_multi;
34 long long unsigned int tx_bytes, tx_packets, tx_drops, tx_errors;
35 long long unsigned int tx_fifo, tx_colls, tx_carrier;
36 long long unsigned int irqs[MAX_CPUS], irqs_srx[MAX_CPUS], irqs_stx[MAX_CPUS];
37 int64_t cpu_user[MAX_CPUS], cpu_nice[MAX_CPUS], cpu_sys[MAX_CPUS];
38 int64_t cpu_idle[MAX_CPUS], cpu_iow[MAX_CPUS], mem_free, mem_total;
39 uint32_t irq_nr, procs_run, procs_iow, cswitch, forks;
40 struct wifi_stat wifi;
41 };
42
43 volatile sig_atomic_t sigint = 0;
44
45 static struct ifstat stats_old, stats_new, stats_delta;
46
47 static int stats_loop = 0;
48
49 static WINDOW *stats_screen = NULL;
50
51 static const char *short_options = "d:t:vhclp";
52 static const struct option long_options[] = {
53 {"dev", required_argument, NULL, 'd'},
54 {"interval", required_argument, NULL, 't'},
55 {"promisc", no_argument, NULL, 'p'},
56 {"csv", no_argument, NULL, 'c'},
57 {"loop", no_argument, NULL, 'l'},
58 {"version", no_argument, NULL, 'v'},
59 {"help", no_argument, NULL, 'h'},
60 {NULL, 0, NULL, 0}
61 };
62
63 static void signal_handler(int number)
64 {
65 switch (number) {
66 case SIGINT:
67 sigint = 1;
68 break;
69 case SIGHUP:
70 default:
71 break;
72 }
73 }
74
75 static inline char *snr_to_str(int level)
76 {
77 if (level > 40)
78 return "very good signal";
79 if (level > 25 && level <= 40)
80 return "good signal";
81 if (level > 15 && level <= 25)
82 return "poor signal";
83 if (level > 10 && level <= 15)
84 return "very poor signal";
85 if (level <= 10)
86 return "no signal";
87
88 return "unknown";
89 }
90
91 static inline int iswireless(const struct ifstat *stats)
92 {
93 return stats->wifi.bitrate > 0;
94 }
95
96 static void help(void)
97 {
98 printf("\nifpps %s, top-like kernel networking and system statistics\n",
99 VERSION_STRING);
100 puts("http://www.netsniff-ng.org\n\n"
101 "Usage: ifpps [options] || ifpps <netdev>\n"
102 "Options:\n"
103 " -d|--dev <netdev> Device to fetch statistics for e.g., eth0\n"
104 " -t|--interval <time> Refresh time in ms (default 1000 ms)\n"
105 " -p|--promisc Promiscuous mode\n"
106 " -c|--csv Output to terminal as Gnuplot-ready data\n"
107 " -l|--loop Continuous CSV output\n"
108 " -v|--version Print version\n"
109 " -h|--help Print this help\n\n"
110 "Examples:\n"
111 " ifpps eth0\n"
112 " ifpps -pd eth0\n"
113 " ifpps -lpcd wlan0 > plot.dat\n\n"
114 "Note:\n"
115 " On 10G cards, RX/TX statistics are usually accumulated each > 1sec.\n"
116 " Thus, in those situations, it's good to use a -t of 10sec.\n\n"
117 "Please report bugs to <bugs@netsniff-ng.org>\n"
118 "Copyright (C) 2009-2013 Daniel Borkmann <dborkma@tik.ee.ethz.ch>\n"
119 "Swiss federal institute of technology (ETH Zurich)\n"
120 "License: GNU GPL version 2.0\n"
121 "This is free software: you are free to change and redistribute it.\n"
122 "There is NO WARRANTY, to the extent permitted by law.\n");
123 die();
124 }
125
126 static void version(void)
127 {
128 printf("\nifpps %s, top-like kernel networking and system statistics\n",
129 VERSION_STRING);
130 puts("http://www.netsniff-ng.org\n\n"
131 "Please report bugs to <bugs@netsniff-ng.org>\n"
132 "Copyright (C) 2009-2013 Daniel Borkmann <dborkma@tik.ee.ethz.ch>\n"
133 "Swiss federal institute of technology (ETH Zurich)\n"
134 "License: GNU GPL version 2.0\n"
135 "This is free software: you are free to change and redistribute it.\n"
136 "There is NO WARRANTY, to the extent permitted by law.\n");
137 die();
138 }
139
140 static int stats_proc_net_dev(const char *ifname, struct ifstat *stats)
141 {
142 int ret = -EINVAL;
143 char buff[256];
144 FILE *fp;
145
146 fp = fopen("/proc/net/dev", "r");
147 if (!fp)
148 panic("Cannot open /proc/net/dev!\n");
149
150 if (fgets(buff, sizeof(buff), fp)) { ; }
151 if (fgets(buff, sizeof(buff), fp)) { ; }
152
153 memset(buff, 0, sizeof(buff));
154
155 while (fgets(buff, sizeof(buff), fp) != NULL) {
156 buff[sizeof(buff) -1] = 0;
157
158 if (strstr(buff, ifname) == NULL)
159 continue;
160
161 if (sscanf(buff, "%*[a-z0-9 .-]:%llu%llu%llu%llu%llu%llu"
162 "%llu%*u%llu%llu%llu%llu%llu%llu%llu",
163 &stats->rx_bytes, &stats->rx_packets,
164 &stats->rx_errors, &stats->rx_drops,
165 &stats->rx_fifo, &stats->rx_frame,
166 &stats->rx_multi, &stats->tx_bytes,
167 &stats->tx_packets, &stats->tx_errors,
168 &stats->tx_drops, &stats->tx_fifo,
169 &stats->tx_colls, &stats->tx_carrier) == 14) {
170 ret = 0;
171 break;
172 }
173
174 memset(buff, 0, sizeof(buff));
175 }
176
177 fclose(fp);
178 return ret;
179 }
180
181 static int stats_proc_interrupts(char *ifname, struct ifstat *stats)
182 {
183 int ret = -EINVAL, i, cpus, try = 0;
184 char *ptr, buff[256];
185 struct ethtool_drvinfo drvinf;
186 FILE *fp;
187
188 fp = fopen("/proc/interrupts", "r");
189 if (!fp)
190 panic("Cannot open /proc/interrupts!\n");
191
192 cpus = get_number_cpus();
193 bug_on(cpus > MAX_CPUS);
194 retry:
195 fseek(fp, 0, SEEK_SET);
196 memset(buff, 0, sizeof(buff));
197
198 while (fgets(buff, sizeof(buff), fp) != NULL) {
199 buff[sizeof(buff) - 1] = 0;
200 ptr = buff;
201
202 if (strstr(buff, ifname) == NULL)
203 continue;
204
205 stats->irq_nr = strtol(ptr, &ptr, 10);
206 bug_on(stats->irq_nr == 0);
207
208 if (ptr)
209 ptr++;
210 for (i = 0; i < cpus && ptr; ++i) {
211 stats->irqs[i] = strtol(ptr, &ptr, 10);
212 if (i == cpus - 1) {
213 ret = 0;
214 goto done;
215 }
216 }
217
218 memset(buff, 0, sizeof(buff));
219 }
220
221 if (ret == -EINVAL && try == 0) {
222 memset(&drvinf, 0, sizeof(drvinf));
223 if (ethtool_drvinf(ifname, &drvinf) < 0)
224 goto done;
225
226 ifname = drvinf.driver;
227 try++;
228
229 goto retry;
230 }
231 done:
232 fclose(fp);
233 return ret;
234 }
235
236 static int stats_proc_softirqs(struct ifstat *stats)
237 {
238 int i, cpus;
239 char *ptr, buff[256];
240 FILE *fp;
241 enum {
242 softirqs_net_rx,
243 softirqs_net_tx,
244 } net_type;
245
246 fp = fopen("/proc/softirqs", "r");
247 if (!fp)
248 panic("Cannot open /proc/softirqs!\n");
249
250 cpus = get_number_cpus();
251 bug_on(cpus > MAX_CPUS);
252
253 memset(buff, 0, sizeof(buff));
254
255 while (fgets(buff, sizeof(buff), fp) != NULL) {
256 buff[sizeof(buff) - 1] = 0;
257
258 if ((ptr = strstr(buff, "NET_TX:")))
259 net_type = softirqs_net_tx;
260 else if ((ptr = strstr(buff, "NET_RX:")))
261 net_type = softirqs_net_rx;
262 else
263 continue;
264
265 for (ptr += strlen("NET_xX:"), i = 0; i < cpus; ++i) {
266 switch (net_type) {
267 case softirqs_net_tx:
268 stats->irqs_stx[i] = strtol(ptr, &ptr, 10);
269 break;
270 case softirqs_net_rx:
271 stats->irqs_srx[i] = strtol(ptr, &ptr, 10);
272 break;
273 }
274 }
275
276 memset(buff, 0, sizeof(buff));
277 }
278
279 fclose(fp);
280 return 0;
281 }
282
283 static int stats_proc_memory(struct ifstat *stats)
284 {
285 char *ptr, buff[256];
286 FILE *fp;
287
288 fp = fopen("/proc/meminfo", "r");
289 if (!fp)
290 panic("Cannot open /proc/meminfo!\n");
291
292 memset(buff, 0, sizeof(buff));
293
294 while (fgets(buff, sizeof(buff), fp) != NULL) {
295 buff[sizeof(buff) - 1] = 0;
296
297 if ((ptr = strstr(buff, "MemTotal:"))) {
298 ptr += strlen("MemTotal:");
299 stats->mem_total = strtol(ptr, &ptr, 10);
300 } else if ((ptr = strstr(buff, "MemFree:"))) {
301 ptr += strlen("MemFree:");
302 stats->mem_free = strtol(ptr, &ptr, 10);
303 }
304
305 memset(buff, 0, sizeof(buff));
306 }
307
308 fclose(fp);
309 return 0;
310 }
311
312 static int stats_proc_system(struct ifstat *stats)
313 {
314 int cpu, cpus;
315 char *ptr, buff[256];
316 FILE *fp;
317
318 fp = fopen("/proc/stat", "r");
319 if (!fp)
320 panic("Cannot open /proc/stat!\n");
321
322 cpus = get_number_cpus();
323 bug_on(cpus > MAX_CPUS);
324
325 memset(buff, 0, sizeof(buff));
326
327 while (fgets(buff, sizeof(buff), fp) != NULL) {
328 buff[sizeof(buff) - 1] = 0;
329
330 if ((ptr = strstr(buff, "cpu"))) {
331 ptr += strlen("cpu");
332 if (isblank(*ptr))
333 goto next;
334
335 cpu = strtol(ptr, &ptr, 10);
336 bug_on(cpu > cpus);
337
338 if (sscanf(ptr, "%lu%lu%lu%lu%lu",
339 &stats->cpu_user[cpu],
340 &stats->cpu_nice[cpu],
341 &stats->cpu_sys[cpu],
342 &stats->cpu_idle[cpu],
343 &stats->cpu_iow[cpu]) != 5)
344 goto next;
345 } else if ((ptr = strstr(buff, "ctxt"))) {
346 ptr += strlen("ctxt");
347 stats->cswitch = strtoul(ptr, &ptr, 10);
348 } else if ((ptr = strstr(buff, "processes"))) {
349 ptr += strlen("processes");
350 stats->forks = strtoul(ptr, &ptr, 10);
351 } else if ((ptr = strstr(buff, "procs_running"))) {
352 ptr += strlen("procs_running");
353 stats->procs_run = strtoul(ptr, &ptr, 10);
354 } else if ((ptr = strstr(buff, "procs_blocked"))) {
355 ptr += strlen("procs_blocked");
356 stats->procs_iow = strtoul(ptr, &ptr, 10);
357 }
358 next:
359 memset(buff, 0, sizeof(buff));
360 }
361
362 fclose(fp);
363 return 0;
364 }
365
366 static int adjust_dbm_level(int in_dbm, int dbm_val)
367 {
368 if (!in_dbm)
369 return dbm_val;
370
371 return dbm_val - 0x100;
372 }
373
374 static int stats_wireless(const char *ifname, struct ifstat *stats)
375 {
376 int ret;
377 struct iw_statistics ws;
378
379 ret = wireless_sigqual(ifname, &ws);
380 if (ret != 0) {
381 stats->wifi.bitrate = 0;
382 return -EINVAL;
383 }
384
385 stats->wifi.bitrate = wireless_bitrate(ifname);
386
387 stats->wifi.signal_level =
388 adjust_dbm_level(ws.qual.updated & IW_QUAL_DBM, ws.qual.level);
389
390 stats->wifi.link_qual = ws.qual.qual;
391 stats->wifi.link_qual_max = wireless_rangemax_sigqual(ifname);
392
393 return ret;
394 }
395
396 #define DIFF1(member) do { diff->member = new->member - old->member; } while (0)
397 #define DIFF(member) do { \
398 if (sizeof(diff->member) != sizeof(new->member) || \
399 sizeof(diff->member) != sizeof(old->member)) \
400 bug(); \
401 bug_on((new->member - old->member) > (new->member)); \
402 DIFF1(member); \
403 } while (0)
404
405 static void stats_diff(struct ifstat *old, struct ifstat *new,
406 struct ifstat *diff)
407 {
408 int cpus, i;
409
410 DIFF(rx_bytes);
411 DIFF(rx_packets);
412 DIFF(rx_drops);
413 DIFF(rx_errors);
414 DIFF(rx_fifo);
415 DIFF(rx_frame);
416 DIFF(rx_multi);
417
418 DIFF(tx_bytes);
419 DIFF(tx_bytes);
420 DIFF(tx_packets);
421 DIFF(tx_drops);
422 DIFF(tx_errors);
423 DIFF(tx_fifo);
424 DIFF(tx_colls);
425 DIFF(tx_carrier);
426
427 DIFF1(procs_run);
428 DIFF1(procs_iow);
429
430 DIFF1(wifi.signal_level);
431 DIFF1(wifi.link_qual);
432
433 DIFF1(cswitch);
434 DIFF1(forks);
435
436 cpus = get_number_cpus();
437 bug_on(cpus > MAX_CPUS);
438
439 for (i = 0; i < cpus; ++i) {
440 DIFF(irqs[i]);
441 DIFF(irqs_srx[i]);
442 DIFF(irqs_stx[i]);
443
444 DIFF1(cpu_user[i]);
445 DIFF1(cpu_nice[i]);
446 DIFF1(cpu_sys[i]);
447 DIFF1(cpu_idle[i]);
448 DIFF1(cpu_iow[i]);
449 }
450 }
451
452 static void stats_fetch(const char *ifname, struct ifstat *stats)
453 {
454 if (stats_proc_net_dev(ifname, stats) < 0)
455 panic("Cannot fetch device stats!\n");
456 if (stats_proc_softirqs(stats) < 0)
457 panic("Cannot fetch software interrupts!\n");
458 if (stats_proc_memory(stats) < 0)
459 panic("Cannot fetch memory stats!\n");
460 if (stats_proc_system(stats) < 0)
461 panic("Cannot fetch system stats!\n");
462
463 stats_proc_interrupts((char *) ifname, stats);
464
465 stats_wireless(ifname, stats);
466 }
467
468 static void stats_sample_generic(const char *ifname, uint64_t ms_interval)
469 {
470 memset(&stats_old, 0, sizeof(stats_old));
471 memset(&stats_new, 0, sizeof(stats_new));
472 memset(&stats_delta, 0, sizeof(stats_delta));
473
474 stats_fetch(ifname, &stats_old);
475 usleep(ms_interval * 1000);
476 stats_fetch(ifname, &stats_new);
477
478 stats_diff(&stats_old, &stats_new, &stats_delta);
479 }
480
481 static void screen_init(WINDOW **screen)
482 {
483 (*screen) = initscr();
484
485 raw();
486 noecho();
487 cbreak();
488 nodelay((*screen), TRUE);
489
490 keypad(stdscr, TRUE);
491
492 refresh();
493 wrefresh((*screen));
494 }
495
496 static void screen_header(WINDOW *screen, const char *ifname, int *voff,
497 uint64_t ms_interval)
498 {
499 size_t len = 0;
500 char buff[64];
501 struct ethtool_drvinfo drvinf;
502 u32 rate = device_bitrate(ifname);
503 int link = ethtool_link(ifname);
504
505 memset(&drvinf, 0, sizeof(drvinf));
506 ethtool_drvinf(ifname, &drvinf);
507
508 memset(buff, 0, sizeof(buff));
509 if (rate)
510 len += snprintf(buff + len, sizeof(buff) - len, " %uMbit/s", rate);
511 if (link >= 0)
512 len += snprintf(buff + len, sizeof(buff) - len, " link:%s",
513 link == 0 ? "no" : "yes");
514
515 mvwprintw(screen, (*voff)++, 2,
516 "Kernel net/sys statistics for %s (%s%s), t=%lums"
517 " ",
518 ifname, drvinf.driver, buff, ms_interval);
519 }
520
521 static void screen_net_dev_rel(WINDOW *screen, const struct ifstat *rel,
522 int *voff)
523 {
524 attron(A_REVERSE);
525
526 mvwprintw(screen, (*voff)++, 0,
527 " RX: %16.3llf MiB/t "
528 "%10llu pkts/t "
529 "%10llu drops/t "
530 "%10llu errors/t ",
531 ((long double) rel->rx_bytes) / (1LLU << 20),
532 rel->rx_packets, rel->rx_drops, rel->rx_errors);
533
534 mvwprintw(screen, (*voff)++, 0,
535 " TX: %16.3llf MiB/t "
536 "%10llu pkts/t "
537 "%10llu drops/t "
538 "%10llu errors/t ",
539 ((long double) rel->tx_bytes) / (1LLU << 20),
540 rel->tx_packets, rel->tx_drops, rel->tx_errors);
541
542 attroff(A_REVERSE);
543 }
544
545 static void screen_net_dev_abs(WINDOW *screen, const struct ifstat *abs,
546 int *voff)
547 {
548 mvwprintw(screen, (*voff)++, 2,
549 "RX: %16.3llf MiB "
550 "%10llu pkts "
551 "%10llu drops "
552 "%10llu errors",
553 ((long double) abs->rx_bytes) / (1LLU << 20),
554 abs->rx_packets, abs->rx_drops, abs->rx_errors);
555
556 mvwprintw(screen, (*voff)++, 2,
557 "TX: %16.3llf MiB "
558 "%10llu pkts "
559 "%10llu drops "
560 "%10llu errors",
561 ((long double) abs->tx_bytes) / (1LLU << 20),
562 abs->tx_packets, abs->tx_drops, abs->tx_errors);
563 }
564
565 static void screen_sys_mem(WINDOW *screen, const struct ifstat *rel,
566 const struct ifstat *abs, int *voff)
567 {
568 mvwprintw(screen, (*voff)++, 2,
569 "SYS: %14u cs/t "
570 "%10.1lf%% mem "
571 "%13u running "
572 "%10u iowait",
573 rel->cswitch,
574 (100.0 * (abs->mem_total - abs->mem_free)) / abs->mem_total,
575 abs->procs_run, abs->procs_iow);
576 }
577
578 static void screen_percpu_states(WINDOW *screen, const struct ifstat *rel,
579 int cpus, int *voff)
580 {
581 int i;
582 uint64_t all;
583
584 for (i = 0; i < cpus; ++i) {
585 all = rel->cpu_user[i] + rel->cpu_nice[i] + rel->cpu_sys[i] +
586 rel->cpu_idle[i] + rel->cpu_iow[i];
587
588 mvwprintw(screen, (*voff)++, 2,
589 "CPU%d: %13.1lf%% usr/t "
590 "%9.1lf%% sys/t "
591 "%10.1lf%% idl/t "
592 "%11.1lf%% iow/t ", i,
593 100.0 * (rel->cpu_user[i] + rel->cpu_nice[i]) / all,
594 100.0 * rel->cpu_sys[i] / all,
595 100.0 * rel->cpu_idle[i] / all,
596 100.0 * rel->cpu_iow[i] / all);
597 }
598 }
599
600 static void screen_percpu_irqs_rel(WINDOW *screen, const struct ifstat *rel,
601 int cpus, int *voff)
602 {
603 int i;
604
605 for (i = 0; i < cpus; ++i) {
606 mvwprintw(screen, (*voff)++, 2,
607 "CPU%d: %14llu irqs/t "
608 "%15llu soirq RX/t "
609 "%15llu soirq TX/t ", i,
610 rel->irqs[i],
611 rel->irqs_srx[i],
612 rel->irqs_stx[i]);
613 }
614 }
615
616 static void screen_percpu_irqs_abs(WINDOW *screen, const struct ifstat *abs,
617 int cpus, int *voff)
618 {
619 int i;
620
621 for (i = 0; i < cpus; ++i) {
622 mvwprintw(screen, (*voff)++, 2,
623 "CPU%d: %14llu irqs", i,
624 abs->irqs[i]);
625 }
626 }
627
628 static void screen_wireless(WINDOW *screen, const struct ifstat *rel,
629 const struct ifstat *abs, int *voff)
630 {
631 if (iswireless(abs)) {
632 mvwprintw(screen, (*voff)++, 2,
633 "LinkQual: %7d/%d (%d/t) ",
634 abs->wifi.link_qual,
635 abs->wifi.link_qual_max,
636 rel->wifi.link_qual);
637
638 mvwprintw(screen, (*voff)++, 2,
639 "Signal: %8d dBm (%d dBm/t) ",
640 abs->wifi.signal_level,
641 rel->wifi.signal_level);
642 }
643 }
644
645 static void screen_update(WINDOW *screen, const char *ifname, const struct ifstat *rel,
646 const struct ifstat *abs, int *first, uint64_t ms_interval)
647 {
648 int cpus, voff = 1, cvoff = 2;
649
650 curs_set(0);
651
652 cpus = get_number_cpus();
653 bug_on(cpus > MAX_CPUS);
654
655 screen_header(screen, ifname, &voff, ms_interval);
656
657 voff++;
658 screen_net_dev_rel(screen, rel, &voff);
659
660 voff++;
661 screen_net_dev_abs(screen, abs, &voff);
662
663 voff++;
664 screen_sys_mem(screen, rel, abs, &voff);
665
666 voff++;
667 screen_percpu_states(screen, rel, cpus, &voff);
668
669 voff++;
670 screen_percpu_irqs_rel(screen, rel, cpus, &voff);
671
672 voff++;
673 screen_percpu_irqs_abs(screen, abs, cpus, &voff);
674
675 voff++;
676 screen_wireless(screen, rel, abs, &voff);
677
678 if (*first) {
679 mvwprintw(screen, cvoff, 2, "Collecting data ...");
680 *first = 0;
681 } else {
682 mvwprintw(screen, cvoff, 2, " ");
683 }
684
685 wrefresh(screen);
686 refresh();
687 }
688
689 static void screen_end(void)
690 {
691 endwin();
692 }
693
694 static int screen_main(const char *ifname, uint64_t ms_interval)
695 {
696 int first = 1, key;
697
698 screen_init(&stats_screen);
699
700 while (!sigint) {
701 key = getch();
702 if (key == 'q' || key == 0x1b || key == KEY_F(10))
703 break;
704
705 screen_update(stats_screen, ifname, &stats_delta, &stats_new,
706 &first, ms_interval);
707
708 stats_sample_generic(ifname, ms_interval);
709 }
710
711 screen_end();
712
713 return 0;
714 }
715
716 static void term_csv(const char *ifname, const struct ifstat *rel,
717 const struct ifstat *abs, uint64_t ms_interval)
718 {
719 int cpus, i;
720
721 printf("%ld ", time(0));
722
723 printf("%llu ", rel->rx_bytes);
724 printf("%llu ", rel->rx_packets);
725 printf("%llu ", rel->rx_drops);
726 printf("%llu ", rel->rx_errors);
727
728 printf("%llu ", abs->rx_bytes);
729 printf("%llu ", abs->rx_packets);
730 printf("%llu ", abs->rx_drops);
731 printf("%llu ", abs->rx_errors);
732
733 printf("%llu ", rel->tx_bytes);
734 printf("%llu ", rel->tx_packets);
735 printf("%llu ", rel->tx_drops);
736 printf("%llu ", rel->tx_errors);
737
738 printf("%llu ", abs->tx_bytes);
739 printf("%llu ", abs->tx_packets);
740 printf("%llu ", abs->tx_drops);
741 printf("%llu ", abs->tx_errors);
742
743 printf("%u ", rel->cswitch);
744 printf("%lu ", abs->mem_free);
745 printf("%lu ", abs->mem_total - abs->mem_free);
746 printf("%lu ", abs->mem_total);
747 printf("%u ", abs->procs_run);
748 printf("%u ", abs->procs_iow);
749
750 cpus = get_number_cpus();
751 bug_on(cpus > MAX_CPUS);
752
753 for (i = 0; i < cpus; ++i) {
754 printf("%lu ", rel->cpu_user[i]);
755 printf("%lu ", rel->cpu_nice[i]);
756 printf("%lu ", rel->cpu_sys[i]);
757 printf("%lu ", rel->cpu_idle[i]);
758 printf("%lu ", rel->cpu_iow[i]);
759
760 printf("%llu ", rel->irqs[i]);
761 printf("%llu ", abs->irqs[i]);
762
763 printf("%llu ", rel->irqs_srx[i]);
764 printf("%llu ", abs->irqs_srx[i]);
765
766 printf("%llu ", rel->irqs_stx[i]);
767 printf("%llu ", abs->irqs_stx[i]);
768 }
769
770 if (iswireless(abs)) {
771 printf("%u ", rel->wifi.link_qual);
772 printf("%u ", abs->wifi.link_qual);
773 printf("%u ", abs->wifi.link_qual_max);
774
775 printf("%d ", rel->wifi.signal_level);
776 printf("%d ", abs->wifi.signal_level);
777 }
778
779 puts("");
780 fflush(stdout);
781 }
782
783 static void term_csv_header(const char *ifname, const struct ifstat *abs,
784 uint64_t ms_interval)
785 {
786 int cpus, i, j = 1;
787
788 printf("# gnuplot dump (#col:description)\n");
789 printf("# networking interface: %s\n", ifname);
790 printf("# sampling interval (t): %lu ms\n", ms_interval);
791 printf("# %d:unixtime ", j++);
792
793 printf("%d:rx-bytes-per-t ", j++);
794 printf("%d:rx-pkts-per-t ", j++);
795 printf("%d:rx-drops-per-t ", j++);
796 printf("%d:rx-errors-per-t ", j++);
797
798 printf("%d:rx-bytes ", j++);
799 printf("%d:rx-pkts ", j++);
800 printf("%d:rx-drops ", j++);
801 printf("%d:rx-errors ", j++);
802
803 printf("%d:tx-bytes-per-t ", j++);
804 printf("%d:tx-pkts-per-t ", j++);
805 printf("%d:tx-drops-per-t ", j++);
806 printf("%d:tx-errors-per-t ", j++);
807
808 printf("%d:tx-bytes ", j++);
809 printf("%d:tx-pkts ", j++);
810 printf("%d:tx-drops ", j++);
811 printf("%d:tx-errors ", j++);
812
813 printf("%d:context-switches-per-t ", j++);
814 printf("%d:mem-free ", j++);
815 printf("%d:mem-used ", j++);
816 printf("%d:mem-total ", j++);
817 printf("%d:procs-in-run ", j++);
818 printf("%d:procs-in-iow ", j++);
819
820 cpus = get_number_cpus();
821 bug_on(cpus > MAX_CPUS);
822
823 for (i = 0, j = 22; i < cpus; ++i) {
824 printf("%d:cpu%i-usr-per-t ", j++, i);
825 printf("%d:cpu%i-nice-per-t ", j++, i);
826 printf("%d:cpu%i-sys-per-t ", j++, i);
827 printf("%d:cpu%i-idle-per-t ", j++, i);
828 printf("%d:cpu%i-iow-per-t ", j++, i);
829
830 printf("%d:cpu%i-net-irqs-per-t ", j++, i);
831 printf("%d:cpu%i-net-irqs ", j++, i);
832
833 printf("%d:cpu%i-net-rx-soft-irqs-per-t ", j++, i);
834 printf("%d:cpu%i-net-rx-soft-irqs ", j++, i);
835 printf("%d:cpu%i-net-tx-soft-irqs-per-t ", j++, i);
836 printf("%d:cpu%i-net-tx-soft-irqs ", j++, i);
837 }
838
839 if (iswireless(abs)) {
840 printf("%d:wifi-link-qual-per-t ", j++);
841 printf("%d:wifi-link-qual ", j++);
842 printf("%d:wifi-link-qual-max ", j++);
843
844 printf("%d:wifi-signal-dbm-per-t ", j++);
845 printf("%d:wifi-signal-dbm ", j++);
846 }
847
848 puts("");
849 printf("# data:\n");
850 fflush(stdout);
851 }
852
853 static int term_main(const char *ifname, uint64_t ms_interval)
854 {
855 int first = 1;
856
857 do {
858 stats_sample_generic(ifname, ms_interval);
859
860 if (first) {
861 first = 0;
862 term_csv_header(ifname, &stats_new, ms_interval);
863 }
864
865 term_csv(ifname, &stats_delta, &stats_new, ms_interval);
866 } while (stats_loop && !sigint);
867
868 return 0;
869 }
870
871 int main(int argc, char **argv)
872 {
873 short ifflags = 0;
874 int c, opt_index, ret, promisc = 0;
875 uint64_t interval = 1000;
876 char *ifname = NULL;
877 int (*func_main)(const char *ifname, uint64_t ms_interval) = screen_main;
878
879 setfsuid(getuid());
880 setfsgid(getgid());
881
882 while ((c = getopt_long(argc, argv, short_options, long_options,
883 &opt_index)) != EOF) {
884 switch (c) {
885 case 'h':
886 help();
887 break;
888 case 'v':
889 version();
890 break;
891 case 'd':
892 ifname = xstrndup(optarg, IFNAMSIZ);
893 break;
894 case 't':
895 interval = strtol(optarg, NULL, 10);
896 break;
897 case 'l':
898 stats_loop = 1;
899 break;
900 case 'p':
901 promisc = 1;
902 break;
903 case 'c':
904 func_main = term_main;
905 break;
906 case '?':
907 switch (optopt) {
908 case 'd':
909 case 't':
910 panic("Option -%c requires an argument!\n",
911 optopt);
912 default:
913 if (isprint(optopt))
914 printf("Unknown option character `0x%X\'!\n", optopt);
915 die();
916 }
917 default:
918 break;
919 }
920 }
921
922 if (argc == 1)
923 help();
924
925 if (argc == 2)
926 ifname = xstrndup(argv[1], IFNAMSIZ);
927 if (ifname == NULL)
928 panic("No networking device given!\n");
929
930 if (!strncmp("lo", ifname, IFNAMSIZ))
931 panic("lo is not supported!\n");
932 if (device_mtu(ifname) == 0)
933 panic("This is no networking device!\n");
934
935 register_signal(SIGINT, signal_handler);
936 register_signal(SIGHUP, signal_handler);
937
938 if (promisc)
939 ifflags = enter_promiscuous_mode(ifname);
940 ret = func_main(ifname, interval);
941 if (promisc)
942 leave_promiscuous_mode(ifname, ifflags);
943
944 xfree(ifname);
945 return ret;
946 }
netsniff-ng toolkit, the packet sniffing beast, staging tree