indent tc_set code
authorHannes Gredler <hannes@gredler.at>
Wed, 7 May 2008 16:35:44 +0000 (18:35 +0200)
committerHannes Gredler <hannes@gredler.at>
Wed, 7 May 2008 16:35:44 +0000 (18:35 +0200)
src/tc_set.c
src/tc_set.h

index db05ac9..139212c 100644 (file)
@@ -1,3 +1,4 @@
+
 /*
  * The olsr.org Optimized Link-State Routing daemon(olsrd)
  * Copyright (c) 2004, Andreas T√łnnesen(andreto@olsr.org)
@@ -56,7 +57,7 @@
 
 /* Root of the link state database */
 struct avl_tree tc_tree;
-struct tc_entry *tc_myself; /* Shortcut to ourselves */
+struct tc_entry *tc_myself;           /* Shortcut to ourselves */
 
 /* Some cookies for stats keeping */
 struct olsr_cookie_info *tc_edge_gc_timer_cookie = NULL;
@@ -78,11 +79,13 @@ struct olsr_cookie_info *tc_mem_cookie = NULL;
 
 /* Value window for ansn, identifies old messages to be ignored */
 #define TC_ANSN_WINDOW 256
+
 /* Value window for seqno, identifies old messages to be ignored */
 #define TC_SEQNO_WINDOW 1024
 
 /* Enlarges the value window for upcoming ansn/seqno to be accepted */
 #define TC_ANSN_WINDOW_MULT 4
+
 /* Enlarges the value window for upcoming ansn/seqno to be accepted */
 #define TC_SEQNO_WINDOW_MULT 8
 
@@ -90,11 +93,11 @@ static olsr_bool
 olsr_seq_inrange_low(int beg, int end, olsr_u16_t seq)
 {
   if (beg < 0) {
-    if (seq >= (olsr_u16_t)beg || seq < end) {
+    if (seq >= (olsr_u16_t) beg || seq < end) {
       return OLSR_TRUE;
     }
   } else if (end >= 0x10000) {
-    if (seq >= beg || seq < (olsr_u16_t)end) {
+    if (seq >= beg || seq < (olsr_u16_t) end) {
       return OLSR_TRUE;
     }
   } else if (seq >= beg && seq < end) {
@@ -107,11 +110,11 @@ static olsr_bool
 olsr_seq_inrange_high(int beg, int end, olsr_u16_t seq)
 {
   if (beg < 0) {
-    if (seq > (olsr_u16_t)beg || seq <= end) {
+    if (seq > (olsr_u16_t) beg || seq <= end) {
       return OLSR_TRUE;
     }
   } else if (end >= 0x10000) {
-    if (seq > beg || seq <= (olsr_u16_t)end) {
+    if (seq > beg || seq <= (olsr_u16_t) end) {
       return OLSR_TRUE;
     }
   } else if (seq > beg && seq <= end) {
@@ -162,8 +165,7 @@ olsr_add_tc_entry(union olsr_ip_addr *adr)
   /*
    * Add a rt_path for ourselves.
    */
-  olsr_insert_routing_table(adr, olsr_cnf->maxplen, adr,
-                            OLSR_RT_ORIGIN_INT);
+  olsr_insert_routing_table(adr, olsr_cnf->maxplen, adr, OLSR_RT_ORIGIN_INT);
 
   return tc;
 }
@@ -182,12 +184,16 @@ olsr_init_tc(void)
   /*
    * Get some cookies for getting stats to ease troubleshooting.
    */
-  tc_edge_gc_timer_cookie = olsr_alloc_cookie("TC edge GC", OLSR_COOKIE_TYPE_TIMER);
-  tc_validity_timer_cookie = olsr_alloc_cookie("TC validity", OLSR_COOKIE_TYPE_TIMER);
+  tc_edge_gc_timer_cookie =
+    olsr_alloc_cookie("TC edge GC", OLSR_COOKIE_TYPE_TIMER);
+  tc_validity_timer_cookie =
+    olsr_alloc_cookie("TC validity", OLSR_COOKIE_TYPE_TIMER);
 
-  tc_edge_mem_cookie = olsr_alloc_cookie("tc_edge_entry", OLSR_COOKIE_TYPE_MEMORY);
-  olsr_cookie_set_memory_size(tc_edge_mem_cookie, sizeof(struct tc_edge_entry) +
-    active_lq_handler->tc_lq_size);
+  tc_edge_mem_cookie =
+    olsr_alloc_cookie("tc_edge_entry", OLSR_COOKIE_TYPE_MEMORY);
+  olsr_cookie_set_memory_size(tc_edge_mem_cookie,
+                             sizeof(struct tc_edge_entry) +
+                             active_lq_handler->tc_lq_size);
 
   tc_mem_cookie = olsr_alloc_cookie("tc_entry", OLSR_COOKIE_TYPE_MEMORY);
   olsr_cookie_set_memory_size(tc_mem_cookie, sizeof(struct tc_entry));
@@ -336,13 +342,13 @@ olsr_tc_edge_to_string(struct tc_edge_entry *tc_edge)
   struct ipaddr_str addrbuf, dstbuf;
   struct tc_entry *tc = tc_edge->tc;
   struct lqtextbuffer lqbuffer1, lqbuffer2;
-  
+
   snprintf(buf, sizeof(buf),
-           "%s > %s, cost (%6s) %s",
-           olsr_ip_to_string(&addrbuf, &tc->addr),
-           olsr_ip_to_string(&dstbuf, &tc_edge->T_dest_addr),
-           get_tc_edge_entry_text(tc_edge, &lqbuffer1),
-           get_linkcost_text(tc_edge->cost, OLSR_FALSE, &lqbuffer2));
+          "%s > %s, cost (%6s) %s",
+          olsr_ip_to_string(&addrbuf, &tc->addr),
+          olsr_ip_to_string(&dstbuf, &tc_edge->T_dest_addr),
+          get_tc_edge_entry_text(tc_edge, &lqbuffer1),
+          get_linkcost_text(tc_edge->cost, OLSR_FALSE, &lqbuffer2));
 
   return buf;
 }
@@ -415,7 +421,7 @@ olsr_calc_tc_edge_entry_etx(struct tc_edge_entry *tc_edge)
  */
 struct tc_edge_entry *
 olsr_add_tc_edge_entry(struct tc_entry *tc, union olsr_ip_addr *addr,
-                       olsr_u16_t ansn)
+                      olsr_u16_t ansn)
 {
 #if !defined(NODEBUG) && defined(DEBUG)
   struct ipaddr_str buf;
@@ -432,7 +438,7 @@ olsr_add_tc_edge_entry(struct tc_entry *tc, union olsr_ip_addr *addr,
   tc_edge->T_dest_addr = *addr;
   tc_edge->ansn = ansn;
   tc_edge->edge_node.key = &tc_edge->T_dest_addr;
-  
+
   /*
    * Insert into the edge tree.
    */
@@ -452,14 +458,14 @@ olsr_add_tc_edge_entry(struct tc_entry *tc, union olsr_ip_addr *addr,
   if (tc_neighbor) {
 #ifdef DEBUG
     OLSR_PRINTF(1, "TC:   found neighbor tc_entry %s\n",
-                olsr_ip_to_string(&buf, &tc_neighbor->addr));
+               olsr_ip_to_string(&buf, &tc_neighbor->addr));
 #endif
 
     tc_edge_inv = olsr_lookup_tc_edge(tc_neighbor, &tc->addr);
     if (tc_edge_inv) {
 #ifdef DEBUG
       OLSR_PRINTF(1, "TC:   found inverse edge for %s\n",
-                  olsr_ip_to_string(&buf, &tc_edge_inv->T_dest_addr));
+                 olsr_ip_to_string(&buf, &tc_edge_inv->T_dest_addr));
 #endif
 
       /*
@@ -550,8 +556,8 @@ olsr_delete_outdated_tc_edges(struct tc_entry *tc)
  */
 static int
 olsr_delete_revoked_tc_edges(struct tc_entry *tc, olsr_u16_t ansn,
-                              union olsr_ip_addr *lower_border,
-                              union olsr_ip_addr *upper_border)
+                            union olsr_ip_addr *lower_border,
+                            union olsr_ip_addr *upper_border)
 {
   struct tc_edge_entry *tc_edge;
   int retval = 0;
@@ -561,20 +567,19 @@ olsr_delete_revoked_tc_edges(struct tc_entry *tc, olsr_u16_t ansn,
 #endif
 
   olsr_bool passedLowerBorder = OLSR_FALSE;
-  
+
   OLSR_FOR_ALL_TC_EDGE_ENTRIES(tc, tc_edge) {
     if (!passedLowerBorder) {
       if (avl_comp_default(lower_border, &tc_edge->T_dest_addr) <= 0) {
-        passedLowerBorder = OLSR_TRUE;
-      }
-      else {
-        continue;
+       passedLowerBorder = OLSR_TRUE;
+      } else {
+       continue;
       }
     }
-    
+
     if (passedLowerBorder) {
       if (avl_comp_default(upper_border, &tc_edge->T_dest_addr) <= 0) {
-        break;
+       break;
       }
     }
 
@@ -582,7 +587,7 @@ olsr_delete_revoked_tc_edges(struct tc_entry *tc, olsr_u16_t ansn,
       olsr_delete_tc_edge_entry(tc_edge);
       retval = 1;
     }
-  }OLSR_FOR_ALL_TC_EDGE_ENTRIES_END(tc, tc_edge);
+  } OLSR_FOR_ALL_TC_EDGE_ENTRIES_END(tc, tc_edge);
 
   return retval;
 }
@@ -599,7 +604,7 @@ olsr_delete_revoked_tc_edges(struct tc_entry *tc, olsr_u16_t ansn,
  */
 static int
 olsr_tc_update_edge(struct tc_entry *tc, olsr_u16_t ansn,
-                    const unsigned char **curr, union olsr_ip_addr *neighbor)
+                   const unsigned char **curr, union olsr_ip_addr *neighbor)
 {
   struct tc_edge_entry *tc_edge;
   int edge_change;
@@ -625,7 +630,7 @@ olsr_tc_update_edge(struct tc_entry *tc, olsr_u16_t ansn,
     }
 
     tc_edge = olsr_add_tc_edge_entry(tc, neighbor, ansn);
-    
+
     olsr_deserialize_tc_lq_pair(curr, tc_edge);
     edge_change = 1;
 
@@ -648,14 +653,13 @@ olsr_tc_update_edge(struct tc_entry *tc, olsr_u16_t ansn,
      */
     if (olsr_calc_tc_edge_entry_etx(tc_edge)) {
       if (tc->msg_hops <= olsr_cnf->lq_dlimit) {
-        edge_change = 1;
+       edge_change = 1;
       }
     }
-
 #if DEBUG
     if (edge_change) {
       OLSR_PRINTF(1, "TC:   chg edge entry %s\n",
-          olsr_tc_edge_to_string(tc_edge));
+                 olsr_tc_edge_to_string(tc_edge));
     }
 #endif
 
@@ -696,23 +700,25 @@ olsr_print_tc_table(void)
   struct tc_entry *tc;
   const int ipwidth = olsr_cnf->ip_version == AF_INET ? 15 : 30;
 
-  OLSR_PRINTF(1, "\n--- %s ------------------------------------------------- TOPOLOGY\n\n"
-      "%-*s %-*s %-14s  %s\n",
-      olsr_wallclock_string(),
-      ipwidth, "Source IP addr", ipwidth, "Dest IP addr", "      LQ      ", "ETX");
+  OLSR_PRINTF(1,
+             "\n--- %s ------------------------------------------------- TOPOLOGY\n\n"
+             "%-*s %-*s %-14s  %s\n", olsr_wallclock_string(), ipwidth,
+             "Source IP addr", ipwidth, "Dest IP addr", "      LQ      ",
+             "ETX");
 
   OLSR_FOR_ALL_TC_ENTRIES(tc) {
     struct tc_edge_entry *tc_edge;
     OLSR_FOR_ALL_TC_EDGE_ENTRIES(tc, tc_edge) {
       struct ipaddr_str addrbuf, dstaddrbuf;
       struct lqtextbuffer lqbuffer1, lqbuffer2;
-      
+
       OLSR_PRINTF(1, "%-*s %-*s %-14s %s\n",
-                  ipwidth, olsr_ip_to_string(&addrbuf, &tc->addr),
-                  ipwidth, olsr_ip_to_string(&dstaddrbuf, &tc_edge->T_dest_addr),
-                  get_tc_edge_entry_text(tc_edge, &lqbuffer1),
-                  get_linkcost_text(tc_edge->cost, OLSR_FALSE, &lqbuffer2));
-      
+                 ipwidth, olsr_ip_to_string(&addrbuf, &tc->addr),
+                 ipwidth, olsr_ip_to_string(&dstaddrbuf,
+                                            &tc_edge->T_dest_addr),
+                 get_tc_edge_entry_text(tc_edge, &lqbuffer1),
+                 get_linkcost_text(tc_edge->cost, OLSR_FALSE, &lqbuffer2));
+
     } OLSR_FOR_ALL_TC_EDGE_ENTRIES_END(tc, tc_edge);
   } OLSR_FOR_ALL_TC_ENTRIES_END(tc);
 #endif
@@ -728,22 +734,27 @@ olsr_print_tc_table(void)
  * @result 1 if lower/upper border ip have been set 
  */
 static int
-olsr_calculate_tc_border(olsr_u8_t lower_border, union olsr_ip_addr *lower_border_ip,
-    olsr_u8_t upper_border, union olsr_ip_addr *upper_border_ip) {
+olsr_calculate_tc_border(olsr_u8_t lower_border,
+                        union olsr_ip_addr *lower_border_ip,
+                        olsr_u8_t upper_border,
+                        union olsr_ip_addr *upper_border_ip)
+{
   if (lower_border == 0 && upper_border == 0) {
     return 0;
-  } 
+  }
   if (lower_border == 0xff) {
     memset(&lower_border_ip, 0, sizeof(lower_border_ip));
   } else {
     int i;
-    
+
     lower_border--;
-    for (i=0; i<lower_border/8; i++) {
+    for (i = 0; i < lower_border / 8; i++) {
       lower_border_ip->v6.in6_u.u6_addr8[olsr_cnf->ipsize - i - 1] = 0;
     }
-    lower_border_ip->v6.in6_u.u6_addr8[olsr_cnf->ipsize - lower_border/8 - 1] &= (0xff << (lower_border & 7));
-    lower_border_ip->v6.in6_u.u6_addr8[olsr_cnf->ipsize - lower_border/8 - 1] |= (1 << (lower_border & 7));
+    lower_border_ip->v6.in6_u.u6_addr8[olsr_cnf->ipsize - lower_border / 8 -
+                                      1] &= (0xff << (lower_border & 7));
+    lower_border_ip->v6.in6_u.u6_addr8[olsr_cnf->ipsize - lower_border / 8 -
+                                      1] |= (1 << (lower_border & 7));
   }
 
   if (upper_border == 0xff) {
@@ -753,11 +764,13 @@ olsr_calculate_tc_border(olsr_u8_t lower_border, union olsr_ip_addr *lower_borde
 
     upper_border--;
 
-    for (i=0; i<upper_border/8; i++) {
+    for (i = 0; i < upper_border / 8; i++) {
       upper_border_ip->v6.in6_u.u6_addr8[olsr_cnf->ipsize - i - 1] = 0;
     }
-    upper_border_ip->v6.in6_u.u6_addr8[olsr_cnf->ipsize - upper_border/8 - 1] &= (0xff << (upper_border & 7));
-    upper_border_ip->v6.in6_u.u6_addr8[olsr_cnf->ipsize - upper_border/8 - 1] |= (1 << (upper_border & 7));
+    upper_border_ip->v6.in6_u.u6_addr8[olsr_cnf->ipsize - upper_border / 8 -
+                                      1] &= (0xff << (upper_border & 7));
+    upper_border_ip->v6.in6_u.u6_addr8[olsr_cnf->ipsize - upper_border / 8 -
+                                      1] |= (1 << (upper_border & 7));
   }
   return 1;
 }
@@ -774,10 +787,10 @@ olsr_calculate_tc_border(olsr_u8_t lower_border, union olsr_ip_addr *lower_borde
  */
 void
 olsr_input_tc(union olsr_message *msg,
-              struct interface *input_if __attribute__((unused)),
-              union olsr_ip_addr *from_addr)
+             struct interface *input_if __attribute__ ((unused)),
+             union olsr_ip_addr *from_addr)
 {
-#ifndef NODEBUG 
+#ifndef NODEBUG
   struct ipaddr_str buf;
 #endif
   olsr_u16_t size, msg_seq, ansn;
@@ -814,48 +827,51 @@ olsr_input_tc(union olsr_message *msg,
   pkt_get_u16(&curr, &msg_seq);
   pkt_get_u16(&curr, &ansn);
 
-  /* get borders */
+  /* Get borders */
   pkt_get_u8(&curr, &lower_border);
   pkt_get_u8(&curr, &upper_border);
 
   tc = olsr_lookup_tc_entry(&originator);
 
   if (tc && 0 != tc->edge_tree.count) {
-    if (olsr_seq_inrange_high(
-          (int)tc->msg_seq - TC_SEQNO_WINDOW,
-          tc->msg_seq,
-          msg_seq) &&
-        olsr_seq_inrange_high(
-          (int)tc->ansn - TC_ANSN_WINDOW,
-          tc->ansn, ansn)) {
+    if (olsr_seq_inrange_high((int)tc->msg_seq - TC_SEQNO_WINDOW,
+                             tc->msg_seq,
+                             msg_seq) &&
+       olsr_seq_inrange_high((int)tc->ansn - TC_ANSN_WINDOW, tc->ansn, ansn)) {
 
       /*
        * Ignore already seen seq/ansn values (small window for mesh memory)
        */
       if ((tc->msg_seq == msg_seq) || (tc->ignored++ < 32)) {
-        return;
+       return;
       }
 
       OLSR_PRINTF(1, "Ignored to much LQTC's for %s, restarting\n",
-          olsr_ip_to_string(&buf, &originator));
+                 olsr_ip_to_string(&buf, &originator));
 
-    } else if (!olsr_seq_inrange_high(tc->msg_seq, (int)tc->msg_seq + TC_SEQNO_WINDOW * TC_SEQNO_WINDOW_MULT, msg_seq)
-        || !olsr_seq_inrange_low(tc->ansn, (int)tc->ansn + TC_ANSN_WINDOW * TC_ANSN_WINDOW_MULT, ansn)) {
+    } else
+      if (!olsr_seq_inrange_high
+         (tc->msg_seq,
+          (int)tc->msg_seq + TC_SEQNO_WINDOW * TC_SEQNO_WINDOW_MULT, msg_seq)
+         || !olsr_seq_inrange_low(tc->ansn,
+                                  (int)tc->ansn +
+                                  TC_ANSN_WINDOW * TC_ANSN_WINDOW_MULT,
+                                  ansn)) {
 
       /*
        * Only accept future seq/ansn values (large window for node reconnects).
        * Restart in all other cases. Ignore a single stray message.
        */
       if (!tc->err_seq_valid) {
-        tc->err_seq = msg_seq;
-        tc->err_seq_valid = OLSR_TRUE;
+       tc->err_seq = msg_seq;
+       tc->err_seq_valid = OLSR_TRUE;
       }
       if (tc->err_seq == msg_seq) {
-        return;
+       return;
       }
 
       OLSR_PRINTF(2, "Detected node restart for %s\n",
-          olsr_ip_to_string(&buf, &originator));
+                 olsr_ip_to_string(&buf, &originator));
     }
   }
 
@@ -882,12 +898,12 @@ olsr_input_tc(union olsr_message *msg,
    */
   if (check_neighbor_link(from_addr) != SYM_LINK) {
     OLSR_PRINTF(2, "Received TC from NON SYM neighbor %s\n",
-        olsr_ip_to_string(&buf, from_addr));
+               olsr_ip_to_string(&buf, from_addr));
     return;
   }
 
   OLSR_PRINTF(1, "Processing TC from %s, seq 0x%04x\n",
-      olsr_ip_to_string(&buf, &originator), ansn);
+             olsr_ip_to_string(&buf, &originator), ansn);
 
   /*
    * Now walk the edge advertisements contained in the packet.
@@ -906,34 +922,38 @@ olsr_input_tc(union olsr_message *msg,
     }
   }
 
-  /* calculate real border ips */
+  /*
+   * Calculate real border IPs.
+   */
   if (borderSet) {
-    borderSet = olsr_calculate_tc_border(lower_border, &lower_border_ip, upper_border, &upper_border_ip);
+    borderSet = olsr_calculate_tc_border(lower_border, &lower_border_ip,
+                                        upper_border, &upper_border_ip);
   }
-  
+
   /*
    * Set or change the expiration timer accordingly.
    */
   olsr_set_timer(&tc->validity_timer, vtime_s * MSEC_PER_SEC,
-                 OLSR_TC_VTIME_JITTER, OLSR_TIMER_ONESHOT,
-                 &olsr_expire_tc_entry, tc, tc_validity_timer_cookie->ci_id);
+                OLSR_TC_VTIME_JITTER, OLSR_TIMER_ONESHOT,
+                &olsr_expire_tc_entry, tc, tc_validity_timer_cookie->ci_id);
 
   if (borderSet) {
+
     /*
-     * delete all old tc edges within borders
+     * Delete all old tc edges within borders.
      */
     olsr_delete_revoked_tc_edges(tc, ansn, &lower_border_ip, &upper_border_ip);
-  }
-  else {
+  } else {
+
     /*
      * Kick the the edge garbage collection timer. In the meantime hopefully
      * all edges belonging to a multipart neighbor set will arrive.
      */
     olsr_set_timer(&tc->edge_gc_timer, OLSR_TC_EDGE_GC_TIME,
-                 OLSR_TC_EDGE_GC_JITTER, OLSR_TIMER_ONESHOT,
-                 &olsr_expire_tc_edge_gc, tc, tc_edge_gc_timer_cookie->ci_id);
+                  OLSR_TC_EDGE_GC_JITTER, OLSR_TIMER_ONESHOT,
+                  &olsr_expire_tc_edge_gc, tc, tc_edge_gc_timer_cookie->ci_id);
   }
-  
+
   /*
    * Last, flood the message to our other neighbors.
    */
index cca3a54..8bc7a21 100644 (file)
@@ -1,3 +1,4 @@
+
 /*
  * The olsr.org Optimized Link-State Routing daemon(olsrd)
  * Copyright (c) 2004, Andreas T√łnnesen(andreto@olsr.org)
  * The SPF calculation operates on these datasets.
  */
 
-struct tc_edge_entry
-{
-  struct avl_node    edge_node; /* edge_tree node in tc_entry */
-  union olsr_ip_addr T_dest_addr; /* edge_node key */
-  struct tc_edge_entry *edge_inv; /* shortcut, used during SPF calculation */
-  struct tc_entry    *tc; /* backpointer to owning tc entry */
-  olsr_linkcost      cost; /* metric used for SPF calculation */
-  olsr_u16_t         ansn; /* ansn of this edge, used for multipart msgs */
-  char               linkquality[0];
+struct tc_edge_entry {
+  struct avl_node edge_node;          /* edge_tree node in tc_entry */
+  union olsr_ip_addr T_dest_addr;      /* edge_node key */
+  struct tc_edge_entry *edge_inv;      /* shortcut, used during SPF calculation */
+  struct tc_entry *tc;                /* backpointer to owning tc entry */
+  olsr_linkcost cost;                 /* metric used for SPF calculation */
+  olsr_u16_t ansn;                    /* ansn of this edge, used for multipart msgs */
+  char linkquality[0];
 };
 
 AVLNODE2STRUCT(edge_tree2tc_edge, struct tc_edge_entry, edge_node);
 
-struct tc_entry
-{
-  struct avl_node    vertex_node; /* node keyed by ip address */
-  union olsr_ip_addr addr; /* vertex_node key */
-  struct avl_node    cand_tree_node; /* SPF candidate heap, node keyed by path_etx */
-  olsr_linkcost      path_cost; /* SPF calculated distance, cand_tree_node key */
-  struct list_node   path_list_node; /* SPF result list */
-  struct avl_tree    edge_tree; /* subtree for edges */
-  struct avl_tree    prefix_tree; /* subtree for prefixes */
-  struct link_entry  *next_hop; /* SPF calculated link to the 1st hop neighbor */
-  struct timer_entry *edge_gc_timer; /* used for edge garbage collection */
-  struct timer_entry *validity_timer; /* tc validity time */
-  olsr_u32_t         refcount; /* reference counter */
-  olsr_u16_t         msg_seq; /* sequence number of the tc message */
-  olsr_u8_t          msg_hops; /* hopcount as per the tc message */
-  olsr_u8_t          hops; /* SPF calculated hopcount */
-  olsr_u16_t         ansn; /* ANSN number of the tc message */
-  olsr_u16_t         ignored; /* how many TC messages ignored in a sequence (kindof emergency brake) */
-  olsr_u16_t         err_seq; /* sequence number of an unplausible TC */
-  olsr_bool          err_seq_valid; /* do we have an error (unplauible seq/ansn) */
+struct tc_entry {
+  struct avl_node vertex_node;        /* node keyed by ip address */
+  union olsr_ip_addr addr;            /* vertex_node key */
+  struct avl_node cand_tree_node;      /* SPF candidate heap, node keyed by path_etx */
+  olsr_linkcost path_cost;            /* SPF calculated distance, cand_tree_node key */
+  struct list_node path_list_node;     /* SPF result list */
+  struct avl_tree edge_tree;          /* subtree for edges */
+  struct avl_tree prefix_tree;        /* subtree for prefixes */
+  struct link_entry *next_hop;        /* SPF calculated link to the 1st hop neighbor */
+  struct timer_entry *edge_gc_timer;   /* used for edge garbage collection */
+  struct timer_entry *validity_timer;  /* tc validity time */
+  olsr_u32_t refcount;                /* reference counter */
+  olsr_u16_t msg_seq;                 /* sequence number of the tc message */
+  olsr_u8_t msg_hops;                 /* hopcount as per the tc message */
+  olsr_u8_t hops;                     /* SPF calculated hopcount */
+  olsr_u16_t ansn;                    /* ANSN number of the tc message */
+  olsr_u16_t ignored;                 /* how many TC messages ignored in a sequence
+                                          (kindof emergency brake) */
+  olsr_u16_t err_seq;                 /* sequence number of an unplausible TC */
+  olsr_bool err_seq_valid;            /* do we have an error (unplauible seq/ansn) */
 };
 
 /*
  * Garbage collection time for edges.
  * This is used for multipart messages.
  */
-#define OLSR_TC_EDGE_GC_TIME (2*1000) /* milliseconds */
-#define OLSR_TC_EDGE_GC_JITTER 5 /* percent */
+#define OLSR_TC_EDGE_GC_TIME (2*1000)  /* milliseconds */
+#define OLSR_TC_EDGE_GC_JITTER 5       /* percent */
 
-#define OLSR_TC_VTIME_JITTER 25 /* percent */
+#define OLSR_TC_VTIME_JITTER 25        /* percent */
 
 
 AVLNODE2STRUCT(vertex_tree2tc, struct tc_entry, vertex_node);
@@ -149,7 +149,7 @@ void olsr_time_out_tc_set(void);
 
 /* tc msg input parser */
 void olsr_input_tc(union olsr_message *, struct interface *,
-                   union olsr_ip_addr *from);
+                  union olsr_ip_addr *from);
 
 /* tc_entry manipulation */
 struct tc_entry *olsr_lookup_tc_entry(union olsr_ip_addr *);
@@ -161,9 +161,9 @@ void olsr_unlock_tc_entry(struct tc_entry *);
 olsr_bool olsr_delete_outdated_tc_edges(struct tc_entry *);
 char *olsr_tc_edge_to_string(struct tc_edge_entry *);
 struct tc_edge_entry *olsr_lookup_tc_edge(struct tc_entry *,
-                                          union olsr_ip_addr *);
+                                         union olsr_ip_addr *);
 struct tc_edge_entry *olsr_add_tc_edge_entry(struct tc_entry *,
-                                             union olsr_ip_addr *, olsr_u16_t);
+                                            union olsr_ip_addr *, olsr_u16_t);
 void olsr_delete_tc_entry(struct tc_entry *);
 void olsr_delete_tc_edge_entry(struct tc_edge_entry *);
 olsr_bool olsr_calc_tc_edge_entry_etx(struct tc_edge_entry *);