Allocate a persistent packet buffer.

[utcp] / utcp.c

diff --git a/utcp.c b/utcp.c
index 7e28f9e27e3aef2a7f0937597eabbd5bd3c36f7a..ae3b2b6da469a56804ea07c2727c7855e6bffb8d 100644 (file)
--- a/utcp.c
+++ b/utcp.c
@@ -415,13 +415,13 @@ static void update_rtt(struct utcp_connection *c, uint32_t rtt) {
        if(!utcp->srtt) {
                utcp->srtt = rtt;
                utcp->rttvar = rtt / 2;
-               utcp->rto = rtt + max(2 * rtt, CLOCK_GRANULARITY);
        } else {
                utcp->rttvar = (utcp->rttvar * 3 + absdiff(utcp->srtt, rtt)) / 4;
                utcp->srtt = (utcp->srtt * 7 + rtt) / 8;
-               utcp->rto = utcp->srtt + max(utcp->rttvar, CLOCK_GRANULARITY);
        }
 
+       utcp->rto = utcp->srtt + max(4 * utcp->rttvar, CLOCK_GRANULARITY);
+
        if(utcp->rto > MAX_RTO) {
                utcp->rto = MAX_RTO;
        }
@@ -527,13 +527,7 @@ static void ack(struct utcp_connection *c, bool sendatleastone) {
        struct {
                struct hdr hdr;
                uint8_t data[];
-       } *pkt;
-
-       pkt = malloc(sizeof(pkt->hdr) + c->utcp->mtu);
-
-       if(!pkt) {
-               return;
-       }
+       } *pkt = c->utcp->pkt;
 
        pkt->hdr.src = c->src;
        pkt->hdr.dst = c->dst;
@@ -566,8 +560,6 @@ static void ack(struct utcp_connection *c, bool sendatleastone) {
                print_packet(c->utcp, "send", pkt, sizeof(pkt->hdr) + seglen);
                c->utcp->send(c->utcp, pkt, sizeof(pkt->hdr) + seglen);
        } while(left);
-
-       free(pkt);
 }
 
 ssize_t utcp_send(struct utcp_connection *c, const void *data, size_t len) {
@@ -629,6 +621,8 @@ ssize_t utcp_send(struct utcp_connection *c, const void *data, size_t len) {
 
        if(is_reliable(c) || (c->state != SYN_SENT && c->state != SYN_RECEIVED)) {
                len = buffer_put(&c->sndbuf, data, len);
+       } else {
+               return 0;
        }
 
        if(len <= 0) {
@@ -685,13 +679,7 @@ static void retransmit(struct utcp_connection *c) {
        struct {
                struct hdr hdr;
                uint8_t data[];
-       } *pkt;
-
-       pkt = malloc(sizeof(pkt->hdr) + c->utcp->mtu);
-
-       if(!pkt) {
-               return;
-       }
+       } *pkt = c->utcp->pkt;
 
        pkt->hdr.src = c->src;
        pkt->hdr.dst = c->dst;
@@ -771,7 +759,7 @@ static void retransmit(struct utcp_connection *c) {
        c->rtt_start.tv_sec = 0; // invalidate RTT timer
 
 cleanup:
-       free(pkt);
+       return;
 }
 
 /* Update receive buffer and SACK entries after consuming data.
@@ -1011,6 +999,8 @@ ssize_t utcp_recv(struct utcp *utcp, const void *data, size_t len) {
                ptr += 2;
        }
 
+       bool has_data = len || (hdr.ctl & (SYN | FIN));
+
        // Try to match the packet to an existing connection
 
        struct utcp_connection *c = find_connection(utcp, hdr.dst, hdr.src);
@@ -1053,6 +1043,7 @@ ssize_t utcp_recv(struct utcp *utcp, const void *data, size_t len) {
                                c->flags = UTCP_TCP;
                        }
 
+synack:
                        // Return SYN+ACK, go to SYN_RECEIVED state
                        c->snd.wnd = hdr.wnd;
                        c->rcv.irs = hdr.seq;
@@ -1105,8 +1096,6 @@ ssize_t utcp_recv(struct utcp *utcp, const void *data, size_t len) {
 
        // It is for an existing connection.
 
-       uint32_t prevrcvnxt = c->rcv.nxt;
-
        // 1. Drop invalid packets.
 
        // 1a. Drop packets that should not happen in our current state.
@@ -1130,7 +1119,7 @@ ssize_t utcp_recv(struct utcp *utcp, const void *data, size_t len) {
                break;
        }
 
-       // 1b. Drop packets with a sequence number not in our receive window.
+       // 1b. Discard data that is not in our receive window.
 
        if(is_reliable(c)) {
                bool acceptable;
@@ -1282,7 +1271,6 @@ ssize_t utcp_recv(struct utcp *utcp, const void *data, size_t len) {
        // 3. Advance snd.una
 
        advanced = seqdiff(hdr.ack, c->snd.una);
-       prevrcvnxt = c->rcv.nxt;
 
        if(advanced) {
                // RTT measurement
@@ -1314,8 +1302,10 @@ ssize_t utcp_recv(struct utcp *utcp, const void *data, size_t len) {
 
                assert(data_acked >= 0);
 
+#ifndef NDEBUG
                int32_t bufused = seqdiff(c->snd.last, c->snd.una);
                assert(data_acked <= bufused);
+#endif
 
                if(data_acked) {
                        buffer_get(&c->sndbuf, NULL, data_acked);
@@ -1347,7 +1337,7 @@ ssize_t utcp_recv(struct utcp *utcp, const void *data, size_t len) {
                case CLOSING:
                        if(c->snd.una == c->snd.last) {
                                gettimeofday(&c->conn_timeout, NULL);
-                               c->conn_timeout.tv_sec += 60;
+                               c->conn_timeout.tv_sec += utcp->timeout;
                                set_state(c, TIME_WAIT);
                        }
 
@@ -1411,6 +1401,9 @@ skip_ack:
                        break;
 
                case SYN_RECEIVED:
+                       // This is a retransmit of a SYN, send back the SYNACK.
+                       goto synack;
+
                case ESTABLISHED:
                case FIN_WAIT_1:
                case FIN_WAIT_2:
@@ -1506,7 +1499,7 @@ skip_ack:
 
                case FIN_WAIT_2:
                        gettimeofday(&c->conn_timeout, NULL);
-                       c->conn_timeout.tv_sec += 60;
+                       c->conn_timeout.tv_sec += utcp->timeout;
                        set_state(c, TIME_WAIT);
                        break;
 
@@ -1536,13 +1529,13 @@ skip_ack:
        }
 
        // Now we send something back if:
-       // - we advanced rcv.nxt (ie, we got some data that needs to be ACKed)
+       // - we received data, so we have to send back an ACK
        //   -> sendatleastone = true
        // - or we got an ack, so we should maybe send a bit more data
        //   -> sendatleastone = false
 
        if(is_reliable(c) || hdr.ctl & SYN || hdr.ctl & FIN) {
-               ack(c, len || prevrcvnxt != c->rcv.nxt);
+               ack(c, has_data);
        }
 
        return 0;
@@ -1854,7 +1847,7 @@ struct utcp *utcp_init(utcp_accept_t accept, utcp_pre_accept_t pre_accept, utcp_
        utcp->pre_accept = pre_accept;
        utcp->send = send;
        utcp->priv = priv;
-       utcp->mtu = DEFAULT_MTU;
+       utcp_set_mtu(utcp, DEFAULT_MTU);
        utcp->timeout = DEFAULT_USER_TIMEOUT; // sec
        utcp->rto = START_RTO; // usec
 
@@ -1893,10 +1886,22 @@ uint16_t utcp_get_mtu(struct utcp *utcp) {
 }
 
 void utcp_set_mtu(struct utcp *utcp, uint16_t mtu) {
-       // TODO: handle overhead of the header
-       if(utcp) {
-               utcp->mtu = mtu;
+       if (!utcp) {
+               return;
        }
+
+       if (mtu <= sizeof(struct hdr)) {
+               return;
+       }
+
+       if (mtu > utcp->mtu) {
+               char *new = realloc(utcp->pkt, mtu);
+               if (!new)
+                       return;
+               utcp->pkt = new;
+       }
+
+       utcp->mtu = mtu;
 }
 
 void utcp_reset_timers(struct utcp *utcp) {
@@ -1919,8 +1924,14 @@ void utcp_reset_timers(struct utcp *utcp) {
                        continue;
                }
 
-               c->rtrx_timeout = now;
-               c->conn_timeout = then;
+               if(timerisset(&c->rtrx_timeout)) {
+                       c->rtrx_timeout = now;
+               }
+
+               if(timerisset(&c->conn_timeout)) {
+                       c->conn_timeout = then;
+               }
+
                c->rtt_start.tv_sec = 0;
        }
 
@@ -2071,19 +2082,24 @@ void utcp_expect_data(struct utcp_connection *c, bool expect) {
 }
 
 void utcp_offline(struct utcp *utcp, bool offline) {
+       struct timeval now;
+       gettimeofday(&now, NULL);
+
        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(c->reapable) {
+                       continue;
+               }
+
+               utcp_expect_data(c, offline);
+
+               if(!offline) {
+                       if(timerisset(&c->rtrx_timeout)) {
+                               c->rtrx_timeout = now;
                        }
+
+                       utcp->connections[i]->rtt_start.tv_sec = 0;
                }
        }