Merge branch 'channels'

[meshlink] / src / meshlink.c

diff --git a/src/meshlink.c b/src/meshlink.c
index 1e2955ef2a02dc97b4e5926f6f70c173a4dfcc6f..ef02580ea93d641059eb203c7e3a8a17b14c1ab9 100644 (file)
--- a/src/meshlink.c
+++ b/src/meshlink.c
@@ -48,8 +48,6 @@ typedef struct {
 #define MSG_NOSIGNAL 0
 #endif
 
-static pthread_mutex_t global_mutex;
-
 __thread meshlink_errno_t meshlink_errno;
 meshlink_log_cb_t global_log_cb;
 meshlink_log_level_t global_log_level;
@@ -549,13 +547,14 @@ static bool invitation_receive(void *handle, uint8_t type, const void *msg, uint
                        return sptps_send_record(&(mesh->sptps), 0, mesh->cookie, sizeof mesh->cookie);
 
                case 0:
-                       mesh->data = xrealloc(mesh->data, len + 1);
-                       memcpy(mesh->data , msg, len);
-                       mesh->thedatalen = len;
-                       //mesh->data[mesh->thedatalen] = 0;
+                       mesh->data = xrealloc(mesh->data, mesh->thedatalen + len + 1);
+                       memcpy(mesh->data + mesh->thedatalen, msg, len);
+                       mesh->thedatalen += len;
+                       mesh->data[mesh->thedatalen] = 0;
                        break;
 
                case 1:
+                       mesh->thedatalen = 0;
                        return finalize_join(mesh);
 
                case 2:
@@ -874,6 +873,8 @@ bool meshlink_start(meshlink_handle_t *mesh) {
        
        logger(mesh, MESHLINK_DEBUG, "meshlink_start called\n");
 
+       mesh->thedatalen = 0;
+
        // TODO: open listening sockets first
 
        //Check that a valid name is set
@@ -1711,7 +1712,7 @@ char *meshlink_export(meshlink_handle_t *mesh) {
        fclose(f);
        buf[len - 1] = 0;
        
-       pthread_mutex_lock(&(mesh->mesh_mutex));
+       pthread_mutex_unlock(&(mesh->mesh_mutex));
        return buf;
 }
 
@@ -1833,7 +1834,10 @@ void meshlink_hint_address(meshlink_handle_t *mesh, meshlink_node_t *node, const
 
        if(host && port) {
                xasprintf(&str, "%s %s", host, port);
-               append_config_file(mesh, node->name, "Address", str);
+               if ( (strncmp ("fe80",host,4) != 0) && ( strncmp("127.",host,4) != 0 ) && ( strcmp("localhost",host) !=0 ) )
+                       append_config_file(mesh, node->name, "Address", str);
+               else
+                       logger(mesh, MESHLINK_DEBUG, "Not adding Link Local IPv6 Address to config\n");
        }
 
        free(str);
@@ -1910,6 +1914,76 @@ meshlink_edge_t **meshlink_get_all_edges_state(meshlink_handle_t *mesh, meshlink
        return result;
 }
 
+static bool channel_pre_accept(struct utcp *utcp, uint16_t port) {
+       //TODO: implement
+       return false;
+}
+
+static void channel_accept(struct utcp_connection *utcp_connection, uint16_t port) {
+       //TODO: implement
+}
+
+static int channel_recv(struct utcp_connection *connection, const void *data, size_t len) {
+       meshlink_channel_t *channel = connection->priv;
+       node_t *n = channel->node;
+       meshlink_handle_t *mesh = n->mesh;
+       if(!channel->receive_cb)
+               return -1;
+       else {
+               channel->receive_cb(mesh, channel, data, len);
+               return 0;
+       }
+}
+
+static int channel_send(struct utcp *utcp, const void *data, size_t len) {
+       node_t *n = utcp->priv;
+       meshlink_handle_t *mesh = n->mesh;
+       return meshlink_send(mesh, (meshlink_node_t *)n, data, len) ? len : -1;
+}
+
+void meshlink_set_channel_accept_cb(meshlink_handle_t *mesh, meshlink_channel_accept_cb_t cb) {
+       mesh->channel_accept_cb = cb;
+}
+
+void meshlink_set_channel_receive_cb(meshlink_handle_t *mesh, meshlink_channel_t *channel, meshlink_channel_receive_cb_t cb) {
+       channel->receive_cb = cb;
+}
+
+meshlink_channel_t *meshlink_channel_open(meshlink_handle_t *mesh, meshlink_node_t *node, uint16_t port, meshlink_channel_receive_cb_t cb, const void *data, size_t len) {
+       node_t *n = (node_t *)node;
+       if(!n->utcp) {
+               n->utcp = utcp_init(channel_accept, channel_pre_accept, channel_send, n);
+               if(!n->utcp)
+                       return NULL;
+       }
+       meshlink_channel_t *channel = xzalloc(sizeof *channel);
+       channel->node = n;
+       channel->receive_cb = cb;
+       channel->c = utcp_connect(n->utcp, port, channel_recv, channel);
+       if(!channel->c) {
+               free(channel);
+               return NULL;
+       }
+       return channel;
+}
+
+void meshlink_channel_shutdown(meshlink_handle_t *mesh, meshlink_channel_t *channel, int direction) {
+       utcp_shutdown(channel->c, direction);
+}
+
+void meshlink_channel_close(meshlink_handle_t *mesh, meshlink_channel_t *channel) {
+       utcp_close(channel->c);
+       free(channel);
+}
+
+ssize_t meshlink_channel_send(meshlink_handle_t *mesh, meshlink_channel_t *channel, const void *data, size_t len) {
+       // TODO: locking.
+       // Ideally we want to put the data into the UTCP connection's send buffer.
+       // Then, preferrably only if there is room in the receiver window,
+       // kick the meshlink thread to go send packets.
+       return utcp_send(channel->c, data, len);
+}
+
 static void __attribute__((constructor)) meshlink_init(void) {
        crypto_init();
 }