Reorganize wxCollapsiblePane event and layout code under GTK+

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

diff --git a/src/common/socket.cpp b/src/common/socket.cpp
index ba15840b28c2931ed99411c177a80deeb705f722..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");

     }
 }
 
     }
 }
 


@@ -770,31 +863,35 @@ bool wxSocketBase::Close()
     // Interrupt pending waits
     InterruptWait();
 
     // Interrupt pending waits
     InterruptWait();
 

-    if (m_impl)
-        m_impl->Shutdown();
+    ShutdownOutput();

 
     m_connected = false;
     m_establishing = false;
     return true;
 }
 
 
     m_connected = false;
     m_establishing = false;
     return true;
 }
 

+void wxSocketBase::ShutdownOutput()
+{
+    if ( m_impl )
+        m_impl->Shutdown();
+}
+

 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;
 }
 
 wxUint32 wxSocketBase::DoRead(void* buffer_, wxUint32 nbytes)
 {
     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<char *>(buffer_);
     // We use pointer arithmetic here which doesn't work with void pointers.
     char *buffer = static_cast<char *>(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
 
     // Try the push back buffer first, even before checking whether the socket
     // is valid to allow reading previously pushed back data from an already


@@ -803,73 +900,66 @@ wxUint32 wxSocketBase::DoRead(void* buffer_, wxUint32 nbytes)
     nbytes -= total;
     buffer += total;
 
     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 ( 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;
             }
             {
                 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;
     }
 
     return total;


@@ -883,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) )


@@ -949,98 +1037,79 @@ 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;
 }
 
 // This function is a mirror image of DoRead() except that it doesn't use the
     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)
 {
 wxUint32 wxSocketBase::DoWrite(const void *buffer_, wxUint32 nbytes)
 {

-    const char *buffer = static_cast<const char *>(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<const char *>(buffer_);

     wxCHECK_MSG( buffer, 0, "NULL buffer" );
 
     wxUint32 total = 0;
     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);
                 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;
             }
             {
                 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;
     }
 
     return total;


@@ -1054,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;


@@ -1093,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;
 }
 


@@ -1116,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
     {


@@ -1133,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;
 }
 


@@ -1229,21 +1286,32 @@ wxSocketEventFlags wxSocketImpl::Select(wxSocketEventFlags flags,
     return detected & flags;
 }
 
     return detected & flags;
 }
 

-bool
+int

 wxSocketBase::DoWait(long seconds, long milliseconds, wxSocketEventFlags flags)
 {
 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;
     // 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
     const wxMilliClock_t timeEnd = wxGetLocalTimeMillis() + timeout;
 
     // Get the active event loop which we'll use for the message dispatching


@@ -1260,11 +1328,25 @@ wxSocketBase::DoWait(long seconds, long milliseconds, 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 )


@@ -1275,9 +1357,6 @@ wxSocketBase::DoWait(long seconds, long milliseconds, wxSocketEventFlags flags)
             timeLeft = 0;
         }
 
             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 )
         {
         wxSocketEventFlags events;
         if ( eventLoop )
         {


@@ -1303,8 +1382,7 @@ wxSocketBase::DoWait(long seconds, long milliseconds, 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;
         }
 


@@ -1316,29 +1394,27 @@ wxSocketBase::DoWait(long seconds, long milliseconds, 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)


@@ -1347,22 +1423,28 @@ bool wxSocketBase::WaitForRead(long seconds, long milliseconds)
     if ( m_unread )
         return true;
 
     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)
 {
 }
 
 
 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)
 {
 }
 
 bool wxSocketBase::WaitForLost(long seconds, long milliseconds)
 {

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

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


@@ -1502,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 )
-        {
-            if ( m_reading || !m_impl->Select(wxSOCKET_INPUT_FLAG) )
-                return;
-        }
-        else if ( notification == wxSOCKET_OUTPUT )
+        // 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_writing || !m_impl->Select(wxSOCKET_OUTPUT_FLAG) )
-                return;
+            return;

         }
 
         wxSocketEvent event(m_id);
         }
 
         wxSocketEvent event(m_id);


@@ -1699,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)


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

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

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


@@ -1837,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;

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


@@ -1932,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