Fix memory and resource leaks.

[utcp] / utcp.c

diff --git a/utcp.c b/utcp.c
index 8ff9553de87f966a2d0e3d9b17b38ae7f79ec844..1fae32cd2eaf44430f93311a0787034c58e2861d 100644 (file)
--- a/utcp.c
+++ b/utcp.c
@@ -127,6 +127,7 @@ static void free_connection(struct utcp_connection *c) {
        memmove(cp + i, cp + i + 1, (utcp->nconnections - i - 1) * sizeof *cp);
        utcp->nconnections--;
 
+       free(c->sndbuf);
        free(c);
 }
 
@@ -181,6 +182,8 @@ static struct utcp_connection *allocate_connection(struct utcp *utcp, uint16_t s
        c->snd.una = c->snd.iss;
        c->snd.nxt = c->snd.iss + 1;
        c->rcv.wnd = utcp->mtu;
+       c->snd.last = c->snd.nxt;
+       c->snd.cwnd = utcp->mtu;
        c->utcp = utcp;
 
        // Add it to the sorted list of connections
@@ -204,8 +207,9 @@ struct utcp_connection *utcp_connect(struct utcp *utcp, uint16_t dst, utcp_recv_
        hdr.dst = c->dst;
        hdr.seq = c->snd.iss;
        hdr.ack = 0;
-       hdr.ctl = SYN;
        hdr.wnd = c->rcv.wnd;
+       hdr.ctl = SYN;
+       hdr.aux = 0;
 
        set_state(c, SYN_SENT);
 
@@ -230,6 +234,63 @@ void utcp_accept(struct utcp_connection *c, utcp_recv_t recv, void *priv) {
        set_state(c, ESTABLISHED);
 }
 
+static void ack(struct utcp_connection *c, bool sendatleastone) {
+       int32_t left = seqdiff(c->snd.last, c->snd.nxt);
+       int32_t cwndleft = c->snd.cwnd - seqdiff(c->snd.nxt, c->snd.una);
+       char *data = c->sndbuf + seqdiff(c->snd.nxt, c->snd.una);
+
+       fprintf(stderr, "ack, left=%d, cwndleft=%d, sendatleastone=%d\n", left, cwndleft, sendatleastone);
+       if(left < 0)
+               abort();
+
+       if(cwndleft <= 0)
+               cwndleft = 0;
+
+       if(cwndleft < left)
+               left = cwndleft;
+
+       if(!left && !sendatleastone)
+               return;
+
+       struct {
+               struct hdr hdr;
+               char data[c->utcp->mtu];
+       } pkt;
+
+       pkt.hdr.src = c->src;
+       pkt.hdr.dst = c->dst;
+       pkt.hdr.ack = c->rcv.nxt;
+       pkt.hdr.wnd = c->snd.wnd;
+       pkt.hdr.ctl = ACK;
+       pkt.hdr.aux = 0;
+
+       do {
+               uint32_t seglen = left > c->utcp->mtu ? c->utcp->mtu : left;
+               pkt.hdr.seq = c->snd.nxt;
+
+               memcpy(pkt.data, data, seglen);
+
+               c->snd.nxt += seglen;
+               data += seglen;
+               left -= seglen;
+
+               if(c->state != ESTABLISHED && !left && seglen) {
+                       switch(c->state) {
+                       case FIN_WAIT_1:
+                       case CLOSING:
+                               seglen--;
+                               pkt.hdr.ctl |= FIN;
+                               break;
+                       default:
+                               break;
+                       }
+               }
+
+               print_packet(c->utcp, "send", &pkt, sizeof pkt.hdr + seglen);
+               c->utcp->send(c->utcp, &pkt, sizeof pkt.hdr + seglen);
+       } while(left);
+}
+
 ssize_t utcp_send(struct utcp_connection *c, const void *data, size_t len) {
        if(c->reapable) {
                debug("Error: send() called on closed connection %p\n", c);
@@ -277,11 +338,22 @@ ssize_t utcp_send(struct utcp_connection *c, const void *data, size_t len) {
         */
 
        if(len > c->sndbufsize - bufused && c->sndbufsize < c->maxsndbufsize) {
+               uint32_t newbufsize;
                if(c->sndbufsize > c->maxsndbufsize / 2)
-                       c->sndbufsize = c->maxsndbufsize;
+                       newbufsize = c->maxsndbufsize;
                else
-                       c->sndbufsize *= 2;
-               c->sndbuf = realloc(c->sndbuf, c->sndbufsize);
+                       newbufsize = c->sndbufsize * 2;
+               if(bufused + len > newbufsize) {
+                       if(bufused + len > c->maxsndbufsize)
+                               newbufsize = c->maxsndbufsize;
+                       else
+                               newbufsize = bufused + len;
+               }
+               char *newbuf = realloc(c->sndbuf, newbufsize);
+               if(newbuf) {
+                       c->sndbuf = newbuf;
+                       c->sndbufsize = newbufsize;
+               }
        }
 
        if(len > c->sndbufsize - bufused)
@@ -293,37 +365,9 @@ ssize_t utcp_send(struct utcp_connection *c, const void *data, size_t len) {
        }
 
        memcpy(c->sndbuf + bufused, data, len);
+       c->snd.last += len;
 
-       // Send segments
-
-       struct {
-               struct hdr hdr;
-               char data[c->utcp->mtu];
-       } pkt;
-
-       pkt.hdr.src = c->src;
-       pkt.hdr.dst = c->dst;
-       pkt.hdr.ack = c->rcv.nxt;
-       pkt.hdr.wnd = c->snd.wnd;
-       pkt.hdr.ctl = ACK;
-
-       uint32_t left = len;
-
-       while(left) {
-               uint32_t seglen = left > c->utcp->mtu ? c->utcp->mtu : left;
-               pkt.hdr.seq = c->snd.nxt;
-
-               memcpy(pkt.data, data, seglen);
-
-               c->snd.nxt += seglen;
-               data += seglen;
-               left -= seglen;
-
-               print_packet(c->utcp, "send", &pkt, sizeof pkt.hdr + seglen);
-               c->utcp->send(c->utcp, &pkt, sizeof pkt.hdr + seglen);
-       }
-
-       fprintf(stderr, "len=%zu\n", len);
+       ack(c, false);
        return len;
 }
 
@@ -561,6 +605,36 @@ int utcp_recv(struct utcp *utcp, const void *data, size_t len) {
                uint32_t left = seqdiff(c->snd.nxt, hdr.ack);
                if(left)
                        memmove(c->sndbuf, c->sndbuf + advanced, left);
+               c->dupack = 0;
+               c->snd.cwnd += utcp->mtu;
+               if(c->snd.cwnd > c->maxsndbufsize)
+                       c->snd.cwnd = c->maxsndbufsize;
+               debug("%p increasing cwnd to %u\n", utcp, c->snd.cwnd);
+
+               // Check if we have sent a FIN that is now ACKed.
+               switch(c->state) {
+               case FIN_WAIT_1:
+                       if(c->snd.una == c->snd.last)
+                               set_state(c, FIN_WAIT_2);
+                       break;
+               case CLOSING:
+                       if(c->snd.una == c->snd.last) {
+                               gettimeofday(&c->conn_timeout, NULL);
+                               c->conn_timeout.tv_sec += 60;
+                               set_state(c, TIME_WAIT);
+                       }
+                       break;
+               default:
+                       break;
+               }
+       } else {
+               if(!len) {
+                       c->dupack++;
+                       if(c->dupack >= 3) {
+                               debug("Triplicate ACK\n");
+                               abort();
+                       }
+               }
        }
 
        // 4. Update timers
@@ -670,6 +744,8 @@ int utcp_recv(struct utcp *utcp, const void *data, size_t len) {
                        set_state(c, CLOSING);
                        break;
                case FIN_WAIT_2:
+                       gettimeofday(&c->conn_timeout, NULL);
+                       c->conn_timeout.tv_sec += 60;
                        set_state(c, TIME_WAIT);
                        break;
                case CLOSE_WAIT:
@@ -684,6 +760,7 @@ int utcp_recv(struct utcp *utcp, const void *data, size_t len) {
 
                // FIN counts as one sequence number
                c->rcv.nxt++;
+               len++;
 
                // Inform the application that the peer closed the connection.
                if(c->recv) {
@@ -699,13 +776,7 @@ int utcp_recv(struct utcp *utcp, const void *data, size_t len) {
                return 0;
 
 ack:
-       hdr.src = c->src;
-       hdr.dst = c->dst;
-       hdr.seq = c->snd.nxt;
-       hdr.ack = c->rcv.nxt;
-       hdr.ctl = ACK;
-       print_packet(c->utcp, "send", &hdr, sizeof hdr);
-       utcp->send(utcp, &hdr, sizeof hdr);
+       ack(c, true);
        return 0;
 
 reset:
@@ -765,21 +836,9 @@ int utcp_shutdown(struct utcp_connection *c, int dir) {
                return 0;
        }
 
-       // Send FIN
+       c->snd.last++;
 
-       struct hdr hdr;
-
-       hdr.src = c->src;
-       hdr.dst = c->dst;
-       hdr.seq = c->snd.nxt;
-       hdr.ack = c->rcv.nxt;
-       hdr.wnd = c->snd.wnd;
-       hdr.ctl = FIN | ACK;
-
-       c->snd.nxt += 1;
-
-       print_packet(c->utcp, "send", &hdr, sizeof hdr);
-       c->utcp->send(c->utcp, &hdr, sizeof hdr);
+       ack(c, false);
        return 0;
 }
 
@@ -982,8 +1041,13 @@ struct utcp *utcp_init(utcp_accept_t accept, utcp_pre_accept_t pre_accept, utcp_
 void utcp_exit(struct utcp *utcp) {
        if(!utcp)
                return;
-       for(int i = 0; i < utcp->nconnections; i++)
-               free_connection(utcp->connections[i]);
+       for(int i = 0; i < utcp->nconnections; i++) {
+               if(!utcp->connections[i]->reapable)
+                       debug("Warning, freeing unclosed connection %p\n", utcp->connections[i]);
+               free(utcp->connections[i]->sndbuf);
+               free(utcp->connections[i]);
+       }
+       free(utcp->connections);
        free(utcp);
 }