Fix the logic for determining whether a packets has an acceptable ack seqno.

[utcp] / utcp.c

diff --git a/utcp.c b/utcp.c
index ad19982ba95afdb613eb780e6ac8d8eff6511ee3..1b498a2897d0c4063b568040c24804c6235f636d 100644 (file)
--- a/utcp.c
+++ b/utcp.c
@@ -314,7 +314,6 @@ static struct utcp_connection *allocate_connection(struct utcp *utcp, uint16_t s
        c->src = src;
        c->dst = dst;
 #ifdef UTCP_DEBUG
-#warning debugging
        c->snd.iss = 0;
 #else
        c->snd.iss = rand();
@@ -334,6 +333,46 @@ static struct utcp_connection *allocate_connection(struct utcp *utcp, uint16_t s
        return c;
 }
 
+// Update RTT variables. See RFC 6298.
+static void update_rtt(struct utcp_connection *c, uint32_t rtt) {
+       if(!rtt) {
+               debug("invalid rtt\n");
+               return;
+       }
+
+       struct utcp *utcp = c->utcp;
+
+       if(!utcp->srtt) {
+               utcp->srtt = rtt;
+               utcp->rttvar = rtt / 2;
+               utcp->rto = rtt + max(2 * rtt, CLOCK_GRANULARITY);
+       } else {
+               utcp->rttvar = (utcp->rttvar * 3 + abs(utcp->srtt - rtt)) / 4;
+               utcp->srtt = (utcp->srtt * 7 + rtt) / 8;
+               utcp->rto = utcp->srtt + max(utcp->rttvar, CLOCK_GRANULARITY);
+       }
+
+       if(utcp->rto > MAX_RTO)
+               utcp->rto = MAX_RTO;
+
+       debug("rtt %u srtt %u rttvar %u rto %u\n", rtt, utcp->srtt, utcp->rttvar, utcp->rto);
+}
+
+static void start_retransmit_timer(struct utcp_connection *c) {
+       gettimeofday(&c->rtrx_timeout, NULL);
+       c->rtrx_timeout.tv_usec += c->utcp->rto;
+       while(c->rtrx_timeout.tv_usec >= 1000000) {
+               c->rtrx_timeout.tv_usec -= 1000000;
+               c->rtrx_timeout.tv_sec++;
+       }
+       debug("timeout set to %lu.%06lu (%u)\n", c->rtrx_timeout.tv_sec, c->rtrx_timeout.tv_usec, c->utcp->rto);
+}
+
+static void stop_retransmit_timer(struct utcp_connection *c) {
+       timerclear(&c->rtrx_timeout);
+       debug("timeout cleared\n");
+}
+
 struct utcp_connection *utcp_connect(struct utcp *utcp, uint16_t dst, utcp_recv_t recv, void *priv) {
        struct utcp_connection *c = allocate_connection(utcp, 0, dst);
        if(!c)
@@ -421,6 +460,13 @@ static void ack(struct utcp_connection *c, bool sendatleastone) {
                        pkt->hdr.ctl |= FIN;
                }
 
+               if(!c->rtt_start.tv_sec) {
+                       // Start RTT measurement
+                       gettimeofday(&c->rtt_start, NULL);
+                       c->rtt_seq = pkt->hdr.seq + seglen;
+                       debug("Starting RTT measurement, expecting ack %u\n", c->rtt_seq);
+               }
+
                print_packet(c->utcp, "send", pkt, sizeof pkt->hdr + seglen);
                c->utcp->send(c->utcp, pkt, sizeof pkt->hdr + seglen);
        } while(left);
@@ -474,6 +520,8 @@ 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))
+               start_retransmit_timer(c);
        return len;
 }
 
@@ -552,10 +600,17 @@ static void retransmit(struct utcp_connection *c) {
 #ifdef UTCP_DEBUG
                        abort();
 #endif
-                       timerclear(&c->rtrx_timeout);
-                       break;
+                       stop_retransmit_timer(c);
+                       goto cleanup;
        }
 
+       start_retransmit_timer(c);
+       utcp->rto *= 2;
+       if(utcp->rto > MAX_RTO)
+               utcp->rto = MAX_RTO;
+       c->rtt_start.tv_sec = 0; // invalidate RTT timer
+
+cleanup:
        free(pkt);
 }
 
@@ -824,10 +879,7 @@ ssize_t utcp_recv(struct utcp *utcp, const void *data, size_t len) {
        // ackno should not roll back, and it should also not be bigger than what we ever could have sent
        // (= snd.una + c->sndbuf.used).
 
-       if(hdr.ctl & ACK &&
-                       ((seqdiff(hdr.ack, c->snd.una + c->sndbuf.used) > 0 &&
-                         seqdiff(hdr.ack, c->snd.nxt) > 0) // TODO: simplify this if
-                        || seqdiff(hdr.ack, c->snd.una) < 0)) {
+       if(hdr.ctl & ACK && (seqdiff(hdr.ack, c->snd.last) > 0 || seqdiff(hdr.ack, c->snd.una) < 0)) {
                debug("Packet ack seqno out of range, %u <= %u < %u\n", c->snd.una, hdr.ack, c->snd.una + c->sndbuf.used);
                // Ignore unacceptable RST packets.
                if(hdr.ctl & RST)
@@ -894,6 +946,20 @@ ssize_t utcp_recv(struct utcp *utcp, const void *data, size_t len) {
        prevrcvnxt = c->rcv.nxt;
 
        if(advanced) {
+               // RTT measurement
+               if(c->rtt_start.tv_sec) {
+                       if(c->rtt_seq == hdr.ack) {
+                               struct timeval now, diff;
+                               gettimeofday(&now, NULL);
+                               timersub(&now, &c->rtt_start, &diff);
+                               update_rtt(c, diff.tv_sec * 1000000 + diff.tv_usec);
+                               c->rtt_start.tv_sec = 0;
+                       } else if(c->rtt_seq < hdr.ack) {
+                               debug("Cancelling RTT measurement: %u < %u\n", c->rtt_seq, hdr.ack);
+                               c->rtt_start.tv_sec = 0;
+                       }
+               }
+
                int32_t data_acked = advanced;
 
                switch(c->state) {
@@ -959,8 +1025,10 @@ ssize_t utcp_recv(struct utcp *utcp, const void *data, size_t len) {
 
        if(advanced) {
                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.nxt)
-                       timerclear(&c->rtrx_timeout);
+               if(c->snd.una == c->snd.last)
+                       stop_retransmit_timer(c);
+               else
+                       start_retransmit_timer(c);
        }
 
        // 5. Process SYN stuff
@@ -1281,13 +1349,6 @@ struct timeval utcp_timeout(struct utcp *utcp) {
                if(timerisset(&c->conn_timeout) && timercmp(&c->conn_timeout, &next, <))
                        next = c->conn_timeout;
 
-               if(c->snd.nxt != c->snd.una) {
-                       c->rtrx_timeout = now;
-                       c->rtrx_timeout.tv_sec++;
-               } else {
-                       timerclear(&c->rtrx_timeout);
-               }
-
                if(timerisset(&c->rtrx_timeout) && timercmp(&c->rtrx_timeout, &next, <))
                        next = c->rtrx_timeout;
        }
@@ -1322,8 +1383,9 @@ 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 = 1000;
-       utcp->timeout = 60;
+       utcp->mtu = DEFAULT_MTU;
+       utcp->timeout = DEFAULT_USER_TIMEOUT; // s
+       utcp->rto = START_RTO; // us
 
        return utcp;
 }