Routing table creation based on LQ compiles. Not tested at all.
authorThomas Lopatic <thomas@lopatic.de>
Sun, 7 Nov 2004 17:51:20 +0000 (17:51 +0000)
committerThomas Lopatic <thomas@lopatic.de>
Sun, 7 Nov 2004 17:51:20 +0000 (17:51 +0000)
src/link_set.c
src/link_set.h
src/lq_list.c [new file with mode: 0644]
src/lq_list.h [new file with mode: 0644]
src/lq_route.c [new file with mode: 0644]
src/lq_route.h [new file with mode: 0644]
src/olsr.c
src/routing_table.c
src/routing_table.h
src/tc_set.h

index 1a6f24d..5158f28 100644 (file)
@@ -19,7 +19,7 @@
  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  * 
  * 
- * $Id: link_set.c,v 1.17 2004/11/05 20:58:09 tlopatic Exp $
+ * $Id: link_set.c,v 1.18 2004/11/07 17:51:20 tlopatic Exp $
  *
  */
 
@@ -1059,10 +1059,10 @@ static void olsr_time_out_packet_loss()
     }
 }
 
-float olsr_neighbor_best_link_quality(union olsr_ip_addr *main)
+double olsr_neighbor_best_link_quality(union olsr_ip_addr *main)
 {
   struct link_entry *walker;
-  float res = 0.0;
+  double res = 0.0;
 
   // loop through all links
 
@@ -1073,10 +1073,58 @@ float olsr_neighbor_best_link_quality(union olsr_ip_addr *main)
       // is better than what we have
 
       if(COMP_IP(&main, &walker->neighbor->neighbor_main_addr) &&
-         walker->loss_link_quality * walker->neigh_link_quality > res)
+         walker->loss_link_quality * walker->neigh_link_quality >= res)
         res = walker->loss_link_quality;
     }
 
   return res;
 }
+
+struct link_entry *olsr_neighbor_best_link(union olsr_ip_addr *main)
+{
+  struct link_entry *walker;
+  double best = 0.0;
+  struct link_entry *res = NULL;
+
+  // loop through all links
+
+  for (walker = link_set; walker != NULL; walker = walker->next)
+  {
+    // check whether it's a link to the requested neighbor and
+    // whether the link's quality is better than what we have
+
+    if(COMP_IP(&main, &walker->neighbor->neighbor_main_addr) &&
+       walker->neigh_link_quality >= best)
+    {
+      best = walker->loss_link_quality;
+      res = walker;
+    }
+  }
+
+  return res;
+}
+
+struct link_entry *olsr_neighbor_best_inverse_link(union olsr_ip_addr *main)
+{
+  struct link_entry *walker;
+  double best = 0.0;
+  struct link_entry *res = NULL;
+
+  // loop through all links
+
+  for (walker = link_set; walker != NULL; walker = walker->next)
+  {
+    // check whether it's a link to the requested neighbor and
+    // whether the link's quality is better than what we have
+
+    if(COMP_IP(&main, &walker->neighbor->neighbor_main_addr) &&
+       walker->loss_link_quality >= best)
+    {
+      best = walker->loss_link_quality;
+      res = walker;
+    }
+  }
+
+  return res;
+}
 #endif
index fa9cefd..b066d6d 100644 (file)
@@ -19,7 +19,7 @@
  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  * 
  * 
- * $Id: link_set.h,v 1.12 2004/11/05 20:58:09 tlopatic Exp $
+ * $Id: link_set.h,v 1.13 2004/11/07 17:51:20 tlopatic Exp $
  *
  */
 
@@ -127,7 +127,9 @@ void olsr_update_packet_loss_hello_int(struct link_entry *entry, double htime);
 void olsr_update_packet_loss(union olsr_ip_addr *rem, union olsr_ip_addr *loc,
                         olsr_u16_t seqno);
 void olsr_print_link_set(void);
-float olsr_neighbor_best_link_quality(union olsr_ip_addr *main);
+double olsr_neighbor_best_link_quality(union olsr_ip_addr *main);
+struct link_entry *olsr_neighbor_best_link(union olsr_ip_addr *main);
+struct link_entry *olsr_neighbor_best_inverse_link(union olsr_ip_addr *main);
 #endif
 
 #endif
diff --git a/src/lq_list.c b/src/lq_list.c
new file mode 100644 (file)
index 0000000..9b1ff6a
--- /dev/null
@@ -0,0 +1,127 @@
+/* 
+ * OLSR ad-hoc routing table management protocol
+ * Copyright (C) 2004 Thomas Lopatic (thomas@lopatic.de)
+ *
+ * This file is part of the olsr.org OLSR daemon.
+ *
+ * olsr.org is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * olsr.org is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with olsr.org; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ *
+ * $Id: lq_list.c,v 1.1 2004/11/07 17:51:20 tlopatic Exp $
+ *
+ */
+
+#if defined USE_LINK_QUALITY
+#include <stdlib.h>
+#include "lq_list.h"
+
+void list_init(struct list *list)
+{
+  list->head = NULL;
+  list->tail = NULL;
+}
+
+struct list_node *list_get_head(struct list *list)
+{
+  return list->head;
+}
+
+struct list_node *list_get_tail(struct list *list)
+{
+  return list->tail;
+}
+
+struct list_node *list_get_next(struct list_node *node)
+{
+  return node->next;
+}
+
+struct list_node *list_get_prev(struct list_node *node)
+{
+  return node->prev;
+}
+
+void list_add_head(struct list *list, struct list_node *node)
+{
+  if (list->head != NULL)
+    list->head->prev = node;
+
+  else
+    list->tail = node;
+
+  node->prev = NULL;
+  node->next = list->head;
+
+  list->head = node;
+}
+
+void list_add_tail(struct list *list, struct list_node *node)
+{
+  if (list->tail != NULL)
+    list->tail->next = node;
+
+  else
+    list->head = node;
+
+  node->prev = list->tail;
+  node->next = NULL;
+
+  list->tail = node;
+}
+
+void list_add_before(struct list *list, struct list_node *pos_node,
+                     struct list_node *node)
+{
+  if (pos_node->prev != NULL)
+    pos_node->prev->next = node;
+
+  else
+    list->head = node;
+
+  node->prev = pos_node->prev;
+  node->next = pos_node;
+
+  pos_node->prev = node;
+}
+
+void list_add_after(struct list *list, struct list_node *pos_node,
+                    struct list_node *node)
+{
+  if (pos_node->next != NULL)
+    pos_node->next->prev = node;
+
+  else
+    list->tail = node;
+
+  node->prev = pos_node;
+  node->next = pos_node->next;
+
+  pos_node->next = node;
+}
+
+void list_remove(struct list *list, struct list_node *node)
+{
+  if (node == list->head)
+    list->head = node->next;
+
+  else
+    node->prev->next = node->next;
+
+  if (node == list->tail)
+    list->tail = node->prev;
+
+  else
+    node->next->prev = node->prev;
+}
+#endif
diff --git a/src/lq_list.h b/src/lq_list.h
new file mode 100644 (file)
index 0000000..a1e4764
--- /dev/null
@@ -0,0 +1,55 @@
+/* 
+ * OLSR ad-hoc routing table management protocol
+ * Copyright (C) 2004 Thomas Lopatic (thomas@lopatic.de)
+ *
+ * This file is part of the olsr.org OLSR daemon.
+ *
+ * olsr.org is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * olsr.org is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with olsr.org; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ *
+ * $Id: lq_list.h,v 1.1 2004/11/07 17:51:20 tlopatic Exp $
+ *
+ */
+
+struct list_node
+{
+  struct list_node *next;
+  struct list_node *prev;
+
+  void *data;
+};
+
+struct list
+{
+  struct list_node *head;
+  struct list_node *tail;
+};
+
+void list_init(struct list *list);
+
+struct list_node *list_get_head(struct list *list);
+struct list_node *list_get_tail(struct list *list);
+
+struct list_node *list_get_next(struct list_node *node);
+struct list_node *list_get_prev(struct list_node *node);
+
+void list_add_head(struct list *list, struct list_node *node);
+void list_add_tail(struct list *list, struct list_node *node);
+
+void list_add_before(struct list *list, struct list_node *pos_node,
+                     struct list_node *node);
+void list_add_after(struct list *list, struct list_node *pos_node,
+                    struct list_node *node);
+
+void list_remove(struct list *list, struct list_node *node);
diff --git a/src/lq_route.c b/src/lq_route.c
new file mode 100644 (file)
index 0000000..4d751ca
--- /dev/null
@@ -0,0 +1,410 @@
+/* 
+ * OLSR ad-hoc routing table management protocol
+ * Copyright (C) 2004 Thomas Lopatic (thomas@lopatic.de)
+ *
+ * This file is part of the olsr.org OLSR daemon.
+ *
+ * olsr.org is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * olsr.org is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with olsr.org; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ *
+ * $Id: lq_route.c,v 1.1 2004/11/07 17:51:20 tlopatic Exp $
+ *
+ */
+
+#if defined USE_LINK_QUALITY
+#include "defs.h"
+#include "tc_set.h"
+#include "neighbor_table.h"
+#include "link_set.h"
+#include "routing_table.h"
+#include "lq_list.h"
+#include "lq_route.h"
+
+#define olsr_malloc(x, y) malloc(x)
+
+struct dijk_edge
+{
+  struct list_node node;
+  struct dijk_vertex *dest;
+  double link_quality;
+};
+
+struct dijk_vertex
+{
+  struct list_node node;
+  union olsr_ip_addr addr;
+  struct list edge_list;
+  double path_quality;
+  struct dijk_vertex *prev;
+  olsr_bool done;
+};
+
+// XXX - bad complexity
+
+static void add_vertex(struct list *vertex_list, union olsr_ip_addr *addr,
+                       double path_quality)
+{
+  struct list_node *node;
+  struct dijk_vertex *vert;
+
+  // see whether this destination is already in our list
+
+  node = list_get_head(vertex_list);
+
+  while (node != NULL)
+  {
+    vert = node->data;
+
+    if (COMP_IP(&vert->addr, addr))
+      break;
+
+    node = list_get_next(node);
+  }
+
+  // if it's not in our list, add it
+
+  if (node == NULL)
+  {
+    vert = olsr_malloc(sizeof (struct dijk_vertex), "Dijkstra vertex");
+
+    vert->node.data = vert;
+
+    COPY_IP(&vert->addr, addr);
+    
+    vert->path_quality = path_quality;
+    vert->prev = NULL;
+    vert->done = OLSR_FALSE;
+
+    list_init(&vert->edge_list);
+
+    list_add_tail(vertex_list, &vert->node);
+  }
+}
+
+// XXX - bad complexity
+
+static void add_edge(struct list *vertex_list, union olsr_ip_addr *src,
+                     union olsr_ip_addr *dst, double link_quality)
+{
+  struct list_node *node;
+  struct dijk_vertex *vert;
+  struct dijk_vertex *svert;
+  struct dijk_vertex *dvert;
+  struct dijk_edge *edge;
+
+  // source and destination lookup
+
+  node = list_get_head(vertex_list);
+
+  svert = NULL;
+  dvert = NULL;
+
+  while (node != NULL)
+  {
+    vert = node->data;
+
+    if (COMP_IP(&vert->addr, src))
+    {
+      svert = vert;
+
+      if (dvert != NULL)
+        break;
+    }
+
+    else if (COMP_IP(&vert->addr, dst))
+    {
+      dvert = vert;
+
+      if (svert != NULL)
+        break;
+    }
+
+    node = list_get_next(node);
+  }
+
+  // source or destination vertex does not exist
+
+  if (svert == NULL || dvert == NULL)
+    return;
+
+  node = list_get_head(&svert->edge_list);
+
+  while (node != NULL)
+  {
+    edge = node->data;
+
+    if (edge->dest == dvert)
+      break;
+
+    node = list_get_next(node);
+  }
+
+  // edge already exists
+
+  if (node != NULL)
+    return;
+
+  edge = olsr_malloc(sizeof (struct dijk_vertex), "Dijkstra edge");
+
+  edge->node.data = edge;
+
+  edge->dest = dvert;
+  edge->link_quality = link_quality;
+
+  list_add_tail(&svert->edge_list, &edge->node);
+}
+
+static void free_everything(struct list *vertex_list)
+{
+  struct list_node *vnode, *enode;
+  struct dijk_vertex *vert;
+  struct dijk_edge *edge;
+
+  vnode = list_get_head(vertex_list);
+
+  // loop through all vertices
+
+  while (vnode != NULL)
+  {
+    vert = vnode->data;
+
+    enode = list_get_head(&vert->edge_list);
+
+    // loop through all edges of the current vertex
+
+    while (enode != NULL)
+    {
+      edge = enode->data;
+
+      enode = list_get_next(enode);
+      free(edge);
+    }
+
+    vnode = list_get_next(vnode);
+    free(vert);
+  }
+}
+
+// XXX - bad complexity
+
+static struct dijk_vertex *extract_best(struct list *vertex_list)
+{
+  double best = 0.0;
+  struct list_node *node;
+  struct dijk_vertex *vert;
+  struct dijk_vertex *res = NULL;
+
+  node = list_get_head(vertex_list);
+
+  // loop through all vertices
+  
+  while (node != NULL)
+  {
+    vert = node->data;
+
+    // see whether the current vertex is better than what we have
+
+    if (!vert->done && vert->path_quality >= best)
+    {
+      best = vert->path_quality;
+      res = vert;
+    }
+
+    node = list_get_next(node);
+  }
+
+  // if we've found a vertex, remove it from the set
+
+  if (res != NULL)
+    res->done = OLSR_TRUE;
+
+  return res;
+}
+
+static void relax(struct dijk_vertex *vert)
+{
+  struct dijk_edge *edge;
+  double new_quality;
+  struct list_node *node;
+
+  node = list_get_head(&vert->edge_list);
+
+  // loop through all edges of this vertex
+
+  while (node != NULL)
+  {
+    edge = node->data;
+
+    // total quality of the path through this vertex to the
+    // destination of this edge
+
+    new_quality = vert->path_quality * edge->link_quality;
+
+    // if it's better than the current path quality of this
+    // edge's destination, then we've found a better path to
+    // this destination
+
+    if (new_quality > edge->dest->path_quality)
+    {
+      edge->dest->path_quality = new_quality;
+      edge->dest->prev = vert;
+    }
+
+    node = list_get_next(node);
+  }
+}
+
+void olsr_calculate_lq_routing_table(void)
+{
+  struct list vertex_list;
+  int i;
+  struct tc_entry *tcsrc;
+  struct topo_dst *tcdst;
+  struct dijk_vertex *vert;
+  struct link_entry *link;
+  struct neighbor_entry *neigh;
+  struct list_node *node;
+  struct dijk_vertex *myself;
+  struct dijk_vertex *walker;
+  int hops;
+
+  // initialize the graph
+
+  list_init(&vertex_list);
+
+  // add ourselves to the vertex list
+
+  add_vertex(&vertex_list, &main_addr, 1.0);
+
+  // add remaining vertices
+
+  for (i = 0; i < HASHSIZE; i++)
+    for (tcsrc = tc_table[i].next; tcsrc != &tc_table[i]; tcsrc = tcsrc->next)
+    {
+      // add source
+
+      add_vertex(&vertex_list, &tcsrc->T_last_addr, 0.0);
+
+      // add destinations of this source
+
+      for (tcdst = tcsrc->destinations.next; tcdst != &tcsrc->destinations;
+           tcdst = tcdst->next)
+        add_vertex(&vertex_list, &tcdst->T_dest_addr, 0.0);
+    }
+
+  // add edges to and from our neighbours
+
+  for (i = 0; i < HASHSIZE; i++)
+    for (neigh = neighbortable[i].next; neigh != &neighbortable[i];
+         neigh = neigh->next)
+      if (neigh->status == SYM)
+      {
+        link = olsr_neighbor_best_link(&neigh->neighbor_main_addr);
+
+        add_edge(&vertex_list, &main_addr, &neigh->neighbor_main_addr,
+                 link->neigh_link_quality);
+
+        link = olsr_neighbor_best_inverse_link(&neigh->neighbor_main_addr);
+
+        add_edge(&vertex_list, &main_addr, &neigh->neighbor_main_addr,
+                 link->loss_link_quality);
+      }
+
+  // add remaining edges
+
+  for (i = 0; i < HASHSIZE; i++)
+    for (tcsrc = tc_table[i].next; tcsrc != &tc_table[i]; tcsrc = tcsrc->next)
+      for (tcdst = tcsrc->destinations.next; tcdst != &tcsrc->destinations;
+           tcdst = tcdst->next)
+      {
+        add_edge(&vertex_list, &tcsrc->T_last_addr, &tcdst->T_dest_addr,
+                 tcdst->link_quality);
+
+        add_edge(&vertex_list, &tcdst->T_dest_addr, &tcsrc->T_last_addr,
+                 tcdst->inverse_link_quality);
+      }
+
+  // run Dijkstra's algorithm
+
+  for (;;)
+  {
+    vert = extract_best(&vertex_list);
+
+    if (vert == NULL)
+      break;
+
+    relax(vert);
+  }
+
+  // save the old routing table
+
+  olsr_move_route_table(routingtable, old_routes);
+
+  for (i = 0; i < 2; i++)
+  {
+    node = list_get_head(&vertex_list);
+
+    // we're the first vertex in the list
+
+    myself = node->data;
+
+    node = list_get_next(node);
+
+    // loop through the remaining vertices
+
+    while (node != NULL)
+    {
+      vert = node->data;
+
+      // one-hop neighbours go first
+
+      if (i == 0 && vert->prev == myself)
+        olsr_insert_routing_table(&vert->addr, &vert->addr, 1);
+
+      // add everybody else in the second pass
+
+      if (i == 1)
+      {
+        hops = 1;
+        walker = vert;
+
+        // count hops to until a one-hop neighbour is reached
+
+        while (walker->prev != myself)
+        {
+          hops++;
+          walker = walker->prev;
+        }
+
+        // add, if this is not a one-hop neighbour
+
+        if (hops > 1)
+          olsr_insert_routing_table(&vert->addr, &walker->addr, hops);
+      }
+    }
+  }
+
+  // free the graph
+
+  free_everything(&vertex_list);
+
+  // move the route changes into the kernel
+
+  olsr_update_kernel_routes();
+
+  // free the saved routing table
+
+  olsr_free_routing_table(old_routes);
+}
+#endif
diff --git a/src/lq_route.h b/src/lq_route.h
new file mode 100644 (file)
index 0000000..681173c
--- /dev/null
@@ -0,0 +1,25 @@
+/* 
+ * OLSR ad-hoc routing table management protocol
+ * Copyright (C) 2004 Thomas Lopatic (thomas@lopatic.de)
+ *
+ * This file is part of the olsr.org OLSR daemon.
+ *
+ * olsr.org is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * olsr.org is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with olsr.org; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ *
+ * $Id: lq_route.h,v 1.1 2004/11/07 17:51:20 tlopatic Exp $
+ *
+ */
+
+void olsr_calculate_lq_routing_table(void);
index 3d54d0d..032fca8 100644 (file)
@@ -19,7 +19,7 @@
  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  * 
  * 
- * $Id: olsr.c,v 1.17 2004/11/05 20:58:10 tlopatic Exp $
+ * $Id: olsr.c,v 1.18 2004/11/07 17:51:20 tlopatic Exp $
  *
  */
 
@@ -38,6 +38,7 @@
 #include "mpr.h"
 #if defined USE_LINK_QUALITY
 #include "lq_mpr.h"
+#include "lq_route.h"
 #endif
 #include "scheduler.h"
 #include "generate_msg.h"
@@ -168,10 +169,11 @@ olsr_process_changes()
       /* Calculate new mprs, HNA and routing table */
 #if !defined USE_LINK_QUALITY
       olsr_calculate_mpr();
+      olsr_calculate_routing_table();
 #else
       olsr_calculate_lq_mpr();
+      olsr_calculate_lq_routing_table();
 #endif
-      olsr_calculate_routing_table();
       olsr_calculate_hna_routes();
 
       goto process_pcf;  
@@ -180,7 +182,11 @@ olsr_process_changes()
   if(changes_topology)
     {
       /* calculate the routing table and HNA */
+#if !defined USE_LINK_QUALITY
       olsr_calculate_routing_table();
+#else
+      olsr_calculate_lq_routing_table();
+#endif
       olsr_calculate_hna_routes();
 
       goto process_pcf;  
index 4825c46..a687215 100644 (file)
@@ -19,7 +19,7 @@
  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  * 
  * 
- * $Id: routing_table.c,v 1.8 2004/10/18 13:13:37 kattemat Exp $
+ * $Id: routing_table.c,v 1.9 2004/11/07 17:51:20 tlopatic Exp $
  *
  */
 
@@ -38,9 +38,6 @@
  * Prototypes for internal functions 
  */
 
-static void
-olsr_free_routing_table(struct rt_entry *);
-
 static int
 olsr_fill_routing_table_with_neighbors(void);
 
@@ -54,9 +51,6 @@ static struct rt_entry *
 olsr_lookup_routing_table(union olsr_ip_addr *);
 
 struct rt_entry *
-olsr_insert_routing_table(union olsr_ip_addr *, union olsr_ip_addr *, int);
-
-struct rt_entry *
 olsr_check_for_lower_hopcount(struct rt_entry *, struct hna_net *, olsr_u16_t);
 
 /* End:
@@ -129,7 +123,7 @@ olsr_lookup_routing_table(union olsr_ip_addr *dst)
  *
  *@return nada
  */
-static void
+void
 olsr_free_routing_table(struct rt_entry *table)
 {
   struct rt_entry *destination;
index 16d657e..4da3df7 100644 (file)
@@ -19,7 +19,7 @@
  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  * 
  * 
- * $Id: routing_table.h,v 1.9 2004/11/05 02:06:14 tlopatic Exp $
+ * $Id: routing_table.h,v 1.10 2004/11/07 17:51:20 tlopatic Exp $
  *
  */
 
@@ -91,4 +91,10 @@ olsr_calculate_hna_routes(void);
 void
 olsr_print_routing_table(struct rt_entry *);
 
+struct rt_entry *
+olsr_insert_routing_table(union olsr_ip_addr *, union olsr_ip_addr *, int);
+
+void
+olsr_free_routing_table(struct rt_entry *);
+
 #endif
index 3b6fac4..a158077 100644 (file)
@@ -19,7 +19,7 @@
  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  * 
  * 
- * $Id: tc_set.h,v 1.6 2004/10/09 22:32:47 kattemat Exp $
+ * $Id: tc_set.h,v 1.7 2004/11/07 17:51:20 tlopatic Exp $
  *
  */
 
@@ -38,6 +38,10 @@ struct topo_dst
   olsr_u16_t T_seq;
   struct topo_dst *next;
   struct topo_dst *prev;
+#if defined USE_LINK_QUALITY
+  double link_quality;
+  double inverse_link_quality;
+#endif
 };