2001-10-28 10:16:18 +00:00
|
|
|
/*
|
|
|
|
graph.c -- graph algorithms
|
2006-04-26 13:52:58 +00:00
|
|
|
Copyright (C) 2001-2006 Guus Sliepen <guus@tinc-vpn.org>,
|
|
|
|
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.
|
|
|
|
|
|
|
|
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.
|
|
|
|
|
2004-03-21 14:21:22 +00:00
|
|
|
$Id$
|
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
|
|
|
|
2003-07-17 15:06:27 +00:00
|
|
|
#include "avl_tree.h"
|
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"
|
2003-07-06 22:11:37 +00:00
|
|
|
#include "logger.h"
|
2003-07-17 15:06:27 +00:00
|
|
|
#include "netutl.h"
|
|
|
|
#include "node.h"
|
|
|
|
#include "process.h"
|
2004-12-01 20:06:39 +00:00
|
|
|
#include "subnet.h"
|
2003-07-17 15:06:27 +00:00
|
|
|
#include "utils.h"
|
2001-10-28 10:16:18 +00:00
|
|
|
|
2006-11-11 14:11:16 +00:00
|
|
|
static bool graph_changed = true;
|
|
|
|
|
2002-03-12 16:30:15 +00:00
|
|
|
/* Implementation of Kruskal's algorithm.
|
|
|
|
Running time: O(EN)
|
|
|
|
Please note that sorting on weight is already done by add_edge().
|
2001-10-28 10:16:18 +00:00
|
|
|
*/
|
|
|
|
|
2001-10-28 22:42:49 +00:00
|
|
|
void mst_kruskal(void)
|
2001-10-28 10:16:18 +00:00
|
|
|
{
|
2002-09-09 21:25:28 +00:00
|
|
|
avl_node_t *node, *next;
|
|
|
|
edge_t *e;
|
|
|
|
node_t *n;
|
|
|
|
connection_t *c;
|
|
|
|
int nodes = 0;
|
|
|
|
int safe_edges = 0;
|
2003-07-22 20:55:21 +00:00
|
|
|
bool skipped;
|
2002-09-09 21:25:28 +00:00
|
|
|
|
|
|
|
cp();
|
|
|
|
|
|
|
|
/* Clear MST status on connections */
|
|
|
|
|
|
|
|
for(node = connection_tree->head; node; node = node->next) {
|
2003-08-28 21:05:11 +00:00
|
|
|
c = node->data;
|
2003-07-22 20:55:21 +00:00
|
|
|
c->status.mst = false;
|
2002-09-09 21:25:28 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Do we have something to do at all? */
|
|
|
|
|
|
|
|
if(!edge_weight_tree->head)
|
|
|
|
return;
|
|
|
|
|
2003-07-12 17:41:48 +00:00
|
|
|
ifdebug(SCARY_THINGS) logger(LOG_DEBUG, "Running Kruskal's algorithm:");
|
2002-09-09 21:25:28 +00:00
|
|
|
|
|
|
|
/* Clear visited status on nodes */
|
|
|
|
|
|
|
|
for(node = node_tree->head; node; node = node->next) {
|
2003-08-28 21:05:11 +00:00
|
|
|
n = node->data;
|
2003-07-22 20:55:21 +00:00
|
|
|
n->status.visited = false;
|
2002-09-09 21:25:28 +00:00
|
|
|
nodes++;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Starting point */
|
|
|
|
|
2006-12-12 14:54:39 +00:00
|
|
|
for(node = edge_weight_tree->head; node; node = node->next) {
|
2006-12-12 14:49:09 +00:00
|
|
|
e = node->data;
|
|
|
|
if(e->from->status.reachable) {
|
|
|
|
e->from->status.visited = true;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
2002-09-09 21:25:28 +00:00
|
|
|
|
|
|
|
/* Add safe edges */
|
|
|
|
|
2003-07-22 20:55:21 +00:00
|
|
|
for(skipped = false, node = edge_weight_tree->head; node; node = next) {
|
2002-09-09 21:25:28 +00:00
|
|
|
next = node->next;
|
2003-08-28 21:05:11 +00:00
|
|
|
e = node->data;
|
2002-09-09 21:25:28 +00:00
|
|
|
|
|
|
|
if(!e->reverse || e->from->status.visited == e->to->status.visited) {
|
2003-07-22 20:55:21 +00:00
|
|
|
skipped = true;
|
2002-09-09 21:25:28 +00:00
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
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
|
|
|
|
|
|
|
safe_edges++;
|
|
|
|
|
2003-07-12 17:41:48 +00:00
|
|
|
ifdebug(SCARY_THINGS) logger(LOG_DEBUG, " Adding edge %s - %s weight %d", e->from->name,
|
2002-09-09 21:25:28 +00:00
|
|
|
e->to->name, e->weight);
|
|
|
|
|
|
|
|
if(skipped) {
|
2003-07-22 20:55:21 +00:00
|
|
|
skipped = false;
|
2002-09-09 21:25:28 +00:00
|
|
|
next = edge_weight_tree->head;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2003-07-12 17:41:48 +00:00
|
|
|
ifdebug(SCARY_THINGS) logger(LOG_DEBUG, "Done, counted %d nodes and %d safe edges.", nodes,
|
2002-09-09 21:25:28 +00:00
|
|
|
safe_edges);
|
2001-10-28 10:16:18 +00:00
|
|
|
}
|
2001-10-28 22:42:49 +00:00
|
|
|
|
|
|
|
/* Implementation of a simple breadth-first search algorithm.
|
|
|
|
Running time: O(E)
|
|
|
|
*/
|
|
|
|
|
2002-02-10 21:57:54 +00:00
|
|
|
void sssp_bfs(void)
|
2001-10-28 22:42:49 +00:00
|
|
|
{
|
2004-12-01 20:06:39 +00:00
|
|
|
avl_node_t *node, *next, *to;
|
2002-09-09 21:25:28 +00:00
|
|
|
edge_t *e;
|
|
|
|
node_t *n;
|
2004-12-01 20:06:39 +00:00
|
|
|
list_t *todo_list;
|
|
|
|
list_node_t *from, *todonext;
|
2003-07-22 20:55:21 +00:00
|
|
|
bool indirect;
|
2002-09-09 21:25:28 +00:00
|
|
|
char *name;
|
|
|
|
char *address, *port;
|
|
|
|
char *envp[7];
|
|
|
|
int i;
|
|
|
|
|
|
|
|
cp();
|
|
|
|
|
2004-12-01 20:06:39 +00:00
|
|
|
todo_list = list_alloc(NULL);
|
2002-09-09 21:25:28 +00:00
|
|
|
|
|
|
|
/* Clear visited status on nodes */
|
|
|
|
|
|
|
|
for(node = node_tree->head; node; node = node->next) {
|
2003-08-28 21:05:11 +00:00
|
|
|
n = node->data;
|
2003-07-22 20:55:21 +00:00
|
|
|
n->status.visited = false;
|
|
|
|
n->status.indirect = true;
|
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;
|
|
|
|
myself->via = myself;
|
2004-12-01 20:06:39 +00:00
|
|
|
list_insert_head(todo_list, myself);
|
|
|
|
|
|
|
|
/* Loop while todo_list is filled */
|
|
|
|
|
|
|
|
for(from = todo_list->head; from; from = todonext) { /* "from" is the node from which we start */
|
|
|
|
n = from->data;
|
|
|
|
|
|
|
|
for(to = n->edge_tree->head; to; to = to->next) { /* "to" is the edge connected to "from" */
|
|
|
|
e = to->data;
|
|
|
|
|
|
|
|
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 e->reverse->address != n->address, then e->to 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 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
|
|
|
|
2004-12-01 20:06:39 +00:00
|
|
|
indirect = n->status.indirect || e->options & OPTION_INDIRECT
|
|
|
|
|| ((n != myself) && sockaddrcmp(&n->address, &e->reverse->address));
|
|
|
|
|
|
|
|
if(e->to->status.visited
|
|
|
|
&& (!e->to->status.indirect || indirect))
|
|
|
|
continue;
|
|
|
|
|
|
|
|
e->to->status.visited = true;
|
|
|
|
e->to->status.indirect = indirect;
|
|
|
|
e->to->nexthop = (n->nexthop == myself) ? e->to : n->nexthop;
|
|
|
|
e->to->via = indirect ? n->via : e->to;
|
|
|
|
e->to->options = e->options;
|
|
|
|
|
|
|
|
if(sockaddrcmp(&e->to->address, &e->address)) {
|
|
|
|
node = avl_unlink(node_udp_tree, e->to);
|
|
|
|
sockaddrfree(&e->to->address);
|
|
|
|
sockaddrcpy(&e->to->address, &e->address);
|
|
|
|
|
|
|
|
if(e->to->hostname)
|
|
|
|
free(e->to->hostname);
|
|
|
|
|
|
|
|
e->to->hostname = sockaddr2hostname(&e->to->address);
|
2005-01-20 15:14:25 +00:00
|
|
|
|
|
|
|
if(node)
|
|
|
|
avl_insert_node(node_udp_tree, node);
|
2004-12-01 20:06:39 +00:00
|
|
|
|
|
|
|
if(e->to->options & OPTION_PMTU_DISCOVERY) {
|
|
|
|
e->to->mtuprobes = 0;
|
|
|
|
e->to->minmtu = 0;
|
|
|
|
e->to->maxmtu = MTU;
|
|
|
|
if(e->to->status.validkey)
|
|
|
|
send_mtu_probe(e->to);
|
|
|
|
}
|
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
|
|
|
|
|
|
|
todonext = from->next;
|
|
|
|
list_delete_node(todo_list, from);
|
2002-09-09 21:25:28 +00:00
|
|
|
}
|
|
|
|
|
2004-12-01 20:06:39 +00:00
|
|
|
list_free(todo_list);
|
2002-09-09 21:25:28 +00:00
|
|
|
|
|
|
|
/* Check reachability status. */
|
|
|
|
|
|
|
|
for(node = node_tree->head; node; node = next) {
|
|
|
|
next = node->next;
|
2003-08-28 21:05:11 +00:00
|
|
|
n = node->data;
|
2002-09-09 21:25:28 +00:00
|
|
|
|
|
|
|
if(n->status.visited != n->status.reachable) {
|
|
|
|
n->status.reachable = !n->status.reachable;
|
|
|
|
|
2003-07-12 17:41:48 +00:00
|
|
|
if(n->status.reachable) {
|
|
|
|
ifdebug(TRAFFIC) logger(LOG_DEBUG, _("Node %s (%s) became reachable"),
|
2003-07-06 22:11:37 +00:00
|
|
|
n->name, n->hostname);
|
2005-01-04 22:19:56 +00:00
|
|
|
avl_insert(node_udp_tree, n);
|
2003-07-12 17:41:48 +00:00
|
|
|
} else {
|
|
|
|
ifdebug(TRAFFIC) logger(LOG_DEBUG, _("Node %s (%s) became unreachable"),
|
2003-07-06 22:11:37 +00:00
|
|
|
n->name, n->hostname);
|
2005-01-04 22:19:56 +00:00
|
|
|
avl_delete(node_udp_tree, n);
|
2003-07-12 17:41:48 +00:00
|
|
|
}
|
2002-09-09 21:25:28 +00:00
|
|
|
|
2003-07-22 20:55:21 +00:00
|
|
|
n->status.validkey = false;
|
|
|
|
n->status.waitingforkey = false;
|
2002-09-09 21:25:28 +00:00
|
|
|
|
2003-12-22 11:04:17 +00:00
|
|
|
n->maxmtu = MTU;
|
|
|
|
n->minmtu = 0;
|
|
|
|
n->mtuprobes = 0;
|
|
|
|
|
2002-09-09 21:25:28 +00:00
|
|
|
asprintf(&envp[0], "NETNAME=%s", netname ? : "");
|
|
|
|
asprintf(&envp[1], "DEVICE=%s", device ? : "");
|
2003-07-18 13:45:06 +00:00
|
|
|
asprintf(&envp[2], "INTERFACE=%s", iface ? : "");
|
2002-09-09 21:25:28 +00:00
|
|
|
asprintf(&envp[3], "NODE=%s", n->name);
|
|
|
|
sockaddr2str(&n->address, &address, &port);
|
|
|
|
asprintf(&envp[4], "REMOTEADDRESS=%s", address);
|
|
|
|
asprintf(&envp[5], "REMOTEPORT=%s", port);
|
|
|
|
envp[6] = NULL;
|
|
|
|
|
2006-06-12 21:45:39 +00:00
|
|
|
execute_script(n->status.reachable ? "host-up" : "host-down", envp);
|
|
|
|
|
2002-09-09 21:25:28 +00:00
|
|
|
asprintf(&name,
|
|
|
|
n->status.reachable ? "hosts/%s-up" : "hosts/%s-down",
|
|
|
|
n->name);
|
|
|
|
execute_script(name, envp);
|
|
|
|
|
|
|
|
free(name);
|
|
|
|
free(address);
|
|
|
|
free(port);
|
|
|
|
|
2004-12-01 20:06:39 +00:00
|
|
|
for(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);
|
2002-09-09 21:25:28 +00:00
|
|
|
}
|
|
|
|
}
|
2002-02-10 21:57:54 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void graph(void)
|
|
|
|
{
|
2002-09-09 21:25:28 +00:00
|
|
|
sssp_bfs();
|
2006-12-12 14:49:09 +00:00
|
|
|
mst_kruskal();
|
2006-11-11 14:11:16 +00:00
|
|
|
graph_changed = true;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/* Dump nodes and edges to a graphviz file.
|
|
|
|
|
|
|
|
The file can be converted to an image with
|
|
|
|
dot -Tpng graph_filename -o image_filename.png -Gconcentrate=true
|
|
|
|
*/
|
|
|
|
|
|
|
|
void dump_graph(void)
|
|
|
|
{
|
|
|
|
avl_node_t *node;
|
|
|
|
node_t *n;
|
|
|
|
edge_t *e;
|
|
|
|
char *filename = NULL, *tmpname = NULL;
|
|
|
|
FILE *file;
|
|
|
|
|
|
|
|
if(!graph_changed || !get_config_string(lookup_config(config_tree, "GraphDumpFile"), &filename))
|
|
|
|
return;
|
|
|
|
|
|
|
|
graph_changed = false;
|
|
|
|
|
|
|
|
ifdebug(PROTOCOL) logger(LOG_NOTICE, "Dumping graph");
|
|
|
|
|
|
|
|
if(filename[0] == '|') {
|
|
|
|
file = popen(filename + 1, "w");
|
|
|
|
} else {
|
|
|
|
asprintf(&tmpname, "%s.new", filename);
|
|
|
|
file = fopen(tmpname, "w");
|
|
|
|
}
|
|
|
|
|
|
|
|
if(!file) {
|
|
|
|
logger(LOG_ERR, "Unable to open graph dump file %s: %s", filename, strerror(errno));
|
|
|
|
free(tmpname);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
fprintf(file, "digraph {\n");
|
|
|
|
|
|
|
|
/* dump all nodes first */
|
|
|
|
for(node = node_tree->head; node; node = node->next) {
|
|
|
|
n = node->data;
|
|
|
|
fprintf(file, " %s [label = \"%s\"];\n", n->name, n->name);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* now dump all edges */
|
|
|
|
for(node = edge_weight_tree->head; node; node = node->next) {
|
|
|
|
e = node->data;
|
|
|
|
fprintf(file, " %s -> %s;\n", e->from->name, e->to->name);
|
|
|
|
}
|
|
|
|
|
|
|
|
fprintf(file, "}\n");
|
|
|
|
|
2006-11-11 14:37:03 +00:00
|
|
|
if(filename[0] == '|') {
|
|
|
|
pclose(file);
|
|
|
|
} else {
|
|
|
|
fclose(file);
|
2006-11-11 14:11:16 +00:00
|
|
|
rename(tmpname, filename);
|
|
|
|
free(tmpname);
|
|
|
|
}
|
2001-10-28 22:42:49 +00:00
|
|
|
}
|