New accept/connect code.

Better error checking.
Better tests.
__tostring implemented.

1 files changed, 149 insertions, 66 deletions

diff --git a/src/wsocket.c b/src/wsocket.c
index f834503..f33e154 100644
--- a/src/wsocket.c
+++ b/src/wsocket.c
@@ -15,9 +15,11 @@
 
 #include "socket.h"
 
-static const char *sock_createstrerror(void);
-static const char *sock_bindstrerror(void);
-static const char *sock_connectstrerror(void);
+static const char *sock_createstrerror(int err);
+static const char *sock_bindstrerror(int err);
+static const char *sock_connectstrerror(int err);
+static const char *sock_acceptstrerror(int err);
+static const char *sock_listenstrerror(int err);
 
 /*-------------------------------------------------------------------------*\
 * Initializes module 
@@ -36,11 +38,23 @@ int sock_open(void)
 }
 
 /*-------------------------------------------------------------------------*\
+* Select with int timeout in ms
+\*-------------------------------------------------------------------------*/
+int sock_select(int n, fd_set *rfds, fd_set *wfds, fd_set *efds, int timeout)
+{
+    struct timeval tv;
+    tv.tv_sec = timeout / 1000;
+    tv.tv_usec = (timeout % 1000) * 1000;
+    return select(n, rfds, wfds, efds, timeout >= 0? &tv: NULL);
+}
+
+/*-------------------------------------------------------------------------*\
 * Close and inutilize socket
 \*-------------------------------------------------------------------------*/
 void sock_destroy(p_sock ps)
 {
     if (*ps != SOCK_INVALID) {
+        sock_setblocking(ps); /* close can take a long time on WIN32 */
         closesocket(*ps);
         *ps = SOCK_INVALID;
     }
@@ -51,7 +65,9 @@ void sock_destroy(p_sock ps)
 \*-------------------------------------------------------------------------*/
 void sock_shutdown(p_sock ps, int how)
 {
+    sock_setblocking(ps);
     shutdown(*ps, how);
+    sock_setnonblocking(ps);
 }
 
 /*-------------------------------------------------------------------------*\
@@ -61,10 +77,11 @@ const char *sock_create(p_sock ps, int domain, int type, int protocol)
 {
     int val = 1;
     t_sock sock = socket(domain, type, protocol);
-    if (sock == SOCK_INVALID) return sock_createstrerror();
+    if (sock == SOCK_INVALID) 
+        return sock_createstrerror(WSAGetLastError());
     *ps = sock;
-    sock_setnonblocking(ps);
     setsockopt(*ps, SOL_SOCKET, SO_REUSEADDR, (char *) &val, sizeof(val));
+    sock_setnonblocking(ps);
     return NULL;
 }
 
@@ -75,7 +92,6 @@ const char *sock_connect(p_sock ps, SA *addr, socklen_t addr_len, p_tm tm)
 {
     t_sock sock = *ps;
     int err, timeout = tm_getretry(tm);
-    struct timeval tv;
     fd_set efds, wfds;
     /* don't call on closed socket */
     if (sock == SOCK_INVALID) return io_strerror(IO_CLOSED);
@@ -84,27 +100,24 @@ const char *sock_connect(p_sock ps, SA *addr, socklen_t addr_len, p_tm tm)
     /* if no error, we're done */
     if (err == 0) return NULL;
     /* make sure the system is trying to connect */
-    if (WSAGetLastError() != WSAEWOULDBLOCK) return sock_connectstrerror();
+    err = WSAGetLastError(); 
+    if (err != WSAEWOULDBLOCK) return sock_connectstrerror(err);
     /* wait for a timeout or for the system's answer */
-    tv.tv_sec = timeout / 1000;
-    tv.tv_usec = (timeout % 1000) * 1000;
     FD_ZERO(&wfds); FD_SET(sock, &wfds);
     FD_ZERO(&efds); FD_SET(sock, &efds);
     /* we run select to wait */
-    err = select(0, NULL, &wfds, &efds, timeout >= 0? &tv: NULL);
+    err = sock_select(0, NULL, &wfds, &efds, timeout);
     /* if select returned due to an event */
     if (err > 0 ) {
         /* if was in efds, we failed */
-        if (FD_ISSET(sock,&efds) || !FD_ISSET(sock,&wfds)) {
-            int why; 
-            int len = sizeof(why);
+        if (FD_ISSET(sock, &efds)) {
+            int why, len = sizeof(why);
             /* find out why we failed */
             getsockopt(sock, SOL_SOCKET, SO_ERROR, (char *)&why, &len); 
-            WSASetLastError(why);
-            return sock_connectstrerror(); 
-        /* if was in wfds, we succeeded */
+            return sock_connectstrerror(why); 
+        /* otherwise it must be in wfds, so we succeeded */
         } else return NULL;
-        /* if nothing happened, we timed out */
+    /* if no event happened, we timed out */
     } else return io_strerror(IO_TIMEOUT);
 }
 
@@ -113,44 +126,60 @@ const char *sock_connect(p_sock ps, SA *addr, socklen_t addr_len, p_tm tm)
 \*-------------------------------------------------------------------------*/
 const char *sock_bind(p_sock ps, SA *addr, socklen_t addr_len)
 {
-    if (bind(*ps, addr, addr_len) < 0) return sock_bindstrerror();
-    else return NULL;
+    const char *err = NULL;
+    sock_setblocking(ps);
+    if (bind(*ps, addr, addr_len) < 0) 
+        err = sock_bindstrerror(WSAGetLastError());
+    sock_setnonblocking(ps);
+    return err;
 }
 
 /*-------------------------------------------------------------------------*\
 * 
 \*-------------------------------------------------------------------------*/
-void sock_listen(p_sock ps, int backlog)
+const char *sock_listen(p_sock ps, int backlog)
 {
-    listen(*ps, backlog);
+    const char *err = NULL;
+    sock_setblocking(ps);
+    if (listen(*ps, backlog) < 0) 
+        err = sock_listenstrerror(WSAGetLastError());
+    sock_setnonblocking(ps);
+    return err;
 }
 
 /*-------------------------------------------------------------------------*\
 * Accept with timeout
 \*-------------------------------------------------------------------------*/
-int sock_accept(p_sock ps, p_sock pa, SA *addr, socklen_t *addr_len, p_tm tm)
+const char *sock_accept(p_sock ps, p_sock pa, SA *addr, 
+        socklen_t *addr_len, p_tm tm)
 {
     t_sock sock = *ps;
     SA dummy_addr;
     socklen_t dummy_len = sizeof(dummy_addr);
-    if (sock == SOCK_INVALID) return IO_CLOSED;
+    if (sock == SOCK_INVALID) return io_strerror(IO_CLOSED);
     if (!addr) addr = &dummy_addr;
     if (!addr_len) addr_len = &dummy_len;
     for (;;) {
+        fd_set rfds;
         int timeout = tm_getretry(tm);
-        struct timeval tv;
-        fd_set fds;
+        int err;
+        /* try to get client socket */
         *pa = accept(sock, addr, addr_len);
-        if (*pa != SOCK_INVALID) return IO_DONE;
-        if (timeout == 0) return IO_TIMEOUT;
-        tv.tv_sec = timeout / 1000;
-        tv.tv_usec = (timeout % 1000) * 1000;
-        FD_ZERO(&fds);
-        FD_SET(sock, &fds);
-        /* call select just to avoid busy-wait. */
-        select(0, &fds, NULL, NULL, timeout >= 0? &tv: NULL);
+        /* if return is valid, we are done */
+        if (*pa != SOCK_INVALID) return NULL;
+        /* optimization */
+        if (timeout == 0) return io_strerror(IO_TIMEOUT);
+        /* otherwise find out why we failed */
+        err = WSAGetLastError(); 
+        /* if we failed because there was no connectoin, keep trying*/
+        if (err != WSAEWOULDBLOCK) return sock_acceptstrerror(err);
+        /* call select to avoid busy wait */
+        FD_ZERO(&rfds);
+        FD_SET(sock, &rfds);
+        err = sock_select(0, &rfds, NULL, NULL, timeout);
+        if (err <= 0) return io_strerror(IO_TIMEOUT);
     } 
-    return IO_TIMEOUT; /* can't get here */
+    return io_strerror(IO_TIMEOUT); /* can't get here */
 }
 
 /*-------------------------------------------------------------------------*\
@@ -172,13 +201,10 @@ int sock_send(p_sock ps, const char *data, size_t count, size_t *sent,
         *sent = 0;
         /* run select to avoid busy wait */
         if (WSAGetLastError() == WSAEWOULDBLOCK) {
-            struct timeval tv;
             fd_set fds;
-            tv.tv_sec = timeout / 1000;
-            tv.tv_usec = (timeout % 1000) * 1000;
             FD_ZERO(&fds);
             FD_SET(sock, &fds);
-            ret = select(0, NULL, &fds, NULL, timeout >= 0 ? &tv : NULL);
+            ret = sock_select(0, NULL, &fds, NULL, timeout);
             /* tell the caller to call us again because there is more data */
             if (ret > 0) return IO_DONE;
             /* tell the caller there was no data before timeout */
@@ -211,13 +237,10 @@ int sock_sendto(p_sock ps, const char *data, size_t count, size_t *sent,
         *sent = 0;
         /* run select to avoid busy wait */
         if (WSAGetLastError() == WSAEWOULDBLOCK) {
-            struct timeval tv;
             fd_set fds;
-            tv.tv_sec = timeout / 1000;
-            tv.tv_usec = (timeout % 1000) * 1000;
             FD_ZERO(&fds);
             FD_SET(sock, &fds);
-            ret = select(0, NULL, &fds, NULL, timeout >= 0 ? &tv : NULL);
+            ret = sock_select(0, NULL, &fds, NULL, timeout);
             /* tell the caller to call us again because there is more data */
             if (ret > 0) return IO_DONE;
             /* tell the caller there was no data before timeout */
@@ -241,16 +264,13 @@ int sock_recv(p_sock ps, char *data, size_t count, size_t *got, int timeout)
     if (sock == SOCK_INVALID) return IO_CLOSED;
     taken = recv(sock, data, (int) count, 0);
     if (taken <= 0) {
-        struct timeval tv;
         fd_set fds;
         int ret;
         *got = 0;
         if (taken == 0) return IO_CLOSED;
-        tv.tv_sec = timeout / 1000;
-        tv.tv_usec = (timeout % 1000) * 1000;
         FD_ZERO(&fds);
         FD_SET(sock, &fds);
-        ret = select(0, &fds, NULL, NULL, timeout >= 0 ? &tv : NULL);
+        ret = sock_select(0, &fds, NULL, NULL, timeout);
         if (ret > 0) return IO_DONE;
         else return IO_TIMEOUT;
     } else {
@@ -270,16 +290,13 @@ int sock_recvfrom(p_sock ps, char *data, size_t count, size_t *got,
     if (sock == SOCK_INVALID) return IO_CLOSED;
     taken = recvfrom(sock, data, (int) count, 0, addr, addr_len);
     if (taken <= 0) {
-        struct timeval tv;
         fd_set fds;
         int ret;
         *got = 0;
         if (taken == 0) return IO_CLOSED;
-        tv.tv_sec = timeout / 1000;
-        tv.tv_usec = (timeout % 1000) * 1000;
         FD_ZERO(&fds);
         FD_SET(sock, &fds);
-        ret = select(0, &fds, NULL, NULL, timeout >= 0 ? &tv : NULL);
+        ret = sock_select(0, &fds, NULL, NULL, timeout);
         if (ret > 0) return IO_DONE;
         else return IO_TIMEOUT;
     } else {
@@ -309,51 +326,117 @@ void sock_setnonblocking(p_sock ps)
 /*-------------------------------------------------------------------------*\
 * Error translation functions
 \*-------------------------------------------------------------------------*/
+/* return error messages for the known errors reported by gethostbyname */
 const char *sock_hoststrerror(void)
 {
     switch (WSAGetLastError()) {
-        case HOST_NOT_FOUND: return "host not found";
-        case NO_ADDRESS: return "unable to resolve host name";
-        case NO_RECOVERY: return "name server error";
-        case TRY_AGAIN: return "name server unavailable, try again later.";
+        case WSANOTINITIALISED: return "not initialized";
+        case WSAENETDOWN: return "network is down";
+        case WSAHOST_NOT_FOUND: return "host not found";
+        case WSATRY_AGAIN: return "name server unavailable, try again later";
+        case WSANO_RECOVERY: return "name server error";
+        case WSANO_DATA: return "host not found";
+        case WSAEINPROGRESS: return "another call in progress";
+        case WSAEFAULT: return "invalid memory address";
+        case WSAEINTR: return "call interrupted";
         default: return "unknown error";
     }
 }
 
-static const char *sock_createstrerror(void)
+/* return error messages for the known errors reported by socket */
+static const char *sock_createstrerror(int err)
 {
-    switch (WSAGetLastError()) {
+    switch (err) {
         case WSANOTINITIALISED: return "not initialized";
         case WSAENETDOWN: return "network is down";
+        case WSAEAFNOSUPPORT: return "address family not supported";
+        case WSAEINPROGRESS: return "another call in progress";
         case WSAEMFILE: return "descriptor table is full";
         case WSAENOBUFS: return "insufficient buffer space";
+        case WSAEPROTONOSUPPORT: return "protocol not supported";
+        case WSAEPROTOTYPE: return "wrong protocol type";
+        case WSAESOCKTNOSUPPORT: return "socket type not supported by family";
         default: return "unknown error";
     }
 }
 
-static const char *sock_bindstrerror(void)
+/* return error messages for the known errors reported by accept */
+static const char *sock_acceptstrerror(int err)
 {
-    switch (WSAGetLastError()) {
+    switch (err) {
         case WSANOTINITIALISED: return "not initialized";
         case WSAENETDOWN: return "network is down";
-        case WSAEADDRINUSE: return "address already in use";
-        case WSAEINVAL: return "socket already bound";
-        case WSAENOBUFS: return "too many connections";
-        case WSAEFAULT: return "invalid address";
-        case WSAENOTSOCK: return "not a socket descriptor";
+        case WSAEFAULT: return "invalid memory address";
+        case WSAEINTR: return "call interrupted";
+        case WSAEINPROGRESS: return "another call in progress";
+        case WSAEINVAL: return "not listening";
+        case WSAEMFILE: return "descriptor table is full";
+        case WSAENOBUFS: return "insufficient buffer space";
+        case WSAENOTSOCK: return "descriptor not a socket";
+        case WSAEOPNOTSUPP: return "not supported";
+        case WSAEWOULDBLOCK: return "call would block";
         default: return "unknown error";
     }
 }
 
-static const char *sock_connectstrerror(void)
+/* return error messages for the known errors reported by bind */
+static const char *sock_bindstrerror(int err)
 {
-    switch (WSAGetLastError()) {
+    switch (err) {
         case WSANOTINITIALISED: return "not initialized";
         case WSAENETDOWN: return "network is down";
+        case WSAEACCES: return "broadcast not enabled for socket";
         case WSAEADDRINUSE: return "address already in use";
-        case WSAEADDRNOTAVAIL: return "address unavailable";
+        case WSAEADDRNOTAVAIL: return "address not available in local host";
+        case WSAEFAULT: return "invalid memory address";
+        case WSAEINPROGRESS: return "another call in progress";
+        case WSAEINVAL: return "already bound";
+        case WSAENOBUFS: return "insuficient buffer space";
+        case WSAENOTSOCK: return "descriptor not a socket";
+        default: return "unknown error";
+    }
+    
+}
+
+/* return error messages for the known errors reported by listen */
+static const char *sock_listenstrerror(int err)
+{
+    switch (err) {
+        case WSANOTINITIALISED: return "not initialized";
+        case WSAENETDOWN: return "network is down";
+        case WSAEADDRINUSE: return "local address already in use";
+        case WSAEINPROGRESS: return "another call in progress";
+        case WSAEINVAL: return "not bound";
+        case WSAEISCONN: return "already connected";
+        case WSAEMFILE: return "descriptor table is full";
+        case WSAENOBUFS: return "insuficient buffer space";
+        case WSAENOTSOCK: return "descriptor not a socket";
+        case WSAEOPNOTSUPP: return "not supported";
+        default: return "unknown error";
+    }
+}
+
+/* return error messages for the known errors reported by connect */
+static const char *sock_connectstrerror(int err)
+{
+    switch (err) {
+        case WSANOTINITIALISED: return "not initialized";
+        case WSAENETDOWN: return "network is down";
+        case WSAEADDRINUSE: return "local address already in use";
+        case WSAEINTR: return "call interrupted";
+        case WSAEINPROGRESS: return "another call in progress";
+        case WSAEALREADY: return "connect already in progress";
+        case WSAEADDRNOTAVAIL: return "invalid remote address";
+        case WSAEAFNOSUPPORT: return "address family not supported";
         case WSAECONNREFUSED: return "connection refused";
+        case WSAEFAULT: return "invalid memory address";
+        case WSAEINVAL: return "socket is listening";
+        case WSAEISCONN: return "socket already connected";
         case WSAENETUNREACH: return "network is unreachable";
+        case WSAENOTSOCK: return "descriptor not a socket";
+        case WSAETIMEDOUT: return io_strerror(IO_TIMEOUT);
+        case WSAEWOULDBLOCK: return "would block";
+        case WSAEACCES: return "broadcast not enabled";
         default: return "unknown error";
     }
 }