HRESULT Library_corlib_native_System_Text_UTF8Encoding::GetBytes___I4__STRING__I4__I4__SZARRAY_U1__I4( CLR_RT_StackFrame& stack )
{
NATIVE_PROFILE_CLR_CORE();
TINYCLR_HEADER();
size_t cMaxBytes;
LPCSTR str = stack.Arg1().RecoverString();
CLR_INT32 strIdx = stack.Arg2().NumericByRef().s4;
CLR_INT32 strCnt = stack.Arg3().NumericByRef().s4;
CLR_RT_HeapBlock_Array* pArrayBytes = stack.Arg4().DereferenceArray();
CLR_INT32 byteIdx = stack.Arg5().NumericByRef().s4;
FAULT_ON_NULL(str);
FAULT_ON_NULL(pArrayBytes);
cMaxBytes = hal_strlen_s(str);
if((strIdx + strCnt) > (CLR_INT32)cMaxBytes ) TINYCLR_SET_AND_LEAVE(CLR_E_OUT_OF_RANGE);
if((byteIdx + strCnt) > (CLR_INT32)pArrayBytes->m_numOfElements) TINYCLR_SET_AND_LEAVE(CLR_E_OUT_OF_RANGE);
memcpy(pArrayBytes->GetElement(byteIdx), &str[strIdx], strCnt);
stack.SetResult_I4(strCnt);
TINYCLR_NOCLEANUP();
}
HRESULT Library_corlib_native_System_Reflection_Assembly::GetVersion___VOID__BYREF_I4__BYREF_I4__BYREF_I4__BYREF_I4( CLR_RT_StackFrame& stack )
{
NATIVE_PROFILE_CLR_CORE();
TINYCLR_HEADER();
CLR_RT_StackFrame* caller = stack.Caller();
if(caller == NULL)
{
TINYCLR_SET_AND_LEAVE(S_OK);
}
else
{
CLR_RT_Assembly_Instance assm;
TINYCLR_CHECK_HRESULT(GetTypeDescriptor( stack.Arg0(), assm ));
const CLR_RECORD_VERSION& version = assm.m_assm->m_header->version;
// we do not check for the reference not to be NULL because this is an internal method
stack.Arg1().Dereference()->NumericByRef().s4 = version.iMajorVersion;
stack.Arg2().Dereference()->NumericByRef().s4 = version.iMinorVersion;
stack.Arg3().Dereference()->NumericByRef().s4 = version.iBuildNumber;
stack.Arg4().Dereference()->NumericByRef().s4 = version.iRevisionNumber;
}
TINYCLR_NOCLEANUP();
}
HRESULT Library_spot_hardware_native_Microsoft_SPOT_Hardware_SPI::InternalWriteRead___VOID__SZARRAY_U2__I4__I4__SZARRAY_U2__I4__I4__I4( CLR_RT_StackFrame& stack )
{
NATIVE_PROFILE_CLR_HARDWARE();
TINYCLR_HEADER();
{
CLR_RT_HeapBlock* pThis = stack.This(); FAULT_ON_NULL(pThis);
CLR_RT_HeapBlock_Array* writeBuffer = stack.Arg1().DereferenceArray(); FAULT_ON_NULL(writeBuffer);
CLR_INT32 writeOffset = stack.Arg2().NumericByRef().s4;
CLR_INT32 writeCount = stack.Arg3().NumericByRef().s4;
CLR_RT_HeapBlock_Array* readBuffer = stack.Arg4().DereferenceArray();
CLR_INT32 readOffset = stack.Arg5().NumericByRef().s4;
CLR_INT32 readCount = stack.Arg6().NumericByRef().s4;
CLR_UINT32 startReadOffset = stack.Arg7().NumericByRef().s4;
SPI_CONFIGURATION config;
TINYCLR_CHECK_HRESULT(Library_spot_hardware_native_Microsoft_SPOT_Hardware_SPI__Configuration::GetInitialConfig( pThis[ FIELD__m_config ], config ));
config.MD_16bits = TRUE;
CPU_SPI_Initialize();
if(!::CPU_SPI_nWrite16_nRead16(
config,
(CLR_UINT16*)writeBuffer->GetElement(writeOffset),
writeCount,
readBuffer == NULL ? NULL : (CLR_UINT16*)readBuffer ->GetElement(readOffset),
readBuffer == NULL ? 0 : readCount,
startReadOffset
))
{
TINYCLR_SET_AND_LEAVE(CLR_E_INVALID_OPERATION);
}
}
TINYCLR_NOCLEANUP();
}
HRESULT Library_security_pkcs11_native_Microsoft_SPOT_Cryptoki_CryptokiVerify::VerifyInternal___BOOLEAN__SZARRAY_U1__I4__I4__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_Array* pSig = stack.Arg4().DereferenceArray();
CLR_INT32 sigOff = stack.Arg5().NumericByRef().s4;
CLR_INT32 sigLen = stack.Arg6().NumericByRef().s4;
CLR_RT_HeapBlock* pSession = pThis[Library_security_pkcs11_native_Microsoft_SPOT_Cryptoki_SessionContainer::FIELD__m_session].Dereference();
CK_SESSION_HANDLE hSession;
bool retVal = false;
CK_RV result;
FAULT_ON_NULL_ARG(pData);
FAULT_ON_NULL_ARG(pSig);
if((offset + len ) > (CLR_INT32)pData->m_numOfElements) TINYCLR_SET_AND_LEAVE(CLR_E_OUT_OF_RANGE);
if((sigOff + sigLen) > (CLR_INT32)pSig->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);
result = C_Verify(hSession, pData->GetElement(offset), len, pSig->GetElement(sigOff), sigLen);
retVal = CKR_OK == result;
stack.SetResult_Boolean(retVal);
TINYCLR_NOCLEANUP();
}
// TODO: Make common functions for transformBlock for encrypt/decrypt when async logic is in place
HRESULT Library_security_pkcs11_native_Microsoft_SPOT_Cryptoki_Decryptor::TransformBlockInternal___I4__SZARRAY_U1__I4__I4__SZARRAY_U1__I4( CLR_RT_StackFrame& stack )
{
TINYCLR_HEADER();
CLR_RT_HeapBlock* pThis = stack.This();
CLR_RT_HeapBlock_Array* pData = stack.Arg1().DereferenceArray();
CLR_INT32 dataOffset = stack.Arg2().NumericByRef().s4;
CLR_INT32 dataLen = stack.Arg3().NumericByRef().s4;
CLR_RT_HeapBlock_Array* pOutput = stack.Arg4().DereferenceArray();
CLR_INT32 outOffset = stack.Arg5().NumericByRef().s4;
CLR_RT_HeapBlock* pSession = pThis[Library_security_pkcs11_native_Microsoft_SPOT_Cryptoki_SessionContainer::FIELD__m_session].Dereference();
CK_SESSION_HANDLE hSession;
CLR_UINT32 decrSize;
FAULT_ON_NULL_ARG(pData);
FAULT_ON_NULL_ARG(pOutput);
FAULT_ON_NULL_ARG(pSession);
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);
if((dataOffset + dataLen) > (CLR_INT32)pData->m_numOfElements ) TINYCLR_SET_AND_LEAVE(CLR_E_OUT_OF_RANGE);
if((outOffset ) > (CLR_INT32)pOutput->m_numOfElements) TINYCLR_SET_AND_LEAVE(CLR_E_OUT_OF_RANGE);
decrSize = pOutput->m_numOfElements - outOffset;
CRYPTOKI_CHECK_RESULT(stack, C_DecryptUpdate(hSession, pData->GetElement(dataOffset), dataLen, pOutput->GetElement(outOffset), (CK_ULONG_PTR)&decrSize));
stack.SetResult_I4(decrSize);
TINYCLR_NOCLEANUP();
}
HRESULT Library_spot_hardware_native_Microsoft_SPOT_Hardware_Port::_ctor___VOID__MicrosoftSPOTHardwareCpuPin__BOOLEAN__BOOLEAN__MicrosoftSPOTHardwarePortResistorMode( CLR_RT_StackFrame& stack )
{
TINYCLR_HEADER();
{
CLR_RT_HeapBlock* pThis = stack.This(); FAULT_ON_NULL(pThis);
CLR_UINT32 portId = stack.Arg1().NumericByRef().u4;
bool initialState = stack.Arg2().NumericByRef().u1 != 0;
bool glitchFilter = stack.Arg3().NumericByRef().u1 != 0;
GPIO_RESISTOR resistorMode = (GPIO_RESISTOR)stack.Arg4().NumericByRef().u4;
TINYCLR_CHECK_HRESULT(Microsoft_SPOT_Hardware_Port_Construct( pThis, portId, glitchFilter, resistorMode, GPIO_INT_NONE, initialState, false ));
}
TINYCLR_NOCLEANUP();
}
HRESULT Library_spot_hardware_native_Microsoft_SPOT_Hardware_Port::_ctor___VOID__MicrosoftSPOTHardwareCpuPin__BOOLEAN__MicrosoftSPOTHardwarePortResistorMode__MicrosoftSPOTHardwarePortInterruptMode( CLR_RT_StackFrame& stack )
{
NATIVE_PROFILE_CLR_HARDWARE();
TINYCLR_HEADER();
{
CLR_RT_HeapBlock* pThis = stack.This(); FAULT_ON_NULL(pThis);
CLR_UINT32 portId = stack.Arg1().NumericByRef().u4;
bool glitchFilterEnable = stack.Arg2().NumericByRef().u1 != 0;
GPIO_RESISTOR resistorMode = (GPIO_RESISTOR)stack.Arg3().NumericByRef().u4;
GPIO_INT_EDGE interruptMode = (GPIO_INT_EDGE)stack.Arg4().NumericByRef().u4;
TINYCLR_CHECK_HRESULT(Microsoft_SPOT_Hardware_Port_Construct( pThis, portId, glitchFilterEnable, resistorMode, interruptMode, false, false ));
}
TINYCLR_NOCLEANUP();
}
HRESULT Library_security_pkcs11_native_Microsoft_SPOT_Cryptoki_CryptokiRNG::GenerateRandom___VOID__SZARRAY_U1__I4__I4__BOOLEAN( CLR_RT_StackFrame& stack )
{
TINYCLR_HEADER();
CLR_RT_HeapBlock* pThis = stack.This();
CLR_RT_HeapBlock* pSession;
CLR_RT_HeapBlock_Array* pData = stack.Arg1().DereferenceArray();
CLR_INT32 offset = stack.Arg2().NumericByRef().s4;
CLR_INT32 len = stack.Arg3().NumericByRef().s4;
bool fNonZero = stack.Arg4().NumericByRef().s4 == 1;
CK_SESSION_HANDLE hSession;
CLR_UINT8* pDataElem;
FAULT_ON_NULL_ARG(pData);
if(len+offset > (CLR_INT32)pData->m_numOfElements) TINYCLR_SET_AND_LEAVE(CLR_E_OUT_OF_RANGE);
pSession = pThis[Library_security_pkcs11_native_Microsoft_SPOT_Cryptoki_SessionContainer::FIELD__m_session].Dereference(); FAULT_ON_NULL(pSession);
hSession = pSession[Library_security_pkcs11_native_Microsoft_SPOT_Cryptoki_Session::FIELD__m_handle].NumericByRef().s4;
pDataElem = pData->GetElement(offset);
CRYPTOKI_CHECK_RESULT(stack, C_GenerateRandom(hSession, pDataElem, len));
if(fNonZero)
{
int i,idx = -1;
CLR_UINT8 replacements[20];
for(i=0; i<len; i++)
{
if(*pDataElem == 0)
{
if(idx == -1 || idx >= ARRAYSIZE(replacements))
{
CRYPTOKI_CHECK_RESULT(stack, C_GenerateRandom(hSession, replacements, ARRAYSIZE(replacements)));
idx = 0;
}
*pDataElem = replacements[idx++];
}
}
}
TINYCLR_NOCLEANUP();
}
HRESULT Library_spot_hardware_native_Microsoft_SPOT_Hardware_HardwareProvider::NativeGetSerialPins___VOID__I4__BYREF_MicrosoftSPOTHardwareCpuPin__BYREF_MicrosoftSPOTHardwareCpuPin__BYREF_MicrosoftSPOTHardwareCpuPin__BYREF_MicrosoftSPOTHardwareCpuPin( CLR_RT_StackFrame& stack )
{
TINYCLR_HEADER();
CLR_RT_HeapBlock hbrxPin;
CLR_RT_HeapBlock hbtxPin;
CLR_RT_HeapBlock hbctsPin;
CLR_RT_HeapBlock hbrtsPin;
CLR_UINT32 port, rxPin, txPin, ctsPin, rtsPin;
port = stack.Arg1().NumericByRef().u4;
rxPin = (CLR_UINT32)-1; // GPIO_NONE
txPin = (CLR_UINT32)-1; // GPIO_NONE
ctsPin = (CLR_UINT32)-1; // GPIO_NONE
rtsPin = (CLR_UINT32)-1; // GPIO_NONE
// COM ports are numbered from 0 up
if(port >= CPU_USART_PortsCount())
{
TINYCLR_SET_AND_LEAVE(CLR_E_INVALID_PARAMETER);
}
::CPU_USART_GetPins( port, rxPin, txPin, ctsPin, rtsPin );
hbrxPin.SetInteger ( (CLR_INT32)rxPin ); TINYCLR_CHECK_HRESULT(hbrxPin.StoreToReference ( stack.Arg2(), 0 ));
hbtxPin.SetInteger ( (CLR_INT32)txPin ); TINYCLR_CHECK_HRESULT(hbtxPin.StoreToReference ( stack.Arg3(), 0 ));
hbctsPin.SetInteger( (CLR_INT32)ctsPin ); TINYCLR_CHECK_HRESULT(hbctsPin.StoreToReference( stack.Arg4(), 0 ));
hbrtsPin.SetInteger( (CLR_INT32)rtsPin ); TINYCLR_CHECK_HRESULT(hbrtsPin.StoreToReference( stack.ArgN(5), 0 ));
TINYCLR_NOCLEANUP();
}
HRESULT Library_spot_hardware_native_Microsoft_SPOT_Hardware_HardwareProvider::NativeGetLCDMetrics___VOID__BYREF_I4__BYREF_I4__BYREF_I4__BYREF_I4( CLR_RT_StackFrame& stack )
{
TINYCLR_HEADER();
CLR_RT_HeapBlock hbLength;
CLR_RT_HeapBlock hbWidth;
CLR_RT_HeapBlock hbBitPP;
CLR_RT_HeapBlock hbOrientation;
CLR_UINT32 length, width, bitPP, orientation;
width = LCD_SCREEN_WIDTH;
length = LCD_SCREEN_HEIGHT;
bitPP = LCD_SCREEN_BPP;
orientation = LCD_SCREEN_ORIENTATION;
hbLength.SetInteger( (CLR_INT32)length );TINYCLR_CHECK_HRESULT(hbLength.StoreToReference( stack.Arg1(), 0 ));
hbWidth.SetInteger (( CLR_INT32)width );TINYCLR_CHECK_HRESULT(hbWidth.StoreToReference ( stack.Arg2(), 0 ));
hbBitPP.SetInteger( (CLR_INT32)bitPP ); TINYCLR_CHECK_HRESULT(hbBitPP.StoreToReference( stack.Arg3(), 0 ));
hbOrientation.SetInteger( (CLR_INT32)orientation ); TINYCLR_CHECK_HRESULT(hbOrientation.StoreToReference( stack.Arg4(), 0 ));
TINYCLR_NOCLEANUP();
}
//--// SPI
HRESULT Library_spot_hardware_native_Microsoft_SPOT_Hardware_HardwareProvider::NativeGetSpiPins___VOID__MicrosoftSPOTHardwareSPISPImodule__BYREF_MicrosoftSPOTHardwareCpuPin__BYREF_MicrosoftSPOTHardwareCpuPin__BYREF_MicrosoftSPOTHardwareCpuPin( CLR_RT_StackFrame& stack )
{
TINYCLR_HEADER();
CLR_RT_HeapBlock hbmsk;
CLR_RT_HeapBlock hbmiso;
CLR_RT_HeapBlock hbmosi;
CLR_UINT32 port, msk, miso, mosi;
msk = (CLR_UINT32)-1; // GPIO_NONE
miso = (CLR_UINT32)-1; // GPIO_NONE
mosi = (CLR_UINT32)-1; // GPIO_NONE
port = stack.Arg1().NumericByRef().u4;
// SPI ports are numbered from 0 up
if(port >= CPU_SPI_PortsCount())
{
TINYCLR_SET_AND_LEAVE(CLR_E_INVALID_PARAMETER);
}
::CPU_SPI_GetPins( port, msk, miso, mosi );
hbmsk.SetInteger ( (CLR_INT32)msk ); TINYCLR_CHECK_HRESULT(hbmsk .StoreToReference( stack.Arg2(), 0 ));
hbmiso.SetInteger( (CLR_INT32)miso ); TINYCLR_CHECK_HRESULT(hbmiso.StoreToReference( stack.Arg3(), 0 ));
hbmosi.SetInteger( (CLR_INT32)mosi ); TINYCLR_CHECK_HRESULT(hbmosi.StoreToReference( stack.Arg4(), 0 ));
TINYCLR_NOCLEANUP();
}
HRESULT Library_spot_net_security_native_Microsoft_SPOT_Net_Security_SslNative::ReadWriteHelper( CLR_RT_StackFrame& stack, bool isWrite )
{
NATIVE_PROFILE_CLR_NETWORK();
TINYCLR_HEADER();
CLR_RT_HeapBlock* socket = stack.Arg0().Dereference();
CLR_RT_HeapBlock_Array* arrData = stack.Arg1().DereferenceArray();
CLR_INT32 offset = stack.Arg2().NumericByRef().s4;
CLR_INT32 count = stack.Arg3().NumericByRef().s4;
CLR_INT32 timeout_ms = stack.Arg4().NumericByRef().s4;
CLR_UINT8* buffer;
CLR_RT_HeapBlock hbTimeout;
CLR_INT32 totReadWrite;
bool fRes = true;
CLR_INT64 *timeout;
int result = 0;
CLR_INT32 handle;
if(count == 0)
{
stack.SetResult_I4( 0 );
TINYCLR_SET_AND_LEAVE(S_OK);
}
FAULT_ON_NULL(socket);
handle = socket[ Library_spot_net_native_Microsoft_SPOT_Net_SocketNative::FIELD__m_Handle ].NumericByRef().s4;
/* Because we could have been a rescheduled call due to a prior call that would have blocked, we need to see
* if our handle has been shutdown before continuing. */
if (handle == Library_spot_net_native_Microsoft_SPOT_Net_SocketNative::DISPOSED_HANDLE)
{
ThrowError( stack, CLR_E_OBJECT_DISPOSED );
TINYCLR_SET_AND_LEAVE(CLR_E_PROCESS_EXCEPTION);
}
FAULT_ON_NULL(arrData);
hbTimeout.SetInteger( timeout_ms );
TINYCLR_CHECK_HRESULT(stack.SetupTimeout( hbTimeout, timeout ));
//
// Push "totReadWrite" onto the eval stack.
//
if(stack.m_customState == 1)
{
stack.PushValueI4( 0 );
stack.m_customState = 2;
}
totReadWrite = stack.m_evalStack[ 1 ].NumericByRef().s4;
buffer = arrData->GetElement( offset + totReadWrite );
count -= totReadWrite;
if((offset + count + totReadWrite) > (int)arrData->m_numOfElements) TINYCLR_SET_AND_LEAVE(CLR_E_INDEX_OUT_OF_RANGE);
while(count > 0)
{
// first make sure we have data to read or ability to write
while(fRes)
{
if(!isWrite)
{
// check SSL_DataAvailable() in case SSL has already read and buffered socket data
result = SSL_DataAvailable(handle);
if((result > 0) || ((result < 0) && (SOCK_getlasterror() != SOCK_EWOULDBLOCK)))
{
break;
}
}
result = Library_spot_net_native_Microsoft_SPOT_Net_SocketNative::Helper__SelectSocket( handle, isWrite ? 1 : 0 );
if((result > 0) || ((result < 0) && (SOCK_getlasterror() != SOCK_EWOULDBLOCK)))
{
break;
}
// non-blocking - allow other threads to run while we wait for socket activity
TINYCLR_CHECK_HRESULT(g_CLR_RT_ExecutionEngine.WaitEvents( stack.m_owningThread, *timeout, CLR_RT_ExecutionEngine::c_Event_Socket, fRes ));
// timeout expired
if(!fRes)
{
result = SOCK_SOCKET_ERROR;
ThrowError(stack, SOCK_ETIMEDOUT);
TINYCLR_SET_AND_LEAVE( CLR_E_PROCESS_EXCEPTION );
}
}
// socket is in the excepted state, so let's bail out
if(SOCK_SOCKET_ERROR == result)
{
break;
}
if(isWrite)
{
result = SSL_Write( handle, (const char*)buffer, count );
}
else
{
result = SSL_Read( handle, (char*)buffer, count );
if(result == SSL_RESULT__WOULD_BLOCK)
{
continue;
}
}
// ThrowOnError expects anything other than 0 to be a failure - so return 0 if we don't have an error
if(result <= 0)
{
break;
}
buffer += result;
totReadWrite += result;
count -= result;
// read is non-blocking if we have any data
if(!isWrite && (totReadWrite > 0))
{
break;
}
stack.m_evalStack[ 1 ].NumericByRef().s4 = totReadWrite;
}
stack.PopValue(); // totReadWrite
stack.PopValue(); // Timeout
if(result < 0)
{
TINYCLR_CHECK_HRESULT(ThrowOnError( stack, result ));
}
stack.SetResult_I4( totReadWrite );
TINYCLR_NOCLEANUP();
}
HRESULT Library_spot_net_native_Microsoft_SPOT_Net_SocketNative::SendRecvHelper( CLR_RT_StackFrame& stack, bool fSend, bool fAddress )
{
NATIVE_PROFILE_CLR_NETWORK();
TINYCLR_HEADER();
CLR_RT_HeapBlock* socket = stack.Arg0().Dereference();
CLR_INT32 handle;
CLR_RT_HeapBlock_Array* arrData = stack.Arg1().DereferenceArray();
CLR_UINT32 offset = stack.Arg2().NumericByRef().u4;
CLR_UINT32 count = stack.Arg3().NumericByRef().u4;
CLR_INT32 flags = stack.Arg4().NumericByRef().s4;
CLR_INT32 timeout_ms = stack.ArgN(5).NumericByRef().s4;
CLR_RT_HeapBlock hbTimeout;
CLR_INT64* timeout;
CLR_UINT8* buf;
bool fRes = true;
CLR_INT32 totReadWrite;
CLR_INT32 ret = 0;
FAULT_ON_NULL(socket);
handle = socket[ FIELD__m_Handle ].NumericByRef().s4;
FAULT_ON_NULL(arrData);
if(offset + count > arrData->m_numOfElements) TINYCLR_SET_AND_LEAVE(CLR_E_INDEX_OUT_OF_RANGE);
/* Because we could have been a rescheduled call due to a prior call that would have blocked, we need to see
* if our handle has been shutdown before continuing. */
if (handle == DISPOSED_HANDLE)
{
ThrowError( stack, CLR_E_OBJECT_DISPOSED );
TINYCLR_SET_AND_LEAVE (CLR_E_PROCESS_EXCEPTION);
}
hbTimeout.SetInteger( timeout_ms );
TINYCLR_CHECK_HRESULT(stack.SetupTimeout( hbTimeout, timeout ));
//
// Push "totReadWrite" onto the eval stack.
//
if(stack.m_customState == 1)
{
stack.PushValueI4( 0 );
stack.m_customState = 2;
}
totReadWrite = stack.m_evalStack[ 1 ].NumericByRef().s4;
buf = arrData->GetElement( offset + totReadWrite );
count -= totReadWrite;
while(count > 0)
{
CLR_INT32 bytes = 0;
// first make sure we have data to read or ability to write
while(fRes)
{
ret = Helper__SelectSocket( handle, fSend ? 1 : 0 );
if(ret != 0) break;
// non-blocking - allow other threads to run while we wait for handle activity
TINYCLR_CHECK_HRESULT(g_CLR_RT_ExecutionEngine.WaitEvents( stack.m_owningThread, *timeout, CLR_RT_ExecutionEngine::c_Event_Socket, fRes ));
}
// timeout expired
if(!fRes)
{
ret = SOCK_SOCKET_ERROR;
ThrowError( stack, SOCK_ETIMEDOUT );
TINYCLR_SET_AND_LEAVE( CLR_E_PROCESS_EXCEPTION );
}
// socket is in the excepted state, so let's bail out
if(SOCK_SOCKET_ERROR == ret)
{
break;
}
if(fAddress)
{
struct SOCK_sockaddr addr;
CLR_UINT32 addrLen = sizeof(addr);
CLR_RT_HeapBlock& blkAddr = stack.ArgN( 6 );
if(fSend)
{
TINYCLR_CHECK_HRESULT(MarshalSockAddress( &addr, addrLen, blkAddr ));
bytes = SOCK_sendto( handle, (const char*)buf, count, flags, &addr, addrLen );
}
else
{
CLR_RT_HeapBlock* pBlkAddr = blkAddr.Dereference();
TINYCLR_CHECK_HRESULT(MarshalSockAddress( &addr, addrLen, *pBlkAddr ));
bytes = SOCK_recvfrom( handle, (char*)buf, count, flags, &addr, (int*)&addrLen );
if(bytes != SOCK_SOCKET_ERROR)
{
TINYCLR_CHECK_HRESULT(MarshalSockAddress( blkAddr, &addr, addrLen ));
}
}
}
else
{
if(fSend)
{
bytes = SOCK_send( handle, (const char*)buf, count, flags );
}
else
{
bytes = SOCK_recv( handle, (char*)buf, count, flags );
}
}
// send/recv/sendto/recvfrom failed
if(bytes == SOCK_SOCKET_ERROR)
{
CLR_INT32 err = SOCK_getlasterror();
if(err != SOCK_EWOULDBLOCK)
{
ret = SOCK_SOCKET_ERROR;
break;
}
continue;
}
// zero recv bytes indicates the handle has been closed.
else if(!fSend && (bytes == 0))
{
break;
}
buf += bytes;
totReadWrite += bytes;
count -= bytes;
stack.m_evalStack[ 1 ].NumericByRef().s4 = totReadWrite;
// receive returns immediately after receiving bytes.
if(!fSend && (totReadWrite > 0))
{
break;
}
}
stack.PopValue(); // totReadWrite
stack.PopValue(); // Timeout
TINYCLR_CHECK_HRESULT(ThrowOnError( stack, ret ));
stack.SetResult_I4( totReadWrite );
TINYCLR_NOCLEANUP();
}
HRESULT Library_spot_net_security_native_Microsoft_SPOT_Net_Security_SslNative::ParseCertificate___STATIC__VOID__SZARRAY_U1__STRING__BYREF_STRING__BYREF_STRING__BYREF_mscorlibSystemDateTime__BYREF_mscorlibSystemDateTime( CLR_RT_StackFrame& stack )
{
NATIVE_PROFILE_CLR_NETWORK();
TINYCLR_HEADER();
CLR_RT_HeapBlock_Array* arrData = stack.Arg0().DereferenceArray();
CLR_UINT8* certBytes;
CLR_RT_HeapBlock hbIssuer;
CLR_RT_HeapBlock hbSubject;
CLR_RT_ProtectFromGC gc1( hbIssuer );
CLR_RT_ProtectFromGC gc2( hbSubject );
X509CertData cert;
CLR_INT64* val;
CLR_INT64 tzOffset;
SYSTEMTIME st;
INT32 standardBias;
CLR_RT_HeapBlock* hbPwd = stack.Arg1().DereferenceString();
LPCSTR szPwd;
FAULT_ON_NULL_ARG(hbPwd);
szPwd = hbPwd->StringText();
CLR_RT_Memory::ZeroFill( &cert, sizeof(cert) );
FAULT_ON_NULL(arrData);
certBytes = arrData->GetFirstElement();
if(!SSL_ParseCertificate( (const char*)certBytes, arrData->m_numOfElements, szPwd, &cert )) TINYCLR_SET_AND_LEAVE(CLR_E_INVALID_PARAMETER);
TINYCLR_CHECK_HRESULT(CLR_RT_HeapBlock_String::CreateInstance( hbIssuer, cert.Issuer ));
TINYCLR_CHECK_HRESULT(hbIssuer.StoreToReference( stack.Arg2(), 0 ));
TINYCLR_CHECK_HRESULT(CLR_RT_HeapBlock_String::CreateInstance( hbSubject, cert.Subject ));
TINYCLR_CHECK_HRESULT(hbSubject.StoreToReference( stack.Arg3(), 0 ));
st.wYear = cert.EffectiveDate.year;
st.wMonth = cert.EffectiveDate.month;
st.wDay = cert.EffectiveDate.day;
st.wHour = cert.EffectiveDate.hour;
st.wMinute = cert.EffectiveDate.minute;
st.wSecond = cert.EffectiveDate.second;
st.wMilliseconds = cert.EffectiveDate.msec;
standardBias = Time_GetTimeZoneOffset();
standardBias *= TIME_CONVERSION__ONEMINUTE;
val = Library_corlib_native_System_DateTime::GetValuePtr( stack.Arg4() );
*val = Time_FromSystemTime( &st );
tzOffset = cert.EffectiveDate.tzOffset;
// adjust for timezone differences
if(standardBias != tzOffset)
{
*val += tzOffset - standardBias;
}
st.wYear = cert.ExpirationDate.year;
st.wMonth = cert.ExpirationDate.month;
st.wDay = cert.ExpirationDate.day;
st.wHour = cert.ExpirationDate.hour;
st.wMinute = cert.ExpirationDate.minute;
st.wSecond = cert.ExpirationDate.second;
st.wMilliseconds = cert.ExpirationDate.msec;
val = Library_corlib_native_System_DateTime::GetValuePtr( stack.ArgN( 5 ) );
*val = Time_FromSystemTime( &st );
tzOffset = cert.ExpirationDate.tzOffset;
if(standardBias != tzOffset)
{
*val += tzOffset - standardBias;
}
TINYCLR_NOCLEANUP();
}
HRESULT Library_spot_native_Microsoft_SPOT_Messaging_EndPoint::SendMessageRaw___SZARRAY_U1__mscorlibSystemType__U4__I4__SZARRAY_U1( CLR_RT_StackFrame& stack )
{
NATIVE_PROFILE_CLR_MESSAGING();
TINYCLR_HEADER();
CLR_RT_HeapBlock* pThis;
CLR_Messaging_Commands::Messaging_Send* rpc;
CLR_RT_HeapBlock_EndPoint::Message* msg;
CLR_RT_HeapBlock_EndPoint::Port port;
CLR_RT_HeapBlock_EndPoint* ep;
CLR_INT64* timeout;
CLR_RT_HeapBlock_Array* pData;
CLR_UINT32 len;
bool fRes;
CLR_UINT32 seq;
pThis = stack.This(); FAULT_ON_NULL(pThis);
TINYCLR_CHECK_HRESULT(CLR_RT_HeapBlock_EndPoint::ExtractInstance( pThis[ FIELD__m_handle ], ep ));
if(CLR_RT_ReflectionDef_Index::Convert( stack.Arg1(), port.m_type ) == false) TINYCLR_SET_AND_LEAVE(CLR_E_NULL_REFERENCE);
port.m_id = stack.Arg2().NumericByRefConst().u4;
TINYCLR_CHECK_HRESULT(stack.SetupTimeout( stack.Arg3(), timeout ));
pData = stack.Arg4().DereferenceArray(); FAULT_ON_NULL(pData);
//Send message
rpc = NULL;
if(stack.m_customState == 1)
{
len = sizeof(CLR_RT_HeapBlock_EndPoint::Address) + pData->m_numOfElements;
rpc = (CLR_Messaging_Commands::Messaging_Send*)CLR_RT_Memory::Allocate( len ); CHECK_ALLOCATION(rpc);
rpc->m_addr.m_to = port;
rpc->m_addr.m_from = ep->m_addr;
rpc->m_addr.m_seq = ep->m_seq++;
memcpy( rpc->m_data, pData->GetFirstElement(), pData->m_numOfElements );
//Push sequence number onto the eval stack to wait for reply
stack.PushValueI4( rpc->m_addr.m_seq );
CLR_EE_MSG_EVENT_RPC( CLR_Messaging_Commands::c_Messaging_Send, len, rpc, WP_Flags::c_NonCritical );
stack.m_customState = 2;
}
//get seq# from stack
seq = stack.m_evalStack[ 1 ].NumericByRef().u4;
fRes = true;
msg = NULL;
while(fRes)
{
msg = ep->FindMessage( CLR_Messaging_Commands::c_Messaging_Reply, &seq );
if(msg) break;
TINYCLR_CHECK_HRESULT(g_CLR_RT_ExecutionEngine.WaitEvents( stack.m_owningThread, *timeout, CLR_RT_ExecutionEngine::c_Event_EndPoint, fRes ));
}
stack.PopValue(); //seq
stack.PopValue(); //Timeout
{
CLR_RT_HeapBlock& top = stack.PushValueAndClear();
if(msg)
{
TINYCLR_CHECK_HRESULT(CLR_RT_HeapBlock_Array::CreateInstance( top, msg->m_length, g_CLR_RT_WellKnownTypes.m_UInt8 ));
memcpy( top.DereferenceArray()->GetFirstElement(), msg->m_data, msg->m_length );
msg->Unlink(); CLR_RT_Memory::Release( msg );
}
}
TINYCLR_NOCLEANUP();
}
