X-Git-Url: http://git.meshlink.io/?a=blobdiff_plain;f=src%2Fgraph.c;h=b0e0b77a198a408cd2d88aecb2c4debde09022d3;hb=963c5055505f2fc117cd5efa06eaa02c9b2bf85d;hp=53cf6a99f8b887da5ef4f62ba3fbff866012d165;hpb=87ad5c97a9a73a65050ad7adce34503f856d8665;p=meshlink diff --git a/src/graph.c b/src/graph.c index 53cf6a99..b0e0b77a 100644 --- a/src/graph.c +++ b/src/graph.c @@ -1,7 +1,6 @@ /* graph.c -- graph algorithms - Copyright (C) 2001 Guus Sliepen , - 2001 Ivo Timmermans + Copyright (C) 2014 Guus Sliepen 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 +12,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.4 2001/10/30 12:59:12 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: @@ -38,143 +35,211 @@ For the SSSP algorithm Dijkstra's seems to be a nice choice. Currently a simple breadth-first search is presented here. -*/ -#include -#include "config.h" -#include + The SSSP algorithm will also be used to determine whether nodes are + reachable from the source. It will also set the correct destination address + and port of a node if possible. +*/ -#include +#include "system.h" -#include "node.h" -#include "edge.h" #include "connection.h" +#include "edge.h" +#include "graph.h" +#include "list.h" +#include "logger.h" +#include "meshlink_internal.h" +#include "netutl.h" +#include "node.h" +#include "protocol.h" +#include "utils.h" +#include "xalloc.h" +#include "graph.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(). +/* Implementation of a simple breadth-first search algorithm. + Running time: O(E) */ -void mst_kruskal(void) -{ - avl_node_t *node; - edge_t *e; - node_t *n; - connection_t *c; - int nodes = 0; - int safe_edges = 0; - int skipped; - - /* 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; - - /* Clear MST status on connections */ - - for(node = connection_tree->head; node; node = node->next) - { - c = (connection_t *)node->data; - c->status.mst = 0; - } - - /* Add safe edges */ - - while(safe_edges < nodes - 1) - for(skipped = 0, node = edge_weight_tree->head; node; node = node->next) - { - e = (edge_t *)node->data; - - if(e->from->status.visited == e->to->status.visited) - { - skipped = 1; - continue; - } - - e->from->status.visited = 1; - e->to->status.visited = 1; - if(e->connection) - e->connection->status.mst = 1; - - safe_edges++; - - if(skipped) - break; - } +static void sssp_bfs(meshlink_handle_t *mesh) { + list_t *todo_list = list_alloc(NULL); + + /* Clear visited status on nodes */ + + for splay_each(node_t, n, mesh->nodes) { + n->status.visited = false; + n->distance = -1; + } + + /* Begin with mesh->self */ + + mesh->self->status.visited = mesh->threadstarted; + mesh->self->nexthop = mesh->self; + mesh->self->prevedge = NULL; + mesh->self->distance = 0; + list_insert_head(todo_list, mesh->self); + + /* Loop while todo_list is filled */ + + for list_each(node_t, n, todo_list) { /* "n" is the node from which we start */ + logger(mesh, MESHLINK_DEBUG, " Examining edges from %s", n->name); + + if(n->distance < 0) { + abort(); + } + + for splay_each(edge_t, e, n->edge_tree) { /* "e" is the edge connected to "from" */ + 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. + */ + + if(e->to->status.visited + && (e->to->distance != n->distance + 1 || e->weight >= e->to->prevedge->weight)) { + continue; + } + + e->to->status.visited = true; + e->to->nexthop = (n->nexthop == mesh->self) ? e->to : n->nexthop; + e->to->prevedge = e; + e->to->distance = n->distance + 1; + + if(!e->to->status.reachable || (e->to->address.sa.sa_family == AF_UNSPEC && e->address.sa.sa_family != AF_UNKNOWN)) { + update_node_udp(mesh, e->to, &e->address); + } + + 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); + } + + list_free(todo_list); } -/* Implementation of a simple breadth-first search algorithm. - Running time: O(E) -*/ +static void check_reachability(meshlink_handle_t *mesh) { + /* Check reachability status. */ + + int reachable = -1; /* Don't count ourself */ + + for splay_each(node_t, n, mesh->nodes) { + if(n->status.visited) { + reachable++; + } + + /* Check for nodes that have changed session_id */ + if(n->status.visited && n->prevedge && n->prevedge->reverse->session_id != n->session_id) { + n->session_id = n->prevedge->reverse->session_id; + + if(n->utcp) { + utcp_abort_all_connections(n->utcp); + } + + if(n->status.visited == n->status.reachable) { + /* This session replaces the previous one without changing reachability status. + * We still need to reset the UDP SPTPS state. + */ + n->status.validkey = false; + 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(&mesh->loop, &n->mtutimeout); + } + } + + if(n->status.visited != n->status.reachable) { + n->status.reachable = !n->status.reachable; + n->status.dirty = true; + + if(!n->status.blacklisted) { + if(n->status.reachable) { + logger(mesh, MESHLINK_DEBUG, "Node %s became reachable", n->name); + bool first_time_reachable = !n->last_reachable; + n->last_reachable = time(NULL); + + if(first_time_reachable) { + if(!node_write_config(mesh, n)) { + logger(mesh, MESHLINK_WARNING, "Could not write host config file for node %s!\n", n->name); + + } + } + } else { + logger(mesh, MESHLINK_DEBUG, "Node %s became unreachable", n->name); + n->last_unreachable = time(NULL); + } + } + + /* TODO: only clear status.validkey if node is unreachable? */ + + n->status.validkey = false; + 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(&mesh->loop, &n->mtutimeout); + + if(!n->status.blacklisted) { + update_node_status(mesh, n); + } + + if(!n->status.reachable) { + update_node_udp(mesh, n, NULL); + n->status.broadcast = false; + } else if(n->connection) { + if(n->connection->status.initiator) { + send_req_key(mesh, n); + } + } + + if(n->utcp) { + utcp_offline(n->utcp, !n->status.reachable); + } + } + } + + if(mesh->reachable != reachable) { + if(!reachable) { + mesh->last_unreachable = mesh->loop.now.tv_sec; + + if(mesh->threadstarted) { + timeout_set(&mesh->loop, &mesh->periodictimer, &(struct timespec) { + 0, prng(mesh, TIMER_FUDGE) + }); + } + } + + mesh->reachable = reachable; + } +} -void sssp_bfs(void) -{ - avl_node_t *node, *from, *next, *to; - edge_t *e; - node_t *n, *check; - avl_tree_t *todo_tree; - - 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; - } - - /* Begin with myself */ - - myself->status.visited = 1; - 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) - { - next = from->next; - n = (node_t *)from->data; - - for(to = n->edge_tree->head; to; to = to->next) - { - e = (edge_t *)to->data; - - if(e->from == n) - check = e->to; - else - check = e->from; - - if(!check->status.visited) - { - check->status.visited = 1; - check->nexthop = (n->nexthop == myself) ? check : n->nexthop; - check->via = check; /* FIXME: only if !(e->options & INDIRECT), otherwise use n->via */ - node = avl_alloc_node(); - node->data = check; - avl_insert_before(todo_tree, from, node); - } - } - - avl_delete_node(todo_tree, from); - } - } - - avl_free_tree(todo_tree); +void graph(meshlink_handle_t *mesh) { + sssp_bfs(mesh); + check_reachability(mesh); }