nettrace fixes

4 files changed, 106 insertions, 29 deletions

diff --git a/src/fnettrace/fnettrace.h b/src/fnettrace/fnettrace.h
index 59b9618a9..66b7378da 100644
--- a/src/fnettrace/fnettrace.h
+++ b/src/fnettrace/fnettrace.h
@@ -29,11 +29,10 @@
 #include <stdarg.h>
 //#define DEBUG 1
 
-//#define NETLOCK_INTERVAL 15
-#define NETLOCK_INTERVAL 60
-#define DISPLAY_INTERVAL 2
-#define DISPLAY_TTL 4
-#define DISPLAY_BW_UNITS 20
+#define NETLOCK_INTERVAL 60     // seconds
+#define DISPLAY_INTERVAL 2      // seconds
+#define DISPLAY_TTL 4           // display intervals (4 * 2 seconds)
+#define DISPLAY_BW_UNITS 20     // length of the bandwidth bar
 
 
 static inline void ansi_topleft(void) {
diff --git a/src/fnettrace/hostnames b/src/fnettrace/hostnames
index a808a3b09..e24ecf218 100644
--- a/src/fnettrace/hostnames
+++ b/src/fnettrace/hostnames
@@ -20,7 +20,7 @@
 #
 # Static Internet Map
 #
-# Unfortunately, we cannot do a hostname lookup. This will leak a lot of
+# Unfortunately we cannot do a hostname lookup. This will leak a lot of
 # information about what network resources we access.
 # A static map, helped out by geoip package available on all Linux distros,
 # will have to do it for now!
diff --git a/src/fnettrace/main.c b/src/fnettrace/main.c
index d5772328c..331311ee8 100644
--- a/src/fnettrace/main.c
+++ b/src/fnettrace/main.c
@@ -26,7 +26,7 @@ static int arg_netfilter = 0;
 static char *arg_log = NULL;
 
 typedef struct hnode_t {
-        struct hnode_t *hnext;  // used for hash table
+        struct hnode_t *hnext;  // used for hash table and unused linked list
         struct hnode_t *dnext;  // used to display stremas on the screen
         uint32_t ip_src;
         uint32_t  bytes;        // number of bytes received in the last display interval
@@ -45,6 +45,36 @@ HNode *htable[HMAX] = {NULL};
 // display linked list
 HNode *dlist = NULL;
 
+
+// speed up malloc/free
+#define HNODE_MAX_MALLOC 16
+static HNode *hnode_unused = NULL;
+static int hnode_malloc_cnt = 0;
+HNode *hmalloc(void) {
+        if (hnode_unused == NULL) {
+                hnode_unused = malloc(sizeof(HNode) * HNODE_MAX_MALLOC);
+                if (!hnode_unused)
+                        errExit("malloc");
+                memset(hnode_unused, 0, sizeof(HNode) * HNODE_MAX_MALLOC);
+                HNode *ptr = hnode_unused;
+                int i;
+                for ( i = 1; i < HNODE_MAX_MALLOC; i++, ptr++)
+                        ptr->hnext = hnode_unused + i;
+        }
+
+        HNode *rv = hnode_unused;
+        hnode_unused = hnode_unused->hnext;
+        return rv;
+}
+
+void hfree(HNode *ptr) {
+        assert(ptr);
+        memset(ptr, 0, sizeof(HNode));
+        ptr->hnext = hnode_unused;
+        hnode_unused = ptr;
+}
+
+
 static void hnode_add(uint32_t ip_src, uint8_t protocol, uint16_t port_src, uint32_t bytes) {
         uint8_t h = hash(ip_src);
 
@@ -65,9 +95,8 @@ static void hnode_add(uint32_t ip_src, uint8_t protocol, uint16_t port_src, uint
 #ifdef DEBUG
         printf("malloc %d.%d.%d.%d\n", PRINT_IP(ip_src));
 #endif
-        HNode *hnew = malloc(sizeof(HNode));
-        if (!hnew)
-                errExit("malloc");
+        HNode *hnew = hmalloc();
+        assert(hnew);
         hnew->hostname = NULL;
         hnew->ip_src = ip_src;
         hnew->port_src = port_src;
@@ -117,7 +146,7 @@ static void hnode_free(HNode *elem) {
                 htable[h] = elem->hnext;
         else
                 prev->hnext = elem->hnext;
-        free(elem);
+        hfree(elem);
 }
 
 #ifdef DEBUG
@@ -194,14 +223,15 @@ static unsigned adjust_bandwidth(unsigned bw) {
 
 static void hnode_print(unsigned bw) {
         assert(!arg_netfilter);
-        ansi_clrscr();
-
+        bw = (bw < 1024 * DISPLAY_INTERVAL)? 1024 * DISPLAY_INTERVAL: bw;
 #ifdef DEBUG
         printf("*********************\n");
         debug_dlist();
         printf("-----------------------------\n");
         debug_hnode();
         printf("*********************\n");
+#else
+        ansi_clrscr();
 #endif
 
         // get terminal size
@@ -291,6 +321,17 @@ static void hnode_print(unsigned bw) {
                 ptr = next;
         }
 
+#ifdef DEBUG
+        {
+                int cnt = 0;
+                HNode *ptr = hnode_unused;
+                while (ptr) {
+                        cnt++;
+                        ptr = ptr->hnext;
+                }
+                printf("hnode unused %d\n", cnt);
+        }
+#endif
 }
 
 static void run_trace(void) {
@@ -343,9 +384,22 @@ static void run_trace(void) {
 
                 unsigned bytes = recvfrom(sock, buf, MAX_BUF_SIZE, 0, NULL, NULL);
                 if (bytes >= 20) { // size of IP header
-                        bw += bytes + 14; // assume a 14 byte Ethernet layer
+#ifdef DEBUG
+                        {
+                                uint32_t ip_src;
+                                memcpy(&ip_src, buf + 12, 4);
+                                ip_src = ntohl(ip_src);
+
+                                uint32_t ip_dst;
+                                memcpy(&ip_dst, buf + 16, 4);
+                                ip_dst = ntohl(ip_dst);
+                                printf("%d.%d.%d.%d -> %d.%d.%d.%d, %u bytes\n", PRINT_IP(ip_src), PRINT_IP(ip_dst), bytes);
+                        }
+#endif
                         // filter out loopback traffic
-                        if (buf[12] != 127) {
+                        if (buf[12] != 127 && buf[16] != 127) {
+                                bw += bytes + 14; // assume a 14 byte Ethernet layer
+
                                 uint32_t ip_src;
                                 memcpy(&ip_src, buf + 12, 4);
                                 ip_src = ntohl(ip_src);
diff --git a/src/fnettrace/radix.c b/src/fnettrace/radix.c
index b9104bd39..c9493717d 100644
--- a/src/fnettrace/radix.c
+++ b/src/fnettrace/radix.c
@@ -34,18 +34,44 @@ typedef struct rnode_t {
 RNode *head = 0;
 int radix_nodes = 0;
 
+// get rid of the malloc overhead
+#define RNODE_MAX_MALLOC 128
+static RNode *rnode_unused = NULL;
+static int rnode_malloc_cnt = 0;
+static RNode *rmalloc(void) {
+        if (rnode_unused == NULL || rnode_malloc_cnt >= RNODE_MAX_MALLOC) {
+                rnode_unused = malloc(sizeof(RNode) * RNODE_MAX_MALLOC);
+                if (!rnode_unused)
+                        errExit("malloc");
+                memset(rnode_unused, 0, sizeof(RNode) * RNODE_MAX_MALLOC);
+                rnode_malloc_cnt = 0;
+        }
+
+        rnode_malloc_cnt++;
+        return rnode_unused + rnode_malloc_cnt - 1;
+}
+
+
+static inline char *duplicate_name(const char *name) {
+        assert(name);
+
+        if (strcmp(name, "United States") == 0)
+                return "United States";
+        else if (strcmp(name, "Amazon") == 0)
+                return "Amazon";
+        return strdup(name);
+}
+
 static inline RNode *addOne(RNode *ptr, char *name) {
         assert(ptr);
         if (ptr->one)
                 return ptr->one;
-        RNode *node = malloc(sizeof(RNode));
-        if (!node)
-                errExit("malloc");
-        memset(node, 0, sizeof(RNode));
+        RNode *node = rmalloc();
+        assert(node);
         if (name) {
-                node->name = strdup(name);
+                node->name = duplicate_name(name);
                 if (!node->name)
-                        errExit("strdup");
+                        errExit("duplicate name");
         }
 
         ptr->one = node;
@@ -56,14 +82,12 @@ static inline RNode *addZero(RNode *ptr, char *name) {
         assert(ptr);
         if (ptr->zero)
                 return ptr->zero;
-        RNode *node = malloc(sizeof(RNode));
-        if (!node)
-                errExit("malloc");
-        memset(node, 0, sizeof(RNode));
+        RNode *node = rmalloc();
+        assert(node);
         if (name) {
-                node->name = strdup(name);
+                node->name = duplicate_name(name);
                 if (!node->name)
-                        errExit("strdup");
+                        errExit("duplicate name");
         }
 
         ptr->zero = node;
@@ -97,9 +121,9 @@ char *radix_add(uint32_t ip, uint32_t mask, char *name) {
         }
         assert(ptr);
         if (!ptr->name) {
-                ptr->name = strdup(name);
+                ptr->name = duplicate_name(name);
                 if (!ptr->name)
-                        errExit("strdup");
+                        errExit("duplicate_name");
         }
 
         return ptr->name;