#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 __UNIX__
+ #include <errno.h>
+#endif
+
+// we use MSG_NOSIGNAL to avoid getting SIGPIPE when sending data to a remote
+// host which closed the connection if it is available, otherwise we rely on
+// SO_NOSIGPIPE existency
+//
+// 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)
+ #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
+
+ #define wxSOCKET_MSG_NOSIGNAL 0
+#endif
+
// DLL options compatibility check:
#include "wx/build.h"
WX_CHECK_BUILD_OPTIONS("wxNet")
// macros and constants
// --------------------------------------------------------------------------
+// event
+wxDEFINE_EVENT(wxEVT_SOCKET, wxSocketEvent);
+
// discard buffer
#define MAX_DISCARD_SIZE (10 * 1024)
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
// ============================================================================
: m_wxsocket(&wxsocket)
{
m_fd = INVALID_SOCKET;
- m_local = NULL;
- m_peer = NULL;
m_error = wxSOCKET_NOERROR;
m_server = false;
m_stream = true;
wxSocketImpl::~wxSocketImpl()
{
- if (m_fd != INVALID_SOCKET)
+ if ( m_fd != INVALID_SOCKET )
Shutdown();
-
- if (m_local)
- GAddress_destroy(m_local);
-
- if (m_peer)
- GAddress_destroy(m_peer);
}
-bool wxSocketImpl::PreCreateCheck(GAddress *addr)
+bool wxSocketImpl::PreCreateCheck(const wxSockAddressImpl& addr)
{
if ( m_fd != INVALID_SOCKET )
{
return false;
}
- if ( !addr || !addr->m_addr )
+ if ( !addr.IsOk() )
{
m_error = wxSOCKET_INVADDR;
return false;
wxSocketError wxSocketImpl::UpdateLocalAddress()
{
- WX_SOCKLEN_T lenAddr = sizeof(*m_local->m_addr);
- if ( getsockname(m_fd, m_local->m_addr, &lenAddr) != 0 )
+ WX_SOCKLEN_T lenAddr = m_local.GetLen();
+ if ( getsockname(m_fd, m_local.GetWritableAddr(), &lenAddr) != 0 )
{
Close();
m_error = wxSOCKET_IOERR;
return m_error;
}
- m_local->m_len = lenAddr;
-
return wxSOCKET_NOERROR;
}
m_stream = true;
// do create the socket
- m_fd = socket(m_local->m_realfamily, SOCK_STREAM, 0);
+ m_fd = socket(m_local.GetFamily(), SOCK_STREAM, 0);
if ( m_fd == INVALID_SOCKET )
{
// and then bind to and listen on it
//
// FIXME: should we test for m_dobind here?
- if ( bind(m_fd, m_local->m_addr, m_local->m_len) != 0 )
+ if ( bind(m_fd, m_local.GetAddr(), m_local.GetLen()) != 0 )
m_error = wxSOCKET_IOERR;
if ( IsOk() )
if ( !PreCreateCheck(m_peer) )
return m_error;
- m_fd = socket(m_peer->m_realfamily, SOCK_STREAM, 0);
+ m_fd = socket(m_peer.GetFamily(), SOCK_STREAM, 0);
if ( m_fd == INVALID_SOCKET )
{
PostCreation();
// If a local address has been set, then bind to it before calling connect
- if ( m_local && m_local->m_addr )
+ if ( m_local.IsOk() )
{
- if ( bind(m_fd, m_local->m_addr, m_local->m_len) != 0 )
+ if ( bind(m_fd, m_local.GetAddr(), m_local.GetLen()) != 0 )
{
Close();
m_error = wxSOCKET_IOERR;
}
// Do connect now
- int rc = connect(m_fd, m_peer->m_addr, m_peer->m_len);
+ int rc = connect(m_fd, m_peer.GetAddr(), m_peer.GetLen());
if ( rc == SOCKET_ERROR )
{
wxSocketError err = GetLastError();
m_stream = false;
m_server = false;
- m_fd = socket(m_local->m_realfamily, SOCK_DGRAM, 0);
+ m_fd = socket(m_local.GetFamily(), SOCK_DGRAM, 0);
if ( m_fd == INVALID_SOCKET )
{
if ( m_dobind )
{
- if ( bind(m_fd, m_local->m_addr, m_local->m_len) != 0 )
+ if ( bind(m_fd, m_local.GetAddr(), m_local.GetLen()) != 0 )
{
Close();
m_error = wxSOCKET_IOERR;
wxSocketImpl *wxSocketImpl::Accept(wxSocketBase& wxsocket)
{
- wxSockAddr from;
+ wxSockAddressStorage from;
WX_SOCKLEN_T fromlen = sizeof(from);
- const SOCKET fd = accept(m_fd, &from, &fromlen);
+ 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;
wxSocketImpl * const sock = Create(wxsocket);
sock->m_fd = fd;
-
- sock->m_peer = GAddress_new();
- _GAddress_translate_from(sock->m_peer, &from, fromlen);
+ sock->m_peer = wxSockAddressImpl(from.addr, fromlen);
sock->UnblockAndRegisterWithEventLoop();
}
}
-/*
- * Disallow further read/write operations on this socket, close
- * the fd and disable all callbacks.
- */
void wxSocketImpl::Shutdown()
{
if ( m_fd != INVALID_SOCKET )
}
/* Address handling */
+wxSocketError wxSocketImpl::SetLocal(const wxSockAddressImpl& local)
+{
+ /* the socket must be initialized, or it must be a server */
+ if (m_fd != INVALID_SOCKET && !m_server)
+ {
+ m_error = wxSOCKET_INVSOCK;
+ return wxSOCKET_INVSOCK;
+ }
-/*
- * Set or get the local or peer address for this socket. The 'set'
- * functions return wxSOCKET_NOERROR on success, an error code otherwise.
- * The 'get' functions return a pointer to a GAddress object on success,
- * or NULL otherwise, in which case they set the error code of the
- * corresponding socket.
- *
- * Error codes:
- * wxSOCKET_INVSOCK - the socket is not valid.
- * wxSOCKET_INVADDR - the address is not valid.
- */
-wxSocketError wxSocketImpl::SetLocal(GAddress *address)
+ if ( !local.IsOk() )
+ {
+ m_error = wxSOCKET_INVADDR;
+ return wxSOCKET_INVADDR;
+ }
+
+ m_local = local;
+
+ return wxSOCKET_NOERROR;
+}
+
+wxSocketError wxSocketImpl::SetPeer(const wxSockAddressImpl& peer)
+{
+ if ( !peer.IsOk() )
+ {
+ m_error = wxSOCKET_INVADDR;
+ return wxSOCKET_INVADDR;
+ }
+
+ m_peer = peer;
+
+ return wxSOCKET_NOERROR;
+}
+
+const wxSockAddressImpl& wxSocketImpl::GetLocal()
+{
+ if ( !m_local.IsOk() )
+ UpdateLocalAddress();
+
+ return m_local;
+}
+
+// ----------------------------------------------------------------------------
+// wxSocketImpl IO
+// ----------------------------------------------------------------------------
+
+// this macro wraps the given expression (normally a syscall) in a loop which
+// ignores any interruptions, i.e. reevaluates it again if it failed and errno
+// is EINTR
+#ifdef __UNIX__
+ #define DO_WHILE_EINTR( rc, syscall ) \
+ do { \
+ rc = (syscall); \
+ } \
+ while ( rc == -1 && errno == EINTR )
+#else
+ #define DO_WHILE_EINTR( rc, syscall ) rc = (syscall)
+#endif
+
+int wxSocketImpl::RecvStream(void *buffer, int size)
{
- /* the socket must be initialized, or it must be a server */
- if (m_fd != INVALID_SOCKET && !m_server)
- {
- m_error = wxSOCKET_INVSOCK;
- return wxSOCKET_INVSOCK;
- }
+ int ret;
+ DO_WHILE_EINTR( ret, recv(m_fd, static_cast<char *>(buffer), size, 0) );
- /* check address */
- if (address == NULL || address->m_family == wxSOCKET_NOFAMILY)
- {
- m_error = wxSOCKET_INVADDR;
- return wxSOCKET_INVADDR;
- }
+ if ( !ret )
+ {
+ // receiving 0 bytes for a TCP socket indicates that the connection was
+ // closed by peer so shut down our end as well (for UDP sockets empty
+ // datagrams are also possible)
+ m_establishing = false;
+ NotifyOnStateChange(wxSOCKET_LOST);
- if (m_local)
- GAddress_destroy(m_local);
+ Shutdown();
- m_local = GAddress_copy(address);
+ // do not return an error in this case however
+ }
- return wxSOCKET_NOERROR;
+ return ret;
}
-wxSocketError wxSocketImpl::SetPeer(GAddress *address)
+int wxSocketImpl::SendStream(const void *buffer, int size)
{
- /* check address */
- if (address == NULL || address->m_family == wxSOCKET_NOFAMILY)
- {
- m_error = wxSOCKET_INVADDR;
- return wxSOCKET_INVADDR;
- }
+ int ret;
+ DO_WHILE_EINTR( ret, send(m_fd, static_cast<const char *>(buffer), size,
+ wxSOCKET_MSG_NOSIGNAL) );
- if (m_peer)
- GAddress_destroy(m_peer);
+ return ret;
+}
- m_peer = GAddress_copy(address);
+int wxSocketImpl::RecvDgram(void *buffer, int size)
+{
+ wxSockAddressStorage from;
+ WX_SOCKLEN_T fromlen = sizeof(from);
- return wxSOCKET_NOERROR;
+ int ret;
+ DO_WHILE_EINTR( ret, recvfrom(m_fd, static_cast<char *>(buffer), size,
+ 0, &from.addr, &fromlen) );
+
+ if ( ret == SOCKET_ERROR )
+ return SOCKET_ERROR;
+
+ m_peer = wxSockAddressImpl(from.addr, fromlen);
+ if ( !m_peer.IsOk() )
+ return -1;
+
+ return ret;
}
-GAddress *wxSocketImpl::GetLocal()
+int wxSocketImpl::SendDgram(const void *buffer, int size)
{
- GAddress *address;
- wxSockAddr addr;
- WX_SOCKLEN_T size = sizeof(addr);
- wxSocketError err;
+ if ( !m_peer.IsOk() )
+ {
+ m_error = wxSOCKET_INVADDR;
+ return -1;
+ }
- /* try to get it from the m_local var first */
- if (m_local)
- return GAddress_copy(m_local);
+ int ret;
+ DO_WHILE_EINTR( ret, sendto(m_fd, static_cast<const char *>(buffer), size,
+ 0, m_peer.GetAddr(), m_peer.GetLen()) );
- /* else, if the socket is initialized, try getsockname */
- if (m_fd == INVALID_SOCKET)
- {
- m_error = wxSOCKET_INVSOCK;
- return NULL;
- }
+ return ret;
+}
- if (getsockname(m_fd, (sockaddr*)&addr, &size) == SOCKET_ERROR)
- {
- m_error = wxSOCKET_IOERR;
- return NULL;
- }
+int wxSocketImpl::Read(void *buffer, int size)
+{
+ // server sockets can't be used for IO, only to accept new connections
+ if ( m_fd == INVALID_SOCKET || m_server )
+ {
+ m_error = wxSOCKET_INVSOCK;
+ return -1;
+ }
- /* got a valid address from getsockname, create a GAddress object */
- if ((address = GAddress_new()) == NULL)
- {
- m_error = wxSOCKET_MEMERR;
- return NULL;
- }
+ int ret = m_stream ? RecvStream(buffer, size)
+ : RecvDgram(buffer, size);
- if ((err = _GAddress_translate_from(address, (sockaddr*)&addr, size)) != wxSOCKET_NOERROR)
- {
- GAddress_destroy(address);
- m_error = err;
- return NULL;
- }
+ m_error = ret == SOCKET_ERROR ? GetLastError() : wxSOCKET_NOERROR;
- return address;
+ return ret;
}
-GAddress *wxSocketImpl::GetPeer()
+int wxSocketImpl::Write(const void *buffer, int size)
{
- /* try to get it from the m_peer var */
- if (m_peer)
- return GAddress_copy(m_peer);
+ if ( m_fd == INVALID_SOCKET || m_server )
+ {
+ m_error = wxSOCKET_INVSOCK;
+ return -1;
+ }
- return NULL;
+ int ret = m_stream ? SendStream(buffer, size)
+ : SendDgram(buffer, size);
+
+ m_error = ret == SOCKET_ERROR ? GetLastError() : wxSOCKET_NOERROR;
+
+ return ret;
}
// ==========================================================================
void wxSocketBase::Init()
{
- m_impl = NULL;
+ m_impl = NULL;
m_type = wxSOCKET_UNINIT;
// state
{
// 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");
}
}
// Interrupt pending waits
InterruptWait();
- if (m_impl)
- m_impl->Shutdown();
+ ShutdownOutput();
m_connected = false;
m_establishing = false;
return true;
}
+void wxSocketBase::ShutdownOutput()
+{
+ if ( m_impl )
+ m_impl->Shutdown();
+}
+
wxSocketBase& wxSocketBase::Read(void* buffer, wxUint32 nbytes)
{
- // Mask read events
- m_reading = true;
+ wxSocketReadGuard read(this);
m_lcount = DoRead(buffer, nbytes);
- // Allow read events from now on
- m_reading = false;
-
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_);
+ 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
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 ( 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;
+
+ // 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;
+ }
- if ( ret == -1 )
+ // retry reading
+ continue;
+ }
+ else // "real" error
{
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;
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) )
if ( !ok )
SetError(wxSOCKET_IOERR);
- m_reading = false;
- SetFlags(old_flags);
-
return *this;
}
wxSocketBase& wxSocketBase::Peek(void* buffer, wxUint32 nbytes)
{
- // Mask read events
- m_reading = true;
+ wxSocketReadGuard read(this);
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)
{
- // Mask write events
- m_writing = true;
+ wxSocketWriteGuard write(this);
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
-// 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)
{
- 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;
- 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);
+ 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 ( ret == -1 )
+ if ( !DoWaitWithTimeout(wxSOCKET_OUTPUT_FLAG) )
+ {
+ SetError(wxSOCKET_TIMEDOUT);
+ break;
+ }
+
+ continue;
+ }
+ else // "real" error
{
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;
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;
if ( !ok )
SetError(wxSOCKET_IOERR);
- m_writing = false;
- SetFlags(old_flags);
-
return *this;
}
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
{
m_lcount = total;
SetError(wxSOCKET_NOERROR);
- // Allow read events again
- m_reading = false;
-
- SetFlags(old_flags);
-
return *this;
}
return detected & flags;
}
-bool
+int
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;
+
+ 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
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)
- 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 )
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 )
{
{
m_connected = false;
m_establishing = false;
- if ( flags & wxSOCKET_LOST_FLAG )
- gotEvent = true;
+ rc = -1;
break;
}
{
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) )
{
- gotEvent = true;
+ rc = true;
break;
}
}
- return gotEvent;
+ return rc;
}
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)
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)
{
- 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)
{
- return DoWait(seconds, milliseconds, wxSOCKET_LOST_FLAG);
+ return DoWait(seconds, milliseconds, wxSOCKET_LOST_FLAG) == -1;
}
// --------------------------------------------------------------------------
// Get local or peer address
//
-bool wxSocketBase::GetPeer(wxSockAddress& addr_man) const
+bool wxSocketBase::GetPeer(wxSockAddress& addr) const
{
- GAddress *peer;
+ wxCHECK_MSG( m_impl, false, "invalid socket" );
- if (!m_impl)
+ const wxSockAddressImpl& peer = m_impl->GetPeer();
+ if ( !peer.IsOk() )
return false;
- peer = m_impl->GetPeer();
-
- // copying a null address would just trigger an assert anyway
-
- if (!peer)
- return false;
-
- addr_man.SetAddress(peer);
- GAddress_destroy(peer);
+ addr.SetAddress(peer);
return true;
}
-bool wxSocketBase::GetLocal(wxSockAddress& addr_man) const
+bool wxSocketBase::GetLocal(wxSockAddress& addr) const
{
- GAddress *local;
+ wxCHECK_MSG( m_impl, false, "invalid socket" );
- if (!m_impl)
+ const wxSockAddressImpl& local = m_impl->GetLocal();
+ if ( !local.IsOk() )
return false;
- local = m_impl->GetLocal();
- addr_man.SetAddress(local);
- GAddress_destroy(local);
+ addr.SetAddress(local);
return true;
}
// 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);
// Ctor
// --------------------------------------------------------------------------
-wxSocketServer::wxSocketServer(const wxSockAddress& addr_man,
+wxSocketServer::wxSocketServer(const wxSockAddress& addr,
wxSocketFlags flags)
: wxSocketBase(flags, wxSOCKET_SERVER)
{
}
// Setup the socket as server
- m_impl->SetLocal(addr_man.GetAddress());
+ m_impl->SetLocal(addr.GetAddress());
if (GetFlags() & wxSOCKET_REUSEADDR) {
m_impl->SetReusable();
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::SetLocal(const wxIPV4address& local)
{
- GAddress* la = local.GetAddress();
-
- // If the address is valid, save it for use when we call Connect
- if (la && la->m_addr)
- {
- m_localAddress = local;
-
- return true;
- }
+ m_localAddress = local;
- return false;
+ return true;
}
// ==========================================================================
m_initialSendBufferSize = -1;
}
-wxSocketClient::~wxSocketClient()
-{
-}
-
// --------------------------------------------------------------------------
// Connect
// --------------------------------------------------------------------------
// Bind to the local IP address and port, when provided or if one had been
// set before
- if ( !local && m_localAddress.GetAddress() )
+ if ( !local && m_localAddress.GetAddress().IsOk() )
local = &m_localAddress;
if ( local )
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;
}
// ==========================================================================
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
projects / wxWidgets.git / blobdiff