ifpps.c

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