X-Git-Url: https://tinc-vpn.org/git/browse?a=blobdiff_plain;f=src%2Ftop.c;h=478e4fb9c59a88db6b74701f59a1b729c1c08d80;hb=0b8b23e0dd7219344543f135ca0aeba8a4a42d48;hp=0a3bae966576a7fcd6f3ed91b95b0283f52a8412;hpb=97355690b9cf8d8b56a316e01f73f8ff1fee68c8;p=tinc

diff --git a/src/top.c b/src/top.c
index 0a3bae96..478e4fb9 100644
--- a/src/top.c
+++ b/src/top.c
@@ -19,48 +19,298 @@
 
 #include "system.h"
 
+#ifdef HAVE_CURSES
+
 #include <curses.h>
 
 #include "control_common.h"
+#include "list.h"
 #include "tincctl.h"
 #include "top.h"
+#include "xalloc.h"
 
-void top(int fd) {
-	initscr();
+typedef struct nodestats_t {
+	char *name;
+	int i;
+	uint64_t in_packets;
+	uint64_t in_bytes;
+	uint64_t out_packets;
+	uint64_t out_bytes;
+	float in_packets_rate;
+	float in_bytes_rate;
+	float out_packets_rate;
+	float out_bytes_rate;
+	bool known;
+} nodestats_t;
 
-	timeout(1000);
+static const char *const sortname[] = {
+	"name",
+	"in pkts",
+	"in bytes",
+	"out pkts",
+	"out bytes",
+	"tot pkts",
+	"tot bytes",
+};
 
-	do {
-		sendline(fd, "%d %d", CONTROL, REQ_DUMP_TRAFFIC);
+static int sortmode = 0;
+static bool cumulative = false;
 
-		erase();
+static list_t node_list;
+static struct timeval now, prev, diff;
+static int delay = 1000;
+static bool changed = true;
+static const char *unit = "bytes";
+static float scale = 1;
 
-		char line[4096];
-		while(recvline(fd, line, sizeof line)) {
-			char node[4096];
-			int code;
-			int req;
-			uint64_t in_packets;
-			uint64_t in_bytes;
-			uint64_t out_packets;
-			uint64_t out_bytes;
+#ifndef timersub
+#define timersub(a, b, c) do {(c)->tv_sec = (a)->tv_sec - (b)->tv_sec; (c)->tv_usec = (a)->tv_usec = (b)->tv_usec;} while(0)
+#endif
 
-			int n = sscanf(line, "%d %d %s %"PRIu64" %"PRIu64" %"PRIu64" %"PRIu64, &code, &req, node, &in_packets, &in_bytes, &out_packets, &out_bytes);
+static void update(int fd) {
+	sendline(fd, "%d %d", CONTROL, REQ_DUMP_TRAFFIC);
+	gettimeofday(&now, NULL);
 
-			if(n == 2)
-				break;
+	timersub(&now, &prev, &diff);
+	prev = now;
+	float interval = diff.tv_sec + diff.tv_usec * 1e-6;
+
+	char line[4096];
+	char name[4096];
+	int code;
+	int req;
+	uint64_t in_packets;
+	uint64_t in_bytes;
+	uint64_t out_packets;
+	uint64_t out_bytes;
+
+	for list_each(nodestats_t, ns, &node_list)
+		ns->known = false;
+
+	while(recvline(fd, line, sizeof line)) {
+		int n = sscanf(line, "%d %d %s %"PRIu64" %"PRIu64" %"PRIu64" %"PRIu64, &code, &req, name, &in_packets, &in_bytes, &out_packets, &out_bytes);
+
+		if(n == 2)
+			break;
+
+		if(n != 7) {
+			endwin();
+			fprintf(stderr, "Error receiving traffic information\n");
+			exit(1);
+		}
 
-			if(n != 7) {
-				fprintf(stderr, "Error receiving traffic information\n");
-				return;
+		nodestats_t *found = NULL;
+
+		for list_each(nodestats_t, ns, &node_list) {
+			int result = strcmp(name, ns->name);
+			if(result > 0) {
+				continue;
+			} if(result == 0) {
+				found = ns;
+				break;
+			} else {
+				found = xmalloc_and_zero(sizeof *found);
+				found->name = xstrdup(name);
+				list_insert_before(&node_list, node, found);
+				changed = true;
+				break;
 			}
+		}
+
+		if(!found) {
+			found = xmalloc_and_zero(sizeof *found);
+			found->name = xstrdup(name);
+			list_insert_tail(&node_list, found);
+			changed = true;
+		}
+
+		found->known = true;
+		found->in_packets_rate = (in_packets - found->in_packets) / interval;
+		found->in_bytes_rate = (in_bytes - found->in_bytes) / interval;
+		found->out_packets_rate = (out_packets - found->out_packets) / interval;
+		found->out_bytes_rate = (out_bytes - found->out_bytes) / interval;
+		found->in_packets = in_packets;
+		found->in_bytes = in_bytes;
+		found->out_packets = out_packets;
+		found->out_bytes = out_bytes;
+	}
+}
+
+static void redraw(void) {
+	erase();
 
-			printw("%16s %8"PRIu64" %8"PRIu64" %8"PRIu64" %8"PRIu64"\n", node, in_packets, in_bytes, out_packets, out_bytes);
+	mvprintw(0, 0, "Tinc %-16s  Nodes: %4d  Sort: %-10s  %s", netname ?: "", node_list.count, sortname[sortmode], cumulative ? "Cumulative" : "Current");
+	attrset(A_REVERSE);
+	mvprintw(2, 0, "Node                IN pkts   IN %s   OUT pkts  OUT %s", unit, unit);
+	chgat(-1, A_REVERSE, 0, NULL);
+
+	static nodestats_t **sorted = 0;
+	static int n = 0;
+	if(changed) {
+		n = 0;
+		sorted = xrealloc(sorted, node_list.count * sizeof *sorted);
+		for list_each(nodestats_t, ns, &node_list)
+			sorted[n++] = ns;
+		changed = false;
+	}
+
+	for(int i = 0; i < n; i++)
+		sorted[i]->i = i;
+	
+	int cmpfloat(float a, float b) {
+		if(a < b)
+			return -1;
+		else if(a > b)
+			return 1;
+		else
+			return 0;
+	}
+
+	int cmpu64(uint64_t a, uint64_t b) {
+		if(a < b)
+			return -1;
+		else if(a > b)
+			return 1;
+		else
+			return 0;
+	}
+
+	int sortfunc(const void *a, const void *b) {
+		const nodestats_t *na = *(const nodestats_t **)a;
+		const nodestats_t *nb = *(const nodestats_t **)b;
+		switch(sortmode) {
+			case 1:
+				if(cumulative)
+					return -cmpu64(na->in_packets, nb->in_packets) ?: na->i - nb->i;
+				else
+					return -cmpfloat(na->in_packets_rate, nb->in_packets_rate) ?: na->i - nb->i;
+			case 2:
+				if(cumulative)
+					return -cmpu64(na->in_bytes, nb->in_bytes) ?: na->i - nb->i;
+				else
+					return -cmpfloat(na->in_bytes_rate, nb->in_bytes_rate) ?: na->i - nb->i;
+			case 3:
+				if(cumulative)
+					return -cmpu64(na->out_packets, nb->out_packets) ?: na->i - nb->i;
+				else
+					return -cmpfloat(na->out_packets_rate, nb->out_packets_rate) ?: na->i - nb->i;
+			case 4:
+				if(cumulative)
+					return -cmpu64(na->out_bytes, nb->out_bytes) ?: na->i - nb->i;
+				else
+					return -cmpfloat(na->out_bytes_rate, nb->out_bytes_rate) ?: na->i - nb->i;
+			case 5:
+				if(cumulative)
+					return -cmpu64(na->in_packets + na->out_packets, nb->in_packets + nb->out_packets) ?: na->i - nb->i;
+				else
+					return -cmpfloat(na->in_packets_rate + na->out_packets_rate, nb->in_packets_rate + nb->out_packets_rate) ?: na->i - nb->i;
+			case 6:
+				if(cumulative)
+					return -cmpu64(na->in_bytes + na->out_bytes, nb->in_bytes + nb->out_bytes) ?: na->i - nb->i;
+				else
+					return -cmpfloat(na->in_bytes_rate + na->out_bytes_rate, nb->in_bytes_rate + nb->out_bytes_rate) ?: na->i - nb->i;
+			default:
+				return strcmp(na->name, nb->name) ?: na->i - nb->i;
 		}
+	}
+
+	qsort(sorted, n, sizeof *sorted, sortfunc);
 
-		refresh();
+	for(int i = 0, row = 3; i < n; i++, row++) {
+		nodestats_t *node = sorted[i];
+		if(node->known)
+			if(node->in_packets_rate || node->out_packets_rate)
+				attrset(A_BOLD);
+			else
+				attrset(A_NORMAL);
+		else
+			attrset(A_DIM);
 
-	} while(getch() == ERR);
+		if(cumulative)
+			mvprintw(row, 0, "%-16s %10"PRIu64" %10.0f %10"PRIu64" %10.0f",
+					node->name, node->in_packets, node->in_bytes * scale, node->out_packets, node->out_bytes * scale);
+		else
+			mvprintw(row, 0, "%-16s %10.0f %10.0f %10.0f %10.0f",
+					node->name, node->in_packets_rate, node->in_bytes_rate * scale, node->out_packets_rate, node->out_bytes_rate * scale);
+	}
+
+	attrset(A_NORMAL);
+	move(1, 0);
+
+	refresh();
+}
+
+void top(int fd) {
+	initscr();
+	timeout(delay);
+	bool running = true;
+
+	while(running) {
+		update(fd);
+		redraw();
+
+		switch(getch()) {
+			case 's': {
+				timeout(-1);
+				float input = delay * 1e-3;
+				mvprintw(1, 0, "Change delay from %.1fs to: ", input);
+				scanw("%f", &input);
+				if(input < 0.1)
+					input = 0.1;
+				delay = input * 1e3;
+				timeout(delay);
+				break;
+			}
+			case 'c':
+				  cumulative = !cumulative;
+				  break;
+			case 'n':
+				  sortmode = 0;
+				  break;
+			case 'i':
+				  sortmode = 2;
+				  break;
+			case 'I':
+				  sortmode = 1;
+				  break;
+			case 'o':
+				  sortmode = 4;
+				  break;
+			case 'O':
+				  sortmode = 3;
+				  break;
+			case 't':
+				  sortmode = 6;
+				  break;
+			case 'T':
+				  sortmode = 5;
+				  break;
+			case 'b':
+				  unit = "bytes";
+				  scale = 1;
+				  break;
+			case 'k':
+				  unit = "kbyte";
+				  scale = 1e-3;
+				  break;
+			case 'M':
+				  unit = "Mbyte";
+				  scale = 1e-6;
+				  break;
+			case 'G':
+				  unit = "Gbyte";
+				  scale = 1e-9;
+				  break;
+			case 'q':
+			case KEY_BREAK:
+				running = false;
+				break;
+			default:
+				break;
+		}
+	}
 
 	endwin();
 }
+
+#endif