no real change: put event handlers together at the end of the file

[wxWidgets.git] / src / common / socket.cpp

diff --git a/src/common/socket.cpp b/src/common/socket.cpp
index bddf312288832c0f84a0b817c6045adf8830304b..abe4f838102f6a614217316647d15a38845adc3c 100644 (file)
--- 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/stopwatch.h"
 #include "wx/thread.h"
 #include "wx/evtloop.h"

+#include "wx/link.h"

 
 #include "wx/private/fd.h"
 #include "wx/private/socket.h"
 
 #include "wx/private/fd.h"
 #include "wx/private/socket.h"


@@ -57,10 +58,12 @@
 // 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
 // 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)
 #ifdef MSG_NOSIGNAL
     #define wxSOCKET_MSG_NOSIGNAL MSG_NOSIGNAL
 #else // MSG_NOSIGNAL not available (BSD including OS X)

-    #if defined(__UNIX__) && !defined(SO_NOSIGPIPE)
+    #if defined(__UNIX__) && !defined(SO_NOSIGPIPE) && !defined( __VMS )

         #error "Writing to socket could generate unhandled SIGPIPE."
         #error "Please post information about your system to wx-dev."
     #endif
         #error "Writing to socket could generate unhandled SIGPIPE."
         #error "Please post information about your system to wx-dev."
     #endif


@@ -76,6 +79,9 @@ WX_CHECK_BUILD_OPTIONS("wxNet")
 // macros and constants
 // --------------------------------------------------------------------------
 
 // macros and constants
 // --------------------------------------------------------------------------
 

+// event
+wxDEFINE_EVENT(wxEVT_SOCKET, wxSocketEvent);
+

 // discard buffer
 #define MAX_DISCARD_SIZE (10 * 1024)
 
 // discard buffer
 #define MAX_DISCARD_SIZE (10 * 1024)
 


@@ -124,6 +130,92 @@ public:
     DECLARE_NO_COPY_CLASS(wxSocketState)
 };
 
     DECLARE_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;
+
+    DECLARE_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;
+
+    DECLARE_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;
+
+    DECLARE_NO_COPY_CLASS(wxSocketWriteGuard)
+};
+

 // ============================================================================
 // wxSocketManager
 // ============================================================================
 // ============================================================================
 // wxSocketManager
 // ============================================================================


@@ -390,6 +482,10 @@ wxSocketImpl *wxSocketImpl::Accept(wxSocketBase& wxsocket)
     WX_SOCKLEN_T fromlen = sizeof(from);
     const SOCKET fd = accept(m_fd, &from.addr, &fromlen);
 
     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;
 
     if ( fd == INVALID_SOCKET )
         return NULL;
 


@@ -412,10 +508,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 )
 void wxSocketImpl::Shutdown()
 {
     if ( m_fd != INVALID_SOCKET )


@@ -647,7 +739,7 @@ void wxSocketBase::Shutdown()
 
 void wxSocketBase::Init()
 {
 
 void wxSocketBase::Init()
 {

-    m_impl       = NULL;
+    m_impl         = NULL;

     m_type         = wxSOCKET_UNINIT;
 
     // state
     m_type         = wxSOCKET_UNINIT;
 
     // state


@@ -678,7 +770,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()
     {
         // 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,14 +878,10 @@ void wxSocketBase::ShutdownOutput()
 
 wxSocketBase& wxSocketBase::Read(void* buffer, wxUint32 nbytes)
 {
 
 wxSocketBase& wxSocketBase::Read(void* buffer, wxUint32 nbytes)
 {

-    // Mask read events
-    m_reading = true;
+    wxSocketReadGuard read(this);

 
     m_lcount = DoRead(buffer, nbytes);
 
 
     m_lcount = DoRead(buffer, nbytes);
 

-    // Allow read events from now on
-    m_reading = false;
-

     return *this;
 }
 
     return *this;
 }
 


@@ -830,8 +919,7 @@ wxUint32 wxSocketBase::DoRead(void* buffer_, wxUint32 nbytes)
 
                 // otherwise wait until the socket becomes ready for reading or
                 // an error occurs on it
 
                 // otherwise wait until the socket becomes ready for reading or
                 // an error occurs on it

-                if ( !DoWaitWithTimeout(wxSOCKET_INPUT_FLAG |
-                                        wxSOCKET_LOST_FLAG) )
+                if ( !DoWaitWithTimeout(wxSOCKET_INPUT_FLAG) )

                 {
                     // and exit if the timeout elapsed before it did
                     SetError(wxSOCKET_TIMEDOUT);
                 {
                     // and exit if the timeout elapsed before it did
                     SetError(wxSOCKET_TIMEDOUT);


@@ -885,11 +973,9 @@ wxSocketBase& wxSocketBase::ReadMsg(void* buffer, wxUint32 nbytes)
         unsigned char len[4];
     } msg;
 
         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) )
 
     bool ok = false;
     if ( DoRead(&msg, sizeof(msg)) == sizeof(msg) )


@@ -951,36 +1037,26 @@ wxSocketBase& wxSocketBase::ReadMsg(void* buffer, wxUint32 nbytes)
     if ( !ok )
         SetError(wxSOCKET_IOERR);
 
     if ( !ok )
         SetError(wxSOCKET_IOERR);
 

-    m_reading = false;
-    SetFlags(old_flags);
-

     return *this;
 }
 
 wxSocketBase& wxSocketBase::Peek(void* buffer, wxUint32 nbytes)
 {
     return *this;
 }
 
 wxSocketBase& wxSocketBase::Peek(void* buffer, wxUint32 nbytes)
 {

-    // Mask read events
-    m_reading = true;
+    wxSocketReadGuard read(this);

 
     m_lcount = DoRead(buffer, nbytes);
 
     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)
 {
 
     return *this;
 }
 
 wxSocketBase& wxSocketBase::Write(const void *buffer, wxUint32 nbytes)
 {

-    // Mask write events
-    m_writing = true;
+    wxSocketWriteGuard write(this);

 
     m_lcount = DoWrite(buffer, nbytes);
 
 
     m_lcount = DoWrite(buffer, nbytes);
 

-    // Allow write events again
-    m_writing = false;
-

     return *this;
 }
 
     return *this;
 }
 


@@ -1012,8 +1088,7 @@ wxUint32 wxSocketBase::DoWrite(const void *buffer_, wxUint32 nbytes)
                 if ( m_flags & wxSOCKET_NOWAIT )
                     break;
 
                 if ( m_flags & wxSOCKET_NOWAIT )
                     break;
 

-                if ( !DoWaitWithTimeout(wxSOCKET_OUTPUT_FLAG |
-                                        wxSOCKET_LOST_FLAG) )
+                if ( !DoWaitWithTimeout(wxSOCKET_OUTPUT_FLAG) )

                 {
                     SetError(wxSOCKET_TIMEDOUT);
                     break;
                 {
                     SetError(wxSOCKET_TIMEDOUT);
                     break;


@@ -1048,11 +1123,9 @@ wxSocketBase& wxSocketBase::WriteMsg(const void *buffer, wxUint32 nbytes)
         unsigned char len[4];
     } msg;
 
         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;
 
     msg.sig[0] = (unsigned char) 0xad;
     msg.sig[1] = (unsigned char) 0xde;


@@ -1087,9 +1160,6 @@ wxSocketBase& wxSocketBase::WriteMsg(const void *buffer, wxUint32 nbytes)
     if ( !ok )
         SetError(wxSOCKET_IOERR);
 
     if ( !ok )
         SetError(wxSOCKET_IOERR);
 

-    m_writing = false;
-    SetFlags(old_flags);
-

     return *this;
 }
 
     return *this;
 }
 


@@ -1110,11 +1180,9 @@ wxSocketBase& wxSocketBase::Discard()
     wxUint32 ret;
     wxUint32 total = 0;
 
     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
     {
 
     do
     {


@@ -1127,11 +1195,6 @@ wxSocketBase& wxSocketBase::Discard()
     m_lcount = total;
     SetError(wxSOCKET_NOERROR);
 
     m_lcount = total;
     SetError(wxSOCKET_NOERROR);
 

-    // Allow read events again
-    m_reading = false;
-
-    SetFlags(old_flags);
-

     return *this;
 }
 
     return *this;
 }
 


@@ -1223,7 +1286,7 @@ wxSocketEventFlags wxSocketImpl::Select(wxSocketEventFlags flags,
     return detected & flags;
 }
 
     return detected & flags;
 }
 

-bool
+int

 wxSocketBase::DoWait(long seconds, long milliseconds, wxSocketEventFlags flags)
 {
     // Use either the provided timeout or the default timeout value associated
 wxSocketBase::DoWait(long seconds, long milliseconds, wxSocketEventFlags flags)
 {
     // Use either the provided timeout or the default timeout value associated


@@ -1236,14 +1299,14 @@ wxSocketBase::DoWait(long seconds, long milliseconds, wxSocketEventFlags flags)
     return DoWait(timeout, flags);
 }
 
     return DoWait(timeout, flags);
 }
 

-bool
+int

 wxSocketBase::DoWait(long timeout, wxSocketEventFlags flags)
 {
 wxSocketBase::DoWait(long timeout, wxSocketEventFlags flags)
 {

-    wxCHECK_MSG( m_impl, false, "can't wait on invalid socket" );
+    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 )
 
     // we're never going to become ready if we're not connected (any more)
     if ( !m_connected && !m_establishing )

-        return (flags & wxSOCKET_LOST_FLAG) != 0;
+        return -1;

 
     // This can be set to true from Interrupt() to exit this function a.s.a.p.
     m_interrupt = false;
 
     // This can be set to true from Interrupt() to exit this function a.s.a.p.
     m_interrupt = false;


@@ -1265,11 +1328,25 @@ wxSocketBase::DoWait(long timeout, wxSocketEventFlags flags)
         eventLoop = NULL;
     }
 
         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)
     // 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 )
     {
         long timeLeft = wxMilliClockToLong(timeEnd - wxGetLocalTimeMillis());
         if ( timeLeft < 0 )


@@ -1305,8 +1382,7 @@ wxSocketBase::DoWait(long timeout, wxSocketEventFlags flags)
         {
             m_connected = false;
             m_establishing = false;
         {
             m_connected = false;
             m_establishing = false;

-            if ( flags & wxSOCKET_LOST_FLAG )
-                gotEvent = true;
+            rc = -1;

             break;
         }
 
             break;
         }
 


@@ -1318,29 +1394,27 @@ wxSocketBase::DoWait(long timeout, wxSocketEventFlags flags)
         {
             m_connected = true;
             m_establishing = false;
         {
             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) )
         {
             break;
         }
 
         // Data available or output buffer ready?
         if ( (events & wxSOCKET_INPUT_FLAG) || (events & wxSOCKET_OUTPUT_FLAG) )
         {

-            gotEvent = true;
+            rc = true;

             break;
         }
     }
 
             break;
         }
     }
 

-    return gotEvent;
+    return rc;

 }
 
 bool wxSocketBase::Wait(long seconds, long milliseconds)
 {
     return DoWait(seconds, milliseconds,
 }
 
 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)
 }
 
 bool wxSocketBase::WaitForRead(long seconds, long milliseconds)


@@ -1356,11 +1430,7 @@ bool wxSocketBase::WaitForRead(long seconds, long milliseconds)
     if ( m_impl->Select(wxSOCKET_INPUT_FLAG) )
         return true;
 
     if ( m_impl->Select(wxSOCKET_INPUT_FLAG) )
         return true;
 

-    // Note that wxSOCKET_LOST_FLAG 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);
+    return DoWait(seconds, milliseconds, wxSOCKET_INPUT_FLAG) != 0;

 }
 
 
 }
 
 


@@ -1369,12 +1439,12 @@ bool wxSocketBase::WaitForWrite(long seconds, long milliseconds)
     if ( m_impl->Select(wxSOCKET_OUTPUT_FLAG) )
         return true;
 
     if ( m_impl->Select(wxSOCKET_OUTPUT_FLAG) )
         return true;
 

-    return DoWait(seconds, milliseconds, wxSOCKET_OUTPUT_FLAG | wxSOCKET_LOST_FLAG);
+    return DoWait(seconds, milliseconds, wxSOCKET_OUTPUT_FLAG) != 0;

 }
 
 bool wxSocketBase::WaitForLost(long seconds, long milliseconds)
 {
 }
 
 bool wxSocketBase::WaitForLost(long seconds, long milliseconds)
 {

-    return DoWait(seconds, milliseconds, wxSOCKET_LOST_FLAG);
+    return DoWait(seconds, milliseconds, wxSOCKET_LOST_FLAG) == -1;

 }
 
 // --------------------------------------------------------------------------
 }
 
 // --------------------------------------------------------------------------


@@ -1514,17 +1584,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 )
     {
     // 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);
         }
 
         wxSocketEvent event(m_id);


@@ -1711,7 +1777,7 @@ wxSocketBase *wxSocketServer::Accept(bool wait)
 
 bool wxSocketServer::WaitForAccept(long seconds, long milliseconds)
 {
 
 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)
 }
 
 bool wxSocketBase::GetOption(int level, int optname, void *optval, int *optlen)


@@ -1759,10 +1825,6 @@ wxSocketClient::wxSocketClient(wxSocketFlags flags)
     m_initialSendBufferSize = -1;
 }
 
     m_initialSendBufferSize = -1;
 }
 

-wxSocketClient::~wxSocketClient()
-{
-}
-

 // --------------------------------------------------------------------------
 // Connect
 // --------------------------------------------------------------------------
 // --------------------------------------------------------------------------
 // Connect
 // --------------------------------------------------------------------------


@@ -1849,12 +1911,10 @@ bool wxSocketClient::WaitOnConnect(long seconds, long milliseconds)
     wxCHECK_MSG( m_establishing && m_impl, false,
                  "No connection establishment attempt in progress" );
 
     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;

 }
 
 // ==========================================================================
 }
 
 // ==========================================================================


@@ -1944,4 +2004,11 @@ private:
 
 IMPLEMENT_DYNAMIC_CLASS(wxSocketModule, wxModule)
 
 
 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
 #endif // wxUSE_SOCKETS