Update etx_ff to a LQ-hysteresis to stabilize LQ values, which should solve some
authorHenning Rogge <hrogge@googlemail.com>
Sun, 25 Oct 2009 18:47:24 +0000 (19:47 +0100)
committerHenning Rogge <hrogge@googlemail.com>
Sun, 25 Oct 2009 18:47:24 +0000 (19:47 +0100)
compatiblity problems with older OLSR versions.
some modifications for etx_fpm/float were necessary to make them run again

src/link_set.c
src/link_set.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/process_package.c

index 0fb4329..f39ffa4 100644 (file)
@@ -359,7 +359,6 @@ olsr_delete_link_entry(struct link_entry *link)
   link->link_hello_timer = NULL;
   olsr_stop_timer(link->link_loss_timer);
   link->link_loss_timer = NULL;
-
   list_remove(&link->link_list);
 
   free(link->if_name);
@@ -388,6 +387,7 @@ olsr_delete_link_entry_by_ip(const union olsr_ip_addr *int_addr)
   OLSR_FOR_ALL_LINK_ENTRIES_END(link);
 }
 
+
 /**
  * Callback for the link loss timer.
  */
@@ -405,6 +405,7 @@ olsr_expire_link_loss_timer(void *context)
   olsr_change_timer(link->link_loss_timer, link->loss_helloint, OLSR_LINK_LOSS_JITTER, OLSR_TIMER_PERIODIC);
 }
 
+
 /**
  * Callback for the link SYM timer.
  */
@@ -564,7 +565,6 @@ add_link_entry(const union olsr_ip_addr *local, const union olsr_ip_addr *remote
     olsr_set_timer(&new_link->link_loss_timer, htime + htime / 2, OLSR_LINK_LOSS_JITTER, OLSR_TIMER_PERIODIC,
                    &olsr_expire_link_loss_timer, new_link, 0);
 
-
     set_loss_link_multiplier(new_link);
   }
 
@@ -803,7 +803,7 @@ olsr_update_packet_loss_hello_int(struct link_entry *entry, olsr_reltime loss_he
 }
 
 void
-olsr_update_packet_loss(struct link_entry *entry)
+olsr_received_hello_handler(struct link_entry *entry)
 {
   olsr_update_packet_loss_worker(entry, false);
 
index c578d3f..1929542 100644 (file)
@@ -123,7 +123,6 @@ void olsr_set_link_timer(struct link_entry *, unsigned int);
 void olsr_init_link_set(void);
 void olsr_delete_link_entry_by_ip(const union olsr_ip_addr *);
 void olsr_expire_link_hello_timer(void *);
-void olsr_update_packet_loss_worker(struct link_entry *, bool);
 void signal_link_changes(bool);        /* XXX ugly */
 
 struct link_entry *get_best_link_to_neighbor(const union olsr_ip_addr *);
@@ -137,7 +136,7 @@ int check_neighbor_link(const union olsr_ip_addr *);
 int replace_neighbor_link_set(const struct neighbor_entry *, struct neighbor_entry *);
 int lookup_link_status(const struct link_entry *);
 void olsr_update_packet_loss_hello_int(struct link_entry *, olsr_reltime);
-void olsr_update_packet_loss(struct link_entry *entry);
+void olsr_received_hello_handler(struct link_entry *entry);
 void olsr_print_link_set(void);
 
 #endif
index f3e8228..9687500 100644 (file)
@@ -217,22 +217,8 @@ olsr_deserialize_tc_lq_pair(const uint8_t ** curr, struct tc_edge_entry *edge)
 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);
-  lq = active_lq_handler->packet_loss_handler(entry, entry->linkquality, lost);
-
-  entry->linkcost = lq;
-
-  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);
+  active_lq_handler->packet_loss_handler(entry, entry->linkquality, lost);
 }
 
 /*
@@ -337,7 +323,7 @@ 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);
-  memcpy(target->linkquality, source->linkquality, active_lq_handler->hello_lq_size);
+  active_lq_handler->copy_link_lq_into_neigh(target->linkquality, source->linkquality);
 }
 
 /*
@@ -476,6 +462,26 @@ olsr_malloc_link_entry(const char *id)
   return h;
 }
 
+/**
+ * This function should be called whenever the current linkcost
+ * value changed in a relevant way.
+ *
+ * @param link pointer to current link
+ * @param newcost new cost of this link
+ */
+void olsr_relevant_linkcost_change(void) {
+  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);
+}
+
 /*
  * Local Variables:
  * c-basic-offset: 2
index 1eb4ce4..7a1d62a 100644 (file)
@@ -66,12 +66,13 @@ struct lqtextbuffer {
 struct lq_handler {
   void (*initialize) (void);
 
-    olsr_linkcost(*calc_hello_cost) (const void *lq);
-    olsr_linkcost(*calc_tc_cost) (const void *lq);
+  olsr_linkcost (*calc_hello_cost) (const void *lq);
+  olsr_linkcost (*calc_tc_cost) (const void *lq);
 
-    olsr_linkcost(*packet_loss_handler) (struct link_entry * entry, void *lq, bool lost);
+  void (*packet_loss_handler) (struct link_entry * entry, void *lq, bool lost);
 
   void (*memorize_foreign_hello) (void *local, void *foreign);
+  void (*copy_link_lq_into_neigh) (void *target, void *source);
   void (*copy_link_lq_into_tc) (void *target, void *source);
   void (*clear_hello) (void *target);
   void (*clear_tc) (void *target);
@@ -136,6 +137,8 @@ struct tc_mpr_addr *olsr_malloc_tc_mpr_addr(const char *id);
 struct lq_hello_neighbor *olsr_malloc_lq_hello_neighbor(const char *id);
 struct link_entry *olsr_malloc_link_entry(const char *id);
 
+void olsr_relevant_linkcost_change(void);
+
 /* Externals. */
 extern struct lq_handler *active_lq_handler;
 
index b7463fb..73a9fb8 100644 (file)
 #include "scheduler.h"
 #include "log.h"
 
+static void default_lq_initialize_ff(void);
+
+static olsr_linkcost default_lq_calc_cost_ff(const void *lq);
+
+static void default_lq_packet_loss_worker_ff(struct link_entry *link, void *lq, bool lost);
+static void default_lq_memorize_foreign_hello_ff(void *local, void *foreign);
+
+static int default_lq_serialize_hello_lq_pair_ff(unsigned char *buff, void *lq);
+static void default_lq_deserialize_hello_lq_pair_ff(const uint8_t ** curr, void *lq);
+static int default_lq_serialize_tc_lq_pair_ff(unsigned char *buff, void *lq);
+static void default_lq_deserialize_tc_lq_pair_ff(const uint8_t ** curr, void *lq);
+
+static void default_lq_copy_link2neigh_ff(void *t, void *s);
+static void default_lq_copy_link2tc_ff(void *target, void *source);
+static void default_lq_clear_ff(void *target);
+static void default_lq_clear_ff_hello(void *target);
+
+static const char *default_lq_print_ff(void *ptr, char separator, struct lqtextbuffer *buffer);
+static const char *default_lq_print_cost_ff(olsr_linkcost cost, struct lqtextbuffer *buffer);
+
 /* etx lq plugin (freifunk fpm version) settings */
 struct lq_handler lq_etx_ff_handler = {
   &default_lq_initialize_ff,
@@ -62,6 +82,7 @@ struct lq_handler lq_etx_ff_handler = {
   &default_lq_packet_loss_worker_ff,
 
   &default_lq_memorize_foreign_hello_ff,
+  &default_lq_copy_link2neigh_ff,
   &default_lq_copy_link2tc_ff,
   &default_lq_clear_ff_hello,
   &default_lq_clear_ff,
@@ -80,6 +101,74 @@ struct lq_handler lq_etx_ff_handler = {
 };
 
 static void
+default_lq_ff_handle_lqchange(void) {
+  struct default_lq_ff_hello *lq;
+  struct ipaddr_str buf;
+  struct link_entry *link;
+
+  bool triggered = false;
+
+  OLSR_FOR_ALL_LINK_ENTRIES(link) {
+    bool relevant = false;
+    lq = (struct default_lq_ff_hello *)link->linkquality;
+
+#if 0
+  fprintf(stderr, "%s: old = %u/%u   new = %u/%u\n", olsr_ip_to_string(&buf, &link->neighbor_iface_addr),
+      lq->smoothed_lq.valueLq, lq->smoothed_lq.valueNlq,
+      lq->lq.valueLq, lq->lq.valueNlq);
+#endif
+
+    if (lq->smoothed_lq.valueLq < lq->lq.valueLq) {
+      if (lq->lq.valueLq == 255 || lq->lq.valueLq - lq->smoothed_lq.valueLq > lq->smoothed_lq.valueLq/10) {
+        relevant = true;
+      }
+    }
+    else if (lq->smoothed_lq.valueLq > lq->lq.valueLq) {
+      if (lq->smoothed_lq.valueLq - lq->lq.valueLq > lq->smoothed_lq.valueLq/10) {
+        relevant = true;
+      }
+    }
+    if (lq->smoothed_lq.valueNlq < lq->lq.valueNlq) {
+      if (lq->lq.valueNlq == 255 || lq->lq.valueNlq - lq->smoothed_lq.valueNlq > lq->smoothed_lq.valueNlq/10) {
+        relevant = true;
+      }
+    }
+    else if (lq->smoothed_lq.valueNlq > lq->lq.valueNlq) {
+      if (lq->smoothed_lq.valueNlq - lq->lq.valueNlq > lq->smoothed_lq.valueNlq/10) {
+        relevant = true;
+      }
+    }
+
+    if (relevant) {
+      memcpy(&lq->smoothed_lq, &lq->lq, sizeof(struct default_lq_ff));
+      link->linkcost = default_lq_calc_cost_ff(&lq->smoothed_lq);
+      triggered = true;
+    }
+  } OLSR_FOR_ALL_LINK_ENTRIES_END(link)
+
+  if (!triggered) {
+    return;
+  }
+
+  OLSR_FOR_ALL_LINK_ENTRIES(link) {
+    lq = (struct default_lq_ff_hello *)link->linkquality;
+
+    if (lq->smoothed_lq.valueLq == 255 && lq->smoothed_lq.valueNlq == 255) {
+      continue;
+    }
+
+    if (lq->smoothed_lq.valueLq == lq->lq.valueLq && lq->smoothed_lq.valueNlq == lq->lq.valueNlq) {
+      continue;
+    }
+
+    memcpy(&lq->smoothed_lq, &lq->lq, sizeof(struct default_lq_ff));
+    link->linkcost = default_lq_calc_cost_ff(&lq->smoothed_lq);
+  } OLSR_FOR_ALL_LINK_ENTRIES_END(link)
+
+  olsr_relevant_linkcost_change();
+}
+
+static void
 default_lq_parser_ff(struct olsr *olsr, struct interface *in_if, union olsr_ip_addr *from_addr)
 {
   const union olsr_ip_addr *main_addr;
@@ -128,6 +217,7 @@ static void
 default_lq_ff_timer(void __attribute__ ((unused)) * context)
 {
   struct link_entry *link;
+
   OLSR_FOR_ALL_LINK_ENTRIES(link) {
     struct default_lq_ff_hello *tlq = (struct default_lq_ff_hello *)link->linkquality;
     fpm ratio;
@@ -171,23 +261,24 @@ default_lq_ff_timer(void __attribute__ ((unused)) * context)
 
       tlq->lq.valueLq = (uint8_t) (fpmtoi(ratio));
     }
-    link->linkcost = default_lq_calc_cost_ff(tlq);
 
     // shift buffer
     tlq->activePtr = (tlq->activePtr + 1) % LQ_FF_WINDOW;
     tlq->total[tlq->activePtr] = 0;
     tlq->received[tlq->activePtr] = 0;
   } OLSR_FOR_ALL_LINK_ENTRIES_END(link);
+
+  default_lq_ff_handle_lqchange();
 }
 
-void
+static void
 default_lq_initialize_ff(void)
 {
   olsr_packetparser_add_function(&default_lq_parser_ff);
   olsr_start_timer(1000, 0, OLSR_TIMER_PERIODIC, &default_lq_ff_timer, NULL, 0);
 }
 
-olsr_linkcost
+static olsr_linkcost
 default_lq_calc_cost_ff(const void *ptr)
 {
   const struct default_lq_ff *lq = ptr;
@@ -206,7 +297,7 @@ default_lq_calc_cost_ff(const void *ptr)
   return cost;
 }
 
-int
+static int
 default_lq_serialize_hello_lq_pair_ff(unsigned char *buff, void *ptr)
 {
   struct default_lq_ff *lq = ptr;
@@ -219,7 +310,7 @@ default_lq_serialize_hello_lq_pair_ff(unsigned char *buff, void *ptr)
   return 4;
 }
 
-void
+static void
 default_lq_deserialize_hello_lq_pair_ff(const uint8_t ** curr, void *ptr)
 {
   struct default_lq_ff *lq = ptr;
@@ -229,7 +320,7 @@ default_lq_deserialize_hello_lq_pair_ff(const uint8_t ** curr, void *ptr)
   pkt_ignore_u16(curr);
 }
 
-int
+static int
 default_lq_serialize_tc_lq_pair_ff(unsigned char *buff, void *ptr)
 {
   struct default_lq_ff *lq = ptr;
@@ -242,7 +333,7 @@ default_lq_serialize_tc_lq_pair_ff(unsigned char *buff, void *ptr)
   return 4;
 }
 
-void
+static void
 default_lq_deserialize_tc_lq_pair_ff(const uint8_t ** curr, void *ptr)
 {
   struct default_lq_ff *lq = ptr;
@@ -252,7 +343,7 @@ default_lq_deserialize_tc_lq_pair_ff(const uint8_t ** curr, void *ptr)
   pkt_ignore_u16(curr);
 }
 
-olsr_linkcost
+static void
 default_lq_packet_loss_worker_ff(struct link_entry *link,
     void __attribute__ ((unused)) *ptr, bool lost)
 {
@@ -261,48 +352,59 @@ default_lq_packet_loss_worker_ff(struct link_entry *link,
   if (lost) {
     tlq->missed_hellos++;
   }
-  return link->linkcost;
+  return;
 }
 
-void
+static void
 default_lq_memorize_foreign_hello_ff(void *ptrLocal, void *ptrForeign)
 {
-  struct default_lq_ff *local = ptrLocal;
+  struct default_lq_ff_hello *local = ptrLocal;
   struct default_lq_ff *foreign = ptrForeign;
 
   if (foreign) {
-    local->valueNlq = foreign->valueLq;
+    local->lq.valueNlq = foreign->valueLq;
   } else {
-    local->valueNlq = 0;
+    local->lq.valueNlq = 0;
   }
 }
 
-void
-default_lq_copy_link2tc_ff(void *target, void *source)
+static void
+default_lq_copy_link2neigh_ff(void *t, void *s)
+{
+  struct default_lq_ff *target = t;
+  struct default_lq_ff_hello *source = s;
+  *target = source->smoothed_lq;
+}
+
+static void
+default_lq_copy_link2tc_ff(void *t, void *s)
 {
-  memcpy(target, source, sizeof(struct default_lq_ff));
+  struct default_lq_ff *target = t;
+  struct default_lq_ff_hello *source = s;
+  *target = source->smoothed_lq;
 }
 
-void
+static void
 default_lq_clear_ff(void *target)
 {
   memset(target, 0, sizeof(struct default_lq_ff));
 }
 
-void
+static void
 default_lq_clear_ff_hello(void *target)
 {
   struct default_lq_ff_hello *local = target;
   int i;
 
   default_lq_clear_ff(&local->lq);
+  default_lq_clear_ff(&local->smoothed_lq);
   local->windowSize = LQ_FF_QUICKSTART_INIT;
   for (i = 0; i < LQ_FF_WINDOW; i++) {
     local->total[i] = 3;
   }
 }
 
-const char *
+static const char *
 default_lq_print_ff(void *ptr, char separator, struct lqtextbuffer *buffer)
 {
   struct default_lq_ff *lq = ptr;
@@ -312,7 +414,7 @@ default_lq_print_ff(void *ptr, char separator, struct lqtextbuffer *buffer)
   return buffer->buf;
 }
 
-const char *
+static const char *
 default_lq_print_cost_ff(olsr_linkcost cost, struct lqtextbuffer *buffer)
 {
   snprintf(buffer->buf, sizeof(buffer->buf), "%s", fpmtoa(cost));
index 7adc9a7..7ca9948 100644 (file)
@@ -59,6 +59,7 @@ struct default_lq_ff {
 };
 
 struct default_lq_ff_hello {
+  struct default_lq_ff smoothed_lq;
   struct default_lq_ff lq;
   uint8_t windowSize, activePtr;
   uint16_t last_seq_nr;
@@ -66,25 +67,6 @@ struct default_lq_ff_hello {
   uint16_t received[LQ_FF_WINDOW], total[LQ_FF_WINDOW];
 };
 
-void default_lq_initialize_ff(void);
-
-olsr_linkcost default_lq_calc_cost_ff(const void *lq);
-
-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);
-
-int default_lq_serialize_hello_lq_pair_ff(unsigned char *buff, void *lq);
-void default_lq_deserialize_hello_lq_pair_ff(const uint8_t ** curr, void *lq);
-int default_lq_serialize_tc_lq_pair_ff(unsigned char *buff, void *lq);
-void default_lq_deserialize_tc_lq_pair_ff(const uint8_t ** curr, void *lq);
-
-void default_lq_copy_link2tc_ff(void *target, void *source);
-void default_lq_clear_ff(void *target);
-void default_lq_clear_ff_hello(void *target);
-
-const char *default_lq_print_ff(void *ptr, char separator, struct lqtextbuffer *buffer);
-const char *default_lq_print_cost_ff(olsr_linkcost cost, struct lqtextbuffer *buffer);
-
 extern struct lq_handler lq_etx_ff_handler;
 
 #endif /*LQ_ETX_FF_ */
index 54fe47e..dfc9ead 100644 (file)
 #include "olsr.h"
 #include "lq_plugin_default_float.h"
 
+static void default_lq_initialize_float(void);
+static olsr_linkcost default_lq_calc_cost_float(const void *lq);
+static void default_lq_packet_loss_worker_float(struct link_entry *link, void *lq, bool lost);
+static void default_lq_memorize_foreign_hello_float(void *local, void *foreign);
+static int default_lq_serialize_hello_lq_pair_float(unsigned char *buff, void *lq);
+static void default_lq_deserialize_hello_lq_pair_float(const uint8_t ** curr, void *lq);
+static int default_lq_serialize_tc_lq_pair_float(unsigned char *buff, void *lq);
+static void default_lq_deserialize_tc_lq_pair_float(const uint8_t ** curr, void *lq);
+static void default_lq_copy_link2tc_float(void *target, void *source);
+static void default_lq_clear_float(void *target);
+static const char *default_lq_print_float(void *ptr, char separator, struct lqtextbuffer *buffer);
+static const char *default_lq_print_cost_float(olsr_linkcost cost, struct lqtextbuffer *buffer);
+
+
 /* Default lq plugin settings */
 struct lq_handler lq_etx_float_handler = {
   &default_lq_initialize_float,
@@ -57,6 +71,7 @@ struct lq_handler lq_etx_float_handler = {
   &default_lq_packet_loss_worker_float,
   &default_lq_memorize_foreign_hello_float,
   &default_lq_copy_link2tc_float,
+  &default_lq_copy_link2tc_float,
   &default_lq_clear_float,
   &default_lq_clear_float,
 
@@ -73,13 +88,13 @@ struct lq_handler lq_etx_float_handler = {
   sizeof(struct default_lq_float)
 };
 
-void
+static void
 default_lq_initialize_float(void)
 {
   return;
 }
 
-olsr_linkcost
+static olsr_linkcost
 default_lq_calc_cost_float(const void *ptr)
 {
   const struct default_lq_float *lq = ptr;
@@ -99,7 +114,7 @@ default_lq_calc_cost_float(const void *ptr)
   return cost;
 }
 
-int
+static int
 default_lq_serialize_hello_lq_pair_float(unsigned char *buff, void *ptr)
 {
   struct default_lq_float *lq = ptr;
@@ -112,7 +127,7 @@ default_lq_serialize_hello_lq_pair_float(unsigned char *buff, void *ptr)
   return 4;
 }
 
-void
+static void
 default_lq_deserialize_hello_lq_pair_float(const uint8_t ** curr, void *ptr)
 {
   struct default_lq_float *lq = ptr;
@@ -126,7 +141,7 @@ default_lq_deserialize_hello_lq_pair_float(const uint8_t ** curr, void *ptr)
   lq->nlq = (float)nlq_value / 255.0;
 }
 
-int
+static int
 default_lq_serialize_tc_lq_pair_float(unsigned char *buff, void *ptr)
 {
   struct default_lq_float *lq = ptr;
@@ -139,7 +154,7 @@ default_lq_serialize_tc_lq_pair_float(unsigned char *buff, void *ptr)
   return 4;
 }
 
-void
+static void
 default_lq_deserialize_tc_lq_pair_float(const uint8_t ** curr, void *ptr)
 {
   struct default_lq_float *lq = ptr;
@@ -153,7 +168,7 @@ default_lq_deserialize_tc_lq_pair_float(const uint8_t ** curr, void *ptr)
   lq->nlq = (float)nlq_value / 255.0;
 }
 
-olsr_linkcost
+static void
 default_lq_packet_loss_worker_float(struct link_entry *link, void *ptr, bool lost)
 {
   struct default_lq_float *tlq = ptr;
@@ -168,10 +183,11 @@ default_lq_packet_loss_worker_float(struct link_entry *link, void *ptr, bool los
   if (lost == 0) {
     tlq->lq += (alpha * link->loss_link_multiplier / 65536);
   }
-  return default_lq_calc_cost_float(ptr);
+  link->linkcost = default_lq_calc_cost_float(ptr);
+  olsr_relevant_linkcost_change();
 }
 
-void
+static void
 default_lq_memorize_foreign_hello_float(void *ptrLocal, void *ptrForeign)
 {
   struct default_lq_float *local = ptrLocal;
@@ -184,19 +200,19 @@ default_lq_memorize_foreign_hello_float(void *ptrLocal, void *ptrForeign)
   }
 }
 
-void
+static void
 default_lq_copy_link2tc_float(void *target, void *source)
 {
   memcpy(target, source, sizeof(struct default_lq_float));
 }
 
-void
+static void
 default_lq_clear_float(void *target)
 {
   memset(target, 0, sizeof(struct default_lq_float));
 }
 
-const char *
+static const char *
 default_lq_print_float(void *ptr, char separator, struct lqtextbuffer *buffer)
 {
   struct default_lq_float *lq = ptr;
@@ -205,7 +221,7 @@ default_lq_print_float(void *ptr, char separator, struct lqtextbuffer *buffer)
   return buffer->buf;
 }
 
-const char *
+static const char *
 default_lq_print_cost_float(olsr_linkcost cost, struct lqtextbuffer *buffer)
 {
   snprintf(buffer->buf, sizeof(struct lqtextbuffer), "%2.3f", ((float)cost) / LQ_PLUGIN_LC_MULTIPLIER);
index eaef681..0672fdb 100644 (file)
@@ -54,24 +54,6 @@ struct default_lq_float {
   uint16_t quickstart;
 };
 
-void default_lq_initialize_float(void);
-
-olsr_linkcost default_lq_calc_cost_float(const void *lq);
-
-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);
-
-int default_lq_serialize_hello_lq_pair_float(unsigned char *buff, void *lq);
-void default_lq_deserialize_hello_lq_pair_float(const uint8_t ** curr, void *lq);
-int default_lq_serialize_tc_lq_pair_float(unsigned char *buff, void *lq);
-void default_lq_deserialize_tc_lq_pair_float(const uint8_t ** curr, void *lq);
-
-void default_lq_copy_link2tc_float(void *target, void *source);
-void default_lq_clear_float(void *target);
-
-const char *default_lq_print_float(void *ptr, char separator, struct lqtextbuffer *buffer);
-const char *default_lq_print_cost_float(olsr_linkcost cost, struct lqtextbuffer *buffer);
-
 extern struct lq_handler lq_etx_float_handler;
 
 #endif /*LQ_PLUGIN_DEFAULT_H_ */
index c5cfb8e..8d23c65 100644 (file)
 #include "olsr.h"
 #include "lq_plugin_default_fpm.h"
 
+static void default_lq_initialize_fpm(void);
+static olsr_linkcost default_lq_calc_cost_fpm(const void *lq);
+static void default_lq_packet_loss_worker_fpm(struct link_entry *link, void *lq, bool lost);
+static void default_lq_memorize_foreign_hello_fpm(void *local, void *foreign);
+static int default_lq_serialize_hello_lq_pair_fpm(unsigned char *buff, void *lq);
+static void default_lq_deserialize_hello_lq_pair_fpm(const uint8_t ** curr, void *lq);
+static int default_lq_serialize_tc_lq_pair_fpm(unsigned char *buff, void *lq);
+static void default_lq_deserialize_tc_lq_pair_fpm(const uint8_t ** curr, void *lq);
+static void default_lq_copy_link2tc_fpm(void *target, void *source);
+static void default_lq_clear_fpm(void *target);
+static const char *default_lq_print_fpm(void *ptr, char separator, struct lqtextbuffer *buffer);
+static const char *default_lq_print_cost_fpm(olsr_linkcost cost, struct lqtextbuffer *buffer);
+
+
 /* etx lq plugin (fpm version) settings */
 struct lq_handler lq_etx_fpm_handler = {
   &default_lq_initialize_fpm,
@@ -58,6 +72,7 @@ struct lq_handler lq_etx_fpm_handler = {
   &default_lq_packet_loss_worker_fpm,
   &default_lq_memorize_foreign_hello_fpm,
   &default_lq_copy_link2tc_fpm,
+  &default_lq_copy_link2tc_fpm,
   &default_lq_clear_fpm,
   &default_lq_clear_fpm,
 
@@ -77,7 +92,7 @@ struct lq_handler lq_etx_fpm_handler = {
 uint32_t aging_factor_new, aging_factor_old;
 uint32_t aging_quickstart_new, aging_quickstart_old;
 
-void
+static void
 default_lq_initialize_fpm(void)
 {
   aging_factor_new = (uint32_t) (olsr_cnf->lq_aging * LQ_FPM_INTERNAL_MULTIPLIER);
@@ -87,7 +102,7 @@ default_lq_initialize_fpm(void)
   aging_quickstart_old = LQ_FPM_INTERNAL_MULTIPLIER - aging_quickstart_new;
 }
 
-olsr_linkcost
+static olsr_linkcost
 default_lq_calc_cost_fpm(const void *ptr)
 {
   const struct default_lq_fpm *lq = ptr;
@@ -106,7 +121,7 @@ default_lq_calc_cost_fpm(const void *ptr)
   return cost;
 }
 
-int
+static int
 default_lq_serialize_hello_lq_pair_fpm(unsigned char *buff, void *ptr)
 {
   struct default_lq_fpm *lq = ptr;
@@ -119,7 +134,7 @@ default_lq_serialize_hello_lq_pair_fpm(unsigned char *buff, void *ptr)
   return 4;
 }
 
-void
+static void
 default_lq_deserialize_hello_lq_pair_fpm(const uint8_t ** curr, void *ptr)
 {
   struct default_lq_fpm *lq = ptr;
@@ -129,7 +144,7 @@ default_lq_deserialize_hello_lq_pair_fpm(const uint8_t ** curr, void *ptr)
   pkt_ignore_u16(curr);
 }
 
-int
+static int
 default_lq_serialize_tc_lq_pair_fpm(unsigned char *buff, void *ptr)
 {
   struct default_lq_fpm *lq = ptr;
@@ -142,7 +157,7 @@ default_lq_serialize_tc_lq_pair_fpm(unsigned char *buff, void *ptr)
   return 4;
 }
 
-void
+static void
 default_lq_deserialize_tc_lq_pair_fpm(const uint8_t ** curr, void *ptr)
 {
   struct default_lq_fpm *lq = ptr;
@@ -152,7 +167,7 @@ default_lq_deserialize_tc_lq_pair_fpm(const uint8_t ** curr, void *ptr)
   pkt_ignore_u16(curr);
 }
 
-olsr_linkcost
+static void
 default_lq_packet_loss_worker_fpm(struct link_entry *link __attribute__ ((unused)), void *ptr, bool lost)
 {
   struct default_lq_fpm *tlq = ptr;
@@ -179,10 +194,11 @@ default_lq_packet_loss_worker_fpm(struct link_entry *link __attribute__ ((unused
   }
   tlq->valueLq = (value * 255 + LQ_FPM_INTERNAL_MULTIPLIER - 1) / LQ_FPM_INTERNAL_MULTIPLIER;
 
-  return default_lq_calc_cost_fpm(ptr);
+  link->linkcost = default_lq_calc_cost_fpm(ptr);
+  olsr_relevant_linkcost_change();
 }
 
-void
+static void
 default_lq_memorize_foreign_hello_fpm(void *ptrLocal, void *ptrForeign)
 {
   struct default_lq_fpm *local = ptrLocal;
@@ -195,19 +211,19 @@ default_lq_memorize_foreign_hello_fpm(void *ptrLocal, void *ptrForeign)
   }
 }
 
-void
+static void
 default_lq_copy_link2tc_fpm(void *target, void *source)
 {
   memcpy(target, source, sizeof(struct default_lq_fpm));
 }
 
-void
+static void
 default_lq_clear_fpm(void *target)
 {
   memset(target, 0, sizeof(struct default_lq_fpm));
 }
 
-const char *
+static const char *
 default_lq_print_fpm(void *ptr, char separator, struct lqtextbuffer *buffer)
 {
   struct default_lq_fpm *lq = ptr;
@@ -217,7 +233,7 @@ default_lq_print_fpm(void *ptr, char separator, struct lqtextbuffer *buffer)
   return buffer->buf;
 }
 
-const char *
+static const char *
 default_lq_print_cost_fpm(olsr_linkcost cost, struct lqtextbuffer *buffer)
 {
   snprintf(buffer->buf, sizeof(buffer->buf), "%.3f", (float)(cost) / LQ_FPM_LINKCOST_MULTIPLIER);
index a32eac4..0e8f587 100644 (file)
@@ -58,24 +58,6 @@ struct default_lq_fpm {
   uint16_t quickstart;
 };
 
-void default_lq_initialize_fpm(void);
-
-olsr_linkcost default_lq_calc_cost_fpm(const void *lq);
-
-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);
-
-int default_lq_serialize_hello_lq_pair_fpm(unsigned char *buff, void *lq);
-void default_lq_deserialize_hello_lq_pair_fpm(const uint8_t ** curr, void *lq);
-int default_lq_serialize_tc_lq_pair_fpm(unsigned char *buff, void *lq);
-void default_lq_deserialize_tc_lq_pair_fpm(const uint8_t ** curr, void *lq);
-
-void default_lq_copy_link2tc_fpm(void *target, void *source);
-void default_lq_clear_fpm(void *target);
-
-const char *default_lq_print_fpm(void *ptr, char separator, struct lqtextbuffer *buffer);
-const char *default_lq_print_cost_fpm(olsr_linkcost cost, struct lqtextbuffer *buffer);
-
 extern struct lq_handler lq_etx_fpm_handler;
 
 #endif /*LQ_ETX_FPM_ */
index 0e6cc54..16ffc20 100644 (file)
@@ -440,7 +440,7 @@ olsr_hello_tap(struct hello_message *message, struct interface *in_if, const uni
     olsr_memorize_foreign_hello_lq(lnk, walker);
 
     /* update packet loss for link quality calculation */
-    olsr_update_packet_loss(lnk);
+    olsr_received_hello_handler(lnk);
   }
 
   neighbor = lnk->neighbor;