X-Git-Url: http://git.meshlink.io/?a=blobdiff_plain;f=utcp.c;h=966295a7f086a079f96a2d818cad1d8d3c90bad2;hb=365dd2877f26120742c409e62865b7e563ec87fa;hp=d9ba952e2290466331d2346b556560577ac5f18d;hpb=93d2e72d3e72e4d91575fc00545dbba96dcdea69;p=utcp diff --git a/utcp.c b/utcp.c index d9ba952..966295a 100644 --- a/utcp.c +++ b/utcp.c @@ -29,120 +29,24 @@ #include #include -#define UTCP_INTERNAL -#include "utcp.h" - -#define PREP(l) char pkt[(l) + sizeof struct hdr]; struct hdr *hdr = &pkt; - -#define SYN 1 -#define ACK 2 -#define FIN 4 -#define RST 8 - -struct hdr { - uint16_t src; // Source port - uint16_t dst; // Destination port - uint32_t seq; // Sequence number - uint32_t ack; // Acknowledgement number - uint32_t wnd; // Window size - uint16_t ctl; // Flags (SYN, ACK, FIN, RST) - uint16_t aux; // other stuff -}; - -enum state { - CLOSED, - LISTEN, - SYN_SENT, - SYN_RECEIVED, - ESTABLISHED, - FIN_WAIT_1, - FIN_WAIT_2, - CLOSE_WAIT, - CLOSING, - LAST_ACK, - TIME_WAIT -}; - -const char *strstate[] = { - "CLOSED", - "LISTEN", - "SYN_SENT", - "SYN_RECEIVED", - "ESTABLISHED", - "FIN_WAIT_1", - "FIN_WAIT_2", - "CLOSE_WAIT", - "CLOSING", - "LAST_ACK", - "TIME_WAIT" -}; - -struct utcp_connection { - void *priv; - struct utcp *utcp; - bool reapable; - - uint16_t src; - uint16_t dst; - enum state state; - - // The following two structures form the TCB - - struct { - uint32_t una; - uint32_t nxt; - uint32_t wnd; - uint32_t up; - uint32_t wl1; - uint32_t wl2; - uint32_t iss; - } snd; - - struct { - uint32_t nxt; - uint32_t wnd; - uint32_t up; - uint32_t irs; - } rcv; - - utcp_recv_t recv; - - struct timeval conn_timeout; - struct timeval rtrx_timeout; - - char *sndbuf; - uint32_t sndbufsize; -}; - -struct utcp { - void *priv; - - utcp_accept_t accept; - utcp_pre_accept_t pre_accept; - utcp_send_t send; - - uint16_t mtu; - - struct utcp_connection **connections; - int nconnections; - int nallocated; - int gap; -}; +#include "utcp_priv.h" static void set_state(struct utcp_connection *c, enum state state) { c->state = state; + if(state == ESTABLISHED) + timerclear(&c->conn_timeout); fprintf(stderr, "%p new state: %s\n", c->utcp, strstate[state]); } -static void print_packet(const void *pkt, size_t len) { +static void print_packet(struct utcp *utcp, const char *dir, const void *pkt, size_t len) { struct hdr hdr; if(len < sizeof hdr) { - fprintf(stderr, "short packet (%zu bytes)\n", len); + fprintf(stderr, "%p %s: short packet (%zu bytes)\n", utcp, dir, len); return; } memcpy(&hdr, pkt, sizeof hdr); - fprintf (stderr, "src=%u dst=%u seq=%u ack=%u wnd=%u ctl=", hdr.src, hdr.dst, hdr.seq, hdr.ack, hdr.wnd); + fprintf (stderr, "%p %s: src=%u dst=%u seq=%u ack=%u wnd=%u ctl=", utcp, dir, hdr.src, hdr.dst, hdr.seq, hdr.ack, hdr.wnd); if(hdr.ctl & SYN) fprintf(stderr, "SYN"); if(hdr.ctl & RST) @@ -163,7 +67,7 @@ static void print_packet(const void *pkt, size_t len) { fprintf(stderr, "\n"); } -static void list_connections(struct utcp *utcp) { +static inline void list_connections(struct utcp *utcp) { fprintf(stderr, "%p has %d connections:\n", utcp, utcp->nconnections); for(int i = 0; i < utcp->nconnections; i++) fprintf(stderr, " %u -> %u state %s\n", utcp->connections[i]->src, utcp->connections[i]->dst, strstate[utcp->connections[i]->state]); @@ -287,9 +191,11 @@ struct utcp_connection *utcp_connect(struct utcp *utcp, uint16_t dst, utcp_recv_ set_state(c, SYN_SENT); + print_packet(utcp, "send", &hdr, sizeof hdr); utcp->send(utcp, &hdr, sizeof hdr); - // Set timeout? + gettimeofday(&c->conn_timeout, NULL); + c->conn_timeout.tv_sec += utcp->timeout; return c; } @@ -346,10 +252,26 @@ ssize_t utcp_send(struct utcp_connection *c, const void *data, size_t len) { uint32_t bufused = c->snd.nxt - c->snd.una; + /* Check our send buffer. + * - If it's big enough, just put the data in there. + * - If not, decide whether to enlarge. (TODO, now we just always enlarge) + * - Cap len so it doesn't overflow our buffer. + */ + + if(len > c->sndbufsize - bufused) { + c->sndbufsize *= 2; + c->sndbuf = realloc(c->sndbuf, c->sndbufsize); + } + if(len > c->sndbufsize - bufused) len = c->sndbufsize - bufused; - memcpy(c->sndbuf + (c->snd.nxt - c->snd.una), data, len); + if(!len) { + errno == EWOULDBLOCK; + return 0; + } + + memcpy(c->sndbuf + bufused, data, len); // Send segments @@ -376,10 +298,11 @@ ssize_t utcp_send(struct utcp_connection *c, const void *data, size_t len) { 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=%u\n", len); + fprintf(stderr, "len=%zu\n", len); return len; } @@ -389,8 +312,8 @@ static void swap_ports(struct hdr *hdr) { hdr->dst = tmp; } -static int16_t seqdiff(uint16_t a, uint16_t b) { - return a -b; +static int32_t seqdiff(uint32_t a, uint32_t b) { + return a - b; } int utcp_recv(struct utcp *utcp, const void *data, size_t len) { @@ -407,8 +330,9 @@ int utcp_recv(struct utcp *utcp, const void *data, size_t len) { return -1; } - fprintf(stderr, "%p got: ", utcp); - print_packet(data, len); + print_packet(utcp, "recv", data, len); + + // Drop packets smaller than the header struct hdr hdr; if(len < sizeof hdr) { @@ -416,27 +340,48 @@ int utcp_recv(struct utcp *utcp, const void *data, size_t len) { return -1; } + // Make a copy from the potentially unaligned data to a struct hdr + memcpy(&hdr, data, sizeof hdr); data += sizeof hdr; len -= sizeof hdr; + // Drop packets with an unknown CTL flag + if(hdr.ctl & ~(SYN | ACK | RST | FIN)) { errno = EBADMSG; return -1; } - //list_connections(utcp); + // 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) { + // Ignore RST packets + if(hdr.ctl & RST) return 0; - if(hdr.ctl & SYN && !(hdr.ctl & ACK) && utcp->accept && (!utcp->pre_accept || utcp->pre_accept(utcp, hdr.dst)) && (c = allocate_connection(utcp, hdr.dst, hdr.src))) { // LISTEN - // Return SYN+ACK + // Is it a SYN packet and are we LISTENing? + + if(hdr.ctl & SYN && !(hdr.ctl & ACK) && utcp->accept) { + // If we don't want to accept it, send a RST back + if((utcp->pre_accept && !utcp->pre_accept(utcp, hdr.dst))) { + len = 1; + goto reset; + } + + // Try to allocate memory, otherwise send a RST back + c = allocate_connection(utcp, hdr.dst, hdr.src); + if(!c) { + len = 1; + goto reset; + } + + // Return SYN+ACK, go to SYN_RECEIVED state c->snd.wnd = hdr.wnd; c->rcv.irs = hdr.seq; c->rcv.nxt = c->rcv.irs + 1; @@ -447,121 +392,181 @@ int utcp_recv(struct utcp *utcp, const void *data, size_t len) { hdr.ack = c->rcv.irs + 1; hdr.seq = c->snd.iss; hdr.ctl = SYN | ACK; + print_packet(c->utcp, "send", &hdr, sizeof hdr); utcp->send(utcp, &hdr, sizeof hdr); - return 0; - } else { // CLOSED + } else { + // No, we don't want your packets, send a RST back len = 1; goto reset; } + + return 0; } fprintf(stderr, "%p state %s\n", c->utcp, strstate[c->state]); - if(c->state == CLOSED) { - fprintf(stderr, "Error: packet recv()d on closed connection %p\n", c); - errno = EBADF; - return -1; - } + // 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) + return 0; // It is for an existing connection. - if(c->state == SYN_SENT) { - if(hdr.ctl & ACK) { - if(seqdiff(hdr.ack, c->snd.iss) <= 0 || seqdiff(hdr.ack, c->snd.nxt) > 0) { - fprintf(stderr, "Invalid ACK, %u %u %u\n", hdr.ack, c->snd.iss, c->snd.nxt); - goto reset; - } - } - if(hdr.ctl & RST) { - if(!(hdr.ctl & ACK)) - return 0; - set_state(c, CLOSED); - errno = ECONNREFUSED; - c->recv(c, NULL, 0); - return 0; - } - if(hdr.ctl & SYN) { - c->dst = hdr.src; - c->rcv.nxt = hdr.seq + 1; - c->rcv.irs = hdr.seq; - c->snd.wnd = hdr.wnd; + // 1. Drop invalid packets. - if(hdr.ctl & ACK) - c->snd.una = hdr.ack; - if(seqdiff(c->snd.una, c->snd.iss) > 0) { - set_state(c, ESTABLISHED); - // TODO: signal app? - swap_ports(&hdr); - hdr.seq = c->snd.nxt; - hdr.ack = c->rcv.nxt; - hdr.ctl = ACK; - } else { - set_state(c, SYN_RECEIVED); - swap_ports(&hdr); - hdr.seq = c->snd.iss; - hdr.ack = c->rcv.nxt; - hdr.ctl = SYN | ACK; - } - utcp->send(utcp, &hdr, sizeof hdr); - // TODO: queue any data? - } + // 1a. Drop packets that should not happen in our current state. - return 0; + switch(c->state) { + case SYN_SENT: + case SYN_RECEIVED: + case ESTABLISHED: + case FIN_WAIT_1: + case FIN_WAIT_2: + case CLOSE_WAIT: + case CLOSING: + case LAST_ACK: + case TIME_WAIT: + break; + default: + abort(); } + // 1b. Drop packets with a sequence number not in our receive window. + bool acceptable; - if(len == 0) + if(c->state == SYN_SENT) + acceptable = true; + + // TODO: handle packets overlapping c->rcv.nxt. +#if 0 + // Only use this when accepting out-of-order packets. + else if(len == 0) if(c->rcv.wnd == 0) acceptable = hdr.seq == c->rcv.nxt; else - acceptable = (hdr.seq >= c->rcv.nxt && hdr.seq < c->rcv.nxt + c->rcv.wnd); + acceptable = (seqdiff(hdr.seq, c->rcv.nxt) >= 0 && seqdiff(hdr.seq, c->rcv.nxt + c->rcv.wnd) < 0); else if(c->rcv.wnd == 0) + // We don't accept data when the receive window is zero. acceptable = false; else - acceptable = (hdr.seq >= c->rcv.nxt && hdr.seq < c->rcv.nxt + c->rcv.wnd) - || (hdr.seq + len - 1 >= c->rcv.nxt && hdr.seq + len - 1 < c->rcv.nxt + c->rcv.wnd); + // Both start and end of packet must be within the receive window + acceptable = (seqdiff(hdr.seq, c->rcv.nxt) >= 0 && seqdiff(hdr.seq, c->rcv.nxt + c->rcv.wnd) < 0) + || (seqdiff(hdr.seq + len + 1, c->rcv.nxt) >= 0 && seqdiff(hdr.seq + len - 1, c->rcv.nxt + c->rcv.wnd) < 0); +#else + if(c->state != SYN_SENT) + acceptable = hdr.seq == c->rcv.nxt; +#endif if(!acceptable) { - fprintf(stderr, "Packet not acceptable, %u %u %u %zu\n", hdr.seq, c->rcv.nxt, c->rcv.wnd, len); + fprintf(stderr, "Packet not acceptable, %u <= %u + %zu < %u\n", c->rcv.nxt, hdr.seq, len, c->rcv.nxt + c->rcv.wnd); + // Ignore unacceptable RST packets. if(hdr.ctl & RST) return 0; - goto ack_and_drop; + // Otherwise, send an ACK back in the hope things improve. + goto ack; } - c->snd.wnd = hdr.wnd; + c->snd.wnd = hdr.wnd; // TODO: move below - // TODO: check whether segment really starts at rcv.nxt, otherwise trim it. + // 1c. Drop packets with an invalid ACK. + // ackno should not roll back, and it should also not be bigger than snd.nxt. + + if(hdr.ctl & ACK && (seqdiff(hdr.ack, c->snd.nxt) > 0 || seqdiff(hdr.ack, c->snd.una) < 0)) { + fprintf(stderr, "Packet ack seqno out of range, %u %u %u\n", hdr.ack, c->snd.una, c->snd.nxt); + // Ignore unacceptable RST packets. + if(hdr.ctl & RST) + return 0; + goto reset; + } + + // 2. Handle RST packets if(hdr.ctl & RST) { switch(c->state) { + case SYN_SENT: + if(!(hdr.ctl & ACK)) + return 0; + // The peer has refused our connection. + set_state(c, CLOSED); + errno = ECONNREFUSED; + if(c->recv) + c->recv(c, NULL, 0); + return 0; case SYN_RECEIVED: - // TODO: delete connection? - break; + if(hdr.ctl & ACK) + return 0; + // We haven't told the application about this connection yet. Silently delete. + free_connection(c); + return 0; case ESTABLISHED: case FIN_WAIT_1: case FIN_WAIT_2: case CLOSE_WAIT: + if(hdr.ctl & ACK) + return 0; + // The peer has aborted our connection. set_state(c, CLOSED); errno = ECONNRESET; - c->recv(c, NULL, 0); - break; + if(c->recv) + c->recv(c, NULL, 0); + return 0; case CLOSING: case LAST_ACK: case TIME_WAIT: - // TODO: delete connection? - break; - default: - // TODO: wtf? + if(hdr.ctl & ACK) + return 0; + // As far as the application is concerned, the connection has already been closed. + // If it has called utcp_close() already, we can immediately free this connection. + if(c->reapable) { + free_connection(c); + return 0; + } + // Otherwise, immediately move to the CLOSED state. + set_state(c, CLOSED); return 0; + default: + abort(); } - set_state(c, CLOSED); - return 0; } + // 3. Advance snd.una + + uint32_t advanced = seqdiff(hdr.ack, c->snd.una); + c->snd.una = hdr.ack; + + if(advanced) { + fprintf(stderr, "%p advanced %u\n", utcp, advanced); + // Make room in the send buffer. + // TODO: try to avoid memmoving too much. Circular buffer? + uint32_t left = seqdiff(c->snd.nxt, hdr.ack); + if(left) + memmove(c->sndbuf, c->sndbuf + advanced, left); + } + + // 4. Update timers + + if(advanced) { + timerclear(&c->conn_timeout); // It should be set anew in utcp_timeout() if c->snd.una != c->snd.nxt. + if(c->snd.una == c->snd.nxt) + timerclear(&c->rtrx_timeout); + } + + // 5. Process SYN stuff + if(hdr.ctl & SYN) { switch(c->state) { + case SYN_SENT: + // This is a SYNACK. It should always have ACKed the SYN. + if(!advanced) + goto reset; + c->rcv.irs = hdr.seq; + c->rcv.nxt = hdr.seq; + set_state(c, ESTABLISHED); + // TODO: notify application of this somehow. + break; case SYN_RECEIVED: case ESTABLISHED: case FIN_WAIT_1: @@ -570,121 +575,120 @@ int utcp_recv(struct utcp *utcp, const void *data, size_t len) { case CLOSING: case LAST_ACK: case TIME_WAIT: - set_state(c, CLOSED); - errno = ECONNRESET; - c->recv(c, NULL, 0); + // Ehm, no. We should never receive a second SYN. goto reset; - break; default: - // TODO: wtf? - return 0; + abort(); } + + // SYN counts as one sequence number + c->rcv.nxt++; } - if(!(hdr.ctl & ACK)) - return 0; + // 6. Process new data - switch(c->state) { - case SYN_RECEIVED: - if(seqdiff(hdr.ack, c->snd.una) >= 0 && seqdiff(hdr.ack, c->snd.nxt) <= 0) - c->utcp->accept(c, hdr.dst); - - if(c->state != ESTABLISHED) + if(c->state == SYN_RECEIVED) { + // This is the ACK after the SYNACK. It should always have ACKed the SYNACK. + if(!advanced) goto reset; - break; - case ESTABLISHED: - case CLOSE_WAIT: - if(seqdiff(hdr.ack, c->snd.una) < 0) - return 0; - if(seqdiff(hdr.ack, c->snd.nxt) > 0) - goto ack_and_drop; - if(seqdiff(hdr.ack, c->snd.una) > 0 && seqdiff(hdr.ack, c->snd.nxt) <= 0) { - c->snd.una = hdr.ack; - if(seqdiff(c->snd.wl1, hdr.seq) < 0 || (c->snd.wl1 == hdr.seq && seqdiff(c->snd.wl2, hdr.ack) <= 0)) { - c->snd.wnd = hdr.wnd; - c->snd.wl1 = hdr.seq; - c->snd.wl2 = hdr.ack; - } - } - break; - case FIN_WAIT_1: - if(hdr.ack == c->snd.nxt) - set_state(c, FIN_WAIT_2); - break; - case FIN_WAIT_2: - // TODO: If nothing left to send, close. - break; - case CLOSING: - if(hdr.ack == c->snd.nxt) { - set_state(c, TIME_WAIT); - } - break; - case LAST_ACK: - if(hdr.ack == c->snd.nxt) { + + // Are we still LISTENing? + if(utcp->accept) + utcp->accept(c, c->src); + + if(c->state != ESTABLISHED) { set_state(c, CLOSED); + c->reapable = true; + goto reset; } - return 0; - case TIME_WAIT: - // TODO: retransmission of remote FIN, ACK and restart 2 MSL timeout - break; - default: - goto reset; } - // Process data + if(len) { + switch(c->state) { + case SYN_SENT: + case SYN_RECEIVED: + // This should never happen. + abort(); + case ESTABLISHED: + case FIN_WAIT_1: + case FIN_WAIT_2: + break; + case CLOSE_WAIT: + case CLOSING: + case LAST_ACK: + case TIME_WAIT: + // Ehm no, We should never receive more data after a FIN. + goto reset; + default: + abort(); + } + + int rxd; - switch(c->state) { - case ESTABLISHED: - case FIN_WAIT_1: - case FIN_WAIT_2: - // TODO: process the data, see page 74 - break; - case CLOSE_WAIT: - case CLOSING: - case LAST_ACK: - case TIME_WAIT: - break; - default: - abort(); + if(c->recv) { + rxd = c->recv(c, data, len); + if(rxd < 0) + rxd = 0; + else if(rxd > len) + rxd = len; // Bad application, bad! + } else { + rxd = len; + } + + c->rcv.nxt += len; } + // 7. Process FIN stuff + if(hdr.ctl & FIN) { switch(c->state) { - case CLOSED: - case LISTEN: case SYN_SENT: - return 0; case SYN_RECEIVED: + // This should never happen. + abort(); case ESTABLISHED: set_state(c, CLOSE_WAIT); - c->rcv.nxt++; - goto ack_and_drop; + break; case FIN_WAIT_1: set_state(c, CLOSING); - c->rcv.nxt++; - goto ack_and_drop; + break; case FIN_WAIT_2: set_state(c, TIME_WAIT); - c->rcv.nxt++; - goto ack_and_drop; + break; case CLOSE_WAIT: case CLOSING: case LAST_ACK: case TIME_WAIT: - break; + // Ehm, no. We should never receive a second FIN. + goto reset; default: abort(); } - } - // Process the data + // FIN counts as one sequence number + c->rcv.nxt++; - if(len && c->recv) { - c->recv(c, data, len); - c->rcv.nxt += len; - goto ack_and_drop; + // Inform the application that the peer closed the connection. + if(c->recv) { + errno = 0; + c->recv(c, NULL, 0); + } } + if(!len && !advanced) + return 0; + + if(!len && !(hdr.ctl & SYN) && !(hdr.ctl & FIN)) + 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); return 0; reset: @@ -698,23 +702,14 @@ reset: hdr.seq = 0; hdr.ctl = RST | ACK; } + print_packet(utcp, "send", &hdr, sizeof hdr); utcp->send(utcp, &hdr, sizeof hdr); return 0; -ack_and_drop: - swap_ports(&hdr); - hdr.seq = c->snd.nxt; - hdr.ack = c->rcv.nxt; - hdr.ctl = ACK; - utcp->send(utcp, &hdr, sizeof hdr); - if(c->state == CLOSE_WAIT || c->state == TIME_WAIT) { - errno = 0; - c->recv(c, NULL, 0); - } - return 0; } int utcp_shutdown(struct utcp_connection *c, int dir) { + fprintf(stderr, "%p shutdown %d\n", c->utcp, dir); if(!c) { errno = EFAULT; return -1; @@ -744,7 +739,7 @@ int utcp_shutdown(struct utcp_connection *c, int dir) { case FIN_WAIT_2: return 0; case CLOSE_WAIT: - set_state(c, LAST_ACK); + set_state(c, CLOSING); break; case CLOSING: @@ -766,6 +761,7 @@ int utcp_shutdown(struct utcp_connection *c, int dir) { c->snd.nxt += 1; + print_packet(c->utcp, "send", &hdr, sizeof hdr); c->utcp->send(c->utcp, &hdr, sizeof hdr); return 0; } @@ -822,41 +818,128 @@ int utcp_abort(struct utcp_connection *c) { hdr.wnd = 0; hdr.ctl = RST; + print_packet(c->utcp, "send", &hdr, sizeof hdr); c->utcp->send(c->utcp, &hdr, sizeof hdr); return 0; } -void utcp_timeout(struct utcp *utcp) { +static void retransmit(struct utcp_connection *c) { + if(c->state == CLOSED || c->snd.nxt == c->snd.una) + return; + + struct utcp *utcp = c->utcp; + + struct { + struct hdr hdr; + char data[c->utcp->mtu]; + } pkt; + + pkt.hdr.src = c->src; + pkt.hdr.dst = c->dst; + + switch(c->state) { + case LISTEN: + // TODO: this should not happen + break; + + case SYN_SENT: + pkt.hdr.seq = c->snd.iss; + pkt.hdr.ack = 0; + pkt.hdr.wnd = c->rcv.wnd; + pkt.hdr.ctl = SYN; + print_packet(c->utcp, "rtrx", &pkt, sizeof pkt.hdr); + utcp->send(utcp, &pkt, sizeof pkt.hdr); + break; + + case SYN_RECEIVED: + 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); + utcp->send(utcp, &pkt, sizeof pkt.hdr); + break; + + case ESTABLISHED: + case FIN_WAIT_1: + pkt.hdr.seq = c->snd.una; + pkt.hdr.ack = c->rcv.nxt; + pkt.hdr.ctl = ACK; + uint32_t len = seqdiff(c->snd.nxt, c->snd.una); + if(c->state == FIN_WAIT_1) + len--; + if(len > utcp->mtu) + len = utcp->mtu; + else { + if(c->state == FIN_WAIT_1) + pkt.hdr.ctl |= FIN; + } + memcpy(pkt.data, c->sndbuf, len); + print_packet(c->utcp, "rtrx", &pkt, sizeof pkt.hdr + len); + utcp->send(utcp, &pkt, sizeof pkt.hdr + len); + break; + + default: + // TODO: implement + abort(); + } +} + +/* Handle timeouts. + * One call to this function will loop through all connections, + * checking if something needs to be resent or not. + * The return value is the time to the next timeout in milliseconds, + * or maybe a negative value if the timeout is infinite. + */ +int utcp_timeout(struct utcp *utcp) { struct timeval now; gettimeofday(&now, NULL); + struct timeval next = {now.tv_sec + 3600, now.tv_usec}; for(int i = 0; i < utcp->nconnections; i++) { struct utcp_connection *c = utcp->connections[i]; if(!c) continue; - if(c->reapable) { - fprintf(stderr, "Reaping %p\n", c); - free_connection(c); + if(c->state == CLOSED) { + if(c->reapable) { + fprintf(stderr, "Reaping %p\n", c); + free_connection(c); + i--; + } continue; } - if(c->state == CLOSED) - return; - - if(c->conn_timeout.tv_sec && timercmp(&c->conn_timeout, &now, <)) { - if(!c->reapable) { - errno = ETIMEDOUT; - c->recv(c, NULL, 0); - } + if(timerisset(&c->conn_timeout) && timercmp(&c->conn_timeout, &now, <)) { + errno = ETIMEDOUT; c->state = CLOSED; - return; + if(c->recv) + c->recv(c, NULL, 0); + continue; + } + + if(timerisset(&c->rtrx_timeout) && timercmp(&c->rtrx_timeout, &now, <)) { + retransmit(c); } - if(c->rtrx_timeout.tv_sec && timercmp(&c->rtrx_timeout, &now, <)) { - // TODO: retransmit stuff; + 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; } + + struct timeval diff; + timersub(&next, &now, &diff); + if(diff.tv_sec < 0) + return 0; + return diff.tv_sec * 1000 + diff.tv_usec / 1000; } struct utcp *utcp_init(utcp_accept_t accept, utcp_pre_accept_t pre_accept, utcp_send_t send, void *priv) { @@ -864,12 +947,17 @@ struct utcp *utcp_init(utcp_accept_t accept, utcp_pre_accept_t pre_accept, utcp_ if(!utcp) return NULL; + if(!send) { + errno = EFAULT; + return NULL; + } + utcp->accept = accept; utcp->pre_accept = pre_accept; utcp->send = send; utcp->priv = priv; - utcp->gap = -1; utcp->mtu = 1000; + utcp->timeout = 60; return utcp; } @@ -881,3 +969,14 @@ void utcp_exit(struct utcp *utcp) { free_connection(utcp->connections[i]); free(utcp); } + +void utcp_set_mtu(struct utcp *utcp, uint16_t mtu) { + // TODO: handle overhead of the header + utcp->mtu = mtu; +} + +int utcp_set_connection_timeout(struct utcp *u, int timeout) { + int prev = u->timeout; + u->timeout = timeout; + return prev; +}