FIX 1: remove lq-hysteresis for tc on the receiver side. It does not work correctly...
authorHenning Rogge <hrogge@googlemail.com>
Sun, 21 Jun 2009 16:25:48 +0000 (18:25 +0200)
committerHenning Rogge <hrogge@googlemail.com>
Sun, 21 Jun 2009 16:25:48 +0000 (18:25 +0200)
FIX 2: enhance protection against malformed packages to prevent OLSR parsing uninitialized data.

13 files changed:
src/hna_set.c
src/lq_packet.h
src/lq_plugin.c
src/lq_plugin.h
src/lq_plugin_default_ff.c
src/lq_plugin_default_ff.h
src/lq_plugin_default_float.c
src/lq_plugin_default_float.h
src/lq_plugin_default_fpm.c
src/lq_plugin_default_fpm.h
src/parser.c
src/process_package.c
src/tc_set.c

index 3c83916..c99d655 100644 (file)
@@ -45,6 +45,7 @@
 #include "scheduler.h"
 #include "net_olsr.h"
 #include "tc_set.h"
+#include "parser.h"
 
 struct hna_entry hna_set[HASHSIZE];
 struct olsr_cookie_info *hna_net_timer_cookie = NULL;
@@ -345,6 +346,7 @@ olsr_input_hna(union olsr_message *m, struct interface *in_if __attribute__ ((un
   const uint8_t *curr, *curr_end;
 
 #ifdef DEBUG
+  struct ipaddr_str buf;
   OLSR_PRINTF(5, "Processing HNA\n");
 #endif
 
@@ -357,7 +359,7 @@ olsr_input_hna(union olsr_message *m, struct interface *in_if __attribute__ ((un
   /* olsr_msgtype */
   pkt_get_u8(&curr, &olsr_msgtype);
   if (olsr_msgtype != HNA_MESSAGE) {
-    OLSR_PRINTF(0, "not a HNA message!\n");
+    OLSR_PRINTF(1, "not a HNA message!\n");
     return false;
   }
   /* Get vtime */
@@ -365,18 +367,14 @@ olsr_input_hna(union olsr_message *m, struct interface *in_if __attribute__ ((un
 
   /* olsr_msgsize */
   pkt_get_u16(&curr, &olsr_msgsize);
-  hnasize =
-    olsr_msgsize - (olsr_cnf->ip_version == AF_INET ? offsetof(struct olsrmsg, message) : offsetof(struct olsrmsg6, message));
-  if (hnasize < 0) {
-    OLSR_PRINTF(0, "message size %d too small (at least %lu)!\n", olsr_msgsize,
-                (unsigned long)(olsr_cnf->ip_version ==
-                                AF_INET ? offsetof(struct olsrmsg, message) : offsetof(struct olsrmsg6, message)));
-    return false;
-  }
-  if ((hnasize % (2 * olsr_cnf->ipsize)) != 0) {
-    OLSR_PRINTF(0, "Illegal message size %d!\n", olsr_msgsize);
+
+  if (olsr_msgsize < 8 + olsr_cnf->ipsize) {
+    OLSR_PRINTF(1, "HNA message size %d too small (at least %lu)!\n", olsr_msgsize,
+                8 + olsr_cnf->ipsize);
     return false;
   }
+
+  hnasize = olsr_msgsize - 8 - olsr_cnf->ipsize;
   curr_end = (const uint8_t *)m + olsr_msgsize;
 
   /* validate originator */
@@ -392,6 +390,12 @@ olsr_input_hna(union olsr_message *m, struct interface *in_if __attribute__ ((un
   /* seqno */
   pkt_get_u16(&curr, &packet_seq_number);
 
+  if ((hnasize % (2 * olsr_cnf->ipsize)) != 0) {
+    OLSR_PRINTF(1, "Illegal HNA message from %s with size %d!\n",
+        olsr_ip_to_string(&buf, &originator), olsr_msgsize);
+    return false;
+  }
+
   /*
    *      If the sender interface (NB: not originator) of this message
    *      is not in the symmetric 1-hop neighborhood of this node, the
index a6971b9..8a9979e 100644 (file)
@@ -104,7 +104,6 @@ struct lq_hello_message {
 };
 
 /* serialized LQ_HELLO */
-
 struct lq_hello_info_header {
   uint8_t link_code;
   uint8_t reserved;
index be48d89..f3e8228 100644 (file)
@@ -134,27 +134,11 @@ activate_lq_handler(const char *name)
 olsr_linkcost
 olsr_calc_tc_cost(const struct tc_edge_entry * tc_edge)
 {
-  assert((const char *)tc_edge + sizeof(*tc_edge) == (const char *)tc_edge->linkquality);
+  assert((const char *)tc_edge + sizeof(*tc_edge) >= (const char *)tc_edge->linkquality);
   return active_lq_handler->calc_tc_cost(tc_edge->linkquality);
 }
 
 /*
- * olsr_is_relevant_costchange
- *
- * decides if the difference between two costs is relevant
- * (for changing the route for example)
- *
- * @param first linkcost value
- * @param second linkcost value
- * @return boolean
- */
-bool
-olsr_is_relevant_costchange(olsr_linkcost c1, olsr_linkcost c2)
-{
-  return active_lq_handler->is_relevant_costchange(c1, c2);
-}
-
-/*
  * olsr_serialize_hello_lq_pair
  *
  * this function converts the lq information of a lq_hello_neighbor into binary package
@@ -167,7 +151,7 @@ olsr_is_relevant_costchange(olsr_linkcost c1, olsr_linkcost c2)
 int
 olsr_serialize_hello_lq_pair(unsigned char *buff, struct lq_hello_neighbor *neigh)
 {
-  assert((const char *)neigh + sizeof(*neigh) == (const char *)neigh->linkquality);
+  assert((const char *)neigh + sizeof(*neigh) >= (const char *)neigh->linkquality);
   return active_lq_handler->serialize_hello_lq(buff, neigh->linkquality);
 }
 
@@ -183,7 +167,7 @@ olsr_serialize_hello_lq_pair(unsigned char *buff, struct lq_hello_neighbor *neig
 void
 olsr_deserialize_hello_lq_pair(const uint8_t ** curr, struct hello_neighbor *neigh)
 {
-  assert((const char *)neigh + sizeof(*neigh) == (const char *)neigh->linkquality);
+  assert((const char *)neigh + sizeof(*neigh) >= (const char *)neigh->linkquality);
   active_lq_handler->deserialize_hello_lq(curr, neigh->linkquality);
   neigh->cost = active_lq_handler->calc_hello_cost(neigh->linkquality);
 }
@@ -201,7 +185,7 @@ olsr_deserialize_hello_lq_pair(const uint8_t ** curr, struct hello_neighbor *nei
 int
 olsr_serialize_tc_lq_pair(unsigned char *buff, struct tc_mpr_addr *neigh)
 {
-  assert((const char *)neigh + sizeof(*neigh) == (const char *)neigh->linkquality);
+  assert((const char *)neigh + sizeof(*neigh) >= (const char *)neigh->linkquality);
   return active_lq_handler->serialize_tc_lq(buff, neigh->linkquality);
 }
 
@@ -216,7 +200,7 @@ olsr_serialize_tc_lq_pair(unsigned char *buff, struct tc_mpr_addr *neigh)
 void
 olsr_deserialize_tc_lq_pair(const uint8_t ** curr, struct tc_edge_entry *edge)
 {
-  assert((const char *)edge + sizeof(*edge) == (const char *)edge->linkquality);
+  assert((const char *)edge + sizeof(*edge) >= (const char *)edge->linkquality);
   active_lq_handler->deserialize_tc_lq(curr, edge->linkquality);
 }
 
@@ -234,23 +218,21 @@ void
 olsr_update_packet_loss_worker(struct link_entry *entry, bool lost)
 {
   olsr_linkcost lq;
-  assert((const char *)entry + sizeof(*entry) == (const char *)entry->linkquality);
+  assert((const char *)entry + sizeof(*entry) >= (const char *)entry->linkquality);
   lq = active_lq_handler->packet_loss_handler(entry, entry->linkquality, lost);
 
-  if (olsr_is_relevant_costchange(lq, entry->linkcost)) {
-    entry->linkcost = lq;
-
-    if (olsr_cnf->lq_dlimit > 0) {
-      changes_neighborhood = true;
-      changes_topology = true;
-    }
-
-    else
-      OLSR_PRINTF(3, "Skipping Dijkstra (1)\n");
+  entry->linkcost = lq;
 
-    /* XXX - we should check whether we actually announce this neighbour */
-    signal_link_changes(true);
+  if (olsr_cnf->lq_dlimit > 0) {
+    changes_neighborhood = true;
+    changes_topology = true;
+  }
+  else {
+    OLSR_PRINTF(3, "Skipping Dijkstra (1)\n");
   }
+
+  /* XXX - we should check whether we actually announce this neighbour */
+  signal_link_changes(true);
 }
 
 /*
@@ -266,9 +248,9 @@ olsr_update_packet_loss_worker(struct link_entry *entry, bool lost)
 void
 olsr_memorize_foreign_hello_lq(struct link_entry *local, struct hello_neighbor *foreign)
 {
-  assert((const char *)local + sizeof(*local) == (const char *)local->linkquality);
+  assert((const char *)local + sizeof(*local) >= (const char *)local->linkquality);
   if (foreign) {
-    assert((const char *)foreign + sizeof(*foreign) == (const char *)foreign->linkquality);
+    assert((const char *)foreign + sizeof(*foreign) >= (const char *)foreign->linkquality);
     active_lq_handler->memorize_foreign_hello(local->linkquality, foreign->linkquality);
   } else {
     active_lq_handler->memorize_foreign_hello(local->linkquality, NULL);
@@ -290,7 +272,7 @@ olsr_memorize_foreign_hello_lq(struct link_entry *local, struct hello_neighbor *
 const char *
 get_link_entry_text(struct link_entry *entry, char separator, struct lqtextbuffer *buffer)
 {
-  assert((const char *)entry + sizeof(*entry) == (const char *)entry->linkquality);
+  assert((const char *)entry + sizeof(*entry) >= (const char *)entry->linkquality);
   return active_lq_handler->print_hello_lq(entry->linkquality, separator, buffer);
 }
 
@@ -309,7 +291,7 @@ get_link_entry_text(struct link_entry *entry, char separator, struct lqtextbuffe
 const char *
 get_tc_edge_entry_text(struct tc_edge_entry *entry, char separator, struct lqtextbuffer *buffer)
 {
-  assert((const char *)entry + sizeof(*entry) == (const char *)entry->linkquality);
+  assert((const char *)entry + sizeof(*entry) >= (const char *)entry->linkquality);
   return active_lq_handler->print_tc_lq(entry->linkquality, separator, buffer);
 }
 
@@ -353,8 +335,8 @@ get_linkcost_text(olsr_linkcost cost, bool route, struct lqtextbuffer *buffer)
 void
 olsr_copy_hello_lq(struct lq_hello_neighbor *target, struct link_entry *source)
 {
-  assert((const char *)target + sizeof(*target) == (const char *)target->linkquality);
-  assert((const char *)source + sizeof(*source) == (const char *)source->linkquality);
+  assert((const char *)target + sizeof(*target) >= (const char *)target->linkquality);
+  assert((const char *)source + sizeof(*source) >= (const char *)source->linkquality);
   memcpy(target->linkquality, source->linkquality, active_lq_handler->hello_lq_size);
 }
 
@@ -370,8 +352,8 @@ olsr_copy_hello_lq(struct lq_hello_neighbor *target, struct link_entry *source)
 void
 olsr_copylq_link_entry_2_tc_mpr_addr(struct tc_mpr_addr *target, struct link_entry *source)
 {
-  assert((const char *)target + sizeof(*target) == (const char *)target->linkquality);
-  assert((const char *)source + sizeof(*source) == (const char *)source->linkquality);
+  assert((const char *)target + sizeof(*target) >= (const char *)target->linkquality);
+  assert((const char *)source + sizeof(*source) >= (const char *)source->linkquality);
   active_lq_handler->copy_link_lq_into_tc(target->linkquality, source->linkquality);
 }
 
@@ -387,8 +369,8 @@ olsr_copylq_link_entry_2_tc_mpr_addr(struct tc_mpr_addr *target, struct link_ent
 void
 olsr_copylq_link_entry_2_tc_edge_entry(struct tc_edge_entry *target, struct link_entry *source)
 {
-  assert((const char *)target + sizeof(*target) == (const char *)target->linkquality);
-  assert((const char *)source + sizeof(*source) == (const char *)source->linkquality);
+  assert((const char *)target + sizeof(*target) >= (const char *)target->linkquality);
+  assert((const char *)source + sizeof(*source) >= (const char *)source->linkquality);
   active_lq_handler->copy_link_lq_into_tc(target->linkquality, source->linkquality);
 }
 
@@ -402,7 +384,7 @@ olsr_copylq_link_entry_2_tc_edge_entry(struct tc_edge_entry *target, struct link
 void
 olsr_clear_tc_lq(struct tc_mpr_addr *target)
 {
-  assert((const char *)target + sizeof(*target) == (const char *)target->linkquality);
+  assert((const char *)target + sizeof(*target) >= (const char *)target->linkquality);
   active_lq_handler->clear_tc(target->linkquality);
 }
 
@@ -423,7 +405,7 @@ olsr_malloc_hello_neighbor(const char *id)
 
   h = olsr_malloc(sizeof(struct hello_neighbor) + active_lq_handler->hello_lq_size, id);
 
-  assert((const char *)h + sizeof(*h) == (const char *)h->linkquality);
+  assert((const char *)h + sizeof(*h) >= (const char *)h->linkquality);
   active_lq_handler->clear_hello(h->linkquality);
   return h;
 }
@@ -445,7 +427,7 @@ olsr_malloc_tc_mpr_addr(const char *id)
 
   t = olsr_malloc(sizeof(struct tc_mpr_addr) + active_lq_handler->tc_lq_size, id);
 
-  assert((const char *)t + sizeof(*t) == (const char *)t->linkquality);
+  assert((const char *)t + sizeof(*t) >= (const char *)t->linkquality);
   active_lq_handler->clear_tc(t->linkquality);
   return t;
 }
@@ -467,7 +449,7 @@ olsr_malloc_lq_hello_neighbor(const char *id)
 
   h = olsr_malloc(sizeof(struct lq_hello_neighbor) + active_lq_handler->hello_lq_size, id);
 
-  assert((const char *)h + sizeof(*h) == (const char *)h->linkquality);
+  assert((const char *)h + sizeof(*h) >= (const char *)h->linkquality);
   active_lq_handler->clear_hello(h->linkquality);
   return h;
 }
@@ -489,7 +471,7 @@ olsr_malloc_link_entry(const char *id)
 
   h = olsr_malloc(sizeof(struct link_entry) + active_lq_handler->hello_lq_size, id);
 
-  assert((const char *)h + sizeof(*h) == (const char *)h->linkquality);
+  assert((const char *)h + sizeof(*h) >= (const char *)h->linkquality);
   active_lq_handler->clear_hello(h->linkquality);
   return h;
 }
index 7ea9870..1eb4ce4 100644 (file)
@@ -69,8 +69,6 @@ struct lq_handler {
     olsr_linkcost(*calc_hello_cost) (const void *lq);
     olsr_linkcost(*calc_tc_cost) (const void *lq);
 
-    bool(*is_relevant_costchange) (olsr_linkcost c1, olsr_linkcost c2);
-
     olsr_linkcost(*packet_loss_handler) (struct link_entry * entry, void *lq, bool lost);
 
   void (*memorize_foreign_hello) (void *local, void *foreign);
@@ -115,7 +113,6 @@ void register_lq_handler(struct lq_handler *handler, const char *name);
 int activate_lq_handler(const char *name);
 
 olsr_linkcost olsr_calc_tc_cost(const struct tc_edge_entry *);
-bool olsr_is_relevant_costchange(olsr_linkcost c1, olsr_linkcost c2);
 
 int olsr_serialize_hello_lq_pair(unsigned char *buff, struct lq_hello_neighbor *neigh);
 void olsr_deserialize_hello_lq_pair(const uint8_t ** curr, struct hello_neighbor *neigh);
index d1882b9..bde7512 100644 (file)
@@ -59,7 +59,6 @@ struct lq_handler lq_etx_ff_handler = {
   &default_lq_calc_cost_ff,
   &default_lq_calc_cost_ff,
 
-  &default_lq_is_relevant_costchange_ff,
   &default_lq_packet_loss_worker_ff,
 
   &default_lq_memorize_foreign_hello_ff,
@@ -217,15 +216,6 @@ default_lq_deserialize_hello_lq_pair_ff(const uint8_t ** curr, void *ptr)
   pkt_ignore_u16(curr);
 }
 
-bool
-default_lq_is_relevant_costchange_ff(olsr_linkcost c1, olsr_linkcost c2)
-{
-  if (c1 > c2) {
-    return c2 - c1 > LQ_PLUGIN_RELEVANT_COSTCHANGE_FF;
-  }
-  return c1 - c2 > LQ_PLUGIN_RELEVANT_COSTCHANGE_FF;
-}
-
 int
 default_lq_serialize_tc_lq_pair_ff(unsigned char *buff, void *ptr)
 {
index 5d2c07c..fe2c860 100644 (file)
@@ -69,8 +69,6 @@ void default_lq_initialize_ff(void);
 
 olsr_linkcost default_lq_calc_cost_ff(const void *lq);
 
-bool default_lq_is_relevant_costchange_ff(olsr_linkcost c1, olsr_linkcost c2);
-
 olsr_linkcost default_lq_packet_loss_worker_ff(struct link_entry *link, void *lq, bool lost);
 void default_lq_memorize_foreign_hello_ff(void *local, void *foreign);
 
index 6c16e9d..54fe47e 100644 (file)
@@ -54,8 +54,6 @@ struct lq_handler lq_etx_float_handler = {
   &default_lq_calc_cost_float,
   &default_lq_calc_cost_float,
 
-  &default_lq_is_relevant_costchange_float,
-
   &default_lq_packet_loss_worker_float,
   &default_lq_memorize_foreign_hello_float,
   &default_lq_copy_link2tc_float,
@@ -128,15 +126,6 @@ default_lq_deserialize_hello_lq_pair_float(const uint8_t ** curr, void *ptr)
   lq->nlq = (float)nlq_value / 255.0;
 }
 
-bool
-default_lq_is_relevant_costchange_float(olsr_linkcost c1, olsr_linkcost c2)
-{
-  if (c1 > c2) {
-    return c2 - c1 > LQ_PLUGIN_RELEVANT_COSTCHANGE;
-  }
-  return c1 - c2 > LQ_PLUGIN_RELEVANT_COSTCHANGE;
-}
-
 int
 default_lq_serialize_tc_lq_pair_float(unsigned char *buff, void *ptr)
 {
index 23a0c84..eaef681 100644 (file)
@@ -58,8 +58,6 @@ void default_lq_initialize_float(void);
 
 olsr_linkcost default_lq_calc_cost_float(const void *lq);
 
-bool default_lq_is_relevant_costchange_float(olsr_linkcost c1, olsr_linkcost c2);
-
 olsr_linkcost default_lq_packet_loss_worker_float(struct link_entry *link, void *lq, bool lost);
 void default_lq_memorize_foreign_hello_float(void *local, void *foreign);
 
index 479c071..b7ba13e 100644 (file)
@@ -55,8 +55,6 @@ struct lq_handler lq_etx_fpm_handler = {
   &default_lq_calc_cost_fpm,
   &default_lq_calc_cost_fpm,
 
-  &default_lq_is_relevant_costchange_fpm,
-
   &default_lq_packet_loss_worker_fpm,
   &default_lq_memorize_foreign_hello_fpm,
   &default_lq_copy_link2tc_fpm,
@@ -131,15 +129,6 @@ default_lq_deserialize_hello_lq_pair_fpm(const uint8_t ** curr, void *ptr)
   pkt_ignore_u16(curr);
 }
 
-bool
-default_lq_is_relevant_costchange_fpm(olsr_linkcost c1, olsr_linkcost c2)
-{
-  if (c1 > c2) {
-    return c2 - c1 > LQ_PLUGIN_RELEVANT_COSTCHANGE_FPM;
-  }
-  return c1 - c2 > LQ_PLUGIN_RELEVANT_COSTCHANGE_FPM;
-}
-
 int
 default_lq_serialize_tc_lq_pair_fpm(unsigned char *buff, void *ptr)
 {
@@ -164,15 +153,28 @@ default_lq_deserialize_tc_lq_pair_fpm(const uint8_t ** curr, void *ptr)
 }
 
 olsr_linkcost
-default_lq_packet_loss_worker_fpm(struct link_entry *link, void *ptr, bool lost)
+default_lq_packet_loss_worker_fpm(struct link_entry *link __attribute__ ((unused)), void *ptr, bool lost)
 {
   struct default_lq_fpm *tlq = ptr;
-  uint32_t alpha_old = aging_factor_old;
-  uint32_t alpha_new = aging_factor_new;
+//  uint32_t alpha_old = aging_factor_old;
+//  uint32_t alpha_new = aging_factor_new;
 
-  uint32_t value;
+//  uint32_t value;
   // fpm link_loss_factor = fpmidiv(itofpm(link->loss_link_multiplier), 65536);
 
+  if (lost) {
+    if (tlq->valueLq > 4) {
+      tlq->valueLq-=4;
+    }
+  }
+  else {
+    if (tlq->valueLq < 255-4) {
+      tlq->valueLq+=4;
+    }
+  }
+
+  return default_lq_calc_cost_fpm(ptr);
+#if 0
   if (tlq->quickstart < LQ_QUICKSTART_STEPS) {
     alpha_new = aging_quickstart_new;
     alpha_old = aging_quickstart_old;
@@ -192,6 +194,7 @@ default_lq_packet_loss_worker_fpm(struct link_entry *link, void *ptr, bool lost)
   tlq->valueLq = (value * 255 + LQ_FPM_INTERNAL_MULTIPLIER - 1) / LQ_FPM_INTERNAL_MULTIPLIER;
 
   return default_lq_calc_cost_fpm(ptr);
+#endif
 }
 
 void
index 4e5db0e..a32eac4 100644 (file)
@@ -50,8 +50,6 @@
 #define LQ_FPM_INTERNAL_MULTIPLIER 65535
 #define LQ_FPM_LINKCOST_MULTIPLIER 65535
 
-#define LQ_PLUGIN_RELEVANT_COSTCHANGE_FPM 64
-
 #define LQ_ALGORITHM_ETX_FPM_NAME "etx_fpm"
 
 struct default_lq_fpm {
@@ -64,8 +62,6 @@ void default_lq_initialize_fpm(void);
 
 olsr_linkcost default_lq_calc_cost_fpm(const void *lq);
 
-bool default_lq_is_relevant_costchange_fpm(olsr_linkcost c1, olsr_linkcost c2);
-
 olsr_linkcost default_lq_packet_loss_worker_fpm(struct link_entry *link, void *lq, bool lost);
 void default_lq_memorize_foreign_hello_fpm(void *local, void *foreign);
 
index 820370a..59d1332 100644 (file)
@@ -305,7 +305,7 @@ parse_packet(struct olsr *olsr, int size, struct interface *in_if, union olsr_ip
   for (; count > 0; m = (union olsr_message *)((char *)m + (msgsize))) {
     bool forward = true;
 
-    if (count < MIN_PACKET_SIZE(olsr_cnf->ip_version))
+    if (count < MIN_PACKET_SIZE(olsr_cnf->ip_version) + 8)
       break;
 
     if (olsr_cnf->ip_version == AF_INET)
@@ -313,6 +313,30 @@ parse_packet(struct olsr *olsr, int size, struct interface *in_if, union olsr_ip
     else
       msgsize = ntohs(m->v6.olsr_msgsize);
 
+    if ((msgsize % 4) != 0) {
+      struct ipaddr_str buf;
+      union olsr_ip_addr *msgorig = (union olsr_ip_addr *) &m->v4.originator;
+      OLSR_PRINTF(1, "Error, OLSR message from %s (type %d) must be"
+          " longword aligned, but has a length of %d bytes\n",
+          olsr_ip_to_string(&buf, msgorig), m->v4.olsr_msgtype, msgsize);
+      olsr_syslog(OLSR_LOG_ERR, "Error, OLSR message from %s (type %d) must be"
+          " longword aligned, but has a length of %d bytes",
+          olsr_ip_to_string(&buf, msgorig), m->v4.olsr_msgtype, msgsize);
+      break;
+    }
+
+    if (msgsize > count) {
+      struct ipaddr_str buf;
+      union olsr_ip_addr *msgorig = (union olsr_ip_addr *) &m->v4.originator;
+      OLSR_PRINTF(1, "Error, OLSR message from %s (type %d) says"
+          " length=%d, but only %d bytes left\n",
+          olsr_ip_to_string(&buf, msgorig), m->v4.olsr_msgtype, msgsize, count);
+      olsr_syslog(OLSR_LOG_ERR, "Error, OLSR message from %s (type %d) says"
+          " length=%d, but only %d bytes left",
+          olsr_ip_to_string(&buf, msgorig), m->v4.olsr_msgtype, msgsize, count);
+      break;
+    }
+
     count -= msgsize;
 
     /* Check size of message */
index 3731441..0e6cc54 100644 (file)
@@ -54,6 +54,7 @@
 #include "scheduler.h"
 #include "net_olsr.h"
 #include "lq_plugin.h"
+#include "log.h"
 
 #include <stddef.h>
 
@@ -75,9 +76,6 @@ process_message_neighbors(struct neighbor_entry *neighbor, const struct hello_me
   struct hello_neighbor *message_neighbors;
 
   for (message_neighbors = message->neighbors; message_neighbors != NULL; message_neighbors = message_neighbors->next) {
-#ifdef DEBUG
-    struct ipaddr_str buf;
-#endif
     union olsr_ip_addr *neigh_addr;
     struct neighbor_2_entry *two_hop_neighbor;
 
@@ -99,9 +97,7 @@ process_message_neighbors(struct neighbor_entry *neighbor, const struct hello_me
 
     if (((message_neighbors->status == SYM_NEIGH) || (message_neighbors->status == MPR_NEIGH))) {
       struct neighbor_2_list_entry *two_hop_neighbor_yet = olsr_lookup_my_neighbors(neighbor, &message_neighbors->address);
-#ifdef DEBUG
-      OLSR_PRINTF(7, "\tProcessing %s\n", olsr_ip_to_string(&buf, &message_neighbors->address));
-#endif
+
       if (two_hop_neighbor_yet != NULL) {
         /* Updating the holding time for this neighbor */
         olsr_set_timer(&two_hop_neighbor_yet->nbr2_list_timer, message->vtime, OLSR_NBR2_LIST_JITTER, OLSR_TIMER_ONESHOT,
@@ -137,9 +133,6 @@ process_message_neighbors(struct neighbor_entry *neighbor, const struct hello_me
       } else {
         two_hop_neighbor = olsr_lookup_two_hop_neighbor_table(&message_neighbors->address);
         if (two_hop_neighbor == NULL) {
-#ifdef DEBUG
-          OLSR_PRINTF(5, "Adding 2 hop neighbor %s\n\n", olsr_ip_to_string(&buf, &message_neighbors->address));
-#endif
           changes_neighborhood = true;
           changes_topology = true;
 
@@ -236,17 +229,15 @@ process_message_neighbors(struct neighbor_entry *neighbor, const struct hello_me
               walker->second_hop_linkcost = new_second_hop_linkcost;
               walker->path_linkcost = new_path_linkcost;
 
-              if (olsr_is_relevant_costchange(new_path_linkcost, walker->saved_path_linkcost)) {
-                walker->saved_path_linkcost = new_path_linkcost;
+              walker->saved_path_linkcost = new_path_linkcost;
 
-                if (olsr_cnf->lq_dlimit > 0) {
-                  changes_neighborhood = true;
-                  changes_topology = true;
-                }
-
-                else
-                  OLSR_PRINTF(3, "Skipping Dijkstra (3)\n");
+              if (olsr_cnf->lq_dlimit > 0) {
+                changes_neighborhood = true;
+                changes_topology = true;
               }
+
+              else
+                OLSR_PRINTF(3, "Skipping Dijkstra (3)\n");
             }
           }
         }
@@ -327,11 +318,14 @@ lookup_mpr_status(const struct hello_message *message, const struct interface *i
 static int
 deserialize_hello(struct hello_message *hello, const void *ser)
 {
-  const unsigned char *limit;
+  const unsigned char *curr, *limit;
   uint8_t type;
   uint16_t size;
+  struct ipaddr_str buf;
 
-  const unsigned char *curr = ser;
+  memset (hello, 0, sizeof(*hello));
+
+  curr = ser;
   pkt_get_u8(&curr, &type);
   if (type != HELLO_MESSAGE && type != LQ_HELLO_MESSAGE) {
     /* No need to do anything more */
@@ -350,21 +344,26 @@ deserialize_hello(struct hello_message *hello, const void *ser)
   pkt_get_u8(&curr, &hello->willingness);
 
   hello->neighbors = NULL;
+
   limit = ((const unsigned char *)ser) + size;
   while (curr < limit) {
-    const struct lq_hello_info_header *info_head = (const struct lq_hello_info_header *)curr;
-    const unsigned char *limit2 = curr + ntohs(info_head->size);
+    const unsigned char *limit2 = curr;
+    uint8_t link_code;
+    uint16_t size2;
 
-    curr = (const unsigned char *)(info_head + 1);
+    pkt_get_u8(&curr, &link_code);
+    pkt_ignore_u8(&curr);
+    pkt_get_u16(&curr, &size2);
+
+    limit2 += size2;
     while (curr < limit2) {
       struct hello_neighbor *neigh = olsr_malloc_hello_neighbor("HELLO deserialization");
       pkt_get_ipaddress(&curr, &neigh->address);
-
       if (type == LQ_HELLO_MESSAGE) {
         olsr_deserialize_hello_lq_pair(&curr, neigh);
       }
-      neigh->link = EXTRACT_LINK(info_head->link_code);
-      neigh->status = EXTRACT_STATUS(info_head->link_code);
+      neigh->link = EXTRACT_LINK(link_code);
+      neigh->status = EXTRACT_STATUS(link_code);
 
       neigh->next = hello->neighbors;
       hello->neighbors = neigh;
index 6d7129f..c521af1 100644 (file)
@@ -410,13 +410,12 @@ olsr_calc_tc_edge_entry_etx(struct tc_edge_entry *tc_edge)
    * Some sanity check before recalculating the etx.
    */
   if (olsr_cnf->lq_level < 1) {
-    return 0;
+    return false;
   }
 
   old = tc_edge->cost;
   tc_edge->cost = olsr_calc_tc_cost(tc_edge);
-
-  return olsr_is_relevant_costchange(old, tc_edge->cost);
+  return true;
 }
 
 /**