#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"
#ifdef MSG_NOSIGNAL
#define wxSOCKET_MSG_NOSIGNAL MSG_NOSIGNAL
#else // MSG_NOSIGNAL not available (BSD including OS X)
- #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
+ // 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)
+ 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
// 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
public:
wxSocketState() : wxObject() {}
- DECLARE_NO_COPY_CLASS(wxSocketState)
+ wxDECLARE_NO_COPY_CLASS(wxSocketState);
};
// wxSocketWaitModeChanger: temporarily change the socket flags affecting its
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
{
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
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);
};
// ============================================================================
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 )
{
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);
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<const char *>(buffer), size,
wxSOCKET_MSG_NOSIGNAL) );
// 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" );
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"));
+ }
}
}
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();
delete m_impl;
// Free the pushback buffer
- if (m_unread)
- free(m_unread);
+ free(m_unread);
}
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
+ // possible as we may have other events pending for it
+ if ( 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;
// 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 )
{
wxSocketReadGuard read(this);
+ // Peek() should never block
+ wxSocketWaitModeChanger changeFlags(this, wxSOCKET_NOWAIT);
+
m_lcount = DoRead(buffer, nbytes);
Pushback(buffer, m_lcount);
wxUint32 total = 0;
while ( nbytes )
{
- if ( !m_connected )
+ if ( m_impl->m_stream && !m_connected )
{
if ( (m_flags & wxSOCKET_WAITALL) || !total )
SetError(wxSOCKET_IOERR);
{
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 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)
+ if ( !m_impl->IsServer() && !m_connected && !m_establishing )
return -1;
// This can be set to true from Interrupt() to exit this function a.s.a.p.
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)
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;
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;
}
delete m_impl;
m_impl = NULL;
- 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 );
+ wxLogTrace( wxTRACE_Socket, wxT("wxSocketServer on fd %d"), 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,
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<const char *>(optval), optlen) == 0;
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;
: 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;
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);
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 __WXMSW__
+ wxFORCE_LINK_MODULE( mswsocket )
+#endif
+
+// and for OSXManagerSetter in the OS X one
+#ifdef __WXOSX__
+ wxFORCE_LINK_MODULE( osxsocket )
+#endif
+
#endif // wxUSE_SOCKETS
projects / wxWidgets.git / blobdiff