mirror of https://github.com/openssl/openssl.git
1608 lines
37 KiB
C++
1608 lines
37 KiB
C++
/*
|
|
* 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;
|
|
}
|
|
}
|
|
}
|
|
*/
|