Logo Search packages:      
Sourcecode: openssl version File versions

MacSocket.cpp

/*
 *    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 <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;
            }
      }
}
*/

Generated by  Doxygen 1.6.0   Back to index