X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/b67397a779eef3fb22ee143c8bd4e027c8c5dfc8..acd32ffcdb319f162633c20e0202db3f8542998a:/src/common/socket.cpp?ds=sidebyside diff --git a/src/common/socket.cpp b/src/common/socket.cpp index f03558c0b7..3c4f417e75 100644 --- a/src/common/socket.cpp +++ b/src/common/socket.cpp @@ -42,6 +42,7 @@ #include "wx/stopwatch.h" #include "wx/thread.h" #include "wx/evtloop.h" +#include "wx/link.h" #include "wx/private/fd.h" #include "wx/private/socket.h" @@ -57,13 +58,45 @@ // this should cover all the current Unix systems (Windows never sends any // signals anyhow) but if we find one that has neither we should explicitly // ignore SIGPIPE for it +// OpenVMS has neither MSG_NOSIGNAL nor SO_NOSIGPIPE. However the socket sample +// seems to work. Not sure if problems will show up on OpenVMS using sockets. #ifdef MSG_NOSIGNAL #define wxSOCKET_MSG_NOSIGNAL MSG_NOSIGNAL #else // MSG_NOSIGNAL not available (BSD including OS X) + // next best possibility is to use SO_NOSIGPIPE socket option, this covers + // BSD systems (including OS X) -- but if we don't have it neither (AIX and + // old HP-UX do not), we have to fall back to the old way of simply + // disabling SIGPIPE temporarily, so define a class to do it in a safe way #if defined(__UNIX__) && !defined(SO_NOSIGPIPE) - #error "Writing to socket could generate unhandled SIGPIPE." - #error "Please post information about your system to wx-dev." - #endif + extern "C" { typedef void (*wxSigHandler_t)(int); } + namespace + { + class IgnoreSignal + { + public: + // ctor disables the given signal + IgnoreSignal(int sig) + : m_handler(signal(sig, SIG_IGN)), + m_sig(sig) + { + } + + // dtor restores the old handler + ~IgnoreSignal() + { + signal(m_sig, m_handler); + } + + private: + const wxSigHandler_t m_handler; + const int m_sig; + + wxDECLARE_NO_COPY_CLASS(IgnoreSignal); + }; + } // anonymous namespace + + #define wxNEEDS_IGNORE_SIGPIPE + #endif // Unix without SO_NOSIGPIPE #define wxSOCKET_MSG_NOSIGNAL 0 #endif @@ -76,6 +109,9 @@ WX_CHECK_BUILD_OPTIONS("wxNet") // macros and constants // -------------------------------------------------------------------------- +// event +wxDEFINE_EVENT(wxEVT_SOCKET, wxSocketEvent); + // discard buffer #define MAX_DISCARD_SIZE (10 * 1024) @@ -121,7 +157,93 @@ public: public: wxSocketState() : wxObject() {} - DECLARE_NO_COPY_CLASS(wxSocketState) + wxDECLARE_NO_COPY_CLASS(wxSocketState); +}; + +// wxSocketWaitModeChanger: temporarily change the socket flags affecting its +// wait mode +class wxSocketWaitModeChanger +{ +public: + // temporarily set the flags to include the flag value which may be either + // wxSOCKET_NOWAIT or wxSOCKET_WAITALL + wxSocketWaitModeChanger(wxSocketBase *socket, int flag) + : m_socket(socket), + m_oldflags(socket->GetFlags()) + + { + wxASSERT_MSG( flag == wxSOCKET_WAITALL || flag == wxSOCKET_NOWAIT, + "not a wait flag" ); + + // preserve wxSOCKET_BLOCK value when switching to wxSOCKET_WAITALL + // mode but not when switching to wxSOCKET_NOWAIT as the latter is + // incompatible with wxSOCKET_BLOCK + if ( flag != wxSOCKET_NOWAIT ) + flag |= m_oldflags & wxSOCKET_BLOCK; + + socket->SetFlags(flag); + } + + ~wxSocketWaitModeChanger() + { + m_socket->SetFlags(m_oldflags); + } + +private: + wxSocketBase * const m_socket; + const int m_oldflags; + + wxDECLARE_NO_COPY_CLASS(wxSocketWaitModeChanger); +}; + +// wxSocketRead/WriteGuard are instantiated before starting reading +// from/writing to the socket +class wxSocketReadGuard +{ +public: + wxSocketReadGuard(wxSocketBase *socket) + : m_socket(socket) + { + wxASSERT_MSG( !m_socket->m_reading, "read reentrancy?" ); + + m_socket->m_reading = true; + } + + ~wxSocketReadGuard() + { + m_socket->m_reading = false; + + m_socket->m_impl->ReenableEvents(wxSOCKET_INPUT_FLAG); + } + +private: + wxSocketBase * const m_socket; + + wxDECLARE_NO_COPY_CLASS(wxSocketReadGuard); +}; + +class wxSocketWriteGuard +{ +public: + wxSocketWriteGuard(wxSocketBase *socket) + : m_socket(socket) + { + wxASSERT_MSG( !m_socket->m_writing, "write reentrancy?" ); + + m_socket->m_writing = true; + + m_socket->m_impl->ReenableEvents(wxSOCKET_OUTPUT_FLAG); + } + + ~wxSocketWriteGuard() + { + m_socket->m_writing = false; + } + +private: + wxSocketBase * const m_socket; + + wxDECLARE_NO_COPY_CLASS(wxSocketWriteGuard); }; // ============================================================================ @@ -390,6 +512,10 @@ wxSocketImpl *wxSocketImpl::Accept(wxSocketBase& wxsocket) WX_SOCKLEN_T fromlen = sizeof(from); const SOCKET fd = accept(m_fd, &from.addr, &fromlen); + // accepting is similar to reading in the sense that it resets "ready for + // read" flag on the socket + ReenableEvents(wxSOCKET_INPUT_FLAG); + if ( fd == INVALID_SOCKET ) return NULL; @@ -412,10 +538,6 @@ void wxSocketImpl::Close() } } -/* - * Disallow further read/write operations on this socket, close - * the fd and disable all callbacks. - */ void wxSocketImpl::Shutdown() { if ( m_fd != INVALID_SOCKET ) @@ -521,6 +643,10 @@ int wxSocketImpl::RecvStream(void *buffer, int size) int wxSocketImpl::SendStream(const void *buffer, int size) { +#ifdef wxNEEDS_IGNORE_SIGPIPE + IgnoreSignal ignore(SIGPIPE); +#endif + int ret; DO_WHILE_EINTR( ret, send(m_fd, static_cast(buffer), size, wxSOCKET_MSG_NOSIGNAL) ); @@ -647,7 +773,7 @@ void wxSocketBase::Shutdown() void wxSocketBase::Init() { - m_impl = NULL; + m_impl = NULL; m_type = wxSOCKET_UNINIT; // state @@ -678,7 +804,8 @@ void wxSocketBase::Init() { // this Initialize() will be undone by wxSocketModule::OnExit(), all // the other calls to it should be matched by a call to Shutdown() - Initialize(); + if (!Initialize()) + wxLogError("Cannot initialize wxSocketBase"); } } @@ -785,21 +912,20 @@ void wxSocketBase::ShutdownOutput() wxSocketBase& wxSocketBase::Read(void* buffer, wxUint32 nbytes) { - // Mask read events - m_reading = true; + wxSocketReadGuard read(this); m_lcount = DoRead(buffer, nbytes); - // Allow read events from now on - m_reading = false; - return *this; } wxUint32 wxSocketBase::DoRead(void* buffer_, wxUint32 nbytes) { + wxCHECK_MSG( m_impl, 0, "socket must be valid" ); + // We use pointer arithmetic here which doesn't work with void pointers. char *buffer = static_cast(buffer_); + wxCHECK_MSG( buffer, 0, "NULL buffer" ); // Try the push back buffer first, even before checking whether the socket // is valid to allow reading previously pushed back data from an already @@ -808,73 +934,66 @@ wxUint32 wxSocketBase::DoRead(void* buffer_, wxUint32 nbytes) nbytes -= total; buffer += total; - // If it's indeed closed or if read everything, there is nothing more to do. - if ( !m_impl || !nbytes ) - return total; - - wxCHECK_MSG( buffer, 0, "NULL buffer" ); - - - // wxSOCKET_NOWAIT overrides all the other flags and means that we are - // polling the socket and don't block at all. - if ( m_flags & wxSOCKET_NOWAIT ) + while ( nbytes ) { - int ret = m_impl->Read(buffer, nbytes); + // our socket is non-blocking so Read() will return immediately if + // there is nothing to read yet and it's more efficient to try it first + // before entering DoWait() which is going to start dispatching GUI + // events and, even more importantly, we must do this under Windows + // where we're not going to get notifications about socket being ready + // for reading before we read all the existing data from it + const int ret = m_connected ? m_impl->Read(buffer, nbytes) : 0; if ( ret == -1 ) { - if ( m_impl->GetLastError() != wxSOCKET_WOULDBLOCK ) - SetError(wxSOCKET_IOERR); - } - else // not an error, even if we didn't read anything - { - total += ret; - } - } - else // blocking socket - { - for ( ;; ) - { - // Wait until socket becomes ready for reading - if ( !WaitForRead() ) - break; - - const int ret = m_impl->Read(buffer, nbytes); - if ( ret == 0 ) + if ( m_impl->GetLastError() == wxSOCKET_WOULDBLOCK ) { - // for connection-oriented (e.g. TCP) sockets we can only read - // 0 bytes if the other end has been closed, and for - // connectionless ones (UDP) this flag doesn't make sense - // anyhow so we can set it to true too without doing any harm - m_closed = true; - break; - } + // if we don't want to wait, just return immediately + if ( m_flags & wxSOCKET_NOWAIT ) + break; - if ( ret == -1 ) + // otherwise wait until the socket becomes ready for reading or + // an error occurs on it + if ( !DoWaitWithTimeout(wxSOCKET_INPUT_FLAG) ) + { + // and exit if the timeout elapsed before it did + SetError(wxSOCKET_TIMEDOUT); + break; + } + + // retry reading + continue; + } + else // "real" error { SetError(wxSOCKET_IOERR); break; } + } + else if ( ret == 0 ) + { + // for connection-oriented (e.g. TCP) sockets we can only read + // 0 bytes if the other end has been closed, and for connectionless + // ones (UDP) this flag doesn't make sense anyhow so we can set it + // to true too without doing any harm + m_closed = true; + + // we're not going to read anything else and so if we haven't read + // anything (or not everything in wxSOCKET_WAITALL case) already, + // signal an error + if ( (m_flags & wxSOCKET_WAITALL) || !total ) + SetError(wxSOCKET_IOERR); + break; + } - total += ret; - - // If wxSOCKET_WAITALL is not set, we can leave now as we did read - // something and we don't need to wait for all nbytes bytes to be - // read. - if ( !(m_flags & wxSOCKET_WAITALL) ) - break; - - // Otherwise continue reading until we do read everything. - nbytes -= ret; - if ( !nbytes ) - break; + total += ret; - buffer += ret; - } + // if we are happy to read something and not the entire nbytes bytes, + // then we're done + if ( !(m_flags & wxSOCKET_WAITALL) ) + break; - // it's an error to not read everything in wxSOCKET_WAITALL mode or to - // not read anything otherwise - if ( ((m_flags & wxSOCKET_WAITALL) && nbytes) || !total ) - SetError(wxSOCKET_IOERR); + nbytes -= ret; + buffer += ret; } return total; @@ -888,11 +1007,9 @@ wxSocketBase& wxSocketBase::ReadMsg(void* buffer, wxUint32 nbytes) unsigned char len[4]; } msg; - // Mask read events - m_reading = true; + wxSocketReadGuard read(this); - int old_flags = m_flags; - SetFlags((m_flags & wxSOCKET_BLOCK) | wxSOCKET_WAITALL); + wxSocketWaitModeChanger changeFlags(this, wxSOCKET_WAITALL); bool ok = false; if ( DoRead(&msg, sizeof(msg)) == sizeof(msg) ) @@ -954,98 +1071,79 @@ wxSocketBase& wxSocketBase::ReadMsg(void* buffer, wxUint32 nbytes) if ( !ok ) SetError(wxSOCKET_IOERR); - m_reading = false; - SetFlags(old_flags); - return *this; } wxSocketBase& wxSocketBase::Peek(void* buffer, wxUint32 nbytes) { - // Mask read events - m_reading = true; + wxSocketReadGuard read(this); m_lcount = DoRead(buffer, nbytes); - Pushback(buffer, m_lcount); - // Allow read events again - m_reading = false; + Pushback(buffer, m_lcount); return *this; } wxSocketBase& wxSocketBase::Write(const void *buffer, wxUint32 nbytes) { - // Mask write events - m_writing = true; + wxSocketWriteGuard write(this); m_lcount = DoWrite(buffer, nbytes); - // Allow write events again - m_writing = false; - return *this; } // This function is a mirror image of DoRead() except that it doesn't use the -// push back buffer, please see comments there +// push back buffer and doesn't treat 0 return value specially (normally this +// shouldn't happen at all here), so please see comments there for explanations wxUint32 wxSocketBase::DoWrite(const void *buffer_, wxUint32 nbytes) { - const char *buffer = static_cast(buffer_); - - // Return if there is nothing to read or the socket is (already?) closed. - if ( !m_impl || !nbytes ) - return 0; + wxCHECK_MSG( m_impl, 0, "socket must be valid" ); + const char *buffer = static_cast(buffer_); wxCHECK_MSG( buffer, 0, "NULL buffer" ); wxUint32 total = 0; - if ( m_flags & wxSOCKET_NOWAIT ) + while ( nbytes ) { - const int ret = m_impl->Write(buffer, nbytes); - if ( ret == -1 ) + if ( !m_connected ) { - if ( m_impl->GetLastError() != wxSOCKET_WOULDBLOCK ) + if ( (m_flags & wxSOCKET_WAITALL) || !total ) SetError(wxSOCKET_IOERR); + break; } - else - { - total += ret; - } - } - else // blocking socket - { - for ( ;; ) - { - if ( !WaitForWrite() ) - break; - const int ret = m_impl->Write(buffer, nbytes); - if ( ret == 0 ) + const int ret = m_impl->Write(buffer, nbytes); + if ( ret == -1 ) + { + if ( m_impl->GetLastError() == wxSOCKET_WOULDBLOCK ) { - m_closed = true; - break; - } + if ( m_flags & wxSOCKET_NOWAIT ) + break; + + if ( !DoWaitWithTimeout(wxSOCKET_OUTPUT_FLAG) ) + { + SetError(wxSOCKET_TIMEDOUT); + break; + } - if ( ret == -1 ) + continue; + } + else // "real" error { SetError(wxSOCKET_IOERR); break; } + } - total += ret; - if ( !(m_flags & wxSOCKET_WAITALL) ) - break; - - nbytes -= ret; - if ( !nbytes ) - break; + total += ret; - buffer += ret; - } + if ( !(m_flags & wxSOCKET_WAITALL) ) + break; - if ( ((m_flags & wxSOCKET_WAITALL) && nbytes) || !total ) - SetError(wxSOCKET_IOERR); + nbytes -= ret; + buffer += ret; } return total; @@ -1059,11 +1157,9 @@ wxSocketBase& wxSocketBase::WriteMsg(const void *buffer, wxUint32 nbytes) unsigned char len[4]; } msg; - // Mask write events - m_writing = true; + wxSocketWriteGuard write(this); - const int old_flags = m_flags; - SetFlags((m_flags & wxSOCKET_BLOCK) | wxSOCKET_WAITALL); + wxSocketWaitModeChanger changeFlags(this, wxSOCKET_WAITALL); msg.sig[0] = (unsigned char) 0xad; msg.sig[1] = (unsigned char) 0xde; @@ -1098,9 +1194,6 @@ wxSocketBase& wxSocketBase::WriteMsg(const void *buffer, wxUint32 nbytes) if ( !ok ) SetError(wxSOCKET_IOERR); - m_writing = false; - SetFlags(old_flags); - return *this; } @@ -1121,11 +1214,9 @@ wxSocketBase& wxSocketBase::Discard() wxUint32 ret; wxUint32 total = 0; - // Mask read events - m_reading = true; + wxSocketReadGuard read(this); - const int old_flags = m_flags; - SetFlags(wxSOCKET_NOWAIT); + wxSocketWaitModeChanger changeFlags(this, wxSOCKET_NOWAIT); do { @@ -1138,11 +1229,6 @@ wxSocketBase& wxSocketBase::Discard() m_lcount = total; SetError(wxSOCKET_NOERROR); - // Allow read events again - m_reading = false; - - SetFlags(old_flags); - return *this; } @@ -1234,21 +1320,32 @@ wxSocketEventFlags wxSocketImpl::Select(wxSocketEventFlags flags, return detected & flags; } -bool +int wxSocketBase::DoWait(long seconds, long milliseconds, wxSocketEventFlags flags) { - wxCHECK_MSG( m_impl, false, "can't wait on invalid socket" ); - - // This can be set to true from Interrupt() to exit this function a.s.a.p. - m_interrupt = false; - - // Use either the provided timeout or the default timeout value associated // with this socket. // // TODO: allow waiting forever, see #9443 const long timeout = seconds == -1 ? m_timeout * 1000 : seconds * 1000 + milliseconds; + + return DoWait(timeout, flags); +} + +int +wxSocketBase::DoWait(long timeout, wxSocketEventFlags flags) +{ + wxCHECK_MSG( m_impl, -1, "can't wait on invalid socket" ); + + // we're never going to become ready if we're not connected (any more) + if ( !m_connected && !m_establishing ) + return -1; + + // This can be set to true from Interrupt() to exit this function a.s.a.p. + m_interrupt = false; + + const wxMilliClock_t timeEnd = wxGetLocalTimeMillis() + timeout; // Get the active event loop which we'll use for the message dispatching @@ -1265,11 +1362,25 @@ wxSocketBase::DoWait(long seconds, long milliseconds, wxSocketEventFlags flags) eventLoop = NULL; } + // Make sure the events we're interested in are enabled before waiting for + // them: this is really necessary here as otherwise this could happen: + // 1. DoRead(wxSOCKET_WAITALL) is called + // 2. There is nothing to read so DoWait(wxSOCKET_INPUT_FLAG) is called + // 3. Some, but not all data appears, wxSocketImplUnix::OnReadWaiting() + // is called and wxSOCKET_INPUT_FLAG events are disabled in it + // 4. Because of wxSOCKET_WAITALL we call DoWait() again but the events + // are still disabled and we block forever + // + // More elegant solution would be nice but for now simply re-enabling the + // events here will do + m_impl->ReenableEvents(flags & (wxSOCKET_INPUT_FLAG | wxSOCKET_OUTPUT_FLAG)); + + // Wait until we receive the event we're waiting for or the timeout expires // (but note that we always execute the loop at least once, even if timeout // is 0 as this is used for polling) - bool gotEvent = false; - for ( bool firstTime = true; !m_interrupt ; firstTime = false ) + int rc = 0; + for ( bool firstTime = true; !m_interrupt; firstTime = false ) { long timeLeft = wxMilliClockToLong(timeEnd - wxGetLocalTimeMillis()); if ( timeLeft < 0 ) @@ -1280,9 +1391,6 @@ wxSocketBase::DoWait(long seconds, long milliseconds, wxSocketEventFlags flags) timeLeft = 0; } - // This function is only called if wxSOCKET_BLOCK flag was not used and - // so we should dispatch the events if there is an event loop capable - // of doing it. wxSocketEventFlags events; if ( eventLoop ) { @@ -1308,8 +1416,7 @@ wxSocketBase::DoWait(long seconds, long milliseconds, wxSocketEventFlags flags) { m_connected = false; m_establishing = false; - if ( flags & wxSOCKET_LOST_FLAG ) - gotEvent = true; + rc = -1; break; } @@ -1321,29 +1428,27 @@ wxSocketBase::DoWait(long seconds, long milliseconds, wxSocketEventFlags flags) { m_connected = true; m_establishing = false; - gotEvent = true; + rc = true; break; } // Data available or output buffer ready? if ( (events & wxSOCKET_INPUT_FLAG) || (events & wxSOCKET_OUTPUT_FLAG) ) { - gotEvent = true; + rc = true; break; } } - return gotEvent; + return rc; } bool wxSocketBase::Wait(long seconds, long milliseconds) { return DoWait(seconds, milliseconds, - wxSOCKET_INPUT_FLAG | - wxSOCKET_OUTPUT_FLAG | - wxSOCKET_CONNECTION_FLAG | - wxSOCKET_LOST_FLAG - ); + wxSOCKET_INPUT_FLAG | + wxSOCKET_OUTPUT_FLAG | + wxSOCKET_CONNECTION_FLAG) != 0; } bool wxSocketBase::WaitForRead(long seconds, long milliseconds) @@ -1352,22 +1457,28 @@ bool wxSocketBase::WaitForRead(long seconds, long milliseconds) if ( m_unread ) return true; - // Note that wxSOCKET_INPUT_LOST has to be explicitly passed to DoWait - // because of the semantics of WaitForRead: a return value of true means - // that a Read call will return immediately, not that there is - // actually data to read. - return DoWait(seconds, milliseconds, wxSOCKET_INPUT_FLAG | wxSOCKET_LOST_FLAG); + // Check if the socket is not already ready for input, if it is, there is + // no need to start waiting for it (worse, we'll actually never get a + // notification about the socket becoming ready if it is already under + // Windows) + if ( m_impl->Select(wxSOCKET_INPUT_FLAG) ) + return true; + + return DoWait(seconds, milliseconds, wxSOCKET_INPUT_FLAG) != 0; } bool wxSocketBase::WaitForWrite(long seconds, long milliseconds) { - return DoWait(seconds, milliseconds, wxSOCKET_OUTPUT_FLAG | wxSOCKET_LOST_FLAG); + if ( m_impl->Select(wxSOCKET_OUTPUT_FLAG) ) + return true; + + return DoWait(seconds, milliseconds, wxSOCKET_OUTPUT_FLAG) != 0; } bool wxSocketBase::WaitForLost(long seconds, long milliseconds) { - return DoWait(seconds, milliseconds, wxSOCKET_LOST_FLAG); + return DoWait(seconds, milliseconds, wxSOCKET_LOST_FLAG) == -1; } // -------------------------------------------------------------------------- @@ -1507,17 +1618,13 @@ void wxSocketBase::OnRequest(wxSocketNotify notification) // send the wx event if enabled and we're interested in it if ( m_notify && (m_eventmask & flag) && m_handler ) { - // If we are in the middle of a R/W operation, do not propagate events - // to users. Also, filter 'late' events which are no longer valid. - if ( notification == wxSOCKET_INPUT ) + // don't generate the events when we're inside DoWait() called from our + // own code as we are going to consume the data that has just become + // available ourselves and the user code won't see it at all + if ( (notification == wxSOCKET_INPUT && m_reading) || + (notification == wxSOCKET_OUTPUT && m_writing) ) { - if ( m_reading || !m_impl->Select(wxSOCKET_INPUT_FLAG) ) - return; - } - else if ( notification == wxSOCKET_OUTPUT ) - { - if ( m_writing || !m_impl->Select(wxSOCKET_OUTPUT_FLAG) ) - return; + return; } wxSocketEvent event(m_id); @@ -1704,7 +1811,7 @@ wxSocketBase *wxSocketServer::Accept(bool wait) bool wxSocketServer::WaitForAccept(long seconds, long milliseconds) { - return DoWait(seconds, milliseconds, wxSOCKET_CONNECTION_FLAG); + return DoWait(seconds, milliseconds, wxSOCKET_CONNECTION_FLAG) == 1; } bool wxSocketBase::GetOption(int level, int optname, void *optval, int *optlen) @@ -1752,10 +1859,6 @@ wxSocketClient::wxSocketClient(wxSocketFlags flags) m_initialSendBufferSize = -1; } -wxSocketClient::~wxSocketClient() -{ -} - // -------------------------------------------------------------------------- // Connect // -------------------------------------------------------------------------- @@ -1842,12 +1945,10 @@ bool wxSocketClient::WaitOnConnect(long seconds, long milliseconds) wxCHECK_MSG( m_establishing && m_impl, false, "No connection establishment attempt in progress" ); - // we must specify wxSOCKET_LOST_FLAG here explicitly because we must return - // true if the connection establishment process is finished, whether it is - // over because we successfully connected or because we were not able to - // connect - return DoWait(seconds, milliseconds, - wxSOCKET_CONNECTION_FLAG | wxSOCKET_LOST_FLAG); + // notice that we return true even if DoWait() returned -1, i.e. if an + // error occurred and connection was lost: this is intentional as we should + // return false only if timeout expired without anything happening + return DoWait(seconds, milliseconds, wxSOCKET_CONNECTION_FLAG) != 0; } // ========================================================================== @@ -1937,4 +2038,11 @@ private: IMPLEMENT_DYNAMIC_CLASS(wxSocketModule, wxModule) +#if defined(wxUSE_SELECT_DISPATCHER) && wxUSE_SELECT_DISPATCHER +// NOTE: we need to force linking against socketiohandler.cpp otherwise in +// static builds of wxWidgets the ManagerSetter::ManagerSetter ctor +// contained there wouldn't be ever called +wxFORCE_LINK_MODULE( socketiohandler ) +#endif + #endif // wxUSE_SOCKETS