X-Git-Url: https://tinc-vpn.org/git/browse?p=tinc;a=blobdiff_plain;f=src%2Ftop.c;h=40b80479a95bce18367d0e5dc3cc771224268351;hp=f14395e23872a926eeee0da656cb5eebb7ceaae8;hb=d4410d0cce40929db9a0ce7042ef962f1867234d;hpb=3fba80174dbe29bcfe0d121a2a1d2e61be5ee57b

diff --git a/src/top.c b/src/top.c
index f14395e2..40b80479 100644
--- a/src/top.c
+++ b/src/top.c
@@ -1,6 +1,6 @@
 /*
     top.c -- Show real-time statistics from a running tincd
-    Copyright (C) 2011 Guus Sliepen <guus@tinc-vpn.org>
+    Copyright (C) 2011-2013 Guus Sliepen <guus@tinc-vpn.org>
 
     This program is free software; you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published by
@@ -21,10 +21,12 @@
 
 #ifdef HAVE_CURSES
 
+#undef KEY_EVENT  /* There are conflicting declarations for KEY_EVENT in Windows wincon.h and curses.h. */
 #include <curses.h>
 
 #include "control_common.h"
 #include "list.h"
+#include "names.h"
 #include "tincctl.h"
 #include "top.h"
 #include "xalloc.h"
@@ -57,23 +59,22 @@ static int sortmode = 0;
 static bool cumulative = false;
 
 static list_t node_list;
-static struct timeval now, prev, diff;
+static struct timeval cur, prev, diff;
 static int delay = 1000;
-static bool running = true;
 static bool changed = true;
-static const char *unit = "bytes";
-static float scale = 1;
+static const char *bunit = "bytes";
+static float bscale = 1;
+static const char *punit = "pkts";
+static float pscale = 1;
 
-#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
+static bool update(int fd) {
+	if(!sendline(fd, "%d %d", CONTROL, REQ_DUMP_TRAFFIC))
+		return false;
 
-static void update(int fd) {
-	sendline(fd, "%d %d", CONTROL, REQ_DUMP_TRAFFIC);
-	gettimeofday(&now, NULL);
+	gettimeofday(&cur, NULL);
 
-	timersub(&now, &prev, &diff);
-	prev = now;
+	timersub(&cur, &prev, &diff);
+	prev = cur;
 	float interval = diff.tv_sec + diff.tv_usec * 1e-6;
 
 	char line[4096];
@@ -85,44 +86,38 @@ static void update(int fd) {
 	uint64_t out_packets;
 	uint64_t out_bytes;
 
-	for(list_node_t *i = node_list.head; i; i = i->next) {
-		nodestats_t *node = i->data;
-		node->known = false;
-	}
+	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;
+			return true;
 
-		if(n != 7) {
-			endwin();
-			fprintf(stderr, "Error receiving traffic information\n");
-			exit(1);
-		}
+		if(n != 7)
+			return false;
 
 		nodestats_t *found = NULL;
 
-		for(list_node_t *i = node_list.head; i; i = i->next) {
-			nodestats_t *node = i->data;
-			int result = strcmp(name, node->name);
+		for list_each(nodestats_t, ns, &node_list) {
+			int result = strcmp(name, ns->name);
 			if(result > 0) {
 				continue;
 			} if(result == 0) {
-				found = node;
+				found = ns;
 				break;
 			} else {
-				found = xmalloc_and_zero(sizeof *found);
+				found = xzalloc(sizeof *found);
 				found->name = xstrdup(name);
-				list_insert_before(&node_list, i, found);
+				list_insert_before(&node_list, node, found);
 				changed = true;
 				break;
 			}
 		}
 
 		if(!found) {
-			found = xmalloc_and_zero(sizeof *found);
+			found = xzalloc(sizeof *found);
 			found->name = xstrdup(name);
 			list_insert_tail(&node_list, found);
 			changed = true;
@@ -138,6 +133,65 @@ static void update(int fd) {
 		found->out_packets = out_packets;
 		found->out_bytes = out_bytes;
 	}
+
+	return false;
+}
+
+static int cmpfloat(float a, float b) {
+	if(a < b)
+		return -1;
+	else if(a > b)
+		return 1;
+	else
+		return 0;
+}
+
+static int cmpu64(uint64_t a, uint64_t b) {
+	if(a < b)
+		return -1;
+	else if(a > b)
+		return 1;
+	else
+		return 0;
+}
+
+static 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;
+	}
 }
 
 static void redraw(void) {
@@ -145,7 +199,7 @@ static void redraw(void) {
 
 	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);
+	mvprintw(2, 0, "Node                IN %s   IN %s   OUT %s  OUT %s", punit, bunit, punit, bunit);
 	chgat(-1, A_REVERSE, 0, NULL);
 
 	static nodestats_t **sorted = 0;
@@ -153,72 +207,16 @@ static void redraw(void) {
 	if(changed) {
 		n = 0;
 		sorted = xrealloc(sorted, node_list.count * sizeof *sorted);
-		for(list_node_t *i = node_list.head; i; i = i->next)
-			sorted[n++] = i->data;
+		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);
+	if(sorted)
+		qsort(sorted, n, sizeof *sorted, sortfunc);
 
 	for(int i = 0, row = 3; i < n; i++, row++) {
 		nodestats_t *node = sorted[i];
@@ -231,11 +229,11 @@ static void redraw(void) {
 			attrset(A_DIM);
 
 		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);
+			mvprintw(row, 0, "%-16s %10.0f %10.0f %10.0f %10.0f",
+					node->name, node->in_packets * pscale, node->in_bytes * bscale, node->out_packets * pscale, node->out_bytes * bscale);
 		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);
+					node->name, node->in_packets_rate * pscale, node->in_bytes_rate * bscale, node->out_packets_rate * pscale, node->out_bytes_rate * bscale);
 	}
 
 	attrset(A_NORMAL);
@@ -247,9 +245,12 @@ static void redraw(void) {
 void top(int fd) {
 	initscr();
 	timeout(delay);
+	bool running = true;
 
 	while(running) {
-		update(fd);
+		if(!update(fd))
+			break;
+
 		redraw();
 
 		switch(getch()) {
@@ -265,45 +266,53 @@ void top(int fd) {
 				break;
 			}
 			case 'c':
-				  cumulative = !cumulative;
-				  break;
+				cumulative = !cumulative;
+				break;
 			case 'n':
-				  sortmode = 0;
-				  break;
+				sortmode = 0;
+				break;
 			case 'i':
-				  sortmode = 2;
-				  break;
+				sortmode = 2;
+				break;
 			case 'I':
-				  sortmode = 1;
-				  break;
+				sortmode = 1;
+				break;
 			case 'o':
-				  sortmode = 4;
-				  break;
+				sortmode = 4;
+				break;
 			case 'O':
-				  sortmode = 3;
-				  break;
+				sortmode = 3;
+				break;
 			case 't':
-				  sortmode = 6;
-				  break;
+				sortmode = 6;
+				break;
 			case 'T':
-				  sortmode = 5;
-				  break;
+				sortmode = 5;
+				break;
 			case 'b':
-				  unit = "bytes";
-				  scale = 1;
-				  break;
+				bunit = "bytes";
+				bscale = 1;
+				punit = "pkts";
+				pscale = 1;
+				break;
 			case 'k':
-				  unit = "kbyte";
-				  scale = 1e-3;
-				  break;
+				bunit = "kbyte";
+				bscale = 1e-3;
+				punit = "pkts";
+				pscale = 1;
+				break;
 			case 'M':
-				  unit = "Mbyte";
-				  scale = 1e-6;
-				  break;
+				bunit = "Mbyte";
+				bscale = 1e-6;
+				punit = "kpkt";
+				pscale = 1e-3;
+				break;
 			case 'G':
-				  unit = "Gbyte";
-				  scale = 1e-9;
-				  break;
+				bunit = "Gbyte";
+				bscale = 1e-9;
+				punit = "Mpkt";
+				pscale = 1e-6;
+				break;
 			case 'q':
 			case KEY_BREAK:
 				running = false;