// 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: 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")
// --------------------------------------------------------------------------
// 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++ )
+ {
+ /*
+ 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.
+ */
+ wxASSERT_MSG( wxThread::IsMain(),
+ 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 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)
// Destroy the GSocket object
if (m_socket)
- GSocket_destroy(m_socket);
+ delete m_socket;
// Free the pushback buffer
if (m_unread)
// 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;
}
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;
wxUint32 wxSocketBase::_Read(void* buffer, wxUint32 nbytes)
{
int total;
- int ret = 1;
// Try the pushback buffer first
total = GetPushback(buffer, nbytes, FALSE);
// 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;
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)
{
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;
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];
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
else
timeout = m_timeout * 1000;
+#if !defined(wxUSE_GUI) || !wxUSE_GUI
+ m_socket->SetTimeout(timeout);
+#endif
+
// Wait in an active polling loop.
//
// NOTE: We duplicate some of the code in OnRequest, but this doesn't
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)
GSOCK_LOST_FLAG);
}
+
bool wxSocketBase::WaitForWrite(long seconds, long milliseconds)
{
return _Wait(seconds, milliseconds, GSOCK_OUTPUT_FLAG);
if (!m_socket)
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;
+
addr_man.SetAddress(peer);
GAddress_destroy(peer);
if (!m_socket)
return FALSE;
- local = GSocket_GetLocal(m_socket);
+ local = m_socket->GetLocal();
addr_man.SetAddress(local);
GAddress_destroy(local);
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;
}
m_timeout = seconds;
if (m_socket)
- GSocket_SetTimeout(m_socket, m_timeout * 1000);
+ m_socket->SetTimeout(m_timeout * 1000);
}
void wxSocketBase::SetFlags(wxSocketFlags 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
// --------------------------------------------------------------------------
// 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;
// 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
}
}
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
+
+ m_socket->SetLocal(addr_man.GetAddress());
+
+ if (GetFlags() & wxSOCKET_REUSEADDR) {
+ m_socket->SetReusable();
+ }
+ if (m_socket->SetServer() != GSOCK_NOERROR)
+ {
+ delete m_socket;
+ m_socket = NULL;
+
+ wxLogTrace( wxTRACE_Socket, _T("*** GSocket_SetServer failed") );
+ return;
+ }
+
+ 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);
}
// --------------------------------------------------------------------------
// 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;
sock.m_socket = child_socket;
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 _Wait(seconds, milliseconds, GSOCK_CONNECTION_FLAG);
}
+bool wxSocketBase::GetOption(int level, int optname, void *optval, int *optlen)
+{
+ 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)
+{
+ if (m_socket->SetSockOpt(level, optname, optval, optlen)
+ != GSOCK_NOERROR)
+ {
+ return FALSE;
+ }
+ return TRUE;
+}
+
// ==========================================================================
// wxSocketClient
// ==========================================================================
{
// Shutdown and destroy the socket
Close();
- GSocket_destroy(m_socket);
+ delete m_socket;
}
m_socket = GSocket_new();
if (!m_socket)
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);
// 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)
{
m_socket = GSocket_new();
if(!m_socket)
+ {
+ wxASSERT_MSG( 0, _T("datagram socket not new'd") );
return;
-
+ }
// Setup the socket as non connection oriented
- 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_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());
+ m_socket->SetPeer(addr.GetAddress());
Write(buf, nBytes);
return (*this);
}
// wxSocketModule
// ==========================================================================
-class WXDLLEXPORT wxSocketModule : public wxModule
+class wxSocketModule : public wxModule
{
- DECLARE_DYNAMIC_CLASS(wxSocketModule)
-
public:
- bool OnInit() { return GSocket_Init() != 0; }
- 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