check that the version of __sync_sub_and_fetch that returns a value is supported...

[wxWidgets.git] / src / mac / carbon / gsocket.cpp

diff --git a/src/mac/carbon/gsocket.cpp b/src/mac/carbon/gsocket.cpp
index 979d7c5d339e1ca656bdedd10f18bfd8f6782c83..1b14f7d3a0d74a2ef033e234d23994f124c56416 100644 (file)
--- a/src/mac/carbon/gsocket.cpp
+++ b/src/mac/carbon/gsocket.cpp
@@ -1,11 +1,13 @@
 /* -------------------------------------------------------------------------
 /* -------------------------------------------------------------------------

- * Project: GSocket (Generic Socket) for WX
- * Name:    gsocket.cpp
- * Authors: Guilhem Lavaux,
- *          Guillermo Rodriguez Garcia <guille@iies.es> (maintainer)
- *          Stefan CSomor
- * Purpose: GSocket main mac file
- * CVSID:   $Id$
+ * Project:     GSocket (Generic Socket) for WX
+ * Name:        src/mac/carbon/gsocket.cpp
+ * Copyright:   (c) Guilhem Lavaux
+ * Licence:     wxWindows Licence
+ * Authors:     Guilhem Lavaux,
+ *              Guillermo Rodriguez Garcia <guille@iies.es> (maintainer)
+ *              Stefan CSomor
+ * Purpose:     GSocket main mac file
+ * CVSID:       $Id$

  * -------------------------------------------------------------------------
  */
 
  * -------------------------------------------------------------------------
  */
 


@@ -14,30 +16,22 @@
  */
 
 #ifndef __GSOCKET_STANDALONE__
  */
 
 #ifndef __GSOCKET_STANDALONE__

-#include "wx/setup.h"

 #include "wx/platform.h"
 #endif
 
 #if wxUSE_SOCKETS || defined(__GSOCKET_STANDALONE__)
 
 #ifdef __DARWIN__
 #include "wx/platform.h"
 #endif
 
 #if wxUSE_SOCKETS || defined(__GSOCKET_STANDALONE__)
 
 #ifdef __DARWIN__

-  #include <CoreServices/CoreServices.h>
-
-  #ifndef FALSE
-    #define FALSE 0
-  #endif
-  #ifndef TRUE
-    #define TRUE 1
-  #endif
+    #include <CoreServices/CoreServices.h>

 #else
 #else

-  #include <MacHeaders.c>
-  #define OTUNIXERRORS 1
-  #include <OpenTransport.h>
-  #include <OpenTransportProviders.h>
-  #include <OpenTptInternet.h>
+    #include <MacHeaders.c>
+    #define OTUNIXERRORS 1
+    #include <OpenTransport.h>
+    #include <OpenTransportProviders.h>
+    #include <OpenTptInternet.h>

 #endif
 #if TARGET_CARBON && !defined(OTAssert)
 #endif
 #if TARGET_CARBON && !defined(OTAssert)

-  #define OTAssert( str , cond ) /* does not exists in Carbon */
+    #define OTAssert( str , cond ) /* does not exists in Carbon */

 #endif
 
 #include <assert.h>
 #endif
 
 #include <assert.h>


@@ -65,22 +59,22 @@
 #endif
 #ifndef __GSOCKET_STANDALONE__
 
 #endif
 #ifndef __GSOCKET_STANDALONE__
 

-#include "wx/mac/macnotfy.h"
-#include "wx/mac/gsockmac.h"
-#include "wx/gsocket.h"
+    #include "wx/mac/macnotfy.h"
+    #include "wx/mac/gsockmac.h"
+    #include "wx/gsocket.h"

 
 #else
 
 
 #else
 

-#include "gsockmac.h"
-#include "gsocket.h"
+    #include "gsockmac.h"
+    #include "gsocket.h"

 
 #endif /* __GSOCKET_STANDALONE__ */
 
 #ifndef ntohl
 
 #endif /* __GSOCKET_STANDALONE__ */
 
 #ifndef ntohl

-#define        ntohl(x)        (x)
-#define        ntohs(x)        (x)
-#define        htonl(x)        (x)
-#define        htons(x)        (x)
+    #define  ntohl(x) (x)
+    #define  ntohs(x) (x)
+    #define  htonl(x) (x)
+    #define  htons(x) (x)

 #endif
 
 void wxCYield() ;
 #endif
 
 void wxCYield() ;


@@ -99,121 +93,121 @@ OTNotifyUPP gOTNotifierUPP = NULL ;
 OSStatus DoNegotiateIPReuseAddrOption(EndpointRef ep, Boolean enableReuseIPMode);
 
 /* Input: ep - endpointref on which to negotiate the option
 OSStatus DoNegotiateIPReuseAddrOption(EndpointRef ep, Boolean enableReuseIPMode);
 
 /* Input: ep - endpointref on which to negotiate the option

-                       enableReuseIPMode - desired option setting - true/false
+               enableReuseIPMode - desired option setting - true/false

    Return: kOTNoError indicates that the option was successfully negotiated
    Return: kOTNoError indicates that the option was successfully negotiated

-                       OSStatus is an error if < 0, otherwise, the status field is
-                       returned and is > 0.
-       
-       IMPORTANT NOTE: The endpoint is assumed to be in synchronous more, otherwise
-                       this code will not function as desired
+           OSStatus is an error if < 0, otherwise, the status field is
+           returned and is > 0.
+
+   IMPORTANT NOTE: The endpoint is assumed to be in synchronous more, otherwise
+                   this code will not function as desired

 */
 
 
 OSStatus DoNegotiateIPReuseAddrOption(EndpointRef ep, Boolean enableReuseIPMode)
 
 {
 */
 
 
 OSStatus DoNegotiateIPReuseAddrOption(EndpointRef ep, Boolean enableReuseIPMode)
 
 {

-       UInt8           buf[kOTFourByteOptionSize];     // define buffer for fourByte Option size
-       TOption*        opt;                                            // option ptr to make items easier to access
-       TOptMgmt        req;
-       TOptMgmt        ret;
-       OSStatus        err;
-       
-       if (!OTIsSynchronous(ep))
-       {
-               return (-1);
-       }
-       opt = (TOption*)buf;                                    // set option ptr to buffer
-       req.opt.buf     = buf;
-       req.opt.len     = sizeof(buf);
-       req.flags       = T_NEGOTIATE;                          // negotiate for option
-
-       ret.opt.buf = buf;
-       ret.opt.maxlen = kOTFourByteOptionSize;
-
-       opt->level      = INET_IP;                                      // dealing with an IP Level function
+    UInt8        buf[kOTFourByteOptionSize]; // define buffer for fourByte Option size
+    TOption*     opt;                        // option ptr to make items easier to access
+    TOptMgmt     req;
+    TOptMgmt     ret;
+    OSStatus     err;
+
+    if (!OTIsSynchronous(ep))
+    {
+        return (-1);
+    }
+    opt = (TOption*)buf; // set option ptr to buffer
+    req.opt.buf = buf;
+    req.opt.len = sizeof(buf);
+    req.flags   = T_NEGOTIATE;    // negotiate for option
+
+    ret.opt.buf = buf;
+    ret.opt.maxlen = kOTFourByteOptionSize;
+
+    opt->level  = INET_IP;        // dealing with an IP Level function

 #ifdef __DARWIN__
 #ifdef __DARWIN__

-       opt->name       = kIP_REUSEADDR;
+    opt->name   = kIP_REUSEADDR;

 #else
 #else

-       opt->name       = IP_REUSEADDR;
+    opt->name   = IP_REUSEADDR;

 #endif
 #endif

-       opt->len        = kOTFourByteOptionSize;
-       opt->status = 0;
-       *(UInt32*)opt->value = enableReuseIPMode;               // set the desired option level, true or false
-
-       err = OTOptionManagement(ep, &req, &ret);
-       
-               // if no error then return the option status value
-       if (err == kOTNoError)
-       {
-               if (opt->status != T_SUCCESS)
-                       err = opt->status;
-               else
-                       err = kOTNoError;
-       }
-                               
-       return err;
+    opt->len    = kOTFourByteOptionSize;
+    opt->status = 0;
+    *(UInt32*)opt->value = enableReuseIPMode;   // set the desired option level, true or false
+
+    err = OTOptionManagement(ep, &req, &ret);
+
+    // if no error then return the option status value
+    if (err == kOTNoError)
+    {
+        if (opt->status != T_SUCCESS)
+            err = opt->status;
+        else
+            err = kOTNoError;
+    }
+
+    return err;

 }
 
 
 pascal void OTInetEventHandler(void*s, OTEventCode event, OTResult, void *cookie) ;
 pascal void OTInetEventHandler(void*s, OTEventCode event, OTResult result, void *cookie)
 {
 }
 
 
 pascal void OTInetEventHandler(void*s, OTEventCode event, OTResult, void *cookie) ;
 pascal void OTInetEventHandler(void*s, OTEventCode event, OTResult result, void *cookie)
 {

-       int wakeUp = true ;
-       GSocket* sock = (GSocket*) s ;
-       
-       if ( event == kOTSyncIdleEvent )
-       {
-               return ;
-       }
-
-       if ( s )
-       {
-               wxMacAddEvent( sock->m_mac_events , _GSocket_Internal_Proc , event , s , wakeUp ) ;
-       }
-
-       return;
+    int wakeUp = true ;
+    GSocket* sock = (GSocket*) s ;
+
+    if ( event == kOTSyncIdleEvent )
+    {
+        return ;
+    }
+
+    if ( s )
+    {
+        wxMacAddEvent( sock->m_mac_events , _GSocket_Internal_Proc , event , s , wakeUp ) ;
+    }
+
+    return;

 }
 
 static void SetDefaultEndpointModes(EndpointRef ep , void *data )
 }
 
 static void SetDefaultEndpointModes(EndpointRef ep , void *data )

-       // This routine sets the supplied endpoint into the default
-       // mode used in this application.  The specifics are:
-       // blocking, synchronous, and using synch idle events with
-       // the standard YieldingNotifier.
+    // This routine sets the supplied endpoint into the default
+    // mode used in this application.  The specifics are:
+    // blocking, synchronous, and using synch idle events with
+    // the standard YieldingNotifier.

 {
 {

-       OSStatus junk = kOTNoError ;
-       OTAssert ("SetDefaultEndpointModes:invalid ref", ep != kOTInvalidEndpointRef ) ;
-       junk = OTSetAsynchronous(ep);
-       OTAssert("SetDefaultEndpointModes: Could not set asynchronous", junk == noErr);
+    OSStatus junk = kOTNoError ;
+    OTAssert ("SetDefaultEndpointModes:invalid ref", ep != kOTInvalidEndpointRef ) ;
+    junk = OTSetAsynchronous(ep);
+    OTAssert("SetDefaultEndpointModes: Could not set asynchronous", junk == noErr);

 /*
 /*

-       junk = OTSetBlocking(ep);
-       OTAssert("SetDefaultEndpointModes: Could not set blocking", junk == noErr);
-       junk = OTSetSynchronous(ep);
-       OTAssert("SetDefaultEndpointModes: Could not set synchronous", junk == noErr);
-       junk = OTSetBlocking(ep);
-       OTAssert("SetDefaultEndpointModes: Could not set blocking", junk == noErr);
+    junk = OTSetBlocking(ep);
+    OTAssert("SetDefaultEndpointModes: Could not set blocking", junk == noErr);
+    junk = OTSetSynchronous(ep);
+    OTAssert("SetDefaultEndpointModes: Could not set synchronous", junk == noErr);
+    junk = OTSetBlocking(ep);
+    OTAssert("SetDefaultEndpointModes: Could not set blocking", junk == noErr);

 */
 */

-       junk = OTInstallNotifier(ep, gOTNotifierUPP, data);
-       OTAssert("SetDefaultEndpointModes: Could not install notifier", junk == noErr);
+    junk = OTInstallNotifier(ep, gOTNotifierUPP, data);
+    OTAssert("SetDefaultEndpointModes: Could not install notifier", junk == noErr);

 /*
 /*

-       junk = OTUseSyncIdleEvents(ep, true);
-       OTAssert("SetDefaultEndpointModes: Could not use sync idle events", junk == noErr);
+    junk = OTUseSyncIdleEvents(ep, true);
+    OTAssert("SetDefaultEndpointModes: Could not use sync idle events", junk == noErr);

 */
 }
 
 /* Global initialisers */
 
 */
 }
 
 /* Global initialisers */
 

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

 {
     // do nothing, wxMac doesn't have wxBase-GUI separation yet
 }
 
 int GSocket_Init()
 {
 {
     // do nothing, wxMac doesn't have wxBase-GUI separation yet
 }
 
 int GSocket_Init()
 {

-    return TRUE;
+    return 1;

 }
 
 }
 

-int GSocket_Verify_Inited() ;
-int GSocket_Verify_Inited()
+bool GSocket_Verify_Inited() ;
+bool GSocket_Verify_Inited()

 {
     OSStatus err ;
 #if TARGET_CARBON
 {
     OSStatus err ;
 #if TARGET_CARBON


@@ -222,35 +216,35 @@ int GSocket_Verify_Inited()
     OTClientContextPtr clientcontext;
 
     if ( gInetSvcRef )
     OTClientContextPtr clientcontext;
 
     if ( gInetSvcRef )

-      return TRUE ;
+      return true ;

 
     InitOpenTransportInContext(kInitOTForApplicationMask, &clientcontext);
     gOTInited = 1 ;
     gInetSvcRef = OTOpenInternetServicesInContext(kDefaultInternetServicesPath,
 
     InitOpenTransportInContext(kInitOTForApplicationMask, &clientcontext);
     gOTInited = 1 ;
     gInetSvcRef = OTOpenInternetServicesInContext(kDefaultInternetServicesPath,

-                                               NULL, &err, clientcontext);
-#else  
+                                                  NULL, &err, clientcontext);
+#else

     if ( gInetSvcRef )
     if ( gInetSvcRef )

-      return TRUE ;
- 
+      return true ;
+

     InitOpenTransport() ;
     gOTInited = 1 ;
     gInetSvcRef = OTOpenInternetServices(kDefaultInternetServicesPath, NULL, &err);
 #endif
     if ( gInetSvcRef == NULL ||  err != kOTNoError )
     {
     InitOpenTransport() ;
     gOTInited = 1 ;
     gInetSvcRef = OTOpenInternetServices(kDefaultInternetServicesPath, NULL, &err);
 #endif
     if ( gInetSvcRef == NULL ||  err != kOTNoError )
     {

-       OTAssert("Could not open Inet Services", err == noErr);
-       return FALSE ;
+        OTAssert("Could not open Inet Services", err == noErr);
+        return false ;

     }
     gOTNotifierUPP = NewOTNotifyUPP( OTInetEventHandler ) ;
     }
     gOTNotifierUPP = NewOTNotifyUPP( OTInetEventHandler ) ;

-    return TRUE ;
+    return true ;

 }
 
 void GSocket_Cleanup()
 {
     if ( gOTInited != 0 )
     {
 }
 
 void GSocket_Cleanup()
 {
     if ( gOTInited != 0 )
     {

-      if ( gInetSvcRef != NULL )
-       OTCloseProvider( gInetSvcRef );
+        if ( gInetSvcRef != NULL )
+            OTCloseProvider( gInetSvcRef );

     #if TARGET_CARBON
       CloseOpenTransportInContext( NULL ) ;
     #else
     #if TARGET_CARBON
       CloseOpenTransportInContext( NULL ) ;
     #else


@@ -263,91 +257,79 @@ void GSocket_Cleanup()
 
 /* Constructors / Destructors for GSocket */
 
 
 /* Constructors / Destructors for GSocket */
 

-GSocket *GSocket_new()
+GSocket::GSocket()

 {
 {

-     

   int i;
   int i;

-  GSocket *socket;
-
- if ( GSocket_Verify_Inited() == FALSE )
-    return NULL ;

 
 

-  socket = (GSocket *)malloc(sizeof(GSocket));
-
-  if (socket == NULL)
-    return NULL;
+  m_ok = GSocket_Verify_Inited();

 
 

-  socket->m_endpoint                  = NULL ;
+  m_endpoint                  = NULL ;

   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             = 1*1000;
+  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             = 1*1000;

                                 /* 10 sec * 1000 millisec */
                                 /* 10 sec * 1000 millisec */

-  socket->m_takesEvents                        = TRUE ;
-  socket->m_mac_events                 = wxMacGetNotifierTable() ;
-  return socket;
+  m_takesEvents         = true ;
+  m_mac_events          = wxMacGetNotifierTable() ;

 }
 
 }
 

-void GSocket_destroy(GSocket *socket)
+GSocket::~GSocket()

 {
 {

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

 
 

-  /* Check that the socket is really shutdowned */
-  if (socket->m_endpoint != kOTInvalidEndpointRef)
-    GSocket_Shutdown(socket);
+    /* Check that the socket is really shutdowned */
+    if (m_endpoint != kOTInvalidEndpointRef)
+        Shutdown();

 
 
 
 

-  /* Destroy private addresses */
-  if (socket->m_local)
-    GAddress_destroy(socket->m_local);
+    /* Destroy private addresses */
+    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()

 {
 {

-  OSStatus err ;
-  int evt;
+    OSStatus err ;
+    int evt;

 
 

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

 
 

-  /* If socket has been created, shutdown it */
-  if (socket->m_endpoint != kOTInvalidEndpointRef )
-  {
-    err = OTSndOrderlyDisconnect( socket->m_endpoint ) ;
-       if ( err != kOTNoError )
-       {
-               
-       }
-    err = OTRcvOrderlyDisconnect( socket->m_endpoint ) ;
-       err = OTUnbind( socket->m_endpoint ) ;
-       err = OTCloseProvider( socket->m_endpoint ) ;
-       socket->m_endpoint = kOTInvalidEndpointRef ;
-  }
+    /* If socket has been created, shutdown it */
+    if (m_endpoint != kOTInvalidEndpointRef )
+    {
+        err = OTSndOrderlyDisconnect( m_endpoint ) ;
+        if ( err != kOTNoError )
+        {
+        }
+
+        err = OTRcvOrderlyDisconnect( m_endpoint ) ;
+        err = OTUnbind( m_endpoint ) ;
+        err = OTCloseProvider( m_endpoint ) ;
+        m_endpoint = kOTInvalidEndpointRef ;
+    }

 
 

-  /* Disable GUI callbacks */
-  for (evt = 0; evt < GSOCK_MAX_EVENT; evt++)
-    socket->m_cbacks[evt] = NULL;
+    /* Disable GUI callbacks */
+    for (evt = 0; evt < GSOCK_MAX_EVENT; evt++)
+        m_cbacks[evt] = NULL;

 
 

-  socket->m_detected = 0;
-  _GSocket_Disable_Events(socket);
-  wxMacRemoveAllNotifiersForData( wxMacGetNotifierTable() , socket ) ;
+    m_detected = 0;
+    Disable_Events();
+    wxMacRemoveAllNotifiersForData( wxMacGetNotifierTable() , this ) ;

 }
 
 
 }
 
 


@@ -367,111 +349,111 @@ 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 */
-  if ((socket->m_endpoint != kOTInvalidEndpointRef && !socket->m_server))
-  {
-    socket->m_error = GSOCK_INVSOCK;
-    return GSOCK_INVSOCK;
-  }
+    /* the socket must be initialized, or it must be a server */
+    if ((m_endpoint != kOTInvalidEndpointRef && !m_server))
+    {
+        m_error = GSOCK_INVSOCK;
+        return GSOCK_INVSOCK;
+    }

 
 

-  /* check address */
-  if (address == NULL || address->m_family == GSOCK_NOFAMILY)
-  {
-    socket->m_error = GSOCK_INVADDR;
-    return GSOCK_INVADDR;
-  }
+    /* check address */
+    if (address == NULL || address->m_family == GSOCK_NOFAMILY)
+    {
+        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;
+    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;
-    return GSOCK_INVADDR;
-  }
+    /* check address */
+    if (address == NULL || address->m_family == GSOCK_NOFAMILY)
+    {
+        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;
+    return GSOCK_NOERROR;

 }
 
 }
 

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

 {
 {

-  GAddress *address = NULL ;
-  GSocketError err;
-  InetAddress loc ;
+    GAddress *address = NULL ;
+    GSocketError err;
+    InetAddress loc ;

 
 

-  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);
+    /* try to get it from the m_local var first */
+    if (m_local)
+        return GAddress_copy(m_local);
+
+    /* else, if the socket is initialized, try getsockname */
+    if (m_endpoint == kOTInvalidEndpointRef)
+    {
+        m_error = GSOCK_INVSOCK;
+        return NULL;
+    }

 
 

-  /* else, if the socket is initialized, try getsockname */
-  if (socket->m_endpoint == kOTInvalidEndpointRef)
-  {
-    socket->m_error = GSOCK_INVSOCK;
-    return NULL;
-  }

 
 

-       

 /* we do not support multihoming with this code at the moment
 /* we do not support multihoming with this code at the moment

-   OTGetProtAddress will have to be used then - but we don't have a handy 
+   OTGetProtAddress will have to be used then - but we don't have a handy

    method to use right now
 */
    method to use right now
 */

-  {
-    InetInterfaceInfo  info;
-    OTInetGetInterfaceInfo(&info, kDefaultInetInterface);
-    loc.fHost = info.fAddress ;
-    loc.fPort = 0 ;
-       loc.fAddressType = AF_INET ;
-  }
+    {
+        InetInterfaceInfo info;
+        OTInetGetInterfaceInfo(&info, kDefaultInetInterface);
+        loc.fHost = info.fAddress ;
+        loc.fPort = 0 ;
+        loc.fAddressType = AF_INET ;
+    }

 
 

-  /* got a valid address from getsockname, create a GAddress object */
-  address = GAddress_new();
-  if (address == NULL)
-  {
-    socket->m_error = GSOCK_MEMERR;
-    return NULL;
-  }
+    /* got a valid address from getsockname, create a GAddress object */
+    address = GAddress_new();
+    if (address == NULL)
+    {
+        m_error = GSOCK_MEMERR;
+        return NULL;
+    }

 
 

-  err = _GAddress_translate_from(address, &loc);
-  if (err != GSOCK_NOERROR)
-  {
-    GAddress_destroy(address);
-    socket->m_error = err;
-    return NULL;
-  }
+    err = _GAddress_translate_from(address, &loc);
+    if (err != GSOCK_NOERROR)
+    {
+        GAddress_destroy(address);
+        m_error = err;
+        return NULL;
+    }

 
 

-  return address;
+    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);
+    /* try to get it from the m_peer var */
+    if (m_peer)
+        return GAddress_copy(m_peer);

 
 

-  return NULL;
+    return NULL;

 }
 
 /* Server specific parts */
 }
 
 /* Server specific parts */


@@ -480,62 +462,62 @@ 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:
  *  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.
  *  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()

 {
 {

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

 
   /* must not be in use */
 
   /* must not be in use */

-  if (sck->m_endpoint != kOTInvalidEndpointRef )
+  if (m_endpoint != kOTInvalidEndpointRef )

   {
   {

-    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_stream   = TRUE;
-  sck->m_server   = TRUE;
-  sck->m_oriented = TRUE;
+  m_stream   = true;
+  m_server   = true;
+  m_oriented = true;

 
 // TODO
 #if 0
   /* Create the socket */
 
 // TODO
 #if 0
   /* Create the socket */

-  sck->m_endpoint = socket(sck->m_local->m_realfamily, SOCK_STREAM, 0);
-  socket_set_ref( sck->m_endpoint , (unsigned long) &gMacNetEvents ,  (unsigned long) sck ) ;
-  if (sck->m_endpoint == kOTInvalidEndpointRef)
+  m_endpoint = socket(m_local->m_realfamily, SOCK_STREAM, 0);
+  socket_set_ref( m_endpoint , (unsigned long) &gMacNetEvents ,  (unsigned long) this ) ;
+  if (m_endpoint == kOTInvalidEndpointRef)

   {
   {

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

     return GSOCK_IOERR;
   }
 
     return GSOCK_IOERR;
   }
 

-  ioctl(sck->m_endpoint, FIONBIO, &arg);
-  _GSocket_Enable_Events(sck);
+  ioctl(m_endpoint, FIONBIO, &arg);
+  Enable_Events();

 
   /* 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_endpoint, sck->m_local->m_addr, sck->m_local->m_len) != 0) ||
-      (getsockname(sck->m_endpoint,
-                   sck->m_local->m_addr,
-                   (SOCKLEN_T *) &sck->m_local->m_len) != 0) ||
-      (listen(sck->m_endpoint, 5) != 0))
+  if ((bind(m_endpoint, m_local->m_addr, m_local->m_len) != 0) ||
+      (getsockname(m_endpoint,
+                   m_local->m_addr,
+                   (WX_SOCKLEN_T *) &m_local->m_len) != 0) ||
+      (listen(m_endpoint, 5) != 0))

   {
   {

-    close(sck->m_endpoint);
-    sck->m_endpoint = -1;
-    sck->m_error = GSOCK_IOERR;
+    close(m_endpoint);
+    m_endpoint = -1;
+    m_error = GSOCK_IOERR;

     return GSOCK_IOERR;
   }
 #endif
     return GSOCK_IOERR;
   }
 #endif


@@ -552,21 +534,21 @@ 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_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()

 {
   GSocket *connection = NULL ;
 
 {
   GSocket *connection = NULL ;
 

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

 
   /* Reenable CONNECTION events */
 
   /* Reenable CONNECTION events */

-  socket->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 (socket->m_endpoint == kOTInvalidEndpointRef || !socket->m_server)
+  if (m_endpoint == kOTInvalidEndpointRef || !m_server)

   {
   {

-    socket->m_error = GSOCK_INVSOCK;
+    m_error = GSOCK_INVSOCK;

     return NULL;
   }
 
     return NULL;
   }
 


@@ -575,45 +557,45 @@ GSocket *GSocket_WaitConnection(GSocket *socket)
 
   if (!connection)
   {
 
   if (!connection)
   {

-    socket->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(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;
   }
 
 // TODO
 #if 0
     return NULL;
   }
 
 // TODO
 #if 0

-  connection->m_endpoint = accept(socket->m_endpoint, &from, (SOCKLEN_T *) &fromlen);
+  connection->m_endpoint = accept(m_endpoint, &from, (WX_SOCKLEN_T *) &fromlen);

 #endif
 
   if (connection->m_endpoint == kOTInvalidEndpointRef )
   {
     if (errno == EWOULDBLOCK)
 #endif
 
   if (connection->m_endpoint == kOTInvalidEndpointRef )
   {
     if (errno == EWOULDBLOCK)

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

     else
     else

-      socket->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_oriented = TRUE;
+  connection->m_server   = false;
+  connection->m_stream   = true;
+  connection->m_oriented = 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);
-    socket->m_error = GSOCK_MEMERR;
+    delete connection;
+    m_error = GSOCK_MEMERR;

     return NULL;
   }
  // TODO
     return NULL;
   }
  // TODO


@@ -623,13 +605,13 @@ GSocket *GSocket_WaitConnection(GSocket *socket)
   {
     GAddress_destroy(connection->m_peer);
     GSocket_destroy(connection);
   {
     GAddress_destroy(connection->m_peer);
     GSocket_destroy(connection);

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

     return NULL;
   }
 
   ioctl(connection->m_endpoint, FIONBIO, &arg);
 #endif
     return NULL;
   }
 
   ioctl(connection->m_endpoint, FIONBIO, &arg);
 #endif

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

 
   return connection;
 }
 
   return connection;
 }


@@ -647,59 +629,59 @@ GSocket *GSocket_WaitConnection(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_SetNonOriented(GSocket *sck)
+GSocketError GSocket::SetNonOriented()

 {
 {

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

 
 

-  if (sck->m_endpoint != kOTInvalidEndpointRef )
+  if (m_endpoint != kOTInvalidEndpointRef )

   {
   {

-    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;
-  sck->m_oriented = FALSE;
+  m_stream   = false;
+  m_server   = false;
+  m_oriented = false;

 
   /* Create the socket */
 
   /* Create the socket */

-  
+

 // TODO
 #if 0
 // TODO
 #if 0

-  sck->m_endpoint = socket(sck->m_local->m_realfamily, SOCK_DGRAM, 0);
-  socket_set_ref( sck->m_endpoint , (unsigned long) &gMacNetEvents ,  (unsigned long) sck ) ;
+  m_endpoint = socket(m_local->m_realfamily, SOCK_DGRAM, 0);
+  socket_set_ref( m_endpoint , (unsigned long) &gMacNetEvents ,  (unsigned long) this ) ;

 #endif
 #endif

-  if (sck->m_endpoint == kOTInvalidEndpointRef )
+  if (m_endpoint == kOTInvalidEndpointRef )

   {
   {

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

     return GSOCK_IOERR;
   }
 
 // TODO
 #if 0
     return GSOCK_IOERR;
   }
 
 // TODO
 #if 0

-  ioctl(sck->m_endpoint, FIONBIO, &arg);
+  ioctl(m_endpoint, FIONBIO, &arg);

 #endif
 #endif

-  _GSocket_Enable_Events(sck);
+  Enable_Events();

 
   /* Bind to the local address,
    * and retrieve the actual address bound.
    */
 // TODO
 #if 0
 
   /* Bind to the local address,
    * and retrieve the actual address bound.
    */
 // TODO
 #if 0

-  if ((bind(sck->m_endpoint, sck->m_local->m_addr, sck->m_local->m_len) != 0) ||
-      (getsockname(sck->m_endpoint,
-                   sck->m_local->m_addr,
-                   (SOCKLEN_T *) &sck->m_local->m_len) != 0))
+  if ((bind(m_endpoint, m_local->m_addr, m_local->m_len) != 0) ||
+      (getsockname(m_endpoint,
+                   m_local->m_addr,
+                   (WX_SOCKLEN_T *) &m_local->m_len) != 0))

   {
   {

-    close(sck->m_endpoint);
-    sck->m_endpoint    = -1;
-    sck->m_error = GSOCK_IOERR;
+    close(m_endpoint);
+    m_endpoint    = -1;
+    m_error = GSOCK_IOERR;

     return GSOCK_IOERR;
   }
 #endif
     return GSOCK_IOERR;
   }
 #endif


@@ -712,7 +694,7 @@ GSocketError GSocket_SetNonOriented(GSocket *sck)
  *  For stream (connection oriented) sockets, GSocket_Connect() tries
  *  to establish a client connection to a server using the peer address
  *  as established with GSocket_SetPeer(). Returns GSOCK_NOERROR if the
  *  For stream (connection oriented) sockets, GSocket_Connect() tries
  *  to establish a client connection to a server using the peer address
  *  as established with GSocket_SetPeer(). Returns GSOCK_NOERROR if the

- *  connection has been succesfully established, or one of the error
+ *  connection has been successfully established, or one of the error

  *  codes listed below. Note that for nonblocking sockets, a return
  *  value of GSOCK_WOULDBLOCK doesn't mean a failure. The connection
  *  request can be completed later; you should use GSocket_Select()
  *  codes listed below. Note that for nonblocking sockets, a return
  *  value of GSOCK_WOULDBLOCK doesn't mean a failure. The connection
  *  request can be completed later; you should use GSocket_Select()


@@ -729,92 +711,92 @@ GSocketError GSocket_SetNonOriented(GSocket *sck)
  *    GSOCK_TIMEDOUT   - timeout, the connection failed.
  *    GSOCK_WOULDBLOCK - connection in progress (nonblocking sockets only)
  *    GSOCK_MEMERR     - couldn't allocate memory.
  *    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)

 {
   InetAddress addr ;
 {
   InetAddress addr ;

-  TEndpointInfo        info;
-   OSStatus            err = kOTNoError;
+  TEndpointInfo   info;
+   OSStatus       err = kOTNoError;

   TCall peer ;
 
   TCall peer ;
 

-  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_endpoint != kOTInvalidEndpointRef )
+  if (m_endpoint != kOTInvalidEndpointRef )

   {
   {

-    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_oriented = TRUE;
-  sck->m_server   = FALSE;
+  m_stream   = (stream == GSOCK_STREAMED);
+  m_oriented = true;
+  m_server   = false;

 
   /* Create the socket */
 #if TARGET_CARBON
 
   /* Create the socket */
 #if TARGET_CARBON

-  sck->m_endpoint = 
-       OTOpenEndpointInContext( OTCreateConfiguration( kTCPName) , 0 , &info , &err , NULL ) ;
+  m_endpoint =
+      OTOpenEndpointInContext( OTCreateConfiguration( kTCPName) , 0 , &info , &err , NULL ) ;

 #else
 #else

-  sck->m_endpoint = 
-       OTOpenEndpoint( OTCreateConfiguration( kTCPName) , 0 , &info , &err ) ;
+  m_endpoint =
+      OTOpenEndpoint( OTCreateConfiguration( kTCPName) , 0 , &info , &err ) ;

 #endif
 #endif

-  if ( sck->m_endpoint == kOTInvalidEndpointRef || err != kOTNoError )
+  if ( m_endpoint == kOTInvalidEndpointRef || err != kOTNoError )

   {
   {

-               sck->m_endpoint = kOTInvalidEndpointRef ;
-       sck->m_error = GSOCK_IOERR;
-       return GSOCK_IOERR;
+    m_endpoint = kOTInvalidEndpointRef ;
+    m_error = GSOCK_IOERR;
+    return GSOCK_IOERR;

   }
   }

-  err = OTBind( sck->m_endpoint , nil , nil ) ;
+  err = OTBind( m_endpoint , nil , nil ) ;

   if ( err != kOTNoError )
   {
   if ( err != kOTNoError )
   {

-       return GSOCK_IOERR;
+    return GSOCK_IOERR;

   }
   }

-  SetDefaultEndpointModes( sck->m_endpoint , sck ) ;
+  SetDefaultEndpointModes( m_endpoint , this ) ;

 // TODO
 #if 0
 // TODO
 #if 0

-  ioctl(sck->m_endpoint, FIONBIO, &arg);
+  ioctl(m_endpoint, FIONBIO, &arg);

 #endif
 #endif

-  _GSocket_Enable_Events(sck);
+  Enable_Events();

 
 

-  _GAddress_translate_to( sck->m_peer , &addr ) ;
+  _GAddress_translate_to( m_peer , &addr ) ;

   memset( &peer , 0 , sizeof( TCall ) ) ;
   peer.addr.len = sizeof( InetAddress ) ;
   peer.addr.buf = (unsigned char*) &addr ;
   memset( &peer , 0 , sizeof( TCall ) ) ;
   peer.addr.len = sizeof( InetAddress ) ;
   peer.addr.buf = (unsigned char*) &addr ;

-  err = OTConnect( sck->m_endpoint , &peer , nil ) ;
+  err = OTConnect( m_endpoint , &peer , nil ) ;

   if ( err != noErr )
   {
     /* If connect failed with EINPROGRESS and the GSocket object
      * is in blocking mode, we select() for the specified timeout
      * checking for writability to see if the connection request
      * completes.
   if ( err != noErr )
   {
     /* If connect failed with EINPROGRESS and the GSocket object
      * is in blocking mode, we select() for the specified timeout
      * checking for writability to see if the connection request
      * completes.

-     */ 
-       
-    if ((err == kOTNoDataErr ) && (!sck->m_non_blocking))
+     */
+
+    if ((err == kOTNoDataErr ) && (!m_non_blocking))

     {
     {

-      if (_GSocket_Output_Timeout(sck) == GSOCK_TIMEDOUT)
+      if (Output_Timeout() == GSOCK_TIMEDOUT)

       {
       {

-       OTSndOrderlyDisconnect( sck->m_endpoint ) ;
-        sck->m_endpoint = kOTInvalidEndpointRef ;
-        /* sck->m_error is set in _GSocket_Output_Timeout */
+        OTSndOrderlyDisconnect( m_endpoint ) ;
+        m_endpoint = kOTInvalidEndpointRef ;
+        /* m_error is set in _GSocket_Output_Timeout */

         return GSOCK_TIMEDOUT;
       }
       else
       {
 /*
         int error;
         return GSOCK_TIMEDOUT;
       }
       else
       {
 /*
         int error;

-        SOCKLEN_T len = sizeof(error);
+        WX_SOCKLEN_T len = sizeof(error);

 
 

-        getsockopt(sck->m_endpoint, SOL_SOCKET, SO_ERROR, (void*) &error, &len);
+        getsockopt(m_endpoint, SOL_SOCKET, SO_ERROR, (void*) &error, &len);

 
         if (!error)
 */
 
         if (!error)
 */


@@ -828,102 +810,102 @@ 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 == kOTNoDataErr) && (sck->m_non_blocking))
+    if ((err == kOTNoDataErr) && (m_non_blocking))

     {
     {

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

       return GSOCK_WOULDBLOCK;
     }
 
     /* If connect failed with an error other than EINPROGRESS,
      * then the call to GSocket_Connect has failed.
      */
       return GSOCK_WOULDBLOCK;
     }
 
     /* If connect failed with an error other than EINPROGRESS,
      * then the call to GSocket_Connect has failed.
      */

-    OTSndOrderlyDisconnect( sck->m_endpoint ) ;
+    OTSndOrderlyDisconnect( m_endpoint ) ;

 
 

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

     return GSOCK_IOERR;
   }
     return GSOCK_IOERR;
   }

-//  OTInetEventHandler(sck, T_CONNECT , kOTNoError , NULL ) ;
+//  OTInetEventHandler(this, T_CONNECT , kOTNoError , NULL ) ;

   return GSOCK_NOERROR;
 }
 
 /* Generic IO */
 
 /* Like recv(), send(), ... */
   return GSOCK_NOERROR;
 }
 
 /* Generic IO */
 
 /* Like recv(), send(), ... */

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

 {
   int ret = 0 ;
 
 {
   int ret = 0 ;
 

-  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_endpoint == kOTInvalidEndpointRef || socket->m_server)
+  if (m_endpoint == kOTInvalidEndpointRef || 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 == -1)
   {
     if (errno == EWOULDBLOCK)
   if (ret == -1)
   {
     if (errno == EWOULDBLOCK)

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

     else
     else

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

   }
   }

-  
+

   return ret;
 }
 
   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_endpoint == kOTInvalidEndpointRef || socket->m_server)
+  if (m_endpoint == kOTInvalidEndpointRef || 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 == -1)
   {
     if (errno == EWOULDBLOCK)
   if (ret == -1)
   {
     if (errno == EWOULDBLOCK)

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

     else
     else

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

 
     /* Only reenable OUTPUT events after an error (just like WSAAsyncSelect
      * in MSW). 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
      * in MSW). 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;
   }

-  
+

   return ret;
 }
 
   return ret;
 }
 


@@ -934,33 +916,33 @@ 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)

 {
 {

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

   wxMacProcessNotifierEvents() ;
   /*
   wxMacProcessNotifierEvents() ;
   /*

-  state = OTGetEndpointState(socket->m_endpoint);
-  
-  if ( ( flags & GSOCK_INPUT_FLAG ) && ! ( socket->m_detected & GSOCK_INPUT_FLAG ) )
+  state = OTGetEndpointState(m_endpoint);
+
+  if ( ( flags & GSOCK_INPUT_FLAG ) && ! ( m_detected & GSOCK_INPUT_FLAG ) )

   {
   {

-       size_t sz = 0 ;
-       OTCountDataBytes( socket->m_endpoint , &sz ) ;
-       if ( state == T_INCON || sz > 0 )
-       {
-        socket->m_detected |= GSOCK_INPUT_FLAG ;
-               (socket->m_cbacks[GSOCK_INPUT])(socket, GSOCK_INPUT, socket->m_data[GSOCK_INPUT]);
-       }
+    size_t sz = 0 ;
+    OTCountDataBytes( m_endpoint , &sz ) ;
+    if ( state == T_INCON || sz > 0 )
+    {
+      m_detected |= GSOCK_INPUT_FLAG ;
+      (m_cbacks[GSOCK_INPUT])(this, GSOCK_INPUT, m_data[GSOCK_INPUT]);
+    }

   }
   }

-  if ( ( flags & GSOCK_INPUT_FLAG ) && ! ( socket->m_detected & GSOCK_OUTPUT_FLAG ) )
+  if ( ( flags & GSOCK_INPUT_FLAG ) && ! ( m_detected & GSOCK_OUTPUT_FLAG ) )

   {
   {

-       if ( state == T_DATAXFER || state == T_INREL )
-       {
-        socket->m_detected |=GSOCK_OUTPUT_FLAG ;
-               (socket->m_cbacks[GSOCK_OUTPUT])(socket, GSOCK_OUTPUT, socket->m_data[GSOCK_OUTPUT]);
-       }
+    if ( state == T_DATAXFER || state == T_INREL )
+    {
+      m_detected |=GSOCK_OUTPUT_FLAG ;
+      (m_cbacks[GSOCK_OUTPUT])(this, GSOCK_OUTPUT, m_data[GSOCK_OUTPUT]);
+    }

   }
   */
   }
   */

-  return ( flags & socket->m_detected ) ;
+  return ( flags & m_detected ) ;

 }
 
 /* Flags */
 }
 
 /* Flags */


@@ -969,36 +951,36 @@ 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 millisec)
+void GSocket::SetTimeout(unsigned long millisec)

 {
 {

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

 
 //  this is usually set too high and we have not yet been able to detect a closed
 //  stream, thus we leave the 10 sec timeout
 
 //  this is usually set too high and we have not yet been able to detect a closed
 //  stream, thus we leave the 10 sec timeout

-//  socket->m_timeout = millisec;
+//  m_timeout = millisec;

 }
 
 /* GSocket_GetError:
 }
 
 /* GSocket_GetError:

- *  Returns the last error occured for this socket. Note that successful
+ *  Returns the last error which occurred for this socket. Note that successful

  *  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 */


@@ -1008,14 +990,14 @@ GSocketError GSocket_GetError(GSocket *socket)
  *   operation, there is still data available, the callback function will
  *   be called again.
  * GSOCK_OUTPUT:
  *   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
  *   assume that it can write since the first OUTPUT event, and no more
  *   OUTPUT events will be generated unless an error occurs.
  * GSOCK_CONNECTION:
  *   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
  *   assume that it can write since the first OUTPUT event, and no more
  *   OUTPUT events will be generated unless an error occurs.
  * GSOCK_CONNECTION:

- *   Connection succesfully established, for client sockets, or incoming
+ *   Connection successfully established, for client sockets, or incoming

  *   client connection, for server sockets. Wait for this event (also watch
  *   out for GSOCK_LOST) after you issue a nonblocking GSocket_Connect() call.
  * GSOCK_LOST:
  *   client connection, for server sockets. Wait for this event (also watch
  *   out for GSOCK_LOST) after you issue a nonblocking GSocket_Connect() call.
  * GSOCK_LOST:


@@ -1031,19 +1013,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;

     }
   }
 }
     }
   }
 }


@@ -1052,18 +1034,18 @@ 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;

     }
   }
 }
     }
   }
 }


@@ -1075,83 +1057,83 @@ void GSocket_UnsetCallback(GSocket *socket, GSocketEventFlags flags)
     socket->m_cbacks[event](socket, event, socket->m_data[event]);      \
 }
 
     socket->m_cbacks[event](socket, event, socket->m_data[event]);      \
 }
 

-int _GSocket_Recv_Stream(GSocket *socket, char *buffer, int size)
+int GSocket::Recv_Stream(char *buffer, int size)

 {
 {

-       OTFlags flags ;
-       OTResult res ;
-       OTByteCount sz = 0 ;
-
-       OTCountDataBytes( socket->m_endpoint , &sz ) ;
-       if ( size > (int)sz )
-         size = sz ;
-       res = OTRcv( socket->m_endpoint , buffer , size , &flags ) ;
-       if ( res < 0 )
-       {
-               return -1 ;
-       }
-       
-       // we simulate another read event if there are still bytes
-       if ( socket->m_takesEvents )
-       {
-               OTByteCount sz = 0 ;
-               OTCountDataBytes( socket->m_endpoint , &sz ) ;
-               if ( sz > 0 )
-               {
-               socket->m_detected |= GSOCK_INPUT_FLAG ;
-                       (socket->m_cbacks[GSOCK_INPUT])(socket, GSOCK_INPUT, socket->m_data[GSOCK_INPUT]);
-               }
-       }
-       return res ;
+    OTFlags flags ;
+    OTResult res ;
+    OTByteCount sz = 0 ;
+
+    OTCountDataBytes( m_endpoint , &sz ) ;
+    if ( size > (int)sz )
+        size = sz ;
+    res = OTRcv( m_endpoint , buffer , size , &flags ) ;
+    if ( res < 0 )
+    {
+        return -1 ;
+    }
+
+    // we simulate another read event if there are still bytes
+    if ( m_takesEvents )
+    {
+        OTByteCount sz = 0 ;
+        OTCountDataBytes( m_endpoint , &sz ) ;
+        if ( sz > 0 )
+        {
+            m_detected |= GSOCK_INPUT_FLAG ;
+            (m_cbacks[GSOCK_INPUT])(this, GSOCK_INPUT, m_data[GSOCK_INPUT]);
+        }
+    }
+    return res ;

 }
 
 }
 

-int _GSocket_Recv_Dgram(GSocket *socket, char *buffer, int size)
+int GSocket::Recv_Dgram(char *buffer, int size)

 {
 // TODO
   int ret = -1;
 #if 0
   struct sockaddr from;
 {
 // TODO
   int ret = -1;
 #if 0
   struct sockaddr from;

-  SOCKLEN_T fromlen = sizeof(from);
+  WX_SOCKLEN_T fromlen = sizeof(from);

   GSocketError err;
 
   fromlen = sizeof(from);
 
   GSocketError err;
 
   fromlen = sizeof(from);
 

-  ret = recvfrom(socket->m_endpoint, buffer, size, 0, &from, (SOCKLEN_T *) &fromlen);
+  ret = recvfrom(m_endpoint, buffer, size, 0, &from, (WX_SOCKLEN_T *) &fromlen);

 
   if (ret == -1)
     return -1;
 
   /* Translate a system address into a GSocket address */
 
   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;
     }
   }
       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;
   }
 #endif
   return ret;
 }
 
     return -1;
   }
 #endif
   return ret;
 }
 

-int _GSocket_Send_Stream(GSocket *socket, const char *buffer, int size)
+int GSocket::Send_Stream(const char *buffer, int size)

 {
 {

-       OTFlags flags = 0 ;
-       OTResult res ;
+    OTFlags flags = 0 ;
+    OTResult res ;

 
 

-       res = OTSnd( socket->m_endpoint , (void*) buffer , size , flags ) ;
-       return res ;
+    res = OTSnd( m_endpoint , (void*) buffer , size , flags ) ;
+    return res ;

 }
 
 }
 

-int _GSocket_Send_Dgram(GSocket *socket, const char *buffer, int size)
+int GSocket::Send_Dgram(const char *buffer, int size)

 {
   int ret = -1 ;
 // TODO
 {
   int ret = -1 ;
 // TODO


@@ -1160,20 +1142,20 @@ int _GSocket_Send_Dgram(GSocket *socket, const char *buffer, int size)
   int len ;
   GSocketError err;
 
   int len ;
   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_endpoint, buffer, size, 0, addr, len);
+  ret = sendto(m_endpoint, buffer, size, 0, addr, len);

 
   /* Frees memory allocated from _GAddress_translate_to */
   free(addr);
 
   /* Frees memory allocated from _GAddress_translate_to */
   free(addr);


@@ -1181,6 +1163,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;
+}
+

 
 /*
  * -------------------------------------------------------------------------
 
 /*
  * -------------------------------------------------------------------------


@@ -1279,7 +1271,7 @@ GSocketError _GAddress_translate_from(GAddress *address,
 GSocketError _GAddress_translate_to(GAddress *address,
                                     InetAddress *addr)
 {
 GSocketError _GAddress_translate_to(GAddress *address,
                                     InetAddress *addr)
 {

- if ( GSocket_Verify_Inited() == FALSE )
+  if ( !GSocket_Verify_Inited() )

     return GSOCK_IOERR ;
   memset(addr, 0 , sizeof(struct InetAddress));
   OTInitInetAddress( addr , address->m_port , address->m_host ) ;
     return GSOCK_IOERR ;
   memset(addr, 0 , sizeof(struct InetAddress));
   OTInitInetAddress( addr , address->m_port , address->m_host ) ;


@@ -1296,7 +1288,7 @@ GSocketError _GAddress_Init_INET(GAddress *address)
 {
   address->m_family = GSOCK_INET;
   address->m_host = kOTAnyInetAddress ;
 {
   address->m_family = GSOCK_INET;
   address->m_host = kOTAnyInetAddress ;

-  
+

   return GSOCK_NOERROR;
 }
 
   return GSOCK_NOERROR;
 }
 


@@ -1305,7 +1297,7 @@ GSocketError GAddress_INET_SetHostName(GAddress *address, const char *hostname)
   InetHostInfo hinfo ;
   OSStatus ret ;
 
   InetHostInfo hinfo ;
   OSStatus ret ;
 

- if ( GSocket_Verify_Inited() == FALSE )
+ if ( !GSocket_Verify_Inited() )

     return GSOCK_IOERR ;
 
   assert(address != NULL);
     return GSOCK_IOERR ;
 
   assert(address != NULL);


@@ -1314,14 +1306,19 @@ GSocketError GAddress_INET_SetHostName(GAddress *address, const char *hostname)
   ret = OTInetStringToAddress( gInetSvcRef , (char*) hostname , &hinfo ) ;
   if ( ret != kOTNoError )
   {
   ret = OTInetStringToAddress( gInetSvcRef , (char*) hostname , &hinfo ) ;
   if ( ret != kOTNoError )
   {

-       address->m_host = INADDR_NONE ;
+    address->m_host = INADDR_NONE ;

     address->m_error = GSOCK_NOHOST;
     return GSOCK_NOHOST;
     address->m_error = GSOCK_NOHOST;
     return GSOCK_NOHOST;

-  }  
+  }

   address->m_host = hinfo.addrs[0] ;
   return GSOCK_NOERROR;
 }
 
   address->m_host = hinfo.addrs[0] ;
   return GSOCK_NOERROR;
 }
 

+GSocketError GAddress_INET_SetBroadcastAddress(GAddress *address)
+{
+  return GAddress_INET_SetHostAddress(address, INADDR_BROADCAST);
+}
+

 GSocketError GAddress_INET_SetAnyAddress(GAddress *address)
 {
   return GAddress_INET_SetHostAddress(address, INADDR_ANY);
 GSocketError GAddress_INET_SetAnyAddress(GAddress *address)
 {
   return GAddress_INET_SetHostAddress(address, INADDR_ANY);


@@ -1339,17 +1336,17 @@ GSocketError GAddress_INET_SetHostAddress(GAddress *address,
   return GSOCK_NOERROR;
 }
 
   return GSOCK_NOERROR;
 }
 

-struct service_entry 
+struct service_entry

 {
 {

-       char * name ;
-       unsigned short port ;
-       char * protocol ; 
+    const char * name ;
+    unsigned short port ;
+    const char * protocol ;

 } ;
 typedef struct service_entry service_entry ;
 
 service_entry gServices[] =
 {
 } ;
 typedef struct service_entry service_entry ;
 
 service_entry gServices[] =
 {

-       { "http" , 80 , "tcp" } 
+    { "http" , 80 , "tcp" }

 } ;
 
 GSocketError GAddress_INET_SetPortName(GAddress *address, const char *port,
 } ;
 
 GSocketError GAddress_INET_SetPortName(GAddress *address, const char *port,


@@ -1367,14 +1364,14 @@ GSocketError GAddress_INET_SetPortName(GAddress *address, const char *port,
   }
   for ( i = 0 ; i < sizeof( gServices) / sizeof( service_entry ) ; ++i )
   {
   }
   for ( i = 0 ; i < sizeof( gServices) / sizeof( service_entry ) ; ++i )
   {

-       if ( strcmp( port , gServices[i].name ) == 0 )
-       {
-               if ( protocol == NULL || strcmp( protocol , gServices[i].protocol ) )
-               {
-                       address->m_port = gServices[i].port ;
-               return GSOCK_NOERROR;
-               }
-       }
+    if ( strcmp( port , gServices[i].name ) == 0 )
+    {
+      if ( protocol == NULL || strcmp( protocol , gServices[i].protocol ) )
+      {
+        address->m_port = gServices[i].port ;
+        return GSOCK_NOERROR;
+      }
+    }

   }
 
   if (isdigit(port[0]))
   }
 
   if (isdigit(port[0]))


@@ -1392,17 +1389,17 @@ GSocketError GAddress_INET_SetPort(GAddress *address, unsigned short port)
   assert(address != NULL);
   CHECK_ADDRESS(address, INET, GSOCK_INVADDR);
   address->m_port = port ;
   assert(address != NULL);
   CHECK_ADDRESS(address, INET, GSOCK_INVADDR);
   address->m_port = port ;

- 
+

   return GSOCK_NOERROR;
 }
 
 GSocketError GAddress_INET_GetHostName(GAddress *address, char *hostname, size_t sbuf)
 {
   InetDomainName name ;
   return GSOCK_NOERROR;
 }
 
 GSocketError GAddress_INET_GetHostName(GAddress *address, char *hostname, size_t sbuf)
 {
   InetDomainName name ;

- if ( GSocket_Verify_Inited() == FALSE )
+  if ( !GSocket_Verify_Inited() )

     return GSOCK_IOERR ;
     return GSOCK_IOERR ;

-  
-  assert(address != NULL); 
+
+  assert(address != NULL);

   CHECK_ADDRESS(address, INET, GSOCK_INVADDR);
 
   OTInetAddressToName( gInetSvcRef , address->m_host , name ) ;
   CHECK_ADDRESS(address, INET, GSOCK_INVADDR);
 
   OTInetAddressToName( gInetSvcRef , address->m_host , name ) ;


@@ -1412,84 +1409,84 @@ GSocketError GAddress_INET_GetHostName(GAddress *address, char *hostname, size_t
 
 unsigned long GAddress_INET_GetHostAddress(GAddress *address)
 {
 
 unsigned long GAddress_INET_GetHostAddress(GAddress *address)
 {

-  assert(address != NULL); 
-  CHECK_ADDRESS(address, INET, 0); 
+  assert(address != NULL);
+  CHECK_ADDRESS(address, INET, 0);

 
   return ntohl(address->m_host);
 }
 
 unsigned short GAddress_INET_GetPort(GAddress *address)
 {
 
   return ntohl(address->m_host);
 }
 
 unsigned short GAddress_INET_GetPort(GAddress *address)
 {

-  assert(address != NULL); 
-  CHECK_ADDRESS(address, INET, 0); 
+  assert(address != NULL);
+  CHECK_ADDRESS(address, INET, 0);

 
   return address->m_port;
 }
 
 
   return address->m_port;
 }
 

-void _GSocket_Enable_Events(GSocket *socket)
+void GSocket::Enable_Events()

 {
 {

-  if ( socket->m_takesEvents )
-       return ;
-  
-  {
-         OTResult      state ;
-         socket->m_takesEvents                 = TRUE ;
-         state = OTGetEndpointState(socket->m_endpoint);
-         
-         {
-               OTByteCount sz = 0 ;
-               OTCountDataBytes( socket->m_endpoint , &sz ) ;
-               if ( state == T_INCON || sz > 0 )
-               {
-               socket->m_detected |= GSOCK_INPUT_FLAG ;
-                       (socket->m_cbacks[GSOCK_INPUT])(socket, GSOCK_INPUT, socket->m_data[GSOCK_INPUT]);
-               }
-         }
-         {
-               if ( state == T_DATAXFER || state == T_INREL )
-               {
-               socket->m_detected |=GSOCK_OUTPUT_FLAG ;
-                       (socket->m_cbacks[GSOCK_OUTPUT])(socket, GSOCK_OUTPUT, socket->m_data[GSOCK_OUTPUT]);
-               }
-         }
-  }
+    if ( m_takesEvents )
+        return ;
+
+    {
+        OTResult  state ;
+        m_takesEvents = true ;
+        state = OTGetEndpointState(m_endpoint);
+
+        {
+            OTByteCount sz = 0 ;
+            OTCountDataBytes( m_endpoint , &sz ) ;
+            if ( state == T_INCON || sz > 0 )
+            {
+                m_detected |= GSOCK_INPUT_FLAG ;
+                (m_cbacks[GSOCK_INPUT])(this, GSOCK_INPUT, m_data[GSOCK_INPUT]);
+            }
+        }
+        {
+            if ( state == T_DATAXFER || state == T_INREL )
+            {
+                m_detected |=GSOCK_OUTPUT_FLAG ;
+                (m_cbacks[GSOCK_OUTPUT])(this, GSOCK_OUTPUT, m_data[GSOCK_OUTPUT]);
+            }
+        }
+    }

 }
 
 }
 

-void _GSocket_Disable_Events(GSocket *socket)
+void GSocket::Disable_Events()

 {
 {

-  socket->m_takesEvents                        = FALSE ;
+    m_takesEvents = false ;

 }
 
 /* _GSocket_Input_Timeout:
  *  For blocking sockets, wait until data is available or
  *  until timeout ellapses.
  */
 }
 
 /* _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()

 {
 {

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

   {
     UnsignedWide now , start ;
   {
     UnsignedWide now , start ;

-    short formerTakesEvents = socket->m_takesEvents ;
+    bool formerTakesEvents = m_takesEvents ;

     Microseconds(&start);
     now = start ;
     Microseconds(&start);
     now = start ;

-    socket->m_takesEvents = FALSE ;
-    
-    while( (now.hi * 4294967296.0 + now.lo) - (start.hi * 4294967296.0 + start.lo) < socket->m_timeout * 1000.0 )
+    m_takesEvents = false ;
+
+    while( (now.hi * 4294967296.0 + now.lo) - (start.hi * 4294967296.0 + start.lo) < m_timeout * 1000.0 )

     {
     {

-       OTResult state ;
-               OTByteCount sz = 0 ;
-                 state = OTGetEndpointState(socket->m_endpoint);
-  
-               OTCountDataBytes( socket->m_endpoint , &sz ) ;
-               if ( state == T_INCON || sz > 0 )
-               {
-               socket->m_takesEvents = formerTakesEvents ;
-                       return GSOCK_NOERROR;
-       }
-       Microseconds(&now); 
+        OTResult state ;
+        OTByteCount sz = 0 ;
+        state = OTGetEndpointState(m_endpoint);
+
+        OTCountDataBytes( m_endpoint , &sz ) ;
+        if ( state == T_INCON || sz > 0 )
+        {
+            m_takesEvents = formerTakesEvents ;
+            return GSOCK_NOERROR;
+        }
+        Microseconds(&now);

     }
     }

-    socket->m_takesEvents = formerTakesEvents ;
-    socket->m_error = GSOCK_TIMEDOUT;
+    m_takesEvents = formerTakesEvents ;
+    m_error = GSOCK_TIMEDOUT;

     return GSOCK_TIMEDOUT;
   }
   return GSOCK_NOERROR;
     return GSOCK_TIMEDOUT;
   }
   return GSOCK_NOERROR;


@@ -1499,30 +1496,30 @@ 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()

 {
 {

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

   {
     UnsignedWide now , start ;
   {
     UnsignedWide now , start ;

-    short formerTakesEvents = socket->m_takesEvents ;
+    bool formerTakesEvents = m_takesEvents ;

     Microseconds(&start);
     now = start ;
     Microseconds(&start);
     now = start ;

-    socket->m_takesEvents = FALSE ;
-    
-    while( (now.hi * 4294967296.0 + now.lo) - (start.hi * 4294967296.0 + start.lo) < socket->m_timeout * 1000.0 )
+    m_takesEvents = false ;
+
+    while( (now.hi * 4294967296.0 + now.lo) - (start.hi * 4294967296.0 + start.lo) < m_timeout * 1000.0 )

     {
     {

-       OTResult state ;
-               state = OTGetEndpointState(socket->m_endpoint);
-  
-               if ( state == T_DATAXFER || state == T_INREL )
-               {
-               socket->m_takesEvents = formerTakesEvents ;
-                       return GSOCK_NOERROR;
-       }
-       Microseconds(&now); 
+        OTResult state ;
+        state = OTGetEndpointState(m_endpoint);
+
+        if ( state == T_DATAXFER || state == T_INREL )
+        {
+            m_takesEvents = formerTakesEvents ;
+            return GSOCK_NOERROR;
+        }
+        Microseconds(&now);

     }
     }

-    socket->m_takesEvents = formerTakesEvents ;
-    socket->m_error = GSOCK_TIMEDOUT;
+    m_takesEvents = formerTakesEvents ;
+    m_error = GSOCK_TIMEDOUT;

     return GSOCK_TIMEDOUT;
   }
   return GSOCK_NOERROR;
     return GSOCK_TIMEDOUT;
   }
   return GSOCK_NOERROR;


@@ -1533,14 +1530,14 @@ GSocketError _GSocket_Output_Timeout(GSocket *socket)
  *   operation, there is still data available, the callback function will
  *   be called again.
  * GSOCK_OUTPUT:
  *   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
  *   assume that it can write since the first OUTPUT event, and no more
  *   OUTPUT events will be generated unless an error occurs.
  * GSOCK_CONNECTION:
  *   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
  *   assume that it can write since the first OUTPUT event, and no more
  *   OUTPUT events will be generated unless an error occurs.
  * GSOCK_CONNECTION:

- *   Connection succesfully established, for client sockets, or incoming
+ *   Connection successfully established, for client sockets, or incoming

  *   client connection, for server sockets. Wait for this event (also watch
  *   out for GSOCK_LOST) after you issue a nonblocking GSocket_Connect() call.
  * GSOCK_LOST:
  *   client connection, for server sockets. Wait for this event (also watch
  *   out for GSOCK_LOST) after you issue a nonblocking GSocket_Connect() call.
  * GSOCK_LOST:


@@ -1550,18 +1547,19 @@ GSocketError _GSocket_Output_Timeout(GSocket *socket)
 
 void _GSocket_Internal_Proc(unsigned long e , void* d )
 {
 
 void _GSocket_Internal_Proc(unsigned long e , void* d )
 {

-               
-  GSocket * socket = (GSocket*) d ;
-  OTEventCode ev = (OTEventCode) e ;
-  GSocketEvent event;
-  GSocketEvent event2;
-  GSocketCallback cback;
-  char *data;
-  GSocketCallback cback2;
-  char *data2;
-
-       if ( !socket )
-               return ;
+    GSocket *socket = (GSocket*) d ;
+
+    if ( !socket )
+        return ;
+
+    OTEventCode ev = (OTEventCode) e ;
+    GSocketEvent event;
+    GSocketEvent event2;
+    GSocketCallback cback;
+    char *data;
+    GSocketCallback cback2;
+    char *data2;
+

     event = GSOCK_MAX_EVENT ;
     event2 = GSOCK_MAX_EVENT ;
     cback = NULL;
     event = GSOCK_MAX_EVENT ;
     event2 = GSOCK_MAX_EVENT ;
     cback = NULL;


@@ -1573,41 +1571,41 @@ void _GSocket_Internal_Proc(unsigned long e , void* d )
      * destroyed) and for safety, check that the m_endpoint field
      * is what we expect it to be.
      */
      * destroyed) and for safety, check that the m_endpoint field
      * is what we expect it to be.
      */

-    if ((socket != NULL) && (socket->m_takesEvents))
+    if ( /* (socket != NULL) && */ (socket->m_takesEvents))

     {
     {

-       switch (ev)
-       {
-               case T_LISTEN :
-                       event = GSOCK_CONNECTION ;
-                       break ;
-               case T_CONNECT :
-                       event = GSOCK_CONNECTION ;
-                       event2 = GSOCK_OUTPUT ;
-                       {
-                                       TCall retCall;
-                                       
-                                       retCall.addr.buf        = NULL;
-                                       retCall.addr.maxlen     = 0;
-                                       retCall.opt.buf         = NULL;
-                                       retCall.opt.maxlen      = 0;
-                                       retCall.udata.buf       = NULL;
-                                       retCall.udata.maxlen= 0;
-                                       OTRcvConnect( socket->m_endpoint , &retCall ) ;
-                               }
-                       break ;
-               case T_DISCONNECT :
-                       event = GSOCK_LOST ;
-                       break ;
-               case T_GODATA :
-               case T_GOEXDATA :
-                       event = GSOCK_OUTPUT ;
-                       break ;
-               case T_DATA :
-                       event = GSOCK_INPUT ;
-                       break ;
-               case T_EXDATA :
-                       event = GSOCK_INPUT ;
-                       break ;
+        switch (ev)
+        {
+            case T_LISTEN :
+                event = GSOCK_CONNECTION ;
+                break ;
+            case T_CONNECT :
+                event = GSOCK_CONNECTION ;
+                event2 = GSOCK_OUTPUT ;
+                {
+                    TCall retCall;
+
+                    retCall.addr.buf     = NULL;
+                    retCall.addr.maxlen  = 0;
+                    retCall.opt.buf      = NULL;
+                    retCall.opt.maxlen   = 0;
+                    retCall.udata.buf    = NULL;
+                    retCall.udata.maxlen = 0;
+                    OTRcvConnect( socket->m_endpoint , &retCall ) ;
+                }
+                break ;
+            case T_DISCONNECT :
+                event = GSOCK_LOST ;
+                break ;
+            case T_GODATA :
+            case T_GOEXDATA :
+                event = GSOCK_OUTPUT ;
+                break ;
+            case T_DATA :
+                event = GSOCK_INPUT ;
+                break ;
+            case T_EXDATA :
+                event = GSOCK_INPUT ;
+                break ;

       }
       if (event != GSOCK_MAX_EVENT)
       {
       }
       if (event != GSOCK_MAX_EVENT)
       {