X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/5c2896013b8be85955c6f5155deb1aec467e00eb..a766986f6d443ba1d50e3af25f3306fa56e4518e:/src/unix/gsocket.cpp?ds=sidebyside diff --git a/src/unix/gsocket.cpp b/src/unix/gsocket.cpp index 33785cc31f..1d1b9cec69 100644 --- a/src/unix/gsocket.cpp +++ b/src/unix/gsocket.cpp @@ -1,26 +1,31 @@ /* ------------------------------------------------------------------------- - * 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$ * ------------------------------------------------------------------------- */ +#if defined(__WATCOMC__) #include "wx/wxprec.h" -#ifndef WX_PRECOMP - #include "wx/app.h" - #include "wx/apptrait.h" -#endif //ndef WX_PRECOMP +#include +#include +#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 */ +#ifndef __GSOCKET_STANDALONE__ #include "wx/defs.h" -#define BSD_SELECT /* use Berkley Sockets select */ +#include "wx/private/gsocketiohandler.h" +#include "wx/thread.h" // for wxThread::IsMain() used in assert +#endif + +#if defined(__VISAGECPP__) +#define BSD_SELECT /* use Berkeley Sockets select */ #endif #if wxUSE_SOCKETS || defined(__GSOCKET_STANDALONE__) @@ -36,6 +41,10 @@ #include #include +#ifdef HAVE_SYS_SELECT_H +# include +#endif + #ifdef __VMS__ #include struct sockaddr_un @@ -85,6 +94,10 @@ int _System bsdselect(int, int _System soclose(int); # endif #endif +#ifdef __EMX__ +#include +#endif + #include #include #include @@ -95,24 +108,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 #endif /* SOCKLEN_T */ +#ifndef SOCKOPTLEN_T +#define SOCKOPTLEN_T WX_SOCKLEN_T +#endif + /* * MSW defines this, Unices don't. */ @@ -133,112 +155,333 @@ 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__ */ -/* debugging helpers */ -#ifdef __GSOCKET_DEBUG__ -# define GSocket_Debug(args) printf args -#else -# define GSocket_Debug(args) -#endif /* __GSOCKET_DEBUG__ */ +#if defined(HAVE_GETHOSTBYNAME) +static struct hostent * deepCopyHostent(struct hostent *h, + const struct hostent *he, + char *buffer, int size, int *err) +{ + /* copy old structure */ + memcpy(h, he, sizeof(struct hostent)); -/////////////////////////////////////////////////////////////////////////// -// GSocketBSDGUIShim -struct GSocketGUIFunctionsTable *GSocketBSDGUIShim::ms_gui_functions = NULL; + /* copy name */ + int len = strlen(h->h_name); + if (len > size) + { + *err = ENOMEM; + return NULL; + } + memcpy(buffer, h->h_name, len); + buffer[len] = '\0'; + h->h_name = buffer; -void GSocket_SetGUIFunctions(struct GSocketGUIFunctionsTable *guifunc) -{ - GSocketBSDGUIShim::ms_gui_functions = guifunc; -} - -inline bool GSocketBSDGUIShim::UseGUI() -{ - return ms_gui_functions; -} + /* track position in the buffer */ + int pos = len + 1; -inline bool GSocketBSDGUIShim::GUI_Init() -{ - return (ms_gui_functions)?ms_gui_functions->GUI_Init():true; -} + /* reuse len to store address length */ + len = h->h_length; -inline void GSocketBSDGUIShim::GUI_Cleanup() -{ - if (ms_gui_functions) ms_gui_functions->GUI_Cleanup(); -} + /* ensure pointer alignment */ + unsigned int misalign = sizeof(char *) - pos%sizeof(char *); + if(misalign < sizeof(char *)) + pos += misalign; -GSocketBSDGUIShim::GSocketBSDGUIShim() -{ - m_ok = (ms_gui_functions ? ms_gui_functions->GUI_Init_Socket(this) : true); -} + /* leave space for pointer list */ + char **p = h->h_addr_list, **q; + char **h_addr_list = (char **)(buffer + pos); + while(*(p++) != 0) + pos += sizeof(char *); -GSocketBSDGUIShim::~GSocketBSDGUIShim() -{ - if (ms_gui_functions) ms_gui_functions->GUI_Destroy_Socket(this); + /* copy addresses and fill new pointer list */ + for (p = h->h_addr_list, q = h_addr_list; *p != 0; p++, q++) + { + if (size < pos + len) + { + *err = ENOMEM; + return NULL; + } + memcpy(buffer + pos, *p, len); /* copy content */ + *q = buffer + pos; /* set copied pointer to copied content */ + pos += len; + } + *++q = 0; /* null terminate the pointer list */ + h->h_addr_list = h_addr_list; /* copy pointer to pointers */ + + /* ensure word alignment of pointers */ + misalign = sizeof(char *) - pos%sizeof(char *); + if(misalign < sizeof(char *)) + pos += misalign; + + /* leave space for pointer list */ + p = h->h_aliases; + char **h_aliases = (char **)(buffer + pos); + while(*(p++) != 0) + pos += sizeof(char *); + + /* copy aliases and fill new pointer list */ + for (p = h->h_aliases, q = h_aliases; *p != 0; p++, q++) + { + len = strlen(*p); + if (size <= pos + len) + { + *err = ENOMEM; + return NULL; + } + memcpy(buffer + pos, *p, len); /* copy content */ + buffer[pos + len] = '\0'; + *q = buffer + pos; /* set copied pointer to copied content */ + pos += len + 1; + } + *++q = 0; /* null terminate the pointer list */ + h->h_aliases = h_aliases; /* copy pointer to pointers */ + + return h; } +#endif -void GSocketBSDGUIShim::EventLoop_Enable_Events() -{ - if (ms_gui_functions) ms_gui_functions->Enable_Events(this); +#if defined(HAVE_GETHOSTBYNAME) && wxUSE_THREADS +static wxMutex nameLock; +#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 + wxMutexLocker locker(nameLock); +#endif + he = gethostbyname(hostname); + if (!he) + *err = h_errno; + else + he = deepCopyHostent(h, he, (char*)buffer, size, err); +#endif + return he; } -void GSocketBSDGUIShim::EventLoop_Disable_Events() -{ - if (ms_gui_functions) ms_gui_functions->Disable_Events(this); +#if defined(HAVE_GETHOSTBYNAME) && wxUSE_THREADS +static wxMutex addrLock; +#endif +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 + 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; } -void GSocketBSDGUIShim::EventLoop_Install_Callback(GSocketEvent event) +#if defined(HAVE_GETSERVBYNAME) +static struct servent * deepCopyServent(struct servent *s, + const struct servent *se, + char *buffer, int size) { - if (ms_gui_functions) ms_gui_functions->Install_Callback(this, event); + /* copy plain old structure */ + memcpy(s, se, sizeof(struct servent)); + + /* copy name */ + int len = strlen(s->s_name); + if (len >= size) + { + return NULL; + } + memcpy(buffer, s->s_name, len); + buffer[len] = '\0'; + s->s_name = buffer; + + /* track position in the buffer */ + int pos = len + 1; + + /* copy protocol */ + len = strlen(s->s_proto); + if (pos + len >= size) + { + return NULL; + } + memcpy(buffer + pos, s->s_proto, len); + buffer[pos + len] = '\0'; + s->s_proto = buffer + pos; + + /* track position in the buffer */ + pos += len + 1; + + /* ensure pointer alignment */ + unsigned int misalign = sizeof(char *) - pos%sizeof(char *); + if(misalign < sizeof(char *)) + pos += misalign; + + /* leave space for pointer list */ + char **p = s->s_aliases, **q; + char **s_aliases = (char **)(buffer + pos); + while(*(p++) != 0) + pos += sizeof(char *); + + /* copy addresses and fill new pointer list */ + for (p = s->s_aliases, q = s_aliases; *p != 0; p++, q++){ + len = strlen(*p); + if (size <= pos + len) + { + return NULL; + } + memcpy(buffer + pos, *p, len); /* copy content */ + buffer[pos + len] = '\0'; + *q = buffer + pos; /* set copied pointer to copied content */ + pos += len + 1; + } + *++q = 0; /* null terminate the pointer list */ + s->s_aliases = s_aliases; /* copy pointer to pointers */ + return s; } +#endif -void GSocketBSDGUIShim::EventLoop_Uninstall_Callback(GSocketEvent event) -{ - if (ms_gui_functions) ms_gui_functions->Uninstall_Callback(this, event); +#if defined(HAVE_GETSERVBYNAME) && wxUSE_THREADS +static wxMutex servLock; +#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 + wxMutexLocker locker(servLock); +#endif + se = getservbyname(port, protocol); + if (se) + se = deepCopyServent(serv, se, (char*)buffer, size); +#endif + return se; } -/////////////////////////////////////////////////////////////////////////// -// GSocketBSD +/* debugging helpers */ +#ifdef __GSOCKET_DEBUG__ +# define GSocket_Debug(args) printf args +#else +# define GSocket_Debug(args) +#endif /* __GSOCKET_DEBUG__ */ -static struct GSocketBaseFunctionsTable gs_base_functions = -{ - GSocketBSD::_GSocket_Detected_Read, - GSocketBSD::_GSocket_Detected_Write -}; +#if wxUSE_IPV6 +typedef struct sockaddr_storage wxSockAddr; +#else +typedef struct sockaddr wxSockAddr; +#endif -/* Global initialisers */ +/* Table of GUI-related functions. We must call them indirectly because + * of wxBase and GUI separation: */ -int GSocket_Init(void) +bool GSocket_Init() { - return GSocketBSDGUIShim::GUI_Init(); + GSocketManager * const manager = GSocketManager::Get(); + return manager && manager->OnInit(); } -void GSocket_Cleanup(void) +void GSocket_Cleanup() { - GSocketBSDGUIShim::GUI_Cleanup(); + GSocketManager * const manager = GSocketManager::Get(); + if ( manager ) + manager->OnExit(); } -GSocketBSD::GSocketBSD() +/* Constructors / Destructors for GSocket */ + +GSocket::GSocket() { int i; m_fd = INVALID_SOCKET; + m_handler = NULL; + for (i=0;iInit_Socket(this); } -void GSocketBSD::Close() +void GSocket::Close() { - EventLoop_Disable_Events(); -// gsockosx.c calls CFSocketInvalidate which closes the socket for us -#if !(defined(__DARWIN__) && (defined(__WXMAC__) || defined(__WXCOCOA__))) - close(m_fd); -#endif + if (m_use_events) + DisableEvents(); + + /* When running on OS X, the gsockosx implementation of GSocketGUIFunctionsTable + will close the socket during Disable_Events. However, it will only do this + if it is being used. That is, it won't do it in a console program. To + ensure we get the right behavior, we have gsockosx set m_fd = INVALID_SOCKET + if it has closed the socket which indicates to us (at runtime, instead of + at compile time as this had been before) that the socket has already + been closed. + */ + if(m_fd != INVALID_SOCKET) + close(m_fd); m_fd = INVALID_SOCKET; } -GSocketBSD::~GSocketBSD() +GSocket::~GSocket() { + assert(this); + + /* Check that the socket is really shutdowned */ + if (m_fd != INVALID_SOCKET) + Shutdown(); + + GSocketManager::Get()->Destroy_Socket(this); + + delete m_handler; + /* Destroy private addresses */ if (m_local) GAddress_destroy(m_local); if (m_peer) GAddress_destroy(m_peer); + } /* GSocket_Shutdown: * Disallow further read/write operations on this socket, close * the fd and disable all callbacks. */ -void GSocketBSD::Shutdown() +void GSocket::Shutdown() { int evt; assert(this); + /* Don't allow events to fire after socket has been closed */ + if (m_use_events) + DisableEvents(); + /* If socket has been created, shutdown it */ if (m_fd != INVALID_SOCKET) { - shutdown(m_fd, 2); + shutdown(m_fd, 1); Close(); } @@ -320,7 +590,7 @@ void GSocketBSD::Shutdown() * GSOCK_INVSOCK - the socket is not valid. * GSOCK_INVADDR - the address is not valid. */ -GSocketError GSocketBSD::SetLocal(GAddress *address) +GSocketError GSocket::SetLocal(GAddress *address) { assert(this); @@ -346,7 +616,7 @@ GSocketError GSocketBSD::SetLocal(GAddress *address) return GSOCK_NOERROR; } -GSocketError GSocketBSD::SetPeer(GAddress *address) +GSocketError GSocket::SetPeer(GAddress *address) { assert(this); @@ -365,11 +635,11 @@ GSocketError GSocketBSD::SetPeer(GAddress *address) return GSOCK_NOERROR; } -GAddress *GSocketBSD::GetLocal() +GAddress *GSocket::GetLocal() { GAddress *address; - struct sockaddr addr; - SOCKLEN_T size = sizeof(addr); + wxSockAddr addr; + WX_SOCKLEN_T size = sizeof(addr); GSocketError err; assert(this); @@ -385,7 +655,7 @@ GAddress *GSocketBSD::GetLocal() return NULL; } - if (getsockname(m_fd, &addr, (SOCKLEN_T *) &size) < 0) + if (getsockname(m_fd, (sockaddr*)&addr, (WX_SOCKLEN_T *) &size) < 0) { m_error = GSOCK_IOERR; return NULL; @@ -399,7 +669,7 @@ GAddress *GSocketBSD::GetLocal() return NULL; } - err = _GAddress_translate_from(address, &addr, size); + err = _GAddress_translate_from(address, (sockaddr*)&addr, size); if (err != GSOCK_NOERROR) { GAddress_destroy(address); @@ -410,7 +680,7 @@ GAddress *GSocketBSD::GetLocal() return address; } -GAddress *GSocketBSD::GetPeer() +GAddress *GSocket::GetPeer() { assert(this); @@ -427,13 +697,13 @@ GAddress *GSocketBSD::GetPeer() * Sets up this socket as a server. The local address must have been * set with GSocket_SetLocal() before GSocket_SetServer() is called. * Returns GSOCK_NOERROR on success, one of the following otherwise: - * + * * Error codes: * GSOCK_INVSOCK - the socket is in use. * GSOCK_INVADDR - the local address has not been set. - * GSOCK_IOERR - low-level error. + * GSOCK_IOERR - low-level error. */ -GSocketError GSocketBSD::SetServer() +GSocketError GSocket::SetServer() { int arg = 1; @@ -454,9 +724,8 @@ GSocketError GSocketBSD::SetServer() } /* Initialize all fields */ - m_stream = TRUE; - m_server = TRUE; - m_oriented = TRUE; + m_stream = true; + m_server = true; /* Create the socket */ m_fd = socket(m_local->m_realfamily, SOCK_STREAM, 0); @@ -466,17 +735,26 @@ GSocketError GSocketBSD::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(arg)); #endif - EventLoop_Enable_Events(); + + ioctl(m_fd, FIONBIO, &arg); + if (m_use_events) + EnableEvents(); /* allow a socket to re-bind if the socket is in the TIME_WAIT state after being previously closed. */ - setsockopt(m_fd, SOL_SOCKET, SO_REUSEADDR, (const char*)&arg, sizeof(u_long)); + if (m_reusable) + { + setsockopt(m_fd, SOL_SOCKET, SO_REUSEADDR, (const char*)&arg, sizeof(arg)); +#ifdef SO_REUSEPORT + setsockopt(m_fd, SOL_SOCKET, SO_REUSEPORT, (const char*)&arg, sizeof(arg)); +#endif + } /* Bind to the local address, * retrieve the actual address bound, @@ -485,7 +763,7 @@ GSocketError GSocketBSD::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(); @@ -506,21 +784,18 @@ GSocketError GSocketBSD::SetServer() * GSOCK_TIMEDOUT - timeout, no incoming connections. * GSOCK_WOULDBLOCK - the call would block and the socket is nonblocking. * GSOCK_MEMERR - couldn't allocate memory. - * GSOCK_IOERR - low-level error. + * GSOCK_IOERR - low-level error. */ -GSocket *GSocketBSD::WaitConnection() +GSocket *GSocket::WaitConnection() { - struct sockaddr from; - SOCKLEN_T fromlen = sizeof(from); + wxSockAddr 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) { @@ -533,7 +808,6 @@ GSocket *GSocketBSD::WaitConnection() if (!connection) { - delete connection; m_error = GSOCK_MEMERR; return NULL; } @@ -546,7 +820,10 @@ GSocket *GSocketBSD::WaitConnection() return NULL; } - connection->m_fd = accept(m_fd, &from, (SOCKLEN_T *) &fromlen); + connection->m_fd = accept(m_fd, (sockaddr*)&from, (WX_SOCKLEN_T *) &fromlen); + + /* Reenable CONNECTION events */ + Enable(GSOCK_CONNECTION); if (connection->m_fd == INVALID_SOCKET) { @@ -560,9 +837,8 @@ GSocket *GSocketBSD::WaitConnection() } /* Initialize all fields */ - connection->m_server = FALSE; - connection->m_stream = TRUE; - connection->m_oriented = TRUE; + connection->m_server = false; + connection->m_stream = true; /* Setup the peer address field */ connection->m_peer = GAddress_new(); @@ -572,31 +848,86 @@ GSocket *GSocketBSD::WaitConnection() m_error = GSOCK_MEMERR; return NULL; } - err = _GAddress_translate_from(connection->m_peer, &from, fromlen); + + err = _GAddress_translate_from(connection->m_peer, (sockaddr*)&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 ioctl(connection->m_fd, FIONBIO, &arg); #endif - connection->EventLoop_Enable_Events(); + if (m_use_events) + connection->Notify(true); return connection; } +void GSocket::Notify(bool flag) +{ + if (flag == m_use_events) + return; +#if wxUSE_THREADS + // it is not safe to attach or detach i/o descriptor in child thread + wxASSERT_MSG( wxThread::IsMain(), "should be called in main thread only" ); +#endif + m_use_events = flag; + EnableEvents(flag); +} + +void GSocket::EnableEvents(bool flag) +{ + if (flag) + GSocketManager::Get()->Enable_Events(this); + else + GSocketManager::Get()->Disable_Events(this); +} + +bool GSocket::SetReusable() +{ + /* socket must not be null, and must not be in use/already bound */ + if (this && m_fd == INVALID_SOCKET) + { + m_reusable = true; + + return true; + } + + return false; +} + +bool GSocket::SetBroadcast() +{ + /* socket must not be in use/already bound */ + if (m_fd == INVALID_SOCKET) { + m_broadcast = true; + return true; + } + return false; +} + +bool GSocket::DontDoBind() +{ + /* socket must not be in use/already bound */ + if (m_fd == INVALID_SOCKET) { + m_dobind = false; + return true; + } + return false; +} + /* Client specific parts */ /* GSocket_Connect: * 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() @@ -613,9 +944,9 @@ GSocket *GSocketBSD::WaitConnection() * GSOCK_TIMEDOUT - timeout, the connection failed. * GSOCK_WOULDBLOCK - connection in progress (nonblocking sockets only) * GSOCK_MEMERR - couldn't allocate memory. - * GSOCK_IOERR - low-level error. + * GSOCK_IOERR - low-level error. */ -GSocketError GSocketBSD::Connect(GSocketStream stream) +GSocketError GSocket::Connect(GSocketStream stream) { int err, ret; int arg = 1; @@ -639,9 +970,8 @@ GSocketError GSocketBSD::Connect(GSocketStream stream) /* Streamed or dgram socket? */ m_stream = (stream == GSOCK_STREAMED); - m_oriented = TRUE; - m_server = FALSE; - m_establishing = FALSE; + m_server = false; + m_establishing = false; /* Create the socket */ m_fd = socket(m_peer->m_realfamily, @@ -652,16 +982,52 @@ GSocketError GSocketBSD::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(arg)); +#endif + #if defined(__EMX__) || defined(__VISAGECPP__) ioctl(m_fd, FIONBIO, (char*)&arg, sizeof(arg)); #else ioctl(m_fd, FIONBIO, &arg); #endif - EventLoop_Enable_Events(); + + // 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(arg)); +#ifdef SO_REUSEPORT + setsockopt(m_fd, SOL_SOCKET, SO_REUSEPORT, (const char*)&arg, sizeof(arg)); +#endif + } + + if (m_initialRecvBufferSize >= 0) + setsockopt(m_fd, SOL_SOCKET, SO_RCVBUF, (const char*)&m_initialRecvBufferSize, sizeof(m_initialRecvBufferSize)); + if (m_initialSendBufferSize >= 0) + setsockopt(m_fd, SOL_SOCKET, SO_SNDBUF, (const char*)&m_initialSendBufferSize, sizeof(m_initialSendBufferSize)); + + // 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_use_events && (m_non_blocking || ret == 0)) + EnableEvents(); + if (ret == -1) { err = errno; @@ -682,9 +1048,11 @@ GSocketError GSocketBSD::Connect(GSocketStream stream) else { int error; - SOCKLEN_T len = sizeof(error); + SOCKOPTLEN_T len = sizeof(error); - getsockopt(m_fd, SOL_SOCKET, SO_ERROR, (void*) &error, &len); + getsockopt(m_fd, SOL_SOCKET, SO_ERROR, (char*) &error, &len); + if (m_use_events) + EnableEvents(); if (!error) return GSOCK_NOERROR; @@ -699,7 +1067,7 @@ GSocketError GSocketBSD::Connect(GSocketStream stream) */ if ((err == EINPROGRESS) && (m_non_blocking)) { - m_establishing = TRUE; + m_establishing = true; m_error = GSOCK_WOULDBLOCK; return GSOCK_WOULDBLOCK; } @@ -709,6 +1077,7 @@ GSocketError GSocketBSD::Connect(GSocketStream stream) */ Close(); m_error = GSOCK_IOERR; + return GSOCK_IOERR; } @@ -728,7 +1097,7 @@ GSocketError GSocketBSD::Connect(GSocketStream stream) * GSOCK_INVADDR - the local address has not been set. * GSOCK_IOERR - low-level error. */ -GSocketError GSocketBSD::SetNonOriented() +GSocketError GSocket::SetNonOriented() { int arg = 1; @@ -747,9 +1116,8 @@ GSocketError GSocketBSD::SetNonOriented() } /* Initialize all fields */ - m_stream = FALSE; - m_server = FALSE; - m_oriented = FALSE; + m_stream = false; + m_server = false; /* Create the socket */ m_fd = socket(m_local->m_realfamily, SOCK_DGRAM, 0); @@ -764,77 +1132,112 @@ GSocketError GSocketBSD::SetNonOriented() #else ioctl(m_fd, FIONBIO, &arg); #endif - EventLoop_Enable_Events(); + if (m_use_events) + EnableEvents(); - /* Bind to the local address, - * and retrieve the actual address bound. - */ - 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)) + if (m_reusable) { - Close(); - m_error = GSOCK_IOERR; - return GSOCK_IOERR; + setsockopt(m_fd, SOL_SOCKET, SO_REUSEADDR, (const char*)&arg, sizeof(arg)); +#ifdef SO_REUSEPORT + setsockopt(m_fd, SOL_SOCKET, SO_REUSEPORT, (const char*)&arg, sizeof(arg)); +#endif } + if (m_broadcast) + { + setsockopt(m_fd, SOL_SOCKET, SO_BROADCAST, (const char*)&arg, sizeof(arg)); + } + if (m_dobind) + { + /* Bind to the local address, + * and retrieve the actual address bound. + */ + if ((bind(m_fd, m_local->m_addr, m_local->m_len) != 0) || + (getsockname(m_fd, + m_local->m_addr, + (WX_SOCKLEN_T *) &m_local->m_len) != 0)) + { + Close(); + m_error = GSOCK_IOERR; + return GSOCK_IOERR; + } + } return GSOCK_NOERROR; } /* Generic IO */ /* Like recv(), send(), ... */ -int GSocketBSD::Read(char *buffer, int size) +int GSocket::Read(char *buffer, int size) { int ret; assert(this); - /* When using CFSocket we MUST NOT reenable events until we finish reading */ -#ifndef __DARWIN__ - /* Reenable INPUT events */ - Enable(GSOCK_INPUT); -#endif - if (m_fd == INVALID_SOCKET || m_server) { m_error = GSOCK_INVSOCK; return -1; } - /* If the socket is blocking, wait for data (with a timeout) */ - if (Input_Timeout() == GSOCK_TIMEDOUT) - return -1; + /* Disable events during query of socket status */ + Disable(GSOCK_INPUT); - /* Read the data */ - if (m_stream) - ret = Recv_Stream(buffer, size); + /* If the socket is blocking, wait for data (with a timeout) */ + 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 - ret = Recv_Dgram(buffer, size); - - if (ret == -1) { - if (errno == EWOULDBLOCK) - m_error = GSOCK_WOULDBLOCK; + /* Read the data */ + if (m_stream) + ret = Recv_Stream(buffer, size); else - m_error = GSOCK_IOERR; + ret = Recv_Dgram(buffer, size); + + /* + * If recv returned zero for a TCP socket (if m_stream == NULL, it's an UDP + * socket and empty datagrams are possible), then the connection has been + * gracefully closed. + * + * 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_stream) + { + /* Make sure wxSOCKET_LOST event gets sent and shut down the socket */ + if (m_use_events) + { + m_detected = GSOCK_LOST_FLAG; + Detected_Read(); + return 0; + } + } + else if (ret == -1) + { + if ((errno == EWOULDBLOCK) || (errno == EAGAIN)) + m_error = GSOCK_WOULDBLOCK; + else + m_error = GSOCK_IOERR; + } } - -#ifdef __DARWIN__ - /* Reenable INPUT events */ + + /* Enable events again now that we are done processing */ Enable(GSOCK_INPUT); -#endif return ret; } -int GSocketBSD::Write(const char *buffer, int size) -{ +int GSocket::Write(const char *buffer, int size) +{ int ret; assert(this); - + GSocket_Debug(( "GSocket_Write #1, size %d\n", size )); if (m_fd == INVALID_SOCKET || m_server) @@ -856,12 +1259,12 @@ int GSocketBSD::Write(const char *buffer, int size) ret = Send_Stream(buffer, size); else ret = Send_Dgram(buffer, size); - + GSocket_Debug(( "GSocket_Write #4, size %d\n", size )); if (ret == -1) { - if (errno == EWOULDBLOCK) + if ((errno == EWOULDBLOCK) || (errno == EAGAIN)) { m_error = GSOCK_WOULDBLOCK; GSocket_Debug(( "GSocket_Write error WOULDBLOCK\n" )); @@ -878,9 +1281,10 @@ int GSocketBSD::Write(const char *buffer, int size) * will further OUTPUT events be posted. */ Enable(GSOCK_OUTPUT); + return -1; } - + GSocket_Debug(( "GSocket_Write #5, size %d ret %d\n", size, ret )); return ret; @@ -893,129 +1297,103 @@ int GSocketBSD::Write(const char *buffer, int size) * performed. This function won't block, regardless of the * mode (blocking | nonblocking) of the socket. */ -GSocketEventFlags GSocketBSD::Select(GSocketEventFlags flags) +GSocketEventFlags GSocket::Select(GSocketEventFlags flags) { - if (!GSocketBSDGUIShim::UseGUI()) - { + assert(this); - GSocketEventFlags result = 0; - fd_set readfds; - fd_set writefds; - fd_set exceptfds; - struct timeval tv; + GSocketEventFlags result = 0; + fd_set readfds; + fd_set writefds; + fd_set exceptfds; + struct timeval tv; - /* Do not use a static struct, Linux can garble it */ - tv.tv_sec = m_timeout / 1000; - tv.tv_usec = (m_timeout % 1000) / 1000; + if (m_fd == -1) + return (GSOCK_LOST_FLAG & flags); - assert(this); + /* Do not use a static struct, Linux can garble it */ + tv.tv_sec = 0; + tv.tv_usec = 0; - FD_ZERO(&readfds); - FD_ZERO(&writefds); - FD_ZERO(&exceptfds); - FD_SET(m_fd, &readfds); - if (flags & GSOCK_OUTPUT_FLAG) - FD_SET(m_fd, &writefds); - FD_SET(m_fd, &exceptfds); + wxFD_ZERO(&readfds); + wxFD_ZERO(&writefds); + wxFD_ZERO(&exceptfds); + wxFD_SET(m_fd, &readfds); + if (flags & GSOCK_OUTPUT_FLAG || flags & GSOCK_CONNECTION_FLAG) + wxFD_SET(m_fd, &writefds); + wxFD_SET(m_fd, &exceptfds); - /* Check 'sticky' CONNECTION flag first */ - result |= (GSOCK_CONNECTION_FLAG & m_detected); + /* Check 'sticky' CONNECTION flag first */ + result |= GSOCK_CONNECTION_FLAG & m_detected; - /* If we have already detected a LOST event, then don't try - * to do any further processing. - */ - if ((m_detected & GSOCK_LOST_FLAG) != 0) - { - m_establishing = FALSE; + /* If we have already detected a LOST event, then don't try + * to do any further processing. + */ + if ((m_detected & GSOCK_LOST_FLAG) != 0) + { + m_establishing = false; + return (GSOCK_LOST_FLAG & flags); + } - return (GSOCK_LOST_FLAG & flags); - } + /* Try select now */ + if (select(m_fd + 1, &readfds, &writefds, &exceptfds, &tv) < 0) + { + /* What to do here? */ + return (result & flags); + } - /* Try select now */ - if (select(m_fd + 1, &readfds, &writefds, &exceptfds, &tv) <= 0) - { - /* What to do here? */ - return (result & flags); - } + /* Check for exceptions and errors */ + if (wxFD_ISSET(m_fd, &exceptfds)) + { + m_establishing = false; + m_detected = GSOCK_LOST_FLAG; - /* Check for readability */ - if (FD_ISSET(m_fd, &readfds)) - { - char c; + /* LOST event: Abort any further processing */ + return (GSOCK_LOST_FLAG & flags); + } - if (recv(m_fd, &c, 1, MSG_PEEK) > 0) - { - 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); - } - } - } + /* Check for readability */ + if (wxFD_ISSET(m_fd, &readfds)) + { + result |= GSOCK_INPUT_FLAG; - /* Check for writability */ - if (FD_ISSET(m_fd, &writefds)) + if (m_server && m_stream) { - if (m_establishing && !m_server) - { - int error; - SOCKLEN_T len = sizeof(error); - - m_establishing = FALSE; + /* 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. */ + m_detected |= GSOCK_CONNECTION_FLAG; + } + } - getsockopt(m_fd, SOL_SOCKET, SO_ERROR, (void*)&error, &len); + /* Check for writability */ + if (wxFD_ISSET(m_fd, &writefds)) + { + if (m_establishing && !m_server) + { + int error; + SOCKOPTLEN_T len = sizeof(error); + m_establishing = false; + getsockopt(m_fd, SOL_SOCKET, SO_ERROR, (char*)&error, &len); - if (error) - { - m_detected = GSOCK_LOST_FLAG; + if (error) + { + m_detected = GSOCK_LOST_FLAG; - /* LOST event: Abort any further processing */ - return (GSOCK_LOST_FLAG & flags); - } - else - { - result |= GSOCK_CONNECTION_FLAG; - m_detected |= GSOCK_CONNECTION_FLAG; - } + /* LOST event: Abort any further processing */ + return (GSOCK_LOST_FLAG & flags); } else { - result |= GSOCK_OUTPUT_FLAG; + m_detected |= GSOCK_CONNECTION_FLAG; } } - - /* Check for exceptions and errors (is this useful in Unices?) */ - if (FD_ISSET(m_fd, &exceptfds)) + else { - m_establishing = FALSE; - m_detected = GSOCK_LOST_FLAG; - - /* LOST event: Abort any further processing */ - return (GSOCK_LOST_FLAG & flags); + result |= GSOCK_OUTPUT_FLAG; } - - return (result & flags); - } - else - { - assert(this); - return flags & m_detected; - - } + return (result | m_detected) & flags; } /* Flags */ @@ -1024,7 +1402,7 @@ GSocketEventFlags GSocketBSD::Select(GSocketEventFlags flags) * Sets the socket to non-blocking mode. All IO calls will return * immediately. */ -void GSocketBSD::SetNonBlocking(int non_block) +void GSocket::SetNonBlocking(bool non_block) { assert(this); @@ -1037,7 +1415,7 @@ void GSocketBSD::SetNonBlocking(int non_block) * Sets the timeout for blocking calls. Time is expressed in * milliseconds. */ -void GSocketBSD::SetTimeout(unsigned long millisec) +void GSocket::SetTimeout(unsigned long millisec) { assert(this); @@ -1045,11 +1423,11 @@ void GSocketBSD::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. */ -GSocketError GSocketBSD::GetError() +GSocketError WXDLLIMPEXP_NET GSocket::GetError() { assert(this); @@ -1063,14 +1441,14 @@ GSocketError GSocketBSD::GetError() * operation, there is still data available, the callback function will * be called again. * GSOCK_OUTPUT: - * The socket is available for writing. That is, the next write call + * The socket is available for writing. That is, the next write call * won't block. This event is generated only once, when the connection is * first established, and then only if a call failed with GSOCK_WOULDBLOCK, * when the output buffer empties again. This means that the app should * 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: @@ -1086,7 +1464,7 @@ GSocketError GSocketBSD::GetError() * * void function(GSocket *socket, GSocketEvent event, char *cdata) */ -void GSocketBSD::SetCallback(GSocketEventFlags flags, +void GSocket::SetCallback(GSocketEventFlags flags, GSocketCallback callback, char *cdata) { int count; @@ -1107,7 +1485,7 @@ void GSocketBSD::SetCallback(GSocketEventFlags flags, * Disables all callbacks specified by 'flags', which may be a * combination of flags OR'ed toghether. */ -void GSocketBSD::UnsetCallback(GSocketEventFlags flags) +void GSocket::UnsetCallback(GSocketEventFlags flags) { int count; @@ -1123,31 +1501,54 @@ void GSocketBSD::UnsetCallback(GSocketEventFlags flags) } } +GSocketError GSocket::GetSockOpt(int level, int optname, + void *optval, int *optlen) +{ + if (getsockopt(m_fd, level, optname, (char*)optval, (SOCKOPTLEN_T*)optlen) == 0) + return GSOCK_NOERROR; -#define CALL_CALLBACK(event) { \ - Disable(event); \ - if (m_cbacks[event]) \ - m_cbacks[event](this, event, m_data[event]); \ + return GSOCK_OPTERR; } +GSocketError GSocket::SetSockOpt(int level, int optname, + const void *optval, int optlen) +{ + if (setsockopt(m_fd, level, optname, (const char*)optval, optlen) == 0) + return GSOCK_NOERROR; -void GSocketBSD::Enable(GSocketEvent event) + return GSOCK_OPTERR; +} + +#define CALL_CALLBACK(socket, event) { \ + socket->Disable(event); \ + if (socket->m_cbacks[event]) \ + socket->m_cbacks[event](socket, event, socket->m_data[event]); \ +} + + +void GSocket::Enable(GSocketEvent event) { - m_detected &= ~(1 << event); - EventLoop_Install_Callback(event); + if (m_use_events) + { + m_detected &= ~(1 << event); + GSocketManager::Get()->Install_Callback(this, event); + } } -void GSocketBSD::Disable(GSocketEvent event) +void GSocket::Disable(GSocketEvent event) { - m_detected |= (1 << event); - EventLoop_Uninstall_Callback(event); + if (m_use_events) + { + m_detected |= (1 << event); + GSocketManager::Get()->Uninstall_Callback(this, event); + } } /* _GSocket_Input_Timeout: * For blocking sockets, wait until data is available or * until timeout ellapses. */ -GSocketError GSocketBSD::Input_Timeout() +GSocketError GSocket::Input_Timeout() { struct timeval tv; fd_set readfds; @@ -1159,8 +1560,8 @@ GSocketError GSocketBSD::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) { @@ -1168,6 +1569,7 @@ GSocketError GSocketBSD::Input_Timeout() m_error = GSOCK_TIMEDOUT; return GSOCK_TIMEDOUT; } + if (ret == -1) { GSocket_Debug(( "GSocket_Input_Timeout, select returned -1\n" )); @@ -1179,6 +1581,7 @@ GSocketError GSocketBSD::Input_Timeout() return GSOCK_TIMEDOUT; } } + return GSOCK_NOERROR; } @@ -1186,7 +1589,7 @@ GSocketError GSocketBSD::Input_Timeout() * For blocking sockets, wait until data can be sent without * blocking or until timeout ellapses. */ -GSocketError GSocketBSD::Output_Timeout() +GSocketError GSocket::Output_Timeout() { struct timeval tv; fd_set writefds; @@ -1200,8 +1603,8 @@ GSocketError GSocketBSD::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) { @@ -1209,6 +1612,7 @@ GSocketError GSocketBSD::Output_Timeout() m_error = GSOCK_TIMEDOUT; return GSOCK_TIMEDOUT; } + if (ret == -1) { GSocket_Debug(( "GSocket_Output_Timeout, select returned -1\n" )); @@ -1219,10 +1623,13 @@ GSocketError GSocketBSD::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" )); } } @@ -1234,21 +1641,32 @@ GSocketError GSocketBSD::Output_Timeout() return GSOCK_NOERROR; } -int GSocketBSD::Recv_Stream(char *buffer, int size) +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 GSocketBSD::Recv_Dgram(char *buffer, int size) +int GSocket::Recv_Dgram(char *buffer, int size) { - struct sockaddr from; - SOCKLEN_T fromlen = sizeof(from); + wxSockAddr 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, (sockaddr*)&from, (WX_SOCKLEN_T *) &fromlen); + } + while (ret == -1 && errno == EINTR); /* Loop until not interrupted */ if (ret == -1) return -1; @@ -1263,7 +1681,8 @@ int GSocketBSD::Recv_Dgram(char *buffer, int size) return -1; } } - err = _GAddress_translate_from(m_peer, &from, fromlen); + + err = _GAddress_translate_from(m_peer, (sockaddr*)&from, fromlen); if (err != GSOCK_NOERROR) { GAddress_destroy(m_peer); @@ -1275,22 +1694,24 @@ int GSocketBSD::Recv_Dgram(char *buffer, int size) return ret; } -int GSocketBSD::Send_Stream(const char *buffer, int size) +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; } -int GSocketBSD::Send_Dgram(const char *buffer, int size) +int GSocket::Send_Dgram(const char *buffer, int size) { struct sockaddr *addr; int len, ret; @@ -1309,13 +1730,15 @@ int GSocketBSD::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); @@ -1323,50 +1746,80 @@ int GSocketBSD::Send_Dgram(const char *buffer, int size) return ret; } -void GSocketBSD::Detected_Read() +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. */ if ((m_detected & GSOCK_LOST_FLAG) != 0) { - m_establishing = FALSE; + m_establishing = false; - CALL_CALLBACK(GSOCK_LOST); + CALL_CALLBACK(this, GSOCK_LOST); Shutdown(); 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(GSOCK_INPUT); + CALL_CALLBACK(this, GSOCK_INPUT); } else { if (m_server && m_stream) { - CALL_CALLBACK(GSOCK_CONNECTION); + CALL_CALLBACK(this, GSOCK_CONNECTION); + } + else if (num == 0) + { + if (m_stream) + { + /* graceful shutdown */ + CALL_CALLBACK(this, GSOCK_LOST); + Shutdown(); + } + else + { + /* Empty datagram received */ + CALL_CALLBACK(this, GSOCK_INPUT); + } } else { - CALL_CALLBACK(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(); + } } } } -void GSocketBSD::Detected_Write() +void GSocket::Detected_Write() { /* If we have already detected a LOST event, then don't try * to do any further processing. */ if ((m_detected & GSOCK_LOST_FLAG) != 0) { - m_establishing = FALSE; + m_establishing = false; - CALL_CALLBACK(GSOCK_LOST); + CALL_CALLBACK(this, GSOCK_LOST); Shutdown(); return; } @@ -1374,60 +1827,45 @@ void GSocketBSD::Detected_Write() if (m_establishing && !m_server) { int error; - SOCKLEN_T len = sizeof(error); + SOCKOPTLEN_T len = sizeof(error); - m_establishing = FALSE; + 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) { - CALL_CALLBACK(GSOCK_LOST); + CALL_CALLBACK(this, GSOCK_LOST); Shutdown(); } else { - CALL_CALLBACK(GSOCK_CONNECTION); + CALL_CALLBACK(this, GSOCK_CONNECTION); /* We have to fire this event by hand because CONNECTION (for clients) * and OUTPUT are internally the same and we just disabled CONNECTION * events with the above macro. */ - CALL_CALLBACK(GSOCK_OUTPUT); + CALL_CALLBACK(this, GSOCK_OUTPUT); } } else { - CALL_CALLBACK(GSOCK_OUTPUT); + CALL_CALLBACK(this, GSOCK_OUTPUT); } } /* Compatibility functions for GSocket */ GSocket *GSocket_new(void) { - GSocket *newsocket = wxTheApp->GetTraits()->CreateGSocket(); - if(newsocket->IsOk()) + GSocket *newsocket = new GSocket(); + if (newsocket->IsOk()) return newsocket; - delete newsocket; - return NULL; -} - -void GSocket_destroy(GSocket *socket) -{ - assert(socket); - /* Check that the socket is really shutdowned */ - if (socket->m_fd != INVALID_SOCKET) - socket->Shutdown(); + delete newsocket; - delete socket; + return NULL; } -void GSocketBSD::_GSocket_Detected_Read(GSocket *socket) -{ socket->Detected_Read(); } - -void GSocketBSD::_GSocket_Detected_Write(GSocket *socket) -{ socket->Detected_Write(); } - /* * ------------------------------------------------------------------------- * GAddress @@ -1541,11 +1979,11 @@ GSocketError _GAddress_translate_from(GAddress *address, case AF_UNIX: address->m_family = GSOCK_UNIX; break; -#ifdef AF_INET6 +#if wxUSE_IPV6 case AF_INET6: address->m_family = GSOCK_INET6; break; -#endif +#endif // wxUSE_IPV6 default: { address->m_error = GSOCK_INVOP; @@ -1564,6 +2002,7 @@ GSocketError _GAddress_translate_from(GAddress *address, address->m_error = GSOCK_MEMERR; return GSOCK_MEMERR; } + memcpy(address->m_addr, addr, len); return GSOCK_NOERROR; @@ -1630,30 +2069,48 @@ 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 */ - int val = 1; //VA doesn't like constants in conditional expressions at all +#ifndef __WXMAC__ + int val = 1; /* VA doesn't like constants in conditional expressions */ if (val) +#endif { #endif 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; } + +GSocketError GAddress_INET_SetBroadcastAddress(GAddress *address) +{ + return GAddress_INET_SetHostAddress(address, INADDR_BROADCAST); +} + GSocketError GAddress_INET_SetAnyAddress(GAddress *address) { return GAddress_INET_SetHostAddress(address, INADDR_ANY); @@ -1669,7 +2126,7 @@ GSocketError GAddress_INET_SetHostAddress(GAddress *address, CHECK_ADDRESS(address, INET); addr = &(((struct sockaddr_in *)address->m_addr)->sin_addr); - addr->s_addr = hostaddr; + addr->s_addr = htonl(hostaddr); return GSOCK_NOERROR; } @@ -1688,8 +2145,15 @@ GSocketError GAddress_INET_SetPortName(GAddress *address, const char *port, address->m_error = GSOCK_INVPORT; 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 @@ -1720,7 +2184,7 @@ GSocketError GAddress_INET_SetPort(GAddress *address, unsigned short port) assert(address != NULL); CHECK_ADDRESS(address, INET); - + addr = (struct sockaddr_in *)address->m_addr; addr->sin_port = htons(port); @@ -1733,13 +2197,21 @@ GSocketError GAddress_INET_GetHostName(GAddress *address, char *hostname, size_t char *addr_buf; struct sockaddr_in *addr; - assert(address != NULL); + assert(address != NULL); CHECK_ADDRESS(address, INET); 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; @@ -1755,25 +2227,188 @@ unsigned long GAddress_INET_GetHostAddress(GAddress *address) { struct sockaddr_in *addr; - assert(address != NULL); - CHECK_ADDRESS_RETVAL(address, INET, 0); + assert(address != NULL); + CHECK_ADDRESS_RETVAL(address, INET, 0); addr = (struct sockaddr_in *)address->m_addr; - return addr->sin_addr.s_addr; + return ntohl(addr->sin_addr.s_addr); } unsigned short GAddress_INET_GetPort(GAddress *address) { struct sockaddr_in *addr; - assert(address != NULL); - CHECK_ADDRESS_RETVAL(address, INET, 0); + assert(address != NULL); + CHECK_ADDRESS_RETVAL(address, INET, 0); addr = (struct sockaddr_in *)address->m_addr; return ntohs(addr->sin_port); } +#if wxUSE_IPV6 +/* + * ------------------------------------------------------------------------- + * Internet IPv6 address family + * ------------------------------------------------------------------------- + */ + +GSocketError _GAddress_Init_INET6(GAddress *address) +{ + struct in6_addr any_address = IN6ADDR_ANY_INIT; + address->m_len = sizeof(struct sockaddr_in6); + address->m_addr = (struct sockaddr *) malloc(address->m_len); + if (address->m_addr == NULL) + { + address->m_error = GSOCK_MEMERR; + return GSOCK_MEMERR; + } + memset(address->m_addr,0,address->m_len); + + address->m_family = GSOCK_INET6; + address->m_realfamily = AF_INET6; + ((struct sockaddr_in6 *)address->m_addr)->sin6_family = AF_INET6; + ((struct sockaddr_in6 *)address->m_addr)->sin6_addr = any_address; + + return GSOCK_NOERROR; +} + +GSocketError GAddress_INET6_SetHostName(GAddress *address, const char *hostname) +{ + assert(address != NULL); + CHECK_ADDRESS(address, INET6); + + addrinfo hints; + memset( & hints, 0, sizeof( hints ) ); + hints.ai_family = AF_INET6; + addrinfo * info = 0; + if ( getaddrinfo( hostname, "0", & hints, & info ) || ! info ) + { + address->m_error = GSOCK_NOHOST; + return GSOCK_NOHOST; + } + + memcpy( address->m_addr, info->ai_addr, info->ai_addrlen ); + freeaddrinfo( info ); + return GSOCK_NOERROR; +} + +GSocketError GAddress_INET6_SetAnyAddress(GAddress *address) +{ + assert(address != NULL); + + CHECK_ADDRESS(address, INET6); + + struct in6_addr addr; + memset( & addr, 0, sizeof( addr ) ); + return GAddress_INET6_SetHostAddress(address, addr); +} +GSocketError GAddress_INET6_SetHostAddress(GAddress *address, + struct in6_addr hostaddr) +{ + assert(address != NULL); + + CHECK_ADDRESS(address, INET6); + + ((struct sockaddr_in6 *)address->m_addr)->sin6_addr = hostaddr; + + return GSOCK_NOERROR; +} + +GSocketError GAddress_INET6_SetPortName(GAddress *address, const char *port, + const char *protocol) +{ + struct servent *se; + struct sockaddr_in6 *addr; + + assert(address != NULL); + CHECK_ADDRESS(address, INET6); + + if (!port) + { + address->m_error = GSOCK_INVPORT; + return GSOCK_INVPORT; + } + + se = getservbyname(port, protocol); + if (!se) + { + if (isdigit(port[0])) + { + int port_int; + + port_int = atoi(port); + addr = (struct sockaddr_in6 *)address->m_addr; + addr->sin6_port = htons((u_short) port_int); + return GSOCK_NOERROR; + } + + address->m_error = GSOCK_INVPORT; + return GSOCK_INVPORT; + } + + addr = (struct sockaddr_in6 *)address->m_addr; + addr->sin6_port = se->s_port; + + return GSOCK_NOERROR; +} + +GSocketError GAddress_INET6_SetPort(GAddress *address, unsigned short port) +{ + struct sockaddr_in6 *addr; + + assert(address != NULL); + CHECK_ADDRESS(address, INET6); + + addr = (struct sockaddr_in6 *)address->m_addr; + addr->sin6_port = htons(port); + + return GSOCK_NOERROR; +} + +GSocketError GAddress_INET6_GetHostName(GAddress *address, char *hostname, size_t sbuf) +{ + struct hostent *he; + char *addr_buf; + struct sockaddr_in6 *addr; + + assert(address != NULL); + CHECK_ADDRESS(address, INET6); + + addr = (struct sockaddr_in6 *)address->m_addr; + addr_buf = (char *)&(addr->sin6_addr); + + he = gethostbyaddr(addr_buf, sizeof(addr->sin6_addr), AF_INET6); + if (he == NULL) + { + address->m_error = GSOCK_NOHOST; + return GSOCK_NOHOST; + } + + strncpy(hostname, he->h_name, sbuf); + + return GSOCK_NOERROR; +} + +GSocketError GAddress_INET6_GetHostAddress(GAddress *address,struct in6_addr *hostaddr) +{ + assert(address != NULL); + assert(hostaddr != NULL); + CHECK_ADDRESS_RETVAL(address, INET6, GSOCK_INVADDR); + *hostaddr = ( (struct sockaddr_in6 *)address->m_addr )->sin6_addr; + return GSOCK_NOERROR; +} + +unsigned short GAddress_INET6_GetPort(GAddress *address) +{ + assert(address != NULL); + CHECK_ADDRESS_RETVAL(address, INET6, 0); + + return ntohs( ((struct sockaddr_in6 *)address->m_addr)->sin6_port ); +} + +#endif // wxUSE_IPV6 + /* * ------------------------------------------------------------------------- * Unix address family @@ -1805,9 +2440,9 @@ GSocketError GAddress_UNIX_SetPath(GAddress *address, const char *path) { struct sockaddr_un *addr; - assert(address != NULL); + assert(address != NULL); - CHECK_ADDRESS(address, UNIX); + CHECK_ADDRESS(address, UNIX); addr = ((struct sockaddr_un *)address->m_addr); strncpy(addr->sun_path, path, UNIX_SOCK_PATHLEN); @@ -1831,4 +2466,3 @@ GSocketError GAddress_UNIX_GetPath(GAddress *address, char *path, size_t sbuf) } #endif /* !defined(__VISAGECPP__) */ #endif /* wxUSE_SOCKETS || defined(__GSOCKET_STANDALONE__) */ -