unify tc-generation and put it into tc_set.c
authorHenning Rogge <hrogge@googlemail.com>
Sat, 8 Aug 2009 18:47:00 +0000 (20:47 +0200)
committerHenning Rogge <hrogge@googlemail.com>
Sat, 8 Aug 2009 18:47:00 +0000 (20:47 +0200)
fix a problem in sequence number handling of tc/hna/mid

15 files changed:
lib/lq_etx_ff/src/lq_plugin_etx_ff.c
lib/lq_etx_ff/src/lq_plugin_etx_ff.h
lib/lq_etx_float/src/lq_plugin_etx_float.c
lib/lq_etx_float/src/lq_plugin_etx_float.h
lib/lq_etx_fpm/src/lq_plugin_etx_fpm.c
lib/lq_etx_fpm/src/lq_plugin_etx_fpm.h
lib/lq_rfc/src/lq_plugin_rfc.c
src/hna_set.c
src/lq_packet.c
src/lq_packet.h
src/lq_plugin.c
src/lq_plugin.h
src/mid_set.c
src/tc_set.c
src/tc_set.h

index 8a593dc..842aa79 100644 (file)
@@ -68,7 +68,6 @@ static void lq_etxff_deinitialize(void);
 
 static olsr_linkcost lq_etxff_calc_link_entry_cost(struct link_entry *);
 static olsr_linkcost lq_etxff_calc_lq_hello_neighbor_cost(struct lq_hello_neighbor *);
-static olsr_linkcost lq_etxff_calc_tc_mpr_addr_cost(struct tc_mpr_addr *);
 static olsr_linkcost lq_etxff_calc_tc_edge_entry_cost(struct tc_edge_entry *);
 
 static bool lq_etxff_is_relevant_costchange(olsr_linkcost c1, olsr_linkcost c2);
@@ -76,14 +75,13 @@ static bool lq_etxff_is_relevant_costchange(olsr_linkcost c1, olsr_linkcost c2);
 static olsr_linkcost lq_etxff_packet_loss_handler(struct link_entry *, bool);
 
 static void lq_etxff_memorize_foreign_hello(struct link_entry *, struct lq_hello_neighbor *);
-static void lq_etxff_copy_link_entry_lq_into_tc_mpr_addr(struct tc_mpr_addr *target, struct link_entry *source);
 static void lq_etxff_copy_link_entry_lq_into_tc_edge_entry(struct tc_edge_entry *target, struct link_entry *source);
 static void lq_etxff_copy_link_lq_into_neighbor(struct lq_hello_neighbor *target, struct link_entry *source);
 
 static void lq_etxff_clear_link_entry(struct link_entry *);
 
 static int lq_etxff_serialize_hello_lq(unsigned char *buff, struct lq_hello_neighbor *lq);
-static int lq_etxff_serialize_tc_lq(unsigned char *buff, struct tc_mpr_addr *lq);
+static void lq_etxff_serialize_tc_lq(uint8_t **curr, struct link_entry *link);
 static void lq_etxff_deserialize_hello_lq(uint8_t const **curr, struct lq_hello_neighbor *lq);
 static void lq_etxff_deserialize_tc_lq(uint8_t const **curr, struct tc_edge_entry *lq);
 
@@ -110,7 +108,6 @@ struct lq_handler lq_etxff_handler = {
 
   &lq_etxff_calc_link_entry_cost,
   &lq_etxff_calc_lq_hello_neighbor_cost,
-  &lq_etxff_calc_tc_mpr_addr_cost,
   &lq_etxff_calc_tc_edge_entry_cost,
 
   &lq_etxff_is_relevant_costchange,
@@ -118,14 +115,12 @@ struct lq_handler lq_etxff_handler = {
   &lq_etxff_packet_loss_handler,
 
   &lq_etxff_memorize_foreign_hello,
-  &lq_etxff_copy_link_entry_lq_into_tc_mpr_addr,
   &lq_etxff_copy_link_entry_lq_into_tc_edge_entry,
   &lq_etxff_copy_link_lq_into_neighbor,
 
   &lq_etxff_clear_link_entry,
   NULL,
   NULL,
-  NULL,
 
   &lq_etxff_serialize_hello_lq,
   &lq_etxff_serialize_tc_lq,
@@ -140,7 +135,6 @@ struct lq_handler lq_etxff_handler = {
   ARRAYSIZE(lq_etxff_linktypes),
 
   sizeof(struct lq_etxff_tc_edge),
-  sizeof(struct lq_etxff_tc_mpr_addr),
   sizeof(struct lq_etxff_lq_hello_neighbor),
   sizeof(struct lq_etxff_link_entry),
 
@@ -310,14 +304,6 @@ lq_etxff_calc_lq_hello_neighbor_cost(struct lq_hello_neighbor *neigh)
   return lq_etxff_calc_linkcost(&lq_neigh->lq);
 }
 
-static olsr_linkcost
-lq_etxff_calc_tc_mpr_addr_cost(struct tc_mpr_addr *mpr)
-{
-  struct lq_etxff_tc_mpr_addr *lq_mpr = (struct lq_etxff_tc_mpr_addr *)mpr;
-
-  return lq_etxff_calc_linkcost(&lq_mpr->lq);
-}
-
 static olsr_linkcost
 lq_etxff_calc_tc_edge_entry_cost(struct tc_edge_entry *edge)
 {
@@ -355,15 +341,6 @@ lq_etxff_memorize_foreign_hello(struct link_entry *target, struct lq_hello_neigh
 
 }
 
-static void
-lq_etxff_copy_link_entry_lq_into_tc_mpr_addr(struct tc_mpr_addr *target, struct link_entry *source)
-{
-  struct lq_etxff_tc_mpr_addr *lq_target = (struct lq_etxff_tc_mpr_addr *)target;
-  struct lq_etxff_link_entry *lq_source = (struct lq_etxff_link_entry *)source;
-
-  lq_target->lq = lq_source->lq;
-}
-
 static void
 lq_etxff_copy_link_entry_lq_into_tc_edge_entry(struct tc_edge_entry *target, struct link_entry *source)
 {
@@ -406,17 +383,15 @@ lq_etxff_serialize_hello_lq(unsigned char *buff, struct lq_hello_neighbor *neigh
 
   return 4;
 }
-static int
-lq_etxff_serialize_tc_lq(unsigned char *buff, struct tc_mpr_addr *mpr)
+static void
+lq_etxff_serialize_tc_lq(uint8_t **curr, struct link_entry *link)
 {
-  struct lq_etxff_tc_mpr_addr *lq_mpr = (struct lq_etxff_tc_mpr_addr *)mpr;
-
-  buff[0] = (unsigned char)lq_mpr->lq.valueLq;
-  buff[1] = (unsigned char)lq_mpr->lq.valueNlq;
-  buff[2] = (unsigned char)(0);
-  buff[3] = (unsigned char)(0);
+  struct lq_etxff_link_entry *lq_link = (struct lq_etxff_link_entry *)link;
 
-  return 4;
+  pkt_put_u8(curr, lq_link->lq.valueLq);
+  pkt_put_u8(curr, lq_link->lq.valueNlq);
+  pkt_put_u8(curr, 0);
+  pkt_put_u8(curr, 0);
 }
 
 static void
index d695ccc..3bd7d9b 100644 (file)
@@ -61,11 +61,6 @@ struct lq_etxff_tc_edge {
   struct lq_etxff_linkquality lq;
 };
 
-struct lq_etxff_tc_mpr_addr {
-  struct tc_mpr_addr core;
-  struct lq_etxff_linkquality lq;
-};
-
 struct lq_etxff_lq_hello_neighbor {
   struct lq_hello_neighbor core;
   struct lq_etxff_linkquality lq;
index 61f6723..37ebc18 100644 (file)
@@ -61,7 +61,6 @@ static bool lq_etxfloat_post_init(void);
 
 static olsr_linkcost lq_etxfloat_calc_link_entry_cost(struct link_entry *);
 static olsr_linkcost lq_etxfloat_calc_lq_hello_neighbor_cost(struct lq_hello_neighbor *);
-static olsr_linkcost lq_etxfloat_calc_tc_mpr_addr_cost(struct tc_mpr_addr *);
 static olsr_linkcost lq_etxfloat_calc_tc_edge_entry_cost(struct tc_edge_entry *);
 
 static bool lq_etxfloat_is_relevant_costchange(olsr_linkcost c1, olsr_linkcost c2);
@@ -69,12 +68,11 @@ static bool lq_etxfloat_is_relevant_costchange(olsr_linkcost c1, olsr_linkcost c
 static olsr_linkcost lq_etxfloat_packet_loss_handler(struct link_entry *, bool);
 
 static void lq_etxfloat_memorize_foreign_hello(struct link_entry *, struct lq_hello_neighbor *);
-static void lq_etxfloat_copy_link_entry_lq_into_tc_mpr_addr(struct tc_mpr_addr *target, struct link_entry *source);
 static void lq_etxfloat_copy_link_entry_lq_into_tc_edge_entry(struct tc_edge_entry *target, struct link_entry *source);
 static void lq_etxfloat_copy_link_lq_into_neighbor(struct lq_hello_neighbor *target, struct link_entry *source);
 
 static int lq_etxfloat_serialize_hello_lq(unsigned char *buff, struct lq_hello_neighbor *lq);
-static int lq_etxfloat_serialize_tc_lq(unsigned char *buff, struct tc_mpr_addr *lq);
+static void lq_etxfloat_serialize_tc_lq(uint8_t **curr, struct link_entry *link);
 static void lq_etxfloat_deserialize_hello_lq(uint8_t const **curr, struct lq_hello_neighbor *lq);
 static void lq_etxfloat_deserialize_tc_lq(uint8_t const **curr, struct tc_edge_entry *lq);
 
@@ -97,7 +95,6 @@ struct lq_handler lq_etxfloat_handler = {
 
   &lq_etxfloat_calc_link_entry_cost,
   &lq_etxfloat_calc_lq_hello_neighbor_cost,
-  &lq_etxfloat_calc_tc_mpr_addr_cost,
   &lq_etxfloat_calc_tc_edge_entry_cost,
 
   &lq_etxfloat_is_relevant_costchange,
@@ -105,14 +102,12 @@ struct lq_handler lq_etxfloat_handler = {
   &lq_etxfloat_packet_loss_handler,
 
   &lq_etxfloat_memorize_foreign_hello,
-  &lq_etxfloat_copy_link_entry_lq_into_tc_mpr_addr,
   &lq_etxfloat_copy_link_entry_lq_into_tc_edge_entry,
   &lq_etxfloat_copy_link_lq_into_neighbor,
 
   NULL,
   NULL,
   NULL,
-  NULL,
 
   &lq_etxfloat_serialize_hello_lq,
   &lq_etxfloat_serialize_tc_lq,
@@ -127,7 +122,6 @@ struct lq_handler lq_etxfloat_handler = {
   ARRAYSIZE(lq_etxfloat_linktypes),
 
   sizeof(struct lq_etxfloat_tc_edge),
-  sizeof(struct lq_etxfloat_tc_mpr_addr),
   sizeof(struct lq_etxfloat_lq_hello_neighbor),
   sizeof(struct lq_etxfloat_link_entry),
 
@@ -197,14 +191,6 @@ lq_etxfloat_calc_lq_hello_neighbor_cost(struct lq_hello_neighbor *neigh)
   return lq_etxfloat_calc_linkcost(&lq_neigh->lq);
 }
 
-static olsr_linkcost
-lq_etxfloat_calc_tc_mpr_addr_cost(struct tc_mpr_addr *mpr)
-{
-  struct lq_etxfloat_tc_mpr_addr *lq_mpr = (struct lq_etxfloat_tc_mpr_addr *)mpr;
-
-  return lq_etxfloat_calc_linkcost(&lq_mpr->lq);
-}
-
 static olsr_linkcost
 lq_etxfloat_calc_tc_edge_entry_cost(struct tc_edge_entry *edge)
 {
@@ -256,15 +242,6 @@ lq_etxfloat_memorize_foreign_hello(struct link_entry *target, struct lq_hello_ne
 
 }
 
-static void
-lq_etxfloat_copy_link_entry_lq_into_tc_mpr_addr(struct tc_mpr_addr *target, struct link_entry *source)
-{
-  struct lq_etxfloat_tc_mpr_addr *lq_target = (struct lq_etxfloat_tc_mpr_addr *)target;
-  struct lq_etxfloat_link_entry *lq_source = (struct lq_etxfloat_link_entry *)source;
-
-  lq_target->lq = lq_source->lq;
-}
-
 static void
 lq_etxfloat_copy_link_entry_lq_into_tc_edge_entry(struct tc_edge_entry *target, struct link_entry *source)
 {
@@ -295,17 +272,15 @@ lq_etxfloat_serialize_hello_lq(unsigned char *buff, struct lq_hello_neighbor *ne
 
   return 4;
 }
-static int
-lq_etxfloat_serialize_tc_lq(unsigned char *buff, struct tc_mpr_addr *mpr)
+static void
+lq_etxfloat_serialize_tc_lq(uint8_t **curr, struct link_entry *link)
 {
-  struct lq_etxfloat_tc_mpr_addr *lq_mpr = (struct lq_etxfloat_tc_mpr_addr *)mpr;
-
-  buff[0] = (unsigned char)(lq_mpr->lq.valueLq * 255);
-  buff[1] = (unsigned char)(lq_mpr->lq.valueNlq * 255);
-  buff[2] = (unsigned char)(0);
-  buff[3] = (unsigned char)(0);
+  struct lq_etxfloat_link_entry *lq_link = (struct lq_etxfloat_link_entry *)link;
 
-  return 4;
+  pkt_put_u8(curr, (unsigned char)(lq_link->lq.valueLq * 255));
+  pkt_put_u8(curr, (unsigned char)(lq_link->lq.valueNlq * 255));
+  pkt_put_u8(curr, 0);
+  pkt_put_u8(curr, 0);
 }
 
 static void
index 83e80e0..5d9ed62 100644 (file)
@@ -57,11 +57,6 @@ struct lq_etxfloat_tc_edge {
   struct lq_etxfloat_linkquality lq;
 };
 
-struct lq_etxfloat_tc_mpr_addr {
-  struct tc_mpr_addr core;
-  struct lq_etxfloat_linkquality lq;
-};
-
 struct lq_etxfloat_lq_hello_neighbor {
   struct lq_hello_neighbor core;
   struct lq_etxfloat_linkquality lq;
index bd20978..2322612 100644 (file)
@@ -63,7 +63,6 @@ static int set_plugin_aging(const char *, void *, set_plugin_parameter_addon);
 
 static olsr_linkcost lq_etxfpm_calc_link_entry_cost(struct link_entry *);
 static olsr_linkcost lq_etxfpm_calc_lq_hello_neighbor_cost(struct lq_hello_neighbor *);
-static olsr_linkcost lq_etxfpm_calc_tc_mpr_addr_cost(struct tc_mpr_addr *);
 static olsr_linkcost lq_etxfpm_calc_tc_edge_entry_cost(struct tc_edge_entry *);
 
 static bool lq_etxfpm_is_relevant_costchange(olsr_linkcost c1, olsr_linkcost c2);
@@ -71,12 +70,11 @@ static bool lq_etxfpm_is_relevant_costchange(olsr_linkcost c1, olsr_linkcost c2)
 static olsr_linkcost lq_etxfpm_packet_loss_handler(struct link_entry *, bool);
 
 static void lq_etxfpm_memorize_foreign_hello(struct link_entry *, struct lq_hello_neighbor *);
-static void lq_etxfpm_copy_link_entry_lq_into_tc_mpr_addr(struct tc_mpr_addr *target, struct link_entry *source);
 static void lq_etxfpm_copy_link_entry_lq_into_tc_edge_entry(struct tc_edge_entry *target, struct link_entry *source);
 static void lq_etxfpm_copy_link_lq_into_neighbor(struct lq_hello_neighbor *target, struct link_entry *source);
 
 static int lq_etxfpm_serialize_hello_lq(unsigned char *buff, struct lq_hello_neighbor *lq);
-static int lq_etxfpm_serialize_tc_lq(unsigned char *buff, struct tc_mpr_addr *lq);
+static void lq_etxfpm_serialize_tc_lq(uint8_t **curr, struct link_entry *link);
 static void lq_etxfpm_deserialize_hello_lq(uint8_t const **curr, struct lq_hello_neighbor *lq);
 static void lq_etxfpm_deserialize_tc_lq(uint8_t const **curr, struct tc_edge_entry *lq);
 
@@ -99,7 +97,6 @@ struct lq_handler lq_etxfpm_handler = {
 
   &lq_etxfpm_calc_link_entry_cost,
   &lq_etxfpm_calc_lq_hello_neighbor_cost,
-  &lq_etxfpm_calc_tc_mpr_addr_cost,
   &lq_etxfpm_calc_tc_edge_entry_cost,
 
   &lq_etxfpm_is_relevant_costchange,
@@ -107,14 +104,12 @@ struct lq_handler lq_etxfpm_handler = {
   &lq_etxfpm_packet_loss_handler,
 
   &lq_etxfpm_memorize_foreign_hello,
-  &lq_etxfpm_copy_link_entry_lq_into_tc_mpr_addr,
   &lq_etxfpm_copy_link_entry_lq_into_tc_edge_entry,
   &lq_etxfpm_copy_link_lq_into_neighbor,
 
   NULL,
   NULL,
   NULL,
-  NULL,
 
   &lq_etxfpm_serialize_hello_lq,
   &lq_etxfpm_serialize_tc_lq,
@@ -129,7 +124,6 @@ struct lq_handler lq_etxfpm_handler = {
   ARRAYSIZE(lq_etxfpm_linktypes),
 
   sizeof(struct lq_etxfpm_tc_edge),
-  sizeof(struct lq_etxfpm_tc_mpr_addr),
   sizeof(struct lq_etxfpm_lq_hello_neighbor),
   sizeof(struct lq_etxfpm_link_entry),
 
@@ -217,14 +211,6 @@ lq_etxfpm_calc_lq_hello_neighbor_cost(struct lq_hello_neighbor *neigh)
   return lq_etxfpm_calc_linkcost(&lq_neigh->lq);
 }
 
-static olsr_linkcost
-lq_etxfpm_calc_tc_mpr_addr_cost(struct tc_mpr_addr *mpr)
-{
-  struct lq_etxfpm_tc_mpr_addr *lq_mpr = (struct lq_etxfpm_tc_mpr_addr *)mpr;
-
-  return lq_etxfpm_calc_linkcost(&lq_mpr->lq);
-}
-
 static olsr_linkcost
 lq_etxfpm_calc_tc_edge_entry_cost(struct tc_edge_entry *edge)
 {
@@ -285,16 +271,6 @@ lq_etxfpm_memorize_foreign_hello(struct link_entry *target, struct lq_hello_neig
   } else {
     lq_target->lq.valueNlq = 0;
   }
-
-}
-
-static void
-lq_etxfpm_copy_link_entry_lq_into_tc_mpr_addr(struct tc_mpr_addr *target, struct link_entry *source)
-{
-  struct lq_etxfpm_tc_mpr_addr *lq_target = (struct lq_etxfpm_tc_mpr_addr *)target;
-  struct lq_etxfpm_link_entry *lq_source = (struct lq_etxfpm_link_entry *)source;
-
-  lq_target->lq = lq_source->lq;
 }
 
 static void
@@ -327,17 +303,15 @@ lq_etxfpm_serialize_hello_lq(unsigned char *buff, struct lq_hello_neighbor *neig
 
   return 4;
 }
-static int
-lq_etxfpm_serialize_tc_lq(unsigned char *buff, struct tc_mpr_addr *mpr)
+static void
+lq_etxfpm_serialize_tc_lq(uint8_t **curr, struct link_entry *link)
 {
-  struct lq_etxfpm_tc_mpr_addr *lq_mpr = (struct lq_etxfpm_tc_mpr_addr *)mpr;
-
-  buff[0] = (unsigned char)lq_mpr->lq.valueLq;
-  buff[1] = (unsigned char)lq_mpr->lq.valueNlq;
-  buff[2] = (unsigned char)(0);
-  buff[3] = (unsigned char)(0);
+  struct lq_etxfpm_link_entry *lq_link = (struct lq_etxfpm_link_entry *)link;
 
-  return 4;
+  pkt_put_u8(curr, lq_link->lq.valueLq);
+  pkt_put_u8(curr, lq_link->lq.valueNlq);
+  pkt_put_u8(curr, 0);
+  pkt_put_u8(curr, 0);
 }
 
 static void
index e1ac7e0..7a3cc0c 100644 (file)
@@ -57,11 +57,6 @@ struct lq_etxfpm_tc_edge {
   struct lq_etxfpm_linkquality lq;
 };
 
-struct lq_etxfpm_tc_mpr_addr {
-  struct tc_mpr_addr core;
-  struct lq_etxfpm_linkquality lq;
-};
-
 struct lq_etxfpm_lq_hello_neighbor {
   struct lq_hello_neighbor core;
   struct lq_etxfpm_linkquality lq;
index 519d4a5..94ecf18 100644 (file)
@@ -63,7 +63,6 @@ static int set_plugin_float(const char *, void *, set_plugin_parameter_addon);
 
 static olsr_linkcost lq_rfc_calc_link_entry_cost(struct link_entry *);
 static olsr_linkcost lq_rfc_calc_lq_hello_neighbor_cost(struct lq_hello_neighbor *);
-static olsr_linkcost lq_rfc_calc_tc_mpr_addr_cost(struct tc_mpr_addr *);
 static olsr_linkcost lq_rfc_calc_tc_edge_entry_cost(struct tc_edge_entry *);
 
 static bool lq_rfc_is_relevant_costchange(olsr_linkcost c1, olsr_linkcost c2);
@@ -71,12 +70,11 @@ static bool lq_rfc_is_relevant_costchange(olsr_linkcost c1, olsr_linkcost c2);
 static olsr_linkcost lq_rfc_packet_loss_handler(struct link_entry *, bool);
 
 static void lq_rfc_memorize_foreign_hello(struct link_entry *, struct lq_hello_neighbor *);
-static void lq_rfc_copy_link_entry_lq_into_tc_mpr_addr(struct tc_mpr_addr *target, struct link_entry *source);
 static void lq_rfc_copy_link_entry_lq_into_tc_edge_entry(struct tc_edge_entry *target, struct link_entry *source);
 static void lq_rfc_copy_link_lq_into_neighbor(struct lq_hello_neighbor *target, struct link_entry *source);
 
 static int lq_rfc_serialize_hello_lq(unsigned char *buff, struct lq_hello_neighbor *lq);
-static int lq_rfc_serialize_tc_lq(unsigned char *buff, struct tc_mpr_addr *lq);
+static void lq_rfc_serialize_tc_lq(uint8_t **curr, struct link_entry *link);
 static void lq_rfc_deserialize_hello_lq(uint8_t const **curr, struct lq_hello_neighbor *lq);
 static void lq_rfc_deserialize_tc_lq(uint8_t const **curr, struct tc_edge_entry *lq);
 
@@ -96,7 +94,6 @@ struct lq_handler lq_rfc_handler = {
 
   &lq_rfc_calc_link_entry_cost,
   &lq_rfc_calc_lq_hello_neighbor_cost,
-  &lq_rfc_calc_tc_mpr_addr_cost,
   &lq_rfc_calc_tc_edge_entry_cost,
 
   &lq_rfc_is_relevant_costchange,
@@ -104,14 +101,12 @@ struct lq_handler lq_rfc_handler = {
   &lq_rfc_packet_loss_handler,
 
   &lq_rfc_memorize_foreign_hello,
-  &lq_rfc_copy_link_entry_lq_into_tc_mpr_addr,
   &lq_rfc_copy_link_entry_lq_into_tc_edge_entry,
   &lq_rfc_copy_link_lq_into_neighbor,
 
   NULL,
   NULL,
   NULL,
-  NULL,
 
   &lq_rfc_serialize_hello_lq,
   &lq_rfc_serialize_tc_lq,
@@ -126,7 +121,6 @@ struct lq_handler lq_rfc_handler = {
   ARRAYSIZE(lq_rfc_linktypes),
 
   sizeof(struct tc_edge_entry),
-  sizeof(struct tc_mpr_addr),
   sizeof(struct lq_hello_neighbor),
   sizeof(struct lq_rfc_link_entry),
 
@@ -179,12 +173,6 @@ lq_rfc_calc_lq_hello_neighbor_cost(struct lq_hello_neighbor __attribute__ ((unus
   return 1;
 }
 
-static olsr_linkcost
-lq_rfc_calc_tc_mpr_addr_cost(struct tc_mpr_addr __attribute__ ((unused)) * mpr)
-{
-  return 1;
-}
-
 static olsr_linkcost
 lq_rfc_calc_tc_edge_entry_cost(struct tc_edge_entry __attribute__ ((unused)) * edge)
 {
@@ -225,12 +213,6 @@ lq_rfc_memorize_foreign_hello(struct link_entry __attribute__ ((unused)) * targe
 {
 }
 
-static void
-lq_rfc_copy_link_entry_lq_into_tc_mpr_addr(struct tc_mpr_addr __attribute__ ((unused)) * target, struct link_entry
-                                           __attribute__ ((unused)) * source)
-{
-}
-
 static void
 lq_rfc_copy_link_entry_lq_into_tc_edge_entry(struct tc_edge_entry __attribute__ ((unused)) * target, struct link_entry
                                              __attribute__ ((unused)) * source)
@@ -248,10 +230,9 @@ lq_rfc_serialize_hello_lq(unsigned char __attribute__ ((unused)) * buff, struct
 {
   return 0;
 }
-static int
-lq_rfc_serialize_tc_lq(unsigned char __attribute__ ((unused)) * buff, struct tc_mpr_addr __attribute__ ((unused)) * mpr)
+static void
+lq_rfc_serialize_tc_lq(uint8_t __attribute__ ((unused)) **curr, struct link_entry __attribute__ ((unused)) *link)
 {
-  return 0;
 }
 
 static void
index b5681a3..fe12f23 100644 (file)
@@ -306,7 +306,7 @@ olsr_input_hna(union olsr_message *msg, struct interface *in_if __attribute__ ((
   }
 
   tc = olsr_locate_tc_entry(&originator);
-  if (status != RESET_SEQNO_OLSR_MESSAGE && olsr_seqno_diff(msg_seq, tc->mid_seq) <= 0) {
+  if (status != RESET_SEQNO_OLSR_MESSAGE && tc->hna_seq != -1 && olsr_seqno_diff(msg_seq, tc->hna_seq) <= 0) {
     /* this HNA is too old, discard it */
     return;
   }
index cd3aed8..c064a1b 100644 (file)
@@ -147,138 +147,6 @@ destroy_lq_hello(struct lq_hello_message *lq_hello)
   lq_hello->neigh = NULL;
 }
 
-static void
-create_lq_tc(struct lq_tc_message *lq_tc, struct interface *outif)
-{
-  struct link_entry *lnk;
-  struct nbr_entry *walker;
-  struct tc_mpr_addr *neigh;
-  static int ttl_list[] = { 2, 8, 2, 16, 2, 8, 2, MAX_TTL };
-
-  // remember that we have generated an LQ TC message; this is
-  // checked in net_output()
-
-  lq_tc_pending = true;
-
-  // initialize the static fields
-
-  lq_tc->comm.type = olsr_get_TC_MessageId();
-  lq_tc->comm.vtime = olsr_cnf->tc_params.validity_time;
-  lq_tc->comm.size = 0;
-
-  lq_tc->comm.orig = olsr_cnf->router_id;
-
-  if (olsr_cnf->lq_fish > 0) {
-    if (outif->ttl_index >= (int)(ARRAYSIZE(ttl_list)))
-      outif->ttl_index = 0;
-
-    lq_tc->comm.ttl = (0 <= outif->ttl_index ? ttl_list[outif->ttl_index] : MAX_TTL);
-    outif->ttl_index++;
-
-    OLSR_DEBUG(LOG_PACKET_CREATION, "Creating LQ TC with TTL %d.\n", lq_tc->comm.ttl);
-  }
-
-  else
-    lq_tc->comm.ttl = MAX_TTL;
-
-  lq_tc->comm.hops = 0;
-
-  lq_tc->from = olsr_cnf->router_id;
-
-  lq_tc->ansn = get_local_ansn_number(false);
-
-  lq_tc->neigh = NULL;
-
-  OLSR_FOR_ALL_NBR_ENTRIES(walker) {
-
-    /*
-     * TC redundancy 2
-     *
-     * Only consider symmetric neighbours.
-     */
-    if (!walker->is_sym) {
-      continue;
-    }
-
-    /*
-     * TC redundancy 1
-     *
-     * Only consider MPRs and MPR selectors
-     */
-    if (olsr_cnf->tc_redundancy == 1 && !walker->is_mpr && walker->mprs_count == 0) {
-      continue;
-    }
-
-    /*
-     * TC redundancy 0
-     *
-     * Only consider MPR selectors
-     */
-    if (olsr_cnf->tc_redundancy == 0 && walker->mprs_count == 0) {
-      continue;
-    }
-
-    /* Set the entry's link quality */
-    lnk = get_best_link_to_neighbor(&walker->nbr_addr);
-    if (!lnk) {
-      continue;                 // no link ?
-    }
-
-    if (lnk->linkcost >= LINK_COST_BROKEN) {
-      continue;                 // don't advertise links with very low LQ
-    }
-
-    /* Allocate a neighbour entry. */
-    neigh = olsr_malloc_tc_mpr_addr();
-
-    /* Set the entry's main address. */
-    neigh->address = walker->nbr_addr;
-
-    if (lnk) {
-      olsr_copylq_link_entry_2_tc_mpr_addr(neigh, lnk);
-    }
-
-    /* Queue the neighbour entry. */
-
-    // TODO: ugly hack until neighbor table is ported to avl tree
-
-    if (lq_tc->neigh == NULL || avl_comp_default(&lq_tc->neigh->address, &neigh->address) > 0) {
-      neigh->next = lq_tc->neigh;
-      lq_tc->neigh = neigh;
-    } else {
-      struct tc_mpr_addr *last = lq_tc->neigh, *n = last->next;
-
-      while (n) {
-        if (avl_comp_default(&n->address, &neigh->address) > 0) {
-          break;
-        }
-        last = n;
-        n = n->next;
-      }
-      neigh->next = n;
-      last->next = neigh;
-    }
-
-    // neigh->next = lq_tc->neigh;
-    // lq_tc->neigh = neigh;
-
-  }
-  OLSR_FOR_ALL_NBR_ENTRIES_END(walker);
-}
-
-static void
-destroy_lq_tc(struct lq_tc_message *lq_tc)
-{
-  struct tc_mpr_addr *walker, *aux;
-
-  // loop through the queued neighbour entries and free them
-
-  for (walker = lq_tc->neigh; walker != NULL; walker = aux) {
-    aux = walker->next;
-    olsr_free_tc_mpr_addr(walker);
-  }
-}
-
 static int
 common_size(void)
 {
@@ -480,142 +348,6 @@ serialize_lq_hello(struct lq_hello_message *lq_hello, struct interface *outif)
   net_outbuffer_push(outif, msg_buffer, size + off);
 }
 
-static uint8_t
-calculate_border_flag(void *lower_border, void *higher_border)
-{
-  uint8_t *lower = lower_border;
-  uint8_t *higher = higher_border;
-  uint8_t bitmask;
-  uint8_t part, bitpos;
-
-  for (part = 0; part < olsr_cnf->ipsize; part++) {
-    if (lower[part] != higher[part]) {
-      break;
-    }
-  }
-
-  if (part == olsr_cnf->ipsize) {       // same IPs ?
-    return 0;
-  }
-  // look for first bit of difference
-  bitmask = 0xfe;
-  for (bitpos = 0; bitpos < 8; bitpos++, bitmask <<= 1) {
-    if ((lower[part] & bitmask) == (higher[part] & bitmask)) {
-      break;
-    }
-  }
-
-  bitpos += 8 * (olsr_cnf->ipsize - part - 1);
-  return bitpos + 1;
-}
-
-static void
-serialize_lq_tc(struct lq_tc_message *lq_tc, struct interface *outif)
-{
-  int off, rem, size, expected_size = 0;
-  struct lq_tc_header *head;
-  struct tc_mpr_addr *neigh;
-  unsigned char *buff;
-
-  union olsr_ip_addr *last_ip = NULL;
-  uint8_t left_border_flag = 0xff;
-
-  // leave space for the OLSR header
-
-  off = common_size();
-
-  // initialize the LQ_TC header
-
-  head = (struct lq_tc_header *)(msg_buffer + off);
-
-  head->ansn = htons(lq_tc->ansn);
-  head->lower_border = 0;
-  head->upper_border = 0;
-
-  // 'off' is the offset of the byte following the LQ_TC header
-
-  off += sizeof(struct lq_tc_header);
-
-  // our work buffer starts at 'off'...
-
-  buff = msg_buffer + off;
-
-  // ... that's why we start with a 'size' of 0 and subtract 'off' from
-  // the remaining bytes in the output buffer
-
-  size = 0;
-  rem = net_outbuffer_bytes_left(outif) - off;
-
-  /*
-   * Initially, we want to put the complete lq_tc into the message.
-   * For this flush the output buffer (if there are some bytes in).
-   * This is a hack/fix, which prevents message fragementation resulting
-   * in instable links. The ugly lq/genmsg code should be reworked anyhow.
-   */
-  if (0 < net_output_pending(outif)) {
-    for (neigh = lq_tc->neigh; neigh != NULL; neigh = neigh->next) {
-      expected_size += olsr_cnf->ipsize + olsr_sizeof_TCLQ();
-    }
-  }
-
-  if (rem < expected_size) {
-    net_output(outif);
-    rem = net_outbuffer_bytes_left(outif) - off;
-  }
-  // loop through neighbors
-
-  for (neigh = lq_tc->neigh; neigh != NULL; neigh = neigh->next) {
-    // we need space for an IP address plus link quality
-    // information
-
-    // force signed comparison
-
-    // TODO sizeof_tc_lq function required
-    if ((int)(size + olsr_cnf->ipsize + 4) > rem) {
-      head->lower_border = left_border_flag;
-      head->upper_border = calculate_border_flag(last_ip, &neigh->address);
-      left_border_flag = head->upper_border;
-
-      // finalize the OLSR header
-
-      lq_tc->comm.size = size + off;
-
-      serialize_common((struct olsr_common *)lq_tc);
-
-      // output packet
-
-      net_outbuffer_push(outif, msg_buffer, size + off);
-
-      net_output(outif);
-
-      // move to the beginning of the buffer
-
-      size = 0;
-      rem = net_outbuffer_bytes_left(outif) - off;
-    }
-    // add the current neighbor's IP address
-    genipcopy(buff + size, &neigh->address);
-
-    // remember last ip
-    last_ip = (union olsr_ip_addr *)(buff + size);
-
-    size += olsr_cnf->ipsize;
-
-    // add the corresponding link quality
-    size += olsr_serialize_tc_lq_pair(&buff[size], neigh);
-  }
-
-  // finalize the OLSR header
-
-  head->lower_border = left_border_flag;
-  head->upper_border = 0xff;
-  lq_tc->comm.size = size + off;
-
-  serialize_common((struct olsr_common *)lq_tc);
-
-  net_outbuffer_push(outif, msg_buffer, size + off);
-}
-
 void
 olsr_output_lq_hello(void *para)
 {
@@ -642,43 +374,6 @@ olsr_output_lq_hello(void *para)
     }
   }
 }
-
-/**
- * Callback for TC generation timer.
- */
-void
-olsr_output_lq_tc(void *ctx)
-{
-  struct lq_tc_message lq_tc;
-  struct interface *outif = ctx;
-
-  if (outif == NULL) {
-    return;
-  }
-
-  /* create LQ_TC in internal format */
-  create_lq_tc(&lq_tc, outif);
-
-  /* empty message ? */
-  if (!lq_tc.neigh) {
-    return;
-  }
-
-  /* convert internal format into transmission format, send it */
-  serialize_lq_tc(&lq_tc, outif);
-
-  /* destroy internal format */
-  destroy_lq_tc(&lq_tc);
-
-  if (net_output_pending(outif)) {
-    if (!outif->immediate_send_tc) {
-      set_buffer_timer(outif);
-    } else {
-      net_output(outif);
-    }
-  }
-}
-
 /*
  * Local Variables:
  * c-basic-offset: 2
index f454975..f655b64 100644 (file)
@@ -117,27 +117,6 @@ struct lq_hello_header {
   uint8_t will;
 };
 
-/* deserialized LQ_TC */
-struct lq_tc_message {
-  struct olsr_common comm;
-  union olsr_ip_addr from;
-  uint16_t ansn;
-  struct tc_mpr_addr *neigh;
-};
-
-struct tc_mpr_addr {
-  union olsr_ip_addr address;
-  struct tc_mpr_addr *next;
-};
-
-/* serialized LQ_TC */
-
-struct lq_tc_header {
-  uint16_t ansn;
-  uint8_t lower_border;
-  uint8_t upper_border;
-};
-
 static INLINE void
 pkt_get_u8(const uint8_t ** p, uint8_t * var)
 {
@@ -293,8 +272,6 @@ uint16_t EXPORT(get_local_ansn_number)(bool increase);
 
 void olsr_output_lq_hello(void *para);
 
-void olsr_output_lq_tc(void *para);
-
 void destroy_lq_hello(struct lq_hello_message *lq_hello);
 
 extern bool lq_tc_pending;
index f8f7a13..28c5b0e 100644 (file)
@@ -54,7 +54,6 @@
 
 struct lq_handler *active_lq_handler = NULL;
 
-static struct olsr_cookie_info *tc_mpr_addr_mem_cookie = NULL;
 static struct olsr_cookie_info *tc_edge_mem_cookie = NULL;
 static struct olsr_cookie_info *lq_hello_neighbor_mem_cookie = NULL;
 static struct olsr_cookie_info *link_entry_mem_cookie = NULL;
@@ -72,9 +71,6 @@ init_lq_handler(void)
   tc_edge_mem_cookie = olsr_alloc_cookie("tc_edge", OLSR_COOKIE_TYPE_MEMORY);
   olsr_cookie_set_memory_size(tc_edge_mem_cookie, active_lq_handler->size_tc_edge);
 
-  tc_mpr_addr_mem_cookie = olsr_alloc_cookie("tc_mpr_addr", OLSR_COOKIE_TYPE_MEMORY);
-  olsr_cookie_set_memory_size(tc_mpr_addr_mem_cookie, active_lq_handler->size_tc_mpr_addr);
-
   lq_hello_neighbor_mem_cookie = olsr_alloc_cookie("lq_hello_neighbor", OLSR_COOKIE_TYPE_MEMORY);
   olsr_cookie_set_memory_size(lq_hello_neighbor_mem_cookie, active_lq_handler->size_lq_hello_neighbor);
 
@@ -160,19 +156,18 @@ olsr_deserialize_hello_lq_pair(const uint8_t ** curr, struct lq_hello_neighbor *
 }
 
 /*
- * olsr_serialize_tc_lq_pair
+ * olsr_serialize_tc_lq
  *
  * this function converts the lq information of a olsr_serialize_tc_lq_pair
  * into binary package format
  *
  * @param pointer to binary buffer to write into
- * @param pointer to olsr_serialize_tc_lq_pair
- * @return number of bytes that have been written
+ * @param pointer to link_entry
  */
-int
-olsr_serialize_tc_lq_pair(unsigned char *buff, struct tc_mpr_addr *neigh)
+void
+olsr_serialize_tc_lq(unsigned char **curr, struct link_entry *lnk)
 {
-  return active_lq_handler->serialize_tc_lq(buff, neigh);
+  active_lq_handler->serialize_tc_lq(curr, lnk);
 }
 
 /*
@@ -389,21 +384,6 @@ olsr_copy_hello_lq(struct lq_hello_neighbor *target, struct link_entry *source)
   active_lq_handler->copy_link_lq_into_neighbor(target, source);
 }
 
-/*
- * olsr_copylq_link_entry_2_tc_mpr_addr
- *
- * this function copies the link quality information from a link_entry to a
- * tc_mpr_addr.
- *
- * @param pointer to tc_mpr_addr
- * @param pointer to link_entry
- */
-void
-olsr_copylq_link_entry_2_tc_mpr_addr(struct tc_mpr_addr *target, struct link_entry *source)
-{
-  active_lq_handler->copy_link_entry_lq_into_tc_mpr_addr(target, source);
-}
-
 /*
  * olsr_copylq_link_entry_2_tc_edge_entry
  *
@@ -438,25 +418,6 @@ olsr_malloc_tc_edge_entry(void)
   return t;
 }
 
-/*
- * olsr_malloc_tc_mpr_addr
- *
- * this function allocates memory for an tc_mpr_addr inclusive
- * linkquality data.
- *
- * @return pointer to tc_mpr_addr
- */
-struct tc_mpr_addr *
-olsr_malloc_tc_mpr_addr(void)
-{
-  struct tc_mpr_addr *t;
-
-  t = olsr_cookie_malloc(tc_mpr_addr_mem_cookie);
-  if (active_lq_handler->clear_tc_mpr_addr)
-    active_lq_handler->clear_tc_mpr_addr(t);
-  return t;
-}
-
 /*
  * olsr_malloc_lq_hello_neighbor
  *
@@ -534,19 +495,6 @@ olsr_free_tc_edge_entry(struct tc_edge_entry *edge)
   olsr_cookie_free(tc_edge_mem_cookie, edge);
 }
 
-/**
- * olsr_free_tc_mpr_addr
- *
- * this functions free a tc_mpr_addr inclusive linkquality data
- *
- * @param pointer to tc_mpr_addr
- */
-void
-olsr_free_tc_mpr_addr(struct tc_mpr_addr *mpr)
-{
-  olsr_cookie_free(tc_mpr_addr_mem_cookie, mpr);
-}
-
 /**
  * olsr_get_Hello_MessageId
  *
index 0698615..2c7b646 100644 (file)
@@ -79,7 +79,6 @@ struct lq_handler {
 
   olsr_linkcost(*calc_link_entry_cost) (struct link_entry *);
   olsr_linkcost(*calc_lq_hello_neighbor_cost) (struct lq_hello_neighbor *);
-  olsr_linkcost(*calc_tc_mpr_addr_cost) (struct tc_mpr_addr *);
   olsr_linkcost(*calc_tc_edge_entry_cost) (struct tc_edge_entry *);
 
   bool(*is_relevant_costchange) (olsr_linkcost c1, olsr_linkcost c2);
@@ -88,17 +87,15 @@ struct lq_handler {
 
   void (*memorize_foreign_hello) (struct link_entry *, struct lq_hello_neighbor *);
 
-  void (*copy_link_entry_lq_into_tc_mpr_addr) (struct tc_mpr_addr *, struct link_entry *);
   void (*copy_link_entry_lq_into_tc_edge_entry) (struct tc_edge_entry *, struct link_entry *);
   void (*copy_link_lq_into_neighbor) (struct lq_hello_neighbor *, struct link_entry *);
 
   void (*clear_link_entry) (struct link_entry *);
   void (*clear_lq_hello_neighbor) (struct lq_hello_neighbor *);
-  void (*clear_tc_mpr_addr) (struct tc_mpr_addr *);
   void (*clear_tc_edge_entry) (struct tc_edge_entry *);
 
   int (*serialize_hello_lq) (unsigned char *, struct lq_hello_neighbor *);
-  int (*serialize_tc_lq) (unsigned char *, struct tc_mpr_addr *);
+  void (*serialize_tc_lq) (uint8_t **, struct link_entry *);
   void (*deserialize_hello_lq) (uint8_t const **, struct lq_hello_neighbor *);
   void (*deserialize_tc_lq) (uint8_t const **, struct tc_edge_entry *);
 
@@ -111,7 +108,6 @@ struct lq_handler {
   int linkdata_hello_count;
 
   size_t size_tc_edge;
-  size_t size_tc_mpr_addr;
   size_t size_lq_hello_neighbor;
   size_t size_link_entry;
 
@@ -130,7 +126,7 @@ bool olsr_is_relevant_costchange(olsr_linkcost c1, olsr_linkcost c2);
 
 int olsr_serialize_hello_lq_pair(unsigned char *, struct lq_hello_neighbor *);
 void olsr_deserialize_hello_lq_pair(const uint8_t **, struct lq_hello_neighbor *);
-int olsr_serialize_tc_lq_pair(unsigned char *, struct tc_mpr_addr *);
+void olsr_serialize_tc_lq(unsigned char **curr, struct link_entry *lnk);
 void olsr_deserialize_tc_lq_pair(const uint8_t **, struct tc_edge_entry *);
 
 void olsr_update_packet_loss_worker(struct link_entry *, bool);
@@ -144,18 +140,15 @@ size_t EXPORT(olsr_get_linklabel_count) (void);
 enum lq_linkdata_quality EXPORT(olsr_get_linkdata_quality) (struct link_entry *, int);
 
 void olsr_copy_hello_lq(struct lq_hello_neighbor *, struct link_entry *);
-void olsr_copylq_link_entry_2_tc_mpr_addr(struct tc_mpr_addr *, struct link_entry *);
 void olsr_copylq_link_entry_2_tc_edge_entry(struct tc_edge_entry *, struct link_entry *);
 
 struct tc_edge_entry *olsr_malloc_tc_edge_entry(void);
-struct tc_mpr_addr *olsr_malloc_tc_mpr_addr(void);
 struct lq_hello_neighbor *olsr_malloc_lq_hello_neighbor(void);
 struct link_entry *olsr_malloc_link_entry(void);
 
 void olsr_free_link_entry(struct link_entry *);
 void olsr_free_lq_hello_neighbor(struct lq_hello_neighbor *);
 void olsr_free_tc_edge_entry(struct tc_edge_entry *);
-void olsr_free_tc_mpr_addr(struct tc_mpr_addr *);
 
 uint8_t olsr_get_Hello_MessageId(void);
 uint8_t olsr_get_TC_MessageId(void);
index 673f7f9..adb693f 100644 (file)
@@ -500,8 +500,10 @@ olsr_input_mid(union olsr_message *msg, struct interface *input_if __attribute__
 
   tc = olsr_locate_tc_entry(&originator);
 
-  if (status != RESET_SEQNO_OLSR_MESSAGE && olsr_seqno_diff(msg_seq, tc->mid_seq) <= 0) {
+  if (status != RESET_SEQNO_OLSR_MESSAGE && tc->mid_seq != -1 && olsr_seqno_diff(msg_seq, tc->mid_seq) <= 0) {
     /* this MID is too old, discard it */
+    OLSR_DEBUG(LOG_MID, "Received too old mid from %s: %d < %d\n",
+        olsr_ip_to_string(&buf, from_addr), msg_seq, tc->mid_seq);
     return;
   }
   tc->mid_seq = msg_seq;
index e45a993..c00ab05 100644 (file)
@@ -97,6 +97,9 @@ olsr_add_tc_entry(const union olsr_ip_addr *adr)
   tc->addr = *adr;
   tc->vertex_node.key = &tc->addr;
 
+  tc->mid_seq = -1;
+  tc->hna_seq = -1;
+  tc->tc_seq = -1;
   /*
    * Insert into the global tc tree.
    */
@@ -828,7 +831,7 @@ olsr_input_tc(union olsr_message * msg, struct interface * input_if __attribute_
   tc = olsr_lookup_tc_entry(&originator);
 
   /* TCs can be splitted, so we are looking for ANSNs equal or higher */
-  if (tc && status != RESET_SEQNO_OLSR_MESSAGE && olsr_seqno_diff(ansn, tc->ansn) < 0) {
+  if (tc && status != RESET_SEQNO_OLSR_MESSAGE && tc->tc_seq != -1 && olsr_seqno_diff(ansn, tc->ansn) < 0) {
     /* this TC is too old, discard it */
     return;
   }
@@ -949,6 +952,136 @@ olsr_delete_all_tc_entries(void) {
   }OLSR_FOR_ALL_TC_ENTRIES_END(tc)
 }
 
+#if 0
+static uint8_t
+calculate_border_flag(void *lower_border, void *higher_border)
+{
+  uint8_t *lower = lower_border;
+  uint8_t *higher = higher_border;
+  uint8_t bitmask;
+  uint8_t part, bitpos;
+
+  for (part = 0; part < olsr_cnf->ipsize; part++) {
+    if (lower[part] != higher[part]) {
+      break;
+    }
+  }
+
+  if (part == olsr_cnf->ipsize) {       // same IPs ?
+    return 0;
+  }
+  // look for first bit of difference
+  bitmask = 0xfe;
+  for (bitpos = 0; bitpos < 8; bitpos++, bitmask <<= 1) {
+    if ((lower[part] & bitmask) == (higher[part] & bitmask)) {
+      break;
+    }
+  }
+
+  bitpos += 8 * (olsr_cnf->ipsize - part - 1);
+  return bitpos + 1;
+}
+#endif
+
+void
+olsr_output_lq_tc(void *ctx)
+{
+  static int ttl_list[] = { 2, 8, 2, 16, 2, 8, 2, MAX_TTL };
+  struct interface *ifp = ctx;
+  struct nbr_entry *nbr;
+  struct link_entry *link;
+  uint8_t msg_buffer[MAXMESSAGESIZE - OLSR_HEADERSIZE];
+  uint8_t *curr = msg_buffer;
+  uint8_t *length_field, *last;
+  bool sendTC = false;
+
+  OLSR_INFO(LOG_PACKET_CREATION, "Building TC on %s\n-------------------\n", ifp->int_name);
+
+  pkt_put_u8(&curr, olsr_get_TC_MessageId());
+  pkt_put_reltime(&curr, olsr_cnf->tc_params.validity_time);
+
+  length_field = curr;
+  pkt_put_u16(&curr, 0); /* put in real messagesize later */
+
+  pkt_put_ipaddress(&curr, &olsr_cnf->router_id);
+
+  if (olsr_cnf->lq_fish > 0) {
+    pkt_put_u8(&curr, ttl_list[ifp->ttl_index]);
+    OLSR_DEBUG(LOG_PACKET_CREATION, "Creating LQ TC with TTL %d.\n", ttl_list[ifp->ttl_index]);
+
+    ifp->ttl_index++;
+    ifp->ttl_index %= ARRAYSIZE(ttl_list);
+  }
+  else {
+    pkt_put_u8(&curr, 255);
+  }
+  pkt_put_u8(&curr, 0);
+  pkt_put_u16(&curr, get_msg_seqno());
+
+  pkt_put_u16(&curr, get_local_ansn_number(false));
+  pkt_put_u16(&curr, 0xffff); /* TODO: border flags and fragmentation */
+
+  last = msg_buffer + sizeof(msg_buffer) - olsr_cnf->ipsize - olsr_sizeof_TCLQ();
+
+  OLSR_FOR_ALL_NBR_ENTRIES(nbr) {
+    /*
+     * TC redundancy 2
+     *
+     * Only consider symmetric neighbours.
+     */
+    if (!nbr->is_sym) {
+      continue;
+    }
+
+    /*
+     * TC redundancy 1
+     *
+     * Only consider MPRs and MPR selectors
+     */
+    if (olsr_cnf->tc_redundancy == 1 && !nbr->is_mpr && nbr->mprs_count == 0) {
+      continue;
+    }
+
+    /*
+     * TC redundancy 0
+     *
+     * Only consider MPR selectors
+     */
+    if (olsr_cnf->tc_redundancy == 0 && nbr->mprs_count == 0) {
+      continue;
+    }
+
+    /* Set the entry's link quality */
+    link = get_best_link_to_neighbor(&nbr->nbr_addr);
+    if (!link) {
+      /* no link ? */
+      continue;
+    }
+
+    if (link->linkcost >= LINK_COST_BROKEN) {
+      /* don't advertisebroken links */
+      continue;
+    }
+
+    pkt_put_ipaddress(&curr, &nbr->nbr_addr);
+    olsr_serialize_tc_lq(&curr, link);
+
+    sendTC = true;
+  } OLSR_FOR_ALL_NBR_ENTRIES_END(nbr)
+
+  if (!sendTC) {
+    return;
+  }
+
+  pkt_put_u16(&length_field, curr - msg_buffer);
+
+  if (net_outbuffer_bytes_left(ifp) < curr - msg_buffer) {
+    net_output(ifp);
+    set_buffer_timer(ifp);
+  }
+  net_outbuffer_push(ifp, msg_buffer, curr - msg_buffer);
+}
+
 /*
  * Local Variables:
  * c-basic-offset: 2
index d0f1756..485f691 100644 (file)
@@ -87,9 +87,9 @@ struct tc_entry {
   struct timer_entry *validity_timer;  /* tc validity time */
   uint32_t refcount;                   /* reference counter */
   bool is_virtual;                     /* true if tc is already timed out */
-  uint16_t tc_seq;                     /* sequence number of the tc message */
-  uint16_t mid_seq;                    /* sequence number of the mid message */
-  uint16_t hna_seq;                    /* sequence number of the hna message */
+  int tc_seq;                          /* sequence number of the tc message */
+  int mid_seq;                         /* sequence number of the mid message */
+  int hna_seq;                         /* sequence number of the hna message */
   uint8_t msg_hops;                    /* hopcount as per the tc message */
   uint8_t hops;                        /* SPF calculated hopcount */
   uint16_t ansn;                       /* ANSN number of the tc message */
@@ -194,6 +194,7 @@ bool olsr_calc_tc_edge_entry_etx(struct tc_edge_entry *);
 void olsr_set_tc_edge_timer(struct tc_edge_entry *, unsigned int);
 void olsr_delete_all_tc_entries(void);
 uint32_t EXPORT(getRelevantTcCount) (void);
+void olsr_output_lq_tc(void *ifp);
 #endif
 
 /*