/*
 * netsniff-ng - the packet sniffing beast
 * Copyright 2009 - 2013 Daniel Borkmann.
 * Copyright 2013 Tobias Klauser
 * Subject to the GPL, version 2.
 */

#include <stdio.h>
#include <string.h>
#include <curses.h>
#include <getopt.h>
#include <ctype.h>
#include <inttypes.h>
#include <sys/socket.h>
#include <sys/fsuid.h>
#include <sys/types.h>
#include <sys/utsname.h>
#include <signal.h>
#include <stdint.h>
#include <stdlib.h>
#include <time.h>
#include <dirent.h>

#include "die.h"
#include "dev.h"
#include "sig.h"
#include "str.h"
#include "link.h"
#include "xmalloc.h"
#include "ioops.h"
#include "cpus.h"
#include "config.h"
#include "built_in.h"
#include "screen.h"

struct wifi_stat {
	uint32_t bitrate;
	int16_t link_qual, link_qual_max;
	int signal_level /*, noise_level*/;
};

struct ifstat {
	long long unsigned int rx_bytes, rx_packets, rx_drops, rx_errors;
	long long unsigned int rx_fifo, rx_frame, rx_multi;
	long long unsigned int tx_bytes, tx_packets, tx_drops, tx_errors;
	long long unsigned int tx_fifo, tx_colls, tx_carrier;
	uint64_t mem_free, mem_total, mem_active, mem_inactive;
	uint64_t swap_total, swap_free, swap_cached;
	uint32_t procs_total, procs_run, procs_iow, cswitch;
	struct wifi_stat wifi;
	/*
	 * Pointer members need to be last in order for stats_zero() to work
	 * properly.
	 */
	long long unsigned int *irqs, *irqs_srx, *irqs_stx;
	uint64_t *cpu_user, *cpu_sys, *cpu_nice, *cpu_idle, *cpu_iow;
};

struct cpu_hit {
	unsigned int idx;
	uint64_t hit;
	long long unsigned int irqs_rel, irqs_abs;
};

struct avg_stat {
	uint64_t cpu_user, cpu_sys, cpu_nice, cpu_idle, cpu_iow;
	long double irqs_abs, irqs_rel, irqs_srx_rel, irqs_stx_rel;
};

static volatile sig_atomic_t sigint = 0;
static struct ifstat stats_old, stats_new, stats_delta;
static struct cpu_hit *cpu_hits;
static struct avg_stat stats_avg;
static int stats_loop = 0;
static int show_median = 0, show_percentage = 0;
static WINDOW *stats_screen = NULL;
static struct utsname uts;

static const char *short_options = "d:n:t:clmopPWvh";
static const struct option long_options[] = {
	{"dev",			required_argument,	NULL, 'd'},
	{"num-cpus",		required_argument,	NULL, 'n'},
	{"interval",		required_argument,	NULL, 't'},
	{"csv",			no_argument,		NULL, 'c'},
	{"loop",		no_argument,		NULL, 'l'},
	{"median",		no_argument,		NULL, 'm'},
	{"omit-header",		no_argument,		NULL, 'o'},
	{"promisc",		no_argument,		NULL, 'p'},
	{"percentage",		no_argument,		NULL, 'P'},
	{"no-warn",		no_argument,		NULL, 'W'},
	{"version",		no_argument,		NULL, 'v'},
	{"help",		no_argument,		NULL, 'h'},
	{NULL, 0, NULL, 0}
};

static const char *copyright =
	"Please report bugs at https://github.com/netsniff-ng/netsniff-ng/issues\n"
	"Copyright (C) 2009-2013 Daniel Borkmann <dborkma@tik.ee.ethz.ch>\n"
	"Swiss federal institute of technology (ETH Zurich)\n"
	"Copyright (C) 2013 Tobias Klauser <tklauser@distanz.ch>\n"
	"License: GNU GPL version 2.0\n"
	"This is free software: you are free to change and redistribute it.\n"
	"There is NO WARRANTY, to the extent permitted by law.";

static void signal_handler(int number)
{
	switch (number) {
	case SIGINT:
	case SIGQUIT:
	case SIGTERM:
		sigint = 1;
		break;
	case SIGHUP:
	default:
		break;
	}
}

static inline int iswireless(const struct ifstat *stats)
{
	return stats->wifi.bitrate > 0;
}

static void __noreturn help(void)
{
	printf("ifpps %s, top-like kernel networking and system statistics\n",
	       VERSION_STRING);
	puts("http://www.netsniff-ng.org\n\n"
	     "Usage: ifpps [options] || ifpps <netdev>\n"
	     "Options:\n"
	     "  -d|--dev <netdev>      Device to fetch statistics for e.g., eth0\n"
	     "  -n|--num-cpus <num>    Number of top hitter CPUs in ncurses mode (def: 5)\n"
	     "  -t|--interval <time>   Refresh time in ms (default 1000 ms)\n"
	     "  -c|--csv               Output to terminal as Gnuplot-ready data\n"
	     "  -l|--loop              Continuous CSV output\n"
	     "  -m|--median            Display median values\n"
	     "  -o|--omit-header       Do not print the CSV header\n"
	     "  -p|--promisc           Promiscuous mode\n"
	     "  -P|--percentage        Show percentage of theoretical line rate\n"
	     "  -W|--no-warn           Suppress warnings\n"
	     "  -v|--version           Print version and exit\n"
	     "  -h|--help              Print this help and exit\n\n"
	     "Examples:\n"
	     "  ifpps eth0\n"
	     "  ifpps -pd eth0\n"
	     "  ifpps -lpcd wlan0 > plot.dat\n\n"
	     "Note:\n"
	     "  On 10G cards, RX/TX statistics are usually accumulated each > 1sec.\n"
	     "  Thus, in those situations, it's good to use a -t of 10sec.\n");
	puts(copyright);
	die();
}

static void __noreturn version(void)
{
	printf("ifpps %s, Git id: %s\n", VERSION_LONG, GITVERSION);
	puts("top-like kernel networking and system statistics\n"
	     "http://www.netsniff-ng.org\n");
	puts(copyright);
	die();
}

static inline int padding_from_num(int n)
{
	int i = 0;
	do {
		i++;
	} while ((n /= 10) > 0);
	return i;
}

#define STATS_ALLOC1(member)	\
	do { stats->member = xcalloc(cpus, sizeof(*(stats->member))); } while (0)

static void stats_alloc(struct ifstat *stats, unsigned int cpus)
{
	STATS_ALLOC1(irqs);
	STATS_ALLOC1(irqs_srx);
	STATS_ALLOC1(irqs_stx);

	STATS_ALLOC1(cpu_user);
	STATS_ALLOC1(cpu_sys);
	STATS_ALLOC1(cpu_nice);
	STATS_ALLOC1(cpu_idle);
	STATS_ALLOC1(cpu_iow);
}

#define STATS_ZERO1(member)	\
	do { memset(stats->member, 0, cpus * sizeof(*(stats->member))); } while (0)

static void stats_zero(struct ifstat *stats, unsigned int cpus)
{
	/* Only clear the non-pointer members */
	memset(stats, 0, offsetof(struct ifstat, irqs));

	STATS_ZERO1(irqs);
	STATS_ZERO1(irqs_srx);
	STATS_ZERO1(irqs_stx);

	STATS_ZERO1(cpu_user);
	STATS_ZERO1(cpu_sys);
	STATS_ZERO1(cpu_nice);
	STATS_ZERO1(cpu_idle);
	STATS_ZERO1(cpu_iow);
}

#define STATS_RELEASE(member)	\
	do { xfree(stats->member); } while (0)

static void stats_release(struct ifstat *stats)
{
	STATS_RELEASE(irqs);
	STATS_RELEASE(irqs_srx);
	STATS_RELEASE(irqs_stx);

	STATS_RELEASE(cpu_user);
	STATS_RELEASE(cpu_sys);
	STATS_RELEASE(cpu_nice);
	STATS_RELEASE(cpu_idle);
	STATS_RELEASE(cpu_iow);
}

static int stats_proc_net_dev(const char *ifname, struct ifstat *stats)
{
	int ret = -EINVAL;
	char buff[256];
	char *ifname_colon;
	FILE *fp;

	fp = fopen("/proc/net/dev", "r");
	if (!fp)
		panic("Cannot open /proc/net/dev!\n");

	ifname_colon = xstrndup(ifname, strlen(ifname) + 2);
	ifname_colon[strlen(ifname)]   = ':';
	ifname_colon[strlen(ifname) + 1] = '\0';

	if (fgets(buff, sizeof(buff), fp)) { ; }
	if (fgets(buff, sizeof(buff), fp)) { ; }

	memset(buff, 0, sizeof(buff));

	while (fgets(buff, sizeof(buff), fp) != NULL) {
		buff[sizeof(buff) - 1] = 0;

		if (strstr(buff, ifname_colon) == NULL)
			continue;

		if (sscanf(buff, "%*[a-zA-Z0-9_ .-]:%llu%llu%llu%llu%llu%llu"
			   "%llu%*u%llu%llu%llu%llu%llu%llu%llu",
			   &stats->rx_bytes, &stats->rx_packets,
			   &stats->rx_errors, &stats->rx_drops,
			   &stats->rx_fifo, &stats->rx_frame,
			   &stats->rx_multi, &stats->tx_bytes,
			   &stats->tx_packets, &stats->tx_errors,
			   &stats->tx_drops, &stats->tx_fifo,
			   &stats->tx_colls, &stats->tx_carrier) == 14) {
			ret = 0;
			break;
		}

		memset(buff, 0, sizeof(buff));
	}

	xfree(ifname_colon);
	fclose(fp);
	return ret;
}

static int stats_proc_interrupts(char *ifname, struct ifstat *stats)
{
	int ret = -EINVAL, try = 0;
	unsigned int i, cpus;
	char *ptr, *buff;
	bool seen = false;
	size_t buff_len;
	struct ethtool_drvinfo drvinf;
	FILE *fp;

	cpus = get_number_cpus();
	buff_len = cpus * 128;
	buff = xmalloc(buff_len);

	fp = fopen("/proc/interrupts", "r");
	if (!fp)
		panic("Cannot open /proc/interrupts!\n");
retry:
	fseek(fp, 0, SEEK_SET);
	memset(buff, 0, buff_len);

	while (fgets(buff, buff_len, fp) != NULL) {
		buff[buff_len - 1] = 0;

		if (strstr(buff, ifname) == NULL)
			continue;

		ptr = strchr(buff, ':');
		if (!ptr)
			continue;
		ptr++;

		for (i = 0; i < cpus && ptr; ++i) {
			if (seen)
				stats->irqs[i] += strtol(ptr, &ptr, 10);
			else
				stats->irqs[i] = strtol(ptr, &ptr, 10);
			if (i == cpus - 1) {
				ret = 0;
				seen = true;
			}
		}

		memset(buff, 0, buff_len);
	}

	if (ret == -EINVAL && try == 0) {
		if (ethtool_drvinf(ifname, &drvinf) < 0)
			goto done;

		ifname = drvinf.driver;
		try++;

		goto retry;
	}
done:
	xfree(buff);
	fclose(fp);
	return ret;
}

static int stats_proc_softirqs(struct ifstat *stats)
{
	unsigned int i, cpus;
	char *ptr, *buff;
	size_t buff_len;
	FILE *fp;
	enum {
		softirqs_net_rx,
		softirqs_net_tx,
	} net_type;

	fp = fopen("/proc/softirqs", "r");
	if (!fp)
		panic("Cannot open /proc/softirqs!\n");

	cpus = get_number_cpus();
	buff_len = cpus * 128;
	buff = xmalloc(buff_len);

	memset(buff, 0, buff_len);

	while (fgets(buff, buff_len, fp) != NULL) {
		buff[buff_len - 1] = 0;

		if ((ptr = strstr(buff, "NET_TX:")))
			net_type = softirqs_net_tx;
		else if ((ptr = strstr(buff, "NET_RX:")))
			net_type = softirqs_net_rx;
		else
			continue;

		ptr += strlen("NET_xX:");

		for (i = 0; i < cpus; ++i) {
			switch (net_type) {
			case softirqs_net_tx:
				stats->irqs_stx[i] = strtol(ptr, &ptr, 10);
				break;
			case softirqs_net_rx:
				stats->irqs_srx[i] = strtol(ptr, &ptr, 10);
				break;
			}
		}

		memset(buff, 0, buff_len);
	}

	xfree(buff);
	fclose(fp);
	return 0;
}

static int stats_proc_memory(struct ifstat *stats)
{
	char *ptr, buff[256];
	FILE *fp;

	fp = fopen("/proc/meminfo", "r");
	if (!fp)
		panic("Cannot open /proc/meminfo!\n");

	memset(buff, 0, sizeof(buff));

	while (fgets(buff, sizeof(buff), fp) != NULL) {
		buff[sizeof(buff) - 1] = 0;

		if ((ptr = strstr(buff, "MemTotal:"))) {
			ptr += strlen("MemTotal:");
			stats->mem_total = strtoul(ptr, &ptr, 10);
		} else if ((ptr = strstr(buff, "MemFree:"))) {
			ptr += strlen("MemFree:");
			stats->mem_free = strtoul(ptr, &ptr, 10);
		} else if ((ptr = strstr(buff, "Active:"))) {
			ptr += strlen("Active:");
			stats->mem_active = strtoul(ptr, &ptr, 10);
		} else if ((ptr = strstr(buff, "Inactive:"))) {
			ptr += strlen("Inactive:");
			stats->mem_inactive = strtoul(ptr, &ptr, 10);
		} else if ((ptr = strstr(buff, "SwapTotal:"))) {
			ptr += strlen("SwapTotal:");
			stats->swap_total = strtoul(ptr, &ptr, 10);
		} else if ((ptr = strstr(buff, "SwapFree:"))) {
			ptr += strlen("SwapFree:");
			stats->swap_free = strtoul(ptr, &ptr, 10);
		} else if ((ptr = strstr(buff, "SwapCached:"))) {
			ptr += strlen("SwapCached:");
			stats->swap_cached = strtoul(ptr, &ptr, 10);
		}

		memset(buff, 0, sizeof(buff));
	}

	fclose(fp);
	return 0;
}

static int stats_proc_system(struct ifstat *stats)
{
	unsigned int cpu, cpus;
	char *ptr, buff[256];
	FILE *fp;

	fp = fopen("/proc/stat", "r");
	if (!fp)
		panic("Cannot open /proc/stat!\n");

	cpus = get_number_cpus();

	memset(buff, 0, sizeof(buff));

	while (fgets(buff, sizeof(buff), fp) != NULL) {
		buff[sizeof(buff) - 1] = 0;

		if ((ptr = strstr(buff, "cpu"))) {
			ptr += strlen("cpu");
			if (isblank(*ptr))
				goto next;

			cpu = strtol(ptr, &ptr, 10);
			bug_on(cpu > cpus);

			if (sscanf(ptr, "%"SCNu64"%"SCNu64"%"SCNu64"%"SCNu64"%"SCNu64,
				   &stats->cpu_user[cpu],
				   &stats->cpu_nice[cpu],
				   &stats->cpu_sys[cpu],
				   &stats->cpu_idle[cpu],
				   &stats->cpu_iow[cpu]) != 5)
				goto next;
		} else if ((ptr = strstr(buff, "ctxt"))) {
			ptr += strlen("ctxt");
			stats->cswitch = strtoul(ptr, &ptr, 10);
		} else if ((ptr = strstr(buff, "procs_running"))) {
			ptr += strlen("procs_running");
			stats->procs_run = strtoul(ptr, &ptr, 10);
		} else if ((ptr = strstr(buff, "procs_blocked"))) {
			ptr += strlen("procs_blocked");
			stats->procs_iow = strtoul(ptr, &ptr, 10);
		}
next:
		memset(buff, 0, sizeof(buff));
	}

	fclose(fp);
	return 0;
}

static int stats_proc_procs(struct ifstat *stats)
{
	DIR *dir;
	struct dirent *e;

	dir = opendir("/proc");
	if (!dir)
		panic("Cannot open /proc\n");

	stats->procs_total = 0;

	while ((e = readdir(dir)) != NULL) {
		const char *name = e->d_name;
		char *end;
		unsigned int pid = strtoul(name, &end, 10);

		/* not a number */
		if (pid == 0 && end == name)
			continue;

		stats->procs_total++;
	}

	closedir(dir);

	return 0;
}

static int adjust_dbm_level(int in_dbm, int dbm_val)
{
	if (!in_dbm)
		return dbm_val;

	return dbm_val - 0x100;
}

static int stats_wireless(const char *ifname, struct ifstat *stats)
{
	int ret;
	struct iw_statistics ws;

	ret = wireless_sigqual(ifname, &ws);
	if (ret != 0) {
		stats->wifi.bitrate = 0;
		return -EINVAL;
	}

	stats->wifi.bitrate = wireless_bitrate(ifname);

	stats->wifi.signal_level =
		adjust_dbm_level(ws.qual.updated & IW_QUAL_DBM, ws.qual.level);

	stats->wifi.link_qual = ws.qual.qual;
	stats->wifi.link_qual_max = wireless_rangemax_sigqual(ifname);

	return ret;
}

#define DIFF1(member)	do { diff->member = new->member - old->member; } while (0)
#define DIFF(member)	do { \
		if (sizeof(diff->member) != sizeof(new->member) || \
		    sizeof(diff->member) != sizeof(old->member)) \
			bug(); \
		if ((new->member - old->member) > (new->member)) { \
			diff->member = 0; \
		} else { \
			DIFF1(member); \
		} \
	} while (0)

static void stats_diff(struct ifstat *old, struct ifstat *new,
		       struct ifstat *diff)
{
	unsigned int cpus, i;

	DIFF(rx_bytes);
	DIFF(rx_packets);
	DIFF(rx_drops);
	DIFF(rx_errors);
	DIFF(rx_fifo);
	DIFF(rx_frame);
	DIFF(rx_multi);

	DIFF(tx_bytes);
	DIFF(tx_packets);
	DIFF(tx_drops);
	DIFF(tx_errors);
	DIFF(tx_fifo);
	DIFF(tx_colls);
	DIFF(tx_carrier);

	DIFF1(wifi.signal_level);
	DIFF1(wifi.link_qual);

	DIFF1(cswitch);

	cpus = get_number_cpus();

	for (i = 0; i < cpus; ++i) {
		DIFF(irqs[i]);
		DIFF(irqs_srx[i]);
		DIFF(irqs_stx[i]);

		DIFF1(cpu_user[i]);
		DIFF1(cpu_nice[i]);
		DIFF1(cpu_sys[i]);
		DIFF1(cpu_idle[i]);
		DIFF1(cpu_iow[i]);
	}
}

static void stats_fetch(const char *ifname, struct ifstat *stats)
{
	if (stats_proc_net_dev(ifname, stats) < 0)
		panic("Cannot fetch device stats!\n");
	if (stats_proc_softirqs(stats) < 0)
		panic("Cannot fetch software interrupts!\n");
	if (stats_proc_memory(stats) < 0)
		panic("Cannot fetch memory stats!\n");
	if (stats_proc_system(stats) < 0)
		panic("Cannot fetch system stats!\n");
	if (stats_proc_procs(stats) < 0)
		panic("Cannot fetch process stats!\n");

	stats_proc_interrupts((char *) ifname, stats);

	stats_wireless(ifname, stats);
}

static void stats_sample_generic(const char *ifname, uint64_t ms_interval)
{
	unsigned int cpus = get_number_cpus();

	stats_zero(&stats_old, cpus);
	stats_zero(&stats_new, cpus);
	stats_zero(&stats_delta, cpus);

	stats_fetch(ifname, &stats_old);
	usleep(ms_interval * 1000);
	stats_fetch(ifname, &stats_new);

	stats_diff(&stats_old, &stats_new, &stats_delta);
}

static int cmp_hits(const void *p1, const void *p2)
{
	const struct cpu_hit *h1 = p1, *h2 = p2;

	/*
	 * We want the hits sorted in descending order, thus reverse the return
	 * values.
	 */
	if (h1->hit == h2->hit)
		return 0;
	else if (h1->hit < h2->hit)
		return 1;
	else
		return -1;
}

static int cmp_irqs_rel(const void *p1, const void *p2)
{
	const struct cpu_hit *h1 = p1, *h2 = p2;

	/*
	 * We want the hits sorted in descending order, thus reverse the return
	 * values.
	 */
	if (h1->irqs_rel == h2->irqs_rel)
		return 0;
	else if (h1->irqs_rel < h2->irqs_rel)
		return 1;
	else
		return -1;
}

static int cmp_irqs_abs(const void *p1, const void *p2)
{
	const struct cpu_hit *h1 = p1, *h2 = p2;

	/*
	 * We want the hits sorted in descending order, thus reverse the return
	 * values.
	 */
	if (h1->irqs_abs == h2->irqs_abs)
		return 0;
	else if (h1->irqs_abs < h2->irqs_abs)
		return 1;
	else
		return -1;
}

static void stats_top(const struct ifstat *rel, const struct ifstat *abs,
		      unsigned int cpus)
{
	unsigned int i;

	memset(&stats_avg, 0, sizeof(stats_avg));

	for (i = 0; i < cpus; ++i) {
		cpu_hits[i].idx = i;
		cpu_hits[i].hit = rel->cpu_user[i] + rel->cpu_nice[i] + rel->cpu_sys[i];
		cpu_hits[i].irqs_rel = rel->irqs[i];
		cpu_hits[i].irqs_abs = abs->irqs[i];

		stats_avg.cpu_user += rel->cpu_user[i];
		stats_avg.cpu_sys += rel->cpu_sys[i];
		stats_avg.cpu_nice += rel->cpu_nice[i];
		stats_avg.cpu_idle += rel->cpu_idle[i];
		stats_avg.cpu_iow += rel->cpu_iow[i];

		stats_avg.irqs_abs += abs->irqs[i];
		stats_avg.irqs_rel += rel->irqs[i];
		stats_avg.irqs_srx_rel += rel->irqs_srx[i];
		stats_avg.irqs_stx_rel += rel->irqs_stx[i];
	}

	stats_avg.cpu_user /= cpus;
	stats_avg.cpu_sys /= cpus;
	stats_avg.cpu_nice /= cpus;
	stats_avg.cpu_idle /= cpus;
	stats_avg.cpu_iow /= cpus;
	stats_avg.irqs_abs /= cpus;
	stats_avg.irqs_rel /= cpus;
	stats_avg.irqs_srx_rel /= cpus;
	stats_avg.irqs_stx_rel /= cpus;
}

static void screen_header(WINDOW *screen, const char *ifname, int *voff,
			  uint32_t rate, uint64_t ms_interval, unsigned int top_cpus)
{
	size_t len = 0;
	char buff[64], machine[64];
	struct ethtool_drvinfo drvinf;
	int link = ethtool_link(ifname);
	unsigned int cpus = get_number_cpus();

	ethtool_drvinf(ifname, &drvinf);

	memset(buff, 0, sizeof(buff));
	memset(machine, 0, sizeof(machine));

	if (rate)
		len += snprintf(buff + len, sizeof(buff) - len, " %uMbit/s", rate);
	if (link >= 0)
		len += snprintf(buff + len, sizeof(buff) - len, " link:%s",
				link == 0 ? "no" : "yes");

	if (!strstr(uts.release, uts.machine))
		slprintf(machine, sizeof(machine), " %s,", uts.machine);

	mvwprintw(screen, (*voff)++, 2,
		  "%s,%s %s (%s%s), t=%"PRIu64"ms, cpus=%u%s/%u"
		  "               ", uts.release, machine,
		  ifname, drvinf.driver, buff, ms_interval, top_cpus,
		  top_cpus > 0 && top_cpus < cpus ? "+1" : "", cpus);
}

static void screen_net_dev_rel(WINDOW *screen, const struct ifstat *rel,
			       int *voff)
{
	attron(A_REVERSE);

	mvwprintw(screen, (*voff)++, 0,
		  "  rx: %16.3llf MiB/t "
		        "%10llu pkts/t "
			"%10llu drops/t "
			"%10llu errors/t  ",
		  ((long double) rel->rx_bytes) / (1LLU << 20),
		  rel->rx_packets, rel->rx_drops, rel->rx_errors);

	mvwprintw(screen, (*voff)++, 0,
		  "  tx: %16.3llf MiB/t "
			"%10llu pkts/t "
			"%10llu drops/t "
			"%10llu errors/t  ",
		  ((long double) rel->tx_bytes) / (1LLU << 20),
		  rel->tx_packets, rel->tx_drops, rel->tx_errors);

	attroff(A_REVERSE);
}

static void screen_net_dev_percentage(WINDOW *screen, const struct ifstat *rel,
				      int *voff, uint32_t rate)
{
	mvwprintw(screen, (*voff)++, 0,
		  "  rx: %15.2llf%% of line rate  "
		  "                                                  ",
		  rate ? ((((long double) rel->rx_bytes) / 125000) / rate) * 100.0 : 0.0);

	mvwprintw(screen, (*voff)++, 0,
		  "  tx: %15.2llf%% of line rate  "
		  "                                                  ",
		  rate ? ((((long double) rel->tx_bytes) / 125000) / rate) * 100.0 : 0.0);
}

static void screen_net_dev_abs(WINDOW *screen, const struct ifstat *abs,
			       int *voff)
{
	mvwprintw(screen, (*voff)++, 2,
		  "rx: %16.3llf MiB   "
		      "%10llu pkts   "
		      "%10llu drops   "
		      "%10llu errors",
		  ((long double) abs->rx_bytes) / (1LLU << 20),
		  abs->rx_packets, abs->rx_drops, abs->rx_errors);

	mvwprintw(screen, (*voff)++, 2,
		  "tx: %16.3llf MiB   "
		      "%10llu pkts   "
		      "%10llu drops   "
		      "%10llu errors",
		  ((long double) abs->tx_bytes) / (1LLU << 20),
		  abs->tx_packets, abs->tx_drops, abs->tx_errors);
}

static void screen_sys(WINDOW *screen, const struct ifstat *rel,
		       const struct ifstat *abs, int *voff)
{
	mvwprintw(screen, (*voff)++, 2,
		  "sys:  %14"PRIu32" cs/t "
			"%11"PRIu32" procs "
			"%11"PRIu32" running "
			"%10"PRIu32" iowait",
		  rel->cswitch, abs->procs_total, abs->procs_run, abs->procs_iow);
}

static void screen_mem_swap(WINDOW *screen, const struct ifstat *abs, int *voff)
{
	mvwprintw(screen, (*voff)++, 2,
		  "mem:  %13"PRIu64"M total "
			 "%9"PRIu64"M used "
			"%11"PRIu64"M active "
			"%10"PRIu64"M inactive",
			abs->mem_total / 1024,
			(abs->mem_total - abs->mem_free) / 1024,
			abs->mem_active / 1024,
			abs->mem_inactive / 1024);

	mvwprintw(screen, (*voff)++, 2,
		  "swap:  %12"PRIu64"M total "
			  "%9uM used "
			 "%11uM cached",
		  abs->swap_total / 1024,
		  (abs->swap_total - abs->swap_free) / 1024,
		  abs->swap_cached / 1024);
}

static void screen_percpu_states_one(WINDOW *screen, const struct ifstat *rel,
				     int *voff, unsigned int idx, char *tag)
{
	int max_padd = padding_from_num(get_number_cpus());
	double usr = 0.0, sys = 0.0, idl = 0.0, iow = 0.0;
	uint64_t all = rel->cpu_user[idx] + rel->cpu_nice[idx] + rel->cpu_sys[idx] +
		       rel->cpu_idle[idx] + rel->cpu_iow[idx];

	if (all > 0) {
		usr = 100.0 * (rel->cpu_user[idx] + rel->cpu_nice[idx]) / all;
		sys = 100.0 * rel->cpu_sys[idx] / all;
		idl = 100.0 * rel->cpu_idle[idx] / all;
		iow = 100.0 * rel->cpu_iow[idx] / all;
	}

	mvwprintw(screen, (*voff)++, 2,
		  "cpu%*d %s: %11.1lf%% usr/t "
			      "%9.1lf%% sys/t "
			     "%10.1lf%% idl/t "
			     "%11.1lf%% iow/t",
		  max_padd, idx, tag, usr, sys, idl, iow);
}

#define MEDIAN_EVEN(member)	do { \
	m_##member = (rel->member[i] + rel->member[j]) / 2.0; \
} while (0)

#define MEDIAN_ODD(member)	do { \
	m_##member = rel->member[i]; \
} while (0)

static void screen_percpu_states(WINDOW *screen, const struct ifstat *rel,
				 const struct avg_stat *avg,
				 unsigned int top_cpus, int *voff)
{
	unsigned int i;
	unsigned int cpus = get_number_cpus();
	int max_padd = padding_from_num(cpus);
	uint64_t all;
	double usr = 0.0, sys = 0.0, idl = 0.0, iow = 0.0;

	if (top_cpus == 0)
		return;

	/* Display top hitter */
	screen_percpu_states_one(screen, rel, voff, cpu_hits[0].idx, "+");

	/* Make sure we don't display the min. hitter twice */
	if (top_cpus == cpus)
		top_cpus--;

	for (i = 1; i < top_cpus; ++i)
		screen_percpu_states_one(screen, rel, voff, cpu_hits[i].idx, "|");

	/* Display minimum hitter */
	if (cpus != 1)
		screen_percpu_states_one(screen, rel, voff, cpu_hits[cpus - 1].idx, "-");

	all = avg->cpu_user + avg->cpu_sys + avg->cpu_nice + avg->cpu_idle + avg->cpu_iow;
	if (all > 0) {
		usr = 100.0 * (avg->cpu_user + avg->cpu_nice) / all;
		sys = 100.0 * avg->cpu_sys / all;
		idl = 100.0 * avg->cpu_idle /all;
		iow = 100.0 * avg->cpu_iow / all;
	}
	mvwprintw(screen, (*voff)++, 2,
		  "avg:%*s%14.1lf%%       "
			"%9.1lf%%       "
		       "%10.1lf%%       "
		       "%11.1lf%%", max_padd, "", usr, sys, idl, iow);

	if (show_median) {
		long double m_cpu_user, m_cpu_nice, m_cpu_sys, m_cpu_idle, m_cpu_iow;
		long double m_all;
		long double m_usr = 0.0, m_sys = 0.0, m_idl = 0.0, m_iow = 0.0;

		i = cpu_hits[cpus / 2].idx;
		if (cpus % 2 == 0) {
			/* take the mean of the 2 middle entries */
			int j = cpu_hits[(cpus / 2) - 1].idx;

			MEDIAN_EVEN(cpu_user);
			MEDIAN_EVEN(cpu_nice);
			MEDIAN_EVEN(cpu_sys);
			MEDIAN_EVEN(cpu_idle);
			MEDIAN_EVEN(cpu_iow);
		} else {
			/* take the middle entry as is */
			MEDIAN_ODD(cpu_user);
			MEDIAN_ODD(cpu_nice);
			MEDIAN_ODD(cpu_sys);
			MEDIAN_ODD(cpu_idle);
			MEDIAN_ODD(cpu_iow);
		}

		m_all = m_cpu_user + m_cpu_sys + m_cpu_nice + m_cpu_idle + m_cpu_iow;
		if (m_all > 0.0) {
			m_usr = 100.0 * (m_cpu_user + m_cpu_nice) / m_all;
			m_sys = 100.0 * m_cpu_sys / m_all;
			m_idl = 100.0 * m_cpu_idle /m_all;
			m_iow = 100.0 * m_cpu_iow / m_all;
		}
		mvwprintw(screen, (*voff)++, 2,
			  "med:%*s%14.1Lf%%       "
				"%9.1Lf%%       "
			       "%10.1Lf%%       "
			       "%11.1Lf%%", max_padd, "", m_usr, m_sys, m_idl, m_iow);
	}
}

static void screen_percpu_irqs_rel_one(WINDOW *screen, const struct ifstat *rel,
				       int *voff, unsigned int idx, char *tag)
{
	int max_padd = padding_from_num(get_number_cpus());

	mvwprintw(screen, (*voff)++, 2,
		  "cpu%*d %s: %12llu irqs/t "
			     "%17llu sirq rx/t "
			     "%17llu sirq tx/t",
		  max_padd, idx, tag,
		  rel->irqs[idx],
		  rel->irqs_srx[idx],
		  rel->irqs_stx[idx]);
}

static void screen_percpu_irqs_rel(WINDOW *screen, const struct ifstat *rel,
				   const struct avg_stat *avg,
				   unsigned int top_cpus, int *voff)
{
	unsigned int i;
	unsigned int cpus = get_number_cpus();
	int max_padd = padding_from_num(cpus);

	screen_percpu_irqs_rel_one(screen, rel, voff, cpu_hits[0].idx, "+");

	if (top_cpus == cpus)
		top_cpus--;

	for (i = 1; i < top_cpus; ++i)
		screen_percpu_irqs_rel_one(screen, rel, voff, cpu_hits[i].idx, "|");

	if (cpus != 1)
		screen_percpu_irqs_rel_one(screen, rel, voff, cpu_hits[cpus - 1].idx, "-");

	mvwprintw(screen, (*voff)++, 2,
		 "avg:%*s%17.1Lf        "
		      "%17.1Lf           "
		      "%17.1Lf", max_padd, "",
		 avg->irqs_rel, avg->irqs_srx_rel, avg->irqs_stx_rel);

	if (show_median) {
		long double m_irqs, m_irqs_srx, m_irqs_stx;

		i = cpu_hits[cpus / 2].idx;
		if (cpus % 2 == 0) {
			/* take the mean of the 2 middle entries */
			int j = cpu_hits[(cpus / 2) - 1].idx;

			MEDIAN_EVEN(irqs);
			MEDIAN_EVEN(irqs_srx);
			MEDIAN_EVEN(irqs_stx);
		} else {
			/* take the middle entry as is */
			MEDIAN_ODD(irqs);
			MEDIAN_ODD(irqs_srx);
			MEDIAN_ODD(irqs_stx);
		}

		mvwprintw(screen, (*voff)++, 2,
			 "med:%*s%17.1Lf        "
			      "%17.1Lf           "
			      "%17.1Lf", max_padd, "",
			 m_irqs, m_irqs_srx, m_irqs_stx);
	}
}

static void screen_percpu_irqs_abs_one(WINDOW *screen, const struct ifstat *abs,
				       int *voff, unsigned int idx, char *tag)
{
	int max_padd = padding_from_num(get_number_cpus());

	mvwprintw(screen, (*voff)++, 2,
		  "cpu%*d %s: %12llu irqs",
		  max_padd, idx, tag, abs->irqs[idx]);
}

static void screen_percpu_irqs_abs(WINDOW *screen, const struct ifstat *abs,
				   const struct avg_stat *avg,
				   unsigned int top_cpus, int *voff)
{
	unsigned int i;
	unsigned int cpus = get_number_cpus();
	int max_padd = padding_from_num(cpus);

	screen_percpu_irqs_abs_one(screen, abs, voff, cpu_hits[0].idx, "+");

	if (top_cpus == cpus)
		top_cpus--;

	for (i = 1; i < top_cpus; ++i)
		screen_percpu_irqs_abs_one(screen, abs, voff, cpu_hits[i].idx, "|");

	if (cpus != 1)
		screen_percpu_irqs_abs_one(screen, abs, voff, cpu_hits[cpus - 1].idx, "-");

	mvwprintw(screen, (*voff)++, 2,
		 "avg:%*s%17.1Lf", max_padd, "", avg->irqs_abs);

	if (show_median) {
		long double m_irqs;

		i = cpu_hits[cpus / 2].idx;
		if (cpus % 2 == 0) {
			/* take the mean of the 2 middle entries */
			int j = cpu_hits[(cpus / 2) - 1].idx;

			m_irqs = (abs->irqs[i] + abs->irqs[j]) / 2;
		} else {
			/* take the middle entry as is */
			m_irqs = abs->irqs[i];
		}

		mvwprintw(screen, (*voff)++, 2,
			  "med:%*s%17.1Lf", max_padd, "", m_irqs);
	}
}

static void screen_wireless(WINDOW *screen, const struct ifstat *rel,
			    const struct ifstat *abs, int *voff)
{
	if (iswireless(abs)) {
		mvwprintw(screen, (*voff)++, 2,
			  "linkqual: %7d/%d (%d/t)          ",
			  abs->wifi.link_qual,
			  abs->wifi.link_qual_max,
			  rel->wifi.link_qual);

		mvwprintw(screen, (*voff)++, 2,
			  "signal: %8d dBm (%d dBm/t)       ",
			  abs->wifi.signal_level,
			  rel->wifi.signal_level);
	}
}

static void screen_update(WINDOW *screen, const char *ifname, const struct ifstat *rel,
			  const struct ifstat *abs, const struct avg_stat *avg,
			  int *first, uint64_t ms_interval, unsigned int top_cpus,
			  bool need_info)
{
	unsigned int cpus, top;
	int voff = 1, cvoff = 2;
	uint32_t rate = device_bitrate(ifname);

	curs_set(0);

	cpus = get_number_cpus();
	top = min(cpus, top_cpus);

	stats_top(rel, abs, cpus);

	qsort(cpu_hits, cpus, sizeof(*cpu_hits), cmp_hits);

	screen_header(screen, ifname, &voff, rate, ms_interval, top_cpus);

	voff++;
	screen_net_dev_rel(screen, rel, &voff);

	if (show_percentage) {
		voff++;
		screen_net_dev_percentage(screen, rel, &voff, rate);
	}

	voff++;
	screen_net_dev_abs(screen, abs, &voff);

	voff++;
	screen_sys(screen, rel, abs, &voff);

	voff++;
	screen_mem_swap(screen, abs, &voff);

	voff++;
	screen_percpu_states(screen, rel, avg, top, &voff);

	qsort(cpu_hits, cpus, sizeof(*cpu_hits), cmp_irqs_rel);

	voff++;
	screen_percpu_irqs_rel(screen, rel, avg, top, &voff);

	qsort(cpu_hits, cpus, sizeof(*cpu_hits), cmp_irqs_abs);

	voff++;
	screen_percpu_irqs_abs(screen, abs, avg, top, &voff);

	voff++;
	screen_wireless(screen, rel, abs, &voff);

	if (*first) {
		mvwprintw(screen, cvoff, 2, "Collecting data ...");
		*first = 0;
	} else {
		if (need_info)
			mvwprintw(screen, cvoff, 2, "(consider to increase "
				  "your sampling interval, e.g. -t %d)",
			rate > SPEED_1000 ? 10000 : 1000);
		else
			mvwprintw(screen, cvoff, 2, "                      "
				  "                                      ");
	}

	wrefresh(screen);
	refresh();
}

static void on_panic_handler(void *arg __maybe_unused)
{
	screen_end();
	fprintf(stderr, "Please check <stderr> for error message\n");
}

static int screen_main(const char *ifname, uint64_t ms_interval,
		       unsigned int top_cpus, bool suppress_warnings,
		       bool omit_header __maybe_unused)
{
	int first = 1, key;
	uint32_t rate = device_bitrate(ifname);
	bool need_info = false;

	stats_screen = screen_init(true);

	panic_handler_add(on_panic_handler, NULL);

	if (((rate > SPEED_1000 && ms_interval <= 10000) ||
	     (rate == SPEED_1000 && ms_interval < 1000)) &&
	     !suppress_warnings)
		need_info = true;

	while (!sigint) {
		key = getch();
		if (key == 'q' || key == 0x1b || key == KEY_F(10))
			break;

		screen_update(stats_screen, ifname, &stats_delta, &stats_new, &stats_avg,
			      &first, ms_interval, top_cpus, need_info);

		stats_sample_generic(ifname, ms_interval);
	}

	screen_end();

	return 0;
}

static void term_csv(const struct ifstat *rel, const struct ifstat *abs)
{
	unsigned int cpus, i;

	printf("%ld ", time(NULL));

	printf("%llu ", rel->rx_bytes);
	printf("%llu ", rel->rx_packets);
	printf("%llu ", rel->rx_drops);
	printf("%llu ", rel->rx_errors);

	printf("%llu ", abs->rx_bytes);
	printf("%llu ", abs->rx_packets);
	printf("%llu ", abs->rx_drops);
	printf("%llu ", abs->rx_errors);

	printf("%llu ", rel->tx_bytes);
	printf("%llu ", rel->tx_packets);
	printf("%llu ", rel->tx_drops);
	printf("%llu ", rel->tx_errors);

	printf("%llu ", abs->tx_bytes);
	printf("%llu ", abs->tx_packets);
	printf("%llu ", abs->tx_drops);
	printf("%llu ", abs->tx_errors);

	printf("%"PRIu32" ",  rel->cswitch);
	printf("%"PRIu64" ", abs->mem_free);
	printf("%"PRIu64" ", abs->mem_total - abs->mem_free);
	printf("%"PRIu64" ", abs->mem_total);
	printf("%"PRIu64" ", abs->swap_free);
	printf("%"PRIu64" ", abs->swap_total - abs->swap_free);
	printf("%"PRIu64" ", abs->swap_total);
	printf("%"PRIu32" ",  abs->procs_total);
	printf("%"PRIu32" ",  abs->procs_run);
	printf("%"PRIu32" ",  abs->procs_iow);

	cpus = get_number_cpus();

	for (i = 0; i < cpus; ++i) {
		printf("%"PRIu64" ", rel->cpu_user[i]);
		printf("%"PRIu64" ", rel->cpu_nice[i]);
		printf("%"PRIu64" ", rel->cpu_sys[i]);
		printf("%"PRIu64" ", rel->cpu_idle[i]);
		printf("%"PRIu64" ", rel->cpu_iow[i]);

		printf("%llu ", rel->irqs[i]);
		printf("%llu ", abs->irqs[i]);

		printf("%llu ", rel->irqs_srx[i]);
		printf("%llu ", abs->irqs_srx[i]);

		printf("%llu ", rel->irqs_stx[i]);
		printf("%llu ", abs->irqs_stx[i]);
	}

	if (iswireless(abs)) {
		printf("%"PRIu16" ", rel->wifi.link_qual);
		printf("%"PRIu16" ", abs->wifi.link_qual);
		printf("%"PRIu16" ", abs->wifi.link_qual_max);

		printf("%d ", rel->wifi.signal_level);
		printf("%d ", abs->wifi.signal_level);
	}

	puts("");
	fflush(stdout);
}

static void term_csv_header(const char *ifname, const struct ifstat *abs,
			    uint64_t ms_interval)
{
	unsigned int cpus, i, j = 1;

	printf("# gnuplot dump (#col:description)\n");
	printf("# networking interface: %s\n", ifname);
	printf("# sampling interval (t): %"PRIu64" ms\n", ms_interval);
	printf("# %d:unixtime ", j++);

	printf("%d:rx-bytes-per-t ", j++);
	printf("%d:rx-pkts-per-t ", j++);
	printf("%d:rx-drops-per-t ", j++);
	printf("%d:rx-errors-per-t ", j++);

	printf("%d:rx-bytes ", j++);
	printf("%d:rx-pkts ", j++);
	printf("%d:rx-drops ", j++);
	printf("%d:rx-errors ", j++);

	printf("%d:tx-bytes-per-t ", j++);
	printf("%d:tx-pkts-per-t ", j++);
	printf("%d:tx-drops-per-t ", j++);
	printf("%d:tx-errors-per-t ", j++);

	printf("%d:tx-bytes ", j++);
	printf("%d:tx-pkts ", j++);
	printf("%d:tx-drops ", j++);
	printf("%d:tx-errors ", j++);

	printf("%d:context-switches-per-t ", j++);
	printf("%d:mem-free ", j++);
	printf("%d:mem-used ", j++);
	printf("%d:mem-total ", j++);
	printf("%d:swap-free ", j++);
	printf("%d:swap-used ", j++);
	printf("%d:swap-total ", j++);
	printf("%d:procs-total ", j++);
	printf("%d:procs-in-run ", j++);
	printf("%d:procs-in-iow ", j++);

	cpus = get_number_cpus();

	for (i = 0; i < cpus; ++i) {
		printf("%d:cpu%i-usr-per-t ", j++, i);
		printf("%d:cpu%i-nice-per-t ", j++, i);
		printf("%d:cpu%i-sys-per-t ", j++, i);
		printf("%d:cpu%i-idle-per-t ", j++, i);
		printf("%d:cpu%i-iow-per-t ", j++, i);

		printf("%d:cpu%i-net-irqs-per-t ", j++, i);
		printf("%d:cpu%i-net-irqs ", j++, i);

		printf("%d:cpu%i-net-rx-soft-irqs-per-t ", j++, i);
		printf("%d:cpu%i-net-rx-soft-irqs ", j++, i);
		printf("%d:cpu%i-net-tx-soft-irqs-per-t ", j++, i);
		printf("%d:cpu%i-net-tx-soft-irqs ", j++, i);
	}

	if (iswireless(abs)) {
		printf("%d:wifi-link-qual-per-t ", j++);
		printf("%d:wifi-link-qual ", j++);
		printf("%d:wifi-link-qual-max ", j++);

		printf("%d:wifi-signal-dbm-per-t ", j++);
		printf("%d:wifi-signal-dbm ", j++);
	}

	puts("");
	printf("# data:\n");
	fflush(stdout);
}

static int term_main(const char *ifname, uint64_t ms_interval,
		     unsigned int top_cpus __maybe_unused,
		     bool suppress_warnings __maybe_unused,
		     bool omit_header)
{
	do {
		stats_sample_generic(ifname, ms_interval);

		if (!omit_header) {
			omit_header = true;
			term_csv_header(ifname, &stats_new, ms_interval);
		}

		term_csv(&stats_delta, &stats_new);
	} while (stats_loop && !sigint);

	return 0;
}

int main(int argc, char **argv)
{
	short ifflags = 0;
	int c, ret, promisc = 0;
	unsigned int cpus, top_cpus = 5;
	uint64_t interval = 1000;
	char *ifname = NULL;
	bool suppress_warnings = false;
	bool omit_header = false;
	int (*func_main)(const char *ifname, uint64_t ms_interval,
			 unsigned int top_cpus, bool suppress_warnings,
			 bool omit_header);

	func_main = screen_main;

	setfsuid(getuid());
	setfsgid(getgid());

	while ((c = getopt_long(argc, argv, short_options, long_options,
				NULL)) != EOF) {
		switch (c) {
		case 'h':
			help();
			break;
		case 'v':
			version();
			break;
		case 'W':
			suppress_warnings = true;
			break;
		case 'd':
			ifname = xstrndup(optarg, IFNAMSIZ);
			break;
		case 't':
			interval = strtoul(optarg, NULL, 10);
			break;
		case 'n':
			top_cpus = strtoul(optarg, NULL, 10);
			if (top_cpus < 1)
				panic("Number of top hitter CPUs must be greater than 0");
			break;
		case 'l':
			stats_loop = 1;
			break;
		case 'p':
			promisc = 1;
			break;
		case 'P':
			show_percentage = 1;
			break;
		case 'm':
			show_median = 1;
			break;
		case 'c':
			func_main = term_main;
			break;
		case 'o':
			omit_header = true;
			break;
		case '?':
			switch (optopt) {
			case 'd':
			case 't':
				panic("Option -%c requires an argument!\n",
				      optopt);
			default:
				if (isprint(optopt))
					printf("Unknown option character `0x%X\'!\n", optopt);
				die();
			}
		default:
			break;
		}
	}

	if (argc == 1)
		help();

	if (argc == 2)
		ifname = xstrndup(argv[1], IFNAMSIZ);
	if (ifname == NULL)
		panic("No networking device given!\n");

	if (!strncmp("lo", ifname, IFNAMSIZ))
		panic("lo is not supported!\n");
	if (device_mtu(ifname) == 0)
		panic("This is no networking device!\n");

	register_signal(SIGINT, signal_handler);
	register_signal(SIGQUIT, signal_handler);
	register_signal(SIGSTOP, signal_handler);
	register_signal(SIGHUP, signal_handler);

	cpus = get_number_cpus();
	top_cpus = min(top_cpus, cpus);
	if (uname(&uts) < 0)
		panic("Cannot execute uname!\n");

	stats_alloc(&stats_old, cpus);
	stats_alloc(&stats_new, cpus);
	stats_alloc(&stats_delta, cpus);

	cpu_hits = xcalloc(cpus, sizeof(*cpu_hits));

	if (promisc)
		ifflags = device_enter_promiscuous_mode(ifname);
	ret = func_main(ifname, interval, top_cpus, suppress_warnings, omit_header);
	if (promisc)
		device_leave_promiscuous_mode(ifname, ifflags);

	stats_release(&stats_old);
	stats_release(&stats_new);
	stats_release(&stats_delta);

	xfree(ifname);
	return ret;
}