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(); }