X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/0ed00ab5be4bb5108ebafeebcaa26274145debe0..76015a6bb79156d8af1b5e8b4b8e46b4e192d18f:/src/common/socket.cpp?ds=sidebyside diff --git a/src/common/socket.cpp b/src/common/socket.cpp index c80b314d60..545a68d54f 100644 --- a/src/common/socket.cpp +++ b/src/common/socket.cpp @@ -7,7 +7,7 @@ // (C) 1999-2000, Guillermo Rodriguez Garcia // (C) 2008 Vadim Zeitlin // RCS_ID: $Id$ -// License: wxWindows licence +// Licence: wxWindows licence ///////////////////////////////////////////////////////////////////////////// // ========================================================================== @@ -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,10 +109,13 @@ WX_CHECK_BUILD_OPTIONS("wxNet") // macros and constants // -------------------------------------------------------------------------- +// event +wxDEFINE_EVENT(wxEVT_SOCKET, wxSocketEvent); + // discard buffer #define MAX_DISCARD_SIZE (10 * 1024) -#define wxTRACE_Socket _T("wxSocket") +#define wxTRACE_Socket wxT("wxSocket") // -------------------------------------------------------------------------- // wxWin macros @@ -121,7 +157,7 @@ public: public: wxSocketState() : wxObject() {} - DECLARE_NO_COPY_CLASS(wxSocketState) + wxDECLARE_NO_COPY_CLASS(wxSocketState); }; // wxSocketWaitModeChanger: temporarily change the socket flags affecting its @@ -136,7 +172,9 @@ public: m_oldflags(socket->GetFlags()) { - wxASSERT_MSG( flag == wxSOCKET_WAITALL || flag == wxSOCKET_NOWAIT, + // We can be passed only wxSOCKET_WAITALL{_READ,_WRITE} or + // wxSOCKET_NOWAIT{_READ,_WRITE} normally. + wxASSERT_MSG( !(flag & wxSOCKET_WAITALL) || !(flag & wxSOCKET_NOWAIT), "not a wait flag" ); // preserve wxSOCKET_BLOCK value when switching to wxSOCKET_WAITALL @@ -157,7 +195,7 @@ private: wxSocketBase * const m_socket; const int m_oldflags; - DECLARE_NO_COPY_CLASS(wxSocketWaitModeChanger) + wxDECLARE_NO_COPY_CLASS(wxSocketWaitModeChanger); }; // wxSocketRead/WriteGuard are instantiated before starting reading @@ -177,13 +215,17 @@ public: { m_socket->m_reading = false; - m_socket->m_impl->ReenableEvents(wxSOCKET_INPUT_FLAG); + // connection could have been lost while reading, in this case calling + // ReenableEvents() would assert and is not necessary anyhow + wxSocketImpl * const impl = m_socket->m_impl; + if ( impl && impl->m_fd != INVALID_SOCKET ) + impl->ReenableEvents(wxSOCKET_INPUT_FLAG); } private: wxSocketBase * const m_socket; - DECLARE_NO_COPY_CLASS(wxSocketReadGuard) + wxDECLARE_NO_COPY_CLASS(wxSocketReadGuard); }; class wxSocketWriteGuard @@ -195,19 +237,21 @@ public: 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; + + wxSocketImpl * const impl = m_socket->m_impl; + if ( impl && impl->m_fd != INVALID_SOCKET ) + impl->ReenableEvents(wxSOCKET_OUTPUT_FLAG); } private: wxSocketBase * const m_socket; - DECLARE_NO_COPY_CLASS(wxSocketWriteGuard) + wxDECLARE_NO_COPY_CLASS(wxSocketWriteGuard); }; // ============================================================================ @@ -328,6 +372,14 @@ void wxSocketImpl::PostCreation() wxSocketError wxSocketImpl::UpdateLocalAddress() { + if ( !m_local.IsOk() ) + { + // ensure that we have a valid object using the correct family: correct + // being the same one as our peer uses as we have no other way to + // determine it + m_local.Create(m_peer.GetFamily()); + } + WX_SOCKLEN_T lenAddr = m_local.GetLen(); if ( getsockname(m_fd, m_local.GetWritableAddr(), &lenAddr) != 0 ) { @@ -474,7 +526,7 @@ wxSocketImpl *wxSocketImpl::Accept(wxSocketBase& wxsocket) { wxSockAddressStorage from; WX_SOCKLEN_T fromlen = sizeof(from); - const SOCKET fd = accept(m_fd, &from.addr, &fromlen); + const wxSOCKET_T 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 @@ -483,7 +535,14 @@ wxSocketImpl *wxSocketImpl::Accept(wxSocketBase& wxsocket) if ( fd == INVALID_SOCKET ) return NULL; - wxSocketImpl * const sock = Create(wxsocket); + wxSocketManager * const manager = wxSocketManager::Get(); + if ( !manager ) + return NULL; + + wxSocketImpl * const sock = manager->CreateSocket(wxsocket); + if ( !sock ) + return NULL; + sock->m_fd = fd; sock->m_peer = wxSockAddressImpl(from.addr, fromlen); @@ -607,6 +666,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) ); @@ -689,36 +752,48 @@ int wxSocketImpl::Write(const void *buffer, int size) // Initialization and shutdown // -------------------------------------------------------------------------- -// FIXME-MT: all this is MT-unsafe, of course, we should protect all accesses -// to m_countInit with a crit section -size_t wxSocketBase::m_countInit = 0; +namespace +{ + +// counts the number of calls to Initialize() minus the number of calls to +// Shutdown(): we don't really need it any more but it was documented that +// Shutdown() must be called the same number of times as Initialize() and using +// a counter helps us to check it +int gs_socketInitCount = 0; + +} // anonymous namespace bool wxSocketBase::IsInitialized() { - return m_countInit > 0; + wxASSERT_MSG( wxIsMainThread(), "unsafe to call from other threads" ); + + return gs_socketInitCount != 0; } bool wxSocketBase::Initialize() { - if ( !m_countInit++ ) + wxCHECK_MSG( wxIsMainThread(), false, + "must be called from the main thread" ); + + if ( !gs_socketInitCount ) { wxSocketManager * const manager = wxSocketManager::Get(); if ( !manager || !manager->OnInit() ) - { - m_countInit--; - return false; - } } + gs_socketInitCount++; + return true; } void wxSocketBase::Shutdown() { - // we should be initialized - wxASSERT_MSG( m_countInit > 0, _T("extra call to Shutdown()") ); - if ( --m_countInit == 0 ) + wxCHECK_RET( wxIsMainThread(), "must be called from the main thread" ); + + wxCHECK_RET( gs_socketInitCount > 0, "too many calls to Shutdown()" ); + + if ( !--gs_socketInitCount ) { wxSocketManager * const manager = wxSocketManager::Get(); wxCHECK_RET( manager, "should have a socket manager" ); @@ -744,6 +819,8 @@ void wxSocketBase::Init() m_writing = m_closed = false; m_lcount = 0; + m_lcount_read = 0; + m_lcount_write = 0; m_timeout = 600; m_beingDeleted = false; @@ -760,11 +837,16 @@ void wxSocketBase::Init() m_eventmask = m_eventsgot = 0; - if ( !IsInitialized() ) + // when we create the first socket in the main thread we initialize the + // OS-dependent socket stuff: notice that this means that the user code + // needs to call wxSocket::Initialize() itself if the first socket it + // creates is not created in the main thread + if ( wxIsMainThread() ) { - // 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 sockets")); + } } } @@ -784,12 +866,6 @@ wxSocketBase::wxSocketBase(wxSocketFlags flags, wxSocketType type) wxSocketBase::~wxSocketBase() { - // Just in case the app called Destroy() *and* then deleted the socket - // immediately: don't leave dangling pointers. - wxAppTraits *traits = wxTheApp ? wxTheApp->GetTraits() : NULL; - if ( traits ) - traits->RemoveFromPendingDelete(this); - // Shutdown and close the socket if (!m_beingDeleted) Close(); @@ -798,8 +874,7 @@ wxSocketBase::~wxSocketBase() delete m_impl; // Free the pushback buffer - if (m_unread) - free(m_unread); + free(m_unread); } bool wxSocketBase::Destroy() @@ -815,14 +890,17 @@ bool wxSocketBase::Destroy() // Suppress events from now on Notify(false); - // schedule this object for deletion - wxAppTraits *traits = wxTheApp ? wxTheApp->GetTraits() : NULL; - if ( traits ) + // Schedule this object for deletion instead of destroying it right now if + // it can have other events pending for it and we have a way to do it. + // + // Notice that sockets used in other threads won't have any events for them + // and we shouldn't use delayed destruction mechanism for them as it's not + // MT-safe. + if ( wxIsMainThread() && wxTheApp ) { - // let the traits object decide what to do with us - traits->ScheduleForDestroy(this); + wxTheApp->ScheduleForDestruction(this); } - else // no app or no traits + else // no app { // in wxBase we might have no app object at all, don't leak memory delete this; @@ -873,7 +951,8 @@ wxSocketBase& wxSocketBase::Read(void* buffer, wxUint32 nbytes) { wxSocketReadGuard read(this); - m_lcount = DoRead(buffer, nbytes); + m_lcount_read = DoRead(buffer, nbytes); + m_lcount = m_lcount_read; return *this; } @@ -901,14 +980,20 @@ wxUint32 wxSocketBase::DoRead(void* buffer_, wxUint32 nbytes) // 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; + const int ret = !m_impl->m_stream || m_connected + ? m_impl->Read(buffer, nbytes) + : 0; if ( ret == -1 ) { if ( m_impl->GetLastError() == wxSOCKET_WOULDBLOCK ) { // if we don't want to wait, just return immediately - if ( m_flags & wxSOCKET_NOWAIT ) + if ( m_flags & wxSOCKET_NOWAIT_READ ) + { + // this shouldn't be counted as an error in this case + SetError(wxSOCKET_NOERROR); break; + } // otherwise wait until the socket becomes ready for reading or // an error occurs on it @@ -939,7 +1024,7 @@ wxUint32 wxSocketBase::DoRead(void* buffer_, wxUint32 nbytes) // 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 ) + if ( (m_flags & wxSOCKET_WAITALL_READ) || !total ) SetError(wxSOCKET_IOERR); break; } @@ -948,7 +1033,7 @@ wxUint32 wxSocketBase::DoRead(void* buffer_, wxUint32 nbytes) // if we are happy to read something and not the entire nbytes bytes, // then we're done - if ( !(m_flags & wxSOCKET_WAITALL) ) + if ( !(m_flags & wxSOCKET_WAITALL_READ) ) break; nbytes -= ret; @@ -968,7 +1053,7 @@ wxSocketBase& wxSocketBase::ReadMsg(void* buffer, wxUint32 nbytes) wxSocketReadGuard read(this); - wxSocketWaitModeChanger changeFlags(this, wxSOCKET_WAITALL); + wxSocketWaitModeChanger changeFlags(this, wxSOCKET_WAITALL_READ); bool ok = false; if ( DoRead(&msg, sizeof(msg)) == sizeof(msg) ) @@ -995,7 +1080,8 @@ wxSocketBase& wxSocketBase::ReadMsg(void* buffer, wxUint32 nbytes) len2 = 0; // Don't attempt to read if the msg was zero bytes long. - m_lcount = len ? DoRead(buffer, len) : 0; + m_lcount_read = len ? DoRead(buffer, len) : 0; + m_lcount = m_lcount_read; if ( len2 ) { @@ -1037,6 +1123,9 @@ wxSocketBase& wxSocketBase::Peek(void* buffer, wxUint32 nbytes) { wxSocketReadGuard read(this); + // Peek() should never block + wxSocketWaitModeChanger changeFlags(this, wxSOCKET_NOWAIT); + m_lcount = DoRead(buffer, nbytes); Pushback(buffer, m_lcount); @@ -1048,7 +1137,8 @@ wxSocketBase& wxSocketBase::Write(const void *buffer, wxUint32 nbytes) { wxSocketWriteGuard write(this); - m_lcount = DoWrite(buffer, nbytes); + m_lcount_write = DoWrite(buffer, nbytes); + m_lcount = m_lcount_write; return *this; } @@ -1066,9 +1156,9 @@ wxUint32 wxSocketBase::DoWrite(const void *buffer_, wxUint32 nbytes) wxUint32 total = 0; while ( nbytes ) { - if ( !m_connected ) + if ( m_impl->m_stream && !m_connected ) { - if ( (m_flags & wxSOCKET_WAITALL) || !total ) + if ( (m_flags & wxSOCKET_WAITALL_WRITE) || !total ) SetError(wxSOCKET_IOERR); break; } @@ -1078,7 +1168,7 @@ wxUint32 wxSocketBase::DoWrite(const void *buffer_, wxUint32 nbytes) { if ( m_impl->GetLastError() == wxSOCKET_WOULDBLOCK ) { - if ( m_flags & wxSOCKET_NOWAIT ) + if ( m_flags & wxSOCKET_NOWAIT_WRITE ) break; if ( !DoWaitWithTimeout(wxSOCKET_OUTPUT_FLAG) ) @@ -1098,7 +1188,7 @@ wxUint32 wxSocketBase::DoWrite(const void *buffer_, wxUint32 nbytes) total += ret; - if ( !(m_flags & wxSOCKET_WAITALL) ) + if ( !(m_flags & wxSOCKET_WAITALL_WRITE) ) break; nbytes -= ret; @@ -1118,7 +1208,7 @@ wxSocketBase& wxSocketBase::WriteMsg(const void *buffer, wxUint32 nbytes) wxSocketWriteGuard write(this); - wxSocketWaitModeChanger changeFlags(this, wxSOCKET_WAITALL); + wxSocketWaitModeChanger changeFlags(this, wxSOCKET_WAITALL_WRITE); msg.sig[0] = (unsigned char) 0xad; msg.sig[1] = (unsigned char) 0xde; @@ -1133,8 +1223,9 @@ wxSocketBase& wxSocketBase::WriteMsg(const void *buffer, wxUint32 nbytes) bool ok = false; if ( DoWrite(&msg, sizeof(msg)) == sizeof(msg) ) { - m_lcount = DoWrite(buffer, nbytes); - if ( m_lcount == nbytes ) + m_lcount_write = DoWrite(buffer, nbytes); + m_lcount = m_lcount_write; + if ( m_lcount_write == nbytes ) { msg.sig[0] = (unsigned char) 0xed; msg.sig[1] = (unsigned char) 0xfe; @@ -1218,17 +1309,31 @@ wxSocketEventFlags wxSocketImpl::Select(wxSocketEventFlags flags, exceptfds; // always want to know about errors if ( flags & wxSOCKET_INPUT_FLAG ) - { preadfds = &readfds; + + if ( flags & wxSOCKET_OUTPUT_FLAG ) + pwritefds = &writefds; + + // When using non-blocking connect() the client socket becomes connected + // (successfully or not) when it becomes writable but when using + // non-blocking accept() the server socket becomes connected when it + // becomes readable. + if ( flags & wxSOCKET_CONNECTION_FLAG ) + { + if ( m_server ) + preadfds = &readfds; + else + pwritefds = &writefds; + } + + if ( preadfds ) + { wxFD_ZERO(preadfds); wxFD_SET(m_fd, preadfds); } - // when using non-blocking connect() the socket becomes connected - // (successfully or not) when it becomes writable - if ( flags & (wxSOCKET_OUTPUT_FLAG | wxSOCKET_CONNECTION_FLAG) ) + if ( pwritefds ) { - pwritefds = &writefds; wxFD_ZERO(pwritefds); wxFD_SET(m_fd, pwritefds); } @@ -1297,8 +1402,11 @@ 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 ) + // we're never going to become ready in a TCP client if we're not connected + // any more (OTOH a server can call this to precisely wait for a connection + // so do wait for it in this case and UDP client is never "connected") + if ( !m_impl->IsServer() && + m_impl->m_stream && !m_connected && !m_establishing ) return -1; // This can be set to true from Interrupt() to exit this function a.s.a.p. @@ -1321,6 +1429,20 @@ wxSocketBase::DoWait(long timeout, 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) @@ -1542,20 +1664,29 @@ void wxSocketBase::OnRequest(wxSocketNotify notification) case wxSOCKET_CONNECTION: flag = wxSOCKET_CONNECTION_FLAG; + + // we're now successfully connected + m_connected = true; + m_establishing = false; + + // error was previously set to wxSOCKET_WOULDBLOCK, but this is not + // the case any longer + SetError(wxSOCKET_NOERROR); break; case wxSOCKET_LOST: flag = wxSOCKET_LOST_FLAG; + + // if we lost the connection the socket is now closed and not + // connected any more + m_connected = false; + m_closed = true; break; default: wxFAIL_MSG( "unknown wxSocket notification" ); } - // if we lost the connection the socket is now closed - if ( notification == wxSOCKET_LOST ) - m_closed = true; - // remember the events which were generated for this socket, we're going to // use this in DoWait() m_eventsgot |= flag; @@ -1663,13 +1794,14 @@ wxSocketServer::wxSocketServer(const wxSockAddress& addr, wxSocketFlags flags) : wxSocketBase(flags, wxSOCKET_SERVER) { - wxLogTrace( wxTRACE_Socket, _T("Opening wxSocketServer") ); + wxLogTrace( wxTRACE_Socket, wxT("Opening wxSocketServer") ); - m_impl = wxSocketImpl::Create(*this); + wxSocketManager * const manager = wxSocketManager::Get(); + m_impl = manager ? manager->CreateSocket(*this) : NULL; if (!m_impl) { - wxLogTrace( wxTRACE_Socket, _T("*** Failed to create m_impl") ); + wxLogTrace( wxTRACE_Socket, wxT("*** Failed to create m_impl") ); return; } @@ -1688,14 +1820,17 @@ wxSocketServer::wxSocketServer(const wxSockAddress& addr, if (m_impl->CreateServer() != wxSOCKET_NOERROR) { - delete m_impl; - m_impl = NULL; + wxDELETE(m_impl); - wxLogTrace( wxTRACE_Socket, _T("*** CreateServer() failed") ); + wxLogTrace( wxTRACE_Socket, wxT("*** CreateServer() failed") ); return; } - wxLogTrace( wxTRACE_Socket, _T("wxSocketServer on fd %d"), m_impl->m_fd ); + // Notice that we need a cast as wxSOCKET_T is 64 bit under Win64 and that + // the cast is safe because a wxSOCKET_T is a handle and so limited to 32 + // (or, actually, even 24) bit values anyhow. + wxLogTrace( wxTRACE_Socket, wxT("wxSocketServer on fd %u"), + static_cast(m_impl->m_fd) ); } // -------------------------------------------------------------------------- @@ -1759,9 +1894,17 @@ bool wxSocketServer::WaitForAccept(long seconds, long milliseconds) return DoWait(seconds, milliseconds, wxSOCKET_CONNECTION_FLAG) == 1; } +wxSOCKET_T wxSocketBase::GetSocket() const +{ + wxASSERT_MSG( m_impl, wxS("Socket not initialised") ); + + return m_impl->m_fd; +} + + bool wxSocketBase::GetOption(int level, int optname, void *optval, int *optlen) { - wxASSERT_MSG( m_impl, _T("Socket not initialised") ); + wxASSERT_MSG( m_impl, wxT("Socket not initialised") ); SOCKOPTLEN_T lenreal = *optlen; if ( getsockopt(m_impl->m_fd, level, optname, @@ -1776,7 +1919,7 @@ bool wxSocketBase::GetOption(int level, int optname, void *optval, int *optlen) bool wxSocketBase::SetOption(int level, int optname, const void *optval, int optlen) { - wxASSERT_MSG( m_impl, _T("Socket not initialised") ); + wxASSERT_MSG( m_impl, wxT("Socket not initialised") ); return setsockopt(m_impl->m_fd, level, optname, static_cast(optval), optlen) == 0; @@ -1823,7 +1966,8 @@ bool wxSocketClient::DoConnect(const wxSockAddress& remote, m_establishing = false; // Create and set up the new one - m_impl = wxSocketImpl::Create(*this); + wxSocketManager * const manager = wxSocketManager::Get(); + m_impl = manager ? manager->CreateSocket(*this) : NULL; if ( !m_impl ) return false; @@ -1905,7 +2049,8 @@ wxDatagramSocket::wxDatagramSocket( const wxSockAddress& addr, : wxSocketBase( flags, wxSOCKET_DATAGRAM ) { // Create the socket - m_impl = wxSocketImpl::Create(*this); + wxSocketManager * const manager = wxSocketManager::Get(); + m_impl = manager ? manager->CreateSocket(*this) : NULL; if (!m_impl) return; @@ -1927,8 +2072,7 @@ wxDatagramSocket::wxDatagramSocket( const wxSockAddress& addr, if ( m_impl->CreateUDP() != wxSOCKET_NOERROR ) { - delete m_impl; - m_impl = NULL; + wxDELETE(m_impl); return; } @@ -1950,7 +2094,7 @@ wxDatagramSocket& wxDatagramSocket::SendTo( const wxSockAddress& addr, const void* buf, wxUint32 nBytes ) { - wxASSERT_MSG( m_impl, _T("Socket not initialised") ); + wxASSERT_MSG( m_impl, wxT("Socket not initialised") ); m_impl->SetPeer(addr.GetAddress()); Write(buf, nBytes); @@ -1983,4 +2127,21 @@ 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 + +// same for ManagerSetter in the MSW file +#ifdef __WINDOWS__ + wxFORCE_LINK_MODULE( mswsocket ) +#endif + +// and for OSXManagerSetter in the OS X one +#ifdef __WXOSX__ + wxFORCE_LINK_MODULE( osxsocket ) +#endif + #endif // wxUSE_SOCKETS