/////////////////////////////////////////////////////////////////////////////
-// Name: socket.cpp
+// Name: src/common/socket.cpp
// Purpose: Socket handler classes
// Authors: Guilhem Lavaux, Guillermo Rodriguez Garcia
// Created: April 1997
// Copyright: (C) 1999-1997, Guilhem Lavaux
// (C) 2000-1999, Guillermo Rodriguez Garcia
// RCS_ID: $Id$
-// License: see wxWindows license
+// License: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
// ==========================================================================
// Declarations
// ==========================================================================
-#ifdef __GNUG__
-#pragma implementation "socket.h"
-#endif
-
// For compilers that support precompilation, includes "wx.h".
#include "wx/wxprec.h"
#ifdef __BORLANDC__
-#pragma hdrstop
+ #pragma hdrstop
#endif
#if wxUSE_SOCKETS
-#include "wx/app.h"
-#include "wx/defs.h"
-#include "wx/object.h"
-#include "wx/string.h"
-#include "wx/timer.h"
-#include "wx/utils.h"
-#include "wx/module.h"
-#include "wx/log.h"
-#include "wx/intl.h"
-#include "wx/event.h"
+#include "wx/socket.h"
-#if wxUSE_GUI
- #include "wx/gdicmn.h" // for wxPendingDelete
-#endif // wxUSE_GUI
+#ifndef WX_PRECOMP
+ #include "wx/object.h"
+ #include "wx/string.h"
+ #include "wx/intl.h"
+ #include "wx/log.h"
+ #include "wx/event.h"
+ #include "wx/app.h"
+ #include "wx/utils.h"
+ #include "wx/timer.h"
+#endif
+
+#include "wx/apptrait.h"
+#include "wx/module.h"
#include "wx/sckaddr.h"
-#include "wx/socket.h"
+#include "wx/datetime.h"
+
+// DLL options compatibility check:
+#include "wx/build.h"
+WX_CHECK_BUILD_OPTIONS("wxNet")
// --------------------------------------------------------------------------
// macros and constants
// discard buffer
#define MAX_DISCARD_SIZE (10 * 1024)
-// what to do within waits: in wxBase we don't do anything as we don't have
-// the event loop anyhow (for now). In GUI apps we have 2 cases: from the main
-// thread itself we have to call wxYield() to let the events (including the
-// GUI events and the low-level (not wxWindows) events from GSocket) be
-// processed. From another thread it is enough to just call wxThread::Yield()
-// which will give away the rest of our time slice: the explanation is that
-// the events will be processed by the main thread anyhow, without calling
-// wxYield(), but we don't want to eat the CPU time uselessly while sitting
-// in the loop waiting for the data
-#if wxUSE_GUI
- #if wxUSE_THREADS
- #define PROCESS_EVENTS() \
- { \
- if ( wxThread::IsMain() ) \
- wxYield(); \
- else \
- wxThread::Yield(); \
- }
- #else // !wxUSE_THREADS
- #define PROCESS_EVENTS() wxYield()
- #endif // wxUSE_THREADS/!wxUSE_THREADS
-#else // !wxUSE_GUI
- #define PROCESS_EVENTS()
-#endif // wxUSE_GUI/!wxUSE_GUI
+// what to do within waits: we have 2 cases: from the main thread itself we
+// have to call wxYield() to let the events (including the GUI events and the
+// low-level (not wxWidgets) events from GSocket) be processed. From another
+// thread it is enough to just call wxThread::Yield() which will give away the
+// rest of our time slice: the explanation is that the events will be processed
+// by the main thread anyhow, without calling wxYield(), but we don't want to
+// eat the CPU time uselessly while sitting in the loop waiting for the data
+#if wxUSE_THREADS
+ #define PROCESS_EVENTS() \
+ { \
+ if ( wxThread::IsMain() ) \
+ wxYield(); \
+ else \
+ wxThread::Yield(); \
+ }
+#else // !wxUSE_THREADS
+ #define PROCESS_EVENTS() wxYield()
+#endif // wxUSE_THREADS/!wxUSE_THREADS
#define wxTRACE_Socket _T("wxSocket")
wxSocketEventFlags m_eventmask;
bool m_notify;
void *m_clientData;
-#if WXWIN_COMPATIBILITY
- wxSocketBase::wxSockCbk m_cbk;
- char *m_cdata;
-#endif // WXWIN_COMPATIBILITY
public:
wxSocketState() : wxObject() {}
+
+ DECLARE_NO_COPY_CLASS(wxSocketState)
};
// ==========================================================================
{
if ( !m_countInit++ )
{
+ /*
+ Details: Initialize() creates a hidden window as a sink for socket
+ events, such as 'read completed'. wxMSW has only one message loop
+ for the main thread. If Initialize is called in a secondary thread,
+ the socket window will be created for the secondary thread, but
+ 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
+ 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.
+ */
+ wxASSERT_MSG( wxIsMainThread(),
+ wxT("Call wxSocketBase::Initialize() from the main thread first!"));
+
+ wxAppTraits *traits = wxAppConsole::GetInstance() ?
+ wxAppConsole::GetInstance()->GetTraits() : NULL;
+ 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()
{
// we should be initialized
wxASSERT_MSG( m_countInit, _T("extra call to Shutdown()") );
- if ( !--m_countInit )
+ if ( --m_countInit == 0 )
{
GSocket_Cleanup();
}
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 WXWIN_COMPATIBILITY
- m_cbk = NULL;
- m_cdata = NULL;
-#endif // WXWIN_COMPATIBILITY
if ( !IsInitialized() )
{
{
// Just in case the app called Destroy() *and* then deleted
// the socket immediately: don't leave dangling pointers.
-#if wxUSE_GUI
- wxPendingDelete.DeleteObject(this);
-#endif
+ wxAppTraits *traits = wxTheApp ? wxTheApp->GetTraits() : NULL;
+ if ( traits )
+ traits->RemoveFromPendingDelete(this);
// Shutdown and close the socket
if (!m_beingDeleted)
// 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);
-#if wxUSE_GUI
- if ( !wxPendingDelete.Member(this) )
- wxPendingDelete.Append(this);
-#else
- delete this;
-#endif
+ // schedule this object for deletion
+ wxAppTraits *traits = wxTheApp ? wxTheApp->GetTraits() : NULL;
+ if ( traits )
+ {
+ // let the traits object decide what to do with us
+ traits->ScheduleForDestroy(this);
+ }
+ else // no app or no traits
+ {
+ // in wxBase we might have no app object at all, don't leak memory
+ 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;
}
wxUint32 wxSocketBase::_Read(void* buffer, wxUint32 nbytes)
{
int total;
- int ret = 1;
// Try the pushback buffer first
- total = GetPushback(buffer, nbytes, FALSE);
+ total = GetPushback(buffer, nbytes, false);
nbytes -= total;
buffer = (char *)buffer + total;
// Return now in one of the following cases:
// - the socket is invalid,
- // - we got all the data,
- // - we got *some* data and we are not using wxSOCKET_WAITALL.
+ // - we got all the data
if ( !m_socket ||
- !nbytes ||
- ((total != 0) && !(m_flags & wxSOCKET_WAITALL)) )
+ !nbytes )
return total;
// Possible combinations (they are checked in this order)
// wxSOCKET_BLOCK
// wxSOCKET_NONE
//
+ 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;
}
wxUint32 wxSocketBase::_Write(const void *buffer, wxUint32 nbytes)
{
wxUint32 total = 0;
- int ret = 1;
// If the socket is invalid or parameters are ill, return immediately
if (!m_socket || !buffer || !nbytes)
// wxSOCKET_BLOCK
// wxSOCKET_NONE
//
+ 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)
{
{
wxUint32 total;
bool error;
- int old_flags;
struct
{
unsigned char sig[4];
} msg;
// Mask write events
- m_writing = TRUE;
+ m_writing = true;
- error = TRUE;
+ error = true;
total = 0;
- old_flags = m_flags;
SetFlags((m_flags & wxSOCKET_BLOCK) | wxSOCKET_WAITALL);
msg.sig[0] = (unsigned char) 0xad;
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;
wxSocketBase& wxSocketBase::Discard()
{
- int old_flags;
char *buffer = new char[MAX_DISCARD_SIZE];
wxUint32 ret;
wxUint32 total = 0;
// Mask read events
- m_reading = TRUE;
+ m_reading = true;
- old_flags = m_flags;
SetFlags(wxSOCKET_NOWAIT);
do
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)
else
timeout = m_timeout * 1000;
+ bool has_event_loop = wxTheApp->GetTraits() ? (wxTheApp->GetTraits()->GetSocketGUIFunctionsTable() ? true : false) : false;
+
// Wait in an active polling loop.
//
// NOTE: We duplicate some of the code in OnRequest, but this doesn't
// Do this at least once (important if timeout == 0, when
// we are just polling). Also, if just polling, do not yield.
- wxStopWatch chrono;
- bool done = FALSE;
+ wxDateTime current_time = wxDateTime::UNow();
+ unsigned int time_limit = (current_time.GetTicks() * 1000) + current_time.GetMillisecond() + timeout;
+ bool done = false;
+ bool valid_result = false;
+
+ if (!has_event_loop)
+ {
+ // This is used to avoid a busy loop on wxBase - having a select
+ // timeout of 50 ms per iteration should be enough.
+ if (timeout > 50)
+ m_socket->SetTimeout(50);
+ else
+ m_socket->SetTimeout(timeout);
+ }
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;
+ valid_result = true;
+ break;
}
// Data available or output buffer ready
if ((result & GSOCK_INPUT_FLAG) || (result & GSOCK_OUTPUT_FLAG))
{
- return TRUE;
+ valid_result = true;
+ break;
}
// Connection lost
if (result & GSOCK_LOST_FLAG)
{
- m_connected = FALSE;
- m_establishing = FALSE;
- return (flags & GSOCK_LOST_FLAG) != 0;
+ m_connected = false;
+ m_establishing = false;
+ valid_result = ((flags & GSOCK_LOST_FLAG) != 0);
+ break;
}
// Wait more?
- if ((!timeout) || (chrono.Time() > timeout) || (m_interrupt))
- done = TRUE;
+ current_time = wxDateTime::UNow();
+ int time_left = time_limit - ((current_time.GetTicks() * 1000) + current_time.GetMillisecond());
+ if ((!timeout) || (time_left <= 0) || (m_interrupt))
+ done = true;
else
- PROCESS_EVENTS();
+ {
+ if (has_event_loop)
+ {
+ PROCESS_EVENTS();
+ }
+ else
+ {
+ // If there's less than 50 ms left, just call select with that timeout.
+ if (time_left < 50)
+ m_socket->SetTimeout(time_left);
+ }
+ }
}
- return FALSE;
+ // Set timeout back to original value (we overwrote it for polling)
+ if (!has_event_loop)
+ m_socket->SetTimeout(m_timeout*1000);
+
+ return valid_result;
}
bool wxSocketBase::Wait(long seconds, long milliseconds)
{
- return _Wait(seconds, milliseconds, GSOCK_INPUT_FLAG |
- GSOCK_OUTPUT_FLAG |
- GSOCK_CONNECTION_FLAG |
- GSOCK_LOST_FLAG);
+ return _Wait(seconds, milliseconds, GSOCK_INPUT_FLAG |
+ GSOCK_OUTPUT_FLAG |
+ GSOCK_CONNECTION_FLAG |
+ GSOCK_LOST_FLAG);
}
bool wxSocketBase::WaitForRead(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
+ // _Wait because of the semantics of WaitForRead: a 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 |
GSOCK_LOST_FLAG);
}
+
bool wxSocketBase::WaitForWrite(long seconds, long milliseconds)
{
- return _Wait(seconds, milliseconds, GSOCK_OUTPUT_FLAG);
+ return _Wait(seconds, milliseconds, GSOCK_OUTPUT_FLAG);
}
bool wxSocketBase::WaitForLost(long seconds, long milliseconds)
{
- return _Wait(seconds, milliseconds, GSOCK_LOST_FLAG);
+ return _Wait(seconds, milliseconds, GSOCK_LOST_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;
+ GAddress *local;
- if (!m_socket)
- return FALSE;
+ if (!m_socket)
+ return false;
- local = GSocket_GetLocal(m_socket);
- addr_man.SetAddress(local);
- GAddress_destroy(local);
+ local = m_socket->GetLocal();
+ addr_man.SetAddress(local);
+ GAddress_destroy(local);
- return TRUE;
+ return true;
}
//
void wxSocketBase::SaveState()
{
- wxSocketState *state;
+ wxSocketState *state;
- state = new wxSocketState();
+ state = new wxSocketState();
- state->m_flags = m_flags;
- state->m_notify = m_notify;
- state->m_eventmask = m_eventmask;
- state->m_clientData = m_clientData;
-#if WXWIN_COMPATIBILITY
- state->m_cbk = m_cbk;
- state->m_cdata = m_cdata;
-#endif // WXWIN_COMPATIBILITY
+ state->m_flags = m_flags;
+ state->m_notify = m_notify;
+ state->m_eventmask = m_eventmask;
+ state->m_clientData = m_clientData;
- m_states.Append(state);
+ m_states.Append(state);
}
void wxSocketBase::RestoreState()
{
- wxNode *node;
- wxSocketState *state;
-
- node = m_states.Last();
- if (!node)
- return;
-
- state = (wxSocketState *)node->Data();
-
- m_flags = state->m_flags;
- m_notify = state->m_notify;
- m_eventmask = state->m_eventmask;
- m_clientData = state->m_clientData;
-#if WXWIN_COMPATIBILITY
- m_cbk = state->m_cbk;
- m_cdata = state->m_cdata;
-#endif // WXWIN_COMPATIBILITY
-
- delete node;
- delete state;
+ wxList::compatibility_iterator node;
+ wxSocketState *state;
+
+ node = m_states.GetLast();
+ if (!node)
+ return;
+
+ state = (wxSocketState *)node->GetData();
+
+ m_flags = state->m_flags;
+ m_notify = state->m_notify;
+ m_eventmask = state->m_eventmask;
+ m_clientData = state->m_clientData;
+
+ m_states.Erase(node);
+ delete state;
}
//
void wxSocketBase::SetTimeout(long seconds)
{
- m_timeout = seconds;
+ m_timeout = seconds;
- if (m_socket)
- GSocket_SetTimeout(m_socket, m_timeout * 1000);
+ if (m_socket)
+ m_socket->SetTimeout(m_timeout * 1000);
}
void wxSocketBase::SetFlags(wxSocketFlags flags)
{
- m_flags = flags;
+ m_flags = flags;
}
-// --------------------------------------------------------------------------
-// Callbacks (now obsolete - use events instead)
-// --------------------------------------------------------------------------
-
-#if WXWIN_COMPATIBILITY
-
-wxSocketBase::wxSockCbk wxSocketBase::Callback(wxSockCbk cbk_)
-{
- wxSockCbk old_cbk = cbk_;
-
- m_cbk = cbk_;
- return old_cbk;
-}
-
-char *wxSocketBase::CallbackData(char *data)
-{
- char *old_data = m_cdata;
-
- m_cdata = data;
- return old_data;
-}
-
-#endif // WXWIN_COMPATIBILITY
-
// --------------------------------------------------------------------------
// Event handling
// --------------------------------------------------------------------------
GSocketEvent notification,
char *cdata)
{
- wxSocketBase *sckobj = (wxSocketBase *)cdata;
+ wxSocketBase *sckobj = (wxSocketBase *)cdata;
- sckobj->OnRequest((wxSocketNotify) notification);
+ sckobj->OnRequest((wxSocketNotify) notification);
}
void wxSocketBase::OnRequest(wxSocketNotify notification)
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:
// Schedule the event
wxSocketEventFlags flag = 0;
+ wxUnusedVar(flag);
switch (notification)
{
case GSOCK_INPUT: flag = GSOCK_INPUT_FLAG; break;
m_handler->AddPendingEvent(event);
}
-
-#if WXWIN_COMPATIBILITY
- if (m_cbk)
- m_cbk(*this, notification, m_cdata);
-#endif // WXWIN_COMPATIBILITY
}
}
void wxSocketBase::Notify(bool notify)
{
- m_notify = notify;
+ m_notify = notify;
}
void wxSocketBase::SetNotify(wxSocketEventFlags flags)
{
- m_eventmask = flags;
+ m_eventmask = flags;
}
void wxSocketBase::SetEventHandler(wxEvtHandler& handler, int id)
{
- m_handler = &handler;
- m_id = id;
+ m_handler = &handler;
+ m_id = id;
}
// --------------------------------------------------------------------------
// Ctor
// --------------------------------------------------------------------------
-wxSocketServer::wxSocketServer(wxSockAddress& addr_man,
+wxSocketServer::wxSocketServer(const wxSockAddress& addr_man,
wxSocketFlags flags)
: wxSocketBase(flags, wxSOCKET_SERVER)
{
// 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 wxSocketServer::WaitForAccept(long seconds, long milliseconds)
{
- return _Wait(seconds, milliseconds, GSOCK_CONNECTION_FLAG);
+ return _Wait(seconds, milliseconds, GSOCK_CONNECTION_FLAG);
+}
+
+bool wxSocketBase::GetOption(int level, int optname, void *optval, int *optlen)
+{
+ wxASSERT_MSG( m_socket, _T("Socket not initialised") );
+
+ if (m_socket->GetSockOpt(level, optname, optval, optlen)
+ != GSOCK_NOERROR)
+ {
+ return false;
+ }
+ return true;
+}
+
+bool wxSocketBase::SetOption(int level, int optname, const void *optval,
+ int optlen)
+{
+ wxASSERT_MSG( m_socket, _T("Socket not initialised") );
+
+ if (m_socket->SetSockOpt(level, optname, optval, optlen)
+ != GSOCK_NOERROR)
+ {
+ return false;
+ }
+ return true;
+}
+
+bool wxSocketBase::SetLocal(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;
+ }
+
+ return false;
}
// ==========================================================================
// Connect
// --------------------------------------------------------------------------
-bool wxSocketClient::Connect(wxSockAddress& addr_man, bool wait)
+bool wxSocketClient::DoConnect(wxSockAddress& addr_man, wxSockAddress* local, bool wait)
{
GSocketError err;
{
// 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);
+
+ // Reuse makes sense for clients too, if we are trying to rebind to the same port
+ if (GetFlags() & wxSOCKET_REUSEADDR)
+ {
+ m_socket->SetReusable();
+ }
- GSocket_SetPeer(m_socket, addr_man.GetAddress());
- err = GSocket_Connect(m_socket, GSOCK_STREAMED);
+ // If no local address was passed and one has been set, use the one that was Set
+ if (!local && m_localAddress.GetAddress())
+ {
+ local = &m_localAddress;
+ }
+
+ // Bind to the local IP address and port, when provided
+ if (local)
+ {
+ GAddress* la = local->GetAddress();
+
+ if (la && la->m_addr)
+ m_socket->SetLocal(la);
+ }
+
+ 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::Connect(wxSockAddress& addr_man, bool wait)
+{
+ return (DoConnect(addr_man, NULL, wait));
+}
+
+bool wxSocketClient::Connect(wxSockAddress& addr_man, wxSockAddress& local, bool wait)
+{
+ return (DoConnect(addr_man, &local, wait));
}
bool wxSocketClient::WaitOnConnect(long seconds, long milliseconds)
{
- if (m_connected) // Already connected
- return TRUE;
+ if (m_connected) // Already connected
+ return true;
- if (!m_establishing || !m_socket) // No connection in progress
- return FALSE;
+ if (!m_establishing || !m_socket) // No connection in progress
+ return false;
- return _Wait(seconds, milliseconds, GSOCK_CONNECTION_FLAG |
- GSOCK_LOST_FLAG);
+ return _Wait(seconds, milliseconds, GSOCK_CONNECTION_FLAG |
+ GSOCK_LOST_FLAG);
}
// ==========================================================================
/* NOTE: experimental stuff - might change */
-wxDatagramSocket::wxDatagramSocket( wxSockAddress& addr,
+wxDatagramSocket::wxDatagramSocket( const wxSockAddress& addr,
wxSocketFlags flags )
: wxSocketBase( flags, wxSOCKET_DATAGRAM )
{
- // Create the socket
- m_socket = GSocket_new();
-
- if(!m_socket)
- return;
-
- // Setup the socket as non connection oriented
- GSocket_SetLocal(m_socket, addr.GetAddress());
- if( GSocket_SetNonOriented(m_socket) != GSOCK_NOERROR )
- {
- GSocket_destroy(m_socket);
- m_socket = NULL;
- return;
- }
+ // Create the socket
+ m_socket = GSocket_new();
- // 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 |
- GSOCK_LOST_FLAG | GSOCK_CONNECTION_FLAG,
- wx_socket_callback, (char*)this );
+ if(!m_socket)
+ {
+ wxFAIL_MSG( _T("datagram socket not new'd") );
+ return;
+ }
+ // Setup the socket as non connection oriented
+ m_socket->SetLocal(addr.GetAddress());
+ if( m_socket->SetNonOriented() != GSOCK_NOERROR )
+ {
+ delete m_socket;
+ m_socket = NULL;
+ return;
+ }
+ // Initialize all stuff
+ 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 );
}
wxDatagramSocket& wxDatagramSocket::RecvFrom( wxSockAddress& addr,
return (*this);
}
-wxDatagramSocket& wxDatagramSocket::SendTo( wxSockAddress& addr,
+wxDatagramSocket& wxDatagramSocket::SendTo( const wxSockAddress& addr,
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);
}
// wxSocketModule
// ==========================================================================
-class WXDLLEXPORT wxSocketModule : public wxModule
+class wxSocketModule : public wxModule
{
public:
virtual bool OnInit()
{
// wxSocketBase will call GSocket_Init() itself when/if needed
- return TRUE;
+ return true;
}
virtual void OnExit()
#endif
// wxUSE_SOCKETS
-
-// vi:sts=4:sw=4:et
projects / wxWidgets.git / blobdiff