X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/db131261984ad9a406373bfa497e117c524ef0ed..85833f5c6c5c136d16ccd01c90cc243d5d025e0a:/src/common/socket.cpp diff --git a/src/common/socket.cpp b/src/common/socket.cpp index 4bb7518282..883ffb82eb 100644 --- a/src/common/socket.cpp +++ b/src/common/socket.cpp @@ -4,15 +4,17 @@ // Authors: Guilhem Lavaux (completely rewritten from a basic API of Andrew // Davidson(1995) in wxWeb) // Created: April 1997 -// Updated: March 1998 -// Copyright: (C) 1998, 1997, Guilhem Lavaux +// Updated: April 1999 +// Copyright: (C) 1999 1998, 1997, Guilhem Lavaux // RCS_ID: $Id$ // License: see wxWindows license //////////////////////////////////////////////////////////////////////////////// #ifdef __GNUG__ #pragma implementation "socket.h" -// #pragma interface -// #pragma implementation "socket.cpp" +#endif + +#ifdef __MWERKS__ +typedef int socklen_t ; #endif // For compilers that support precompilation, includes "wx.h". @@ -22,6 +24,8 @@ #pragma hdrstop #endif +#if wxUSE_SOCKETS + ///////////////////////////////////////////////////////////////////////////// // wxWindows headers ///////////////////////////////////////////////////////////////////////////// @@ -41,6 +45,15 @@ ///////////////////////////////////////////////////////////////////////////// // System specific headers ///////////////////////////////////////////////////////////////////////////// +#ifdef __WXMAC__ +// in order to avoid problems with our c library and double definitions +#define close closesocket +#define ioctl ioctlsocket + +#include + +#endif + #if defined(__WINDOWS__) #include #endif // __WINDOWS__ @@ -66,37 +79,22 @@ #include #include -#ifdef _MSC_VER +#ifdef __VISUALC__ #include #endif -#if defined(__WXMOTIF__) || defined(__WXXT__) -#include - -///////////////////////////// -// Needs internal variables -///////////////////////////// -#ifdef __WXXT__ -#define Uses_XtIntrinsic -#endif - -#endif - -#if defined(__WXGTK__) -#include -#endif - ///////////////////////////////////////////////////////////////////////////// // wxSocket headers ///////////////////////////////////////////////////////////////////////////// -#include "wx/module.h" +#include #define WXSOCK_INTERNAL -#include "wx/sckaddr.h" -#include "wx/socket.h" +#include +#include +#include -///////////////////////////////////////////////////////////////////////////// -// Some patch ///// BEGIN -///////////////////////////////////////////////////////////////////////////// +// ---------------------- +// Some patch ----- BEGIN +// ---------------------- #ifdef __WINDOWS__ #define close closesocket #define ioctl ioctlsocket @@ -117,42 +115,34 @@ #define INVALID_SOCKET -1 #endif -#ifdef __WXMOTIF__ -#define wxAPP_CONTEXT ((XtAppContext)wxTheApp->GetAppContext()) -#endif - #ifdef __WINDOWS__ // This is an MS TCP/IP routine and is not needed here. Some WinSock // implementations (such as PC-NFS) will require you to include this // or a similar routine (see appendix in WinSock doc or help file). -#if defined( NEED_WSAFDIsSet ) || defined( _MSC_VER ) +#if defined( NEED_WSAFDIsSet ) || defined( __VISUALC__ ) int PASCAL FAR __WSAFDIsSet(SOCKET fd, fd_set FAR *set) { - int i = set->fd_count; + int i = set->fd_count; - while (i--) - { - if (set->fd_array[i] == fd) - return 1; - } + while (i--) + { + if (set->fd_array[i] == fd) + return 1; + } - return 0; + return 0; } #endif #endif -#if defined(__WINDOWS__) -#define PROCESS_EVENTS() wxYield() -#elif defined(__WXXT__) || defined(__WXMOTIF__) -#define PROCESS_EVENTS() XtAppProcessEvent(wxAPP_CONTEXT, XtIMAll) -#elif defined(__WXGTK__) -#define PROCESS_EVENTS() wxYield() -#endif +// ------------------- +// Some patch ---- END +// ------------------- -///////////////////////////////////////////////////////////////////////////// -// Some patch ///// END -///////////////////////////////////////////////////////////////////////////// +#ifdef GetClassInfo +#undef GetClassInfo +#endif // -------------------------------------------------------------- // Module @@ -178,130 +168,68 @@ IMPLEMENT_DYNAMIC_CLASS(wxSocketEvent, wxEvent) IMPLEMENT_DYNAMIC_CLASS(wxSocketModule, wxModule) #endif -class wxSockWakeUp : public wxTimer -{ -public: - int *my_id; - int n_val; - wxSocketBase *sock; - - wxSockWakeUp(wxSocketBase *_sock, int *id, int new_val) - { - my_id = id; n_val = new_val; - sock = _sock; - } - virtual void Notify() - { - *my_id = n_val; - if (sock) sock->Notify(FALSE); - } -}; - -/// Socket request -class SockRequest : public wxObject -{ -public: - char *buffer; - size_t size, nbytes; - bool done; - int error; - wxSockWakeUp *auto_wakeup; - wxSocketBase::wxRequestNotify type; -}; - - -///////////////////////////////////////////////////////////////////////////// -// Some internal define -///////////////////////////////////////////////////////////////////////////// - // -------------------------------------------------------------- // --------- wxSocketBase CONSTRUCTOR --------------------------- // -------------------------------------------------------------- wxSocketBase::wxSocketBase(wxSocketBase::wxSockFlags _flags, - wxSocketBase::wxSockType _type) : + wxSocketBase::wxSockType _type) : wxEvtHandler(), m_flags(_flags), m_type(_type), m_connected(FALSE), m_connecting(FALSE), - m_fd(INVALID_SOCKET), m_waitflags(0), m_cbk(0), m_cdata(0), m_id(-1), + m_fd(INVALID_SOCKET), m_id(-1), m_handler(0), m_neededreq((wxRequestNotify)(REQ_READ | REQ_LOST)), - m_cbkon(FALSE), + m_timeout(3600), m_unread(NULL), m_unrd_size(0), - m_processing(FALSE), - m_timeout(1), m_wantbuf(0) + m_cbk(NULL), m_cdata(NULL), + m_notify_state(FALSE) { - m_internal = new wxSockInternal; -#if defined(__WXXT__) || defined(__WXMOTIF__) || defined(__WXGTK__) - m_internal->sock_inputid = 0; - m_internal->sock_outputid = 0; - m_internal->sock_exceptid = 0; -#endif -#ifdef __WINDOWS__ - m_internal->my_msg = 0; -#endif + m_internal = new wxSocketInternal(this); } wxSocketBase::wxSocketBase() : wxEvtHandler(), m_flags(WAITALL), m_type(SOCK_UNINIT), m_connected(FALSE), - m_connecting(FALSE), m_fd(INVALID_SOCKET), m_waitflags(0), - m_cbk(0), m_cdata(0), + m_connecting(FALSE), m_fd(INVALID_SOCKET), m_id(-1), m_handler(0), m_neededreq((wxRequestNotify)(REQ_READ | REQ_LOST)), - m_cbkon(FALSE), + m_timeout(3600), m_unread(NULL), m_unrd_size(0), - m_processing(FALSE), - m_timeout(1), m_wantbuf(0) + m_cbk(NULL), m_cdata(NULL), + m_notify_state(FALSE) { - m_internal = new wxSockInternal; -#if defined(__WXXT__) || defined(__WXMOTIF__) || defined(__WXGTK__) - m_internal->sock_inputid = 0; - m_internal->sock_outputid = 0; - m_internal->sock_exceptid = 0; -#endif -#ifdef __WINDOWS__ - m_internal->my_msg = 0; -#endif + m_internal = new wxSocketInternal(this); } // -------------------------------------------------------------- -// --------- wxSocketBase CONSTRUCTOR --------------------------- +// wxSocketBase // -------------------------------------------------------------- + wxSocketBase::~wxSocketBase() { - DestroyCallbacks(); + // First, close the file descriptor. Close(); if (m_unread) free(m_unread); - if (m_handler) { -#ifdef __WINDOWS__ - if (m_internal->my_msg) - m_handler->DestroyMessage(m_internal->my_msg); -#endif + // Unregister from the handler database. + if (m_handler) m_handler->UnRegister(this); - } + + // Destroy all saved states. m_states.DeleteContents(TRUE); + // Destroy the socket manager. delete m_internal; } bool wxSocketBase::Close() { - if (m_fd != INVALID_SOCKET) { - for (int i=0;i<3;i++) { - wxNode *n, *node = req_list[i].First(); - - while (node) { - SockRequest *req = (SockRequest *)node->Data(); - req->done = TRUE; - - n = node->Next(); - delete node; - node = n; - } - } + if (m_fd != INVALID_SOCKET) + { + if (m_notify_state == TRUE) + Notify(FALSE); - DestroyCallbacks(); + // Shutdown the connection. shutdown(m_fd, 2); close(m_fd); m_fd = INVALID_SOCKET; @@ -312,47 +240,36 @@ bool wxSocketBase::Close() } // -------------------------------------------------------------- -// --------- wxSocketBase base IO functions --------------------- +// wxSocketBase base IO function // -------------------------------------------------------------- + wxSocketBase& wxSocketBase::Read(char* buffer, size_t nbytes) { m_lcount = GetPushback(buffer, nbytes, FALSE); + nbytes -= m_lcount; + buffer += m_lcount; // 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)) ) - return *this; - - WantBuffer(buffer, nbytes, EVT_READ); - - return *this; -} - -wxSocketBase& wxSocketBase::Peek(char* buffer, size_t nbytes) -{ - size_t nbytes_old = nbytes; - - nbytes -= GetPushback(buffer, nbytes, TRUE); - if (!nbytes) { - m_lcount = nbytes_old; + if (!nbytes || (m_lcount && !(m_flags & WAITALL)) ) { return *this; } - WantBuffer(buffer, nbytes, EVT_PEEK); + WantBuffer(buffer, nbytes, EVT_READ); return *this; } -wxSocketBase& wxSocketBase::Write(const char *buffer, size_t nbytes) -{ - WantBuffer((char *)buffer, nbytes, EVT_WRITE); - return *this; -} - wxSocketBase& wxSocketBase::ReadMsg(char* buffer, size_t nbytes) { - SockMsg msg; - size_t len, len2, sig; + unsigned long len, len2, sig; + struct { + char sig[4]; + char len[4]; + } msg; + + // sig should be an explicit 32-bit unsigned integer; I've seen + // compilers in which size_t was actually a 16-bit unsigned integer Read((char *)&msg, sizeof(msg)); if (m_lcount != sizeof(msg)) @@ -369,13 +286,20 @@ wxSocketBase& wxSocketBase::ReadMsg(char* buffer, size_t nbytes) len |= (size_t)(msg.len[1] & 0xff) << 8; len |= (size_t)(msg.len[2] & 0xff) << 16; len |= (size_t)(msg.len[3] & 0xff) << 24; - len2 = len; - if (len > nbytes) + + // len2 is incorrectly computed in the original; this sequence is + // the fix + if (len > nbytes) { + len2 = len - nbytes; len = nbytes; + } else len2 = 0; - if (Read(buffer, len).LastCount() != len) + // the "len &&" in the following statement is necessary so that + // we don't attempt to read (and possibly hang the system) + // if the message was zero bytes long + if (len && Read(buffer, len).LastCount() != len) return *this; if (len2 && (Read(NULL, len2).LastCount() != len2)) return *this; @@ -387,22 +311,54 @@ wxSocketBase& wxSocketBase::ReadMsg(char* buffer, size_t nbytes) sig |= (size_t)(msg.sig[2] & 0xff) << 16; sig |= (size_t)(msg.sig[3] & 0xff) << 24; // ERROR +// we return *this either way, so a smart optimizer will +// optimize the following sequence out; I'm leaving it in anyway if (sig != 0xdeadfeed) return *this; return *this; } +wxSocketBase& wxSocketBase::Peek(char* buffer, size_t nbytes) +{ + m_lcount = GetPushback(buffer, nbytes, TRUE); + if (nbytes-m_lcount == 0) + { + return *this; + } + buffer += m_lcount; + nbytes -= m_lcount; + + WantBuffer(buffer, nbytes, EVT_PEEK); + + return *this; +} + +wxSocketBase& wxSocketBase::Write(const char *buffer, size_t nbytes) +{ + m_lcount = 0; + WantBuffer((char *)buffer, nbytes, EVT_WRITE); + return *this; +} + wxSocketBase& wxSocketBase::WriteMsg(const char *buffer, size_t nbytes) { - SockMsg msg; + struct { + char sig[4]; + char len[4]; + } msg; + + // warning about 'cast truncates constant value' +#ifdef __VISUALC__ + #pragma warning(disable: 4310) +#endif // __VISUALC__ msg.sig[0] = (char) 0xad; msg.sig[1] = (char) 0xde; msg.sig[2] = (char) 0xed; msg.sig[3] = (char) 0xfe; - msg.len[0] = (char) nbytes & 0xff; + msg.len[0] = (char) nbytes & 0xff; msg.len[1] = (char) (nbytes >> 8) & 0xff; msg.len[2] = (char) (nbytes >> 16) & 0xff; msg.len[3] = (char) (nbytes >> 24) & 0xff; @@ -420,11 +376,19 @@ wxSocketBase& wxSocketBase::WriteMsg(const char *buffer, size_t nbytes) Write((char *)&msg, sizeof(msg)); return *this; + +#ifdef __VISUALC__ + #pragma warning(default: 4310) +#endif // __VISUALC__ } wxSocketBase& wxSocketBase::Unread(const char *buffer, size_t nbytes) { - CreatePushbackAfter(buffer, nbytes); + m_lcount = 0; + if (nbytes != 0) { + CreatePushbackAfter(buffer, nbytes); + m_lcount = nbytes; + } return *this; } @@ -438,11 +402,16 @@ bool wxSocketBase::IsData() const if (m_unrd_size > 0) return TRUE; + m_internal->AcquireFD(); + tv.tv_sec = 0; tv.tv_usec = 0; FD_ZERO(&sock_set); FD_SET(m_fd, &sock_set); - select(FD_SETSIZE, &sock_set, NULL, NULL, &tv); + select(m_fd+1, &sock_set, NULL, NULL, &tv); + + m_internal->ReleaseFD(); + return (FD_ISSET(m_fd, &sock_set) != 0); } @@ -458,7 +427,8 @@ void wxSocketBase::Discard() SaveState(); SetFlags((wxSockFlags)(NOWAIT | SPEED)); - while (recv_size == MAX_BUFSIZE) { + while (recv_size == MAX_BUFSIZE) + { recv_size = Read(my_data, MAX_BUFSIZE).LastCount(); } @@ -468,20 +438,43 @@ void wxSocketBase::Discard() #undef MAX_BUFSIZE } +// If what? Who seems to need unsigned int? +// BTW uint isn't even defined on wxMSW for VC++ for some reason. Even if it +// were, getpeername/getsockname don't take unsigned int*, they take int*. +// +// Under glibc 2.0.7, socketbits.h declares socklen_t to be unsigned int +// and it uses *socklen_t as the 3rd parameter. Robert. + +// JACS - How can we detect this? +// Meanwhile, if your compiler complains about socklen_t, +// switch lines below. + +#if wxHAVE_GLIBC2 +# define wxSOCKET_INT socklen_t +#else +# define wxSOCKET_INT int +#endif + // -------------------------------------------------------------- -// --------- wxSocketBase socket info functions ----------------- +// wxSocketBase socket info functions // -------------------------------------------------------------- + bool wxSocketBase::GetPeer(wxSockAddress& addr_man) const { struct sockaddr my_addr; - uint len_addr = sizeof(my_addr); + wxSOCKET_INT len_addr = sizeof(my_addr); if (m_fd < 0) return FALSE; - if (getpeername(m_fd, (struct sockaddr *)&my_addr, &len_addr) < 0) + m_internal->AcquireFD(); + + if (getpeername(m_fd, (struct sockaddr *)&my_addr, &len_addr) < 0) { + m_internal->ReleaseFD(); return FALSE; + } + m_internal->ReleaseFD(); addr_man.Disassemble(&my_addr, len_addr); return TRUE; } @@ -489,216 +482,132 @@ bool wxSocketBase::GetPeer(wxSockAddress& addr_man) const bool wxSocketBase::GetLocal(wxSockAddress& addr_man) const { struct sockaddr my_addr; - uint len_addr = sizeof(my_addr); + wxSOCKET_INT len_addr = sizeof(my_addr); if (m_fd < 0) return FALSE; - if (getsockname(m_fd, (struct sockaddr *)&my_addr, &len_addr) < 0) + m_internal->AcquireFD(); + if (getsockname(m_fd, (struct sockaddr *)&my_addr, &len_addr) < 0) { + m_internal->ReleaseFD(); return FALSE; + } + m_internal->ReleaseFD(); addr_man.Disassemble(&my_addr, len_addr); return TRUE; } // -------------------------------------------------------------- -// --------- wxSocketBase wait functions ------------------------ +// wxSocketBase wait functions // -------------------------------------------------------------- void wxSocketBase::SaveState() { - wxSockState *state = new wxSockState; + SocketState *state = new SocketState; - state->cbk_on = m_cbkon; - state->cbk_set= m_neededreq; - state->cbk = m_cbk; - state->cdata = m_cdata; - state->flags = m_flags; - state->notif = m_notifyme; + state->notify_state = m_notify_state; + state->evt_notify_state = m_neededreq; + state->socket_flags = m_flags; + state->c_callback = m_cbk; + state->c_callback_data = m_cdata; - m_states.Append(state); + m_states.Append((wxObject *)state); } void wxSocketBase::RestoreState() { wxNode *node; + SocketState *state; node = m_states.Last(); if (!node) return; - wxSockState *state = (wxSockState *)node->Data(); + state = (SocketState *)node->Data(); - SetFlags(state->flags); - m_neededreq = state->cbk_set; - m_cbk = state->cbk; - m_cdata = state->cdata; - m_notifyme = state->notif; - if (state->cbk_on) - SetupCallbacks(); - else - DestroyCallbacks(); + SetFlags(state->socket_flags); + m_internal->AcquireData(); + m_neededreq = state->evt_notify_state; + m_internal->ReleaseData(); + m_cbk = state->c_callback; + m_cdata = state->c_callback_data; + Notify(state->notify_state); delete node; delete state; } // -------------------------------------------------------------- -// --------- wxSocketBase wait functions ------------------------ +// --------- wxSocketBase callback functions -------------------- // -------------------------------------------------------------- -bool wxSocketBase::_Wait(long seconds, long microseconds, int type) -{ - if ((!m_connected && !m_connecting) || m_fd < 0) - return FALSE; - - wxSockWakeUp wakeup(this, &m_waitflags, 0); - - SaveState(); - SetNotify((wxRequestNotify)type); - SetupCallbacks(); - - if (seconds != -1) - wakeup.Start((int)(seconds*1000 + (microseconds / 1000)), TRUE); - - m_waitflags = 0x80 | type; - while (m_waitflags & 0x80) - PROCESS_EVENTS(); - - RestoreState(); - - if (m_waitflags & 0x40) { - m_waitflags = 0; - return TRUE; - } - m_waitflags = 0; - - return FALSE; -} - -bool wxSocketBase::Wait(long seconds, long microseconds) +wxSocketBase::wxSockCbk wxSocketBase::Callback(wxSockCbk cbk_) { - return _Wait(seconds, microseconds, REQ_ACCEPT | REQ_CONNECT | - REQ_READ | REQ_WRITE | REQ_LOST); -} + wxSockCbk old_cbk = cbk_; -bool wxSocketBase::WaitForRead(long seconds, long microseconds) -{ - return _Wait(seconds, microseconds, REQ_READ | REQ_LOST); + m_cbk = cbk_; + return old_cbk; } -bool wxSocketBase::WaitForWrite(long seconds, long microseconds) +char *wxSocketBase::CallbackData(char *data) { - return _Wait(seconds, microseconds, REQ_WRITE); -} + char *old_data = m_cdata; -bool wxSocketBase::WaitForLost(long seconds, long microseconds) -{ - return _Wait(seconds, microseconds, REQ_LOST); + m_cdata = data; + return old_data; } // -------------------------------------------------------------- -// --------- wxSocketBase callback management ------------------- +// --------- wxSocketBase wait functions ------------------------ // -------------------------------------------------------------- -#if defined(__WXMOTIF__) || defined(__WXXT__) || defined(__WXGTK__) -#if defined(__WXMOTIF__) || defined(__WXXT__) -static void wx_socket_read(XtPointer client, int *fid, - XtInputId *WXUNUSED(id)) -#define fd *fid -#else -static void wx_socket_read(gpointer client, gint fd, - GdkInputCondition WXUNUSED(cond)) -#define fd fd -#endif +bool wxSocketBase::_Wait(long seconds, long milliseconds, int type) { - wxSocketBase *sock = (wxSocketBase *)client; - char c; - int i; - - i = recv(fd, &c, 1, MSG_PEEK); + SockRequest *req; - if (i == -1 && (sock->NeededReq() & wxSocketBase::REQ_ACCEPT)) { - sock->OnRequest(wxSocketBase::EVT_ACCEPT); - return; - } + if ((!m_connected && !m_connecting) || m_fd < 0) + return FALSE; - if (i != 0) { - if (!(sock->NeededReq() & wxSocketBase::REQ_READ)) - return; + req = new SockRequest; - sock->OnRequest(wxSocketBase::EVT_READ); - } else { - if (!(sock->NeededReq() & wxSocketBase::REQ_LOST)) { - sock->Close(); - return; - } + req->type = REQ_WAIT | type; + req->timeout = seconds * 1000 + milliseconds; + req->done = FALSE; + req->buffer = NULL; + req->size = 0; + req->error = 0; + req->wait = TRUE; + m_internal->QueueRequest(req, TRUE); - sock->OnRequest(wxSocketBase::EVT_LOST); - } + return (req->io_nbytes != 0); } -#undef fd -#if defined(__WXMOTIF__) || defined(__WXXT__) -static void wx_socket_write(XtPointer client, int *WXUNUSED(fid), - XtInputId *WXUNUSED(id)) -#else -static void wx_socket_write(gpointer client, gint WXUNUSED(fd), - GdkInputCondition WXUNUSED(cond)) -#endif +bool wxSocketBase::Wait(long seconds, long milliseconds) { - wxSocketBase *sock = (wxSocketBase *)client; - - if (!sock->IsConnected()) - sock->OnRequest(wxSocketBase::EVT_CONNECT); - else - sock->OnRequest(wxSocketBase::EVT_WRITE); + return _Wait(seconds, milliseconds, REQ_ACCEPT | REQ_CONNECT | + REQ_READ | REQ_WRITE | REQ_LOST); } -#endif -#ifdef wx_xview -Notify_value wx_sock_read_xview (Notify_client client, int fd) +bool wxSocketBase::WaitForRead(long seconds, long milliseconds) { - wxSocketBase *sock = (wxSocketBase *)client; - char c; - int i; - - i = recv(fd, &c, 1, MSG_PEEK); - - if (i == -1 && (sock->NeededReq() & wxSocketBase::REQ_ACCEPT)) { - sock->OnRequest(wxSocketBase::EVT_ACCEPT); - return; - } - - /* Bytes arrived */ - if (i != 0) { - if (!(sock->NeededReq() & wxSocketBase::REQ_READ)) - return (Notify_value) FALSE; - - sock->OnRequest(wxSocketBase::EVT_READ); - } else { - if (!(sock->NeededReq() & wxSocketBase::REQ_LOST)) - return; - - sock->OnRequest(wxSocketBase::EVT_LOST); - } - - return (Notify_value) FALSE; + return _Wait(seconds, milliseconds, REQ_READ | REQ_LOST); } -Notify_value wx_sock_write_xview (Notify_client client, int fd) +bool wxSocketBase::WaitForWrite(long seconds, long milliseconds) { - wxSocketBase *sock = (wxSocketBase *)client; - - if (!sock->IsConnected()) - sock->OnRequest(wxSocketBase::EVT_CONNECT); - else - sock->OnRequest(wxSocketBase::EVT_WRITE); + return _Wait(seconds, milliseconds, REQ_WRITE); +} - return (Notify_value) TRUE; +bool wxSocketBase::WaitForLost(long seconds, long milliseconds) +{ + return _Wait(seconds, milliseconds, REQ_LOST); } -#endif + +// -------------------------------------------------------------- +// --------- wxSocketBase callback management ------------------- +// -------------------------------------------------------------- wxSocketBase::wxRequestNotify wxSocketBase::EventToNotify(wxRequestEvent evt) { @@ -723,168 +632,59 @@ wxSocketBase::wxRequestNotify wxSocketBase::EventToNotify(wxRequestEvent evt) void wxSocketBase::SetFlags(wxSockFlags _flags) { m_flags = _flags; - if (_flags & SPEED) - { - unsigned long flag = 0; - ioctl(m_fd, FIONBIO, &flag); - + if (_flags & SPEED) { // SPEED and WAITALL are antagonists. m_flags = (wxSockFlags)(m_flags & ~WAITALL); - - Notify(FALSE); - } - else - { - unsigned long flag = 1; - ioctl(m_fd, FIONBIO, &flag); } } -void wxSocketBase::SetNotify(wxRequestNotify flags) +wxSocketBase::wxSockFlags wxSocketBase::GetFlags() const { - wxRequestNotify old_needed_req = m_neededreq; - if (flags & REQ_ACCEPT) - { - /* Check if server */ - if (!(GetClassInfo()->IsKindOf(CLASSINFO(wxSocketServer)))) - flags &= ~REQ_ACCEPT; - } - m_neededreq = flags; - -/* - if (m_cbkon && old_needed_req != flags) seems to be wrong, Robert Roebling - SetupCallbacks(); -*/ - - if ((!m_cbkon) || (old_needed_req != flags)) - SetupCallbacks(); + return m_flags; } -void wxSocketBase::SetupCallbacks() +void wxSocketBase::SetNotify(wxRequestNotify flags) { - if (m_fd == INVALID_SOCKET || !m_handler || (m_flags & SPEED)) - return; - -#if defined(__WXMOTIF__) || defined(__WXXT__) || defined(__WXGTK__) - if (m_cbkon) - DestroyCallbacks(); - if (m_neededreq & (REQ_ACCEPT | REQ_READ | REQ_LOST)) { -#ifdef __WXGTK__ - m_internal->sock_inputid = gdk_input_add(m_fd, GDK_INPUT_READ, - wx_socket_read, (gpointer)this); -#else - m_internal->sock_inputid = XtAppAddInput (wxAPP_CONTEXT, m_fd, - (XtPointer *) XtInputReadMask, - (XtInputCallbackProc) wx_socket_read, - (XtPointer) this); -#endif - } - if (m_neededreq & (REQ_CONNECT | REQ_WRITE)) { -#ifdef __WXGTK__ - m_internal->sock_outputid = gdk_input_add(m_fd, GDK_INPUT_WRITE, - wx_socket_write, (gpointer)this); -#else - m_internal->sock_outputid = XtAppAddInput (wxAPP_CONTEXT, m_fd, - (XtPointer *) XtInputWriteMask, - (XtInputCallbackProc) wx_socket_write, - (XtPointer) this); -#endif - } -#endif -#ifdef __WINDOWS__ - WORD mask = 0; - - if (m_neededreq & REQ_READ) - mask |= FD_READ; - if (m_neededreq & REQ_WRITE) - mask |= FD_WRITE; - if (m_neededreq & REQ_LOST) - mask |= FD_CLOSE; - if (m_neededreq & REQ_ACCEPT) - mask |= FD_ACCEPT; - if (m_neededreq & REQ_CONNECT) - mask |= FD_CONNECT; - - if (!m_internal->my_msg) - m_internal->my_msg = m_handler->NewMessage(this); - WSAAsyncSelect(m_fd, m_handler->GetHWND(), m_internal->my_msg, mask); -#endif - m_cbkon = TRUE; - m_processing = FALSE; -} + /* Check if server */ + if (m_type != SOCK_SERVER) + flags &= ~REQ_ACCEPT; -void wxSocketBase::DestroyCallbacks() -{ - if (!m_cbkon || !m_handler) - return; - - m_cbkon = FALSE; - m_processing = FALSE; -#if defined(__WXMOTIF__) || defined(__WXXT__) - if (m_internal->sock_inputid > 0) - XtRemoveInput(m_internal->sock_inputid); - m_internal->sock_inputid = 0; - if (m_internal->sock_outputid > 0) - XtRemoveInput(m_internal->sock_outputid); - m_internal->sock_outputid = 0; -#endif -#ifdef __WXGTK__ - if (m_internal->sock_inputid > 0) - gdk_input_remove(m_internal->sock_inputid); - m_internal->sock_inputid = 0; - if (m_internal->sock_outputid > 0) - gdk_input_remove(m_internal->sock_outputid); - m_internal->sock_outputid = 0; -#endif -#ifdef __WINDOWS__ - WSAAsyncSelect(m_fd, m_handler->GetHWND(), 0, 0); -#endif + m_internal->AcquireData(); + m_neededreq = flags; + m_internal->ReleaseData(); + if (m_neededreq == 0) + m_internal->StopWaiter(); + else + Notify(m_notify_state); } void wxSocketBase::Notify(bool notify) { - if (m_notifyme == notify) + m_notify_state = notify; + if (m_fd == INVALID_SOCKET) return; + if (notify) - SetupCallbacks(); + m_internal->ResumeWaiter(); else - DestroyCallbacks(); - m_notifyme = notify; + m_internal->StopWaiter(); } void wxSocketBase::OnRequest(wxRequestEvent req_evt) { - wxRequestNotify req_notif = EventToNotify(req_evt); - - // Mask the current event - SetNotify(m_neededreq & ~req_notif); - - if (req_evt <= EVT_WRITE && DoRequests(req_evt)) - return; + wxSocketEvent event(m_id); + wxRequestNotify notify = EventToNotify(req_evt); - if (m_waitflags & 0xF0) - { - // Wake up - if ((m_waitflags & 0x0F) == req_evt) - { - m_waitflags = 0x80; -#ifndef __WXGTK__ - DestroyCallbacks(); // I disable it to prevent infinite loop on X11. -#endif - } - return; - } + if ((m_neededreq & notify) == notify) { + event.m_socket = this; + event.m_skevt = req_evt; + ProcessEvent(event); + // TODOTODO + // OldOnNotify(req_evt); - if (req_evt == EVT_LOST) - { - m_connected = FALSE; - Close(); + // We disable the event reporting. + m_neededreq &= ~notify; } - if (m_notifyme) - OldOnNotify(req_evt); - - // Unmask - SetNotify(m_neededreq | req_notif); } wxSocketEvent::wxSocketEvent(int id) @@ -895,37 +695,23 @@ wxSocketEvent::wxSocketEvent(int id) SetEventType(type); } -void wxSocketBase::OldOnNotify(wxRequestEvent evt) +void wxSocketEvent::CopyObject(wxObject& obj_d) const { - wxSocketEvent event(m_id); + wxSocketEvent *event = (wxSocketEvent *)&obj_d; - event.SetEventObject(this); - event.m_skevt = evt; - ProcessEvent(event); + wxEvent::CopyObject(obj_d); - if (m_cbk) - m_cbk(*this, evt, m_cdata); + event->m_skevt = m_skevt; + event->m_socket = m_socket; } -// -------------------------------------------------------------- -// --------- wxSocketBase functions [Callback, CallbackData] ---- -// -------------------------------------------------------------- - -wxSocketBase::wxSockCbk wxSocketBase::Callback(wxSocketBase::wxSockCbk _cbk) +void wxSocketBase::OldOnNotify(wxRequestEvent evt) { - wxSockCbk old_cbk = m_cbk; - - m_cbk = _cbk; - return old_cbk; } -char *wxSocketBase::CallbackData(char *cdata_) -{ - char *old_cdata = m_cdata; - - m_cdata = cdata_; - return old_cdata; -} +// -------------------------------------------------------------- +// --------- wxSocketBase functions [Callback, CallbackData] ---- +// -------------------------------------------------------------- void wxSocketBase::SetEventHandler(wxEvtHandler& h_evt, int id) { @@ -941,7 +727,10 @@ void wxSocketBase::CreatePushbackAfter(const char *buffer, size_t size) { char *curr_pos; - m_unread = (char *) realloc(m_unread, m_unrd_size+size); + if (m_unread != NULL) + m_unread = (char *) realloc(m_unread, m_unrd_size+size); + else + m_unread = (char *) malloc(size); curr_pos = m_unread + m_unrd_size; memcpy(curr_pos, buffer, size); @@ -956,9 +745,10 @@ void wxSocketBase::CreatePushbackBefore(const char *buffer, size_t size) curr_pos = new_buf + size; memcpy(new_buf, buffer, size); - memcpy(curr_pos, m_unread, m_unrd_size); - - free(m_unread); + if (m_unrd_size != 0) { + memcpy(curr_pos, m_unread, m_unrd_size); + free(m_unread); + } m_unread = new_buf; m_unrd_size += size; } @@ -974,7 +764,7 @@ size_t wxSocketBase::GetPushback(char *buffer, size_t size, bool peek) if (!peek) { m_unrd_size -= size; - if (!m_unrd_size) { + if (m_unrd_size == 0) { free(m_unread); m_unread = NULL; } @@ -984,143 +774,38 @@ size_t wxSocketBase::GetPushback(char *buffer, size_t size, bool peek) } // -------------------------------------------------------------- -// --------- wxSocketBase "multi-thread" core ------------------- +// --------- wxSocketBase buffer core requester ----------------- // -------------------------------------------------------------- -bool wxSocketBase::DoRequests(wxRequestEvent req_flag) -{ - wxNode *node = req_list[req_flag].First(); - size_t len; - int ret; - - if (!node) - return FALSE; - - SockRequest *req = (SockRequest *)node->Data(); - - delete node; - - switch (req->type) - { - case EVT_READ: - case EVT_PEEK: - ret = recv(m_fd, req->buffer, req->size, - (req->type == EVT_PEEK) ? MSG_PEEK : 0); - if (ret < 0) { - req->error = errno; - req->done = TRUE; - break; - } - len = ret; - if ((len < req->size) && (m_flags & WAITALL)) { - req->size -= len; - req->nbytes += len; - req->buffer += len; - req->auto_wakeup->Start(m_timeout*1000, TRUE); - req_list[req_flag].Insert(req); - break; - } - req->done = TRUE; - req->nbytes += len; -#ifndef __WXGTK__ - DestroyCallbacks(); -#endif - break; - case EVT_WRITE: - ret = send(m_fd, req->buffer, req->size, 0); - if (ret < 0) { - req->error = errno; - req->done = TRUE; - break; - } - len = ret; - if ((len < req->size) && (m_flags & WAITALL)) { - req->size -= len; - req->nbytes += len; - req->buffer += len; - req->auto_wakeup->Start(m_timeout*1000, TRUE); - req_list[req_flag].Insert(req); - break; - } - req->done = TRUE; - req->nbytes += len; -#ifndef __WXGTK__ - DestroyCallbacks(); -#endif - break; - default: - return FALSE; - } - return TRUE; -} - -void wxSocketBase::WantSpeedBuffer(char *buffer, size_t nbytes, - wxRequestEvent evt) -{ - int ret = 0; - - switch (evt) { - case EVT_PEEK: - case EVT_READ: - ret = recv(m_fd, buffer, nbytes, - (evt == EVT_PEEK) ? MSG_PEEK : 0); - break; - case EVT_WRITE: - ret = send(m_fd, buffer, nbytes, 0); - break; - } - if (ret < 0) { - m_lcount = 0; - m_error = errno; - } else { - m_lcount = ret; - m_error = 0; - } -} - void wxSocketBase::WantBuffer(char *buffer, size_t nbytes, - wxRequestEvent evt) + wxRequestEvent evt) { bool buf_timed_out; if (m_fd == INVALID_SOCKET || !m_handler || !m_connected) return; - if (m_flags & SPEED) { - WantSpeedBuffer(buffer, nbytes, evt); - return; - } - SockRequest *buf = new SockRequest; - wxSockWakeUp s_wake(NULL, (int *)&buf_timed_out, (int)TRUE); - - m_wantbuf++; - req_list[evt].Append(buf); SaveState(); - SetNotify(REQ_LOST | EventToNotify(evt)); - SetupCallbacks(); buf->buffer = buffer; buf->size = nbytes; buf->done = FALSE; - buf->type = evt; - buf->nbytes = 0; - buf->auto_wakeup = &s_wake; + buf->type = EventToNotify(evt); + buf->io_nbytes = 0; buf->error = 0; + buf->wait = TRUE; + buf->timeout = 1000; buf_timed_out = FALSE; - s_wake.Start(m_timeout*1000, TRUE); - if (m_flags & NOWAIT) - { - DoRequests(evt); - } - else - { - while (!buf->done && !buf_timed_out) - PROCESS_EVENTS(); - } - m_wantbuf--; - m_lcount = buf->nbytes; + if ((m_flags & SPEED) != 0) + m_internal->QueueRequest(buf, FALSE); + else + if ((m_flags & NOWAIT) != 0) + m_internal->QueueRequest(buf, TRUE); + else + m_internal->QueueRequest(buf, TRUE); + m_lcount += buf->io_nbytes; if (buf_timed_out) m_error = ETIMEDOUT; else @@ -1131,14 +816,11 @@ void wxSocketBase::WantBuffer(char *buffer, size_t nbytes, } // -------------------------------------------------------------- -// wxSocketServer /////////////////////////////////////////////// +// wxSocketServer // -------------------------------------------------------------- -// -------------------------------------------------------------- -// --------- wxSocketServer CONSTRUCTOR ------------------------- -// -------------------------------------------------------------- wxSocketServer::wxSocketServer(wxSockAddress& addr_man, - wxSockFlags flags) : + wxSockFlags flags) : wxSocketBase(flags, SOCK_SERVER) { m_fd = socket(addr_man.GetFamily(), SOCK_STREAM, 0); @@ -1160,17 +842,26 @@ wxSocketServer::wxSocketServer(wxSockAddress& addr_man, m_fd = INVALID_SOCKET; return; } + + m_internal->SetFD(m_fd); + + Notify(TRUE); } // -------------------------------------------------------------- -// --------- wxSocketServer Accept ------------------------------ +// wxSocketServer Accept // -------------------------------------------------------------- + bool wxSocketServer::AcceptWith(wxSocketBase& sock) { int fd2; - if ((fd2 = accept(m_fd, 0, 0)) < 0) + m_internal->AcquireFD(); + if ((fd2 = accept(m_fd, 0, 0)) < 0) { + m_internal->ReleaseFD(); return FALSE; + } + m_internal->ReleaseFD(); struct linger linger; linger.l_onoff = 0; @@ -1181,15 +872,14 @@ bool wxSocketServer::AcceptWith(wxSocketBase& sock) int flag = 0; setsockopt(fd2, SOL_SOCKET, SO_KEEPALIVE, (char*)&flag, sizeof(int)); - if (!(sock.m_flags & SPEED)) { - unsigned long flag2 = 1; - ioctl(fd2, FIONBIO, &flag2); - } - sock.m_type = SOCK_INTERNAL; sock.m_fd = fd2; sock.m_connected = TRUE; + sock.m_internal->SetFD(fd2); + + sock.m_internal->ResumeWaiter(); + return TRUE; } @@ -1209,23 +899,13 @@ wxSocketBase *wxSocketServer::Accept() } // -------------------------------------------------------------- -// --------- wxSocketServer callbacks --------------------------- -// -------------------------------------------------------------- -void wxSocketServer::OnRequest(wxRequestEvent evt) -{ - if (evt == EVT_ACCEPT) { - OldOnNotify(EVT_ACCEPT); - } -} - -// -------------------------------------------------------------- -// wxSocketClient /////////////////////////////////////////////// +// wxSocketClient // -------------------------------------------------------------- // --------- wxSocketClient CONSTRUCTOR ------------------------- // -------------------------------------------------------------- wxSocketClient::wxSocketClient(wxSockFlags _flags) : - wxSocketBase(_flags, SOCK_CLIENT) + wxSocketBase(_flags, SOCK_CLIENT) { } @@ -1246,6 +926,8 @@ bool wxSocketClient::Connect(wxSockAddress& addr_man, bool WXUNUSED(wait) ) if (IsConnected()) Close(); + // Initializes all socket stuff ... + // -------------------------------- m_fd = socket(addr_man.GetFamily(), SOCK_STREAM, 0); if (m_fd < 0) @@ -1278,11 +960,10 @@ bool wxSocketClient::Connect(wxSockAddress& addr_man, bool WXUNUSED(wait) ) if (connect(m_fd, remote, len) != 0) return FALSE; - if (!(m_flags & SPEED)) { - flag = 1; - ioctl(m_fd, FIONBIO, &flag); - } + m_internal->SetFD(m_fd); + // Enables bg events. + // ------------------ Notify(TRUE); m_connected = TRUE; @@ -1301,15 +982,14 @@ bool wxSocketClient::WaitOnConnect(long seconds, long microseconds) void wxSocketClient::OnRequest(wxRequestEvent evt) { - if (evt == EVT_CONNECT) { - if (m_connected) { - SetNotify(m_neededreq & ~REQ_CONNECT); + if (evt == EVT_CONNECT) + { + if (m_connected) + { + m_neededreq &= ~REQ_CONNECT; return; } - m_waitflags = 0x40; m_connected = TRUE; - OldOnNotify(EVT_CONNECT); - DestroyCallbacks(); return; } wxSocketBase::OnRequest(evt); @@ -1327,77 +1007,16 @@ static int win_initialized = 0; // -------------------------------------------------------------- // --------- wxSocketHandler CONSTRUCTOR ------------------------ // -------------------------------------------------------------- -#ifdef __WINDOWS__ - -extern char wxPanelClassName[]; - -LRESULT APIENTRY _EXPORT wxSocketHandlerWndProc(HWND hWnd, UINT message, - WPARAM wParam, LPARAM lParam) -{ - if(message==WM_DESTROY) - { - ::SetWindowLong(hWnd, GWL_WNDPROC, (LONG) DefWindowProc); - return DefWindowProc(hWnd, message, wParam, lParam); - } - wxSocketHandler *h_sock = (wxSocketHandler *)GetWindowLong(hWnd, GWL_USERDATA); - wxNode *node = h_sock->smsg_list->Find(message); - wxSocketBase *sock; - wxSocketBase::wxRequestEvent sk_req; - UINT event = WSAGETSELECTEVENT(lParam); - - if (!node) - return DefWindowProc(hWnd, message, wParam, lParam); - - sock = (wxSocketBase *)node->Data(); - - switch (event) { - case FD_READ: - sk_req = wxSocketBase::EVT_READ; - break; - case FD_WRITE: - sk_req = wxSocketBase::EVT_WRITE; - break; - case FD_CLOSE: - sk_req = wxSocketBase::EVT_LOST; - break; - case FD_ACCEPT: - sk_req = wxSocketBase::EVT_ACCEPT; - break; - case FD_CONNECT: - sk_req = wxSocketBase::EVT_CONNECT; - break; - } - sock->OnRequest(sk_req); - - return (LRESULT)0; -} - -FARPROC wxSocketSubClassProc = NULL; - -#endif - wxSocketHandler::wxSocketHandler() { #if defined(__WINDOWS__) - if (!win_initialized) { + if (!win_initialized) + { WSADATA wsaData; WSAStartup((1 << 8) | 1, &wsaData); win_initialized = 1; } - internal = new wxSockHandlerInternal; - internal->sockWin = ::CreateWindow(wxPanelClassName, NULL, 0, - 0, 0, 0, 0, NULL, (HMENU) NULL, - wxhInstance, 0); - - // Subclass the window - if (!wxSocketSubClassProc) - wxSocketSubClassProc = MakeProcInstance((FARPROC) wxSocketHandlerWndProc, wxhInstance); - ::SetWindowLong(internal->sockWin, GWL_WNDPROC, (LONG) wxSocketSubClassProc); - ::SetWindowLong(internal->sockWin, GWL_USERDATA, (LONG) this); - - internal->firstAvailableMsg = 5000; - smsg_list = new wxList(wxKEY_INTEGER); #endif socks = new wxList; @@ -1414,7 +1033,8 @@ wxSocketHandler::~wxSocketHandler() { wxNode *next_node, *node = socks->First(); - while (node) { + while (node) + { wxSocketBase* sock = (wxSocketBase*)node->Data(); delete sock; @@ -1426,34 +1046,31 @@ wxSocketHandler::~wxSocketHandler() delete socks; #ifdef __WINDOWS__ - delete smsg_list; - - ::DestroyWindow(internal->sockWin); WSACleanup(); win_initialized = 0; - - delete internal; #endif } // -------------------------------------------------------------- // --------- wxSocketHandler registering functions -------------- // -------------------------------------------------------------- + void wxSocketHandler::Register(wxSocketBase* sock) { wxNode *node; - for (node = socks->First(); node != NULL; node = node->Next()) { + for (node = socks->First(); node != NULL; node = node->Next()) + { wxSocketBase* s = (wxSocketBase*)node->Data(); if (s == sock) return; } - if (sock) { + if (sock) + { socks->Append(sock); sock->SetHandler(this); - sock->SetupCallbacks(); } } @@ -1461,12 +1078,13 @@ void wxSocketHandler::UnRegister(wxSocketBase* sock) { wxNode *node; - for (node = socks->First(); node; node = node->Next()) { + for (node = socks->First(); node; node = node->Next()) + { wxSocketBase* s = (wxSocketBase*)node->Data(); - if (s == sock) { + if (s == sock) + { delete node; - sock->DestroyCallbacks(); sock->SetHandler(NULL); return; } @@ -1481,24 +1099,17 @@ unsigned long wxSocketHandler::Count() const // -------------------------------------------------------------- // --------- wxSocketHandler "big" wait functions --------------- // -------------------------------------------------------------- -void handler_cbk(wxSocketBase& sock, - wxSocketBase::wxRequestEvent WXUNUSED(flags), - char *cdata) -{ - int *a_wait = (int *)cdata; - - (*a_wait)++; - sock.Notify(FALSE); -} int wxSocketHandler::Wait(long seconds, long microseconds) { + // TODO Needs the completely asynchronous notifier. + + /* int i; int on_wait; - wxSockWakeUp s_wake(NULL, &on_wait, -2); wxNode *node; - - for (node = socks->First(), i=0; node; node = node->Next(), i++) { + for (node = socks->First(), i=0; node; node = node->Next(), i++) + { wxSocketBase *sock = (wxSocketBase *)node->Data(); sock->SaveState(); @@ -1515,7 +1126,8 @@ int wxSocketHandler::Wait(long seconds, long microseconds) while (!on_wait) PROCESS_EVENTS(); - for (node = socks->First(), i=0; node; node = node->Next(), i++) { + for (node = socks->First(), i=0; node; node = node->Next(), i++) + { wxSocketBase *sock = (wxSocketBase *)node->Data(); sock->RestoreState(); @@ -1525,23 +1137,19 @@ int wxSocketHandler::Wait(long seconds, long microseconds) return 0; return on_wait; + */ + return 0; } void wxSocketHandler::YieldSock() { wxNode *node; - for (node = socks->First(); node; node = node->Next() ) { + // Nothing to do anymore here except waiting for the queue emptying. + for (node = socks->First(); node; node=node->Next()) { wxSocketBase *sock = (wxSocketBase *)node->Data(); - sock->SaveState(); - - sock->SetFlags(wxSocketBase::SPEED); - if (sock->IsData()) - sock->DoRequests(wxSocketBase::EVT_READ); - sock->DoRequests(wxSocketBase::EVT_WRITE); - - sock->RestoreState(); + sock->m_internal->WaitForEnd(NULL); } } @@ -1549,7 +1157,7 @@ void wxSocketHandler::YieldSock() // --------- wxSocketHandler: create and register the socket ---- // -------------------------------------------------------------- wxSocketServer *wxSocketHandler::CreateServer(wxSockAddress& addr, - wxSocketBase::wxSockFlags flags) + wxSocketBase::wxSockFlags flags) { wxSocketServer *serv = new wxSocketServer(addr, flags); @@ -1565,39 +1173,20 @@ wxSocketClient *wxSocketHandler::CreateClient(wxSocketBase::wxSockFlags flags) return client; } -#ifdef __WINDOWS__ -// -------------------------------------------------------------- -// --------- wxSocketHandler: Windows specific methods ---------- -// -------------------------------------------------------------- -UINT wxSocketHandler::NewMessage(wxSocketBase *sock) -{ - internal->firstAvailableMsg++; - smsg_list->Append(internal->firstAvailableMsg, sock); - return internal->firstAvailableMsg; -} - -void wxSocketHandler::DestroyMessage(UINT msg) +bool wxSocketModule::OnInit() { - wxNode *node = smsg_list->Find(msg); - delete node; -} - -HWND wxSocketHandler::GetHWND() const -{ - return internal->sockWin; -} - -#endif - -bool wxSocketModule::OnInit() { wxSocketHandler::master = new wxSocketHandler(); return TRUE; } -void wxSocketModule::OnExit() { +void wxSocketModule::OnExit() +{ delete wxSocketHandler::master; wxSocketHandler::master = NULL; } #endif // __WXSTUBS__ + +#endif + // wxUSE_SOCKETS