From 3562e78743202e43aec8727005182a2558117eca Mon Sep 17 00:00:00 2001 From: marha Date: Sun, 28 Jun 2009 22:07:26 +0000 Subject: Checked in the following released items: xkeyboard-config-1.4.tar.gz ttf-bitstream-vera-1.10.tar.gz font-alias-1.0.1.tar.gz font-sun-misc-1.0.0.tar.gz font-sun-misc-1.0.0.tar.gz font-sony-misc-1.0.0.tar.gz font-schumacher-misc-1.0.0.tar.gz font-mutt-misc-1.0.0.tar.gz font-misc-misc-1.0.0.tar.gz font-misc-meltho-1.0.0.tar.gz font-micro-misc-1.0.0.tar.gz font-jis-misc-1.0.0.tar.gz font-isas-misc-1.0.0.tar.gz font-dec-misc-1.0.0.tar.gz font-daewoo-misc-1.0.0.tar.gz font-cursor-misc-1.0.0.tar.gz font-arabic-misc-1.0.0.tar.gz font-winitzki-cyrillic-1.0.0.tar.gz font-misc-cyrillic-1.0.0.tar.gz font-cronyx-cyrillic-1.0.0.tar.gz font-screen-cyrillic-1.0.1.tar.gz font-xfree86-type1-1.0.1.tar.gz font-adobe-utopia-type1-1.0.1.tar.gz font-ibm-type1-1.0.0.tar.gz font-bitstream-type1-1.0.0.tar.gz font-bitstream-speedo-1.0.0.tar.gz font-bh-ttf-1.0.0.tar.gz font-bh-type1-1.0.0.tar.gz font-bitstream-100dpi-1.0.0.tar.gz font-bh-lucidatypewriter-100dpi-1.0.0.tar.gz font-bh-100dpi-1.0.0.tar.gz font-adobe-utopia-100dpi-1.0.1.tar.gz font-adobe-100dpi-1.0.0.tar.gz font-util-1.0.1.tar.gz font-bitstream-75dpi-1.0.0.tar.gz font-bh-lucidatypewriter-75dpi-1.0.0.tar.gz font-adobe-utopia-75dpi-1.0.1.tar.gz font-bh-75dpi-1.0.0.tar.gz bdftopcf-1.0.1.tar.gz font-adobe-75dpi-1.0.0.tar.gz mkfontscale-1.0.6.tar.gz openssl-0.9.8k.tar.gz bigreqsproto-1.0.2.tar.gz xtrans-1.2.2.tar.gz resourceproto-1.0.2.tar.gz inputproto-1.4.4.tar.gz compositeproto-0.4.tar.gz damageproto-1.1.0.tar.gz zlib-1.2.3.tar.gz xkbcomp-1.0.5.tar.gz freetype-2.3.9.tar.gz pthreads-w32-2-8-0-release.tar.gz pixman-0.12.0.tar.gz kbproto-1.0.3.tar.gz evieext-1.0.2.tar.gz fixesproto-4.0.tar.gz recordproto-1.13.2.tar.gz randrproto-1.2.2.tar.gz scrnsaverproto-1.1.0.tar.gz renderproto-0.9.3.tar.gz xcmiscproto-1.1.2.tar.gz fontsproto-2.0.2.tar.gz xextproto-7.0.3.tar.gz xproto-7.0.14.tar.gz libXdmcp-1.0.2.tar.gz libxkbfile-1.0.5.tar.gz libfontenc-1.0.4.tar.gz libXfont-1.3.4.tar.gz libX11-1.1.5.tar.gz libXau-1.0.4.tar.gz libxcb-1.1.tar.gz xorg-server-1.5.3.tar.gz --- openssl/MacOS/GetHTTPS.src/MacSocket.cpp | 1607 ++++++++++++++++++++++++++++++ 1 file changed, 1607 insertions(+) create mode 100644 openssl/MacOS/GetHTTPS.src/MacSocket.cpp (limited to 'openssl/MacOS/GetHTTPS.src/MacSocket.cpp') diff --git a/openssl/MacOS/GetHTTPS.src/MacSocket.cpp b/openssl/MacOS/GetHTTPS.src/MacSocket.cpp new file mode 100644 index 000000000..c95d804d5 --- /dev/null +++ b/openssl/MacOS/GetHTTPS.src/MacSocket.cpp @@ -0,0 +1,1607 @@ +/* + * A simple socket-like package. + * This could undoubtedly be improved, since it does polling and busy-waiting. + * At least it uses asynch I/O and implements timeouts! + * + * Other funkiness includes the use of my own (possibly brain-damaged) error-handling infrastructure. + * + * -Roy Wood (roy@centricsystems.ca) + * + */ + + +/* ==================================================================== + * Copyright (c) 1998-1999 The OpenSSL Project. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in + * the documentation and/or other materials provided with the + * distribution. + * + * 3. All advertising materials mentioning features or use of this + * software must display the following acknowledgment: + * "This product includes software developed by the OpenSSL Project + * for use in the OpenSSL Toolkit. (http://www.openssl.org/)" + * + * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to + * endorse or promote products derived from this software without + * prior written permission. For written permission, please contact + * openssl-core@openssl.org. + * + * 5. Products derived from this software may not be called "OpenSSL" + * nor may "OpenSSL" appear in their names without prior written + * permission of the OpenSSL Project. + * + * 6. Redistributions of any form whatsoever must retain the following + * acknowledgment: + * "This product includes software developed by the OpenSSL Project + * for use in the OpenSSL Toolkit (http://www.openssl.org/)" + * + * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY + * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR + * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE OpenSSL PROJECT OR + * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, + * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED + * OF THE POSSIBILITY OF SUCH DAMAGE. + * ==================================================================== + * + * This product includes cryptographic software written by Eric Young + * (eay@cryptsoft.com). This product includes software written by Tim + * Hudson (tjh@cryptsoft.com). + * + */ + + + + + +#include "MacSocket.h" + +#include + +#include +#include +#include + + + +#include "CPStringUtils.hpp" +#include "ErrorHandling.hpp" + + +// #define MACSOCKET_DEBUG 1 + +#ifdef MACSOCKET_DEBUG + #include +#endif + + + +extern int errno; + + +#define kMaxNumSockets 4 + + +struct SocketStruct +{ + Boolean mIsInUse; + + Boolean mEndpointIsBound; + + Boolean mLocalEndIsConnected; + Boolean mRemoteEndIsConnected; + + Boolean mReceivedTOpenComplete; + Boolean mReceivedTBindComplete; + Boolean mReceivedTConnect; + Boolean mReceivedTListen; + Boolean mReceivedTPassCon; + Boolean mReceivedTDisconnect; + Boolean mReceivedTOrdRel; + Boolean mReceivedTDisconnectComplete; + + long mTimeoutTicks; + long mOperationStartTicks; + + MacSocket_IdleWaitCallback mIdleWaitCallback; + void *mUserRefPtr; + + OTEventCode mExpectedCode; + OTResult mAsyncOperationResult; + + EndpointRef mEndPointRef; + TBind *mBindRequestedAddrInfo; + TBind *mAssignedAddrInfo; + TCall *mRemoteAddrInfo; + + Boolean mReadyToReadData; + Boolean mReadyToWriteData; + + Ptr mReadBuffer; + Ptr mWriteBuffer; + + int mLastError; + char mErrMessage[256]; +}; + +typedef struct SocketStruct SocketStruct; + + +static SocketStruct sSockets[kMaxNumSockets]; +static Boolean sSocketsSetup = false; + + + + +static OSErr MyBusyWait(SocketStruct *ioSocket,Boolean returnImmediatelyOnError,OTResult *outOTResult,Boolean *inAsyncOperationCompleteFlag); + +static pascal void OTNonYieldingNotifier(void *contextPtr,OTEventCode code,OTResult result,void *cookie); + +static Boolean SocketIndexIsValid(const int inSocketNum); + +static void InitSocket(SocketStruct *ioSocket); + +static void PrepareForAsyncOperation(SocketStruct *ioSocket,const OTEventCode inExpectedCode); + +static Boolean TimeoutElapsed(const SocketStruct *inSocket); + +static OSStatus NegotiateIPReuseAddrOption(EndpointRef inEndpoint,const Boolean inEnableReuseIP); + + + +void MacSocket_GetSocketErrorInfo(const int inSocketNum,int *outSocketErrCode,char *outSocketErrString,const int inSocketErrStringMaxLength) +{ + if (outSocketErrCode != nil) + { + *outSocketErrCode = -1; + } + + if (outSocketErrString != nil) + { + CopyCStrToCStr("",outSocketErrString,inSocketErrStringMaxLength); + } + + + if (SocketIndexIsValid(inSocketNum)) + { + SocketStruct *theSocketStruct = &(sSockets[inSocketNum]); + + + if (outSocketErrCode != nil) + { + *outSocketErrCode = theSocketStruct->mLastError; + } + + if (outSocketErrString != nil) + { + CopyCStrToCStr(theSocketStruct->mErrMessage,outSocketErrString,inSocketErrStringMaxLength); + } + } +} + + +void MacSocket_SetUserRefPtr(const int inSocketNum,void *inNewRefPtr) +{ + if (SocketIndexIsValid(inSocketNum)) + { + SocketStruct *theSocketStruct = &(sSockets[inSocketNum]); + + theSocketStruct->mUserRefPtr = inNewRefPtr; + } +} + + + +void MacSocket_GetLocalIPAndPort(const int inSocketNum,char *outIPAndPort,const int inIPAndPortLength) +{ + if (outIPAndPort != nil && SocketIndexIsValid(inSocketNum)) + { + char tempString[256]; + SocketStruct *theSocketStruct = &(sSockets[inSocketNum]); + + + CopyCStrToCStr("",tempString,sizeof(tempString)); + + if (theSocketStruct->mAssignedAddrInfo != nil) + { + InetAddress *theInetAddress = (InetAddress *) theSocketStruct->mAssignedAddrInfo->addr.buf; + InetHost theInetHost = theInetAddress->fHost; + + if (theInetHost == 0) + { + InetInterfaceInfo theInetInterfaceInfo; + + if (::OTInetGetInterfaceInfo(&theInetInterfaceInfo,kDefaultInetInterface) == noErr) + { + theInetHost = theInetInterfaceInfo.fAddress; + } + } + + ::OTInetHostToString(theInetHost,tempString); + + ConcatCStrToCStr(":",tempString,sizeof(tempString)); + ConcatLongIntToCStr(theInetAddress->fPort,tempString,sizeof(tempString)); + } + + CopyCStrToCStr(tempString,outIPAndPort,inIPAndPortLength); + } +} + + + +void MacSocket_GetRemoteIPAndPort(const int inSocketNum,char *outIPAndPort,const int inIPAndPortLength) +{ + if (outIPAndPort != nil && SocketIndexIsValid(inSocketNum)) + { + char tempString[256]; + SocketStruct *theSocketStruct = &(sSockets[inSocketNum]); + + + CopyCStrToCStr("",tempString,sizeof(tempString)); + + if (theSocketStruct->mRemoteAddrInfo != nil) + { + InetAddress *theInetAddress = (InetAddress *) theSocketStruct->mRemoteAddrInfo->addr.buf; + InetHost theInetHost = theInetAddress->fHost; + + if (theInetHost == 0) + { + InetInterfaceInfo theInetInterfaceInfo; + + if (::OTInetGetInterfaceInfo(&theInetInterfaceInfo,kDefaultInetInterface) == noErr) + { + theInetHost = theInetInterfaceInfo.fAddress; + } + } + + ::OTInetHostToString(theInetHost,tempString); + + ConcatCStrToCStr(":",tempString,sizeof(tempString)); + ConcatLongIntToCStr(theInetAddress->fPort,tempString,sizeof(tempString)); + } + + CopyCStrToCStr(tempString,outIPAndPort,inIPAndPortLength); + } +} + + + +Boolean MacSocket_RemoteEndIsClosing(const int inSocketNum) +{ +Boolean theResult = false; + + if (SocketIndexIsValid(inSocketNum)) + { + SocketStruct *theSocketStruct = &(sSockets[inSocketNum]); + + theResult = theSocketStruct->mReceivedTOrdRel; + } + + return(theResult); +} + + + +Boolean MacSocket_ListenCompleted(const int inSocketNum) +{ +Boolean theResult = false; + + if (SocketIndexIsValid(inSocketNum)) + { + SocketStruct *theSocketStruct = &(sSockets[inSocketNum]); + + theResult = theSocketStruct->mReceivedTPassCon; + } + + return(theResult); +} + + + +Boolean MacSocket_RemoteEndIsOpen(const int inSocketNum) +{ + if (SocketIndexIsValid(inSocketNum)) + { + SocketStruct *theSocketStruct = &(sSockets[inSocketNum]); + + return(theSocketStruct->mRemoteEndIsConnected); + } + + else + { + return(false); + } +} + + + +Boolean MacSocket_LocalEndIsOpen(const int inSocketNum) +{ + if (SocketIndexIsValid(inSocketNum)) + { + SocketStruct *theSocketStruct = &(sSockets[inSocketNum]); + + return(theSocketStruct->mLocalEndIsConnected); + } + + else + { + return(false); + } +} + + + +static Boolean TimeoutElapsed(const SocketStruct *inSocket) +{ +Boolean timeIsUp = false; + + if (inSocket != nil && inSocket->mTimeoutTicks > 0 && ::TickCount() > inSocket->mOperationStartTicks + inSocket->mTimeoutTicks) + { + timeIsUp = true; + } + + + return(timeIsUp); +} + + + +static Boolean SocketIndexIsValid(const int inSocketNum) +{ + if (inSocketNum >= 0 && inSocketNum < kMaxNumSockets && sSockets[inSocketNum].mEndPointRef != kOTInvalidEndpointRef) + { + return(true); + } + + else + { + return(false); + } +} + + + +static void InitSocket(SocketStruct *ioSocket) +{ + ioSocket->mIsInUse = false; + + ioSocket->mEndpointIsBound = false; + + ioSocket->mLocalEndIsConnected = false; + ioSocket->mRemoteEndIsConnected = false; + + ioSocket->mReceivedTOpenComplete = false; + ioSocket->mReceivedTBindComplete = false; + ioSocket->mReceivedTConnect = false; + ioSocket->mReceivedTListen = false; + ioSocket->mReceivedTPassCon = false; + ioSocket->mReceivedTDisconnect = false; + ioSocket->mReceivedTOrdRel = false; + ioSocket->mReceivedTDisconnectComplete = false; + + ioSocket->mTimeoutTicks = 30 * 60; + ioSocket->mOperationStartTicks = -1; + + ioSocket->mIdleWaitCallback = nil; + ioSocket->mUserRefPtr = nil; + + ioSocket->mExpectedCode = 0; + ioSocket->mAsyncOperationResult = noErr; + + ioSocket->mEndPointRef = kOTInvalidEndpointRef; + + ioSocket->mBindRequestedAddrInfo = nil; + ioSocket->mAssignedAddrInfo = nil; + ioSocket->mRemoteAddrInfo = nil; + + ioSocket->mReadyToReadData = false; + ioSocket->mReadyToWriteData = true; + + ioSocket->mReadBuffer = nil; + ioSocket->mWriteBuffer = nil; + + ioSocket->mLastError = noErr; + CopyCStrToCStr("",ioSocket->mErrMessage,sizeof(ioSocket->mErrMessage)); +} + + + +static void PrepareForAsyncOperation(SocketStruct *ioSocket,const OTEventCode inExpectedCode) +{ + ioSocket->mOperationStartTicks = ::TickCount(); + + ioSocket->mAsyncOperationResult = noErr; + + ioSocket->mExpectedCode = inExpectedCode; +} + + +// The wait function.... + +static OSErr MyBusyWait(SocketStruct *ioSocket,Boolean returnImmediatelyOnError,OTResult *outOTResult,Boolean *inAsyncOperationCompleteFlag) +{ +OSErr errCode = noErr; +OTResult theOTResult = noErr; + + + SetErrorMessageAndBailIfNil(ioSocket,"MyBusyWait: Bad parameter, ioSocket = nil"); + SetErrorMessageAndBailIfNil(inAsyncOperationCompleteFlag,"MyBusyWait: Bad parameter, inAsyncOperationCompleteFlag = nil"); + + for (;;) + { + if (*inAsyncOperationCompleteFlag) + { + theOTResult = ioSocket->mAsyncOperationResult; + + break; + } + + if (ioSocket->mIdleWaitCallback != nil) + { + theOTResult = (*(ioSocket->mIdleWaitCallback))(ioSocket->mUserRefPtr); + + if (theOTResult != noErr && returnImmediatelyOnError) + { + break; + } + } + + if (TimeoutElapsed(ioSocket)) + { + theOTResult = kMacSocket_TimeoutErr; + + break; + } + } + + +EXITPOINT: + + if (outOTResult != nil) + { + *outOTResult = theOTResult; + } + + return(errCode); +} + + + +// I used to do thread switching, but stopped. It could easily be rolled back in though.... + +static pascal void OTNonYieldingNotifier(void *contextPtr,OTEventCode code,OTResult result,void *cookie) +{ +SocketStruct *theSocketStruct = (SocketStruct *) contextPtr; + + if (theSocketStruct != nil) + { + if (theSocketStruct->mExpectedCode != 0 && code == theSocketStruct->mExpectedCode) + { + theSocketStruct->mAsyncOperationResult = result; + + theSocketStruct->mExpectedCode = 0; + } + + + switch (code) + { + case T_OPENCOMPLETE: + { + theSocketStruct->mReceivedTOpenComplete = true; + + theSocketStruct->mEndPointRef = (EndpointRef) cookie; + + break; + } + + + case T_BINDCOMPLETE: + { + theSocketStruct->mReceivedTBindComplete = true; + + break; + } + + + case T_CONNECT: + { + theSocketStruct->mReceivedTConnect = true; + + theSocketStruct->mLocalEndIsConnected = true; + + theSocketStruct->mRemoteEndIsConnected = true; + + break; + } + + + case T_LISTEN: + { + theSocketStruct->mReceivedTListen = true; + + break; + } + + + case T_PASSCON: + { + theSocketStruct->mReceivedTPassCon = true; + + theSocketStruct->mLocalEndIsConnected = true; + + theSocketStruct->mRemoteEndIsConnected = true; + + break; + } + + + case T_DATA: + { + theSocketStruct->mReadyToReadData = true; + + break; + } + + case T_GODATA: + { + theSocketStruct->mReadyToWriteData = true; + + break; + } + + case T_DISCONNECT: + { + theSocketStruct->mReceivedTDisconnect = true; + + theSocketStruct->mRemoteEndIsConnected = false; + + theSocketStruct->mLocalEndIsConnected = false; + + ::OTRcvDisconnect(theSocketStruct->mEndPointRef,nil); + + break; + } + + case T_ORDREL: + { + theSocketStruct->mReceivedTOrdRel = true; + + // We can still write data, so don't clear mRemoteEndIsConnected + + ::OTRcvOrderlyDisconnect(theSocketStruct->mEndPointRef); + + break; + } + + case T_DISCONNECTCOMPLETE: + { + theSocketStruct->mReceivedTDisconnectComplete = true; + + theSocketStruct->mRemoteEndIsConnected = false; + + theSocketStruct->mLocalEndIsConnected = false; + + break; + } + } + } +/* +T_LISTEN OTListen +T_CONNECT OTRcvConnect +T_DATA OTRcv, OTRcvUData +T_DISCONNECT OTRcvDisconnect +T_ORDREL OTRcvOrderlyDisconnect +T_GODATA OTSnd, OTSndUData, OTLook +T_PASSCON none + +T_EXDATA OTRcv +T_GOEXDATA OTSnd, OTLook +T_UDERR OTRcvUDErr +*/ +} + + + +// Initialize the main socket data structure + +OSErr MacSocket_Startup(void) +{ + if (!sSocketsSetup) + { + for (int i = 0;i < kMaxNumSockets;i++) + { + InitSocket(&(sSockets[i])); + } + + ::InitOpenTransport(); + + sSocketsSetup = true; + } + + + return(noErr); +} + + + +// Cleanup before exiting + +OSErr MacSocket_Shutdown(void) +{ + if (sSocketsSetup) + { + for (int i = 0;i < kMaxNumSockets;i++) + { + SocketStruct *theSocketStruct = &(sSockets[i]); + + if (theSocketStruct->mIsInUse) + { + if (theSocketStruct->mEndPointRef != kOTInvalidEndpointRef) + { + OTResult theOTResult; + + + // Since we're killing the endpoint, I don't bother to send the disconnect (sorry!) + +/* + if (theSocketStruct->mLocalEndIsConnected) + { + // This is an abortive action, so we do a hard disconnect instead of an OTSndOrderlyDisconnect + + theOTResult = ::OTSndDisconnect(theSocketStruct->mEndPointRef, nil); + + // Now we have to watch for T_DISCONNECTCOMPLETE event + + theSocketStruct->mLocalEndIsConnected = false; + } +*/ + + theOTResult = ::OTCloseProvider(theSocketStruct->mEndPointRef); + + + theSocketStruct->mEndPointRef = kOTInvalidEndpointRef; + } + + if (theSocketStruct->mBindRequestedAddrInfo != nil) + { + ::OTFree((void *) theSocketStruct->mBindRequestedAddrInfo,T_BIND); + + theSocketStruct->mBindRequestedAddrInfo = nil; + } + + if (theSocketStruct->mAssignedAddrInfo != nil) + { + ::OTFree((void *) theSocketStruct->mAssignedAddrInfo,T_BIND); + + theSocketStruct->mAssignedAddrInfo = nil; + } + + if (theSocketStruct->mRemoteAddrInfo != nil) + { + ::OTFree((void *) theSocketStruct->mRemoteAddrInfo,T_CALL); + + theSocketStruct->mRemoteAddrInfo = nil; + } + + + } + } + + ::CloseOpenTransport(); + + sSocketsSetup = false; + } + + return(noErr); +} + + + + + + +// Allocate a socket + +OSErr MacSocket_socket(int *outSocketNum,const Boolean inDoThreadSwitching,const long inTimeoutTicks,MacSocket_IdleWaitCallback inIdleWaitCallback,void *inUserRefPtr) +{ +// Gotta roll support back in for threads eventually..... + +#pragma unused(inDoThreadSwitching) + + +OSErr errCode = noErr; + + + SetErrorMessageAndBailIfNil(outSocketNum,"MacSocket_socket: Bad parameter, outSocketNum == nil"); + + *outSocketNum = -1; + + + // Find an unused socket + + for (int i = 0;i < kMaxNumSockets;i++) + { + if (sSockets[i].mIsInUse == false) + { + OTResult theOTResult; + SocketStruct *theSocketStruct = &(sSockets[i]); + + + InitSocket(theSocketStruct); + + theSocketStruct->mIdleWaitCallback = inIdleWaitCallback; + theSocketStruct->mUserRefPtr = inUserRefPtr; + + theSocketStruct->mTimeoutTicks = inTimeoutTicks; + + + // Set up OT endpoint + + PrepareForAsyncOperation(theSocketStruct,T_OPENCOMPLETE); + + theOTResult = ::OTAsyncOpenEndpoint(OTCreateConfiguration(kTCPName),0,nil,OTNonYieldingNotifier,(void *) theSocketStruct); + + SetErrorMessageAndLongIntAndBailIfError(theOTResult,"MacSocket_socket: Can't create OT endpoint, OTAsyncOpenEndpoint() = ",theOTResult); + + BailIfError(MyBusyWait(theSocketStruct,false,&theOTResult,&(theSocketStruct->mReceivedTOpenComplete))); + + SetErrorMessageAndLongIntAndBailIfError(theOTResult,"MacSocket_socket: Can't create OT endpoint, OTAsyncOpenEndpoint() = ",theOTResult); + + + *outSocketNum = i; + + errCode = noErr; + + theSocketStruct->mIsInUse = true; + + break; + } + + else if (i == kMaxNumSockets - 1) + { + SetErrorMessageAndBail("MacSocket_socket: No sockets available"); + } + } + + +EXITPOINT: + + errno = errCode; + + return(errCode); +} + + + + +OSErr MacSocket_listen(const int inSocketNum,const int inPortNum) +{ +OSErr errCode = noErr; +SocketStruct *theSocketStruct = nil; + + + if (!SocketIndexIsValid(inSocketNum)) + { + SetErrorMessageAndBail("MacSocket_listen: Invalid socket number specified"); + } + + + theSocketStruct = &(sSockets[inSocketNum]); + + +OTResult theOTResult; + + + if (theSocketStruct->mBindRequestedAddrInfo == nil) + { + theSocketStruct->mBindRequestedAddrInfo = (TBind *) ::OTAlloc(theSocketStruct->mEndPointRef,T_BIND,T_ADDR,&theOTResult); + + SetErrorMessageAndLongIntAndBailIfError(theOTResult,"MacSocket_listen: Can't allocate OT T_BIND structure, OTAlloc() = ",theOTResult); + SetErrorMessageAndBailIfNil(theSocketStruct->mBindRequestedAddrInfo,"MacSocket_listen: Can't allocate OT T_BIND structure, OTAlloc() returned nil"); + } + + if (theSocketStruct->mAssignedAddrInfo == nil) + { + theSocketStruct->mAssignedAddrInfo = (TBind *) ::OTAlloc(theSocketStruct->mEndPointRef,T_BIND,T_ADDR,&theOTResult); + + SetErrorMessageAndLongIntAndBailIfError(theOTResult,"MacSocket_listen: Can't allocate OT T_BIND structure, OTAlloc() = ",theOTResult); + SetErrorMessageAndBailIfNil(theSocketStruct->mAssignedAddrInfo,"MacSocket_listen: Can't allocate OT T_BIND structure, OTAlloc() returned nil"); + } + + if (theSocketStruct->mRemoteAddrInfo == nil) + { + theSocketStruct->mRemoteAddrInfo = (TCall *) ::OTAlloc(theSocketStruct->mEndPointRef,T_CALL,T_ADDR,&theOTResult); + + SetErrorMessageAndLongIntAndBailIfError(theOTResult,"MacSocket_listen: Can't allocate OT T_CALL structure, OTAlloc() = ",theOTResult); + SetErrorMessageAndBailIfNil(theSocketStruct->mRemoteAddrInfo,"MacSocket_listen: Can't allocate OT T_CALL structure, OTAlloc() returned nil"); + } + + + if (!theSocketStruct->mEndpointIsBound) + { + InetInterfaceInfo theInetInterfaceInfo; + + theOTResult = ::OTInetGetInterfaceInfo(&theInetInterfaceInfo,kDefaultInetInterface); + + SetErrorMessageAndLongIntAndBailIfError(theOTResult,"MacSocket_listen: Can't determine OT interface info, OTInetGetInterfaceInfo() = ",theOTResult); + + + InetAddress *theInetAddress = (InetAddress *) theSocketStruct->mBindRequestedAddrInfo->addr.buf; + +// theInetAddress->fAddressType = AF_INET; +// theInetAddress->fPort = inPortNum; +// theInetAddress->fHost = theInetInterfaceInfo.fAddress; + + ::OTInitInetAddress(theInetAddress,inPortNum,theInetInterfaceInfo.fAddress); + + theSocketStruct->mBindRequestedAddrInfo->addr.len = sizeof(InetAddress); + + theSocketStruct->mBindRequestedAddrInfo->qlen = 1; + + + theOTResult = ::OTSetSynchronous(theSocketStruct->mEndPointRef); + + SetErrorMessageAndLongIntAndBailIfError(theOTResult,"MacSocket_listen: Can't set OT endpoint mode, OTSetSynchronous() = ",theOTResult); + + theOTResult = NegotiateIPReuseAddrOption(theSocketStruct->mEndPointRef,true); + + SetErrorMessageAndLongIntAndBailIfError(theOTResult,"MacSocket_listen: Can't set OT IP address reuse flag, NegotiateIPReuseAddrOption() = ",theOTResult); + + theOTResult = ::OTSetAsynchronous(theSocketStruct->mEndPointRef); + + SetErrorMessageAndLongIntAndBailIfError(theOTResult,"MacSocket_listen: Can't set OT endpoint mode, OTSetAsynchronous() = ",theOTResult); + + + PrepareForAsyncOperation(theSocketStruct,T_BINDCOMPLETE); + + theOTResult = ::OTBind(theSocketStruct->mEndPointRef,theSocketStruct->mBindRequestedAddrInfo,theSocketStruct->mAssignedAddrInfo); + + SetErrorMessageAndLongIntAndBailIfError(theOTResult,"MacSocket_listen: Can't bind OT endpoint, OTBind() = ",theOTResult); + + BailIfError(MyBusyWait(theSocketStruct,false,&theOTResult,&(theSocketStruct->mReceivedTBindComplete))); + + SetErrorMessageAndLongIntAndBailIfError(theOTResult,"MacSocket_listen: Can't bind OT endpoint, OTBind() = ",theOTResult); + + + theSocketStruct->mEndpointIsBound = true; + } + + + PrepareForAsyncOperation(theSocketStruct,T_LISTEN); + + theOTResult = ::OTListen(theSocketStruct->mEndPointRef,theSocketStruct->mRemoteAddrInfo); + + if (theOTResult == noErr) + { + PrepareForAsyncOperation(theSocketStruct,T_PASSCON); + + theOTResult = ::OTAccept(theSocketStruct->mEndPointRef,theSocketStruct->mEndPointRef,theSocketStruct->mRemoteAddrInfo); + + SetErrorMessageAndLongIntAndBailIfError(theOTResult,"MacSocket_listen: Can't begin OT accept, OTAccept() = ",theOTResult); + + BailIfError(MyBusyWait(theSocketStruct,false,&theOTResult,&(theSocketStruct->mReceivedTPassCon))); + + SetErrorMessageAndLongIntAndBailIfError(theOTResult,"MacSocket_listen: Can't accept OT connection, OTAccept() = ",theOTResult); + } + + else if (theOTResult == kOTNoDataErr) + { + theOTResult = noErr; + } + + else + { + SetErrorMessageAndLongIntAndBail("MacSocket_listen: Can't begin OT listen, OTListen() = ",theOTResult); + } + + + errCode = noErr; + + +EXITPOINT: + + if (theSocketStruct != nil) + { + theSocketStruct->mLastError = noErr; + + CopyCStrToCStr("",theSocketStruct->mErrMessage,sizeof(theSocketStruct->mErrMessage)); + + if (errCode != noErr) + { + theSocketStruct->mLastError = errCode; + + CopyCStrToCStr(GetErrorMessage(),theSocketStruct->mErrMessage,sizeof(theSocketStruct->mErrMessage)); + } + } + + errno = errCode; + + return(errCode); +} + + + + +OSErr MacSocket_connect(const int inSocketNum,char *inTargetAddressAndPort) +{ +OSErr errCode = noErr; +SocketStruct *theSocketStruct = nil; + + + if (!SocketIndexIsValid(inSocketNum)) + { + SetErrorMessageAndBail("MacSocket_connect: Invalid socket number specified"); + } + + theSocketStruct = &(sSockets[inSocketNum]); + + if (theSocketStruct->mEndpointIsBound) + { + SetErrorMessageAndBail("MacSocket_connect: Socket previously bound"); + } + + +OTResult theOTResult; + + theSocketStruct->mBindRequestedAddrInfo = (TBind *) ::OTAlloc(theSocketStruct->mEndPointRef,T_BIND,T_ADDR,&theOTResult); + + SetErrorMessageAndLongIntAndBailIfError(theOTResult,"MacSocket_connect: Can't allocate OT T_BIND structure, OTAlloc() = ",theOTResult); + SetErrorMessageAndBailIfNil(theSocketStruct->mBindRequestedAddrInfo,"MacSocket_connect: Can't allocate OT T_BIND structure, OTAlloc() returned nil"); + + + theSocketStruct->mAssignedAddrInfo = (TBind *) ::OTAlloc(theSocketStruct->mEndPointRef,T_BIND,T_ADDR,&theOTResult); + + SetErrorMessageAndLongIntAndBailIfError(theOTResult,"MacSocket_connect: Can't allocate OT T_BIND structure, OTAlloc() = ",theOTResult); + SetErrorMessageAndBailIfNil(theSocketStruct->mAssignedAddrInfo,"MacSocket_connect: Can't allocate OT T_BIND structure, OTAlloc() returned nil"); + + + theSocketStruct->mRemoteAddrInfo = (TCall *) ::OTAlloc(theSocketStruct->mEndPointRef,T_CALL,T_ADDR,&theOTResult); + + SetErrorMessageAndLongIntAndBailIfError(theOTResult,"MacSocket_connect: Can't allocate OT T_CALL structure, OTAlloc() = ",theOTResult); + SetErrorMessageAndBailIfNil(theSocketStruct->mRemoteAddrInfo,"MacSocket_connect: Can't allocate OT T_CALL structure, OTAlloc() returned nil"); + + + PrepareForAsyncOperation(theSocketStruct,T_BINDCOMPLETE); + + theOTResult = ::OTBind(theSocketStruct->mEndPointRef,nil,theSocketStruct->mAssignedAddrInfo); + + SetErrorMessageAndLongIntAndBailIfError(theOTResult,"MacSocket_connect: Can't bind OT endpoint, OTBind() = ",theOTResult); + + BailIfError(MyBusyWait(theSocketStruct,false,&theOTResult,&(theSocketStruct->mReceivedTBindComplete))); + + SetErrorMessageAndLongIntAndBailIfError(theOTResult,"MacSocket_connect: Can't bind OT endpoint, OTBind() = ",theOTResult); + + theSocketStruct->mEndpointIsBound = true; + + +TCall sndCall; +DNSAddress hostDNSAddress; + + // Set up target address + + sndCall.addr.buf = (UInt8 *) &hostDNSAddress; + sndCall.addr.len = ::OTInitDNSAddress(&hostDNSAddress,inTargetAddressAndPort); + sndCall.opt.buf = nil; + sndCall.opt.len = 0; + sndCall.udata.buf = nil; + sndCall.udata.len = 0; + sndCall.sequence = 0; + + // Connect! + + PrepareForAsyncOperation(theSocketStruct,T_CONNECT); + + theOTResult = ::OTConnect(theSocketStruct->mEndPointRef,&sndCall,nil); + + if (theOTResult == kOTNoDataErr) + { + theOTResult = noErr; + } + + SetErrorMessageAndLongIntAndBailIfError(theOTResult,"MacSocket_connect: Can't connect OT endpoint, OTConnect() = ",theOTResult); + + BailIfError(MyBusyWait(theSocketStruct,false,&theOTResult,&(theSocketStruct->mReceivedTConnect))); + + if (theOTResult == kMacSocket_TimeoutErr) + { + SetErrorMessageAndBail("MacSocket_connect: Can't connect OT endpoint, OTConnect() = kMacSocket_TimeoutErr"); + } + + else + { + SetErrorMessageAndLongIntAndBailIfError(theOTResult,"MacSocket_connect: Can't connect OT endpoint, OTConnect() = ",theOTResult); + } + + theOTResult = ::OTRcvConnect(theSocketStruct->mEndPointRef,nil); + + SetErrorMessageAndLongIntAndBailIfError(theOTResult,"MacSocket_connect: Can't complete connect on OT endpoint, OTRcvConnect() = ",theOTResult); + + + errCode = noErr; + + +#ifdef MACSOCKET_DEBUG + printf("MacSocket_connect: connect completed\n"); +#endif + +EXITPOINT: + + if (theSocketStruct != nil) + { + theSocketStruct->mLastError = noErr; + + CopyCStrToCStr("",theSocketStruct->mErrMessage,sizeof(theSocketStruct->mErrMessage)); + + if (errCode != noErr) + { + theSocketStruct->mLastError = errCode; + + CopyCStrToCStr(GetErrorMessage(),theSocketStruct->mErrMessage,sizeof(theSocketStruct->mErrMessage)); + } + } + + errno = errCode; + + return(errCode); +} + + + + +// Close a connection + +OSErr MacSocket_close(const int inSocketNum) +{ +OSErr errCode = noErr; +SocketStruct *theSocketStruct = nil; + + + if (!SocketIndexIsValid(inSocketNum)) + { + SetErrorMessageAndBail("MacSocket_close: Invalid socket number specified"); + } + + + theSocketStruct = &(sSockets[inSocketNum]); + + if (theSocketStruct->mEndPointRef != kOTInvalidEndpointRef) + { + OTResult theOTResult = noErr; + + // Try to play nice + + if (theSocketStruct->mReceivedTOrdRel) + { + // Already did an OTRcvOrderlyDisconnect() in the notifier + + if (theSocketStruct->mLocalEndIsConnected) + { + theOTResult = ::OTSndOrderlyDisconnect(theSocketStruct->mEndPointRef); + + theSocketStruct->mLocalEndIsConnected = false; + } + } + + else if (theSocketStruct->mLocalEndIsConnected) + { + theOTResult = ::OTSndOrderlyDisconnect(theSocketStruct->mEndPointRef); + + theSocketStruct->mLocalEndIsConnected = false; + + // Wait for other end to hang up too! + +// PrepareForAsyncOperation(theSocketStruct,T_ORDREL); +// +// errCode = MyBusyWait(theSocketStruct,false,&theOTResult,&(theSocketStruct->mReceivedTOrdRel)); + } + + + if (theOTResult != noErr) + { + ::OTCloseProvider(theSocketStruct->mEndPointRef); + } + + else + { + theOTResult = ::OTCloseProvider(theSocketStruct->mEndPointRef); + } + + theSocketStruct->mEndPointRef = kOTInvalidEndpointRef; + + errCode = theOTResult; + } + + + theSocketStruct->mIsInUse = false; + + +EXITPOINT: + + if (theSocketStruct != nil) + { + theSocketStruct->mLastError = noErr; + + CopyCStrToCStr("",theSocketStruct->mErrMessage,sizeof(theSocketStruct->mErrMessage)); + + if (errCode != noErr) + { + theSocketStruct->mLastError = errCode; + + CopyCStrToCStr(GetErrorMessage(),theSocketStruct->mErrMessage,sizeof(theSocketStruct->mErrMessage)); + } + } + + errno = errCode; + + return(errCode); +} + + + + +// Receive some bytes + +int MacSocket_recv(const int inSocketNum,void *outBuff,int outBuffLength,const Boolean inBlock) +{ +OSErr errCode = noErr; +int totalBytesRead = 0; +SocketStruct *theSocketStruct = nil; + + + SetErrorMessageAndBailIfNil(outBuff,"MacSocket_recv: Bad parameter, outBuff = nil"); + + if (outBuffLength <= 0) + { + SetErrorMessageAndBail("MacSocket_recv: Bad parameter, outBuffLength <= 0"); + } + + if (!SocketIndexIsValid(inSocketNum)) + { + SetErrorMessageAndBail("MacSocket_recv: Invalid socket number specified"); + } + + theSocketStruct = &(sSockets[inSocketNum]); + + if (!theSocketStruct->mLocalEndIsConnected) + { + SetErrorMessageAndBail("MacSocket_recv: Socket not connected"); + } + + if (theSocketStruct->mReceivedTOrdRel) + { + totalBytesRead = 0; + + goto EXITPOINT; + } + + + PrepareForAsyncOperation(theSocketStruct,0); + + for (;;) + { + int bytesRead; + OTResult theOTResult; + + + theOTResult = ::OTRcv(theSocketStruct->mEndPointRef,(void *) ((unsigned long) outBuff + (unsigned long) totalBytesRead),outBuffLength - totalBytesRead,nil); + + if (theOTResult >= 0) + { + bytesRead = theOTResult; + +#ifdef MACSOCKET_DEBUG + printf("MacSocket_recv: read %d bytes in part\n",bytesRead); +#endif + } + + else if (theOTResult == kOTNoDataErr) + { + bytesRead = 0; + } + + else + { + SetErrorMessageAndLongIntAndBail("MacSocket_recv: Can't receive OT data, OTRcv() = ",theOTResult); + } + + + totalBytesRead += bytesRead; + + + if (totalBytesRead <= 0) + { + if (theSocketStruct->mReceivedTOrdRel) + { + break; + } + + // This seems pretty stupid to me now. Maybe I'll delete this blocking garbage. + + if (inBlock) + { + if (TimeoutElapsed(theSocketStruct)) + { + SetErrorCodeAndMessageAndBail(kMacSocket_TimeoutErr,"MacSocket_recv: Receive operation timed-out"); + } + + if (theSocketStruct->mIdleWaitCallback != nil) + { + theOTResult = (*(theSocketStruct->mIdleWaitCallback))(theSocketStruct->mUserRefPtr); + + SetErrorMessageAndBailIfError(theOTResult,"MacSocket_recv: User cancelled operation"); + } + + continue; + } + } + + + break; + } + + errCode = noErr; + + +#ifdef MACSOCKET_DEBUG + printf("MacSocket_recv: read %d bytes in total\n",totalBytesRead); +#endif + + +EXITPOINT: + + if (theSocketStruct != nil) + { + theSocketStruct->mLastError = noErr; + + CopyCStrToCStr("",theSocketStruct->mErrMessage,sizeof(theSocketStruct->mErrMessage)); + + if (errCode != noErr) + { + theSocketStruct->mLastError = errCode; + + CopyCStrToCStr(GetErrorMessage(),theSocketStruct->mErrMessage,sizeof(theSocketStruct->mErrMessage)); + } + } + + errno = errCode; + + return(totalBytesRead); +} + + + +// Send some bytes + +int MacSocket_send(const int inSocketNum,const void *inBuff,int inBuffLength) +{ +OSErr errCode = noErr; +int bytesSent = 0; +SocketStruct *theSocketStruct = nil; + + + SetErrorMessageAndBailIfNil(inBuff,"MacSocket_send: Bad parameter, inBuff = nil"); + + if (inBuffLength <= 0) + { + SetErrorMessageAndBail("MacSocket_send: Bad parameter, inBuffLength <= 0"); + } + + if (!SocketIndexIsValid(inSocketNum)) + { + SetErrorMessageAndBail("MacSocket_send: Invalid socket number specified"); + } + + + theSocketStruct = &(sSockets[inSocketNum]); + + if (!theSocketStruct->mLocalEndIsConnected) + { + SetErrorMessageAndBail("MacSocket_send: Socket not connected"); + } + + +OTResult theOTResult; + + + PrepareForAsyncOperation(theSocketStruct,0); + + while (bytesSent < inBuffLength) + { + if (theSocketStruct->mIdleWaitCallback != nil) + { + theOTResult = (*(theSocketStruct->mIdleWaitCallback))(theSocketStruct->mUserRefPtr); + + SetErrorMessageAndBailIfError(theOTResult,"MacSocket_send: User cancelled"); + } + + + theOTResult = ::OTSnd(theSocketStruct->mEndPointRef,(void *) ((unsigned long) inBuff + bytesSent),inBuffLength - bytesSent,0); + + if (theOTResult >= 0) + { + bytesSent += theOTResult; + + theOTResult = noErr; + + // Reset timer.... + + PrepareForAsyncOperation(theSocketStruct,0); + } + + if (theOTResult == kOTFlowErr) + { + if (TimeoutElapsed(theSocketStruct)) + { + SetErrorCodeAndMessageAndBail(kMacSocket_TimeoutErr,"MacSocket_send: Send timed-out") + } + + theOTResult = noErr; + } + + SetErrorMessageAndLongIntAndBailIfError(theOTResult,"MacSocket_send: Can't send OT data, OTSnd() = ",theOTResult); + } + + + errCode = noErr; + +#ifdef MACSOCKET_DEBUG + printf("MacSocket_send: sent %d bytes\n",bytesSent); +#endif + + +EXITPOINT: + + if (theSocketStruct != nil) + { + theSocketStruct->mLastError = noErr; + + CopyCStrToCStr("",theSocketStruct->mErrMessage,sizeof(theSocketStruct->mErrMessage)); + + if (errCode != noErr) + { + theSocketStruct->mLastError = errCode; + + CopyCStrToCStr(GetErrorMessage(),theSocketStruct->mErrMessage,sizeof(theSocketStruct->mErrMessage)); + } + } + + if (errCode != noErr) + { + ::SysBeep(1); + } + + errno = errCode; + + return(bytesSent); +} + + + + + +static OSStatus NegotiateIPReuseAddrOption(EndpointRef inEndpoint,const Boolean inEnableReuseIP) +{ +OSStatus errCode; +UInt8 buf[kOTFourByteOptionSize]; +TOption* theOTOption; +TOptMgmt theOTRequest; +TOptMgmt theOTResult; + + + if (!OTIsSynchronous(inEndpoint)) + { + SetErrorMessageAndBail("NegotiateIPReuseAddrOption: Open Transport endpoint is not synchronous"); + } + + theOTRequest.opt.buf = buf; + theOTRequest.opt.len = sizeof(buf); + theOTRequest.flags = T_NEGOTIATE; + + theOTResult.opt.buf = buf; + theOTResult.opt.maxlen = kOTFourByteOptionSize; + + + theOTOption = (TOption *) buf; + + theOTOption->level = INET_IP; + theOTOption->name = IP_REUSEADDR; + theOTOption->len = kOTFourByteOptionSize; + theOTOption->status = 0; + *((UInt32 *) (theOTOption->value)) = inEnableReuseIP; + + errCode = ::OTOptionManagement(inEndpoint,&theOTRequest,&theOTResult); + + if (errCode == kOTNoError) + { + if (theOTOption->status != T_SUCCESS) + { + errCode = theOTOption->status; + } + + else + { + errCode = kOTNoError; + } + } + + +EXITPOINT: + + errno = errCode; + + return(errCode); +} + + + + + +// Some rough notes.... + + + +// OTAckSends(ep); +// OTAckSends(ep) // enable AckSend option +// ...... +// buf = OTAllocMem( nbytes); // Allocate nbytes of memory from OT +// OTSnd(ep, buf, nbytes, 0); // send a packet +// ...... +// NotifyProc( .... void* theParam) // Notifier Proc +// case T_MEMORYRELEASED: // process event +// OTFreeMem( theParam); // free up memory +// break; + + + +/* +struct InetInterfaceInfo +{ + InetHost fAddress; + InetHost fNetmask; + InetHost fBroadcastAddr; + InetHost fDefaultGatewayAddr; + InetHost fDNSAddr; + UInt16 fVersion; + UInt16 fHWAddrLen; + UInt8* fHWAddr; + UInt32 fIfMTU; + UInt8* fReservedPtrs[2]; + InetDomainName fDomainName; + UInt32 fIPSecondaryCount; + UInt8 fReserved[252]; +}; +typedef struct InetInterfaceInfo InetInterfaceInfo; + + + +((InetAddress *) addr.buf)->fHost + +struct TBind +{ + TNetbuf addr; + OTQLen qlen; +}; + +typedef struct TBind TBind; + +struct TNetbuf +{ + size_t maxlen; + size_t len; + UInt8* buf; +}; + +typedef struct TNetbuf TNetbuf; + + + struct InetAddress +{ + OTAddressType fAddressType; // always AF_INET + InetPort fPort; // Port number + InetHost fHost; // Host address in net byte order + UInt8 fUnused[8]; // Traditional unused bytes +}; +typedef struct InetAddress InetAddress; +*/ + + + +/* +static pascal void Notifier(void* context, OTEventCode event, OTResult result, void* cookie) +{ +EPInfo* epi = (EPInfo*) context; + + switch (event) + { + case T_LISTEN: + { + DoListenAccept(); + return; + } + + case T_ACCEPTCOMPLETE: + { + if (result != kOTNoError) + DBAlert1("Notifier: T_ACCEPTCOMPLETE - result %d",result); + return; + } + + case T_PASSCON: + { + if (result != kOTNoError) + { + DBAlert1("Notifier: T_PASSCON result %d", result); + return; + } + + OTAtomicAdd32(1, &gCntrConnections); + OTAtomicAdd32(1, &gCntrTotalConnections); + OTAtomicAdd32(1, &gCntrIntervalConnects); + + if ( OTAtomicSetBit(&epi->stateFlags, kPassconBit) != 0 ) + { + ReadData(epi); + } + + return; + } + + case T_DATA: + { + if ( OTAtomicSetBit(&epi->stateFlags, kPassconBit) != 0 ) + { + ReadData(epi); + } + + return; + } + + case T_GODATA: + { + SendData(epi); + return; + } + + case T_DISCONNECT: + { + DoRcvDisconnect(epi); + return; + } + + case T_DISCONNECTCOMPLETE: + { + if (result != kOTNoError) + DBAlert1("Notifier: T_DISCONNECT_COMPLETE result %d",result); + + return; + } + + case T_MEMORYRELEASED: + { + OTAtomicAdd32(-1, &epi->outstandingSends); + return; + } + + default: + { + DBAlert1("Notifier: unknown event <%x>", event); + return; + } + } +} +*/ -- cgit v1.2.3