void BS_MemChunkHeader (MemChunkHeaderPtr pChunk) { typedef struct { UInt32 one; UInt32 two; } swap; if (! pChunk) return; ((swap*)pChunk)->one = BYTE_SWAP_32(((swap*)pChunk)->one); ((swap*)pChunk)->two = BYTE_SWAP_32(((swap*)pChunk)->two); }
void BS_MemMstrPtrTableHeader (MemMstrPtrTablePtr pTable) { if (! pTable) return; pTable->numEntries = BYTE_SWAP_16(pTable->numEntries); pTable->nextTblOffset = BYTE_SWAP_32(pTable->nextTblOffset); }
/* * Byte swap a database list. */ void BS_DatabaseListHeader (DatabaseListPtr pList) { if (! pList) return; pList->nextRecordListID = BYTE_SWAP_32(pList->nextRecordListID); pList->numDatabases = BYTE_SWAP_16(pList->numDatabases); }
/* * Does not swap the record list */ void BS_DatabaseHdrHeader (DatabaseHdrPtr pDatabase) { if (! pDatabase) return; pDatabase->attributes = BYTE_SWAP_16(pDatabase->attributes); pDatabase->version = BYTE_SWAP_16(pDatabase->version); pDatabase->creationDate = BYTE_SWAP_32(pDatabase->creationDate); pDatabase->modificationDate = BYTE_SWAP_32(pDatabase->modificationDate); pDatabase->lastBackupDate = BYTE_SWAP_32(pDatabase->lastBackupDate); pDatabase->modificationNumber = BYTE_SWAP_32(pDatabase->modificationNumber); pDatabase->appInfoID = BYTE_SWAP_32(pDatabase->appInfoID); pDatabase->sortInfoID = BYTE_SWAP_32(pDatabase->sortInfoID); pDatabase->type = BYTE_SWAP_32(pDatabase->type); pDatabase->creator = BYTE_SWAP_32(pDatabase->creator); pDatabase->uniqueIDSeed = BYTE_SWAP_32(pDatabase->uniqueIDSeed); }
/* PROTO */ uint32_t four_to_32(unsigned char *value) { uint32_t temp; memcpy(&temp, value, 4); if (endianness == HOST_LITTLE_ENDIAN) temp = BYTE_SWAP_32(temp); return temp; }
/* PROTO */ uint32_t pkt_get32(pkt_t * pkt) { uint32_t val; memcpy(&val, pkt->data + pkt->offset, 4); if (endianness == HOST_LITTLE_ENDIAN) val = BYTE_SWAP_32(val); pkt->offset += 4; return val; }
void BS_RecordListHeader (RecordListPtr pRecordList) { UInt8* pItem; if (! pRecordList) return; pItem = (UInt8*)(&(pRecordList->firstEntry)); pRecordList->nextRecordListID = BYTE_SWAP_32(pRecordList->nextRecordListID); pRecordList->numRecords = BYTE_SWAP_16(pRecordList->numRecords); }
/* Swaps only the MemHeapHeader, not the MemMstrPtrTable or its header */ void BS_HeapHeader (MemHeapHeaderUnionType* pHeader, UInt16 version) { if (! pHeader) return; pHeader->header.ver3.flags = BYTE_SWAP_16(pHeader->header.ver3.flags); switch (version) { case 1: pHeader->header.ver1.size = BYTE_SWAP_16(pHeader->header.ver1.size); break; case 2: pHeader->header.ver2.size = BYTE_SWAP_32(pHeader->header.ver2.size); break; case 3: case 4: pHeader->header.ver3.size = BYTE_SWAP_32(pHeader->header.ver3.size); pHeader->header.ver3.firstFreeChunkOffset = BYTE_SWAP_32(pHeader->header.ver3.firstFreeChunkOffset); } }
void BS_GenericList32 (void* pArray, UInt16 numEntries, UInt16 stepSize) { UInt16 idex; if (! pArray) return; for (idex = 0; idex < numEntries; idex++) { *(UInt32*)pArray = (UInt32) BYTE_SWAP_32 (*(UInt32*)pArray); pArray = (UInt8*)pArray + stepSize; } }
/* PROTO */ IMCOMM_RET pkt_add32(pkt_t * pkt, uint32_t val) { uint32_t tmpval; if (pkt_empty(pkt) < 4) return IMCOMM_RET_ERROR; if (endianness == HOST_BIG_ENDIAN) { memcpy(pkt->data + pkt->offset, &val, 4); } else { tmpval = BYTE_SWAP_32(val); memcpy(pkt->data + pkt->offset, &tmpval, 4); } pkt->offset += 4; return IMCOMM_RET_OK; }
void BS_SysNVParams (SysNVParamsPtr pParams) { if (! pParams) return; pParams->rtcHours = BYTE_SWAP_32(pParams->rtcHours); pParams->rtcHourMinSecCopy = BYTE_SWAP_32(pParams->rtcHourMinSecCopy); pParams->splashScreenPtr = (void*)BYTE_SWAP_32(pParams->splashScreenPtr); pParams->hardResetScreenPtr = (void*)BYTE_SWAP_32(pParams->hardResetScreenPtr); pParams->localeLanguage = BYTE_SWAP_16(pParams->localeLanguage); pParams->localeCountry = BYTE_SWAP_16(pParams->localeCountry); pParams->sysNVOEMStorage1 = BYTE_SWAP_32(pParams->sysNVOEMStorage1); pParams->sysNVOEMStorage2 = BYTE_SWAP_32(pParams->sysNVOEMStorage2); }
void BS_OverlaySpecHeader (OmOverlaySpecType* pOvly) { if (! pOvly) return; pOvly->version = BYTE_SWAP_16(pOvly->version); pOvly->flags = BYTE_SWAP_32(pOvly->flags); pOvly->baseChecksum = BYTE_SWAP_32(pOvly->baseChecksum); BS_Locale(&pOvly->targetLocale); pOvly->baseDBType = BYTE_SWAP_32(pOvly->baseDBType); pOvly->baseDBCreator = BYTE_SWAP_32(pOvly->baseDBCreator); pOvly->baseDBCreateDate = BYTE_SWAP_32(pOvly->baseDBCreateDate); pOvly->baseDBModDate = BYTE_SWAP_32(pOvly->baseDBModDate); pOvly->numOverlays = BYTE_SWAP_16(pOvly->numOverlays); }
void BS_StorageHeader (StorageHeaderPtr pStore) { if (! pStore) return; pStore->signature = BYTE_SWAP_32(pStore->signature); pStore->version = BYTE_SWAP_16(pStore->version); pStore->flags = BYTE_SWAP_16(pStore->flags); pStore->creationDate = BYTE_SWAP_32(pStore->creationDate); pStore->backupDate = BYTE_SWAP_32(pStore->backupDate); pStore->heapListOffset = BYTE_SWAP_32(pStore->heapListOffset); pStore->initCodeOffset1 = BYTE_SWAP_32(pStore->initCodeOffset1); pStore->initCodeOffset2 = BYTE_SWAP_32(pStore->initCodeOffset2); pStore->databaseDirID = BYTE_SWAP_32(pStore->databaseDirID); pStore->rsvSpace = BYTE_SWAP_32(pStore->rsvSpace); pStore->dynHeapSpace = BYTE_SWAP_32(pStore->dynHeapSpace); pStore->firstRAMBlockSize = BYTE_SWAP_32(pStore->firstRAMBlockSize); BS_SysNVParams(&(pStore->nvParams)); pStore->initCodeOffset3 = BYTE_SWAP_32(pStore->initCodeOffset3); pStore->crc = BYTE_SWAP_32(pStore->crc); }
void BS_CardHeader (CardHeaderPtr pCard) { if (! pCard) return; pCard->initStack = BYTE_SWAP_32(pCard->initStack); pCard->resetVector = BYTE_SWAP_32(pCard->resetVector); pCard->signature = BYTE_SWAP_32(pCard->signature); pCard->hdrVersion = BYTE_SWAP_16(pCard->hdrVersion); pCard->flags = BYTE_SWAP_16(pCard->flags); pCard->version = BYTE_SWAP_16(pCard->version); pCard->creationDate = BYTE_SWAP_32(pCard->creationDate); pCard->numRAMBlocks = BYTE_SWAP_16(pCard->numRAMBlocks); pCard->blockListOffset = BYTE_SWAP_32(pCard->blockListOffset); pCard->readWriteParmsOffset = BYTE_SWAP_32(pCard->readWriteParmsOffset); pCard->readWriteParmsSize = BYTE_SWAP_32(pCard->readWriteParmsSize); pCard->readOnlyParmsOffset = BYTE_SWAP_32(pCard->readOnlyParmsOffset); pCard->bigROMOffset = BYTE_SWAP_32(pCard->bigROMOffset); pCard->checksumBytes = BYTE_SWAP_32(pCard->checksumBytes); pCard->checksumValue = BYTE_SWAP_16(pCard->checksumValue); pCard->readWriteWorkingOffset= BYTE_SWAP_32(pCard->readWriteWorkingOffset); pCard->readWriteWorkingSize = BYTE_SWAP_32(pCard->readWriteWorkingSize); pCard->halCodeOffset = BYTE_SWAP_32(pCard->halCodeOffset); }