X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/9d71596027d122c937c93983c0c718dada60f797..106d80ad373817594dba9aeacef76b663eda2d0b:/src/unix/gsocket.cpp diff --git a/src/unix/gsocket.cpp b/src/unix/gsocket.cpp index 89dbef4603..bf8c5bc7a3 100644 --- a/src/unix/gsocket.cpp +++ b/src/unix/gsocket.cpp @@ -1,20 +1,24 @@ /* ------------------------------------------------------------------------- - * 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$ * ------------------------------------------------------------------------- */ -#include "wx/wxprec.h" -#ifndef WX_PRECOMP - #include "wx/app.h" - #include "wx/apptrait.h" -#endif //ndef WX_PRECOMP +/* + * PLEASE don't put C++ comments here - this is a C source file. + */ + +#ifndef __GSOCKET_STANDALONE__ +#include "wx/setup.h" +#endif #if defined(__VISAGECPP__) /* Seems to be needed by Visual Age C++, though I don't see how it manages @@ -85,6 +89,10 @@ int _System bsdselect(int, int _System soclose(int); # endif #endif +#ifdef __EMX__ +#include +#endif + #include #include #include @@ -95,6 +103,9 @@ int _System soclose(int); #ifdef sgi # include #endif +#ifdef _AIX +# include +#endif #include #ifndef SOCKLEN_T @@ -106,6 +117,8 @@ int _System soclose(int); # if __GLIBC__ == 2 # define SOCKLEN_T socklen_t # endif +# elif defined(__WXMAC__) +# define SOCKLEN_T socklen_t # else # define SOCKLEN_T int # endif @@ -113,6 +126,10 @@ int _System soclose(int); #endif /* SOCKLEN_T */ +#ifndef SOCKOPTLEN_T +#define SOCKOPTLEN_T SOCKLEN_T +#endif + /* * MSW defines this, Unices don't. */ @@ -143,6 +160,15 @@ int _System soclose(int); signal(SIGPIPE, old_handler); \ } +/* 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" @@ -159,82 +185,73 @@ int _System soclose(int); # define GSocket_Debug(args) #endif /* __GSOCKET_DEBUG__ */ -/////////////////////////////////////////////////////////////////////////// -// GSocketBSDGUIShim -struct GSocketGUIFunctionsTable *GSocketBSDGUIShim::ms_gui_functions = NULL; +/* Table of GUI-related functions. We must call them indirectly because + * of wxBase and GUI separation: */ -void GSocket_SetGUIFunctions(struct GSocketGUIFunctionsTable *guifunc) -{ - GSocketBSDGUIShim::ms_gui_functions = guifunc; -} - -inline bool GSocketBSDGUIShim::UseGUI() -{ - return ms_gui_functions; -} - -inline bool GSocketBSDGUIShim::GUI_Init() -{ - return (ms_gui_functions)?ms_gui_functions->GUI_Init():true; -} +static GSocketGUIFunctionsTable *gs_gui_functions; -inline void GSocketBSDGUIShim::GUI_Cleanup() +class GSocketGUIFunctionsTableNull: public GSocketGUIFunctionsTable { - if (ms_gui_functions) ms_gui_functions->GUI_Cleanup(); -} - -GSocketBSDGUIShim::GSocketBSDGUIShim() -{ - m_ok = (ms_gui_functions ? ms_gui_functions->GUI_Init_Socket(this) : true); -} - -GSocketBSDGUIShim::~GSocketBSDGUIShim() -{ - if (ms_gui_functions) ms_gui_functions->GUI_Destroy_Socket(this); -} - -void GSocketBSDGUIShim::EventLoop_Enable_Events() -{ - if (ms_gui_functions) ms_gui_functions->Enable_Events(this); -} - -void GSocketBSDGUIShim::EventLoop_Disable_Events() -{ - if (ms_gui_functions) ms_gui_functions->Disable_Events(this); -} +public: + virtual bool OnInit(); + virtual void OnExit(); + virtual bool CanUseEventLoop(); + virtual bool Init_Socket(GSocket *socket); + virtual void Destroy_Socket(GSocket *socket); + virtual void Install_Callback(GSocket *socket, GSocketEvent event); + virtual void Uninstall_Callback(GSocket *socket, GSocketEvent event); + virtual void Enable_Events(GSocket *socket); + virtual void Disable_Events(GSocket *socket); +}; -void GSocketBSDGUIShim::EventLoop_Install_Callback(GSocketEvent event) -{ - if (ms_gui_functions) ms_gui_functions->Install_Callback(this, event); -} +bool GSocketGUIFunctionsTableNull::OnInit() +{ return true; } +void GSocketGUIFunctionsTableNull::OnExit() +{} +bool GSocketGUIFunctionsTableNull::CanUseEventLoop() +{ return false; } +bool GSocketGUIFunctionsTableNull::Init_Socket(GSocket *socket) +{ return true; } +void GSocketGUIFunctionsTableNull::Destroy_Socket(GSocket *socket) +{} +void GSocketGUIFunctionsTableNull::Install_Callback(GSocket *socket, GSocketEvent event) +{} +void GSocketGUIFunctionsTableNull::Uninstall_Callback(GSocket *socket, GSocketEvent event) +{} +void GSocketGUIFunctionsTableNull::Enable_Events(GSocket *socket) +{} +void GSocketGUIFunctionsTableNull::Disable_Events(GSocket *socket) +{} +/* Global initialisers */ -void GSocketBSDGUIShim::EventLoop_Uninstall_Callback(GSocketEvent event) +void GSocket_SetGUIFunctions(GSocketGUIFunctionsTable *guifunc) { - if (ms_gui_functions) ms_gui_functions->Uninstall_Callback(this, event); + gs_gui_functions = guifunc; } -/////////////////////////////////////////////////////////////////////////// -// GSocketBSD - -static struct GSocketBaseFunctionsTable gs_base_functions = -{ - GSocketBSD::_GSocket_Detected_Read, - GSocketBSD::_GSocket_Detected_Write -}; - -/* Global initialisers */ - int GSocket_Init(void) { - return GSocketBSDGUIShim::GUI_Init(); + if (!gs_gui_functions) + { + static GSocketGUIFunctionsTableNull table; + gs_gui_functions = &table; + } + if ( !gs_gui_functions->OnInit() ) + return 0; + return 1; } void GSocket_Cleanup(void) { - GSocketBSDGUIShim::GUI_Cleanup(); + if (gs_gui_functions) + { + gs_gui_functions->OnExit(); + } } -GSocketBSD::GSocketBSD() +/* Constructors / Destructors for GSocket */ + +GSocket::GSocket() { int i; @@ -247,31 +264,41 @@ GSocketBSD::GSocketBSD() m_local = NULL; m_peer = NULL; m_error = GSOCK_NOERROR; - m_server = FALSE; - m_stream = TRUE; + m_server = false; + m_stream = true; m_gui_dependent = NULL; - m_non_blocking = FALSE; + m_non_blocking = false; + m_reusable = false; m_timeout = 10*60*1000; /* 10 minutes * 60 sec * 1000 millisec */ - m_establishing = FALSE; - - m_functions = &gs_base_functions; + m_establishing = false; - m_ok = true; + assert(gs_gui_functions); + /* Per-socket GUI-specific initialization */ + m_ok = gs_gui_functions->Init_Socket(this); } -void GSocketBSD::Close() +void GSocket::Close() { - EventLoop_Disable_Events(); -// gsockosx.c calls CFSocketInvalidate which closes the socket for us + gs_gui_functions->Disable_Events(this); + /* gsockosx.c calls CFSocketInvalidate which closes the socket for us */ #if !(defined(__DARWIN__) && (defined(__WXMAC__) || defined(__WXCOCOA__))) close(m_fd); #endif m_fd = INVALID_SOCKET; } -GSocketBSD::~GSocketBSD() +GSocket::~GSocket() { + assert(this); + + /* Check that the socket is really shutdowned */ + if (m_fd != INVALID_SOCKET) + Shutdown(); + + /* Per-socket GUI-specific cleanup */ + gs_gui_functions->Destroy_Socket(this); + /* Destroy private addresses */ if (m_local) GAddress_destroy(m_local); @@ -284,7 +311,7 @@ GSocketBSD::~GSocketBSD() * Disallow further read/write operations on this socket, close * the fd and disable all callbacks. */ -void GSocketBSD::Shutdown() +void GSocket::Shutdown() { int evt; @@ -320,7 +347,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 +373,7 @@ GSocketError GSocketBSD::SetLocal(GAddress *address) return GSOCK_NOERROR; } -GSocketError GSocketBSD::SetPeer(GAddress *address) +GSocketError GSocket::SetPeer(GAddress *address) { assert(this); @@ -365,7 +392,7 @@ GSocketError GSocketBSD::SetPeer(GAddress *address) return GSOCK_NOERROR; } -GAddress *GSocketBSD::GetLocal() +GAddress *GSocket::GetLocal() { GAddress *address; struct sockaddr addr; @@ -410,7 +437,7 @@ GAddress *GSocketBSD::GetLocal() return address; } -GAddress *GSocketBSD::GetPeer() +GAddress *GSocket::GetPeer() { assert(this); @@ -427,13 +454,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 +481,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 +492,20 @@ 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(u_long)); #endif - EventLoop_Enable_Events(); + + 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. */ - 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(u_long)); /* Bind to the local address, * retrieve the actual address bound, @@ -506,9 +535,9 @@ 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); @@ -518,9 +547,6 @@ GSocket *GSocketBSD::WaitConnection() 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 +559,6 @@ GSocket *GSocketBSD::WaitConnection() if (!connection) { - delete connection; m_error = GSOCK_MEMERR; return NULL; } @@ -548,6 +573,9 @@ GSocket *GSocketBSD::WaitConnection() connection->m_fd = accept(m_fd, &from, (SOCKLEN_T *) &fromlen); + /* Reenable CONNECTION events */ + Enable(GSOCK_CONNECTION); + if (connection->m_fd == INVALID_SOCKET) { if (errno == EWOULDBLOCK) @@ -560,9 +588,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(); @@ -575,7 +602,6 @@ GSocket *GSocketBSD::WaitConnection() 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; @@ -585,11 +611,21 @@ GSocket *GSocketBSD::WaitConnection() #else ioctl(connection->m_fd, FIONBIO, &arg); #endif - connection->EventLoop_Enable_Events(); + gs_gui_functions->Enable_Events(connection); return connection; } +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; +} + /* Client specific parts */ /* GSocket_Connect: @@ -613,9 +649,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 +675,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 +687,28 @@ 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(u_long)); +#endif + #if defined(__EMX__) || defined(__VISAGECPP__) ioctl(m_fd, FIONBIO, (char*)&arg, sizeof(arg)); #else ioctl(m_fd, FIONBIO, &arg); #endif - EventLoop_Enable_Events(); /* 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 e aren't shutting down the socket */ + + if (m_non_blocking) + { + gs_gui_functions->Enable_Events(this); + } + if (ret == -1) { err = errno; @@ -682,9 +729,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, (char*) &error, &len); - getsockopt(m_fd, SOL_SOCKET, SO_ERROR, (void*) &error, &len); + gs_gui_functions->Enable_Events(this); if (!error) return GSOCK_NOERROR; @@ -699,7 +748,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; } @@ -728,7 +777,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 +796,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,7 +812,7 @@ GSocketError GSocketBSD::SetNonOriented() #else ioctl(m_fd, FIONBIO, &arg); #endif - EventLoop_Enable_Events(); + gs_gui_functions->Enable_Events(this); /* Bind to the local address, * and retrieve the actual address bound. @@ -785,7 +833,7 @@ GSocketError GSocketBSD::SetNonOriented() /* Generic IO */ /* Like recv(), send(), ... */ -int GSocketBSD::Read(char *buffer, int size) +int GSocket::Read(char *buffer, int size) { int ret; @@ -799,7 +847,7 @@ int GSocketBSD::Read(char *buffer, int size) /* Disable events during query of socket status */ 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! */ @@ -811,27 +859,27 @@ int GSocketBSD::Read(char *buffer, int size) else ret = Recv_Dgram(buffer, size); } - + if (ret == -1) { - if (errno == EWOULDBLOCK) + if ((errno == EWOULDBLOCK) || (errno == EAGAIN)) m_error = GSOCK_WOULDBLOCK; else m_error = GSOCK_IOERR; } - + /* Enable events again now that we are done processing */ Enable(GSOCK_INPUT); 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) @@ -853,12 +901,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" )); @@ -877,7 +925,7 @@ int GSocketBSD::Write(const char *buffer, int size) Enable(GSOCK_OUTPUT); return -1; } - + GSocket_Debug(( "GSocket_Write #5, size %d ret %d\n", size, ret )); return ret; @@ -890,9 +938,9 @@ 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()) + if (!gs_gui_functions->CanUseEventLoop()) { GSocketEventFlags result = 0; @@ -905,7 +953,7 @@ GSocketEventFlags GSocketBSD::Select(GSocketEventFlags flags) /* Do not use a static struct, Linux can garble it */ tv.tv_sec = m_timeout / 1000; - tv.tv_usec = (m_timeout % 1000) / 1000; + tv.tv_usec = (m_timeout % 1000) * 1000; FD_ZERO(&readfds); FD_ZERO(&writefds); @@ -923,7 +971,7 @@ GSocketEventFlags GSocketBSD::Select(GSocketEventFlags flags) */ if ((m_detected & GSOCK_LOST_FLAG) != 0) { - m_establishing = FALSE; + m_establishing = false; return (GSOCK_LOST_FLAG & flags); } @@ -940,7 +988,9 @@ GSocketEventFlags GSocketBSD::Select(GSocketEventFlags flags) { char c; - if (recv(m_fd, &c, 1, MSG_PEEK) > 0) + int num = recv(m_fd, &c, 1, MSG_PEEK | GSOCKET_MSG_NOSIGNAL); + + if (num > 0) { result |= GSOCK_INPUT_FLAG; } @@ -951,11 +1001,11 @@ GSocketEventFlags GSocketBSD::Select(GSocketEventFlags flags) result |= GSOCK_CONNECTION_FLAG; m_detected |= GSOCK_CONNECTION_FLAG; } - else + else if ((errno != EWOULDBLOCK) && (errno != EAGAIN) && (errno != EINTR)) { m_detected = GSOCK_LOST_FLAG; - m_establishing = FALSE; - + m_establishing = false; + /* LOST event: Abort any further processing */ return (GSOCK_LOST_FLAG & flags); } @@ -968,11 +1018,11 @@ GSocketEventFlags GSocketBSD::Select(GSocketEventFlags flags) 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) { @@ -996,7 +1046,7 @@ GSocketEventFlags GSocketBSD::Select(GSocketEventFlags flags) /* Check for exceptions and errors (is this useful in Unices?) */ if (FD_ISSET(m_fd, &exceptfds)) { - m_establishing = FALSE; + m_establishing = false; m_detected = GSOCK_LOST_FLAG; /* LOST event: Abort any further processing */ @@ -1021,7 +1071,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); @@ -1034,7 +1084,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); @@ -1046,7 +1096,7 @@ void GSocketBSD::SetTimeout(unsigned long millisec) * 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); @@ -1060,7 +1110,7 @@ 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 @@ -1083,7 +1133,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; @@ -1104,7 +1154,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; @@ -1120,31 +1170,50 @@ 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; + } + return GSOCK_OPTERR; +} -#define CALL_CALLBACK(event) { \ - Disable(event); \ - if (m_cbacks[event]) \ - m_cbacks[event](this, event, m_data[event]); \ +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; + } + 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 GSocketBSD::Enable(GSocketEvent event) +void GSocket::Enable(GSocketEvent event) { m_detected &= ~(1 << event); - EventLoop_Install_Callback(event); + gs_gui_functions->Install_Callback(this, event); } -void GSocketBSD::Disable(GSocketEvent event) +void GSocket::Disable(GSocketEvent event) { m_detected |= (1 << event); - EventLoop_Uninstall_Callback(event); + gs_gui_functions->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; @@ -1183,7 +1252,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; @@ -1231,12 +1300,17 @@ 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); @@ -1245,7 +1319,10 @@ int GSocketBSD::Recv_Dgram(char *buffer, int size) fromlen = sizeof(from); - ret = recvfrom(m_fd, buffer, size, 0, &from, (SOCKLEN_T *) &fromlen); + do + { + ret = recvfrom(m_fd, buffer, size, 0, &from, (SOCKLEN_T *) &fromlen); + } while (ret == -1 && errno == EINTR); /* Loop until not interrupted */ if (ret == -1) return -1; @@ -1272,22 +1349,25 @@ 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); + MASK_SIGNAL(); +#endif + do + { + ret = send(m_fd, (char *)buffer, size, GSOCKET_MSG_NOSIGNAL); + } while (ret == -1 && errno == EINTR); /* Loop until not interrupted */ +#ifndef __VISAGECPP__ 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; @@ -1308,10 +1388,13 @@ int GSocketBSD::Send_Dgram(const char *buffer, int size) #ifndef __VISAGECPP__ MASK_SIGNAL(); - ret = sendto(m_fd, buffer, size, 0, addr, len); +#endif + do + { + ret = sendto(m_fd, (char *)buffer, size, 0, addr, len); + } while (ret == -1 && errno == EINTR); /* Loop until not interrupted */ +#ifndef __VISAGECPP__ UNMASK_SIGNAL(); -#else - ret = sendto(m_fd, (char *)buffer, size, 0, addr, len); #endif /* Frees memory allocated from _GAddress_translate_to */ @@ -1320,50 +1403,66 @@ 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 { - 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; } @@ -1371,60 +1470,43 @@ 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 = new GSocketBSDGUIShim(); + 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 socket; -} - -void GSocketBSD::_GSocket_Detected_Read(GSocket *socket) -{ socket->Detected_Read(); } - -void GSocketBSD::_GSocket_Detected_Write(GSocket *socket) -{ socket->Detected_Write(); } - /* * ------------------------------------------------------------------------- * GAddress @@ -1627,12 +1709,12 @@ 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 */ #ifndef __WXMAC__ - int val = 1; //VA doesn't like constants in conditional expressions at all + int val = 1; /* VA doesn't like constants in conditional expressions */ if (val) #endif { @@ -1687,8 +1769,12 @@ GSocketError GAddress_INET_SetPortName(GAddress *address, const char *port, address->m_error = GSOCK_INVPORT; return GSOCK_INVPORT; } - + +#if defined(__WXPM__) && defined(__EMX__) + se = getservbyname(port, (char*)protocol); +#else se = getservbyname(port, protocol); +#endif if (!se) { /* the cast to int suppresses compiler warnings about subscript having the @@ -1719,7 +1805,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); @@ -1732,7 +1818,7 @@ 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; @@ -1754,8 +1840,8 @@ 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; @@ -1766,8 +1852,8 @@ 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); @@ -1804,9 +1890,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);