HRESULT Library_security_pkcs11_native_Microsoft_SPOT_Cryptoki_Decryptor::TransformFinalBlockInternal___SZARRAY_U1__SZARRAY_U1__I4__I4( CLR_RT_StackFrame& stack )
{
TINYCLR_HEADER();
CLR_RT_HeapBlock* pThis = stack.This();
CLR_RT_HeapBlock_Array* pData = stack.Arg1().DereferenceArray();
CLR_INT32 offset = stack.Arg2().NumericByRef().s4;
CLR_INT32 len = stack.Arg3().NumericByRef().s4;
CLR_RT_HeapBlock* pSession = pThis[Library_security_pkcs11_native_Microsoft_SPOT_Cryptoki_SessionContainer::FIELD__m_session].Dereference();
CLR_UINT32 decrSize = 0;
CK_SESSION_HANDLE hSession;
CLR_RT_HeapBlock hbRef;
CLR_RT_HeapBlock* pRet;
CLR_UINT32 maxOut;
FAULT_ON_NULL_ARG(pData);
FAULT_ON_NULL_ARG(pSession);
if((offset + len) > (CLR_INT32)pData->m_numOfElements) TINYCLR_SET_AND_LEAVE(CLR_E_OUT_OF_RANGE);
hSession = (CK_SESSION_HANDLE)pSession[Library_security_pkcs11_native_Microsoft_SPOT_Cryptoki_Session::FIELD__m_handle].NumericByRef().s4;
if(hSession == CK_SESSION_HANDLE_INVALID) TINYCLR_SET_AND_LEAVE(CLR_E_OBJECT_DISPOSED);
CRYPTOKI_CHECK_RESULT(stack, C_Decrypt(hSession, pData->GetElement(offset), len, NULL, (CK_ULONG_PTR)&decrSize));
maxOut = decrSize;
TINYCLR_CHECK_HRESULT(CLR_RT_HeapBlock_Array::CreateInstance(hbRef, decrSize, g_CLR_RT_WellKnownTypes.m_UInt8));
CRYPTOKI_CHECK_RESULT(stack, C_Decrypt(hSession, pData->GetElement(offset), len, hbRef.DereferenceArray()->GetFirstElement(), (CK_ULONG_PTR)&decrSize));
if(decrSize < maxOut)
{
CLR_RT_HeapBlock refSmall;
TINYCLR_CHECK_HRESULT(CLR_RT_HeapBlock_Array::CreateInstance(refSmall, decrSize, g_CLR_RT_WellKnownTypes.m_UInt8));
memcpy(refSmall.DereferenceArray()->GetFirstElement(), hbRef.DereferenceArray()->GetFirstElement(), decrSize);
pRet = refSmall.Dereference();
}
else
{
pRet = hbRef.Dereference();
}
stack.SetResult_Object(pRet);
TINYCLR_NOCLEANUP();
}
HRESULT Library_corlib_native_System_Reflection_Assembly::GetType___SystemType__STRING( CLR_RT_StackFrame& stack )
{
NATIVE_PROFILE_CLR_CORE();
TINYCLR_HEADER();
CLR_RT_Assembly_Instance assm;
CLR_RT_TypeDef_Index td;
CLR_RT_HeapBlock* hbRef;
CLR_RT_HeapBlock* hbObj;
LPCSTR szClass = stack.Arg1().RecoverString();
CLR_RT_HeapBlock* hbAsm = stack.Arg0().Dereference();
FAULT_ON_NULL(szClass);
FAULT_ON_NULL(hbAsm);
TINYCLR_CHECK_HRESULT(GetTypeDescriptor( *hbAsm, assm ));
hbRef = &stack.PushValueAndClear();
if(g_CLR_RT_TypeSystem.FindTypeDef( szClass, assm.m_assm, td ))
{
TINYCLR_CHECK_HRESULT(g_CLR_RT_ExecutionEngine.NewObjectFromIndex(*hbRef, g_CLR_RT_WellKnownTypes.m_TypeStatic));
hbObj = hbRef->Dereference();
hbObj->SetReflection( td );
}
TINYCLR_NOCLEANUP();
}
CLR_INT64* Library_corlib_native_System_TimeSpan::GetValuePtr( CLR_RT_HeapBlock& ref )
{
NATIVE_PROFILE_CLR_CORE();
CLR_RT_HeapBlock* obj = &ref;
CLR_DataType dt = obj->DataType();
if(dt == DATATYPE_OBJECT || dt == DATATYPE_BYREF)
{
obj = obj->Dereference(); if(!obj) return NULL;
dt = obj->DataType();
}
if(dt == DATATYPE_TIMESPAN)
{
return (CLR_INT64*)&obj->NumericByRef().s8;
}
if(dt == DATATYPE_I8)
{
return (CLR_INT64*)&obj->NumericByRef().s8;
}
if(dt == DATATYPE_VALUETYPE && obj->ObjectCls().m_data == g_CLR_RT_WellKnownTypes.m_TimeSpan.m_data)
{
return (CLR_INT64*)&obj[ FIELD__m_ticks ].NumericByRef().s8;
}
return NULL;
}
HRESULT Library_security_pkcs11_native_Microsoft_SPOT_Cryptoki_FindObjectEnum::FindObjectsInit___VOID__SZARRAY_MicrosoftSPOTCryptokiCryptokiAttribute( CLR_RT_StackFrame& stack )
{
TINYCLR_HEADER();
CLR_RT_HeapBlock* pThis = stack.This();
CLR_RT_HeapBlock_Array* pAttribs = stack.Arg1().DereferenceArray();
CLR_RT_HeapBlock* pAttrib;
CLR_RT_HeapBlock* pSession = pThis[Library_security_pkcs11_native_Microsoft_SPOT_Cryptoki_FindObjectEnum::FIELD__m_session].Dereference();
CK_SESSION_HANDLE hSession;
CK_ATTRIBUTE attribs[20];
CLR_UINT32 i;
FAULT_ON_NULL_ARG(pAttribs);
FAULT_ON_NULL(pSession);
if(pAttribs->m_numOfElements > ARRAYSIZE(attribs)) TINYCLR_SET_AND_LEAVE(CLR_E_OUT_OF_RANGE);
hSession = pSession[Library_security_pkcs11_native_Microsoft_SPOT_Cryptoki_Session::FIELD__m_handle].NumericByRef().u4;
pAttrib = (CLR_RT_HeapBlock*)pAttribs->GetFirstElement();
for(i=0; i<pAttribs->m_numOfElements; i++)
{
CLR_RT_HeapBlock* pElement = pAttrib->Dereference(); FAULT_ON_NULL(pElement);
CLR_RT_HeapBlock_Array* pValueArray = pElement[Library_security_pkcs11_native_Microsoft_SPOT_Cryptoki_CryptokiAttribute::FIELD__Value].DereferenceArray(); FAULT_ON_NULL(pValueArray);
attribs[i].type = pElement[Library_security_pkcs11_native_Microsoft_SPOT_Cryptoki_CryptokiAttribute::FIELD__Type].NumericByRef().u4;
attribs[i].pValue = pValueArray->GetFirstElement();
attribs[i].ulValueLen = pValueArray->m_numOfElements;
pAttrib++;
}
CRYPTOKI_CHECK_RESULT(stack, C_FindObjectsInit(hSession, attribs, pAttribs->m_numOfElements));
TINYCLR_NOCLEANUP();
}
void CLR_RT_DUMP::POST_PROCESS_EXCEPTION( CLR_RT_HeapBlock& ref )
{
// socket exceptions have an extra field (ErrorCode), so lets display that as well
if (CLR_RT_ExecutionEngine::IsInstanceOf( ref, g_CLR_RT_WellKnownTypes.m_SocketException ))
{
CLR_RT_HeapBlock* obj = ref.Dereference();
if(obj != NULL)
{
CLR_INT32 errorCode = obj[ Library_system_sockets_System_Net_Sockets_SocketException::FIELD___errorCode ].NumericByRef().s4;
CLR_Debug::Printf( " #### SocketException ErrorCode = %d\r\n", errorCode );
}
}
}
HRESULT Library_spot_native_Microsoft_SPOT_Reflection::GetAssemblies___STATIC__SZARRAY_mscorlibSystemReflectionAssembly( CLR_RT_StackFrame& stack )
{
NATIVE_PROFILE_CLR_CORE();
TINYCLR_HEADER();
CLR_RT_HeapBlock& top = stack.PushValueAndClear();
#if defined(TINYCLR_APPDOMAINS)
TINYCLR_CHECK_HRESULT(g_CLR_RT_ExecutionEngine.GetCurrentAppDomain()->GetAssemblies( top ));
#else
int count = 0;
CLR_RT_HeapBlock* pArray = NULL;
for(int pass=0; pass<2; pass++)
{
TINYCLR_FOREACH_ASSEMBLY(g_CLR_RT_TypeSystem)
{
if(pASSM->m_header->flags & CLR_RECORD_ASSEMBLY::c_Flags_Patch) continue;
if(pass == 0)
{
count++;
}
else
{
CLR_RT_HeapBlock* hbObj;
CLR_RT_Assembly_Index idx; idx.Set( pASSM->m_idx );
TINYCLR_CHECK_HRESULT(g_CLR_RT_ExecutionEngine.NewObjectFromIndex(*pArray, g_CLR_RT_WellKnownTypes.m_Assembly));
hbObj = pArray->Dereference();
hbObj->SetReflection( idx );
pArray++;
}
}
TINYCLR_FOREACH_ASSEMBLY_END();
if(pass == 0)
{
TINYCLR_CHECK_HRESULT(CLR_RT_HeapBlock_Array::CreateInstance( top, count, g_CLR_RT_WellKnownTypes.m_Assembly ));
pArray = (CLR_RT_HeapBlock*)top.DereferenceArray()->GetFirstElement();
}
}
#endif //TINYCLR_APPDOMAINS
TINYCLR_NOCLEANUP();
}
HRESULT CLR_RT_HeapBlock_XmlNameTable::AddEntry( CLR_RT_HeapBlock_String*& str, CLR_INT32 hashCode )
{
TINYCLR_HEADER();
CLR_RT_HeapBlock newEntryHB;
CLR_RT_HeapBlock_XmlNameTable_Entry* newEntry;
CLR_RT_HeapBlock* entryHB;
CLR_INT32 count;
// create a new instance of the Entry object
TINYCLR_CHECK_HRESULT(g_CLR_RT_ExecutionEngine.NewObjectFromIndex( newEntryHB, g_CLR_RT_WellKnownTypes.m_XmlNameTable_Entry ));
newEntry = (CLR_RT_HeapBlock_XmlNameTable_Entry*)newEntryHB.Dereference();
// attach it to the front of the bucket
entryHB = (CLR_RT_HeapBlock*)GetEntries()->GetElement( GetMask() & hashCode );
newEntry->SetStr( str );
newEntry->SetHashCode( hashCode );
newEntry->SetNext( (CLR_RT_HeapBlock_XmlNameTable_Entry*)entryHB->Dereference() );
entryHB->SetObjectReference( newEntry );
count = GetCount() + 1;
SetCount( count );
// if we reach the threshold, we'll grow the buckets
if(count == GetMask())
{
Grow();
}
TINYCLR_NOCLEANUP();
}
HRESULT CLR_RT_HeapBlock_XmlNameTable::Grow()
{
TINYCLR_HEADER();
CLR_RT_HeapBlock_Array* oldEntries;
CLR_RT_HeapBlock newEntriesHB;
CLR_RT_HeapBlock_Array* newEntries;
CLR_RT_HeapBlock_XmlNameTable_Entry* entry;
CLR_RT_HeapBlock_XmlNameTable_Entry* next;
CLR_RT_HeapBlock* newEntryHB;
CLR_UINT32 i;
CLR_INT32 newIndex;
CLR_INT32 newMask;
newMask = GetMask() * 2 + 1;
// allocate a new instance of Entry array
TINYCLR_CHECK_HRESULT(CLR_RT_HeapBlock_Array::CreateInstance( newEntriesHB, newMask + 1, g_CLR_RT_WellKnownTypes.m_XmlNameTable_Entry ));
newEntries = newEntriesHB.DereferenceArray();
oldEntries = GetEntries();
// Go through the old buckets, and resort them
for(i = 0; i < oldEntries->m_numOfElements; i++)
{
entry = (CLR_RT_HeapBlock_XmlNameTable_Entry*)((CLR_RT_HeapBlock*)oldEntries->GetElement( i ))->Dereference();
while(entry != NULL)
{
newIndex = entry->GetHashCode() & newMask;
next = entry->GetNext();
newEntryHB = (CLR_RT_HeapBlock*)newEntries->GetElement( newIndex );
entry->SetNext( (CLR_RT_HeapBlock_XmlNameTable_Entry*)newEntryHB->Dereference() );
newEntryHB->SetObjectReference( entry );
entry = next;
}
}
SetEntries( newEntries );
SetMask ( newMask );
TINYCLR_NOCLEANUP();
}
HRESULT Library_corlib_native_System_Reflection_RuntimeFieldInfo::GetValue___OBJECT__OBJECT( CLR_RT_StackFrame& stack )
{
NATIVE_PROFILE_CLR_CORE();
TINYCLR_HEADER();
CLR_RT_HeapBlock* argObj = &stack.Arg1();
CLR_RT_FieldDef_Instance instFD;
CLR_RT_TypeDef_Instance instTD;
const CLR_RECORD_FIELDDEF* fd;
CLR_RT_HeapBlock* obj;
CLR_RT_HeapBlock dst;
TINYCLR_CHECK_HRESULT(Library_corlib_native_System_Reflection_FieldInfo::Initialize( stack, instFD, instTD, obj ));
fd = instFD.m_target;
if(fd->flags & CLR_RECORD_FIELDDEF::FD_NoReflection) // don't allow reflection for fields with NoReflection attribute
{
TINYCLR_SET_AND_LEAVE(CLR_E_NOT_SUPPORTED);
}
{
dst.Assign( *obj );
#if defined(TINYCLR_APPDOMAINS)
//Marshal if necessary.
if(argObj->IsTransparentProxy())
{
_ASSERTE(argObj->DataType() == DATATYPE_OBJECT);
argObj = argObj->Dereference();
_ASSERTE(argObj != NULL && argObj->DataType() == DATATYPE_TRANSPARENT_PROXY);
TINYCLR_CHECK_HRESULT(argObj->TransparentProxyValidate());
TINYCLR_CHECK_HRESULT(g_CLR_RT_ExecutionEngine.GetCurrentAppDomain()->MarshalObject( *obj, dst, argObj->TransparentProxyAppDomain() ));
}
#endif
CLR_RT_HeapBlock& res = stack.PushValueAndAssign( dst );
TINYCLR_CHECK_HRESULT(res.PerformBoxingIfNeeded());
}
TINYCLR_NOCLEANUP();
}
// Note that prefix and namespaceURI need to be atomized (with nametable) prior to calling AddNamespace
HRESULT CLR_RT_HeapBlock_XmlNamespaceStack::AddNamespace( CLR_RT_HeapBlock_String* prefix, CLR_RT_HeapBlock_String* namespaceURI )
{
TINYCLR_HEADER();
CLR_RT_HeapBlock ref;
CLR_RT_HeapBlock_XmlNamespaceEntry* entry;
TINYCLR_CHECK_HRESULT(g_CLR_RT_ExecutionEngine.NewObjectFromIndex( ref, g_CLR_RT_WellKnownTypes.m_XmlReader_NamespaceEntry ));
entry = (CLR_RT_HeapBlock_XmlNamespaceEntry*)ref.Dereference();
entry->SetPrefix ( prefix );
entry->SetNamespaceURI( namespaceURI );
TINYCLR_SET_AND_LEAVE(Push( entry ));
TINYCLR_NOCLEANUP();
}
HRESULT Library_corlib_native_System_AppDomain::GetAppDomain( CLR_RT_HeapBlock& ref, CLR_RT_AppDomain*& appDomain, CLR_RT_AppDomain*& appDomainSav, bool fCheckForUnloadingAppDomain )
{
NATIVE_PROFILE_CLR_CORE();
TINYCLR_HEADER();
CLR_RT_HeapBlock* obj;
CLR_RT_ObjectToEvent_Source* src;
//Setting up appDomainSav is guaranteed to be initialized correctly by this function
appDomainSav = g_CLR_RT_ExecutionEngine.GetCurrentAppDomain();
_ASSERTE(ref.DataType() == DATATYPE_OBJECT);
obj = ref.Dereference(); FAULT_ON_NULL(obj);
if(obj->DataType() == DATATYPE_TRANSPARENT_PROXY)
{
appDomain = obj->TransparentProxyAppDomain();
if(!appDomain) TINYCLR_SET_AND_LEAVE(CLR_E_APPDOMAIN_EXITED);
obj = obj->TransparentProxyDereference(); FAULT_ON_NULL(obj);
}
_ASSERTE(obj->DataType() == DATATYPE_CLASS );
_ASSERTE(obj->ObjectCls().m_data == g_CLR_RT_WellKnownTypes.m_AppDomain.m_data);
src = CLR_RT_ObjectToEvent_Source::ExtractInstance( obj[ FIELD__m_appDomain ] ); FAULT_ON_NULL(src);
appDomain = (CLR_RT_AppDomain*)src->m_eventPtr ; FAULT_ON_NULL(appDomain);
_ASSERTE(appDomain->DataType() == DATATYPE_APPDOMAIN_HEAD);
if(fCheckForUnloadingAppDomain)
{
if(!appDomain->IsLoaded()) TINYCLR_SET_AND_LEAVE(CLR_E_APPDOMAIN_EXITED);
}
(void)g_CLR_RT_ExecutionEngine.SetCurrentAppDomain( appDomain );
TINYCLR_NOCLEANUP();
}
HRESULT Library_spot_hardware_native_Microsoft_SPOT_Hardware_I2CDevice__Configuration::GetInitialConfig(CLR_RT_HeapBlock& ref, I2C_USER_CONFIGURATION& nativeConfig)
{
NATIVE_PROFILE_CLR_HARDWARE();
TINYCLR_HEADER();
CLR_RT_HeapBlock* config = ref.Dereference();
FAULT_ON_NULL(config);
nativeConfig.Address = config[ FIELD__Address ].NumericByRef().u2;
nativeConfig.ClockRate = config[ FIELD__ClockRateKhz ].NumericByRef().s4;
if(nativeConfig.Address > c_MaxI2cAddress)
{
TINYCLR_SET_AND_LEAVE(CLR_E_INVALID_PARAMETER);
}
if(nativeConfig.ClockRate < c_MimimumClockRateKhz || c_MaximumClockRateKhz < nativeConfig.ClockRate)
{
TINYCLR_SET_AND_LEAVE(CLR_E_INVALID_PARAMETER)
}
TINYCLR_NOCLEANUP();
}
HRESULT Library_corlib_native_System_Reflection_Assembly::GetTypes___SZARRAY_SystemType( CLR_RT_StackFrame& stack )
{
NATIVE_PROFILE_CLR_CORE();
TINYCLR_HEADER();
CLR_RT_Assembly_Instance assm;
CLR_RT_HeapBlock* hbAsm = stack.Arg0().Dereference();
TINYCLR_CHECK_HRESULT(GetTypeDescriptor( *hbAsm, assm ));
{
CLR_RT_Assembly* pASSM = assm.m_assm;
CLR_UINT32 num = pASSM->m_pTablesSize[ TBL_TypeDef ];
CLR_RT_HeapBlock& top = stack.PushValue();
CLR_RT_HeapBlock* hbObj;
TINYCLR_CHECK_HRESULT(CLR_RT_HeapBlock_Array::CreateInstance( top, num, g_CLR_RT_WellKnownTypes.m_TypeStatic ));
if(num)
{
CLR_RT_HeapBlock* pArray = (CLR_RT_HeapBlock*)top.DereferenceArray()->GetFirstElement();
for(CLR_UINT32 i=0; i<num; i++, pArray++)
{
CLR_RT_TypeDef_Index idx; idx.Set( pASSM->m_idx, i );
TINYCLR_CHECK_HRESULT(g_CLR_RT_ExecutionEngine.NewObjectFromIndex(*pArray, g_CLR_RT_WellKnownTypes.m_TypeStatic));
hbObj = pArray->Dereference();
hbObj->SetReflection( idx );
}
}
}
TINYCLR_NOCLEANUP();
}
HRESULT CLR_RT_HeapBlock_Queue::Dequeue( CLR_RT_HeapBlock*& value )
{
NATIVE_PROFILE_CLR_CORE();
TINYCLR_HEADER();
CLR_RT_HeapBlock_Array* array = GetArray();
CLR_INT32 size = GetSize();
CLR_INT32 head = Head();
CLR_RT_HeapBlock* removed;
if(size == 0) TINYCLR_SET_AND_LEAVE(CLR_E_INVALID_OPERATION);
removed = (CLR_RT_HeapBlock*)array->GetElement( head );
value = removed->Dereference();
removed->SetObjectReference( NULL );
SetHead( (head + 1) % array->m_numOfElements );
SetSize( size - 1 );
TINYCLR_NOCLEANUP();
}
HRESULT CLR_RT_XmlState_BetweenElements::Process( CLR_RT_XmlState* st )
{
TINYCLR_HEADER();
CLR_RT_XmlState_BetweenElements* state = &st->BetweenElements;
CLR_RT_HeapBlock_XmlReader* reader = state->reader;
CLR_RT_HeapBlock_Stack* xmlNodes = reader->GetXmlNodes();
CLR_RT_HeapBlock_XmlNode* xmlNode;
CLR_UINT8* buffer = state->buffer;
if(state->fromEndElement)
{
CLR_UINT32 namespaceCount;
bool hasXmlSpace;
bool hasXmlLang;
CLR_RT_HeapBlock* tmp;
_ASSERTE(xmlNodes->GetSize() > 0);
_ASSERTE(reader->GetXmlSpaces()->GetSize() > 0);
_ASSERTE(reader->GetXmlLangs()->GetSize() > 0);
xmlNodes->Peek( (CLR_RT_HeapBlock*&)xmlNode );
xmlNode->GetFlags( namespaceCount, hasXmlSpace, hasXmlLang );
reader->GetNamespaces()->PopScope( namespaceCount );
if(hasXmlSpace)
{
reader->GetXmlSpaces()->Pop( tmp );
}
if(hasXmlLang)
{
reader->GetXmlLangs()->Pop( tmp );
}
reader->SetIsEmptyElement( false );
}
else
{
CLR_RT_HeapBlock xmlNodeHB;
TINYCLR_CHECK_HRESULT(g_CLR_RT_ExecutionEngine.NewObjectFromIndex( xmlNodeHB, g_CLR_RT_WellKnownTypes.m_XmlReader_XmlNode ));
xmlNode = (CLR_RT_HeapBlock_XmlNode*)xmlNodeHB.Dereference();
TINYCLR_CHECK_HRESULT(xmlNodes->Push( xmlNode ));
}
xmlNode->Clear();
TINYCLR_CHECK_HRESULT(reader->GetAttributes()->Clear());
if(*buffer == '<')
{
CLR_RT_XmlState_NewTag::Setup( st );
}
else if(c_XmlCharType[ *buffer ] & XmlCharType_Space)
{
CLR_RT_XmlState_InValue::SetupWhitespace( st, buffer );
}
else
{
if(state->docState != XmlDocState_MainDocument)
{
TINYCLR_SET_AND_LEAVE(XML_E_INVALID_ROOT_DATA);
}
CLR_RT_XmlState_InValue::SetupText( st, buffer, false );
}
TINYCLR_NOCLEANUP();
}
HRESULT CLR_RT_HeapBlock_Array::Copy( CLR_RT_HeapBlock_Array* arraySrc, int indexSrc, CLR_RT_HeapBlock_Array* arrayDst, int indexDst, int length )
{
NATIVE_PROFILE_CLR_CORE();
TINYCLR_HEADER();
if(length)
{
int numElemSrc = arraySrc->m_numOfElements;
int numElemDst = arrayDst->m_numOfElements;
if(length < 0 ||
indexSrc < 0 ||
indexDst < 0 ||
length + indexSrc > numElemSrc ||
length + indexDst > numElemDst )
{
TINYCLR_SET_AND_LEAVE(CLR_E_OUT_OF_RANGE);
}
//
// Copy of an array on itself.
//
if(arraySrc == arrayDst && indexSrc == indexDst) TINYCLR_SET_AND_LEAVE(S_OK);
if(arraySrc->SameHeader( *arrayDst ))
{
CLR_UINT8* dataSrc = arraySrc->GetFirstElement();
CLR_UINT8* dataDst = arrayDst->GetFirstElement();
CLR_UINT8 sizeElem = arraySrc->m_sizeOfElement;
dataSrc += indexSrc * sizeElem;
dataDst += indexDst * sizeElem;
if(!arraySrc->m_fReference)
{
memmove( dataDst, dataSrc, length * sizeElem );
}
else
{
CLR_RT_HeapBlock* ptrSrc = (CLR_RT_HeapBlock*)dataSrc;
CLR_RT_HeapBlock* ptrDst = (CLR_RT_HeapBlock*)dataDst;
int incr;
if(arraySrc == arrayDst && ptrSrc < ptrDst)
{
incr = -1;
ptrSrc += length-1;
ptrDst += length-1;
}
else
{
incr = 1;
}
for(int i=0; i<length; i++, ptrSrc += incr, ptrDst += incr)
{
TINYCLR_CHECK_HRESULT(ptrDst->Reassign( *ptrSrc ));
}
}
}
else if(arraySrc->m_fReference && arrayDst->m_fReference)
{
CLR_RT_TypeDescriptor descSrc;
CLR_RT_TypeDescriptor descDst;
CLR_RT_HeapBlock* ptrSrc = (CLR_RT_HeapBlock*)arraySrc->GetElement( indexSrc );
CLR_RT_HeapBlock* ptrDst = (CLR_RT_HeapBlock*)arrayDst->GetElement( indexDst );
TINYCLR_CHECK_HRESULT(descDst.InitializeFromObject( *arrayDst )); descDst.GetElementType( descDst );
for(int i=0; i<length; i++, ptrSrc++, ptrDst++)
{
if(ptrSrc->DataType() == DATATYPE_OBJECT && ptrSrc->Dereference() == NULL)
{
;
}
else
{
TINYCLR_CHECK_HRESULT(descSrc.InitializeFromObject( *ptrSrc ));
if(CLR_RT_ExecutionEngine::IsInstanceOf( descSrc, descDst ) == false)
{
TINYCLR_SET_AND_LEAVE(CLR_E_INVALID_CAST);
}
}
TINYCLR_CHECK_HRESULT(ptrDst->Reassign( *ptrSrc ));
}
}
else
{
CLR_RT_TypeDescriptor descSrc;
CLR_RT_TypeDescriptor descDst;
CLR_RT_HeapBlock ref;
CLR_RT_HeapBlock elem; elem.SetObjectReference( NULL );
CLR_RT_ProtectFromGC gc( elem );
TINYCLR_CHECK_HRESULT(descDst.InitializeFromObject( *arrayDst )); descDst.GetElementType( descDst );
for(int i=0; i<length; i++)
{
ref.InitializeArrayReferenceDirect( *arraySrc, indexSrc++ ); TINYCLR_CHECK_HRESULT(elem.LoadFromReference( ref ));
if(elem.DataType() == DATATYPE_OBJECT && elem.Dereference() == NULL)
{
;
}
else
{
TINYCLR_CHECK_HRESULT(descSrc.InitializeFromObject( elem ));
if(CLR_RT_ExecutionEngine::IsInstanceOf( descSrc, descDst ) == false)
{
TINYCLR_SET_AND_LEAVE(CLR_E_INVALID_CAST);
}
}
ref.InitializeArrayReferenceDirect( *arrayDst, indexDst++ ); TINYCLR_CHECK_HRESULT(elem.StoreToReference( ref, 0 ));
}
}
}
TINYCLR_NOCLEANUP();
}
HRESULT Library_spot_net_security_native_Microsoft_SPOT_Net_Security_SslNative::InitHelper( CLR_RT_StackFrame& stack, bool isServer )
{
NATIVE_PROFILE_CLR_NETWORK();
TINYCLR_HEADER();
CLR_INT32 sslContext = -1;
CLR_INT32 sslMode = stack.Arg0().NumericByRef().s4;
CLR_INT32 sslVerify = stack.Arg1().NumericByRef().s4;
CLR_RT_HeapBlock *hbCert = stack.Arg2().Dereference();
CLR_RT_HeapBlock_Array* arrCA = stack.Arg3().DereferenceArray();
CLR_RT_HeapBlock_Array* arrCert = NULL;
CLR_UINT8* sslCert = NULL;
int result;
int i;
bool isFirstCall = false;
LPCSTR szPwd = "";
if(!g_SSL_SeedData.Initialized)
{
BOOL fOK = FALSE;
isFirstCall = true;
#if !defined(_WIN32) && !defined(WIN32) && !defined(_WIN32_WCE)
int i;
if(!HAL_CONFIG_BLOCK::ApplyConfig( g_SSL_SeedData.Config.GetDriverName(), &g_SSL_SeedData.Config, sizeof(g_SSL_SeedData.Config) ))
{
return CLR_E_NOT_SUPPORTED;
}
// validate the security key (make sure it isn't all 0x00 or all 0xFF
for(i=1; i<sizeof(g_SSL_SeedData.Config.SslSeedKey) && !fOK; i++)
{
if( g_SSL_SeedData.Config.SslSeedKey[ i ] != 0 &&
g_SSL_SeedData.Config.SslSeedKey[ i ] != 0xFF &&
g_SSL_SeedData.Config.SslSeedKey[ i-1 ] != g_SSL_SeedData.Config.SslSeedKey[ i ])
{
fOK = TRUE;
}
}
if(!fOK)
{
return CLR_E_NOT_SUPPORTED;
}
#endif
g_SSL_SeedData.m_completion.Initialize();
g_SSL_SeedData.m_completion.InitializeForUserMode( UpdateSslSeedValue, NULL );
g_SSL_SeedData.Initialized = TRUE;
}
if(hbCert != NULL)
{
arrCert = hbCert[ Library_spot_native_System_Security_Cryptography_X509Certificates_X509Certificate::FIELD__m_certificate ].DereferenceArray(); //FAULT_ON_NULL(arrCert);
// If arrCert == NULL then the certificate is an X509Certificate2 which uses a certificate handle
if(arrCert == NULL)
{
arrCert = hbCert[ Library_spot_native_System_Security_Cryptography_X509Certificates_X509Certificate::FIELD__m_handle ].DereferenceArray(); FAULT_ON_NULL(arrCert);
// pass the certificate handle as the cert data parameter
sslCert = arrCert->GetFirstElement();
arrCert = hbCert[ Library_spot_native_System_Security_Cryptography_X509Certificates_X509Certificate::FIELD__m_sessionHandle ].DereferenceArray(); FAULT_ON_NULL(arrCert);
// pass the session handle as the ssl context parameter
sslContext = *(INT32*)arrCert->GetFirstElement();
// the certificate has already been loaded so just pass an empty string
szPwd = "";
}
else
{
arrCert->Pin();
sslCert = arrCert->GetFirstElement();
CLR_RT_HeapBlock *hbPwd = hbCert[ Library_spot_native_System_Security_Cryptography_X509Certificates_X509Certificate::FIELD__m_password ].Dereference();// FAULT_ON_NULL(hbPwd);
szPwd = hbPwd->StringText();
}
}
SSL_RegisterTimeCallback( Time_GetDateTime );
if(isServer)
{
result = (SSL_ServerInit( sslMode, sslVerify, (const char*)sslCert, sslCert == NULL ? 0 : arrCert->m_numOfElements, szPwd, sslContext ) ? 0 : -1);
}
else
{
result = (SSL_ClientInit( sslMode, sslVerify, (const char*)sslCert, sslCert == NULL ? 0 : arrCert->m_numOfElements, szPwd, sslContext ) ? 0 : -1);
}
TINYCLR_CHECK_HRESULT(ThrowOnError( stack, result ));
if(isFirstCall)
{
GenerateNewSslSeed();
}
if(arrCA != NULL)
{
for(i=0; i<(int)arrCA->m_numOfElements; i++)
{
hbCert = (CLR_RT_HeapBlock*)arrCA->GetElement( i ); FAULT_ON_NULL(hbCert);
hbCert = hbCert->Dereference(); FAULT_ON_NULL(hbCert);
arrCert = hbCert[ Library_spot_native_System_Security_Cryptography_X509Certificates_X509Certificate::FIELD__m_certificate ].DereferenceArray(); //FAULT_ON_NULL(arrCert);
// If arrCert == NULL then the certificate is an X509Certificate2 which uses a certificate handle
if(arrCert == NULL)
{
CLR_INT32 sessionCtx = 0;
arrCert = hbCert[ Library_spot_native_System_Security_Cryptography_X509Certificates_X509Certificate::FIELD__m_handle ].DereferenceArray(); FAULT_ON_NULL(arrCert);
sslCert = arrCert->GetFirstElement();
arrCert = hbCert[ Library_spot_native_System_Security_Cryptography_X509Certificates_X509Certificate::FIELD__m_sessionHandle ].DereferenceArray(); FAULT_ON_NULL(arrCert);
sessionCtx = *(INT32*)arrCert->GetFirstElement();
// pass the session handle down as the password paramter and the certificate handle as the data parameter
result = (SSL_AddCertificateAuthority( sslContext, (const char*)sslCert, arrCert->m_numOfElements, (LPCSTR)&sessionCtx ) ? 0 : -1);
TINYCLR_CHECK_HRESULT(ThrowOnError( stack, result ));
}
else
{
arrCert->Pin();
sslCert = arrCert->GetFirstElement();
CLR_RT_HeapBlock *hbPwd = hbCert[ Library_spot_native_System_Security_Cryptography_X509Certificates_X509Certificate::FIELD__m_password ].Dereference(); FAULT_ON_NULL(hbPwd);
LPCSTR szCAPwd = hbPwd->StringText();
result = (SSL_AddCertificateAuthority( sslContext, (const char*)sslCert, arrCert->m_numOfElements, szCAPwd ) ? 0 : -1);
TINYCLR_CHECK_HRESULT(ThrowOnError( stack, result ));
}
}
}
stack.SetResult_I4( sslContext );
TINYCLR_CLEANUP();
if(FAILED(hr) && (sslContext != -1))
{
SSL_ExitContext( sslContext );
}
TINYCLR_CLEANUP_END();
}
HRESULT CLR_RT_StackFrame::FixCall()
{
NATIVE_PROFILE_CLR_CORE();
TINYCLR_HEADER();
const CLR_RECORD_METHODDEF* target = m_call.m_target;
CLR_UINT8 numArgs = target->numArgs;
//
// The copy of ValueTypes is delayed as much as possible.
//
// If an argument is a ValueType, now it's a good time to clone it.
//
if(numArgs)
{
CLR_RT_SignatureParser parser;
parser.Initialize_MethodSignature( m_call.m_assm, target );
CLR_RT_SignatureParser::Element res;
CLR_RT_HeapBlock* args = m_arguments;
if(parser.m_flags & PIMAGE_CEE_CS_CALLCONV_HASTHIS)
{
args++;
}
//
// Skip return value.
//
TINYCLR_CHECK_HRESULT(parser.Advance( res ));
for(; parser.Available() > 0; args++)
{
TINYCLR_CHECK_HRESULT(parser.Advance( res ));
if(res.m_levels > 0) continue; // Array, no need to fix.
if(args->DataType() == DATATYPE_OBJECT)
{
CLR_RT_TypeDef_Instance inst;
inst.InitializeFromIndex( res.m_cls );
CLR_DataType dtT = (CLR_DataType)inst.m_target->dataType;
const CLR_RT_DataTypeLookup& dtl = c_CLR_RT_DataTypeLookup[ dtT ];
if(dtl.m_flags & (CLR_RT_DataTypeLookup::c_OptimizedValueType | CLR_RT_DataTypeLookup::c_ValueType))
{
CLR_RT_HeapBlock* value = args->FixBoxingReference();
FAULT_ON_NULL(value);
if(value->DataType() == dtT)
{
// It's a boxed primitive/enum type.
args->Assign( *value );
}
else if(args->Dereference()->ObjectCls().m_data == res.m_cls.m_data)
{
TINYCLR_CHECK_HRESULT(args->PerformUnboxing( inst ));
}
else
{
TINYCLR_SET_AND_LEAVE(CLR_E_WRONG_TYPE);
}
}
}
if(res.m_dt == DATATYPE_VALUETYPE && res.m_fByRef == false)
{
if(args->IsAReferenceOfThisType( DATATYPE_VALUETYPE ))
{
TINYCLR_CHECK_HRESULT(g_CLR_RT_ExecutionEngine.CloneObject( *args, *args ));
}
}
}
}
TINYCLR_NOCLEANUP();
}
HRESULT CLR_RT_StackFrame::HandleSynchronized( bool fAcquire, bool fGlobal )
{
NATIVE_PROFILE_CLR_CORE();
TINYCLR_HEADER();
CLR_RT_HeapBlock refType;
CLR_RT_HeapBlock* obj;
CLR_RT_HeapBlock ref;
CLR_RT_HeapBlock** ppGlobalLock;
CLR_RT_HeapBlock* pGlobalLock;
if(fGlobal)
{
obj = &ref;
#if defined(TINYCLR_APPDOMAINS)
//With AppDomains enabled, the global lock is no longer global. It is only global wrt the AppDomain/
//Do we need a GlobalGlobalLock? (an attribute on GloballySynchronized (GlobalAcrossAppDomain?)
ppGlobalLock = &g_CLR_RT_ExecutionEngine.GetCurrentAppDomain()->m_globalLock;
#else
ppGlobalLock = &g_CLR_RT_ExecutionEngine.m_globalLock;
#endif
pGlobalLock = *ppGlobalLock;
if(pGlobalLock)
{
obj->SetObjectReference( pGlobalLock );
}
else
{
//
// Create an private object to implement global locks.
//
TINYCLR_CHECK_HRESULT(g_CLR_RT_ExecutionEngine.NewObjectFromIndex( *obj, g_CLR_RT_WellKnownTypes.m_Object ));
*ppGlobalLock = obj->Dereference();
}
}
else if(m_call.m_target->flags & CLR_RECORD_METHODDEF::MD_Static)
{
CLR_RT_TypeDef_Index idx;
idx.Set( m_call.Assembly(), m_call.CrossReference().GetOwner() );
refType.SetReflection( idx );
obj = &refType;
}
else
{
obj = &Arg0();
}
if(fAcquire)
{
TINYCLR_SET_AND_LEAVE(g_CLR_RT_ExecutionEngine.LockObject( *obj, m_owningSubThread, TIMEOUT_INFINITE, false ));
}
else
{
TINYCLR_SET_AND_LEAVE(g_CLR_RT_ExecutionEngine.UnlockObject( *obj, m_owningSubThread ));
}
TINYCLR_NOCLEANUP();
}
HRESULT Library_corlib_native_System_Reflection_FieldInfo::SetValue___VOID__OBJECT__OBJECT( CLR_RT_StackFrame& stack )
{
NATIVE_PROFILE_CLR_CORE();
TINYCLR_HEADER();
CLR_RT_FieldDef_Instance instFD;
CLR_RT_TypeDef_Instance instTD;
CLR_RT_TypeDescriptor instTDescObj;
CLR_RT_TypeDef_Instance instTDField;
const CLR_RECORD_FIELDDEF* fd;
CLR_RT_HeapBlock* obj;
bool fValueType;
CLR_RT_HeapBlock& srcVal = stack.Arg2();
CLR_RT_HeapBlock& srcObj = stack.Arg1();
CLR_RT_HeapBlock val; val.Assign( srcVal );
CLR_RT_ProtectFromGC gc( val );
TINYCLR_CHECK_HRESULT(Library_corlib_native_System_Reflection_FieldInfo::Initialize( stack, instFD, instTD, obj ));
fd = instFD.m_target;
if(fd->flags & CLR_RECORD_FIELDDEF::FD_NoReflection) // don't allow reflection for fields with NoReflection attribute
{
TINYCLR_SET_AND_LEAVE(CLR_E_NOT_SUPPORTED);
}
TINYCLR_CHECK_HRESULT(instTDescObj.InitializeFromFieldDefinition(instFD));
// make sure the right side object is of the same type as the left side
if(NULL != val.Dereference() && !CLR_RT_ExecutionEngine::IsInstanceOf(val, instTDescObj.m_handlerCls)) TINYCLR_SET_AND_LEAVE(CLR_E_WRONG_TYPE);
fValueType = obj->IsAValueType();
if(fValueType || (c_CLR_RT_DataTypeLookup[ obj->DataType() ].m_flags & CLR_RT_DataTypeLookup::c_OptimizedValueType))
{
if(val.Dereference() == NULL || !val.Dereference()->IsBoxed()) TINYCLR_SET_AND_LEAVE(CLR_E_WRONG_TYPE);
if(fValueType)
{
_ASSERTE(NULL != obj->Dereference());
if(NULL == obj->Dereference()) TINYCLR_SET_AND_LEAVE(CLR_E_INVALID_PARAMETER);
instTDField.InitializeFromIndex( obj->Dereference()->ObjectCls() );
}
else
{
instTDField.InitializeFromIndex( *c_CLR_RT_DataTypeLookup[ obj->DataType() ].m_cls );
}
TINYCLR_CHECK_HRESULT(val.PerformUnboxing( instTDField ));
}
else
{
#if defined(TINYCLR_APPDOMAINS)
if(srcObj.IsTransparentProxy())
{
_ASSERTE(srcObj.DataType() == DATATYPE_OBJECT);
_ASSERTE(srcObj.Dereference() != NULL && srcObj.Dereference()->DataType() == DATATYPE_TRANSPARENT_PROXY);
TINYCLR_CHECK_HRESULT(srcObj.Dereference()->TransparentProxyValidate());
TINYCLR_CHECK_HRESULT(srcObj.Dereference()->TransparentProxyAppDomain()->MarshalObject( val, val ));
}
#endif
}
switch(obj->DataType())
{
case DATATYPE_DATETIME: // Special case.
case DATATYPE_TIMESPAN: // Special case.
obj->NumericByRef().s8 = val.NumericByRefConst().s8;
break;
default:
obj->Assign( val );
break;
}
TINYCLR_NOCLEANUP();
}
HRESULT CLR_RT_XmlState_InName::Process( CLR_RT_XmlState* st )
{
TINYCLR_HEADER();
CLR_RT_XmlState_InName* state = &st->InName;
if(state->stage == Xml_ProcessNameStage_InLocalName)
{
goto ProcessLocalName;
}
if(FAILED(hr = ProcessNameParts( state, state->nameLen, state->prefixStopMark )))
{
state->stage = Xml_ProcessNameStage_InPrefix;
TINYCLR_LEAVE();
}
if(*(state->buffer) == ':')
{
state->prefixLen = state->nameLen;
state->localName = state->buffer + 1;
state->stage = Xml_ProcessNameStage_InLocalName;
state->nameLen++; // for the ':'
if(++(state->buffer) == state->bufferEnd) TINYCLR_SET_AND_LEAVE(XML_E_NEED_MORE_DATA);
ProcessLocalName:
TINYCLR_CHECK_HRESULT(ProcessNameParts( state, state->localNameLen, state->localNameStopMark ));
state->nameLen += state->localNameLen;
}
else
{
state->localNameLen = state->nameLen;
}
{
CLR_RT_HeapBlock_XmlReader* reader = state->reader;
CLR_RT_HeapBlock_XmlNameTable* nameTable = reader->GetNameTable();
CLR_RT_HeapBlock_String* name = NULL;
CLR_RT_HeapBlock_String* prefix = NULL;
CLR_RT_HeapBlock_String* localName = NULL;
CLR_RT_XmlNameType type = state->type;
TINYCLR_CHECK_HRESULT(nameTable->Add( (LPCSTR)state->name , state->nameLen , name ));
TINYCLR_CHECK_HRESULT(nameTable->Add( (LPCSTR)state->prefix , state->prefixLen , prefix ));
TINYCLR_CHECK_HRESULT(nameTable->Add( (LPCSTR)state->localName, state->localNameLen, localName ));
if(type == XmlNameType_Element || type == XmlNameType_PITarget)
{
CLR_RT_HeapBlock_XmlNode* node;
TINYCLR_CHECK_HRESULT(reader->GetXmlNodes()->Peek( (CLR_RT_HeapBlock*&)node ));
node->SetName ( name );
node->SetPrefix ( prefix );
node->SetLocalName( localName );
if(type == XmlNameType_Element)
{
CLR_RT_XmlState_InStartElement::Setup( st );
}
else
{
CLR_RT_XmlState_InProcessingInstruction::Setup( st, state->buffer );
}
}
else // attribute or xml declaration
{
CLR_RT_HeapBlock attributeHB;
CLR_RT_HeapBlock_XmlAttribute* attribute;
CLR_INT32 index;
TINYCLR_CHECK_HRESULT(g_CLR_RT_ExecutionEngine.NewObjectFromIndex( attributeHB, g_CLR_RT_WellKnownTypes.m_XmlReader_XmlAttribute ));
attribute = (CLR_RT_HeapBlock_XmlAttribute*)attributeHB.Dereference();
attribute->SetName ( name );
attribute->SetPrefix ( prefix );
attribute->SetLocalName( localName );
TINYCLR_CHECK_HRESULT(reader->GetAttributes()->Add( attribute, index ));
CLR_RT_XmlState_InAttribute::Setup( st );
}
}
TINYCLR_NOCLEANUP();
}
