#if wxUSE_SOCKETS
-/////////////////////////////////////////////////////////////////////////////
-// wxWindows headers
-/////////////////////////////////////////////////////////////////////////////
+// ==========================================================================
+// Headers and constants
+// ==========================================================================
#include "wx/app.h"
#include "wx/defs.h"
#include "wx/module.h"
#include "wx/log.h"
#include "wx/intl.h"
-
-/////////////////////////////////////////////////////////////////////////////
-// wxSocket headers
-/////////////////////////////////////////////////////////////////////////////
+#include "wx/gdicmn.h" // for wxPendingDelete
#include "wx/sckaddr.h"
#include "wx/socket.h"
+
// discard buffer
#define MAX_DISCARD_SIZE (10 * 1024)
#define PROCESS_EVENTS() wxYield()
// use wxPostEvent or not
-#define EXPERIMENTAL_USE_POST 1
+#define USE_DELAYED_EVENTS 1
-// --------------------------------------------------------------
+// --------------------------------------------------------------------------
// ClassInfos
-// --------------------------------------------------------------
+// --------------------------------------------------------------------------
IMPLEMENT_CLASS(wxSocketBase, wxObject)
IMPLEMENT_CLASS(wxSocketServer, wxSocketBase)
{
public:
bool m_notify_state;
- GSocketEventFlags m_neededreq;
+ wxSocketEventFlags m_neededreq;
wxSockFlags m_flags;
wxSocketBase::wxSockCbk m_cbk;
char *m_cdata;
wxSocketState() : wxObject() {}
};
-// --------------------------------------------------------------
-// wxSocketBase ctor and dtor
-// --------------------------------------------------------------
+
+// ==========================================================================
+// wxSocketBase
+// ==========================================================================
+
+// --------------------------------------------------------------------------
+// Ctor and dtor
+// --------------------------------------------------------------------------
wxSocketBase::wxSocketBase(wxSockFlags _flags, wxSockType _type) :
wxEvtHandler(),
GSocket_destroy(m_socket);
}
+/*
+bool wxSocketBase::Destroy()
+{
+ // 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;
+ Close();
+
+ if ( !wxPendingDelete.Member(this) )
+ wxPendingDelete.Append(this);
+
+ return TRUE;
+}
+*/
+
+// --------------------------------------------------------------------------
+// Basic IO operations
+// --------------------------------------------------------------------------
+
+// The following IO operations update m_error and m_lcount:
+// {Read, Write, ReadMsg, WriteMsg, Peek, Unread, Discard}
+//
+// TODO: Should Connect, Accept and AcceptWith update m_error?
+
bool wxSocketBase::Close()
{
// Interrupt pending waits
GSocket_Shutdown(m_socket);
}
- m_connected = FALSE; // (GRG)
+ m_connected = FALSE;
m_establishing = FALSE;
return TRUE;
}
-// --------------------------------------------------------------
-// wxSocketBase basic IO operations
-// --------------------------------------------------------------
-
-// All IO operations {Read, Write, ReadMsg, WriteMsg, Peek,
-// Unread, Discard} update m_error and m_lcount.
-//
-// TODO: Should Connect, Accept and AcceptWith update m_error?
-
-class _wxSocketInternalTimer: public wxTimer
-{
-public:
- int *m_state;
- unsigned long m_new_val;
-
- void Notify()
- {
- *m_state = (int)m_new_val; // Change the value
- }
-};
-
wxSocketBase& wxSocketBase::Read(char* buffer, wxUint32 nbytes)
{
// Mask read events
nbytes -= total;
buffer += total;
- // If the socket is invalid or we got all the data, return now (GRG)
+ // If the socket is invalid or we got all the data, return now
if (!m_socket || !nbytes)
return total;
wxUint32 total = 0;
int ret = 1;
- // If the socket is invalid, return immediately (GRG)
+ // If the socket is invalid, return immediately
if (!m_socket)
return 0;
return *this;
}
-// --------------------------------------------------------------
-// wxSocketBase get local or peer addresses
-// --------------------------------------------------------------
-
-bool wxSocketBase::GetPeer(wxSockAddress& addr_man) const
-{
- GAddress *peer;
-
- if (!m_socket)
- return FALSE;
-
- peer = GSocket_GetPeer(m_socket);
- addr_man.SetAddress(peer);
- GAddress_destroy(peer);
-
- return TRUE;
-}
-
-bool wxSocketBase::GetLocal(wxSockAddress& addr_man) const
-{
- GAddress *local;
-
- if (!m_socket)
- return FALSE;
-
- local = GSocket_GetLocal(m_socket);
- addr_man.SetAddress(local);
- GAddress_destroy(local);
-
- return TRUE;
-}
-
-// --------------------------------------------------------------
-// wxSocketBase save and restore socket state
-// --------------------------------------------------------------
-
-void wxSocketBase::SaveState()
-{
- wxSocketState *state;
-
- state = new wxSocketState();
-
- state->m_notify_state = m_notify_state;
- state->m_neededreq = m_neededreq;
- state->m_flags = m_flags;
- state->m_cbk = m_cbk;
- state->m_cdata = m_cdata;
+// --------------------------------------------------------------------------
+// Wait functions
+// --------------------------------------------------------------------------
- m_states.Append(state);
-}
+// All Wait functions poll the socket using GSocket_Select() to
+// check for the specified combination of conditions, until one
+// of these conditions become true, an error occurs, or the
+// timeout elapses. The polling loop calls PROCESS_EVENTS(), so
+// this won't block the GUI.
-void wxSocketBase::RestoreState()
+class _wxSocketInternalTimer: public wxTimer
{
- wxNode *node;
- wxSocketState *state;
-
- node = m_states.Last();
- if (!node)
- return;
-
- state = (wxSocketState *)node->Data();
-
- SetFlags(state->m_flags);
- m_cbk = state->m_cbk;
- m_cdata = state->m_cdata;
- m_neededreq = state->m_neededreq;
- Notify(state->m_notify_state);
-
- delete node;
- delete state;
-}
-
-
-// --------------------------------------------------------------
-// wxSocketBase Wait functions
-// --------------------------------------------------------------
+public:
+ int *m_state;
+ unsigned long m_new_val;
-// These WaitXXX unctions do not depend on the event system any
-// longer; instead, they poll the socket, using GSocket_Select()
-// to check for the specified combination of event flags, until
-// an event occurs or until the timeout ellapses. The polling
-// loop calls PROCESS_EVENTS(), so this won't block the GUI.
+ void Notify()
+ {
+ *m_state = (int)m_new_val; // Change the value
+ }
+};
bool wxSocketBase::_Wait(long seconds, long milliseconds,
wxSocketEventFlags flags)
// Set this to TRUE to interrupt ongoing waits
m_interrupt = FALSE;
- // Check for valid socket (GRG)
+ // Check for valid socket
if (!m_socket)
return FALSE;
// Active polling (without using events)
//
// NOTE: this duplicates some of the code in OnRequest (lost
- // connection and connection establishment handling) but this
- // doesn't hurt. It has to be here because the event might
- // be a bit delayed, and it has to be in OnRequest as well
- // because maybe the WaitXXX functions are not being used.
+ // connection and connection establishment handling) but
+ // this doesn't hurt. It has to be here because the event
+ // might be a bit delayed, and it has to be in OnRequest
+ // as well because maybe the Wait functions are not being
+ // used.
//
// Do this at least once (important if timeout == 0, when
// we are just polling). Also, if just polling, do not yield.
- //
+
while (state == -1)
{
result = GSocket_Select(m_socket, flags | GSOCK_LOST_FLAG);
if (result & GSOCK_LOST_FLAG)
{
timer.Stop();
- m_connected = FALSE; // (GRG)
+ m_connected = FALSE;
m_establishing = FALSE;
- return (flags & GSOCK_LOST_FLAG); // (GRG) <--- Maybe here???
+ return (flags & GSOCK_LOST_FLAG);
}
// Wait more?
bool wxSocketBase::WaitForRead(long seconds, long milliseconds)
{
- // Check pushback buffer
+ // Check pushback buffer before entering _Wait
if (m_unread)
return TRUE;
- return _Wait(seconds, milliseconds, GSOCK_INPUT_FLAG);
+ // 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
+ // 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_LOST_FLAG);
}
+// --------------------------------------------------------------------------
+// Miscellaneous
+// --------------------------------------------------------------------------
+
+//
+// Get local or peer address
+//
+
+bool wxSocketBase::GetPeer(wxSockAddress& addr_man) const
+{
+ GAddress *peer;
+
+ if (!m_socket)
+ return FALSE;
+
+ peer = GSocket_GetPeer(m_socket);
+ addr_man.SetAddress(peer);
+ GAddress_destroy(peer);
+
+ return TRUE;
+}
+
+bool wxSocketBase::GetLocal(wxSockAddress& addr_man) const
+{
+ GAddress *local;
+
+ if (!m_socket)
+ return FALSE;
+
+ local = GSocket_GetLocal(m_socket);
+ addr_man.SetAddress(local);
+ GAddress_destroy(local);
+
+ return TRUE;
+}
+
+//
+// Save and restore socket state
+//
+
+void wxSocketBase::SaveState()
+{
+ wxSocketState *state;
+
+ state = new wxSocketState();
+
+ state->m_notify_state = m_notify_state;
+ state->m_neededreq = m_neededreq;
+ state->m_flags = m_flags;
+ state->m_cbk = m_cbk;
+ state->m_cdata = m_cdata;
+
+ m_states.Append(state);
+}
+
+void wxSocketBase::RestoreState()
+{
+ wxNode *node;
+ wxSocketState *state;
+
+ node = m_states.Last();
+ if (!node)
+ return;
+
+ state = (wxSocketState *)node->Data();
+
+ SetFlags(state->m_flags);
+ m_cbk = state->m_cbk;
+ m_cdata = state->m_cdata;
+ m_neededreq = state->m_neededreq;
+ Notify(state->m_notify_state);
+
+ delete node;
+ delete state;
+}
+
+//
+// Timeout and flags
+//
+
void wxSocketBase::SetTimeout(long seconds)
{
m_timeout = seconds;
GSocket_SetTimeout(m_socket, m_timeout * 1000);
}
-// --------------------------------------------------------------
-// wxSocketBase flags
-// --------------------------------------------------------------
-
void wxSocketBase::SetFlags(wxSockFlags _flags)
{
m_flags = _flags;
}
-// --------------------------------------------------------------
-// wxSocketBase callback management
-// --------------------------------------------------------------
+// --------------------------------------------------------------------------
+// Callbacks (now obsolete - use events instead)
+// --------------------------------------------------------------------------
wxSocketBase::wxSockCbk wxSocketBase::Callback(wxSockCbk cbk_)
{
return old_data;
}
-// --------------------------------------------------------------
-// wxSocketBase automatic notifier
-// --------------------------------------------------------------
+// --------------------------------------------------------------------------
+// Event system
+// --------------------------------------------------------------------------
// All events (INPUT, OUTPUT, CONNECTION, LOST) are now always
// internally watched; but users will only be notified of those
// events they are interested in.
static void LINKAGEMODE wx_socket_callback(GSocket * WXUNUSED(socket),
- GSocketEvent event, char *cdata)
+ GSocketEvent event,
+ char *cdata)
{
wxSocketBase *sckobj = (wxSocketBase *)cdata;
wxSocketEvent event(m_id);
wxSocketEventFlags flag = EventToNotify(req_evt);
- // This duplicates some code in _Wait(), but this doesn't
+ // This duplicates some code in _Wait, but this doesn't
// hurt. It has to be here because we don't know whether
- // WaitXXX will be used, and it has to be in _Wait as well
- // because the event might be a bit delayed.
- //
+ // the Wait functions will be used, and it has to be in
+ // _Wait as well because the event might be a bit delayed.
+
switch(req_evt)
{
case wxSOCKET_CONNECTION:
// 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.
- //
+
case wxSOCKET_INPUT:
if (m_reading || !GSocket_Select(m_socket, GSOCK_INPUT_FLAG))
return;
event.m_skevt = req_evt;
if (m_evt_handler)
-#if EXPERIMENTAL_USE_POST
+#if USE_DELAYED_EVENTS
wxPostEvent(m_evt_handler, event);
#else
ProcessEvent(event);
{
}
-// --------------------------------------------------------------
-// wxSocketBase set event handler
-// --------------------------------------------------------------
-
void wxSocketBase::SetEventHandler(wxEvtHandler& h_evt, int id)
{
m_evt_handler = &h_evt;
SetNextHandler(&h_evt);
}
-// --------------------------------------------------------------
-// wxSocketBase pushback
-// --------------------------------------------------------------
+// --------------------------------------------------------------------------
+// Pushback buffer
+// --------------------------------------------------------------------------
void wxSocketBase::Pushback(const char *buffer, wxUint32 size)
{
return size;
}
-// --------------------------------------------------------------
+// ==========================================================================
// wxSocketServer
-// --------------------------------------------------------------
+// ==========================================================================
-// --------------------------------------------------------------
-// wxSocketServer ctor and dtor
-// --------------------------------------------------------------
+// --------------------------------------------------------------------------
+// Ctor
+// --------------------------------------------------------------------------
wxSocketServer::wxSocketServer(wxSockAddress& addr_man,
- wxSockFlags flags) :
- wxSocketBase(flags, SOCK_SERVER)
+ wxSockFlags flags)
+ : wxSocketBase(flags, SOCK_SERVER)
{
// Create the socket
m_socket = GSocket_new();
}
-// --------------------------------------------------------------
-// wxSocketServer Accept
-// --------------------------------------------------------------
+// --------------------------------------------------------------------------
+// Accept
+// --------------------------------------------------------------------------
bool wxSocketServer::AcceptWith(wxSocketBase& sock, bool wait)
{
return _Wait(seconds, milliseconds, GSOCK_CONNECTION_FLAG);
}
-// --------------------------------------------------------------
+// ==========================================================================
// wxSocketClient
-// --------------------------------------------------------------
+// ==========================================================================
-// --------------------------------------------------------------
-// wxSocketClient ctor and dtor
-// --------------------------------------------------------------
+// --------------------------------------------------------------------------
+// Ctor and dtor
+// --------------------------------------------------------------------------
-wxSocketClient::wxSocketClient(wxSockFlags _flags) :
- wxSocketBase(_flags, SOCK_CLIENT)
+wxSocketClient::wxSocketClient(wxSockFlags _flags)
+ : wxSocketBase(_flags, SOCK_CLIENT)
{
}
+// XXX: What is this for ?
wxSocketClient::~wxSocketClient()
{
}
-// --------------------------------------------------------------
-// wxSocketClient Connect functions
-// --------------------------------------------------------------
+// --------------------------------------------------------------------------
+// Connect
+// --------------------------------------------------------------------------
bool wxSocketClient::Connect(wxSockAddress& addr_man, bool wait)
{
GSocketError err;
- if (m_socket) // (GRG)
+ if (m_socket)
{
// Shutdown and destroy the socket
Close();
return _Wait(seconds, milliseconds, GSOCK_CONNECTION_FLAG);
}
-// --------------------------------------------------------------
+// ==========================================================================
// wxDatagramSocket
-// --------------------------------------------------------------
+// ==========================================================================
/* NOTE: experimental stuff - might change */
return (*this);
}
-// --------------------------------------------------------------
+// ==========================================================================
// wxSocketEvent
-// --------------------------------------------------------------
+// ==========================================================================
// XXX: Should be moved to event.cpp ?
wxSocketEvent::wxSocketEvent(int id)
- : wxEvent(id)
+ : wxEvent(id)
{
wxEventType type = (wxEventType)wxEVT_SOCKET;
event->m_socket = m_socket;
}
-// --------------------------------------------------------------------------
+// ==========================================================================
// wxSocketModule
-// --------------------------------------------------------------------------
+// ==========================================================================
class WXDLLEXPORT wxSocketModule: public wxModule
{
projects / wxWidgets.git / blobdiff