Another file moved; random interface stuff.

lib/Makefile.am

@@ -1,17 +1,17 @@
 ## Process this file with automake to produce Makefile.in
-# $Id: Makefile.am,v 1.7 2002/04/28 12:46:25 zarq Exp $
+# $Id: Makefile.am,v 1.8 2002/05/02 11:50:07 zarq Exp $
 
 noinst_LIBRARIES = libtinc.a
 
 INCLUDES = @INCLUDES@ -I. -I$(top_builddir) -I$(top_srcdir)/intl
 
 libtinc_a_SOURCES = xmalloc.c pidfile.c utils.c getopt.c getopt1.c	\
-	list.c avl_tree.c hooks.c dropin.c edge.c conf.c netutl.c logging.c connection.c subnet.c node.c
+	list.c avl_tree.c hooks.c dropin.c edge.c conf.c netutl.c logging.c connection.c subnet.c node.c graph.c
 
 libtinc_a_LIBADD = @LIBOBJS@ @ALLOCA@
 libtinc_a_DEPENDENCIES = $(libvpn_a_LIBADD)
 
 noinst_HEADERS = xalloc.h pidfile.h utils.h getopt.h list.h avl_tree.h	\
-	hooks.h dropin.h edge.h net.h conf.h netutl.h logging.h connection.h subnet.h node.h
+	hooks.h dropin.h edge.h net.h conf.h netutl.h logging.h connection.h subnet.h node.h graph.h
 
 EXTRA_DIST = README

lib/graph.c

@@ -0,0 +1,285 @@
+/*
+    graph.c -- graph algorithms
+    Copyright (C) 2001-2002 Guus Sliepen <guus@sliepen.warande.net>,
+                  2001-2002 Ivo Timmermans <itimmermans@bigfoot.com>
+
+    This program 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.
+
+    This program 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 this program; if not, write to the Free Software
+    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+
+    $Id: graph.c,v 1.1 2002/05/02 11:50:07 zarq Exp $
+*/
+
+/* We need to generate two trees from the graph:
+
+   1. A minimum spanning tree for broadcasts,
+   2. A single-source shortest path tree for unicasts.
+
+   Actually, the first one alone would suffice but would make unicast packets
+   take longer routes than necessary.
+
+   For the MST algorithm we can choose from Prim's or Kruskal's. I personally
+   favour Kruskal's, because we make an extra AVL tree of edges sorted on
+   weights (metric). That tree only has to be updated when an edge is added or
+   removed, and during the MST algorithm we just have go linearly through that
+   tree, adding safe edges until #edges = #nodes - 1. The implementation here
+   however is not so fast, because I tried to avoid having to make a forest and
+   merge trees.
+
+   For the SSSP algorithm Dijkstra's seems to be a nice choice. Currently a
+   simple breadth-first search is presented here.
+
+   The SSSP algorithm will also be used to determine whether nodes are directly,
+   indirectly or not reachable from the source. It will also set the correct
+   destination address and port of a node if possible.
+*/
+
+#include "config.h"
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#if defined(HAVE_FREEBSD) || defined(HAVE_OPENBSD)
+ #include <sys/param.h>
+#endif
+#include <netinet/in.h>
+
+#include <avl_tree.h>
+#include <hooks.h>
+#include <utils.h>
+
+#include "netutl.h"
+#include "node.h"
+#include "edge.h"
+#include "connection.h"
+#include "logging.h"
+
+#include "system.h"
+
+/* Implementation of Kruskal's algorithm.
+   Running time: O(EN)
+   Please note that sorting on weight is already done by add_edge().
+*/
+
+void mst_kruskal(void)
+{
+  avl_node_t *node, *next;
+  edge_t *e;
+  node_t *n;
+  connection_t *c;
+  int nodes = 0;
+  int safe_edges = 0;
+  int skipped;
+
+  /* Clear MST status on connections */
+
+  for(node = connection_tree->head; node; node = node->next)
+    {
+      c = (connection_t *)node->data;
+      c->status.mst = 0;
+    }
+
+  /* Do we have something to do at all? */
+  
+  if(!edge_weight_tree->head)
+    return;
+
+  if(debug_lvl >= DEBUG_SCARY_THINGS)
+    syslog(LOG_DEBUG, "Running Kruskal's algorithm:");
+
+  /* Clear visited status on nodes */
+
+  for(node = node_tree->head; node; node = node->next)
+    {
+      n = (node_t *)node->data;
+      n->status.visited = 0;
+      nodes++;
+    }
+
+  /* Starting point */
+  
+  ((edge_t *)edge_weight_tree->head->data)->from.node->status.visited = 1;
+
+  /* Add safe edges */
+
+  for(skipped = 0, node = edge_weight_tree->head; node; node = next)
+    {
+      next = node->next;
+      e = (edge_t *)node->data;
+
+      if(e->from.node->status.visited == e->to.node->status.visited)
+        {
+          skipped = 1;
+          continue;
+        }
+
+      e->from.node->status.visited = 1;
+      e->to.node->status.visited = 1;
+      if(e->connection)
+        e->connection->status.mst = 1;
+
+      safe_edges++;
+
+      if(debug_lvl >= DEBUG_SCARY_THINGS)
+	syslog(LOG_DEBUG, " Adding edge %s - %s weight %d", e->from.node->name, e->to.node->name, e->weight);
+
+      if(skipped)
+        {
+          next = edge_weight_tree->head;
+          continue;
+        }
+    }
+
+  if(debug_lvl >= DEBUG_SCARY_THINGS)
+    syslog(LOG_DEBUG, "Done, counted %d nodes and %d safe edges.", nodes, safe_edges);
+}
+
+/* Implementation of a simple breadth-first search algorithm.
+   Running time: O(E)
+*/
+
+void sssp_bfs(void)
+{
+  avl_node_t *node, *from, *next, *to;
+  edge_t *e;
+  node_t *n;
+  halfconnection_t to_hc, from_hc;
+  avl_tree_t *todo_tree;
+  int indirect;
+
+  todo_tree = avl_alloc_tree(NULL, NULL);
+
+  /* Clear visited status on nodes */
+
+  for(node = node_tree->head; node; node = node->next)
+    {
+      n = (node_t *)node->data;
+      n->status.visited = 0;
+      n->status.indirect = 1;
+    }
+
+  /* Begin with myself */
+
+  myself->status.visited = 1;
+  myself->status.indirect = 0;
+  myself->nexthop = myself;
+  myself->via = myself;
+  node = avl_alloc_node();
+  node->data = myself;
+  avl_insert_top(todo_tree, node);
+
+  /* Loop while todo_tree is filled */
+
+  while(todo_tree->head)
+    {
+      for(from = todo_tree->head; from; from = next)             /* "from" is the node from which we start */
+        {
+          next = from->next;
+          n = (node_t *)from->data;
+
+          for(to = n->edge_tree->head; to; to = to->next)        /* "to" is the edge connected to "from" */
+            {
+              e = (edge_t *)to->data;
+
+              if(e->from.node == n)                              /* "from_hc" is the halfconnection with .node == from */
+                to_hc = e->to, from_hc = e->from;
+              else
+                to_hc = e->from, from_hc = e->to;
+
+              /* Situation:
+
+	        	  /
+	        	 /
+		 ------(n)from_hc-----to_hc
+                	 \
+                	  \
+
+                 n->address is set to the to_hc.udpaddress of the edge left of n.
+		 We are currently examining the edge right of n:
+
+                 - If from_hc.udpaddress != n->address, then to_hc.node is probably
+		   not reachable for the nodes left of n. We do as if the indirectdata
+		   flag is set on edge e.
+		 - If edge e provides for better reachability of to_hc.node, update
+		   to_hc.node and (re)add it to the todo_tree to (re)examine the reachability
+		   of nodes behind it.
+	      */
+
+              indirect = n->status.indirect || e->options & OPTION_INDIRECT || ((n != myself) && sockaddrcmp(&n->address, &from_hc.udpaddress));
+
+              if(to_hc.node->status.visited && (!to_hc.node->status.indirect || indirect))
+	        continue;
+
+              to_hc.node->status.visited = 1;
+              to_hc.node->status.indirect = indirect;
+              to_hc.node->nexthop = (n->nexthop == myself) ? to_hc.node : n->nexthop;
+              to_hc.node->via = indirect ? n->via : to_hc.node;
+	      to_hc.node->options = e->options;
+              if(sockaddrcmp(&to_hc.node->address, &to_hc.udpaddress))
+	      {
+                node = avl_unlink(node_udp_tree, to_hc.node);
+                to_hc.node->address = to_hc.udpaddress;
+		if(to_hc.node->hostname)
+		  free(to_hc.node->hostname);
+		to_hc.node->hostname = sockaddr2hostname(&to_hc.udpaddress);
+                avl_insert_node(node_udp_tree, node);
+	      }
+              node = avl_alloc_node();
+              node->data = to_hc.node;
+              avl_insert_before(todo_tree, from, node);
+            }
+
+          avl_delete_node(todo_tree, from);
+        }
+    }
+
+  avl_free_tree(todo_tree);
+  
+  /* Check reachability status. */
+
+  for(node = node_tree->head; node; node = next)
+    {
+      next = node->next;
+      n = (node_t *)node->data;
+
+      if(n->status.visited)
+      {
+        if(!n->status.reachable)
+	{
+          if(debug_lvl >= DEBUG_TRAFFIC)
+            syslog(LOG_DEBUG, _("Node %s (%s) became reachable"), n->name, n->hostname);
+          n->status.reachable = 1;
+	  run_hooks("node-visible", n);
+	}
+      }
+      else
+      {
+        if(n->status.reachable)
+	{
+          if(debug_lvl >= DEBUG_TRAFFIC)
+            syslog(LOG_DEBUG, _("Node %s (%s) became unreachable"), n->name, n->hostname);
+          n->status.reachable = 0;
+	  n->status.validkey = 0;
+	  n->status.waitingforkey = 0;
+	  n->sent_seqno = 0;
+          run_hooks("node-invisible", n);
+	}
+      }
+    }
+}
+
+void graph(void)
+{
+  mst_kruskal();
+  sssp_bfs();
+}

lib/graph.h

@@ -0,0 +1,25 @@
+/*
+    graph.h -- header for graph.c
+    Copyright (C) 2001-2002 Guus Sliepen <guus@sliepen.warande.net>,
+                  2001-2002 Ivo Timmermans <itimmermans@bigfoot.com>
+
+    This program 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.
+
+    This program 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 this program; if not, write to the Free Software
+    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+
+    $Id: graph.h,v 1.1 2002/05/02 11:50:07 zarq Exp $
+*/
+
+extern void graph(void);
+extern void mst_kruskal(void);
+extern void sssp_bfs(void);

lib/hooks.c

@@ -0,0 +1,120 @@
+/*
+    hooks.c -- hooks management
+    Copyright (C) 2002 Guus Sliepen <guus@sliepen.warande.net>,
+                  2002 Ivo Timmermans <ivo@o2w.nl>
+
+    This program 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.
+
+    This program 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 this program; if not, write to the Free Software
+    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+
+    $Id: hooks.c,v 1.2 2002/05/02 11:50:07 zarq Exp $
+*/
+
+#include "config.h"
+
+#include <assert.h>
+#include <stdarg.h>
+#include <stdio.h>
+
+#include <avl_tree.h>
+#include <hooks.h>
+#include <xalloc.h>
+
+avl_tree_t *hooks_tree = NULL;
+
+struct hooks_node {
+  const char *type;
+  avl_tree_t *hooks;
+} hooks_node;
+
+static int hook_type_compare(const void *a, const void *b)
+{
+  return strcmp(((const struct hooks_node*)a)->type,
+		((const struct hooks_node*)b)->type);
+}
+
+static int hook_dummy_compare(const void *a, const void *b)
+{
+  if(a < b)
+    return -1;
+  if(a > b)
+    return 1;
+  return 0;
+}
+
+void run_hooks(const char *type, ...)
+{
+  avl_node_t *avlnode;
+  va_list args;
+  struct hooks_node *hn;
+  struct hooks_node target;
+
+  if(!hooks_tree)
+    return;
+  
+  target.type = type;
+  hn = (struct hooks_node*)avl_search(hooks_tree, &target);
+  if(!hn || !(hn->hooks->head))
+    {
+      fprintf(stderr, "Warning, no hooks found for `%s'\n", type);
+      return;
+    }
+
+  va_start(args, type);
+  for(avlnode = hn->hooks->head; avlnode; avlnode = avlnode->next)
+    {
+      assert(avlnode->data);
+      ((hook_function_t*)(avlnode->data))(type, args);
+    }
+  va_end(args);
+}
+
+void add_hook(const char *type, hook_function_t *hook)
+{
+  struct hooks_node *hn;
+  struct hooks_node target;
+  
+  if(!hooks_tree)
+    hooks_tree = avl_alloc_tree(hook_type_compare, NULL);
+
+  target.type = type;
+  hn = avl_search(hooks_tree, &target);
+  if(!hn)
+    {
+      avl_tree_t *t;
+      
+      hn = xmalloc(sizeof(struct hooks_node));
+      t = avl_alloc_tree(hook_dummy_compare, NULL);
+      hn->type = type;
+      hn->hooks = t;
+      avl_insert(hooks_tree, (void*)hn);
+    }
+
+  avl_insert(hn->hooks, (void*)hook);
+}
+
+void del_hook(const char *type, hook_function_t *hook)
+{
+  avl_tree_t *t;
+  struct hooks_node target;
+
+  if(!hooks_tree)
+    return;
+
+  target.type = type;
+  t = avl_search(hooks_tree, &target);
+  if(!t)
+    return;
+
+  avl_delete(t, (void*)hook);
+}

lib/node.h

@@ -17,13 +17,15 @@
     along with this program; if not, write to the Free Software
     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 
-    $Id: node.h,v 1.1 2002/04/28 12:46:26 zarq Exp $
+    $Id: node.h,v 1.2 2002/05/02 11:50:07 zarq Exp $
 */
 
 #ifndef __TINC_NODE_H__
 #define __TINC_NODE_H__
 
+#ifdef USE_GCRYPT
 #include <gcrypt.h>
+#endif
 
 #include <avl_tree.h>