void InitialPermutation(EncryptBlk *sourceBlkPTr,EncryptBlk *resultBlkPTr )
{
doubleLong dataToEncrypt;
uint32_t resultLow = 0;
uint32_t resultHi = 0;
register uint32_t gTestVal = 0;
#if TARGET_RT_BIG_ENDIAN
dataToEncrypt.bits49to64 = sourceBlkPTr->keyLo & klowWord;
dataToEncrypt.bits33to48 = sourceBlkPTr->keyHi & klowWord;
dataToEncrypt.bits17to32 = sourceBlkPTr->keyLo >> kwordSize;
dataToEncrypt.bits1to16 = sourceBlkPTr->keyHi >> kwordSize;
#else
dataToEncrypt.bits49to64 = CFSwapInt16(sourceBlkPTr->keyLo >> kwordSize);
dataToEncrypt.bits33to48 = CFSwapInt16(sourceBlkPTr->keyHi >> kwordSize);
dataToEncrypt.bits17to32 = CFSwapInt16(sourceBlkPTr->keyLo & klowWord);
dataToEncrypt.bits1to16 = CFSwapInt16(sourceBlkPTr->keyHi & klowWord);
#endif
Extract(&dataToEncrypt, &resultLow, &resultHi);
RORightLong(resultLow)
RORightLong(resultHi)
Extract(&dataToEncrypt, &resultLow, &resultHi);
resultBlkPTr->keyLo = resultLow;
resultBlkPTr->keyHi = resultHi;
}
_xai_packet_param_normal* generateParamNormalFromData(void* packetData,int size){
if (size < _XPPS_N_FIXED_ALL) { //长度不够
printf("XAI - NORMAL PACKET FIXED DATA SIZE ENOUGH");
return NULL;
}
if (packetData == NULL) {
printf("XAI - Normal packet is null");
return NULL;
}
_xai_packet_param_normal* aParam = generatePacketParamNormal();
//读取固定格式
packet_to_param_helper(aParam->from_guid, packetData, _XPP_N_FROM_GUID_START, _XPP_N_FROM_GUID_END);
packet_to_param_helper(aParam->to_guid, packetData, _XPP_N_TO_GUID_START, _XPP_N_TO_GUID_END);
packet_to_param_helper(&aParam->flag, packetData, _XPP_N_FLAG_START, _XPP_N_FLAG_END);
packet_to_param_helper(&aParam->msgid, packetData, _XPP_N_MSGID_START, _XPP_N_MSGID_END);
packet_to_param_helper(&aParam->magic_number, packetData, _XPP_N_MAGIC_NUMBER_START, _XPP_N_MAGIC_NUMBER_END);
packet_to_param_helper(&aParam->length, packetData, _XPP_N_LENGTH_START, _XPP_N_LENGTH_END);
void* lit_from = generateSwapGUID(aParam->from_guid);
void* lit_to = generateSwapGUID(aParam->to_guid);
byte_data_copy(aParam->from_guid, lit_from, sizeof(aParam->from_guid), lengthOfGUID());
byte_data_copy(aParam->to_guid, lit_to, sizeof(aParam->to_guid), lengthOfGUID());
purgeGUID(lit_from);
purgeGUID(lit_to);
aParam->msgid = CFSwapInt32(aParam->msgid);
aParam->magic_number = CFSwapInt16(aParam->magic_number);
aParam->length = CFSwapInt16(aParam->length);
if (size < _XPPS_N_FIXED_ALL + aParam->length) {
purgePacketParamNormal(aParam);
printf("XAI - NORMAL PACKET UNFIXED DATA SIZE ENOUGH");
return NULL;
}
//unfixed
aParam->data = malloc(aParam->length);
memset(aParam->data, 0, aParam->length);
//packet_to_param_helper(aParam->data, packetData, _XPP_N_DATA_START, _XPP_N_DATA_START+aParam->length);
memcpy(aParam->data, packetData+_XPP_N_DATA_START, aParam->length);
return aParam;
}
/* The guts of getCharacter() have been separated in order to allow getCharacter() to be small and more easily inline-able. Note that a check late in the 10.3 development cycle indicates that getCharacter() should call getCharacterGuts() less than 2% of the time. (In 29000 calls, less than 400 called this. Note that a majority of calls have advanceStream set, so that was left in the inline version. Also note that some calls to getCharacter() were changed to go through the functions _inputStreamGetCharacter() or _inputStreamPeekCharacter(), as the expansion in using the inline version didn't seem worthwhile. See 3275503 for some data supporting this.
*/
static Boolean getCharacterGuts(_CFXMLInputStream *stream, UniChar *ch, Boolean advanceStream) {
if (stream->currentByte - CFDataGetBytePtr(stream->data) >= CFDataGetLength(stream->data)) {
return false; // EOF
} else if (!((stream->mark || stream->parserMark) && advanceStream) &&
(((stream->flags & ENCODING_MATCHES_ASCII) && *(stream->currentByte) < 0x7F) ||
(stream->flags & (ENCODING_IS_UNICODE_NATURAL | ENCODING_IS_UNICODE_SWAPPED)))) {
// We can only perform optimizations if neither mark is set (if the mark is set, we must fill the character buffer so we can retrieve the characters later), and the encoding is Unicode, or the encoding matches ASCII and we're looking at a low-byte character.
if (stream->flags & ENCODING_MATCHES_ASCII) {
*ch = (UniChar)*(stream->currentByte);
if (advanceStream) {
stream->currentByte ++;
}
} else if (stream->flags & ENCODING_IS_UNICODE_NATURAL) {
*ch = *(UniChar *)(stream->currentByte);
if (advanceStream) {
stream->currentByte += 2;
}
} else {
// Unicode with swapped bytes
*ch = CFSwapInt16(*(UniChar *)(stream->currentByte));
if (advanceStream) {
stream->currentByte += 2;
}
}
} else {
fillCharacterBuffer(stream); // this takes into account markIsSet to make sure and do the right thing
if (!stream->charBuffer || !stream->currentChar) {
return false;
} else {
*ch = *(stream->currentChar);
if (advanceStream) {
stream->currentChar ++;
if (stream->currentChar == stream->charBuffer + stream->bufferLength) {
stream->currentChar = NULL;
}
}
}
}
return true;
}
_xai_packet_param_data* generateParamDataOneFromData(void* data,int size){
if (size < _XPPS_CD_FIXED_ALL) {
printf("XAI - CTRL DATA FIXED DATA SIZE ENOUGH");
return NULL;
}
_xai_packet_param_data* ctrl_param_data = generatePacketParamData();
//fixed
packet_to_param_helper(&ctrl_param_data->data_type, data, _XPP_CD_TYPE_START, _XPP_CD_TYPE_END);
packet_to_param_helper(&ctrl_param_data->data_len, data, _XPP_CD_LEN_START, _XPP_CD_LEN_END);
ctrl_param_data->data_len = CFSwapInt16(ctrl_param_data->data_len);
if (size < _XPPS_CD_FIXED_ALL + ctrl_param_data->data_len) {
purgePacketParamData(ctrl_param_data);
printf("XAI - CTRL DATA UNFIXED DATA SIZE ENOUGH");
return NULL;
}
/*type 大端 小端转化*/
void* in_data = malloc(ctrl_param_data->data_len);
memset(in_data, 0, ctrl_param_data->data_len);
memcpy(in_data, data+_XPP_CD_DATA_START, ctrl_param_data->data_len);
//packet_to_param_helper(in_data, data, _XPP_CD_DATA_START, _XPP_CD_DATA_START+ctrl_param_data->data_len);
if (XAI_DATA_TYPE_BIN_DIGITAL_UNSIGN == ctrl_param_data->data_type) {
SwapBytes(in_data, ctrl_param_data->data_len);
}
if (XAI_DATA_TYPE_BIN_APSN == ctrl_param_data->data_type) {
SwapBytes(in_data, ctrl_param_data->data_len);
}
if (XAI_DATA_TYPE_BIN_LUID == ctrl_param_data->data_type) {
SwapBytes(in_data, ctrl_param_data->data_len);
}
//unfixed
ctrl_param_data->data = malloc(ctrl_param_data->data_len);
memset(ctrl_param_data->data, 0, ctrl_param_data->data_len);
//packet_to_param_helper(ctrl_param_data->data, data, _XPP_CD_DATA_START, _XPP_CD_DATA_START+ctrl_param_data->data_len);
packet_to_param_helper(ctrl_param_data->data, in_data, 0, ctrl_param_data->data_len);
free(in_data);
return ctrl_param_data;
}
_xai_packet* generatePacketFromeDataOne(_xai_packet_param_data* ctrl_param_data){
if (ctrl_param_data == NULL) return NULL;
_xai_packet* ctrl_data = generatePacket();
char* payload = malloc(1000);
memset(payload,0,1000);
if(!payload) return NULL;
//big
uint16_t big_len = CFSwapInt16(ctrl_param_data->data_len);
//存入固定格式
param_to_packet_helper(payload, &ctrl_param_data->data_type, _XPP_CD_TYPE_START, _XPP_CD_TYPE_END);
param_to_packet_helper(payload, &big_len, _XPP_CD_LEN_START, _XPP_CD_LEN_END);
ctrl_data->pre_load = malloc(_XPPS_CD_FIXED_ALL);
memcpy(ctrl_data->pre_load, payload, _XPPS_CD_FIXED_ALL);
int pos = _XPPS_CD_FIXED_ALL;
if (NULL != ctrl_param_data->data) {
/*type 大端 小端转化*/
void* in_data = malloc(ctrl_param_data->data_len);
memset(in_data, 0, ctrl_param_data->data_len);
memcpy(in_data, ctrl_param_data->data, ctrl_param_data->data_len);
if (XAI_DATA_TYPE_BIN_DIGITAL_UNSIGN == ctrl_param_data->data_type) {
SwapBytes(in_data, ctrl_param_data->data_len);
}
if (XAI_DATA_TYPE_BIN_APSN == ctrl_param_data->data_type) {
SwapBytes(in_data, ctrl_param_data->data_len);
}
if (XAI_DATA_TYPE_BIN_LUID == ctrl_param_data->data_type) {
SwapBytes(in_data, ctrl_param_data->data_len);
}
ctrl_data->data_load = malloc(ctrl_param_data->data_len);
memset(ctrl_data->data_load, 0, ctrl_param_data->data_len);
memcpy(ctrl_data->data_load, in_data, ctrl_param_data->data_len);
//param_to_packet_helper(payload, in_data, 0 , 0 + ctrl_param_data->data_len);
memcpy(payload+pos, in_data, ctrl_param_data->data_len);
pos += ctrl_param_data->data_len;
free(in_data);
in_data = NULL;
}else{
ctrl_data->data_load = NULL;
}
ctrl_data->all_load = malloc(pos);
memcpy(ctrl_data->all_load, payload, pos);
ctrl_data->size = pos;
free(payload);
return ctrl_data;
}
OSErr SplitFileIfNeeded(FSRef * inFileReference,FSRef * inParentReference,FSCatalogInfo * inFileCatalogInfo,HFSUniStr255 * inFileName)
{
OSErr tErr;
Boolean splitNeeded=FALSE;
SInt16 tForkRefNum;
UInt32 tResourceForkSize=0;
static HFSUniStr255 sResourceForkName={0,{}};
Boolean hasResourceFork=FALSE;
static UInt8 tPOSIXPath[PATH_MAX*2+1];
static UInt32 tPOSIXPathMaxLength=PATH_MAX*2;
struct stat tFileStat;
SInt16 tNewFileRefNum;
if (sResourceForkName.length==0)
{
tErr=FSGetResourceForkName(&sResourceForkName);
if (tErr!=noErr)
{
logerror("An error occurred when obtaining the ResourceFork name\n");
return -1;
}
}
// 1. Check for the presence of a resource fork
tErr=FSOpenFork(inFileReference,sResourceForkName.length,sResourceForkName.unicode,fsRdPerm,&tForkRefNum);
if (tErr==noErr)
{
SInt64 tForkSize;
// Get the size of the resource fork
tErr=FSGetForkSize(tForkRefNum,&tForkSize);
if (tErr!=noErr)
{
logerror("An error occurred on getting the resource fork size of a file or director\n");
FSCloseFork(tForkRefNum);
return -1;
}
if (tForkSize>0xFFFFFFFF)
{
FSCloseFork(tForkRefNum);
// AppleDouble File format does not support forks bigger than 2GB
logerror("AppleDouble file format does not support forks bigger than 2 GB\n");
return -1;
}
tResourceForkSize=tForkSize;
if (tForkSize>0)
{
hasResourceFork=TRUE;
splitNeeded=TRUE;
}
else
{
FSCloseFork(tForkRefNum);
}
}
else
{
switch(tErr)
{
case errFSForkNotFound:
case eofErr:
// No resource Fork
tErr=noErr;
break;
default:
logerror("Unable to open fork\n");
return -1;
break;
}
}
// 2. Check for the presence of FinderInfo or ExtFinderInfo
if (splitNeeded==FALSE)
{
UInt32 * tUnsignedInt32Ptr;
int i;
// 1. We need to save the Folder(Ext) Info in the ._ file if there are any folder/finder or extend folder/finder info
tUnsignedInt32Ptr= (UInt32 *) inFileCatalogInfo->finderInfo;
for(i=0;i<4;i++)
{
if (tUnsignedInt32Ptr[i]!=0)
{
// We need to create a ._file
splitNeeded=TRUE;
break;
}
}
if (splitNeeded==TRUE) // 01/02/07: Symbolic link looks like this
{
UInt32 tSymbolicLink;
tSymbolicLink='s';
tSymbolicLink='l'+(tSymbolicLink<<8);
tSymbolicLink='n'+(tSymbolicLink<<8);
tSymbolicLink='k'+(tSymbolicLink<<8);
if (tUnsignedInt32Ptr[0]==tSymbolicLink)
{
splitNeeded=FALSE;
}
}
else
{
tUnsignedInt32Ptr= (UInt32 *) inFileCatalogInfo->extFinderInfo;
for(i=0;i<4;i++)
{
if (tUnsignedInt32Ptr[i]!=0)
{
// We need to create a ._file
splitNeeded=TRUE;
break;
}
}
}
}
// 3. Split if needed
if (splitNeeded==TRUE)
{
FSRef tNewFileReference;
HFSUniStr255 tNewFileName;
// Get the absolute Posix Path Name
tErr=FSRefMakePath(inFileReference,tPOSIXPath,tPOSIXPathMaxLength);
if (tErr==noErr)
{
if (lstat((char *) tPOSIXPath,&tFileStat)==-1)
{
switch(errno)
{
case ENOENT:
// A COMPLETER
break;
default:
// A COMPLETER
break;
}
tErr=-1;
goto byebye;
}
}
else
{
logerror("An error occurred when trying to get the absolute path of a file or directory\n");
tErr=-1;
goto byebye;
}
if (gVerboseMode==TRUE)
{
printf(" splitting %s...\n",tPOSIXPath);
}
// Check that we do not explode the current limit for file names
if (inFileName->length>gMaxFileNameLength)
{
// We do not have enough space to add the ._ prefix
// The file name is too long
// Write the error
logerror("File name is too long. The maximum length allowed is %ld characters\n",gMaxFileNameLength+2);
return -1;
}
tNewFileName.length=inFileName->length+2;
tNewFileName.unicode[0]='.';
tNewFileName.unicode[1]='_';
BlockMoveData(inFileName->unicode,tNewFileName.unicode+2,inFileName->length*sizeof(UniChar));
// We need to create a ._file
tryagain:
tErr=FSCreateFileUnicode(inParentReference,tNewFileName.length,tNewFileName.unicode,0,NULL,&tNewFileReference,NULL);
if (tErr!=noErr)
{
switch(tErr)
{
case bdNamErr:
case fsmBadFFSNameErr:
case errFSNameTooLong:
// The file name is too long
// Write the error
logerror("File name is too long. The maximum length allowed is %ld characters\n",gMaxFileNameLength+2);
break;
case dskFulErr:
logerror("Disk is full\n");
break;
case errFSQuotaExceeded:
logerror("Your quota are exceeded\n");
break;
case dupFNErr:
// The file already exists, we need to try to delete it before recreating it
tErr=FSMakeFSRefUnicode(inParentReference,tNewFileName.length,tNewFileName.unicode,kTextEncodingDefaultFormat,&tNewFileReference);
if (tErr==noErr)
{
// Delete the current ._file
tErr=FSDeleteObject(&tNewFileReference);
if (tErr==noErr)
{
goto tryagain;
}
else
{
// A COMPLETER
}
}
else
{
// A COMPLETER
}
break;
case afpVolLocked:
// A COMPLETER
break;
default:
// A COMPLETER
break;
}
return -1;
}
tErr=FSOpenFork(&tNewFileReference,0,NULL,fsWrPerm,&tNewFileRefNum);
if (tErr==noErr)
{
unsigned char tAppleDoubleMagicNumber[4]= {0x00,0x05,0x16,0x07};
unsigned char tAppleDoubleVersionNumber[4]={0x00,0x02,0x00,0x00};
unsigned char tAppleDoubleFiller[16]={0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00};
ByteCount tRequestCount;
UInt16 tNumberOfEntries;
UInt16 tSwappedNumberOfEntries;
UInt32 tEntryID;
UInt32 tEntryOffset;
UInt32 tEntryLength;
// Write the Magic Number
tRequestCount=4;
tErr=FSWriteFork(tNewFileRefNum,fsAtMark,0,tRequestCount,tAppleDoubleMagicNumber,NULL);
if (tErr!=noErr)
{
goto writebail;
}
// Write the Version Number
tRequestCount=4;
tErr=FSWriteFork(tNewFileRefNum,fsAtMark,0,tRequestCount,tAppleDoubleVersionNumber,NULL);
if (tErr!=noErr)
{
goto writebail;
}
// Write the Filler
tRequestCount=16;
tErr=FSWriteFork(tNewFileRefNum,fsAtMark,0,tRequestCount,tAppleDoubleFiller,NULL);
if (tErr!=noErr)
{
goto writebail;
}
// Compute the Number of Entries
tNumberOfEntries=0x0002;
tSwappedNumberOfEntries=tNumberOfEntries;
#ifdef __LITTLE_ENDIAN__
// Swap for Intel processor
tSwappedNumberOfEntries=CFSwapInt16(tSwappedNumberOfEntries);
#endif
tRequestCount=2;
tErr=FSWriteFork(tNewFileRefNum,fsAtMark,0,tRequestCount,&tSwappedNumberOfEntries,NULL);
if (tErr!=noErr)
{
goto writebail;
}
// Write the Entries Descriptor
// **** Finder Info
tEntryID=0x00000009; // Finder Info ID
tEntryOffset=0x0000001A+tNumberOfEntries*12;
tEntryLength=0x00000020; // 32 bytes
#ifdef __LITTLE_ENDIAN__
// Swap for Intel processor
tEntryID=CFSwapInt32(tEntryID);
tEntryOffset=CFSwapInt32(tEntryOffset);
tEntryLength=CFSwapInt32(tEntryLength);
#endif
tRequestCount=4;
tErr=FSWriteFork(tNewFileRefNum,fsAtMark,0,tRequestCount,&tEntryID,NULL);
if (tErr!=noErr)
{
goto writebail;
}
tErr=FSWriteFork(tNewFileRefNum,fsAtMark,0,tRequestCount,&tEntryOffset,NULL);
if (tErr!=noErr)
{
goto writebail;
}
tErr=FSWriteFork(tNewFileRefNum,fsAtMark,0,tRequestCount,&tEntryLength,NULL);
if (tErr!=noErr)
{
goto writebail;
}
tEntryID=0x00000002; // Resource Fork ID
tEntryOffset=0x00000052;
if (hasResourceFork==TRUE)
{
// **** Finder Info
tEntryLength=tResourceForkSize; // As you can see the AppleDouble format file is not ready for forks bigger than 2 GB
}
else
{
tEntryLength=0;
}
#ifdef __LITTLE_ENDIAN__
// Swap for Intel processor
tEntryID=CFSwapInt32(tEntryID);
tEntryOffset=CFSwapInt32(tEntryOffset);
tEntryLength=CFSwapInt32(tEntryLength);
#endif
tRequestCount=4;
tErr=FSWriteFork(tNewFileRefNum,fsAtMark,0,tRequestCount,&tEntryID,NULL);
if (tErr!=noErr)
{
goto writebail;
}
tErr=FSWriteFork(tNewFileRefNum,fsAtMark,0,tRequestCount,&tEntryOffset,NULL);
if (tErr!=noErr)
{
goto writebail;
}
tErr=FSWriteFork(tNewFileRefNum,fsAtMark,0,tRequestCount,&tEntryLength,NULL);
if (tErr!=noErr)
{
goto writebail;
}
// Write the Entries
// **** Write Finder Info
#ifdef __LITTLE_ENDIAN__
// Intel Processors
// Even though it's referenced as a bytes field in the File API, this is actually a structure we need to swap...
if (inFileCatalogInfo->nodeFlags & kFSNodeIsDirectoryMask)
{
// It's a fragging folder
FolderInfo * tFolderInfoStruct;
ExtendedFolderInfo * tExtendedFolderInfoStruct;
// Swap FolderInfo Structure
tFolderInfoStruct=(FolderInfo *) inFileCatalogInfo->finderInfo;
SWAP_RECT(tFolderInfoStruct->windowBounds);
tFolderInfoStruct->finderFlags=CFSwapInt16(tFolderInfoStruct->finderFlags);
SWAP_POINT(tFolderInfoStruct->location);
tFolderInfoStruct->reservedField=CFSwapInt16(tFolderInfoStruct->reservedField);
// Swap ExtendedFolderInfo Info Structure
tExtendedFolderInfoStruct=(ExtendedFolderInfo *) inFileCatalogInfo->extFinderInfo;
SWAP_POINT(tExtendedFolderInfoStruct->scrollPosition);
tExtendedFolderInfoStruct->reserved1=CFSwapInt32(tExtendedFolderInfoStruct->reserved1);
tExtendedFolderInfoStruct->extendedFinderFlags=CFSwapInt16(tExtendedFolderInfoStruct->extendedFinderFlags);
tExtendedFolderInfoStruct->reserved2=CFSwapInt16(tExtendedFolderInfoStruct->reserved2);
tExtendedFolderInfoStruct->putAwayFolderID=CFSwapInt32(tExtendedFolderInfoStruct->putAwayFolderID);
}
else
{
// I'm just a file, you know
FileInfo * tFileInfoStruct;
ExtendedFileInfo * tExtendedFileInfoStruct;
// Swap FileInfo Structure
tFileInfoStruct=(FileInfo *) inFileCatalogInfo->finderInfo;
tFileInfoStruct->fileType=CFSwapInt32(tFileInfoStruct->fileType);
tFileInfoStruct->fileCreator=CFSwapInt32(tFileInfoStruct->fileCreator);
tFileInfoStruct->finderFlags=CFSwapInt16(tFileInfoStruct->finderFlags);
SWAP_POINT(tFileInfoStruct->location);
tFileInfoStruct->reservedField=CFSwapInt16(tFileInfoStruct->reservedField);
// Swap ExtendedFileInfo Structure
tExtendedFileInfoStruct=(ExtendedFileInfo *) inFileCatalogInfo->extFinderInfo;
tExtendedFileInfoStruct->reserved1[0]=CFSwapInt16(tExtendedFileInfoStruct->reserved1[0]);
tExtendedFileInfoStruct->reserved1[1]=CFSwapInt16(tExtendedFileInfoStruct->reserved1[1]);
tExtendedFileInfoStruct->reserved1[2]=CFSwapInt16(tExtendedFileInfoStruct->reserved1[2]);
tExtendedFileInfoStruct->reserved1[3]=CFSwapInt16(tExtendedFileInfoStruct->reserved1[3]);
tExtendedFileInfoStruct->extendedFinderFlags=CFSwapInt16(tExtendedFileInfoStruct->extendedFinderFlags);
tExtendedFileInfoStruct->reserved2=CFSwapInt16(tExtendedFileInfoStruct->reserved2);
tExtendedFileInfoStruct->putAwayFolderID=CFSwapInt32(tExtendedFileInfoStruct->putAwayFolderID);
}
#endif
tRequestCount=16;
tErr=FSWriteFork(tNewFileRefNum,fsAtMark,0,tRequestCount,inFileCatalogInfo->finderInfo,NULL);
if (tErr!=noErr)
{
goto writebail;
}
tErr=FSWriteFork(tNewFileRefNum,fsAtMark,0,tRequestCount,inFileCatalogInfo->extFinderInfo,NULL);
if (tErr!=noErr)
{
goto writebail;
}
// **** Write Resource Fork?
if (hasResourceFork==TRUE)
{
// We need to be clever and copy the Resource Fork by chunks to avoid using too much memory
static UInt8 * tBuffer=NULL;
static ByteCount tReadRequestCount=0;
ByteCount tReadActualCount;
OSErr tReadErr;
#define GOLDIN_BUFFER_ONE_MEGABYTE_SIZE 1048576
if (tBuffer==NULL)
{
tReadRequestCount=GOLDIN_BUFFER_ONE_MEGABYTE_SIZE;
do
{
tBuffer=(UInt8 *) malloc(tReadRequestCount*sizeof(UInt8));
tReadRequestCount/=2;
}
while (tBuffer==NULL && tReadRequestCount>1);
if (tBuffer!=NULL && tReadRequestCount>1)
{
tReadRequestCount*=2;
}
else
{
// A COMPLETER
}
}
do
{
tReadErr=FSReadFork(tForkRefNum, fsAtMark,0, tReadRequestCount, tBuffer, &tReadActualCount);
if (tReadErr==noErr || tReadErr==eofErr)
{
tErr=FSWriteFork(tNewFileRefNum,fsAtMark,0,tReadActualCount,tBuffer,NULL);
if (tErr!=noErr)
{
break;
}
}
else
{
break;
}
}
while (tReadErr!=eofErr);
if (tReadErr!=eofErr)
{
// A problem occurred while reading the Resource Fork
goto writebail;
}
else
if (tErr!=noErr)
{
// A problem occurred while writing the Resource Fork Data to the AppleDouble file
goto writebail;
}
}
tErr=FSCloseFork(tNewFileRefNum);
tErr=noErr;
// Set the owner
tErr=FSSetCatalogInfo(&tNewFileReference,kFSCatInfoPermissions,inFileCatalogInfo);
if (tErr!=noErr)
{
//logerror("Permissions, owner and group could not be set for the AppleDouble file of %s\n",tPOSIXPath);
tErr=-1;
goto byebye;
}
}
else
{
// A COMPLETER
}
// Close the Resource Fork if needed
if (hasResourceFork==TRUE)
{
tErr=FSCloseFork(tForkRefNum);
if (gStripResourceForks==TRUE && tErr==noErr)
{
// Strip the resource fork
tErr=FSDeleteFork(inFileReference,sResourceForkName.length,sResourceForkName.unicode);
if (tErr!=noErr)
{
switch(tErr)
{
case errFSForkNotFound:
// This is not important
tErr=noErr;
break;
default:
// A COMPLETER
break;
}
}
}
else
{
if (gStripResourceForks==TRUE && tErr!=noErr)
{
logerror("Resource Fork could not be stripped from %s\n",tPOSIXPath);
// A COMPLETER
}
}
}
}
return tErr;
writebail:
switch(tErr)
{
case dskFulErr:
logerror("Disk is full\n");
break;
case errFSQuotaExceeded:
logerror("Your quota are exceeded\n");
break;
default:
logerror("An unknown error occurred while writing the AppleDouble file of %s\n",tPOSIXPath);
break;
}
FSCloseFork(tNewFileRefNum);
byebye:
if (hasResourceFork==TRUE)
{
FSCloseFork(tForkRefNum);
}
return tErr;
}
short SwapShort(unsigned short data)
{
return (short)CFSwapInt16(data);
}
/********************************************************************
* SwapShort
********************************************************************/
unsigned short SwapUShort(unsigned short data)
{
return CFSwapInt16(data);
}
int16_t SwapShort(uint16_t data)
{
return (int16_t)CFSwapInt16(data);
}
/********************************************************************
* SwapShort
********************************************************************/
uint16_t SwapUShort(uint16_t data)
{
return CFSwapInt16(data);
}
_xai_packet* generatePacketFromParamNormal(_xai_packet_param_normal* normal_param){
_xai_packet* packet = generatePacket();
uint8_t* payload = malloc(1000);
memset(payload,0,1000);
if(!payload){
return NULL;
}
uint16_t big_msgid = CFSwapInt16(normal_param->msgid);
uint16_t big_magic_number = CFSwapInt16(normal_param->magic_number);
uint16_t big_length = CFSwapInt16(normal_param->length);
void* big_from = generateSwapGUID(normal_param->from_guid);
void* big_to = generateSwapGUID(normal_param->to_guid);
//存入固定格式
param_to_packet_helper(payload, big_from,_XPP_N_FROM_GUID_START,_XPP_N_FROM_GUID_END);
param_to_packet_helper(payload, big_to ,_XPP_N_TO_GUID_START,_XPP_N_TO_GUID_END);
param_to_packet_helper(payload, &normal_param->flag, _XPP_N_FLAG_START, _XPP_N_FLAG_END);
param_to_packet_helper(payload, &big_msgid, _XPP_N_MSGID_START, _XPP_N_MSGID_END);
param_to_packet_helper(payload, &big_magic_number, _XPP_N_MAGIC_NUMBER_START, _XPP_N_MAGIC_NUMBER_END);
param_to_packet_helper(payload, &big_length, _XPP_N_LENGTH_START, _XPP_N_LENGTH_END);
purgeGUID(big_from);
purgeGUID(big_to);
/*fixed size */
packet->fix_pos = _XPPS_N_FIXED_ALL; //固定格式位置
unsigned int pos = _XPPS_N_FIXED_ALL;
/*preload --- fixed*/
packet->pre_load = malloc(pos);
memset(packet->pre_load, 0, pos);
memcpy(packet->pre_load, payload, pos);
/*allload*/
if (NULL != normal_param->data && 0 != normal_param->length){
packet->data_load = malloc(normal_param->length);
memset(packet->data_load, 0, normal_param->length);
memcpy(packet->data_load, normal_param->data, normal_param->length);
param_to_packet_helper(payload, normal_param->data, _XPPS_N_FIXED_ALL, _XPPS_N_FIXED_ALL+normal_param->length);
memcpy(payload+pos, normal_param->data, normal_param->length);
pos += normal_param->length;
}else{
packet->data_load = NULL;
}
//复制内存到all
packet->all_load = malloc(pos);
memset(packet->all_load, 0, pos);
memcpy(packet->all_load,payload,pos);
packet->size = pos;
free(payload);
return packet;
}