X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/1eef64d83657a6bccd4e22b0c5155ce2e5207306..ed97f493ab59a3fc510b50bad9e1cc8648fc490f:/src/unix/gsocket.cpp diff --git a/src/unix/gsocket.cpp b/src/unix/gsocket.cpp index f857c3c176..97eeb0153b 100644 --- a/src/unix/gsocket.cpp +++ b/src/unix/gsocket.cpp @@ -1,28 +1,29 @@ /* ------------------------------------------------------------------------- - * Project: GSocket (Generic Socket) for WX - * Name: gsocket.c - * Authors: David Elliott (C++ conversion, maintainer) - * Guilhem Lavaux, - * Guillermo Rodriguez Garcia - * Purpose: GSocket main Unix and OS/2 file - * Licence: The wxWindows licence - * CVSID: $Id$ + * Project: GSocket (Generic Socket) for WX + * Name: gsocket.c + * Copyright: (c) Guilhem Lavaux + * Licence: wxWindows Licence + * Authors: David Elliott (C++ conversion, maintainer) + * Guilhem Lavaux, + * Guillermo Rodriguez Garcia + * Purpose: GSocket main Unix and OS/2 file + * Licence: The wxWindows licence + * CVSID: $Id$ * ------------------------------------------------------------------------- */ -/* - * PLEASE don't put C++ comments here - this is a C source file. - */ +#if defined(__WATCOMC__) +#include "wx/wxprec.h" +#include +#include +#endif #ifndef __GSOCKET_STANDALONE__ -#include "wx/setup.h" +#include "wx/defs.h" #endif #if defined(__VISAGECPP__) -/* Seems to be needed by Visual Age C++, though I don't see how it manages - to not break on including a C++ header into a plain C source file */ -#include "wx/defs.h" -#define BSD_SELECT /* use Berkley Sockets select */ +#define BSD_SELECT /* use Berkeley Sockets select */ #endif #if wxUSE_SOCKETS || defined(__GSOCKET_STANDALONE__) @@ -101,30 +102,33 @@ int _System soclose(int); #ifdef sgi # include #endif +#ifdef _AIX +# include +#endif #include -#ifndef SOCKLEN_T +#ifndef WX_SOCKLEN_T #ifdef VMS -# define SOCKLEN_T unsigned int +# define WX_SOCKLEN_T unsigned int #else # ifdef __GLIBC__ # if __GLIBC__ == 2 -# define SOCKLEN_T socklen_t +# define WX_SOCKLEN_T socklen_t # endif +# elif defined(__WXMAC__) +# define WX_SOCKLEN_T socklen_t # else -# define SOCKLEN_T int +# define WX_SOCKLEN_T int # endif #endif -#else - /* undefine for OSX - its really an int */ -# ifdef __DARWIN__ -# undef SOCKLEN_T -# define SOCKLEN_T int -# endif #endif /* SOCKLEN_T */ +#ifndef SOCKOPTLEN_T +#define SOCKOPTLEN_T WX_SOCKLEN_T +#endif + /* * MSW defines this, Unices don't. */ @@ -145,25 +149,218 @@ int _System soclose(int); #define INADDR_NONE INADDR_BROADCAST #endif -#define MASK_SIGNAL() \ -{ \ - void (*old_handler)(int); \ - \ - old_handler = signal(SIGPIPE, SIG_IGN); +#if defined(__VISAGECPP__) || defined(__WATCOMC__) -#define UNMASK_SIGNAL() \ - signal(SIGPIPE, old_handler); \ -} + #define MASK_SIGNAL() { + #define UNMASK_SIGNAL() } + +#else + extern "C" { typedef void (*wxSigHandler)(int); } + #define MASK_SIGNAL() \ + { \ + wxSigHandler old_handler = signal(SIGPIPE, SIG_IGN); + + #define UNMASK_SIGNAL() \ + signal(SIGPIPE, old_handler); \ + } + +#endif + +/* If a SIGPIPE is issued by a socket call on a remotely closed socket, + the program will "crash" unless it explicitly handles the SIGPIPE. + By using MSG_NOSIGNAL, the SIGPIPE is suppressed. Later, we will + use SO_NOSIGPIPE (if available), the BSD equivalent. */ +#ifdef MSG_NOSIGNAL +# define GSOCKET_MSG_NOSIGNAL MSG_NOSIGNAL +#else /* MSG_NOSIGNAL not available (FreeBSD including OS X) */ +# define GSOCKET_MSG_NOSIGNAL 0 +#endif /* MSG_NOSIGNAL */ #ifndef __GSOCKET_STANDALONE__ # include "wx/unix/gsockunx.h" +# include "wx/unix/private.h" # include "wx/gsocket.h" +#if wxUSE_THREADS && (defined(HAVE_GETHOSTBYNAME) || defined(HAVE_GETSERVBYNAME)) +# include "wx/thread.h" +#endif #else # include "gsockunx.h" # include "gsocket.h" +# ifndef WXUNUSED +# define WXUNUSED(x) +# endif #endif /* __GSOCKET_STANDALONE__ */ +#if defined(HAVE_GETHOSTBYNAME) +static struct hostent * deepCopyHostent(struct hostent *h, + const struct hostent *he, + char *buffer, int size, int *err) +{ + memcpy(h, he, sizeof(struct hostent)); + int len = strlen(h->h_name); + if (len > size) + len = size - 1; + memcpy(buffer, h->h_name, len); + buffer[len] = '\0'; + h->h_name = buffer; + buffer += len + 1; + size -= len + 1; + len = h->h_length; + for (char **p = h->h_addr_list; *p != 0; p++) { + if (size < len){ + *err = ENOMEM; + return NULL; + } + memcpy(buffer, *p, len); + *p = buffer; + buffer += len; + size -= len; + } + for (char **q = h->h_aliases; size > 0 && *q != 0; q++){ + len = strlen(*q); + if (len > size) + len = size - 1; + memcpy(buffer, *q, len); + buffer[len] = '\0'; + *q = buffer; + buffer += len + 1; + size -= len + 1; + } + return h; +} +#endif + +struct hostent * wxGethostbyname_r(const char *hostname, struct hostent *h, + void *buffer, int size, int *err) + +{ + struct hostent *he = NULL; + *err = 0; +#if defined(HAVE_FUNC_GETHOSTBYNAME_R_6) + if (gethostbyname_r(hostname, h, (char*)buffer, size, &he, err)) + he = NULL; +#elif defined(HAVE_FUNC_GETHOSTBYNAME_R_5) + he = gethostbyname_r(hostname, h, (char*)buffer, size, err); +#elif defined(HAVE_FUNC_GETHOSTBYNAME_R_3) + if (gethostbyname_r(hostname, h, (struct hostent_data*) buffer)) + { + he = NULL; + *err = h_errno; + } + else + he = h; +#elif defined(HAVE_GETHOSTBYNAME) +#if wxUSE_THREADS + static wxMutex nameLock; + wxMutexLocker locker(nameLock); +#endif + he = gethostbyname(hostname); + if (!he) + *err = h_errno; + else + he = deepCopyHostent(h, he, (char*)buffer, size, err); +#endif + return he; +} + +struct hostent * wxGethostbyaddr_r(const char *addr_buf, int buf_size, + int proto, struct hostent *h, + void *buffer, int size, int *err) +{ + struct hostent *he = NULL; + *err = 0; +#if defined(HAVE_FUNC_GETHOSTBYNAME_R_6) + if (gethostbyaddr_r(addr_buf, buf_size, proto, h, + (char*)buffer, size, &he, err)) + he = NULL; +#elif defined(HAVE_FUNC_GETHOSTBYNAME_R_5) + he = gethostbyaddr_r(addr_buf, buf_size, proto, h, (char*)buffer, size, err); +#elif defined(HAVE_FUNC_GETHOSTBYNAME_R_3) + if (gethostbyaddr_r(addr_buf, buf_size, proto, h, + (struct hostent_data*) buffer)) + { + he = NULL; + *err = h_errno; + } + else + he = h; +#elif defined(HAVE_GETHOSTBYNAME) +#if wxUSE_THREADS + static wxMutex addrLock; + wxMutexLocker locker(addrLock); +#endif + he = gethostbyaddr(addr_buf, buf_size, proto); + if (!he) + *err = h_errno; + else + he = deepCopyHostent(h, he, (char*)buffer, size, err); +#endif + return he; +} + +#if defined(HAVE_GETSERVBYNAME) +static struct servent * deepCopyServent(struct servent *s, + const struct servent *se, + char *buffer, int size) +{ + memcpy(s, se, sizeof(struct servent)); + int len = strlen(s->s_name); + if (len > size) + len = size - 1; + memcpy(buffer, s->s_name, len); + buffer[len] = '\0'; + s->s_name = buffer; + buffer += len + 1; + size -= len + 1; + len = strlen(s->s_proto); + if (len > size) + len = size - 1; + memcpy(buffer, s->s_proto, len); + buffer[len] = '\0'; + s->s_proto = buffer; + buffer += len + 1; + size -= len + 1; + for (char **q = s->s_aliases; size > 0 && *q != 0; q++){ + len = strlen(*q); + if (len > size) + len = size - 1; + memcpy(buffer, *q, len); + buffer[len] = '\0'; + *q = buffer; + buffer += len + 1; + size -= len + 1; + } + return s; +} +#endif + +struct servent *wxGetservbyname_r(const char *port, const char *protocol, + struct servent *serv, void *buffer, int size) +{ + struct servent *se = NULL; +#if defined(HAVE_FUNC_GETSERVBYNAME_R_6) + if (getservbyname_r(port, protocol, serv, (char*)buffer, size, &se)) + se = NULL; +#elif defined(HAVE_FUNC_GETSERVBYNAME_R_5) + se = getservbyname_r(port, protocol, serv, (char*)buffer, size); +#elif defined(HAVE_FUNC_GETSERVBYNAME_R_4) + if (getservbyname_r(port, protocol, serv, (struct servent_data*) buffer)) + se = NULL; + else + se = serv; +#elif defined(HAVE_GETSERVBYNAME) +#if wxUSE_THREADS + static wxMutex servLock; + wxMutexLocker locker(servLock); +#endif + se = getservbyname(port, protocol); + if (se) + se = deepCopyServent(serv, se, (char*)buffer, size); +#endif + return se; +} + /* debugging helpers */ #ifdef __GSOCKET_DEBUG__ # define GSocket_Debug(args) printf args @@ -196,17 +393,17 @@ void GSocketGUIFunctionsTableNull::OnExit() {} bool GSocketGUIFunctionsTableNull::CanUseEventLoop() { return false; } -bool GSocketGUIFunctionsTableNull::Init_Socket(GSocket *socket) +bool GSocketGUIFunctionsTableNull::Init_Socket(GSocket *WXUNUSED(socket)) { return true; } -void GSocketGUIFunctionsTableNull::Destroy_Socket(GSocket *socket) +void GSocketGUIFunctionsTableNull::Destroy_Socket(GSocket *WXUNUSED(socket)) {} -void GSocketGUIFunctionsTableNull::Install_Callback(GSocket *socket, GSocketEvent event) +void GSocketGUIFunctionsTableNull::Install_Callback(GSocket *WXUNUSED(socket), GSocketEvent WXUNUSED(event)) {} -void GSocketGUIFunctionsTableNull::Uninstall_Callback(GSocket *socket, GSocketEvent event) +void GSocketGUIFunctionsTableNull::Uninstall_Callback(GSocket *WXUNUSED(socket), GSocketEvent WXUNUSED(event)) {} -void GSocketGUIFunctionsTableNull::Enable_Events(GSocket *socket) +void GSocketGUIFunctionsTableNull::Enable_Events(GSocket *WXUNUSED(socket)) {} -void GSocketGUIFunctionsTableNull::Disable_Events(GSocket *socket) +void GSocketGUIFunctionsTableNull::Disable_Events(GSocket *WXUNUSED(socket)) {} /* Global initialisers */ @@ -303,6 +500,9 @@ void GSocket::Shutdown() assert(this); + /* Don't allow events to fire after socket has been closed */ + gs_gui_functions->Disable_Events(this); + /* If socket has been created, shutdown it */ if (m_fd != INVALID_SOCKET) { @@ -382,7 +582,7 @@ GAddress *GSocket::GetLocal() { GAddress *address; struct sockaddr addr; - SOCKLEN_T size = sizeof(addr); + WX_SOCKLEN_T size = sizeof(addr); GSocketError err; assert(this); @@ -398,7 +598,7 @@ GAddress *GSocket::GetLocal() return NULL; } - if (getsockname(m_fd, &addr, (SOCKLEN_T *) &size) < 0) + if (getsockname(m_fd, &addr, (WX_SOCKLEN_T *) &size) < 0) { m_error = GSOCK_IOERR; return NULL; @@ -478,18 +678,25 @@ GSocketError GSocket::SetServer() m_error = GSOCK_IOERR; return GSOCK_IOERR; } -#if defined(__EMX__) || defined(__VISAGECPP__) - ioctl(m_fd, FIONBIO, (char*)&arg, sizeof(arg)); -#else - ioctl(m_fd, FIONBIO, &arg); + + /* FreeBSD variants can't use MSG_NOSIGNAL, and instead use a socket option */ +#ifdef SO_NOSIGPIPE + setsockopt(m_fd, SOL_SOCKET, SO_NOSIGPIPE, (const char*)&arg, sizeof(u_long)); #endif + + ioctl(m_fd, FIONBIO, &arg); gs_gui_functions->Enable_Events(this); /* allow a socket to re-bind if the socket is in the TIME_WAIT state after being previously closed. */ if (m_reusable) + { setsockopt(m_fd, SOL_SOCKET, SO_REUSEADDR, (const char*)&arg, sizeof(u_long)); +#ifdef SO_REUSEPORT + setsockopt(m_fd, SOL_SOCKET, SO_REUSEPORT, (const char*)&arg, sizeof(u_long)); +#endif + } /* Bind to the local address, * retrieve the actual address bound, @@ -498,7 +705,7 @@ GSocketError GSocket::SetServer() if ((bind(m_fd, m_local->m_addr, m_local->m_len) != 0) || (getsockname(m_fd, m_local->m_addr, - (SOCKLEN_T *) &m_local->m_len) != 0) || + (WX_SOCKLEN_T *) &m_local->m_len) != 0) || (listen(m_fd, 5) != 0)) { Close(); @@ -524,16 +731,13 @@ GSocketError GSocket::SetServer() GSocket *GSocket::WaitConnection() { struct sockaddr from; - SOCKLEN_T fromlen = sizeof(from); + WX_SOCKLEN_T fromlen = sizeof(from); GSocket *connection; GSocketError err; int arg = 1; assert(this); - /* Reenable CONNECTION events */ - Enable(GSOCK_CONNECTION); - /* If the socket has already been created, we exit immediately */ if (m_fd == INVALID_SOCKET || !m_server) { @@ -558,7 +762,10 @@ GSocket *GSocket::WaitConnection() return NULL; } - connection->m_fd = accept(m_fd, &from, (SOCKLEN_T *) &fromlen); + connection->m_fd = accept(m_fd, &from, (WX_SOCKLEN_T *) &fromlen); + + /* Reenable CONNECTION events */ + Enable(GSOCK_CONNECTION); if (connection->m_fd == INVALID_SOCKET) { @@ -583,14 +790,15 @@ GSocket *GSocket::WaitConnection() m_error = GSOCK_MEMERR; return NULL; } + err = _GAddress_translate_from(connection->m_peer, &from, fromlen); if (err != GSOCK_NOERROR) { - GAddress_destroy(connection->m_peer); delete connection; m_error = err; return NULL; } + #if defined(__EMX__) || defined(__VISAGECPP__) ioctl(connection->m_fd, FIONBIO, (char*)&arg, sizeof(arg)); #else @@ -604,10 +812,13 @@ GSocket *GSocket::WaitConnection() bool GSocket::SetReusable() { /* socket must not be null, and must not be in use/already bound */ - if (this && m_fd == INVALID_SOCKET) { + if (this && m_fd == INVALID_SOCKET) + { m_reusable = true; + return true; } + return false; } @@ -617,7 +828,7 @@ bool GSocket::SetReusable() * For stream (connection oriented) sockets, GSocket_Connect() tries * to establish a client connection to a server using the peer address * as established with GSocket_SetPeer(). Returns GSOCK_NOERROR if the - * connection has been succesfully established, or one of the error + * connection has been successfully established, or one of the error * codes listed below. Note that for nonblocking sockets, a return * value of GSOCK_WOULDBLOCK doesn't mean a failure. The connection * request can be completed later; you should use GSocket_Select() @@ -672,16 +883,47 @@ GSocketError GSocket::Connect(GSocketStream stream) m_error = GSOCK_IOERR; return GSOCK_IOERR; } + + /* FreeBSD variants can't use MSG_NOSIGNAL, and instead use a socket option */ +#ifdef SO_NOSIGPIPE + setsockopt(m_fd, SOL_SOCKET, SO_NOSIGPIPE, (const char*)&arg, sizeof(u_long)); +#endif + #if defined(__EMX__) || defined(__VISAGECPP__) ioctl(m_fd, FIONBIO, (char*)&arg, sizeof(arg)); #else ioctl(m_fd, FIONBIO, &arg); #endif - gs_gui_functions->Enable_Events(this); + + // If the reuse flag is set, use the applicable socket reuse flags(s) + if (m_reusable) + { + setsockopt(m_fd, SOL_SOCKET, SO_REUSEADDR, (const char*)&arg, sizeof(u_long)); +#ifdef SO_REUSEPORT + setsockopt(m_fd, SOL_SOCKET, SO_REUSEPORT, (const char*)&arg, sizeof(u_long)); +#endif + } + + // If a local address has been set, then we need to bind to it before calling connect + if (m_local && m_local->m_addr) + { + bind(m_fd, m_local->m_addr, m_local->m_len); + } /* Connect it to the peer address, with a timeout (see below) */ ret = connect(m_fd, m_peer->m_addr, m_peer->m_len); + /* We only call Enable_Events if we know we aren't shutting down the socket. + * NB: Enable_Events needs to be called whether the socket is blocking or + * non-blocking, it just shouldn't be called prior to knowing there is a + * connection _if_ blocking sockets are being used. + * If connect above returns 0, we are already connected and need to make the + * call to Enable_Events now. + */ + + if (m_non_blocking || ret == 0) + gs_gui_functions->Enable_Events(this); + if (ret == -1) { err = errno; @@ -702,9 +944,11 @@ GSocketError GSocket::Connect(GSocketStream stream) else { int error; - SOCKLEN_T len = sizeof(error); + SOCKOPTLEN_T len = sizeof(error); + + getsockopt(m_fd, SOL_SOCKET, SO_ERROR, (char*) &error, &len); - getsockopt(m_fd, SOL_SOCKET, SO_ERROR, (void*) &error, &len); + gs_gui_functions->Enable_Events(this); if (!error) return GSOCK_NOERROR; @@ -729,6 +973,7 @@ GSocketError GSocket::Connect(GSocketStream stream) */ Close(); m_error = GSOCK_IOERR; + return GSOCK_IOERR; } @@ -791,7 +1036,7 @@ GSocketError GSocket::SetNonOriented() if ((bind(m_fd, m_local->m_addr, m_local->m_len) != 0) || (getsockname(m_fd, m_local->m_addr, - (SOCKLEN_T *) &m_local->m_len) != 0)) + (WX_SOCKLEN_T *) &m_local->m_len) != 0)) { Close(); m_error = GSOCK_IOERR; @@ -820,23 +1065,33 @@ int GSocket::Read(char *buffer, int size) Disable(GSOCK_INPUT); /* If the socket is blocking, wait for data (with a timeout) */ - if (Input_Timeout() == GSOCK_TIMEDOUT) - /* We no longer return here immediately, otherwise socket events would not be re-enabled! */ + if (Input_Timeout() == GSOCK_TIMEDOUT) { + m_error = GSOCK_TIMEDOUT; + /* Don't return here immediately, otherwise socket events would not be + * re-enabled! */ ret = -1; - else { + } + else + { /* Read the data */ if (m_stream) ret = Recv_Stream(buffer, size); else ret = Recv_Dgram(buffer, size); - } - if (ret == -1) - { - if (errno == EWOULDBLOCK) - m_error = GSOCK_WOULDBLOCK; - else + /* If recv returned zero, then the connection is lost, and errno is not set. + * Otherwise, recv has returned an error (-1), in which case we have lost the + * socket only if errno does _not_ indicate that there may be more data to read. + */ + if (ret == 0) m_error = GSOCK_IOERR; + else if (ret == -1) + { + if ((errno == EWOULDBLOCK) || (errno == EAGAIN)) + m_error = GSOCK_WOULDBLOCK; + else + m_error = GSOCK_IOERR; + } } /* Enable events again now that we are done processing */ @@ -877,7 +1132,7 @@ int GSocket::Write(const char *buffer, int size) if (ret == -1) { - if (errno == EWOULDBLOCK) + if ((errno == EWOULDBLOCK) || (errno == EAGAIN)) { m_error = GSOCK_WOULDBLOCK; GSocket_Debug(( "GSocket_Write error WOULDBLOCK\n" )); @@ -894,6 +1149,7 @@ int GSocket::Write(const char *buffer, int size) * will further OUTPUT events be posted. */ Enable(GSOCK_OUTPUT); + return -1; } @@ -922,17 +1178,20 @@ GSocketEventFlags GSocket::Select(GSocketEventFlags flags) assert(this); + if (m_fd == -1) + return (GSOCK_LOST_FLAG & flags); + /* Do not use a static struct, Linux can garble it */ tv.tv_sec = m_timeout / 1000; tv.tv_usec = (m_timeout % 1000) * 1000; - FD_ZERO(&readfds); - FD_ZERO(&writefds); - FD_ZERO(&exceptfds); - FD_SET(m_fd, &readfds); + wxFD_ZERO(&readfds); + wxFD_ZERO(&writefds); + wxFD_ZERO(&exceptfds); + wxFD_SET(m_fd, &readfds); if (flags & GSOCK_OUTPUT_FLAG || flags & GSOCK_CONNECTION_FLAG) - FD_SET(m_fd, &writefds); - FD_SET(m_fd, &exceptfds); + wxFD_SET(m_fd, &writefds); + wxFD_SET(m_fd, &exceptfds); /* Check 'sticky' CONNECTION flag first */ result |= (GSOCK_CONNECTION_FLAG & m_detected); @@ -954,44 +1213,42 @@ GSocketEventFlags GSocket::Select(GSocketEventFlags flags) return (result & flags); } + /* Check for exceptions and errors */ + if (wxFD_ISSET(m_fd, &exceptfds)) + { + m_establishing = false; + m_detected = GSOCK_LOST_FLAG; + + /* LOST event: Abort any further processing */ + return (GSOCK_LOST_FLAG & flags); + } + /* Check for readability */ - if (FD_ISSET(m_fd, &readfds)) + if (wxFD_ISSET(m_fd, &readfds)) { - char c; + result |= GSOCK_INPUT_FLAG; - if (recv(m_fd, &c, 1, MSG_PEEK) > 0) + if (m_server && m_stream) { - result |= GSOCK_INPUT_FLAG; - } - else - { - if (m_server && m_stream) - { - result |= GSOCK_CONNECTION_FLAG; - m_detected |= GSOCK_CONNECTION_FLAG; - } - else - { - m_detected = GSOCK_LOST_FLAG; - m_establishing = false; - - /* LOST event: Abort any further processing */ - return (GSOCK_LOST_FLAG & flags); - } + /* This is a TCP server socket that detected a connection. + While the INPUT_FLAG is also set, it doesn't matter on + this kind of sockets, as we can only Accept() from them. */ + result |= GSOCK_CONNECTION_FLAG; + m_detected |= GSOCK_CONNECTION_FLAG; } } /* Check for writability */ - if (FD_ISSET(m_fd, &writefds)) + if (wxFD_ISSET(m_fd, &writefds)) { if (m_establishing && !m_server) { int error; - SOCKLEN_T len = sizeof(error); + SOCKOPTLEN_T len = sizeof(error); m_establishing = false; - getsockopt(m_fd, SOL_SOCKET, SO_ERROR, (void*)&error, &len); + getsockopt(m_fd, SOL_SOCKET, SO_ERROR, (char*)&error, &len); if (error) { @@ -1012,25 +1269,13 @@ GSocketEventFlags GSocket::Select(GSocketEventFlags flags) } } - /* Check for exceptions and errors (is this useful in Unices?) */ - if (FD_ISSET(m_fd, &exceptfds)) - { - m_establishing = false; - m_detected = GSOCK_LOST_FLAG; - - /* LOST event: Abort any further processing */ - return (GSOCK_LOST_FLAG & flags); - } - return (result & flags); } else { - assert(this); return flags & m_detected; - } } @@ -1061,7 +1306,7 @@ void GSocket::SetTimeout(unsigned long millisec) } /* GSocket_GetError: - * Returns the last error occured for this socket. Note that successful + * Returns the last error occurred for this socket. Note that successful * operations do not clear this back to GSOCK_NOERROR, so use it only * after an error. */ @@ -1086,7 +1331,7 @@ GSocketError WXDLLIMPEXP_NET GSocket::GetError() * assume that it can write since the first OUTPUT event, and no more * OUTPUT events will be generated unless an error occurs. * GSOCK_CONNECTION: - * Connection succesfully established, for client sockets, or incoming + * Connection successfully established, for client sockets, or incoming * client connection, for server sockets. Wait for this event (also watch * out for GSOCK_LOST) after you issue a nonblocking GSocket_Connect() call. * GSOCK_LOST: @@ -1142,20 +1387,18 @@ void GSocket::UnsetCallback(GSocketEventFlags flags) GSocketError GSocket::GetSockOpt(int level, int optname, void *optval, int *optlen) { - if (getsockopt(m_fd, level, optname, optval, (SOCKLEN_T*)optlen) == 0) - { + if (getsockopt(m_fd, level, optname, (char*)optval, (SOCKOPTLEN_T*)optlen) == 0) return GSOCK_NOERROR; - } + return GSOCK_OPTERR; } GSocketError GSocket::SetSockOpt(int level, int optname, const void *optval, int optlen) { - if (setsockopt(m_fd, level, optname, optval, optlen) == 0) - { + if (setsockopt(m_fd, level, optname, (const char*)optval, optlen) == 0) return GSOCK_NOERROR; - } + return GSOCK_OPTERR; } @@ -1194,8 +1437,8 @@ GSocketError GSocket::Input_Timeout() if (!m_non_blocking) { - FD_ZERO(&readfds); - FD_SET(m_fd, &readfds); + wxFD_ZERO(&readfds); + wxFD_SET(m_fd, &readfds); ret = select(m_fd + 1, &readfds, NULL, NULL, &tv); if (ret == 0) { @@ -1203,6 +1446,7 @@ GSocketError GSocket::Input_Timeout() m_error = GSOCK_TIMEDOUT; return GSOCK_TIMEDOUT; } + if (ret == -1) { GSocket_Debug(( "GSocket_Input_Timeout, select returned -1\n" )); @@ -1214,6 +1458,7 @@ GSocketError GSocket::Input_Timeout() return GSOCK_TIMEDOUT; } } + return GSOCK_NOERROR; } @@ -1235,8 +1480,8 @@ GSocketError GSocket::Output_Timeout() if (!m_non_blocking) { - FD_ZERO(&writefds); - FD_SET(m_fd, &writefds); + wxFD_ZERO(&writefds); + wxFD_SET(m_fd, &writefds); ret = select(m_fd + 1, NULL, &writefds, NULL, &tv); if (ret == 0) { @@ -1244,6 +1489,7 @@ GSocketError GSocket::Output_Timeout() m_error = GSOCK_TIMEDOUT; return GSOCK_TIMEDOUT; } + if (ret == -1) { GSocket_Debug(( "GSocket_Output_Timeout, select returned -1\n" )); @@ -1254,10 +1500,13 @@ GSocketError GSocket::Output_Timeout() m_error = GSOCK_TIMEDOUT; return GSOCK_TIMEDOUT; } - if ( ! FD_ISSET(m_fd, &writefds) ) { + + if ( ! wxFD_ISSET(m_fd, &writefds) ) + { GSocket_Debug(( "GSocket_Output_Timeout is buggy!\n" )); } - else { + else + { GSocket_Debug(( "GSocket_Output_Timeout seems correct\n" )); } } @@ -1271,19 +1520,30 @@ GSocketError GSocket::Output_Timeout() int GSocket::Recv_Stream(char *buffer, int size) { - return recv(m_fd, buffer, size, 0); + int ret; + do + { + ret = recv(m_fd, buffer, size, GSOCKET_MSG_NOSIGNAL); + } + while (ret == -1 && errno == EINTR); /* Loop until not interrupted */ + + return ret; } int GSocket::Recv_Dgram(char *buffer, int size) { struct sockaddr from; - SOCKLEN_T fromlen = sizeof(from); + WX_SOCKLEN_T fromlen = sizeof(from); int ret; GSocketError err; fromlen = sizeof(from); - ret = recvfrom(m_fd, buffer, size, 0, &from, (SOCKLEN_T *) &fromlen); + do + { + ret = recvfrom(m_fd, buffer, size, 0, &from, (WX_SOCKLEN_T *) &fromlen); + } + while (ret == -1 && errno == EINTR); /* Loop until not interrupted */ if (ret == -1) return -1; @@ -1298,6 +1558,7 @@ int GSocket::Recv_Dgram(char *buffer, int size) return -1; } } + err = _GAddress_translate_from(m_peer, &from, fromlen); if (err != GSOCK_NOERROR) { @@ -1314,13 +1575,15 @@ int GSocket::Send_Stream(const char *buffer, int size) { int ret; -#ifndef __VISAGECPP__ MASK_SIGNAL(); - ret = send(m_fd, buffer, size, 0); + + do + { + ret = send(m_fd, (char *)buffer, size, GSOCKET_MSG_NOSIGNAL); + } + while (ret == -1 && errno == EINTR); /* Loop until not interrupted */ + UNMASK_SIGNAL(); -#else - ret = send(m_fd, (char *)buffer, size, 0); -#endif return ret; } @@ -1344,13 +1607,15 @@ int GSocket::Send_Dgram(const char *buffer, int size) return -1; } -#ifndef __VISAGECPP__ MASK_SIGNAL(); - ret = sendto(m_fd, buffer, size, 0, addr, len); + + do + { + ret = sendto(m_fd, (char *)buffer, size, 0, addr, len); + } + while (ret == -1 && errno == EINTR); /* Loop until not interrupted */ + UNMASK_SIGNAL(); -#else - ret = sendto(m_fd, (char *)buffer, size, 0, addr, len); -#endif /* Frees memory allocated from _GAddress_translate_to */ free(addr); @@ -1362,6 +1627,12 @@ void GSocket::Detected_Read() { char c; + /* Safeguard against straggling call to Detected_Read */ + if (m_fd == INVALID_SOCKET) + { + return; + } + /* If we have already detected a LOST event, then don't try * to do any further processing. */ @@ -1374,7 +1645,9 @@ void GSocket::Detected_Read() return; } - if (recv(m_fd, &c, 1, MSG_PEEK) > 0) + int num = recv(m_fd, &c, 1, MSG_PEEK | GSOCKET_MSG_NOSIGNAL); + + if (num > 0) { CALL_CALLBACK(this, GSOCK_INPUT); } @@ -1386,8 +1659,16 @@ void GSocket::Detected_Read() } else { - CALL_CALLBACK(this, GSOCK_LOST); - Shutdown(); + /* Do not throw a lost event in cases where the socket isn't really lost */ + if ((errno == EWOULDBLOCK) || (errno == EAGAIN) || (errno == EINTR)) + { + CALL_CALLBACK(this, GSOCK_INPUT); + } + else + { + CALL_CALLBACK(this, GSOCK_LOST); + Shutdown(); + } } } } @@ -1409,11 +1690,11 @@ void GSocket::Detected_Write() if (m_establishing && !m_server) { int error; - SOCKLEN_T len = sizeof(error); + SOCKOPTLEN_T len = sizeof(error); m_establishing = false; - getsockopt(m_fd, SOL_SOCKET, SO_ERROR, (void*)&error, &len); + getsockopt(m_fd, SOL_SOCKET, SO_ERROR, (char*)&error, &len); if (error) { @@ -1440,9 +1721,11 @@ void GSocket::Detected_Write() GSocket *GSocket_new(void) { GSocket *newsocket = new GSocket(); - if(newsocket->IsOk()) + if (newsocket->IsOk()) return newsocket; + delete newsocket; + return NULL; } @@ -1582,6 +1865,7 @@ GSocketError _GAddress_translate_from(GAddress *address, address->m_error = GSOCK_MEMERR; return GSOCK_MEMERR; } + memcpy(address->m_addr, addr, len); return GSOCK_NOERROR; @@ -1648,7 +1932,7 @@ GSocketError GAddress_INET_SetHostName(GAddress *address, const char *hostname) if (inet_aton(hostname, addr) == 0) { #elif defined(HAVE_INET_ADDR) - if ( (addr->s_addr = inet_addr(hostname)) == -1 ) + if ( (addr->s_addr = inet_addr(hostname)) == (unsigned)-1 ) { #else /* Use gethostbyname by default */ @@ -1661,16 +1945,26 @@ GSocketError GAddress_INET_SetHostName(GAddress *address, const char *hostname) struct in_addr *array_addr; /* It is a real name, we solve it */ - if ((he = gethostbyname(hostname)) == NULL) + struct hostent h; +#if defined(HAVE_FUNC_GETHOSTBYNAME_R_3) + struct hostent_data buffer; +#else + char buffer[1024]; +#endif + int err; + he = wxGethostbyname_r(hostname, &h, (void*)&buffer, sizeof(buffer), &err); + if (he == NULL) { /* Reset to invalid address */ addr->s_addr = INADDR_NONE; address->m_error = GSOCK_NOHOST; return GSOCK_NOHOST; } + array_addr = (struct in_addr *) *(he->h_addr_list); addr->s_addr = array_addr[0].s_addr; } + return GSOCK_NOERROR; } @@ -1709,7 +2003,14 @@ GSocketError GAddress_INET_SetPortName(GAddress *address, const char *port, return GSOCK_INVPORT; } - se = getservbyname(port, protocol); +#if defined(HAVE_FUNC_GETSERVBYNAME_R_4) + struct servent_data buffer; +#else + char buffer[1024]; +#endif + struct servent serv; + se = wxGetservbyname_r(port, protocol, &serv, + (void*)&buffer, sizeof(buffer)); if (!se) { /* the cast to int suppresses compiler warnings about subscript having the @@ -1759,7 +2060,15 @@ GSocketError GAddress_INET_GetHostName(GAddress *address, char *hostname, size_t addr = (struct sockaddr_in *)address->m_addr; addr_buf = (char *)&(addr->sin_addr); - he = gethostbyaddr(addr_buf, sizeof(addr->sin_addr), AF_INET); + struct hostent temphost; +#if defined(HAVE_FUNC_GETHOSTBYNAME_R_3) + struct hostent_data buffer; +#else + char buffer[1024]; +#endif + int err; + he = wxGethostbyaddr_r(addr_buf, sizeof(addr->sin_addr), AF_INET, &temphost, + (void*)&buffer, sizeof(buffer), &err); if (he == NULL) { address->m_error = GSOCK_NOHOST; @@ -1851,4 +2160,3 @@ GSocketError GAddress_UNIX_GetPath(GAddress *address, char *path, size_t sbuf) } #endif /* !defined(__VISAGECPP__) */ #endif /* wxUSE_SOCKETS || defined(__GSOCKET_STANDALONE__) */ -