src/mac/carbon/gsocket.cpp

   1 /* -------------------------------------------------------------------------
   2  * Project: GSocket (Generic Socket) for WX
   3  * Name:    gsocket.cpp
   4  * Authors: Guilhem Lavaux,
   5  *          Guillermo Rodriguez Garcia <guille@iies.es> (maintainer)
   6  *          Stefan CSomor
   7  * Purpose: GSocket main mac file
   8  * CVSID:   $Id$
   9  * -------------------------------------------------------------------------
  10  */
  11
  12 /*
  13  * PLEASE don't put C++ comments here - this is a C source file.
  14  */
  15
  16 #ifndef __GSOCKET_STANDALONE__
  17 #include "wx/setup.h"
  18 #include "wx/platform.h"
  19 #endif
  20
  21 #if wxUSE_SOCKETS || defined(__GSOCKET_STANDALONE__)
  22
  23 #ifdef __DARWIN__
  24   #include <CoreServices/CoreServices.h>
  25
  26 #else
  27   #include <MacHeaders.c>
  28   #define OTUNIXERRORS 1
  29   #include <OpenTransport.h>
  30   #include <OpenTransportProviders.h>
  31   #include <OpenTptInternet.h>
  32 #endif
  33 #if TARGET_CARBON && !defined(OTAssert)
  34   #define OTAssert( str , cond ) /* does not exists in Carbon */
  35 #endif
  36
  37 #include <assert.h>
  38 #include <errno.h>
  39 #include <string.h>
  40 #include <unistd.h>
  41 #include <stdio.h>
  42 #include <stdlib.h>
  43 #include <stddef.h>
  44 #include <ctype.h>
  45 #include <utime.h>
  46
  47 /*
  48  * INADDR_BROADCAST is identical to INADDR_NONE which is not defined
  49  * on all unices. INADDR_BROADCAST should be fine to indicate an error.
  50  */
  51 #ifndef INADDR_BROADCAST
  52 #define INADDR_BROADCAST 0xFFFFFFFFUL
  53 #endif
  54 #ifndef INADDR_NONE
  55 #define INADDR_NONE INADDR_BROADCAST
  56 #endif
  57 #ifndef INADDR_ANY
  58 #define INADDR_ANY 0x0UL
  59 #endif
  60 #ifndef __GSOCKET_STANDALONE__
  61
  62 #include "wx/mac/macnotfy.h"
  63 #include "wx/mac/gsockmac.h"
  64 #include "wx/gsocket.h"
  65
  66 #else
  67
  68 #include "gsockmac.h"
  69 #include "gsocket.h"
  70
  71 #endif /* __GSOCKET_STANDALONE__ */
  72
  73 #ifndef ntohl
  74 #define ntohl(x)        (x)
  75 #define ntohs(x)        (x)
  76 #define htonl(x)        (x)
  77 #define htons(x)        (x)
  78 #endif
  79
  80 void wxCYield() ;
  81 #ifdef __WXDEBUG__
  82 #define qDebug 1
  83 #define qDebug2 1
  84 extern pascal void OTDebugStr(const char* str);
  85 #endif
  86 #ifndef __DARWIN__
  87   #include <OTDebug.h>
  88 #endif
  89 InetSvcRef gInetSvcRef = 0 ;
  90 int gOTInited = 0 ;
  91 OTNotifyUPP gOTNotifierUPP = NULL ;
  92
  93 OSStatus DoNegotiateIPReuseAddrOption(EndpointRef ep, Boolean enableReuseIPMode);
  94
  95 /* Input: ep - endpointref on which to negotiate the option
  96                         enableReuseIPMode - desired option setting - true/false
  97    Return: kOTNoError indicates that the option was successfully negotiated
  98                         OSStatus is an error if < 0, otherwise, the status field is
  99                         returned and is > 0.
 100
 101         IMPORTANT NOTE: The endpoint is assumed to be in synchronous more, otherwise
 102                         this code will not function as desired
 103 */
 104
 105
 106 OSStatus DoNegotiateIPReuseAddrOption(EndpointRef ep, Boolean enableReuseIPMode)
 107
 108 {
 109         UInt8           buf[kOTFourByteOptionSize];     // define buffer for fourByte Option size
 110         TOption*        opt;                                            // option ptr to make items easier to access
 111         TOptMgmt        req;
 112         TOptMgmt        ret;
 113         OSStatus        err;
 114
 115         if (!OTIsSynchronous(ep))
 116         {
 117                 return (-1);
 118         }
 119         opt = (TOption*)buf;                                    // set option ptr to buffer
 120         req.opt.buf     = buf;
 121         req.opt.len     = sizeof(buf);
 122         req.flags       = T_NEGOTIATE;                          // negotiate for option
 123
 124         ret.opt.buf = buf;
 125         ret.opt.maxlen = kOTFourByteOptionSize;
 126
 127         opt->level      = INET_IP;                                      // dealing with an IP Level function
 128 #ifdef __DARWIN__
 129         opt->name       = kIP_REUSEADDR;
 130 #else
 131         opt->name       = IP_REUSEADDR;
 132 #endif
 133         opt->len        = kOTFourByteOptionSize;
 134         opt->status = 0;
 135         *(UInt32*)opt->value = enableReuseIPMode;               // set the desired option level, true or false
 136
 137         err = OTOptionManagement(ep, &req, &ret);
 138
 139                 // if no error then return the option status value
 140         if (err == kOTNoError)
 141         {
 142                 if (opt->status != T_SUCCESS)
 143                         err = opt->status;
 144                 else
 145                         err = kOTNoError;
 146         }
 147
 148         return err;
 149 }
 150
 151
 152 pascal void OTInetEventHandler(void*s, OTEventCode event, OTResult, void *cookie) ;
 153 pascal void OTInetEventHandler(void*s, OTEventCode event, OTResult result, void *cookie)
 154 {
 155         int wakeUp = true ;
 156         GSocket* sock = (GSocket*) s ;
 157
 158         if ( event == kOTSyncIdleEvent )
 159         {
 160                 return ;
 161         }
 162
 163         if ( s )
 164         {
 165                 wxMacAddEvent( sock->m_mac_events , _GSocket_Internal_Proc , event , s , wakeUp ) ;
 166         }
 167
 168         return;
 169 }
 170
 171 static void SetDefaultEndpointModes(EndpointRef ep , void *data )
 172         // This routine sets the supplied endpoint into the default
 173         // mode used in this application.  The specifics are:
 174         // blocking, synchronous, and using synch idle events with
 175         // the standard YieldingNotifier.
 176 {
 177         OSStatus junk = kOTNoError ;
 178         OTAssert ("SetDefaultEndpointModes:invalid ref", ep != kOTInvalidEndpointRef ) ;
 179         junk = OTSetAsynchronous(ep);
 180         OTAssert("SetDefaultEndpointModes: Could not set asynchronous", junk == noErr);
 181 /*
 182         junk = OTSetBlocking(ep);
 183         OTAssert("SetDefaultEndpointModes: Could not set blocking", junk == noErr);
 184         junk = OTSetSynchronous(ep);
 185         OTAssert("SetDefaultEndpointModes: Could not set synchronous", junk == noErr);
 186         junk = OTSetBlocking(ep);
 187         OTAssert("SetDefaultEndpointModes: Could not set blocking", junk == noErr);
 188 */
 189         junk = OTInstallNotifier(ep, gOTNotifierUPP, data);
 190         OTAssert("SetDefaultEndpointModes: Could not install notifier", junk == noErr);
 191 /*
 192         junk = OTUseSyncIdleEvents(ep, true);
 193         OTAssert("SetDefaultEndpointModes: Could not use sync idle events", junk == noErr);
 194 */
 195 }
 196
 197 /* Global initialisers */
 198
 199 void GSocket_SetGUIFunctions(GSocketGUIFunctionsTable *table)
 200 {
 201     // do nothing, wxMac doesn't have wxBase-GUI separation yet
 202 }
 203
 204 int GSocket_Init()
 205 {
 206     return 1;
 207 }
 208
 209 bool GSocket_Verify_Inited() ;
 210 bool GSocket_Verify_Inited()
 211 {
 212     OSStatus err ;
 213 #if TARGET_CARBON
 214     // Marc Newsam: added the clientcontext variable
 215     //              however, documentation is unclear how this works
 216     OTClientContextPtr clientcontext;
 217
 218     if ( gInetSvcRef )
 219       return true ;
 220
 221     InitOpenTransportInContext(kInitOTForApplicationMask, &clientcontext);
 222     gOTInited = 1 ;
 223     gInetSvcRef = OTOpenInternetServicesInContext(kDefaultInternetServicesPath,
 224                                                 NULL, &err, clientcontext);
 225 #else
 226     if ( gInetSvcRef )
 227       return true ;
 228
 229     InitOpenTransport() ;
 230     gOTInited = 1 ;
 231     gInetSvcRef = OTOpenInternetServices(kDefaultInternetServicesPath, NULL, &err);
 232 #endif
 233     if ( gInetSvcRef == NULL ||  err != kOTNoError )
 234     {
 235         OTAssert("Could not open Inet Services", err == noErr);
 236         return false ;
 237     }
 238     gOTNotifierUPP = NewOTNotifyUPP( OTInetEventHandler ) ;
 239     return true ;
 240 }
 241
 242 void GSocket_Cleanup()
 243 {
 244     if ( gOTInited != 0 )
 245     {
 246       if ( gInetSvcRef != NULL )
 247         OTCloseProvider( gInetSvcRef );
 248     #if TARGET_CARBON
 249       CloseOpenTransportInContext( NULL ) ;
 250     #else
 251       CloseOpenTransport() ;
 252     #endif
 253         if ( gOTNotifierUPP )
 254             DisposeOTNotifyUPP( gOTNotifierUPP ) ;
 255     }
 256 }
 257
 258 /* Constructors / Destructors for GSocket */
 259
 260 GSocket::GSocket()
 261 {
 262   int i;
 263
 264   m_ok = GSocket_Verify_Inited();
 265
 266   m_endpoint                  = NULL ;
 267   for (i=0;i<GSOCK_MAX_EVENT;i++)
 268   {
 269     m_cbacks[i]         = NULL;
 270   }
 271   m_detected            = 0;
 272   m_local               = NULL;
 273   m_peer                = NULL;
 274   m_error               = GSOCK_NOERROR;
 275   m_server              = false;
 276   m_stream              = true;
 277   m_non_blocking        = false;
 278   m_timeout             = 1*1000;
 279                                 /* 10 sec * 1000 millisec */
 280   m_takesEvents                 = true ;
 281   m_mac_events                  = wxMacGetNotifierTable() ;
 282 }
 283
 284 GSocket::~GSocket()
 285 {
 286   assert(this);
 287
 288   /* Check that the socket is really shutdowned */
 289   if (m_endpoint != kOTInvalidEndpointRef)
 290     Shutdown();
 291
 292
 293   /* Destroy private addresses */
 294   if (m_local)
 295     GAddress_destroy(m_local);
 296
 297   if (m_peer)
 298     GAddress_destroy(m_peer);
 299 }
 300
 301 /* GSocket_Shutdown:
 302  *  Disallow further read/write operations on this socket, close
 303  *  the fd and disable all callbacks.
 304  */
 305 void GSocket::Shutdown()
 306 {
 307   OSStatus err ;
 308   int evt;
 309
 310   assert(this);
 311
 312   /* If socket has been created, shutdown it */
 313   if (m_endpoint != kOTInvalidEndpointRef )
 314   {
 315     err = OTSndOrderlyDisconnect( m_endpoint ) ;
 316         if ( err != kOTNoError )
 317         {
 318
 319         }
 320     err = OTRcvOrderlyDisconnect( m_endpoint ) ;
 321         err = OTUnbind( m_endpoint ) ;
 322         err = OTCloseProvider( m_endpoint ) ;
 323         m_endpoint = kOTInvalidEndpointRef ;
 324   }
 325
 326   /* Disable GUI callbacks */
 327   for (evt = 0; evt < GSOCK_MAX_EVENT; evt++)
 328     m_cbacks[evt] = NULL;
 329
 330   m_detected = 0;
 331   Disable_Events();
 332   wxMacRemoveAllNotifiersForData( wxMacGetNotifierTable() , this ) ;
 333 }
 334
 335
 336 /* Address handling */
 337
 338 /* GSocket_SetLocal:
 339  * GSocket_GetLocal:
 340  * GSocket_SetPeer:
 341  * GSocket_GetPeer:
 342  *  Set or get the local or peer address for this socket. The 'set'
 343  *  functions return GSOCK_NOERROR on success, an error code otherwise.
 344  *  The 'get' functions return a pointer to a GAddress object on success,
 345  *  or NULL otherwise, in which case they set the error code of the
 346  *  corresponding GSocket.
 347  *
 348  *  Error codes:
 349  *    GSOCK_INVSOCK - the socket is not valid.
 350  *    GSOCK_INVADDR - the address is not valid.
 351  */
 352 GSocketError GSocket::SetLocal(GAddress *address)
 353 {
 354   assert(this);
 355
 356   /* the socket must be initialized, or it must be a server */
 357   if ((m_endpoint != kOTInvalidEndpointRef && !m_server))
 358   {
 359     m_error = GSOCK_INVSOCK;
 360     return GSOCK_INVSOCK;
 361   }
 362
 363   /* check address */
 364   if (address == NULL || address->m_family == GSOCK_NOFAMILY)
 365   {
 366     m_error = GSOCK_INVADDR;
 367     return GSOCK_INVADDR;
 368   }
 369
 370   if (m_local)
 371     GAddress_destroy(m_local);
 372
 373   m_local = GAddress_copy(address);
 374
 375   return GSOCK_NOERROR;
 376 }
 377
 378 GSocketError GSocket::SetPeer(GAddress *address)
 379 {
 380   assert(this);
 381
 382   /* check address */
 383   if (address == NULL || address->m_family == GSOCK_NOFAMILY)
 384   {
 385     m_error = GSOCK_INVADDR;
 386     return GSOCK_INVADDR;
 387   }
 388
 389   if (m_peer)
 390     GAddress_destroy(m_peer);
 391
 392   m_peer = GAddress_copy(address);
 393
 394   return GSOCK_NOERROR;
 395 }
 396
 397 GAddress *GSocket::GetLocal()
 398 {
 399   GAddress *address = NULL ;
 400   GSocketError err;
 401   InetAddress loc ;
 402
 403   assert(this);
 404
 405   /* try to get it from the m_local var first */
 406   if (m_local)
 407     return GAddress_copy(m_local);
 408
 409   /* else, if the socket is initialized, try getsockname */
 410   if (m_endpoint == kOTInvalidEndpointRef)
 411   {
 412     m_error = GSOCK_INVSOCK;
 413     return NULL;
 414   }
 415
 416
 417 /* we do not support multihoming with this code at the moment
 418    OTGetProtAddress will have to be used then - but we don't have a handy
 419    method to use right now
 420 */
 421   {
 422     InetInterfaceInfo   info;
 423     OTInetGetInterfaceInfo(&info, kDefaultInetInterface);
 424     loc.fHost = info.fAddress ;
 425     loc.fPort = 0 ;
 426         loc.fAddressType = AF_INET ;
 427   }
 428
 429   /* got a valid address from getsockname, create a GAddress object */
 430   address = GAddress_new();
 431   if (address == NULL)
 432   {
 433     m_error = GSOCK_MEMERR;
 434     return NULL;
 435   }
 436
 437   err = _GAddress_translate_from(address, &loc);
 438   if (err != GSOCK_NOERROR)
 439   {
 440     GAddress_destroy(address);
 441     m_error = err;
 442     return NULL;
 443   }
 444
 445   return address;
 446 }
 447
 448 GAddress *GSocket::GetPeer()
 449 {
 450   assert(this);
 451
 452   /* try to get it from the m_peer var */
 453   if (m_peer)
 454     return GAddress_copy(m_peer);
 455
 456   return NULL;
 457 }
 458
 459 /* Server specific parts */
 460
 461 /* GSocket_SetServer:
 462  *  Sets up this socket as a server. The local address must have been
 463  *  set with GSocket_SetLocal() before GSocket_SetServer() is called.
 464  *  Returns GSOCK_NOERROR on success, one of the following otherwise:
 465  *
 466  *  Error codes:
 467  *    GSOCK_INVSOCK - the socket is in use.
 468  *    GSOCK_INVADDR - the local address has not been set.
 469  *    GSOCK_IOERR   - low-level error.
 470  */
 471 GSocketError GSocket::SetServer()
 472 {
 473   assert(this);
 474
 475   /* must not be in use */
 476   if (m_endpoint != kOTInvalidEndpointRef )
 477   {
 478     m_error = GSOCK_INVSOCK;
 479     return GSOCK_INVSOCK;
 480   }
 481
 482   /* the local addr must have been set */
 483   if (!m_local)
 484   {
 485     m_error = GSOCK_INVADDR;
 486     return GSOCK_INVADDR;
 487   }
 488
 489   /* Initialize all fields */
 490   m_stream   = true;
 491   m_server   = true;
 492   m_oriented = true;
 493
 494 // TODO
 495 #if 0
 496   /* Create the socket */
 497   m_endpoint = socket(m_local->m_realfamily, SOCK_STREAM, 0);
 498   socket_set_ref( m_endpoint , (unsigned long) &gMacNetEvents ,  (unsigned long) this ) ;
 499   if (m_endpoint == kOTInvalidEndpointRef)
 500   {
 501     m_error = GSOCK_IOERR;
 502     return GSOCK_IOERR;
 503   }
 504
 505   ioctl(m_endpoint, FIONBIO, &arg);
 506   Enable_Events();
 507
 508   /* Bind to the local address,
 509    * retrieve the actual address bound,
 510    * and listen up to 5 connections.
 511    */
 512   if ((bind(m_endpoint, m_local->m_addr, m_local->m_len) != 0) ||
 513       (getsockname(m_endpoint,
 514                    m_local->m_addr,
 515                    (SOCKLEN_T *) &m_local->m_len) != 0) ||
 516       (listen(m_endpoint, 5) != 0))
 517   {
 518     close(m_endpoint);
 519     m_endpoint = -1;
 520     m_error = GSOCK_IOERR;
 521     return GSOCK_IOERR;
 522   }
 523 #endif
 524   return GSOCK_NOERROR;
 525 }
 526
 527 /* GSocket_WaitConnection:
 528  *  Waits for an incoming client connection. Returns a pointer to
 529  *  a GSocket object, or NULL if there was an error, in which case
 530  *  the last error field will be updated for the calling GSocket.
 531  *
 532  *  Error codes (set in the calling GSocket)
 533  *    GSOCK_INVSOCK    - the socket is not valid or not a server.
 534  *    GSOCK_TIMEDOUT   - timeout, no incoming connections.
 535  *    GSOCK_WOULDBLOCK - the call would block and the socket is nonblocking.
 536  *    GSOCK_MEMERR     - couldn't allocate memory.
 537  *    GSOCK_IOERR      - low-level error.
 538  */
 539 GSocket *GSocket::WaitConnection()
 540 {
 541   GSocket *connection = NULL ;
 542
 543   assert(this);
 544
 545   /* Reenable CONNECTION events */
 546   m_detected &= ~GSOCK_CONNECTION_FLAG;
 547
 548   /* If the socket has already been created, we exit immediately */
 549   if (m_endpoint == kOTInvalidEndpointRef || !m_server)
 550   {
 551     m_error = GSOCK_INVSOCK;
 552     return NULL;
 553   }
 554
 555   /* Create a GSocket object for the new connection */
 556   connection = GSocket_new();
 557
 558   if (!connection)
 559   {
 560     m_error = GSOCK_MEMERR;
 561     return NULL;
 562   }
 563
 564   /* Wait for a connection (with timeout) */
 565   if (Input_Timeout() == GSOCK_TIMEDOUT)
 566   {
 567     delete connection;
 568     /* m_error set by _GSocket_Input_Timeout */
 569     return NULL;
 570   }
 571
 572 // TODO
 573 #if 0
 574   connection->m_endpoint = accept(m_endpoint, &from, (SOCKLEN_T *) &fromlen);
 575 #endif
 576
 577   if (connection->m_endpoint == kOTInvalidEndpointRef )
 578   {
 579     if (errno == EWOULDBLOCK)
 580       m_error = GSOCK_WOULDBLOCK;
 581     else
 582       m_error = GSOCK_IOERR;
 583
 584     delete connection;
 585     return NULL;
 586   }
 587
 588   /* Initialize all fields */
 589   connection->m_server   = false;
 590   connection->m_stream   = true;
 591   connection->m_oriented = true;
 592
 593   /* Setup the peer address field */
 594   connection->m_peer = GAddress_new();
 595   if (!connection->m_peer)
 596   {
 597     delete connection;
 598     m_error = GSOCK_MEMERR;
 599     return NULL;
 600   }
 601  // TODO
 602  #if 0
 603   err = _GAddress_translate_from(connection->m_peer, &from, fromlen);
 604   if (err != GSOCK_NOERROR)
 605   {
 606     GAddress_destroy(connection->m_peer);
 607     GSocket_destroy(connection);
 608     m_error = err;
 609     return NULL;
 610   }
 611
 612   ioctl(connection->m_endpoint, FIONBIO, &arg);
 613 #endif
 614   connection->Enable_Events();
 615
 616   return connection;
 617 }
 618
 619 /* Datagram sockets */
 620
 621 /* GSocket_SetNonOriented:
 622  *  Sets up this socket as a non-connection oriented (datagram) socket.
 623  *  Before using this function, the local address must have been set
 624  *  with GSocket_SetLocal(), or the call will fail. Returns GSOCK_NOERROR
 625  *  on success, or one of the following otherwise.
 626  *
 627  *  Error codes:
 628  *    GSOCK_INVSOCK - the socket is in use.
 629  *    GSOCK_INVADDR - the local address has not been set.
 630  *    GSOCK_IOERR   - low-level error.
 631  */
 632 GSocketError GSocket::SetNonOriented()
 633 {
 634   assert(this);
 635
 636   if (m_endpoint != kOTInvalidEndpointRef )
 637   {
 638     m_error = GSOCK_INVSOCK;
 639     return GSOCK_INVSOCK;
 640   }
 641
 642   if (!m_local)
 643   {
 644     m_error = GSOCK_INVADDR;
 645     return GSOCK_INVADDR;
 646   }
 647
 648   /* Initialize all fields */
 649   m_stream   = false;
 650   m_server   = false;
 651   m_oriented = false;
 652
 653   /* Create the socket */
 654
 655 // TODO
 656 #if 0
 657   m_endpoint = socket(m_local->m_realfamily, SOCK_DGRAM, 0);
 658   socket_set_ref( m_endpoint , (unsigned long) &gMacNetEvents ,  (unsigned long) this ) ;
 659 #endif
 660   if (m_endpoint == kOTInvalidEndpointRef )
 661   {
 662     m_error = GSOCK_IOERR;
 663     return GSOCK_IOERR;
 664   }
 665
 666 // TODO
 667 #if 0
 668   ioctl(m_endpoint, FIONBIO, &arg);
 669 #endif
 670   Enable_Events();
 671
 672   /* Bind to the local address,
 673    * and retrieve the actual address bound.
 674    */
 675 // TODO
 676 #if 0
 677   if ((bind(m_endpoint, m_local->m_addr, m_local->m_len) != 0) ||
 678       (getsockname(m_endpoint,
 679                    m_local->m_addr,
 680                    (SOCKLEN_T *) &m_local->m_len) != 0))
 681   {
 682     close(m_endpoint);
 683     m_endpoint    = -1;
 684     m_error = GSOCK_IOERR;
 685     return GSOCK_IOERR;
 686   }
 687 #endif
 688   return GSOCK_NOERROR;
 689 }
 690
 691 /* Client specific parts */
 692
 693 /* GSocket_Connect:
 694  *  For stream (connection oriented) sockets, GSocket_Connect() tries
 695  *  to establish a client connection to a server using the peer address
 696  *  as established with GSocket_SetPeer(). Returns GSOCK_NOERROR if the
 697  *  connection has been succesfully established, or one of the error
 698  *  codes listed below. Note that for nonblocking sockets, a return
 699  *  value of GSOCK_WOULDBLOCK doesn't mean a failure. The connection
 700  *  request can be completed later; you should use GSocket_Select()
 701  *  to poll for GSOCK_CONNECTION | GSOCK_LOST, or wait for the
 702  *  corresponding asynchronous events.
 703  *
 704  *  For datagram (non connection oriented) sockets, GSocket_Connect()
 705  *  just sets the peer address established with GSocket_SetPeer() as
 706  *  default destination.
 707  *
 708  *  Error codes:
 709  *    GSOCK_INVSOCK    - the socket is in use or not valid.
 710  *    GSOCK_INVADDR    - the peer address has not been established.
 711  *    GSOCK_TIMEDOUT   - timeout, the connection failed.
 712  *    GSOCK_WOULDBLOCK - connection in progress (nonblocking sockets only)
 713  *    GSOCK_MEMERR     - couldn't allocate memory.
 714  *    GSOCK_IOERR      - low-level error.
 715  */
 716 GSocketError GSocket::Connect(GSocketStream stream)
 717 {
 718   InetAddress addr ;
 719   TEndpointInfo info;
 720    OSStatus             err = kOTNoError;
 721   TCall peer ;
 722
 723   assert(this);
 724
 725   /* Enable CONNECTION events (needed for nonblocking connections) */
 726   m_detected &= ~GSOCK_CONNECTION_FLAG;
 727
 728   if (m_endpoint != kOTInvalidEndpointRef )
 729   {
 730     m_error = GSOCK_INVSOCK;
 731     return GSOCK_INVSOCK;
 732   }
 733
 734   if (!m_peer)
 735   {
 736     m_error = GSOCK_INVADDR;
 737     return GSOCK_INVADDR;
 738   }
 739
 740   /* Streamed or dgram socket? */
 741   m_stream   = (stream == GSOCK_STREAMED);
 742   m_oriented = true;
 743   m_server   = false;
 744
 745   /* Create the socket */
 746 #if TARGET_CARBON
 747   m_endpoint =
 748         OTOpenEndpointInContext( OTCreateConfiguration( kTCPName) , 0 , &info , &err , NULL ) ;
 749 #else
 750   m_endpoint =
 751         OTOpenEndpoint( OTCreateConfiguration( kTCPName) , 0 , &info , &err ) ;
 752 #endif
 753   if ( m_endpoint == kOTInvalidEndpointRef || err != kOTNoError )
 754   {
 755                 m_endpoint = kOTInvalidEndpointRef ;
 756         m_error = GSOCK_IOERR;
 757         return GSOCK_IOERR;
 758   }
 759   err = OTBind( m_endpoint , nil , nil ) ;
 760   if ( err != kOTNoError )
 761   {
 762         return GSOCK_IOERR;
 763   }
 764   SetDefaultEndpointModes( m_endpoint , this ) ;
 765 // TODO
 766 #if 0
 767   ioctl(m_endpoint, FIONBIO, &arg);
 768 #endif
 769   Enable_Events();
 770
 771   _GAddress_translate_to( m_peer , &addr ) ;
 772   memset( &peer , 0 , sizeof( TCall ) ) ;
 773   peer.addr.len = sizeof( InetAddress ) ;
 774   peer.addr.buf = (unsigned char*) &addr ;
 775   err = OTConnect( m_endpoint , &peer , nil ) ;
 776   if ( err != noErr )
 777   {
 778     /* If connect failed with EINPROGRESS and the GSocket object
 779      * is in blocking mode, we select() for the specified timeout
 780      * checking for writability to see if the connection request
 781      * completes.
 782      */
 783
 784     if ((err == kOTNoDataErr ) && (!m_non_blocking))
 785     {
 786       if (Output_Timeout() == GSOCK_TIMEDOUT)
 787       {
 788         OTSndOrderlyDisconnect( m_endpoint ) ;
 789         m_endpoint = kOTInvalidEndpointRef ;
 790         /* m_error is set in _GSocket_Output_Timeout */
 791         return GSOCK_TIMEDOUT;
 792       }
 793       else
 794       {
 795 /*
 796         int error;
 797         SOCKLEN_T len = sizeof(error);
 798
 799         getsockopt(m_endpoint, SOL_SOCKET, SO_ERROR, (void*) &error, &len);
 800
 801         if (!error)
 802 */
 803           return GSOCK_NOERROR;
 804       }
 805     }
 806
 807     /* If connect failed with EINPROGRESS and the GSocket object
 808      * is set to nonblocking, we set m_error to GSOCK_WOULDBLOCK
 809      * (and return GSOCK_WOULDBLOCK) but we don't close the socket;
 810      * this way if the connection completes, a GSOCK_CONNECTION
 811      * event will be generated, if enabled.
 812      */
 813     if ((err == kOTNoDataErr) && (m_non_blocking))
 814     {
 815       m_error = GSOCK_WOULDBLOCK;
 816       return GSOCK_WOULDBLOCK;
 817     }
 818
 819     /* If connect failed with an error other than EINPROGRESS,
 820      * then the call to GSocket_Connect has failed.
 821      */
 822     OTSndOrderlyDisconnect( m_endpoint ) ;
 823
 824     m_endpoint = kOTInvalidEndpointRef ;
 825     m_error = GSOCK_IOERR;
 826     return GSOCK_IOERR;
 827   }
 828 //  OTInetEventHandler(this, T_CONNECT , kOTNoError , NULL ) ;
 829   return GSOCK_NOERROR;
 830 }
 831
 832 /* Generic IO */
 833
 834 /* Like recv(), send(), ... */
 835 int GSocket::Read(char *buffer, int size)
 836 {
 837   int ret = 0 ;
 838
 839   assert(this);
 840
 841   /* Reenable INPUT events */
 842   m_detected &= ~GSOCK_INPUT_FLAG;
 843
 844   if (m_endpoint == kOTInvalidEndpointRef || m_server)
 845   {
 846     m_error = GSOCK_INVSOCK;
 847     return -1;
 848   }
 849
 850   /* If the socket is blocking, wait for data (with a timeout) */
 851   if (Input_Timeout() == GSOCK_TIMEDOUT)
 852     return -1;
 853
 854   /* Read the data */
 855   if (m_stream)
 856     ret = Recv_Stream(buffer, size);
 857   else
 858     ret = Recv_Dgram(buffer, size);
 859
 860   if (ret == -1)
 861   {
 862     if (errno == EWOULDBLOCK)
 863       m_error = GSOCK_WOULDBLOCK;
 864     else
 865       m_error = GSOCK_IOERR;
 866   }
 867
 868   return ret;
 869 }
 870
 871 int GSocket::Write(const char *buffer, int size)
 872 {
 873   int ret;
 874
 875   assert(this);
 876
 877   if (m_endpoint == kOTInvalidEndpointRef || m_server)
 878   {
 879     m_error = GSOCK_INVSOCK;
 880     return -1;
 881   }
 882
 883   /* If the socket is blocking, wait for writability (with a timeout) */
 884   if (Output_Timeout() == GSOCK_TIMEDOUT)
 885     return -1;
 886
 887   /* Write the data */
 888   if (m_stream)
 889     ret = Send_Stream(buffer, size);
 890   else
 891     ret = Send_Dgram(buffer, size);
 892
 893   if (ret == -1)
 894   {
 895     if (errno == EWOULDBLOCK)
 896       m_error = GSOCK_WOULDBLOCK;
 897     else
 898       m_error = GSOCK_IOERR;
 899
 900     /* Only reenable OUTPUT events after an error (just like WSAAsyncSelect
 901      * in MSW). Once the first OUTPUT event is received, users can assume
 902      * that the socket is writable until a read operation fails. Only then
 903      * will further OUTPUT events be posted.
 904      */
 905     m_detected &= ~GSOCK_OUTPUT_FLAG;
 906     return -1;
 907   }
 908
 909   return ret;
 910 }
 911
 912 /* GSocket_Select:
 913  *  Polls the socket to determine its status. This function will
 914  *  check for the events specified in the 'flags' parameter, and
 915  *  it will return a mask indicating which operations can be
 916  *  performed. This function won't block, regardless of the
 917  *  mode (blocking | nonblocking) of the socket.
 918  */
 919 GSocketEventFlags GSocket::Select(GSocketEventFlags flags)
 920 {
 921   assert(this);
 922   wxMacProcessNotifierEvents() ;
 923   /*
 924   state = OTGetEndpointState(m_endpoint);
 925
 926   if ( ( flags & GSOCK_INPUT_FLAG ) && ! ( m_detected & GSOCK_INPUT_FLAG ) )
 927   {
 928         size_t sz = 0 ;
 929         OTCountDataBytes( m_endpoint , &sz ) ;
 930         if ( state == T_INCON || sz > 0 )
 931         {
 932         m_detected |= GSOCK_INPUT_FLAG ;
 933                 (m_cbacks[GSOCK_INPUT])(this, GSOCK_INPUT, m_data[GSOCK_INPUT]);
 934         }
 935   }
 936   if ( ( flags & GSOCK_INPUT_FLAG ) && ! ( m_detected & GSOCK_OUTPUT_FLAG ) )
 937   {
 938         if ( state == T_DATAXFER || state == T_INREL )
 939         {
 940         m_detected |=GSOCK_OUTPUT_FLAG ;
 941                 (m_cbacks[GSOCK_OUTPUT])(this, GSOCK_OUTPUT, m_data[GSOCK_OUTPUT]);
 942         }
 943   }
 944   */
 945   return ( flags & m_detected ) ;
 946 }
 947
 948 /* Flags */
 949
 950 /* GSocket_SetNonBlocking:
 951  *  Sets the socket to non-blocking mode. All IO calls will return
 952  *  immediately.
 953  */
 954 void GSocket::SetNonBlocking(bool non_block)
 955 {
 956   assert(this);
 957
 958   m_non_blocking = non_block;
 959 }
 960
 961 /* GSocket_SetTimeout:
 962  *  Sets the timeout for blocking calls. Time is expressed in
 963  *  milliseconds.
 964  */
 965 void GSocket::SetTimeout(unsigned long millisec)
 966 {
 967   assert(this);
 968
 969 //  this is usually set too high and we have not yet been able to detect a closed
 970 //  stream, thus we leave the 10 sec timeout
 971 //  m_timeout = millisec;
 972 }
 973
 974 /* GSocket_GetError:
 975  *  Returns the last error occured for this socket. Note that successful
 976  *  operations do not clear this back to GSOCK_NOERROR, so use it only
 977  *  after an error.
 978  */
 979 GSocketError WXDLLIMPEXP_NET GSocket::GetError()
 980 {
 981   assert(this);
 982
 983   return m_error;
 984 }
 985
 986 /* Callbacks */
 987
 988 /* GSOCK_INPUT:
 989  *   There is data to be read in the input buffer. If, after a read
 990  *   operation, there is still data available, the callback function will
 991  *   be called again.
 992  * GSOCK_OUTPUT:
 993  *   The socket is available for writing. That is, the next write call
 994  *   won't block. This event is generated only once, when the connection is
 995  *   first established, and then only if a call failed with GSOCK_WOULDBLOCK,
 996  *   when the output buffer empties again. This means that the app should
 997  *   assume that it can write since the first OUTPUT event, and no more
 998  *   OUTPUT events will be generated unless an error occurs.
 999  * GSOCK_CONNECTION:
1000  *   Connection succesfully established, for client sockets, or incoming
1001  *   client connection, for server sockets. Wait for this event (also watch
1002  *   out for GSOCK_LOST) after you issue a nonblocking GSocket_Connect() call.
1003  * GSOCK_LOST:
1004  *   The connection is lost (or a connection request failed); this could
1005  *   be due to a failure, or due to the peer closing it gracefully.
1006  */
1007
1008 /* GSocket_SetCallback:
1009  *  Enables the callbacks specified by 'flags'. Note that 'flags'
1010  *  may be a combination of flags OR'ed toghether, so the same
1011  *  callback function can be made to accept different events.
1012  *  The callback function must have the following prototype:
1013  *
1014  *  void function(GSocket *socket, GSocketEvent event, char *cdata)
1015  */
1016 void GSocket::SetCallback(GSocketEventFlags flags,
1017                          GSocketCallback callback, char *cdata)
1018 {
1019   int count;
1020
1021   assert(this);
1022
1023   for (count = 0; count < GSOCK_MAX_EVENT; count++)
1024   {
1025     if ((flags & (1 << count)) != 0)
1026     {
1027       m_cbacks[count] = callback;
1028       m_data[count] = cdata;
1029     }
1030   }
1031 }
1032
1033 /* GSocket_UnsetCallback:
1034  *  Disables all callbacks specified by 'flags', which may be a
1035  *  combination of flags OR'ed toghether.
1036  */
1037 void GSocket::UnsetCallback(GSocketEventFlags flags)
1038 {
1039   int count;
1040
1041   assert(this);
1042
1043   for (count = 0; count < GSOCK_MAX_EVENT; count++)
1044   {
1045     if ((flags & (1 << count)) != 0)
1046     {
1047       m_cbacks[count] = NULL;
1048       m_data[count] = NULL;
1049     }
1050   }
1051 }
1052
1053
1054 #define CALL_CALLBACK(socket, event) {                                  \
1055   _GSocket_Disable(socket, event);                                      \
1056   if (socket->m_cbacks[event])                                          \
1057     socket->m_cbacks[event](socket, event, socket->m_data[event]);      \
1058 }
1059
1060 int GSocket::Recv_Stream(char *buffer, int size)
1061 {
1062         OTFlags flags ;
1063         OTResult res ;
1064         OTByteCount sz = 0 ;
1065
1066         OTCountDataBytes( m_endpoint , &sz ) ;
1067         if ( size > (int)sz )
1068           size = sz ;
1069         res = OTRcv( m_endpoint , buffer , size , &flags ) ;
1070         if ( res < 0 )
1071         {
1072                 return -1 ;
1073         }
1074
1075         // we simulate another read event if there are still bytes
1076         if ( m_takesEvents )
1077         {
1078                 OTByteCount sz = 0 ;
1079                 OTCountDataBytes( m_endpoint , &sz ) ;
1080                 if ( sz > 0 )
1081                 {
1082                 m_detected |= GSOCK_INPUT_FLAG ;
1083                         (m_cbacks[GSOCK_INPUT])(this, GSOCK_INPUT, m_data[GSOCK_INPUT]);
1084                 }
1085         }
1086         return res ;
1087 }
1088
1089 int GSocket::Recv_Dgram(char *buffer, int size)
1090 {
1091 // TODO
1092   int ret = -1;
1093 #if 0
1094   struct sockaddr from;
1095   SOCKLEN_T fromlen = sizeof(from);
1096   GSocketError err;
1097
1098   fromlen = sizeof(from);
1099
1100   ret = recvfrom(m_endpoint, buffer, size, 0, &from, (SOCKLEN_T *) &fromlen);
1101
1102   if (ret == -1)
1103     return -1;
1104
1105   /* Translate a system address into a GSocket address */
1106   if (!m_peer)
1107   {
1108     m_peer = GAddress_new();
1109     if (!m_peer)
1110     {
1111       m_error = GSOCK_MEMERR;
1112       return -1;
1113     }
1114   }
1115   err = _GAddress_translate_from(m_peer, &from, fromlen);
1116   if (err != GSOCK_NOERROR)
1117   {
1118     GAddress_destroy(m_peer);
1119     m_peer  = NULL;
1120     m_error = err;
1121     return -1;
1122   }
1123 #endif
1124   return ret;
1125 }
1126
1127 int GSocket::Send_Stream(const char *buffer, int size)
1128 {
1129         OTFlags flags = 0 ;
1130         OTResult res ;
1131
1132         res = OTSnd( m_endpoint , (void*) buffer , size , flags ) ;
1133         return res ;
1134 }
1135
1136 int GSocket::Send_Dgram(const char *buffer, int size)
1137 {
1138   int ret = -1 ;
1139 // TODO
1140 #if 0
1141   struct sockaddr *addr;
1142   int len ;
1143   GSocketError err;
1144
1145   if (!m_peer)
1146   {
1147     m_error = GSOCK_INVADDR;
1148     return -1;
1149   }
1150
1151   err = _GAddress_translate_to(m_peer, &addr, &len);
1152   if (err != GSOCK_NOERROR)
1153   {
1154     m_error = err;
1155     return -1;
1156   }
1157
1158   ret = sendto(m_endpoint, buffer, size, 0, addr, len);
1159
1160   /* Frees memory allocated from _GAddress_translate_to */
1161   free(addr);
1162 #endif
1163   return ret;
1164 }
1165
1166
1167 /*
1168  * -------------------------------------------------------------------------
1169  * GAddress
1170  * -------------------------------------------------------------------------
1171  */
1172
1173 /* CHECK_ADDRESS verifies that the current family is either GSOCK_NOFAMILY
1174  * or GSOCK_*family*, and if it is GSOCK_NOFAMILY, it initalizes address
1175  * to be a GSOCK_*family*. In other cases, it returns GSOCK_INVADDR.
1176  */
1177 #define CHECK_ADDRESS(address, family, retval)                      \
1178 {                                                                   \
1179   if (address->m_family == GSOCK_NOFAMILY)                          \
1180     if (_GAddress_Init_##family(address) != GSOCK_NOERROR)          \
1181       return address->m_error;                                      \
1182   if (address->m_family != GSOCK_##family)                          \
1183   {                                                                 \
1184     address->m_error = GSOCK_INVADDR;                               \
1185     return retval;                                                  \
1186   }                                                                 \
1187 }
1188
1189 GAddress *GAddress_new()
1190 {
1191   GAddress *address;
1192
1193   if ((address = (GAddress *) malloc(sizeof(GAddress))) == NULL)
1194     return NULL;
1195
1196   address->m_family  = GSOCK_NOFAMILY;
1197   address->m_host = INADDR_NONE ;
1198   address->m_port = 0 ;
1199
1200   return address;
1201 }
1202
1203 GAddress *GAddress_copy(GAddress *address)
1204 {
1205   GAddress *addr2;
1206
1207   assert(address != NULL);
1208
1209   if ((addr2 = (GAddress *) malloc(sizeof(GAddress))) == NULL)
1210     return NULL;
1211
1212   memcpy(addr2, address, sizeof(GAddress));
1213   return addr2;
1214 }
1215
1216 void GAddress_destroy(GAddress *address)
1217 {
1218   assert(address != NULL);
1219
1220   free(address);
1221 }
1222
1223 void GAddress_SetFamily(GAddress *address, GAddressType type)
1224 {
1225   assert(address != NULL);
1226
1227   address->m_family = type;
1228 }
1229
1230 GAddressType GAddress_GetFamily(GAddress *address)
1231 {
1232   assert(address != NULL);
1233
1234   return address->m_family;
1235 }
1236
1237 GSocketError _GAddress_translate_from(GAddress *address,
1238                                       InetAddress *addr)
1239 {
1240   switch (addr->fAddressType)
1241   {
1242     case AF_INET:
1243       address->m_family = GSOCK_INET;
1244       break;
1245 #ifdef AF_INET6
1246     case AF_INET6:
1247       address->m_family = GSOCK_INET6;
1248       break;
1249 #endif
1250     default:
1251     {
1252       address->m_error = GSOCK_INVOP;
1253       return GSOCK_INVOP;
1254     }
1255   }
1256   address->m_host = addr->fHost ;
1257   address->m_port = addr->fPort ;
1258   return GSOCK_NOERROR;
1259 }
1260
1261 GSocketError _GAddress_translate_to(GAddress *address,
1262                                     InetAddress *addr)
1263 {
1264  if ( !GSocket_Verify_Inited() )
1265     return GSOCK_IOERR ;
1266   memset(addr, 0 , sizeof(struct InetAddress));
1267   OTInitInetAddress( addr , address->m_port , address->m_host ) ;
1268   return GSOCK_NOERROR;
1269 }
1270
1271 /*
1272  * -------------------------------------------------------------------------
1273  * Internet address family
1274  * -------------------------------------------------------------------------
1275  */
1276
1277 GSocketError _GAddress_Init_INET(GAddress *address)
1278 {
1279   address->m_family = GSOCK_INET;
1280   address->m_host = kOTAnyInetAddress ;
1281
1282   return GSOCK_NOERROR;
1283 }
1284
1285 GSocketError GAddress_INET_SetHostName(GAddress *address, const char *hostname)
1286 {
1287   InetHostInfo hinfo ;
1288   OSStatus ret ;
1289
1290  if ( !GSocket_Verify_Inited() )
1291     return GSOCK_IOERR ;
1292
1293   assert(address != NULL);
1294
1295   CHECK_ADDRESS(address, INET, GSOCK_INVADDR);
1296   ret = OTInetStringToAddress( gInetSvcRef , (char*) hostname , &hinfo ) ;
1297   if ( ret != kOTNoError )
1298   {
1299         address->m_host = INADDR_NONE ;
1300     address->m_error = GSOCK_NOHOST;
1301     return GSOCK_NOHOST;
1302   }
1303   address->m_host = hinfo.addrs[0] ;
1304   return GSOCK_NOERROR;
1305 }
1306
1307 GSocketError GAddress_INET_SetAnyAddress(GAddress *address)
1308 {
1309   return GAddress_INET_SetHostAddress(address, INADDR_ANY);
1310 }
1311
1312 GSocketError GAddress_INET_SetHostAddress(GAddress *address,
1313                                           unsigned long hostaddr)
1314 {
1315   assert(address != NULL);
1316
1317   CHECK_ADDRESS(address, INET, GSOCK_INVADDR);
1318
1319   address->m_host = htonl(hostaddr) ;
1320
1321   return GSOCK_NOERROR;
1322 }
1323
1324 struct service_entry
1325 {
1326         const char * name ;
1327         unsigned short port ;
1328         const char * protocol ;
1329 } ;
1330 typedef struct service_entry service_entry ;
1331
1332 service_entry gServices[] =
1333 {
1334         { "http" , 80 , "tcp" }
1335 } ;
1336
1337 GSocketError GAddress_INET_SetPortName(GAddress *address, const char *port,
1338                                        const char *protocol)
1339 {
1340   size_t i ;
1341
1342   assert(address != NULL);
1343   CHECK_ADDRESS(address, INET, GSOCK_INVADDR);
1344
1345   if (!port)
1346   {
1347     address->m_error = GSOCK_INVPORT;
1348     return GSOCK_INVPORT;
1349   }
1350   for ( i = 0 ; i < sizeof( gServices) / sizeof( service_entry ) ; ++i )
1351   {
1352         if ( strcmp( port , gServices[i].name ) == 0 )
1353         {
1354                 if ( protocol == NULL || strcmp( protocol , gServices[i].protocol ) )
1355                 {
1356                         address->m_port = gServices[i].port ;
1357                 return GSOCK_NOERROR;
1358                 }
1359         }
1360   }
1361
1362   if (isdigit(port[0]))
1363   {
1364      address->m_port = atoi(port);
1365      return GSOCK_NOERROR;
1366   }
1367
1368   address->m_error = GSOCK_INVPORT;
1369   return GSOCK_INVPORT;
1370 }
1371
1372 GSocketError GAddress_INET_SetPort(GAddress *address, unsigned short port)
1373 {
1374   assert(address != NULL);
1375   CHECK_ADDRESS(address, INET, GSOCK_INVADDR);
1376   address->m_port = port ;
1377
1378   return GSOCK_NOERROR;
1379 }
1380
1381 GSocketError GAddress_INET_GetHostName(GAddress *address, char *hostname, size_t sbuf)
1382 {
1383   InetDomainName name ;
1384  if ( !GSocket_Verify_Inited() )
1385     return GSOCK_IOERR ;
1386
1387   assert(address != NULL);
1388   CHECK_ADDRESS(address, INET, GSOCK_INVADDR);
1389
1390   OTInetAddressToName( gInetSvcRef , address->m_host , name ) ;
1391   strncpy( hostname , name , sbuf ) ;
1392   return GSOCK_NOERROR;
1393 }
1394
1395 unsigned long GAddress_INET_GetHostAddress(GAddress *address)
1396 {
1397   assert(address != NULL);
1398   CHECK_ADDRESS(address, INET, 0);
1399
1400   return ntohl(address->m_host);
1401 }
1402
1403 unsigned short GAddress_INET_GetPort(GAddress *address)
1404 {
1405   assert(address != NULL);
1406   CHECK_ADDRESS(address, INET, 0);
1407
1408   return address->m_port;
1409 }
1410
1411 void GSocket::Enable_Events()
1412 {
1413   if ( m_takesEvents )
1414         return ;
1415
1416   {
1417           OTResult      state ;
1418           m_takesEvents                 = true ;
1419           state = OTGetEndpointState(m_endpoint);
1420
1421           {
1422                 OTByteCount sz = 0 ;
1423                 OTCountDataBytes( m_endpoint , &sz ) ;
1424                 if ( state == T_INCON || sz > 0 )
1425                 {
1426                 m_detected |= GSOCK_INPUT_FLAG ;
1427                         (m_cbacks[GSOCK_INPUT])(this, GSOCK_INPUT, m_data[GSOCK_INPUT]);
1428                 }
1429           }
1430           {
1431                 if ( state == T_DATAXFER || state == T_INREL )
1432                 {
1433                 m_detected |=GSOCK_OUTPUT_FLAG ;
1434                         (m_cbacks[GSOCK_OUTPUT])(this, GSOCK_OUTPUT, m_data[GSOCK_OUTPUT]);
1435                 }
1436           }
1437   }
1438 }
1439
1440 void GSocket::Disable_Events()
1441 {
1442   m_takesEvents                 = false ;
1443 }
1444
1445 /* _GSocket_Input_Timeout:
1446  *  For blocking sockets, wait until data is available or
1447  *  until timeout ellapses.
1448  */
1449 GSocketError GSocket::Input_Timeout()
1450 {
1451   if ( !m_non_blocking )
1452   {
1453     UnsignedWide now , start ;
1454     bool formerTakesEvents = m_takesEvents ;
1455     Microseconds(&start);
1456     now = start ;
1457     m_takesEvents = false ;
1458
1459     while( (now.hi * 4294967296.0 + now.lo) - (start.hi * 4294967296.0 + start.lo) < m_timeout * 1000.0 )
1460     {
1461         OTResult state ;
1462                 OTByteCount sz = 0 ;
1463                   state = OTGetEndpointState(m_endpoint);
1464
1465                 OTCountDataBytes( m_endpoint , &sz ) ;
1466                 if ( state == T_INCON || sz > 0 )
1467                 {
1468                 m_takesEvents = formerTakesEvents ;
1469                         return GSOCK_NOERROR;
1470         }
1471         Microseconds(&now);
1472     }
1473     m_takesEvents = formerTakesEvents ;
1474     m_error = GSOCK_TIMEDOUT;
1475     return GSOCK_TIMEDOUT;
1476   }
1477   return GSOCK_NOERROR;
1478 }
1479
1480 /* _GSocket_Output_Timeout:
1481  *  For blocking sockets, wait until data can be sent without
1482  *  blocking or until timeout ellapses.
1483  */
1484 GSocketError GSocket::Output_Timeout()
1485 {
1486   if ( !m_non_blocking )
1487   {
1488     UnsignedWide now , start ;
1489     bool formerTakesEvents = m_takesEvents ;
1490     Microseconds(&start);
1491     now = start ;
1492     m_takesEvents = false ;
1493
1494     while( (now.hi * 4294967296.0 + now.lo) - (start.hi * 4294967296.0 + start.lo) < m_timeout * 1000.0 )
1495     {
1496         OTResult state ;
1497                 state = OTGetEndpointState(m_endpoint);
1498
1499                 if ( state == T_DATAXFER || state == T_INREL )
1500                 {
1501                 m_takesEvents = formerTakesEvents ;
1502                         return GSOCK_NOERROR;
1503         }
1504         Microseconds(&now);
1505     }
1506     m_takesEvents = formerTakesEvents ;
1507     m_error = GSOCK_TIMEDOUT;
1508     return GSOCK_TIMEDOUT;
1509   }
1510   return GSOCK_NOERROR;
1511 }
1512
1513 /* GSOCK_INPUT:
1514  *   There is data to be read in the input buffer. If, after a read
1515  *   operation, there is still data available, the callback function will
1516  *   be called again.
1517  * GSOCK_OUTPUT:
1518  *   The socket is available for writing. That is, the next write call
1519  *   won't block. This event is generated only once, when the connection is
1520  *   first established, and then only if a call failed with GSOCK_WOULDBLOCK,
1521  *   when the output buffer empties again. This means that the app should
1522  *   assume that it can write since the first OUTPUT event, and no more
1523  *   OUTPUT events will be generated unless an error occurs.
1524  * GSOCK_CONNECTION:
1525  *   Connection succesfully established, for client sockets, or incoming
1526  *   client connection, for server sockets. Wait for this event (also watch
1527  *   out for GSOCK_LOST) after you issue a nonblocking GSocket_Connect() call.
1528  * GSOCK_LOST:
1529  *   The connection is lost (or a connection request failed); this could
1530  *   be due to a failure, or due to the peer closing it gracefully.
1531  */
1532
1533 void _GSocket_Internal_Proc(unsigned long e , void* d )
1534 {
1535
1536   GSocket * socket = (GSocket*) d ;
1537   OTEventCode ev = (OTEventCode) e ;
1538   GSocketEvent event;
1539   GSocketEvent event2;
1540   GSocketCallback cback;
1541   char *data;
1542   GSocketCallback cback2;
1543   char *data2;
1544
1545         if ( !socket )
1546                 return ;
1547     event = GSOCK_MAX_EVENT ;
1548     event2 = GSOCK_MAX_EVENT ;
1549     cback = NULL;
1550     data = NULL;
1551     cback2 = NULL;
1552     data2 = NULL;
1553
1554     /* Check that the socket still exists (it has not been
1555      * destroyed) and for safety, check that the m_endpoint field
1556      * is what we expect it to be.
1557      */
1558     if ((socket != NULL) && (socket->m_takesEvents))
1559     {
1560         switch (ev)
1561         {
1562                 case T_LISTEN :
1563                         event = GSOCK_CONNECTION ;
1564                         break ;
1565                 case T_CONNECT :
1566                         event = GSOCK_CONNECTION ;
1567                         event2 = GSOCK_OUTPUT ;
1568                         {
1569                                         TCall retCall;
1570
1571                                         retCall.addr.buf        = NULL;
1572                                         retCall.addr.maxlen     = 0;
1573                                         retCall.opt.buf         = NULL;
1574                                         retCall.opt.maxlen      = 0;
1575                                         retCall.udata.buf       = NULL;
1576                                         retCall.udata.maxlen= 0;
1577                                         OTRcvConnect( socket->m_endpoint , &retCall ) ;
1578                                 }
1579                         break ;
1580                 case T_DISCONNECT :
1581                         event = GSOCK_LOST ;
1582                         break ;
1583                 case T_GODATA :
1584                 case T_GOEXDATA :
1585                         event = GSOCK_OUTPUT ;
1586                         break ;
1587                 case T_DATA :
1588                         event = GSOCK_INPUT ;
1589                         break ;
1590                 case T_EXDATA :
1591                         event = GSOCK_INPUT ;
1592                         break ;
1593       }
1594       if (event != GSOCK_MAX_EVENT)
1595       {
1596         cback = socket->m_cbacks[event];
1597         data = socket->m_data[event];
1598
1599         if (event == GSOCK_LOST)
1600           socket->m_detected = GSOCK_LOST_FLAG;
1601         else
1602           socket->m_detected |= (1 << event);
1603       }
1604       if (event2 != GSOCK_MAX_EVENT)
1605       {
1606         cback2 = socket->m_cbacks[event2];
1607         data2 = socket->m_data[event2];
1608
1609         if (event2 == GSOCK_LOST)
1610           socket->m_detected = GSOCK_LOST_FLAG;
1611         else
1612           socket->m_detected |= (1 << event2);
1613       }
1614     }
1615
1616     /* OK, we can now leave the critical section because we have
1617      * already obtained the callback address (we make no further
1618      * accesses to socket->whatever). However, the app should
1619      * be prepared to handle events from a socket that has just
1620      * been closed!
1621      */
1622
1623     if (cback != NULL)
1624       (cback)(socket, event, data);
1625     if (cback2 != NULL)
1626       (cback2)(socket, event2, data2);
1627
1628 }
1629
1630 /* Hack added for Mac OS X */
1631 GSocketError GAddress_UNIX_GetPath(GAddress *addr, char *path, size_t buf)
1632 {
1633     return GSOCK_INVADDR;
1634 }
1635
1636 GSocketError GAddress_UNIX_SetPath(GAddress *addr, const char *path)
1637 {
1638     return GSOCK_INVADDR;
1639 }
1640
1641 #endif  /* wxUSE_SOCKETS || defined(__GSOCKET_STANDALONE__) */