X-Git-Url: http://git.meshlink.io/?p=utcp;a=blobdiff_plain;f=utcp.c;h=67d4be3a7a632d4cdafd004b217ad01976092caa;hp=802d95a2ba87ea3de46d9235176f5273361e6ca7;hb=fc13e49d321c16fc65e5c8fcf5d205ce805f7a0e;hpb=eb85ec4ae5f32102430e0622e3855aaba110c032 diff --git a/utcp.c b/utcp.c index 802d95a..67d4be3 100644 --- a/utcp.c +++ b/utcp.c @@ -29,6 +29,7 @@ #include #include #include +#include #include "utcp_priv.h" @@ -54,6 +55,10 @@ } while (0) #endif +static inline size_t min(size_t a, size_t b) { + return a < b ? a : b; +} + static inline size_t max(size_t a, size_t b) { return a > b ? a : b; } @@ -61,61 +66,74 @@ static inline size_t max(size_t a, size_t b) { #ifdef UTCP_DEBUG #include -static void debug(const char *format, ...) { +#ifndef UTCP_DEBUG_DATALEN +#define UTCP_DEBUG_DATALEN 20 +#endif + +static void debug(struct utcp_connection *c, const char *format, ...) { + struct timespec tv; + char buf[1024]; + int len; + + clock_gettime(CLOCK_REALTIME, &tv); + len = snprintf(buf, sizeof(buf), "%ld.%06lu %u:%u ", (long)tv.tv_sec, tv.tv_nsec / 1000, c ? c->src : 0, c ? c->dst : 0); va_list ap; va_start(ap, format); - vfprintf(stderr, format, ap); + len += vsnprintf(buf + len, sizeof(buf) - len, format, ap); va_end(ap); + + if(len > 0 && (size_t)len < sizeof(buf)) { + fwrite(buf, len, 1, stderr); + } } -static void print_packet(struct utcp *utcp, const char *dir, const void *pkt, size_t len) { +static void print_packet(struct utcp_connection *c, const char *dir, const void *pkt, size_t len) { struct hdr hdr; if(len < sizeof(hdr)) { - debug("%p %s: short packet (%lu bytes)\n", utcp, dir, (unsigned long)len); + debug(c, "%s: short packet (%lu bytes)\n", dir, (unsigned long)len); return; } memcpy(&hdr, pkt, sizeof(hdr)); - debug("%p %s: len=%lu, src=%u dst=%u seq=%u ack=%u wnd=%u aux=%x ctl=", utcp, dir, (unsigned long)len, hdr.src, hdr.dst, hdr.seq, hdr.ack, hdr.wnd, hdr.aux); - if(hdr.ctl & SYN) { - debug("SYN"); - } + uint32_t datalen; - if(hdr.ctl & RST) { - debug("RST"); + if(len > sizeof(hdr)) { + datalen = min(len - sizeof(hdr), UTCP_DEBUG_DATALEN); + } else { + datalen = 0; } - if(hdr.ctl & FIN) { - debug("FIN"); - } - if(hdr.ctl & ACK) { - debug("ACK"); - } - - if(len > sizeof(hdr)) { - uint32_t datalen = len - sizeof(hdr); - const uint8_t *data = (uint8_t *)pkt + sizeof(hdr); - char str[datalen * 2 + 1]; - char *p = str; + 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]; - } + for(uint32_t i = 0; i < datalen; i++) { + *p++ = "0123456789ABCDEF"[data[i] >> 4]; + *p++ = "0123456789ABCDEF"[data[i] & 15]; + } - *p = 0; + *p = 0; - debug(" data=%s", str); - } + debug(c, "%s: len %lu src %u dst %u seq %u ack %u wnd %u aux %x ctl %s%s%s%s data %s\n", + dir, (unsigned long)len, hdr.src, hdr.dst, hdr.seq, hdr.ack, hdr.wnd, hdr.aux, + hdr.ctl & SYN ? "SYN" : "", + hdr.ctl & RST ? "RST" : "", + hdr.ctl & FIN ? "FIN" : "", + hdr.ctl & ACK ? "ACK" : "", + str + ); +} - debug("\n"); +static void debug_cwnd(struct utcp_connection *c) { + debug(c, "snd.cwnd %u snd.ssthresh %u\n", c->snd.cwnd, ~c->snd.ssthresh ? c->snd.ssthresh : 0); } #else #define debug(...) do {} while(0) #define print_packet(...) do {} while(0) +#define debug_cwnd(...) do {} while(0) #endif static void set_state(struct utcp_connection *c, enum state state) { @@ -125,7 +143,7 @@ static void set_state(struct utcp_connection *c, enum state state) { timerclear(&c->conn_timeout); } - debug("%p new state: %s\n", c->utcp, strstate[state]); + debug(c, "state %s\n", strstate[state]); } static bool fin_wanted(struct utcp_connection *c, uint32_t seq) { @@ -157,7 +175,7 @@ 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) { - debug("buffer_put_at %lu %lu %lu\n", (unsigned long)buf->used, (unsigned long)offset, (unsigned long)len); + debug(NULL, "buffer_put_at %lu %lu %lu\n", (unsigned long)buf->used, (unsigned long)offset, (unsigned long)len); size_t required = offset + len; @@ -382,9 +400,10 @@ static struct utcp_connection *allocate_connection(struct utcp *utcp, uint16_t s #endif 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->snd.cwnd = (utcp->mtu > 2190 ? 2 : utcp->mtu > 1095 ? 3 : 4) * utcp->mtu; + c->snd.ssthresh = ~0; + debug_cwnd(c); c->utcp = utcp; // Add it to the sorted list of connections @@ -406,7 +425,7 @@ static inline uint32_t absdiff(uint32_t a, uint32_t b) { // Update RTT variables. See RFC 6298. static void update_rtt(struct utcp_connection *c, uint32_t rtt) { if(!rtt) { - debug("invalid rtt\n"); + debug(c, "invalid rtt\n"); return; } @@ -426,7 +445,7 @@ static void update_rtt(struct utcp_connection *c, uint32_t rtt) { utcp->rto = MAX_RTO; } - debug("rtt %u srtt %u rttvar %u rto %u\n", rtt, utcp->srtt, utcp->rttvar, utcp->rto); + debug(c, "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) { @@ -438,12 +457,12 @@ static void start_retransmit_timer(struct utcp_connection *c) { 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); + debug(c, "rtrx_timeout %ld.%06lu\n", c->rtrx_timeout.tv_sec, c->rtrx_timeout.tv_usec); } static void stop_retransmit_timer(struct utcp_connection *c) { timerclear(&c->rtrx_timeout); - debug("timeout cleared\n"); + debug(c, "rtrx_timeout cleared\n"); } struct utcp_connection *utcp_connect_ex(struct utcp *utcp, uint16_t dst, utcp_recv_t recv, void *priv, uint32_t flags) { @@ -468,7 +487,7 @@ struct utcp_connection *utcp_connect_ex(struct utcp *utcp, uint16_t dst, utcp_re pkt.hdr.dst = c->dst; pkt.hdr.seq = c->snd.iss; pkt.hdr.ack = 0; - pkt.hdr.wnd = c->rcv.wnd; + pkt.hdr.wnd = c->rcvbuf.maxsize; pkt.hdr.ctl = SYN; pkt.hdr.aux = 0x0101; pkt.init[0] = 1; @@ -478,7 +497,7 @@ struct utcp_connection *utcp_connect_ex(struct utcp *utcp, uint16_t dst, utcp_re set_state(c, SYN_SENT); - print_packet(utcp, "send", &pkt, sizeof(pkt)); + print_packet(c, "send", &pkt, sizeof(pkt)); utcp->send(utcp, &pkt, sizeof(pkt)); gettimeofday(&c->conn_timeout, NULL); @@ -495,11 +514,11 @@ struct utcp_connection *utcp_connect(struct utcp *utcp, uint16_t dst, utcp_recv_ void utcp_accept(struct utcp_connection *c, utcp_recv_t recv, void *priv) { if(c->reapable || c->state != SYN_RECEIVED) { - debug("Error: accept() called on invalid connection %p in state %s\n", c, strstate[c->state]); + debug(c, "accept() called on invalid connection in state %s\n", c, strstate[c->state]); return; } - debug("%p accepted, %p %p\n", c, recv, priv); + debug(c, "accepted %p %p\n", c, recv, priv); c->recv = recv; c->priv = priv; set_state(c, ESTABLISHED); @@ -507,19 +526,22 @@ void utcp_accept(struct utcp_connection *c, utcp_recv_t recv, void *priv) { 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); - debug("cwndleft = %d\n", cwndleft); + int32_t cwndleft = min(c->snd.cwnd, c->snd.wnd) - seqdiff(c->snd.nxt, c->snd.una); assert(left >= 0); if(cwndleft <= 0) { - cwndleft = 0; - } - - if(cwndleft < left) { + left = 0; + } else if(cwndleft < left) { left = cwndleft; + + if(!sendatleastone || cwndleft > c->utcp->mtu) { + left -= left % c->utcp->mtu; + } } + debug(c, "cwndleft %d left %d\n", cwndleft, left); + if(!left && !sendatleastone) { return; } @@ -538,7 +560,7 @@ static void ack(struct utcp_connection *c, bool sendatleastone) { pkt->hdr.src = c->src; pkt->hdr.dst = c->dst; pkt->hdr.ack = c->rcv.nxt; - pkt->hdr.wnd = c->snd.wnd; + pkt->hdr.wnd = c->rcvbuf.maxsize; pkt->hdr.ctl = ACK; pkt->hdr.aux = 0; @@ -560,10 +582,10 @@ static void ack(struct utcp_connection *c, bool sendatleastone) { // 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); + debug(c, "starting RTT measurement, expecting ack %u\n", c->rtt_seq); } - print_packet(c->utcp, "send", pkt, sizeof(pkt->hdr) + seglen); + print_packet(c, "send", pkt, sizeof(pkt->hdr) + seglen); c->utcp->send(c->utcp, pkt, sizeof(pkt->hdr) + seglen); } while(left); @@ -572,7 +594,7 @@ static void ack(struct utcp_connection *c, bool sendatleastone) { 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); + debug(c, "send() called on closed connection\n"); errno = EBADF; return -1; } @@ -580,7 +602,7 @@ ssize_t utcp_send(struct utcp_connection *c, const void *data, size_t len) { switch(c->state) { case CLOSED: case LISTEN: - debug("Error: send() called on unconnected connection %p\n", c); + debug(c, "send() called on unconnected connection\n"); errno = ENOTCONN; return -1; @@ -595,7 +617,7 @@ ssize_t utcp_send(struct utcp_connection *c, const void *data, size_t len) { case CLOSING: case LAST_ACK: case TIME_WAIT: - debug("Error: send() called on closing connection %p\n", c); + debug(c, "send() called on closed connection\n"); errno = EPIPE; return -1; } @@ -629,6 +651,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) { @@ -673,9 +697,62 @@ static void swap_ports(struct hdr *hdr) { hdr->dst = tmp; } +static void fast_retransmit(struct utcp_connection *c) { + if(c->state == CLOSED || c->snd.last == c->snd.una) { + debug(c, "fast_retransmit() called but nothing to retransmit!\n"); + return; + } + + struct utcp *utcp = c->utcp; + + struct { + struct hdr hdr; + uint8_t data[]; + } *pkt; + + pkt = malloc(sizeof(pkt->hdr) + c->utcp->mtu); + + if(!pkt) { + return; + } + + pkt->hdr.src = c->src; + pkt->hdr.dst = c->dst; + pkt->hdr.wnd = c->rcvbuf.maxsize; + pkt->hdr.aux = 0; + + switch(c->state) { + case ESTABLISHED: + case FIN_WAIT_1: + case CLOSE_WAIT: + case CLOSING: + case LAST_ACK: + // Send unacked data again. + pkt->hdr.seq = c->snd.una; + pkt->hdr.ack = c->rcv.nxt; + pkt->hdr.ctl = ACK; + uint32_t len = min(seqdiff(c->snd.last, c->snd.una), utcp->mtu); + + if(fin_wanted(c, c->snd.una + len)) { + len--; + pkt->hdr.ctl |= FIN; + } + + buffer_copy(&c->sndbuf, pkt->data, 0, len); + print_packet(c, "rtrx", pkt, sizeof(pkt->hdr) + len); + utcp->send(utcp, pkt, sizeof(pkt->hdr) + len); + break; + + default: + break; + } + + free(pkt); +} + static void retransmit(struct utcp_connection *c) { if(c->state == CLOSED || c->snd.last == c->snd.una) { - debug("Retransmit() called but nothing to retransmit!\n"); + debug(c, "retransmit() called but nothing to retransmit!\n"); stop_retransmit_timer(c); return; } @@ -695,7 +772,7 @@ 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.wnd = c->rcvbuf.maxsize; pkt->hdr.aux = 0; switch(c->state) { @@ -709,7 +786,7 @@ static void retransmit(struct utcp_connection *c) { pkt->data[1] = 0; pkt->data[2] = 0; pkt->data[3] = c->flags & 0x7; - print_packet(c->utcp, "rtrx", pkt, sizeof(pkt->hdr) + 4); + print_packet(c, "rtrx", pkt, sizeof(pkt->hdr) + 4); utcp->send(utcp, pkt, sizeof(pkt->hdr) + 4); break; @@ -718,7 +795,7 @@ static void retransmit(struct utcp_connection *c) { pkt->hdr.seq = c->snd.nxt; pkt->hdr.ack = c->rcv.nxt; pkt->hdr.ctl = SYN | ACK; - print_packet(c->utcp, "rtrx", pkt, sizeof(pkt->hdr)); + print_packet(c, "rtrx", pkt, sizeof(pkt->hdr)); utcp->send(utcp, pkt, sizeof(pkt->hdr)); break; @@ -731,22 +808,24 @@ static void retransmit(struct utcp_connection *c) { pkt->hdr.seq = c->snd.una; pkt->hdr.ack = c->rcv.nxt; pkt->hdr.ctl = ACK; - uint32_t len = seqdiff(c->snd.last, c->snd.una); - - if(len > utcp->mtu) { - len = utcp->mtu; - } + uint32_t len = min(seqdiff(c->snd.last, c->snd.una), utcp->mtu); if(fin_wanted(c, c->snd.una + len)) { len--; pkt->hdr.ctl |= FIN; } - c->snd.nxt = c->snd.una + len; - c->snd.cwnd = utcp->mtu; // reduce cwnd on retransmit + // RFC 5681 slow start after timeout + uint32_t flightsize = seqdiff(c->snd.nxt, c->snd.una); + c->snd.ssthresh = max(flightsize / 2, utcp->mtu * 2); // eq. 4 + c->snd.cwnd = utcp->mtu; + debug_cwnd(c); + buffer_copy(&c->sndbuf, pkt->data, 0, len); - print_packet(c->utcp, "rtrx", pkt, sizeof(pkt->hdr) + len); + print_packet(c, "rtrx", pkt, sizeof(pkt->hdr) + len); utcp->send(utcp, pkt, sizeof(pkt->hdr) + len); + + c->snd.nxt = c->snd.una + len; break; case CLOSED: @@ -793,10 +872,10 @@ cleanup: * - 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 %lu\n", (unsigned long)len); + debug(c, "sack_consume %lu\n", (unsigned long)len); if(len > c->rcvbuf.used) { - debug("All SACK entries consumed"); + debug(c, "all SACK entries consumed\n"); c->sacks[0].len = 0; return; } @@ -823,12 +902,12 @@ static void sack_consume(struct utcp_connection *c, size_t len) { } for(int i = 0; i < NSACKS && c->sacks[i].len; i++) { - debug("SACK[%d] offset %u len %u\n", i, c->sacks[i].offset, c->sacks[i].len); + debug(c, "SACK[%d] offset %u len %u\n", i, c->sacks[i].offset, c->sacks[i].len); } } static void handle_out_of_order(struct utcp_connection *c, uint32_t offset, const void *data, size_t len) { - debug("out of order packet, offset %u\n", offset); + debug(c, "out of order packet, offset %u\n", offset); // Packet loss or reordering occured. Store the data in the buffer. ssize_t rxd = buffer_put_at(&c->rcvbuf, offset, data, len); @@ -839,30 +918,30 @@ static void handle_out_of_order(struct utcp_connection *c, uint32_t offset, cons // Make note of where we put it. for(int i = 0; i < NSACKS; i++) { if(!c->sacks[i].len) { // nothing to merge, add new entry - debug("New SACK entry %d\n", i); + debug(c, "new SACK entry %d\n", i); c->sacks[i].offset = offset; c->sacks[i].len = rxd; break; } else if(offset < c->sacks[i].offset) { if(offset + rxd < c->sacks[i].offset) { // insert before if(!c->sacks[NSACKS - 1].len) { // only if room left - debug("Insert SACK entry at %d\n", i); + debug(c, "insert SACK entry at %d\n", i); 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"); + debug(c, "SACK entries full, dropping packet\n"); } break; } else { // merge - debug("Merge with start of SACK entry at %d\n", i); + debug(c, "merge with start of SACK entry at %d\n", i); c->sacks[i].offset = offset; break; } } else if(offset <= c->sacks[i].offset + c->sacks[i].len) { if(offset + rxd > c->sacks[i].offset + c->sacks[i].len) { // merge - debug("Merge with end of SACK entry at %d\n", i); + debug(c, "merge with end of SACK entry at %d\n", i); c->sacks[i].len = offset + rxd - c->sacks[i].offset; // TODO: handle potential merge with next entry } @@ -872,14 +951,14 @@ static void handle_out_of_order(struct utcp_connection *c, uint32_t offset, cons } for(int i = 0; i < NSACKS && c->sacks[i].len; i++) { - debug("SACK[%d] offset %u len %u\n", i, c->sacks[i].offset, c->sacks[i].len); + debug(c, "SACK[%d] offset %u len %u\n", i, c->sacks[i].offset, c->sacks[i].len); } } 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 %lu connected with SACK at %u\n", (unsigned long)len, c->sacks[0].offset); + debug(c, "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; @@ -940,13 +1019,12 @@ ssize_t utcp_recv(struct utcp *utcp, const void *data, size_t len) { return -1; } - print_packet(utcp, "recv", data, len); - // Drop packets smaller than the header struct hdr hdr; if(len < sizeof(hdr)) { + print_packet(NULL, "recv", data, len); errno = EBADMSG; return -1; } @@ -954,12 +1032,21 @@ ssize_t utcp_recv(struct utcp *utcp, const void *data, size_t len) { // Make a copy from the potentially unaligned data to a struct hdr memcpy(&hdr, ptr, sizeof(hdr)); + + // Try to match the packet to an existing connection + + struct utcp_connection *c = find_connection(utcp, hdr.dst, hdr.src); + print_packet(c, "recv", data, len); + + // Process the header + ptr += sizeof(hdr); len -= sizeof(hdr); // Drop packets with an unknown CTL flag if(hdr.ctl & ~(SYN | ACK | RST | FIN)) { + print_packet(NULL, "recv", data, len); errno = EBADMSG; return -1; } @@ -1013,10 +1100,6 @@ ssize_t utcp_recv(struct utcp *utcp, const void *data, size_t len) { 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); - // Is it for a new connection? if(!c) { @@ -1071,7 +1154,7 @@ synack: pkt.hdr.dst = c->dst; pkt.hdr.ack = c->rcv.irs + 1; pkt.hdr.seq = c->snd.iss; - pkt.hdr.wnd = c->rcv.wnd; + pkt.hdr.wnd = c->rcvbuf.maxsize; pkt.hdr.ctl = SYN | ACK; if(init) { @@ -1080,11 +1163,11 @@ synack: pkt.data[1] = 0; pkt.data[2] = 0; pkt.data[3] = c->flags & 0x7; - print_packet(c->utcp, "send", &pkt, sizeof(hdr) + 4); + print_packet(c, "send", &pkt, sizeof(hdr) + 4); utcp->send(utcp, &pkt, sizeof(hdr) + 4); } else { pkt.hdr.aux = 0; - print_packet(c->utcp, "send", &pkt, sizeof(hdr)); + print_packet(c, "send", &pkt, sizeof(hdr)); utcp->send(utcp, &pkt, sizeof(hdr)); } } else { @@ -1096,13 +1179,13 @@ synack: return 0; } - debug("%p state %s\n", c->utcp, strstate[c->state]); + debug(c, "state %s\n", strstate[c->state]); // 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) { - debug("Got packet for closed connection\n"); + debug(c, "got packet for closed connection\n"); return 0; } @@ -1158,7 +1241,7 @@ synack: } if(!acceptable) { - debug("Packet not acceptable, %u <= %u + %lu < %u\n", c->rcv.nxt, hdr.seq, (unsigned long)len, c->rcv.nxt + c->rcvbuf.maxsize); + debug(c, "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) { @@ -1183,7 +1266,7 @@ synack: } 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); + debug(c, "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) { @@ -1294,7 +1377,7 @@ synack: 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); + debug(c, "cancelling RTT measurement: %u < %u\n", c->rtt_seq, hdr.ack); c->rtt_start.tv_sec = 0; } } @@ -1314,8 +1397,10 @@ synack: 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); @@ -1328,13 +1413,28 @@ synack: c->snd.una = hdr.ack; - c->dupack = 0; - c->snd.cwnd += utcp->mtu; + if(c->dupack) { + if(c->dupack >= 3) { + debug(c, "fast recovery ended\n"); + c->snd.cwnd = c->snd.ssthresh; + } + + c->dupack = 0; + } + + // Increase the congestion window according to RFC 5681 + if(c->snd.cwnd < c->snd.ssthresh) { + c->snd.cwnd += min(advanced, utcp->mtu); // eq. 2 + } else { + c->snd.cwnd += max(1, (utcp->mtu * utcp->mtu) / c->snd.cwnd); // eq. 3 + } if(c->snd.cwnd > c->sndbuf.maxsize) { c->snd.cwnd = c->sndbuf.maxsize; } + debug_cwnd(c); + // Check if we have sent a FIN that is now ACKed. switch(c->state) { case FIN_WAIT_1: @@ -1359,15 +1459,30 @@ synack: } else { if(!len && is_reliable(c)) { c->dupack++; + debug(c, "duplicate ACK %d\n", c->dupack); if(c->dupack == 3) { - debug("Triplicate ACK\n"); - //TODO: Resend one packet and go to fast recovery mode. See RFC 6582. - //We do a very simple variant here; reset the nxt pointer to the last acknowledged packet from the peer. - //Reset the congestion window so we wait for ACKs. - c->snd.nxt = c->snd.una; - c->snd.cwnd = utcp->mtu; - start_retransmit_timer(c); + // RFC 5681 fast recovery + debug(c, "fast recovery started\n", c->dupack); + uint32_t flightsize = seqdiff(c->snd.nxt, c->snd.una); + c->snd.ssthresh = max(flightsize / 2, utcp->mtu * 2); // eq. 4 + c->snd.cwnd = min(c->snd.ssthresh + 3 * utcp->mtu, c->sndbuf.maxsize); + + if(c->snd.cwnd > c->sndbuf.maxsize) { + c->snd.cwnd = c->sndbuf.maxsize; + } + + debug_cwnd(c); + + fast_retransmit(c); + } else if(c->dupack > 3) { + c->snd.cwnd += utcp->mtu; + + if(c->snd.cwnd > c->sndbuf.maxsize) { + c->snd.cwnd = c->sndbuf.maxsize; + } + + debug_cwnd(c); } } } @@ -1564,14 +1679,14 @@ reset: hdr.ctl = RST | ACK; } - print_packet(utcp, "send", &hdr, sizeof(hdr)); + print_packet(c, "send", &hdr, sizeof(hdr)); utcp->send(utcp, &hdr, sizeof(hdr)); return 0; } int utcp_shutdown(struct utcp_connection *c, int dir) { - debug("%p shutdown %d at %u\n", c ? c->utcp : NULL, dir, c ? c->snd.last : 0); + debug(c, "shutdown %d at %u\n", dir, c ? c->snd.last : 0); if(!c) { errno = EFAULT; @@ -1579,7 +1694,7 @@ int utcp_shutdown(struct utcp_connection *c, int dir) { } if(c->reapable) { - debug("Error: shutdown() called on closed connection %p\n", c); + debug(c, "shutdown() called on closed connection\n"); errno = EBADF; return -1; } @@ -1653,7 +1768,7 @@ static bool reset_connection(struct utcp_connection *c) { } if(c->reapable) { - debug("Error: abort() called on closed connection %p\n", c); + debug(c, "abort() called on closed connection\n"); errno = EBADF; return false; } @@ -1693,7 +1808,7 @@ static bool reset_connection(struct utcp_connection *c) { hdr.wnd = 0; hdr.ctl = RST; - print_packet(c->utcp, "send", &hdr, sizeof(hdr)); + print_packet(c, "send", &hdr, sizeof(hdr)); c->utcp->send(c->utcp, &hdr, sizeof(hdr)); return true; } @@ -1772,7 +1887,7 @@ struct timeval utcp_timeout(struct utcp *utcp) { // delete connections that have been utcp_close()d. if(c->state == CLOSED) { if(c->reapable) { - debug("Reaping %p\n", c); + debug(c, "reaping\n"); free_connection(c); i--; } @@ -1796,7 +1911,7 @@ struct timeval utcp_timeout(struct utcp *utcp) { } if(timerisset(&c->rtrx_timeout) && timercmp(&c->rtrx_timeout, &now, <)) { - debug("retransmit()\n"); + debug(c, "retransmitting after timeout\n"); retransmit(c); }