X-Git-Url: http://git.meshlink.io/?a=blobdiff_plain;f=utcp.c;h=97c43637f4ce52ceb74efd978c278f3e0df1eafb;hb=4368d8c9956242f0bdc00d43ebf32a72332522c1;hp=5db93eac623eb592d40213db18196ce98ffd716c;hpb=95d7d348316f1ed8d2ff3e37cb7f962abf4a7f84;p=utcp diff --git a/utcp.c b/utcp.c index 5db93ea..97c4363 100644 --- a/utcp.c +++ b/utcp.c @@ -29,117 +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; -}; - -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(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) @@ -152,7 +59,7 @@ static void print_packet(void *pkt, size_t len) { if(len > sizeof hdr) { fprintf(stderr, " data="); for(int i = sizeof hdr; i < len; i++) { - char *data = pkt; + const char *data = pkt; fprintf(stderr, "%c", data[i] >= 32 ? data[i] : '.'); } } @@ -160,98 +67,139 @@ static void print_packet(void *pkt, size_t len) { fprintf(stderr, "\n"); } -static struct utcp_connection *allocate_connection(struct utcp *utcp) { - struct utcp_connection *c; +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]); +} + +static int32_t seqdiff(uint32_t a, uint32_t b) { + return a - b; +} - // Initial allocation? +// Connections are stored in a sorted list. +// This gives O(log(N)) lookup time, O(N log(N)) insertion time and O(N) deletion time. - if(!utcp->nconnections) { - utcp->nallocated = 4; - utcp->nconnections = 1; // Skip 0 - utcp->connections = calloc(utcp->nallocated, sizeof *utcp->connections); - } +static int compare(const void *va, const void *vb) { + const struct utcp_connection *a = *(struct utcp_connection **)va; + const struct utcp_connection *b = *(struct utcp_connection **)vb; + if(!a->src || !b->src) + abort(); + int c = (int)a->src - (int)b->src; + if(c) + return c; + c = (int)a->dst - (int)b->dst; + return c; +} - // If there is a hole in the list of connections, use it. - // Otherwise, add a new connection to the end. +static struct utcp_connection *find_connection(const struct utcp *utcp, uint16_t src, uint16_t dst) { + if(!utcp->nconnections) + return NULL; + struct utcp_connection key = { + .src = src, + .dst = dst, + }, *keyp = &key; + struct utcp_connection **match = bsearch(&keyp, utcp->connections, utcp->nconnections, sizeof *utcp->connections, compare); + return match ? *match : NULL; +} + +static void free_connection(struct utcp_connection *c) { + struct utcp *utcp = c->utcp; + struct utcp_connection **cp = bsearch(&c, utcp->connections, utcp->nconnections, sizeof *utcp->connections, compare); + if(!cp) + abort(); - if(utcp->gap >= 0) { - c = utcp->connections[utcp->gap] = calloc(1, sizeof *c); - c->src = utcp->gap; - while(++utcp->gap < utcp->nconnections) - if(!utcp->connections[utcp->gap]) - break; + int i = cp - utcp->connections; + memmove(cp + i, cp + i + 1, (utcp->nconnections - i - 1) * sizeof *cp); + utcp->nconnections--; - if(utcp->gap >= utcp->nconnections) - utcp->gap = -1; - } else { - // Too many connections? + free(c); +} + +static struct utcp_connection *allocate_connection(struct utcp *utcp, uint16_t src, uint16_t dst) { + // Check whether this combination of src and dst is free - if(utcp->nconnections >= 65536) { + if(src) { + if(find_connection(utcp, src, dst)) { + errno = EADDRINUSE; + return NULL; + } + } else { // If src == 0, generate a random port number with the high bit set + if(utcp->nconnections >= 32767) { errno = ENOMEM; return NULL; } + src = rand() | 0x8000; + while(find_connection(utcp, src, dst)) + src++; + } - // Need to reserve more memory? + // Allocate memory for the new connection - if(utcp->nconnections >= utcp->nallocated) { + if(utcp->nconnections >= utcp->nallocated) { + if(!utcp->nallocated) + utcp->nallocated = 4; + else utcp->nallocated *= 2; - utcp->connections = realloc(utcp->connections, utcp->nallocated * sizeof *utcp->connections); - } + struct utcp_connection **new_array = realloc(utcp->connections, utcp->nallocated * sizeof *utcp->connections); + if(!new_array) + return NULL; + utcp->connections = new_array; + } + + struct utcp_connection *c = calloc(1, sizeof *c); + if(!c) + return NULL; - c = utcp->connections[utcp->nconnections] = calloc(1, sizeof *c); - c->src = utcp->nconnections++; + c->sndbufsize = DEFAULT_SNDBUFSIZE; + c->maxsndbufsize = DEFAULT_MAXSNDBUFSIZE; + c->sndbuf = malloc(c->sndbufsize); + if(!c->sndbuf) { + free(c); + return NULL; } + // Fill in the details + + c->src = src; + c->dst = dst; c->snd.iss = rand(); c->snd.una = c->snd.iss; c->snd.nxt = c->snd.iss + 1; c->rcv.wnd = utcp->mtu; c->utcp = utcp; - return c; -} -static struct utcp_connection *find_connection(struct utcp *utcp, uint16_t src) { - if(src < utcp->nconnections && utcp->connections[src]) - return utcp->connections[src]; + // Add it to the sorted list of connections - errno = EINVAL; - return NULL; -} + utcp->connections[utcp->nconnections++] = c; + qsort(utcp->connections, utcp->nconnections, sizeof *utcp->connections, compare); -static void free_connection(struct utcp_connection *c) { - if(!c) - return; - if(c->utcp->gap < 0 || c->src < c->utcp->gap) - c->utcp->gap = c->src; - c->utcp->connections[c->src] = NULL; - free(c); + return c; } -struct utcp_connection *utcp_connect(struct utcp *utcp, void *data, size_t len, utcp_recv_t recv, void *priv) { - struct utcp_connection *c = allocate_connection(utcp); +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) return NULL; c->recv = recv; - struct { - struct hdr hdr; - char data[len]; - } pkt; + struct hdr hdr; - pkt.hdr.src = c->src; - pkt.hdr.dst = 0; - pkt.hdr.seq = c->snd.iss; - pkt.hdr.ack = 0; - pkt.hdr.ctl = SYN; - pkt.hdr.wnd = c->rcv.wnd; - memcpy(pkt.data, data, len); + hdr.src = c->src; + hdr.dst = c->dst; + hdr.seq = c->snd.iss; + hdr.ack = 0; + hdr.ctl = SYN; + hdr.wnd = c->rcv.wnd; set_state(c, SYN_SENT); - utcp->send(utcp, &pkt, sizeof pkt.hdr + len); + 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; } @@ -268,7 +216,7 @@ void utcp_accept(struct utcp_connection *c, utcp_recv_t recv, void *priv) { set_state(c, ESTABLISHED); } -int utcp_send(struct utcp_connection *c, void *data, size_t len) { +ssize_t utcp_send(struct utcp_connection *c, const void *data, size_t len) { if(c->reapable) { fprintf(stderr, "Error: send() called on closed connection %p\n", c); errno = EBADF; @@ -295,30 +243,74 @@ int utcp_send(struct utcp_connection *c, void *data, size_t len) { errno = EPIPE; return -1; } - + + // Add data to send buffer + + if(!len) + return 0; + + if(!data) { + errno = EFAULT; + return -1; + } + + uint32_t bufused = seqdiff(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 if possible. + * - Cap len so it doesn't overflow our buffer. + */ + + if(len > c->sndbufsize - bufused && c->sndbufsize < c->maxsndbufsize) { + if(c->sndbufsize > c->maxsndbufsize / 2) + c->sndbufsize = c->maxsndbufsize; + else + c->sndbufsize *= 2; + c->sndbuf = realloc(c->sndbuf, c->sndbufsize); + } + + if(len > c->sndbufsize - bufused) + len = c->sndbufsize - bufused; + + if(!len) { + errno == EWOULDBLOCK; + return 0; + } + + memcpy(c->sndbuf + bufused, data, len); + + // Send segments + struct { struct hdr hdr; - char data[len]; + char data[c->utcp->mtu]; } pkt; pkt.hdr.src = c->src; pkt.hdr.dst = c->dst; - pkt.hdr.seq = c->snd.nxt; pkt.hdr.ack = c->rcv.nxt; pkt.hdr.wnd = c->snd.wnd; pkt.hdr.ctl = ACK; - memcpy(pkt.data, data, len); + uint32_t left = len; - c->snd.nxt += len; + while(left) { + uint32_t seglen = left > c->utcp->mtu ? c->utcp->mtu : left; + pkt.hdr.seq = c->snd.nxt; - c->utcp->send(c->utcp, &pkt, sizeof pkt.hdr + len); - // - // Can we add it to the send window? - - // Do we need to kick some timers? - - return 0; + 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); + return len; } static void swap_ports(struct hdr *hdr) { @@ -327,9 +319,23 @@ static void swap_ports(struct hdr *hdr) { hdr->dst = tmp; } -int utcp_recv(struct utcp *utcp, void *data, size_t len) { - fprintf(stderr, "%p got: ", utcp); - print_packet(data, len); +int utcp_recv(struct utcp *utcp, const void *data, size_t len) { + if(!utcp) { + errno = EFAULT; + return -1; + } + + if(!len) + return 0; + + if(!data) { + errno = EFAULT; + return -1; + } + + print_packet(utcp, "recv", data, len); + + // Drop packets smaller than the header struct hdr hdr; if(len < sizeof hdr) { @@ -337,153 +343,233 @@ int utcp_recv(struct utcp *utcp, 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; } - struct utcp_connection *c = find_connection(utcp, hdr.dst); + // 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, data, len)) && (c = allocate_connection(utcp))) { // 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->snd.iss = rand(); - c->snd.una = c->snd.iss; - c->snd.nxt = c->snd.iss + 1; c->rcv.nxt = c->rcv.irs + 1; set_state(c, SYN_RECEIVED); - hdr.dst = c->dst = hdr.src; + hdr.dst = c->dst; hdr.src = c->src; 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(hdr.ack <= c->snd.iss || hdr.ack > c->snd.nxt) { - 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; - if(hdr.ctl & ACK) - c->snd.una = hdr.ack; - if(c->snd.una > c->snd.iss) { - 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? - } + // 1. Drop invalid packets. - return 0; + // 1a. Drop packets that should not happen in our current state. + + 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; + // Otherwise, send an ACK back in the hope things improve. + goto ack; + } + + c->snd.wnd = hdr.wnd; // TODO: move below + + // 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 ack_and_drop; + goto reset; } - c->snd.wnd = hdr.wnd; + // 2. Handle RST packets - // TODO: check whether segment really starts at rcv.nxt, otherwise trim it. - 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: @@ -492,121 +578,120 @@ int utcp_recv(struct utcp *utcp, 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(hdr.ack >= c->snd.una && hdr.ack <= c->snd.nxt) - c->utcp->accept(c, NULL, 0); - - 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(hdr.ack < c->snd.una) - return 0; - if(hdr.ack > c->snd.nxt) - goto ack_and_drop; - if(hdr.ack > c->snd.una && hdr.ack <= c->snd.nxt) { - c->snd.una = hdr.ack; - if(c->snd.wl1 < hdr.seq || (c->snd.wl1 == hdr.seq && c->snd.wl2 <= hdr.ack)) { - 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(); + } - 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(); + int rxd; + + 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 - - if(len && c->recv) { - c->recv(c, data, len); - c->rcv.nxt += len; - goto ack_and_drop; + // FIN counts as one sequence number + c->rcv.nxt++; + + // 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: @@ -620,37 +705,34 @@ 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; } -void utcp_shutdown(struct utcp_connection *c, int dir) { +int utcp_shutdown(struct utcp_connection *c, int dir) { + fprintf(stderr, "%p shutdown %d\n", c->utcp, dir); + if(!c) { + errno = EFAULT; + return -1; + } + if(c->reapable) { fprintf(stderr, "Error: shutdown() called on closed connection %p\n", c); - return; + errno = EBADF; + return -1; } // TODO: handle dir switch(c->state) { case CLOSED: - return; + return 0; case LISTEN: case SYN_SENT: set_state(c, CLOSED); - return; + return 0; case SYN_RECEIVED: case ESTABLISHED: @@ -658,15 +740,15 @@ void utcp_shutdown(struct utcp_connection *c, int dir) { break; case FIN_WAIT_1: case FIN_WAIT_2: - return; + return 0; case CLOSE_WAIT: - set_state(c, LAST_ACK); + set_state(c, CLOSING); break; case CLOSING: case LAST_ACK: case TIME_WAIT: - return; + return 0; } // Send FIN @@ -682,32 +764,42 @@ void 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; } -void utcp_close(struct utcp_connection *c) { - utcp_shutdown(c, SHUT_RDWR); +int utcp_close(struct utcp_connection *c) { + if(utcp_shutdown(c, SHUT_RDWR)) + return -1; c->reapable = true; + return 0; } -void utcp_abort(struct utcp_connection *c) { +int utcp_abort(struct utcp_connection *c) { + if(!c) { + errno = EFAULT; + return -1; + } + if(c->reapable) { fprintf(stderr, "Error: abort() called on closed connection %p\n", c); - return; + errno = EBADF; + return -1; } c->reapable = true; switch(c->state) { case CLOSED: - return; + return 0; case LISTEN: case SYN_SENT: case CLOSING: case LAST_ACK: case TIME_WAIT: set_state(c, CLOSED); - return; + return 0; case SYN_RECEIVED: case ESTABLISHED: @@ -729,40 +821,128 @@ void 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) { @@ -770,12 +950,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; } @@ -787,3 +972,50 @@ void utcp_exit(struct utcp *utcp) { free_connection(utcp->connections[i]); free(utcp); } + +uint16_t utcp_get_mtu(struct utcp *utcp) { + return utcp->mtu; +} + +void utcp_set_mtu(struct utcp *utcp, uint16_t mtu) { + // TODO: handle overhead of the header + utcp->mtu = mtu; +} + +int utcp_get_user_timeout(struct utcp *u) { + return u->timeout; +} + +void utcp_set_user_timeout(struct utcp *u, int timeout) { + u->timeout = timeout; +} + +size_t utcp_get_sndbuf(struct utcp_connection *c) { + return c->maxsndbufsize; +} + +void utcp_set_sndbuf(struct utcp_connection *c, size_t size) { + c->maxsndbufsize = size; + if(c->maxsndbufsize != size) + c->maxsndbufsize = -1; +} + +bool utcp_get_nodelay(struct utcp_connection *c) { + return c->nodelay; +} + +void utcp_set_nodelay(struct utcp_connection *c, bool nodelay) { + c->nodelay = nodelay; +} + +bool utcp_get_keepalive(struct utcp_connection *c) { + return c->keepalive; +} + +void utcp_set_keepalive(struct utcp_connection *c, bool keepalive) { + c->keepalive = keepalive; +} + +size_t utcp_get_outq(struct utcp_connection *c) { + return seqdiff(c->snd.nxt, c->snd.una); +}