Cleanup Hello generation and move it into link_set.c
authorHenning Rogge <hrogge@googlemail.com>
Wed, 12 Aug 2009 16:20:28 +0000 (18:20 +0200)
committerHenning Rogge <hrogge@googlemail.com>
Wed, 12 Aug 2009 16:20:28 +0000 (18:20 +0200)
18 files changed:
lib/lq_etx_ff/src/lq_plugin_etx_ff.c
lib/lq_etx_float/src/lq_plugin_etx_float.c
lib/lq_etx_fpm/src/lq_plugin_etx_fpm.c
lib/lq_rfc/src/lq_plugin_rfc.c
src/interfaces.h
src/link_set.c
src/link_set.h
src/lq_packet.c
src/lq_packet.h
src/lq_plugin.c
src/lq_plugin.h
src/net_olsr.c
src/olsr.c
src/olsr_protocol.h
src/process_package.c
src/tc_set.c
src/unix/ifnet.c
src/win32/ifnet.c

index 842aa79..0098a62 100644 (file)
@@ -76,11 +76,10 @@ 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_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 void lq_etxff_serialize_hello_lq(uint8_t **curr, struct link_entry *link);
 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);
@@ -116,7 +115,6 @@ struct lq_handler lq_etxff_handler = {
 
   &lq_etxff_memorize_foreign_hello,
   &lq_etxff_copy_link_entry_lq_into_tc_edge_entry,
-  &lq_etxff_copy_link_lq_into_neighbor,
 
   &lq_etxff_clear_link_entry,
   NULL,
@@ -350,15 +348,6 @@ lq_etxff_copy_link_entry_lq_into_tc_edge_entry(struct tc_edge_entry *target, str
   lq_target->lq = lq_source->lq;
 }
 
-static void
-lq_etxff_copy_link_lq_into_neighbor(struct lq_hello_neighbor *target, struct link_entry *source)
-{
-  struct lq_etxff_lq_hello_neighbor *lq_target = (struct lq_etxff_lq_hello_neighbor *)target;
-  struct lq_etxff_link_entry *lq_source = (struct lq_etxff_link_entry *)source;
-
-  lq_target->lq = lq_source->lq;
-}
-
 static void
 lq_etxff_clear_link_entry(struct link_entry *link)
 {
@@ -371,17 +360,14 @@ lq_etxff_clear_link_entry(struct link_entry *link)
   }
 }
 
-static int
-lq_etxff_serialize_hello_lq(unsigned char *buff, struct lq_hello_neighbor *neigh)
+static void
+lq_etxff_serialize_hello_lq(uint8_t **curr, struct link_entry *link)
 {
-  struct lq_etxff_lq_hello_neighbor *lq_neigh = (struct lq_etxff_lq_hello_neighbor *)neigh;
-
-  buff[0] = (unsigned char)lq_neigh->lq.valueLq;
-  buff[1] = (unsigned char)lq_neigh->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_u16(curr, 0);
 }
 static void
 lq_etxff_serialize_tc_lq(uint8_t **curr, struct link_entry *link)
@@ -390,8 +376,7 @@ lq_etxff_serialize_tc_lq(uint8_t **curr, struct link_entry *link)
 
   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);
+  pkt_put_u16(curr, 0);
 }
 
 static void
index 37ebc18..e53e1dc 100644 (file)
@@ -69,9 +69,8 @@ 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_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 void lq_etxfloat_serialize_hello_lq(uint8_t **curr, struct link_entry *link);
 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);
@@ -103,7 +102,6 @@ struct lq_handler lq_etxfloat_handler = {
 
   &lq_etxfloat_memorize_foreign_hello,
   &lq_etxfloat_copy_link_entry_lq_into_tc_edge_entry,
-  &lq_etxfloat_copy_link_lq_into_neighbor,
 
   NULL,
   NULL,
@@ -252,26 +250,16 @@ lq_etxfloat_copy_link_entry_lq_into_tc_edge_entry(struct tc_edge_entry *target,
 }
 
 static void
-lq_etxfloat_copy_link_lq_into_neighbor(struct lq_hello_neighbor *target, struct link_entry *source)
+lq_etxfloat_serialize_hello_lq(uint8_t **curr, struct link_entry *link)
 {
-  struct lq_etxfloat_lq_hello_neighbor *lq_target = (struct lq_etxfloat_lq_hello_neighbor *)target;
-  struct lq_etxfloat_link_entry *lq_source = (struct lq_etxfloat_link_entry *)source;
+  struct lq_etxfloat_link_entry *lq_link = (struct lq_etxfloat_link_entry *)link;
 
-  lq_target->lq = lq_source->lq;
+  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 int
-lq_etxfloat_serialize_hello_lq(unsigned char *buff, struct lq_hello_neighbor *neigh)
-{
-  struct lq_etxfloat_lq_hello_neighbor *lq_neigh = (struct lq_etxfloat_lq_hello_neighbor *)neigh;
-
-  buff[0] = (unsigned char)(lq_neigh->lq.valueLq * 255);
-  buff[1] = (unsigned char)(lq_neigh->lq.valueNlq * 255);
-  buff[2] = (unsigned char)(0);
-  buff[3] = (unsigned char)(0);
-
-  return 4;
-}
 static void
 lq_etxfloat_serialize_tc_lq(uint8_t **curr, struct link_entry *link)
 {
index 2322612..0665232 100644 (file)
@@ -71,9 +71,8 @@ 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_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 void lq_etxfpm_serialize_hello_lq(uint8_t **curr, struct link_entry *link);
 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);
@@ -105,7 +104,6 @@ struct lq_handler lq_etxfpm_handler = {
 
   &lq_etxfpm_memorize_foreign_hello,
   &lq_etxfpm_copy_link_entry_lq_into_tc_edge_entry,
-  &lq_etxfpm_copy_link_lq_into_neighbor,
 
   NULL,
   NULL,
@@ -283,26 +281,16 @@ lq_etxfpm_copy_link_entry_lq_into_tc_edge_entry(struct tc_edge_entry *target, st
 }
 
 static void
-lq_etxfpm_copy_link_lq_into_neighbor(struct lq_hello_neighbor *target, struct link_entry *source)
+lq_etxfpm_serialize_hello_lq(uint8_t **curr, struct link_entry *link)
 {
-  struct lq_etxfpm_lq_hello_neighbor *lq_target = (struct lq_etxfpm_lq_hello_neighbor *)target;
-  struct lq_etxfpm_link_entry *lq_source = (struct lq_etxfpm_link_entry *)source;
+  struct lq_etxfpm_link_entry *lq_link = (struct lq_etxfpm_link_entry *)link;
 
-  lq_target->lq = lq_source->lq;
+  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 int
-lq_etxfpm_serialize_hello_lq(unsigned char *buff, struct lq_hello_neighbor *neigh)
-{
-  struct lq_etxfpm_lq_hello_neighbor *lq_neigh = (struct lq_etxfpm_lq_hello_neighbor *)neigh;
-
-  buff[0] = (unsigned char)lq_neigh->lq.valueLq;
-  buff[1] = (unsigned char)lq_neigh->lq.valueNlq;
-  buff[2] = (unsigned char)(0);
-  buff[3] = (unsigned char)(0);
-
-  return 4;
-}
 static void
 lq_etxfpm_serialize_tc_lq(uint8_t **curr, struct link_entry *link)
 {
index 94ecf18..36a4809 100644 (file)
@@ -71,9 +71,8 @@ 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_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 void lq_rfc_serialize_hello_lq(uint8_t **curr, struct link_entry *link);
 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);
@@ -102,7 +101,6 @@ struct lq_handler lq_rfc_handler = {
 
   &lq_rfc_memorize_foreign_hello,
   &lq_rfc_copy_link_entry_lq_into_tc_edge_entry,
-  &lq_rfc_copy_link_lq_into_neighbor,
 
   NULL,
   NULL,
@@ -220,16 +218,10 @@ lq_rfc_copy_link_entry_lq_into_tc_edge_entry(struct tc_edge_entry __attribute__
 }
 
 static void
-lq_rfc_copy_link_lq_into_neighbor(struct lq_hello_neighbor __attribute__ ((unused)) * target,
-                                  struct link_entry __attribute__ ((unused)) * source)
+lq_rfc_serialize_hello_lq(uint8_t __attribute__ ((unused)) **curr, struct link_entry __attribute__ ((unused)) *link)
 {
 }
 
-static int
-lq_rfc_serialize_hello_lq(unsigned char __attribute__ ((unused)) * buff, struct lq_hello_neighbor __attribute__ ((unused)) * neigh)
-{
-  return 0;
-}
 static void
 lq_rfc_serialize_tc_lq(uint8_t __attribute__ ((unused)) **curr, struct link_entry __attribute__ ((unused)) *link)
 {
index 2d3175d..9c3189b 100644 (file)
@@ -150,8 +150,6 @@ struct interface {
   /* Message build related  */
   struct timer_entry *buffer_hold_timer;        /* Timer for message batching */
   struct olsr_netbuf netbuf;           /* the build buffer */
-  bool immediate_send_tc;              /* Hello's are sent immediately normally,
-                                          this flag prefers to send TC's */
 
 #ifdef linux
 
index 4359f55..bb4dcea 100644 (file)
@@ -817,6 +817,96 @@ olsr_update_packet_loss(struct link_entry *entry)
                  OLSR_LINK_LOSS_JITTER, OLSR_TIMER_PERIODIC, &olsr_expire_link_loss_timer, entry, link_loss_timer_cookie);
 }
 
+void
+generate_hello(void *p) {
+  struct interface *ifp = p;
+  uint8_t msg_buffer[MAXMESSAGESIZE - OLSR_HEADERSIZE];
+  uint8_t *curr = msg_buffer;
+  uint8_t *length_field, *last;
+  struct link_entry *link;
+  uint8_t writeLinkType, writeNeighType;
+  OLSR_INFO(LOG_PACKET_CREATION, "Building Hello for %s\n-------------------\n", ifp->int_name);
+
+  pkt_put_u8(&curr, olsr_get_Hello_MessageId());
+  pkt_put_reltime(&curr, ifp->hello_validity);
+
+  length_field = curr;
+  pkt_put_u16(&curr, 0); /* put in real messagesize later */
+
+  pkt_put_ipaddress(&curr, &olsr_cnf->router_id);
+
+  pkt_put_u8(&curr, 1);
+  pkt_put_u8(&curr, 0);
+  pkt_put_u16(&curr, get_msg_seqno());
+
+  pkt_put_u16(&curr, 0);
+  pkt_put_reltime(&curr, ifp->hello_interval);
+  pkt_put_u8(&curr, olsr_cnf->willingness);
+
+  last = msg_buffer + sizeof(msg_buffer) - olsr_cnf->ipsize;
+
+  /* first calculate local link status */
+  OLSR_FOR_ALL_LINK_ENTRIES(link) {
+    if (olsr_ipcmp(&link->local_iface_addr, &ifp->ip_addr) != 0) {
+      link->iflocal_link_status = UNSPEC_LINK;
+    }
+    else {
+      link->iflocal_link_status = lookup_link_status(link);
+    }
+
+    if (link->neighbor->is_mpr) {
+      link->iflocal_neigh_status = MPR_NEIGH;
+    }
+    else if (link->neighbor->is_sym) {
+      link->iflocal_neigh_status = SYM_NEIGH;
+    }
+    else {
+      link->iflocal_neigh_status = NOT_NEIGH;
+    }
+  } OLSR_FOR_ALL_LINK_ENTRIES_END(link)
+
+  for (writeNeighType = 0; writeNeighType < COUNT_NEIGH_TYPES; writeNeighType++) {
+    for (writeLinkType = 0; writeLinkType < COUNT_LINK_TYPES; writeLinkType++) {
+      bool first = true;
+      uint8_t *linkstart = NULL;
+
+      OLSR_FOR_ALL_LINK_ENTRIES(link) {
+        if (link->iflocal_link_status != writeLinkType
+            || link->iflocal_neigh_status != writeNeighType) {
+          continue;
+        }
+
+        if (first) {
+          pkt_put_u8(&curr, CREATE_LINK_CODE(writeNeighType, writeLinkType));
+          pkt_put_u8(&curr, 0);
+          first = false;
+
+          /* put in dummy length */
+          linkstart = curr;
+          pkt_put_u16(&curr, 0);
+        }
+
+        pkt_put_ipaddress(&curr, &link->neighbor_iface_addr);
+        olsr_serialize_hello_lq_pair(&curr, link);
+      } OLSR_FOR_ALL_LINK_ENTRIES_END(link)
+
+      /* fix length field of hello block */
+      if (linkstart != NULL) {
+        pkt_put_u16(&linkstart, curr + 2 - linkstart);
+      }
+    }
+  }
+
+  /* fix length field of message */
+  pkt_put_u16(&length_field, curr - msg_buffer);
+
+  /* send hello immediately */
+  if (net_outbuffer_bytes_left(ifp) < curr - msg_buffer) {
+    net_output(ifp);
+  }
+  net_outbuffer_push(ifp, msg_buffer, curr - msg_buffer);
+  net_output(ifp);
+}
 /*
  * Local Variables:
  * c-basic-offset: 2
index bbd7d75..88650dc 100644 (file)
@@ -69,6 +69,9 @@ struct link_entry {
 
   bool is_mpr, is_mprs;
 
+  /* for faster hello packet generation */
+  uint8_t iflocal_link_status, iflocal_neigh_status;
+
   /*
    * packet loss
    */
@@ -131,7 +134,7 @@ int lookup_link_status(const struct link_entry *);
 void olsr_update_packet_loss_hello_int(struct link_entry *, uint32_t);
 void olsr_update_packet_loss(struct link_entry *entry);
 void olsr_print_link_set(void);
-
+void generate_hello(void *);
 #endif
 
 /*
index 4dc7bf7..71a16ef 100644 (file)
 
 #include <stdlib.h>
 
-bool lq_tc_pending = false;
-
-static unsigned char msg_buffer[MAXMESSAGESIZE - OLSR_HEADERSIZE];
-
-static void
-create_lq_hello(struct lq_hello_message *lq_hello, struct interface *outif)
-{
-  struct link_entry *walker;
-
-  // initialize the static fields
-
-  lq_hello->comm.type = olsr_get_Hello_MessageId();
-  lq_hello->comm.vtime = outif->hello_validity;
-  lq_hello->comm.size = 0;
-
-  lq_hello->comm.orig = olsr_cnf->router_id;
-
-  lq_hello->comm.ttl = 1;
-  lq_hello->comm.hops = 0;
-
-  lq_hello->htime = outif->hello_interval;
-  lq_hello->will = olsr_cnf->willingness;
-
-  lq_hello->neigh = NULL;
-
-  // loop through the link set
-
-  OLSR_FOR_ALL_LINK_ENTRIES(walker) {
-
-    // allocate a neighbour entry
-    struct lq_hello_neighbor *neigh = olsr_malloc_lq_hello_neighbor();
-
-    // a) this neighbor interface IS NOT visible via the output interface
-    if (olsr_ipcmp(&walker->local_iface_addr, &outif->ip_addr) != 0)
-      neigh->link_type = UNSPEC_LINK;
-
-    // b) this neighbor interface IS visible via the output interface
-
-    else
-      neigh->link_type = lookup_link_status(walker);
-
-    // set the entry's link quality
-    olsr_copy_hello_lq(neigh, walker);
-
-    // set the entry's neighbour type
-
-    if (walker->neighbor->is_mpr)
-      neigh->neigh_type = MPR_NEIGH;
-
-    else if (walker->neighbor->is_sym)
-      neigh->neigh_type = SYM_NEIGH;
-
-    else
-      neigh->neigh_type = NOT_NEIGH;
-
-    // set the entry's neighbour interface address
-
-    neigh->addr = walker->neighbor_iface_addr;
-
-    // queue the neighbour entry
-    neigh->next = lq_hello->neigh;
-    lq_hello->neigh = neigh;
-
-  }
-  OLSR_FOR_ALL_LINK_ENTRIES_END(walker);
-}
-
 void
 destroy_lq_hello(struct lq_hello_message *lq_hello)
 {
@@ -138,233 +71,6 @@ destroy_lq_hello(struct lq_hello_message *lq_hello)
   lq_hello->neigh = NULL;
 }
 
-static int
-common_size(void)
-{
-  // return the size of the header shared by all OLSR messages
-
-  return (olsr_cnf->ip_version == AF_INET) ? sizeof(struct olsr_header_v4) : sizeof(struct olsr_header_v6);
-}
-
-static void
-serialize_common(struct olsr_common *comm)
-{
-  if (olsr_cnf->ip_version == AF_INET) {
-    // serialize an IPv4 OLSR message header
-    struct olsr_header_v4 *olsr_head_v4 = (struct olsr_header_v4 *)msg_buffer;
-
-    olsr_head_v4->type = comm->type;
-    olsr_head_v4->vtime = reltime_to_me(comm->vtime);
-    olsr_head_v4->size = htons(comm->size);
-
-    olsr_head_v4->orig = comm->orig.v4.s_addr;
-
-    olsr_head_v4->ttl = comm->ttl;
-    olsr_head_v4->hops = comm->hops;
-    olsr_head_v4->seqno = htons(get_msg_seqno());
-  } else {
-    // serialize an IPv6 OLSR message header
-    struct olsr_header_v6 *olsr_head_v6 = (struct olsr_header_v6 *)msg_buffer;
-
-    olsr_head_v6->type = comm->type;
-    olsr_head_v6->vtime = reltime_to_me(comm->vtime);
-    olsr_head_v6->size = htons(comm->size);
-
-    memcpy(&olsr_head_v6->orig, &comm->orig.v6.s6_addr, sizeof(olsr_head_v6->orig));
-
-    olsr_head_v6->ttl = comm->ttl;
-    olsr_head_v6->hops = comm->hops;
-    olsr_head_v6->seqno = htons(get_msg_seqno());
-  }
-}
-
-static void
-serialize_lq_hello(struct lq_hello_message *lq_hello, struct interface *outif)
-{
-  static const int LINK_ORDER[] = { SYM_LINK, UNSPEC_LINK, ASYM_LINK, LOST_LINK };
-  int rem, size, req, expected_size = 0;
-  struct lq_hello_info_header *info_head;
-  struct lq_hello_neighbor *neigh;
-  unsigned char *buff;
-  bool is_first;
-  int i;
-
-  // leave space for the OLSR header
-  int off = common_size();
-
-  // initialize the LQ_HELLO header
-
-  struct lq_hello_header *head = (struct lq_hello_header *)(msg_buffer + off);
-
-  head->reserved = 0;
-  head->htime = reltime_to_me(lq_hello->htime);
-  head->will = lq_hello->will;
-
-  // 'off' is the offset of the byte following the LQ_HELLO header
-
-  off += sizeof(struct lq_hello_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_hello 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 (i = 0; i <= MAX_NEIGH; i++) {
-      unsigned int j;
-      for (j = 0; j < ARRAYSIZE(LINK_ORDER); j++) {
-        is_first = true;
-        for (neigh = lq_hello->neigh; neigh != NULL; neigh = neigh->next) {
-          if (0 == i && 0 == j)
-            expected_size += olsr_cnf->ipsize + olsr_sizeof_TCLQ();
-          if (neigh->neigh_type == i && neigh->link_type == LINK_ORDER[j]) {
-            if (is_first) {
-              expected_size += sizeof(struct lq_hello_info_header);
-              is_first = false;
-            }
-          }
-        }
-      }
-    }
-  }
-
-  if (rem < expected_size) {
-    net_output(outif);
-    rem = net_outbuffer_bytes_left(outif) - off;
-  }
-
-  info_head = NULL;
-
-  // iterate through all neighbor types ('i') and all link types ('j')
-
-  for (i = 0; i <= MAX_NEIGH; i++) {
-    unsigned int j;
-    for (j = 0; j < ARRAYSIZE(LINK_ORDER); j++) {
-      is_first = true;
-
-      // loop through neighbors
-
-      for (neigh = lq_hello->neigh; neigh != NULL; neigh = neigh->next) {
-        if (neigh->neigh_type != i || neigh->link_type != LINK_ORDER[j])
-          continue;
-
-        // we need space for an IP address plus link quality
-        // information
-
-        req = olsr_cnf->ipsize + 4;
-
-        // no, we also need space for an info header, as this is the
-        // first neighbor with the current neighor type and link type
-
-        if (is_first)
-          req += sizeof(struct lq_hello_info_header);
-
-        // we do not have enough space left
-
-        // force signed comparison
-
-        if ((int)(size + req) > rem) {
-          // finalize the OLSR header
-
-          lq_hello->comm.size = size + off;
-
-          serialize_common(&lq_hello->comm);
-
-          // finalize the info header
-
-          info_head->size = ntohs(buff + size - (unsigned char *)info_head);
-
-          // 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;
-
-          // we need a new info header
-
-          is_first = true;
-        }
-        // create a new info header
-
-        if (is_first) {
-          info_head = (struct lq_hello_info_header *)(buff + size);
-          size += sizeof(struct lq_hello_info_header);
-
-          info_head->reserved = 0;
-          info_head->link_code = CREATE_LINK_CODE(i, LINK_ORDER[j]);
-        }
-        // add the current neighbor's IP address
-
-        genipcopy(buff + size, &neigh->addr);
-        size += olsr_cnf->ipsize;
-
-        // add the corresponding link quality
-        size += olsr_serialize_hello_lq_pair(&buff[size], neigh);
-
-        is_first = false;
-      }
-
-      // finalize the info header, if there are any neighbors with the
-      // current neighbor type and link type
-
-      if (!is_first)
-        info_head->size = ntohs(buff + size - (unsigned char *)info_head);
-    }
-  }
-
-  // finalize the OLSR header
-
-  lq_hello->comm.size = size + off;
-
-  serialize_common((struct olsr_common *)lq_hello);
-
-  // move the message to the output buffer
-
-  net_outbuffer_push(outif, msg_buffer, size + off);
-}
-
-void
-olsr_output_lq_hello(void *para)
-{
-  struct lq_hello_message lq_hello;
-  struct interface *outif = para;
-
-  if (outif == NULL) {
-    return;
-  }
-  // create LQ_HELLO in internal format
-  create_lq_hello(&lq_hello, outif);
-
-  // convert internal format into transmission format, send it
-  serialize_lq_hello(&lq_hello, outif);
-
-  // destroy internal format
-  destroy_lq_hello(&lq_hello);
-
-  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 d9c2eea..e1ee36d 100644 (file)
@@ -268,12 +268,8 @@ pkt_put_prefixlen(uint8_t ** p, uint8_t var)
   *p += olsr_cnf->ipsize;
 }
 
-void olsr_output_lq_hello(void *para);
-
 void destroy_lq_hello(struct lq_hello_message *lq_hello);
 
-extern bool lq_tc_pending;
-
 #endif
 
 /*
index 28c5b0e..4614d30 100644 (file)
@@ -130,13 +130,12 @@ olsr_is_relevant_costchange(olsr_linkcost c1, olsr_linkcost c2)
  * format
  *
  * @param pointer to binary buffer to write into
- * @param pointer to lq_hello_neighbor
- * @return number of bytes that have been written
+ * @param pointer to link_entry
  */
-int
-olsr_serialize_hello_lq_pair(unsigned char *buff, struct lq_hello_neighbor *neigh)
+void
+olsr_serialize_hello_lq_pair(uint8_t **buff, struct link_entry *link)
 {
-  return active_lq_handler->serialize_hello_lq(buff, neigh);
+  active_lq_handler->serialize_hello_lq(buff, link);
 }
 
 /*
@@ -229,11 +228,7 @@ olsr_update_packet_loss_worker(struct link_entry *entry, bool lost)
 void
 olsr_memorize_foreign_hello_lq(struct link_entry *local, struct lq_hello_neighbor *foreign)
 {
-  if (foreign) {
-    active_lq_handler->memorize_foreign_hello(local, foreign);
-  } else {
-    active_lq_handler->memorize_foreign_hello(local, NULL);
-  }
+  active_lq_handler->memorize_foreign_hello(local, foreign);
 }
 
 /*
@@ -369,21 +364,6 @@ enum lq_linkdata_quality olsr_get_linkdata_quality (struct link_entry *link, int
   return LQ_QUALITY_BAD;
 }
 
-/*
- * olsr_copy_hello_lq
- *
- * this function copies the link quality information from a link_entry to a
- * lq_hello_neighbor.
- *
- * @param pointer to target lq_hello_neighbor
- * @param pointer to source link_entry
- */
-void
-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_edge_entry
  *
index 2c7b646..76bbddb 100644 (file)
@@ -86,15 +86,13 @@ struct lq_handler {
   olsr_linkcost(*packet_loss_handler) (struct link_entry *, bool);
 
   void (*memorize_foreign_hello) (struct link_entry *, struct lq_hello_neighbor *);
-
   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_edge_entry) (struct tc_edge_entry *);
 
-  int (*serialize_hello_lq) (unsigned char *, struct lq_hello_neighbor *);
+  void (*serialize_hello_lq) (uint8_t **, struct link_entry *);
   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 *);
@@ -124,9 +122,9 @@ void deinit_lq_handler(void);
 olsr_linkcost olsr_calc_tc_cost(struct tc_edge_entry *);
 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_serialize_hello_lq_pair(uint8_t **, struct link_entry *);
 void olsr_deserialize_hello_lq_pair(const uint8_t **, struct lq_hello_neighbor *);
-void olsr_serialize_tc_lq(unsigned char **curr, struct link_entry *lnk);
+void olsr_serialize_tc_lq(uint8_t **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);
@@ -139,7 +137,6 @@ size_t EXPORT(olsr_get_linklabel_maxlength) (int);
 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_edge_entry(struct tc_edge_entry *, struct link_entry *);
 
 struct tc_edge_entry *olsr_malloc_tc_edge_entry(void);
index de156d9..28a4f45 100644 (file)
@@ -378,13 +378,6 @@ net_output(struct interface *ifp)
   }
 
   ifp->netbuf.pending = 0;
-
-  /*
-   * if we've just transmitted a TC message, let Dijkstra use the current
-   * link qualities for the links to our neighbours
-   */
-
-  lq_tc_pending = false;
   return retval;
 }
 
index 848db55..4cae4ae 100644 (file)
@@ -517,8 +517,6 @@ olsr_link_to_string(uint8_t linktype)
     return "SYM";
   case (LOST_LINK):
     return "LOST";
-  case (HIDE_LINK):
-    return "HIDE";
   default:
     break;
   }
index e3e1ed8..0a8f536 100644 (file)
  *Message Types
  */
 
-#define HELLO_MESSAGE         1
-#define TC_MESSAGE            2
-#define MID_MESSAGE           3
-#define HNA_MESSAGE           4
-#define MAX_MESSAGE           4
+enum olsr_message_types {
+  HELLO_MESSAGE,        /* 1 */
+  TC_MESSAGE,           /* 2 */
+  MID_MESSAGE,          /* 3 */
+  HNA_MESSAGE,          /* 4 */
+  COUNT_MESSAGE_TYPES
+};
 
 /*
  *Link Types
  */
 
-#define UNSPEC_LINK           0
-#define ASYM_LINK             1
-#define SYM_LINK              2
-#define LOST_LINK             3
-#define HIDE_LINK             4
-#define MAX_LINK              4
+enum olsr_link_types {
+  UNSPEC_LINK,          /* 0 */
+  ASYM_LINK,            /* 1 */
+  SYM_LINK,             /* 2 */
+  LOST_LINK,            /* 3 */
+  COUNT_LINK_TYPES
+};
 
 /*
  *Neighbor Types
  */
 
-#define NOT_NEIGH             0
-#define SYM_NEIGH             1
-#define MPR_NEIGH             2
-#define MAX_NEIGH             2
+enum olsr_neigh_types {
+  NOT_NEIGH,            /* 0 */
+  SYM_NEIGH,            /* 1 */
+  MPR_NEIGH,            /* 2 */
+  COUNT_NEIGH_TYPES
+};
 
 /*
  *Willingness
index db7cdc8..9f27d22 100644 (file)
@@ -217,7 +217,7 @@ deserialize_hello(struct lq_hello_message *hello, const void *ser)
 
   const unsigned char *curr = ser;
   pkt_get_u8(&curr, &type);
-  if (type != HELLO_MESSAGE && type != LQ_HELLO_MESSAGE) {
+  if (type != olsr_get_Hello_MessageId()) {
     /* No need to do anything more */
     return true;
   }
index 80cfe2f..8cab0dc 100644 (file)
@@ -804,7 +804,7 @@ olsr_input_tc(union olsr_message * msg, struct interface * input_if __attribute_
 
   /* We are only interested in TC message types. */
   pkt_get_u8(&curr, &type);
-  if ((type != LQ_TC_MESSAGE) && (type != TC_MESSAGE)) {
+  if (type != olsr_get_TC_MessageId()) {
     return;
   }
 
index c476e62..0de34cb 100644 (file)
@@ -524,7 +524,6 @@ chk_if_up(struct olsr_if_config *iface)
    */
   ifp->int_name = olsr_strdup(ifr_basename);
 
-  ifp->immediate_send_tc = olsr_cnf->tc_params.emission_interval < iface->cnf->hello_params.emission_interval;
 #if 0
   ifp->gen_properties = NULL;
 #endif
@@ -590,7 +589,7 @@ chk_if_up(struct olsr_if_config *iface)
    */
   ifp->hello_gen_timer =
     olsr_start_timer(iface->cnf->hello_params.emission_interval,
-                     HELLO_JITTER, OLSR_TIMER_PERIODIC, &olsr_output_lq_hello, ifp, hello_gen_timer_cookie);
+                     HELLO_JITTER, OLSR_TIMER_PERIODIC, &generate_hello, ifp, hello_gen_timer_cookie);
   ifp->hello_interval = iface->cnf->hello_params.emission_interval;
   ifp->hello_validity = iface->cnf->hello_params.validity_time;
 
index e5fe4a0..b5b6ca9 100644 (file)
@@ -645,7 +645,6 @@ chk_if_up(struct olsr_if_config *IntConf)
 
   New = olsr_cookie_malloc(interface_mem_cookie);
 
-  New->immediate_send_tc = (olsr_cnf->tc_params.emission_interval < IntConf->cnf->hello_params.emission_interval);
 #if 0
   New->gen_properties = NULL;
 #endif