Check for astyle version 3 before formatting the code.

[utcp] / utcp.c

diff --git a/utcp.c b/utcp.c
index b939dc8a0e5e4f6723ea2eaa6f1b610adc1ecfee..4875f8405ef7799aa5a935b3d1910a88d668f2a6 100644 (file)
--- a/utcp.c
+++ b/utcp.c
@@ -580,12 +580,12 @@ ssize_t utcp_send(struct utcp_connection *c, const void *data, size_t len) {
        switch(c->state) {
        case CLOSED:
        case LISTEN:
-       case SYN_SENT:
-       case SYN_RECEIVED:
                debug("Error: send() called on unconnected connection %p\n", c);
                errno = ENOTCONN;
                return -1;
 
+       case SYN_SENT:
+       case SYN_RECEIVED:
        case ESTABLISHED:
        case CLOSE_WAIT:
                break;
@@ -621,6 +621,13 @@ ssize_t utcp_send(struct utcp_connection *c, const void *data, size_t len) {
        }
 
        c->snd.last += len;
+
+       // Don't send anything yet if the connection has not fully established yet
+
+       if(c->state == SYN_SENT || c->state == SYN_RECEIVED) {
+               return len;
+       }
+
        ack(c, false);
 
        if(!is_reliable(c)) {
@@ -892,6 +899,8 @@ static void handle_incoming_data(struct utcp_connection *c, uint32_t seq, const
 
 
 ssize_t utcp_recv(struct utcp *utcp, const void *data, size_t len) {
+       const uint8_t *ptr = data;
+
        if(!utcp) {
                errno = EFAULT;
                return -1;
@@ -919,8 +928,8 @@ 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, data, sizeof(hdr));
-       data += sizeof(hdr);
+       memcpy(&hdr, ptr, sizeof(hdr));
+       ptr += sizeof(hdr);
        len -= sizeof(hdr);
 
        // Drop packets with an unknown CTL flag
@@ -952,7 +961,7 @@ ssize_t utcp_recv(struct utcp *utcp, const void *data, size_t len) {
                                return -1;
                        }
 
-                       init = data;
+                       init = ptr;
                        break;
 
                default:
@@ -961,7 +970,7 @@ ssize_t utcp_recv(struct utcp *utcp, const void *data, size_t len) {
                }
 
                len -= auxlen;
-               data += auxlen;
+               ptr += auxlen;
 
                if(!(aux & 0x800)) {
                        break;
@@ -972,9 +981,9 @@ ssize_t utcp_recv(struct utcp *utcp, const void *data, size_t len) {
                        return -1;
                }
 
-               memcpy(&aux, data, 2);
+               memcpy(&aux, ptr, 2);
                len -= 2;
-               data += 2;
+               ptr += 2;
        }
 
        // Try to match the packet to an existing connection
@@ -1112,7 +1121,7 @@ ssize_t utcp_recv(struct utcp *utcp, const void *data, size_t len) {
                        acceptable = len > (size_t) - rcv_offset;
 
                        if(acceptable) {
-                               data -= rcv_offset;
+                               ptr -= rcv_offset;
                                len += rcv_offset;
                                hdr.seq -= rcv_offset;
                        }
@@ -1222,13 +1231,16 @@ ssize_t utcp_recv(struct utcp *utcp, const void *data, size_t len) {
                }
        }
 
+       uint32_t advanced;
+
        if(!(hdr.ctl & ACK)) {
+               advanced = 0;
                goto skip_ack;
        }
 
        // 3. Advance snd.una
 
-       uint32_t advanced = seqdiff(hdr.ack, c->snd.una);
+       advanced = seqdiff(hdr.ack, c->snd.una);
        prevrcvnxt = c->rcv.nxt;
 
        if(advanced) {
@@ -1345,7 +1357,14 @@ skip_ack:
 
                        c->rcv.irs = hdr.seq;
                        c->rcv.nxt = hdr.seq;
-                       set_state(c, ESTABLISHED);
+
+                       if(c->shut_wr) {
+                               c->snd.last++;
+                               set_state(c, FIN_WAIT_1);
+                       } else {
+                               set_state(c, ESTABLISHED);
+                       }
+
                        // TODO: notify application of this somehow.
                        break;
 
@@ -1420,7 +1439,7 @@ skip_ack:
                        return 0;
                }
 
-               handle_incoming_data(c, hdr.seq, data, len);
+               handle_incoming_data(c, hdr.seq, ptr, len);
        }
 
        // 7. Process FIN stuff
@@ -1533,6 +1552,13 @@ int utcp_shutdown(struct utcp_connection *c, int dir) {
                return 0;
        }
 
+       // Only process shutting down writes once.
+       if(c->shut_wr) {
+               return 0;
+       }
+
+       c->shut_wr = true;
+
        switch(c->state) {
        case CLOSED:
        case LISTEN:
@@ -1540,7 +1566,6 @@ int utcp_shutdown(struct utcp_connection *c, int dir) {
                return -1;
 
        case SYN_SENT:
-               set_state(c, CLOSED);
                return 0;
 
        case SYN_RECEIVED:
@@ -1573,36 +1598,24 @@ int utcp_shutdown(struct utcp_connection *c, int dir) {
        return 0;
 }
 
-int utcp_close(struct utcp_connection *c) {
-       if(utcp_shutdown(c, SHUT_RDWR) && errno != ENOTCONN) {
-               return -1;
-       }
-
-       c->recv = NULL;
-       c->poll = NULL;
-       c->reapable = true;
-       return 0;
-}
-
-int utcp_abort(struct utcp_connection *c) {
+static bool reset_connection(struct utcp_connection *c) {
        if(!c) {
                errno = EFAULT;
-               return -1;
+               return false;
        }
 
        if(c->reapable) {
                debug("Error: abort() called on closed connection %p\n", c);
                errno = EBADF;
-               return -1;
+               return false;
        }
 
        c->recv = NULL;
        c->poll = NULL;
-       c->reapable = true;
 
        switch(c->state) {
        case CLOSED:
-               return 0;
+               return true;
 
        case LISTEN:
        case SYN_SENT:
@@ -1610,7 +1623,7 @@ int utcp_abort(struct utcp_connection *c) {
        case LAST_ACK:
        case TIME_WAIT:
                set_state(c, CLOSED);
-               return 0;
+               return true;
 
        case SYN_RECEIVED:
        case ESTABLISHED:
@@ -1634,6 +1647,53 @@ int utcp_abort(struct utcp_connection *c) {
 
        print_packet(c->utcp, "send", &hdr, sizeof(hdr));
        c->utcp->send(c->utcp, &hdr, sizeof(hdr));
+       return true;
+}
+
+// Closes all the opened connections
+void utcp_abort_all_connections(struct utcp *utcp) {
+       if(!utcp) {
+               errno = EINVAL;
+               return;
+       }
+
+       for(int i = 0; i < utcp->nconnections; i++) {
+               struct utcp_connection *c = utcp->connections[i];
+
+               if(c->reapable || c->state == CLOSED) {
+                       continue;
+               }
+
+               utcp_recv_t old_recv = c->recv;
+
+               reset_connection(c);
+
+               if(old_recv) {
+                       errno = 0;
+                       old_recv(c, NULL, 0);
+               }
+       }
+
+       return;
+}
+
+int utcp_close(struct utcp_connection *c) {
+       if(utcp_shutdown(c, SHUT_RDWR) && errno != ENOTCONN) {
+               return -1;
+       }
+
+       c->recv = NULL;
+       c->poll = NULL;
+       c->reapable = true;
+       return 0;
+}
+
+int utcp_abort(struct utcp_connection *c) {
+       if(!reset_connection(c)) {
+               return -1;
+       }
+
+       c->reapable = true;
        return 0;
 }
 
@@ -1818,9 +1878,18 @@ size_t utcp_get_sndbuf(struct utcp_connection *c) {
 }
 
 size_t utcp_get_sndbuf_free(struct utcp_connection *c) {
-       if(c && (c->state == ESTABLISHED || c->state == CLOSE_WAIT)) {
+       if(!c) {
+               return 0;
+       }
+
+       switch(c->state) {
+       case SYN_SENT:
+       case SYN_RECEIVED:
+       case ESTABLISHED:
+       case CLOSE_WAIT:
                return buffer_free(&c->sndbuf);
-       } else {
+
+       default:
                return 0;
        }
 }
@@ -1861,6 +1930,14 @@ void utcp_set_rcvbuf(struct utcp_connection *c, size_t size) {
        }
 }
 
+size_t utcp_get_sendq(struct utcp_connection *c) {
+       return c->sndbuf.used;
+}
+
+size_t utcp_get_recvq(struct utcp_connection *c) {
+       return c->rcvbuf.used;
+}
+
 bool utcp_get_nodelay(struct utcp_connection *c) {
        return c ? c->nodelay : false;
 }