Move meshlink_get_all_edges_state() to devtools_get_all_edges().

[meshlink] / src / meshlink.c

diff --git a/src/meshlink.c b/src/meshlink.c
index 21144c32ff6f58a67752e578f29bf819f8f637e1..e70ac5f624589023139dc54fda2ba797dd391940 100644 (file)
--- a/src/meshlink.c
+++ b/src/meshlink.c
@@ -1044,6 +1044,20 @@ void meshlink_stop(meshlink_handle_t *mesh) {
 
        mesh->threadstarted = false;
 
+       // Close all metaconnections
+       if(mesh->connections) {
+               for(list_node_t *node = mesh->connections->head, *next; node; node = next) {
+                       next = node->next;
+                       connection_t *c = node->data;
+                       c->outgoing = NULL;
+                       terminate_connection(mesh, c, false);
+               }
+       }
+
+       if(mesh->outgoings)
+               list_delete_list(mesh->outgoings);
+       mesh->outgoings = NULL;
+
        pthread_mutex_unlock(&(mesh->mesh_mutex));
 }
 
@@ -1194,8 +1208,8 @@ bool meshlink_send(meshlink_handle_t *mesh, meshlink_node_t *destination, const
        memset(hdr, 0, sizeof(*hdr));
        // leave the last byte as 0 to make sure strings are always
        // null-terminated if they are longer than the buffer
-       strncpy(hdr->destination, destination->name, (sizeof(hdr)->destination) - 1);
-       strncpy(hdr->source, mesh->self->name, (sizeof(hdr)->source) - 1);
+       strncpy((char *)hdr->destination, destination->name, (sizeof(hdr)->destination) - 1);
+       strncpy((char *)hdr->source, mesh->self->name, (sizeof(hdr)->source) - 1);
 
        memcpy(packet->data + sizeof(*hdr), data, len);
 
@@ -1932,6 +1946,7 @@ char *meshlink_export(meshlink_handle_t *mesh) {
        if(fread(buf + len - fsize - 1, fsize, 1, f) != 1) {
                logger(mesh, MESHLINK_DEBUG, "Error reading from %s: %s\n", filename, strerror(errno));
                fclose(f);
+               free(buf);
                meshlink_errno = MESHLINK_ESTORAGE;
                pthread_mutex_unlock(&(mesh->mesh_mutex));
                return NULL;
@@ -2071,7 +2086,7 @@ void meshlink_hint_address(meshlink_handle_t *mesh, meshlink_node_t *node, const
        if(host && port) {
                xasprintf(&str, "%s %s", host, port);
                if((strncmp("fe80", host, 4) != 0) && (strncmp("127.", host, 4) != 0) && (strcmp("localhost", host) != 0))
-                       append_config_file(mesh, node->name, "Address", str);
+                       modify_config_file(mesh, node->name, "Address", str, 5);
                else
                        logger(mesh, MESHLINK_DEBUG, "Not adding Link Local IPv6 Address to config\n");
        }
@@ -2084,70 +2099,10 @@ void meshlink_hint_address(meshlink_handle_t *mesh, meshlink_node_t *node, const
        // @TODO do we want to fire off a connection attempt right away?
 }
 
-/* Return an array of edges in the current network graph.
- * Data captures the current state and will not be updated.
- * Caller must deallocate data when done.
- */
-meshlink_edge_t **meshlink_get_all_edges_state(meshlink_handle_t *mesh, meshlink_edge_t **edges, size_t *nmemb) {
-       if(!mesh || !nmemb || (*nmemb && !edges)) {
-               meshlink_errno = MESHLINK_EINVAL;
-               return NULL;
-       }
-
-       pthread_mutex_lock(&(mesh->mesh_mutex));
-
-       meshlink_edge_t **result = NULL;
-       meshlink_edge_t *copy = NULL;
-       int result_size = 0;
-
-       result_size = mesh->edges->count;
-
-       // if result is smaller than edges, we have to dealloc all the excess meshlink_edge_t
-       if(result_size > *nmemb)
-               result = realloc(edges, result_size * sizeof(meshlink_edge_t *));
-       else
-               result = edges;
-
-       if(result) {
-               meshlink_edge_t **p = result;
-               int n = 0;
-               for splay_each(edge_t, e, mesh->edges) {
-                       // skip edges that do not represent a two-directional connection
-                       if((!e->reverse) || (e->reverse->to != e->from)) {
-                               result_size--;
-                               continue;
-                       }
-                       n++;
-                       // the first *nmemb members of result can be re-used
-                       if(n > *nmemb)
-                               copy = xzalloc(sizeof(*copy));
-                       else
-                               copy = *p;
-                       copy->from = (meshlink_node_t *)e->from;
-                       copy->to = (meshlink_node_t *)e->to;
-                       copy->address = e->address.storage;
-                       copy->options = e->options;
-                       copy->weight = e->weight;
-                       *p++ = copy;
-               }
-               // shrink result to the actual amount of memory used
-               for(int i = *nmemb; i > result_size; i--)
-                       free(result[i - 1]);
-               result = realloc(result, result_size * sizeof(meshlink_edge_t *));
-               *nmemb = result_size;
-       } else {
-               *nmemb = 0;
-               meshlink_errno = MESHLINK_ENOMEM;
-       }
-
-       pthread_mutex_unlock(&(mesh->mesh_mutex));
-
-       return result;
-}
-
 static bool channel_pre_accept(struct utcp *utcp, uint16_t port) {
-       //TODO: implement
-       return true;
+       node_t *n = utcp->priv;
+       meshlink_handle_t *mesh = n->mesh;
+       return mesh->channel_accept_cb;
 }
 
 static ssize_t channel_recv(struct utcp_connection *connection, const void *data, size_t len) {