Fix handling retransmitted data when the receive buffer is full.

[utcp] / utcp.c

diff --git a/utcp.c b/utcp.c
index 95a82c428710ca91f5f2752045eea036bee40c79..6b882c6f4cd4a0a888aff9dfafe18d080681dc5c 100644 (file)
--- a/utcp.c
+++ b/utcp.c
@@ -49,13 +49,13 @@
        (r)->tv_sec = (a)->tv_sec - (b)->tv_sec;\
        (r)->tv_usec = (a)->tv_usec - (b)->tv_usec;\
        if((r)->tv_usec < 0)\
-               (r)->tv_sec--, (r)->tv_usec += 1000000;\
+               (r)->tv_sec--, (r)->tv_usec += USEC_PER_SEC;\
 } while (0)
 #endif
 
-#ifndef max
-#define max(a, b) ((a) > (b) ? (a) : (b))
-#endif
+static inline size_t max(size_t a, size_t b) {
+       return a > b ? a : b;
+}
 
 #ifdef UTCP_DEBUG
 #include <stdarg.h>
@@ -70,12 +70,12 @@ static void debug(const char *format, ...) {
 static void print_packet(struct utcp *utcp, const char *dir, const void *pkt, size_t len) {
        struct hdr hdr;
        if(len < sizeof hdr) {
-               debug("%p %s: short packet (%zu bytes)\n", utcp, dir, len);
+               debug("%p %s: short packet (%lu bytes)\n", utcp, dir, (unsigned long)len);
                return;
        }
 
        memcpy(&hdr, pkt, sizeof hdr);
-       fprintf (stderr, "%p %s: len=%zu, src=%u dst=%u seq=%u ack=%u wnd=%u ctl=", utcp, dir, 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 ctl=", utcp, dir, (unsigned long)len, hdr.src, hdr.dst, hdr.seq, hdr.ack, hdr.wnd);
        if(hdr.ctl & SYN)
                debug("SYN");
        if(hdr.ctl & RST)
@@ -87,27 +87,17 @@ static void print_packet(struct utcp *utcp, const char *dir, const void *pkt, si
 
        if(len > sizeof hdr) {
                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;
+               const uint8_t *data = (uint8_t *)pkt + sizeof hdr;
+               char str[datalen * 2 + 1];
+               char *p = str;
+
+               for(uint32_t i = 0; i < datalen; i++) {
+                       *p++ = "0123456789ABCDEF"[data[i] >> 4];
+                       *p++ = "0123456789ABCDEF"[data[i] & 15];
                }
-               *strptr = 0;
+               *p = 0;
 
-               debug(str);
-               free(str);
+               debug(" data=%s", str);
        }
 
        debug("\n");
@@ -152,16 +142,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 %zu %zu %zu\n", buf->used, offset, len);
+       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;
        }
@@ -173,7 +159,7 @@ static ssize_t buffer_put_at(struct buffer *buf, size_t offset, const void *data
                } else {
                        do {
                                newsize *= 2;
-                       } while(newsize < buf->used + len);
+                       } while(newsize < required);
                }
                if(newsize > buf->maxsize)
                        newsize = buf->maxsize;
@@ -650,15 +636,18 @@ cleanup:
  * 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 is after ^, 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)
-               abort();
+       debug("sack_consume %lu\n", (unsigned long)len);
+       if(len > c->rcvbuf.used) {
+               debug("All SACK entries consumed");
+               c->sacks[0].len = 0;
+               return;
+       }
 
        buffer_get(&c->rcvbuf, NULL, len);
 
@@ -706,6 +695,8 @@ static void handle_out_of_order(struct utcp_connection *c, uint32_t offset, cons
                                        memmove(&c->sacks[i + 1], &c->sacks[i], (NSACKS - i - 1) * sizeof c->sacks[i]);
                                        c->sacks[i].offset = offset;
                                        c->sacks[i].len = rxd;
+                               } else {
+                                       debug("SACK entries full, dropping packet\n");
                                }
                                break;
                        } else { // merge
@@ -730,7 +721,7 @@ static void handle_out_of_order(struct utcp_connection *c, uint32_t offset, cons
 static void handle_in_order(struct utcp_connection *c, const void *data, size_t len) {
        // Check if we can process out-of-order data now.
        if(c->sacks[0].len && len >= c->sacks[0].offset) { // TODO: handle overlap with second SACK
-               debug("incoming packet len %zu connected with SACK at %u\n", len, c->sacks[0].offset);
+               debug("incoming packet len %lu connected with SACK at %u\n", (unsigned long)len, c->sacks[0].offset);
                buffer_put_at(&c->rcvbuf, 0, data, len); // TODO: handle return value
                len = max(len, c->sacks[0].offset + c->sacks[0].len);
                data = c->rcvbuf.data;
@@ -855,8 +846,10 @@ ssize_t utcp_recv(struct utcp *utcp, const void *data, size_t len) {
        // In case this is for a CLOSED connection, ignore the packet.
        // TODO: make it so incoming packets can never match a CLOSED connection.
 
-       if(c->state == CLOSED)
+       if(c->state == CLOSED) {
+               debug("Got packet for closed connection\n");
                return 0;
+       }
 
        // It is for an existing connection.
 
@@ -908,7 +901,7 @@ ssize_t utcp_recv(struct utcp *utcp, const void *data, size_t len) {
        }
 
        if(!acceptable) {
-               debug("Packet not acceptable, %u <= %u + %zu < %u\n", c->rcv.nxt, hdr.seq, len, c->rcv.nxt + c->rcvbuf.maxsize);
+               debug("Packet not acceptable, %u <= %u + %lu < %u\n", c->rcv.nxt, hdr.seq, (unsigned long)len, c->rcv.nxt + c->rcvbuf.maxsize);
                // Ignore unacceptable RST packets.
                if(hdr.ctl & RST)
                        return 0;
@@ -1292,7 +1285,7 @@ int utcp_shutdown(struct utcp_connection *c, int dir) {
 }
 
 int utcp_close(struct utcp_connection *c) {
-       if(utcp_shutdown(c, SHUT_RDWR))
+       if(utcp_shutdown(c, SHUT_RDWR) && errno != ENOTCONN)
                return -1;
        c->recv = NULL;
        c->poll = NULL;
@@ -1432,8 +1425,8 @@ struct utcp *utcp_init(utcp_accept_t accept, utcp_pre_accept_t pre_accept, utcp_
        utcp->send = send;
        utcp->priv = priv;
        utcp->mtu = DEFAULT_MTU;
-       utcp->timeout = DEFAULT_USER_TIMEOUT; // s
-       utcp->rto = START_RTO; // us
+       utcp->timeout = DEFAULT_USER_TIMEOUT; // sec
+       utcp->rto = START_RTO; // usec
 
        return utcp;
 }