MacSocket.cpp

Go to the documentation of this file.

/*
 *  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 ([email protected])
 *
 */


/* ====================================================================
 * 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
 *    [email protected].
 *
 * 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
 * ([email protected]).  This product includes software written by Tim
 * Hudson ([email protected]).
 *
 */
 




#include "MacSocket.h"

#include <Threads.h>

#include <OpenTransport.h>
#include <OpenTpTInternet.h>
#include <OpenTptClient.h>



#include "CPStringUtils.hpp"
#include "ErrorHandling.hpp"


//  #define MACSOCKET_DEBUG     1

#ifdef MACSOCKET_DEBUG
    #include <stdio.h>
#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;
        }
    }
}
*/