src/mac/carbon/gsocket.c

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