Various fixes for the encrypted storage support.

[meshlink] / src / net.c

diff --git a/src/net.c b/src/net.c
index 84625917198c8cda4a339c7529f84a52b5e43b0c..348c9e343b34a14dae8b04a9b4a2902035d5d6df 100644 (file)
--- a/src/net.c
+++ b/src/net.c
@@ -57,7 +57,7 @@ void terminate_connection(meshlink_handle_t *mesh, connection_t *c, bool report)
 
        if(c->edge) {
                if(report) {
-                       send_del_edge(mesh, mesh->everyone, c->edge);
+                       send_del_edge(mesh, mesh->everyone, c->edge, 0);
                }
 
                edge_del(mesh, c->edge);
@@ -74,7 +74,7 @@ void terminate_connection(meshlink_handle_t *mesh, connection_t *c, bool report)
                        e = lookup_edge(c->node, mesh->self);
 
                        if(e) {
-                               send_del_edge(mesh, mesh->everyone, e);
+                               send_del_edge(mesh, mesh->everyone, e, 0);
                                edge_del(mesh, e);
                        }
                }
@@ -387,8 +387,6 @@ static void periodic_handler(event_loop_t *loop, void *data) {
 
                // get min_connects and max_connects
 
-               assert(mesh->devclass >= 0 && mesh->devclass <= _DEV_CLASS_MAX);
-
                unsigned int min_connects = dev_class_traits[mesh->devclass].min_connects;
                unsigned int max_connects = dev_class_traits[mesh->devclass].max_connects;
 
@@ -402,18 +400,18 @@ static void periodic_handler(event_loop_t *loop, void *data) {
                        splay_tree_t *nodes = splay_alloc_tree(node_compare_devclass_asc_lsc_desc, NULL);
 
                        for splay_each(node_t, n, mesh->nodes) {
-                               logger(mesh, MESHLINK_DEBUG, "* n->devclass = %d", n->devclass);
+                               logger(mesh, MESHLINK_DEBUG, "* %s->devclass = %d", n->name, n->devclass);
 
-                               if(n != mesh->self && n->devclass <= mesh->devclass && !n->connection && (n->last_connect_try == 0 || (time(NULL) - n->last_connect_try) > retry_timeout)) {
+                               if(n != mesh->self && n->devclass <= mesh->devclass && !n->connection && !n->status.blacklisted && (n->last_connect_try == 0 || (time(NULL) - n->last_connect_try) > retry_timeout)) {
                                        splay_insert(nodes, n);
                                }
                        }
 
                        if(nodes->head) {
-                               logger(mesh, MESHLINK_DEBUG, "* found best one for initial connect");
-
                                //timeout = 0;
                                connect_to = (node_t *)nodes->head->data;
+
+                               logger(mesh, MESHLINK_DEBUG, "* found best one for initial connect: %s", connect_to->name);
                        } else {
                                logger(mesh, MESHLINK_DEBUG, "* could not find node for initial connect");
                        }
@@ -427,7 +425,7 @@ static void periodic_handler(event_loop_t *loop, void *data) {
                if(!connect_to && min_connects <= cur_connects && cur_connects < max_connects) {
                        unsigned int connects = 0;
 
-                       for(unsigned int devclass = 0; devclass <= mesh->devclass; ++devclass) {
+                       for(int32_t devclass = 0; devclass <= mesh->devclass; ++devclass) {
                                for list_each(connection_t, c, mesh->connections) {
                                        if(c->status.active && c->node && c->node->devclass == devclass) {
                                                connects += 1;
@@ -438,7 +436,7 @@ static void periodic_handler(event_loop_t *loop, void *data) {
                                        splay_tree_t *nodes = splay_alloc_tree(node_compare_lsc_desc, NULL);
 
                                        for splay_each(node_t, n, mesh->nodes) {
-                                               if(n != mesh->self && n->devclass == devclass && !n->connection && (n->last_connect_try == 0 || (time(NULL) - n->last_connect_try) > retry_timeout)) {
+                                               if(n != mesh->self && n->devclass == devclass && !n->connection && !n->status.blacklisted && (n->last_connect_try == 0 || (time(NULL) - n->last_connect_try) > retry_timeout)) {
                                                        splay_insert(nodes, n);
                                                }
                                        }
@@ -469,7 +467,7 @@ static void periodic_handler(event_loop_t *loop, void *data) {
                        splay_tree_t *nodes = splay_alloc_tree(node_compare_devclass_asc_lsc_desc, NULL);
 
                        for splay_each(node_t, n, mesh->nodes) {
-                               if(n != mesh->self && n->devclass <= mesh->devclass && !n->status.reachable && (n->last_connect_try == 0 || (time(NULL) - n->last_connect_try) > retry_timeout)) {
+                               if(n != mesh->self && n->devclass <= mesh->devclass && !n->status.reachable && !n->status.blacklisted && (n->last_connect_try == 0 || (time(NULL) - n->last_connect_try) > retry_timeout)) {
                                        splay_insert(nodes, n);
                                }
                        }
@@ -489,26 +487,30 @@ static void periodic_handler(event_loop_t *loop, void *data) {
 
                if(connect_to && !connect_to->connection) {
                        connect_to->last_connect_try = time(NULL);
+                       logger(mesh, MESHLINK_DEBUG, "Autoconnect trying to connect to %s", connect_to->name);
 
                        /* check if there is already a connection attempt to this node */
-                       bool found = false;
+                       bool skip = false;
 
                        for list_each(outgoing_t, outgoing, mesh->outgoings) {
-                               if(!strcmp(outgoing->name, connect_to->name)) {
-                                       found = true;
+                               if(outgoing->node == connect_to) {
+                                       logger(mesh, MESHLINK_DEBUG, "* skip autoconnect since it is an outgoing connection already");
+                                       skip = true;
                                        break;
                                }
                        }
 
-                       if(!found) {
+                       if(!node_read_public_key(mesh, connect_to)) {
+                               logger(mesh, MESHLINK_DEBUG, "* skip autoconnect since we don't know this node's public key");
+                               skip = true;
+                       }
+
+                       if(!skip) {
                                logger(mesh, MESHLINK_DEBUG, "Autoconnecting to %s", connect_to->name);
                                outgoing_t *outgoing = xzalloc(sizeof(outgoing_t));
-                               outgoing->mesh = mesh;
-                               outgoing->name = xstrdup(connect_to->name);
+                               outgoing->node = connect_to;
                                list_insert_tail(mesh->outgoings, outgoing);
                                setup_outgoing_connection(mesh, outgoing);
-                       } else {
-                               logger(mesh, MESHLINK_DEBUG, "* skip autoconnect since it is an outgoing connection already");
                        }
                }
 
@@ -518,7 +520,7 @@ static void periodic_handler(event_loop_t *loop, void *data) {
                if(min_connects < cur_connects /*&& cur_connects <= max_connects*/) {
                        unsigned int connects = 0;
 
-                       for(unsigned int devclass = 0; devclass <= mesh->devclass; ++devclass) {
+                       for(int32_t devclass = 0; devclass <= mesh->devclass; ++devclass) {
                                for list_each(connection_t, c, mesh->connections) {
                                        if(c->status.active && c->node && c->node->devclass == devclass) {
                                                connects += 1;
@@ -589,6 +591,13 @@ static void periodic_handler(event_loop_t *loop, void *data) {
                logger(mesh, MESHLINK_DEBUG, "--- autoconnect end ---");
        }
 
+       for splay_each(node_t, n, mesh->nodes) {
+               if(n->status.dirty) {
+                       node_write_config(mesh, n);
+                       n->status.dirty = false;
+               }
+       }
+
        timeout_set(&mesh->loop, data, &(struct timeval) {
                timeout, rand() % 100000
        });