void WP_Message::PrepareReply( const WP_Packet& req, UINT32 flags, UINT32 payloadSize, UINT8* payload )
{
memcpy( m_header.m_signature, m_parent->m_szMarker ? m_parent->m_szMarker : MARKER_PACKET_V1, sizeof(m_header.m_signature) );
m_header.m_crcData = SUPPORT_ComputeCRC( payload, payloadSize, 0 );
m_header.m_cmd = req.m_cmd;
m_header.m_seq = m_parent->m_lastOutboundMessage++;
m_header.m_seqReply = req.m_seq;
m_header.m_flags = flags | WP_Flags::c_Reply;
m_header.m_size = payloadSize;
m_payload = payload;
//
// The CRC for the header is computed setting the CRC field to zero and then running the CRC algorithm.
//
m_header.m_crcHeader = 0;
#if defined(BIG_ENDIAN)
SwapEndian();
#endif
m_header.m_crcHeader = SUPPORT_ComputeCRC( (UINT8*)&m_header, sizeof(m_header), 0 );
#if defined(BIG_ENDIAN)
m_header.m_crcHeader = ::SwapEndian( m_header.m_crcHeader );
#endif
}
BOOL HAL_CONFIG_BLOCK::Prepare( const char* Name, void* Data, UINT32 Size )
{
if(Name == NULL || hal_strlen_s( Name ) >= sizeof(DriverName)) return FALSE;
memset( this, 0, sizeof(*this) );
this->Signature = c_Version_V2;
this->DataCRC = SUPPORT_ComputeCRC( Data, Size, 0 );
this->Size = Size;
hal_strcpy_s( this->DriverName, ARRAYSIZE(this->DriverName), Name );
this->HeaderCRC = SUPPORT_ComputeCRC( ((UINT8*)&DataCRC), sizeof(*this) - offsetof(HAL_CONFIG_BLOCK,DataCRC), c_Seed );
return TRUE;
}
BOOL UpdateValidationCRC::ValidateUpdate( MFUpdate* pUpdate, UINT8* pValidation, INT32 validationLen )
{
UINT8 buff[512];
INT32 len = sizeof(buff);
INT32 updateSize = pUpdate->Header.UpdateSize;
INT32 offset = 0;
UINT32 crc = 0;
if(pUpdate->Providers->Storage == NULL ) return FALSE;
if(validationLen != sizeof(crc)) return FALSE;
while(offset < updateSize)
{
if((offset + len) > updateSize)
{
len = updateSize - offset;
}
pUpdate->Providers->Storage->Read(pUpdate->StorageHandle, offset, buff, len);
crc = SUPPORT_ComputeCRC(buff, len, crc);
offset += len;
}
return crc == *(UINT32*)pValidation;
}
HRESULT Parse_GoodAssembly(IN PBYTE pvBase)
{
PBYTE pPtr = pvBase;
CLR_RECORD_ASSEMBLY reAssembly = {0};
ReadByteX(&reAssembly,pPtr,sizeof(CLR_RECORD_ASSEMBLY));
UINT32 u32HeaderCrc = reAssembly.headerCRC;
reAssembly.headerCRC = 0;
if(u32HeaderCrc != SUPPORT_ComputeCRC(&reAssembly,sizeof(CLR_RECORD_ASSEMBLY),0) ||
reAssembly.stringTableVersion != c_CLR_StringTable_Version ||
memcmp(reAssembly.marker,"MSSpot1",sizeof(reAssembly.marker))!=0 ||
reAssembly.assemblyCRC != SUPPORT_ComputeCRC(pPtr,reAssembly.startOfTables[ TBL_EndOfAssembly ] - sizeof(CLR_RECORD_ASSEMBLY),0))
{
return RESULT_INVALID_CHECKSUM;
}
return RESULT_SUCCESS;
}
bool WP_Message::VerifyHeader()
{
bool fRes;
#if !defined(BIG_ENDIAN)
UINT32 crc = m_header.m_crcHeader;
#else
UINT32 crc = ::SwapEndian( m_header.m_crcHeader );
#endif
m_header.m_crcHeader = 0;
fRes = SUPPORT_ComputeCRC( (UINT8*)&m_header, sizeof(m_header), 0 ) == crc;
m_header.m_crcHeader = crc;
return fRes;
}
BOOL SimpleStorage::Create( LPCSTR fileName, LPCSTR groupName, UINT32 fileType, UINT8* data, UINT32 dataLength )
{
BOOL retVal = FALSE;
SIMPLESTORAGE_FILE_HEADER header;
INT32 available;
if(fileName == NULL) return FALSE;
if(!Initialize()) return FALSE;
if(!SeekToFile(fileName, groupName, header, TRUE))
{
Compact();
if(!SeekToFile(fileName, groupName, header, TRUE)) return FALSE;
}
available = s_pCurrentStream->Length - s_pCurrentStream->CurrentIndex;
if(available < (INT32)dataLength)
{
Compact();
if(!SeekToFile(fileName, groupName, header, TRUE)) return FALSE;
}
header.Signature = SIMPLESTORAGE_FILE_SIGNATURE;
hal_strcpy_s(header.FileName, ARRAYSIZE(header.FileName), fileName);
if(groupName == NULL)
{
header.Group[0] = 0;
}
else
{
hal_strcpy_s(header.Group, ARRAYSIZE(header.Group), groupName);
}
header.FileType = fileType;
header.Length = dataLength;
header.Attrib = 0xFFFFFFFF; // uninitialized flash
header.HeaderCRC = SUPPORT_ComputeCRC(&header, sizeof(header) - sizeof(header.HeaderCRC) - sizeof(header.Attrib), 0);
if(s_pCurrentStream->Write((UINT8*)&header, sizeof(header)))
{
retVal = s_pCurrentStream->Write((UINT8*)data, dataLength);
}
return retVal;
}
BOOL HAL_CONFIG_BLOCK::IsGoodData() const
{
DEBUG_TRACE1( TRACE_CONFIG, "read Size=%5d\r\n", Size );
// what is the blob's CRC
UINT32 CRC = SUPPORT_ComputeCRC( Data(), Size, 0 );
DEBUG_TRACE1( TRACE_CONFIG, "calc blob CRC=0x%08x\r\n", CRC );
// this indicates that this record has been marked as invalid, but still allows the helper to move
// to the next record.
if(CRC != DataCRC)
{
return FALSE;
}
return TRUE;
}
BOOL SimpleStorage::ReadToNextFile(SIMPLESTORAGE_FILE_HEADER& header)
{
UINT32 crc = 0;
while(s_pCurrentStream->CurrentIndex + sizeof(header) < s_pCurrentStream->Length)
{
if(!s_pCurrentStream->ReadIntoBuffer((UINT8*)&header, sizeof(header))) return FALSE;
if(header.Signature == SIMPLESTORAGE_FILE_SIGNATURE_UNINIT)
{
s_pCurrentStream->Seek(-(sizeof(header)), BlockStorageStream::SeekCurrent);
return TRUE;
}
crc = SUPPORT_ComputeCRC(&header, sizeof(header) - sizeof(header.HeaderCRC) - sizeof(header.Attrib), 0);
if(header.HeaderCRC != crc)
{
UINT32 sig = 0;
while(s_pCurrentStream->CurrentIndex + sizeof(header) < s_pCurrentStream->Length)
{
if(!s_pCurrentStream->ReadIntoBuffer((UINT8*)&sig, sizeof(sig)))
{
return FALSE;
}
if(sig == SIMPLESTORAGE_FILE_SIGNATURE)
{
s_pCurrentStream->Seek(-4, BlockStorageStream::SeekCurrent);
break;
}
}
continue;
}
if(header.Attrib == SIMPLESTORAGE_DELETED_ATTRIB) s_pCurrentStream->Seek(ROUNDTOMULTIPLE(header.Length, 4), BlockStorageStream::SeekCurrent);
else return TRUE;
}
return FALSE;
}
HRESULT Library_spot_native_Microsoft_SPOT_Hardware_Utility::ComputeCRC___STATIC__U4__SZARRAY_U1__I4__I4__U4( CLR_RT_StackFrame& stack )
{
NATIVE_PROFILE_CLR_CORE();
TINYCLR_HEADER();
CLR_RT_HeapBlock* pArgs;
CLR_RT_HeapBlock_Array* array;
int offset;
int length;
CLR_UINT32 crc;
int totLength;
pArgs = &(stack.Arg0());
array = pArgs[ 0 ].DereferenceArray(); FAULT_ON_NULL(array);
offset = pArgs[ 1 ].NumericByRef().s4;
length = pArgs[ 2 ].NumericByRef().s4;
crc = pArgs[ 3 ].NumericByRef().u4;
totLength = array->m_numOfElements;
if(offset < 0 || offset > totLength)
{
TINYCLR_SET_AND_LEAVE(CLR_E_OUT_OF_RANGE);
}
if(length == -1)
{
length = totLength - offset;
}
else
{
if(length < 0 || (offset+length) > totLength)
{
TINYCLR_SET_AND_LEAVE(CLR_E_OUT_OF_RANGE);
}
}
crc = SUPPORT_ComputeCRC( array->GetElement( offset ), length, crc );
stack.SetResult( crc, DATATYPE_U4 );
TINYCLR_NOCLEANUP();
}
BOOL HAL_CONFIG_BLOCK::IsGoodBlock() const
{
if(Signature != c_Version_V2)
{
return FALSE;
}
DEBUG_TRACE2( TRACE_CONFIG, "read header CRC=0x%08x at %08x\r\n", HeaderCRC, (size_t)this );
// what is the header's CRC
UINT32 CRC = SUPPORT_ComputeCRC( ((UINT8*)&DataCRC), sizeof(*this) - offsetof(HAL_CONFIG_BLOCK,DataCRC), c_Seed );
DEBUG_TRACE1(TRACE_CONFIG, "calc header CRC=0x%08x\r\n", CRC);
if(CRC != HeaderCRC)
{
DEBUG_TRACE3( TRACE_ALWAYS, "FAILED HEADER CRC at %08x: 0x%08x != 0x%08x\r\n", (size_t)this, CRC, HeaderCRC );
return FALSE;
}
return TRUE;
}
BOOL UpdateValidationCRC::ValidatePacket( MFUpdate* pUpdate, UINT8* pPacket, INT32 packetLen, UINT8* pValidation, INT32 validationLen )
{
if(validationLen != sizeof(UINT32) || pPacket == NULL || pValidation == NULL) return FALSE;
return (SUPPORT_ComputeCRC(pPacket, packetLen, 0) == *(UINT32*)pValidation);
}
bool WP_Message::VerifyPayload()
{
if(m_payload == NULL && m_header.m_size) return false;
return SUPPORT_ComputeCRC( m_payload, m_header.m_size, 0 ) == m_header.m_crcData;
}
