New accept/connect code.
Better error checking. Better tests. __tostring implemented.
This commit is contained in:
Diego Nehab
parent
42e0e74487
commit
0c9f420a35
10 changed files with 424 additions and 196 deletions
215
src/wsocket.c
215
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
|
||||
|
|
@ -35,12 +37,24 @@ int sock_open(void)
|
|||
return 1;
|
||||
}
|
||||
|
||||
/*-------------------------------------------------------------------------*\
|
||||
* 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";
|
||||
}
|
||||
}
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue