// (C) 1999-2000, Guillermo Rodriguez Garcia
// (C) 2008 Vadim Zeitlin
// RCS_ID: $Id$
-// License: wxWindows licence
+// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
// ==========================================================================
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
{
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
m_writing =
m_closed = false;
m_lcount = 0;
+ m_lcount_read = 0;
+ m_lcount_write = 0;
m_timeout = 600;
m_beingDeleted = false;
Notify(false);
// Schedule this object for deletion instead of destroying it right now if
- // possible as we may have other events pending for it
- if ( wxTheApp )
+ // 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 )
{
wxTheApp->ScheduleForDestruction(this);
}
{
wxSocketReadGuard read(this);
- m_lcount = DoRead(buffer, nbytes);
+ m_lcount_read = DoRead(buffer, nbytes);
+ m_lcount = m_lcount_read;
return *this;
}
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;
}
{
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 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 )
+ // 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.
if (m_impl->CreateServer() != wxSOCKET_NOERROR)
{
- delete m_impl;
- m_impl = NULL;
+ wxDELETE(m_impl);
wxLogTrace( wxTRACE_Socket, wxT("*** CreateServer() failed") );
return;
}
- wxLogTrace( wxTRACE_Socket, wxT("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, wxT("Socket not initialised") );
if ( m_impl->CreateUDP() != wxSOCKET_NOERROR )
{
- delete m_impl;
- m_impl = NULL;
+ wxDELETE(m_impl);
return;
}
#endif
// same for ManagerSetter in the MSW file
-#ifdef __WXMSW__
+#ifdef __WINDOWS__
wxFORCE_LINK_MODULE( mswsocket )
#endif
// and for OSXManagerSetter in the OS X one
-#ifdef __WXMAC__
+#ifdef __WXOSX__
wxFORCE_LINK_MODULE( osxsocket )
#endif
projects / wxWidgets.git / blobdiff