From: Guillermo Rodriguez Garcia Date: Sat, 11 Sep 1999 20:27:55 +0000 (+0000) Subject: - Completed WaitOnAccept X-Git-Url: https://git.saurik.com/wxWidgets.git/commitdiff_plain/56d8adc0c0de446235b11e9d449158d4c47b9ec8?ds=inline - Completed WaitOnAccept - Rewritten all the WaitXXX functions so that they do not depend on the event notification system. - Rewritten all the internal event system; now all events are internally monitorized, but users are notified only of these events they are interested in. This solves a lot of hard-to-catch little problems and bugs which could arise sometimes. - Rewritten all the automatic event notifier code. - Added callback management code, which had been forgotten (badly needed for wxTCPConnection in IPC classes) - Fixed wxSocketBase::Write(), which didn't honour the WAITALL flag. - Fixed some other bugs. - The code is now much more stable and robust than before (because the architecture is more robust, but it still needs testing). git-svn-id: https://svn.wxwidgets.org/svn/wx/wxWidgets/trunk@3613 c3d73ce0-8a6f-49c7-b76d-6d57e0e08775 --- diff --git a/src/common/socket.cpp b/src/common/socket.cpp index fd788e9e96..3a34fceba9 100644 --- a/src/common/socket.cpp +++ b/src/common/socket.cpp @@ -1,13 +1,16 @@ -//////////////////////////////////////////////////////////////////////////////// +///////////////////////////////////////////////////////////////////////////// // Name: socket.cpp // Purpose: Socket handler classes -// Authors: Guilhem Lavaux +// Authors: Guilhem Lavaux, Guillermo Rodriguez Garcia // Created: April 1997 // Updated: July 1999 // Copyright: (C) 1999, 1998, 1997, Guilhem Lavaux // RCS_ID: $Id$ // License: see wxWindows license -//////////////////////////////////////////////////////////////////////////////// +///////////////////////////////////////////////////////////////////////////// + +#include + #ifdef __GNUG__ #pragma implementation "socket.h" #endif @@ -24,13 +27,13 @@ ///////////////////////////////////////////////////////////////////////////// // wxWindows headers ///////////////////////////////////////////////////////////////////////////// -#include -#include -#include -#include -#include -#include -#include +#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 #include @@ -39,8 +42,8 @@ ///////////////////////////////////////////////////////////////////////////// // wxSocket headers ///////////////////////////////////////////////////////////////////////////// -#include -#include +#include "wx/sckaddr.h" +#include "wx/socket.h" // -------------------------------------------------------------- // ClassInfos @@ -52,7 +55,8 @@ IMPLEMENT_CLASS(wxSocketClient, wxSocketBase) IMPLEMENT_DYNAMIC_CLASS(wxSocketEvent, wxEvent) #endif -class wxSocketState : public wxObject { +class wxSocketState : public wxObject +{ public: bool notify_state; GSocketEventFlags evt_notify_state; @@ -65,13 +69,14 @@ public: }; // -------------------------------------------------------------- -// --------- wxSocketBase CONSTRUCTOR --------------------------- +// wxSocketBase ctor and dtor // -------------------------------------------------------------- + wxSocketBase::wxSocketBase(wxSocketBase::wxSockFlags _flags, wxSocketBase::wxSockType _type) : wxEvtHandler(), m_socket(NULL), m_flags(_flags), m_type(_type), - m_neededreq(GSOCK_INPUT_FLAG | GSOCK_LOST_FLAG), + m_neededreq(0), m_lcount(0), m_timeout(600), m_unread(NULL), m_unrd_size(0), m_unrd_cur(0), m_cbk(NULL), m_cdata(NULL), @@ -84,8 +89,8 @@ wxSocketBase::wxSocketBase(wxSocketBase::wxSockFlags _flags, wxSocketBase::wxSocketBase() : wxEvtHandler(), - m_socket(NULL), m_flags(SPEED | WAITALL), m_type(SOCK_UNINIT), - m_neededreq(GSOCK_INPUT_FLAG | GSOCK_LOST_FLAG), + m_socket(NULL), m_flags(WAITALL | SPEED), m_type(SOCK_UNINIT), + m_neededreq(0), m_lcount(0), m_timeout(600), m_unread(NULL), m_unrd_size(0), m_unrd_cur(0), m_cbk(NULL), m_cdata(NULL), @@ -96,18 +101,15 @@ wxSocketBase::wxSocketBase() : { } -// -------------------------------------------------------------- -// wxSocketBase destructor -// -------------------------------------------------------------- - wxSocketBase::~wxSocketBase() { if (m_unread) free(m_unread); - // At last, close the file descriptor. + // Shutdown and close the socket Close(); + // Destroy the GSocket object if (m_socket) GSocket_destroy(m_socket); } @@ -116,10 +118,11 @@ bool wxSocketBase::Close() { if (m_socket) { - if (m_notify_state == TRUE) - Notify(FALSE); + // Disable callbacks + GSocket_UnsetCallback(m_socket, GSOCK_INPUT_FLAG | GSOCK_OUTPUT_FLAG | + GSOCK_LOST_FLAG | GSOCK_CONNECTION_FLAG); - // Shutdown the connection. + // Shutdown the connection GSocket_Shutdown(m_socket); m_connected = FALSE; m_establishing = FALSE; @@ -129,23 +132,31 @@ bool wxSocketBase::Close() } // -------------------------------------------------------------- -// wxSocketBase base IO function +// wxSocketBase basic IO operations // -------------------------------------------------------------- -class _wxSocketInternalTimer: public wxTimer { - public: + +// GRG: I have made some changes to wxSocket internal event +// system; now, all events (INPUT, OUTPUT, CONNECTION, LOST) +// are always internally monitored; but users will only be +// notified of these events they are interested in. So we +// no longer have to change the event mask with SetNotify() +// in internal functions like DeferRead, DeferWrite, and +// the like. This solves a lot of problems. + +class _wxSocketInternalTimer: public wxTimer +{ +public: int *m_state; unsigned long m_new_val; void Notify() - { - *m_state = m_new_val; // Change the value - } + { + *m_state = m_new_val; // Change the value + } }; int wxSocketBase::DeferRead(char *buffer, wxUint32 nbytes) { - wxSocketEventFlags old_event_flags; - bool old_notify_state; // Timer for timeout _wxSocketInternalTimer timer; @@ -154,14 +165,6 @@ int wxSocketBase::DeferRead(char *buffer, wxUint32 nbytes) // Set the defering mode to READ. m_defering = DEFER_READ; - // Save the old state. - old_event_flags = NeededReq(); - old_notify_state = m_notify_state; - - // Set the new async flag. - SetNotify(GSOCK_INPUT_FLAG | GSOCK_LOST_FLAG); - Notify(TRUE); - // Set the current buffer. m_defer_buffer = buffer; m_defer_nbytes = nbytes; @@ -172,16 +175,16 @@ int wxSocketBase::DeferRead(char *buffer, wxUint32 nbytes) timer.Start(m_timeout * 1000, FALSE); + // If the socket is readable, call DoDefer for the first time + if (GSocket_Select(m_socket, GSOCK_INPUT_FLAG)) + DoDefer(); + // Wait for buffer completion. while (m_defer_buffer != NULL) wxYield(); timer.Stop(); - // Restore the old state. - Notify(old_notify_state); - SetNotify(old_event_flags); - // Disable defering mode. m_defering = NO_DEFER; m_defer_timer = NULL; @@ -201,31 +204,34 @@ wxSocketBase& wxSocketBase::Read(char* buffer, wxUint32 nbytes) if (!m_connected) return *this; - // If we have got the whole needed buffer or if we don't want to - // wait then it returns immediately. - if (!nbytes || (m_lcount && !(m_flags & WAITALL)) ) { + // If we have got the whole needed buffer, return immediately + if (!nbytes) + { return *this; } - if ((m_flags & SPEED) != 0) { - - if ((m_flags & WAITALL) != 0) { - while (ret > 0 && nbytes > 0) { - ret = GSocket_Read(m_socket, buffer, nbytes); - m_lcount += ret; - buffer += ret; - nbytes -= ret; - } - // In case the last call was an error ... - if (ret < 0) - m_lcount ++; - } else { + if (m_flags & SPEED & WAITALL) // SPEED && WAITALL + { + while (ret > 0 && nbytes > 0) + { ret = GSocket_Read(m_socket, buffer, nbytes); - if (ret > 0) - m_lcount += ret; + m_lcount += ret; + buffer += ret; + nbytes -= ret; } + // In case the last call was an error ... + if (ret < 0) + m_lcount ++; + } + else if (m_flags & SPEED) // SPEED && !WAITALL + { + ret = GSocket_Read(m_socket, buffer, nbytes); - } else { + if (ret > 0) + m_lcount += ret; + } + else // !SPEED + { ret = DeferRead(buffer, nbytes); if (ret > 0) @@ -303,8 +309,6 @@ wxSocketBase& wxSocketBase::Peek(char* buffer, wxUint32 nbytes) int wxSocketBase::DeferWrite(const char *buffer, wxUint32 nbytes) { - wxSocketEventFlags old_event_flags; - bool old_notify_state; // Timer for timeout _wxSocketInternalTimer timer; @@ -312,24 +316,22 @@ int wxSocketBase::DeferWrite(const char *buffer, wxUint32 nbytes) m_defering = DEFER_WRITE; - // Save the old state - old_event_flags = NeededReq(); - old_notify_state = m_notify_state; - - SetNotify(GSOCK_OUTPUT_FLAG | GSOCK_LOST_FLAG); - Notify(TRUE); - // Set the current buffer m_defer_buffer = (char *)buffer; m_defer_nbytes = nbytes; + m_defer_timer = &timer; // Start timer timer.m_state = (int *)&m_defer_buffer; timer.m_new_val = 0; - m_defer_timer = &timer; timer.Start(m_timeout * 1000, FALSE); + // If the socket is writable, call DoDefer for the first time + if (GSocket_Select(m_socket, GSOCK_OUTPUT_FLAG)) + DoDefer(); + + // Wait for buffer completion. while (m_defer_buffer != NULL) wxYield(); @@ -337,10 +339,6 @@ int wxSocketBase::DeferWrite(const char *buffer, wxUint32 nbytes) m_defer_timer = NULL; timer.Stop(); - // Restore the old state - Notify(old_notify_state); - SetNotify(old_event_flags); - m_defering = NO_DEFER; return nbytes-m_defer_nbytes; @@ -348,15 +346,40 @@ int wxSocketBase::DeferWrite(const char *buffer, wxUint32 nbytes) wxSocketBase& wxSocketBase::Write(const char *buffer, wxUint32 nbytes) { - int ret; + int ret = 1; + + m_lcount = 0; + + if (!m_connected) + return *this; - if ((m_flags & SPEED) != 0) + if (m_flags & SPEED & WAITALL) // SPEED && WAITALL + { + while (ret > 0 && nbytes > 0) + { + ret = GSocket_Write(m_socket, buffer, nbytes); + m_lcount += ret; + buffer += ret; + nbytes -= ret; + } + // In case the last call was an error ... + if (ret < 0) + m_lcount ++; + } + else if (m_flags & SPEED) // SPEED && !WAITALL + { ret = GSocket_Write(m_socket, buffer, nbytes); - else + + if (ret > 0) + m_lcount += ret; + } + else // !SPEED + { ret = DeferWrite(buffer, nbytes); - if (ret != -1) - m_lcount += ret; + if (ret > 0) + m_lcount += ret; + } return *this; } @@ -405,7 +428,8 @@ wxSocketBase& wxSocketBase::WriteMsg(const char *buffer, wxUint32 nbytes) wxSocketBase& wxSocketBase::Unread(const char *buffer, wxUint32 nbytes) { m_lcount = 0; - if (nbytes != 0) { + if (nbytes != 0) + { CreatePushbackAfter(buffer, nbytes); m_lcount = nbytes; } @@ -417,52 +441,53 @@ bool wxSocketBase::IsData() const if (!m_socket) return FALSE; - return (GSocket_DataAvailable(m_socket)); + return (GSocket_Select(m_socket, GSOCK_INPUT_FLAG)); } -void wxSocketBase::DoDefer(wxSocketNotify req_evt) +// GRG: DoDefer() no longer needs to know which event occured, +// because this was only used to catch LOST events and set +// m_defer_buffer = NULL; this is done in OnRequest() now. + +void wxSocketBase::DoDefer() { int ret; - if (req_evt == wxSOCKET_LOST) { - Close(); - m_defer_buffer = NULL; + if (!m_defer_buffer) return; - } - switch (m_defering) { - case DEFER_READ: - ret = GSocket_Read(m_socket, m_defer_buffer, m_defer_nbytes); - break; - case DEFER_WRITE: - ret = GSocket_Write(m_socket, m_defer_buffer, m_defer_nbytes); - break; - default: - ret = -1; - break; - } - m_defer_nbytes -= ret; + switch (m_defering) + { + case DEFER_READ: + ret = GSocket_Read(m_socket, m_defer_buffer, m_defer_nbytes); + break; + case DEFER_WRITE: + ret = GSocket_Write(m_socket, m_defer_buffer, m_defer_nbytes); + break; + default: + ret = -1; + break; + } - if (ret < 0) - m_defer_nbytes++; + if (ret >= 0) + m_defer_nbytes -= ret; - // If we are waiting for all bytes to be acquired, keep the defering modei - // enabled. - if ((m_flags & WAITALL) == 0 || m_defer_nbytes == 0 || ret < 0) { + // If we are waiting for all bytes to be acquired, keep the defering + // mode enabled. + if ((m_flags & WAITALL) == 0 || m_defer_nbytes == 0 || ret < 0) + { m_defer_buffer = NULL; - Notify(FALSE); - } else { + } + else + { m_defer_buffer += ret; m_defer_timer->Start(m_timeout * 1000, FALSE); } } -// --------------------------------------------------------------------- -// --------- wxSocketBase Discard(): deletes all byte in the input queue -// --------------------------------------------------------------------- void wxSocketBase::Discard() { #define MAX_BUFSIZE (10*1024) + char *my_data = new char[MAX_BUFSIZE]; wxUint32 recv_size = MAX_BUFSIZE; @@ -481,7 +506,7 @@ void wxSocketBase::Discard() } // -------------------------------------------------------------- -// wxSocketBase socket info functions +// wxSocketBase get local or peer addresses // -------------------------------------------------------------- bool wxSocketBase::GetPeer(wxSockAddress& addr_man) const @@ -513,7 +538,7 @@ bool wxSocketBase::GetLocal(wxSockAddress& addr_man) const } // -------------------------------------------------------------- -// wxSocketBase wait functions +// wxSocketBase save and restore socket state // -------------------------------------------------------------- void wxSocketBase::SaveState() @@ -552,75 +577,52 @@ void wxSocketBase::RestoreState() delete state; } -// -------------------------------------------------------------- -// --------- wxSocketBase callback functions -------------------- -// -------------------------------------------------------------- - -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; -} // -------------------------------------------------------------- -// --------- wxSocketBase wait functions ------------------------ +// wxSocketBase Wait functions // -------------------------------------------------------------- -static void wx_socket_wait(GSocket *socket, GSocketEvent event, char *cdata) -{ - int *state = (int *)cdata; - - *state = event; -} +// GRG: I have completely rewritten this family of functions +// so that they don't depend on event notifications; 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 wxYield(), so this won't block the GUI. -bool wxSocketBase::_Wait(long seconds, long milliseconds, int type) +bool wxSocketBase::_Wait(long seconds, long milliseconds, wxSocketEventFlags flags) { - bool old_notify_state = m_notify_state; - int state = -1; + GSocketEventFlags result; _wxSocketInternalTimer timer; + long timeout; + int state = -1; + // Check for valid socket if ((!m_connected && !m_establishing) || !m_socket) return FALSE; - // Set the variable to change - timer.m_state = &state; - timer.m_new_val = GSOCK_MAX_EVENT; + // Check for valid timeout value + if (seconds != -1) + timeout = seconds * 1000 + milliseconds; + else + timeout = m_timeout * 1000; - // Disable the previous handler - Notify(FALSE); + // Activate timer + timer.m_state = &state; + timer.m_new_val = 0; + timer.Start(timeout, TRUE); - // Set the timeout - timer.Start(seconds * 1000 + milliseconds, TRUE); - GSocket_SetCallback(m_socket, type, wx_socket_wait, (char *)&state); + // Active polling (without using events) + result = GSocket_Select(m_socket, flags); - while (state == -1) + while ((result == 0) && (state == -1)) + { wxYield(); + result = GSocket_Select(m_socket, flags); + } - GSocket_UnsetCallback(m_socket, type); timer.Stop(); - // Notify will restore automatically the old GSocket flags - Notify(old_notify_state); - - // GRG: If a LOST event occured, we set m_establishing to - // FALSE here (this is a quick hack to make WaitOnConnect - // work; it will be removed when this function is modified - // so that it tells the caller which event occured). - // - if (state == GSOCK_LOST) - m_establishing = FALSE; - - return (state != GSOCK_MAX_EVENT); + return (result != 0); } bool wxSocketBase::Wait(long seconds, long milliseconds) @@ -647,25 +649,9 @@ bool wxSocketBase::WaitForLost(long seconds, long milliseconds) } // -------------------------------------------------------------- -// --------- wxSocketBase callback management ------------------- +// wxSocketBase flags // -------------------------------------------------------------- -wxSocketEventFlags wxSocketBase::EventToNotify(wxSocketNotify evt) -{ - switch (evt) - { - case GSOCK_INPUT: - return GSOCK_INPUT_FLAG; - case GSOCK_OUTPUT: - return GSOCK_OUTPUT_FLAG; - case GSOCK_CONNECTION: - return GSOCK_CONNECTION_FLAG; - case GSOCK_LOST: - return GSOCK_LOST_FLAG; - } - return 0; -} - void wxSocketBase::SetFlags(wxSockFlags _flags) { m_flags = _flags; @@ -676,23 +662,28 @@ wxSocketBase::wxSockFlags wxSocketBase::GetFlags() const return m_flags; } -void wxSocketBase::SetNotify(wxSocketEventFlags flags) +// -------------------------------------------------------------- +// wxSocketBase callback management +// -------------------------------------------------------------- + +wxSocketBase::wxSockCbk wxSocketBase::Callback(wxSockCbk cbk_) { - // GRG: A client can also have connection events! -/* - if (m_type != SOCK_SERVER) - flags &= ~GSOCK_CONNECTION_FLAG; -*/ + wxSockCbk old_cbk = cbk_; - m_neededreq = flags; - if (m_neededreq == 0) - Notify(FALSE); - else - Notify(m_notify_state); + m_cbk = cbk_; + return old_cbk; +} + +char *wxSocketBase::CallbackData(char *data) +{ + char *old_data = m_cdata; + + m_cdata = data; + return old_data; } // -------------------------------------------------------------- -// Automatic notifier +// wxSocketBase automatic notifier // -------------------------------------------------------------- static void wx_socket_callback(GSocket *socket, GSocketEvent event, char *cdata) @@ -702,24 +693,32 @@ static void wx_socket_callback(GSocket *socket, GSocketEvent event, char *cdata) sckobj->OnRequest((wxSocketNotify)event); } -void wxSocketBase::Notify(bool notify) +wxSocketEventFlags wxSocketBase::EventToNotify(wxSocketNotify evt) { - m_notify_state = notify; - if (!m_socket) - return; + switch (evt) + { + case GSOCK_INPUT: return GSOCK_INPUT_FLAG; + case GSOCK_OUTPUT: return GSOCK_OUTPUT_FLAG; + case GSOCK_CONNECTION: return GSOCK_CONNECTION_FLAG; + case GSOCK_LOST: return GSOCK_LOST_FLAG; + } + return 0; +} - GSocket_UnsetCallback(m_socket, GSOCK_INPUT_FLAG | GSOCK_OUTPUT_FLAG | - GSOCK_LOST_FLAG | GSOCK_CONNECTION_FLAG); - if (!notify) - return; +void wxSocketBase::SetNotify(wxSocketEventFlags flags) +{ + m_neededreq = flags; +} - GSocket_SetCallback(m_socket, m_neededreq, wx_socket_callback, (char *)this); +void wxSocketBase::Notify(bool notify) +{ + m_notify_state = notify; } void wxSocketBase::OnRequest(wxSocketNotify req_evt) { wxSocketEvent event(m_id); - wxSocketEventFlags notify = EventToNotify(req_evt); + wxSocketEventFlags flag = EventToNotify(req_evt); switch(req_evt) { @@ -728,25 +727,33 @@ void wxSocketBase::OnRequest(wxSocketNotify req_evt) m_connected = TRUE; break; case wxSOCKET_LOST: + m_defer_buffer = NULL; Close(); break; case wxSOCKET_INPUT: case wxSOCKET_OUTPUT: - if (m_defering != NO_DEFER) + if (m_defer_buffer) { - DoDefer(req_evt); + // GRG: DoDefer() no longer needs to know which + // event occured, because this was only used to + // catch LOST events and set m_defer_buffer to + // NULL, and this is done in OnRequest() now. + DoDefer(); // Do not notify to user return; } break; } - if ((m_neededreq & notify) == notify) + if (((m_neededreq & flag) == flag) && m_notify_state) { event.m_socket = this; event.m_skevt = req_evt; ProcessEvent(event); OldOnNotify(req_evt); + + if (m_cbk) + m_cbk(*this, req_evt, m_cdata); } } @@ -755,7 +762,7 @@ void wxSocketBase::OldOnNotify(wxSocketNotify evt) } // -------------------------------------------------------------- -// --------- wxSocketBase functions [Callback, CallbackData] ---- +// wxSocketBase set event handler // -------------------------------------------------------------- void wxSocketBase::SetEventHandler(wxEvtHandler& h_evt, int id) @@ -765,7 +772,7 @@ void wxSocketBase::SetEventHandler(wxEvtHandler& h_evt, int id) } // -------------------------------------------------------------- -// --------- wxSocketBase pushback library ---------------------- +// wxSocketBase pushback library // -------------------------------------------------------------- void wxSocketBase::CreatePushbackAfter(const char *buffer, wxUint32 size) @@ -828,23 +835,34 @@ wxUint32 wxSocketBase::GetPushback(char *buffer, wxUint32 size, bool peek) // wxSocketServer // -------------------------------------------------------------- +// -------------------------------------------------------------- +// wxSocketServer ctor and dtor +// -------------------------------------------------------------- + wxSocketServer::wxSocketServer(wxSockAddress& addr_man, wxSockFlags flags) : wxSocketBase(flags, SOCK_SERVER) { + // Create the socket m_socket = GSocket_new(); if (!m_socket) return; + // Setup the socket as server GSocket_SetLocal(m_socket, addr_man.GetAddress()); - if (GSocket_SetServer(m_socket) != GSOCK_NOERROR) { + if (GSocket_SetServer(m_socket) != GSOCK_NOERROR) + { GSocket_destroy(m_socket); m_socket = NULL; return; } - Notify(TRUE); + 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); + } // -------------------------------------------------------------- @@ -855,12 +873,9 @@ bool wxSocketServer::AcceptWith(wxSocketBase& sock, bool wait) { GSocket *child_socket; - // GRG: If wait == FALSE, then set the socket to - // nonblocking. I will set it back to blocking later, - // but I am not sure if this is really a good idea. - // IMO, all GSockets objects used in wxSocket should - // be non-blocking. - // -------------------------------- + // GRG: 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, TRUE); @@ -878,6 +893,11 @@ bool wxSocketServer::AcceptWith(wxSocketBase& sock, bool wait) sock.m_socket = child_socket; sock.m_connected = TRUE; + GSocket_SetTimeout(sock.m_socket, sock.m_timeout); + GSocket_SetCallback(sock.m_socket, GSOCK_INPUT_FLAG | GSOCK_OUTPUT_FLAG | + GSOCK_LOST_FLAG | GSOCK_CONNECTION_FLAG, + wx_socket_callback, (char *)&sock); + return TRUE; } @@ -895,8 +915,6 @@ wxSocketBase *wxSocketServer::Accept(bool wait) bool wxSocketServer::WaitOnAccept(long seconds, long milliseconds) { - // TODO: return immediately if there is already a pending connection. - return _Wait(seconds, milliseconds, GSOCK_CONNECTION_FLAG | GSOCK_LOST_FLAG); } @@ -904,23 +922,21 @@ bool wxSocketServer::WaitOnAccept(long seconds, long milliseconds) // wxSocketClient // -------------------------------------------------------------- -// --------- wxSocketClient CONSTRUCTOR ------------------------- // -------------------------------------------------------------- +// wxSocketClient ctor and dtor +// -------------------------------------------------------------- + wxSocketClient::wxSocketClient(wxSockFlags _flags) : wxSocketBase(_flags, SOCK_CLIENT) { - m_establishing = FALSE; } -// -------------------------------------------------------------- -// --------- wxSocketClient DESTRUCTOR -------------------------- -// -------------------------------------------------------------- wxSocketClient::~wxSocketClient() { } // -------------------------------------------------------------- -// --------- wxSocketClient Connect functions ------------------- +// wxSocketClient Connect functions // -------------------------------------------------------------- bool wxSocketClient::Connect(wxSockAddress& addr_man, bool wait) { @@ -933,8 +949,7 @@ bool wxSocketClient::Connect(wxSockAddress& addr_man, bool wait) if (m_socket) GSocket_destroy(m_socket); - // Initializes all socket stuff ... - // -------------------------------- + // Initialize all socket stuff ... m_socket = GSocket_new(); m_connected = FALSE; m_establishing = FALSE; @@ -942,30 +957,31 @@ bool wxSocketClient::Connect(wxSockAddress& addr_man, bool wait) if (!m_socket) return FALSE; - // Update the flags of m_socket and enable BG events - SetFlags(m_flags); - Notify(TRUE); + GSocket_SetTimeout(m_socket, m_timeout); + + // GRG: If wait == FALSE, then the call should be nonblocking. + // When we are finished, we put the socket to blocking mode + // again. - // GRG: If wait == FALSE, then set the socket to - // nonblocking. I will set it back to blocking later, - // but I am not sure if this is really a good idea. - // IMO, all GSockets objects used in wxSocket should - // be non-blocking. - // -------------------------------- if (!wait) GSocket_SetNonBlocking(m_socket, TRUE); GSocket_SetPeer(m_socket, addr_man.GetAddress()); err = GSocket_Connect(m_socket, GSOCK_STREAMED); + GSocket_SetCallback(m_socket, GSOCK_INPUT_FLAG | GSOCK_OUTPUT_FLAG | + GSOCK_LOST_FLAG | GSOCK_CONNECTION_FLAG, + wx_socket_callback, (char *)this); if (!wait) GSocket_SetNonBlocking(m_socket, FALSE); - if (err == GSOCK_WOULDBLOCK) - m_establishing = TRUE; - if (err != GSOCK_NOERROR) + { + if (err == GSOCK_WOULDBLOCK) + m_establishing = TRUE; + return FALSE; + } m_connected = TRUE; return TRUE; @@ -975,42 +991,37 @@ bool wxSocketClient::WaitOnConnect(long seconds, long milliseconds) { bool ret; - // Already connected - if (m_connected) + if (m_connected) // Already connected return TRUE; - // There is no connection in progress - if (!m_establishing) + if (!m_establishing) // No connection in progress return FALSE; ret = _Wait(seconds, milliseconds, GSOCK_CONNECTION_FLAG | GSOCK_LOST_FLAG); + // GRG: m_connected and m_establishing will be updated in + // OnRequest(), but we do it here anyway because sometimes + // the event might be a bit delayed, and if that happens, + // when WaitOnConnect() returns, m_connected will still be + // FALSE. We have to do it as well in OnRequest because + // maybe WaitOnConnect() is not being used... + if (ret) { - if (m_establishing) // it wasn't GSOCK_LOST - m_connected = TRUE; - + m_connected = GSocket_Select(m_socket, GSOCK_CONNECTION_FLAG); m_establishing = FALSE; } return m_connected; } -void wxSocketClient::OnRequest(wxSocketNotify evt) + +void wxSocketClient::OnRequest(wxSocketNotify req_evt) { - if ((GSocketEvent)evt == GSOCK_CONNECTION) - { - if (m_connected) - { - m_neededreq &= ~GSOCK_CONNECTION_FLAG; - return; - } - m_connected = TRUE; - return; - } - wxSocketBase::OnRequest(evt); + wxSocketBase::OnRequest(req_evt); } + // -------------------------------------------------------------- // wxSocketEvent // --------------------------------------------------------------