From 9a79d500eb3e015f5bf579aab714916d49c1f289 Mon Sep 17 00:00:00 2001 From: Diego Nehab Date: Thu, 15 Jul 2004 06:11:53 +0000 Subject: Still need to fix windows. :o/ --- src/usocket.c | 368 ++++++++++++++++++++++++++++++---------------------------- 1 file changed, 189 insertions(+), 179 deletions(-) (limited to 'src/usocket.c') diff --git a/src/usocket.c b/src/usocket.c index 4e73a96..4d4f092 100644 --- a/src/usocket.c +++ b/src/usocket.c @@ -13,6 +13,63 @@ #include "socket.h" +/*-------------------------------------------------------------------------*\ +* Wait for readable/writable/connected socket with timeout +\*-------------------------------------------------------------------------*/ +#ifdef SOCK_POLL +#include + +#define WAITFD_R POLLIN +#define WAITFD_W POLLOUT +#define WAITFD_C (POLLIN|POLLOUT) +static int sock_waitfd(int fd, int sw, p_tm tm) { + int ret; + struct pollfd pfd; + pfd.fd = fd; + pfd.events = sw; + pfd.revents = 0; + if (tm_iszero(tm)) return IO_TIMEOUT; /* optimize timeout == 0 case */ + do ret = poll(&pfd, 1, (int)(tm_getretry(tm)*1e3)); + while (ret == -1 && errno == EINTR); + if (ret == -1) return errno; + if (ret == 0) return IO_TIMEOUT; + if (sw == WAITFD_C && (pfd.revents & (POLLIN|POLLERR))) return IO_CLOSED; + return IO_DONE; +} +#else + +#define WAITFD_R 1 +#define WAITFD_W 2 +#define WAITFD_C (WAITFD_R|WAITFD_W) + +static int sock_waitfd(int fd, int sw, p_tm 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 */ + do { + /* must set bits within loop, because select may have modifed them */ + rp = wp = NULL; + if (sw & WAITFD_R) { FD_ZERO(&rfds); FD_SET(fd, &rfds); rp = &rfds; } + if (sw & WAITFD_W) { FD_ZERO(&wfds); FD_SET(fd, &wfds); wp = &wfds; } + t = tm_getretry(tm); + tp = NULL; + if (t >= 0.0) { + tv.tv_sec = (int)t; + tv.tv_usec = (int)((t-tv.tv_sec)*1.0e6); + tp = &tv; + } + ret = select(fd+1, rp, wp, NULL, tp); + } while (ret == -1 && errno == EINTR); + if (ret == -1) return errno; + if (ret == 0) return IO_TIMEOUT; + if (sw == WAITFD_C && FD_ISSET(fd, &rfds)) return IO_CLOSED; + return IO_DONE; +} +#endif + + /*-------------------------------------------------------------------------*\ * Initializes module \*-------------------------------------------------------------------------*/ @@ -58,59 +115,19 @@ int sock_select(int n, fd_set *rfds, fd_set *wfds, fd_set *efds, p_tm tm) { /*-------------------------------------------------------------------------*\ * Creates and sets up a socket \*-------------------------------------------------------------------------*/ -const char *sock_create(p_sock ps, int domain, int type, int protocol) { - t_sock sock = socket(domain, type, protocol); - if (sock == SOCK_INVALID) return sock_strerror(); - *ps = sock; - return NULL; -} - -/*-------------------------------------------------------------------------*\ -* Connects or returns error message -\*-------------------------------------------------------------------------*/ -const char *sock_connect(p_sock ps, SA *addr, socklen_t addr_len, p_tm tm) { - t_sock sock = *ps; - int err; - /* don't call on closed socket */ - if (sock == SOCK_INVALID) return io_strerror(IO_CLOSED); - /* ask system to connect */ - do err = connect(sock, addr, addr_len); - while (err < 0 && errno == EINTR); - /* if no error, we're done */ - if (err == 0) return NULL; - /* make sure the system is trying to connect */ - if (errno != EINPROGRESS) return sock_strerror(); - /* optimize for timeout = 0 */ - if (tm_get(tm) == 0.0) return io_strerror(IO_TIMEOUT); - /* wait for a timeout or for the system's answer */ - for ( ;; ) { - fd_set rfds, wfds; - FD_ZERO(&rfds); FD_SET(sock, &rfds); - FD_ZERO(&wfds); FD_SET(sock, &wfds); - /* we run select to avoid busy waiting */ - err = sock_select(sock+1, &rfds, &wfds, NULL, tm); - /* if there was an event, check what happened */ - if (err > 0) { - char dummy; - /* recv will set errno to the value a blocking connect would set */ - if (err > 1 && FD_ISSET(sock, &rfds) && - recv(sock, &dummy, 0, 0) < 0 && errno != EAGAIN) - return sock_strerror(); - else - return NULL; - /* if no event happened, there was a timeout */ - } else if (err == 0) return io_strerror(IO_TIMEOUT); - } - return sock_strerror(); +int sock_create(p_sock ps, int domain, int type, int protocol) { + *ps = socket(domain, type, protocol); + if (*ps != SOCK_INVALID) return IO_DONE; + else return errno; } /*-------------------------------------------------------------------------*\ * Binds or returns error message \*-------------------------------------------------------------------------*/ -const char *sock_bind(p_sock ps, SA *addr, socklen_t addr_len) { - const char *err = NULL; +int sock_bind(p_sock ps, SA *addr, socklen_t len) { + int err = IO_DONE; sock_setblocking(ps); - if (bind(*ps, addr, addr_len) < 0) err = sock_strerror(); + if (bind(*ps, addr, len) < 0) err = errno; sock_setnonblocking(ps); return err; } @@ -118,10 +135,10 @@ const char *sock_bind(p_sock ps, SA *addr, socklen_t addr_len) { /*-------------------------------------------------------------------------*\ * \*-------------------------------------------------------------------------*/ -const char* sock_listen(p_sock ps, int backlog) { - const char *err = NULL; +int sock_listen(p_sock ps, int backlog) { + int err = IO_DONE; sock_setblocking(ps); - if (listen(*ps, backlog)) err = sock_strerror(); + if (listen(*ps, backlog)) err = errno; sock_setnonblocking(ps); return err; } @@ -135,38 +152,46 @@ void sock_shutdown(p_sock ps, int how) { sock_setnonblocking(ps); } +/*-------------------------------------------------------------------------*\ +* Connects or returns error message +\*-------------------------------------------------------------------------*/ +int sock_connect(p_sock ps, SA *addr, socklen_t len, p_tm tm) { + int err; + /* avoid calling on closed sockets */ + if (*ps == SOCK_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; + /* wait until we have the result of the connection attempt or timeout */ + if ((err = sock_waitfd(*ps, WAITFD_C, tm)) == IO_CLOSED) { + /* finaly find out if we succeeded connecting */ + if (recv(*ps, (char *) &err, 0, 0) == 0) return IO_DONE; + else return errno; + /* timed out or some weirder error */ + } else return err; +} + /*-------------------------------------------------------------------------*\ * Accept with timeout \*-------------------------------------------------------------------------*/ -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_strerror(IO_CLOSED); - if (!addr) addr = &dummy_addr; - if (!addr_len) addr_len = &dummy_len; - for (;;) { - int err; - fd_set fds; - /* try to accept */ - do *pa = accept(sock, addr, addr_len); - while (*pa < 0 && errno == EINTR); - /* if result is valid, we are done */ - if (*pa != SOCK_INVALID) return NULL; - /* find out if we failed for a fatal reason */ - /* if connection was aborted, we can try again if we have time */ - if (errno != EAGAIN && errno != ECONNABORTED) return sock_strerror(); - /* optimize for timeout = 0 case */ - if (tm_get(tm) == 0.0) return io_strerror(IO_TIMEOUT); - /* call select to avoid busy-wait. */ - FD_ZERO(&fds); - FD_SET(sock, &fds); - err = sock_select(sock+1, &fds, NULL, NULL, tm); - if (err == 0) return io_strerror(IO_TIMEOUT); - else if (err < 0) break; - } - return sock_strerror(); +int sock_accept(p_sock ps, p_sock pa, SA *addr, socklen_t *len, p_tm tm) { + SA daddr; + socklen_t dlen = sizeof(daddr); + int err; + if (*ps == SOCK_INVALID) return IO_CLOSED; + if (!addr) addr = &daddr; + if (!len) len = &dlen; + for ( ;; ) { + if ((*pa = accept(*ps, addr, len)) != SOCK_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; + } + /* can't reach here */ + return err; } /*-------------------------------------------------------------------------*\ @@ -174,132 +199,100 @@ const char *sock_accept(p_sock ps, p_sock pa, SA *addr, \*-------------------------------------------------------------------------*/ int sock_send(p_sock ps, const char *data, size_t count, size_t *sent, p_tm tm) { - t_sock sock = *ps; + int err; /* avoid making system calls on closed sockets */ - if (sock == SOCK_INVALID) return IO_CLOSED; + if (*ps == SOCK_INVALID) return IO_CLOSED; /* loop until we send something or we give up on error */ + *sent = 0; for ( ;; ) { - int ret; - fd_set fds; - ssize_t put; - /* make sure we repeat in case the call was interrupted */ - do put = send(sock, data, count, 0); - while (put < 0 && errno == EINTR); - /* if we sent something, get out */ - if (put > 0) { + ssize_t put = send(*ps, data, count, 0); + /* if we sent anything, we are done */ + if (put > 0) { *sent = put; return IO_DONE; } - /* deal with failure */ - *sent = 0; - /* here we know the connection has been closed */ - if (put < 0 && errno == EPIPE) return IO_CLOSED; - /* send shouldn't return zero and we can only proceed if - * there was no serious error */ - if (put == 0 || errno != EAGAIN) return IO_USER; - /* optimize for the timeout = 0 case */ - if (tm_get(tm) == 0.0) return IO_TIMEOUT; - /* run select to avoid busy wait */ - FD_ZERO(&fds); - FD_SET(sock, &fds); - ret = sock_select(sock+1, NULL, &fds, NULL, tm); - if (ret == 0) return IO_TIMEOUT; - else if (ret < 0) break; - /* otherwise, try sending again */ - } - return IO_USER; + err = errno; + /* send can't really return 0, but EPIPE means the connection was + closed */ + if (put == 0 || err == EPIPE) return IO_CLOSED; + /* we call was interrupted, just try again */ + if (err == EINTR) continue; + /* 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; + } + /* can't reach here */ + return err; } /*-------------------------------------------------------------------------*\ * Sendto with timeout \*-------------------------------------------------------------------------*/ int sock_sendto(p_sock ps, const char *data, size_t count, size_t *sent, - SA *addr, socklen_t addr_len, p_tm tm) + SA *addr, socklen_t len, p_tm tm) { - t_sock sock = *ps; - /* avoid making system calls on closed sockets */ - if (sock == SOCK_INVALID) return IO_CLOSED; - /* loop until we send something or we give up on error */ + int err; + if (*ps == SOCK_INVALID) return IO_CLOSED; + *sent = 0; for ( ;; ) { - int ret; - fd_set fds; - ssize_t put; - do put = sendto(sock, data, count, 0, addr, addr_len); - while (put < 0 && errno == EINTR); - if (put > 0) { + ssize_t put = sendto(*ps, data, count, 0, addr, len); + if (put > 0) { *sent = put; return IO_DONE; } - *sent = 0; - if (put < 0 && errno == EPIPE) return IO_CLOSED; - if (put == 0 || errno != EAGAIN) return IO_USER; - if (tm_get(tm) == 0.0) return IO_TIMEOUT; - FD_ZERO(&fds); - FD_SET(sock, &fds); - ret = sock_select(sock+1, NULL, &fds, NULL, tm); - if (ret == 0) return IO_TIMEOUT; - else if (ret < 0) break; - } - return IO_USER; + err = errno; + 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; + } + return err; } /*-------------------------------------------------------------------------*\ * Receive with timeout \*-------------------------------------------------------------------------*/ int sock_recv(p_sock ps, char *data, size_t count, size_t *got, p_tm tm) { - t_sock sock = *ps; - if (sock == SOCK_INVALID) return IO_CLOSED; + int err; + if (*ps == SOCK_INVALID) return IO_CLOSED; for ( ;; ) { - fd_set fds; - int ret; - ssize_t taken; - do taken = read(sock, data, count); - while (taken < 0 && errno == EINTR); + ssize_t taken = recv(*ps, data, count, 0); if (taken > 0) { *got = taken; return IO_DONE; } + err = errno; *got = 0; if (taken == 0) return IO_CLOSED; - if (errno != EAGAIN) return IO_USER; - if (tm_get(tm) == 0.0) return IO_TIMEOUT; - FD_ZERO(&fds); - FD_SET(sock, &fds); - ret = sock_select(sock+1, &fds, NULL, NULL, tm); - if (ret == 0) return IO_TIMEOUT; - else if (ret < 0) break; - } - return IO_USER; + if (err == EINTR) continue; + if (err != EAGAIN) return err; + if ((err = sock_waitfd(*ps, WAITFD_R, tm)) != IO_DONE) return err; + } + return err; } /*-------------------------------------------------------------------------*\ * Recvfrom with timeout \*-------------------------------------------------------------------------*/ int sock_recvfrom(p_sock ps, char *data, size_t count, size_t *got, - SA *addr, socklen_t *addr_len, p_tm tm) { - t_sock sock = *ps; - if (sock == SOCK_INVALID) return IO_CLOSED; + SA *addr, socklen_t *len, p_tm tm) { + int err; + if (*ps == SOCK_INVALID) return IO_CLOSED; for ( ;; ) { - fd_set fds; - int ret; - ssize_t taken; - do taken = recvfrom(sock, data, count, 0, addr, addr_len); - while (taken < 0 && errno == EINTR); + ssize_t taken = recvfrom(*ps, data, count, 0, addr, len); if (taken > 0) { *got = taken; return IO_DONE; } + err = errno; *got = 0; if (taken == 0) return IO_CLOSED; - if (errno != EAGAIN) return IO_USER; - if (tm_get(tm) == 0.0) return IO_TIMEOUT; - FD_ZERO(&fds); - FD_SET(sock, &fds); - ret = sock_select(sock+1, &fds, NULL, NULL, tm); - if (ret == 0) return IO_TIMEOUT; - else if (ret < 0) break; - } - return IO_USER; + if (err == EINTR) continue; + if (err != EAGAIN) return err; + if ((err = sock_waitfd(*ps, WAITFD_R, tm)) != IO_DONE) return err; + } + return err; } /*-------------------------------------------------------------------------*\ @@ -320,30 +313,47 @@ void sock_setnonblocking(p_sock ps) { fcntl(*ps, F_SETFL, flags); } +/*-------------------------------------------------------------------------*\ +* DNS helpers +\*-------------------------------------------------------------------------*/ +int sock_gethostbyaddr(const char *addr, socklen_t len, struct hostent **hp) { + *hp = gethostbyaddr(addr, len, AF_INET); + if (*hp) return IO_DONE; + else return h_errno; +} + +int sock_gethostbyname(const char *addr, struct hostent **hp) { + *hp = gethostbyname(addr); + if (*hp) return IO_DONE; + else return h_errno; +} + /*-------------------------------------------------------------------------*\ * Error translation functions +* Make sure important error messages are standard \*-------------------------------------------------------------------------*/ -const char *sock_hoststrerror(void) { - switch (h_errno) { - case HOST_NOT_FOUND: - return "host not found"; - default: - return hstrerror(h_errno); +const char *sock_hoststrerror(int err) { + if (err <= 0) return io_strerror(err); + switch (err) { + case HOST_NOT_FOUND: return "host_not_found"; + default: return hstrerror(err); } } -/* make sure important error messages are standard */ -const char *sock_strerror(void) { - switch (errno) { - case EADDRINUSE: - return "address already in use"; - default: - return strerror(errno); +const char *sock_strerror(int err) { + if (err <= 0) return io_strerror(err); + switch (err) { + case EADDRINUSE: return "eaddrinuse"; + case EACCES: return "eaccess"; + case ECONNABORTED: return "econnaborted"; + case ECONNREFUSED: return "econnrefused"; + case ECONNRESET: return "econnreset"; + case ETIMEDOUT: return "etimedout"; + default: return strerror(errno); } } -const char *sock_geterr(p_sock ps, int code) { +const char *sock_ioerror(p_sock ps, int err) { (void) ps; - (void) code; - return sock_strerror(); -} + return sock_strerror(err); +} -- cgit v1.2.3-55-g6feb