From 39f2e20489cbc3e924547b684340bf722a0df028 Mon Sep 17 00:00:00 2001
From: Guus Sliepen <guus@meshlink.io>
Date: Fri, 23 Apr 2021 09:30:18 +0200
Subject: [PATCH] Add meshlink_channel_abort().

This is similar to meshlink_channel_close(), but resets the UTCP channel
instead of doing a normal FIN shutdown. It will also drop the send and
receive buffers.
---
 src/meshlink++.h | 18 ++++++++++++++++++
 src/meshlink.c   | 26 ++++++++++++++++++++++++++
 src/meshlink.h   | 16 +++++++++++++++-
 src/meshlink.sym |  1 +
 src/utcp.c       |  3 +++
 5 files changed, 63 insertions(+), 1 deletion(-)

diff --git a/src/meshlink++.h b/src/meshlink++.h
index baf08ae1..25fd34f3 100644
--- a/src/meshlink++.h
+++ b/src/meshlink++.h
@@ -1012,12 +1012,30 @@ public:
 	 *  It also causes the local node to stop accepting incoming data from the remote node.
 	 *  Afterwards, the channel handle is invalid and must not be used any more.
 	 *
+	 *  It is allowed to call this function at any time on a valid handle, even inside callback functions.
+	 *  If called with a valid handle, this function always succeeds, otherwise the result is undefined.
+	 *
 	 *  @param channel      A handle for the channel.
 	 */
 	void channel_close(meshlink_channel_t *channel) {
 		return meshlink_channel_close(handle, channel);
 	}
 
+	/// Abort a reliable stream channel.
+	/** This aborts a channel.
+	 *  Data that was in the send and receive buffers is dropped, so potentially there is some data that
+	 *  was sent on this channel that will not be received by the peer.
+	 *  Afterwards, the channel handle is invalid and must not be used any more.
+	 *
+	 *  It is allowed to call this function at any time on a valid handle, even inside callback functions.
+	 *  If called with a valid handle, this function always succeeds, otherwise the result is undefined.
+	 *
+	 *  @param channel      A handle for the channel.
+	 */
+	void channel_abort(meshlink_channel_t *channel) {
+		return meshlink_channel_abort(handle, channel);
+	}
+
 	/// Transmit data on a channel
 	/** This queues data to send to the remote node.
 	 *
diff --git a/src/meshlink.c b/src/meshlink.c
index 63feee2c..4280c4f1 100644
--- a/src/meshlink.c
+++ b/src/meshlink.c
@@ -4252,6 +4252,32 @@ void meshlink_channel_close(meshlink_handle_t *mesh, meshlink_channel_t *channel
 	pthread_mutex_unlock(&mesh->mutex);
 }
 
+void meshlink_channel_abort(meshlink_handle_t *mesh, meshlink_channel_t *channel) {
+	if(!mesh || !channel) {
+		meshlink_errno = MESHLINK_EINVAL;
+		return;
+	}
+
+	if(pthread_mutex_lock(&mesh->mutex) != 0) {
+		abort();
+	}
+
+	if(channel->c) {
+		utcp_abort(channel->c);
+		channel->c = NULL;
+
+		/* Clean up any outstanding AIO buffers. */
+		aio_abort(mesh, channel, &channel->aio_send);
+		aio_abort(mesh, channel, &channel->aio_receive);
+	}
+
+	if(!channel->in_callback) {
+		free(channel);
+	}
+
+	pthread_mutex_unlock(&mesh->mutex);
+}
+
 ssize_t meshlink_channel_send(meshlink_handle_t *mesh, meshlink_channel_t *channel, const void *data, size_t len) {
 	if(!mesh || !channel) {
 		meshlink_errno = MESHLINK_EINVAL;
diff --git a/src/meshlink.h b/src/meshlink.h
index 3e372865..a6c5b4b9 100644
--- a/src/meshlink.h
+++ b/src/meshlink.h
@@ -1531,7 +1531,6 @@ void meshlink_channel_shutdown(struct meshlink_handle *mesh, struct meshlink_cha
 /// Close a reliable stream channel.
 /** This informs the remote node that the local node has finished sending all data on the channel.
  *  It also causes the local node to stop accepting incoming data from the remote node.
- *  It will free the struct meshlink_channel and all associated resources.
  *  Afterwards, the channel handle is invalid and must not be used any more.
  *
  *  It is allowed to call this function at any time on a valid handle, even inside callback functions.
@@ -1543,6 +1542,21 @@ void meshlink_channel_shutdown(struct meshlink_handle *mesh, struct meshlink_cha
  */
 void meshlink_channel_close(struct meshlink_handle *mesh, struct meshlink_channel *channel);
 
+/// Abort a reliable stream channel.
+/** This aborts a channel.
+ *  Data that was in the send and receive buffers is dropped, so potentially there is some data that
+ *  was sent on this channel that will not be received by the peer.
+ *  Afterwards, the channel handle is invalid and must not be used any more.
+ *
+ *  It is allowed to call this function at any time on a valid handle, even inside callback functions.
+ *  If called with a valid handle, this function always succeeds, otherwise the result is undefined.
+ *
+ *  \memberof meshlink_channel
+ *  @param mesh         A handle which represents an instance of MeshLink.
+ *  @param channel      A handle for the channel.
+ */
+void meshlink_channel_abort(struct meshlink_handle *mesh, struct meshlink_channel *channel);
+
 /// Transmit data on a channel
 /** This queues data to send to the remote node.
  *
diff --git a/src/meshlink.sym b/src/meshlink.sym
index ce78f112..7c4de629 100644
--- a/src/meshlink.sym
+++ b/src/meshlink.sym
@@ -13,6 +13,7 @@ meshlink_add_external_address
 meshlink_add_invitation_address
 meshlink_blacklist
 meshlink_blacklist_by_name
+meshlink_channel_abort
 meshlink_channel_aio_fd_receive
 meshlink_channel_aio_fd_send
 meshlink_channel_aio_receive
diff --git a/src/utcp.c b/src/utcp.c
index 8b3509ef..e3070b89 100644
--- a/src/utcp.c
+++ b/src/utcp.c
@@ -2072,6 +2072,9 @@ static bool reset_connection(struct utcp_connection *c) {
 		return false;
 	}
 
+	buffer_clear(&c->sndbuf);
+	buffer_clear(&c->rcvbuf);
+
 	c->recv = NULL;
 	c->poll = NULL;
 
-- 
2.39.5