X-Git-Url: http://git.meshlink.io/?a=blobdiff_plain;f=src%2Futcp.c;h=ca91bee26ef6d21c0f0f57dd743c27c0f9b14f8b;hb=2bd86439e6cee8742a01bb715461be62f6d33ac8;hp=2fe650508dc90b0c52718a3a71bb16cf6b031262;hpb=773e88d3742739e1a6375b166967d8595965b0e7;p=meshlink

diff --git a/src/utcp.c b/src/utcp.c
index 2fe65050..ca91bee2 100644
--- a/src/utcp.c
+++ b/src/utcp.c
@@ -196,6 +196,16 @@ static bool buffer_wraps(struct buffer *buf) {
 }
 
 static bool buffer_resize(struct buffer *buf, uint32_t newsize) {
+	assert(!buf->external);
+
+	if(!newsize) {
+		free(buf->data);
+		buf->data = NULL;
+		buf->size = 0;
+		buf->offset = 0;
+		return true;
+	}
+
 	char *newdata = realloc(buf->data, newsize);
 
 	if(!newdata) {
@@ -395,6 +405,94 @@ static bool buffer_set_size(struct buffer *buf, uint32_t minsize, uint32_t maxsi
 	return buf->size >= minsize || buffer_resize(buf, minsize);
 }
 
+static void buffer_transfer(struct buffer *buf, char *newdata, size_t newsize) {
+	if(buffer_wraps(buf)) {
+		// Old situation:
+		// [345......012]
+		// New situation:
+		// [012345......]
+		uint32_t tailsize = buf->size - buf->offset;
+		memcpy(newdata, buf->data + buf->offset, tailsize);
+		memcpy(newdata + tailsize, buf->data, buf->used - tailsize);
+	} else {
+		// Old situation:
+		// [....012345..]
+		// New situation:
+		// [012345......]
+		memcpy(newdata, buf->data + buf->offset, buf->used);
+	}
+
+	buf->offset = 0;
+	buf->size = newsize;
+}
+
+static void set_buffer_storage(struct buffer *buf, char *data, size_t size) {
+	if(size > UINT32_MAX) {
+		size = UINT32_MAX;
+	}
+
+	buf->maxsize = size;
+
+	if(data) {
+		if(buf->external) {
+			// Don't allow resizing an external buffer
+			abort();
+		}
+
+		if(size < buf->used) {
+			// Ignore requests for an external buffer if we are already using more than it can store
+			return;
+		}
+
+		// Transition from internal to external buffer
+		buffer_transfer(buf, data, size);
+		free(buf->data);
+		buf->data = data;
+		buf->external = true;
+	} else if(buf->external) {
+		// Transition from external to internal buf
+		size_t minsize = buf->used <= DEFAULT_SNDBUFSIZE ? DEFAULT_SNDBUFSIZE : buf->used;
+
+		if(minsize) {
+			data = malloc(minsize);
+
+			if(!data) {
+				// Cannot handle this
+				abort();
+			}
+
+			buffer_transfer(buf, data, minsize);
+			buf->data = data;
+		} else {
+			buf->data = NULL;
+			buf->size = 0;
+		}
+
+		buf->external = false;
+	} else {
+		// Don't do anything if the buffer wraps
+		if(buffer_wraps(buf)) {
+			return;
+		}
+
+		// Realloc internal storage
+		size_t minsize = max(DEFAULT_SNDBUFSIZE, buf->offset + buf->used);
+
+		if(minsize) {
+			data = realloc(buf->data, minsize);
+
+			if(data) {
+				buf->data = data;
+				buf->size = minsize;
+			}
+		} else {
+			free(buf->data);
+			buf->data = NULL;
+			buf->size = 0;
+		}
+	}
+}
+
 static void buffer_exit(struct buffer *buf) {
 	if(!buf->external) {
 		free(buf->data);
@@ -1502,6 +1600,8 @@ synack:
 			// The peer has aborted our connection.
 			set_state(c, CLOSED);
 			errno = ECONNRESET;
+			buffer_clear(&c->sndbuf);
+			buffer_clear(&c->rcvbuf);
 
 			if(c->recv) {
 				c->recv(c, NULL, 0);
@@ -1974,8 +2074,8 @@ static bool reset_connection(struct utcp_connection *c) {
 		return false;
 	}
 
-	c->recv = NULL;
-	c->poll = NULL;
+	buffer_clear(&c->sndbuf);
+	buffer_clear(&c->rcvbuf);
 
 	switch(c->state) {
 	case CLOSED:
@@ -2008,14 +2108,24 @@ static bool reset_connection(struct utcp_connection *c) {
 	hdr.ack = c->rcv.nxt;
 	hdr.wnd = 0;
 	hdr.ctl = RST;
+	hdr.aux = 0;
 
 	print_packet(c, "send", &hdr, sizeof(hdr));
 	c->utcp->send(c->utcp, &hdr, sizeof(hdr));
 	return true;
 }
 
-// Closes all the opened connections
-void utcp_abort_all_connections(struct utcp *utcp) {
+static void set_reapable(struct utcp_connection *c) {
+	set_buffer_storage(&c->sndbuf, NULL, min(c->sndbuf.maxsize, DEFAULT_MAXSNDBUFSIZE));
+	set_buffer_storage(&c->rcvbuf, NULL, min(c->rcvbuf.maxsize, DEFAULT_MAXRCVBUFSIZE));
+
+	c->recv = NULL;
+	c->poll = NULL;
+	c->reapable = true;
+}
+
+// Resets all connections, but does not invalidate connection handles
+void utcp_reset_all_connections(struct utcp *utcp) {
 	if(!utcp) {
 		errno = EINVAL;
 		return;
@@ -2028,19 +2138,16 @@ void utcp_abort_all_connections(struct utcp *utcp) {
 			continue;
 		}
 
-		utcp_recv_t old_recv = c->recv;
-		utcp_poll_t old_poll = c->poll;
-
 		reset_connection(c);
 
-		if(old_recv) {
+		if(c->recv) {
 			errno = 0;
-			old_recv(c, NULL, 0);
+			c->recv(c, NULL, 0);
 		}
 
-		if(old_poll && !c->reapable) {
+		if(c->poll && !c->reapable) {
 			errno = 0;
-			old_poll(c, 0);
+			c->poll(c, 0);
 		}
 	}
 
@@ -2052,9 +2159,7 @@ int utcp_close(struct utcp_connection *c) {
 		return -1;
 	}
 
-	c->recv = NULL;
-	c->poll = NULL;
-	c->reapable = true;
+	set_reapable(c);
 	return 0;
 }
 
@@ -2063,7 +2168,7 @@ int utcp_abort(struct utcp_connection *c) {
 		return -1;
 	}
 
-	c->reapable = true;
+	set_reapable(c);
 	return 0;
 }
 
@@ -2099,6 +2204,8 @@ struct timespec utcp_timeout(struct utcp *utcp) {
 		if(timespec_isset(&c->conn_timeout) && timespec_lt(&c->conn_timeout, &now)) {
 			errno = ETIMEDOUT;
 			c->state = CLOSED;
+			buffer_clear(&c->sndbuf);
+			buffer_clear(&c->rcvbuf);
 
 			if(c->recv) {
 				c->recv(c, NULL, 0);
@@ -2201,6 +2308,9 @@ void utcp_exit(struct utcp *utcp) {
 		struct utcp_connection *c = utcp->connections[i];
 
 		if(!c->reapable) {
+			buffer_clear(&c->sndbuf);
+			buffer_clear(&c->rcvbuf);
+
 			if(c->recv) {
 				c->recv(c, NULL, 0);
 			}
@@ -2318,66 +2428,6 @@ size_t utcp_get_sndbuf_free(struct utcp_connection *c) {
 	}
 }
 
-static void buffer_transfer(struct buffer *buf, char *newdata, size_t newsize) {
-	if(buffer_wraps(buf)) {
-		// Old situation:
-		// [345......012]
-		// New situation:
-		// [012345......]
-		uint32_t tailsize = buf->size - buf->offset;
-		memcpy(newdata, buf->data + buf->offset, tailsize);
-		memcpy(newdata + tailsize, buf->data, buf->used - tailsize);
-	} else {
-		// Old situation:
-		// [....012345..]
-		// New situation:
-		// [012345......]
-		memcpy(newdata, buf->data + buf->offset, buf->used);
-	}
-
-	buf->offset = 0;
-	buf->size = newsize;
-}
-
-static void set_buffer_storage(struct buffer *buf, char *data, size_t size) {
-	if(size > UINT32_MAX) {
-		size = UINT32_MAX;
-	}
-
-	buf->maxsize = size;
-
-	if(data) {
-		if(buf->external) {
-			// Don't allow resizing an external buffer
-			abort();
-		}
-
-		if(size < buf->used) {
-			// Ignore requests for an external buffer if we are already using more than it can store
-			return;
-		}
-
-		// Transition from internal to external buffer
-		buffer_transfer(buf, data, size);
-		free(buf->data);
-		buf->data = data;
-		buf->external = true;
-	} else if(buf->external) {
-		// Transition from external to internal buf
-		size_t minsize = buf->used < DEFAULT_SNDBUFSIZE ? DEFAULT_SNDBUFSIZE : buf->used;
-		data = malloc(minsize);
-
-		if(!data) {
-			// Cannot handle this
-			abort();
-		}
-
-		buffer_transfer(buf, data, minsize);
-		buf->data = data;
-		buf->external = false;
-	}
-}
-
 void utcp_set_sndbuf(struct utcp_connection *c, void *data, size_t size) {
 	if(!c) {
 		return;