]> git.saurik.com Git - wxWidgets.git/blame_incremental - src/mac/carbon/gsocket.cpp
Use IsOk() instead of Ok()
[wxWidgets.git] / src / mac / carbon / gsocket.cpp
... / ...
CommitLineData
1/* -------------------------------------------------------------------------
2 * Project: GSocket (Generic Socket) for WX
3 * Name: src/mac/carbon/gsocket.cpp
4 * Copyright: (c) Guilhem Lavaux
5 * Licence: wxWindows Licence
6 * Authors: Guilhem Lavaux,
7 * Guillermo Rodriguez Garcia <guille@iies.es> (maintainer)
8 * Stefan CSomor
9 * Purpose: GSocket main mac file
10 * CVSID: $Id$
11 * -------------------------------------------------------------------------
12 */
13
14/*
15 * PLEASE don't put C++ comments here - this is a C source file.
16 */
17
18#ifndef __GSOCKET_STANDALONE__
19#include "wx/platform.h"
20#endif
21
22#if wxUSE_SOCKETS || defined(__GSOCKET_STANDALONE__)
23
24#ifdef __DARWIN__
25 #include <CoreServices/CoreServices.h>
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
80void wxCYield() ;
81#ifdef __WXDEBUG__
82#define qDebug 1
83#define qDebug2 1
84extern pascal void OTDebugStr(const char* str);
85#endif
86#ifndef __DARWIN__
87 #include <OTDebug.h>
88#endif
89InetSvcRef gInetSvcRef = 0 ;
90int gOTInited = 0 ;
91OTNotifyUPP gOTNotifierUPP = NULL ;
92
93OSStatus 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
106OSStatus 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
152pascal void OTInetEventHandler(void*s, OTEventCode event, OTResult, void *cookie) ;
153pascal 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
171static 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
199void GSocket_SetGUIFunctions(GSocketGUIFunctionsTable *table)
200{
201 // do nothing, wxMac doesn't have wxBase-GUI separation yet
202}
203
204int GSocket_Init()
205{
206 return 1;
207}
208
209bool GSocket_Verify_Inited() ;
210bool 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
242void 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
260GSocket::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
284GSocket::~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 */
305void 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 */
352GSocketError 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
378GSocketError 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
397GAddress *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
448GAddress *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 */
471GSocketError 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 (WX_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 */
539GSocket *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, (WX_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 */
632GSocketError 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 (WX_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 successfully 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 */
716GSocketError 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 WX_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(), ... */
835int 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
871int 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 */
919GSocketEventFlags 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 */
954void 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 */
965void 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 which occurred 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 */
979GSocketError 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 successfully 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 */
1016void 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 */
1037void 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
1060int 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
1089int GSocket::Recv_Dgram(char *buffer, int size)
1090{
1091// TODO
1092 int ret = -1;
1093#if 0
1094 struct sockaddr from;
1095 WX_SOCKLEN_T fromlen = sizeof(from);
1096 GSocketError err;
1097
1098 fromlen = sizeof(from);
1099
1100 ret = recvfrom(m_endpoint, buffer, size, 0, &from, (WX_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
1127int 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
1136int 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/* Compatibility functions for GSocket */
1167GSocket *GSocket_new(void)
1168{
1169 GSocket *newsocket = new GSocket();
1170 if(newsocket->IsOk())
1171 return newsocket;
1172 delete newsocket;
1173 return NULL;
1174}
1175
1176
1177/*
1178 * -------------------------------------------------------------------------
1179 * GAddress
1180 * -------------------------------------------------------------------------
1181 */
1182
1183/* CHECK_ADDRESS verifies that the current family is either GSOCK_NOFAMILY
1184 * or GSOCK_*family*, and if it is GSOCK_NOFAMILY, it initalizes address
1185 * to be a GSOCK_*family*. In other cases, it returns GSOCK_INVADDR.
1186 */
1187#define CHECK_ADDRESS(address, family, retval) \
1188{ \
1189 if (address->m_family == GSOCK_NOFAMILY) \
1190 if (_GAddress_Init_##family(address) != GSOCK_NOERROR) \
1191 return address->m_error; \
1192 if (address->m_family != GSOCK_##family) \
1193 { \
1194 address->m_error = GSOCK_INVADDR; \
1195 return retval; \
1196 } \
1197}
1198
1199GAddress *GAddress_new()
1200{
1201 GAddress *address;
1202
1203 if ((address = (GAddress *) malloc(sizeof(GAddress))) == NULL)
1204 return NULL;
1205
1206 address->m_family = GSOCK_NOFAMILY;
1207 address->m_host = INADDR_NONE ;
1208 address->m_port = 0 ;
1209
1210 return address;
1211}
1212
1213GAddress *GAddress_copy(GAddress *address)
1214{
1215 GAddress *addr2;
1216
1217 assert(address != NULL);
1218
1219 if ((addr2 = (GAddress *) malloc(sizeof(GAddress))) == NULL)
1220 return NULL;
1221
1222 memcpy(addr2, address, sizeof(GAddress));
1223 return addr2;
1224}
1225
1226void GAddress_destroy(GAddress *address)
1227{
1228 assert(address != NULL);
1229
1230 free(address);
1231}
1232
1233void GAddress_SetFamily(GAddress *address, GAddressType type)
1234{
1235 assert(address != NULL);
1236
1237 address->m_family = type;
1238}
1239
1240GAddressType GAddress_GetFamily(GAddress *address)
1241{
1242 assert(address != NULL);
1243
1244 return address->m_family;
1245}
1246
1247GSocketError _GAddress_translate_from(GAddress *address,
1248 InetAddress *addr)
1249{
1250 switch (addr->fAddressType)
1251 {
1252 case AF_INET:
1253 address->m_family = GSOCK_INET;
1254 break;
1255#ifdef AF_INET6
1256 case AF_INET6:
1257 address->m_family = GSOCK_INET6;
1258 break;
1259#endif
1260 default:
1261 {
1262 address->m_error = GSOCK_INVOP;
1263 return GSOCK_INVOP;
1264 }
1265 }
1266 address->m_host = addr->fHost ;
1267 address->m_port = addr->fPort ;
1268 return GSOCK_NOERROR;
1269}
1270
1271GSocketError _GAddress_translate_to(GAddress *address,
1272 InetAddress *addr)
1273{
1274 if ( !GSocket_Verify_Inited() )
1275 return GSOCK_IOERR ;
1276 memset(addr, 0 , sizeof(struct InetAddress));
1277 OTInitInetAddress( addr , address->m_port , address->m_host ) ;
1278 return GSOCK_NOERROR;
1279}
1280
1281/*
1282 * -------------------------------------------------------------------------
1283 * Internet address family
1284 * -------------------------------------------------------------------------
1285 */
1286
1287GSocketError _GAddress_Init_INET(GAddress *address)
1288{
1289 address->m_family = GSOCK_INET;
1290 address->m_host = kOTAnyInetAddress ;
1291
1292 return GSOCK_NOERROR;
1293}
1294
1295GSocketError GAddress_INET_SetHostName(GAddress *address, const char *hostname)
1296{
1297 InetHostInfo hinfo ;
1298 OSStatus ret ;
1299
1300 if ( !GSocket_Verify_Inited() )
1301 return GSOCK_IOERR ;
1302
1303 assert(address != NULL);
1304
1305 CHECK_ADDRESS(address, INET, GSOCK_INVADDR);
1306 ret = OTInetStringToAddress( gInetSvcRef , (char*) hostname , &hinfo ) ;
1307 if ( ret != kOTNoError )
1308 {
1309 address->m_host = INADDR_NONE ;
1310 address->m_error = GSOCK_NOHOST;
1311 return GSOCK_NOHOST;
1312 }
1313 address->m_host = hinfo.addrs[0] ;
1314 return GSOCK_NOERROR;
1315}
1316
1317GSocketError GAddress_INET_SetBroadcastAddress(GAddress *address)
1318{
1319 return GAddress_INET_SetHostAddress(address, INADDR_BROADCAST);
1320}
1321
1322GSocketError GAddress_INET_SetAnyAddress(GAddress *address)
1323{
1324 return GAddress_INET_SetHostAddress(address, INADDR_ANY);
1325}
1326
1327GSocketError GAddress_INET_SetHostAddress(GAddress *address,
1328 unsigned long hostaddr)
1329{
1330 assert(address != NULL);
1331
1332 CHECK_ADDRESS(address, INET, GSOCK_INVADDR);
1333
1334 address->m_host = htonl(hostaddr) ;
1335
1336 return GSOCK_NOERROR;
1337}
1338
1339struct service_entry
1340{
1341 const char * name ;
1342 unsigned short port ;
1343 const char * protocol ;
1344} ;
1345typedef struct service_entry service_entry ;
1346
1347service_entry gServices[] =
1348{
1349 { "http" , 80 , "tcp" }
1350} ;
1351
1352GSocketError GAddress_INET_SetPortName(GAddress *address, const char *port,
1353 const char *protocol)
1354{
1355 size_t i ;
1356
1357 assert(address != NULL);
1358 CHECK_ADDRESS(address, INET, GSOCK_INVADDR);
1359
1360 if (!port)
1361 {
1362 address->m_error = GSOCK_INVPORT;
1363 return GSOCK_INVPORT;
1364 }
1365 for ( i = 0 ; i < sizeof( gServices) / sizeof( service_entry ) ; ++i )
1366 {
1367 if ( strcmp( port , gServices[i].name ) == 0 )
1368 {
1369 if ( protocol == NULL || strcmp( protocol , gServices[i].protocol ) )
1370 {
1371 address->m_port = gServices[i].port ;
1372 return GSOCK_NOERROR;
1373 }
1374 }
1375 }
1376
1377 if (isdigit(port[0]))
1378 {
1379 address->m_port = atoi(port);
1380 return GSOCK_NOERROR;
1381 }
1382
1383 address->m_error = GSOCK_INVPORT;
1384 return GSOCK_INVPORT;
1385}
1386
1387GSocketError GAddress_INET_SetPort(GAddress *address, unsigned short port)
1388{
1389 assert(address != NULL);
1390 CHECK_ADDRESS(address, INET, GSOCK_INVADDR);
1391 address->m_port = port ;
1392
1393 return GSOCK_NOERROR;
1394}
1395
1396GSocketError GAddress_INET_GetHostName(GAddress *address, char *hostname, size_t sbuf)
1397{
1398 InetDomainName name ;
1399 if ( !GSocket_Verify_Inited() )
1400 return GSOCK_IOERR ;
1401
1402 assert(address != NULL);
1403 CHECK_ADDRESS(address, INET, GSOCK_INVADDR);
1404
1405 OTInetAddressToName( gInetSvcRef , address->m_host , name ) ;
1406 strncpy( hostname , name , sbuf ) ;
1407 return GSOCK_NOERROR;
1408}
1409
1410unsigned long GAddress_INET_GetHostAddress(GAddress *address)
1411{
1412 assert(address != NULL);
1413 CHECK_ADDRESS(address, INET, 0);
1414
1415 return ntohl(address->m_host);
1416}
1417
1418unsigned short GAddress_INET_GetPort(GAddress *address)
1419{
1420 assert(address != NULL);
1421 CHECK_ADDRESS(address, INET, 0);
1422
1423 return address->m_port;
1424}
1425
1426void GSocket::Enable_Events()
1427{
1428 if ( m_takesEvents )
1429 return ;
1430
1431 {
1432 OTResult state ;
1433 m_takesEvents = true ;
1434 state = OTGetEndpointState(m_endpoint);
1435
1436 {
1437 OTByteCount sz = 0 ;
1438 OTCountDataBytes( m_endpoint , &sz ) ;
1439 if ( state == T_INCON || sz > 0 )
1440 {
1441 m_detected |= GSOCK_INPUT_FLAG ;
1442 (m_cbacks[GSOCK_INPUT])(this, GSOCK_INPUT, m_data[GSOCK_INPUT]);
1443 }
1444 }
1445 {
1446 if ( state == T_DATAXFER || state == T_INREL )
1447 {
1448 m_detected |=GSOCK_OUTPUT_FLAG ;
1449 (m_cbacks[GSOCK_OUTPUT])(this, GSOCK_OUTPUT, m_data[GSOCK_OUTPUT]);
1450 }
1451 }
1452 }
1453}
1454
1455void GSocket::Disable_Events()
1456{
1457 m_takesEvents = false ;
1458}
1459
1460/* _GSocket_Input_Timeout:
1461 * For blocking sockets, wait until data is available or
1462 * until timeout ellapses.
1463 */
1464GSocketError GSocket::Input_Timeout()
1465{
1466 if ( !m_non_blocking )
1467 {
1468 UnsignedWide now , start ;
1469 bool formerTakesEvents = m_takesEvents ;
1470 Microseconds(&start);
1471 now = start ;
1472 m_takesEvents = false ;
1473
1474 while( (now.hi * 4294967296.0 + now.lo) - (start.hi * 4294967296.0 + start.lo) < m_timeout * 1000.0 )
1475 {
1476 OTResult state ;
1477 OTByteCount sz = 0 ;
1478 state = OTGetEndpointState(m_endpoint);
1479
1480 OTCountDataBytes( m_endpoint , &sz ) ;
1481 if ( state == T_INCON || sz > 0 )
1482 {
1483 m_takesEvents = formerTakesEvents ;
1484 return GSOCK_NOERROR;
1485 }
1486 Microseconds(&now);
1487 }
1488 m_takesEvents = formerTakesEvents ;
1489 m_error = GSOCK_TIMEDOUT;
1490 return GSOCK_TIMEDOUT;
1491 }
1492 return GSOCK_NOERROR;
1493}
1494
1495/* _GSocket_Output_Timeout:
1496 * For blocking sockets, wait until data can be sent without
1497 * blocking or until timeout ellapses.
1498 */
1499GSocketError GSocket::Output_Timeout()
1500{
1501 if ( !m_non_blocking )
1502 {
1503 UnsignedWide now , start ;
1504 bool formerTakesEvents = m_takesEvents ;
1505 Microseconds(&start);
1506 now = start ;
1507 m_takesEvents = false ;
1508
1509 while( (now.hi * 4294967296.0 + now.lo) - (start.hi * 4294967296.0 + start.lo) < m_timeout * 1000.0 )
1510 {
1511 OTResult state ;
1512 state = OTGetEndpointState(m_endpoint);
1513
1514 if ( state == T_DATAXFER || state == T_INREL )
1515 {
1516 m_takesEvents = formerTakesEvents ;
1517 return GSOCK_NOERROR;
1518 }
1519 Microseconds(&now);
1520 }
1521 m_takesEvents = formerTakesEvents ;
1522 m_error = GSOCK_TIMEDOUT;
1523 return GSOCK_TIMEDOUT;
1524 }
1525 return GSOCK_NOERROR;
1526}
1527
1528/* GSOCK_INPUT:
1529 * There is data to be read in the input buffer. If, after a read
1530 * operation, there is still data available, the callback function will
1531 * be called again.
1532 * GSOCK_OUTPUT:
1533 * The socket is available for writing. That is, the next write call
1534 * won't block. This event is generated only once, when the connection is
1535 * first established, and then only if a call failed with GSOCK_WOULDBLOCK,
1536 * when the output buffer empties again. This means that the app should
1537 * assume that it can write since the first OUTPUT event, and no more
1538 * OUTPUT events will be generated unless an error occurs.
1539 * GSOCK_CONNECTION:
1540 * Connection successfully established, for client sockets, or incoming
1541 * client connection, for server sockets. Wait for this event (also watch
1542 * out for GSOCK_LOST) after you issue a nonblocking GSocket_Connect() call.
1543 * GSOCK_LOST:
1544 * The connection is lost (or a connection request failed); this could
1545 * be due to a failure, or due to the peer closing it gracefully.
1546 */
1547
1548void _GSocket_Internal_Proc(unsigned long e , void* d )
1549{
1550 GSocket *socket = (GSocket*) d ;
1551
1552 if ( !socket )
1553 return ;
1554
1555 OTEventCode ev = (OTEventCode) e ;
1556 GSocketEvent event;
1557 GSocketEvent event2;
1558 GSocketCallback cback;
1559 char *data;
1560 GSocketCallback cback2;
1561 char *data2;
1562
1563 event = GSOCK_MAX_EVENT ;
1564 event2 = GSOCK_MAX_EVENT ;
1565 cback = NULL;
1566 data = NULL;
1567 cback2 = NULL;
1568 data2 = NULL;
1569
1570 /* Check that the socket still exists (it has not been
1571 * destroyed) and for safety, check that the m_endpoint field
1572 * is what we expect it to be.
1573 */
1574 if ( /* (socket != NULL) && */ (socket->m_takesEvents))
1575 {
1576 switch (ev)
1577 {
1578 case T_LISTEN :
1579 event = GSOCK_CONNECTION ;
1580 break ;
1581 case T_CONNECT :
1582 event = GSOCK_CONNECTION ;
1583 event2 = GSOCK_OUTPUT ;
1584 {
1585 TCall retCall;
1586
1587 retCall.addr.buf = NULL;
1588 retCall.addr.maxlen = 0;
1589 retCall.opt.buf = NULL;
1590 retCall.opt.maxlen = 0;
1591 retCall.udata.buf = NULL;
1592 retCall.udata.maxlen = 0;
1593 OTRcvConnect( socket->m_endpoint , &retCall ) ;
1594 }
1595 break ;
1596 case T_DISCONNECT :
1597 event = GSOCK_LOST ;
1598 break ;
1599 case T_GODATA :
1600 case T_GOEXDATA :
1601 event = GSOCK_OUTPUT ;
1602 break ;
1603 case T_DATA :
1604 event = GSOCK_INPUT ;
1605 break ;
1606 case T_EXDATA :
1607 event = GSOCK_INPUT ;
1608 break ;
1609 }
1610 if (event != GSOCK_MAX_EVENT)
1611 {
1612 cback = socket->m_cbacks[event];
1613 data = socket->m_data[event];
1614
1615 if (event == GSOCK_LOST)
1616 socket->m_detected = GSOCK_LOST_FLAG;
1617 else
1618 socket->m_detected |= (1 << event);
1619 }
1620 if (event2 != GSOCK_MAX_EVENT)
1621 {
1622 cback2 = socket->m_cbacks[event2];
1623 data2 = socket->m_data[event2];
1624
1625 if (event2 == GSOCK_LOST)
1626 socket->m_detected = GSOCK_LOST_FLAG;
1627 else
1628 socket->m_detected |= (1 << event2);
1629 }
1630 }
1631
1632 /* OK, we can now leave the critical section because we have
1633 * already obtained the callback address (we make no further
1634 * accesses to socket->whatever). However, the app should
1635 * be prepared to handle events from a socket that has just
1636 * been closed!
1637 */
1638
1639 if (cback != NULL)
1640 (cback)(socket, event, data);
1641 if (cback2 != NULL)
1642 (cback2)(socket, event2, data2);
1643
1644}
1645
1646/* Hack added for Mac OS X */
1647GSocketError GAddress_UNIX_GetPath(GAddress *addr, char *path, size_t buf)
1648{
1649 return GSOCK_INVADDR;
1650}
1651
1652GSocketError GAddress_UNIX_SetPath(GAddress *addr, const char *path)
1653{
1654 return GSOCK_INVADDR;
1655}
1656
1657#endif /* wxUSE_SOCKETS || defined(__GSOCKET_STANDALONE__) */