X-Git-Url: http://git.meshlink.io/?a=blobdiff_plain;f=src%2Fmeshlink.c;h=42573c8ffa6f68837fb1e06f3a567f0baefbdbd9;hb=c023ad12147aa88810629c110ea6b1ab94267196;hp=134abd83da5e548c3640a1dc056ec107ea189063;hpb=53522b1c11222273c7b41f72b374e759d13b2165;p=meshlink

diff --git a/src/meshlink.c b/src/meshlink.c
index 134abd83..42573c8f 100644
--- a/src/meshlink.c
+++ b/src/meshlink.c
@@ -531,6 +531,10 @@ int check_port(meshlink_handle_t *mesh) {
 }
 
 static bool write_main_config_files(meshlink_handle_t *mesh) {
+	if(!mesh->confbase) {
+		return true;
+	}
+
 	uint8_t buf[4096];
 
 	/* Write the main config file */
@@ -548,7 +552,7 @@ static bool write_main_config_files(meshlink_handle_t *mesh) {
 
 	config_t config = {buf, packmsg_output_size(&out, buf)};
 
-	if(!main_config_write(mesh, &config)) {
+	if(!main_config_write(mesh, "current", &config, mesh->config_key)) {
 		return false;
 	}
 
@@ -595,10 +599,10 @@ static bool finalize_join(meshlink_handle_t *mesh, const void *buf, uint16_t len
 	free(mesh->self->name);
 	mesh->name = name;
 	mesh->self->name = xstrdup(name);
-	mesh->self->devclass = devclass;
+	mesh->self->devclass = devclass == DEV_CLASS_UNKNOWN ? mesh->devclass : devclass;
 
 	// Initialize configuration directory
-	if(!config_init(mesh)) {
+	if(!config_init(mesh, "current")) {
 		return false;
 	}
 
@@ -652,7 +656,7 @@ static bool finalize_join(meshlink_handle_t *mesh, const void *buf, uint16_t len
 
 		node_add(mesh, n);
 
-		if(!config_write(mesh, n->name, &config)) {
+		if(!config_write(mesh, "current", n->name, &config, mesh->config_key)) {
 			return false;
 		}
 	}
@@ -740,8 +744,9 @@ static bool recvline(meshlink_handle_t *mesh, size_t len) {
 
 	return true;
 }
+
 static bool sendline(int fd, char *format, ...) {
-	static char buffer[4096];
+	char buffer[4096];
 	char *p = buffer;
 	int blen = 0;
 	va_list ap;
@@ -856,8 +861,8 @@ static void add_local_addresses(meshlink_handle_t *mesh) {
 }
 
 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));
+	if(!config_init(mesh, "current")) {
+		logger(mesh, MESHLINK_ERROR, "Could not set up configuration in %s/current: %s\n", mesh->confbase, strerror(errno));
 		meshlink_errno = MESHLINK_ESTORAGE;
 		return false;
 	}
@@ -880,6 +885,8 @@ static bool meshlink_setup(meshlink_handle_t *mesh) {
 	mesh->self->ecdsa = ecdsa_set_public_key(ecdsa_get_public_key(mesh->private_key));
 
 	if(!write_main_config_files(mesh)) {
+		logger(mesh, MESHLINK_ERROR, "Could not write main config files into %s/current: %s\n", mesh->confbase, strerror(errno));
+		meshlink_errno = MESHLINK_ESTORAGE;
 		return false;
 	}
 
@@ -902,7 +909,7 @@ static bool meshlink_read_config(meshlink_handle_t *mesh) {
 
 	config_t config;
 
-	if(!main_config_read(mesh, &config)) {
+	if(!main_config_read(mesh, "current", &config, mesh->config_key)) {
 		logger(NULL, MESHLINK_ERROR, "Could not read main configuration file!");
 		return false;
 	}
@@ -1051,6 +1058,85 @@ bool meshlink_open_params_set_storage_key(meshlink_open_params_t *params, const
 	return true;
 }
 
+bool meshlink_encrypted_key_rotate(meshlink_handle_t *mesh, const void *new_key, size_t new_keylen) {
+	if(!mesh || !new_key || !new_keylen) {
+		logger(mesh, MESHLINK_ERROR, "Invalid arguments given!\n");
+		meshlink_errno = MESHLINK_EINVAL;
+		return false;
+	}
+
+	pthread_mutex_lock(&(mesh->mesh_mutex));
+
+	// Create hash for the new key
+	void *new_config_key;
+	new_config_key = xmalloc(CHACHA_POLY1305_KEYLEN);
+
+	if(!prf(new_key, new_keylen, "MeshLink configuration key", 26, new_config_key, CHACHA_POLY1305_KEYLEN)) {
+		logger(mesh, MESHLINK_ERROR, "Error creating new configuration key!\n");
+		meshlink_errno = MESHLINK_EINTERNAL;
+		pthread_mutex_unlock(&(mesh->mesh_mutex));
+		return false;
+	}
+
+	// Copy contents of the "current" confbase sub-directory to "new" confbase sub-directory with the new key
+
+	if(!config_copy(mesh, "current", mesh->config_key, "new", new_config_key)) {
+		logger(mesh, MESHLINK_ERROR, "Could not set up configuration in %s/old: %s\n", mesh->confbase, strerror(errno));
+		meshlink_errno = MESHLINK_ESTORAGE;
+		pthread_mutex_unlock(&(mesh->mesh_mutex));
+		return false;
+	}
+
+	devtool_keyrotate_probe(1);
+
+	main_config_unlock(mesh);
+
+	// Rename confbase/current/ to confbase/old
+
+	if(!config_rename(mesh, "current", "old")) {
+		logger(mesh, MESHLINK_ERROR, "Cannot rename %s/current to %s/old\n", mesh->confbase, mesh->confbase);
+		meshlink_errno = MESHLINK_ESTORAGE;
+		main_config_lock(mesh);
+		pthread_mutex_unlock(&(mesh->mesh_mutex));
+		return false;
+	}
+
+	devtool_keyrotate_probe(2);
+
+	// Rename confbase/new/ to confbase/current
+
+	if(!config_rename(mesh, "new", "current")) {
+		logger(mesh, MESHLINK_ERROR, "Cannot rename %s/new to %s/current\n", mesh->confbase, mesh->confbase);
+		meshlink_errno = MESHLINK_ESTORAGE;
+		main_config_lock(mesh);
+		pthread_mutex_unlock(&(mesh->mesh_mutex));
+		return false;
+	}
+
+	devtool_keyrotate_probe(3);
+
+	if(!main_config_lock(mesh)) {
+		pthread_mutex_unlock(&(mesh->mesh_mutex));
+		return false;
+	}
+
+	// Cleanup the "old" confbase sub-directory
+
+	if(!config_destroy(mesh->confbase, "old")) {
+		pthread_mutex_unlock(&(mesh->mesh_mutex));
+		return false;
+	}
+
+	// Change the mesh handle key with new key
+
+	free(mesh->config_key);
+	mesh->config_key = new_config_key;
+
+	pthread_mutex_unlock(&(mesh->mesh_mutex));
+
+	return true;
+}
+
 void meshlink_open_params_free(meshlink_open_params_t *params) {
 	if(!params) {
 		meshlink_errno = MESHLINK_EINVAL;
@@ -1206,7 +1292,7 @@ meshlink_handle_t *meshlink_open_ex(const meshlink_open_params_t *params) {
 
 	// If no configuration exists yet, create it.
 
-	if(!main_config_exists(mesh)) {
+	if(!meshlink_confbase_exists(mesh)) {
 		if(!meshlink_setup(mesh)) {
 			logger(NULL, MESHLINK_ERROR, "Cannot create initial configuration\n");
 			meshlink_close(mesh);
@@ -1296,21 +1382,42 @@ static void *meshlink_main_loop(void *arg) {
 #ifdef HAVE_SETNS
 
 		if(setns(mesh->netns, CLONE_NEWNET) != 0) {
+			pthread_cond_signal(&mesh->cond);
 			return NULL;
 		}
 
 #else
+		pthread_cond_signal(&mesh->cond);
 		return NULL;
 #endif // HAVE_SETNS
 	}
 
+#if HAVE_CATTA
+
+	if(mesh->discovery) {
+		discovery_start(mesh);
+	}
+
+#endif
+
 	pthread_mutex_lock(&(mesh->mesh_mutex));
 
 	logger(mesh, MESHLINK_DEBUG, "Starting main_loop...\n");
+	pthread_cond_broadcast(&mesh->cond);
 	main_loop(mesh);
 	logger(mesh, MESHLINK_DEBUG, "main_loop returned.\n");
 
 	pthread_mutex_unlock(&(mesh->mesh_mutex));
+
+#if HAVE_CATTA
+
+	// Stop discovery
+	if(mesh->discovery) {
+		discovery_stop(mesh);
+	}
+
+#endif
+
 	return NULL;
 }
 
@@ -1327,6 +1434,9 @@ bool meshlink_start(meshlink_handle_t *mesh) {
 
 	pthread_mutex_lock(&(mesh->mesh_mutex));
 
+	assert(mesh->self->ecdsa);
+	assert(!memcmp((uint8_t *)mesh->self->ecdsa + 64, (uint8_t *)mesh->private_key + 64, 32));
+
 	if(mesh->threadstarted) {
 		logger(mesh, MESHLINK_DEBUG, "thread was already running\n");
 		pthread_mutex_unlock(&(mesh->mesh_mutex));
@@ -1366,20 +1476,9 @@ bool meshlink_start(meshlink_handle_t *mesh) {
 		return false;
 	}
 
+	pthread_cond_wait(&mesh->cond, &mesh->mesh_mutex);
 	mesh->threadstarted = true;
 
-#if HAVE_CATTA
-
-	if(mesh->discovery) {
-		discovery_start(mesh);
-	}
-
-#endif
-
-	assert(mesh->self->ecdsa);
-	assert(!memcmp((uint8_t *)mesh->self->ecdsa + 64, (uint8_t *)mesh->private_key + 64, 32));
-
-
 	pthread_mutex_unlock(&(mesh->mesh_mutex));
 	return true;
 }
@@ -1393,15 +1492,6 @@ void meshlink_stop(meshlink_handle_t *mesh) {
 	pthread_mutex_lock(&(mesh->mesh_mutex));
 	logger(mesh, MESHLINK_DEBUG, "meshlink_stop called\n");
 
-#if HAVE_CATTA
-
-	// Stop discovery
-	if(mesh->discovery) {
-		discovery_stop(mesh);
-	}
-
-#endif
-
 	// Shut down the main thread
 	event_loop_stop(&mesh->loop);
 
@@ -1508,7 +1598,21 @@ bool meshlink_destroy(const char *confbase) {
 		return false;
 	}
 
-	return config_destroy(confbase);
+	if(!config_destroy(confbase, "current")) {
+		logger(NULL, MESHLINK_ERROR, "Cannot remove confbase sub-directories %s: %s\n", confbase, strerror(errno));
+		return false;
+	}
+
+	config_destroy(confbase, "new");
+	config_destroy(confbase, "old");
+
+	if(rmdir(confbase) && errno != ENOENT) {
+		logger(NULL, MESHLINK_ERROR, "Cannot remove directory %s: %s\n", confbase, strerror(errno));
+		meshlink_errno = MESHLINK_ESTORAGE;
+		return false;
+	}
+
+	return true;
 }
 
 void meshlink_set_receive_cb(meshlink_handle_t *mesh, meshlink_receive_cb_t cb) {
@@ -1799,7 +1903,7 @@ static meshlink_node_t **meshlink_get_all_nodes_by_condition(meshlink_handle_t *
 static bool search_node_by_dev_class(const node_t *node, const void *condition) {
 	dev_class_t *devclass = (dev_class_t *)condition;
 
-	if(*devclass == node->devclass) {
+	if(*devclass == (dev_class_t)node->devclass) {
 		return true;
 	}
 
@@ -2043,6 +2147,7 @@ bool meshlink_set_port(meshlink_handle_t *mesh, int port) {
 	mesh->self = new_node();
 	mesh->self->name = xstrdup(mesh->name);
 	mesh->self->devclass = mesh->devclass;
+	xasprintf(&mesh->myport, "%d", port);
 
 	if(!node_read_public_key(mesh, mesh->self)) {
 		logger(NULL, MESHLINK_ERROR, "Could not read our host configuration file!");
@@ -2096,7 +2201,7 @@ char *meshlink_invite_ex(meshlink_handle_t *mesh, meshlink_submesh_t *submesh, c
 	}
 
 	// Ensure no host configuration file with that name exists
-	if(config_exists(mesh, name)) {
+	if(config_exists(mesh, "current", name)) {
 		logger(mesh, MESHLINK_DEBUG, "A host config file for %s already exists!\n", name);
 		meshlink_errno = MESHLINK_EEXIST;
 		pthread_mutex_unlock(&(mesh->mesh_mutex));
@@ -2166,7 +2271,7 @@ char *meshlink_invite_ex(meshlink_handle_t *mesh, meshlink_submesh_t *submesh, c
 	config_t configs[5] = {NULL};
 	int count = 0;
 
-	if(config_read(mesh, mesh->self->name, &configs[count])) {
+	if(config_read(mesh, "current", mesh->self->name, &configs[count], mesh->config_key)) {
 		count++;
 	}
 
@@ -2180,7 +2285,7 @@ char *meshlink_invite_ex(meshlink_handle_t *mesh, meshlink_submesh_t *submesh, c
 
 	config_t config = {outbuf, packmsg_output_size(&inv, outbuf)};
 
-	if(!invitation_write(mesh, cookiehash, &config)) {
+	if(!invitation_write(mesh, "current", cookiehash, &config, mesh->config_key)) {
 		logger(mesh, MESHLINK_DEBUG, "Could not create invitation file %s: %s\n", cookiehash, strerror(errno));
 		meshlink_errno = MESHLINK_ESTORAGE;
 		pthread_mutex_unlock(&(mesh->mesh_mutex));
@@ -2210,7 +2315,15 @@ bool meshlink_join(meshlink_handle_t *mesh, const char *invitation) {
 
 	//Before doing meshlink_join make sure we are not connected to another mesh
 	if(mesh->threadstarted) {
-		logger(mesh, MESHLINK_DEBUG, "Already connected to a mesh\n");
+		logger(mesh, MESHLINK_ERROR, "Cannot join while started\n");
+		meshlink_errno = MESHLINK_EINVAL;
+		pthread_mutex_unlock(&(mesh->mesh_mutex));
+		return false;
+	}
+
+	// Refuse to join a mesh if we are already part of one. We are part of one if we know at least one other node.
+	if(mesh->nodes->count > 1) {
+		logger(mesh, MESHLINK_ERROR, "Already part of an existing mesh\n");
 		meshlink_errno = MESHLINK_EINVAL;
 		pthread_mutex_unlock(&(mesh->mesh_mutex));
 		return false;
@@ -2574,7 +2687,7 @@ bool meshlink_import(meshlink_handle_t *mesh, const char *data) {
 			break;
 		}
 
-		config_write(mesh, n->name, &config);
+		config_write(mesh, "current", n->name, &config, mesh->config_key);
 		node_add(mesh, n);
 	}
 
@@ -2694,6 +2807,18 @@ static bool channel_pre_accept(struct utcp *utcp, uint16_t port) {
 	return mesh->channel_accept_cb;
 }
 
+static void aio_signal(meshlink_handle_t *mesh, meshlink_channel_t *channel, meshlink_aio_buffer_t *aio) {
+	if(aio->data) {
+		if(aio->cb.buffer) {
+			aio->cb.buffer(mesh, channel, aio->data, aio->len, aio->priv);
+		}
+	} else {
+		if(aio->cb.fd) {
+			aio->cb.fd(mesh, channel, aio->fd, aio->done, aio->priv);
+		}
+	}
+}
+
 static ssize_t channel_recv(struct utcp_connection *connection, const void *data, size_t len) {
 	meshlink_channel_t *channel = connection->priv;
 
@@ -2706,8 +2831,48 @@ static ssize_t channel_recv(struct utcp_connection *connection, const void *data
 
 	if(n->status.destroyed) {
 		meshlink_channel_close(mesh, channel);
-	} else if(channel->receive_cb) {
-		channel->receive_cb(mesh, channel, data, len);
+		return len;
+	}
+
+	const char *p = data;
+	size_t left = len;
+
+	while(channel->aio_receive) {
+		meshlink_aio_buffer_t *aio = channel->aio_receive;
+		size_t todo = aio->len - aio->done;
+
+		if(todo > left) {
+			todo = left;
+		}
+
+		if(aio->data) {
+			memcpy((char *)aio->data + aio->done, p, todo);
+		} else {
+			ssize_t result = write(aio->fd, p, todo);
+
+			if(result > 0) {
+				todo = result;
+			}
+		}
+
+		aio->done += todo;
+
+		if(aio->done == aio->len) {
+			channel->aio_receive = aio->next;
+			aio_signal(mesh, channel, aio);
+			free(aio);
+		}
+
+		p += todo;
+		left -= todo;
+
+		if(!left && len) {
+			return len;
+		}
+	}
+
+	if(channel->receive_cb) {
+		channel->receive_cb(mesh, channel, p, left);
 	}
 
 	return len;
@@ -2777,16 +2942,63 @@ static void channel_poll(struct utcp_connection *connection, size_t len) {
 
 	node_t *n = channel->node;
 	meshlink_handle_t *mesh = n->mesh;
+	meshlink_aio_buffer_t *aio = channel->aio_send;
+
+	if(aio) {
+		/* We at least one AIO buffer. Send as much as possible form the first buffer. */
+		size_t left = aio->len - aio->done;
+		ssize_t sent;
+
+		if(len > left) {
+			len = left;
+		}
+
+		if(aio->data) {
+			sent = utcp_send(connection, (char *)aio->data + aio->done, len);
+		} else {
+			char buf[65536];
+			size_t todo = utcp_get_sndbuf_free(connection);
+
+			if(todo > left) {
+				todo = left;
+			}
+
+			if(todo > sizeof(buf)) {
+				todo = sizeof(buf);
+			}
+
+			ssize_t result = read(aio->fd, buf, todo);
+
+			if(result > 0) {
+				sent = utcp_send(connection, buf, result);
+			} else {
+				sent = result;
+			}
+		}
 
-	if(channel->poll_cb) {
-		channel->poll_cb(mesh, channel, len);
+		if(sent >= 0) {
+			aio->done += sent;
+		}
+
+		/* If the buffer is now completely sent, call the callback and dispose of it. */
+		if(aio->done >= aio->len) {
+			channel->aio_send = aio->next;
+			aio_signal(mesh, channel, aio);
+			free(aio);
+		}
+	} else {
+		if(channel->poll_cb) {
+			channel->poll_cb(mesh, channel, len);
+		} else {
+			utcp_set_poll_cb(connection, NULL);
+		}
 	}
 }
 
 void meshlink_set_channel_poll_cb(meshlink_handle_t *mesh, meshlink_channel_t *channel, meshlink_channel_poll_cb_t cb) {
 	(void)mesh;
 	channel->poll_cb = cb;
-	utcp_set_poll_cb(channel->c, cb ? channel_poll : NULL);
+	utcp_set_poll_cb(channel->c, (cb || channel->aio_send) ? channel_poll : NULL);
 }
 
 void meshlink_set_channel_accept_cb(meshlink_handle_t *mesh, meshlink_channel_accept_cb_t cb) {
@@ -2808,6 +3020,32 @@ void meshlink_set_channel_accept_cb(meshlink_handle_t *mesh, meshlink_channel_ac
 	pthread_mutex_unlock(&mesh->mesh_mutex);
 }
 
+void meshlink_set_channel_sndbuf(meshlink_handle_t *mesh, meshlink_channel_t *channel, size_t size) {
+	(void)mesh;
+
+	if(!channel) {
+		meshlink_errno = MESHLINK_EINVAL;
+		return;
+	}
+
+	pthread_mutex_lock(&mesh->mesh_mutex);
+	utcp_set_sndbuf(channel->c, size);
+	pthread_mutex_unlock(&mesh->mesh_mutex);
+}
+
+void meshlink_set_channel_rcvbuf(meshlink_handle_t *mesh, meshlink_channel_t *channel, size_t size) {
+	(void)mesh;
+
+	if(!channel) {
+		meshlink_errno = MESHLINK_EINVAL;
+		return;
+	}
+
+	pthread_mutex_lock(&mesh->mesh_mutex);
+	utcp_set_rcvbuf(channel->c, size);
+	pthread_mutex_unlock(&mesh->mesh_mutex);
+}
+
 meshlink_channel_t *meshlink_channel_open_ex(meshlink_handle_t *mesh, meshlink_node_t *node, uint16_t port, meshlink_channel_receive_cb_t cb, const void *data, size_t len, uint32_t flags) {
 	if(data || len) {
 		abort();        // TODO: handle non-NULL data
@@ -2869,6 +3107,20 @@ void meshlink_channel_close(meshlink_handle_t *mesh, meshlink_channel_t *channel
 	}
 
 	utcp_close(channel->c);
+
+	/* Clean up any outstanding AIO buffers. */
+	for(meshlink_aio_buffer_t *aio = channel->aio_send, *next; aio; aio = next) {
+		next = aio->next;
+		aio_signal(mesh, channel, aio);
+		free(aio);
+	}
+
+	for(meshlink_aio_buffer_t *aio = channel->aio_receive, *next; aio; aio = next) {
+		next = aio->next;
+		aio_signal(mesh, channel, aio);
+		free(aio);
+	}
+
 	free(channel);
 }
 
@@ -2892,8 +3144,17 @@ ssize_t meshlink_channel_send(meshlink_handle_t *mesh, meshlink_channel_t *chann
 	// Then, preferably only if there is room in the receiver window,
 	// kick the meshlink thread to go send packets.
 
+	ssize_t retval;
+
 	pthread_mutex_lock(&mesh->mesh_mutex);
-	ssize_t retval = utcp_send(channel->c, data, len);
+
+	/* Disallow direct calls to utcp_send() while we still have AIO active. */
+	if(channel->aio_send) {
+		retval = 0;
+	} else {
+		retval = utcp_send(channel->c, data, len);
+	}
+
 	pthread_mutex_unlock(&mesh->mesh_mutex);
 
 	if(retval < 0) {
@@ -2903,6 +3164,146 @@ ssize_t meshlink_channel_send(meshlink_handle_t *mesh, meshlink_channel_t *chann
 	return retval;
 }
 
+bool meshlink_channel_aio_send(meshlink_handle_t *mesh, meshlink_channel_t *channel, const void *data, size_t len, meshlink_aio_cb_t cb, void *priv) {
+	if(!mesh || !channel) {
+		meshlink_errno = MESHLINK_EINVAL;
+		return false;
+	}
+
+	if(!len || !data) {
+		meshlink_errno = MESHLINK_EINVAL;
+		return false;
+	}
+
+	meshlink_aio_buffer_t *aio = xzalloc(sizeof(*aio));
+	aio->data = data;
+	aio->len = len;
+	aio->cb.buffer = cb;
+	aio->priv = priv;
+
+	pthread_mutex_lock(&mesh->mesh_mutex);
+
+	/* Append the AIO buffer descriptor to the end of the chain */
+	meshlink_aio_buffer_t **p = &channel->aio_send;
+
+	while(*p) {
+		p = &(*p)->next;
+	}
+
+	*p = aio;
+
+	/* Ensure the poll callback is set, and call it right now to push data if possible */
+	utcp_set_poll_cb(channel->c, channel_poll);
+	channel_poll(channel->c, len);
+
+	pthread_mutex_unlock(&mesh->mesh_mutex);
+
+	return true;
+}
+
+bool meshlink_channel_aio_fd_send(meshlink_handle_t *mesh, meshlink_channel_t *channel, int fd, size_t len, meshlink_aio_fd_cb_t cb, void *priv) {
+	if(!mesh || !channel) {
+		meshlink_errno = MESHLINK_EINVAL;
+		return false;
+	}
+
+	if(!len || fd == -1) {
+		meshlink_errno = MESHLINK_EINVAL;
+		return false;
+	}
+
+	meshlink_aio_buffer_t *aio = xzalloc(sizeof(*aio));
+	aio->fd = fd;
+	aio->len = len;
+	aio->cb.fd = cb;
+	aio->priv = priv;
+
+	pthread_mutex_lock(&mesh->mesh_mutex);
+
+	/* Append the AIO buffer descriptor to the end of the chain */
+	meshlink_aio_buffer_t **p = &channel->aio_send;
+
+	while(*p) {
+		p = &(*p)->next;
+	}
+
+	*p = aio;
+
+	/* Ensure the poll callback is set, and call it right now to push data if possible */
+	utcp_set_poll_cb(channel->c, channel_poll);
+	channel_poll(channel->c, len);
+
+	pthread_mutex_unlock(&mesh->mesh_mutex);
+
+	return true;
+}
+
+bool meshlink_channel_aio_receive(meshlink_handle_t *mesh, meshlink_channel_t *channel, const void *data, size_t len, meshlink_aio_cb_t cb, void *priv) {
+	if(!mesh || !channel) {
+		meshlink_errno = MESHLINK_EINVAL;
+		return false;
+	}
+
+	if(!len || !data) {
+		meshlink_errno = MESHLINK_EINVAL;
+		return false;
+	}
+
+	meshlink_aio_buffer_t *aio = xzalloc(sizeof(*aio));
+	aio->data = data;
+	aio->len = len;
+	aio->cb.buffer = cb;
+	aio->priv = priv;
+
+	pthread_mutex_lock(&mesh->mesh_mutex);
+
+	/* Append the AIO buffer descriptor to the end of the chain */
+	meshlink_aio_buffer_t **p = &channel->aio_receive;
+
+	while(*p) {
+		p = &(*p)->next;
+	}
+
+	*p = aio;
+
+	pthread_mutex_unlock(&mesh->mesh_mutex);
+
+	return true;
+}
+
+bool meshlink_channel_aio_fd_receive(meshlink_handle_t *mesh, meshlink_channel_t *channel, int fd, size_t len, meshlink_aio_fd_cb_t cb, void *priv) {
+	if(!mesh || !channel) {
+		meshlink_errno = MESHLINK_EINVAL;
+		return false;
+	}
+
+	if(!len || fd == -1) {
+		meshlink_errno = MESHLINK_EINVAL;
+		return false;
+	}
+
+	meshlink_aio_buffer_t *aio = xzalloc(sizeof(*aio));
+	aio->fd = fd;
+	aio->len = len;
+	aio->cb.fd = cb;
+	aio->priv = priv;
+
+	pthread_mutex_lock(&mesh->mesh_mutex);
+
+	/* Append the AIO buffer descriptor to the end of the chain */
+	meshlink_aio_buffer_t **p = &channel->aio_receive;
+
+	while(*p) {
+		p = &(*p)->next;
+	}
+
+	*p = aio;
+
+	pthread_mutex_unlock(&mesh->mesh_mutex);
+
+	return true;
+}
+
 uint32_t meshlink_channel_get_flags(meshlink_handle_t *mesh, meshlink_channel_t *channel) {
 	if(!mesh || !channel) {
 		meshlink_errno = MESHLINK_EINVAL;
@@ -2982,6 +3383,16 @@ end:
 #endif
 }
 
+void handle_network_change(meshlink_handle_t *mesh, bool online) {
+	(void)online;
+
+	if(!mesh->connections) {
+		return;
+	}
+
+	retry(mesh);
+}
+
 static void __attribute__((constructor)) meshlink_init(void) {
 	crypto_init();
 	unsigned int seed;
@@ -2994,7 +3405,7 @@ static void __attribute__((destructor)) meshlink_exit(void) {
 }
 
 /// Device class traits
-dev_class_traits_t dev_class_traits[_DEV_CLASS_MAX + 1] = {
+const dev_class_traits_t dev_class_traits[_DEV_CLASS_MAX + 1] = {
 	{ .min_connects = 3, .max_connects = 10000, .edge_weight = 1 }, // DEV_CLASS_BACKBONE
 	{ .min_connects = 3, .max_connects = 100, .edge_weight = 3 },   // DEV_CLASS_STATIONARY
 	{ .min_connects = 3, .max_connects = 3, .edge_weight = 6 },             // DEV_CLASS_PORTABLE