2001-10-28 10:16:18 +00:00
|
|
|
/*
|
|
|
|
graph.c -- graph algorithms
|
2013-01-20 20:03:22 +00:00
|
|
|
Copyright (C) 2001-2013 Guus Sliepen <guus@tinc-vpn.org>,
|
2006-04-26 13:52:58 +00:00
|
|
|
2001-2005 Ivo Timmermans
|
2001-10-28 10:16:18 +00:00
|
|
|
|
|
|
|
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.
|
|
|
|
|
2009-09-24 22:01:00 +00:00
|
|
|
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.,
|
|
|
|
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
|
2001-10-28 10:16:18 +00:00
|
|
|
*/
|
|
|
|
|
|
|
|
/* 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.
|
2001-10-29 13:14:57 +00:00
|
|
|
|
2001-10-28 10:16:18 +00:00
|
|
|
Actually, the first one alone would suffice but would make unicast packets
|
|
|
|
take longer routes than necessary.
|
2001-10-29 13:14:57 +00:00
|
|
|
|
2001-10-28 10:16:18 +00:00
|
|
|
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
|
2002-03-12 16:30:15 +00:00
|
|
|
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.
|
2001-10-28 10:16:18 +00:00
|
|
|
|
2001-10-28 22:42:49 +00:00
|
|
|
For the SSSP algorithm Dijkstra's seems to be a nice choice. Currently a
|
|
|
|
simple breadth-first search is presented here.
|
2002-02-10 21:57:54 +00:00
|
|
|
|
|
|
|
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.
|
2001-10-28 10:16:18 +00:00
|
|
|
*/
|
|
|
|
|
2003-07-17 15:06:27 +00:00
|
|
|
#include "system.h"
|
2001-10-28 22:42:49 +00:00
|
|
|
|
2006-11-11 14:11:16 +00:00
|
|
|
#include "config.h"
|
2001-10-28 10:16:18 +00:00
|
|
|
#include "connection.h"
|
2002-07-10 11:27:06 +00:00
|
|
|
#include "device.h"
|
2003-07-17 15:06:27 +00:00
|
|
|
#include "edge.h"
|
2011-05-28 21:36:52 +00:00
|
|
|
#include "graph.h"
|
2012-10-07 19:59:53 +00:00
|
|
|
#include "list.h"
|
2003-07-06 22:11:37 +00:00
|
|
|
#include "logger.h"
|
2013-01-17 15:39:02 +00:00
|
|
|
#include "names.h"
|
2003-07-17 15:06:27 +00:00
|
|
|
#include "netutl.h"
|
|
|
|
#include "node.h"
|
|
|
|
#include "process.h"
|
2010-02-02 00:02:40 +00:00
|
|
|
#include "protocol.h"
|
2004-12-01 20:06:39 +00:00
|
|
|
#include "subnet.h"
|
2003-07-17 15:06:27 +00:00
|
|
|
#include "utils.h"
|
2009-09-08 16:18:36 +00:00
|
|
|
#include "xalloc.h"
|
2011-05-28 01:56:06 +00:00
|
|
|
#include "graph.h"
|
2001-10-28 10:16:18 +00:00
|
|
|
|
2002-03-12 16:30:15 +00:00
|
|
|
/* Implementation of Kruskal's algorithm.
|
2013-01-17 10:21:18 +00:00
|
|
|
Running time: O(EN)
|
2002-03-12 16:30:15 +00:00
|
|
|
Please note that sorting on weight is already done by add_edge().
|
2001-10-28 10:16:18 +00:00
|
|
|
*/
|
|
|
|
|
2012-02-25 22:03:09 +00:00
|
|
|
static void mst_kruskal(void) {
|
2002-09-09 21:25:28 +00:00
|
|
|
/* Clear MST status on connections */
|
|
|
|
|
2012-10-07 22:35:38 +00:00
|
|
|
for list_each(connection_t, c, connection_list)
|
2003-07-22 20:55:21 +00:00
|
|
|
c->status.mst = false;
|
2002-09-09 21:25:28 +00:00
|
|
|
|
2012-02-26 17:37:36 +00:00
|
|
|
logger(DEBUG_SCARY_THINGS, LOG_DEBUG, "Running Kruskal's algorithm:");
|
2002-09-09 21:25:28 +00:00
|
|
|
|
|
|
|
/* Clear visited status on nodes */
|
|
|
|
|
2012-10-07 22:35:38 +00:00
|
|
|
for splay_each(node_t, n, node_tree)
|
2003-07-22 20:55:21 +00:00
|
|
|
n->status.visited = false;
|
2002-09-09 21:25:28 +00:00
|
|
|
|
2013-01-17 10:21:18 +00:00
|
|
|
/* Starting point */
|
|
|
|
|
|
|
|
for splay_each(edge_t, e, edge_weight_tree) {
|
|
|
|
if(e->from->status.reachable) {
|
|
|
|
e->from->status.visited = true;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2002-09-09 21:25:28 +00:00
|
|
|
/* Add safe edges */
|
|
|
|
|
2013-01-17 10:21:18 +00:00
|
|
|
bool skipped = false;
|
|
|
|
|
2012-10-07 22:35:38 +00:00
|
|
|
for splay_each(edge_t, e, edge_weight_tree) {
|
2013-01-17 10:21:18 +00:00
|
|
|
if(!e->reverse || (e->from->status.visited == e->to->status.visited)) {
|
|
|
|
skipped = true;
|
2002-09-09 21:25:28 +00:00
|
|
|
continue;
|
2013-01-17 10:21:18 +00:00
|
|
|
}
|
2002-09-09 21:25:28 +00:00
|
|
|
|
2003-07-22 20:55:21 +00:00
|
|
|
e->from->status.visited = true;
|
|
|
|
e->to->status.visited = true;
|
2002-09-09 21:25:28 +00:00
|
|
|
|
|
|
|
if(e->connection)
|
2003-07-22 20:55:21 +00:00
|
|
|
e->connection->status.mst = true;
|
2002-09-09 21:25:28 +00:00
|
|
|
|
|
|
|
if(e->reverse->connection)
|
2003-07-22 20:55:21 +00:00
|
|
|
e->reverse->connection->status.mst = true;
|
2002-09-09 21:25:28 +00:00
|
|
|
|
2013-01-17 10:21:18 +00:00
|
|
|
logger(DEBUG_SCARY_THINGS, LOG_DEBUG, " Adding edge %s - %s weight %d", e->from->name, e->to->name, e->weight);
|
|
|
|
|
|
|
|
if(skipped) {
|
|
|
|
skipped = false;
|
|
|
|
next = edge_weight_tree->head;
|
|
|
|
}
|
2008-12-11 18:07:26 +00:00
|
|
|
}
|
|
|
|
}
|
2002-09-09 21:25:28 +00:00
|
|
|
|
2001-10-28 22:42:49 +00:00
|
|
|
/* Implementation of a simple breadth-first search algorithm.
|
|
|
|
Running time: O(E)
|
|
|
|
*/
|
|
|
|
|
2012-02-25 22:03:09 +00:00
|
|
|
static void sssp_bfs(void) {
|
2012-10-07 22:35:38 +00:00
|
|
|
list_t *todo_list = list_alloc(NULL);
|
2002-09-09 21:25:28 +00:00
|
|
|
|
|
|
|
/* Clear visited status on nodes */
|
|
|
|
|
2012-10-07 22:35:38 +00:00
|
|
|
for splay_each(node_t, n, node_tree) {
|
2003-07-22 20:55:21 +00:00
|
|
|
n->status.visited = false;
|
|
|
|
n->status.indirect = true;
|
2012-07-20 18:35:07 +00:00
|
|
|
n->distance = -1;
|
2002-09-09 21:25:28 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Begin with myself */
|
|
|
|
|
2003-07-22 20:55:21 +00:00
|
|
|
myself->status.visited = true;
|
|
|
|
myself->status.indirect = false;
|
2002-09-09 21:25:28 +00:00
|
|
|
myself->nexthop = myself;
|
2012-02-22 22:17:43 +00:00
|
|
|
myself->prevedge = NULL;
|
2002-09-09 21:25:28 +00:00
|
|
|
myself->via = myself;
|
2012-07-20 18:35:07 +00:00
|
|
|
myself->distance = 0;
|
2004-12-01 20:06:39 +00:00
|
|
|
list_insert_head(todo_list, myself);
|
|
|
|
|
|
|
|
/* Loop while todo_list is filled */
|
|
|
|
|
2012-10-10 15:17:49 +00:00
|
|
|
for list_each(node_t, n, todo_list) { /* "n" is the node from which we start */
|
2012-10-07 22:35:38 +00:00
|
|
|
logger(DEBUG_SCARY_THINGS, LOG_DEBUG, " Examining edges from %s", n->name);
|
|
|
|
|
2012-07-20 18:35:07 +00:00
|
|
|
if(n->distance < 0)
|
|
|
|
abort();
|
2004-12-01 20:06:39 +00:00
|
|
|
|
2012-10-10 15:17:49 +00:00
|
|
|
for splay_each(edge_t, e, n->edge_tree) { /* "e" is the edge connected to "from" */
|
2004-12-01 20:06:39 +00:00
|
|
|
if(!e->reverse)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
/* Situation:
|
|
|
|
|
|
|
|
/
|
|
|
|
/
|
|
|
|
----->(n)---e-->(e->to)
|
|
|
|
\
|
|
|
|
\
|
|
|
|
|
|
|
|
Where e is an edge, (n) and (e->to) are nodes.
|
|
|
|
n->address is set to the e->address of the edge left of n to n.
|
|
|
|
We are currently examining the edge e right of n from n:
|
|
|
|
|
|
|
|
- If edge e provides for better reachability of e->to, update
|
|
|
|
e->to and (re)add it to the todo_list to (re)examine the reachability
|
|
|
|
of nodes behind it.
|
|
|
|
*/
|
2002-09-09 21:25:28 +00:00
|
|
|
|
2012-10-07 22:35:38 +00:00
|
|
|
bool indirect = n->status.indirect || e->options & OPTION_INDIRECT;
|
2004-12-01 20:06:39 +00:00
|
|
|
|
|
|
|
if(e->to->status.visited
|
2012-07-20 18:35:07 +00:00
|
|
|
&& (!e->to->status.indirect || indirect)
|
|
|
|
&& (e->to->distance != n->distance + 1 || e->weight >= e->to->prevedge->weight))
|
2004-12-01 20:06:39 +00:00
|
|
|
continue;
|
|
|
|
|
|
|
|
e->to->status.visited = true;
|
|
|
|
e->to->status.indirect = indirect;
|
|
|
|
e->to->nexthop = (n->nexthop == myself) ? e->to : n->nexthop;
|
2012-02-22 22:17:43 +00:00
|
|
|
e->to->prevedge = e;
|
2004-12-01 20:06:39 +00:00
|
|
|
e->to->via = indirect ? n->via : e->to;
|
|
|
|
e->to->options = e->options;
|
2012-07-20 18:35:07 +00:00
|
|
|
e->to->distance = n->distance + 1;
|
2004-12-01 20:06:39 +00:00
|
|
|
|
2012-10-07 22:35:38 +00:00
|
|
|
if(!e->to->status.reachable || (e->to->address.sa.sa_family == AF_UNSPEC && e->address.sa.sa_family != AF_UNKNOWN))
|
2009-04-02 23:05:23 +00:00
|
|
|
update_node_udp(e->to, &e->address);
|
2002-09-09 21:25:28 +00:00
|
|
|
|
2004-12-01 20:06:39 +00:00
|
|
|
list_insert_tail(todo_list, e->to);
|
2002-09-09 21:25:28 +00:00
|
|
|
}
|
2004-12-01 20:06:39 +00:00
|
|
|
|
2012-10-07 22:35:38 +00:00
|
|
|
next = node->next; /* Because the list_insert_tail() above could have added something extra for us! */
|
|
|
|
list_delete_node(todo_list, node);
|
2002-09-09 21:25:28 +00:00
|
|
|
}
|
|
|
|
|
2004-12-01 20:06:39 +00:00
|
|
|
list_free(todo_list);
|
2008-12-11 18:07:26 +00:00
|
|
|
}
|
|
|
|
|
2011-05-28 01:57:20 +00:00
|
|
|
static void check_reachability(void) {
|
2002-09-09 21:25:28 +00:00
|
|
|
/* Check reachability status. */
|
|
|
|
|
2012-10-07 22:35:38 +00:00
|
|
|
for splay_each(node_t, n, node_tree) {
|
2002-09-09 21:25:28 +00:00
|
|
|
if(n->status.visited != n->status.reachable) {
|
|
|
|
n->status.reachable = !n->status.reachable;
|
2013-03-08 13:11:15 +00:00
|
|
|
n->last_state_change = now.tv_sec;
|
2002-09-09 21:25:28 +00:00
|
|
|
|
2003-07-12 17:41:48 +00:00
|
|
|
if(n->status.reachable) {
|
2012-02-26 17:37:36 +00:00
|
|
|
logger(DEBUG_TRAFFIC, LOG_DEBUG, "Node %s (%s) became reachable",
|
2003-07-06 22:11:37 +00:00
|
|
|
n->name, n->hostname);
|
2003-07-12 17:41:48 +00:00
|
|
|
} else {
|
2012-02-26 17:37:36 +00:00
|
|
|
logger(DEBUG_TRAFFIC, LOG_DEBUG, "Node %s (%s) became unreachable",
|
2003-07-06 22:11:37 +00:00
|
|
|
n->name, n->hostname);
|
2003-07-12 17:41:48 +00:00
|
|
|
}
|
2002-09-09 21:25:28 +00:00
|
|
|
|
2012-07-31 19:43:49 +00:00
|
|
|
if(experimental && OPTION_VERSION(n->options) >= 2)
|
|
|
|
n->status.sptps = true;
|
|
|
|
|
2009-04-02 23:05:23 +00:00
|
|
|
/* TODO: only clear status.validkey if node is unreachable? */
|
|
|
|
|
2003-07-22 20:55:21 +00:00
|
|
|
n->status.validkey = false;
|
2012-10-07 11:31:19 +00:00
|
|
|
if(n->status.sptps) {
|
|
|
|
sptps_stop(&n->sptps);
|
|
|
|
n->status.waitingforkey = false;
|
|
|
|
}
|
2010-01-23 17:48:01 +00:00
|
|
|
n->last_req_key = 0;
|
2002-09-09 21:25:28 +00:00
|
|
|
|
2012-10-10 12:46:22 +00:00
|
|
|
n->status.udp_confirmed = false;
|
2003-12-22 11:04:17 +00:00
|
|
|
n->maxmtu = MTU;
|
|
|
|
n->minmtu = 0;
|
|
|
|
n->mtuprobes = 0;
|
|
|
|
|
2012-11-29 11:28:23 +00:00
|
|
|
timeout_del(&n->mtutimeout);
|
2009-06-11 17:07:54 +00:00
|
|
|
|
2012-10-07 22:35:38 +00:00
|
|
|
char *name;
|
|
|
|
char *address;
|
|
|
|
char *port;
|
|
|
|
char *envp[7];
|
|
|
|
|
2009-09-08 16:18:36 +00:00
|
|
|
xasprintf(&envp[0], "NETNAME=%s", netname ? : "");
|
|
|
|
xasprintf(&envp[1], "DEVICE=%s", device ? : "");
|
|
|
|
xasprintf(&envp[2], "INTERFACE=%s", iface ? : "");
|
|
|
|
xasprintf(&envp[3], "NODE=%s", n->name);
|
2002-09-09 21:25:28 +00:00
|
|
|
sockaddr2str(&n->address, &address, &port);
|
2009-09-08 16:18:36 +00:00
|
|
|
xasprintf(&envp[4], "REMOTEADDRESS=%s", address);
|
|
|
|
xasprintf(&envp[5], "REMOTEPORT=%s", port);
|
2002-09-09 21:25:28 +00:00
|
|
|
envp[6] = NULL;
|
|
|
|
|
2006-06-12 21:45:39 +00:00
|
|
|
execute_script(n->status.reachable ? "host-up" : "host-down", envp);
|
|
|
|
|
2012-10-07 22:35:38 +00:00
|
|
|
xasprintf(&name, n->status.reachable ? "hosts/%s-up" : "hosts/%s-down", n->name);
|
2002-09-09 21:25:28 +00:00
|
|
|
execute_script(name, envp);
|
|
|
|
|
|
|
|
free(name);
|
|
|
|
free(address);
|
|
|
|
free(port);
|
|
|
|
|
2012-10-07 22:35:38 +00:00
|
|
|
for(int i = 0; i < 6; i++)
|
2002-09-09 21:25:28 +00:00
|
|
|
free(envp[i]);
|
2004-12-01 20:06:39 +00:00
|
|
|
|
|
|
|
subnet_update(n, NULL, n->status.reachable);
|
2009-12-08 22:18:37 +00:00
|
|
|
|
2012-07-30 16:36:59 +00:00
|
|
|
if(!n->status.reachable) {
|
2009-12-08 22:18:37 +00:00
|
|
|
update_node_udp(n, NULL);
|
2012-10-11 20:21:30 +00:00
|
|
|
memset(&n->status, 0, sizeof n->status);
|
|
|
|
n->options = 0;
|
2012-07-30 16:36:59 +00:00
|
|
|
} else if(n->connection) {
|
2012-07-31 19:43:49 +00:00
|
|
|
if(n->status.sptps) {
|
2012-07-30 16:36:59 +00:00
|
|
|
if(n->connection->outgoing)
|
|
|
|
send_req_key(n);
|
|
|
|
} else {
|
|
|
|
send_ans_key(n);
|
|
|
|
}
|
|
|
|
}
|
2002-09-09 21:25:28 +00:00
|
|
|
}
|
|
|
|
}
|
2002-02-10 21:57:54 +00:00
|
|
|
}
|
|
|
|
|
2007-05-18 10:00:00 +00:00
|
|
|
void graph(void) {
|
2009-11-07 22:43:25 +00:00
|
|
|
subnet_cache_flush();
|
2012-02-25 22:03:09 +00:00
|
|
|
sssp_bfs();
|
2008-12-11 18:07:26 +00:00
|
|
|
check_reachability();
|
2007-05-17 21:14:30 +00:00
|
|
|
mst_kruskal();
|
|
|
|
}
|