// Copyright: (C) 1999-1997, Guilhem Lavaux
// (C) 2000-1999, Guillermo Rodriguez Garcia
// RCS_ID: $Id$
-// License: see wxWindows license
+// License: see wxWindows licence
/////////////////////////////////////////////////////////////////////////////
// ==========================================================================
// Declarations
// ==========================================================================
-#ifdef __GNUG__
+#if defined(__GNUG__) && !defined(NO_GCC_PRAGMA)
#pragma implementation "socket.h"
#endif
#if wxUSE_SOCKETS
#include "wx/app.h"
+#include "wx/apptrait.h"
#include "wx/defs.h"
#include "wx/object.h"
#include "wx/string.h"
#include "wx/intl.h"
#include "wx/event.h"
-#if wxUSE_GUI
- #include "wx/gdicmn.h" // for wxPendingDelete
-#endif // wxUSE_GUI
-
#include "wx/sckaddr.h"
#include "wx/socket.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
-#if wxUSE_GUI
- #define PROCESS_EVENTS() wxYield()
-#else
- #define PROCESS_EVENTS()
-#endif
+// 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 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_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")
// --------------------------------------------------------------------------
// wxWin macros
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)
};
// ==========================================================================
// wxSocketBase
// ==========================================================================
+// --------------------------------------------------------------------------
+// Initialization and shutdown
+// --------------------------------------------------------------------------
+
+// FIXME-MT: all this is MT-unsafe, of course, we should protect all accesses
+// to m_countInit with a crit section
+size_t wxSocketBase::m_countInit = 0;
+
+bool wxSocketBase::IsInitialized()
+{
+ return m_countInit > 0;
+}
+
+bool wxSocketBase::Initialize()
+{
+ if ( !m_countInit++ )
+ {
+ 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 TRUE;
+}
+
+void wxSocketBase::Shutdown()
+{
+ // we should be initialized
+ wxASSERT_MSG( m_countInit, _T("extra call to Shutdown()") );
+ if ( !--m_countInit )
+ {
+ GSocket_Cleanup();
+ }
+}
+
// --------------------------------------------------------------------------
// Ctor and dtor
// --------------------------------------------------------------------------
m_clientData = NULL;
m_notify = FALSE;
m_eventmask = 0;
-#if WXWIN_COMPATIBILITY
- m_cbk = NULL;
- m_cdata = NULL;
-#endif // WXWIN_COMPATIBILITY
+
+ if ( !IsInitialized() )
+ {
+ // this Initialize() will be undone by wxSocketModule::OnExit(), all the
+ // other calls to it should be matched by a call to Shutdown()
+ Initialize();
+ }
}
wxSocketBase::wxSocketBase()
{
// 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)
// Supress events from now on
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;
}
wxUint32 wxSocketBase::_Read(void* buffer, wxUint32 nbytes)
{
int total;
- int ret = 1;
// Try the pushback buffer first
total = GetPushback(buffer, nbytes, FALSE);
nbytes -= total;
buffer = (char *)buffer + total;
- // If the socket is invalid or we got all the data, return now
- if (!m_socket || !nbytes)
+ // 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.
+ if ( !m_socket ||
+ !nbytes ||
+ ((total != 0) && !(m_flags & wxSOCKET_WAITALL)) )
return total;
// Possible combinations (they are checked in this order)
// wxSOCKET_NOWAIT
- // wxSOCKET_WAITALL | wxSOCKET_BLOCK
- // wxSOCKET_WAITALL
+ // wxSOCKET_WAITALL (with or without wxSOCKET_BLOCK)
// wxSOCKET_BLOCK
// wxSOCKET_NONE
//
+ int ret;
if (m_flags & wxSOCKET_NOWAIT)
{
- GSocket_SetNonBlocking(m_socket, TRUE);
+ GSocket_SetNonBlocking(m_socket, 1);
ret = GSocket_Read(m_socket, (char *)buffer, nbytes);
- GSocket_SetNonBlocking(m_socket, FALSE);
+ GSocket_SetNonBlocking(m_socket, 0);
if (ret > 0)
total += ret;
}
- else if (m_flags & wxSOCKET_WAITALL)
+ else
{
- while (ret > 0 && nbytes > 0)
+ bool more = TRUE;
+
+ while (more)
{
- if (!(m_flags & wxSOCKET_BLOCK) && !WaitForRead())
- break;
+ if ( !(m_flags & wxSOCKET_BLOCK) && !WaitForRead() )
+ break;
ret = GSocket_Read(m_socket, (char *)buffer, nbytes);
nbytes -= ret;
buffer = (char *)buffer + ret;
}
- }
- }
- else
- {
- if ((m_flags & wxSOCKET_BLOCK) || WaitForRead())
- {
- ret = GSocket_Read(m_socket, (char *)buffer, nbytes);
- if (ret > 0)
- total += ret;
+ // If we got here and wxSOCKET_WAITALL is not set, we can leave
+ // now. Otherwise, wait until we recv all the data or until there
+ // is an error.
+ //
+ more = (ret > 0 && nbytes > 0 && (m_flags & wxSOCKET_WAITALL));
}
}
if (sig != 0xfeeddead)
{
- wxLogWarning( _("wxSocket: invalid signature in ReadMsg."));
+ wxLogWarning(_("wxSocket: invalid signature in ReadMsg."));
goto exit;
}
if (sig != 0xdeadfeed)
{
- wxLogWarning( _("wxSocket: invalid signature in ReadMsg."));
+ wxLogWarning(_("wxSocket: invalid signature in ReadMsg."));
goto exit;
}
wxUint32 wxSocketBase::_Write(const void *buffer, wxUint32 nbytes)
{
wxUint32 total = 0;
- int ret = 1;
- // If the socket is invalid, return immediately
- if (!m_socket)
+ // If the socket is invalid or parameters are ill, return immediately
+ if (!m_socket || !buffer || !nbytes)
return 0;
// Possible combinations (they are checked in this order)
// wxSOCKET_NOWAIT
- // wxSOCKET_WAITALL | wxSOCKET_BLOCK
- // wxSOCKET_WAITALL
+ // wxSOCKET_WAITALL (with or without wxSOCKET_BLOCK)
// wxSOCKET_BLOCK
// wxSOCKET_NONE
//
+ int ret;
if (m_flags & wxSOCKET_NOWAIT)
{
- GSocket_SetNonBlocking(m_socket, TRUE);
+ GSocket_SetNonBlocking(m_socket, 1);
ret = GSocket_Write(m_socket, (const char *)buffer, nbytes);
- GSocket_SetNonBlocking(m_socket, FALSE);
+ GSocket_SetNonBlocking(m_socket, 0);
if (ret > 0)
total = ret;
}
- else if (m_flags & wxSOCKET_WAITALL)
+ else
{
- while (ret > 0 && nbytes > 0)
+ bool more = TRUE;
+
+ while (more)
{
- if (!(m_flags & wxSOCKET_BLOCK) && !WaitForWrite())
- break;
+ if ( !(m_flags & wxSOCKET_BLOCK) && !WaitForWrite() )
+ break;
ret = GSocket_Write(m_socket, (const char *)buffer, nbytes);
-
+
if (ret > 0)
{
total += ret;
nbytes -= ret;
buffer = (const char *)buffer + ret;
}
- }
- }
- else
- {
- if ((m_flags & wxSOCKET_BLOCK) || WaitForWrite())
- {
- ret = GSocket_Write(m_socket, (const char *)buffer, nbytes);
- if (ret > 0)
- total = ret;
+ // If we got here and wxSOCKET_WAITALL is not set, we can leave
+ // now. Otherwise, wait until we send all the data or until there
+ // is an error.
+ //
+ more = (ret > 0 && nbytes > 0 && (m_flags & wxSOCKET_WAITALL));
}
}
{
wxUint32 total;
bool error;
- int old_flags;
struct
{
unsigned char sig[4];
error = TRUE;
total = 0;
- old_flags = m_flags;
SetFlags((m_flags & wxSOCKET_BLOCK) | wxSOCKET_WAITALL);
msg.sig[0] = (unsigned char) 0xad;
wxSocketBase& wxSocketBase::Discard()
{
- int old_flags;
char *buffer = new char[MAX_DISCARD_SIZE];
wxUint32 ret;
wxUint32 total = 0;
// Mask read events
m_reading = TRUE;
- old_flags = m_flags;
SetFlags(wxSOCKET_NOWAIT);
do
return FALSE;
peer = GSocket_GetPeer(m_socket);
+
+ // copying a null address would just trigger an assert anyway
+
+ if (!peer)
+ return FALSE;
+
addr_man.SetAddress(peer);
GAddress_destroy(peer);
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
m_states.Append(state);
}
void wxSocketBase::RestoreState()
{
- wxNode *node;
+ wxList::compatibility_iterator node;
wxSocketState *state;
- node = m_states.Last();
+ node = m_states.GetLast();
if (!node)
return;
- state = (wxSocketState *)node->Data();
+ state = (wxSocketState *)node->GetData();
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;
+
+ m_states.Erase(node);
delete state;
}
}
-// --------------------------------------------------------------------------
-// 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
// --------------------------------------------------------------------------
// decoupled from wx_socket_callback and thus they suffer from a variety
// of problems. Avoid them where possible and use events instead.
-static void LINKAGEMODE wx_socket_callback(GSocket * WXUNUSED(socket),
- GSocketEvent notification,
- char *cdata)
+extern "C"
+void LINKAGEMODE wx_socket_callback(GSocket * WXUNUSED(socket),
+ GSocketEvent notification,
+ char *cdata)
{
wxSocketBase *sckobj = (wxSocketBase *)cdata;
// Schedule the event
wxSocketEventFlags flag = 0;
+ wxUnusedVar(flag);
switch (notification)
{
case GSOCK_INPUT: flag = GSOCK_INPUT_FLAG; break;
case GSOCK_CONNECTION: flag = GSOCK_CONNECTION_FLAG; break;
case GSOCK_LOST: flag = GSOCK_LOST_FLAG; break;
default:
- wxLogWarning( _("wxSocket: unknown event!."));
+ wxLogWarning(_("wxSocket: unknown event!."));
return;
}
m_handler->AddPendingEvent(event);
}
-
-#if WXWIN_COMPATIBILITY
- if (m_cbk)
- m_cbk(*this, notification, m_cdata);
-#endif // WXWIN_COMPATIBILITY
}
}
// ==========================================================================
-// wxSocketServer
+// wxSocketServer
// ==========================================================================
// --------------------------------------------------------------------------
wxSocketFlags flags)
: wxSocketBase(flags, wxSOCKET_SERVER)
{
- // Create the socket
- m_socket = GSocket_new();
+ wxLogTrace( wxTRACE_Socket, _T("Opening wxSocketServer") );
- if (!m_socket)
- return;
+ m_socket = GSocket_new();
- // Setup the socket as server
- GSocket_SetLocal(m_socket, addr_man.GetAddress());
- if (GSocket_SetServer(m_socket) != GSOCK_NOERROR)
- {
- GSocket_destroy(m_socket);
- m_socket = NULL;
- return;
- }
+ if (!m_socket)
+ {
+ wxLogTrace( wxTRACE_Socket, _T("*** GSocket_new failed") );
+ return;
+ }
- GSocket_SetTimeout(m_socket, m_timeout * 1000);
- GSocket_SetCallback(m_socket, GSOCK_INPUT_FLAG | GSOCK_OUTPUT_FLAG |
- GSOCK_LOST_FLAG | GSOCK_CONNECTION_FLAG,
- wx_socket_callback, (char *)this);
+ // Setup the socket as server
+
+ GSocket_SetLocal(m_socket, addr_man.GetAddress());
+ if (GSocket_SetServer(m_socket) != GSOCK_NOERROR)
+ {
+ GSocket_destroy(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 |
+ GSOCK_LOST_FLAG | GSOCK_CONNECTION_FLAG,
+ wx_socket_callback, (char *)this);
}
// --------------------------------------------------------------------------
// again.
if (!wait)
- GSocket_SetNonBlocking(m_socket, TRUE);
+ GSocket_SetNonBlocking(m_socket, 1);
child_socket = GSocket_WaitConnection(m_socket);
if (!wait)
- GSocket_SetNonBlocking(m_socket, FALSE);
+ GSocket_SetNonBlocking(m_socket, 0);
if (!child_socket)
return FALSE;
sock->SetFlags(m_flags);
if (!AcceptWith(*sock, wait))
- return NULL;
+ {
+ sock->Destroy();
+ sock = NULL;
+ }
return sock;
}
// again.
if (!wait)
- GSocket_SetNonBlocking(m_socket, TRUE);
+ GSocket_SetNonBlocking(m_socket, 1);
GSocket_SetPeer(m_socket, addr_man.GetAddress());
err = GSocket_Connect(m_socket, GSOCK_STREAMED);
if (!wait)
- GSocket_SetNonBlocking(m_socket, FALSE);
+ GSocket_SetNonBlocking(m_socket, 0);
if (err != GSOCK_NOERROR)
{
return (*this);
}
-// ==========================================================================
-// wxSocketEvent
-// ==========================================================================
-
-wxSocketEvent::wxSocketEvent(int id) : wxEvent(id)
-{
- SetEventType( (wxEventType)wxEVT_SOCKET );
-}
-
-void wxSocketEvent::CopyObject(wxObject& object_dest) const
-{
- wxSocketEvent *event = (wxSocketEvent *)&object_dest;
-
- wxEvent::CopyObject(object_dest);
-
- event->m_event = m_event;
- event->m_clientData = m_clientData;
-}
-
// ==========================================================================
// wxSocketModule
// ==========================================================================
-class WXDLLEXPORT wxSocketModule : public wxModule
+class wxSocketModule : public wxModule
{
- DECLARE_DYNAMIC_CLASS(wxSocketModule)
-
public:
- bool OnInit() { return GSocket_Init(); }
- void OnExit() { GSocket_Cleanup(); }
+ virtual bool OnInit()
+ {
+ // wxSocketBase will call GSocket_Init() itself when/if needed
+ return TRUE;
+ }
+
+ virtual void OnExit()
+ {
+ if ( wxSocketBase::IsInitialized() )
+ wxSocketBase::Shutdown();
+ }
+
+private:
+ DECLARE_DYNAMIC_CLASS(wxSocketModule)
};
IMPLEMENT_DYNAMIC_CLASS(wxSocketModule, wxModule)
#endif
// wxUSE_SOCKETS
+
+// vi:sts=4:sw=4:et
projects / wxWidgets.git / blobdiff