resolve merge conflicts
authorHannes Gredler <hannes@gredler.at>
Wed, 27 May 2009 11:11:12 +0000 (13:11 +0200)
committerHannes Gredler <hannes@gredler.at>
Wed, 27 May 2009 11:11:12 +0000 (13:11 +0200)
20 files changed:
lib/debuginfo/src/olsrd_debuginfo.c
lib/debuginfo/src/olsrd_debuginfo.h
lib/httpinfo/src/olsrd_httpinfo.c
scripts/rename.sh [new file with mode: 0755]
src/common/avl.h
src/duplicate_set.c
src/duplicate_set.h
src/interfaces.c
src/lq_mpr.c
src/mid_set.c
src/mpr.c
src/neighbor_table.c
src/neighbor_table.h
src/olsr.c
src/olsr_comport.c
src/olsr_cookie.h
src/parser.c
src/process_package.c
src/two_hop_neighbor_table.c
src/two_hop_neighbor_table.h

index 11aab7f..6dddf5c 100644 (file)
@@ -57,6 +57,8 @@
 #include "parser.h"
 #include "olsr_comport_txt.h"
 #include "olsrd_debuginfo.h"
+#include "olsr_types.h"
+#include "defs.h"
 
 #include "common/autobuf.h"
 
@@ -75,7 +77,8 @@ struct debuginfo_cmd {
 static void debuginfo_new(void) __attribute__ ((constructor));
 static void debuginfo_delete(void) __attribute__ ((destructor));
 
-static enum olsr_txtcommand_result debuginfo_stat(struct comport_connection *con,  char *cmd, char *param);
+static enum olsr_txtcommand_result debuginfo_msgstat(struct comport_connection *con,  char *cmd, char *param);
+static enum olsr_txtcommand_result debuginfo_pktstat(struct comport_connection *con,  char *cmd, char *param);
 static enum olsr_txtcommand_result debuginfo_cookies(struct comport_connection *con,  char *cmd, char *param);
 
 static void update_statistics_ptr(void *);
@@ -85,25 +88,36 @@ static void update_statistics_ptr(void *data __attribute__ ((unused)));
 
 /* plugin configuration */
 static struct ip_acl allowed_nets;
+static uint32_t traffic_interval, traffic_slots, current_slot;
 
 /* plugin parameters */
 static const struct olsrd_plugin_parameters plugin_parameters[] = {
   {.name = IP_ACL_ACCEPT_PARAP,.set_plugin_parameter = &ip_acl_add_plugin_accept,.data = &allowed_nets},
   {.name = IP_ACL_REJECT_PARAM,.set_plugin_parameter = &ip_acl_add_plugin_reject,.data = &allowed_nets},
   {.name = IP_ACL_CHECKFIRST_PARAM,.set_plugin_parameter = &ip_acl_add_plugin_checkFirst,.data = &allowed_nets},
-  {.name = IP_ACL_DEFAULTPOLICY_PARAM,.set_plugin_parameter = &ip_acl_add_plugin_defaultPolicy,.data = &allowed_nets}
+  {.name = IP_ACL_DEFAULTPOLICY_PARAM,.set_plugin_parameter = &ip_acl_add_plugin_defaultPolicy,.data = &allowed_nets},
+  {.name = "stat_interval", .set_plugin_parameter = &set_plugin_int, .data = &traffic_interval},
+  {.name = "stat_slots", .set_plugin_parameter = &set_plugin_int, .data = &traffic_slots},
 };
 
 /* command callbacks and names */
 static struct debuginfo_cmd commands[] = {
-    {"stat", &debuginfo_stat, NULL, NULL},
+    {"msgstat", &debuginfo_msgstat, NULL, NULL},
+    {"pktstat", &debuginfo_pktstat, NULL, NULL},
     {"cookies", &debuginfo_cookies, NULL, NULL}
 };
 
 /* variables for statistics */
-static uint32_t recv_packets[60], recv_messages[60][6];
-static uint32_t recv_last_relevantTCs;
+static struct avl_tree stat_msg_tree, stat_pkt_tree;
+
+static struct debug_msgtraffic_count total_msg_traffic;
+static struct debug_pkttraffic_count total_pkt_traffic;
+
 static struct olsr_cookie_info *statistics_timer = NULL;
+static struct olsr_cookie_info *statistics_msg_mem = NULL;
+static struct olsr_cookie_info *statistics_pkt_mem = NULL;
+
+static union olsr_ip_addr total_ip_addr;
 
 int
 olsrd_plugin_interface_version(void)
@@ -130,6 +144,12 @@ debuginfo_new(void)
 
   ip_acl_init(&allowed_nets);
 
+  traffic_interval = 5; /* seconds */
+  traffic_slots = 12;      /* number of 5000 second slots */
+  current_slot = 0;
+
+  memset(&total_ip_addr, 255, sizeof(total_ip_addr));
+
   /* always allow localhost */
   if (olsr_cnf->ip_version == AF_INET) {
     union olsr_ip_addr ip;
@@ -172,28 +192,120 @@ olsrd_plugin_init(void)
   }
 
   statistics_timer = olsr_alloc_cookie("debuginfo statistics timer", OLSR_COOKIE_TYPE_TIMER);
-  olsr_start_timer(1000, 0, true, &update_statistics_ptr, NULL, statistics_timer->ci_id);
+  olsr_start_timer(traffic_interval * 1000, 0, true, &update_statistics_ptr, NULL, statistics_timer->ci_id);
+
+  statistics_msg_mem = olsr_alloc_cookie("debuginfo msg statistics memory", OLSR_COOKIE_TYPE_MEMORY);
+  olsr_cookie_set_memory_size(statistics_msg_mem,
+      sizeof(struct debug_msgtraffic) + sizeof(struct debug_msgtraffic_count) * traffic_slots);
 
-  memset(recv_packets, 0, sizeof(recv_packets));
-  memset(recv_messages, 0, sizeof(recv_messages));
+  statistics_pkt_mem = olsr_alloc_cookie("debuginfo pkt statistics memory", OLSR_COOKIE_TYPE_MEMORY);
+  olsr_cookie_set_memory_size(statistics_pkt_mem,
+      sizeof(struct debug_pkttraffic) + sizeof(struct debug_pkttraffic_count) * traffic_slots);
+
+  memset(&total_msg_traffic, 0, sizeof(total_msg_traffic));
+  memset(&total_pkt_traffic, 0, sizeof(total_pkt_traffic));
+  avl_init(&stat_msg_tree, avl_comp_default);
+  avl_init(&stat_pkt_tree, avl_comp_default);
 
-  recv_last_relevantTCs = 0;
   olsr_parser_add_function(&olsr_msg_statistics, PROMISCUOUS);
   olsr_preprocessor_add_function(&olsr_packet_statistics);
   return 1;
 }
 
+static struct debug_msgtraffic *get_msgtraffic_entry(union olsr_ip_addr *ip) {
+  struct debug_msgtraffic *tr;
+  tr = (struct debug_msgtraffic *) avl_find(&stat_msg_tree, ip);
+  if (tr == NULL) {
+    tr = olsr_cookie_malloc(statistics_msg_mem);
+
+    memcpy(&tr->ip, ip, sizeof(union olsr_ip_addr));
+    tr->node.key = &tr->ip;
+
+    avl_insert(&stat_msg_tree, &tr->node, AVL_DUP_NO);
+  }
+  return tr;
+}
+
+static struct debug_pkttraffic *get_pkttraffic_entry(union olsr_ip_addr *ip, struct interface *in) {
+  struct debug_pkttraffic *tr;
+  tr = (struct debug_pkttraffic *) avl_find(&stat_pkt_tree, ip);
+  if (tr == NULL) {
+    tr = olsr_cookie_malloc(statistics_pkt_mem);
+
+    memcpy(&tr->ip, ip, sizeof(union olsr_ip_addr));
+    tr->node.key = &tr->ip;
+
+    tr->int_name = strdup(in ? in->int_name : "---");
+
+    avl_insert(&stat_pkt_tree, &tr->node, AVL_DUP_NO);
+  }
+  return tr;
+}
 
 static void
 update_statistics_ptr(void *data __attribute__ ((unused)))
 {
-  uint32_t now = now_times / 1000;
-  int i;
-
-  recv_packets[now % 60] = 0;
-  for (i = 0; i < 6; i++) {
-    recv_messages[now % 60][i] = 0;
+  struct debug_msgtraffic *msg;
+  struct debug_pkttraffic *pkt;
+  uint32_t last_slot, i;
+
+  last_slot = current_slot;
+  current_slot++;
+  if (current_slot == traffic_slots) {
+    current_slot = 0;
   }
+
+  /* move data from "current" template to slot array */
+  OLSR_FOR_ALL_MSGTRAFFIC_ENTRIES(msg) {
+    /* subtract old values from node count and total count */
+    for (i=0; i<DTR_MSG_COUNT; i++) {
+      msg->total.data[i] -= msg->traffic[current_slot].data[i];
+    }
+
+    /* copy new traffic into slot */
+    msg->traffic[current_slot] = msg->current;
+
+    /* add new values to node count and total count */
+    for (i=0; i<DTR_MSG_COUNT; i++) {
+      msg->total.data[i] += msg->current.data[i];
+    }
+
+    /* erase new traffic */
+    memset(&msg->current, 0, sizeof(msg->current));
+
+    if (msg->total.data[DTR_MESSAGES] == 0) {
+      /* no traffic left, cleanup ! */
+
+      avl_delete(&stat_msg_tree, &msg->node);
+      olsr_cookie_free(statistics_msg_mem, msg);
+    }
+  } OLSR_FOR_ALL_MSGTRAFFIC_ENTRIES_END(msg)
+
+  OLSR_FOR_ALL_PKTTRAFFIC_ENTRIES(pkt) {
+    /* subtract old values from node count and total count */
+    for (i=0; i<DTR_PKT_COUNT; i++) {
+      pkt->total.data[i] -= pkt->traffic[current_slot].data[i];
+    }
+
+    /* copy new traffic into slot */
+    pkt->traffic[current_slot] = pkt->current;
+
+    /* add new values to node count and total count */
+    for (i=0; i<DTR_PKT_COUNT; i++) {
+      pkt->total.data[i] += pkt->current.data[i];
+    }
+
+    /* erase new traffic */
+    memset(&pkt->current, 0, sizeof(pkt->current));
+
+    if (pkt->total.data[DTR_PACKETS] == 0) {
+      /* no traffic left, cleanup ! */
+
+      avl_delete(&stat_msg_tree, &pkt->node);
+      free(pkt->int_name);
+      olsr_cookie_free(statistics_msg_mem, pkt);
+    }
+  } OLSR_FOR_ALL_PKTTRAFFIC_ENTRIES_END(pkt)
 }
 
 /* update message statistics */
@@ -201,95 +313,262 @@ static bool
 olsr_msg_statistics(union olsr_message *msg,
                     struct interface *input_if __attribute__ ((unused)), union olsr_ip_addr *from_addr __attribute__ ((unused)))
 {
-  uint32_t now = now_times / 1000;
-  int idx, msgtype;
-
+  int msgtype, msgsize;
+  union olsr_ip_addr origaddr;
+  enum debug_msgtraffic_type type;
+  struct debug_msgtraffic *tr;
+#if !defined REMOVE_DEBUG
+  struct ipaddr_str buf;
+#endif
+
+  memset(&origaddr, 0, sizeof(origaddr));
   if (olsr_cnf->ip_version == AF_INET) {
     msgtype = msg->v4.olsr_msgtype;
+    msgsize = ntohs(msg->v4.olsr_msgsize);
+    origaddr.v4.s_addr = msg->v4.originator;
   } else {
     msgtype = msg->v6.olsr_msgtype;
+    msgsize = ntohs(msg->v6.olsr_msgsize);
+    origaddr.v6 = msg->v6.originator;
   }
 
   switch (msgtype) {
   case HELLO_MESSAGE:
+    type = DTR_HELLO;
+    break;
   case TC_MESSAGE:
+    type = DTR_TC;
+    break;
   case MID_MESSAGE:
+    type = DTR_MID;
+    break;
   case HNA_MESSAGE:
-    idx = msgtype - 1;
+    type = DTR_HNA;
     break;
-
   case LQ_HELLO_MESSAGE:
-    idx = 0;
+    type = DTR_HELLO;
     break;
   case LQ_TC_MESSAGE:
-    idx = 1;
+    type = DTR_TC;
     break;
   default:
-    idx = 4;
+    type = DTR_OTHER;
     break;
   }
 
-  recv_messages[now % 60][idx]++;
-  if (recv_last_relevantTCs != getRelevantTcCount()) {
-    recv_messages[now % 60][5]++;
-    recv_last_relevantTCs++;
-  }
+  /* input data for specific node */
+  tr = get_msgtraffic_entry(&origaddr);
+  tr->current.data[type]++;
+  tr->current.data[DTR_MESSAGES]++;
+  tr->current.data[DTR_MSG_TRAFFIC] += msgsize;
+
+  OLSR_DEBUG(LOG_PLUGINS, "Added message type %d to statistics of %s: %d\n",
+      type, olsr_ip_to_string(&buf, &tr->ip), tr->current.data[type]);
+
+  /* input data for total traffic handling */
+  tr = get_msgtraffic_entry(&total_ip_addr);
+  tr->current.data[type]++;
+  tr->current.data[DTR_MESSAGES]++;
+  tr->current.data[DTR_MSG_TRAFFIC] += msgsize;
   return true;
 }
 
 /* update traffic statistics */
 static char *
 olsr_packet_statistics(char *packet __attribute__ ((unused)),
-                       struct interface *interface __attribute__ ((unused)),
-                       union olsr_ip_addr *ip __attribute__ ((unused)), int *length __attribute__ ((unused)))
+                       struct interface *interface,
+                       union olsr_ip_addr *ip, int *length)
 {
-  uint32_t now = now_times / 1000;
-  recv_packets[now % 60] += *length;
-
+  struct debug_pkttraffic *tr;
+  tr = get_pkttraffic_entry(ip, interface);
+  tr->current.data[DTR_PACK_TRAFFIC] += *length;
+  tr->current.data[DTR_PACKETS] ++;
+
+  tr = get_pkttraffic_entry(&total_ip_addr, NULL);
+  tr->current.data[DTR_PACK_TRAFFIC] += *length;
+  tr->current.data[DTR_PACKETS] ++;
   return packet;
 }
 
+static const char *debuginfo_print_trafficip(struct ipaddr_str *buf, union olsr_ip_addr *ip) {
+  static const char *total = "Total";
+  if (olsr_ipcmp(ip, &total_ip_addr) == 0) {
+    return total;
+  }
+  return olsr_ip_to_string(buf, ip);
+}
+
+static bool debuginfo_print_msgstat(struct autobuf *buf, bool csv, union olsr_ip_addr *ip, struct debug_msgtraffic_count *cnt) {
+  struct ipaddr_str strbuf;
+
+  if (csv) {
+    return abuf_appendf(buf, "msgstat,%s,%d,%d,%d,%d,%d,%d,%d\n",
+        debuginfo_print_trafficip(&strbuf, ip),
+        cnt->data[DTR_HELLO],
+        cnt->data[DTR_TC],
+        cnt->data[DTR_MID],
+        cnt->data[DTR_HNA],
+        cnt->data[DTR_OTHER],
+        cnt->data[DTR_MESSAGES],
+        cnt->data[DTR_MSG_TRAFFIC]) < 0;
+  }
+
+  return abuf_appendf(buf, "%-*s\t%d\t%d\t%d\t%d\t%d\t%d\t%d\t\n",
+      olsr_cnf->ip_version == AF_INET ? INET_ADDRSTRLEN : INET6_ADDRSTRLEN, debuginfo_print_trafficip(&strbuf, ip),
+      cnt->data[DTR_HELLO],
+      cnt->data[DTR_TC],
+      cnt->data[DTR_MID],
+      cnt->data[DTR_HNA],
+      cnt->data[DTR_OTHER],
+      cnt->data[DTR_MESSAGES],
+      cnt->data[DTR_MSG_TRAFFIC]) < 0;
+}
+
 static enum olsr_txtcommand_result
-debuginfo_stat(struct comport_connection *con,  char *cmd __attribute__ ((unused)), char *param __attribute__ ((unused)))
+debuginfo_msgstat(struct comport_connection *con,  char *cmd __attribute__ ((unused)), char *param __attribute__ ((unused)))
 {
-  static const char *names[] = { "HELLO", "TC", "MID", "HNA", "Other", "Rel.TCs" };
+  struct debug_msgtraffic *tr;
 
-  uint32_t msgs[6], traffic, i, j;
-  uint32_t slot = (now_times / 1000 + 59) % 60;
+  if (!con->is_csv) {
+    if (abuf_appendf(&con->out, "Slot size: %d seconds\tSlot count: %d\n", traffic_interval, traffic_slots) < 0) {
+      return ABUF_ERROR;
+    }
+    if (abuf_appendf(&con->out,
+        "Table: Statistics (without duplicates)\n%-*s\tHello\tTC\tMID\tHNA\tOther\tTotal\tBytes\n",
+        olsr_cnf->ip_version == AF_INET ? INET_ADDRSTRLEN : INET6_ADDRSTRLEN, "IP"
+        ) < 0) {
+      return ABUF_ERROR;
+    }
+  }
 
-  if (!con->is_csv && abuf_puts(&con->out, "Table: Statistics (without duplicates)\nType\tlast seconds\t\t\t\tlast min.\taverage\n") < 0) {
-    return ABUF_ERROR;
+  if (param == NULL || strcasecmp(param, "node") == 0) {
+    OLSR_FOR_ALL_MSGTRAFFIC_ENTRIES(tr) {
+      if (debuginfo_print_msgstat(&con->out, con->is_csv, &tr->ip, &tr->traffic[current_slot])) {
+        return ABUF_ERROR;
+      }
+    } OLSR_FOR_ALL_MSGTRAFFIC_ENTRIES_END(tr)
   }
+  else {
+    uint32_t mult = 1, divisor = 1;
+    struct debug_msgtraffic_count cnt;
+    int i;
 
-  for (j = 0; j < 6; j++) {
-    msgs[j] = 0;
-    for (i = 0; i < 60; i++) {
-      msgs[j] += recv_messages[i][j];
+    if (strcasecmp(param, "total") == 0) {
+      divisor = 1;
+    }
+    else if (strcasecmp(param, "average") == 0) {
+      divisor = traffic_slots;
+    }
+    else if (strcasecmp(param, "avgsec") == 0) {
+      divisor = traffic_slots * traffic_interval;
+      mult = 1;
+    }
+    else if (strcasecmp(param, "avgmin") == 0) {
+      divisor = traffic_slots * traffic_interval;
+      mult = 60;
+    }
+    else if (strcasecmp(param, "avghour") == 0) {
+      divisor = traffic_slots * traffic_interval;
+      mult = 3600;
+    }
+    else {
+      abuf_appendf(&con->out, "Error, unknown parameter %s for msgstat\n", param);
+      return CONTINUE;
     }
+
+    OLSR_FOR_ALL_MSGTRAFFIC_ENTRIES(tr) {
+      for (i=0; i<DTR_MSG_COUNT; i++) {
+        cnt.data[i] = (tr->total.data[i] * mult) / divisor;
+      }
+      if (debuginfo_print_msgstat(&con->out, con->is_csv, &tr->ip, &cnt)) {
+        return ABUF_ERROR;
+      }
+    } OLSR_FOR_ALL_MSGTRAFFIC_ENTRIES_END(tr)
   }
 
-  traffic = 0;
-  for (i = 0; i < 60; i++) {
-    traffic += recv_packets[i];
+  return CONTINUE;
+}
+
+static bool debuginfo_print_pktstat(struct autobuf *buf, bool csv, union olsr_ip_addr *ip, char *int_name, struct debug_pkttraffic_count *cnt) {
+  struct ipaddr_str strbuf;
+
+  if (csv) {
+    return abuf_appendf(buf, "msgstat,%s,%s,%d,%d\n",
+        debuginfo_print_trafficip(&strbuf, ip),
+        int_name,
+        cnt->data[DTR_PACKETS],
+        cnt->data[DTR_PACK_TRAFFIC]) < 0;
   }
 
-  for (i = 0; i < 6; i++) {
-    if (abuf_appendf(&con->out, !con->is_csv ? "%s\t%u\t%u\t%u\t%u\t%u\t%u\t\t%u\n" : "stat,%s,%u,%u,%u,%u,%u,%u,%u\n",
-                     names[i],
-                     recv_messages[(slot) % 60][i],
-                     recv_messages[(slot + 59) % 60][i],
-                     recv_messages[(slot + 58) % 60][i],
-                     recv_messages[(slot + 57) % 60][i],
-                     recv_messages[(slot + 56) % 60][i],
-                     msgs[i],
-                     msgs[i] / 60) < 0) {
-        return ABUF_ERROR;
+  return abuf_appendf(buf, "%-*s\t%s\t%d\t%d\n",
+      olsr_cnf->ip_version == AF_INET ? INET_ADDRSTRLEN : INET6_ADDRSTRLEN, debuginfo_print_trafficip(&strbuf, ip),
+      int_name,
+      cnt->data[DTR_PACKETS],
+      cnt->data[DTR_PACK_TRAFFIC]) < 0;
+}
+
+static enum olsr_txtcommand_result
+debuginfo_pktstat(struct comport_connection *con,  char *cmd __attribute__ ((unused)), char *param __attribute__ ((unused)))
+{
+  struct debug_pkttraffic *tr;
+
+  if (!con->is_csv) {
+    if (abuf_appendf(&con->out, "Slot size: %d seconds\tSlot count: %d\n", traffic_interval, traffic_slots) < 0) {
+      return ABUF_ERROR;
+    }
+    if (abuf_appendf(&con->out,
+        "Table: Statistics (without duplicates)\n%-*s\tInterf.\tPackets\tBytes\n",
+        olsr_cnf->ip_version == AF_INET ? INET_ADDRSTRLEN : INET6_ADDRSTRLEN, "IP"
+        ) < 0) {
+      return ABUF_ERROR;
     }
   }
-  if (abuf_appendf(&con->out, !con->is_csv ? "\nTraffic: %8u bytes/s\t%u bytes/minute\taverage %u bytes/s\n" : "stat,Traffic,%u,%u,%u\n",
-      recv_packets[(slot) % 60], traffic, traffic / 60) < 0) {
-    return ABUF_ERROR;
+
+  if (param == NULL || strcasecmp(param, "node") == 0) {
+    OLSR_FOR_ALL_PKTTRAFFIC_ENTRIES(tr) {
+      if (debuginfo_print_pktstat(&con->out, con->is_csv, &tr->ip, tr->int_name, &tr->traffic[current_slot])) {
+        return ABUF_ERROR;
+      }
+    } OLSR_FOR_ALL_PKTTRAFFIC_ENTRIES_END(tr)
   }
+  else {
+    uint32_t mult = 1, divisor = 1;
+    struct debug_pkttraffic_count cnt;
+    int i;
+
+    if (strcasecmp(param, "total") == 0) {
+      divisor = 1;
+    }
+    else if (strcasecmp(param, "average") == 0) {
+      divisor = traffic_slots;
+    }
+    else if (strcasecmp(param, "avgsec") == 0) {
+      divisor = traffic_slots * traffic_interval;
+      mult = 1;
+    }
+    else if (strcasecmp(param, "avgmin") == 0) {
+      divisor = traffic_slots * traffic_interval;
+      mult = 60;
+    }
+    else if (strcasecmp(param, "avghour") == 0) {
+      divisor = traffic_slots * traffic_interval;
+      mult = 3600;
+    }
+    else {
+      abuf_appendf(&con->out, "Error, unknown parameter %s for msgstat\n", param);
+      return CONTINUE;
+    }
+
+    OLSR_FOR_ALL_PKTTRAFFIC_ENTRIES(tr) {
+      for (i=0; i<DTR_PKT_COUNT; i++) {
+        cnt.data[i] = (tr->total.data[i] * mult) / divisor;
+      }
+      if (debuginfo_print_pktstat(&con->out, con->is_csv, &tr->ip, tr->int_name, &cnt)) {
+        return ABUF_ERROR;
+      }
+    } OLSR_FOR_ALL_PKTTRAFFIC_ENTRIES_END(tr)
+  }
+
   return CONTINUE;
 }
 
index c28e7fa..83aeb7c 100644 (file)
 #include "olsr_types.h"
 #include "plugin.h"
 #include "plugin_util.h"
+#include "common/avl.h"
 
-extern int nompr;
+enum debug_msgtraffic_type {
+  DTR_HELLO,
+  DTR_TC,
+  DTR_MID,
+  DTR_HNA,
+  DTR_OTHER,
+
+  DTR_MESSAGES,
+  DTR_MSG_TRAFFIC,
+
+  /* this one must be the last one */
+  DTR_MSG_COUNT
+};
+
+enum debug_pkttraffic_type {
+  DTR_PACKETS,
+  DTR_PACK_TRAFFIC,
+
+  /* this one must be the last one */
+  DTR_PKT_COUNT
+};
+
+struct debug_msgtraffic_count {
+  uint32_t data[DTR_MSG_COUNT];
+};
+
+struct debug_pkttraffic_count {
+  uint32_t data[DTR_PKT_COUNT];
+};
+
+struct debug_msgtraffic {
+  struct avl_node node;
+  union olsr_ip_addr ip;
+
+  struct debug_msgtraffic_count total;
+  struct debug_msgtraffic_count current;
+  struct debug_msgtraffic_count traffic[0];
+};
+
+struct debug_pkttraffic {
+  struct avl_node node;
+  union olsr_ip_addr ip;
+  char *int_name;
+
+  struct debug_pkttraffic_count total;
+  struct debug_pkttraffic_count current;
+  struct debug_pkttraffic_count traffic[0];
+};
+
+#define OLSR_FOR_ALL_MSGTRAFFIC_ENTRIES(tr) \
+{ \
+  struct avl_node *tr_tree_node, *next_tr_tree_node; \
+  for (tr_tree_node = avl_walk_first(&stat_msg_tree); \
+    tr_tree_node; tr_tree_node = next_tr_tree_node) { \
+    next_tr_tree_node = avl_walk_next(tr_tree_node); \
+    tr = (struct debug_msgtraffic *)(tr_tree_node);
+#define OLSR_FOR_ALL_MSGTRAFFIC_ENTRIES_END(tr) }}
+
+#define OLSR_FOR_ALL_PKTTRAFFIC_ENTRIES(tr) \
+{ \
+  struct avl_node *tr_tree_node, *next_tr_tree_node; \
+  for (tr_tree_node = avl_walk_first(&stat_pkt_tree); \
+    tr_tree_node; tr_tree_node = next_tr_tree_node) { \
+    next_tr_tree_node = avl_walk_next(tr_tree_node); \
+    tr = (struct debug_pkttraffic *)(tr_tree_node);
+#define OLSR_FOR_ALL_PKTTRAFFIC_ENTRIES_END(tr) }}
 
 #endif
 
index ef348fd..6feb0b1 100644 (file)
@@ -972,7 +972,7 @@ build_neigh_body(struct autobuf *abuf)
     thop_cnt = 0;
     OLSR_FOR_ALL_NBR2_LIST_ENTRIES(neigh, list_2) {
       struct ipaddr_str strbuf;
-      abuf_appendf(abuf, "<option>%s</option>\n", olsr_ip_to_string(&strbuf, &list_2->neighbor_2->neighbor_2_addr));
+      abuf_appendf(abuf, "<option>%s</option>\n", olsr_ip_to_string(&strbuf, &list_2->nbr2->nbr2_addr));
       thop_cnt++;
     } OLSR_FOR_ALL_NBR2_LIST_ENTRIES_END(neigh, list_2);
     abuf_appendf(abuf, "</select> (%d)</td></tr>\n", thop_cnt);
diff --git a/scripts/rename.sh b/scripts/rename.sh
new file mode 100755 (executable)
index 0000000..6fe8b51
--- /dev/null
@@ -0,0 +1,5 @@
+#!/bin/sh
+# 
+# Walk a source tree and search/replace all occurences of a given term.
+# The script comes handy for refactoring projects.
+for i in $(find . -type f -name "*.c" -o -name "*.h"); do sed 's/search-term/replace-term/g' $i > $i-tmp; mv $i $i-backup; mv $i-tmp $i; done
index 36583f9..75401ad 100644 (file)
@@ -43,7 +43,6 @@
 #define _AVL_H
 
 #include "../defs.h"
-
 #include <stddef.h>
 
 struct avl_node {
@@ -70,10 +69,10 @@ struct avl_tree {
 #define AVL_DUP    1
 #define AVL_DUP_NO 0
 
-void avl_init(struct avl_tree *, avl_tree_comp);
+void EXPORT(avl_init)(struct avl_tree *, avl_tree_comp);
 struct avl_node *EXPORT(avl_find) (struct avl_tree *, const void *);
-int avl_insert(struct avl_tree *, struct avl_node *, int);
-void avl_delete(struct avl_tree *, struct avl_node *);
+int EXPORT(avl_insert)(struct avl_tree *, struct avl_node *, int);
+void EXPORT(avl_delete)(struct avl_tree *, struct avl_node *);
 
 static INLINE struct avl_node *
 avl_walk_first(struct avl_tree *tree)
index 95f6128..da743b1 100644 (file)
@@ -53,7 +53,7 @@
 
 static void olsr_cleanup_duplicate_entry(void *unused);
 
-static struct avl_tree duplicate_set;
+static struct avl_tree forward_set, processing_set;
 static struct timer_entry *duplicate_cleanup_timer;
 
 /* Some cookies for stats keeping */
@@ -65,7 +65,8 @@ olsr_init_duplicate_set(void)
 {
   OLSR_INFO(LOG_DUPLICATE_SET, "Initialize duplicate set...\n");
 
-  avl_init(&duplicate_set, olsr_cnf->ip_version == AF_INET ? &avl_comp_ipv4 : &avl_comp_ipv6);
+  avl_init(&forward_set, avl_comp_default);
+  avl_init(&processing_set, avl_comp_default);
 
   /*
    * Get some cookies for getting stats to ease troubleshooting.
@@ -98,7 +99,7 @@ olsr_create_duplicate_entry(union olsr_ip_addr *ip, uint16_t seqnr)
 static void
 olsr_delete_duplicate_entry(struct dup_entry *entry)
 {
-  avl_delete(&duplicate_set, &entry->avl);
+  avl_delete(&forward_set, &entry->avl);
   olsr_cookie_free(duplicate_mem_cookie, entry);
 }
 
@@ -107,7 +108,13 @@ olsr_cleanup_duplicate_entry(void __attribute__ ((unused)) * unused)
 {
   struct dup_entry *entry;
 
-  OLSR_FOR_ALL_DUP_ENTRIES(entry) {
+  OLSR_FOR_ALL_DUP_ENTRIES(&forward_set, entry) {
+    if (TIMED_OUT(entry->valid_until)) {
+      olsr_delete_duplicate_entry(entry);
+    }
+  }
+  OLSR_FOR_ALL_DUP_ENTRIES_END(entry);
+  OLSR_FOR_ALL_DUP_ENTRIES(&processing_set, entry) {
     if (TIMED_OUT(entry->valid_until)) {
       olsr_delete_duplicate_entry(entry);
     }
@@ -123,27 +130,33 @@ olsr_flush_duplicate_entries(void)
 {
   struct dup_entry *entry;
 
-  OLSR_FOR_ALL_DUP_ENTRIES(entry) {
-    olsr_delete_duplicate_entry(entry);
-  } OLSR_FOR_ALL_DUP_ENTRIES_END(entry);
-
   olsr_stop_timer(duplicate_cleanup_timer);
   duplicate_cleanup_timer = NULL;
+
+  OLSR_FOR_ALL_DUP_ENTRIES(&forward_set, entry) {
+    olsr_delete_duplicate_entry(entry);
+  } OLSR_FOR_ALL_DUP_ENTRIES_END(entry);
+  OLSR_FOR_ALL_DUP_ENTRIES(&processing_set, entry) {
+    olsr_delete_duplicate_entry(entry);
+  } OLSR_FOR_ALL_DUP_ENTRIES_END(entry);
 }
 
 int
-olsr_message_is_duplicate(union olsr_message *m)
+olsr_message_is_duplicate(union olsr_message *m, bool forwarding)
 {
+  struct avl_tree *tree;
   struct dup_entry *entry;
   int diff;
   union olsr_ip_addr *mainIp;
   uint32_t valid_until;
   uint16_t seqnr;
   union olsr_ip_addr *ip;
+
 #if !defined(REMOVE_LOG_DEBUG)
   struct ipaddr_str buf;
 #endif
 
+  tree = forwarding ? &forward_set : &processing_set;
   if (olsr_cnf->ip_version == AF_INET) {
     seqnr = ntohs(m->v4.seqno);
     ip = (union olsr_ip_addr *)&m->v4.originator;
@@ -160,11 +173,11 @@ olsr_message_is_duplicate(union olsr_message *m)
 
   valid_until = GET_TIMESTAMP(DUPLICATE_VTIME);
 
-  entry = (struct dup_entry *)avl_find(&duplicate_set, ip);
+  entry = (struct dup_entry *)avl_find(tree, ip);
   if (entry == NULL) {
     entry = olsr_create_duplicate_entry(ip, seqnr);
     if (entry != NULL) {
-      avl_insert(&duplicate_set, &entry->avl, 0);
+      avl_insert(tree, &entry->avl, 0);
       entry->valid_until = valid_until;
     }
     return false;               // okay, we process this package
@@ -226,11 +239,21 @@ olsr_print_duplicate_table(void)
   struct dup_entry *entry;
   const int ipwidth = olsr_cnf->ip_version == AF_INET ? 15 : 30;
 
-  OLSR_INFO(LOG_DUPLICATE_SET, "\n--- %s ------------------------------------------------- DUPLICATE SET\n\n",
+  OLSR_INFO(LOG_DUPLICATE_SET, "\n--- %s ------------------------------------------------- DUPLICATE SET (forwarding)\n\n",
+            olsr_wallclock_string());
+  OLSR_INFO_NH(LOG_DUPLICATE_SET, "%-*s %8s %s\n", ipwidth, "Node IP", "DupArray", "VTime");
+
+  OLSR_FOR_ALL_DUP_ENTRIES(&forward_set, entry) {
+    struct ipaddr_str addrbuf;
+    OLSR_INFO_NH(LOG_DUPLICATE_SET, "%-*s %08x %s\n",
+                 ipwidth, olsr_ip_to_string(&addrbuf, entry->avl.key), entry->array, olsr_clock_string(entry->valid_until));
+  } OLSR_FOR_ALL_DUP_ENTRIES_END(entry);
+
+  OLSR_INFO(LOG_DUPLICATE_SET, "\n--- %s ------------------------------------------------- DUPLICATE SET (processing)\n\n",
             olsr_wallclock_string());
   OLSR_INFO_NH(LOG_DUPLICATE_SET, "%-*s %8s %s\n", ipwidth, "Node IP", "DupArray", "VTime");
 
-  OLSR_FOR_ALL_DUP_ENTRIES(entry) {
+  OLSR_FOR_ALL_DUP_ENTRIES(&processing_set, entry) {
     struct ipaddr_str addrbuf;
     OLSR_INFO_NH(LOG_DUPLICATE_SET, "%-*s %08x %s\n",
                  ipwidth, olsr_ip_to_string(&addrbuf, entry->avl.key), entry->array, olsr_clock_string(entry->valid_until));
index d20b4fe..0f89f07 100644 (file)
@@ -47,7 +47,7 @@
 #include "mantissa.h"
 #include "common/avl.h"
 
-#define DUPLICATE_CLEANUP_INTERVAL 15000
+#define DUPLICATE_CLEANUP_INTERVAL 30000
 #define DUPLICATE_CLEANUP_JITTER 25
 #define DUPLICATE_VTIME 120000
 
@@ -63,14 +63,14 @@ struct dup_entry {
 AVLNODE2STRUCT(duptree2dupentry, struct dup_entry, avl);
 
 void olsr_init_duplicate_set(void);
-int olsr_message_is_duplicate(union olsr_message *m);
+int olsr_message_is_duplicate(union olsr_message *m, bool forward_set);
 void olsr_print_duplicate_table(void);
 void olsr_flush_duplicate_entries(void);
 
-#define OLSR_FOR_ALL_DUP_ENTRIES(dup) \
+#define OLSR_FOR_ALL_DUP_ENTRIES(avltree, dup) \
 { \
   struct avl_node *dup_tree_node, *next_dup_tree_node; \
-  for (dup_tree_node = avl_walk_first(&duplicate_set); \
+  for (dup_tree_node = avl_walk_first(avltree); \
     dup_tree_node; dup_tree_node = next_dup_tree_node) { \
     next_dup_tree_node = avl_walk_next(dup_tree_node); \
     dup = duptree2dupentry(dup_tree_node);
index c697f98..543835d 100644 (file)
@@ -193,14 +193,19 @@ remove_interface(struct interface **pinterf)
    * Deregister functions for periodic message generation
    */
   olsr_stop_timer(ifp->hello_gen_timer);
+  ifp->hello_gen_timer = NULL;
   olsr_stop_timer(ifp->tc_gen_timer);
+  ifp->tc_gen_timer = NULL;
   olsr_stop_timer(ifp->mid_gen_timer);
+  ifp->mid_gen_timer = NULL;
   olsr_stop_timer(ifp->hna_gen_timer);
+  ifp->hna_gen_timer = NULL;
 
   /*
    * Stop interface pacing.
    */
   olsr_stop_timer(ifp->buffer_hold_timer);
+  ifp->buffer_hold_timer = NULL;
 
   /*
    * Unlink from config.
index 0fa4c50..2f02309 100644 (file)
@@ -50,8 +50,8 @@
 void
 olsr_calculate_lq_mpr(void)
 {
-  struct neighbor_2_entry *neigh2;
-  struct neighbor_list_entry *walker;
+  struct nbr2_entry *neigh2;
+  struct nbr_list_entry *walker;
   int i, k;
   struct nbr_entry *neigh;
   olsr_linkcost best, best_1hop;
@@ -90,7 +90,7 @@ olsr_calculate_lq_mpr(void)
 
       /* check whether this 2-hop neighbour is also a neighbour */
 
-      neigh = olsr_lookup_nbr_entry(&neigh2->neighbor_2_addr);
+      neigh = olsr_lookup_nbr_entry(&neigh2->nbr2_addr);
 
       /* if it's a neighbour and also symmetric, then examine
          the link quality */
@@ -111,7 +111,7 @@ olsr_calculate_lq_mpr(void)
 
         /* see wether we find a better route via an MPR */
 
-        for (walker = neigh2->neighbor_2_nblist.next; walker != &neigh2->neighbor_2_nblist; walker = walker->next)
+        for (walker = neigh2->nbr2_nblist.next; walker != &neigh2->nbr2_nblist; walker = walker->next)
           if (walker->path_linkcost < best_1hop)
             break;
 
@@ -119,7 +119,7 @@ olsr_calculate_lq_mpr(void)
          * a better route via an MPR - so, skip MPR selection for
          * this 1-hop neighbor */
 
-        if (walker == &neigh2->neighbor_2_nblist)
+        if (walker == &neigh2->nbr2_nblist)
           continue;
       }
 
@@ -128,7 +128,7 @@ olsr_calculate_lq_mpr(void)
 
       /* mark all 1-hop neighbours as not selected */
 
-      for (walker = neigh2->neighbor_2_nblist.next; walker != &neigh2->neighbor_2_nblist; walker = walker->next)
+      for (walker = neigh2->nbr2_nblist.next; walker != &neigh2->nbr2_nblist; walker = walker->next)
         walker->neighbor->skip = false;
 
       for (k = 0; k < olsr_cnf->mpr_coverage; k++) {
@@ -138,7 +138,7 @@ olsr_calculate_lq_mpr(void)
         neigh = NULL;
         best = LINK_COST_BROKEN;
 
-        for (walker = neigh2->neighbor_2_nblist.next; walker != &neigh2->neighbor_2_nblist; walker = walker->next)
+        for (walker = neigh2->nbr2_nblist.next; walker != &neigh2->nbr2_nblist; walker = walker->next)
           if (walker->neighbor->status == SYM && !walker->neighbor->skip && walker->path_linkcost < best) {
             neigh = walker->neighbor;
             best = walker->path_linkcost;
index 55d0853..890ecb6 100644 (file)
@@ -128,7 +128,7 @@ olsr_flush_nbr2_duplicates(struct mid_entry *alias)
 
   OLSR_FOR_ALL_TC_MID_ENTRIES(tc, alias) {
     struct nbr_entry *nbr;
-    struct neighbor_2_entry *nbr2 = olsr_lookup_two_hop_neighbor_table_mid(&alias->mid_alias_addr);
+    struct nbr2_entry *nbr2 = olsr_lookup_two_hop_neighbor_table_mid(&alias->mid_alias_addr);
 
     /* Delete possible 2 hop neighbor */
     if (nbr2) {
index 40b32c0..e4b98cd 100644 (file)
--- a/src/mpr.c
+++ b/src/mpr.c
@@ -76,7 +76,7 @@ static int olsr_chosen_mpr(struct nbr_entry *, uint16_t *);
 static int
 olsr_chosen_mpr(struct nbr_entry *one_hop_neighbor, uint16_t * two_hop_covered_count)
 {
-  struct neighbor_list_entry *the_one_hop_list;
+  struct nbr_list_entry *the_one_hop_list;
   struct nbr2_list_entry *second_hop_entries;
   struct nbr_entry *dup_neighbor;
   uint16_t count;
@@ -93,34 +93,34 @@ olsr_chosen_mpr(struct nbr_entry *one_hop_neighbor, uint16_t * two_hop_covered_c
 
   OLSR_FOR_ALL_NBR2_LIST_ENTRIES(one_hop_neighbor, second_hop_entries) {
 
-    dup_neighbor = olsr_lookup_nbr_entry(&second_hop_entries->neighbor_2->neighbor_2_addr);
+    dup_neighbor = olsr_lookup_nbr_entry(&second_hop_entries->nbr2->nbr2_addr);
 
     if ((dup_neighbor != NULL) && (dup_neighbor->status == SYM)) {
       OLSR_DEBUG(LOG_MPR, "(2)Skipping 2h neighbor %s - already 1hop\n",
-                 olsr_ip_to_string(&buf, &second_hop_entries->neighbor_2->neighbor_2_addr));
+                 olsr_ip_to_string(&buf, &second_hop_entries->nbr2->nbr2_addr));
       continue;
     }
-    //      if(!second_hop_entries->neighbor_2->neighbor_2_state)
-    //if(second_hop_entries->neighbor_2->mpr_covered_count < olsr_cnf->mpr_coverage)
+    //      if(!second_hop_entries->nbr2->nbr2_state)
+    //if(second_hop_entries->nbr2->mpr_covered_count < olsr_cnf->mpr_coverage)
     //{
     /*
        Now the neighbor is covered by this mpr
      */
-    second_hop_entries->neighbor_2->mpr_covered_count++;
-    the_one_hop_list = second_hop_entries->neighbor_2->neighbor_2_nblist.next;
+    second_hop_entries->nbr2->mpr_covered_count++;
+    the_one_hop_list = second_hop_entries->nbr2->nbr2_nblist.next;
 
     OLSR_DEBUG(LOG_MPR, "[%s] has coverage %d\n",
-               olsr_ip_to_string(&buf, &second_hop_entries->neighbor_2->neighbor_2_addr),
-               second_hop_entries->neighbor_2->mpr_covered_count);
+               olsr_ip_to_string(&buf, &second_hop_entries->nbr2->nbr2_addr),
+               second_hop_entries->nbr2->mpr_covered_count);
 
-    if (second_hop_entries->neighbor_2->mpr_covered_count >= olsr_cnf->mpr_coverage)
+    if (second_hop_entries->nbr2->mpr_covered_count >= olsr_cnf->mpr_coverage)
       count++;
 
-    while (the_one_hop_list != &second_hop_entries->neighbor_2->neighbor_2_nblist) {
+    while (the_one_hop_list != &second_hop_entries->nbr2->nbr2_nblist) {
 
       if ((the_one_hop_list->neighbor->status == SYM)) {
-        if (second_hop_entries->neighbor_2->mpr_covered_count >= olsr_cnf->mpr_coverage) {
-          the_one_hop_list->neighbor->neighbor_2_nocov--;
+        if (second_hop_entries->nbr2->mpr_covered_count >= olsr_cnf->mpr_coverage) {
+          the_one_hop_list->neighbor->nbr2_nocov--;
         }
       }
       the_one_hop_list = the_one_hop_list->next;
@@ -156,11 +156,11 @@ olsr_find_maximum_covered(int willingness)
 
     OLSR_DEBUG(LOG_MPR, "[%s] nocov: %d mpr: %d will: %d max: %d\n\n",
                olsr_ip_to_string(&buf, &a_neighbor->neighbor_main_addr),
-               a_neighbor->neighbor_2_nocov, a_neighbor->is_mpr, a_neighbor->willingness, maximum);
+               a_neighbor->nbr2_nocov, a_neighbor->is_mpr, a_neighbor->willingness, maximum);
 
-    if ((!a_neighbor->is_mpr) && (a_neighbor->willingness == willingness) && (maximum < a_neighbor->neighbor_2_nocov)) {
+    if ((!a_neighbor->is_mpr) && (a_neighbor->willingness == willingness) && (maximum < a_neighbor->nbr2_nocov)) {
 
-      maximum = a_neighbor->neighbor_2_nocov;
+      maximum = a_neighbor->nbr2_nocov;
       mpr_candidate = a_neighbor;
     }
   } OLSR_FOR_ALL_NBR_ENTRIES_END(a_neighbor);
@@ -188,7 +188,7 @@ olsr_clear_mprs(void)
 
     /* Clear two hop neighbors coverage count/ */
     OLSR_FOR_ALL_NBR2_LIST_ENTRIES(a_neighbor, two_hop_list) {
-      two_hop_list->neighbor_2->mpr_covered_count = 0;
+      two_hop_list->nbr2->mpr_covered_count = 0;
     } OLSR_FOR_ALL_NBR2_LIST_ENTRIES_END(a_neighbor, two_hop_list);
   } OLSR_FOR_ALL_NBR_ENTRIES_END(a_neighbor);
 }
@@ -232,10 +232,10 @@ olsr_clear_two_hop_processed(void)
   int idx;
 
   for (idx = 0; idx < HASHSIZE; idx++) {
-    struct neighbor_2_entry *neighbor_2;
-    for (neighbor_2 = two_hop_neighbortable[idx].next; neighbor_2 != &two_hop_neighbortable[idx]; neighbor_2 = neighbor_2->next) {
+    struct nbr2_entry *nbr2;
+    for (nbr2 = two_hop_neighbortable[idx].next; nbr2 != &two_hop_neighbortable[idx]; nbr2 = nbr2->next) {
       /* Clear */
-      neighbor_2->processed = 0;
+      nbr2->processed = 0;
     }
   }
 
@@ -260,22 +260,22 @@ olsr_calculate_two_hop_neighbors(void)
   OLSR_FOR_ALL_NBR_ENTRIES(a_neighbor) {
 
     if (a_neighbor->status == NOT_SYM) {
-      a_neighbor->neighbor_2_nocov = count;
+      a_neighbor->nbr2_nocov = count;
       continue;
     }
 
     OLSR_FOR_ALL_NBR2_LIST_ENTRIES(a_neighbor, twohop_neighbors) {
-      dup_neighbor = olsr_lookup_nbr_entry(&twohop_neighbors->neighbor_2->neighbor_2_addr);
+      dup_neighbor = olsr_lookup_nbr_entry(&twohop_neighbors->nbr2->nbr2_addr);
 
       if ((dup_neighbor == NULL) || (dup_neighbor->status != SYM)) {
         n_count++;
-        if (!twohop_neighbors->neighbor_2->processed) {
+        if (!twohop_neighbors->nbr2->processed) {
           count++;
-          twohop_neighbors->neighbor_2->processed = 1;
+          twohop_neighbors->nbr2->processed = 1;
         }
       }
     } OLSR_FOR_ALL_NBR2_LIST_ENTRIES_END(a_neighbor, twohop_neighbors);
-    a_neighbor->neighbor_2_nocov = n_count;
+    a_neighbor->nbr2_nocov = n_count;
 
     /* Add the two hop count */
     sum += count;
@@ -324,7 +324,7 @@ olsr_calculate_mpr(void)
   struct ipaddr_str buf;
 #endif
 
-  struct neighbor_2_entry *nbr2;
+  struct nbr2_entry *nbr2;
   struct nbr_entry *nbr;
   struct nbr_entry *mprs;
   uint16_t two_hop_covered_count;
@@ -350,28 +350,28 @@ olsr_calculate_mpr(void)
       /*
        * Eliminate 2 hop neighbors which already are in our 1 hop neighborhood.
        */
-      nbr = olsr_lookup_nbr_entry(&nbr2->neighbor_2_addr);
+      nbr = olsr_lookup_nbr_entry(&nbr2->nbr2_addr);
       if (nbr && (nbr->status != NOT_SYM)) {
         OLSR_DEBUG(LOG_MPR, "Skipping 2-hop neighbor2 %s - already 1hop\n",
-                   olsr_ip_to_string(&buf, &nbr2->neighbor_2_addr));
+                   olsr_ip_to_string(&buf, &nbr2->nbr2_addr));
         continue;
       }
 
       /*
        * Eliminate 2 hop neighbors which are not single link.
        */
-      if (nbr2->neighbor_2_pointer != 1) {
+      if (nbr2->nbr2_refcount != 1) {
         OLSR_DEBUG(LOG_MPR, "Skipping 2-hop neighbor %s - not single link\n",
-                   olsr_ip_to_string(&buf, &nbr2->neighbor_2_addr));
+                   olsr_ip_to_string(&buf, &nbr2->nbr2_addr));
         continue;
       }
 
-      nbr = nbr2->neighbor_2_nblist.next->neighbor;
+      nbr = nbr2->nbr2_nblist.next->neighbor;
 
       /* Already an elected MPR ? */
       if (nbr->is_mpr) {
         OLSR_DEBUG(LOG_MPR, "Skipping 2-hop neighbor %s - already MPR\n",
-                   olsr_ip_to_string(&buf, &nbr2->neighbor_2_addr));
+                   olsr_ip_to_string(&buf, &nbr2->nbr2_addr));
         continue;
       }
 
@@ -388,7 +388,7 @@ olsr_calculate_mpr(void)
       /*
        * This 2 hop neighbor is good enough.
        */
-      OLSR_DEBUG(LOG_MPR, "One link adding %s\n", olsr_ip_to_string(&buf, &nbr2->neighbor_2_addr));
+      OLSR_DEBUG(LOG_MPR, "One link adding %s\n", olsr_ip_to_string(&buf, &nbr2->nbr2_addr));
       olsr_chosen_mpr(nbr, &two_hop_covered_count);
 
     } OLSR_FOR_ALL_NBR2_ENTRIES_END(nbr2);
@@ -454,16 +454,16 @@ olsr_optimize_mpr_set(void)
         int remove_it = 1;
 
         OLSR_FOR_ALL_NBR2_LIST_ENTRIES(a_neighbor, two_hop_list) {
-          const struct nbr_entry *dup_neighbor = olsr_lookup_nbr_entry(&two_hop_list->neighbor_2->neighbor_2_addr);
+          const struct nbr_entry *dup_neighbor = olsr_lookup_nbr_entry(&two_hop_list->nbr2->nbr2_addr);
 
           if ((dup_neighbor != NULL) && (dup_neighbor->status != NOT_SYM)) {
             continue;
           }
 
-          OLSR_DEBUG(LOG_MPR, "\t[%s] coverage %d\n", olsr_ip_to_string(&buf, &two_hop_list->neighbor_2->neighbor_2_addr),
-                     two_hop_list->neighbor_2->mpr_covered_count);
+          OLSR_DEBUG(LOG_MPR, "\t[%s] coverage %d\n", olsr_ip_to_string(&buf, &two_hop_list->nbr2->nbr2_addr),
+                     two_hop_list->nbr2->mpr_covered_count);
           /* Do not remove if we find a entry which need this MPR */
-          if (two_hop_list->neighbor_2->mpr_covered_count <= olsr_cnf->mpr_coverage) {
+          if (two_hop_list->nbr2->mpr_covered_count <= olsr_cnf->mpr_coverage) {
             remove_it = 0;
             break;
           }
index 84d3f89..c68b4d8 100644 (file)
@@ -85,14 +85,14 @@ olsr_init_neighbor_table(void)
  * Add a neighbor 2 reference to a neighbor.
  */
 struct nbr2_list_entry *
-olsr_add_nbr2_list_entry(struct nbr_entry *nbr, struct neighbor_2_entry *nbr2, float vtime)
+olsr_add_nbr2_list_entry(struct nbr_entry *nbr, struct nbr2_entry *nbr2, float vtime)
 {
   struct nbr2_list_entry *nbr2_list;
 
   /*
    * check first if the entry exists.
    */
-  nbr2_list = olsr_lookup_nbr2_list_entry(nbr, &nbr2->neighbor_2_addr);
+  nbr2_list = olsr_lookup_nbr2_list_entry(nbr, &nbr2->nbr2_addr);
   if (nbr2_list) {
 
     /* 
@@ -107,9 +107,10 @@ olsr_add_nbr2_list_entry(struct nbr_entry *nbr, struct neighbor_2_entry *nbr2, f
    */
   nbr2_list = olsr_cookie_malloc(nbr2_list_mem_cookie);
 
-  nbr2_list->neighbor_2 = nbr2;
-  nbr2->neighbor_2_pointer++;   /* XXX move to olsr_lock_nbr2 () */
-  nbr2_list->nbr2_nbr = nbr;    /* XXX nbr needs refcount protection as well */
+  nbr2_list->nbr2 = nbr2;
+  olsr_lock_nbr2(nbr2);
+
+  nbr2_list->nbr2_nbr = nbr;    /* XXX nbr refcount protection */
 
   /*
    * Start the timer.
@@ -118,7 +119,7 @@ olsr_add_nbr2_list_entry(struct nbr_entry *nbr, struct neighbor_2_entry *nbr2, f
                    &olsr_expire_nbr2_list, nbr2_list, nbr2_list_timer_cookie->ci_id);
 
   /* Add to the nbr2 reference subtree */
-  nbr2_list->nbr2_list_node.key = &nbr2->neighbor_2_addr;
+  nbr2_list->nbr2_list_node.key = &nbr2->nbr2_addr;
   avl_insert(&nbr->nbr2_list_tree, &nbr2_list->nbr2_list_node, AVL_DUP_NO);
 
   return nbr2_list;
@@ -131,18 +132,12 @@ olsr_add_nbr2_list_entry(struct nbr_entry *nbr, struct neighbor_2_entry *nbr2, f
 static void
 olsr_delete_nbr2_list_entry(struct nbr2_list_entry *nbr2_list)
 {
-  struct neighbor_2_entry *nbr2;
+  struct nbr2_entry *nbr2;
   struct nbr_entry *nbr;
 
-  nbr2 = nbr2_list->neighbor_2;
+  nbr2 = nbr2_list->nbr2;
   nbr = nbr2_list->nbr2_nbr;
 
-  /* XXX move to olsr_unlock_nbr2() */
-  if (nbr2->neighbor_2_pointer < 1) {
-    DEQUEUE_ELEM(nbr2);
-    free(nbr2);
-  }
-
   /*
    * Kill running timers.
    */
@@ -152,6 +147,10 @@ olsr_delete_nbr2_list_entry(struct nbr2_list_entry *nbr2_list)
   /* Remove from neighbor2 reference subtree */
   avl_delete(&nbr->nbr2_list_tree, &nbr2_list->nbr2_list_node);
 
+  /* Remove reference to a two-hop neighbor, unlock */
+  nbr2_list->nbr2 = NULL;
+  olsr_unlock_nbr2(nbr2);
+
   olsr_cookie_free(nbr2_list_mem_cookie, nbr2_list);
 
   /* Set flags to recalculate the MPR set and the routing table */
@@ -235,8 +234,7 @@ olsr_delete_nbr_entry(const union olsr_ip_addr * addr)
   OLSR_DEBUG(LOG_NEIGHTABLE, "Delete 1-hop neighbor: %s\n", olsr_ip_to_string(&buf, addr));
 
   OLSR_FOR_ALL_NBR2_LIST_ENTRIES(nbr, nbr2_list) {
-    nbr2_list->neighbor_2->neighbor_2_pointer--;        /* XXX move to olsr_nbr2_unlock() */
-    olsr_delete_neighbor_pointer(nbr2_list->neighbor_2, nbr);
+    olsr_delete_neighbor_pointer(nbr2_list->nbr2, nbr);
     olsr_delete_nbr2_list_entry(nbr2_list);
   } OLSR_FOR_ALL_NBR2_LIST_ENTRIES_END(nbr, nbr2_list);
 
@@ -355,7 +353,7 @@ olsr_update_nbr_status(struct nbr_entry *entry, int lnk)
   if (lnk == SYM_LINK) {
     /* N_status is set to SYM */
     if (entry->status == NOT_SYM) {
-      struct neighbor_2_entry *two_hop_neighbor;
+      struct nbr2_entry *two_hop_neighbor;
 
       /* Delete posible 2 hop entry on this neighbor */
       if ((two_hop_neighbor = olsr_lookup_two_hop_neighbor_table(&entry->neighbor_main_addr)) != NULL) {
@@ -392,16 +390,16 @@ olsr_expire_nbr2_list(void *context)
 {
   struct nbr2_list_entry *nbr2_list;
   struct nbr_entry *nbr;
-  struct neighbor_2_entry *nbr2;
+  struct nbr2_entry *nbr2;
 
   nbr2_list = (struct nbr2_list_entry *)context;
   nbr2_list->nbr2_list_timer = NULL;
 
   nbr = nbr2_list->nbr2_nbr;
-  nbr2 = nbr2_list->neighbor_2;
+  nbr2 = nbr2_list->nbr2;
 
-  nbr2->neighbor_2_pointer--;   /* XXX move to olsr_unlock_nbr2() */
   olsr_delete_neighbor_pointer(nbr2, nbr);
+  olsr_unlock_nbr2(nbr2);
 
   olsr_delete_nbr2_list_entry(nbr2_list);
 }
index f27ed38..112576e 100644 (file)
@@ -55,7 +55,7 @@
 struct nbr2_list_entry {
   struct avl_node nbr2_list_node;
   struct nbr_entry *nbr2_nbr;          /* backpointer to owning nbr entry */
-  struct neighbor_2_entry *neighbor_2;
+  struct nbr2_entry *nbr2;
   struct timer_entry *nbr2_list_timer;
 };
 
@@ -71,7 +71,7 @@ struct nbr_entry {
   unsigned int is_mpr:1;
   unsigned int was_mpr:1;              /* Used to detect changes in MPR */
   unsigned int skip:1;
-  int neighbor_2_nocov;
+  int nbr2_nocov;
   unsigned int linkcount;
   struct avl_tree nbr2_list_tree;      /* subtree for nbr2 pointers */
 } __attribute__ ((packed));
@@ -113,9 +113,9 @@ extern struct olsr_cookie_info *nbr2_list_timer_cookie;
 void olsr_init_neighbor_table(void);
 bool olsr_delete_nbr2_list_entry_by_addr(struct nbr_entry *, union olsr_ip_addr *);
 struct nbr2_list_entry *olsr_lookup_nbr2_list_entry(struct nbr_entry *, const union olsr_ip_addr *);
-struct nbr2_list_entry *olsr_add_nbr2_list_entry(struct nbr_entry *, struct neighbor_2_entry *, float);
+struct nbr2_list_entry *olsr_add_nbr2_list_entry(struct nbr_entry *, struct nbr2_entry *, float);
 bool olsr_delete_nbr_entry(const union olsr_ip_addr *);
-void olsr_link_nbr_nbr2(struct nbr_entry *, struct neighbor_2_entry *, float);
+void olsr_link_nbr_nbr2(struct nbr_entry *, struct nbr2_entry *, float);
 struct nbr_entry *olsr_add_nbr_entry(const union olsr_ip_addr *);
 struct nbr_entry *olsr_lookup_nbr_entry(const union olsr_ip_addr *);
 struct nbr_entry *olsr_lookup_nbr_entry_alias(const union olsr_ip_addr *);
index 4381834..c500c00 100644 (file)
@@ -298,7 +298,7 @@ olsr_forward_message(union olsr_message *m, struct interface *in_if, union olsr_
   }
 
   /* check if we already forwarded this message */
-  if (olsr_message_is_duplicate(m)) {
+  if (olsr_message_is_duplicate(m, true)) {
     return 0;                   /* it's a duplicate, forget about it */
   }
 
index 623eda9..f6c7e27 100644 (file)
@@ -363,8 +363,6 @@ static void olsr_com_parse_connection(int fd, void *data, unsigned int flags) {
     }
   }
 
-  fprintf(stderr, "State: %d\n", con->state);
-
   /* end of connection ? */
   if (con->state == CLEANUP) {
     OLSR_DEBUG(LOG_COMPORT, "  cleanup\n");
index 778408e..8788be5 100644 (file)
@@ -45,7 +45,7 @@
 #ifndef _OLSR_COOKIE_H
 #define _OLSR_COOKIE_H
 
-#define COOKIE_ID_MAX  40       /* maximum number of cookies in the system */
+#define COOKIE_ID_MAX  50       /* maximum number of cookies in the system */
 
 typedef enum olsr_cookie_type_ {
   OLSR_COOKIE_TYPE_MIN,
index ca940eb..d51822d 100644 (file)
@@ -294,15 +294,20 @@ parse_packet(struct olsr *olsr, int size, struct interface *in_if, union olsr_ip
       continue;
     }
 
-    for (entry = parse_functions; entry != NULL; entry = entry->next) {
-      /* Should be the same for IPv4 and IPv6 */
-      /* Promiscuous or exact match */
-      if ((entry->type == PROMISCUOUS) || (entry->type == m->v4.olsr_msgtype)) {
-        if (!entry->function(m, in_if, from_addr))
-          forward = false;
+    if (olsr_message_is_duplicate(m, false)) {
+      OLSR_INFO(LOG_PACKET_PARSING, "Not processing message duplicate from %s!\n",
+          olsr_ip_to_string(&buf, (union olsr_ip_addr *)&m->v4.originator));
+    }
+    else {
+      for (entry = parse_functions; entry != NULL; entry = entry->next) {
+        /* Should be the same for IPv4 and IPv6 */
+        /* Promiscuous or exact match */
+        if ((entry->type == PROMISCUOUS) || (entry->type == m->v4.olsr_msgtype)) {
+          if (!entry->function(m, in_if, from_addr))
+            forward = false;
+        }
       }
     }
-
     if (forward) {
       olsr_forward_message(m, in_if, from_addr);
     }
index 67868b3..683d8a7 100644 (file)
@@ -96,7 +96,7 @@ process_message_neighbors(struct nbr_entry *neighbor, const struct lq_hello_mess
     if (message_neighbors->neigh_type == SYM_NEIGH || message_neighbors->neigh_type == MPR_NEIGH) {
       struct nbr2_list_entry *two_hop_neighbor_yet = olsr_lookup_nbr2_list_entry(neighbor, &message_neighbors->addr);
       if (two_hop_neighbor_yet != NULL) {
-        struct neighbor_list_entry *walker;
+        struct nbr_list_entry *walker;
 
         /* Updating the holding time for this neighbor */
         olsr_set_timer(&two_hop_neighbor_yet->nbr2_list_timer,
@@ -113,8 +113,8 @@ process_message_neighbors(struct nbr_entry *neighbor, const struct lq_hello_mess
          * loop through the one-hop neighbors that see this
          * 'two_hop_neighbor'
          */
-        for (walker = two_hop_neighbor_yet->neighbor_2->neighbor_2_nblist.next;
-             walker != &two_hop_neighbor_yet->neighbor_2->neighbor_2_nblist; walker = walker->next) {
+        for (walker = two_hop_neighbor_yet->nbr2->nbr2_nblist.next;
+             walker != &two_hop_neighbor_yet->nbr2->nbr2_nblist; walker = walker->next) {
           /*
            * have we found the one-hop neighbor that sent the
            * HELLO message that we're current processing?
@@ -124,14 +124,14 @@ process_message_neighbors(struct nbr_entry *neighbor, const struct lq_hello_mess
           }
         }
       } else {
-        struct neighbor_2_entry *two_hop_neighbor = olsr_lookup_two_hop_neighbor_table(&message_neighbors->addr);
+        struct nbr2_entry *two_hop_neighbor = olsr_lookup_two_hop_neighbor_table(&message_neighbors->addr);
         if (two_hop_neighbor == NULL) {
           OLSR_DEBUG(LOG_LINKS, "Adding 2 hop neighbor %s\n\n", olsr_ip_to_string(&buf, &message_neighbors->addr));
           two_hop_neighbor = olsr_malloc(sizeof(*two_hop_neighbor), "Process HELLO");
-          two_hop_neighbor->neighbor_2_nblist.next = &two_hop_neighbor->neighbor_2_nblist;
-          two_hop_neighbor->neighbor_2_nblist.prev = &two_hop_neighbor->neighbor_2_nblist;
-          two_hop_neighbor->neighbor_2_pointer = 0;
-          two_hop_neighbor->neighbor_2_addr = message_neighbors->addr;
+          two_hop_neighbor->nbr2_nblist.next = &two_hop_neighbor->nbr2_nblist;
+          two_hop_neighbor->nbr2_nblist.prev = &two_hop_neighbor->nbr2_nblist;
+          two_hop_neighbor->nbr2_refcount = 0;
+          two_hop_neighbor->nbr2_addr = message_neighbors->addr;
           olsr_insert_two_hop_neighbor_table(two_hop_neighbor);
         }
         /*
@@ -165,7 +165,7 @@ process_message_neighbors(struct nbr_entry *neighbor, const struct lq_hello_mess
       continue;
     }
     if (message_neighbors->neigh_type == SYM_NEIGH || message_neighbors->neigh_type == MPR_NEIGH) {
-      struct neighbor_list_entry *walker;
+      struct nbr_list_entry *walker;
       struct nbr2_list_entry *two_hop_neighbor_yet = olsr_lookup_nbr2_list_entry(neighbor, &message_neighbors->addr);
 
       if (!two_hop_neighbor_yet) {
@@ -174,10 +174,10 @@ process_message_neighbors(struct nbr_entry *neighbor, const struct lq_hello_mess
 
       /*
        *  loop through the one-hop neighbors that see this
-       * 'two_hop_neighbor_yet->neighbor_2'
+       * 'two_hop_neighbor_yet->nbr2'
        */
-      for (walker = two_hop_neighbor_yet->neighbor_2->neighbor_2_nblist.next;
-           walker != &two_hop_neighbor_yet->neighbor_2->neighbor_2_nblist; walker = walker->next) {
+      for (walker = two_hop_neighbor_yet->nbr2->nbr2_nblist.next;
+           walker != &two_hop_neighbor_yet->nbr2->nbr2_nblist; walker = walker->next) {
         /*
          * have we found the one-hop neighbor that sent the
          * HELLO message that we're current processing?
index 1b2a83e..56bc163 100644 (file)
@@ -50,7 +50,7 @@
 
 #include <stdlib.h>
 
-struct neighbor_2_entry two_hop_neighbortable[HASHSIZE];
+struct nbr2_entry two_hop_neighbortable[HASHSIZE];
 
 /**
  *Initialize 2 hop neighbor table
@@ -68,6 +68,33 @@ olsr_init_two_hop_table(void)
   }
 }
 
+/**
+ * A Reference to a two-hop neighbor entry has been added.
+ * Bump the refcouunt.
+ */
+void
+olsr_lock_nbr2(struct nbr2_entry *nbr2)
+{
+  nbr2->nbr2_refcount++;
+}
+
+/**
+ * Unlock and free a neighbor 2 entry if the refcount has gone below 1.
+ */
+void
+olsr_unlock_nbr2(struct nbr2_entry *nbr2)
+{
+  if (--nbr2->nbr2_refcount) {
+    return;
+  }
+
+  /*
+   * Nobody is interested in this nbr2 anymore.
+   * Remove all references to it and free.
+   */
+  olsr_delete_two_hop_neighbor_table(nbr2);
+}
+
 /**
  *Remove a one hop neighbor from a two hop neighbors
  *one hop list.
@@ -79,12 +106,12 @@ olsr_init_two_hop_table(void)
  *@return nada
  */
 void
-olsr_delete_neighbor_pointer(struct neighbor_2_entry *two_hop_entry, struct nbr_entry *neigh)
+olsr_delete_neighbor_pointer(struct nbr2_entry *two_hop_entry, struct nbr_entry *neigh)
 {
-  struct neighbor_list_entry *entry = two_hop_entry->neighbor_2_nblist.next;
-  while (entry != &two_hop_entry->neighbor_2_nblist) {
+  struct nbr_list_entry *entry = two_hop_entry->nbr2_nblist.next;
+  while (entry != &two_hop_entry->nbr2_nblist) {
     if (entry->neighbor == neigh) {
-      struct neighbor_list_entry *entry_to_delete = entry;
+      struct nbr_list_entry *entry_to_delete = entry;
       entry = entry->next;
 
       /* dequeue */
@@ -105,18 +132,18 @@ olsr_delete_neighbor_pointer(struct neighbor_2_entry *two_hop_entry, struct nbr_
  *@return nada
  */
 void
-olsr_delete_two_hop_neighbor_table(struct neighbor_2_entry *two_hop_neighbor)
+olsr_delete_two_hop_neighbor_table(struct nbr2_entry *two_hop_neighbor)
 {
-  struct neighbor_list_entry *one_hop_list;
+  struct nbr_list_entry *one_hop_list;
 
-  one_hop_list = two_hop_neighbor->neighbor_2_nblist.next;
+  one_hop_list = two_hop_neighbor->nbr2_nblist.next;
 
   /* Delete one hop links */
-  while (one_hop_list != &two_hop_neighbor->neighbor_2_nblist) {
+  while (one_hop_list != &two_hop_neighbor->nbr2_nblist) {
     struct nbr_entry *one_hop_entry = one_hop_list->neighbor;
-    struct neighbor_list_entry *entry_to_delete = one_hop_list;
+    struct nbr_list_entry *entry_to_delete = one_hop_list;
 
-    olsr_delete_nbr2_list_entry_by_addr(one_hop_entry, &two_hop_neighbor->neighbor_2_addr);
+    olsr_delete_nbr2_list_entry_by_addr(one_hop_entry, &two_hop_neighbor->nbr2_addr);
     one_hop_list = one_hop_list->next;
     /* no need to dequeue */
     free(entry_to_delete);
@@ -135,14 +162,14 @@ olsr_delete_two_hop_neighbor_table(struct neighbor_2_entry *two_hop_neighbor)
  *@return nada
  */
 void
-olsr_insert_two_hop_neighbor_table(struct neighbor_2_entry *two_hop_neighbor)
+olsr_insert_two_hop_neighbor_table(struct nbr2_entry *two_hop_neighbor)
 {
 #if !defined REMOVE_LOG_DEBUG
   struct ipaddr_str buf;
 #endif
-  uint32_t hash = olsr_ip_hashing(&two_hop_neighbor->neighbor_2_addr);
+  uint32_t hash = olsr_ip_hashing(&two_hop_neighbor->nbr2_addr);
 
-  OLSR_DEBUG(LOG_2NEIGH, "Adding 2 hop neighbor %s\n", olsr_ip_to_string(&buf, &two_hop_neighbor->neighbor_2_addr));
+  OLSR_DEBUG(LOG_2NEIGH, "Adding 2 hop neighbor %s\n", olsr_ip_to_string(&buf, &two_hop_neighbor->nbr2_addr));
 
   /* Queue */
   QUEUE_ELEM(two_hop_neighbortable[hash], two_hop_neighbor);
@@ -153,27 +180,27 @@ olsr_insert_two_hop_neighbor_table(struct neighbor_2_entry *two_hop_neighbor)
  *
  *@param dest the IP address of the entry to find
  *
- *@return a pointer to a neighbor_2_entry struct
+ *@return a pointer to a nbr2_entry struct
  *representing the two hop neighbor
  */
-struct neighbor_2_entry *
+struct nbr2_entry *
 olsr_lookup_two_hop_neighbor_table(const union olsr_ip_addr *dest)
 {
-  struct neighbor_2_entry *neighbor_2;
+  struct nbr2_entry *nbr2;
   uint32_t hash = olsr_ip_hashing(dest);
 
-  for (neighbor_2 = two_hop_neighbortable[hash].next; neighbor_2 != &two_hop_neighbortable[hash]; neighbor_2 = neighbor_2->next) {
+  for (nbr2 = two_hop_neighbortable[hash].next; nbr2 != &two_hop_neighbortable[hash]; nbr2 = nbr2->next) {
     struct tc_entry *tc;
 
-    if (olsr_ipcmp(&neighbor_2->neighbor_2_addr, dest) == 0) {
-      return neighbor_2;
+    if (olsr_ipcmp(&nbr2->nbr2_addr, dest) == 0) {
+      return nbr2;
     }
     /*
      * Locate the hookup point and check if this is a registered alias.
      */
-    tc = olsr_locate_tc_entry(&neighbor_2->neighbor_2_addr);
+    tc = olsr_locate_tc_entry(&nbr2->nbr2_addr);
     if (olsr_lookup_tc_mid_entry(tc, dest)) {
-      return neighbor_2;
+      return nbr2;
     }
   }
   return NULL;
@@ -185,18 +212,18 @@ olsr_lookup_two_hop_neighbor_table(const union olsr_ip_addr *dest)
  *
  *@param dest the IP address of the entry to find
  *
- *@return a pointer to a neighbor_2_entry struct
+ *@return a pointer to a nbr2_entry struct
  *representing the two hop neighbor
  */
-struct neighbor_2_entry *
+struct nbr2_entry *
 olsr_lookup_two_hop_neighbor_table_mid(const union olsr_ip_addr *dest)
 {
-  struct neighbor_2_entry *neighbor_2;
+  struct nbr2_entry *nbr2;
   uint32_t hash = olsr_ip_hashing(dest);
 
-  for (neighbor_2 = two_hop_neighbortable[hash].next; neighbor_2 != &two_hop_neighbortable[hash]; neighbor_2 = neighbor_2->next) {
-    if (olsr_ipcmp(&neighbor_2->neighbor_2_addr, dest) == 0)
-      return neighbor_2;
+  for (nbr2 = two_hop_neighbortable[hash].next; nbr2 != &two_hop_neighbortable[hash]; nbr2 = nbr2->next) {
+    if (olsr_ipcmp(&nbr2->nbr2_addr, dest) == 0)
+      return nbr2;
   }
   return NULL;
 }
@@ -210,11 +237,11 @@ olsr_lookup_two_hop_neighbor_table_mid(const union olsr_ip_addr *dest)
  * @return nada
  */
 void
-olsr_link_nbr_nbr2(struct nbr_entry *nbr, struct neighbor_2_entry *nbr2, float vtime)
+olsr_link_nbr_nbr2(struct nbr_entry *nbr, struct nbr2_entry *nbr2, float vtime)
 {
-  struct neighbor_list_entry *nbr_list;
+  struct nbr_list_entry *nbr_list;
 
-  nbr_list = olsr_malloc(sizeof(struct neighbor_list_entry), "Link entries 1");
+  nbr_list = olsr_malloc(sizeof(struct nbr_list_entry), "Link entries 1");
 
   nbr_list->neighbor = nbr;
 
@@ -223,10 +250,10 @@ olsr_link_nbr_nbr2(struct nbr_entry *nbr, struct neighbor_2_entry *nbr2, float v
   nbr_list->saved_path_linkcost = LINK_COST_BROKEN;
 
   /* Add nbr_list to nbr2 */
-  nbr2->neighbor_2_nblist.next->prev = nbr_list;
-  nbr_list->next = nbr2->neighbor_2_nblist.next;
-  nbr2->neighbor_2_nblist.next = nbr_list;
-  nbr_list->prev = &nbr2->neighbor_2_nblist;
+  nbr2->nbr2_nblist.next->prev = nbr_list;
+  nbr_list->next = nbr2->nbr2_nblist.next;
+  nbr2->nbr2_nblist.next = nbr_list;
+  nbr_list->prev = &nbr2->nbr2_nblist;
 
   olsr_add_nbr2_list_entry(nbr, nbr2, vtime);
 }
@@ -248,17 +275,17 @@ olsr_print_two_hop_neighbor_table(void)
             "IP addr (2-hop)  IP addr (1-hop)  Total cost\n", olsr_wallclock_string());
 
   for (i = 0; i < HASHSIZE; i++) {
-    struct neighbor_2_entry *neigh2;
+    struct nbr2_entry *neigh2;
     for (neigh2 = two_hop_neighbortable[i].next; neigh2 != &two_hop_neighbortable[i]; neigh2 = neigh2->next) {
-      struct neighbor_list_entry *entry;
+      struct nbr_list_entry *entry;
       bool first = true;
 
-      for (entry = neigh2->neighbor_2_nblist.next; entry != &neigh2->neighbor_2_nblist; entry = entry->next) {
+      for (entry = neigh2->nbr2_nblist.next; entry != &neigh2->nbr2_nblist; entry = entry->next) {
         struct ipaddr_str buf;
         struct lqtextbuffer lqbuffer;
 
         OLSR_INFO_NH(LOG_2NEIGH, "%-15s  %-15s  %s\n",
-                     first ? olsr_ip_to_string(&buf, &neigh2->neighbor_2_addr) : "",
+                     first ? olsr_ip_to_string(&buf, &neigh2->nbr2_addr) : "",
                      olsr_ip_to_string(&buf, &entry->neighbor->neighbor_main_addr),
                      get_linkcost_text(entry->path_linkcost, false, &lqbuffer));
 
index 992c4a5..7cc8a22 100644 (file)
 #define        NB2S_COVERED    0x1     /* node has been covered by a MPR */
 
 
-struct neighbor_list_entry {
-  struct nbr_entry *neighbor;
+struct nbr_list_entry {
+  struct nbr_entry *neighbor;          /* backpointer to owning nbr entry */
   olsr_linkcost second_hop_linkcost;
   olsr_linkcost path_linkcost;
   olsr_linkcost saved_path_linkcost;
-  struct neighbor_list_entry *next;
-  struct neighbor_list_entry *prev;
+  struct nbr_list_entry *next;
+  struct nbr_list_entry *prev;
 };
 
 
-struct neighbor_2_entry {
-  union olsr_ip_addr neighbor_2_addr;
-  uint8_t mpr_covered_count;           /*used in mpr calculation */
-  uint8_t processed;                   /*used in mpr calculation */
-  int16_t neighbor_2_pointer;          /* Neighbor count */
-  struct neighbor_list_entry neighbor_2_nblist;
-  struct neighbor_2_entry *prev;
-  struct neighbor_2_entry *next;
-};
+struct nbr2_entry {
+  union olsr_ip_addr nbr2_addr;
+  struct nbr2_entry *prev;
+  struct nbr2_entry *next;
+  unsigned int mpr_covered_count;      /* Used in mpr calculation */
+  unsigned int processed:1;            /* Used in mpr calculation */
+  unsigned int nbr2_refcount;          /* Reference counter */
+  struct nbr_list_entry nbr2_nblist;
+} __attribute__ ((packed));;
 
 /*
- * macros for traversing two-hop neighbors lists.
+ * macros for traversing two-hop neighbors.
  * it is recommended to use this because it hides all the internal
  * datastructure from the callers.
  *
@@ -87,15 +87,17 @@ struct neighbor_2_entry {
   nbr2 = nbr2->next)
 #define OLSR_FOR_ALL_NBR2_ENTRIES_END(nbr2) }}
 
-extern struct neighbor_2_entry two_hop_neighbortable[HASHSIZE];
+extern struct nbr2_entry two_hop_neighbortable[HASHSIZE];
 
-void olsr_init_two_hop_table(void); 
-void olsr_delete_neighbor_pointer(struct neighbor_2_entry *, struct nbr_entry *);
-void olsr_delete_two_hop_neighbor_table(struct neighbor_2_entry *);
-void olsr_insert_two_hop_neighbor_table(struct neighbor_2_entry *);
-struct neighbor_2_entry *olsr_lookup_two_hop_neighbor_table(const union olsr_ip_addr *);
-struct neighbor_2_entry *olsr_lookup_two_hop_neighbor_table_mid(const union olsr_ip_addr *);
-void olsr_link_nbr_nbr2(struct nbr_entry *, struct neighbor_2_entry *, float);
+void olsr_init_two_hop_table(void);
+void olsr_lock_nbr2(struct nbr2_entry *);
+void olsr_unlock_nbr2(struct nbr2_entry *);
+void olsr_delete_neighbor_pointer(struct nbr2_entry *, struct nbr_entry *);
+void olsr_delete_two_hop_neighbor_table(struct nbr2_entry *);
+void olsr_insert_two_hop_neighbor_table(struct nbr2_entry *);
+struct nbr2_entry *olsr_lookup_two_hop_neighbor_table(const union olsr_ip_addr *);
+struct nbr2_entry *olsr_lookup_two_hop_neighbor_table_mid(const union olsr_ip_addr *);
+void olsr_link_nbr_nbr2(struct nbr_entry *, struct nbr2_entry *, float);
 void olsr_print_two_hop_neighbor_table(void);
 
 #endif