X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/e6f2ec1408be51b6d023e805dc75d24958d62586..9d5507f7a2701395e1d5c121bd877bb9066ee6ea:/src/mac/carbon/gsocket.cpp diff --git a/src/mac/carbon/gsocket.cpp b/src/mac/carbon/gsocket.cpp index 979d7c5d33..1b14f7d3a0 100644 --- a/src/mac/carbon/gsocket.cpp +++ b/src/mac/carbon/gsocket.cpp @@ -1,11 +1,13 @@ /* ------------------------------------------------------------------------- - * Project: GSocket (Generic Socket) for WX - * Name: gsocket.cpp - * Authors: Guilhem Lavaux, - * Guillermo Rodriguez Garcia (maintainer) - * Stefan CSomor - * Purpose: GSocket main mac file - * CVSID: $Id$ + * Project: GSocket (Generic Socket) for WX + * Name: src/mac/carbon/gsocket.cpp + * Copyright: (c) Guilhem Lavaux + * Licence: wxWindows Licence + * Authors: Guilhem Lavaux, + * Guillermo Rodriguez Garcia (maintainer) + * Stefan CSomor + * Purpose: GSocket main mac file + * CVSID: $Id$ * ------------------------------------------------------------------------- */ @@ -14,30 +16,22 @@ */ #ifndef __GSOCKET_STANDALONE__ -#include "wx/setup.h" #include "wx/platform.h" #endif #if wxUSE_SOCKETS || defined(__GSOCKET_STANDALONE__) #ifdef __DARWIN__ - #include - - #ifndef FALSE - #define FALSE 0 - #endif - #ifndef TRUE - #define TRUE 1 - #endif + #include #else - #include - #define OTUNIXERRORS 1 - #include - #include - #include + #include + #define OTUNIXERRORS 1 + #include + #include + #include #endif #if TARGET_CARBON && !defined(OTAssert) - #define OTAssert( str , cond ) /* does not exists in Carbon */ + #define OTAssert( str , cond ) /* does not exists in Carbon */ #endif #include @@ -65,22 +59,22 @@ #endif #ifndef __GSOCKET_STANDALONE__ -#include "wx/mac/macnotfy.h" -#include "wx/mac/gsockmac.h" -#include "wx/gsocket.h" + #include "wx/mac/macnotfy.h" + #include "wx/mac/gsockmac.h" + #include "wx/gsocket.h" #else -#include "gsockmac.h" -#include "gsocket.h" + #include "gsockmac.h" + #include "gsocket.h" #endif /* __GSOCKET_STANDALONE__ */ #ifndef ntohl -#define ntohl(x) (x) -#define ntohs(x) (x) -#define htonl(x) (x) -#define htons(x) (x) + #define ntohl(x) (x) + #define ntohs(x) (x) + #define htonl(x) (x) + #define htons(x) (x) #endif void wxCYield() ; @@ -99,121 +93,121 @@ OTNotifyUPP gOTNotifierUPP = NULL ; OSStatus DoNegotiateIPReuseAddrOption(EndpointRef ep, Boolean enableReuseIPMode); /* Input: ep - endpointref on which to negotiate the option - enableReuseIPMode - desired option setting - true/false + enableReuseIPMode - desired option setting - true/false Return: kOTNoError indicates that the option was successfully negotiated - OSStatus is an error if < 0, otherwise, the status field is - returned and is > 0. - - IMPORTANT NOTE: The endpoint is assumed to be in synchronous more, otherwise - this code will not function as desired + OSStatus is an error if < 0, otherwise, the status field is + returned and is > 0. + + IMPORTANT NOTE: The endpoint is assumed to be in synchronous more, otherwise + this code will not function as desired */ OSStatus DoNegotiateIPReuseAddrOption(EndpointRef ep, Boolean enableReuseIPMode) { - UInt8 buf[kOTFourByteOptionSize]; // define buffer for fourByte Option size - TOption* opt; // option ptr to make items easier to access - TOptMgmt req; - TOptMgmt ret; - OSStatus err; - - if (!OTIsSynchronous(ep)) - { - return (-1); - } - opt = (TOption*)buf; // set option ptr to buffer - req.opt.buf = buf; - req.opt.len = sizeof(buf); - req.flags = T_NEGOTIATE; // negotiate for option - - ret.opt.buf = buf; - ret.opt.maxlen = kOTFourByteOptionSize; - - opt->level = INET_IP; // dealing with an IP Level function + UInt8 buf[kOTFourByteOptionSize]; // define buffer for fourByte Option size + TOption* opt; // option ptr to make items easier to access + TOptMgmt req; + TOptMgmt ret; + OSStatus err; + + if (!OTIsSynchronous(ep)) + { + return (-1); + } + opt = (TOption*)buf; // set option ptr to buffer + req.opt.buf = buf; + req.opt.len = sizeof(buf); + req.flags = T_NEGOTIATE; // negotiate for option + + ret.opt.buf = buf; + ret.opt.maxlen = kOTFourByteOptionSize; + + opt->level = INET_IP; // dealing with an IP Level function #ifdef __DARWIN__ - opt->name = kIP_REUSEADDR; + opt->name = kIP_REUSEADDR; #else - opt->name = IP_REUSEADDR; + opt->name = IP_REUSEADDR; #endif - opt->len = kOTFourByteOptionSize; - opt->status = 0; - *(UInt32*)opt->value = enableReuseIPMode; // set the desired option level, true or false - - err = OTOptionManagement(ep, &req, &ret); - - // if no error then return the option status value - if (err == kOTNoError) - { - if (opt->status != T_SUCCESS) - err = opt->status; - else - err = kOTNoError; - } - - return err; + opt->len = kOTFourByteOptionSize; + opt->status = 0; + *(UInt32*)opt->value = enableReuseIPMode; // set the desired option level, true or false + + err = OTOptionManagement(ep, &req, &ret); + + // if no error then return the option status value + if (err == kOTNoError) + { + if (opt->status != T_SUCCESS) + err = opt->status; + else + err = kOTNoError; + } + + return err; } pascal void OTInetEventHandler(void*s, OTEventCode event, OTResult, void *cookie) ; pascal void OTInetEventHandler(void*s, OTEventCode event, OTResult result, void *cookie) { - int wakeUp = true ; - GSocket* sock = (GSocket*) s ; - - if ( event == kOTSyncIdleEvent ) - { - return ; - } - - if ( s ) - { - wxMacAddEvent( sock->m_mac_events , _GSocket_Internal_Proc , event , s , wakeUp ) ; - } - - return; + int wakeUp = true ; + GSocket* sock = (GSocket*) s ; + + if ( event == kOTSyncIdleEvent ) + { + return ; + } + + if ( s ) + { + wxMacAddEvent( sock->m_mac_events , _GSocket_Internal_Proc , event , s , wakeUp ) ; + } + + return; } static void SetDefaultEndpointModes(EndpointRef ep , void *data ) - // This routine sets the supplied endpoint into the default - // mode used in this application. The specifics are: - // blocking, synchronous, and using synch idle events with - // the standard YieldingNotifier. + // This routine sets the supplied endpoint into the default + // mode used in this application. The specifics are: + // blocking, synchronous, and using synch idle events with + // the standard YieldingNotifier. { - OSStatus junk = kOTNoError ; - OTAssert ("SetDefaultEndpointModes:invalid ref", ep != kOTInvalidEndpointRef ) ; - junk = OTSetAsynchronous(ep); - OTAssert("SetDefaultEndpointModes: Could not set asynchronous", junk == noErr); + OSStatus junk = kOTNoError ; + OTAssert ("SetDefaultEndpointModes:invalid ref", ep != kOTInvalidEndpointRef ) ; + junk = OTSetAsynchronous(ep); + OTAssert("SetDefaultEndpointModes: Could not set asynchronous", junk == noErr); /* - junk = OTSetBlocking(ep); - OTAssert("SetDefaultEndpointModes: Could not set blocking", junk == noErr); - junk = OTSetSynchronous(ep); - OTAssert("SetDefaultEndpointModes: Could not set synchronous", junk == noErr); - junk = OTSetBlocking(ep); - OTAssert("SetDefaultEndpointModes: Could not set blocking", junk == noErr); + junk = OTSetBlocking(ep); + OTAssert("SetDefaultEndpointModes: Could not set blocking", junk == noErr); + junk = OTSetSynchronous(ep); + OTAssert("SetDefaultEndpointModes: Could not set synchronous", junk == noErr); + junk = OTSetBlocking(ep); + OTAssert("SetDefaultEndpointModes: Could not set blocking", junk == noErr); */ - junk = OTInstallNotifier(ep, gOTNotifierUPP, data); - OTAssert("SetDefaultEndpointModes: Could not install notifier", junk == noErr); + junk = OTInstallNotifier(ep, gOTNotifierUPP, data); + OTAssert("SetDefaultEndpointModes: Could not install notifier", junk == noErr); /* - junk = OTUseSyncIdleEvents(ep, true); - OTAssert("SetDefaultEndpointModes: Could not use sync idle events", junk == noErr); + junk = OTUseSyncIdleEvents(ep, true); + OTAssert("SetDefaultEndpointModes: Could not use sync idle events", junk == noErr); */ } /* Global initialisers */ -void GSocket_SetGUIFunctions(struct GSocketGUIFunctionsTable *table) +void GSocket_SetGUIFunctions(GSocketGUIFunctionsTable *table) { // do nothing, wxMac doesn't have wxBase-GUI separation yet } int GSocket_Init() { - return TRUE; + return 1; } -int GSocket_Verify_Inited() ; -int GSocket_Verify_Inited() +bool GSocket_Verify_Inited() ; +bool GSocket_Verify_Inited() { OSStatus err ; #if TARGET_CARBON @@ -222,35 +216,35 @@ int GSocket_Verify_Inited() OTClientContextPtr clientcontext; if ( gInetSvcRef ) - return TRUE ; + return true ; InitOpenTransportInContext(kInitOTForApplicationMask, &clientcontext); gOTInited = 1 ; gInetSvcRef = OTOpenInternetServicesInContext(kDefaultInternetServicesPath, - NULL, &err, clientcontext); -#else + NULL, &err, clientcontext); +#else if ( gInetSvcRef ) - return TRUE ; - + return true ; + InitOpenTransport() ; gOTInited = 1 ; gInetSvcRef = OTOpenInternetServices(kDefaultInternetServicesPath, NULL, &err); #endif if ( gInetSvcRef == NULL || err != kOTNoError ) { - OTAssert("Could not open Inet Services", err == noErr); - return FALSE ; + OTAssert("Could not open Inet Services", err == noErr); + return false ; } gOTNotifierUPP = NewOTNotifyUPP( OTInetEventHandler ) ; - return TRUE ; + return true ; } void GSocket_Cleanup() { if ( gOTInited != 0 ) { - if ( gInetSvcRef != NULL ) - OTCloseProvider( gInetSvcRef ); + if ( gInetSvcRef != NULL ) + OTCloseProvider( gInetSvcRef ); #if TARGET_CARBON CloseOpenTransportInContext( NULL ) ; #else @@ -263,91 +257,79 @@ void GSocket_Cleanup() /* Constructors / Destructors for GSocket */ -GSocket *GSocket_new() +GSocket::GSocket() { - int i; - GSocket *socket; - - if ( GSocket_Verify_Inited() == FALSE ) - return NULL ; - socket = (GSocket *)malloc(sizeof(GSocket)); - - if (socket == NULL) - return NULL; + m_ok = GSocket_Verify_Inited(); - socket->m_endpoint = NULL ; + m_endpoint = NULL ; for (i=0;im_cbacks[i] = NULL; + m_cbacks[i] = NULL; } - socket->m_detected = 0; - socket->m_local = NULL; - socket->m_peer = NULL; - socket->m_error = GSOCK_NOERROR; - socket->m_server = FALSE; - socket->m_stream = TRUE; - socket->m_non_blocking = FALSE; - socket->m_timeout = 1*1000; + m_detected = 0; + m_local = NULL; + m_peer = NULL; + m_error = GSOCK_NOERROR; + m_server = false; + m_stream = true; + m_non_blocking = false; + m_timeout = 1*1000; /* 10 sec * 1000 millisec */ - socket->m_takesEvents = TRUE ; - socket->m_mac_events = wxMacGetNotifierTable() ; - return socket; + m_takesEvents = true ; + m_mac_events = wxMacGetNotifierTable() ; } -void GSocket_destroy(GSocket *socket) +GSocket::~GSocket() { - assert(socket != NULL); + assert(this); - /* Check that the socket is really shutdowned */ - if (socket->m_endpoint != kOTInvalidEndpointRef) - GSocket_Shutdown(socket); + /* Check that the socket is really shutdowned */ + if (m_endpoint != kOTInvalidEndpointRef) + Shutdown(); - /* Destroy private addresses */ - if (socket->m_local) - GAddress_destroy(socket->m_local); + /* Destroy private addresses */ + if (m_local) + GAddress_destroy(m_local); - if (socket->m_peer) - GAddress_destroy(socket->m_peer); - - /* Destroy the socket itself */ - free(socket); + if (m_peer) + GAddress_destroy(m_peer); } /* GSocket_Shutdown: * Disallow further read/write operations on this socket, close * the fd and disable all callbacks. */ -void GSocket_Shutdown(GSocket *socket) +void GSocket::Shutdown() { - OSStatus err ; - int evt; + OSStatus err ; + int evt; - assert(socket != NULL); + assert(this); - /* If socket has been created, shutdown it */ - if (socket->m_endpoint != kOTInvalidEndpointRef ) - { - err = OTSndOrderlyDisconnect( socket->m_endpoint ) ; - if ( err != kOTNoError ) - { - - } - err = OTRcvOrderlyDisconnect( socket->m_endpoint ) ; - err = OTUnbind( socket->m_endpoint ) ; - err = OTCloseProvider( socket->m_endpoint ) ; - socket->m_endpoint = kOTInvalidEndpointRef ; - } + /* If socket has been created, shutdown it */ + if (m_endpoint != kOTInvalidEndpointRef ) + { + err = OTSndOrderlyDisconnect( m_endpoint ) ; + if ( err != kOTNoError ) + { + } + + err = OTRcvOrderlyDisconnect( m_endpoint ) ; + err = OTUnbind( m_endpoint ) ; + err = OTCloseProvider( m_endpoint ) ; + m_endpoint = kOTInvalidEndpointRef ; + } - /* Disable GUI callbacks */ - for (evt = 0; evt < GSOCK_MAX_EVENT; evt++) - socket->m_cbacks[evt] = NULL; + /* Disable GUI callbacks */ + for (evt = 0; evt < GSOCK_MAX_EVENT; evt++) + m_cbacks[evt] = NULL; - socket->m_detected = 0; - _GSocket_Disable_Events(socket); - wxMacRemoveAllNotifiersForData( wxMacGetNotifierTable() , socket ) ; + m_detected = 0; + Disable_Events(); + wxMacRemoveAllNotifiersForData( wxMacGetNotifierTable() , this ) ; } @@ -367,111 +349,111 @@ void GSocket_Shutdown(GSocket *socket) * GSOCK_INVSOCK - the socket is not valid. * GSOCK_INVADDR - the address is not valid. */ -GSocketError GSocket_SetLocal(GSocket *socket, GAddress *address) +GSocketError GSocket::SetLocal(GAddress *address) { - assert(socket != NULL); + assert(this); - /* the socket must be initialized, or it must be a server */ - if ((socket->m_endpoint != kOTInvalidEndpointRef && !socket->m_server)) - { - socket->m_error = GSOCK_INVSOCK; - return GSOCK_INVSOCK; - } + /* the socket must be initialized, or it must be a server */ + if ((m_endpoint != kOTInvalidEndpointRef && !m_server)) + { + m_error = GSOCK_INVSOCK; + return GSOCK_INVSOCK; + } - /* check address */ - if (address == NULL || address->m_family == GSOCK_NOFAMILY) - { - socket->m_error = GSOCK_INVADDR; - return GSOCK_INVADDR; - } + /* check address */ + if (address == NULL || address->m_family == GSOCK_NOFAMILY) + { + m_error = GSOCK_INVADDR; + return GSOCK_INVADDR; + } - if (socket->m_local) - GAddress_destroy(socket->m_local); + if (m_local) + GAddress_destroy(m_local); - socket->m_local = GAddress_copy(address); + m_local = GAddress_copy(address); - return GSOCK_NOERROR; + return GSOCK_NOERROR; } -GSocketError GSocket_SetPeer(GSocket *socket, GAddress *address) +GSocketError GSocket::SetPeer(GAddress *address) { - assert(socket != NULL); + assert(this); - /* check address */ - if (address == NULL || address->m_family == GSOCK_NOFAMILY) - { - socket->m_error = GSOCK_INVADDR; - return GSOCK_INVADDR; - } + /* check address */ + if (address == NULL || address->m_family == GSOCK_NOFAMILY) + { + m_error = GSOCK_INVADDR; + return GSOCK_INVADDR; + } - if (socket->m_peer) - GAddress_destroy(socket->m_peer); + if (m_peer) + GAddress_destroy(m_peer); - socket->m_peer = GAddress_copy(address); + m_peer = GAddress_copy(address); - return GSOCK_NOERROR; + return GSOCK_NOERROR; } -GAddress *GSocket_GetLocal(GSocket *socket) +GAddress *GSocket::GetLocal() { - GAddress *address = NULL ; - GSocketError err; - InetAddress loc ; + GAddress *address = NULL ; + GSocketError err; + InetAddress loc ; - assert(socket != NULL); + assert(this); - /* try to get it from the m_local var first */ - if (socket->m_local) - return GAddress_copy(socket->m_local); + /* try to get it from the m_local var first */ + if (m_local) + return GAddress_copy(m_local); + + /* else, if the socket is initialized, try getsockname */ + if (m_endpoint == kOTInvalidEndpointRef) + { + m_error = GSOCK_INVSOCK; + return NULL; + } - /* else, if the socket is initialized, try getsockname */ - if (socket->m_endpoint == kOTInvalidEndpointRef) - { - socket->m_error = GSOCK_INVSOCK; - return NULL; - } - /* we do not support multihoming with this code at the moment - OTGetProtAddress will have to be used then - but we don't have a handy + OTGetProtAddress will have to be used then - but we don't have a handy method to use right now */ - { - InetInterfaceInfo info; - OTInetGetInterfaceInfo(&info, kDefaultInetInterface); - loc.fHost = info.fAddress ; - loc.fPort = 0 ; - loc.fAddressType = AF_INET ; - } + { + InetInterfaceInfo info; + OTInetGetInterfaceInfo(&info, kDefaultInetInterface); + loc.fHost = info.fAddress ; + loc.fPort = 0 ; + loc.fAddressType = AF_INET ; + } - /* got a valid address from getsockname, create a GAddress object */ - address = GAddress_new(); - if (address == NULL) - { - socket->m_error = GSOCK_MEMERR; - return NULL; - } + /* got a valid address from getsockname, create a GAddress object */ + address = GAddress_new(); + if (address == NULL) + { + m_error = GSOCK_MEMERR; + return NULL; + } - err = _GAddress_translate_from(address, &loc); - if (err != GSOCK_NOERROR) - { - GAddress_destroy(address); - socket->m_error = err; - return NULL; - } + err = _GAddress_translate_from(address, &loc); + if (err != GSOCK_NOERROR) + { + GAddress_destroy(address); + m_error = err; + return NULL; + } - return address; + return address; } -GAddress *GSocket_GetPeer(GSocket *socket) +GAddress *GSocket::GetPeer() { - assert(socket != NULL); + assert(this); - /* try to get it from the m_peer var */ - if (socket->m_peer) - return GAddress_copy(socket->m_peer); + /* try to get it from the m_peer var */ + if (m_peer) + return GAddress_copy(m_peer); - return NULL; + return NULL; } /* Server specific parts */ @@ -480,62 +462,62 @@ GAddress *GSocket_GetPeer(GSocket *socket) * Sets up this socket as a server. The local address must have been * set with GSocket_SetLocal() before GSocket_SetServer() is called. * Returns GSOCK_NOERROR on success, one of the following otherwise: - * + * * Error codes: * GSOCK_INVSOCK - the socket is in use. * GSOCK_INVADDR - the local address has not been set. - * GSOCK_IOERR - low-level error. + * GSOCK_IOERR - low-level error. */ -GSocketError GSocket_SetServer(GSocket *sck) +GSocketError GSocket::SetServer() { - assert(sck != NULL); + assert(this); /* must not be in use */ - if (sck->m_endpoint != kOTInvalidEndpointRef ) + if (m_endpoint != kOTInvalidEndpointRef ) { - sck->m_error = GSOCK_INVSOCK; + m_error = GSOCK_INVSOCK; return GSOCK_INVSOCK; } /* the local addr must have been set */ - if (!sck->m_local) + if (!m_local) { - sck->m_error = GSOCK_INVADDR; + m_error = GSOCK_INVADDR; return GSOCK_INVADDR; } /* Initialize all fields */ - sck->m_stream = TRUE; - sck->m_server = TRUE; - sck->m_oriented = TRUE; + m_stream = true; + m_server = true; + m_oriented = true; // TODO #if 0 /* Create the socket */ - sck->m_endpoint = socket(sck->m_local->m_realfamily, SOCK_STREAM, 0); - socket_set_ref( sck->m_endpoint , (unsigned long) &gMacNetEvents , (unsigned long) sck ) ; - if (sck->m_endpoint == kOTInvalidEndpointRef) + m_endpoint = socket(m_local->m_realfamily, SOCK_STREAM, 0); + socket_set_ref( m_endpoint , (unsigned long) &gMacNetEvents , (unsigned long) this ) ; + if (m_endpoint == kOTInvalidEndpointRef) { - sck->m_error = GSOCK_IOERR; + m_error = GSOCK_IOERR; return GSOCK_IOERR; } - ioctl(sck->m_endpoint, FIONBIO, &arg); - _GSocket_Enable_Events(sck); + ioctl(m_endpoint, FIONBIO, &arg); + Enable_Events(); /* Bind to the local address, * retrieve the actual address bound, * and listen up to 5 connections. */ - if ((bind(sck->m_endpoint, sck->m_local->m_addr, sck->m_local->m_len) != 0) || - (getsockname(sck->m_endpoint, - sck->m_local->m_addr, - (SOCKLEN_T *) &sck->m_local->m_len) != 0) || - (listen(sck->m_endpoint, 5) != 0)) + if ((bind(m_endpoint, m_local->m_addr, m_local->m_len) != 0) || + (getsockname(m_endpoint, + m_local->m_addr, + (WX_SOCKLEN_T *) &m_local->m_len) != 0) || + (listen(m_endpoint, 5) != 0)) { - close(sck->m_endpoint); - sck->m_endpoint = -1; - sck->m_error = GSOCK_IOERR; + close(m_endpoint); + m_endpoint = -1; + m_error = GSOCK_IOERR; return GSOCK_IOERR; } #endif @@ -552,21 +534,21 @@ GSocketError GSocket_SetServer(GSocket *sck) * GSOCK_TIMEDOUT - timeout, no incoming connections. * GSOCK_WOULDBLOCK - the call would block and the socket is nonblocking. * GSOCK_MEMERR - couldn't allocate memory. - * GSOCK_IOERR - low-level error. + * GSOCK_IOERR - low-level error. */ -GSocket *GSocket_WaitConnection(GSocket *socket) +GSocket *GSocket::WaitConnection() { GSocket *connection = NULL ; - assert(socket != NULL); + assert(this); /* Reenable CONNECTION events */ - socket->m_detected &= ~GSOCK_CONNECTION_FLAG; + m_detected &= ~GSOCK_CONNECTION_FLAG; /* If the socket has already been created, we exit immediately */ - if (socket->m_endpoint == kOTInvalidEndpointRef || !socket->m_server) + if (m_endpoint == kOTInvalidEndpointRef || !m_server) { - socket->m_error = GSOCK_INVSOCK; + m_error = GSOCK_INVSOCK; return NULL; } @@ -575,45 +557,45 @@ GSocket *GSocket_WaitConnection(GSocket *socket) if (!connection) { - socket->m_error = GSOCK_MEMERR; + m_error = GSOCK_MEMERR; return NULL; } /* Wait for a connection (with timeout) */ - if (_GSocket_Input_Timeout(socket) == GSOCK_TIMEDOUT) + if (Input_Timeout() == GSOCK_TIMEDOUT) { - GSocket_destroy(connection); - /* socket->m_error set by _GSocket_Input_Timeout */ + delete connection; + /* m_error set by _GSocket_Input_Timeout */ return NULL; } // TODO #if 0 - connection->m_endpoint = accept(socket->m_endpoint, &from, (SOCKLEN_T *) &fromlen); + connection->m_endpoint = accept(m_endpoint, &from, (WX_SOCKLEN_T *) &fromlen); #endif if (connection->m_endpoint == kOTInvalidEndpointRef ) { if (errno == EWOULDBLOCK) - socket->m_error = GSOCK_WOULDBLOCK; + m_error = GSOCK_WOULDBLOCK; else - socket->m_error = GSOCK_IOERR; + m_error = GSOCK_IOERR; - GSocket_destroy(connection); + delete connection; return NULL; } /* Initialize all fields */ - connection->m_server = FALSE; - connection->m_stream = TRUE; - connection->m_oriented = TRUE; + connection->m_server = false; + connection->m_stream = true; + connection->m_oriented = true; /* Setup the peer address field */ connection->m_peer = GAddress_new(); if (!connection->m_peer) { - GSocket_destroy(connection); - socket->m_error = GSOCK_MEMERR; + delete connection; + m_error = GSOCK_MEMERR; return NULL; } // TODO @@ -623,13 +605,13 @@ GSocket *GSocket_WaitConnection(GSocket *socket) { GAddress_destroy(connection->m_peer); GSocket_destroy(connection); - socket->m_error = err; + m_error = err; return NULL; } ioctl(connection->m_endpoint, FIONBIO, &arg); #endif - _GSocket_Enable_Events(connection); + connection->Enable_Events(); return connection; } @@ -647,59 +629,59 @@ GSocket *GSocket_WaitConnection(GSocket *socket) * GSOCK_INVADDR - the local address has not been set. * GSOCK_IOERR - low-level error. */ -GSocketError GSocket_SetNonOriented(GSocket *sck) +GSocketError GSocket::SetNonOriented() { - assert(sck != NULL); + assert(this); - if (sck->m_endpoint != kOTInvalidEndpointRef ) + if (m_endpoint != kOTInvalidEndpointRef ) { - sck->m_error = GSOCK_INVSOCK; + m_error = GSOCK_INVSOCK; return GSOCK_INVSOCK; } - if (!sck->m_local) + if (!m_local) { - sck->m_error = GSOCK_INVADDR; + m_error = GSOCK_INVADDR; return GSOCK_INVADDR; } /* Initialize all fields */ - sck->m_stream = FALSE; - sck->m_server = FALSE; - sck->m_oriented = FALSE; + m_stream = false; + m_server = false; + m_oriented = false; /* Create the socket */ - + // TODO #if 0 - sck->m_endpoint = socket(sck->m_local->m_realfamily, SOCK_DGRAM, 0); - socket_set_ref( sck->m_endpoint , (unsigned long) &gMacNetEvents , (unsigned long) sck ) ; + m_endpoint = socket(m_local->m_realfamily, SOCK_DGRAM, 0); + socket_set_ref( m_endpoint , (unsigned long) &gMacNetEvents , (unsigned long) this ) ; #endif - if (sck->m_endpoint == kOTInvalidEndpointRef ) + if (m_endpoint == kOTInvalidEndpointRef ) { - sck->m_error = GSOCK_IOERR; + m_error = GSOCK_IOERR; return GSOCK_IOERR; } // TODO #if 0 - ioctl(sck->m_endpoint, FIONBIO, &arg); + ioctl(m_endpoint, FIONBIO, &arg); #endif - _GSocket_Enable_Events(sck); + Enable_Events(); /* Bind to the local address, * and retrieve the actual address bound. */ // TODO #if 0 - if ((bind(sck->m_endpoint, sck->m_local->m_addr, sck->m_local->m_len) != 0) || - (getsockname(sck->m_endpoint, - sck->m_local->m_addr, - (SOCKLEN_T *) &sck->m_local->m_len) != 0)) + if ((bind(m_endpoint, m_local->m_addr, m_local->m_len) != 0) || + (getsockname(m_endpoint, + m_local->m_addr, + (WX_SOCKLEN_T *) &m_local->m_len) != 0)) { - close(sck->m_endpoint); - sck->m_endpoint = -1; - sck->m_error = GSOCK_IOERR; + close(m_endpoint); + m_endpoint = -1; + m_error = GSOCK_IOERR; return GSOCK_IOERR; } #endif @@ -712,7 +694,7 @@ GSocketError GSocket_SetNonOriented(GSocket *sck) * For stream (connection oriented) sockets, GSocket_Connect() tries * to establish a client connection to a server using the peer address * as established with GSocket_SetPeer(). Returns GSOCK_NOERROR if the - * connection has been succesfully established, or one of the error + * connection has been successfully established, or one of the error * codes listed below. Note that for nonblocking sockets, a return * value of GSOCK_WOULDBLOCK doesn't mean a failure. The connection * request can be completed later; you should use GSocket_Select() @@ -729,92 +711,92 @@ GSocketError GSocket_SetNonOriented(GSocket *sck) * GSOCK_TIMEDOUT - timeout, the connection failed. * GSOCK_WOULDBLOCK - connection in progress (nonblocking sockets only) * GSOCK_MEMERR - couldn't allocate memory. - * GSOCK_IOERR - low-level error. + * GSOCK_IOERR - low-level error. */ -GSocketError GSocket_Connect(GSocket *sck, GSocketStream stream) +GSocketError GSocket::Connect(GSocketStream stream) { InetAddress addr ; - TEndpointInfo info; - OSStatus err = kOTNoError; + TEndpointInfo info; + OSStatus err = kOTNoError; TCall peer ; - assert(sck != NULL); + assert(this); /* Enable CONNECTION events (needed for nonblocking connections) */ - sck->m_detected &= ~GSOCK_CONNECTION_FLAG; + m_detected &= ~GSOCK_CONNECTION_FLAG; - if (sck->m_endpoint != kOTInvalidEndpointRef ) + if (m_endpoint != kOTInvalidEndpointRef ) { - sck->m_error = GSOCK_INVSOCK; + m_error = GSOCK_INVSOCK; return GSOCK_INVSOCK; } - if (!sck->m_peer) + if (!m_peer) { - sck->m_error = GSOCK_INVADDR; + m_error = GSOCK_INVADDR; return GSOCK_INVADDR; } /* Streamed or dgram socket? */ - sck->m_stream = (stream == GSOCK_STREAMED); - sck->m_oriented = TRUE; - sck->m_server = FALSE; + m_stream = (stream == GSOCK_STREAMED); + m_oriented = true; + m_server = false; /* Create the socket */ #if TARGET_CARBON - sck->m_endpoint = - OTOpenEndpointInContext( OTCreateConfiguration( kTCPName) , 0 , &info , &err , NULL ) ; + m_endpoint = + OTOpenEndpointInContext( OTCreateConfiguration( kTCPName) , 0 , &info , &err , NULL ) ; #else - sck->m_endpoint = - OTOpenEndpoint( OTCreateConfiguration( kTCPName) , 0 , &info , &err ) ; + m_endpoint = + OTOpenEndpoint( OTCreateConfiguration( kTCPName) , 0 , &info , &err ) ; #endif - if ( sck->m_endpoint == kOTInvalidEndpointRef || err != kOTNoError ) + if ( m_endpoint == kOTInvalidEndpointRef || err != kOTNoError ) { - sck->m_endpoint = kOTInvalidEndpointRef ; - sck->m_error = GSOCK_IOERR; - return GSOCK_IOERR; + m_endpoint = kOTInvalidEndpointRef ; + m_error = GSOCK_IOERR; + return GSOCK_IOERR; } - err = OTBind( sck->m_endpoint , nil , nil ) ; + err = OTBind( m_endpoint , nil , nil ) ; if ( err != kOTNoError ) { - return GSOCK_IOERR; + return GSOCK_IOERR; } - SetDefaultEndpointModes( sck->m_endpoint , sck ) ; + SetDefaultEndpointModes( m_endpoint , this ) ; // TODO #if 0 - ioctl(sck->m_endpoint, FIONBIO, &arg); + ioctl(m_endpoint, FIONBIO, &arg); #endif - _GSocket_Enable_Events(sck); + Enable_Events(); - _GAddress_translate_to( sck->m_peer , &addr ) ; + _GAddress_translate_to( m_peer , &addr ) ; memset( &peer , 0 , sizeof( TCall ) ) ; peer.addr.len = sizeof( InetAddress ) ; peer.addr.buf = (unsigned char*) &addr ; - err = OTConnect( sck->m_endpoint , &peer , nil ) ; + err = OTConnect( m_endpoint , &peer , nil ) ; if ( err != noErr ) { /* If connect failed with EINPROGRESS and the GSocket object * is in blocking mode, we select() for the specified timeout * checking for writability to see if the connection request * completes. - */ - - if ((err == kOTNoDataErr ) && (!sck->m_non_blocking)) + */ + + if ((err == kOTNoDataErr ) && (!m_non_blocking)) { - if (_GSocket_Output_Timeout(sck) == GSOCK_TIMEDOUT) + if (Output_Timeout() == GSOCK_TIMEDOUT) { - OTSndOrderlyDisconnect( sck->m_endpoint ) ; - sck->m_endpoint = kOTInvalidEndpointRef ; - /* sck->m_error is set in _GSocket_Output_Timeout */ + OTSndOrderlyDisconnect( m_endpoint ) ; + m_endpoint = kOTInvalidEndpointRef ; + /* m_error is set in _GSocket_Output_Timeout */ return GSOCK_TIMEDOUT; } else { /* int error; - SOCKLEN_T len = sizeof(error); + WX_SOCKLEN_T len = sizeof(error); - getsockopt(sck->m_endpoint, SOL_SOCKET, SO_ERROR, (void*) &error, &len); + getsockopt(m_endpoint, SOL_SOCKET, SO_ERROR, (void*) &error, &len); if (!error) */ @@ -828,102 +810,102 @@ GSocketError GSocket_Connect(GSocket *sck, GSocketStream stream) * this way if the connection completes, a GSOCK_CONNECTION * event will be generated, if enabled. */ - if ((err == kOTNoDataErr) && (sck->m_non_blocking)) + if ((err == kOTNoDataErr) && (m_non_blocking)) { - sck->m_error = GSOCK_WOULDBLOCK; + m_error = GSOCK_WOULDBLOCK; return GSOCK_WOULDBLOCK; } /* If connect failed with an error other than EINPROGRESS, * then the call to GSocket_Connect has failed. */ - OTSndOrderlyDisconnect( sck->m_endpoint ) ; + OTSndOrderlyDisconnect( m_endpoint ) ; - sck->m_endpoint = kOTInvalidEndpointRef ; - sck->m_error = GSOCK_IOERR; + m_endpoint = kOTInvalidEndpointRef ; + m_error = GSOCK_IOERR; return GSOCK_IOERR; } -// OTInetEventHandler(sck, T_CONNECT , kOTNoError , NULL ) ; +// OTInetEventHandler(this, T_CONNECT , kOTNoError , NULL ) ; return GSOCK_NOERROR; } /* Generic IO */ /* Like recv(), send(), ... */ -int GSocket_Read(GSocket *socket, char *buffer, int size) +int GSocket::Read(char *buffer, int size) { int ret = 0 ; - assert(socket != NULL); + assert(this); /* Reenable INPUT events */ - socket->m_detected &= ~GSOCK_INPUT_FLAG; + m_detected &= ~GSOCK_INPUT_FLAG; - if (socket->m_endpoint == kOTInvalidEndpointRef || socket->m_server) + if (m_endpoint == kOTInvalidEndpointRef || m_server) { - socket->m_error = GSOCK_INVSOCK; + m_error = GSOCK_INVSOCK; return -1; } /* If the socket is blocking, wait for data (with a timeout) */ - if (_GSocket_Input_Timeout(socket) == GSOCK_TIMEDOUT) + if (Input_Timeout() == GSOCK_TIMEDOUT) return -1; /* Read the data */ - if (socket->m_stream) - ret = _GSocket_Recv_Stream(socket, buffer, size); + if (m_stream) + ret = Recv_Stream(buffer, size); else - ret = _GSocket_Recv_Dgram(socket, buffer, size); - + ret = Recv_Dgram(buffer, size); + if (ret == -1) { if (errno == EWOULDBLOCK) - socket->m_error = GSOCK_WOULDBLOCK; + m_error = GSOCK_WOULDBLOCK; else - socket->m_error = GSOCK_IOERR; + m_error = GSOCK_IOERR; } - + return ret; } -int GSocket_Write(GSocket *socket, const char *buffer, int size) -{ +int GSocket::Write(const char *buffer, int size) +{ int ret; - assert(socket != NULL); + assert(this); - if (socket->m_endpoint == kOTInvalidEndpointRef || socket->m_server) + if (m_endpoint == kOTInvalidEndpointRef || m_server) { - socket->m_error = GSOCK_INVSOCK; + m_error = GSOCK_INVSOCK; return -1; } /* If the socket is blocking, wait for writability (with a timeout) */ - if (_GSocket_Output_Timeout(socket) == GSOCK_TIMEDOUT) + if (Output_Timeout() == GSOCK_TIMEDOUT) return -1; /* Write the data */ - if (socket->m_stream) - ret = _GSocket_Send_Stream(socket, buffer, size); + if (m_stream) + ret = Send_Stream(buffer, size); else - ret = _GSocket_Send_Dgram(socket, buffer, size); - + ret = Send_Dgram(buffer, size); + if (ret == -1) { if (errno == EWOULDBLOCK) - socket->m_error = GSOCK_WOULDBLOCK; + m_error = GSOCK_WOULDBLOCK; else - socket->m_error = GSOCK_IOERR; + m_error = GSOCK_IOERR; /* Only reenable OUTPUT events after an error (just like WSAAsyncSelect * in MSW). Once the first OUTPUT event is received, users can assume * that the socket is writable until a read operation fails. Only then * will further OUTPUT events be posted. */ - socket->m_detected &= ~GSOCK_OUTPUT_FLAG; + m_detected &= ~GSOCK_OUTPUT_FLAG; return -1; } - + return ret; } @@ -934,33 +916,33 @@ int GSocket_Write(GSocket *socket, const char *buffer, int size) * performed. This function won't block, regardless of the * mode (blocking | nonblocking) of the socket. */ -GSocketEventFlags GSocket_Select(GSocket *socket, GSocketEventFlags flags) +GSocketEventFlags GSocket::Select(GSocketEventFlags flags) { - assert(socket != NULL); + assert(this); wxMacProcessNotifierEvents() ; /* - state = OTGetEndpointState(socket->m_endpoint); - - if ( ( flags & GSOCK_INPUT_FLAG ) && ! ( socket->m_detected & GSOCK_INPUT_FLAG ) ) + state = OTGetEndpointState(m_endpoint); + + if ( ( flags & GSOCK_INPUT_FLAG ) && ! ( m_detected & GSOCK_INPUT_FLAG ) ) { - size_t sz = 0 ; - OTCountDataBytes( socket->m_endpoint , &sz ) ; - if ( state == T_INCON || sz > 0 ) - { - socket->m_detected |= GSOCK_INPUT_FLAG ; - (socket->m_cbacks[GSOCK_INPUT])(socket, GSOCK_INPUT, socket->m_data[GSOCK_INPUT]); - } + size_t sz = 0 ; + OTCountDataBytes( m_endpoint , &sz ) ; + if ( state == T_INCON || sz > 0 ) + { + m_detected |= GSOCK_INPUT_FLAG ; + (m_cbacks[GSOCK_INPUT])(this, GSOCK_INPUT, m_data[GSOCK_INPUT]); + } } - if ( ( flags & GSOCK_INPUT_FLAG ) && ! ( socket->m_detected & GSOCK_OUTPUT_FLAG ) ) + if ( ( flags & GSOCK_INPUT_FLAG ) && ! ( m_detected & GSOCK_OUTPUT_FLAG ) ) { - if ( state == T_DATAXFER || state == T_INREL ) - { - socket->m_detected |=GSOCK_OUTPUT_FLAG ; - (socket->m_cbacks[GSOCK_OUTPUT])(socket, GSOCK_OUTPUT, socket->m_data[GSOCK_OUTPUT]); - } + if ( state == T_DATAXFER || state == T_INREL ) + { + m_detected |=GSOCK_OUTPUT_FLAG ; + (m_cbacks[GSOCK_OUTPUT])(this, GSOCK_OUTPUT, m_data[GSOCK_OUTPUT]); + } } */ - return ( flags & socket->m_detected ) ; + return ( flags & m_detected ) ; } /* Flags */ @@ -969,36 +951,36 @@ GSocketEventFlags GSocket_Select(GSocket *socket, GSocketEventFlags flags) * Sets the socket to non-blocking mode. All IO calls will return * immediately. */ -void GSocket_SetNonBlocking(GSocket *socket, int non_block) +void GSocket::SetNonBlocking(bool non_block) { - assert(socket != NULL); + assert(this); - socket->m_non_blocking = non_block; + m_non_blocking = non_block; } /* GSocket_SetTimeout: * Sets the timeout for blocking calls. Time is expressed in * milliseconds. */ -void GSocket_SetTimeout(GSocket *socket, unsigned long millisec) +void GSocket::SetTimeout(unsigned long millisec) { - assert(socket != NULL); + assert(this); // this is usually set too high and we have not yet been able to detect a closed // stream, thus we leave the 10 sec timeout -// socket->m_timeout = millisec; +// m_timeout = millisec; } /* GSocket_GetError: - * Returns the last error occured for this socket. Note that successful + * Returns the last error which occurred for this socket. Note that successful * operations do not clear this back to GSOCK_NOERROR, so use it only * after an error. */ -GSocketError GSocket_GetError(GSocket *socket) +GSocketError WXDLLIMPEXP_NET GSocket::GetError() { - assert(socket != NULL); + assert(this); - return socket->m_error; + return m_error; } /* Callbacks */ @@ -1008,14 +990,14 @@ GSocketError GSocket_GetError(GSocket *socket) * operation, there is still data available, the callback function will * be called again. * GSOCK_OUTPUT: - * The socket is available for writing. That is, the next write call + * The socket is available for writing. That is, the next write call * won't block. This event is generated only once, when the connection is * first established, and then only if a call failed with GSOCK_WOULDBLOCK, * when the output buffer empties again. This means that the app should * assume that it can write since the first OUTPUT event, and no more * OUTPUT events will be generated unless an error occurs. * GSOCK_CONNECTION: - * Connection succesfully established, for client sockets, or incoming + * Connection successfully established, for client sockets, or incoming * client connection, for server sockets. Wait for this event (also watch * out for GSOCK_LOST) after you issue a nonblocking GSocket_Connect() call. * GSOCK_LOST: @@ -1031,19 +1013,19 @@ GSocketError GSocket_GetError(GSocket *socket) * * void function(GSocket *socket, GSocketEvent event, char *cdata) */ -void GSocket_SetCallback(GSocket *socket, GSocketEventFlags flags, +void GSocket::SetCallback(GSocketEventFlags flags, GSocketCallback callback, char *cdata) { int count; - assert(socket != NULL); + assert(this); for (count = 0; count < GSOCK_MAX_EVENT; count++) { if ((flags & (1 << count)) != 0) { - socket->m_cbacks[count] = callback; - socket->m_data[count] = cdata; + m_cbacks[count] = callback; + m_data[count] = cdata; } } } @@ -1052,18 +1034,18 @@ void GSocket_SetCallback(GSocket *socket, GSocketEventFlags flags, * Disables all callbacks specified by 'flags', which may be a * combination of flags OR'ed toghether. */ -void GSocket_UnsetCallback(GSocket *socket, GSocketEventFlags flags) +void GSocket::UnsetCallback(GSocketEventFlags flags) { int count; - assert(socket != NULL); + assert(this); for (count = 0; count < GSOCK_MAX_EVENT; count++) { if ((flags & (1 << count)) != 0) { - socket->m_cbacks[count] = NULL; - socket->m_data[count] = NULL; + m_cbacks[count] = NULL; + m_data[count] = NULL; } } } @@ -1075,83 +1057,83 @@ void GSocket_UnsetCallback(GSocket *socket, GSocketEventFlags flags) socket->m_cbacks[event](socket, event, socket->m_data[event]); \ } -int _GSocket_Recv_Stream(GSocket *socket, char *buffer, int size) +int GSocket::Recv_Stream(char *buffer, int size) { - OTFlags flags ; - OTResult res ; - OTByteCount sz = 0 ; - - OTCountDataBytes( socket->m_endpoint , &sz ) ; - if ( size > (int)sz ) - size = sz ; - res = OTRcv( socket->m_endpoint , buffer , size , &flags ) ; - if ( res < 0 ) - { - return -1 ; - } - - // we simulate another read event if there are still bytes - if ( socket->m_takesEvents ) - { - OTByteCount sz = 0 ; - OTCountDataBytes( socket->m_endpoint , &sz ) ; - if ( sz > 0 ) - { - socket->m_detected |= GSOCK_INPUT_FLAG ; - (socket->m_cbacks[GSOCK_INPUT])(socket, GSOCK_INPUT, socket->m_data[GSOCK_INPUT]); - } - } - return res ; + OTFlags flags ; + OTResult res ; + OTByteCount sz = 0 ; + + OTCountDataBytes( m_endpoint , &sz ) ; + if ( size > (int)sz ) + size = sz ; + res = OTRcv( m_endpoint , buffer , size , &flags ) ; + if ( res < 0 ) + { + return -1 ; + } + + // we simulate another read event if there are still bytes + if ( m_takesEvents ) + { + OTByteCount sz = 0 ; + OTCountDataBytes( m_endpoint , &sz ) ; + if ( sz > 0 ) + { + m_detected |= GSOCK_INPUT_FLAG ; + (m_cbacks[GSOCK_INPUT])(this, GSOCK_INPUT, m_data[GSOCK_INPUT]); + } + } + return res ; } -int _GSocket_Recv_Dgram(GSocket *socket, char *buffer, int size) +int GSocket::Recv_Dgram(char *buffer, int size) { // TODO int ret = -1; #if 0 struct sockaddr from; - SOCKLEN_T fromlen = sizeof(from); + WX_SOCKLEN_T fromlen = sizeof(from); GSocketError err; fromlen = sizeof(from); - ret = recvfrom(socket->m_endpoint, buffer, size, 0, &from, (SOCKLEN_T *) &fromlen); + ret = recvfrom(m_endpoint, buffer, size, 0, &from, (WX_SOCKLEN_T *) &fromlen); if (ret == -1) return -1; /* Translate a system address into a GSocket address */ - if (!socket->m_peer) + if (!m_peer) { - socket->m_peer = GAddress_new(); - if (!socket->m_peer) + m_peer = GAddress_new(); + if (!m_peer) { - socket->m_error = GSOCK_MEMERR; + m_error = GSOCK_MEMERR; return -1; } } - err = _GAddress_translate_from(socket->m_peer, &from, fromlen); + err = _GAddress_translate_from(m_peer, &from, fromlen); if (err != GSOCK_NOERROR) { - GAddress_destroy(socket->m_peer); - socket->m_peer = NULL; - socket->m_error = err; + GAddress_destroy(m_peer); + m_peer = NULL; + m_error = err; return -1; } #endif return ret; } -int _GSocket_Send_Stream(GSocket *socket, const char *buffer, int size) +int GSocket::Send_Stream(const char *buffer, int size) { - OTFlags flags = 0 ; - OTResult res ; + OTFlags flags = 0 ; + OTResult res ; - res = OTSnd( socket->m_endpoint , (void*) buffer , size , flags ) ; - return res ; + res = OTSnd( m_endpoint , (void*) buffer , size , flags ) ; + return res ; } -int _GSocket_Send_Dgram(GSocket *socket, const char *buffer, int size) +int GSocket::Send_Dgram(const char *buffer, int size) { int ret = -1 ; // TODO @@ -1160,20 +1142,20 @@ int _GSocket_Send_Dgram(GSocket *socket, const char *buffer, int size) int len ; GSocketError err; - if (!socket->m_peer) + if (!m_peer) { - socket->m_error = GSOCK_INVADDR; + m_error = GSOCK_INVADDR; return -1; } - err = _GAddress_translate_to(socket->m_peer, &addr, &len); + err = _GAddress_translate_to(m_peer, &addr, &len); if (err != GSOCK_NOERROR) { - socket->m_error = err; + m_error = err; return -1; } - ret = sendto(socket->m_endpoint, buffer, size, 0, addr, len); + ret = sendto(m_endpoint, buffer, size, 0, addr, len); /* Frees memory allocated from _GAddress_translate_to */ free(addr); @@ -1181,6 +1163,16 @@ int _GSocket_Send_Dgram(GSocket *socket, const char *buffer, int size) return ret; } +/* Compatibility functions for GSocket */ +GSocket *GSocket_new(void) +{ + GSocket *newsocket = new GSocket(); + if(newsocket->IsOk()) + return newsocket; + delete newsocket; + return NULL; +} + /* * ------------------------------------------------------------------------- @@ -1279,7 +1271,7 @@ GSocketError _GAddress_translate_from(GAddress *address, GSocketError _GAddress_translate_to(GAddress *address, InetAddress *addr) { - if ( GSocket_Verify_Inited() == FALSE ) + if ( !GSocket_Verify_Inited() ) return GSOCK_IOERR ; memset(addr, 0 , sizeof(struct InetAddress)); OTInitInetAddress( addr , address->m_port , address->m_host ) ; @@ -1296,7 +1288,7 @@ GSocketError _GAddress_Init_INET(GAddress *address) { address->m_family = GSOCK_INET; address->m_host = kOTAnyInetAddress ; - + return GSOCK_NOERROR; } @@ -1305,7 +1297,7 @@ GSocketError GAddress_INET_SetHostName(GAddress *address, const char *hostname) InetHostInfo hinfo ; OSStatus ret ; - if ( GSocket_Verify_Inited() == FALSE ) + if ( !GSocket_Verify_Inited() ) return GSOCK_IOERR ; assert(address != NULL); @@ -1314,14 +1306,19 @@ GSocketError GAddress_INET_SetHostName(GAddress *address, const char *hostname) ret = OTInetStringToAddress( gInetSvcRef , (char*) hostname , &hinfo ) ; if ( ret != kOTNoError ) { - address->m_host = INADDR_NONE ; + address->m_host = INADDR_NONE ; address->m_error = GSOCK_NOHOST; return GSOCK_NOHOST; - } + } address->m_host = hinfo.addrs[0] ; return GSOCK_NOERROR; } +GSocketError GAddress_INET_SetBroadcastAddress(GAddress *address) +{ + return GAddress_INET_SetHostAddress(address, INADDR_BROADCAST); +} + GSocketError GAddress_INET_SetAnyAddress(GAddress *address) { return GAddress_INET_SetHostAddress(address, INADDR_ANY); @@ -1339,17 +1336,17 @@ GSocketError GAddress_INET_SetHostAddress(GAddress *address, return GSOCK_NOERROR; } -struct service_entry +struct service_entry { - char * name ; - unsigned short port ; - char * protocol ; + const char * name ; + unsigned short port ; + const char * protocol ; } ; typedef struct service_entry service_entry ; service_entry gServices[] = { - { "http" , 80 , "tcp" } + { "http" , 80 , "tcp" } } ; GSocketError GAddress_INET_SetPortName(GAddress *address, const char *port, @@ -1367,14 +1364,14 @@ GSocketError GAddress_INET_SetPortName(GAddress *address, const char *port, } for ( i = 0 ; i < sizeof( gServices) / sizeof( service_entry ) ; ++i ) { - if ( strcmp( port , gServices[i].name ) == 0 ) - { - if ( protocol == NULL || strcmp( protocol , gServices[i].protocol ) ) - { - address->m_port = gServices[i].port ; - return GSOCK_NOERROR; - } - } + if ( strcmp( port , gServices[i].name ) == 0 ) + { + if ( protocol == NULL || strcmp( protocol , gServices[i].protocol ) ) + { + address->m_port = gServices[i].port ; + return GSOCK_NOERROR; + } + } } if (isdigit(port[0])) @@ -1392,17 +1389,17 @@ GSocketError GAddress_INET_SetPort(GAddress *address, unsigned short port) assert(address != NULL); CHECK_ADDRESS(address, INET, GSOCK_INVADDR); address->m_port = port ; - + return GSOCK_NOERROR; } GSocketError GAddress_INET_GetHostName(GAddress *address, char *hostname, size_t sbuf) { InetDomainName name ; - if ( GSocket_Verify_Inited() == FALSE ) + if ( !GSocket_Verify_Inited() ) return GSOCK_IOERR ; - - assert(address != NULL); + + assert(address != NULL); CHECK_ADDRESS(address, INET, GSOCK_INVADDR); OTInetAddressToName( gInetSvcRef , address->m_host , name ) ; @@ -1412,84 +1409,84 @@ GSocketError GAddress_INET_GetHostName(GAddress *address, char *hostname, size_t unsigned long GAddress_INET_GetHostAddress(GAddress *address) { - assert(address != NULL); - CHECK_ADDRESS(address, INET, 0); + assert(address != NULL); + CHECK_ADDRESS(address, INET, 0); return ntohl(address->m_host); } unsigned short GAddress_INET_GetPort(GAddress *address) { - assert(address != NULL); - CHECK_ADDRESS(address, INET, 0); + assert(address != NULL); + CHECK_ADDRESS(address, INET, 0); return address->m_port; } -void _GSocket_Enable_Events(GSocket *socket) +void GSocket::Enable_Events() { - if ( socket->m_takesEvents ) - return ; - - { - OTResult state ; - socket->m_takesEvents = TRUE ; - state = OTGetEndpointState(socket->m_endpoint); - - { - OTByteCount sz = 0 ; - OTCountDataBytes( socket->m_endpoint , &sz ) ; - if ( state == T_INCON || sz > 0 ) - { - socket->m_detected |= GSOCK_INPUT_FLAG ; - (socket->m_cbacks[GSOCK_INPUT])(socket, GSOCK_INPUT, socket->m_data[GSOCK_INPUT]); - } - } - { - if ( state == T_DATAXFER || state == T_INREL ) - { - socket->m_detected |=GSOCK_OUTPUT_FLAG ; - (socket->m_cbacks[GSOCK_OUTPUT])(socket, GSOCK_OUTPUT, socket->m_data[GSOCK_OUTPUT]); - } - } - } + if ( m_takesEvents ) + return ; + + { + OTResult state ; + m_takesEvents = true ; + state = OTGetEndpointState(m_endpoint); + + { + OTByteCount sz = 0 ; + OTCountDataBytes( m_endpoint , &sz ) ; + if ( state == T_INCON || sz > 0 ) + { + m_detected |= GSOCK_INPUT_FLAG ; + (m_cbacks[GSOCK_INPUT])(this, GSOCK_INPUT, m_data[GSOCK_INPUT]); + } + } + { + if ( state == T_DATAXFER || state == T_INREL ) + { + m_detected |=GSOCK_OUTPUT_FLAG ; + (m_cbacks[GSOCK_OUTPUT])(this, GSOCK_OUTPUT, m_data[GSOCK_OUTPUT]); + } + } + } } -void _GSocket_Disable_Events(GSocket *socket) +void GSocket::Disable_Events() { - socket->m_takesEvents = FALSE ; + m_takesEvents = false ; } /* _GSocket_Input_Timeout: * For blocking sockets, wait until data is available or * until timeout ellapses. */ -GSocketError _GSocket_Input_Timeout(GSocket *socket) +GSocketError GSocket::Input_Timeout() { - if ( !socket->m_non_blocking ) + if ( !m_non_blocking ) { UnsignedWide now , start ; - short formerTakesEvents = socket->m_takesEvents ; + bool formerTakesEvents = m_takesEvents ; Microseconds(&start); now = start ; - socket->m_takesEvents = FALSE ; - - while( (now.hi * 4294967296.0 + now.lo) - (start.hi * 4294967296.0 + start.lo) < socket->m_timeout * 1000.0 ) + m_takesEvents = false ; + + while( (now.hi * 4294967296.0 + now.lo) - (start.hi * 4294967296.0 + start.lo) < m_timeout * 1000.0 ) { - OTResult state ; - OTByteCount sz = 0 ; - state = OTGetEndpointState(socket->m_endpoint); - - OTCountDataBytes( socket->m_endpoint , &sz ) ; - if ( state == T_INCON || sz > 0 ) - { - socket->m_takesEvents = formerTakesEvents ; - return GSOCK_NOERROR; - } - Microseconds(&now); + OTResult state ; + OTByteCount sz = 0 ; + state = OTGetEndpointState(m_endpoint); + + OTCountDataBytes( m_endpoint , &sz ) ; + if ( state == T_INCON || sz > 0 ) + { + m_takesEvents = formerTakesEvents ; + return GSOCK_NOERROR; + } + Microseconds(&now); } - socket->m_takesEvents = formerTakesEvents ; - socket->m_error = GSOCK_TIMEDOUT; + m_takesEvents = formerTakesEvents ; + m_error = GSOCK_TIMEDOUT; return GSOCK_TIMEDOUT; } return GSOCK_NOERROR; @@ -1499,30 +1496,30 @@ GSocketError _GSocket_Input_Timeout(GSocket *socket) * For blocking sockets, wait until data can be sent without * blocking or until timeout ellapses. */ -GSocketError _GSocket_Output_Timeout(GSocket *socket) +GSocketError GSocket::Output_Timeout() { - if ( !socket->m_non_blocking ) + if ( !m_non_blocking ) { UnsignedWide now , start ; - short formerTakesEvents = socket->m_takesEvents ; + bool formerTakesEvents = m_takesEvents ; Microseconds(&start); now = start ; - socket->m_takesEvents = FALSE ; - - while( (now.hi * 4294967296.0 + now.lo) - (start.hi * 4294967296.0 + start.lo) < socket->m_timeout * 1000.0 ) + m_takesEvents = false ; + + while( (now.hi * 4294967296.0 + now.lo) - (start.hi * 4294967296.0 + start.lo) < m_timeout * 1000.0 ) { - OTResult state ; - state = OTGetEndpointState(socket->m_endpoint); - - if ( state == T_DATAXFER || state == T_INREL ) - { - socket->m_takesEvents = formerTakesEvents ; - return GSOCK_NOERROR; - } - Microseconds(&now); + OTResult state ; + state = OTGetEndpointState(m_endpoint); + + if ( state == T_DATAXFER || state == T_INREL ) + { + m_takesEvents = formerTakesEvents ; + return GSOCK_NOERROR; + } + Microseconds(&now); } - socket->m_takesEvents = formerTakesEvents ; - socket->m_error = GSOCK_TIMEDOUT; + m_takesEvents = formerTakesEvents ; + m_error = GSOCK_TIMEDOUT; return GSOCK_TIMEDOUT; } return GSOCK_NOERROR; @@ -1533,14 +1530,14 @@ GSocketError _GSocket_Output_Timeout(GSocket *socket) * operation, there is still data available, the callback function will * be called again. * GSOCK_OUTPUT: - * The socket is available for writing. That is, the next write call + * The socket is available for writing. That is, the next write call * won't block. This event is generated only once, when the connection is * first established, and then only if a call failed with GSOCK_WOULDBLOCK, * when the output buffer empties again. This means that the app should * assume that it can write since the first OUTPUT event, and no more * OUTPUT events will be generated unless an error occurs. * GSOCK_CONNECTION: - * Connection succesfully established, for client sockets, or incoming + * Connection successfully established, for client sockets, or incoming * client connection, for server sockets. Wait for this event (also watch * out for GSOCK_LOST) after you issue a nonblocking GSocket_Connect() call. * GSOCK_LOST: @@ -1550,18 +1547,19 @@ GSocketError _GSocket_Output_Timeout(GSocket *socket) void _GSocket_Internal_Proc(unsigned long e , void* d ) { - - GSocket * socket = (GSocket*) d ; - OTEventCode ev = (OTEventCode) e ; - GSocketEvent event; - GSocketEvent event2; - GSocketCallback cback; - char *data; - GSocketCallback cback2; - char *data2; - - if ( !socket ) - return ; + GSocket *socket = (GSocket*) d ; + + if ( !socket ) + return ; + + OTEventCode ev = (OTEventCode) e ; + GSocketEvent event; + GSocketEvent event2; + GSocketCallback cback; + char *data; + GSocketCallback cback2; + char *data2; + event = GSOCK_MAX_EVENT ; event2 = GSOCK_MAX_EVENT ; cback = NULL; @@ -1573,41 +1571,41 @@ void _GSocket_Internal_Proc(unsigned long e , void* d ) * destroyed) and for safety, check that the m_endpoint field * is what we expect it to be. */ - if ((socket != NULL) && (socket->m_takesEvents)) + if ( /* (socket != NULL) && */ (socket->m_takesEvents)) { - switch (ev) - { - case T_LISTEN : - event = GSOCK_CONNECTION ; - break ; - case T_CONNECT : - event = GSOCK_CONNECTION ; - event2 = GSOCK_OUTPUT ; - { - TCall retCall; - - retCall.addr.buf = NULL; - retCall.addr.maxlen = 0; - retCall.opt.buf = NULL; - retCall.opt.maxlen = 0; - retCall.udata.buf = NULL; - retCall.udata.maxlen= 0; - OTRcvConnect( socket->m_endpoint , &retCall ) ; - } - break ; - case T_DISCONNECT : - event = GSOCK_LOST ; - break ; - case T_GODATA : - case T_GOEXDATA : - event = GSOCK_OUTPUT ; - break ; - case T_DATA : - event = GSOCK_INPUT ; - break ; - case T_EXDATA : - event = GSOCK_INPUT ; - break ; + switch (ev) + { + case T_LISTEN : + event = GSOCK_CONNECTION ; + break ; + case T_CONNECT : + event = GSOCK_CONNECTION ; + event2 = GSOCK_OUTPUT ; + { + TCall retCall; + + retCall.addr.buf = NULL; + retCall.addr.maxlen = 0; + retCall.opt.buf = NULL; + retCall.opt.maxlen = 0; + retCall.udata.buf = NULL; + retCall.udata.maxlen = 0; + OTRcvConnect( socket->m_endpoint , &retCall ) ; + } + break ; + case T_DISCONNECT : + event = GSOCK_LOST ; + break ; + case T_GODATA : + case T_GOEXDATA : + event = GSOCK_OUTPUT ; + break ; + case T_DATA : + event = GSOCK_INPUT ; + break ; + case T_EXDATA : + event = GSOCK_INPUT ; + break ; } if (event != GSOCK_MAX_EVENT) {