#include "wx/sckaddr.h"
#include "wx/socket.h"
+#include "wx/stopwatch.h"
// DLL options compatibility check:
#include "wx/build.h"
{
if ( !m_countInit++ )
{
-#ifdef __WXMSW__
- /*
- The following asserting might be neccessary for linux as well,
- but I cannot verify this.
- */
- wxASSERT(wxThread::IsMain(),
- wxT("To use sockets in a secondary thread, ")
- wxT("call wxSocketBase::Initialize() from the main thread."));
/*
Details: Initialize() creates a hidden window as a sink for socket
events, such as 'read completed'. wxMSW has only one message loop
since there is no message loop on this thread, it will never
receive events and all socket operations will time out.
BTW, the main thread must not be stopped using sleep or block
- on a semaphore (a bad idea in any case) or socket operations
+ on a semaphore (a bad idea in any case) or socket operations
will time out.
+
+ On the Mac side, Initialize() stores a pointer to the CFRunLoop for
+ the main thread. Because secondary threads do not have run loops,
+ adding event notifications to the "Current" loop would have no
+ effect at all, events would never fire.
*/
-#endif
+ wxASSERT_MSG( wxIsMainThread(),
+ wxT("Call wxSocketBase::Initialize() from the main thread first!"));
+
wxAppTraits *traits = wxAppConsole::GetInstance() ?
wxAppConsole::GetInstance()->GetTraits() : NULL;
- GSocketGUIFunctionsTable *functions =
+ GSocketGUIFunctionsTable *functions =
traits ? traits->GetSocketGUIFunctionsTable() : NULL;
GSocket_SetGUIFunctions(functions);
-
+
if ( !GSocket_Init() )
{
m_countInit--;
- return FALSE;
+ return false;
}
}
- return TRUE;
+ return true;
}
void wxSocketBase::Shutdown()
m_establishing =
m_reading =
m_writing =
- m_error = FALSE;
+ m_error = false;
m_lcount = 0;
m_timeout = 600;
- m_beingDeleted = FALSE;
+ m_beingDeleted = false;
// pushback buffer
m_unread = NULL;
m_unrd_cur = 0;
// events
- m_id = -1;
+ m_id = wxID_ANY;
m_handler = NULL;
m_clientData = NULL;
- m_notify = FALSE;
+ m_notify = false;
m_eventmask = 0;
if ( !IsInitialized() )
// Destroy the GSocket object
if (m_socket)
- GSocket_destroy(m_socket);
+ delete m_socket;
// Free the pushback buffer
if (m_unread)
// Delayed destruction: the socket will be deleted during the next
// idle loop iteration. This ensures that all pending events have
// been processed.
- m_beingDeleted = TRUE;
+ m_beingDeleted = true;
// Shutdown and close the socket
Close();
// Supress events from now on
- Notify(FALSE);
+ Notify(false);
// schedule this object for deletion
wxAppTraits *traits = wxTheApp ? wxTheApp->GetTraits() : NULL;
delete this;
}
- return TRUE;
+ return true;
}
// --------------------------------------------------------------------------
if (m_socket)
{
// Disable callbacks
- GSocket_UnsetCallback(m_socket, GSOCK_INPUT_FLAG | GSOCK_OUTPUT_FLAG |
+ m_socket->UnsetCallback(GSOCK_INPUT_FLAG | GSOCK_OUTPUT_FLAG |
GSOCK_LOST_FLAG | GSOCK_CONNECTION_FLAG);
// Shutdown the connection
- GSocket_Shutdown(m_socket);
+ m_socket->Shutdown();
}
- m_connected = FALSE;
- m_establishing = FALSE;
- return TRUE;
+ m_connected = false;
+ m_establishing = false;
+ return true;
}
wxSocketBase& wxSocketBase::Read(void* buffer, wxUint32 nbytes)
{
// Mask read events
- m_reading = TRUE;
+ m_reading = true;
m_lcount = _Read(buffer, nbytes);
m_error = (m_lcount == 0);
// Allow read events from now on
- m_reading = FALSE;
+ m_reading = false;
return *this;
}
int total;
// Try the pushback buffer first
- total = GetPushback(buffer, nbytes, FALSE);
+ total = GetPushback(buffer, nbytes, false);
nbytes -= total;
buffer = (char *)buffer + total;
int ret;
if (m_flags & wxSOCKET_NOWAIT)
{
- GSocket_SetNonBlocking(m_socket, 1);
- ret = GSocket_Read(m_socket, (char *)buffer, nbytes);
- GSocket_SetNonBlocking(m_socket, 0);
+ m_socket->SetNonBlocking(1);
+ ret = m_socket->Read((char *)buffer, nbytes);
+ m_socket->SetNonBlocking(0);
if (ret > 0)
total += ret;
}
else
{
- bool more = TRUE;
+ bool more = true;
while (more)
{
if ( !(m_flags & wxSOCKET_BLOCK) && !WaitForRead() )
break;
- ret = GSocket_Read(m_socket, (char *)buffer, nbytes);
+ ret = m_socket->Read((char *)buffer, nbytes);
if (ret > 0)
{
} msg;
// Mask read events
- m_reading = TRUE;
+ m_reading = true;
total = 0;
- error = TRUE;
+ error = true;
old_flags = m_flags;
SetFlags((m_flags & wxSOCKET_BLOCK) | wxSOCKET_WAITALL);
}
// everything was OK
- error = FALSE;
+ error = false;
exit:
m_error = error;
m_lcount = total;
- m_reading = FALSE;
+ m_reading = false;
SetFlags(old_flags);
return *this;
wxSocketBase& wxSocketBase::Peek(void* buffer, wxUint32 nbytes)
{
// Mask read events
- m_reading = TRUE;
+ m_reading = true;
m_lcount = _Read(buffer, nbytes);
Pushback(buffer, m_lcount);
m_error = (m_lcount == 0);
// Allow read events again
- m_reading = FALSE;
+ m_reading = false;
return *this;
}
wxSocketBase& wxSocketBase::Write(const void *buffer, wxUint32 nbytes)
{
// Mask write events
- m_writing = TRUE;
+ m_writing = true;
m_lcount = _Write(buffer, nbytes);
m_error = (m_lcount == 0);
// Allow write events again
- m_writing = FALSE;
+ m_writing = false;
return *this;
}
int ret;
if (m_flags & wxSOCKET_NOWAIT)
{
- GSocket_SetNonBlocking(m_socket, 1);
- ret = GSocket_Write(m_socket, (const char *)buffer, nbytes);
- GSocket_SetNonBlocking(m_socket, 0);
+ m_socket->SetNonBlocking(1);
+ ret = m_socket->Write((const char *)buffer, nbytes);
+ m_socket->SetNonBlocking(0);
if (ret > 0)
total = ret;
}
else
{
- bool more = TRUE;
+ bool more = true;
while (more)
{
if ( !(m_flags & wxSOCKET_BLOCK) && !WaitForWrite() )
break;
- ret = GSocket_Write(m_socket, (const char *)buffer, nbytes);
+ ret = m_socket->Write((const char *)buffer, nbytes);
if (ret > 0)
{
} msg;
// Mask write events
- m_writing = TRUE;
+ m_writing = true;
- error = TRUE;
+ error = true;
total = 0;
SetFlags((m_flags & wxSOCKET_BLOCK) | wxSOCKET_WAITALL);
goto exit;
// everything was OK
- error = FALSE;
+ error = false;
exit:
m_error = error;
m_lcount = total;
- m_writing = FALSE;
+ m_writing = false;
return *this;
}
if (nbytes != 0)
Pushback(buffer, nbytes);
- m_error = FALSE;
+ m_error = false;
m_lcount = nbytes;
return *this;
wxUint32 total = 0;
// Mask read events
- m_reading = TRUE;
+ m_reading = true;
SetFlags(wxSOCKET_NOWAIT);
delete[] buffer;
m_lcount = total;
- m_error = FALSE;
+ m_error = false;
// Allow read events again
- m_reading = FALSE;
+ m_reading = false;
return *this;
}
GSocketEventFlags result;
long timeout;
- // Set this to TRUE to interrupt ongoing waits
- m_interrupt = FALSE;
+ // Set this to true to interrupt ongoing waits
+ m_interrupt = false;
// Check for valid socket
if (!m_socket)
- return FALSE;
+ return false;
// Check for valid timeout value.
if (seconds != -1)
timeout = m_timeout * 1000;
#if !defined(wxUSE_GUI) || !wxUSE_GUI
- GSocket_SetTimeout(m_socket, timeout);
-#endif
+ m_socket->SetTimeout(timeout);
+#endif
// Wait in an active polling loop.
//
// we are just polling). Also, if just polling, do not yield.
wxStopWatch chrono;
- bool done = FALSE;
+ bool done = false;
while (!done)
{
- result = GSocket_Select(m_socket, flags | GSOCK_LOST_FLAG);
+ result = m_socket->Select(flags | GSOCK_LOST_FLAG);
// Incoming connection (server) or connection established (client)
if (result & GSOCK_CONNECTION_FLAG)
{
- m_connected = TRUE;
- m_establishing = FALSE;
- return TRUE;
+ m_connected = true;
+ m_establishing = false;
+ return true;
}
// Data available or output buffer ready
if ((result & GSOCK_INPUT_FLAG) || (result & GSOCK_OUTPUT_FLAG))
{
- return TRUE;
+ return true;
}
// Connection lost
if (result & GSOCK_LOST_FLAG)
{
- m_connected = FALSE;
- m_establishing = FALSE;
+ m_connected = false;
+ m_establishing = false;
return (flags & GSOCK_LOST_FLAG) != 0;
}
// Wait more?
if ((!timeout) || (chrono.Time() > timeout) || (m_interrupt))
- done = TRUE;
+ done = true;
else
PROCESS_EVENTS();
}
- return FALSE;
+ return false;
}
bool wxSocketBase::Wait(long seconds, long milliseconds)
{
// Check pushback buffer before entering _Wait
if (m_unread)
- return TRUE;
+ return true;
// Note that GSOCK_INPUT_LOST has to be explicitly passed to
// _Wait becuase of the semantics of WaitForRead: a return
- // value of TRUE means that a GSocket_Read call will return
+ // value of true means that a GSocket_Read call will return
// immediately, not that there is actually data to read.
return _Wait(seconds, milliseconds, GSOCK_INPUT_FLAG |
GAddress *peer;
if (!m_socket)
- return FALSE;
+ return false;
- peer = GSocket_GetPeer(m_socket);
+ peer = m_socket->GetPeer();
// copying a null address would just trigger an assert anyway
if (!peer)
- return FALSE;
+ return false;
addr_man.SetAddress(peer);
GAddress_destroy(peer);
- return TRUE;
+ return true;
}
bool wxSocketBase::GetLocal(wxSockAddress& addr_man) const
GAddress *local;
if (!m_socket)
- return FALSE;
+ return false;
- local = GSocket_GetLocal(m_socket);
+ local = m_socket->GetLocal();
addr_man.SetAddress(local);
GAddress_destroy(local);
- return TRUE;
+ return true;
}
//
m_notify = state->m_notify;
m_eventmask = state->m_eventmask;
m_clientData = state->m_clientData;
-
+
m_states.Erase(node);
delete state;
}
m_timeout = seconds;
if (m_socket)
- GSocket_SetTimeout(m_socket, m_timeout * 1000);
+ m_socket->SetTimeout(m_timeout * 1000);
}
void wxSocketBase::SetFlags(wxSocketFlags flags)
switch(notification)
{
case wxSOCKET_CONNECTION:
- m_establishing = FALSE;
- m_connected = TRUE;
+ m_establishing = false;
+ m_connected = true;
break;
// If we are in the middle of a R/W operation, do not
// which are no longer valid.
case wxSOCKET_INPUT:
- if (m_reading || !GSocket_Select(m_socket, GSOCK_INPUT_FLAG))
+ if (m_reading || !m_socket->Select(GSOCK_INPUT_FLAG))
return;
break;
case wxSOCKET_OUTPUT:
- if (m_writing || !GSocket_Select(m_socket, GSOCK_OUTPUT_FLAG))
+ if (m_writing || !m_socket->Select(GSOCK_OUTPUT_FLAG))
return;
break;
case wxSOCKET_LOST:
- m_connected = FALSE;
- m_establishing = FALSE;
+ m_connected = false;
+ m_establishing = false;
break;
default:
// Setup the socket as server
- GSocket_SetLocal(m_socket, addr_man.GetAddress());
- if (GSocket_SetServer(m_socket) != GSOCK_NOERROR)
+ m_socket->SetLocal(addr_man.GetAddress());
+
+ if (GetFlags() & wxSOCKET_REUSEADDR) {
+ m_socket->SetReusable();
+ }
+
+ if (m_socket->SetServer() != GSOCK_NOERROR)
{
- GSocket_destroy(m_socket);
+ delete m_socket;
m_socket = NULL;
wxLogTrace( wxTRACE_Socket, _T("*** GSocket_SetServer failed") );
return;
}
- GSocket_SetTimeout(m_socket, m_timeout * 1000);
- GSocket_SetCallback(m_socket, GSOCK_INPUT_FLAG | GSOCK_OUTPUT_FLAG |
+ m_socket->SetTimeout(m_timeout * 1000);
+ m_socket->SetCallback(GSOCK_INPUT_FLAG | GSOCK_OUTPUT_FLAG |
GSOCK_LOST_FLAG | GSOCK_CONNECTION_FLAG,
wx_socket_callback, (char *)this);
}
GSocket *child_socket;
if (!m_socket)
- return FALSE;
+ return false;
- // If wait == FALSE, then the call should be nonblocking.
+ // If wait == false, then the call should be nonblocking.
// When we are finished, we put the socket to blocking mode
// again.
if (!wait)
- GSocket_SetNonBlocking(m_socket, 1);
+ m_socket->SetNonBlocking(1);
- child_socket = GSocket_WaitConnection(m_socket);
+ child_socket = m_socket->WaitConnection();
if (!wait)
- GSocket_SetNonBlocking(m_socket, 0);
+ m_socket->SetNonBlocking(0);
if (!child_socket)
- return FALSE;
+ return false;
sock.m_type = wxSOCKET_BASE;
sock.m_socket = child_socket;
- sock.m_connected = TRUE;
+ sock.m_connected = true;
- GSocket_SetTimeout(sock.m_socket, sock.m_timeout * 1000);
- GSocket_SetCallback(sock.m_socket, GSOCK_INPUT_FLAG | GSOCK_OUTPUT_FLAG |
+ sock.m_socket->SetTimeout(sock.m_timeout * 1000);
+ sock.m_socket->SetCallback(GSOCK_INPUT_FLAG | GSOCK_OUTPUT_FLAG |
GSOCK_LOST_FLAG | GSOCK_CONNECTION_FLAG,
wx_socket_callback, (char *)&sock);
- return TRUE;
+ return true;
}
wxSocketBase *wxSocketServer::Accept(bool wait)
bool wxSocketBase::GetOption(int level, int optname, void *optval, int *optlen)
{
- if (GSocket_GetSockOpt(m_socket, level, optname, optval, optlen)
+ wxASSERT_MSG( m_socket, _T("Socket not initialised") );
+
+ if (m_socket->GetSockOpt(level, optname, optval, optlen)
!= GSOCK_NOERROR)
{
- return FALSE;
+ return false;
}
- return TRUE;
+ return true;
}
-bool wxSocketBase::SetOption(int level, int optname, const void *optval,
+bool wxSocketBase::SetOption(int level, int optname, const void *optval,
int optlen)
{
- if (GSocket_SetSockOpt(m_socket, level, optname, optval, optlen)
+ wxASSERT_MSG( m_socket, _T("Socket not initialised") );
+
+ if (m_socket->SetSockOpt(level, optname, optval, optlen)
!= GSOCK_NOERROR)
{
- return FALSE;
+ return false;
}
- return TRUE;
+ return true;
}
// ==========================================================================
{
// Shutdown and destroy the socket
Close();
- GSocket_destroy(m_socket);
+ delete m_socket;
}
m_socket = GSocket_new();
- m_connected = FALSE;
- m_establishing = FALSE;
+ m_connected = false;
+ m_establishing = false;
if (!m_socket)
- return FALSE;
+ return false;
- GSocket_SetTimeout(m_socket, m_timeout * 1000);
- GSocket_SetCallback(m_socket, GSOCK_INPUT_FLAG | GSOCK_OUTPUT_FLAG |
+ m_socket->SetTimeout(m_timeout * 1000);
+ m_socket->SetCallback(GSOCK_INPUT_FLAG | GSOCK_OUTPUT_FLAG |
GSOCK_LOST_FLAG | GSOCK_CONNECTION_FLAG,
wx_socket_callback, (char *)this);
- // If wait == FALSE, then the call should be nonblocking.
+ // If wait == false, then the call should be nonblocking.
// When we are finished, we put the socket to blocking mode
// again.
if (!wait)
- GSocket_SetNonBlocking(m_socket, 1);
+ m_socket->SetNonBlocking(1);
- GSocket_SetPeer(m_socket, addr_man.GetAddress());
- err = GSocket_Connect(m_socket, GSOCK_STREAMED);
+ m_socket->SetPeer(addr_man.GetAddress());
+ err = m_socket->Connect(GSOCK_STREAMED);
if (!wait)
- GSocket_SetNonBlocking(m_socket, 0);
+ m_socket->SetNonBlocking(0);
if (err != GSOCK_NOERROR)
{
if (err == GSOCK_WOULDBLOCK)
- m_establishing = TRUE;
+ m_establishing = true;
- return FALSE;
+ return false;
}
- m_connected = TRUE;
- return TRUE;
+ m_connected = true;
+ return true;
}
bool wxSocketClient::WaitOnConnect(long seconds, long milliseconds)
{
if (m_connected) // Already connected
- return TRUE;
+ return true;
if (!m_establishing || !m_socket) // No connection in progress
- return FALSE;
+ return false;
return _Wait(seconds, milliseconds, GSOCK_CONNECTION_FLAG |
GSOCK_LOST_FLAG);
return;
}
// Setup the socket as non connection oriented
- GSocket_Unstreamed(m_socket);
- GSocket_SetLocal(m_socket, addr.GetAddress());
- if( GSocket_SetNonOriented(m_socket) != GSOCK_NOERROR )
+ m_socket->SetLocal(addr.GetAddress());
+ if( m_socket->SetNonOriented() != GSOCK_NOERROR )
{
- GSocket_destroy(m_socket);
+ delete m_socket;
m_socket = NULL;
return;
}
// Initialize all stuff
- m_connected = FALSE;
- m_establishing = FALSE;
- GSocket_SetTimeout( m_socket, m_timeout );
- GSocket_SetCallback( m_socket, GSOCK_INPUT_FLAG | GSOCK_OUTPUT_FLAG |
+ m_connected = false;
+ m_establishing = false;
+ m_socket->SetTimeout( m_timeout );
+ m_socket->SetCallback( GSOCK_INPUT_FLAG | GSOCK_OUTPUT_FLAG |
GSOCK_LOST_FLAG | GSOCK_CONNECTION_FLAG,
wx_socket_callback, (char*)this );
const void* buf,
wxUint32 nBytes )
{
- GSocket_SetPeer(m_socket, addr.GetAddress());
+ wxASSERT_MSG( m_socket, _T("Socket not initialised") );
+
+ m_socket->SetPeer(addr.GetAddress());
Write(buf, nBytes);
return (*this);
}
virtual bool OnInit()
{
// wxSocketBase will call GSocket_Init() itself when/if needed
- return TRUE;
+ return true;
}
virtual void OnExit()
projects / wxWidgets.git / blobdiff