X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/97e6ee04541e844fe134fd1de99a24d0ec5cb2d5..286694ba265d1bf68290cac192bbe54259c313d9:/src/unix/gsocket.cpp diff --git a/src/unix/gsocket.cpp b/src/unix/gsocket.cpp index dc6c7e5702..5ff4d21442 100644 --- a/src/unix/gsocket.cpp +++ b/src/unix/gsocket.cpp @@ -1,8 +1,9 @@ /* ------------------------------------------------------------------------- * Project: GSocket (Generic Socket) for WX * Name: gsocket.c - * Authors: Guilhem Lavaux, - * Guillermo Rodriguez Garcia (maintainer) + * Authors: David Elliott (C++ conversion, maintainer) + * Guilhem Lavaux, + * Guillermo Rodriguez Garcia * Purpose: GSocket main Unix and OS/2 file * Licence: The wxWindows licence * CVSID: $Id$ @@ -86,6 +87,10 @@ int _System bsdselect(int, int _System soclose(int); # endif #endif +#ifdef __EMX__ +#include +#endif + #include #include #include @@ -96,6 +101,9 @@ int _System soclose(int); #ifdef sgi # include #endif +#ifdef _AIX +# include +#endif #include #ifndef SOCKLEN_T @@ -114,6 +122,10 @@ int _System soclose(int); #endif /* SOCKLEN_T */ +#ifndef SOCKOPTLEN_T +#define SOCKOPTLEN_T SOCKLEN_T +#endif + /* * MSW defines this, Unices don't. */ @@ -144,6 +156,15 @@ int _System soclose(int); signal(SIGPIPE, old_handler); \ } +/* If a SIGPIPE is issued by a socket call on a remotely closed socket, + the program will "crash" unless it explicitly handles the SIGPIPE. + By using MSG_NOSIGNAL, the SIGPIPE is suppressed. Later, we will + use SO_NOSIGPIPE (if available), the BSD equivalent. */ +#ifdef MSG_NOSIGNAL +# define GSOCKET_MSG_NOSIGNAL MSG_NOSIGNAL +#else /* MSG_NOSIGNAL not available (FreeBSD including OS X) */ +# define GSOCKET_MSG_NOSIGNAL 0 +#endif /* MSG_NOSIGNAL */ #ifndef __GSOCKET_STANDALONE__ # include "wx/unix/gsockunx.h" @@ -163,48 +184,56 @@ int _System soclose(int); /* Table of GUI-related functions. We must call them indirectly because * of wxBase and GUI separation: */ -static struct GSocketGUIFunctionsTable *gs_gui_functions; - -#define USE_GUI() (gs_gui_functions != NULL) - -/* Define macros to simplify indirection: */ -#define _GSocket_GUI_Init() \ - if (gs_gui_functions) gs_gui_functions->GUI_Init() -#define _GSocket_GUI_Cleanup() \ - if (gs_gui_functions) gs_gui_functions->GUI_Cleanup() -#define _GSocket_GUI_Init_Socket(socket) \ - (gs_gui_functions ? gs_gui_functions->GUI_Init_Socket(socket) : 1) -#define _GSocket_GUI_Destroy_Socket(socket) \ - if (gs_gui_functions) gs_gui_functions->GUI_Destroy_Socket(socket) -#define _GSocket_Enable_Events(socket) \ - if (gs_gui_functions) gs_gui_functions->Enable_Events(socket) -#define _GSocket_Disable_Events(socket) \ - if (gs_gui_functions) gs_gui_functions->Disable_Events(socket) -#define _GSocket_Install_Callback(socket, event) \ - if (gs_gui_functions) gs_gui_functions->Install_Callback(socket, event) -#define _GSocket_Uninstall_Callback(socket, event) \ - if (gs_gui_functions) gs_gui_functions->Uninstall_Callback(socket, event) - -static struct GSocketBaseFunctionsTable gs_base_functions = +static GSocketGUIFunctionsTable *gs_gui_functions; + +class GSocketGUIFunctionsTableNull: public GSocketGUIFunctionsTable { - _GSocket_Detected_Read, - _GSocket_Detected_Write +public: + virtual bool OnInit(); + virtual void OnExit(); + virtual bool CanUseEventLoop(); + virtual bool Init_Socket(GSocket *socket); + virtual void Destroy_Socket(GSocket *socket); + virtual void Install_Callback(GSocket *socket, GSocketEvent event); + virtual void Uninstall_Callback(GSocket *socket, GSocketEvent event); + virtual void Enable_Events(GSocket *socket); + virtual void Disable_Events(GSocket *socket); }; +bool GSocketGUIFunctionsTableNull::OnInit() +{ return true; } +void GSocketGUIFunctionsTableNull::OnExit() +{} +bool GSocketGUIFunctionsTableNull::CanUseEventLoop() +{ return false; } +bool GSocketGUIFunctionsTableNull::Init_Socket(GSocket *socket) +{ return true; } +void GSocketGUIFunctionsTableNull::Destroy_Socket(GSocket *socket) +{} +void GSocketGUIFunctionsTableNull::Install_Callback(GSocket *socket, GSocketEvent event) +{} +void GSocketGUIFunctionsTableNull::Uninstall_Callback(GSocket *socket, GSocketEvent event) +{} +void GSocketGUIFunctionsTableNull::Enable_Events(GSocket *socket) +{} +void GSocketGUIFunctionsTableNull::Disable_Events(GSocket *socket) +{} /* Global initialisers */ -void GSocket_SetGUIFunctions(struct GSocketGUIFunctionsTable *guifunc) +void GSocket_SetGUIFunctions(GSocketGUIFunctionsTable *guifunc) { gs_gui_functions = guifunc; } - + int GSocket_Init(void) { - if (gs_gui_functions) + if (!gs_gui_functions) { - if ( !gs_gui_functions->GUI_Init() ) - return 0; + static GSocketGUIFunctionsTableNull table; + gs_gui_functions = &table; } + if ( !gs_gui_functions->OnInit() ) + return 0; return 1; } @@ -212,106 +241,90 @@ void GSocket_Cleanup(void) { if (gs_gui_functions) { - gs_gui_functions->GUI_Cleanup(); + gs_gui_functions->OnExit(); } } /* Constructors / Destructors for GSocket */ -GSocket *GSocket_new(void) +GSocket::GSocket() { - int i, success; - GSocket *socket; - - socket = (GSocket *)malloc(sizeof(GSocket)); + int i; - if (socket == NULL) - return NULL; - - socket->m_fd = INVALID_SOCKET; + m_fd = INVALID_SOCKET; for (i=0;im_cbacks[i] = NULL; - } - socket->m_detected = 0; - socket->m_local = NULL; - socket->m_peer = NULL; - socket->m_error = GSOCK_NOERROR; - socket->m_server = FALSE; - socket->m_stream = TRUE; - socket->m_gui_dependent = NULL; - socket->m_non_blocking = FALSE; - socket->m_timeout = 10*60*1000; + m_cbacks[i] = NULL; + } + m_detected = 0; + m_local = NULL; + m_peer = NULL; + m_error = GSOCK_NOERROR; + m_server = false; + m_stream = true; + m_gui_dependent = NULL; + m_non_blocking = false; + m_reusable = false; + m_timeout = 10*60*1000; /* 10 minutes * 60 sec * 1000 millisec */ - socket->m_establishing = FALSE; - - socket->m_functions = &gs_base_functions; + m_establishing = false; + assert(gs_gui_functions); /* Per-socket GUI-specific initialization */ - success = _GSocket_GUI_Init_Socket(socket); - if (!success) - { - free(socket); - return NULL; - } - - return socket; + m_ok = gs_gui_functions->Init_Socket(this); } -void GSocket_close(GSocket *socket) +void GSocket::Close() { - _GSocket_Disable_Events(socket); -// gsockosx.c calls CFSocketInvalidate which closes the socket for us + gs_gui_functions->Disable_Events(this); + /* gsockosx.c calls CFSocketInvalidate which closes the socket for us */ #if !(defined(__DARWIN__) && (defined(__WXMAC__) || defined(__WXCOCOA__))) - close(socket->m_fd); + close(m_fd); #endif - socket->m_fd = INVALID_SOCKET; + m_fd = INVALID_SOCKET; } -void GSocket_destroy(GSocket *socket) +GSocket::~GSocket() { - assert(socket != NULL); + assert(this); /* Check that the socket is really shutdowned */ - if (socket->m_fd != INVALID_SOCKET) - GSocket_Shutdown(socket); + if (m_fd != INVALID_SOCKET) + Shutdown(); /* Per-socket GUI-specific cleanup */ - _GSocket_GUI_Destroy_Socket(socket); + gs_gui_functions->Destroy_Socket(this); /* Destroy private addresses */ - if (socket->m_local) - GAddress_destroy(socket->m_local); - - if (socket->m_peer) - GAddress_destroy(socket->m_peer); + if (m_local) + GAddress_destroy(m_local); - /* Destroy the socket itself */ - free(socket); + if (m_peer) + GAddress_destroy(m_peer); } /* GSocket_Shutdown: * Disallow further read/write operations on this socket, close * the fd and disable all callbacks. */ -void GSocket_Shutdown(GSocket *socket) +void GSocket::Shutdown() { int evt; - assert(socket != NULL); + assert(this); /* If socket has been created, shutdown it */ - if (socket->m_fd != INVALID_SOCKET) + if (m_fd != INVALID_SOCKET) { - shutdown(socket->m_fd, 2); - GSocket_close(socket); + shutdown(m_fd, 2); + Close(); } /* Disable GUI callbacks */ for (evt = 0; evt < GSOCK_MAX_EVENT; evt++) - socket->m_cbacks[evt] = NULL; + m_cbacks[evt] = NULL; - socket->m_detected = GSOCK_LOST_FLAG; + m_detected = GSOCK_LOST_FLAG; } /* Address handling */ @@ -330,74 +343,74 @@ void GSocket_Shutdown(GSocket *socket) * GSOCK_INVSOCK - the socket is not valid. * GSOCK_INVADDR - the address is not valid. */ -GSocketError GSocket_SetLocal(GSocket *socket, GAddress *address) +GSocketError GSocket::SetLocal(GAddress *address) { - assert(socket != NULL); + assert(this); /* the socket must be initialized, or it must be a server */ - if ((socket->m_fd != INVALID_SOCKET && !socket->m_server)) + if ((m_fd != INVALID_SOCKET && !m_server)) { - socket->m_error = GSOCK_INVSOCK; + m_error = GSOCK_INVSOCK; return GSOCK_INVSOCK; } /* check address */ if (address == NULL || address->m_family == GSOCK_NOFAMILY) { - socket->m_error = GSOCK_INVADDR; + m_error = GSOCK_INVADDR; return GSOCK_INVADDR; } - if (socket->m_local) - GAddress_destroy(socket->m_local); + if (m_local) + GAddress_destroy(m_local); - socket->m_local = GAddress_copy(address); + m_local = GAddress_copy(address); return GSOCK_NOERROR; } -GSocketError GSocket_SetPeer(GSocket *socket, GAddress *address) +GSocketError GSocket::SetPeer(GAddress *address) { - assert(socket != NULL); + assert(this); /* check address */ if (address == NULL || address->m_family == GSOCK_NOFAMILY) { - socket->m_error = GSOCK_INVADDR; + m_error = GSOCK_INVADDR; return GSOCK_INVADDR; } - if (socket->m_peer) - GAddress_destroy(socket->m_peer); + if (m_peer) + GAddress_destroy(m_peer); - socket->m_peer = GAddress_copy(address); + m_peer = GAddress_copy(address); return GSOCK_NOERROR; } -GAddress *GSocket_GetLocal(GSocket *socket) +GAddress *GSocket::GetLocal() { GAddress *address; struct sockaddr addr; SOCKLEN_T size = sizeof(addr); GSocketError err; - assert(socket != NULL); + assert(this); /* try to get it from the m_local var first */ - if (socket->m_local) - return GAddress_copy(socket->m_local); + if (m_local) + return GAddress_copy(m_local); /* else, if the socket is initialized, try getsockname */ - if (socket->m_fd == INVALID_SOCKET) + if (m_fd == INVALID_SOCKET) { - socket->m_error = GSOCK_INVSOCK; + m_error = GSOCK_INVSOCK; return NULL; } - if (getsockname(socket->m_fd, &addr, (SOCKLEN_T *) &size) < 0) + if (getsockname(m_fd, &addr, (SOCKLEN_T *) &size) < 0) { - socket->m_error = GSOCK_IOERR; + m_error = GSOCK_IOERR; return NULL; } @@ -405,7 +418,7 @@ GAddress *GSocket_GetLocal(GSocket *socket) address = GAddress_new(); if (address == NULL) { - socket->m_error = GSOCK_MEMERR; + m_error = GSOCK_MEMERR; return NULL; } @@ -413,20 +426,20 @@ GAddress *GSocket_GetLocal(GSocket *socket) if (err != GSOCK_NOERROR) { GAddress_destroy(address); - socket->m_error = err; + m_error = err; return NULL; } return address; } -GAddress *GSocket_GetPeer(GSocket *socket) +GAddress *GSocket::GetPeer() { - assert(socket != NULL); + assert(this); /* try to get it from the m_peer var */ - if (socket->m_peer) - return GAddress_copy(socket->m_peer); + if (m_peer) + return GAddress_copy(m_peer); return NULL; } @@ -437,69 +450,71 @@ GAddress *GSocket_GetPeer(GSocket *socket) * Sets up this socket as a server. The local address must have been * set with GSocket_SetLocal() before GSocket_SetServer() is called. * Returns GSOCK_NOERROR on success, one of the following otherwise: - * + * * Error codes: * GSOCK_INVSOCK - the socket is in use. * GSOCK_INVADDR - the local address has not been set. - * GSOCK_IOERR - low-level error. + * GSOCK_IOERR - low-level error. */ -GSocketError GSocket_SetServer(GSocket *sck) +GSocketError GSocket::SetServer() { int arg = 1; - assert(sck != NULL); + assert(this); /* must not be in use */ - if (sck->m_fd != INVALID_SOCKET) + if (m_fd != INVALID_SOCKET) { - sck->m_error = GSOCK_INVSOCK; + m_error = GSOCK_INVSOCK; return GSOCK_INVSOCK; } /* the local addr must have been set */ - if (!sck->m_local) + if (!m_local) { - sck->m_error = GSOCK_INVADDR; + m_error = GSOCK_INVADDR; return GSOCK_INVADDR; } /* Initialize all fields */ - sck->m_stream = TRUE; - sck->m_server = TRUE; - sck->m_oriented = TRUE; + m_stream = true; + m_server = true; /* Create the socket */ - sck->m_fd = socket(sck->m_local->m_realfamily, SOCK_STREAM, 0); + m_fd = socket(m_local->m_realfamily, SOCK_STREAM, 0); - if (sck->m_fd == INVALID_SOCKET) + if (m_fd == INVALID_SOCKET) { - sck->m_error = GSOCK_IOERR; + m_error = GSOCK_IOERR; return GSOCK_IOERR; } -#if defined(__EMX__) || defined(__VISAGECPP__) - ioctl(sck->m_fd, FIONBIO, (char*)&arg, sizeof(arg)); -#else - ioctl(sck->m_fd, FIONBIO, &arg); + + /* FreeBSD variants can't use MSG_NOSIGNAL, and instead use a socket option */ +#ifdef SO_NOSIGPIPE + setsockopt(m_fd, SOL_SOCKET, SO_NOSIGPIPE, (const char*)&arg, sizeof(u_long)); #endif - _GSocket_Enable_Events(sck); + + ioctl(m_fd, FIONBIO, &arg); + gs_gui_functions->Enable_Events(this); /* allow a socket to re-bind if the socket is in the TIME_WAIT state after being previously closed. */ - setsockopt(sck->m_fd, SOL_SOCKET, SO_REUSEADDR, (const char*)&arg, sizeof(u_long)); + if (m_reusable) + setsockopt(m_fd, SOL_SOCKET, SO_REUSEADDR, (const char*)&arg, sizeof(u_long)); /* Bind to the local address, * retrieve the actual address bound, * and listen up to 5 connections. */ - if ((bind(sck->m_fd, sck->m_local->m_addr, sck->m_local->m_len) != 0) || - (getsockname(sck->m_fd, - sck->m_local->m_addr, - (SOCKLEN_T *) &sck->m_local->m_len) != 0) || - (listen(sck->m_fd, 5) != 0)) - { - GSocket_close(sck); - sck->m_error = GSOCK_IOERR; + if ((bind(m_fd, m_local->m_addr, m_local->m_len) != 0) || + (getsockname(m_fd, + m_local->m_addr, + (SOCKLEN_T *) &m_local->m_len) != 0) || + (listen(m_fd, 5) != 0)) + { + Close(); + m_error = GSOCK_IOERR; return GSOCK_IOERR; } @@ -516,9 +531,9 @@ GSocketError GSocket_SetServer(GSocket *sck) * GSOCK_TIMEDOUT - timeout, no incoming connections. * GSOCK_WOULDBLOCK - the call would block and the socket is nonblocking. * GSOCK_MEMERR - couldn't allocate memory. - * GSOCK_IOERR - low-level error. + * GSOCK_IOERR - low-level error. */ -GSocket *GSocket_WaitConnection(GSocket *socket) +GSocket *GSocket::WaitConnection() { struct sockaddr from; SOCKLEN_T fromlen = sizeof(from); @@ -526,15 +541,12 @@ GSocket *GSocket_WaitConnection(GSocket *socket) GSocketError err; int arg = 1; - assert(socket != NULL); - - /* Reenable CONNECTION events */ - _GSocket_Enable(socket, GSOCK_CONNECTION); + assert(this); /* If the socket has already been created, we exit immediately */ - if (socket->m_fd == INVALID_SOCKET || !socket->m_server) + if (m_fd == INVALID_SOCKET || !m_server) { - socket->m_error = GSOCK_INVSOCK; + m_error = GSOCK_INVSOCK; return NULL; } @@ -543,50 +555,51 @@ GSocket *GSocket_WaitConnection(GSocket *socket) if (!connection) { - socket->m_error = GSOCK_MEMERR; + m_error = GSOCK_MEMERR; return NULL; } /* Wait for a connection (with timeout) */ - if (_GSocket_Input_Timeout(socket) == GSOCK_TIMEDOUT) + if (Input_Timeout() == GSOCK_TIMEDOUT) { - GSocket_destroy(connection); - /* socket->m_error set by _GSocket_Input_Timeout */ + delete connection; + /* m_error set by _GSocket_Input_Timeout */ return NULL; } - connection->m_fd = accept(socket->m_fd, &from, (SOCKLEN_T *) &fromlen); + connection->m_fd = accept(m_fd, &from, (SOCKLEN_T *) &fromlen); + + /* Reenable CONNECTION events */ + Enable(GSOCK_CONNECTION); if (connection->m_fd == INVALID_SOCKET) { if (errno == EWOULDBLOCK) - socket->m_error = GSOCK_WOULDBLOCK; + m_error = GSOCK_WOULDBLOCK; else - socket->m_error = GSOCK_IOERR; + m_error = GSOCK_IOERR; - GSocket_destroy(connection); + delete connection; return NULL; } /* Initialize all fields */ - connection->m_server = FALSE; - connection->m_stream = TRUE; - connection->m_oriented = TRUE; + connection->m_server = false; + connection->m_stream = true; /* Setup the peer address field */ connection->m_peer = GAddress_new(); if (!connection->m_peer) { - GSocket_destroy(connection); - socket->m_error = GSOCK_MEMERR; + delete connection; + m_error = GSOCK_MEMERR; return NULL; } err = _GAddress_translate_from(connection->m_peer, &from, fromlen); if (err != GSOCK_NOERROR) { - GAddress_destroy(connection->m_peer); - GSocket_destroy(connection); - socket->m_error = err; + delete connection; + m_error = err; return NULL; } #if defined(__EMX__) || defined(__VISAGECPP__) @@ -594,11 +607,21 @@ GSocket *GSocket_WaitConnection(GSocket *socket) #else ioctl(connection->m_fd, FIONBIO, &arg); #endif - _GSocket_Enable_Events(connection); + gs_gui_functions->Enable_Events(connection); return connection; } +bool GSocket::SetReusable() +{ + /* socket must not be null, and must not be in use/already bound */ + if (this && m_fd == INVALID_SOCKET) { + m_reusable = true; + return true; + } + return false; +} + /* Client specific parts */ /* GSocket_Connect: @@ -622,54 +645,65 @@ GSocket *GSocket_WaitConnection(GSocket *socket) * GSOCK_TIMEDOUT - timeout, the connection failed. * GSOCK_WOULDBLOCK - connection in progress (nonblocking sockets only) * GSOCK_MEMERR - couldn't allocate memory. - * GSOCK_IOERR - low-level error. + * GSOCK_IOERR - low-level error. */ -GSocketError GSocket_Connect(GSocket *sck, GSocketStream stream) +GSocketError GSocket::Connect(GSocketStream stream) { int err, ret; int arg = 1; - assert(sck != NULL); + assert(this); /* Enable CONNECTION events (needed for nonblocking connections) */ - _GSocket_Enable(sck, GSOCK_CONNECTION); + Enable(GSOCK_CONNECTION); - if (sck->m_fd != INVALID_SOCKET) + if (m_fd != INVALID_SOCKET) { - sck->m_error = GSOCK_INVSOCK; + m_error = GSOCK_INVSOCK; return GSOCK_INVSOCK; } - if (!sck->m_peer) + if (!m_peer) { - sck->m_error = GSOCK_INVADDR; + m_error = GSOCK_INVADDR; return GSOCK_INVADDR; } /* Streamed or dgram socket? */ - sck->m_stream = (stream == GSOCK_STREAMED); - sck->m_oriented = TRUE; - sck->m_server = FALSE; - sck->m_establishing = FALSE; + m_stream = (stream == GSOCK_STREAMED); + m_server = false; + m_establishing = false; /* Create the socket */ - sck->m_fd = socket(sck->m_peer->m_realfamily, - sck->m_stream? SOCK_STREAM : SOCK_DGRAM, 0); + m_fd = socket(m_peer->m_realfamily, + m_stream? SOCK_STREAM : SOCK_DGRAM, 0); - if (sck->m_fd == INVALID_SOCKET) + if (m_fd == INVALID_SOCKET) { - sck->m_error = GSOCK_IOERR; + m_error = GSOCK_IOERR; return GSOCK_IOERR; } + + /* FreeBSD variants can't use MSG_NOSIGNAL, and instead use a socket option */ +#ifdef SO_NOSIGPIPE + setsockopt(m_fd, SOL_SOCKET, SO_NOSIGPIPE, (const char*)&arg, sizeof(u_long)); +#endif + #if defined(__EMX__) || defined(__VISAGECPP__) - ioctl(sck->m_fd, FIONBIO, (char*)&arg, sizeof(arg)); + ioctl(m_fd, FIONBIO, (char*)&arg, sizeof(arg)); #else - ioctl(sck->m_fd, FIONBIO, &arg); + ioctl(m_fd, FIONBIO, &arg); #endif - _GSocket_Enable_Events(sck); /* Connect it to the peer address, with a timeout (see below) */ - ret = connect(sck->m_fd, sck->m_peer->m_addr, sck->m_peer->m_len); + ret = connect(m_fd, m_peer->m_addr, m_peer->m_len); + + /* We only call Enable_Events if we know e aren't shutting down the socket */ + + if (m_non_blocking) + { + gs_gui_functions->Enable_Events(this); + } if (ret == -1) { @@ -680,20 +714,22 @@ GSocketError GSocket_Connect(GSocket *sck, GSocketStream stream) * checking for writability to see if the connection request * completes. */ - if ((err == EINPROGRESS) && (!sck->m_non_blocking)) + if ((err == EINPROGRESS) && (!m_non_blocking)) { - if (_GSocket_Output_Timeout(sck) == GSOCK_TIMEDOUT) + if (Output_Timeout() == GSOCK_TIMEDOUT) { - GSocket_close(sck); - /* sck->m_error is set in _GSocket_Output_Timeout */ + Close(); + /* m_error is set in _GSocket_Output_Timeout */ return GSOCK_TIMEDOUT; } else { int error; - SOCKLEN_T len = sizeof(error); + SOCKOPTLEN_T len = sizeof(error); + + getsockopt(m_fd, SOL_SOCKET, SO_ERROR, (char*) &error, &len); - getsockopt(sck->m_fd, SOL_SOCKET, SO_ERROR, (void*) &error, &len); + gs_gui_functions->Enable_Events(this); if (!error) return GSOCK_NOERROR; @@ -706,18 +742,18 @@ GSocketError GSocket_Connect(GSocket *sck, GSocketStream stream) * this way if the connection completes, a GSOCK_CONNECTION * event will be generated, if enabled. */ - if ((err == EINPROGRESS) && (sck->m_non_blocking)) + if ((err == EINPROGRESS) && (m_non_blocking)) { - sck->m_establishing = TRUE; - sck->m_error = GSOCK_WOULDBLOCK; + m_establishing = true; + m_error = GSOCK_WOULDBLOCK; return GSOCK_WOULDBLOCK; } /* If connect failed with an error other than EINPROGRESS, * then the call to GSocket_Connect has failed. */ - GSocket_close(sck); - sck->m_error = GSOCK_IOERR; + Close(); + m_error = GSOCK_IOERR; return GSOCK_IOERR; } @@ -737,54 +773,53 @@ GSocketError GSocket_Connect(GSocket *sck, GSocketStream stream) * GSOCK_INVADDR - the local address has not been set. * GSOCK_IOERR - low-level error. */ -GSocketError GSocket_SetNonOriented(GSocket *sck) +GSocketError GSocket::SetNonOriented() { int arg = 1; - assert(sck != NULL); + assert(this); - if (sck->m_fd != INVALID_SOCKET) + if (m_fd != INVALID_SOCKET) { - sck->m_error = GSOCK_INVSOCK; + m_error = GSOCK_INVSOCK; return GSOCK_INVSOCK; } - if (!sck->m_local) + if (!m_local) { - sck->m_error = GSOCK_INVADDR; + m_error = GSOCK_INVADDR; return GSOCK_INVADDR; } /* Initialize all fields */ - sck->m_stream = FALSE; - sck->m_server = FALSE; - sck->m_oriented = FALSE; + m_stream = false; + m_server = false; /* Create the socket */ - sck->m_fd = socket(sck->m_local->m_realfamily, SOCK_DGRAM, 0); + m_fd = socket(m_local->m_realfamily, SOCK_DGRAM, 0); - if (sck->m_fd == INVALID_SOCKET) + if (m_fd == INVALID_SOCKET) { - sck->m_error = GSOCK_IOERR; + m_error = GSOCK_IOERR; return GSOCK_IOERR; } #if defined(__EMX__) || defined(__VISAGECPP__) - ioctl(sck->m_fd, FIONBIO, (char*)&arg, sizeof(arg)); + ioctl(m_fd, FIONBIO, (char*)&arg, sizeof(arg)); #else - ioctl(sck->m_fd, FIONBIO, &arg); + ioctl(m_fd, FIONBIO, &arg); #endif - _GSocket_Enable_Events(sck); + gs_gui_functions->Enable_Events(this); /* Bind to the local address, * and retrieve the actual address bound. */ - if ((bind(sck->m_fd, sck->m_local->m_addr, sck->m_local->m_len) != 0) || - (getsockname(sck->m_fd, - sck->m_local->m_addr, - (SOCKLEN_T *) &sck->m_local->m_len) != 0)) + if ((bind(m_fd, m_local->m_addr, m_local->m_len) != 0) || + (getsockname(m_fd, + m_local->m_addr, + (SOCKLEN_T *) &m_local->m_len) != 0)) { - GSocket_close(sck); - sck->m_error = GSOCK_IOERR; + Close(); + m_error = GSOCK_IOERR; return GSOCK_IOERR; } @@ -794,90 +829,87 @@ GSocketError GSocket_SetNonOriented(GSocket *sck) /* Generic IO */ /* Like recv(), send(), ... */ -int GSocket_Read(GSocket *socket, char *buffer, int size) +int GSocket::Read(char *buffer, int size) { int ret; - assert(socket != NULL); - - /* When using CFSocket we MUST NOT reenable events until we finish reading */ -#ifndef __DARWIN__ - /* Reenable INPUT events */ - _GSocket_Enable(socket, GSOCK_INPUT); -#endif + assert(this); - if (socket->m_fd == INVALID_SOCKET || socket->m_server) + if (m_fd == INVALID_SOCKET || m_server) { - socket->m_error = GSOCK_INVSOCK; + m_error = GSOCK_INVSOCK; return -1; } + /* Disable events during query of socket status */ + Disable(GSOCK_INPUT); + /* If the socket is blocking, wait for data (with a timeout) */ - if (_GSocket_Input_Timeout(socket) == GSOCK_TIMEDOUT) - return -1; + if (Input_Timeout() == GSOCK_TIMEDOUT) + /* We no longer return here immediately, otherwise socket events would not be re-enabled! */ + ret = -1; + else { + /* Read the data */ + if (m_stream) + ret = Recv_Stream(buffer, size); + else + ret = Recv_Dgram(buffer, size); + } - /* Read the data */ - if (socket->m_stream) - ret = _GSocket_Recv_Stream(socket, buffer, size); - else - ret = _GSocket_Recv_Dgram(socket, buffer, size); - if (ret == -1) { - if (errno == EWOULDBLOCK) - socket->m_error = GSOCK_WOULDBLOCK; + if ((errno == EWOULDBLOCK) || (errno == EAGAIN)) + m_error = GSOCK_WOULDBLOCK; else - socket->m_error = GSOCK_IOERR; + m_error = GSOCK_IOERR; } - -#ifdef __DARWIN__ - /* Reenable INPUT events */ - _GSocket_Enable(socket, GSOCK_INPUT); -#endif + + /* Enable events again now that we are done processing */ + Enable(GSOCK_INPUT); return ret; } -int GSocket_Write(GSocket *socket, const char *buffer, int size) -{ +int GSocket::Write(const char *buffer, int size) +{ int ret; - assert(socket != NULL); - + assert(this); + GSocket_Debug(( "GSocket_Write #1, size %d\n", size )); - if (socket->m_fd == INVALID_SOCKET || socket->m_server) + if (m_fd == INVALID_SOCKET || m_server) { - socket->m_error = GSOCK_INVSOCK; + m_error = GSOCK_INVSOCK; return -1; } GSocket_Debug(( "GSocket_Write #2, size %d\n", size )); /* If the socket is blocking, wait for writability (with a timeout) */ - if (_GSocket_Output_Timeout(socket) == GSOCK_TIMEDOUT) + if (Output_Timeout() == GSOCK_TIMEDOUT) return -1; GSocket_Debug(( "GSocket_Write #3, size %d\n", size )); /* Write the data */ - if (socket->m_stream) - ret = _GSocket_Send_Stream(socket, buffer, size); + if (m_stream) + ret = Send_Stream(buffer, size); else - ret = _GSocket_Send_Dgram(socket, buffer, size); - + ret = Send_Dgram(buffer, size); + GSocket_Debug(( "GSocket_Write #4, size %d\n", size )); if (ret == -1) { - if (errno == EWOULDBLOCK) + if ((errno == EWOULDBLOCK) || (errno == EAGAIN)) { - socket->m_error = GSOCK_WOULDBLOCK; + m_error = GSOCK_WOULDBLOCK; GSocket_Debug(( "GSocket_Write error WOULDBLOCK\n" )); } else { - socket->m_error = GSOCK_IOERR; + m_error = GSOCK_IOERR; GSocket_Debug(( "GSocket_Write error IOERR\n" )); } @@ -886,10 +918,10 @@ int GSocket_Write(GSocket *socket, const char *buffer, int size) * that the socket is writable until a read operation fails. Only then * will further OUTPUT events be posted. */ - _GSocket_Enable(socket, GSOCK_OUTPUT); + Enable(GSOCK_OUTPUT); return -1; } - + GSocket_Debug(( "GSocket_Write #5, size %d ret %d\n", size, ret )); return ret; @@ -902,9 +934,9 @@ int GSocket_Write(GSocket *socket, const char *buffer, int size) * performed. This function won't block, regardless of the * mode (blocking | nonblocking) of the socket. */ -GSocketEventFlags GSocket_Select(GSocket *socket, GSocketEventFlags flags) +GSocketEventFlags GSocket::Select(GSocketEventFlags flags) { - if (!USE_GUI()) + if (!gs_gui_functions->CanUseEventLoop()) { GSocketEventFlags result = 0; @@ -913,61 +945,63 @@ GSocketEventFlags GSocket_Select(GSocket *socket, GSocketEventFlags flags) fd_set exceptfds; struct timeval tv; - /* Do not use a static struct, Linux can garble it */ - tv.tv_sec = socket->m_timeout / 1000; - tv.tv_usec = (socket->m_timeout % 1000) / 1000; + assert(this); - assert(socket != NULL); + /* Do not use a static struct, Linux can garble it */ + tv.tv_sec = m_timeout / 1000; + tv.tv_usec = (m_timeout % 1000) * 1000; FD_ZERO(&readfds); FD_ZERO(&writefds); FD_ZERO(&exceptfds); - FD_SET(socket->m_fd, &readfds); - if (flags & GSOCK_OUTPUT_FLAG) - FD_SET(socket->m_fd, &writefds); - FD_SET(socket->m_fd, &exceptfds); + FD_SET(m_fd, &readfds); + if (flags & GSOCK_OUTPUT_FLAG || flags & GSOCK_CONNECTION_FLAG) + FD_SET(m_fd, &writefds); + FD_SET(m_fd, &exceptfds); /* Check 'sticky' CONNECTION flag first */ - result |= (GSOCK_CONNECTION_FLAG & socket->m_detected); + result |= (GSOCK_CONNECTION_FLAG & m_detected); /* If we have already detected a LOST event, then don't try * to do any further processing. */ - if ((socket->m_detected & GSOCK_LOST_FLAG) != 0) + if ((m_detected & GSOCK_LOST_FLAG) != 0) { - socket->m_establishing = FALSE; + m_establishing = false; return (GSOCK_LOST_FLAG & flags); } /* Try select now */ - if (select(socket->m_fd + 1, &readfds, &writefds, &exceptfds, &tv) <= 0) + if (select(m_fd + 1, &readfds, &writefds, &exceptfds, &tv) <= 0) { /* What to do here? */ return (result & flags); } /* Check for readability */ - if (FD_ISSET(socket->m_fd, &readfds)) + if (FD_ISSET(m_fd, &readfds)) { char c; - if (recv(socket->m_fd, &c, 1, MSG_PEEK) > 0) + int num = recv(m_fd, &c, 1, MSG_PEEK | GSOCKET_MSG_NOSIGNAL); + + if (num > 0) { result |= GSOCK_INPUT_FLAG; } else { - if (socket->m_server && socket->m_stream) + if (m_server && m_stream) { result |= GSOCK_CONNECTION_FLAG; - socket->m_detected |= GSOCK_CONNECTION_FLAG; + m_detected |= GSOCK_CONNECTION_FLAG; } - else + else if ((errno != EWOULDBLOCK) && (errno != EAGAIN) && (errno != EINTR)) { - socket->m_detected = GSOCK_LOST_FLAG; - socket->m_establishing = FALSE; - + m_detected = GSOCK_LOST_FLAG; + m_establishing = false; + /* LOST event: Abort any further processing */ return (GSOCK_LOST_FLAG & flags); } @@ -975,20 +1009,20 @@ GSocketEventFlags GSocket_Select(GSocket *socket, GSocketEventFlags flags) } /* Check for writability */ - if (FD_ISSET(socket->m_fd, &writefds)) + if (FD_ISSET(m_fd, &writefds)) { - if (socket->m_establishing && !socket->m_server) + if (m_establishing && !m_server) { int error; - SOCKLEN_T len = sizeof(error); + SOCKOPTLEN_T len = sizeof(error); - socket->m_establishing = FALSE; + m_establishing = false; - getsockopt(socket->m_fd, SOL_SOCKET, SO_ERROR, (void*)&error, &len); + getsockopt(m_fd, SOL_SOCKET, SO_ERROR, (char*)&error, &len); if (error) { - socket->m_detected = GSOCK_LOST_FLAG; + m_detected = GSOCK_LOST_FLAG; /* LOST event: Abort any further processing */ return (GSOCK_LOST_FLAG & flags); @@ -996,7 +1030,7 @@ GSocketEventFlags GSocket_Select(GSocket *socket, GSocketEventFlags flags) else { result |= GSOCK_CONNECTION_FLAG; - socket->m_detected |= GSOCK_CONNECTION_FLAG; + m_detected |= GSOCK_CONNECTION_FLAG; } } else @@ -1006,10 +1040,10 @@ GSocketEventFlags GSocket_Select(GSocket *socket, GSocketEventFlags flags) } /* Check for exceptions and errors (is this useful in Unices?) */ - if (FD_ISSET(socket->m_fd, &exceptfds)) + if (FD_ISSET(m_fd, &exceptfds)) { - socket->m_establishing = FALSE; - socket->m_detected = GSOCK_LOST_FLAG; + m_establishing = false; + m_detected = GSOCK_LOST_FLAG; /* LOST event: Abort any further processing */ return (GSOCK_LOST_FLAG & flags); @@ -1021,8 +1055,8 @@ GSocketEventFlags GSocket_Select(GSocket *socket, GSocketEventFlags flags) else { - assert(socket != NULL); - return flags & socket->m_detected; + assert(this); + return flags & m_detected; } } @@ -1033,24 +1067,24 @@ GSocketEventFlags GSocket_Select(GSocket *socket, GSocketEventFlags flags) * Sets the socket to non-blocking mode. All IO calls will return * immediately. */ -void GSocket_SetNonBlocking(GSocket *socket, int non_block) +void GSocket::SetNonBlocking(bool non_block) { - assert(socket != NULL); + assert(this); GSocket_Debug( ("GSocket_SetNonBlocking: %d\n", (int)non_block) ); - socket->m_non_blocking = non_block; + m_non_blocking = non_block; } /* GSocket_SetTimeout: * Sets the timeout for blocking calls. Time is expressed in * milliseconds. */ -void GSocket_SetTimeout(GSocket *socket, unsigned long millisec) +void GSocket::SetTimeout(unsigned long millisec) { - assert(socket != NULL); + assert(this); - socket->m_timeout = millisec; + m_timeout = millisec; } /* GSocket_GetError: @@ -1058,11 +1092,11 @@ void GSocket_SetTimeout(GSocket *socket, unsigned long millisec) * operations do not clear this back to GSOCK_NOERROR, so use it only * after an error. */ -GSocketError GSocket_GetError(GSocket *socket) +GSocketError WXDLLIMPEXP_NET GSocket::GetError() { - assert(socket != NULL); + assert(this); - return socket->m_error; + return m_error; } /* Callbacks */ @@ -1072,7 +1106,7 @@ GSocketError GSocket_GetError(GSocket *socket) * operation, there is still data available, the callback function will * be called again. * GSOCK_OUTPUT: - * The socket is available for writing. That is, the next write call + * The socket is available for writing. That is, the next write call * won't block. This event is generated only once, when the connection is * first established, and then only if a call failed with GSOCK_WOULDBLOCK, * when the output buffer empties again. This means that the app should @@ -1095,19 +1129,19 @@ GSocketError GSocket_GetError(GSocket *socket) * * void function(GSocket *socket, GSocketEvent event, char *cdata) */ -void GSocket_SetCallback(GSocket *socket, GSocketEventFlags flags, +void GSocket::SetCallback(GSocketEventFlags flags, GSocketCallback callback, char *cdata) { int count; - assert(socket != NULL); + assert(this); for (count = 0; count < GSOCK_MAX_EVENT; count++) { if ((flags & (1 << count)) != 0) { - socket->m_cbacks[count] = callback; - socket->m_data[count] = cdata; + m_cbacks[count] = callback; + m_data[count] = cdata; } } } @@ -1116,65 +1150,84 @@ void GSocket_SetCallback(GSocket *socket, GSocketEventFlags flags, * Disables all callbacks specified by 'flags', which may be a * combination of flags OR'ed toghether. */ -void GSocket_UnsetCallback(GSocket *socket, GSocketEventFlags flags) +void GSocket::UnsetCallback(GSocketEventFlags flags) { int count; - assert(socket != NULL); + assert(this); for (count = 0; count < GSOCK_MAX_EVENT; count++) { if ((flags & (1 << count)) != 0) { - socket->m_cbacks[count] = NULL; - socket->m_data[count] = NULL; + m_cbacks[count] = NULL; + m_data[count] = NULL; } } } +GSocketError GSocket::GetSockOpt(int level, int optname, + void *optval, int *optlen) +{ + if (getsockopt(m_fd, level, optname, (char*)optval, (SOCKOPTLEN_T*)optlen) == 0) + { + return GSOCK_NOERROR; + } + return GSOCK_OPTERR; +} + +GSocketError GSocket::SetSockOpt(int level, int optname, + const void *optval, int optlen) +{ + if (setsockopt(m_fd, level, optname, (const char*)optval, optlen) == 0) + { + return GSOCK_NOERROR; + } + return GSOCK_OPTERR; +} #define CALL_CALLBACK(socket, event) { \ - _GSocket_Disable(socket, event); \ + socket->Disable(event); \ if (socket->m_cbacks[event]) \ socket->m_cbacks[event](socket, event, socket->m_data[event]); \ } -void _GSocket_Enable(GSocket *socket, GSocketEvent event) +void GSocket::Enable(GSocketEvent event) { - socket->m_detected &= ~(1 << event); - _GSocket_Install_Callback(socket, event); + m_detected &= ~(1 << event); + gs_gui_functions->Install_Callback(this, event); } -void _GSocket_Disable(GSocket *socket, GSocketEvent event) +void GSocket::Disable(GSocketEvent event) { - socket->m_detected |= (1 << event); - _GSocket_Uninstall_Callback(socket, event); + m_detected |= (1 << event); + gs_gui_functions->Uninstall_Callback(this, event); } /* _GSocket_Input_Timeout: * For blocking sockets, wait until data is available or * until timeout ellapses. */ -GSocketError _GSocket_Input_Timeout(GSocket *socket) +GSocketError GSocket::Input_Timeout() { struct timeval tv; fd_set readfds; int ret; /* Linux select() will overwrite the struct on return */ - tv.tv_sec = (socket->m_timeout / 1000); - tv.tv_usec = (socket->m_timeout % 1000) * 1000; + tv.tv_sec = (m_timeout / 1000); + tv.tv_usec = (m_timeout % 1000) * 1000; - if (!socket->m_non_blocking) + if (!m_non_blocking) { FD_ZERO(&readfds); - FD_SET(socket->m_fd, &readfds); - ret = select(socket->m_fd + 1, &readfds, NULL, NULL, &tv); + FD_SET(m_fd, &readfds); + ret = select(m_fd + 1, &readfds, NULL, NULL, &tv); if (ret == 0) { GSocket_Debug(( "GSocket_Input_Timeout, select returned 0\n" )); - socket->m_error = GSOCK_TIMEDOUT; + m_error = GSOCK_TIMEDOUT; return GSOCK_TIMEDOUT; } if (ret == -1) @@ -1184,7 +1237,7 @@ GSocketError _GSocket_Input_Timeout(GSocket *socket) if (errno == EINTR) { GSocket_Debug(( "A non blocked signal was caught\n" )); } if (errno == EINVAL) { GSocket_Debug(( "The highest number descriptor is negative\n" )); } if (errno == ENOMEM) { GSocket_Debug(( "Not enough memory\n" )); } - socket->m_error = GSOCK_TIMEDOUT; + m_error = GSOCK_TIMEDOUT; return GSOCK_TIMEDOUT; } } @@ -1195,27 +1248,27 @@ GSocketError _GSocket_Input_Timeout(GSocket *socket) * For blocking sockets, wait until data can be sent without * blocking or until timeout ellapses. */ -GSocketError _GSocket_Output_Timeout(GSocket *socket) +GSocketError GSocket::Output_Timeout() { struct timeval tv; fd_set writefds; int ret; /* Linux select() will overwrite the struct on return */ - tv.tv_sec = (socket->m_timeout / 1000); - tv.tv_usec = (socket->m_timeout % 1000) * 1000; + tv.tv_sec = (m_timeout / 1000); + tv.tv_usec = (m_timeout % 1000) * 1000; - GSocket_Debug( ("m_non_blocking has: %d\n", (int)socket->m_non_blocking) ); + GSocket_Debug( ("m_non_blocking has: %d\n", (int)m_non_blocking) ); - if (!socket->m_non_blocking) + if (!m_non_blocking) { FD_ZERO(&writefds); - FD_SET(socket->m_fd, &writefds); - ret = select(socket->m_fd + 1, NULL, &writefds, NULL, &tv); + FD_SET(m_fd, &writefds); + ret = select(m_fd + 1, NULL, &writefds, NULL, &tv); if (ret == 0) { GSocket_Debug(( "GSocket_Output_Timeout, select returned 0\n" )); - socket->m_error = GSOCK_TIMEDOUT; + m_error = GSOCK_TIMEDOUT; return GSOCK_TIMEDOUT; } if (ret == -1) @@ -1225,10 +1278,10 @@ GSocketError _GSocket_Output_Timeout(GSocket *socket) if (errno == EINTR) { GSocket_Debug(( "A non blocked signal was caught\n" )); } if (errno == EINVAL) { GSocket_Debug(( "The highest number descriptor is negative\n" )); } if (errno == ENOMEM) { GSocket_Debug(( "Not enough memory\n" )); } - socket->m_error = GSOCK_TIMEDOUT; + m_error = GSOCK_TIMEDOUT; return GSOCK_TIMEDOUT; } - if ( ! FD_ISSET(socket->m_fd, &writefds) ) { + if ( ! FD_ISSET(m_fd, &writefds) ) { GSocket_Debug(( "GSocket_Output_Timeout is buggy!\n" )); } else { @@ -1243,12 +1296,17 @@ GSocketError _GSocket_Output_Timeout(GSocket *socket) return GSOCK_NOERROR; } -int _GSocket_Recv_Stream(GSocket *socket, char *buffer, int size) +int GSocket::Recv_Stream(char *buffer, int size) { - return recv(socket->m_fd, buffer, size, 0); + int ret; + do + { + ret = recv(m_fd, buffer, size, GSOCKET_MSG_NOSIGNAL); + } while (ret == -1 && errno == EINTR); /* Loop until not interrupted */ + return ret; } -int _GSocket_Recv_Dgram(GSocket *socket, char *buffer, int size) +int GSocket::Recv_Dgram(char *buffer, int size) { struct sockaddr from; SOCKLEN_T fromlen = sizeof(from); @@ -1257,73 +1315,82 @@ int _GSocket_Recv_Dgram(GSocket *socket, char *buffer, int size) fromlen = sizeof(from); - ret = recvfrom(socket->m_fd, buffer, size, 0, &from, (SOCKLEN_T *) &fromlen); + do + { + ret = recvfrom(m_fd, buffer, size, 0, &from, (SOCKLEN_T *) &fromlen); + } while (ret == -1 && errno == EINTR); /* Loop until not interrupted */ if (ret == -1) return -1; /* Translate a system address into a GSocket address */ - if (!socket->m_peer) + if (!m_peer) { - socket->m_peer = GAddress_new(); - if (!socket->m_peer) + m_peer = GAddress_new(); + if (!m_peer) { - socket->m_error = GSOCK_MEMERR; + m_error = GSOCK_MEMERR; return -1; } } - err = _GAddress_translate_from(socket->m_peer, &from, fromlen); + err = _GAddress_translate_from(m_peer, &from, fromlen); if (err != GSOCK_NOERROR) { - GAddress_destroy(socket->m_peer); - socket->m_peer = NULL; - socket->m_error = err; + GAddress_destroy(m_peer); + m_peer = NULL; + m_error = err; return -1; } return ret; } -int _GSocket_Send_Stream(GSocket *socket, const char *buffer, int size) +int GSocket::Send_Stream(const char *buffer, int size) { int ret; #ifndef __VISAGECPP__ - MASK_SIGNAL(); - ret = send(socket->m_fd, buffer, size, 0); + MASK_SIGNAL(); +#endif + do + { + ret = send(m_fd, (char *)buffer, size, GSOCKET_MSG_NOSIGNAL); + } while (ret == -1 && errno == EINTR); /* Loop until not interrupted */ +#ifndef __VISAGECPP__ UNMASK_SIGNAL(); -#else - ret = send(socket->m_fd, (char *)buffer, size, 0); #endif return ret; } -int _GSocket_Send_Dgram(GSocket *socket, const char *buffer, int size) +int GSocket::Send_Dgram(const char *buffer, int size) { struct sockaddr *addr; int len, ret; GSocketError err; - if (!socket->m_peer) + if (!m_peer) { - socket->m_error = GSOCK_INVADDR; + m_error = GSOCK_INVADDR; return -1; } - err = _GAddress_translate_to(socket->m_peer, &addr, &len); + err = _GAddress_translate_to(m_peer, &addr, &len); if (err != GSOCK_NOERROR) { - socket->m_error = err; + m_error = err; return -1; } #ifndef __VISAGECPP__ MASK_SIGNAL(); - ret = sendto(socket->m_fd, buffer, size, 0, addr, len); +#endif + do + { + ret = sendto(m_fd, (char *)buffer, size, 0, addr, len); + } while (ret == -1 && errno == EINTR); /* Loop until not interrupted */ +#ifndef __VISAGECPP__ UNMASK_SIGNAL(); -#else - ret = sendto(socket->m_fd, (char *)buffer, size, 0, addr, len); #endif /* Frees memory allocated from _GAddress_translate_to */ @@ -1332,84 +1399,110 @@ int _GSocket_Send_Dgram(GSocket *socket, const char *buffer, int size) return ret; } -void _GSocket_Detected_Read(GSocket *socket) +void GSocket::Detected_Read() { char c; + /* Safeguard against straggling call to Detected_Read */ + if (m_fd == INVALID_SOCKET) + { + return; + } + /* If we have already detected a LOST event, then don't try * to do any further processing. */ - if ((socket->m_detected & GSOCK_LOST_FLAG) != 0) + if ((m_detected & GSOCK_LOST_FLAG) != 0) { - socket->m_establishing = FALSE; + m_establishing = false; - CALL_CALLBACK(socket, GSOCK_LOST); - GSocket_Shutdown(socket); + CALL_CALLBACK(this, GSOCK_LOST); + Shutdown(); return; } - if (recv(socket->m_fd, &c, 1, MSG_PEEK) > 0) + int num = recv(m_fd, &c, 1, MSG_PEEK | GSOCKET_MSG_NOSIGNAL); + + if (num > 0) { - CALL_CALLBACK(socket, GSOCK_INPUT); + CALL_CALLBACK(this, GSOCK_INPUT); } else { - if (socket->m_server && socket->m_stream) + if (m_server && m_stream) { - CALL_CALLBACK(socket, GSOCK_CONNECTION); + CALL_CALLBACK(this, GSOCK_CONNECTION); } else { - CALL_CALLBACK(socket, GSOCK_LOST); - GSocket_Shutdown(socket); + /* Do not throw a lost event in cases where the socket isn't really lost */ + if ((errno == EWOULDBLOCK) || (errno == EAGAIN) || (errno == EINTR)) + { + CALL_CALLBACK(this, GSOCK_INPUT); + } + else + { + CALL_CALLBACK(this, GSOCK_LOST); + Shutdown(); + } } } } -void _GSocket_Detected_Write(GSocket *socket) +void GSocket::Detected_Write() { /* If we have already detected a LOST event, then don't try * to do any further processing. */ - if ((socket->m_detected & GSOCK_LOST_FLAG) != 0) + if ((m_detected & GSOCK_LOST_FLAG) != 0) { - socket->m_establishing = FALSE; + m_establishing = false; - CALL_CALLBACK(socket, GSOCK_LOST); - GSocket_Shutdown(socket); + CALL_CALLBACK(this, GSOCK_LOST); + Shutdown(); return; } - if (socket->m_establishing && !socket->m_server) + if (m_establishing && !m_server) { int error; - SOCKLEN_T len = sizeof(error); + SOCKOPTLEN_T len = sizeof(error); - socket->m_establishing = FALSE; + m_establishing = false; - getsockopt(socket->m_fd, SOL_SOCKET, SO_ERROR, (void*)&error, &len); + getsockopt(m_fd, SOL_SOCKET, SO_ERROR, (char*)&error, &len); if (error) { - CALL_CALLBACK(socket, GSOCK_LOST); - GSocket_Shutdown(socket); + CALL_CALLBACK(this, GSOCK_LOST); + Shutdown(); } else { - CALL_CALLBACK(socket, GSOCK_CONNECTION); + CALL_CALLBACK(this, GSOCK_CONNECTION); /* We have to fire this event by hand because CONNECTION (for clients) * and OUTPUT are internally the same and we just disabled CONNECTION * events with the above macro. */ - CALL_CALLBACK(socket, GSOCK_OUTPUT); + CALL_CALLBACK(this, GSOCK_OUTPUT); } } else { - CALL_CALLBACK(socket, GSOCK_OUTPUT); + CALL_CALLBACK(this, GSOCK_OUTPUT); } } +/* Compatibility functions for GSocket */ +GSocket *GSocket_new(void) +{ + GSocket *newsocket = new GSocket(); + if(newsocket->IsOk()) + return newsocket; + delete newsocket; + return NULL; +} + /* * ------------------------------------------------------------------------- * GAddress @@ -1612,12 +1705,14 @@ GSocketError GAddress_INET_SetHostName(GAddress *address, const char *hostname) if (inet_aton(hostname, addr) == 0) { #elif defined(HAVE_INET_ADDR) - if ( (addr->s_addr = inet_addr(hostname)) == -1 ) + if ( (addr->s_addr = inet_addr(hostname)) == (unsigned)-1 ) { #else /* Use gethostbyname by default */ - int val = 1; //VA doesn't like constants in conditional expressions at all +#ifndef __WXMAC__ + int val = 1; /* VA doesn't like constants in conditional expressions */ if (val) +#endif { #endif struct in_addr *array_addr; @@ -1651,7 +1746,7 @@ GSocketError GAddress_INET_SetHostAddress(GAddress *address, CHECK_ADDRESS(address, INET); addr = &(((struct sockaddr_in *)address->m_addr)->sin_addr); - addr->s_addr = hostaddr; + addr->s_addr = htonl(hostaddr); return GSOCK_NOERROR; } @@ -1670,8 +1765,12 @@ GSocketError GAddress_INET_SetPortName(GAddress *address, const char *port, address->m_error = GSOCK_INVPORT; return GSOCK_INVPORT; } - + +#if defined(__WXPM__) && defined(__EMX__) + se = getservbyname(port, (char*)protocol); +#else se = getservbyname(port, protocol); +#endif if (!se) { /* the cast to int suppresses compiler warnings about subscript having the @@ -1702,7 +1801,7 @@ GSocketError GAddress_INET_SetPort(GAddress *address, unsigned short port) assert(address != NULL); CHECK_ADDRESS(address, INET); - + addr = (struct sockaddr_in *)address->m_addr; addr->sin_port = htons(port); @@ -1715,7 +1814,7 @@ GSocketError GAddress_INET_GetHostName(GAddress *address, char *hostname, size_t char *addr_buf; struct sockaddr_in *addr; - assert(address != NULL); + assert(address != NULL); CHECK_ADDRESS(address, INET); addr = (struct sockaddr_in *)address->m_addr; @@ -1737,20 +1836,20 @@ unsigned long GAddress_INET_GetHostAddress(GAddress *address) { struct sockaddr_in *addr; - assert(address != NULL); - CHECK_ADDRESS_RETVAL(address, INET, 0); + assert(address != NULL); + CHECK_ADDRESS_RETVAL(address, INET, 0); addr = (struct sockaddr_in *)address->m_addr; - return addr->sin_addr.s_addr; + return ntohl(addr->sin_addr.s_addr); } unsigned short GAddress_INET_GetPort(GAddress *address) { struct sockaddr_in *addr; - assert(address != NULL); - CHECK_ADDRESS_RETVAL(address, INET, 0); + assert(address != NULL); + CHECK_ADDRESS_RETVAL(address, INET, 0); addr = (struct sockaddr_in *)address->m_addr; return ntohs(addr->sin_port); @@ -1787,9 +1886,9 @@ GSocketError GAddress_UNIX_SetPath(GAddress *address, const char *path) { struct sockaddr_un *addr; - assert(address != NULL); + assert(address != NULL); - CHECK_ADDRESS(address, UNIX); + CHECK_ADDRESS(address, UNIX); addr = ((struct sockaddr_un *)address->m_addr); strncpy(addr->sun_path, path, UNIX_SOCK_PATHLEN);