diff options
author | William Joye <wjoye@cfa.harvard.edu> | 2017-05-02 16:41:35 (GMT) |
---|---|---|
committer | William Joye <wjoye@cfa.harvard.edu> | 2017-05-02 16:41:35 (GMT) |
commit | 3d328008deedc58cd7a11c79063cefa7d662d4fc (patch) | |
tree | cb41a048885ce7b493f406360cf5f6edf689c468 /openssl/MacOS/GetHTTPS.src | |
parent | 0a2b8b8e0bc2e91a9f10659b30e2e4f5b79ce692 (diff) | |
download | blt-3d328008deedc58cd7a11c79063cefa7d662d4fc.zip blt-3d328008deedc58cd7a11c79063cefa7d662d4fc.tar.gz blt-3d328008deedc58cd7a11c79063cefa7d662d4fc.tar.bz2 |
inital commit
Diffstat (limited to 'openssl/MacOS/GetHTTPS.src')
-rw-r--r-- | openssl/MacOS/GetHTTPS.src/CPStringUtils.cpp | 2753 | ||||
-rw-r--r-- | openssl/MacOS/GetHTTPS.src/CPStringUtils.hpp | 104 | ||||
-rw-r--r-- | openssl/MacOS/GetHTTPS.src/ErrorHandling.cpp | 170 | ||||
-rw-r--r-- | openssl/MacOS/GetHTTPS.src/ErrorHandling.hpp | 147 | ||||
-rw-r--r-- | openssl/MacOS/GetHTTPS.src/GetHTTPS.cpp | 209 | ||||
-rw-r--r-- | openssl/MacOS/GetHTTPS.src/MacSocket.cpp | 1607 | ||||
-rw-r--r-- | openssl/MacOS/GetHTTPS.src/MacSocket.h | 104 |
7 files changed, 5094 insertions, 0 deletions
diff --git a/openssl/MacOS/GetHTTPS.src/CPStringUtils.cpp b/openssl/MacOS/GetHTTPS.src/CPStringUtils.cpp new file mode 100644 index 0000000..617aae2 --- /dev/null +++ b/openssl/MacOS/GetHTTPS.src/CPStringUtils.cpp @@ -0,0 +1,2753 @@ +/* ==================================================================== + * 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 "CPStringUtils.hpp" +#include "ErrorHandling.hpp" + + + +#define kNumberFormatString "\p########0.00#######;-########0.00#######" + + + +// Useful utility functions which could be optimized a whole lot + + +void CopyPStrToCStr(const unsigned char *thePStr,char *theCStr,const int maxCStrLength) +{ +int i,numPChars; + + + if (thePStr != nil && theCStr != nil && maxCStrLength > 0) + { + numPChars = thePStr[0]; + + for (i = 0;;i++) + { + if (i >= numPChars || i >= maxCStrLength - 1) + { + theCStr[i] = 0; + + break; + } + + else + { + theCStr[i] = thePStr[i + 1]; + } + } + } +} + + +void CopyPStrToPStr(const unsigned char *theSrcPStr,unsigned char *theDstPStr,const int maxDstStrLength) +{ +int theMaxDstStrLength; + + + theMaxDstStrLength = maxDstStrLength; + + + if (theDstPStr != nil && theSrcPStr != nil && theMaxDstStrLength > 0) + { + if (theMaxDstStrLength > 255) + { + theMaxDstStrLength = 255; + } + + + if (theMaxDstStrLength - 1 < theSrcPStr[0]) + { + BlockMove(theSrcPStr + 1,theDstPStr + 1,theMaxDstStrLength - 1); + + theDstPStr[0] = theMaxDstStrLength - 1; + } + + else + { + BlockMove(theSrcPStr,theDstPStr,theSrcPStr[0] + 1); + } + } +} + + +void CopyCStrToCStr(const char *theSrcCStr,char *theDstCStr,const int maxDstStrLength) +{ +int i; + + + if (theDstCStr != nil && theSrcCStr != nil && maxDstStrLength > 0) + { + for (i = 0;;i++) + { + if (theSrcCStr[i] == 0 || i >= maxDstStrLength - 1) + { + theDstCStr[i] = 0; + + break; + } + + else + { + theDstCStr[i] = theSrcCStr[i]; + } + } + } +} + + + +void CopyCSubstrToCStr(const char *theSrcCStr,const int maxCharsToCopy,char *theDstCStr,const int maxDstStrLength) +{ +int i; + + + if (theDstCStr != nil && theSrcCStr != nil && maxDstStrLength > 0) + { + for (i = 0;;i++) + { + if (theSrcCStr[i] == 0 || i >= maxDstStrLength - 1 || i >= maxCharsToCopy) + { + theDstCStr[i] = 0; + + break; + } + + else + { + theDstCStr[i] = theSrcCStr[i]; + } + } + } +} + + + +void CopyCSubstrToPStr(const char *theSrcCStr,const int maxCharsToCopy,unsigned char *theDstPStr,const int maxDstStrLength) +{ +int i; +int theMaxDstStrLength; + + + theMaxDstStrLength = maxDstStrLength; + + if (theDstPStr != nil && theSrcCStr != nil && theMaxDstStrLength > 0) + { + if (theMaxDstStrLength > 255) + { + theMaxDstStrLength = 255; + } + + + for (i = 0;;i++) + { + if (theSrcCStr[i] == 0 || i >= theMaxDstStrLength - 1 || i >= maxCharsToCopy) + { + theDstPStr[0] = i; + + break; + } + + else + { + theDstPStr[i + 1] = theSrcCStr[i]; + } + } + } +} + + + +void CopyCStrToPStr(const char *theSrcCStr,unsigned char *theDstPStr,const int maxDstStrLength) +{ +int i; +int theMaxDstStrLength; + + + theMaxDstStrLength = maxDstStrLength; + + if (theDstPStr != nil && theSrcCStr != nil && theMaxDstStrLength > 0) + { + if (theMaxDstStrLength > 255) + { + theMaxDstStrLength = 255; + } + + + for (i = 0;;i++) + { + if (i >= theMaxDstStrLength - 1 || theSrcCStr[i] == 0) + { + theDstPStr[0] = i; + + break; + } + + else + { + theDstPStr[i + 1] = theSrcCStr[i]; + } + } + } +} + + +void ConcatPStrToCStr(const unsigned char *thePStr,char *theCStr,const int maxCStrLength) +{ +int i,numPChars,cStrLength; + + + if (thePStr != nil && theCStr != nil && maxCStrLength > 0) + { + for (cStrLength = 0;theCStr[cStrLength] != 0;cStrLength++) + { + + } + + + numPChars = thePStr[0]; + + + for (i = 0;;i++) + { + if (i >= numPChars || cStrLength >= maxCStrLength - 1) + { + theCStr[cStrLength++] = 0; + + break; + } + + else + { + theCStr[cStrLength++] = thePStr[i + 1]; + } + } + } +} + + + +void ConcatPStrToPStr(const unsigned char *theSrcPStr,unsigned char *theDstPStr,const int maxDstStrLength) +{ +int theMaxDstStrLength; + + + theMaxDstStrLength = maxDstStrLength; + + if (theSrcPStr != nil && theDstPStr != nil && theMaxDstStrLength > 0) + { + if (theMaxDstStrLength > 255) + { + theMaxDstStrLength = 255; + } + + + if (theMaxDstStrLength - theDstPStr[0] - 1 < theSrcPStr[0]) + { + BlockMove(theSrcPStr + 1,theDstPStr + theDstPStr[0] + 1,theMaxDstStrLength - 1 - theDstPStr[0]); + + theDstPStr[0] = theMaxDstStrLength - 1; + } + + else + { + BlockMove(theSrcPStr + 1,theDstPStr + theDstPStr[0] + 1,theSrcPStr[0]); + + theDstPStr[0] += theSrcPStr[0]; + } + } +} + + + +void ConcatCStrToPStr(const char *theSrcCStr,unsigned char *theDstPStr,const int maxDstStrLength) +{ +int i,thePStrLength; +int theMaxDstStrLength; + + + theMaxDstStrLength = maxDstStrLength; + + if (theSrcCStr != nil && theDstPStr != nil && theMaxDstStrLength > 0) + { + if (theMaxDstStrLength > 255) + { + theMaxDstStrLength = 255; + } + + + thePStrLength = theDstPStr[0]; + + for (i = 0;;i++) + { + if (theSrcCStr[i] == 0 || thePStrLength >= theMaxDstStrLength - 1) + { + theDstPStr[0] = thePStrLength; + + break; + } + + else + { + theDstPStr[thePStrLength + 1] = theSrcCStr[i]; + + thePStrLength++; + } + } + } +} + + + +void ConcatCStrToCStr(const char *theSrcCStr,char *theDstCStr,const int maxCStrLength) +{ +int cStrLength; + + + if (theSrcCStr != nil && theDstCStr != nil && maxCStrLength > 0) + { + for (cStrLength = 0;theDstCStr[cStrLength] != 0;cStrLength++) + { + + } + + + for (;;) + { + if (*theSrcCStr == 0 || cStrLength >= maxCStrLength - 1) + { + theDstCStr[cStrLength++] = 0; + + break; + } + + else + { + theDstCStr[cStrLength++] = *theSrcCStr++; + } + } + } +} + + + +void ConcatCharToCStr(const char theChar,char *theDstCStr,const int maxCStrLength) +{ +int cStrLength; + + + if (theDstCStr != nil && maxCStrLength > 0) + { + cStrLength = CStrLength(theDstCStr); + + if (cStrLength < maxCStrLength - 1) + { + theDstCStr[cStrLength++] = theChar; + theDstCStr[cStrLength++] = '\0'; + } + } +} + + + +void ConcatCharToPStr(const char theChar,unsigned char *theDstPStr,const int maxPStrLength) +{ +int pStrLength; + + + if (theDstPStr != nil && maxPStrLength > 0) + { + pStrLength = PStrLength(theDstPStr); + + if (pStrLength < maxPStrLength - 1 && pStrLength < 255) + { + theDstPStr[pStrLength + 1] = theChar; + theDstPStr[0] += 1; + } + } +} + + + + +int CompareCStrs(const char *theFirstCStr,const char *theSecondCStr,const Boolean ignoreCase) +{ +int returnValue; +char firstChar,secondChar; + + + returnValue = 0; + + + if (theFirstCStr != nil && theSecondCStr != nil) + { + for (;;) + { + firstChar = *theFirstCStr; + secondChar = *theSecondCStr; + + if (ignoreCase == true) + { + if (firstChar >= 'A' && firstChar <= 'Z') + { + firstChar = 'a' + (firstChar - 'A'); + } + + if (secondChar >= 'A' && secondChar <= 'Z') + { + secondChar = 'a' + (secondChar - 'A'); + } + } + + + if (firstChar == 0 && secondChar != 0) + { + returnValue = -1; + + break; + } + + else if (firstChar != 0 && secondChar == 0) + { + returnValue = 1; + + break; + } + + else if (firstChar == 0 && secondChar == 0) + { + returnValue = 0; + + break; + } + + else if (firstChar < secondChar) + { + returnValue = -1; + + break; + } + + else if (firstChar > secondChar) + { + returnValue = 1; + + break; + } + + theFirstCStr++; + theSecondCStr++; + } + } + + + return(returnValue); +} + + + +Boolean CStrsAreEqual(const char *theFirstCStr,const char *theSecondCStr,const Boolean ignoreCase) +{ + if (CompareCStrs(theFirstCStr,theSecondCStr,ignoreCase) == 0) + { + return true; + } + + else + { + return false; + } +} + + +Boolean PStrsAreEqual(const unsigned char *theFirstPStr,const unsigned char *theSecondPStr,const Boolean ignoreCase) +{ + if (ComparePStrs(theFirstPStr,theSecondPStr,ignoreCase) == 0) + { + return true; + } + + else + { + return false; + } +} + + + +int ComparePStrs(const unsigned char *theFirstPStr,const unsigned char *theSecondPStr,const Boolean ignoreCase) +{ +int i,returnValue; +char firstChar,secondChar; + + + returnValue = 0; + + + if (theFirstPStr != nil && theSecondPStr != nil) + { + for (i = 1;;i++) + { + firstChar = theFirstPStr[i]; + secondChar = theSecondPStr[i]; + + if (ignoreCase == true) + { + if (firstChar >= 'A' && firstChar <= 'Z') + { + firstChar = 'a' + (firstChar - 'A'); + } + + if (secondChar >= 'A' && secondChar <= 'Z') + { + secondChar = 'a' + (secondChar - 'A'); + } + } + + + if (theFirstPStr[0] < i && theSecondPStr[0] >= i) + { + returnValue = -1; + + break; + } + + else if (theFirstPStr[0] >= i && theSecondPStr[0] < i) + { + returnValue = 1; + + break; + } + + else if (theFirstPStr[0] < i && theSecondPStr[0] < i) + { + returnValue = 0; + + break; + } + + else if (firstChar < secondChar) + { + returnValue = -1; + + break; + } + + else if (firstChar > secondChar) + { + returnValue = 1; + + break; + } + } + } + + + return(returnValue); +} + + + +int CompareCStrToPStr(const char *theCStr,const unsigned char *thePStr,const Boolean ignoreCase) +{ +int returnValue; +char tempString[256]; + + + returnValue = 0; + + if (theCStr != nil && thePStr != nil) + { + CopyPStrToCStr(thePStr,tempString,sizeof(tempString)); + + returnValue = CompareCStrs(theCStr,tempString,ignoreCase); + } + + + return(returnValue); +} + + + +void ConcatLongIntToCStr(const long theNum,char *theCStr,const int maxCStrLength,const int numDigits) +{ +Str255 theStr255; + + + NumToString(theNum,theStr255); + + + if (numDigits > 0) + { + int charsToInsert; + + + charsToInsert = numDigits - PStrLength(theStr255); + + if (charsToInsert > 0) + { + char tempString[256]; + + CopyCStrToCStr("",tempString,sizeof(tempString)); + + for (;charsToInsert > 0;charsToInsert--) + { + ConcatCStrToCStr("0",tempString,sizeof(tempString)); + } + + ConcatPStrToCStr(theStr255,tempString,sizeof(tempString)); + + CopyCStrToPStr(tempString,theStr255,sizeof(theStr255)); + } + } + + + ConcatPStrToCStr(theStr255,theCStr,maxCStrLength); +} + + + + +void ConcatLongIntToPStr(const long theNum,unsigned char *thePStr,const int maxPStrLength,const int numDigits) +{ +Str255 theStr255; + + + NumToString(theNum,theStr255); + + + if (numDigits > 0) + { + int charsToInsert; + + + charsToInsert = numDigits - PStrLength(theStr255); + + if (charsToInsert > 0) + { + char tempString[256]; + + CopyCStrToCStr("",tempString,sizeof(tempString)); + + for (;charsToInsert > 0;charsToInsert--) + { + ConcatCStrToCStr("0",tempString,sizeof(tempString)); + } + + ConcatPStrToCStr(theStr255,tempString,sizeof(tempString)); + + CopyCStrToPStr(tempString,theStr255,sizeof(theStr255)); + } + } + + + ConcatPStrToPStr(theStr255,thePStr,maxPStrLength); +} + + + +void CopyCStrAndConcatLongIntToCStr(const char *theSrcCStr,const long theNum,char *theDstCStr,const int maxDstStrLength) +{ + CopyCStrToCStr(theSrcCStr,theDstCStr,maxDstStrLength); + + ConcatLongIntToCStr(theNum,theDstCStr,maxDstStrLength); +} + + + +void CopyLongIntToCStr(const long theNum,char *theCStr,const int maxCStrLength,const int numDigits) +{ +Str255 theStr255; + + + NumToString(theNum,theStr255); + + + if (numDigits > 0) + { + int charsToInsert; + + + charsToInsert = numDigits - PStrLength(theStr255); + + if (charsToInsert > 0) + { + char tempString[256]; + + CopyCStrToCStr("",tempString,sizeof(tempString)); + + for (;charsToInsert > 0;charsToInsert--) + { + ConcatCStrToCStr("0",tempString,sizeof(tempString)); + } + + ConcatPStrToCStr(theStr255,tempString,sizeof(tempString)); + + CopyCStrToPStr(tempString,theStr255,sizeof(theStr255)); + } + } + + + CopyPStrToCStr(theStr255,theCStr,maxCStrLength); +} + + + + + +void CopyUnsignedLongIntToCStr(const unsigned long theNum,char *theCStr,const int maxCStrLength) +{ +char tempString[256]; +int srcCharIndex,dstCharIndex; +unsigned long tempNum,quotient,remainder; + + + if (theNum == 0) + { + CopyCStrToCStr("0",theCStr,maxCStrLength); + } + + else + { + srcCharIndex = 0; + + tempNum = theNum; + + for (;;) + { + if (srcCharIndex >= sizeof(tempString) - 1 || tempNum == 0) + { + for (dstCharIndex = 0;;) + { + if (dstCharIndex >= maxCStrLength - 1 || srcCharIndex <= 0) + { + theCStr[dstCharIndex] = 0; + + break; + } + + theCStr[dstCharIndex++] = tempString[--srcCharIndex]; + } + + break; + } + + + quotient = tempNum / 10; + + remainder = tempNum - (quotient * 10); + + tempString[srcCharIndex] = '0' + remainder; + + srcCharIndex++; + + tempNum = quotient; + } + } +} + + + + +void CopyLongIntToPStr(const long theNum,unsigned char *thePStr,const int maxPStrLength,const int numDigits) +{ +char tempString[256]; + + + CopyLongIntToCStr(theNum,tempString,sizeof(tempString),numDigits); + + CopyCStrToPStr(tempString,thePStr,maxPStrLength); +} + + + +OSErr CopyLongIntToNewHandle(const long inTheLongInt,Handle *theHandle) +{ +OSErr errCode = noErr; +char tempString[32]; + + + CopyLongIntToCStr(inTheLongInt,tempString,sizeof(tempString)); + + errCode = CopyCStrToNewHandle(tempString,theHandle); + + return(errCode); +} + + +OSErr CopyLongIntToExistingHandle(const long inTheLongInt,Handle theHandle) +{ +OSErr errCode = noErr; +char tempString[32]; + + + CopyLongIntToCStr(inTheLongInt,tempString,sizeof(tempString)); + + errCode = CopyCStrToExistingHandle(tempString,theHandle); + + return(errCode); +} + + + + +OSErr CopyCStrToExistingHandle(const char *theCString,Handle theHandle) +{ +OSErr errCode = noErr; +long stringLength; + + + if (theCString == nil) + { + SetErrorMessageAndBail(("CopyCStrToExistingHandle: Bad parameter, theCString == nil")); + } + + if (theHandle == nil) + { + SetErrorMessageAndBail(("CopyCStrToExistingHandle: Bad parameter, theHandle == nil")); + } + + if (*theHandle == nil) + { + SetErrorMessageAndBail(("CopyCStrToExistingHandle: Bad parameter, *theHandle == nil")); + } + + + + stringLength = CStrLength(theCString) + 1; + + SetHandleSize(theHandle,stringLength); + + if (GetHandleSize(theHandle) < stringLength) + { + SetErrorMessageAndLongIntAndBail("CopyCStrToExistingHandle: Can't set Handle size, MemError() = ",MemError()); + } + + + ::BlockMove(theCString,*theHandle,stringLength); + + +EXITPOINT: + + return(errCode); +} + + + + + +OSErr CopyCStrToNewHandle(const char *theCString,Handle *theHandle) +{ +OSErr errCode = noErr; +long stringLength; + + + if (theCString == nil) + { + SetErrorMessageAndBail(("CopyCStrToNewHandle: Bad parameter, theCString == nil")); + } + + if (theHandle == nil) + { + SetErrorMessageAndBail(("CopyCStrToNewHandle: Bad parameter, theHandle == nil")); + } + + + + stringLength = CStrLength(theCString) + 1; + + *theHandle = NewHandle(stringLength); + + if (*theHandle == nil) + { + SetErrorMessageAndLongIntAndBail("CopyCStrToNewHandle: Can't allocate Handle, MemError() = ",MemError()); + } + + + ::BlockMove(theCString,**theHandle,stringLength); + + +EXITPOINT: + + return(errCode); +} + + + +OSErr CopyPStrToNewHandle(const unsigned char *thePString,Handle *theHandle) +{ +OSErr errCode = noErr; +long stringLength; + + + if (thePString == nil) + { + SetErrorMessageAndBail(("CopyPStrToNewHandle: Bad parameter, thePString == nil")); + } + + if (theHandle == nil) + { + SetErrorMessageAndBail(("CopyPStrToNewHandle: Bad parameter, theHandle == nil")); + } + + + + stringLength = PStrLength(thePString) + 1; + + *theHandle = NewHandle(stringLength); + + if (*theHandle == nil) + { + SetErrorMessageAndLongIntAndBail("CopyPStrToNewHandle: Can't allocate Handle, MemError() = ",MemError()); + } + + + if (stringLength > 1) + { + BlockMove(thePString + 1,**theHandle,stringLength - 1); + } + + (**theHandle)[stringLength - 1] = 0; + + +EXITPOINT: + + return(errCode); +} + + +OSErr AppendPStrToHandle(const unsigned char *thePString,Handle theHandle,long *currentLength) +{ +OSErr errCode = noErr; +char tempString[256]; + + + CopyPStrToCStr(thePString,tempString,sizeof(tempString)); + + errCode = AppendCStrToHandle(tempString,theHandle,currentLength); + + +EXITPOINT: + + return(errCode); +} + + + +OSErr AppendCStrToHandle(const char *theCString,Handle theHandle,long *currentLength,long *maxLength) +{ +OSErr errCode = noErr; +long handleMaxLength,handleCurrentLength,stringLength,byteCount; + + + if (theCString == nil) + { + SetErrorMessageAndBail(("AppendCStrToHandle: Bad parameter, theCString == nil")); + } + + if (theHandle == nil) + { + SetErrorMessageAndBail(("AppendCStrToHandle: Bad parameter, theHandle == nil")); + } + + + if (maxLength != nil) + { + handleMaxLength = *maxLength; + } + + else + { + handleMaxLength = GetHandleSize(theHandle); + } + + + if (currentLength != nil && *currentLength >= 0) + { + handleCurrentLength = *currentLength; + } + + else + { + handleCurrentLength = CStrLength(*theHandle); + } + + + stringLength = CStrLength(theCString); + + byteCount = handleCurrentLength + stringLength + 1; + + if (byteCount > handleMaxLength) + { + SetHandleSize(theHandle,handleCurrentLength + stringLength + 1); + + if (maxLength != nil) + { + *maxLength = GetHandleSize(theHandle); + + handleMaxLength = *maxLength; + } + + else + { + handleMaxLength = GetHandleSize(theHandle); + } + + if (byteCount > handleMaxLength) + { + SetErrorMessageAndLongIntAndBail("AppendCStrToHandle: Can't increase Handle allocation, MemError() = ",MemError()); + } + } + + + BlockMove(theCString,*theHandle + handleCurrentLength,stringLength + 1); + + + if (currentLength != nil) + { + *currentLength += stringLength; + } + + + errCode = noErr; + + +EXITPOINT: + + return(errCode); +} + + + +OSErr AppendCharsToHandle(const char *theChars,const int numChars,Handle theHandle,long *currentLength,long *maxLength) +{ +OSErr errCode = noErr; +long handleMaxLength,handleCurrentLength,byteCount; + + + if (theChars == nil) + { + SetErrorMessageAndBail(("AppendCharsToHandle: Bad parameter, theChars == nil")); + } + + if (theHandle == nil) + { + SetErrorMessageAndBail(("AppendCharsToHandle: Bad parameter, theHandle == nil")); + } + + + if (maxLength != nil) + { + handleMaxLength = *maxLength; + } + + else + { + handleMaxLength = GetHandleSize(theHandle); + } + + + if (currentLength != nil && *currentLength >= 0) + { + handleCurrentLength = *currentLength; + } + + else + { + handleCurrentLength = CStrLength(*theHandle); + } + + + byteCount = handleCurrentLength + numChars + 1; + + if (byteCount > handleMaxLength) + { + SetHandleSize(theHandle,handleCurrentLength + numChars + 1); + + if (maxLength != nil) + { + *maxLength = GetHandleSize(theHandle); + + handleMaxLength = *maxLength; + } + + else + { + handleMaxLength = GetHandleSize(theHandle); + } + + if (byteCount > handleMaxLength) + { + SetErrorMessageAndLongIntAndBail("AppendCharsToHandle: Can't increase Handle allocation, MemError() = ",MemError()); + } + } + + + BlockMove(theChars,*theHandle + handleCurrentLength,numChars); + + (*theHandle)[handleCurrentLength + numChars] = '\0'; + + if (currentLength != nil) + { + *currentLength += numChars; + } + + + errCode = noErr; + + +EXITPOINT: + + return(errCode); +} + + + +OSErr AppendLongIntToHandle(const long inTheLongInt,Handle theHandle,long *currentLength) +{ +OSErr errCode = noErr; +char tempString[32]; + + + CopyLongIntToCStr(inTheLongInt,tempString,sizeof(tempString)); + + errCode = AppendCStrToHandle(tempString,theHandle,currentLength); + + return(errCode); +} + + + + +long CStrLength(const char *theCString) +{ +long cStrLength = 0; + + + if (theCString != nil) + { + for (cStrLength = 0;theCString[cStrLength] != 0;cStrLength++) + { + + } + } + + + return(cStrLength); +} + + + +long PStrLength(const unsigned char *thePString) +{ +long pStrLength = 0; + + + if (thePString != nil) + { + pStrLength = thePString[0]; + } + + + return(pStrLength); +} + + + + + +void ZeroMem(void *theMemPtr,const unsigned long numBytes) +{ +unsigned char *theBytePtr; +unsigned long *theLongPtr; +unsigned long numSingleBytes; +unsigned long theNumBytes; + + + theNumBytes = numBytes; + + if (theMemPtr != nil && theNumBytes > 0) + { + theBytePtr = (unsigned char *) theMemPtr; + + numSingleBytes = (unsigned long) theBytePtr & 0x0003; + + while (numSingleBytes > 0) + { + *theBytePtr++ = 0; + + theNumBytes--; + numSingleBytes--; + } + + + theLongPtr = (unsigned long *) theBytePtr; + + while (theNumBytes >= 4) + { + *theLongPtr++ = 0; + + theNumBytes -= 4; + } + + + theBytePtr = (unsigned char *) theLongPtr; + + while (theNumBytes > 0) + { + *theBytePtr++ = 0; + + theNumBytes--; + } + } +} + + + + +char *FindCharInCStr(const char theChar,const char *theCString) +{ +char *theStringSearchPtr; + + + theStringSearchPtr = (char *) theCString; + + if (theStringSearchPtr != nil) + { + while (*theStringSearchPtr != '\0' && *theStringSearchPtr != theChar) + { + theStringSearchPtr++; + } + + if (*theStringSearchPtr == '\0') + { + theStringSearchPtr = nil; + } + } + + return(theStringSearchPtr); +} + + + +long FindCharOffsetInCStr(const char theChar,const char *theCString,const Boolean inIgnoreCase) +{ +long theOffset = -1; + + + if (theCString != nil) + { + theOffset = 0; + + + if (inIgnoreCase) + { + char searchChar = theChar; + + if (searchChar >= 'a' && searchChar <= 'z') + { + searchChar = searchChar - 'a' + 'A'; + } + + + while (*theCString != 0) + { + char currentChar = *theCString; + + if (currentChar >= 'a' && currentChar <= 'z') + { + currentChar = currentChar - 'a' + 'A'; + } + + if (currentChar == searchChar) + { + break; + } + + theCString++; + theOffset++; + } + } + + else + { + while (*theCString != 0 && *theCString != theChar) + { + theCString++; + theOffset++; + } + } + + if (*theCString == 0) + { + theOffset = -1; + } + } + + return(theOffset); +} + + +long FindCStrOffsetInCStr(const char *theCSubstring,const char *theCString,const Boolean inIgnoreCase) +{ +long theOffset = -1; + + + if (theCSubstring != nil && theCString != nil) + { + for (theOffset = 0;;theOffset++) + { + if (theCString[theOffset] == 0) + { + theOffset = -1; + + goto EXITPOINT; + } + + + for (const char *tempSubstringPtr = theCSubstring,*tempCStringPtr = theCString + theOffset;;tempSubstringPtr++,tempCStringPtr++) + { + if (*tempSubstringPtr == 0) + { + goto EXITPOINT; + } + + else if (*tempCStringPtr == 0) + { + break; + } + + char searchChar = *tempSubstringPtr; + char currentChar = *tempCStringPtr; + + if (inIgnoreCase && searchChar >= 'a' && searchChar <= 'z') + { + searchChar = searchChar - 'a' + 'A'; + } + + if (inIgnoreCase && currentChar >= 'a' && currentChar <= 'z') + { + currentChar = currentChar - 'a' + 'A'; + } + + if (currentChar != searchChar) + { + break; + } + } + } + + theOffset = -1; + } + + +EXITPOINT: + + return(theOffset); +} + + + +void InsertCStrIntoCStr(const char *theSrcCStr,const int theInsertionOffset,char *theDstCStr,const int maxDstStrLength) +{ +int currentLength; +int insertLength; +int numCharsToInsert; +int numCharsToShift; + + + if (theDstCStr != nil && theSrcCStr != nil && maxDstStrLength > 0 && theInsertionOffset < maxDstStrLength - 1) + { + currentLength = CStrLength(theDstCStr); + + insertLength = CStrLength(theSrcCStr); + + + if (theInsertionOffset + insertLength < maxDstStrLength - 1) + { + numCharsToInsert = insertLength; + } + + else + { + numCharsToInsert = maxDstStrLength - 1 - theInsertionOffset; + } + + + if (numCharsToInsert + currentLength < maxDstStrLength - 1) + { + numCharsToShift = currentLength - theInsertionOffset; + } + + else + { + numCharsToShift = maxDstStrLength - 1 - theInsertionOffset - numCharsToInsert; + } + + + if (numCharsToShift > 0) + { + BlockMove(theDstCStr + theInsertionOffset,theDstCStr + theInsertionOffset + numCharsToInsert,numCharsToShift); + } + + if (numCharsToInsert > 0) + { + BlockMove(theSrcCStr,theDstCStr + theInsertionOffset,numCharsToInsert); + } + + theDstCStr[theInsertionOffset + numCharsToInsert + numCharsToShift] = 0; + } +} + + + +void InsertPStrIntoCStr(const unsigned char *theSrcPStr,const int theInsertionOffset,char *theDstCStr,const int maxDstStrLength) +{ +int currentLength; +int insertLength; +int numCharsToInsert; +int numCharsToShift; + + + if (theDstCStr != nil && theSrcPStr != nil && maxDstStrLength > 0 && theInsertionOffset < maxDstStrLength - 1) + { + currentLength = CStrLength(theDstCStr); + + insertLength = PStrLength(theSrcPStr); + + + if (theInsertionOffset + insertLength < maxDstStrLength - 1) + { + numCharsToInsert = insertLength; + } + + else + { + numCharsToInsert = maxDstStrLength - 1 - theInsertionOffset; + } + + + if (numCharsToInsert + currentLength < maxDstStrLength - 1) + { + numCharsToShift = currentLength - theInsertionOffset; + } + + else + { + numCharsToShift = maxDstStrLength - 1 - theInsertionOffset - numCharsToInsert; + } + + + if (numCharsToShift > 0) + { + BlockMove(theDstCStr + theInsertionOffset,theDstCStr + theInsertionOffset + numCharsToInsert,numCharsToShift); + } + + if (numCharsToInsert > 0) + { + BlockMove(theSrcPStr + 1,theDstCStr + theInsertionOffset,numCharsToInsert); + } + + theDstCStr[theInsertionOffset + numCharsToInsert + numCharsToShift] = 0; + } +} + + + +OSErr InsertCStrIntoHandle(const char *theCString,Handle theHandle,const long inInsertOffset) +{ +OSErr errCode; +int currentLength; +int insertLength; + + + SetErrorMessageAndBailIfNil(theCString,"InsertCStrIntoHandle: Bad parameter, theCString == nil"); + + SetErrorMessageAndBailIfNil(theHandle,"InsertCStrIntoHandle: Bad parameter, theHandle == nil"); + + currentLength = CStrLength(*theHandle); + + if (currentLength + 1 > ::GetHandleSize(theHandle)) + { + SetErrorMessageAndBail("InsertCStrIntoHandle: Handle has been overflowed"); + } + + if (inInsertOffset > currentLength) + { + SetErrorMessageAndBail("InsertCStrIntoHandle: Insertion offset is greater than string length"); + } + + insertLength = CStrLength(theCString); + + ::SetHandleSize(theHandle,currentLength + 1 + insertLength); + + if (::GetHandleSize(theHandle) < currentLength + 1 + insertLength) + { + SetErrorMessageAndLongIntAndBail("InsertCStrIntoHandle: Can't expand storage for Handle, MemError() = ",MemError()); + } + + ::BlockMove(*theHandle + inInsertOffset,*theHandle + inInsertOffset + insertLength,currentLength - inInsertOffset + 1); + + ::BlockMove(theCString,*theHandle + inInsertOffset,insertLength); + + + errCode = noErr; + + +EXITPOINT: + + return(errCode); +} + + + + +void CopyCStrAndInsert1LongIntIntoCStr(const char *theSrcCStr,const long theNum,char *theDstCStr,const int maxDstStrLength) +{ + CopyCStrAndInsertCStrLongIntIntoCStr(theSrcCStr,nil,theNum,theDstCStr,maxDstStrLength); +} + + +void CopyCStrAndInsert2LongIntsIntoCStr(const char *theSrcCStr,const long long1,const long long2,char *theDstCStr,const int maxDstStrLength) +{ +const long theLongInts[] = { long1,long2 }; + + CopyCStrAndInsertCStrsLongIntsIntoCStr(theSrcCStr,nil,theLongInts,theDstCStr,maxDstStrLength); +} + + +void CopyCStrAndInsert3LongIntsIntoCStr(const char *theSrcCStr,const long long1,const long long2,const long long3,char *theDstCStr,const int maxDstStrLength) +{ +const long theLongInts[] = { long1,long2,long3 }; + + CopyCStrAndInsertCStrsLongIntsIntoCStr(theSrcCStr,nil,theLongInts,theDstCStr,maxDstStrLength); +} + + +void CopyCStrAndInsertCStrIntoCStr(const char *theSrcCStr,const char *theInsertCStr,char *theDstCStr,const int maxDstStrLength) +{ +const char *theCStrs[2] = { theInsertCStr,nil }; + + CopyCStrAndInsertCStrsLongIntsIntoCStr(theSrcCStr,theCStrs,nil,theDstCStr,maxDstStrLength); +} + + + +void CopyCStrAndInsertCStrLongIntIntoCStr(const char *theSrcCStr,const char *theInsertCStr,const long theNum,char *theDstCStr,const int maxDstStrLength) +{ +const char *theCStrs[2] = { theInsertCStr,nil }; +const long theLongInts[1] = { theNum }; + + CopyCStrAndInsertCStrsLongIntsIntoCStr(theSrcCStr,theCStrs,theLongInts,theDstCStr,maxDstStrLength); +} + + + +void CopyCStrAndInsertCStrsLongIntsIntoCStr(const char *theSrcCStr,const char **theInsertCStrs,const long *theLongInts,char *theDstCStr,const int maxDstStrLength) +{ +int dstCharIndex,srcCharIndex,theMaxDstStrLength; +int theCStrIndex = 0; +int theLongIntIndex = 0; + + + theMaxDstStrLength = maxDstStrLength; + + if (theDstCStr != nil && theSrcCStr != nil && theMaxDstStrLength > 0) + { + dstCharIndex = 0; + + srcCharIndex = 0; + + + // Allow room for NULL at end of string + + theMaxDstStrLength--; + + + for (;;) + { + // Hit end of buffer? + + if (dstCharIndex >= theMaxDstStrLength) + { + theDstCStr[dstCharIndex++] = 0; + + goto EXITPOINT; + } + + // End of source string? + + else if (theSrcCStr[srcCharIndex] == 0) + { + theDstCStr[dstCharIndex++] = 0; + + goto EXITPOINT; + } + + // Did we find a '%s'? + + else if (theInsertCStrs != nil && theInsertCStrs[theCStrIndex] != nil && theSrcCStr[srcCharIndex] == '%' && theSrcCStr[srcCharIndex + 1] == 's') + { + // Skip over the '%s' + + srcCharIndex += 2; + + + // Terminate the dest string and then concat the string + + theDstCStr[dstCharIndex] = 0; + + ConcatCStrToCStr(theInsertCStrs[theCStrIndex],theDstCStr,theMaxDstStrLength); + + dstCharIndex = CStrLength(theDstCStr); + + theCStrIndex++; + } + + // Did we find a '%ld'? + + else if (theLongInts != nil && theSrcCStr[srcCharIndex] == '%' && theSrcCStr[srcCharIndex + 1] == 'l' && theSrcCStr[srcCharIndex + 2] == 'd') + { + // Skip over the '%ld' + + srcCharIndex += 3; + + + // Terminate the dest string and then concat the number + + theDstCStr[dstCharIndex] = 0; + + ConcatLongIntToCStr(theLongInts[theLongIntIndex],theDstCStr,theMaxDstStrLength); + + theLongIntIndex++; + + dstCharIndex = CStrLength(theDstCStr); + } + + else + { + theDstCStr[dstCharIndex++] = theSrcCStr[srcCharIndex++]; + } + } + } + + + +EXITPOINT: + + return; +} + + + + + +OSErr CopyCStrAndInsertCStrLongIntIntoHandle(const char *theSrcCStr,const char *theInsertCStr,const long theNum,Handle *theHandle) +{ +OSErr errCode; +long byteCount; + + + if (theHandle != nil) + { + byteCount = CStrLength(theSrcCStr) + CStrLength(theInsertCStr) + 32; + + *theHandle = NewHandle(byteCount); + + if (*theHandle == nil) + { + SetErrorMessageAndLongIntAndBail("CopyCStrAndInsertCStrLongIntIntoHandle: Can't allocate Handle, MemError() = ",MemError()); + } + + + HLock(*theHandle); + + CopyCStrAndInsertCStrLongIntIntoCStr(theSrcCStr,theInsertCStr,theNum,**theHandle,byteCount); + + HUnlock(*theHandle); + } + + errCode = noErr; + + +EXITPOINT: + + return(errCode); +} + + + + + +OSErr CopyIndexedWordToCStr(char *theSrcCStr,int whichWord,char *theDstCStr,int maxDstCStrLength) +{ +OSErr errCode; +char *srcCharPtr,*dstCharPtr; +int wordCount; +int byteCount; + + + if (theSrcCStr == nil) + { + SetErrorMessageAndBail(("CopyIndexedWordToCStr: Bad parameter, theSrcCStr == nil")); + } + + if (theDstCStr == nil) + { + SetErrorMessageAndBail(("CopyIndexedWordToCStr: Bad parameter, theDstCStr == nil")); + } + + if (whichWord < 0) + { + SetErrorMessageAndBail(("CopyIndexedWordToCStr: Bad parameter, whichWord < 0")); + } + + if (maxDstCStrLength <= 0) + { + SetErrorMessageAndBail(("CopyIndexedWordToCStr: Bad parameter, maxDstCStrLength <= 0")); + } + + + *theDstCStr = '\0'; + + srcCharPtr = theSrcCStr; + + while (*srcCharPtr == ' ' || *srcCharPtr == '\t') + { + srcCharPtr++; + } + + + for (wordCount = 0;wordCount < whichWord;wordCount++) + { + while (*srcCharPtr != ' ' && *srcCharPtr != '\t' && *srcCharPtr != '\r' && *srcCharPtr != '\n' && *srcCharPtr != '\0') + { + srcCharPtr++; + } + + if (*srcCharPtr == '\r' || *srcCharPtr == '\n' || *srcCharPtr == '\0') + { + errCode = noErr; + + goto EXITPOINT; + } + + while (*srcCharPtr == ' ' || *srcCharPtr == '\t') + { + srcCharPtr++; + } + + if (*srcCharPtr == '\r' || *srcCharPtr == '\n' || *srcCharPtr == '\0') + { + errCode = noErr; + + goto EXITPOINT; + } + } + + + dstCharPtr = theDstCStr; + byteCount = 0; + + + for(;;) + { + if (byteCount >= maxDstCStrLength - 1 || *srcCharPtr == '\0' || *srcCharPtr == ' ' || *srcCharPtr == '\t' || *srcCharPtr == '\r' || *srcCharPtr == '\n') + { + *dstCharPtr = '\0'; + break; + } + + *dstCharPtr++ = *srcCharPtr++; + + byteCount++; + } + + + errCode = noErr; + + +EXITPOINT: + + return(errCode); +} + + + + + +OSErr CopyIndexedWordToNewHandle(char *theSrcCStr,int whichWord,Handle *outTheHandle) +{ +OSErr errCode; +char *srcCharPtr; +int wordCount; +int byteCount; + + + if (theSrcCStr == nil) + { + SetErrorMessageAndBail(("CopyIndexedWordToNewHandle: Bad parameter, theSrcCStr == nil")); + } + + if (outTheHandle == nil) + { + SetErrorMessageAndBail(("CopyIndexedWordToNewHandle: Bad parameter, outTheHandle == nil")); + } + + if (whichWord < 0) + { + SetErrorMessageAndBail(("CopyIndexedWordToNewHandle: Bad parameter, whichWord < 0")); + } + + + *outTheHandle = nil; + + + srcCharPtr = theSrcCStr; + + while (*srcCharPtr == ' ' || *srcCharPtr == '\t') + { + srcCharPtr++; + } + + + for (wordCount = 0;wordCount < whichWord;wordCount++) + { + while (*srcCharPtr != ' ' && *srcCharPtr != '\t' && *srcCharPtr != '\r' && *srcCharPtr != '\n' && *srcCharPtr != '\0') + { + srcCharPtr++; + } + + if (*srcCharPtr == '\r' || *srcCharPtr == '\n' || *srcCharPtr == '\0') + { + break; + } + + while (*srcCharPtr == ' ' || *srcCharPtr == '\t') + { + srcCharPtr++; + } + + if (*srcCharPtr == '\r' || *srcCharPtr == '\n' || *srcCharPtr == '\0') + { + break; + } + } + + + for (byteCount = 0;;byteCount++) + { + if (srcCharPtr[byteCount] == ' ' || srcCharPtr[byteCount] == '\t' || srcCharPtr[byteCount] == '\r' || srcCharPtr[byteCount] == '\n' || srcCharPtr[byteCount] == '\0') + { + break; + } + } + + + *outTheHandle = NewHandle(byteCount + 1); + + if (*outTheHandle == nil) + { + SetErrorMessageAndLongIntAndBail("CopyIndexedWordToNewHandle: Can't allocate Handle, MemError() = ",MemError()); + } + + + ::BlockMove(srcCharPtr,**outTheHandle,byteCount); + + (**outTheHandle)[byteCount] = '\0'; + + errCode = noErr; + + +EXITPOINT: + + return(errCode); +} + + + +OSErr CopyIndexedLineToCStr(const char *theSrcCStr,int inWhichLine,int *lineEndIndex,Boolean *gotLastLine,char *theDstCStr,const int maxDstCStrLength) +{ +OSErr errCode; +int theCurrentLine; +int theCurrentLineOffset; +int theEOSOffset; + + + if (theSrcCStr == nil) + { + SetErrorMessageAndBail(("CopyIndexedLineToCStr: Bad parameter, theSrcCStr == nil")); + } + + if (theDstCStr == nil) + { + SetErrorMessageAndBail(("CopyIndexedLineToCStr: Bad parameter, theDstCStr == nil")); + } + + if (inWhichLine < 0) + { + SetErrorMessageAndBail(("CopyIndexedLineToCStr: Bad parameter, inWhichLine < 0")); + } + + if (maxDstCStrLength <= 0) + { + SetErrorMessageAndBail(("CopyIndexedLineToCStr: Bad parameter, maxDstCStrLength <= 0")); + } + + + if (gotLastLine != nil) + { + *gotLastLine = false; + } + + + *theDstCStr = 0; + + theCurrentLineOffset = 0; + + theCurrentLine = 0; + + + while (theCurrentLine < inWhichLine) + { + while (theSrcCStr[theCurrentLineOffset] != '\r' && theSrcCStr[theCurrentLineOffset] != 0) + { + theCurrentLineOffset++; + } + + if (theSrcCStr[theCurrentLineOffset] == 0) + { + break; + } + + theCurrentLineOffset++; + theCurrentLine++; + } + + if (theSrcCStr[theCurrentLineOffset] == 0) + { + SetErrorMessageAndLongIntAndBail("CopyIndexedLineToCStr: Too few lines in source text, can't get line ",inWhichLine); + } + + + theEOSOffset = FindCharOffsetInCStr('\r',theSrcCStr + theCurrentLineOffset); + + if (theEOSOffset >= 0) + { + CopyCSubstrToCStr(theSrcCStr + theCurrentLineOffset,theEOSOffset,theDstCStr,maxDstCStrLength); + + if (gotLastLine != nil) + { + *gotLastLine = false; + } + + if (lineEndIndex != nil) + { + *lineEndIndex = theEOSOffset; + } + } + + else + { + theEOSOffset = CStrLength(theSrcCStr + theCurrentLineOffset); + + CopyCSubstrToCStr(theSrcCStr + theCurrentLineOffset,theEOSOffset,theDstCStr,maxDstCStrLength); + + if (gotLastLine != nil) + { + *gotLastLine = true; + } + + if (lineEndIndex != nil) + { + *lineEndIndex = theEOSOffset; + } + } + + + errCode = noErr; + + +EXITPOINT: + + return(errCode); +} + + + +OSErr CopyIndexedLineToNewHandle(const char *theSrcCStr,int inWhichLine,Handle *outNewHandle) +{ +OSErr errCode; +int theCurrentLine; +int theCurrentLineOffset; +int byteCount; + + + SetErrorMessageAndBailIfNil(theSrcCStr,"CopyIndexedLineToNewHandle: Bad parameter, theSrcCStr == nil"); + SetErrorMessageAndBailIfNil(outNewHandle,"CopyIndexedLineToNewHandle: Bad parameter, outNewHandle == nil"); + + if (inWhichLine < 0) + { + SetErrorMessageAndBail(("CopyIndexedLineToNewHandle: Bad parameter, inWhichLine < 0")); + } + + + theCurrentLineOffset = 0; + + theCurrentLine = 0; + + + while (theCurrentLine < inWhichLine) + { + while (theSrcCStr[theCurrentLineOffset] != '\r' && theSrcCStr[theCurrentLineOffset] != '\0') + { + theCurrentLineOffset++; + } + + if (theSrcCStr[theCurrentLineOffset] == '\0') + { + break; + } + + theCurrentLineOffset++; + theCurrentLine++; + } + + if (theSrcCStr[theCurrentLineOffset] == '\0') + { + SetErrorMessageAndLongIntAndBail("CopyIndexedLineToNewHandle: Too few lines in source text, can't get line #",inWhichLine); + } + + + byteCount = 0; + + while (theSrcCStr[theCurrentLineOffset + byteCount] != '\r' && theSrcCStr[theCurrentLineOffset + byteCount] != '\0') + { + byteCount++; + } + + + *outNewHandle = NewHandle(byteCount + 1); + + if (*outNewHandle == nil) + { + SetErrorMessageAndLongIntAndBail("CopyIndexedLineToNewHandle: Can't allocate Handle, MemError() = ",MemError()); + } + + ::BlockMove(theSrcCStr + theCurrentLineOffset,**outNewHandle,byteCount); + + (**outNewHandle)[byteCount] = '\0'; + + errCode = noErr; + + +EXITPOINT: + + return(errCode); +} + + + + +OSErr CountDigits(const char *inCStr,int *outNumIntegerDigits,int *outNumFractDigits) +{ +OSErr errCode = noErr; +int numIntDigits = 0; +int numFractDigits = 0; +int digitIndex = 0; + + + SetErrorMessageAndBailIfNil(inCStr,"CountDigits: Bad parameter, theSrcCStr == nil"); + SetErrorMessageAndBailIfNil(outNumIntegerDigits,"CountDigits: Bad parameter, outNumIntegerDigits == nil"); + SetErrorMessageAndBailIfNil(outNumFractDigits,"CountDigits: Bad parameter, outNumFractDigits == nil"); + + digitIndex = 0; + + while (inCStr[digitIndex] >= '0' && inCStr[digitIndex] <= '9') + { + digitIndex++; + numIntDigits++; + } + + if (inCStr[digitIndex] == '.') + { + digitIndex++; + + while (inCStr[digitIndex] >= '0' && inCStr[digitIndex] <= '9') + { + digitIndex++; + numFractDigits++; + } + } + + *outNumIntegerDigits = numIntDigits; + + *outNumFractDigits = numFractDigits; + + errCode = noErr; + +EXITPOINT: + + return(errCode); +} + + + +OSErr ExtractIntFromCStr(const char *theSrcCStr,int *outInt,Boolean skipLeadingSpaces) +{ +OSErr errCode; +int theCharIndex; + + + if (theSrcCStr == nil) + { + SetErrorMessageAndBail(("ExtractIntFromCStr: Bad parameter, theSrcCStr == nil")); + } + + if (outInt == nil) + { + SetErrorMessageAndBail(("ExtractIntFromCStr: Bad parameter, outInt == nil")); + } + + + *outInt = 0; + + theCharIndex = 0; + + if (skipLeadingSpaces == true) + { + while (theSrcCStr[theCharIndex] == ' ') + { + theCharIndex++; + } + } + + if (theSrcCStr[theCharIndex] < '0' || theSrcCStr[theCharIndex] > '9') + { + SetErrorMessageAndBail(("ExtractIntFromCStr: Bad parameter, theSrcCStr contains a bogus numeric representation")); + } + + + while (theSrcCStr[theCharIndex] >= '0' && theSrcCStr[theCharIndex] <= '9') + { + *outInt = (*outInt * 10) + (theSrcCStr[theCharIndex] - '0'); + + theCharIndex++; + } + + + errCode = noErr; + + +EXITPOINT: + + return(errCode); +} + + + +OSErr ExtractIntFromPStr(const unsigned char *theSrcPStr,int *outInt,Boolean skipLeadingSpaces) +{ +OSErr errCode; +char theCStr[256]; + + + if (theSrcPStr == nil) + { + SetErrorMessageAndBail(("ExtractIntFromPStr: Bad parameter, theSrcPStr == nil")); + } + + if (outInt == nil) + { + SetErrorMessageAndBail(("ExtractIntFromPStr: Bad parameter, outInt == nil")); + } + + + CopyPStrToCStr(theSrcPStr,theCStr,sizeof(theCStr)); + + + errCode = ExtractIntFromCStr(theCStr,outInt,skipLeadingSpaces); + + +EXITPOINT: + + return(errCode); +} + + + +int CountOccurencesOfCharInCStr(const char inChar,const char *inSrcCStr) +{ +int theSrcCharIndex; +int numOccurrences = -1; + + + if (inSrcCStr != nil && inChar != '\0') + { + numOccurrences = 0; + + for (theSrcCharIndex = 0;inSrcCStr[theSrcCharIndex] != '\0';theSrcCharIndex++) + { + if (inSrcCStr[theSrcCharIndex] == inChar) + { + numOccurrences++; + } + } + } + + return(numOccurrences); +} + + +int CountWordsInCStr(const char *inSrcCStr) +{ +int numWords = -1; + + + if (inSrcCStr != nil) + { + numWords = 0; + + // Skip lead spaces + + while (*inSrcCStr == ' ') + { + inSrcCStr++; + } + + while (*inSrcCStr != '\0') + { + numWords++; + + while (*inSrcCStr != ' ' && *inSrcCStr != '\0') + { + inSrcCStr++; + } + + while (*inSrcCStr == ' ') + { + inSrcCStr++; + } + } + } + + return(numWords); +} + + + + +void ConvertCStrToUpperCase(char *theSrcCStr) +{ +char *theCharPtr; + + + if (theSrcCStr != nil) + { + theCharPtr = theSrcCStr; + + while (*theCharPtr != 0) + { + if (*theCharPtr >= 'a' && *theCharPtr <= 'z') + { + *theCharPtr = *theCharPtr - 'a' + 'A'; + } + + theCharPtr++; + } + } +} + + + + + + + +void ExtractCStrItemFromCStr(const char *inSrcCStr,const char inItemDelimiter,const int inItemNumber,Boolean *foundItem,char *outDstCharPtr,const int inDstCharPtrMaxLength,const Boolean inTreatMultipleDelimsAsSingleDelim) +{ +int theItem; +int theSrcCharIndex; +int theDstCharIndex; + + + if (foundItem != nil) + { + *foundItem = false; + } + + + if (outDstCharPtr != nil && inDstCharPtrMaxLength > 0 && inItemNumber >= 0 && inItemDelimiter != 0) + { + *outDstCharPtr = 0; + + + theSrcCharIndex = 0; + + for (theItem = 0;theItem < inItemNumber;theItem++) + { + while (inSrcCStr[theSrcCharIndex] != inItemDelimiter && inSrcCStr[theSrcCharIndex] != '\0') + { + theSrcCharIndex++; + } + + if (inSrcCStr[theSrcCharIndex] == inItemDelimiter) + { + theSrcCharIndex++; + + if (inTreatMultipleDelimsAsSingleDelim) + { + while (inSrcCStr[theSrcCharIndex] == inItemDelimiter) + { + theSrcCharIndex++; + } + } + } + + + if (inSrcCStr[theSrcCharIndex] == '\0') + { + goto EXITPOINT; + } + } + + + if (foundItem != nil) + { + *foundItem = true; + } + + + theDstCharIndex = 0; + + for (;;) + { + if (inSrcCStr[theSrcCharIndex] == 0 || inSrcCStr[theSrcCharIndex] == inItemDelimiter || theDstCharIndex >= inDstCharPtrMaxLength - 1) + { + outDstCharPtr[theDstCharIndex] = 0; + + break; + } + + outDstCharPtr[theDstCharIndex++] = inSrcCStr[theSrcCharIndex++]; + } + } + + +EXITPOINT: + + return; +} + + + +OSErr ExtractCStrItemFromCStrIntoNewHandle(const char *inSrcCStr,const char inItemDelimiter,const int inItemNumber,Boolean *foundItem,Handle *outNewHandle,const Boolean inTreatMultipleDelimsAsSingleDelim) +{ +OSErr errCode; +int theItem; +int theSrcCharIndex; +int theItemLength; + + + if (inSrcCStr == nil) + { + SetErrorMessage("ExtractCStrItemFromCStrIntoNewHandle: Bad parameter, inSrcCStr == nil"); + errCode = kGenericError; + goto EXITPOINT; + } + + if (outNewHandle == nil) + { + SetErrorMessage("ExtractCStrItemFromCStrIntoNewHandle: Bad parameter, outNewHandle == nil"); + errCode = kGenericError; + goto EXITPOINT; + } + + if (foundItem == nil) + { + SetErrorMessage("ExtractCStrItemFromCStrIntoNewHandle: Bad parameter, foundItem == nil"); + errCode = kGenericError; + goto EXITPOINT; + } + + if (inItemNumber < 0) + { + SetErrorMessage("ExtractCStrItemFromCStrIntoNewHandle: Bad parameter, inItemNumber < 0"); + errCode = kGenericError; + goto EXITPOINT; + } + + if (inItemDelimiter == 0) + { + SetErrorMessage("ExtractCStrItemFromCStrIntoNewHandle: Bad parameter, inItemDelimiter == 0"); + errCode = kGenericError; + goto EXITPOINT; + } + + + *foundItem = false; + + theSrcCharIndex = 0; + + for (theItem = 0;theItem < inItemNumber;theItem++) + { + while (inSrcCStr[theSrcCharIndex] != inItemDelimiter && inSrcCStr[theSrcCharIndex] != '\0') + { + theSrcCharIndex++; + } + + if (inSrcCStr[theSrcCharIndex] == inItemDelimiter) + { + theSrcCharIndex++; + + if (inTreatMultipleDelimsAsSingleDelim) + { + while (inSrcCStr[theSrcCharIndex] == inItemDelimiter) + { + theSrcCharIndex++; + } + } + } + + + if (inSrcCStr[theSrcCharIndex] == '\0') + { + errCode = noErr; + + goto EXITPOINT; + } + } + + + *foundItem = true; + + + for (theItemLength = 0;;theItemLength++) + { + if (inSrcCStr[theSrcCharIndex + theItemLength] == 0 || inSrcCStr[theSrcCharIndex + theItemLength] == inItemDelimiter) + { + break; + } + } + + + *outNewHandle = NewHandle(theItemLength + 1); + + if (*outNewHandle == nil) + { + SetErrorMessageAndLongIntAndBail("ExtractCStrItemFromCStrIntoNewHandle: Can't allocate Handle, MemError() = ",MemError()); + } + + + BlockMove(inSrcCStr + theSrcCharIndex,**outNewHandle,theItemLength); + + (**outNewHandle)[theItemLength] = 0; + + errCode = noErr; + + +EXITPOINT: + + return(errCode); +} + + + + + + +OSErr ExtractFloatFromCStr(const char *inCString,extended80 *outFloat) +{ +OSErr errCode; +Str255 theStr255; +Handle theNumberPartsTableHandle = nil; +long theNumberPartsOffset,theNumberPartsLength; +FormatResultType theFormatResultType; +NumberParts theNumberPartsTable; +NumFormatStringRec theNumFormatStringRec; + + + if (inCString == nil) + { + SetErrorMessage("ExtractFloatFromCStr: Bad parameter, inCString == nil"); + errCode = kGenericError; + goto EXITPOINT; + } + + if (outFloat == nil) + { + SetErrorMessage("ExtractFloatFromCStr: Bad parameter, outFloat == nil"); + errCode = kGenericError; + goto EXITPOINT; + } + + +// GetIntlResourceTable(smRoman,smNumberPartsTable,&theNumberPartsTableHandle,&theNumberPartsOffset,&theNumberPartsLength); + + GetIntlResourceTable(GetScriptManagerVariable(smSysScript),smNumberPartsTable,&theNumberPartsTableHandle,&theNumberPartsOffset,&theNumberPartsLength); + + if (theNumberPartsTableHandle == nil) + { + SetErrorMessage("ExtractFloatFromCStr: Can't get number parts table for converting string representations to/from numeric representations"); + errCode = kGenericError; + goto EXITPOINT; + } + + if (theNumberPartsLength > sizeof(theNumberPartsTable)) + { + SetErrorMessage("ExtractFloatFromCStr: Number parts table has bad length"); + errCode = kGenericError; + goto EXITPOINT; + } + + + BlockMove(*theNumberPartsTableHandle + theNumberPartsOffset,&theNumberPartsTable,theNumberPartsLength); + + + theFormatResultType = (FormatResultType) StringToFormatRec(kNumberFormatString,&theNumberPartsTable,&theNumFormatStringRec); + + if (theFormatResultType != fFormatOK) + { + SetErrorMessage("ExtractFloatFromCStr: StringToFormatRec() != fFormatOK"); + errCode = kGenericError; + goto EXITPOINT; + } + + + CopyCStrToPStr(inCString,theStr255,sizeof(theStr255)); + + + theFormatResultType = (FormatResultType) StringToExtended(theStr255,&theNumFormatStringRec,&theNumberPartsTable,outFloat); + + if (theFormatResultType != fFormatOK && theFormatResultType != fBestGuess) + { + SetErrorMessageAndLongIntAndBail("ExtractFloatFromCStr: StringToExtended() = ",theFormatResultType); + } + + + errCode = noErr; + + +EXITPOINT: + + return(errCode); +} + + + +OSErr CopyFloatToCStr(const extended80 *theFloat,char *theCStr,const int maxCStrLength,const int inMaxNumIntDigits,const int inMaxNumFractDigits) +{ +OSErr errCode; +Str255 theStr255; +Handle theNumberPartsTableHandle = nil; +long theNumberPartsOffset,theNumberPartsLength; +FormatResultType theFormatResultType; +NumberParts theNumberPartsTable; +NumFormatStringRec theNumFormatStringRec; + + + if (theCStr == nil) + { + SetErrorMessage("CopyFloatToCStr: Bad parameter, theCStr == nil"); + errCode = kGenericError; + goto EXITPOINT; + } + + if (theFloat == nil) + { + SetErrorMessage("CopyFloatToCStr: Bad parameter, theFloat == nil"); + errCode = kGenericError; + goto EXITPOINT; + } + + +// GetIntlResourceTable(smRoman,smNumberPartsTable,&theNumberPartsTableHandle,&theNumberPartsOffset,&theNumberPartsLength); + + GetIntlResourceTable(GetScriptManagerVariable(smSysScript),smNumberPartsTable,&theNumberPartsTableHandle,&theNumberPartsOffset,&theNumberPartsLength); + + if (theNumberPartsTableHandle == nil) + { + SetErrorMessage("CopyFloatToCStr: Can't get number parts table for converting string representations to/from numeric representations"); + errCode = kGenericError; + goto EXITPOINT; + } + + if (theNumberPartsLength > sizeof(theNumberPartsTable)) + { + SetErrorMessage("CopyFloatToCStr: Number parts table has bad length"); + errCode = kGenericError; + goto EXITPOINT; + } + + + BlockMove(*theNumberPartsTableHandle + theNumberPartsOffset,&theNumberPartsTable,theNumberPartsLength); + + + if (inMaxNumIntDigits >= 0 || inMaxNumFractDigits >= 0) + { + char numberFormat[64]; + int numberFormatLength = 0; + + for (int i = 0;i < inMaxNumIntDigits && numberFormatLength < sizeof(numberFormat) - 1;i++) + { + numberFormat[numberFormatLength++] = '0'; + } + + if (inMaxNumFractDigits > 0 && numberFormatLength < sizeof(numberFormat) - 1) + { + numberFormat[numberFormatLength++] = '.'; + + for (int i = 0;i < inMaxNumFractDigits && numberFormatLength < sizeof(numberFormat) - 1;i++) + { + numberFormat[numberFormatLength++] = '0'; + } + } + + + if (numberFormatLength < sizeof(numberFormat) - 1) + { + numberFormat[numberFormatLength++] = ';'; + } + + if (numberFormatLength < sizeof(numberFormat) - 1) + { + numberFormat[numberFormatLength++] = '-'; + } + + + for (int i = 0;i < inMaxNumIntDigits && numberFormatLength < sizeof(numberFormat) - 1;i++) + { + numberFormat[numberFormatLength++] = '0'; + } + + if (inMaxNumFractDigits > 0 && numberFormatLength < sizeof(numberFormat) - 1) + { + numberFormat[numberFormatLength++] = '.'; + + for (int i = 0;i < inMaxNumFractDigits && numberFormatLength < sizeof(numberFormat) - 1;i++) + { + numberFormat[numberFormatLength++] = '0'; + } + } + + numberFormat[numberFormatLength] = '\0'; + + + Str255 tempStr255; + + CopyCStrToPStr(numberFormat,tempStr255,sizeof(tempStr255)); + + theFormatResultType = (FormatResultType) StringToFormatRec(tempStr255,&theNumberPartsTable,&theNumFormatStringRec); + } + + else + { + theFormatResultType = (FormatResultType) StringToFormatRec(kNumberFormatString,&theNumberPartsTable,&theNumFormatStringRec); + } + + if (theFormatResultType != fFormatOK) + { + SetErrorMessage("CopyFloatToCStr: StringToFormatRec() != fFormatOK"); + errCode = kGenericError; + goto EXITPOINT; + } + + + theFormatResultType = (FormatResultType) ExtendedToString(theFloat,&theNumFormatStringRec,&theNumberPartsTable,theStr255); + + if (theFormatResultType != fFormatOK) + { + SetErrorMessage("CopyFloatToCStr: ExtendedToString() != fFormatOK"); + errCode = kGenericError; + goto EXITPOINT; + } + + + CopyPStrToCStr(theStr255,theCStr,maxCStrLength); + + errCode = noErr; + + +EXITPOINT: + + return(errCode); +} + + + + + +void SkipWhiteSpace(char **ioSrcCharPtr,const Boolean inStopAtEOL) +{ + if (ioSrcCharPtr != nil && *ioSrcCharPtr != nil) + { + if (inStopAtEOL) + { + while ((**ioSrcCharPtr == ' ' || **ioSrcCharPtr == '\t') && **ioSrcCharPtr != '\r' && **ioSrcCharPtr != '\n') + { + *ioSrcCharPtr++; + } + } + + else + { + while (**ioSrcCharPtr == ' ' || **ioSrcCharPtr == '\t') + { + *ioSrcCharPtr++; + } + } + } +} diff --git a/openssl/MacOS/GetHTTPS.src/CPStringUtils.hpp b/openssl/MacOS/GetHTTPS.src/CPStringUtils.hpp new file mode 100644 index 0000000..5045c41 --- /dev/null +++ b/openssl/MacOS/GetHTTPS.src/CPStringUtils.hpp @@ -0,0 +1,104 @@ +#pragma once + +#ifdef __cplusplus +extern "C" { +#endif + +void CopyPStrToCStr(const unsigned char *thePStr,char *theCStr,const int maxCStrLength); +void CopyPStrToPStr(const unsigned char *theSrcPStr,unsigned char *theDstPStr,const int maxDstStrLength); +void CopyCStrToCStr(const char *theSrcCStr,char *theDstCStr,const int maxDstStrLength); +void CopyCStrToPStr(const char *theSrcCStr,unsigned char *theDstPStr,const int maxDstStrLength); +void ConcatPStrToCStr(const unsigned char *thePStr,char *theCStr,const int maxCStrLength); +void ConcatPStrToPStr(const unsigned char *theSrcPStr,unsigned char *theDstPStr,const int maxDstStrLength); +void ConcatCStrToPStr(const char *theSrcCStr,unsigned char *theDstPStr,const int maxDstStrLength); +void ConcatCStrToCStr(const char *theSrcCStr,char *theDstCStr,const int maxCStrLength); + +void ConcatCharToCStr(const char theChar,char *theDstCStr,const int maxCStrLength); +void ConcatCharToPStr(const char theChar,unsigned char *theDstPStr,const int maxPStrLength); + +int ComparePStrs(const unsigned char *theFirstPStr,const unsigned char *theSecondPStr,const Boolean ignoreCase = true); +int CompareCStrs(const char *theFirstCStr,const char *theSecondCStr,const Boolean ignoreCase = true); +int CompareCStrToPStr(const char *theCStr,const unsigned char *thePStr,const Boolean ignoreCase = true); + +Boolean CStrsAreEqual(const char *theFirstCStr,const char *theSecondCStr,const Boolean ignoreCase = true); +Boolean PStrsAreEqual(const unsigned char *theFirstCStr,const unsigned char *theSecondCStr,const Boolean ignoreCase = true); + +void CopyLongIntToCStr(const long theNum,char *theCStr,const int maxCStrLength,const int numDigits = -1); +void CopyUnsignedLongIntToCStr(const unsigned long theNum,char *theCStr,const int maxCStrLength); +void ConcatLongIntToCStr(const long theNum,char *theCStr,const int maxCStrLength,const int numDigits = -1); +void CopyCStrAndConcatLongIntToCStr(const char *theSrcCStr,const long theNum,char *theDstCStr,const int maxDstStrLength); + +void CopyLongIntToPStr(const long theNum,unsigned char *thePStr,const int maxPStrLength,const int numDigits = -1); +void ConcatLongIntToPStr(const long theNum,unsigned char *thePStr,const int maxPStrLength,const int numDigits = -1); + +long CStrLength(const char *theCString); +long PStrLength(const unsigned char *thePString); + +OSErr CopyCStrToExistingHandle(const char *theCString,Handle theHandle); +OSErr CopyLongIntToExistingHandle(const long inTheLongInt,Handle theHandle); + +OSErr CopyCStrToNewHandle(const char *theCString,Handle *theHandle); +OSErr CopyPStrToNewHandle(const unsigned char *thePString,Handle *theHandle); +OSErr CopyLongIntToNewHandle(const long inTheLongInt,Handle *theHandle); + +OSErr AppendCStrToHandle(const char *theCString,Handle theHandle,long *currentLength = nil,long *maxLength = nil); +OSErr AppendCharsToHandle(const char *theChars,const int numChars,Handle theHandle,long *currentLength = nil,long *maxLength = nil); +OSErr AppendPStrToHandle(const unsigned char *thePString,Handle theHandle,long *currentLength = nil); +OSErr AppendLongIntToHandle(const long inTheLongInt,Handle theHandle,long *currentLength = nil); + +void ZeroMem(void *theMemPtr,const unsigned long numBytes); + +char *FindCharInCStr(const char theChar,const char *theCString); +long FindCharOffsetInCStr(const char theChar,const char *theCString,const Boolean inIgnoreCase = false); +long FindCStrOffsetInCStr(const char *theCSubstring,const char *theCString,const Boolean inIgnoreCase = false); + +void CopyCSubstrToCStr(const char *theSrcCStr,const int maxCharsToCopy,char *theDstCStr,const int maxDstStrLength); +void CopyCSubstrToPStr(const char *theSrcCStr,const int maxCharsToCopy,unsigned char *theDstPStr,const int maxDstStrLength); + +void InsertCStrIntoCStr(const char *theSrcCStr,const int theInsertionOffset,char *theDstCStr,const int maxDstStrLength); +void InsertPStrIntoCStr(const unsigned char *theSrcPStr,const int theInsertionOffset,char *theDstCStr,const int maxDstStrLength); +OSErr InsertCStrIntoHandle(const char *theCString,Handle theHandle,const long inInsertOffset); + +void CopyCStrAndInsertCStrIntoCStr(const char *theSrcCStr,const char *theInsertCStr,char *theDstCStr,const int maxDstStrLength); + +void CopyCStrAndInsertCStrsLongIntsIntoCStr(const char *theSrcCStr,const char **theInsertCStrs,const long *theLongInts,char *theDstCStr,const int maxDstStrLength); + +void CopyCStrAndInsert1LongIntIntoCStr(const char *theSrcCStr,const long theNum,char *theDstCStr,const int maxDstStrLength); +void CopyCStrAndInsert2LongIntsIntoCStr(const char *theSrcCStr,const long long1,const long long2,char *theDstCStr,const int maxDstStrLength); +void CopyCStrAndInsert3LongIntsIntoCStr(const char *theSrcCStr,const long long1,const long long2,const long long3,char *theDstCStr,const int maxDstStrLength); + +void CopyCStrAndInsertCStrLongIntIntoCStr(const char *theSrcCStr,const char *theInsertCStr,const long theNum,char *theDstCStr,const int maxDstStrLength); +OSErr CopyCStrAndInsertCStrLongIntIntoHandle(const char *theSrcCStr,const char *theInsertCStr,const long theNum,Handle *theHandle); + + +OSErr CopyIndexedWordToCStr(char *theSrcCStr,int whichWord,char *theDstCStr,int maxDstCStrLength); +OSErr CopyIndexedWordToNewHandle(char *theSrcCStr,int whichWord,Handle *outTheHandle); + +OSErr CopyIndexedLineToCStr(const char *theSrcCStr,int inWhichLine,int *lineEndIndex,Boolean *gotLastLine,char *theDstCStr,const int maxDstCStrLength); +OSErr CopyIndexedLineToNewHandle(const char *theSrcCStr,int inWhichLine,Handle *outNewHandle); + +OSErr ExtractIntFromCStr(const char *theSrcCStr,int *outInt,Boolean skipLeadingSpaces = true); +OSErr ExtractIntFromPStr(const unsigned char *theSrcPStr,int *outInt,Boolean skipLeadingSpaces = true); + + +void ConvertCStrToUpperCase(char *theSrcCStr); + + +int CountOccurencesOfCharInCStr(const char inChar,const char *inSrcCStr); +int CountWordsInCStr(const char *inSrcCStr); + +OSErr CountDigits(const char *inCStr,int *outNumIntegerDigits,int *outNumFractDigits); + +void ExtractCStrItemFromCStr(const char *inSrcCStr,const char inItemDelimiter,const int inItemNumber,Boolean *foundItem,char *outDstCharPtr,const int inDstCharPtrMaxLength,const Boolean inTreatMultipleDelimsAsSingleDelim = false); +OSErr ExtractCStrItemFromCStrIntoNewHandle(const char *inSrcCStr,const char inItemDelimiter,const int inItemNumber,Boolean *foundItem,Handle *outNewHandle,const Boolean inTreatMultipleDelimsAsSingleDelim = false); + + +OSErr ExtractFloatFromCStr(const char *inCString,extended80 *outFloat); +OSErr CopyFloatToCStr(const extended80 *theFloat,char *theCStr,const int maxCStrLength,const int inMaxNumIntDigits = -1,const int inMaxNumFractDigits = -1); + +void SkipWhiteSpace(char **ioSrcCharPtr,const Boolean inStopAtEOL = false); + + +#ifdef __cplusplus +} +#endif diff --git a/openssl/MacOS/GetHTTPS.src/ErrorHandling.cpp b/openssl/MacOS/GetHTTPS.src/ErrorHandling.cpp new file mode 100644 index 0000000..80b6a67 --- /dev/null +++ b/openssl/MacOS/GetHTTPS.src/ErrorHandling.cpp @@ -0,0 +1,170 @@ +/* ==================================================================== + * 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 "ErrorHandling.hpp" +#include "CPStringUtils.hpp" + +#ifdef __EXCEPTIONS_ENABLED__ + #include "CMyException.hpp" +#endif + + +static char gErrorMessageBuffer[512]; + +char *gErrorMessage = gErrorMessageBuffer; +int gErrorMessageMaxLength = sizeof(gErrorMessageBuffer); + + + +void SetErrorMessage(const char *theErrorMessage) +{ + if (theErrorMessage != nil) + { + CopyCStrToCStr(theErrorMessage,gErrorMessage,gErrorMessageMaxLength); + } +} + + +void SetErrorMessageAndAppendLongInt(const char *theErrorMessage,const long theLongInt) +{ + if (theErrorMessage != nil) + { + CopyCStrAndConcatLongIntToCStr(theErrorMessage,theLongInt,gErrorMessage,gErrorMessageMaxLength); + } +} + +void SetErrorMessageAndCStrAndLongInt(const char *theErrorMessage,const char * theCStr,const long theLongInt) +{ + if (theErrorMessage != nil) + { + CopyCStrAndInsertCStrLongIntIntoCStr(theErrorMessage,theCStr,theLongInt,gErrorMessage,gErrorMessageMaxLength); + } + +} + +void SetErrorMessageAndCStr(const char *theErrorMessage,const char * theCStr) +{ + if (theErrorMessage != nil) + { + CopyCStrAndInsertCStrLongIntIntoCStr(theErrorMessage,theCStr,-1,gErrorMessage,gErrorMessageMaxLength); + } +} + + +void AppendCStrToErrorMessage(const char *theErrorMessage) +{ + if (theErrorMessage != nil) + { + ConcatCStrToCStr(theErrorMessage,gErrorMessage,gErrorMessageMaxLength); + } +} + + +void AppendLongIntToErrorMessage(const long theLongInt) +{ + ConcatLongIntToCStr(theLongInt,gErrorMessage,gErrorMessageMaxLength); +} + + + +char *GetErrorMessage(void) +{ + return gErrorMessage; +} + + +OSErr GetErrorMessageInNewHandle(Handle *inoutHandle) +{ +OSErr errCode; + + + errCode = CopyCStrToNewHandle(gErrorMessage,inoutHandle); + + return(errCode); +} + + +OSErr GetErrorMessageInExistingHandle(Handle inoutHandle) +{ +OSErr errCode; + + + errCode = CopyCStrToExistingHandle(gErrorMessage,inoutHandle); + + return(errCode); +} + + + +OSErr AppendErrorMessageToHandle(Handle inoutHandle) +{ +OSErr errCode; + + + errCode = AppendCStrToHandle(gErrorMessage,inoutHandle,nil); + + return(errCode); +} + + +#ifdef __EXCEPTIONS_ENABLED__ + +void ThrowErrorMessageException(void) +{ + ThrowDescriptiveException(gErrorMessage); +} + +#endif diff --git a/openssl/MacOS/GetHTTPS.src/ErrorHandling.hpp b/openssl/MacOS/GetHTTPS.src/ErrorHandling.hpp new file mode 100644 index 0000000..fbfbe78 --- /dev/null +++ b/openssl/MacOS/GetHTTPS.src/ErrorHandling.hpp @@ -0,0 +1,147 @@ +#ifdef __cplusplus +extern "C" { +#endif + +#ifndef kGenericError + #define kGenericError -1 +#endif + +extern char *gErrorMessage; + + +void SetErrorMessage(const char *theErrorMessage); +void SetErrorMessageAndAppendLongInt(const char *theErrorMessage,const long theLongInt); +void SetErrorMessageAndCStrAndLongInt(const char *theErrorMessage,const char * theCStr,const long theLongInt); +void SetErrorMessageAndCStr(const char *theErrorMessage,const char * theCStr); +void AppendCStrToErrorMessage(const char *theErrorMessage); +void AppendLongIntToErrorMessage(const long theLongInt); + + +char *GetErrorMessage(void); +OSErr GetErrorMessageInNewHandle(Handle *inoutHandle); +OSErr GetErrorMessageInExistingHandle(Handle inoutHandle); +OSErr AppendErrorMessageToHandle(Handle inoutHandle); + + +#ifdef __EXCEPTIONS_ENABLED__ + void ThrowErrorMessageException(void); +#endif + + + +// A bunch of evil macros that would be unnecessary if I were always using C++ ! + +#define SetErrorMessageAndBailIfNil(theArg,theMessage) \ +{ \ + if (theArg == nil) \ + { \ + SetErrorMessage(theMessage); \ + errCode = kGenericError; \ + goto EXITPOINT; \ + } \ +} + + +#define SetErrorMessageAndBail(theMessage) \ +{ \ + SetErrorMessage(theMessage); \ + errCode = kGenericError; \ + goto EXITPOINT; \ +} + + +#define SetErrorMessageAndLongIntAndBail(theMessage,theLongInt) \ +{ \ + SetErrorMessageAndAppendLongInt(theMessage,theLongInt); \ + errCode = kGenericError; \ + goto EXITPOINT; \ +} + + +#define SetErrorMessageAndLongIntAndBailIfError(theErrCode,theMessage,theLongInt) \ +{ \ + if (theErrCode != noErr) \ + { \ + SetErrorMessageAndAppendLongInt(theMessage,theLongInt); \ + errCode = theErrCode; \ + goto EXITPOINT; \ + } \ +} + + +#define SetErrorMessageCStrLongIntAndBailIfError(theErrCode,theMessage,theCStr,theLongInt) \ +{ \ + if (theErrCode != noErr) \ + { \ + SetErrorMessageAndCStrAndLongInt(theMessage,theCStr,theLongInt); \ + errCode = theErrCode; \ + goto EXITPOINT; \ + } \ +} + + +#define SetErrorMessageAndCStrAndBail(theMessage,theCStr) \ +{ \ + SetErrorMessageAndCStr(theMessage,theCStr); \ + errCode = kGenericError; \ + goto EXITPOINT; \ +} + + +#define SetErrorMessageAndBailIfError(theErrCode,theMessage) \ +{ \ + if (theErrCode != noErr) \ + { \ + SetErrorMessage(theMessage); \ + errCode = theErrCode; \ + goto EXITPOINT; \ + } \ +} + + +#define SetErrorMessageAndLongIntAndBailIfNil(theArg,theMessage,theLongInt) \ +{ \ + if (theArg == nil) \ + { \ + SetErrorMessageAndAppendLongInt(theMessage,theLongInt); \ + errCode = kGenericError; \ + goto EXITPOINT; \ + } \ +} + + +#define BailIfError(theErrCode) \ +{ \ + if ((theErrCode) != noErr) \ + { \ + goto EXITPOINT; \ + } \ +} + + +#define SetErrCodeAndBail(theErrCode) \ +{ \ + errCode = theErrCode; \ + \ + goto EXITPOINT; \ +} + + +#define SetErrorCodeAndMessageAndBail(theErrCode,theMessage) \ +{ \ + SetErrorMessage(theMessage); \ + errCode = theErrCode; \ + goto EXITPOINT; \ +} + + +#define BailNow() \ +{ \ + errCode = kGenericError; \ + goto EXITPOINT; \ +} + + +#ifdef __cplusplus +} +#endif diff --git a/openssl/MacOS/GetHTTPS.src/GetHTTPS.cpp b/openssl/MacOS/GetHTTPS.src/GetHTTPS.cpp new file mode 100644 index 0000000..3a5e3f0 --- /dev/null +++ b/openssl/MacOS/GetHTTPS.src/GetHTTPS.cpp @@ -0,0 +1,209 @@ +/* + * An demo illustrating how to retrieve a URI from a secure HTTP server. + * + * Author: Roy Wood + * Date: September 7, 1999 + * Comments: This relies heavily on my MacSockets library. + * This project is also set up so that it expects the OpenSSL source folder (0.9.4 as I write this) + * to live in a folder called "OpenSSL-0.9.4" in this project's parent folder. For example: + * + * Macintosh HD: + * Development: + * OpenSSL-0.9.4: + * (OpenSSL sources here) + * OpenSSL Example: + * (OpenSSL example junk here) + * + * + * Also-- before attempting to compile this, make sure the aliases in "OpenSSL-0.9.4:include:openssl" + * are installed! Use the AppleScript applet in the "openssl-0.9.4" folder to do this! + */ +/* modified to seed the PRNG */ +/* modified to use CRandomizer for seeding */ + + +// Include some funky libs I've developed over time + +#include "CPStringUtils.hpp" +#include "ErrorHandling.hpp" +#include "MacSocket.h" +#include "Randomizer.h" + +// We use the OpenSSL implementation of SSL.... +// This was a lot of work to finally get going, though you wouldn't know it by the results! + +#include <openssl/ssl.h> +#include <openssl/err.h> + +#include <timer.h> + +// Let's try grabbing some data from here: + +#define kHTTPS_DNS "www.apache-ssl.org" +#define kHTTPS_Port 443 +#define kHTTPS_URI "/" + + +// Forward-declare this + +OSErr MyMacSocket_IdleWaitCallback(void *inUserRefPtr); + +// My idle-wait callback. Doesn't do much, does it? Silly cooperative multitasking. + +OSErr MyMacSocket_IdleWaitCallback(void *inUserRefPtr) +{ +#pragma unused(inUserRefPtr) + +EventRecord theEvent; + ::EventAvail(everyEvent,&theEvent); + + CRandomizer *randomizer = (CRandomizer*)inUserRefPtr; + if (randomizer) + randomizer->PeriodicAction(); + + return(noErr); +} + + +// Finally! + +void main(void) +{ + OSErr errCode; + int theSocket = -1; + int theTimeout = 30; + + SSL_CTX *ssl_ctx = nil; + SSL *ssl = nil; + + char tempString[256]; + UnsignedWide microTickCount; + + + CRandomizer randomizer; + + printf("OpenSSL Demo by Roy Wood, roy@centricsystems.ca\n\n"); + + BailIfError(errCode = MacSocket_Startup()); + + + + // Create a socket-like object + + BailIfError(errCode = MacSocket_socket(&theSocket,false,theTimeout * 60,MyMacSocket_IdleWaitCallback,&randomizer)); + + + // Set up the connect string and try to connect + + CopyCStrAndInsertCStrLongIntIntoCStr("%s:%ld",kHTTPS_DNS,kHTTPS_Port,tempString,sizeof(tempString)); + + printf("Connecting to %s....\n",tempString); + + BailIfError(errCode = MacSocket_connect(theSocket,tempString)); + + + // Init SSL stuff + + SSL_load_error_strings(); + + SSLeay_add_ssl_algorithms(); + + + // Pick the SSL method + +// ssl_ctx = SSL_CTX_new(SSLv2_client_method()); + ssl_ctx = SSL_CTX_new(SSLv23_client_method()); +// ssl_ctx = SSL_CTX_new(SSLv3_client_method()); + + + // Create an SSL thingey and try to negotiate the connection + + ssl = SSL_new(ssl_ctx); + + SSL_set_fd(ssl,theSocket); + + errCode = SSL_connect(ssl); + + if (errCode < 0) + { + SetErrorMessageAndLongIntAndBail("OpenSSL: Can't initiate SSL connection, SSL_connect() = ",errCode); + } + + // Request the URI from the host + + CopyCStrToCStr("GET ",tempString,sizeof(tempString)); + ConcatCStrToCStr(kHTTPS_URI,tempString,sizeof(tempString)); + ConcatCStrToCStr(" HTTP/1.0\r\n\r\n",tempString,sizeof(tempString)); + + + errCode = SSL_write(ssl,tempString,CStrLength(tempString)); + + if (errCode < 0) + { + SetErrorMessageAndLongIntAndBail("OpenSSL: Error writing data via ssl, SSL_write() = ",errCode); + } + + + for (;;) + { + char tempString[256]; + int bytesRead; + + + // Read some bytes and dump them to the console + + bytesRead = SSL_read(ssl,tempString,sizeof(tempString) - 1); + + if (bytesRead == 0 && MacSocket_RemoteEndIsClosing(theSocket)) + { + break; + } + + else if (bytesRead < 0) + { + SetErrorMessageAndLongIntAndBail("OpenSSL: Error reading data via ssl, SSL_read() = ",bytesRead); + } + + + tempString[bytesRead] = '\0'; + + printf("%s", tempString); + } + + printf("\n\n\n"); + + // All done! + + errCode = noErr; + + +EXITPOINT: + + // Clean up and go home + + if (theSocket >= 0) + { + MacSocket_close(theSocket); + } + + if (ssl != nil) + { + SSL_free(ssl); + } + + if (ssl_ctx != nil) + { + SSL_CTX_free(ssl_ctx); + } + + + if (errCode != noErr) + { + printf("An error occurred:\n"); + + printf("%s",GetErrorMessage()); + } + + + MacSocket_Shutdown(); +} diff --git a/openssl/MacOS/GetHTTPS.src/MacSocket.cpp b/openssl/MacOS/GetHTTPS.src/MacSocket.cpp new file mode 100644 index 0000000..c95d804 --- /dev/null +++ b/openssl/MacOS/GetHTTPS.src/MacSocket.cpp @@ -0,0 +1,1607 @@ +/* + * A simple socket-like package. + * This could undoubtedly be improved, since it does polling and busy-waiting. + * At least it uses asynch I/O and implements timeouts! + * + * Other funkiness includes the use of my own (possibly brain-damaged) error-handling infrastructure. + * + * -Roy Wood (roy@centricsystems.ca) + * + */ + + +/* ==================================================================== + * Copyright (c) 1998-1999 The OpenSSL Project. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in + * the documentation and/or other materials provided with the + * distribution. + * + * 3. All advertising materials mentioning features or use of this + * software must display the following acknowledgment: + * "This product includes software developed by the OpenSSL Project + * for use in the OpenSSL Toolkit. (http://www.openssl.org/)" + * + * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to + * endorse or promote products derived from this software without + * prior written permission. For written permission, please contact + * openssl-core@openssl.org. + * + * 5. Products derived from this software may not be called "OpenSSL" + * nor may "OpenSSL" appear in their names without prior written + * permission of the OpenSSL Project. + * + * 6. Redistributions of any form whatsoever must retain the following + * acknowledgment: + * "This product includes software developed by the OpenSSL Project + * for use in the OpenSSL Toolkit (http://www.openssl.org/)" + * + * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY + * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR + * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE OpenSSL PROJECT OR + * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, + * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED + * OF THE POSSIBILITY OF SUCH DAMAGE. + * ==================================================================== + * + * This product includes cryptographic software written by Eric Young + * (eay@cryptsoft.com). This product includes software written by Tim + * Hudson (tjh@cryptsoft.com). + * + */ + + + + + +#include "MacSocket.h" + +#include <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; + } + } +} +*/ diff --git a/openssl/MacOS/GetHTTPS.src/MacSocket.h b/openssl/MacOS/GetHTTPS.src/MacSocket.h new file mode 100644 index 0000000..155d40d --- /dev/null +++ b/openssl/MacOS/GetHTTPS.src/MacSocket.h @@ -0,0 +1,104 @@ +#pragma once + + +#ifdef __cplusplus +extern "C" { +#endif + +enum { + kMacSocket_TimeoutErr = -2 +}; + +// Since MacSocket does busy waiting, I do a callback while waiting + +typedef OSErr(*MacSocket_IdleWaitCallback) (void *); + +// Call this before anything else! + +OSErr MacSocket_Startup(void); + +// Call this to cleanup before quitting + +OSErr MacSocket_Shutdown(void); + +// Call this to allocate a "socket" (reference number is returned in +// outSocketNum) +// Note that inDoThreadSwitching is pretty much irrelevant right now, since I +// ignore it +// The inTimeoutTicks parameter is applied during reads/writes of data +// The inIdleWaitCallback parameter specifies a callback which is called +// during busy-waiting periods +// The inUserRefPtr parameter is passed back to the idle-wait callback + +OSErr MacSocket_socket(int *outSocketNum, const Boolean inDoThreadSwitching, + const long inTimeoutTicks, + MacSocket_IdleWaitCallback inIdleWaitCallback, + void *inUserRefPtr); + +// Call this to connect to an IP/DNS address +// Note that inTargetAddressAndPort is in "IP:port" format-- e.g. +// 10.1.1.1:123 + +OSErr MacSocket_connect(const int inSocketNum, char *inTargetAddressAndPort); + +// Call this to listen on a port +// Since this a low-performance implementation, I allow a maximum of 1 (one!) +// incoming request when I listen + +OSErr MacSocket_listen(const int inSocketNum, const int inPortNum); + +// Call this to close a socket + +OSErr MacSocket_close(const int inSocketNum); + +// Call this to receive data on a socket +// Most parameters' purpose are obvious-- except maybe "inBlock" which +// controls whether I wait for data or return immediately + +int MacSocket_recv(const int inSocketNum, void *outBuff, int outBuffLength, + const Boolean inBlock); + +// Call this to send data on a socket + +int MacSocket_send(const int inSocketNum, const void *inBuff, + int inBuffLength); + +// If zero bytes were read in a call to MacSocket_recv(), it may be that the +// remote end has done a half-close +// This function will let you check whether that's true or not + +Boolean MacSocket_RemoteEndIsClosing(const int inSocketNum); + +// Call this to see if the listen has completed after a call to +// MacSocket_listen() + +Boolean MacSocket_ListenCompleted(const int inSocketNum); + +// These really aren't very useful anymore + +Boolean MacSocket_LocalEndIsOpen(const int inSocketNum); +Boolean MacSocket_RemoteEndIsOpen(const int inSocketNum); + +// You may wish to change the userRefPtr for a socket callback-- use this to +// do it + +void MacSocket_SetUserRefPtr(const int inSocketNum, void *inNewRefPtr); + +// Call these to get the socket's IP:port descriptor + +void MacSocket_GetLocalIPAndPort(const int inSocketNum, char *outIPAndPort, + const int inIPAndPortLength); +void MacSocket_GetRemoteIPAndPort(const int inSocketNum, char *outIPAndPort, + const int inIPAndPortLength); + +// Call this to get error info from a socket + +void MacSocket_GetSocketErrorInfo(const int inSocketNum, + int *outSocketErrCode, + char *outSocketErrString, + const int inSocketErrStringMaxLength); + + +#ifdef __cplusplus +} +#endif |