HRESULT Library_spot_net_native_Microsoft_SPOT_Net_SocketNative::ThrowOnError( CLR_RT_StackFrame& stack, CLR_INT32 res ) { NATIVE_PROFILE_CLR_NETWORK(); TINYCLR_HEADER(); if(res == SOCK_SOCKET_ERROR) { CLR_INT32 err = SOCK_getlasterror(); ThrowError( stack, err ); TINYCLR_SET_AND_LEAVE( CLR_E_PROCESS_EXCEPTION ); } TINYCLR_NOCLEANUP(); }
HRESULT Library_spot_net_native_Microsoft_SPOT_Net_SocketNative::BindConnectHelper( CLR_RT_StackFrame& stack, bool fBind ) { NATIVE_PROFILE_CLR_NETWORK(); TINYCLR_HEADER(); CLR_RT_HeapBlock* socket = stack.Arg0().Dereference(); CLR_INT32 handle; SOCK_sockaddr addr; CLR_UINT32 addrLen = sizeof(addr); CLR_INT32 ret; bool fThrowOnWouldBlock = false; FAULT_ON_NULL(socket); handle = socket[ FIELD__m_Handle ].NumericByRef().s4; TINYCLR_CHECK_HRESULT(MarshalSockAddress( &addr, addrLen, stack.Arg1() )); if(fBind) { ret = SOCK_bind( handle, &addr, addrLen ); } else { ret = SOCK_connect( handle, &addr, addrLen ); fThrowOnWouldBlock = (stack.Arg2().NumericByRefConst().s4 != 0); if(!fThrowOnWouldBlock && SOCK_getlasterror() == SOCK_EWOULDBLOCK) { TINYCLR_SET_AND_LEAVE(S_OK); } } TINYCLR_CHECK_HRESULT(ThrowOnError( stack, ret )); TINYCLR_NOCLEANUP(); }
INT32 SNTPClient::Connect() { SOCK_SOCKET timeSocket = SOCK_SOCKET_ERROR; INT32 sockErr = 0; UINT32 usedServer = 0; // look up outstdanding queries for this set of servers OutstandingQuery* query = FindOutstandingConnection(m_ipAddressPrimary, m_ipAddressAlternate); if(query != NULL) { // // signal failed queries // if(query->IsOld()) { query->Dispose(); query = NULL; } else { // // resume old connection // timeSocket = query->GetSocket(); } } if(timeSocket == SOCK_SOCKET_ERROR) { // // new connection // timeSocket = SOCK_socket(SOCK_AF_INET, SOCK_SOCK_DGRAM, SOCK_IPPROTO_UDP); if(timeSocket == SOCK_SOCKET_ERROR) { sockErr = SOCK_getlasterror(); return (sockErr == 0 ? HAL_TIMESERVICE_ERROR : sockErr); } SOCK_sockaddr addr; SOCK_sockaddr_in* dst = (SOCK_sockaddr_in*)&addr; memset(dst, 0, sizeof(SOCK_sockaddr_in)); dst->sin_family = SOCK_AF_INET; dst->sin_port = SOCK_htons(123); dst->sin_addr.S_un.S_addr = SOCK_htonl(m_ipAddressPrimary); usedServer = m_ipAddressPrimary; if(SOCK_connect(timeSocket, &addr, sizeof(addr)) == SOCK_SOCKET_ERROR && SOCK_getlasterror() != SOCK_EWOULDBLOCK) { if(m_ipAddressAlternate != 0) { usedServer = m_ipAddressAlternate; dst->sin_addr.S_un.S_addr = SOCK_htonl(m_ipAddressAlternate); if(SOCK_connect(timeSocket, &addr, sizeof(addr)) == SOCK_SOCKET_ERROR && SOCK_getlasterror() != SOCK_EWOULDBLOCK) { sockErr = SOCK_getlasterror(); SOCK_close(timeSocket); return (sockErr == 0 ? HAL_TIMESERVICE_ERROR : sockErr); } } else { sockErr = SOCK_getlasterror(); SOCK_close(timeSocket); return (sockErr == 0 ? HAL_TIMESERVICE_ERROR : sockErr); } } Initialize(); int sent = SOCK_send(timeSocket, (char*)SNTPData, sizeof(SNTPData), 0); if(sent != sizeof(SNTPData)) { sockErr = SOCK_getlasterror(); SOCK_close(timeSocket); return (sockErr == 0 ? HAL_TIMESERVICE_ERROR : sockErr); } } // retry 10 times every time we stop by INT32 retry = 10; INT32 bytesToRead = c_SNTPDataLength; char* buf = (char*)SNTPData; while(retry-- > 0) { int read = SOCK_recv(timeSocket, buf, bytesToRead, 0); if(read < 0 && (sockErr = SOCK_getlasterror()) != SOCK_EWOULDBLOCK) { SOCK_close(timeSocket); return (sockErr == 0 ? HAL_TIMESERVICE_ERROR : sockErr); } else if(read > 0) { bytesToRead -= read; if(bytesToRead <= 0) { break; } buf += read; // incase we start receiving data towards the end // of the retry limit. retry++; } } // if we could not finish reading, then cache and retry later // if we read a part of answer, then declare failure // in the future we could try and cope with this problem if(bytesToRead == c_SNTPDataLength) { // // if this is a new connection, get a slot // if(query == NULL) { query = GetQuery(usedServer, timeSocket); } return HAL_TIMESERVICE_WANT_READ_WRITE; } else if(bytesToRead > 0 && bytesToRead < c_SNTPDataLength) { if(query != NULL) query->Dispose(); return HAL_TIMESERVICE_WANT_READ_WRITE; } else { if(query != NULL) { query->Dispose(); query = NULL; } else { if( timeSocket != SOCK_SOCKET_ERROR ) { SOCK_close(timeSocket); timeSocket = SOCK_SOCKET_ERROR; } } } DestinationTimestamp = Time_GetUtcTime(); if( !IsResponseValid() ) { if(query != NULL) { query->Dispose(); query = NULL; } else { if( timeSocket != SOCK_SOCKET_ERROR ) { SOCK_close(timeSocket); timeSocket = SOCK_SOCKET_ERROR; } } return HAL_TIMESERVICE_ERROR; } return HAL_TIMESERVICE_SUCCESS; }
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::getaddrinfo___STATIC__VOID__STRING__BYREF_STRING__BYREF_SZARRAY_SZARRAY_U1( CLR_RT_StackFrame& stack ) { NATIVE_PROFILE_CLR_NETWORK(); TINYCLR_HEADER(); LPCSTR szName = stack.Arg0().RecoverString(); struct SOCK_addrinfo hints; struct SOCK_addrinfo* addr = NULL; struct SOCK_addrinfo* addrT; CLR_UINT32 cAddresses = 0; CLR_RT_HeapBlock* pAddress; CLR_INT32 timeout_ms = 30000; CLR_RT_HeapBlock hbTimeout; CLR_INT32 ret; bool fRes = true; CLR_INT64* timeout; hbTimeout.SetInteger( timeout_ms ); TINYCLR_CHECK_HRESULT(stack.SetupTimeout( hbTimeout, timeout )); do { memset( &hints, 0, sizeof(hints) ); ret = SOCK_getaddrinfo( szName, NULL, &hints, &addr ); if(ret == SOCK_SOCKET_ERROR) { if(SOCK_getlasterror() == SOCK_EWOULDBLOCK) { // 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 )); } else { break; } } else { break; } } while(fRes); // timeout expired if(!fRes) { ret = SOCK_SOCKET_ERROR; ThrowError( stack, SOCK_ETIMEDOUT ); TINYCLR_SET_AND_LEAVE( CLR_E_PROCESS_EXCEPTION ); } // getaddrinfo returns a winsock error code rather than SOCK_SOCKET_ERROR, so pass this on to the exception handling if(ret != 0) { ThrowError( stack, ret ); TINYCLR_SET_AND_LEAVE(CLR_E_PROCESS_EXCEPTION); } { CLR_RT_HeapBlock hbCanonicalName; CLR_RT_HeapBlock hbAddresses; hbCanonicalName.SetObjectReference( NULL ); CLR_RT_ProtectFromGC gc( hbCanonicalName ); hbAddresses.SetObjectReference( NULL ); CLR_RT_ProtectFromGC gc2( hbAddresses ); for(int pass = 0; pass < 2; pass++) { cAddresses = 0; for(addrT = addr; addrT != NULL; addrT = addrT->ai_next) { if(pass == 1) { if(addrT->ai_canonname && addrT->ai_canonname[ 0 ]) { //allocate return string TINYCLR_CHECK_HRESULT(CLR_RT_HeapBlock_String::CreateInstance( hbCanonicalName, addrT->ai_canonname )); TINYCLR_CHECK_HRESULT(hbCanonicalName.StoreToReference( stack.Arg1(), 0 )); } //allocate address and store into array pAddress = (CLR_RT_HeapBlock*)hbAddresses.DereferenceArray()->GetElement( cAddresses ); TINYCLR_CHECK_HRESULT(CLR_RT_HeapBlock_Array::CreateInstance( *pAddress, (CLR_UINT32)addrT->ai_addrlen, g_CLR_RT_WellKnownTypes.m_UInt8 )); //copy address. memcpy( pAddress->DereferenceArray()->GetFirstElement(), addrT->ai_addr, addrT->ai_addrlen ); } cAddresses++; } if(pass == 0) { //allocate array of byte arrays CLR_RT_ReflectionDef_Index idx; idx.m_kind = REFLECTION_TYPE; idx.m_levels = 2; idx.m_data.m_type.m_data = g_CLR_RT_WellKnownTypes.m_UInt8.m_data; TINYCLR_CHECK_HRESULT(CLR_RT_HeapBlock_Array::CreateInstance( hbAddresses, cAddresses, idx )); TINYCLR_CHECK_HRESULT(hbAddresses.StoreToReference( stack.Arg2(), 0 )); } } } stack.PopValue(); // Timeout TINYCLR_CLEANUP(); if( addr ) SOCK_freeaddrinfo( addr ); TINYCLR_CLEANUP_END(); }
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(); }