Various fixes for the encrypted storage support.

- create_initial_config_files() and node_write_config() are now the only
  functions that generate the content of new config files from scratch.
- All public API functions that change config files now immediately
  write them out.
- Config files of nodes that join using an invitation file are immediately
  written out.
- Ensure nodes marked dirty have their config files written out in
  periodic_handler(), and on meshlink_stop().
- Fix some memory leaks.
- Write out updated config files, and recreate mesh->self in meshlink_set_port().

diff --git a/doc/Configuration.md b/doc/Configuration.md
index 1520ee570b6c322f60698444468bce0b3405f786..6b76457bacbce7a1f06f0e25db943bbb599537e6 100644 (file)
--- a/doc/Configuration.md
+++ b/doc/Configuration.md
@@ -43,9 +43,10 @@ The contents of a host configuration are:
 
 - uint32: configuration format version
 - str: name of the node
+- str: name of the submesh this node is part of, or "." if it's in the core mesh
 - int32: device class
 - bool: blacklisted
-- bin: public Ed25519 key
+- bin: public Ed25519 key, or zero-length if no key is known
 - str: canonical address (may be zero length if unset)
 - arr[ext]: recent addresses
 
@@ -56,6 +57,7 @@ The contents of an invitation file are:
 
 - uint32: invitation format version
 - str: name of the invitee
+- str: name of the submesh this node will be part of, or "." if it's in the core mesh
 - int32: device class of the invitee (may be unused)
 - arr[bin]: one or more host config files
 

diff --git a/src/conf.c b/src/conf.c
index 9664e2b776a923a9d33d69451d5867c52986b5b4..1a3c82ae2e8c45e5cf07cceaf2945bcc9eaac6bf 100644 (file)
--- a/src/conf.c
+++ b/src/conf.c
@@ -223,6 +223,7 @@ bool config_read_file(meshlink_handle_t *mesh, FILE *f, config_t *config) {
                chacha_poly1305_set_key(ctx, mesh->config_key);
 
                if(len > 12 && chacha_poly1305_decrypt_iv96(ctx, buf, buf + 12, len - 12, decrypted, &decrypted_len)) {
+                       chacha_poly1305_exit(ctx);
                        free(buf);
                        config->buf = decrypted;
                        config->len = decrypted_len;
@@ -230,6 +231,7 @@ bool config_read_file(meshlink_handle_t *mesh, FILE *f, config_t *config) {
                } else {
                        logger(mesh, MESHLINK_ERROR, "Cannot decrypt config file\n");
                        meshlink_errno = MESHLINK_ESTORAGE;
+                       chacha_poly1305_exit(ctx);
                        free(decrypted);
                        free(buf);
                        return false;
@@ -330,7 +332,7 @@ void config_scan_all(meshlink_handle_t *mesh, config_scan_action_t action) {
        DIR *dir;
        struct dirent *ent;
        char dname[PATH_MAX];
-       make_host_path(mesh, NULL, dname, sizeof(dname));
+       make_host_path(mesh, "", dname, sizeof(dname));
 
        dir = opendir(dname);
 

diff --git a/src/meshlink.c b/src/meshlink.c
index cead9960d42bc62e0e19bea3722a40260b3f2082..134abd83da5e548c3640a1dc056ec107ea189063 100644 (file)
--- a/src/meshlink.c
+++ b/src/meshlink.c
@@ -530,6 +530,36 @@ int check_port(meshlink_handle_t *mesh) {
        return 0;
 }
 
+static bool write_main_config_files(meshlink_handle_t *mesh) {
+       uint8_t buf[4096];
+
+       /* Write the main config file */
+       packmsg_output_t out = {buf, sizeof buf};
+
+       packmsg_add_uint32(&out, MESHLINK_CONFIG_VERSION);
+       packmsg_add_str(&out, mesh->name);
+       packmsg_add_bin(&out, ecdsa_get_private_key(mesh->private_key), 96);
+       packmsg_add_bin(&out, ecdsa_get_private_key(mesh->invitation_key), 96);
+       packmsg_add_uint16(&out, atoi(mesh->myport));
+
+       if(!packmsg_output_ok(&out)) {
+               return false;
+       }
+
+       config_t config = {buf, packmsg_output_size(&out, buf)};
+
+       if(!main_config_write(mesh, &config)) {
+               return false;
+       }
+
+       /* Write our own host config file */
+       if(!node_write_config(mesh, mesh->self)) {
+               return false;
+       }
+
+       return true;
+}
+
 static bool finalize_join(meshlink_handle_t *mesh, const void *buf, uint16_t len) {
        packmsg_input_t in = {buf, len};
        uint32_t version = packmsg_get_uint32(&in);
@@ -551,48 +581,28 @@ static bool finalize_join(meshlink_handle_t *mesh, const void *buf, uint16_t len
 
        if(!check_id(name)) {
                logger(mesh, MESHLINK_DEBUG, "Invalid Name found in invitation: %s!\n", name);
+               free(name);
                return false;
        }
 
        if(!count) {
                logger(mesh, MESHLINK_ERROR, "Incomplete invitation file!\n");
+               free(name);
                return false;
        }
 
+       free(mesh->name);
+       free(mesh->self->name);
+       mesh->name = name;
+       mesh->self->name = xstrdup(name);
+       mesh->self->devclass = devclass;
+
        // Initialize configuration directory
        if(!config_init(mesh)) {
                return false;
        }
 
-       // Write main config file
-       uint8_t outbuf[4096];
-       packmsg_output_t out = {outbuf, sizeof(outbuf)};
-       packmsg_add_uint32(&out, MESHLINK_CONFIG_VERSION);
-       packmsg_add_str(&out, name);
-       packmsg_add_bin(&out, ecdsa_get_private_key(mesh->private_key), 96);
-       packmsg_add_uint16(&out, atoi(mesh->myport));
-
-       config_t config = {outbuf, packmsg_output_size(&out, outbuf)};
-
-       if(!main_config_write(mesh, &config)) {
-               return false;
-       }
-
-       // Write our own host config file
-       out.ptr = outbuf;
-       out.len = sizeof(outbuf);
-       packmsg_add_uint32(&out, MESHLINK_CONFIG_VERSION);
-       packmsg_add_str(&out, name);
-       packmsg_add_str(&out, CORE_MESH);
-       packmsg_add_int32(&out, devclass);
-       packmsg_add_bool(&out, false);
-       packmsg_add_bin(&out, ecdsa_get_public_key(mesh->private_key), 32);
-       packmsg_add_str(&out, ""); // TODO: copy existing canonical address, in case it was added before meshlink_join().
-       packmsg_add_array(&out, 0);
-
-       config.len = packmsg_output_size(&out, outbuf);
-
-       if(!config_write(mesh, name, &config)) {
+       if(!write_main_config_files(mesh)) {
                return false;
        }
 
@@ -606,19 +616,36 @@ static bool finalize_join(meshlink_handle_t *mesh, const void *buf, uint16_t len
                        return false;
                }
 
-               config_t config = {data, len};
-               node_t *n = new_node();
+               packmsg_input_t in2 = {data, len};
+               uint32_t version = packmsg_get_uint32(&in2);
+               char *name = packmsg_get_str_dup(&in2);
 
-               if(!node_read_from_config(mesh, n, &config)) {
-                       free_node(n);
-                       logger(mesh, MESHLINK_ERROR, "Invalid host config file in invitation file!\n");
+               if(!packmsg_input_ok(&in2) || version != MESHLINK_CONFIG_VERSION || !check_id(name)) {
+                       free(name);
+                       packmsg_input_invalidate(&in);
+                       break;
+               }
+
+               if(!check_id(name)) {
+                       free(name);
+                       break;
+               }
+
+               if(!strcmp(name, mesh->name)) {
+                       logger(mesh, MESHLINK_DEBUG, "Secondary chunk would overwrite our own host config file.\n");
+                       free(name);
                        meshlink_errno = MESHLINK_EPEER;
                        return false;
                }
 
-               if(!strcmp(n->name, name)) {
-                       logger(mesh, MESHLINK_DEBUG, "Secondary chunk would overwrite our own host config file.\n");
+               node_t *n = new_node();
+               n->name = name;
+
+               config_t config = {data, len};
+
+               if(!node_read_from_config(mesh, n, &config)) {
                        free_node(n);
+                       logger(mesh, MESHLINK_ERROR, "Invalid host config file in invitation file!\n");
                        meshlink_errno = MESHLINK_EPEER;
                        return false;
                }
@@ -632,11 +659,6 @@ static bool finalize_join(meshlink_handle_t *mesh, const void *buf, uint16_t len
 
        sptps_send_record(&(mesh->sptps), 1, ecdsa_get_public_key(mesh->private_key), 32);
 
-       free(mesh->name);
-       free(mesh->self->name);
-       mesh->name = xstrdup(name);
-       mesh->self->name = xstrdup(name);
-
        logger(mesh, MESHLINK_DEBUG, "Configuration stored in: %s\n", mesh->confbase);
 
        return true;
@@ -833,24 +855,6 @@ static void add_local_addresses(meshlink_handle_t *mesh) {
        }
 }
 
-#if 0
-static bool meshlink_write_config(meshlink_handle_t *mesh) {
-       uint8_t buf[1024];
-       packmsg_output_t out = {buf, sizeof buf};
-       packmsg_add_str(&out, mesh->name);
-       packmsg_add_uint32(&out, mesh->devclass);
-       packmsg_add_uint16(&out, mesh->port);
-       packmsg_add_bin(&out, ecdsa, sizeof(ecdsa));
-       uint32_t len = packmsg_output_size(&out, buf);
-
-       if(!len) {
-               logger(mesh, MESHLINK_DEBUG, "Could not create configuration data\n",);
-               meshlink_errno = MESHLINK_EINTERNAL;
-               return false;
-       }
-}
-#endif
-
 static bool meshlink_setup(meshlink_handle_t *mesh) {
        if(!config_init(mesh)) {
                logger(mesh, MESHLINK_ERROR, "Could not set up configuration in %s: %s\n", mesh->confbase, strerror(errno));
@@ -875,36 +879,13 @@ static bool meshlink_setup(meshlink_handle_t *mesh) {
        mesh->self->devclass = mesh->devclass;
        mesh->self->ecdsa = ecdsa_set_public_key(ecdsa_get_public_key(mesh->private_key));
 
-       // Write the main config file
-       uint8_t buf[4096];
-       packmsg_output_t out = {buf, sizeof(buf)};
-
-       packmsg_add_uint32(&out, MESHLINK_CONFIG_VERSION);
-       packmsg_add_str(&out, mesh->name);
-       packmsg_add_bin(&out, ecdsa_get_private_key(mesh->private_key), 96);
-       packmsg_add_bin(&out, ecdsa_get_private_key(mesh->invitation_key), 96);
-       packmsg_add_uint16(&out, atoi(mesh->myport));
-
-       config_t config = {buf, packmsg_output_size(&out, buf)};
-
-       if(!main_config_write(mesh, &config)) {
+       if(!write_main_config_files(mesh)) {
                return false;
        }
 
-       // Write our own host config file
-       out.ptr = buf;
-       out.len = sizeof(buf);
-       packmsg_add_uint32(&out, MESHLINK_CONFIG_VERSION);
-       packmsg_add_str(&out, mesh->name);
-       packmsg_add_int32(&out, mesh->devclass);
-       packmsg_add_bool(&out, false);
-       packmsg_add_bin(&out, ecdsa_get_public_key(mesh->private_key), 32);
-       packmsg_add_str(&out, ""); // TODO: copy existing canonical address, in case it was added before meshlink_join().
-       packmsg_add_array(&out, 0);
-
-       config.len = packmsg_output_size(&out, buf);
-
-       if(!config_write(mesh, mesh->name, &config)) {
+       if(!main_config_lock(mesh)) {
+               logger(NULL, MESHLINK_ERROR, "Cannot lock main config file\n");
+               meshlink_errno = MESHLINK_ESTORAGE;
                return false;
        }
 
@@ -971,6 +952,7 @@ static bool meshlink_read_config(meshlink_handle_t *mesh) {
 
        if(!node_read_public_key(mesh, mesh->self)) {
                logger(NULL, MESHLINK_ERROR, "Could not read our host configuration file!");
+               meshlink_errno = MESHLINK_ESTORAGE;
                free_node(mesh->self);
                mesh->self = NULL;
                return false;
@@ -1204,6 +1186,7 @@ meshlink_handle_t *meshlink_open_ex(const meshlink_open_params_t *params) {
 
                if(!prf(params->key, params->keylen, "MeshLink configuration key", 26, mesh->config_key, CHACHA_POLY1305_KEYLEN)) {
                        logger(NULL, MESHLINK_ERROR, "Error creating configuration key!\n");
+                       meshlink_close(mesh);
                        meshlink_errno = MESHLINK_EINTERNAL;
                        return NULL;
                }
@@ -1458,6 +1441,16 @@ void meshlink_stop(meshlink_handle_t *mesh) {
 
        exit_outgoings(mesh);
 
+       // Write out any changed node config files
+       if(mesh->nodes) {
+               for splay_each(node_t, n, mesh->nodes) {
+                       if(n->status.dirty) {
+                               node_write_config(mesh, n);
+                               n->status.dirty = false;
+                       }
+               }
+       }
+
        pthread_mutex_unlock(&(mesh->mesh_mutex));
 }
 
@@ -1498,6 +1491,8 @@ void meshlink_close(meshlink_handle_t *mesh) {
        free(mesh->name);
        free(mesh->appname);
        free(mesh->confbase);
+       free(mesh->config_key);
+       ecdsa_free(mesh->private_key);
        pthread_mutex_destroy(&(mesh->mesh_mutex));
 
        main_config_unlock(mesh);
@@ -1966,7 +1961,7 @@ bool meshlink_set_canonical_address(meshlink_handle_t *mesh, meshlink_node_t *no
        node_t *n = (node_t *)node;
        free(n->canonical_address);
        n->canonical_address = canonical_address;
-       n->status.dirty = true;
+       node_write_config(mesh, n);
 
        pthread_mutex_unlock(&(mesh->mesh_mutex));
 
@@ -2035,11 +2030,26 @@ bool meshlink_set_port(meshlink_handle_t *mesh, int port) {
                goto done;
        }
 
+       free(mesh->myport);
+       xasprintf(&mesh->myport, "%d", port);
+
+       /* Write meshlink.conf with the updated port number */
+       write_main_config_files(mesh);
+
+       /* Close down the network. This also deletes mesh->self. */
        close_network_connections(mesh);
 
-       // TODO: write meshlink.conf again
+       /* Recreate mesh->self. */
+       mesh->self = new_node();
+       mesh->self->name = xstrdup(mesh->name);
+       mesh->self->devclass = mesh->devclass;
 
-       if(!setup_network(mesh)) {
+       if(!node_read_public_key(mesh, mesh->self)) {
+               logger(NULL, MESHLINK_ERROR, "Could not read our host configuration file!");
+               meshlink_errno = MESHLINK_ESTORAGE;
+               free_node(mesh->self);
+               mesh->self = NULL;
+       } else if(!setup_network(mesh)) {
                meshlink_errno = MESHLINK_ENETWORK;
        } else {
                rval = true;
@@ -2149,7 +2159,10 @@ char *meshlink_invite_ex(meshlink_handle_t *mesh, meshlink_submesh_t *submesh, c
        packmsg_add_str(&inv, s ? s->name : CORE_MESH);
        packmsg_add_int32(&inv, DEV_CLASS_UNKNOWN); /* TODO: allow this to be set by inviter? */
 
-       /* TODO: Add several host config files to bootstrap connections */
+       /* TODO: Add several host config files to bootstrap connections.
+        * Note: make sure we only add config files of nodes that are in the core mesh or the same submesh,
+        * and are not blacklisted.
+        */
        config_t configs[5] = {NULL};
        int count = 0;
 
@@ -2321,7 +2334,7 @@ bool meshlink_join(meshlink_handle_t *mesh, const char *invitation) {
 
        mesh->blen = 0;
 
-       if(!sendline(mesh->sock, "0 ?%s %d.%d %s", b64key, PROT_MAJOR, 1, mesh->appname)) {
+       if(!sendline(mesh->sock, "0 ?%s %d.%d %s", b64key, PROT_MAJOR, PROT_MINOR, mesh->appname)) {
                logger(mesh, MESHLINK_DEBUG, "Error sending request to %s port %s: %s\n", address, port, strerror(errno));
                closesocket(mesh->sock);
                meshlink_errno = MESHLINK_ENETWORK;
@@ -2533,7 +2546,7 @@ bool meshlink_import(meshlink_handle_t *mesh, const char *data) {
 
                if(!packmsg_input_ok(&in2) || version != MESHLINK_CONFIG_VERSION || !check_id(name)) {
                        free(name);
-                       packmsg_input_invalidate(&in2);
+                       packmsg_input_invalidate(&in);
                        break;
                }
 
@@ -2545,58 +2558,24 @@ bool meshlink_import(meshlink_handle_t *mesh, const char *data) {
                node_t *n = lookup_node(mesh, name);
 
                if(n) {
-                       free(name);
                        logger(mesh, MESHLINK_DEBUG, "Node %s already exists, not importing\n", name);
+                       free(name);
                        continue;
                }
 
                n = new_node();
                n->name = name;
-               char *submesh_name = packmsg_get_str_dup(&in2);
-
-               if(submesh_name) {
-                       if(!strcmp(submesh_name, CORE_MESH)) {
-                               n->submesh = NULL;
-                       } else {
-                               n->submesh = lookup_or_create_submesh(mesh, submesh_name);
 
-                               if(!n->submesh) {
-                                       packmsg_input_invalidate(&in2);
-                               }
-                       }
-
-                       free(submesh_name);
-               }
-
-               n->devclass = packmsg_get_int32(&in2);
-               n->status.blacklisted = packmsg_get_bool(&in2);
-               const void *key;
-               uint32_t keylen = packmsg_get_bin_raw(&in2, &key);
-
-               if(keylen == 32) {
-                       n->ecdsa = ecdsa_set_public_key(key);
-               }
-
-               n->canonical_address = packmsg_get_str_dup(&in2);
-               uint32_t count = packmsg_get_array(&in2);
-
-               if(count > 5) {
-                       count = 5;
-               }
-
-               for(uint32_t i = 0; i < count; i++) {
-                       n->recent[i] = packmsg_get_sockaddr(&in2);
-               }
+               config_t config = {data, len};
 
-               if(!packmsg_done(&in2) || keylen != 32) {
-                       packmsg_input_invalidate(&in);
+               if(!node_read_from_config(mesh, n, &config)) {
                        free_node(n);
+                       packmsg_input_invalidate(&in);
                        break;
-               } else {
-                       config_t config = {data, len};
-                       config_write(mesh, n->name, &config);
-                       node_add(mesh, n);
                }
+
+               config_write(mesh, n->name, &config);
+               node_add(mesh, n);
        }
 
        pthread_mutex_unlock(&(mesh->mesh_mutex));
@@ -2635,7 +2614,7 @@ void meshlink_blacklist(meshlink_handle_t *mesh, meshlink_node_t *node) {
        }
 
        n->status.blacklisted = true;
-       n->status.dirty = true;
+       node_write_config(mesh, n);
        logger(mesh, MESHLINK_DEBUG, "Blacklisted %s.\n", node->name);
 
        //Immediately terminate any connections we have with the blacklisted node
@@ -2678,7 +2657,7 @@ void meshlink_whitelist(meshlink_handle_t *mesh, meshlink_node_t *node) {
        }
 
        n->status.blacklisted = false;
-       n->status.dirty = true;
+       node_write_config(mesh, n);
 
        pthread_mutex_unlock(&(mesh->mesh_mutex));
        return;
@@ -2702,7 +2681,7 @@ void meshlink_hint_address(meshlink_handle_t *mesh, meshlink_node_t *node, const
        node_t *n = (node_t *)node;
        memmove(n->recent + 1, n->recent, 4 * sizeof(*n->recent));
        memcpy(n->recent, addr, SALEN(*addr));
-       n->status.dirty = true;
+       node_write_config(mesh, n);
 
        pthread_mutex_unlock(&(mesh->mesh_mutex));
        // @TODO do we want to fire off a connection attempt right away?

diff --git a/src/net.c b/src/net.c
index ce7e00d862a931bf21490e7582d5bb8afe7de327..348c9e343b34a14dae8b04a9b4a2902035d5d6df 100644 (file)
--- a/src/net.c
+++ b/src/net.c
@@ -490,23 +490,27 @@ static void periodic_handler(event_loop_t *loop, void *data) {
                        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(outgoing->node == connect_to) {
-                                       found = true;
+                                       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->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");
                        }
                }
 
@@ -587,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
        });

diff --git a/src/net_setup.c b/src/net_setup.c
index 4f2022b7e02de08868d336c7a6a6d3f7d3fbd5dc..64088b3af1877f1fbf88d4d6826fb805c265cd90 100644 (file)
--- a/src/net_setup.c
+++ b/src/net_setup.c
@@ -124,6 +124,34 @@ bool node_read_public_key(meshlink_handle_t *mesh, node_t *n) {
        }
 
        n->ecdsa = ecdsa_set_public_key(key);
+
+       // While we are at it, read known address information
+       if(!n->canonical_address) {
+               n->canonical_address = packmsg_get_str_dup(&in);
+       } else {
+               packmsg_skip_element(&in);
+       }
+
+       // Append any known addresses in the config file to the list we currently have
+       uint32_t known_count = 0;
+
+       for(uint32_t i = 0; i < 5; i++) {
+               if(n->recent[i].sa.sa_family) {
+                       known_count++;
+               }
+       }
+
+       uint32_t count = packmsg_get_array(&in);
+
+       if(count > 5 - known_count) {
+               count = 5 - known_count;
+       }
+
+       for(uint32_t i = 0; i < count; i++) {
+               n->recent[i + known_count] = packmsg_get_sockaddr(&in);
+       }
+
+
        config_free(&config);
        return true;
 }
@@ -207,7 +235,6 @@ bool node_write_config(meshlink_handle_t *mesh, node_t *n) {
        packmsg_add_str(&out, n->name);
        packmsg_add_str(&out, n->submesh ? n->submesh->name : CORE_MESH);
        packmsg_add_int32(&out, n->devclass);
-       assert(n->devclass != 3);
        packmsg_add_bool(&out, n->status.blacklisted);
 
        if(ecdsa_active(n->ecdsa)) {
@@ -456,11 +483,13 @@ void close_network_connections(meshlink_handle_t *mesh) {
        exit_requests(mesh);
        exit_edges(mesh);
        exit_nodes(mesh);
+       exit_submeshes(mesh);
        exit_connections(mesh);
 
-       if(mesh->myport) {
-               free(mesh->myport);
-       }
+       free(mesh->myport);
+       mesh->myport = NULL;
+
+       mesh->self = NULL;
 
        return;
 }

diff --git a/src/netutl.c b/src/netutl.c
index 1d0181b80d48046b3b4e82b627c7e98ca0c5007a..38f4d487db0fbac6897d949fbd13a0308a9891f2 100644 (file)
--- a/src/netutl.c
+++ b/src/netutl.c
@@ -234,11 +234,11 @@ void sockaddrcpy_setport(sockaddr_t *a, const sockaddr_t *b, uint16_t port) {
 
        switch(b->sa.sa_family) {
        case AF_INET:
-               a->in.sin_port = port;
+               a->in.sin_port = htons(port);
                break;
 
        case AF_INET6:
-               a->in6.sin6_port = port;
+               a->in6.sin6_port = htons(port);
                break;
 
        default:

diff --git a/src/node.c b/src/node.c
index 3a43b8f1783c77e77c3180a567f83512e8c2eb9a..690599c5edf822dfc9e34019a5f246dcc80335db 100644 (file)
--- a/src/node.c
+++ b/src/node.c
@@ -81,6 +81,7 @@ void free_node(node_t *n) {
        }
 
        free(n->name);
+       free(n->canonical_address);
 
        free(n);
 }

diff --git a/src/protocol_auth.c b/src/protocol_auth.c
index 9fec1ffad737451a94d17f7b5d5132196a0ff7bc..d26b0f651f3dde6c374a7dcd49784d998bb6efde 100644 (file)
--- a/src/protocol_auth.c
+++ b/src/protocol_auth.c
@@ -164,9 +164,8 @@ static bool finalize_invitation(meshlink_handle_t *mesh, connection_t *c, const
        n->devclass = DEV_CLASS_UNKNOWN;
        n->ecdsa = ecdsa_set_public_key(data);
        n->submesh = c->submesh;
-       n->status.dirty = true;
        node_add(mesh, n);
-       // TODO: immediately write the config file?
+       node_write_config(mesh, n);
 
        logger(mesh, MESHLINK_INFO, "Key successfully received from %s", c->name);
 

diff --git a/src/submesh.c b/src/submesh.c
index 661ec280e42de404f2f180951870fbb650f32f8d..a3bccc144e0d863abeae8857ac6753e60575f64e 100644 (file)
--- a/src/submesh.c
+++ b/src/submesh.c
@@ -35,7 +35,10 @@ void init_submeshes(meshlink_handle_t *mesh) {
 }
 
 void exit_submeshes(meshlink_handle_t *mesh) {
-       list_delete_list(mesh->submeshes);
+       if(mesh->submeshes) {
+               list_delete_list(mesh->submeshes);
+       }
+
        mesh->submeshes = NULL;
 }