From d4f1bfacd6e7add63982692e89af39ec66c24b60 Mon Sep 17 00:00:00 2001
From: Guus Sliepen <guus@meshlink.io>
Date: Sat, 26 Jul 2014 19:45:51 +0200
Subject: [PATCH] A first attempt at merging UTCP into MeshLink.

The accept callbacks are a bit awkward at the moment, it's better if
UTCP drops the pre_accept and just has one callback.
---
 src/meshlink.c          | 70 +++++++++++++++++++++++++++++++++++++++++
 src/meshlink_internal.h |  9 ++++++
 src/node.h              |  5 +++
 3 files changed, 84 insertions(+)

diff --git a/src/meshlink.c b/src/meshlink.c
index 27ba877a..f44dba47 100644
--- a/src/meshlink.c
+++ b/src/meshlink.c
@@ -1381,6 +1381,76 @@ void meshlink_blacklist(meshlink_handle_t *mesh, meshlink_node_t *node) {
 
 }
 
+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();
 }
diff --git a/src/meshlink_internal.h b/src/meshlink_internal.h
index 7c3a7d4c..0e035920 100644
--- a/src/meshlink_internal.h
+++ b/src/meshlink_internal.h
@@ -65,6 +65,8 @@ struct meshlink_handle {
 	meshlink_log_cb_t log_cb;
 	meshlink_log_level_t log_level;
 
+	meshlink_channel_accept_cb_t channel_accept_cb;
+
 	pthread_t thread;
 	bool threadstarted;
 	pthread_mutex_t outpacketqueue_mutex;
@@ -132,6 +134,13 @@ struct meshlink_node {
 	void *priv;
 };
 
+/// A channel.
+struct meshlink_channel {
+	struct utcp_connection *c;
+	struct node_t *node;
+	meshlink_channel_receive_cb_t receive_cb;
+};
+
 /// Header for data packets routed between nodes
 typedef struct meshlink_packethdr {
 	uint8_t destination[16];
diff --git a/src/node.h b/src/node.h
index 4f0f1308..427bc83a 100644
--- a/src/node.h
+++ b/src/node.h
@@ -23,6 +23,7 @@
 #include "event.h"
 #include "sockaddr.h"
 #include "sptps.h"
+#include "utcp/utcp.h"
 
 typedef struct node_status_t {
 	unsigned int unused_active:1;           /* 1 if active (not used for nodes) */
@@ -40,6 +41,8 @@ typedef struct node_status_t {
 
 typedef struct node_t {
 	char *name;                             /* name of this node */
+	void *priv;
+
 	uint32_t options;                       /* options turned on for this node */
 
 	struct meshlink_handle *mesh;           /* The mesh this node belongs to */
@@ -85,6 +88,8 @@ typedef struct node_t {
 	float bandwidth;                        /* Last measured bandwidth */
 	float packetloss;                       /* Last measured packet loss rate */
 
+	struct utcp *utcp;
+
 	uint64_t in_packets;
 	uint64_t in_bytes;
 	uint64_t out_packets;
-- 
2.39.2