X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/32524c8fb857819d408fc4b90fd00ce96d65f6db..1d6560d796aefb5dbdf217109767b1054c68c291:/src/msw/gsocket.cpp?ds=sidebyside diff --git a/src/msw/gsocket.cpp b/src/msw/gsocket.cpp index c045edb02e..fbe81c4a01 100644 --- a/src/msw/gsocket.cpp +++ b/src/msw/gsocket.cpp @@ -1,6 +1,6 @@ /* ------------------------------------------------------------------------- * Project: GSocket (Generic Socket) - * Name: gsocket.c + * Name: gsocket.cpp * Author: Guillermo Rodriguez Garcia * Purpose: GSocket main MSW file * Licence: The wxWindows licence @@ -8,9 +8,12 @@ * ------------------------------------------------------------------------- */ -/* - * PLEASE don't put C++ comments here - this is a C source file. - */ +// For compilers that support precompilation, includes "wx.h". +#include "wx/wxprec.h" + +#ifdef __BORLANDC__ + #pragma hdrstop +#endif #ifdef _MSC_VER /* RPCNOTIFICATION_ROUTINE in rasasync.h (included from winsock.h), @@ -81,31 +84,37 @@ /* 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 GSocketGUIFunctionsTable *gs_gui_functions; +class GSocketGUIFunctionsTableNull: public GSocketGUIFunctionsTable +{ +public: + virtual bool OnInit(); + virtual void OnExit(); + virtual bool CanUseEventLoop(); + virtual bool Init_Socket(GSocket *socket); + virtual void Destroy_Socket(GSocket *socket); + 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 *WXUNUSED(socket)) +{ return true; } +void GSocketGUIFunctionsTableNull::Destroy_Socket(GSocket *WXUNUSED(socket)) +{} +void GSocketGUIFunctionsTableNull::Enable_Events(GSocket *WXUNUSED(socket)) +{} +void GSocketGUIFunctionsTableNull::Disable_Events(GSocket *WXUNUSED(socket)) +{} /* Global initialisers */ -void GSocket_SetGUIFunctions(struct GSocketGUIFunctionsTable *guifunc) +void GSocket_SetGUIFunctions(GSocketGUIFunctionsTable *guifunc) { gs_gui_functions = guifunc; } @@ -114,10 +123,14 @@ int GSocket_Init(void) { WSADATA wsaData; - 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; } /* Initialize WinSocket */ @@ -128,7 +141,7 @@ void GSocket_Cleanup(void) { if (gs_gui_functions) { - gs_gui_functions->GUI_Cleanup(); + gs_gui_functions->OnExit(); } /* Cleanup WinSocket */ @@ -137,93 +150,80 @@ void GSocket_Cleanup(void) /* Constructors / Destructors for GSocket */ -GSocket *GSocket_new(void) +GSocket::GSocket() { - int i, success; - GSocket *socket; + int i; - if ((socket = (GSocket *) malloc(sizeof(GSocket))) == NULL) - return NULL; - - socket->m_fd = INVALID_SOCKET; + m_fd = INVALID_SOCKET; for (i = 0; i < GSOCK_MAX_EVENT; i++) { - socket->m_cbacks[i] = NULL; + m_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_non_blocking = FALSE; - socket->m_timeout.tv_sec = 10 * 60; /* 10 minutes */ - socket->m_timeout.tv_usec = 0; - socket->m_establishing = FALSE; - socket->m_reusable = FALSE; - + m_detected = 0; + m_local = NULL; + m_peer = NULL; + m_error = GSOCK_NOERROR; + m_server = false; + m_stream = true; + m_non_blocking = false; + m_timeout.tv_sec = 10 * 60; /* 10 minutes */ + m_timeout.tv_usec = 0; + m_establishing = false; + m_reusable = false; + + assert(gs_gui_functions); /* Per-socket GUI-specific initialization */ - success = _GSocket_GUI_Init_Socket(socket); - if (!success) - { - free(socket); - socket = NULL; - } - - return socket; + m_ok = gs_gui_functions->Init_Socket(this); } -void GSocket_close(GSocket *socket) +void GSocket::Close() { - _GSocket_Disable_Events(socket); - closesocket(socket->m_fd); - socket->m_fd = INVALID_SOCKET; + gs_gui_functions->Disable_Events(this); + closesocket(m_fd); + m_fd = INVALID_SOCKET; } -void GSocket_destroy(GSocket *socket) +GSocket::~GSocket() { - assert(socket != NULL); + assert(this); /* Per-socket GUI-specific cleanup */ - _GSocket_GUI_Destroy_Socket(socket); + gs_gui_functions->Destroy_Socket(this); /* Check that the socket is really shutdowned */ - if (socket->m_fd != INVALID_SOCKET) - GSocket_Shutdown(socket); + if (m_fd != INVALID_SOCKET) + Shutdown(); /* Destroy private addresses */ - if (socket->m_local) - GAddress_destroy(socket->m_local); + if (m_local) + GAddress_destroy(m_local); - if (socket->m_peer) - GAddress_destroy(socket->m_peer); - - /* 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 */ @@ -242,101 +242,101 @@ 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, &size) == SOCKET_ERROR) + if (getsockname(m_fd, &addr, &size) == SOCKET_ERROR) { - socket->m_error = GSOCK_IOERR; + m_error = GSOCK_IOERR; return NULL; } /* got a valid address from getsockname, create a GAddress object */ if ((address = GAddress_new()) == NULL) { - socket->m_error = GSOCK_MEMERR; + m_error = GSOCK_MEMERR; return NULL; } if ((err = _GAddress_translate_from(address, &addr, size)) != 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; } @@ -353,61 +353,61 @@ GAddress *GSocket_GetPeer(GSocket *socket) * GSOCK_INVADDR - the local address has not been set. * GSOCK_IOERR - low-level error. */ -GSocketError GSocket_SetServer(GSocket *sck) +GSocketError GSocket::SetServer() { u_long 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_server = TRUE; - sck->m_stream = TRUE; + m_server = true; + m_stream = 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; } - ioctlsocket(sck->m_fd, FIONBIO, (u_long FAR *) &arg); - _GSocket_Enable_Events(sck); + ioctlsocket(m_fd, FIONBIO, (u_long FAR *) &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. */ - if (sck->m_reusable) { - 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)) + 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)) { - GSocket_close(sck); - sck->m_error = GSOCK_IOERR; + Close(); + m_error = GSOCK_IOERR; return GSOCK_IOERR; } @@ -426,7 +426,7 @@ GSocketError GSocket_SetServer(GSocket *sck) * GSOCK_MEMERR - couldn't allocate memory. * GSOCK_IOERR - low-level error. */ -GSocket *GSocket_WaitConnection(GSocket *sck) +GSocket *GSocket::WaitConnection() { GSocket *connection; struct sockaddr from; @@ -434,15 +434,15 @@ GSocket *GSocket_WaitConnection(GSocket *sck) GSocketError err; u_long arg = 1; - assert(sck != NULL); + assert(this); /* Reenable CONNECTION events */ - sck->m_detected &= ~GSOCK_CONNECTION_FLAG; + m_detected &= ~GSOCK_CONNECTION_FLAG; /* If the socket has already been created, we exit immediately */ - if (sck->m_fd == INVALID_SOCKET || !sck->m_server) + if (m_fd == INVALID_SOCKET || !m_server) { - sck->m_error = GSOCK_INVSOCK; + m_error = GSOCK_INVSOCK; return NULL; } @@ -451,54 +451,54 @@ GSocket *GSocket_WaitConnection(GSocket *sck) if (!connection) { - sck->m_error = GSOCK_MEMERR; + m_error = GSOCK_MEMERR; return NULL; } /* Wait for a connection (with timeout) */ - if (_GSocket_Input_Timeout(sck) == GSOCK_TIMEDOUT) + if (Input_Timeout() == GSOCK_TIMEDOUT) { - GSocket_destroy(connection); - /* sck->m_error set by _GSocket_Input_Timeout */ + delete connection; + /* m_error set by _GSocket_Input_Timeout */ return NULL; } - connection->m_fd = accept(sck->m_fd, &from, &fromlen); + connection->m_fd = accept(m_fd, &from, &fromlen); if (connection->m_fd == INVALID_SOCKET) { if (WSAGetLastError() == WSAEWOULDBLOCK) - sck->m_error = GSOCK_WOULDBLOCK; + m_error = GSOCK_WOULDBLOCK; else - sck->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_server = false; + connection->m_stream = true; /* Setup the peer address field */ connection->m_peer = GAddress_new(); if (!connection->m_peer) { - GSocket_destroy(connection); - sck->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); - sck->m_error = err; + delete connection; + m_error = err; return NULL; } ioctlsocket(connection->m_fd, FIONBIO, (u_long FAR *) &arg); - _GSocket_Enable_Events(connection); + gs_gui_functions->Enable_Events(connection); return connection; } @@ -508,17 +508,17 @@ GSocket *GSocket_WaitConnection(GSocket *sck) * make the appropriate setsockopt() call. * Implemented as a GSocket function because clients (ie, wxSocketServer) * don't have access to the GSocket struct information. -* Returns TRUE if the flag was set correctly, FALSE if an error occured +* Returns true if the flag was set correctly, false if an error occured * (ie, if the parameter was NULL) */ -int GSocket_SetReusable(GSocket *socket) +bool GSocket::SetReusable() { /* socket must not be null, and must not be in use/already bound */ - if (NULL != socket && socket->m_fd == INVALID_SOCKET) { - socket->m_reusable = TRUE; - return TRUE; + if (this && m_fd == INVALID_SOCKET) { + m_reusable = true; + return true; } - return FALSE; + return false; } /* Client specific parts */ @@ -546,48 +546,48 @@ int GSocket_SetReusable(GSocket *socket) * GSOCK_MEMERR - couldn't allocate memory. * GSOCK_IOERR - low-level error. */ -GSocketError GSocket_Connect(GSocket *sck, GSocketStream stream) +GSocketError GSocket::Connect(GSocketStream stream) { int ret, err; u_long arg = 1; - assert(sck != NULL); + assert(this); /* Enable CONNECTION events (needed for nonblocking connections) */ - sck->m_detected &= ~GSOCK_CONNECTION_FLAG; + m_detected &= ~GSOCK_CONNECTION_FLAG; - 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_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; } - ioctlsocket(sck->m_fd, FIONBIO, (u_long FAR *) &arg); - _GSocket_Enable_Events(sck); + ioctlsocket(m_fd, FIONBIO, (u_long FAR *) &arg); + gs_gui_functions->Enable_Events(this); /* 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); if (ret == SOCKET_ERROR) { @@ -598,14 +598,14 @@ GSocketError GSocket_Connect(GSocket *sck, GSocketStream stream) * checking for writability to see if the connection request * completes. */ - if ((err == WSAEWOULDBLOCK) && (!sck->m_non_blocking)) + if ((err == WSAEWOULDBLOCK) && (!m_non_blocking)) { - err = _GSocket_Connect_Timeout(sck); + err = Connect_Timeout(); if (err != GSOCK_NOERROR) { - GSocket_close(sck); - /* sck->m_error is set in _GSocket_Connect_Timeout */ + Close(); + /* m_error is set in _GSocket_Connect_Timeout */ } return (GSocketError) err; @@ -617,18 +617,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 == WSAEWOULDBLOCK) && (sck->m_non_blocking)) + if ((err == WSAEWOULDBLOCK) && (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 EWOULDBLOCK, * then the call to GSocket_Connect() has failed. */ - GSocket_close(sck); - sck->m_error = GSOCK_IOERR; + Close(); + m_error = GSOCK_IOERR; return GSOCK_IOERR; } @@ -648,50 +648,50 @@ 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() { u_long 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; + 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; } - ioctlsocket(sck->m_fd, FIONBIO, (u_long FAR *) &arg); - _GSocket_Enable_Events(sck); + ioctlsocket(m_fd, FIONBIO, (u_long FAR *) &arg); + 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; } @@ -701,78 +701,78 @@ 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); + assert(this); /* Reenable INPUT events */ - socket->m_detected &= ~GSOCK_INPUT_FLAG; + m_detected &= ~GSOCK_INPUT_FLAG; - 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; } /* If the socket is blocking, wait for data (with a timeout) */ - if (_GSocket_Input_Timeout(socket) == GSOCK_TIMEDOUT) + if (Input_Timeout() == GSOCK_TIMEDOUT) return -1; /* Read the data */ - if (socket->m_stream) - ret = _GSocket_Recv_Stream(socket, buffer, size); + if (m_stream) + ret = Recv_Stream(buffer, size); else - ret = _GSocket_Recv_Dgram(socket, buffer, size); + ret = Recv_Dgram(buffer, size); if (ret == SOCKET_ERROR) { if (WSAGetLastError() != WSAEWOULDBLOCK) - socket->m_error = GSOCK_IOERR; + m_error = GSOCK_IOERR; else - socket->m_error = GSOCK_WOULDBLOCK; + m_error = GSOCK_WOULDBLOCK; return -1; } 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); - 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; } /* 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; /* 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); if (ret == SOCKET_ERROR) { if (WSAGetLastError() != WSAEWOULDBLOCK) - socket->m_error = GSOCK_IOERR; + m_error = GSOCK_IOERR; else - socket->m_error = GSOCK_WOULDBLOCK; + m_error = GSOCK_WOULDBLOCK; /* Only reenable OUTPUT events after an error (just like WSAAsyncSelect * does). Once the first OUTPUT event is received, users can assume * that the socket is writable until a read operation fails. Only then * will further OUTPUT events be posted. */ - socket->m_detected &= ~GSOCK_OUTPUT_FLAG; + m_detected &= ~GSOCK_OUTPUT_FLAG; return -1; } @@ -786,66 +786,66 @@ 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; fd_set readfds; fd_set writefds; fd_set exceptfds; - assert(socket != NULL); + assert(this); FD_ZERO(&readfds); FD_ZERO(&writefds); FD_ZERO(&exceptfds); - FD_SET(socket->m_fd, &readfds); + FD_SET(m_fd, &readfds); if (flags & GSOCK_OUTPUT_FLAG || flags & GSOCK_CONNECTION_FLAG) - FD_SET(socket->m_fd, &writefds); - FD_SET(socket->m_fd, &exceptfds); + 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, - &socket->m_timeout) <= 0) + if (select(m_fd + 1, &readfds, &writefds, &exceptfds, + &m_timeout) <= 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 (!socket->m_stream || recv(socket->m_fd, &c, 1, MSG_PEEK) > 0) + if (!m_stream || recv(m_fd, &c, 1, MSG_PEEK) > 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 { - 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); @@ -854,20 +854,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); - socket->m_establishing = FALSE; + m_establishing = false; - getsockopt(socket->m_fd, SOL_SOCKET, SO_ERROR, (char*)&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); @@ -875,7 +875,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 @@ -885,10 +885,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); @@ -898,8 +898,8 @@ GSocketEventFlags GSocket_Select(GSocket *socket, GSocketEventFlags flags) } else /* USE_GUI() */ { - assert(socket != NULL); - return flags & socket->m_detected; + assert(this); + return flags & m_detected; } } @@ -909,23 +909,23 @@ 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); - 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 millis) +void GSocket::SetTimeout(unsigned long millis) { - assert(socket != NULL); + assert(this); - socket->m_timeout.tv_sec = (millis / 1000); - socket->m_timeout.tv_usec = (millis % 1000) * 1000; + m_timeout.tv_sec = (millis / 1000); + m_timeout.tv_usec = (millis % 1000) * 1000; } /* GSocket_GetError: @@ -933,11 +933,11 @@ void GSocket_SetTimeout(GSocket *socket, unsigned long millis) * 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 */ @@ -970,19 +970,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; } } } @@ -991,36 +991,36 @@ 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(GSocket *socket, int level, int optname, +GSocketError GSocket::GetSockOpt(int level, int optname, void *optval, int *optlen) { - if (getsockopt(socket->m_fd, level, optname, (char*)optval, optlen) == 0) + if (getsockopt(m_fd, level, optname, (char*)optval, optlen) == 0) { return GSOCK_NOERROR; } return GSOCK_OPTERR; } -GSocketError GSocket_SetSockOpt(GSocket *socket, int level, int optname, +GSocketError GSocket::SetSockOpt(int level, int optname, const void *optval, int optlen) { - if (setsockopt(socket->m_fd, level, optname, (char*)optval, optlen) == 0) + if (setsockopt(m_fd, level, optname, (char*)optval, optlen) == 0) { return GSOCK_NOERROR; } @@ -1033,17 +1033,17 @@ GSocketError GSocket_SetSockOpt(GSocket *socket, int level, int optname, * For blocking sockets, wait until data is available or * until timeout ellapses. */ -GSocketError _GSocket_Input_Timeout(GSocket *socket) +GSocketError GSocket::Input_Timeout() { fd_set readfds; - if (!socket->m_non_blocking) + if (!m_non_blocking) { FD_ZERO(&readfds); - FD_SET(socket->m_fd, &readfds); - if (select(0, &readfds, NULL, NULL, &socket->m_timeout) == 0) + FD_SET(m_fd, &readfds); + if (select(0, &readfds, NULL, NULL, &m_timeout) == 0) { - socket->m_error = GSOCK_TIMEDOUT; + m_error = GSOCK_TIMEDOUT; return GSOCK_TIMEDOUT; } } @@ -1054,17 +1054,17 @@ 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() { fd_set writefds; - if (!socket->m_non_blocking) + if (!m_non_blocking) { FD_ZERO(&writefds); - FD_SET(socket->m_fd, &writefds); - if (select(0, NULL, &writefds, NULL, &socket->m_timeout) == 0) + FD_SET(m_fd, &writefds); + if (select(0, NULL, &writefds, NULL, &m_timeout) == 0) { - socket->m_error = GSOCK_TIMEDOUT; + m_error = GSOCK_TIMEDOUT; return GSOCK_TIMEDOUT; } } @@ -1075,93 +1075,93 @@ GSocketError _GSocket_Output_Timeout(GSocket *socket) * For blocking sockets, wait until the connection is * established or fails, or until timeout ellapses. */ -GSocketError _GSocket_Connect_Timeout(GSocket *socket) +GSocketError GSocket::Connect_Timeout() { fd_set writefds; fd_set exceptfds; FD_ZERO(&writefds); FD_ZERO(&exceptfds); - FD_SET(socket->m_fd, &writefds); - FD_SET(socket->m_fd, &exceptfds); - if (select(0, NULL, &writefds, &exceptfds, &socket->m_timeout) == 0) + FD_SET(m_fd, &writefds); + FD_SET(m_fd, &exceptfds); + if (select(0, NULL, &writefds, &exceptfds, &m_timeout) == 0) { - 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)) { - socket->m_error = GSOCK_IOERR; + m_error = GSOCK_IOERR; return GSOCK_IOERR; } 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); + return recv(m_fd, buffer, size, 0); } -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); int ret; GSocketError err; - ret = recvfrom(socket->m_fd, buffer, size, 0, &from, &fromlen); + ret = recvfrom(m_fd, buffer, size, 0, &from, &fromlen); if (ret == SOCKET_ERROR) return SOCKET_ERROR; /* 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) { - return send(socket->m_fd, buffer, size, 0); + return send(m_fd, buffer, size, 0); } -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; } - ret = sendto(socket->m_fd, buffer, size, 0, addr, len); + ret = sendto(m_fd, buffer, size, 0, addr, len); /* Frees memory allocated by _GAddress_translate_to */ free(addr); @@ -1169,6 +1169,16 @@ int _GSocket_Send_Dgram(GSocket *socket, const char *buffer, int size) return ret; } +/* Compatibility functions for GSocket */ +GSocket *GSocket_new(void) +{ + GSocket *newsocket = new GSocket(); + if(newsocket->IsOk()) + return newsocket; + delete newsocket; + return NULL; +} + /* * ------------------------------------------------------------------------- @@ -1518,24 +1528,15 @@ GSocketError _GAddress_Init_UNIX(GAddress *address) return GSOCK_INVADDR; } -GSocketError GAddress_UNIX_SetPath(GAddress *address, const char *path) +GSocketError GAddress_UNIX_SetPath(GAddress *address, const char *WXUNUSED(path)) { -#if defined(__BORLANDC__) - /* prevents unused variable message in Borland */ - (void)path; -#endif assert (address != NULL); address->m_error = GSOCK_INVADDR; return GSOCK_INVADDR; } -GSocketError GAddress_UNIX_GetPath(GAddress *address, char *path, size_t sbuf) +GSocketError GAddress_UNIX_GetPath(GAddress *address, char *WXUNUSED(path), size_t WXUNUSED(sbuf)) { -#if defined(__BORLANDC__) - /* prevents unused variable message in Borland */ - (void)path; - (void)sbuf; -#endif assert (address != NULL); address->m_error = GSOCK_INVADDR; return GSOCK_INVADDR;