X-Git-Url: https://tinc-vpn.org/git/browse?a=blobdiff_plain;f=src%2Fgraph.c;h=73db3b2fddb46e05a15d2d61ed360584e6248246;hb=6bc5d626a8726fc23365ee705761a3c666a08ad4;hp=d1bd2ac34c908a8f9c569f4e92189e5f798f5e38;hpb=f75dcef72a81a337e847adf0bae54198894f65b9;p=tinc diff --git a/src/graph.c b/src/graph.c index d1bd2ac3..73db3b2f 100644 --- a/src/graph.c +++ b/src/graph.c @@ -1,7 +1,7 @@ /* graph.c -- graph algorithms - Copyright (C) 2001-2002 Guus Sliepen , - 2001-2002 Ivo Timmermans + Copyright (C) 2001-2012 Guus Sliepen , + 2001-2005 Ivo Timmermans 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 @@ -13,11 +13,9 @@ 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.2.19 2002/09/09 21:24:34 guus Exp $ + 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. */ /* We need to generate two trees from the graph: @@ -44,263 +42,226 @@ destination address and port of a node if possible. */ -#include "config.h" +#include "system.h" -#include -#include #include "config.h" -#include -#ifdef HAVE_SYS_PARAM_H -#include -#endif -#include - -#include -#include - +#include "connection.h" +#include "device.h" +#include "edge.h" +#include "graph.h" +#include "list.h" +#include "logger.h" #include "netutl.h" #include "node.h" -#include "edge.h" -#include "connection.h" #include "process.h" -#include "device.h" - -#include "system.h" +#include "protocol.h" +#include "subnet.h" +#include "utils.h" +#include "xalloc.h" +#include "graph.h" /* Implementation of Kruskal's algorithm. - Running time: O(EN) + Running time: O(E) 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; - - cp(); - +static void mst_kruskal(void) { /* 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? */ + for list_each(connection_t, c, connection_list) + c->status.mst = false; - if(!edge_weight_tree->head) - return; - - if(debug_lvl >= DEBUG_SCARY_THINGS) - syslog(LOG_DEBUG, "Running Kruskal's algorithm:"); + logger(DEBUG_SCARY_THINGS, 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->status.visited = 1; + for splay_each(node_t, n, node_tree) + n->status.visited = false; /* Add safe edges */ - for(skipped = 0, node = edge_weight_tree->head; node; node = next) { - next = node->next; - e = (edge_t *) node->data; - - if(!e->reverse || e->from->status.visited == e->to->status.visited) { - skipped = 1; + for splay_each(edge_t, e, edge_weight_tree) { + if(!e->reverse || (e->from->status.visited && e->to->status.visited)) continue; - } - e->from->status.visited = 1; - e->to->status.visited = 1; + e->from->status.visited = true; + e->to->status.visited = true; if(e->connection) - e->connection->status.mst = 1; + e->connection->status.mst = true; if(e->reverse->connection) - e->reverse->connection->status.mst = 1; - - safe_edges++; + e->reverse->connection->status.mst = true; - if(debug_lvl >= DEBUG_SCARY_THINGS) - syslog(LOG_DEBUG, " Adding edge %s - %s weight %d", e->from->name, + logger(DEBUG_SCARY_THINGS, LOG_DEBUG, " Adding edge %s - %s weight %d", e->from->name, e->to->name, e->weight); - - if(skipped) { - skipped = 0; - 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; - avl_tree_t *todo_tree; - int indirect; - char *name; - char *address, *port; - char *envp[7]; - int i; - - cp(); - - todo_tree = avl_alloc_tree(NULL, NULL); +static void sssp_bfs(void) { + list_t *todo_list = list_alloc(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; + for splay_each(node_t, n, node_tree) { + n->status.visited = false; + n->status.indirect = true; + n->distance = -1; } /* Begin with myself */ - myself->status.visited = 1; - myself->status.indirect = 0; + myself->status.visited = true; + myself->status.indirect = false; myself->nexthop = myself; + myself->prevedge = NULL; myself->via = myself; - node = avl_alloc_node(); - node->data = myself; - avl_insert_top(todo_tree, node); + myself->distance = 0; + list_insert_head(todo_list, myself); - /* Loop while todo_tree is filled */ + /* Loop while todo_list 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 list_each(node_t, n, todo_list) { /* "n" is the node from which we start */ + logger(DEBUG_SCARY_THINGS, LOG_DEBUG, " Examining edges from %s", n->name); - for(to = n->edge_tree->head; to; to = to->next) { /* "to" is the edge connected to "from" */ - e = (edge_t *) to->data; + if(n->distance < 0) + abort(); - if(!e->reverse) - continue; + for splay_each(edge_t, e, n->edge_tree) { /* "e" is the edge connected to "from" */ + if(!e->reverse) + continue; - /* Situation: + /* Situation: / - / - ------(n)-----(e->to) - \ + / + ----->(n)---e-->(e->to) + \ \ - 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: + 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_tree to (re)examine the reachability - of nodes behind it. - */ + - 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. + */ - indirect = n->status.indirect || e->options & OPTION_INDIRECT - || ((n != myself) - && sockaddrcmp(&n->address, &e->reverse->address)); + bool indirect = n->status.indirect || e->options & OPTION_INDIRECT; - if(e->to->status.visited - && (!e->to->status.indirect || indirect)) - continue; + if(e->to->status.visited + && (!e->to->status.indirect || indirect) + && (e->to->distance != n->distance + 1 || e->weight >= e->to->prevedge->weight)) + continue; - e->to->status.visited = 1; - 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; + e->to->status.visited = true; + e->to->status.indirect = indirect; + e->to->nexthop = (n->nexthop == myself) ? e->to : n->nexthop; + e->to->prevedge = e; + e->to->via = indirect ? n->via : e->to; + e->to->options = e->options; + e->to->distance = n->distance + 1; - if(sockaddrcmp(&e->to->address, &e->address)) { - node = avl_unlink(node_udp_tree, e->to); - e->to->address = e->address; - - if(e->to->hostname) - free(e->to->hostname); - - e->to->hostname = sockaddr2hostname(&e->to->address); - avl_insert_node(node_udp_tree, node); - } + if(!e->to->status.reachable || (e->to->address.sa.sa_family == AF_UNSPEC && e->address.sa.sa_family != AF_UNKNOWN)) + update_node_udp(e->to, &e->address); - node = avl_alloc_node(); - node->data = e->to; - avl_insert_before(todo_tree, from, node); - } - - avl_delete_node(todo_tree, from); + list_insert_tail(todo_list, e->to); } + + next = node->next; /* Because the list_insert_tail() above could have added something extra for us! */ + list_delete_node(todo_list, node); } - avl_free_tree(todo_tree); + list_free(todo_list); +} +static void check_reachability(void) { /* Check reachability status. */ - for(node = node_tree->head; node; node = next) { - next = node->next; - n = (node_t *) node->data; - + for splay_each(node_t, n, node_tree) { if(n->status.visited != n->status.reachable) { n->status.reachable = !n->status.reachable; + n->last_state_change = time(NULL); + + if(n->status.reachable) { + logger(DEBUG_TRAFFIC, LOG_DEBUG, "Node %s (%s) became reachable", + n->name, n->hostname); + } else { + logger(DEBUG_TRAFFIC, LOG_DEBUG, "Node %s (%s) became unreachable", + n->name, n->hostname); + } - if(debug_lvl >= DEBUG_TRAFFIC) - if(n->status.reachable) - syslog(LOG_DEBUG, _("Node %s (%s) became reachable"), - n->name, n->hostname); - else - syslog(LOG_DEBUG, _("Node %s (%s) became unreachable"), - n->name, n->hostname); - - n->status.validkey = 0; - n->status.waitingforkey = 0; - - asprintf(&envp[0], "NETNAME=%s", netname ? : ""); - asprintf(&envp[1], "DEVICE=%s", device ? : ""); - asprintf(&envp[2], "INTERFACE=%s", interface ? : ""); - asprintf(&envp[3], "NODE=%s", n->name); + if(experimental && OPTION_VERSION(n->options) >= 2) + n->status.sptps = true; + + /* TODO: only clear status.validkey if node is unreachable? */ + + n->status.validkey = false; + if(n->status.sptps) { + sptps_stop(&n->sptps); + n->status.waitingforkey = false; + } + n->last_req_key = 0; + + n->status.udp_confirmed = false; + n->maxmtu = MTU; + n->minmtu = 0; + n->mtuprobes = 0; + + timeout_del(&n->mtutimeout); + + char *name; + char *address; + char *port; + char *envp[7]; + + 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); sockaddr2str(&n->address, &address, &port); - asprintf(&envp[4], "REMOTEADDRESS=%s", address); - asprintf(&envp[5], "REMOTEPORT=%s", port); + xasprintf(&envp[4], "REMOTEADDRESS=%s", address); + xasprintf(&envp[5], "REMOTEPORT=%s", port); envp[6] = NULL; - asprintf(&name, - n->status.reachable ? "hosts/%s-up" : "hosts/%s-down", - n->name); + execute_script(n->status.reachable ? "host-up" : "host-down", envp); + + xasprintf(&name, n->status.reachable ? "hosts/%s-up" : "hosts/%s-down", n->name); execute_script(name, envp); free(name); free(address); free(port); - for(i = 0; i < 7; i++) + for(int i = 0; i < 6; i++) free(envp[i]); + + subnet_update(n, NULL, n->status.reachable); + + if(!n->status.reachable) { + update_node_udp(n, NULL); + memset(&n->status, 0, sizeof n->status); + n->options = 0; + } else if(n->connection) { + if(n->status.sptps) { + if(n->connection->outgoing) + send_req_key(n); + } else { + send_ans_key(n); + } + } } } } -void graph(void) -{ - mst_kruskal(); +void graph(void) { + subnet_cache_flush(); sssp_bfs(); + check_reachability(); + mst_kruskal(); }