// Copyright: (C) 1999-1997, Guilhem Lavaux
// (C) 1999-2000, Guillermo Rodriguez Garcia
// (C) 2008 Vadim Zeitlin
-// RCS_ID: $Id$
-// License: wxWindows licence
+// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
// ==========================================================================
#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
// 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
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
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 )
{
{
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
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_writing =
m_closed = false;
m_lcount = 0;
+ m_lcount_read = 0;
+ m_lcount_write = 0;
m_timeout = 600;
m_beingDeleted = false;
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
+ // 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;
{
wxSocketReadGuard read(this);
- m_lcount = DoRead(buffer, nbytes);
+ m_lcount_read = DoRead(buffer, nbytes);
+ m_lcount = m_lcount_read;
return *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 )
{
// 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
// 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;
}
// 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;
wxSocketReadGuard read(this);
- wxSocketWaitModeChanger changeFlags(this, wxSOCKET_WAITALL);
+ wxSocketWaitModeChanger changeFlags(this, wxSOCKET_WAITALL_READ);
bool ok = false;
if ( DoRead(&msg, sizeof(msg)) == sizeof(msg) )
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 )
{
{
wxSocketReadGuard read(this);
+ // Peek() should never block
+ wxSocketWaitModeChanger changeFlags(this, wxSOCKET_NOWAIT);
+
m_lcount = DoRead(buffer, nbytes);
Pushback(buffer, m_lcount);
{
wxSocketWriteGuard write(this);
- m_lcount = DoWrite(buffer, nbytes);
+ m_lcount_write = DoWrite(buffer, nbytes);
+ m_lcount = m_lcount_write;
return *this;
}
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;
}
{
if ( m_impl->GetLastError() == wxSOCKET_WOULDBLOCK )
{
- if ( m_flags & wxSOCKET_NOWAIT )
+ if ( m_flags & wxSOCKET_NOWAIT_WRITE )
break;
if ( !DoWaitWithTimeout(wxSOCKET_OUTPUT_FLAG) )
total += ret;
- if ( !(m_flags & wxSOCKET_WAITALL) )
+ if ( !(m_flags & wxSOCKET_WAITALL_WRITE) )
break;
nbytes -= ret;
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;
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;
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);
}
{
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.
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;
}
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<unsigned>(m_impl->m_fd) );
}
// --------------------------------------------------------------------------
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,
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;
if ( m_impl->CreateUDP() != wxSOCKET_NOERROR )
{
- delete m_impl;
- m_impl = NULL;
+ wxDELETE(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 __WINDOWS__
+ 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