Always check the return value of malloc().

[utcp] / utcp.c

diff --git a/utcp.c b/utcp.c
index 25590a091560df177d7bbd4d75afed8ad01ba4e1..95a82c428710ca91f5f2752045eea036bee40c79 100644 (file)
--- a/utcp.c
+++ b/utcp.c
@@ -86,11 +86,28 @@ static void print_packet(struct utcp *utcp, const char *dir, const void *pkt, si
                debug("ACK");
 
        if(len > sizeof hdr) {
-               debug(" data=");
-               for(int i = sizeof hdr; i < len; i++) {
-                       const char *data = pkt;
-                       debug("%c", data[i] >= 32 ? data[i] : '.');
+               uint32_t datalen = len - sizeof hdr;
+               uint8_t *str = malloc((datalen << 1) + 7);
+               if(!str) {
+                       debug("out of memory");
+                       return;
                }
+               memcpy(str, " data=", 6);
+               uint8_t *strptr = str + 6;
+               const uint8_t *data = pkt;
+               const uint8_t *dataend = data + datalen;
+
+               while(data != dataend) {
+                       *strptr = (*data >> 4) > 9? (*data >> 4) + 55 : (*data >> 4) + 48;
+                       ++strptr;
+                       *strptr = (*data & 0xf) > 9? (*data & 0xf) + 55 : (*data & 0xf) + 48;
+                       ++strptr;
+                       ++data;
+               }
+               *strptr = 0;
+
+               debug(str);
+               free(str);
        }
 
        debug("\n");
@@ -260,6 +277,7 @@ static void free_connection(struct utcp_connection *c) {
        memmove(cp, cp + 1, (utcp->nconnections - i - 1) * sizeof *cp);
        utcp->nconnections--;
 
+       buffer_exit(&c->rcvbuf);
        buffer_exit(&c->sndbuf);
        free(c);
 }
@@ -305,6 +323,7 @@ static struct utcp_connection *allocate_connection(struct utcp *utcp, uint16_t s
        }
 
        if(!buffer_init(&c->rcvbuf, DEFAULT_RCVBUFSIZE, DEFAULT_MAXRCVBUFSIZE)) {
+               buffer_exit(&c->sndbuf);
                free(c);
                return NULL;
        }
@@ -532,8 +551,11 @@ static void swap_ports(struct hdr *hdr) {
 }
 
 static void retransmit(struct utcp_connection *c) {
-       if(c->state == CLOSED || c->snd.nxt == c->snd.una)
+       if(c->state == CLOSED || c->snd.last == c->snd.una) {
+               debug("Retransmit() called but nothing to retransmit!\n");
+               stop_retransmit_timer(c);
                return;
+       }
 
        struct utcp *utcp = c->utcp;
 
@@ -548,13 +570,14 @@ static void retransmit(struct utcp_connection *c) {
 
        pkt->hdr.src = c->src;
        pkt->hdr.dst = c->dst;
+       pkt->hdr.wnd = c->rcv.wnd;
+       pkt->hdr.aux = 0;
 
        switch(c->state) {
                case SYN_SENT:
                        // Send our SYN again
                        pkt->hdr.seq = c->snd.iss;
                        pkt->hdr.ack = 0;
-                       pkt->hdr.wnd = c->rcv.wnd;
                        pkt->hdr.ctl = SYN;
                        print_packet(c->utcp, "rtrx", pkt, sizeof pkt->hdr);
                        utcp->send(utcp, pkt, sizeof pkt->hdr);
@@ -614,7 +637,24 @@ cleanup:
        free(pkt);
 }
 
-// Update receive buffer and SACK entries after consuming data.
+/* Update receive buffer and SACK entries after consuming data.
+ *
+ * Situation:
+ *
+ * |.....0000..1111111111.....22222......3333|
+ * |---------------^
+ *
+ * 0..3 represent the SACK entries. The ^ indicates up to which point we want
+ * to remove data from the receive buffer. The idea is to substract "len"
+ * from the offset of all the SACK entries, and then remove/cut down entries
+ * that are shifted to before the start of the receive buffer.
+ *
+ * There are three cases:
+ * - the SACK entry is ahead of ^, in that case just change the offset.
+ * - the SACK entry starts before and ends after ^, so we have to
+ *   change both its offset and size.
+ * - the SACK entry is completely before ^, in that case delete it.
+ */
 static void sack_consume(struct utcp_connection *c, size_t len) {
        debug("sack_consume %zu\n", len);
        if(len > c->rcvbuf.used)
@@ -627,13 +667,13 @@ static void sack_consume(struct utcp_connection *c, size_t len) {
                        c->sacks[i].offset -= len;
                        i++;
                } else if(len < c->sacks[i].offset + c->sacks[i].len) {
-                       c->sacks[i].offset = 0;
                        c->sacks[i].len -= len - c->sacks[i].offset;
+                       c->sacks[i].offset = 0;
                        i++;
                } else {
                        if(i < NSACKS - 1) {
                                memmove(&c->sacks[i], &c->sacks[i + 1], (NSACKS - 1 - i) * sizeof c->sacks[i]);
-                               c->sacks[i + 1].len = 0;
+                               c->sacks[NSACKS - 1].len = 0;
                        } else {
                                c->sacks[i].len = 0;
                                break;
@@ -850,18 +890,22 @@ ssize_t utcp_recv(struct utcp *utcp, const void *data, size_t len) {
 
        if(c->state == SYN_SENT)
                acceptable = true;
-
-       // TODO: handle packets overlapping c->rcv.nxt.
-#if 1
-       // Only use this when accepting out-of-order packets.
        else if(len == 0)
                acceptable = seqdiff(hdr.seq, c->rcv.nxt) >= 0;
-       else
+       else {
+               int32_t rcv_offset = seqdiff(hdr.seq, c->rcv.nxt);
+
+               // cut already accepted front overlapping
+               if(rcv_offset < 0) {
+                       acceptable = rcv_offset + len >= 0;
+                       if(acceptable) {
+                               data -= rcv_offset;
+                               len += rcv_offset;
+                       }
+               }
+
                acceptable = seqdiff(hdr.seq, c->rcv.nxt) >= 0 && seqdiff(hdr.seq, c->rcv.nxt) + len <= c->rcvbuf.maxsize;
-#else
-       if(c->state != SYN_SENT)
-               acceptable = hdr.seq == c->rcv.nxt;
-#endif
+       }
 
        if(!acceptable) {
                debug("Packet not acceptable, %u <= %u + %zu < %u\n", c->rcv.nxt, hdr.seq, len, c->rcv.nxt + c->rcvbuf.maxsize);
@@ -1242,6 +1286,8 @@ int utcp_shutdown(struct utcp_connection *c, int dir) {
        c->snd.last++;
 
        ack(c, false);
+       if(!timerisset(&c->rtrx_timeout))
+               start_retransmit_timer(c);
        return 0;
 }
 
@@ -1398,6 +1444,7 @@ void utcp_exit(struct utcp *utcp) {
        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]);
        }