New routing metric plugin with sequence number handling.
authorHenning Rogge <rogge@fgan.de>
Thu, 26 Jun 2008 05:57:00 +0000 (07:57 +0200)
committerHenning Rogge <rogge@fgan.de>
Thu, 26 Jun 2008 05:57:00 +0000 (07:57 +0200)
12 files changed:
src/cfgparser/oparse.y
src/link_set.c
src/link_set.h
src/lq_plugin.c
src/lq_plugin.h
src/lq_plugin_default_ff.c [new file with mode: 0644]
src/lq_plugin_default_ff.h [new file with mode: 0644]
src/lq_plugin_default_float.h
src/lq_plugin_default_fpm.c
src/lq_plugin_default_fpm.h
src/parser.c
src/parser.h

index 03944ae..fa34080 100644 (file)
@@ -45,6 +45,7 @@
 #include "../defs.h"
 #include "../ipcalc.h"
 #include "../net_olsr.h"
+#include "../link_set.h"
 
 #include <stddef.h>
 #include <stdio.h>
@@ -103,7 +104,7 @@ static int lq_mult_helper(YYSTYPE ip_addr_arg, YYSTYPE mult_arg)
     }
 
     mult->addr = addr;
-    mult->value = (olsr_u32_t)(mult_arg->floating * 65536);
+    mult->value = (olsr_u32_t)(mult_arg->floating * LINK_LOSS_MULTIPLIER);
 
     mult->next = walker->cnf->lq_mult;
     walker->cnf->lq_mult = mult;
index 6aa14d3..8c9dc37 100644 (file)
@@ -327,7 +327,7 @@ set_loss_link_multiplier(struct link_entry *entry)
 
   /* if we have not found an entry, then use the default multiplier */
   if (val == 0) {
-    val = 65536;
+    val = LINK_LOSS_MULTIPLIER;
   }
 
   /* store the multiplier */
index 3d50d1e..e166252 100644 (file)
@@ -53,6 +53,8 @@
 
 #define MID_ALIAS_HACK_VTIME  10.0
 
+#define LINK_LOSS_MULTIPLIER (1<<16)
+
 struct link_entry {
   union olsr_ip_addr local_iface_addr;
   union olsr_ip_addr neighbor_iface_addr;
index 674c074..210d6da 100644 (file)
@@ -50,6 +50,7 @@
 
 #include "lq_plugin_default_float.h"
 #include "lq_plugin_default_fpm.h"
+#include "lq_plugin_default_ff.h"
 
 struct avl_tree lq_handler_tree;
 struct lq_handler *active_lq_handler = NULL;
@@ -67,7 +68,7 @@ init_lq_handler_tree(void)
   avl_init(&lq_handler_tree, &avl_strcasecmp);
   register_lq_handler(&lq_etx_float_handler, LQ_ALGORITHM_ETX_FLOAT_NAME);
   register_lq_handler(&lq_etx_fpm_handler, LQ_ALGORITHM_ETX_FPM_NAME);
-  
+  register_lq_handler(&lq_etx_ff_handler, LQ_ALGORITHM_ETX_FF_NAME);
   if (activate_lq_handler(olsr_cnf->lq_algorithm)) {
     activate_lq_handler(LQ_ALGORITHM_ETX_FPM_NAME);
   }
index 9201cee..84cb133 100644 (file)
@@ -54,6 +54,7 @@
 #define ZERO_ROUTE_COST 0
 
 #define MINIMAL_USEFUL_LQ 0.1
+#define LQ_PLUGIN_RELEVANT_COSTCHANGE 16
 
 #define LQ_QUICKSTART_STEPS 12
 #define LQ_QUICKSTART_AGING 0.25
diff --git a/src/lq_plugin_default_ff.c b/src/lq_plugin_default_ff.c
new file mode 100644 (file)
index 0000000..9129fb7
--- /dev/null
@@ -0,0 +1,267 @@
+/*
+ * The olsr.org Optimized Link-State Routing daemon(olsrd)
+ * Copyright (c) 2008 Henning Rogge <rogge@fgan.de>
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without 
+ * modification, are permitted provided that the following conditions 
+ * are met:
+ *
+ * * Redistributions of source code must retain the above copyright 
+ *   notice, this list of conditions and the following disclaimer.
+ * * Redistributions in binary form must reproduce the above copyright 
+ *   notice, this list of conditions and the following disclaimer in 
+ *   the documentation and/or other materials provided with the 
+ *   distribution.
+ * * Neither the name of olsr.org, olsrd nor the names of its 
+ *   contributors may be used to endorse or promote products derived 
+ *   from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS 
+ * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE 
+ * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, 
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, 
+ * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; 
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER 
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN 
+ * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 
+ * POSSIBILITY OF SUCH DAMAGE.
+ *
+ * Visit http://www.olsr.org for more information.
+ *
+ * If you find this software useful feel free to make a donation
+ * to the project. For more information see the website or contact
+ * the copyright holders.
+ *
+ */
+
+#include "tc_set.h"
+#include "link_set.h"
+#include "lq_plugin.h"
+#include "olsr_spf.h"
+#include "lq_packet.h"
+#include "packet.h"
+#include "olsr.h"
+#include "lq_plugin_default_ff.h"
+#include "parser.h"
+#include "fpm.h"
+#include "mid_set.h"
+#include "scheduler.h"
+
+/* etx lq plugin (freifunk fpm version) settings */
+struct lq_handler lq_etx_ff_handler = {
+    &default_lq_initialize_ff,
+    &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, 
+    &default_lq_copy_link2tc_ff,
+    &default_lq_clear_ff,
+    &default_lq_clear_ff,
+
+    &default_lq_serialize_hello_lq_pair_ff,
+    &default_lq_serialize_tc_lq_pair_ff,
+    &default_lq_deserialize_hello_lq_pair_ff,
+    &default_lq_deserialize_tc_lq_pair_ff,
+
+    &default_lq_print_ff,
+    &default_lq_print_ff,
+    &default_lq_print_cost_ff,
+
+    sizeof(struct default_lq_ff),
+    sizeof(struct default_lq_ff)
+};
+
+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;
+  struct link_entry *lnk;
+  struct default_lq_ff *lq;
+  olsr_u32_t seq_diff;
+  
+  /* Find main address */
+  if (!(main_addr = mid_lookup_main_addr(from_addr)))
+    main_addr = from_addr;
+  
+  /* Loopup link entry */
+  lnk = lookup_link_entry(main_addr, NULL, in_if);
+  if (lnk == NULL) {
+    return;
+  }
+  
+  lq = (struct default_lq_ff *)lnk->linkquality;
+  
+  if (lq->last_seq_nr > olsr->olsr_seqno) {
+    seq_diff = (olsr_u32_t)olsr->olsr_seqno + 65536 - lq->last_seq_nr;
+  } else {
+    seq_diff = olsr->olsr_seqno - lq->last_seq_nr;
+  }
+  
+  /* Jump in sequence numbers ? */
+  if (seq_diff > 256) {
+    seq_diff = 1;
+  }
+  
+  lq->received[lq->activePtr]++;
+  lq->lost[lq->activePtr] += (seq_diff - 1);
+  
+  lq->last_seq_nr = olsr->olsr_seqno;
+}
+
+static void default_lq_ff_timer(void __attribute__((unused)) *context) {
+  struct link_entry *link;
+  OLSR_FOR_ALL_LINK_ENTRIES(link) {
+    struct default_lq_ff *tlq = (struct default_lq_ff *)link->linkquality;
+    fpm ratio;
+    olsr_u16_t i, received, lost;
+
+    received = 0;
+    lost = 0;
+
+    /* enlarge window if still in quickstart phase */
+    if (tlq->windowSize < LQ_FF_WINDOW) {
+      tlq->windowSize++;
+    }
+    for (i=0; i < tlq->windowSize; i++) {
+      received += tlq->received[i];
+      lost += tlq->lost[i];
+    }
+
+    /* calculate link quality */
+    if (received + lost == 0) {
+      tlq->valueLq = 0;
+    }
+    else {
+      // start with link-loss-factor
+      ratio = fpmidiv(itofpm(link->loss_link_multiplier), 65536);
+
+      // calculate received/(received + loss) factor
+      ratio = fpmmuli(ratio, (int)received);
+      ratio = fpmidiv(ratio, (int)(received + lost));
+      ratio = fpmmuli(ratio, 255);
+
+      tlq->valueLq = (olsr_u8_t)(fpmtoi(ratio));
+    }
+    link->linkcost = default_lq_calc_cost_ff(tlq);
+
+    // shift buffer
+    tlq->activePtr = (tlq->activePtr + 1) % LQ_FF_WINDOW;
+    tlq->lost[tlq->activePtr] = 0;
+    tlq->received[tlq->activePtr] = 0;
+  }OLSR_FOR_ALL_LINK_ENTRIES_END(link);
+}
+
+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 default_lq_calc_cost_ff(const void *ptr) {
+  const struct default_lq_ff *lq = ptr;
+  olsr_linkcost cost;
+  
+  if (lq->valueLq < (unsigned int)(255 * MINIMAL_USEFUL_LQ) || lq->valueNlq < (unsigned int)(255 * MINIMAL_USEFUL_LQ)) {
+    return LINK_COST_BROKEN;
+  }
+  
+  cost = fpmidiv(itofpm(255 * 255), (int)lq->valueLq * (int)lq->valueNlq);
+  
+  if (cost > LINK_COST_BROKEN)
+    return LINK_COST_BROKEN;
+  if (cost == 0)
+    return 1;
+  return cost;
+}
+
+int default_lq_serialize_hello_lq_pair_ff(unsigned char *buff, void *ptr) {
+  struct default_lq_ff *lq = ptr;
+  
+  buff[0] = (unsigned char)lq->valueLq;
+  buff[1] = (unsigned char)lq->valueNlq;
+  buff[2] = (unsigned char)(0);
+  buff[3] = (unsigned char)(0);
+  
+  return 4;
+}
+
+void default_lq_deserialize_hello_lq_pair_ff(const olsr_u8_t **curr, void *ptr) {
+  struct default_lq_ff *lq = ptr;
+  
+  pkt_get_u8(curr, &lq->valueLq);
+  pkt_get_u8(curr, &lq->valueNlq);
+  pkt_ignore_u16(curr);
+}
+
+olsr_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) {
+  struct default_lq_ff *lq = ptr;
+  
+  buff[0] = (unsigned char)lq->valueLq;
+  buff[1] = (unsigned char)lq->valueNlq;
+  buff[2] = (unsigned char)(0);
+  buff[3] = (unsigned char)(0);
+  
+  return 4;
+}
+
+void default_lq_deserialize_tc_lq_pair_ff(const olsr_u8_t **curr, void *ptr) {
+  struct default_lq_ff *lq = ptr;
+  
+  pkt_get_u8(curr, &lq->valueLq);
+  pkt_get_u8(curr, &lq->valueNlq);
+  pkt_ignore_u16(curr);
+}
+
+olsr_linkcost default_lq_packet_loss_worker_ff(struct link_entry __attribute__((unused)) *link, void __attribute__((unused)) *ptr, olsr_bool __attribute__((unused)) lost) {
+  return link->linkcost;
+}
+
+void default_lq_memorize_foreign_hello_ff(void *ptrLocal, void *ptrForeign) {
+  struct default_lq_ff *local = ptrLocal;
+  struct default_lq_ff *foreign = ptrForeign;
+  
+  if (foreign) {
+    local->valueNlq = foreign->valueLq;
+  } else {
+    local->valueNlq = 0;
+  }
+}
+
+void default_lq_copy_link2tc_ff(void *target, void *source) {
+  memcpy(target, source, sizeof(struct default_lq_ff));
+}
+
+void default_lq_clear_ff(void *target) {
+  struct default_lq_ff *local = target;
+  int i;
+  
+  memset(target, 0, sizeof(struct default_lq_ff));
+  
+  local->windowSize = LQ_FF_QUICKSTART_INIT;
+  for (i=0; i<LQ_FF_WINDOW; i++) {
+    local->lost[i] = 3;
+  }
+}
+
+const char *default_lq_print_ff(void *ptr, struct lqtextbuffer *buffer) {
+  struct default_lq_ff *lq = ptr;
+  
+  sprintf(buffer->buf, "%s/%s", fpmtoa(fpmidiv(itofpm((int)lq->valueLq), 255)), fpmtoa(fpmidiv(itofpm((int)lq->valueNlq), 255)));
+  return buffer->buf;
+}
+
+const char *default_lq_print_cost_ff(olsr_linkcost cost, struct lqtextbuffer *buffer) {
+  sprintf(buffer->buf, "%s", fpmtoa(cost));
+  return buffer->buf;
+}
diff --git a/src/lq_plugin_default_ff.h b/src/lq_plugin_default_ff.h
new file mode 100644 (file)
index 0000000..48b10c8
--- /dev/null
@@ -0,0 +1,85 @@
+/*
+ * The olsr.org Optimized Link-State Routing daemon(olsrd)
+ * Copyright (c) 2008 Henning Rogge <rogge@fgan.de>
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without 
+ * modification, are permitted provided that the following conditions 
+ * are met:
+ *
+ * * Redistributions of source code must retain the above copyright 
+ *   notice, this list of conditions and the following disclaimer.
+ * * Redistributions in binary form must reproduce the above copyright 
+ *   notice, this list of conditions and the following disclaimer in 
+ *   the documentation and/or other materials provided with the 
+ *   distribution.
+ * * Neither the name of olsr.org, olsrd nor the names of its 
+ *   contributors may be used to endorse or promote products derived 
+ *   from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS 
+ * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE 
+ * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, 
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, 
+ * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; 
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER 
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN 
+ * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 
+ * POSSIBILITY OF SUCH DAMAGE.
+ *
+ * Visit http://www.olsr.org for more information.
+ *
+ * If you find this software useful feel free to make a donation
+ * to the project. For more information see the website or contact
+ * the copyright holders.
+ *
+ */
+
+#ifndef LQ_ETX_FF_
+#define LQ_ETX_FF_
+
+#include "olsr_types.h"
+#include "lq_plugin.h"
+
+#define LQ_PLUGIN_LC_MULTIPLIER 1024
+#define LQ_PLUGIN_RELEVANT_COSTCHANGE_FF 16
+
+#define LQ_ALGORITHM_ETX_FF_NAME "etx_ff"
+
+#define LQ_FF_WINDOW 32
+#define LQ_FF_QUICKSTART_INIT 4
+
+struct default_lq_ff {
+       olsr_u8_t valueLq;
+       olsr_u8_t valueNlq;
+       olsr_u8_t windowSize, activePtr;
+       olsr_u16_t last_seq_nr;
+       olsr_u16_t received[LQ_FF_WINDOW], lost[LQ_FF_WINDOW];
+};
+
+void default_lq_initialize_ff(void);
+
+olsr_linkcost default_lq_calc_cost_ff(const void *lq);
+
+olsr_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, olsr_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 olsr_u8_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 olsr_u8_t **curr, void *lq);
+
+void default_lq_copy_link2tc_ff(void *target, void *source);
+void default_lq_clear_ff(void *target);
+
+const char *default_lq_print_ff(void *ptr, 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 09b8aaa..5538131 100644 (file)
@@ -47,7 +47,6 @@
 #define LQ_ALGORITHM_ETX_FLOAT_NAME "etx_float"
 
 #define LQ_PLUGIN_LC_MULTIPLIER 1024
-#define LQ_PLUGIN_RELEVANT_COSTCHANGE 8
 
 struct default_lq_float {
   float lq, nlq;
index 082d887..f57122b 100644 (file)
@@ -46,7 +46,6 @@
 #include "packet.h"
 #include "olsr.h"
 #include "lq_plugin_default_fpm.h"
-#include "fpm.h"
 
 /* etx lq plugin (fpm version) settings */
 struct lq_handler lq_etx_fpm_handler = {
@@ -76,15 +75,15 @@ struct lq_handler lq_etx_fpm_handler = {
     sizeof(struct default_lq_fpm)
 };
 
-fpm aging_factor_new, aging_factor_old;
-fpm aging_quickstart_new, aging_quickstart_old;
+olsr_u32_t aging_factor_new, aging_factor_old;
+olsr_u32_t aging_quickstart_new, aging_quickstart_old;
 
 void default_lq_initialize_fpm(void) {
-  aging_factor_new = ftofpm(olsr_cnf->lq_aging);
-  aging_factor_old = fpmsub(itofpm(1), aging_factor_new);
+  aging_factor_new = (olsr_u32_t)(olsr_cnf->lq_aging * LQ_FPM_INTERNAL_MULTIPLIER);
+  aging_factor_old = LQ_FPM_INTERNAL_MULTIPLIER - aging_factor_new;
   
-  aging_quickstart_new = ftofpm(LQ_QUICKSTART_AGING);
-  aging_quickstart_old = fpmsub(itofpm(1), aging_quickstart_new);
+  aging_quickstart_new = (olsr_u32_t)(LQ_QUICKSTART_AGING * LQ_FPM_INTERNAL_MULTIPLIER);
+  aging_quickstart_old = LQ_FPM_INTERNAL_MULTIPLIER - aging_quickstart_new;
 }
 
 olsr_linkcost default_lq_calc_cost_fpm(const void *ptr) {
@@ -95,7 +94,7 @@ olsr_linkcost default_lq_calc_cost_fpm(const void *ptr) {
     return LINK_COST_BROKEN;
   }
   
-  cost = fpmidiv(itofpm(255 * 255), (int)lq->valueLq * (int)lq->valueNlq);
+  cost = LQ_FPM_LINKCOST_MULTIPLIER * 255/(int)lq->valueLq * 255/(int)lq->valueNlq;
 
   if (cost > LINK_COST_BROKEN)
     return LINK_COST_BROKEN;
@@ -151,11 +150,11 @@ void default_lq_deserialize_tc_lq_pair_fpm(const olsr_u8_t **curr, void *ptr) {
 
 olsr_linkcost default_lq_packet_loss_worker_fpm(struct link_entry *link, void *ptr, olsr_bool lost) {
   struct default_lq_fpm *tlq = ptr;
-  fpm alpha_old = aging_factor_old;
-  fpm alpha_new = aging_factor_new;
+  olsr_u32_t alpha_old = aging_factor_old;
+  olsr_u32_t alpha_new = aging_factor_new;
   
-  fpm value;
-  fpm link_loss_factor = fpmidiv(itofpm(link->loss_link_multiplier), 65536);
+  olsr_u32_t value;
+  // fpm link_loss_factor = fpmidiv(itofpm(link->loss_link_multiplier), 65536);
   
   if (tlq->quickstart < LQ_QUICKSTART_STEPS) {
     alpha_new = aging_quickstart_new;
@@ -164,17 +163,17 @@ olsr_linkcost default_lq_packet_loss_worker_fpm(struct link_entry *link, void *p
   }
 
   // exponential moving average
-  value = itofpm(tlq->valueLq);
+  value = (olsr_u32_t)(tlq->valueLq) * LQ_FPM_INTERNAL_MULTIPLIER / 255;
 
-  value = fpmmul(value, alpha_old);
+  value = (value * alpha_old + LQ_FPM_INTERNAL_MULTIPLIER-1) / LQ_FPM_INTERNAL_MULTIPLIER;
   
   if (!lost) {
-    fpm ratio;
-    ratio = fpmmuli(alpha_new, 255);
-    ratio = fpmmul(ratio, link_loss_factor);
-    value = fpmadd(value, ratio);
+    olsr_u32_t ratio;
+    
+    ratio = (alpha_new * link->loss_link_multiplier + LINK_LOSS_MULTIPLIER-1) / LINK_LOSS_MULTIPLIER;
+    value += ratio;
   }
-  tlq->valueLq = fpmtoi(value);
+  tlq->valueLq = (value * 255 + LQ_FPM_INTERNAL_MULTIPLIER-1) / LQ_FPM_INTERNAL_MULTIPLIER;
   
   return default_lq_calc_cost_fpm(ptr);
 }
@@ -202,13 +201,13 @@ void default_lq_clear_fpm(void *target) {
 const char *default_lq_print_fpm(void *ptr, struct lqtextbuffer *buffer) {
   struct default_lq_fpm *lq = ptr;
   
-  sprintf(buffer->buf, "%s/%s",
-    fpmtoa(fpmidiv(itofpm((int)lq->valueLq), 255)),
-    fpmtoa(fpmidiv(itofpm((int)lq->valueNlq), 255)));
+  sprintf(buffer->buf, "%0.3f/%0.3f",
+      (float)(lq->valueLq) / 255.0,
+      (float)(lq->valueNlq) / 255.0);
   return buffer->buf;
 }
 
 const char *default_lq_print_cost_fpm(olsr_linkcost cost, struct lqtextbuffer *buffer) {
-  sprintf(buffer->buf, "%s", fpmtoa(cost));
+  sprintf(buffer->buf, "%.3f", (float)(cost) / LQ_FPM_LINKCOST_MULTIPLIER);
   return buffer->buf;
 }
index 20f4f4d..b49e76f 100644 (file)
 #define LQ_ETX_FPM_
 
 #include "olsr_types.h"
-#include "fpm.h"
 #include "lq_plugin.h"
 
-#define LQ_PLUGIN_LC_MULTIPLIER 1024
-#define LQ_PLUGIN_RELEVANT_COSTCHANGE_FPM 16
+/* use only 1<<16 - 1 to allow the multiplication of two
+ * upscaled numbers between 0 and 1 */
+#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 {
        olsr_u8_t valueLq;
        olsr_u8_t valueNlq;
index 4a359ee..d916a26 100644 (file)
@@ -72,6 +72,7 @@ unsigned int cpu_overload_exit = 0;
 
 struct parse_function_entry *parse_functions;
 struct preprocessor_function_entry *preprocessor_functions;
+struct packetparser_function_entry *packetparser_functions;
 
 static char inbuf[MAXMESSAGESIZE+1];
 
@@ -178,6 +179,47 @@ int olsr_preprocessor_remove_function(preprocessor_function *function) {
   return 0;
 }
 
+void olsr_packetparser_add_function(packetparser_function *function) {
+  struct packetparser_function_entry *new_entry;
+  
+  OLSR_PRINTF(3, "Parser: registering packetparser\n");
+  
+  new_entry = olsr_malloc(sizeof(struct packetparser_function_entry), "Register packetparser function");
+  
+  new_entry->function = function;
+  
+  /* Queue */
+  new_entry->next = packetparser_functions;
+  packetparser_functions = new_entry;
+  
+  OLSR_PRINTF(3, "Registered packetparser  function\n");
+  
+}
+
+int olsr_packetparser_remove_function(packetparser_function *function) {
+  struct packetparser_function_entry *entry, *prev;
+  
+  entry = packetparser_functions;
+  prev = NULL;
+  
+  while (entry) {
+    if (entry->function == function) {
+      if (entry == packetparser_functions) {
+        packetparser_functions = entry->next;
+      } else {
+        prev->next = entry->next;
+      }
+      free(entry);
+      return 1;
+    }
+    
+    prev = entry;
+    entry = entry->next;
+  }
+  
+  return 0;
+}
+
 /**
  *Process a newly received OLSR packet. Checks the type
  *and to the neccessary convertions and call the
@@ -195,6 +237,7 @@ void parse_packet(struct olsr *olsr, int size, struct interface *in_if, union ol
   int msgsize;
   int processed;
   struct parse_function_entry *entry;
+  struct packetparser_function_entry *packetparser;
   
   count = size - ((char *)m - (char *)olsr);
   
@@ -210,6 +253,16 @@ void parse_packet(struct olsr *olsr, int size, struct interface *in_if, union ol
     return;
   }
   
+  // translate sequence number to host order
+  olsr->olsr_seqno = ntohs(olsr->olsr_seqno);
+  
+  // call packetparser
+  packetparser = packetparser_functions;
+  while (packetparser) {
+    packetparser->function(olsr, in_if, from_addr);
+    packetparser = packetparser->next;
+  }
+  
   //printf("Message from %s\n\n", olsr_ip_to_string(&buf, from_addr)); 
 
   /* Display packet */
index bb82b5d..7440b35 100644 (file)
@@ -1,6 +1,6 @@
 /*
  * The olsr.org Optimized Link-State Routing daemon(olsrd)
- * Copyright (c) 2004, Andreas Tønnesen(andreto@olsr.org)
+ * Copyright (c) 2004, Andreas Tnnesen(andreto@olsr.org)
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without 
@@ -57,8 +57,6 @@ struct parse_function_entry
   struct parse_function_entry *next;
 };
 
-extern struct parse_function_entry *parse_functions;
-
 typedef char *preprocessor_function(char *packet, struct interface *, union olsr_ip_addr *, int *length);
 
 struct preprocessor_function_entry
@@ -67,7 +65,13 @@ struct preprocessor_function_entry
   struct preprocessor_function_entry *next;
 };
 
-extern struct preprocessor_function_entry *preprocessor_functions;
+typedef void packetparser_function(struct olsr *olsr, struct interface *in_if, union olsr_ip_addr *from_addr);
+
+struct packetparser_function_entry
+{
+  packetparser_function *function;
+  struct packetparser_function_entry *next;
+};
 
 void
 parser_set_disp_pack_in(olsr_bool);
@@ -94,6 +98,12 @@ int
 olsr_preprocessor_remove_function(preprocessor_function);
 
 void
+olsr_packetparser_add_function(packetparser_function *function);
+
+int
+olsr_packetparser_remove_function(packetparser_function *function);
+
+void
 parse_packet(struct olsr *, int, struct interface *, union olsr_ip_addr *);
 
 #endif