reverted last commit, still broken for VC6

[wxWidgets.git] / src / msw / gsocket.cpp

diff --git a/src/msw/gsocket.cpp b/src/msw/gsocket.cpp
index c045edb02eb1f7a11d58ec9ed1eb96fbfdb08f43..fbe81c4a01a5c512d83af7f1f054e7d0c70af71d 100644 (file)
--- a/src/msw/gsocket.cpp
+++ b/src/msw/gsocket.cpp
@@ -1,6 +1,6 @@
 /* -------------------------------------------------------------------------
  * Project: GSocket (Generic Socket)
 /* -------------------------------------------------------------------------
  * Project: GSocket (Generic Socket)

- * Name:    gsocket.c
+ * Name:    gsocket.cpp

  * Author:  Guillermo Rodriguez Garcia <guille@iies.es>
  * Purpose: GSocket main MSW file
  * Licence: The wxWindows licence
  * Author:  Guillermo Rodriguez Garcia <guille@iies.es>
  * 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),
 
 #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: */
 
 /* 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 */
 
 /* Global initialisers */
 

-void GSocket_SetGUIFunctions(struct GSocketGUIFunctionsTable *guifunc)
+void GSocket_SetGUIFunctions(GSocketGUIFunctionsTable *guifunc)

 {
   gs_gui_functions = guifunc;
 }
 {
   gs_gui_functions = guifunc;
 }


@@ -114,10 +123,14 @@ int GSocket_Init(void)
 {
   WSADATA wsaData;
 
 {
   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 */
   }
 
   /* Initialize WinSocket */


@@ -128,7 +141,7 @@ void GSocket_Cleanup(void)
 {
   if (gs_gui_functions)
   {
 {
   if (gs_gui_functions)
   {

-      gs_gui_functions->GUI_Cleanup();
+      gs_gui_functions->OnExit();

   }
 
   /* Cleanup WinSocket */
   }
 
   /* Cleanup WinSocket */


@@ -137,93 +150,80 @@ void GSocket_Cleanup(void)
 
 /* Constructors / Destructors for GSocket */
 
 
 /* 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++)
   {
   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 */
   /* 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 */
 
   /* Per-socket GUI-specific cleanup */

-  _GSocket_GUI_Destroy_Socket(socket);
+  gs_gui_functions->Destroy_Socket(this);

 
   /* Check that the socket is really shutdowned */
 
   /* 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 */
 
   /* 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.
  */
 }
 
 /* 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;
 
 {
   int evt;
 

-  assert(socket != NULL);
+  assert(this);

 
   /* If socket has been created, shutdown it */
 
   /* 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++)
   }
 
   /* 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 */
 }
 
 /* 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.
  */
  *    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 */
 
   /* 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)
   {
     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;
   }
 
     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;
 }
 
 
   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)
   {
 
   /* check address */
   if (address == NULL || address->m_family == GSOCK_NOFAMILY)
   {

-    socket->m_error = GSOCK_INVADDR;
+    m_error = GSOCK_INVADDR;

     return 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;
 }
 
 
   return GSOCK_NOERROR;
 }
 

-GAddress *GSocket_GetLocal(GSocket *socket)
+GAddress *GSocket::GetLocal()

 {
   GAddress *address;
   struct sockaddr addr;
   SOCKLEN_T size = sizeof(addr);
   GSocketError err;
 
 {
   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 */
 
   /* 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 */
 
   /* 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;
   }
 
     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)
   {
     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);
      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;
 }
 
      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 */
 
   /* 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;
 }
 
   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.
  */
  *    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;
 
 {
   u_long arg = 1;
 

-  assert(sck != NULL);
+  assert(this);

 
   /* must not be in use */
 
   /* 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 */
     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 */
     return GSOCK_INVADDR;
   }
 
   /* Initialize all fields */

-  sck->m_server   = TRUE;
-  sck->m_stream   = TRUE;
+  m_server   = true;
+  m_stream   = true;

 
   /* Create the socket */
 
   /* 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;
   }
 
     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.
    */
 
   /* 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.
    */
   }
 
   /* 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;
   }
 
     return GSOCK_IOERR;
   }
 


@@ -426,7 +426,7 @@ GSocketError GSocket_SetServer(GSocket *sck)
  *    GSOCK_MEMERR     - couldn't allocate memory.
  *    GSOCK_IOERR      - low-level error.
  */
  *    GSOCK_MEMERR     - couldn't allocate memory.
  *    GSOCK_IOERR      - low-level error.
  */

-GSocket *GSocket_WaitConnection(GSocket *sck)
+GSocket *GSocket::WaitConnection()

 {
   GSocket *connection;
   struct sockaddr from;
 {
   GSocket *connection;
   struct sockaddr from;


@@ -434,15 +434,15 @@ GSocket *GSocket_WaitConnection(GSocket *sck)
   GSocketError err;
   u_long arg = 1;
 
   GSocketError err;
   u_long arg = 1;
 

-  assert(sck != NULL);
+  assert(this);

 
   /* Reenable CONNECTION events */
 
   /* 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 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;
   }
 
     return NULL;
   }
 


@@ -451,54 +451,54 @@ GSocket *GSocket_WaitConnection(GSocket *sck)
 
   if (!connection)
   {
 
   if (!connection)
   {

-    sck->m_error = GSOCK_MEMERR;
+    m_error = GSOCK_MEMERR;

     return NULL;
   }
 
   /* Wait for a connection (with timeout) */
     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;
   }
 
     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)
 
   if (connection->m_fd == INVALID_SOCKET)
   {
     if (WSAGetLastError() == WSAEWOULDBLOCK)

-      sck->m_error = GSOCK_WOULDBLOCK;
+      m_error = GSOCK_WOULDBLOCK;

     else
     else

-      sck->m_error = GSOCK_IOERR;
+      m_error = GSOCK_IOERR;

 
 

-    GSocket_destroy(connection);
+    delete connection;

     return NULL;
   }
 
   /* Initialize all fields */
     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)
   {
 
   /* 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);
     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);
     return NULL;
   }
 
   ioctlsocket(connection->m_fd, FIONBIO, (u_long FAR *) &arg);

-  _GSocket_Enable_Events(connection);
+  gs_gui_functions->Enable_Events(connection);

 
   return 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.
 *  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)
 */
 *  (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 */
 {
     /* 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 */
 }
 
 /* Client specific parts */


@@ -546,48 +546,48 @@ int GSocket_SetReusable(GSocket *socket)
  *    GSOCK_MEMERR     - couldn't allocate memory.
  *    GSOCK_IOERR      - low-level error.
  */
  *    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;
 
 {
   int ret, err;
   u_long arg = 1;
 

-  assert(sck != NULL);
+  assert(this);

 
   /* Enable CONNECTION events (needed for nonblocking connections) */
 
   /* 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;
   }
 
     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? */
     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 */
 
   /* 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;
   }
 
     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) */
 
   /* 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)
   {
 
   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.
      */
      * 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)
       {
 
       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;
       }
 
       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.
      */
      * 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.
      */
       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;
   }
 
     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.
  */
  *    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;
 
 {
   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;
   }
 
     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 */
     return GSOCK_INVADDR;
   }
 
   /* Initialize all fields */

-  sck->m_stream   = FALSE;
-  sck->m_server   = FALSE;
+  m_stream   = false;
+  m_server   = false;

 
   /* Create the socket */
 
   /* 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;
   }
 
     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.
    */
 
   /* 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;
   }
 
     return GSOCK_IOERR;
   }
 


@@ -701,78 +701,78 @@ GSocketError GSocket_SetNonOriented(GSocket *sck)
 /* Generic IO */
 
 /* Like recv(), send(), ... */
 /* Generic IO */
 
 /* Like recv(), send(), ... */

-int GSocket_Read(GSocket *socket, char *buffer, int size)
+int GSocket::Read(char *buffer, int size)

 {
   int ret;
 
 {
   int ret;
 

-  assert(socket != NULL);
+  assert(this);

 
   /* Reenable INPUT events */
 
   /* 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) */
     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 */
     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
   else

-    ret = _GSocket_Recv_Dgram(socket, buffer, size);
+    ret = Recv_Dgram(buffer, size);

 
   if (ret == SOCKET_ERROR)
   {
     if (WSAGetLastError() != WSAEWOULDBLOCK)
 
   if (ret == SOCKET_ERROR)
   {
     if (WSAGetLastError() != WSAEWOULDBLOCK)

-      socket->m_error = GSOCK_IOERR;
+      m_error = GSOCK_IOERR;

     else
     else

-      socket->m_error = GSOCK_WOULDBLOCK;
+      m_error = GSOCK_WOULDBLOCK;

     return -1;
   }
 
   return ret;
 }
 
     return -1;
   }
 
   return ret;
 }
 

-int GSocket_Write(GSocket *socket, const char *buffer, int size)
+int GSocket::Write(const char *buffer, int size)

 {
   int ret;
 
 {
   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) */
     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 */
     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
   else

-    ret = _GSocket_Send_Dgram(socket, buffer, size);
+    ret = Send_Dgram(buffer, size);

 
   if (ret == SOCKET_ERROR)
   {
     if (WSAGetLastError() != WSAEWOULDBLOCK)
 
   if (ret == SOCKET_ERROR)
   {
     if (WSAGetLastError() != WSAEWOULDBLOCK)

-      socket->m_error = GSOCK_IOERR;
+      m_error = GSOCK_IOERR;

     else
     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.
      */
 
     /* 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;
   }
 
     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.
  */
  *  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;
 
   {
     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_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)
     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 */
 
     /* 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 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 */
 
       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 */
     {
       /* 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;
 
     {
       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
       {
       {
         result |= GSOCK_INPUT_FLAG;
       }
       else
       {

-        if (socket->m_server && socket->m_stream)
+        if (m_server && m_stream)

         {
           result |= GSOCK_CONNECTION_FLAG;
         {
           result |= GSOCK_CONNECTION_FLAG;

-          socket->m_detected |= GSOCK_CONNECTION_FLAG;
+          m_detected |= GSOCK_CONNECTION_FLAG;

         }
         else
         {
         }
         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);
 
           /* 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 */
     }
 
     /* 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);
 
       {
         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)
         {
 
         if (error)
         {

-          socket->m_detected = GSOCK_LOST_FLAG;
+          m_detected = GSOCK_LOST_FLAG;

 
           /* LOST event: Abort any further processing */
           return (GSOCK_LOST_FLAG & flags);
 
           /* 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;
         else
         {
           result |= GSOCK_CONNECTION_FLAG;

-          socket->m_detected |= GSOCK_CONNECTION_FLAG;
+          m_detected |= GSOCK_CONNECTION_FLAG;

         }
       }
       else
         }
       }
       else


@@ -885,10 +885,10 @@ GSocketEventFlags GSocket_Select(GSocket *socket, GSocketEventFlags flags)
     }
 
     /* Check for exceptions and errors (is this useful in Unices?) */
     }
 
     /* 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);
 
       /* 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() */
   {
   }
   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.
  */
  *  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.
  */
 }
 
 /* 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:
 }
 
 /* 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.
  */
  *  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 */
 }
 
 /* Callbacks */


@@ -970,19 +970,19 @@ GSocketError GSocket_GetError(GSocket *socket)
  *
  *  void function(GSocket *socket, GSocketEvent event, char *cdata)
  */
  *
  *  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;
 
                          GSocketCallback callback, char *cdata)
 {
   int count;
 

-  assert(socket != NULL);
+  assert(this);

 
   for (count = 0; count < GSOCK_MAX_EVENT; count++)
   {
     if ((flags & (1 << count)) != 0)
     {
 
   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.
  */
  *  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;
 
 {
   int count;
 

-  assert(socket != NULL);
+  assert(this);

 
   for (count = 0; count < GSOCK_MAX_EVENT; count++)
   {
     if ((flags & (1 << count)) != 0)
     {
 
   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)
 {
                                 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;
 }
 
     {
         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)
 {
                                 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;
     }
     {
         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.
  */
  *  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;
 
 {
   fd_set readfds;
 

-  if (!socket->m_non_blocking)
+  if (!m_non_blocking)

   {
     FD_ZERO(&readfds);
   {
     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;
     }
   }
       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.
  */
  *  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;
 
 {
   fd_set writefds;
 

-  if (!socket->m_non_blocking)
+  if (!m_non_blocking)

   {
     FD_ZERO(&writefds);
   {
     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;
     }
   }
       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.
  */
  *  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 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;
   }
     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;
 }
 
     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;
 
 {
   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 (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;
     }
   }
       return -1;
     }
   }

-  err = _GAddress_translate_from(socket->m_peer, &from, fromlen);
+  err = _GAddress_translate_from(m_peer, &from, fromlen);

   if (err != GSOCK_NOERROR)
   {
   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;
 }
 
     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;
 
 {
   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;
   }
 
     return -1;
   }
 

-  err = _GAddress_translate_to(socket->m_peer, &addr, &len);
+  err = _GAddress_translate_to(m_peer, &addr, &len);

   if (err != GSOCK_NOERROR)
   {
   if (err != GSOCK_NOERROR)
   {

-    socket->m_error = err;
+    m_error = err;

     return -1;
   }
 
     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);
 
   /* 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;
 }
 
   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;
 }
 
   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;
 }
 
   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;
   assert (address != NULL);
   address->m_error = GSOCK_INVADDR;
   return GSOCK_INVADDR;