X-Git-Url: http://git.meshlink.io/?a=blobdiff_plain;f=utcp.c;h=5938ea5bcea6af1a99b9d2e885b8fd68bdf70435;hb=3bc564058072a79a22320f8c5bc50e8844896114;hp=7c4e5638ab0bbb04bf3e9e29898c5ac093b092a0;hpb=fad2787f2394bad3cf105ca5b4cf411db6d34aa6;p=utcp

diff --git a/utcp.c b/utcp.c
index 7c4e563..5938ea5 100644
--- a/utcp.c
+++ b/utcp.c
@@ -611,6 +611,20 @@ ssize_t utcp_send(struct utcp_connection *c, const void *data, size_t len) {
 		return -1;
 	}
 
+	// Check if we need to be able to buffer all data
+
+	if(c->flags & UTCP_NO_PARTIAL) {
+		if(len > buffer_free(&c->sndbuf)) {
+			if(len > c->sndbuf.maxsize) {
+				errno = EMSGSIZE;
+				return -1;
+			} else {
+				errno = EWOULDBLOCK;
+				return 0;
+			}
+		}
+	}
+
 	// Add data to send buffer.
 
 	len = buffer_put(&c->sndbuf, data, len);
@@ -624,8 +638,9 @@ ssize_t utcp_send(struct utcp_connection *c, const void *data, size_t len) {
 
 	// Don't send anything yet if the connection has not fully established yet
 
-	if (c->state == SYN_SENT || c->state == SYN_RECEIVED)
+	if(c->state == SYN_SENT || c->state == SYN_RECEIVED) {
 		return len;
+	}
 
 	ack(c, false);
 
@@ -638,6 +653,11 @@ ssize_t utcp_send(struct utcp_connection *c, const void *data, size_t len) {
 		start_retransmit_timer(c);
 	}
 
+	if(is_reliable(c) && !timerisset(&c->conn_timeout)) {
+		gettimeofday(&c->conn_timeout, NULL);
+		c->conn_timeout.tv_sec += c->utcp->timeout;
+	}
+
 	return len;
 }
 
@@ -1333,12 +1353,13 @@ ssize_t utcp_recv(struct utcp *utcp, const void *data, size_t len) {
 	// 4. Update timers
 
 	if(advanced) {
-		timerclear(&c->conn_timeout); // It will be set anew in utcp_timeout() if c->snd.una != c->snd.nxt.
-
 		if(c->snd.una == c->snd.last) {
 			stop_retransmit_timer(c);
+			timerclear(&c->conn_timeout);
 		} else if(is_reliable(c)) {
 			start_retransmit_timer(c);
+			gettimeofday(&c->conn_timeout, NULL);
+			c->conn_timeout.tv_sec += utcp->timeout;
 		}
 	}
 
@@ -1356,12 +1377,14 @@ skip_ack:
 
 			c->rcv.irs = hdr.seq;
 			c->rcv.nxt = hdr.seq;
+
 			if(c->shut_wr) {
 				c->snd.last++;
 				set_state(c, FIN_WAIT_1);
 			} else {
 				set_state(c, ESTABLISHED);
 			}
+
 			// TODO: notify application of this somehow.
 			break;
 
@@ -1550,8 +1573,9 @@ int utcp_shutdown(struct utcp_connection *c, int dir) {
 	}
 
 	// Only process shutting down writes once.
-	if (c->shut_wr)
+	if(c->shut_wr) {
 		return 0;
+	}
 
 	c->shut_wr = true;
 
@@ -1594,36 +1618,24 @@ int utcp_shutdown(struct utcp_connection *c, int dir) {
 	return 0;
 }
 
-int utcp_close(struct utcp_connection *c) {
-	if(utcp_shutdown(c, SHUT_RDWR) && errno != ENOTCONN) {
-		return -1;
-	}
-
-	c->recv = NULL;
-	c->poll = NULL;
-	c->reapable = true;
-	return 0;
-}
-
-int utcp_abort(struct utcp_connection *c) {
+static bool reset_connection(struct utcp_connection *c) {
 	if(!c) {
 		errno = EFAULT;
-		return -1;
+		return false;
 	}
 
 	if(c->reapable) {
 		debug("Error: abort() called on closed connection %p\n", c);
 		errno = EBADF;
-		return -1;
+		return false;
 	}
 
 	c->recv = NULL;
 	c->poll = NULL;
-	c->reapable = true;
 
 	switch(c->state) {
 	case CLOSED:
-		return 0;
+		return true;
 
 	case LISTEN:
 	case SYN_SENT:
@@ -1631,7 +1643,7 @@ int utcp_abort(struct utcp_connection *c) {
 	case LAST_ACK:
 	case TIME_WAIT:
 		set_state(c, CLOSED);
-		return 0;
+		return true;
 
 	case SYN_RECEIVED:
 	case ESTABLISHED:
@@ -1655,6 +1667,53 @@ int utcp_abort(struct utcp_connection *c) {
 
 	print_packet(c->utcp, "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) {
+	if(!utcp) {
+		errno = EINVAL;
+		return;
+	}
+
+	for(int i = 0; i < utcp->nconnections; i++) {
+		struct utcp_connection *c = utcp->connections[i];
+
+		if(c->reapable || c->state == CLOSED) {
+			continue;
+		}
+
+		utcp_recv_t old_recv = c->recv;
+
+		reset_connection(c);
+
+		if(old_recv) {
+			errno = 0;
+			old_recv(c, NULL, 0);
+		}
+	}
+
+	return;
+}
+
+int utcp_close(struct utcp_connection *c) {
+	if(utcp_shutdown(c, SHUT_RDWR) && errno != ENOTCONN) {
+		return -1;
+	}
+
+	c->recv = NULL;
+	c->poll = NULL;
+	c->reapable = true;
+	return 0;
+}
+
+int utcp_abort(struct utcp_connection *c) {
+	if(!reset_connection(c)) {
+		return -1;
+	}
+
+	c->reapable = true;
 	return 0;
 }
 
@@ -1695,6 +1754,10 @@ struct timeval utcp_timeout(struct utcp *utcp) {
 				c->recv(c, NULL, 0);
 			}
 
+			if(c->poll) {
+				c->poll(c, 0);
+			}
+
 			continue;
 		}
 
@@ -1814,9 +1877,15 @@ void utcp_reset_timers(struct utcp *utcp) {
 	then.tv_sec += utcp->timeout;
 
 	for(int i = 0; i < utcp->nconnections; i++) {
-		utcp->connections[i]->rtrx_timeout = now;
-		utcp->connections[i]->conn_timeout = then;
-		utcp->connections[i]->rtt_start.tv_sec = 0;
+		struct utcp_connection *c = utcp->connections[i];
+
+		if(c->reapable) {
+			continue;
+		}
+
+		c->rtrx_timeout = now;
+		c->conn_timeout = then;
+		c->rtt_start.tv_sec = 0;
 	}
 
 	if(utcp->rto > START_RTO) {
@@ -1839,8 +1908,9 @@ size_t utcp_get_sndbuf(struct utcp_connection *c) {
 }
 
 size_t utcp_get_sndbuf_free(struct utcp_connection *c) {
-	if (!c)
+	if(!c) {
 		return 0;
+	}
 
 	switch(c->state) {
 	case SYN_SENT:
@@ -1890,6 +1960,14 @@ void utcp_set_rcvbuf(struct utcp_connection *c, size_t size) {
 	}
 }
 
+size_t utcp_get_sendq(struct utcp_connection *c) {
+	return c->sndbuf.used;
+}
+
+size_t utcp_get_recvq(struct utcp_connection *c) {
+	return c->rcvbuf.used;
+}
+
 bool utcp_get_nodelay(struct utcp_connection *c) {
 	return c ? c->nodelay : false;
 }
@@ -1932,3 +2010,48 @@ void utcp_set_accept_cb(struct utcp *utcp, utcp_accept_t accept, utcp_pre_accept
 		utcp->pre_accept = pre_accept;
 	}
 }
+
+void utcp_expect_data(struct utcp_connection *c, bool expect) {
+	if(!c || c->reapable) {
+		return;
+	}
+
+	if(!(c->state == ESTABLISHED || c->state == FIN_WAIT_1 || c->state == FIN_WAIT_2)) {
+		return;
+	}
+
+	if(expect) {
+		// If we expect data, start the connection timer.
+		if(!timerisset(&c->conn_timeout)) {
+			gettimeofday(&c->conn_timeout, NULL);
+			c->conn_timeout.tv_sec += c->utcp->timeout;
+		}
+	} else {
+		// If we want to cancel expecting data, only clear the timer when there is no unACKed data.
+		if(c->snd.una == c->snd.last) {
+			timerclear(&c->conn_timeout);
+		}
+	}
+}
+
+void utcp_offline(struct utcp *utcp, bool offline) {
+	for(int i = 0; i < utcp->nconnections; i++) {
+		struct utcp_connection *c = utcp->connections[i];
+
+		if(!c->reapable) {
+			utcp_expect_data(c, offline);
+
+			// If we are online again, reset the retransmission timers, but keep the connection timeout as it is,
+			// to prevent peers toggling online/offline state frequently from keeping connections alive
+			// if there is no progress in sending actual data.
+			if(!offline) {
+				gettimeofday(&utcp->connections[i]->rtrx_timeout, NULL);
+				utcp->connections[i]->rtt_start.tv_sec = 0;
+			}
+		}
+	}
+
+	if(!offline && utcp->rto > START_RTO) {
+		utcp->rto = START_RTO;
+	}
+}