Try connections to unreachable nodes more often.

[meshlink] / src / net.c

diff --git a/src/net.c b/src/net.c
index 866bacb10c7eb46d5cdaaf93086f8d72ad1129d0..0475335592fd5c2b8445cf25f3ffd622dfd7c894 100644 (file)
--- a/src/net.c
+++ b/src/net.c
@@ -162,8 +162,18 @@ static void periodic_handler(event_loop_t *loop, void *data) {
                        int i = 0;
 
                        for splay_each(node_t, n, mesh->nodes) {
-                               if(i++ != r)
-                                       continue;
+                               bool trying_unreachable = false;
+
+                               if(i++ != r) {
+                                       if(n->status->reachable) {
+                                               continue;
+                                       } else {
+                                               /* If we see an unreachable node
+                                                  before node i, try it anyway.
+                                               */
+                                               trying_unreachable = true;
+                                       }
+                               }
 
                                if(n->connection)
                                        break;
@@ -178,11 +188,22 @@ static void periodic_handler(event_loop_t *loop, void *data) {
                                }
 
                                if(!found) {
+                                       //TODO: if the node is blacklisted the connection will not happen, but
+                                       //the user will read this debug message "Autoconnecting to %s" that is misleading
                                        logger(DEBUG_CONNECTIONS, LOG_INFO, "Autoconnecting to %s", n->name);
                                        outgoing_t *outgoing = xzalloc(sizeof *outgoing);
                                        outgoing->name = xstrdup(n->name);
                                        list_insert_tail(mesh->outgoings, outgoing);
                                        setup_outgoing_connection(mesh, outgoing);
+                               } else if(trying_unreachable) {
+                                       /* We're trying an unreachable node instead
+                                          of node i. We already have an outgoing
+                                          to it. Try the next node rather than
+                                          breaking here, to avoid churning on a
+                                          connection attempt to the first
+                                          unreachable node.
+                                       */
+                                       continue;
                                }
                                break;
                        }
@@ -267,6 +288,10 @@ int main_loop(meshlink_handle_t *mesh) {
        timeout_add(&mesh->loop, &mesh->pingtimer, timeout_handler, &mesh->pingtimer, &(struct timeval){mesh->pingtimeout, rand() % 100000});
        timeout_add(&mesh->loop, &mesh->periodictimer, periodic_handler, &mesh->periodictimer, &(struct timeval){mesh->pingtimeout, rand() % 100000});
 
+       //Add signal handler
+       mesh->datafromapp.signum = 0;
+       signal_add(&(mesh->loop),&(mesh->datafromapp), (signal_cb_t)meshlink_send_from_queue,mesh, mesh->datafromapp.signum);
+
        if(!event_loop_run(&mesh->loop)) {
                logger(DEBUG_ALWAYS, LOG_ERR, "Error while waiting for input: %s", strerror(errno));
                return 1;