X-Git-Url: http://git.meshlink.io/?a=blobdiff_plain;f=utcp.c;h=57b98135ad482b5cb29dbe6f9549db6ac6adaeaa;hb=1d8aa0d5a55bb871ce56bca355ade80b08a7c1e5;hp=bb29de5824a923a89c3cb28dd110190c199d2d66;hpb=2b97914c7e2d7d589258cc18e58ad92e32a3457c;p=utcp

diff --git a/utcp.c b/utcp.c
index bb29de5..57b9813 100644
--- a/utcp.c
+++ b/utcp.c
@@ -75,7 +75,7 @@ static void print_packet(struct utcp *utcp, const char *dir, const void *pkt, si
 	}
 
 	memcpy(&hdr, pkt, sizeof hdr);
-	debug("%p %s: len=%lu, src=%u dst=%u seq=%u ack=%u wnd=%u ctl=", utcp, dir, (unsigned long)len, hdr.src, hdr.dst, hdr.seq, hdr.ack, hdr.wnd);
+	debug("%p %s: len=%lu, src=%u dst=%u seq=%u ack=%u wnd=%u aux=%x ctl=", utcp, dir, (unsigned long)len, hdr.src, hdr.dst, hdr.seq, hdr.ack, hdr.wnd, hdr.aux);
 	if(hdr.ctl & SYN)
 		debug("SYN");
 	if(hdr.ctl & RST)
@@ -127,6 +127,10 @@ static bool fin_wanted(struct utcp_connection *c, uint32_t seq) {
 	}
 }
 
+static bool is_reliable(struct utcp_connection *c) {
+	return c->flags & UTCP_RELIABLE;
+}
+
 static inline void list_connections(struct utcp *utcp) {
 	debug("%p has %d connections:\n", utcp, utcp->nconnections);
 	for(int i = 0; i < utcp->nconnections; i++)
@@ -142,16 +146,12 @@ static int32_t seqdiff(uint32_t a, uint32_t b) {
 
 // Store data into the buffer
 static ssize_t buffer_put_at(struct buffer *buf, size_t offset, const void *data, size_t len) {
-	if(buf->maxsize <= buf->used)
-		return 0;
-
 	debug("buffer_put_at %lu %lu %lu\n", (unsigned long)buf->used, (unsigned long)offset, (unsigned long)len);
 
 	size_t required = offset + len;
 	if(required > buf->maxsize) {
 		if(offset >= buf->maxsize)
 			return 0;
-		abort();
 		len = buf->maxsize - offset;
 		required = buf->maxsize;
 	}
@@ -382,35 +382,51 @@ static void stop_retransmit_timer(struct utcp_connection *c) {
 	debug("timeout cleared\n");
 }
 
-struct utcp_connection *utcp_connect(struct utcp *utcp, uint16_t dst, utcp_recv_t recv, void *priv) {
+struct utcp_connection *utcp_connect_ex(struct utcp *utcp, uint16_t dst, utcp_recv_t recv, void *priv, uint32_t flags) {
 	struct utcp_connection *c = allocate_connection(utcp, 0, dst);
 	if(!c)
 		return NULL;
 
+	assert((flags & ~0xf) == 0);
+
+	c->flags = flags;
 	c->recv = recv;
 	c->priv = priv;
 
-	struct hdr hdr;
-
-	hdr.src = c->src;
-	hdr.dst = c->dst;
-	hdr.seq = c->snd.iss;
-	hdr.ack = 0;
-	hdr.wnd = c->rcv.wnd;
-	hdr.ctl = SYN;
-	hdr.aux = 0;
+	struct {
+		struct hdr hdr;
+		uint8_t init[4];
+	} pkt;
+
+	pkt.hdr.src = c->src;
+	pkt.hdr.dst = c->dst;
+	pkt.hdr.seq = c->snd.iss;
+	pkt.hdr.ack = 0;
+	pkt.hdr.wnd = c->rcv.wnd;
+	pkt.hdr.ctl = SYN;
+	pkt.hdr.aux = 0x0101;
+	pkt.init[0] = 1;
+	pkt.init[1] = 0;
+	pkt.init[2] = 0;
+	pkt.init[3] = flags & 0x7;
 
 	set_state(c, SYN_SENT);
 
-	print_packet(utcp, "send", &hdr, sizeof hdr);
-	utcp->send(utcp, &hdr, sizeof hdr);
+	print_packet(utcp, "send", &pkt, sizeof pkt);
+	utcp->send(utcp, &pkt, sizeof pkt);
 
 	gettimeofday(&c->conn_timeout, NULL);
 	c->conn_timeout.tv_sec += utcp->timeout;
 
+	start_retransmit_timer(c);
+
 	return c;
 }
 
+struct utcp_connection *utcp_connect(struct utcp *utcp, uint16_t dst, utcp_recv_t recv, void *priv) {
+	return utcp_connect_ex(utcp, dst, recv, priv, UTCP_TCP);
+}
+
 void utcp_accept(struct utcp_connection *c, utcp_recv_t recv, void *priv) {
 	if(c->reapable || c->state != SYN_RECEIVED) {
 		debug("Error: accept() called on invalid connection %p in state %s\n", c, strstate[c->state]);
@@ -441,7 +457,7 @@ static void ack(struct utcp_connection *c, bool sendatleastone) {
 
 	struct {
 		struct hdr hdr;
-		char data[];
+		uint8_t data[];
 	} *pkt;
 
 	pkt = malloc(sizeof pkt->hdr + c->utcp->mtu);
@@ -511,7 +527,7 @@ ssize_t utcp_send(struct utcp_connection *c, const void *data, size_t len) {
 		return -1;
 	}
 
-	// Add data to send buffer
+	// Exit early if we have nothing to send.
 
 	if(!len)
 		return 0;
@@ -521,6 +537,8 @@ ssize_t utcp_send(struct utcp_connection *c, const void *data, size_t len) {
 		return -1;
 	}
 
+	// Add data to send buffer.
+
 	len = buffer_put(&c->sndbuf, data, len);
 	if(len <= 0) {
 		errno = EWOULDBLOCK;
@@ -529,7 +547,11 @@ ssize_t utcp_send(struct utcp_connection *c, const void *data, size_t len) {
 
 	c->snd.last += len;
 	ack(c, false);
-	if(!timerisset(&c->rtrx_timeout))
+	if(!is_reliable(c)) {
+		c->snd.una = c->snd.nxt = c->snd.last;
+		buffer_get(&c->sndbuf, NULL, c->sndbuf.used);
+	}
+	if(is_reliable(c) && !timerisset(&c->rtrx_timeout))
 		start_retransmit_timer(c);
 	return len;
 }
@@ -551,7 +573,7 @@ static void retransmit(struct utcp_connection *c) {
 
 	struct {
 		struct hdr hdr;
-		char data[];
+		uint8_t data[];
 	} *pkt;
 
 	pkt = malloc(sizeof pkt->hdr + c->utcp->mtu);
@@ -569,8 +591,13 @@ static void retransmit(struct utcp_connection *c) {
 			pkt->hdr.seq = c->snd.iss;
 			pkt->hdr.ack = 0;
 			pkt->hdr.ctl = SYN;
-			print_packet(c->utcp, "rtrx", pkt, sizeof pkt->hdr);
-			utcp->send(utcp, pkt, sizeof pkt->hdr);
+			pkt->hdr.aux = 0x0101;
+			pkt->data[0] = 1;
+			pkt->data[1] = 0;
+			pkt->data[2] = 0;
+			pkt->data[3] = c->flags & 0x7;
+			print_packet(c->utcp, "rtrx", pkt, sizeof pkt->hdr + 4);
+			utcp->send(utcp, pkt, sizeof pkt->hdr + 4);
 			break;
 
 		case SYN_RECEIVED:
@@ -647,8 +674,11 @@ cleanup:
  */
 static void sack_consume(struct utcp_connection *c, size_t len) {
 	debug("sack_consume %lu\n", (unsigned long)len);
-	if(len > c->rcvbuf.used)
-		abort();
+	if(len > c->rcvbuf.used) {
+		debug("All SACK entries consumed");
+		c->sacks[0].len = 0;
+		return;
+	}
 
 	buffer_get(&c->rcvbuf, NULL, len);
 
@@ -744,6 +774,12 @@ static void handle_in_order(struct utcp_connection *c, const void *data, size_t
 
 
 static void handle_incoming_data(struct utcp_connection *c, uint32_t seq, const void *data, size_t len) {
+	if(!is_reliable(c)) {
+		c->recv(c, data, len);
+		c->rcv.nxt = seq + len;
+		return;
+	}
+
 	uint32_t offset = seqdiff(seq, c->rcv.nxt);
 	if(offset + len > c->rcvbuf.maxsize)
 		abort();
@@ -792,6 +828,49 @@ ssize_t utcp_recv(struct utcp *utcp, const void *data, size_t len) {
 		return -1;
 	}
 
+	// Check for auxiliary headers
+
+	const uint8_t *init = NULL;
+
+	uint16_t aux = hdr.aux;
+	while(aux) {
+		size_t auxlen = 4 * (aux >> 8) & 0xf;
+		uint8_t auxtype = aux & 0xff;
+
+		if(len < auxlen) {
+			errno = EBADMSG;
+			return -1;
+		}
+
+		switch(auxtype) {
+		case AUX_INIT:
+			if(!(hdr.ctl & SYN) || auxlen != 4) {
+				errno = EBADMSG;
+				return -1;
+			}
+			init = data;
+			break;
+		default:
+			errno = EBADMSG;
+			return -1;
+		}
+
+		len -= auxlen;
+		data += auxlen;
+
+		if(!(aux & 0x800))
+			break;
+
+		if(len < 2) {
+			errno = EBADMSG;
+			return -1;
+		}
+
+		memcpy(&aux, data, 2);
+		len -= 2;
+		data += 2;
+	}
+
 	// Try to match the packet to an existing connection
 
 	struct utcp_connection *c = find_connection(utcp, hdr.dst, hdr.src);
@@ -820,19 +899,47 @@ ssize_t utcp_recv(struct utcp *utcp, const void *data, size_t len) {
 				goto reset;
 			}
 
+			// Parse auxilliary information
+			if(init) {
+				if(init[0] < 1) {
+					len = 1;
+					goto reset;
+				}
+				c->flags = init[3] & 0x7;
+			} else {
+				c->flags = UTCP_TCP;
+			}
+
 			// Return SYN+ACK, go to SYN_RECEIVED state
 			c->snd.wnd = hdr.wnd;
 			c->rcv.irs = hdr.seq;
 			c->rcv.nxt = c->rcv.irs + 1;
 			set_state(c, SYN_RECEIVED);
 
-			hdr.dst = c->dst;
-			hdr.src = c->src;
-			hdr.ack = c->rcv.irs + 1;
-			hdr.seq = c->snd.iss;
-			hdr.ctl = SYN | ACK;
-			print_packet(c->utcp, "send", &hdr, sizeof hdr);
-			utcp->send(utcp, &hdr, sizeof hdr);
+			struct {
+				struct hdr hdr;
+				uint8_t data[4];
+			} pkt;
+
+			pkt.hdr.src = c->src;
+			pkt.hdr.dst = c->dst;
+			pkt.hdr.ack = c->rcv.irs + 1;
+			pkt.hdr.seq = c->snd.iss;
+			pkt.hdr.wnd = c->rcv.wnd;
+			pkt.hdr.ctl = SYN | ACK;
+			if(init) {
+				pkt.hdr.aux = 0x0101;
+				pkt.data[0] = 1;
+				pkt.data[1] = 0;
+				pkt.data[2] = 0;
+				pkt.data[3] = c->flags & 0x7;
+				print_packet(c->utcp, "send", &pkt, sizeof hdr + 4);
+				utcp->send(utcp, &pkt, sizeof hdr + 4);
+			} else {
+				pkt.hdr.aux = 0;
+				print_packet(c->utcp, "send", &pkt, sizeof hdr);
+				utcp->send(utcp, &pkt, sizeof hdr);
+			}
 		} else {
 			// No, we don't want your packets, send a RST back
 			len = 1;
@@ -891,14 +998,15 @@ ssize_t utcp_recv(struct utcp *utcp, const void *data, size_t len) {
 
 		// cut already accepted front overlapping
 		if(rcv_offset < 0) {
-			acceptable = rcv_offset + len >= 0;
+			acceptable = len > -rcv_offset;
 			if(acceptable) {
 				data -= rcv_offset;
 				len += rcv_offset;
+				hdr.seq -= rcv_offset;
 			}
+		} else {
+			acceptable = seqdiff(hdr.seq, c->rcv.nxt) >= 0 && seqdiff(hdr.seq, c->rcv.nxt) + len <= c->rcvbuf.maxsize;
 		}
-
-		acceptable = seqdiff(hdr.seq, c->rcv.nxt) >= 0 && seqdiff(hdr.seq, c->rcv.nxt) + len <= c->rcvbuf.maxsize;
 	}
 
 	if(!acceptable) {
@@ -906,9 +1014,8 @@ ssize_t utcp_recv(struct utcp *utcp, const void *data, size_t len) {
 		// Ignore unacceptable RST packets.
 		if(hdr.ctl & RST)
 			return 0;
-		// Otherwise, send an ACK back in the hope things improve.
-		ack(c, true);
-		return 0;
+		// Otherwise, continue processing.
+		len = 0;
 	}
 
 	c->snd.wnd = hdr.wnd; // TODO: move below
@@ -978,6 +1085,9 @@ ssize_t utcp_recv(struct utcp *utcp, const void *data, size_t len) {
 		}
 	}
 
+	if(!(hdr.ctl & ACK))
+		goto skip_ack;
+
 	// 3. Advance snd.una
 
 	uint32_t advanced = seqdiff(hdr.ack, c->snd.una);
@@ -1046,7 +1156,7 @@ ssize_t utcp_recv(struct utcp *utcp, const void *data, size_t len) {
 			break;
 		}
 	} else {
-		if(!len) {
+		if(!len && is_reliable(c)) {
 			c->dupack++;
 			if(c->dupack == 3) {
 				debug("Triplicate ACK\n");
@@ -1066,10 +1176,11 @@ ssize_t utcp_recv(struct utcp *utcp, const void *data, size_t len) {
 		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);
-		else
+		else if(is_reliable(c))
 			start_retransmit_timer(c);
 	}
 
+skip_ack:
 	// 5. Process SYN stuff
 
 	if(hdr.ctl & SYN) {
@@ -1092,7 +1203,7 @@ ssize_t utcp_recv(struct utcp *utcp, const void *data, size_t len) {
 		case LAST_ACK:
 		case TIME_WAIT:
 			// Ehm, no. We should never receive a second SYN.
-			goto reset;
+			return 0;
 		default:
 #ifdef UTCP_DEBUG
 			abort();
@@ -1209,6 +1320,7 @@ ssize_t utcp_recv(struct utcp *utcp, const void *data, size_t len) {
 reset:
 	swap_ports(&hdr);
 	hdr.wnd = 0;
+	hdr.aux = 0;
 	if(hdr.ctl & ACK) {
 		hdr.seq = hdr.ack;
 		hdr.ctl = RST;
@@ -1385,8 +1497,15 @@ struct timeval utcp_timeout(struct utcp *utcp) {
 			retransmit(c);
 		}
 
-		if(c->poll && buffer_free(&c->sndbuf) && (c->state == ESTABLISHED || c->state == CLOSE_WAIT))
-			c->poll(c, buffer_free(&c->sndbuf));
+		if(c->poll) {
+			if((c->state == ESTABLISHED || c->state == CLOSE_WAIT)) {
+				uint32_t len =  buffer_free(&c->sndbuf);
+				if(len)
+					c->poll(c, len);
+			} else if(c->state == CLOSED) {
+				c->poll(c, 0);
+			}
+		}
 
 		if(timerisset(&c->conn_timeout) && timercmp(&c->conn_timeout, &next, <))
 			next = c->conn_timeout;
@@ -1436,11 +1555,13 @@ void utcp_exit(struct utcp *utcp) {
 	if(!utcp)
 		return;
 	for(int i = 0; i < utcp->nconnections; i++) {
-		if(!utcp->connections[i]->reapable)
-			debug("Warning, freeing unclosed connection %p\n", utcp->connections[i]);
-		buffer_exit(&utcp->connections[i]->rcvbuf);
-		buffer_exit(&utcp->connections[i]->sndbuf);
-		free(utcp->connections[i]);
+		struct utcp_connection *c = utcp->connections[i];
+		if(!c->reapable)
+			if(c->recv)
+				c->recv(c, NULL, 0);
+		buffer_exit(&c->rcvbuf);
+		buffer_exit(&c->sndbuf);
+		free(c);
 	}
 	free(utcp->connections);
 	free(utcp);
@@ -1456,6 +1577,22 @@ void utcp_set_mtu(struct utcp *utcp, uint16_t mtu) {
 		utcp->mtu = mtu;
 }
 
+void utcp_reset_timers(struct utcp *utcp) {
+	if(!utcp)
+		return;
+	struct timeval now, then;
+	gettimeofday(&now, NULL);
+	then = now;
+	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;
+	}
+	if(utcp->rto > START_RTO)
+		utcp->rto = START_RTO;
+}
+
 int utcp_get_user_timeout(struct utcp *u) {
 	return u ? u->timeout : 0;
 }