Before compiling on Windows.

1 files changed, 57 insertions, 56 deletions

diff --git a/src/usocket.c b/src/usocket.c
index f067fa1..e9db6dd 100644
--- a/src/usocket.c
+++ b/src/usocket.c
@@ -16,21 +16,21 @@
 /*-------------------------------------------------------------------------*\
 * Wait for readable/writable/connected socket with timeout
 \*-------------------------------------------------------------------------*/
-#ifdef SOCK_POLL
+#ifdef SOCKET_POLL
 #include <sys/poll.h>
 
 #define WAITFD_R        POLLIN
 #define WAITFD_W        POLLOUT
 #define WAITFD_C        (POLLIN|POLLOUT)
-int sock_waitfd(p_sock ps, int sw, p_tm tm) {
+int socket_waitfd(p_socket ps, int sw, p_timeout tm) {
     int ret;
     struct pollfd pfd;
     pfd.fd = *ps;
     pfd.events = sw;
     pfd.revents = 0;
-    if (tm_iszero(tm)) return IO_TIMEOUT;  /* optimize timeout == 0 case */
+    if (timeout_iszero(tm)) return IO_TIMEOUT;  /* optimize timeout == 0 case */
     do {
-                int t = (int)(tm_getretry(tm)*1e3);
+                int t = (int)(timeout_getretry(tm)*1e3);
                 ret = poll(&pfd, 1, t >= 0? t: -1);
         } while (ret == -1 && errno == EINTR);
     if (ret == -1) return errno;
@@ -44,18 +44,18 @@ int sock_waitfd(p_sock ps, int sw, p_tm tm) {
 #define WAITFD_W        2
 #define WAITFD_C        (WAITFD_R|WAITFD_W)
 
-int sock_waitfd(p_sock ps, int sw, p_tm tm) {
+int socket_waitfd(p_socket ps, int sw, p_timeout tm) {
     int ret;
     fd_set rfds, wfds, *rp, *wp;
     struct timeval tv, *tp;
     double t;
-    if (tm_iszero(tm)) return IO_TIMEOUT;  /* optimize timeout == 0 case */
+    if (timeout_iszero(tm)) return IO_TIMEOUT;  /* optimize timeout == 0 case */
     do {
         /* must set bits within loop, because select may have modifed them */
         rp = wp = NULL;
         if (sw & WAITFD_R) { FD_ZERO(&rfds); FD_SET(*ps, &rfds); rp = &rfds; }
         if (sw & WAITFD_W) { FD_ZERO(&wfds); FD_SET(*ps, &wfds); wp = &wfds; }
-        t = tm_getretry(tm);
+        t = timeout_getretry(tm);
         tp = NULL;
         if (t >= 0.0) {
             tv.tv_sec = (int)t;
@@ -75,7 +75,7 @@ int sock_waitfd(p_sock ps, int sw, p_tm tm) {
 /*-------------------------------------------------------------------------*\
 * Initializes module 
 \*-------------------------------------------------------------------------*/
-int sock_open(void) {
+int socket_open(void) {
     /* instals a handler to ignore sigpipe or it will crash us */
     signal(SIGPIPE, SIG_IGN);
     return 1;
@@ -84,29 +84,29 @@ int sock_open(void) {
 /*-------------------------------------------------------------------------*\
 * Close module 
 \*-------------------------------------------------------------------------*/
-int sock_close(void) {
+int socket_close(void) {
     return 1;
 }
 
 /*-------------------------------------------------------------------------*\
 * Close and inutilize socket
 \*-------------------------------------------------------------------------*/
-void sock_destroy(p_sock ps) {
-    if (*ps != SOCK_INVALID) {
-        sock_setblocking(ps);
+void socket_destroy(p_socket ps) {
+    if (*ps != SOCKET_INVALID) {
+        socket_setblocking(ps);
         close(*ps);
-        *ps = SOCK_INVALID;
+        *ps = SOCKET_INVALID;
     }
 }
 
 /*-------------------------------------------------------------------------*\
 * Select with timeout control
 \*-------------------------------------------------------------------------*/
-int sock_select(int n, fd_set *rfds, fd_set *wfds, fd_set *efds, p_tm tm) {
+int socket_select(int n, fd_set *rfds, fd_set *wfds, fd_set *efds, p_timeout tm) {
     int ret;
     do {
         struct timeval tv;
-        double t = tm_getretry(tm);
+        double t = timeout_getretry(tm);
         tv.tv_sec = (int) t;
         tv.tv_usec = (int) ((t - tv.tv_sec) * 1.0e6);
         ret = select(n, rfds, wfds, efds, t >= 0.0? &tv: NULL);
@@ -117,59 +117,59 @@ int sock_select(int n, fd_set *rfds, fd_set *wfds, fd_set *efds, p_tm tm) {
 /*-------------------------------------------------------------------------*\
 * Creates and sets up a socket
 \*-------------------------------------------------------------------------*/
-int sock_create(p_sock ps, int domain, int type, int protocol) {
+int socket_create(p_socket ps, int domain, int type, int protocol) {
     *ps = socket(domain, type, protocol);
-    if (*ps != SOCK_INVALID) return IO_DONE; 
+    if (*ps != SOCKET_INVALID) return IO_DONE; 
     else return errno; 
 }
 
 /*-------------------------------------------------------------------------*\
 * Binds or returns error message
 \*-------------------------------------------------------------------------*/
-int sock_bind(p_sock ps, SA *addr, socklen_t len) {
+int socket_bind(p_socket ps, SA *addr, socklen_t len) {
     int err = IO_DONE;
-    sock_setblocking(ps);
+    socket_setblocking(ps);
     if (bind(*ps, addr, len) < 0) err = errno; 
-    sock_setnonblocking(ps);
+    socket_setnonblocking(ps);
     return err;
 }
 
 /*-------------------------------------------------------------------------*\
 * 
 \*-------------------------------------------------------------------------*/
-int sock_listen(p_sock ps, int backlog) {
+int socket_listen(p_socket ps, int backlog) {
     int err = IO_DONE; 
-    sock_setblocking(ps);
+    socket_setblocking(ps);
     if (listen(*ps, backlog)) err = errno; 
-    sock_setnonblocking(ps);
+    socket_setnonblocking(ps);
     return err;
 }
 
 /*-------------------------------------------------------------------------*\
 * 
 \*-------------------------------------------------------------------------*/
-void sock_shutdown(p_sock ps, int how) {
-    sock_setblocking(ps);
+void socket_shutdown(p_socket ps, int how) {
+    socket_setblocking(ps);
     shutdown(*ps, how);
-    sock_setnonblocking(ps);
+    socket_setnonblocking(ps);
 }
 
 /*-------------------------------------------------------------------------*\
 * Connects or returns error message
 \*-------------------------------------------------------------------------*/
-int sock_connect(p_sock ps, SA *addr, socklen_t len, p_tm tm) {
+int socket_connect(p_socket ps, SA *addr, socklen_t len, p_timeout tm) {
     int err;
     /* avoid calling on closed sockets */
-    if (*ps == SOCK_INVALID) return IO_CLOSED;
+    if (*ps == SOCKET_INVALID) return IO_CLOSED;
     /* call connect until done or failed without being interrupted */
     do if (connect(*ps, addr, len) == 0) return IO_DONE;
     while ((err = errno) == EINTR);
     /* if connection failed immediately, return error code */
     if (err != EINPROGRESS && err != EAGAIN) return err; 
     /* zero timeout case optimization */
-    if (tm_iszero(tm)) return IO_TIMEOUT;
+    if (timeout_iszero(tm)) return IO_TIMEOUT;
     /* wait until we have the result of the connection attempt or timeout */
-    err = sock_waitfd(ps, WAITFD_C, tm);
+    err = socket_waitfd(ps, WAITFD_C, tm);
     if (err == IO_CLOSED) {
         if (recv(*ps, (char *) &err, 0, 0) == 0) return IO_DONE;
         else return errno;
@@ -179,19 +179,19 @@ int sock_connect(p_sock ps, SA *addr, socklen_t len, p_tm tm) {
 /*-------------------------------------------------------------------------*\
 * Accept with timeout
 \*-------------------------------------------------------------------------*/
-int sock_accept(p_sock ps, p_sock pa, SA *addr, socklen_t *len, p_tm tm) {
+int socket_accept(p_socket ps, p_socket pa, SA *addr, socklen_t *len, p_timeout tm) {
     SA daddr;
     socklen_t dlen = sizeof(daddr);
-    if (*ps == SOCK_INVALID) return IO_CLOSED; 
+    if (*ps == SOCKET_INVALID) return IO_CLOSED; 
     if (!addr) addr = &daddr;
     if (!len) len = &dlen;
     for ( ;; ) {
         int err;
-        if ((*pa = accept(*ps, addr, len)) != SOCK_INVALID) return IO_DONE;
+        if ((*pa = accept(*ps, addr, len)) != SOCKET_INVALID) return IO_DONE;
         err = errno;
         if (err == EINTR) continue;
         if (err != EAGAIN && err != ECONNABORTED) return err;
-        if ((err = sock_waitfd(ps, WAITFD_R, tm)) != IO_DONE) return err;
+        if ((err = socket_waitfd(ps, WAITFD_R, tm)) != IO_DONE) return err;
     }
     /* can't reach here */
     return IO_UNKNOWN;
@@ -200,11 +200,12 @@ int sock_accept(p_sock ps, p_sock pa, SA *addr, socklen_t *len, p_tm tm) {
 /*-------------------------------------------------------------------------*\
 * Send with timeout
 \*-------------------------------------------------------------------------*/
-int sock_send(p_sock ps, const char *data, size_t count, size_t *sent, p_tm tm)
+int socket_send(p_socket ps, const char *data, size_t count, 
+        size_t *sent, p_timeout tm)
 {
     int err;
     /* avoid making system calls on closed sockets */
-    if (*ps == SOCK_INVALID) return IO_CLOSED;
+    if (*ps == SOCKET_INVALID) return IO_CLOSED;
     /* loop until we send something or we give up on error */
     *sent = 0;
     for ( ;; ) {
@@ -223,7 +224,7 @@ int sock_send(p_sock ps, const char *data, size_t count, size_t *sent, p_tm tm)
         /* if failed fatal reason, report error */
         if (err != EAGAIN) return err;
         /* wait until we can send something or we timeout */
-        if ((err = sock_waitfd(ps, WAITFD_W, tm)) != IO_DONE) return err;
+        if ((err = socket_waitfd(ps, WAITFD_W, tm)) != IO_DONE) return err;
     }
     /* can't reach here */
     return IO_UNKNOWN;
@@ -232,11 +233,11 @@ int sock_send(p_sock ps, const char *data, size_t count, size_t *sent, p_tm tm)
 /*-------------------------------------------------------------------------*\
 * Sendto with timeout
 \*-------------------------------------------------------------------------*/
-int sock_sendto(p_sock ps, const char *data, size_t count, size_t *sent, 
-        SA *addr, socklen_t len, p_tm tm)
+int socket_sendto(p_socket ps, const char *data, size_t count, size_t *sent, 
+        SA *addr, socklen_t len, p_timeout tm)
 {
     int err;
-    if (*ps == SOCK_INVALID) return IO_CLOSED;
+    if (*ps == SOCKET_INVALID) return IO_CLOSED;
     *sent = 0;
     for ( ;; ) {
         long put = (long) sendto(*ps, data, count, 0, addr, len);  
@@ -248,7 +249,7 @@ int sock_sendto(p_sock ps, const char *data, size_t count, size_t *sent,
         if (put == 0 || err == EPIPE) return IO_CLOSED;
         if (err == EINTR) continue;
         if (err != EAGAIN) return err;
-        if ((err = sock_waitfd(ps, WAITFD_W, tm)) != IO_DONE) return err;
+        if ((err = socket_waitfd(ps, WAITFD_W, tm)) != IO_DONE) return err;
     }
     return IO_UNKNOWN;
 }
@@ -256,9 +257,9 @@ int sock_sendto(p_sock ps, const char *data, size_t count, size_t *sent,
 /*-------------------------------------------------------------------------*\
 * Receive with timeout
 \*-------------------------------------------------------------------------*/
-int sock_recv(p_sock ps, char *data, size_t count, size_t *got, p_tm tm) {
+int socket_recv(p_socket ps, char *data, size_t count, size_t *got, p_timeout tm) {
     int err;
-    if (*ps == SOCK_INVALID) return IO_CLOSED;
+    if (*ps == SOCKET_INVALID) return IO_CLOSED;
     for ( ;; ) {
         long taken = (long) recv(*ps, data, count, 0);
         if (taken > 0) {
@@ -270,7 +271,7 @@ int sock_recv(p_sock ps, char *data, size_t count, size_t *got, p_tm tm) {
         if (taken == 0) return IO_CLOSED;
         if (err == EINTR) continue;
         if (err != EAGAIN) return err; 
-        if ((err = sock_waitfd(ps, WAITFD_R, tm)) != IO_DONE) return err; 
+        if ((err = socket_waitfd(ps, WAITFD_R, tm)) != IO_DONE) return err; 
     }
     return IO_UNKNOWN;
 }
@@ -278,10 +279,10 @@ int sock_recv(p_sock ps, char *data, size_t count, size_t *got, p_tm tm) {
 /*-------------------------------------------------------------------------*\
 * Recvfrom with timeout
 \*-------------------------------------------------------------------------*/
-int sock_recvfrom(p_sock ps, char *data, size_t count, size_t *got, 
-        SA *addr, socklen_t *len, p_tm tm) {
+int socket_recvfrom(p_socket ps, char *data, size_t count, size_t *got, 
+        SA *addr, socklen_t *len, p_timeout tm) {
     int err;
-    if (*ps == SOCK_INVALID) return IO_CLOSED;
+    if (*ps == SOCKET_INVALID) return IO_CLOSED;
     for ( ;; ) {
         long taken = (long) recvfrom(*ps, data, count, 0, addr, len);
         if (taken > 0) {
@@ -293,7 +294,7 @@ int sock_recvfrom(p_sock ps, char *data, size_t count, size_t *got,
         if (taken == 0) return IO_CLOSED;
         if (err == EINTR) continue;
         if (err != EAGAIN) return err; 
-        if ((err = sock_waitfd(ps, WAITFD_R, tm)) != IO_DONE) return err; 
+        if ((err = socket_waitfd(ps, WAITFD_R, tm)) != IO_DONE) return err; 
     }
     return IO_UNKNOWN;
 }
@@ -301,7 +302,7 @@ int sock_recvfrom(p_sock ps, char *data, size_t count, size_t *got,
 /*-------------------------------------------------------------------------*\
 * Put socket into blocking mode
 \*-------------------------------------------------------------------------*/
-void sock_setblocking(p_sock ps) {
+void socket_setblocking(p_socket ps) {
     int flags = fcntl(*ps, F_GETFL, 0);
     flags &= (~(O_NONBLOCK));
     fcntl(*ps, F_SETFL, flags);
@@ -310,7 +311,7 @@ void sock_setblocking(p_sock ps) {
 /*-------------------------------------------------------------------------*\
 * Put socket into non-blocking mode
 \*-------------------------------------------------------------------------*/
-void sock_setnonblocking(p_sock ps) {
+void socket_setnonblocking(p_socket ps) {
     int flags = fcntl(*ps, F_GETFL, 0);
     flags |= O_NONBLOCK;
     fcntl(*ps, F_SETFL, flags);
@@ -319,7 +320,7 @@ void sock_setnonblocking(p_sock ps) {
 /*-------------------------------------------------------------------------*\
 * DNS helpers 
 \*-------------------------------------------------------------------------*/
-int sock_gethostbyaddr(const char *addr, socklen_t len, struct hostent **hp) {
+int socket_gethostbyaddr(const char *addr, socklen_t len, struct hostent **hp) {
     *hp = gethostbyaddr(addr, len, AF_INET);
     if (*hp) return IO_DONE;
     else if (h_errno) return h_errno;
@@ -327,7 +328,7 @@ int sock_gethostbyaddr(const char *addr, socklen_t len, struct hostent **hp) {
     else return IO_UNKNOWN;
 }
 
-int sock_gethostbyname(const char *addr, struct hostent **hp) {
+int socket_gethostbyname(const char *addr, struct hostent **hp) {
     *hp = gethostbyname(addr);
     if (*hp) return IO_DONE;
     else if (h_errno) return h_errno;
@@ -339,7 +340,7 @@ int sock_gethostbyname(const char *addr, struct hostent **hp) {
 * Error translation functions
 * Make sure important error messages are standard
 \*-------------------------------------------------------------------------*/
-const char *sock_hoststrerror(int err) {
+const char *socket_hoststrerror(int err) {
     if (err <= 0) return io_strerror(err);
     switch (err) {
         case HOST_NOT_FOUND: return "host not found";
@@ -347,7 +348,7 @@ const char *sock_hoststrerror(int err) {
     }
 }
 
-const char *sock_strerror(int err) {
+const char *socket_strerror(int err) {
     if (err <= 0) return io_strerror(err);
     switch (err) {
         case EADDRINUSE: return "address already in use";
@@ -361,7 +362,7 @@ const char *sock_strerror(int err) {
     }
 }
 
-const char *sock_ioerror(p_sock ps, int err) {
+const char *socket_ioerror(p_socket ps, int err) {
     (void) ps;
-    return sock_strerror(err);
+    return socket_strerror(err);
 }