BOOL SSL_ParseCertificate( const char* certificate, size_t certLength, const char* szPwd, X509CertData* certData ) { if (!s_init_done) s_init_done=ssl_initialize_internal(); NATIVE_PROFILE_PAL_COM(); return ssl_parse_certificate_internal((void *)certificate, TINYCLR_SSL_STRLEN(certificate), NULL, (void*)certData); }
BOOL SSL_Initialize() { NATIVE_PROFILE_PAL_COM(); memset(&g_SSL_Driver, 0, sizeof(g_SSL_Driver)); return TRUE; }
void Sockets_NetduinoIP_Driver::ApplyConfigExtended() { NATIVE_PROFILE_PAL_COM(); if(!HAL_CONFIG_BLOCK::ApplyConfig( g_NetworkConfigExtended.GetDriverName(), &g_NetworkConfigExtended, sizeof(g_NetworkConfigExtended) )) { // save to the dynamic config section so that MFDeploy will be able to get the configuration. SaveConfigExtended(0, NULL); } }
BOOL USART_Driver::Initialize( int ComPortNum, int BaudRate, int Parity, int DataBits, int StopBits, int FlowValue ) { NATIVE_PROFILE_PAL_COM(); if((ComPortNum < 0) || (ComPortNum >= TOTAL_USART_PORT)) { //DEBUG_TRACE1(TRACE_ALWAYS, "ERROR: VTE_USART_Initialize: invalid ComPortNum %u\r\n", ComPortNum); return FALSE; } { GLOBAL_LOCK(irq); HAL_USART_STATE& State = Hal_Usart_State[ComPortNum]; if(!IS_USART_INITIALIZED(State)) { State.fDataEventSet = FALSE; State.PortIndex = ComPortNum; // DO NOT INITIALIZE EVENT CALLBACKS HERE BECAUSE THEY CAN BE SET PRIOR TO INITIALIZE State.Flag = 0; //clear all the flag bits SET_USART_FLAG(State, HAL_USART_STATE::c_INITIALIZED | HAL_USART_STATE::c_TX_XON_STATE); // If SW flow control on input is enabled if (FlowValue & USART_FLOW_SW_IN_EN) { SET_USART_FLAG(State, HAL_USART_STATE::c_RX_SWFLOW_CTRL); } // If SW flow control on output is enabled if (FlowValue & USART_FLOW_SW_OUT_EN) { SET_USART_FLAG(State, HAL_USART_STATE::c_TX_SWFLOW_CTRL); } // If HW flow control on input is enabled (HW output control is either totally in hardware or in HAL only) if (FlowValue & USART_FLOW_HW_IN_EN) { SET_USART_FLAG(State, HAL_USART_STATE::c_RX_HWFLOW_CTRL); } State.RxBufferHighWaterMark = USART_BUFFER_HIGH_WATER_MARK( RX_USART_BUFFER_SIZE ); State.RxBufferLowWaterMark = USART_BUFFER_LOW_WATER_MARK ( RX_USART_BUFFER_SIZE ); State.TicksStartTxXOFF = 0; State.TxQueue.Initialize( &TxBuffer_Com[ComPortNum * TX_USART_BUFFER_SIZE], TX_USART_BUFFER_SIZE); State.RxQueue.Initialize( &RxBuffer_Com[ComPortNum * RX_USART_BUFFER_SIZE], RX_USART_BUFFER_SIZE ); return CPU_USART_Initialize( ComPortNum, BaudRate, Parity, DataBits, StopBits, FlowValue ); } return TRUE; } }
void I2C_HAL_XACTION::Initialize( I2C_USER_CONFIGURATION& config, I2C_HAL_XACTION_UNIT** xActionUnits, size_t numXActionUnits ) { NATIVE_PROFILE_PAL_COM(); m_xActionUnits = xActionUnits; m_numXActionUnits = numXActionUnits; m_current = 0; m_clockRate = I2C_Internal_GetClockRate( config.ClockRate ); m_address = config.Address; m_status = c_Status_Idle; }
int USART_Driver::Read( int ComPortNum, char* Data, size_t size ) { NATIVE_PROFILE_PAL_COM(); if((ComPortNum < 0) || (ComPortNum >= TOTAL_USART_PORT)) {ASSERT(FALSE); return -1;} if(Data == NULL ) return -1; HAL_USART_STATE& State = Hal_Usart_State[ComPortNum]; if ( IS_POWERSAVE_ENABLED(State) || (!IS_USART_INITIALIZED(State))) return -1; int CharsRead = 0; while(CharsRead < size) { // keep interrupts off only during pointer movement so we are atomic GLOBAL_LOCK(irq); size_t toRead; UINT8 *Src; toRead = size - CharsRead; Src = State.RxQueue.Pop( toRead ); if( NULL == Src ) break; // Check if FIFO level has just passed or gotten down to the low water mark if(State.RxQueue.NumberOfElements() <= State.RxBufferLowWaterMark && (State.RxQueue.NumberOfElements() + toRead) > State.RxBufferLowWaterMark) { if( USART_FLAG_STATE(State, HAL_USART_STATE::c_RX_SWFLOW_CTRL) ) { // Clear our XOFF state SendXON( ComPortNum, XOFF_FLAG_FULL ); } if( USART_FLAG_STATE(State, HAL_USART_STATE::c_RX_HWFLOW_CTRL) ) { CPU_USART_RxBufferFullInterruptEnable(ComPortNum, TRUE); } } memcpy(&Data[CharsRead], Src, toRead); // Copy data from queue to Read buffer CharsRead += toRead; } { GLOBAL_LOCK(irq); State.fDataEventSet = FALSE; if(!State.RxQueue.IsEmpty()) { SetEvent( ComPortNum, USART_EVENT_DATA_CHARS ); } } return CharsRead; }
BOOL SSL_Uninitialize() { NATIVE_PROFILE_PAL_COM(); BOOL retVal; retVal = ssl_uninitialize_internal(); s_init_done = FALSE; return retVal; }
void SSL_ClearCertificateAuthority( int sslContextHandle ) { NATIVE_PROFILE_PAL_COM(); if((sslContextHandle >= ARRAYSIZE(g_SSL_Driver.m_sslContextArray)) || (sslContextHandle < 0)) { return; } memset(&g_SSL_Driver.m_sslContextArray[sslContextHandle].m_certificates[0], 0, sizeof(g_SSL_Driver.m_sslContextArray[sslContextHandle].m_certificates)); g_SSL_Driver.m_sslContextArray[sslContextHandle].m_certificateCount = 0; }
void Sockets_NetduinoIP_Driver::SaveConfigExtended(INT32 index, SOCK_NetworkConfigurationExtended *cfg) { NATIVE_PROFILE_PAL_COM(); if(index >= NETWORK_INTERFACE_COUNT) return; if(cfg) { memcpy( &g_NetworkConfigExtended.NetworkInterfaces[index], cfg, sizeof(SOCK_NetworkConfigurationExtended) ); } HAL_CONFIG_BLOCK::UpdateBlockWithName(g_NetworkConfigExtended.GetDriverName(), &g_NetworkConfigExtended, sizeof(g_NetworkConfigExtended), TRUE); }
void Sockets_NetduinoIP_Driver::SaveWirelessConfig(INT32 index, SOCK_NetworkConfiguration *cfg) { NATIVE_PROFILE_PAL_COM(); if(index >= WIRELESS_INTERFACE_COUNT) return; if(cfg) { memcpy( &g_WirelessConfig.WirelessInterfaces[index], cfg, sizeof(SOCK_WirelessConfiguration) ); } HAL_CONFIG_BLOCK::UpdateBlockWithName(g_WirelessConfig.GetDriverName(), &g_WirelessConfig, sizeof(g_WirelessConfig), TRUE); }
void Sockets_NetduinoIP_Driver::ApplyWirelessConfig() { NATIVE_PROFILE_PAL_COM(); if(!s_wirelessInitialized) { if(!HAL_CONFIG_BLOCK::ApplyConfig( g_WirelessConfig.GetDriverName(), &g_WirelessConfig, sizeof(g_WirelessConfig) )) { SaveWirelessConfig(0, NULL); } s_wirelessInitialized = TRUE; } }
BOOL Sockets_NetduinoIP_Driver::Initialize() { NATIVE_PROFILE_PAL_COM(); if(!s_initialized) { ApplyConfig(); ApplyConfigExtended(); ApplyWirelessConfig(); s_initialized = TRUE; } }
BOOL SSL_ParseCertificate( const char* certificate, size_t certLength, const char* szPwd, X509CertData* certData ) { NATIVE_PROFILE_PAL_COM(); RTCertificate rt_cert; int ret; rt_cert.cert = (X509Certificate)certificate; rt_cert.size = certLength; ret = secure_parse_certificate( (const RTCertificate *)&rt_cert, (RTCertData*)certData ); return (-1 != ret); }
void I2C_Driver::StartNext() { NATIVE_PROFILE_PAL_COM(); I2C_HAL_XACTION* xAction = (I2C_HAL_XACTION*)g_I2C_Driver.m_xActions.FirstValidNode(); if(xAction == NULL) { return; } xAction->SetState( I2C_HAL_XACTION::c_Status_Processing ); I2C_Internal_XActionStart( xAction, false ); }
BOOL DebuggerPort_Flush( COM_HANDLE ComPortNum ) { NATIVE_PROFILE_PAL_COM(); switch(ExtractTransport(ComPortNum)) { case USART_TRANSPORT: return USART_Flush( ConvertCOM_ComPort( ComPortNum ) ); case USB_TRANSPORT: return USB_Flush( ConvertCOM_UsbStream(ComPortNum) ); case SOCKET_TRANSPORT: return SOCKETS_Flush( ConvertCOM_SockPort(ComPortNum) ); } return FALSE; }
void CPU_ProtectCommunicationGPIOs( BOOL On ) { NATIVE_PROFILE_PAL_COM(); switch(ExtractTransport(HalSystemConfig.DebugTextPort)) { case USART_TRANSPORT: CPU_USART_ProtectPins( ConvertCOM_ComPort(HalSystemConfig.DebugTextPort), On ); return ; case USB_TRANSPORT: CPU_USB_ProtectPins ( ConvertCOM_UsbController(HalSystemConfig.DebugTextPort), On ); return; default: return; } }
BOOL DebuggerPort_Uninitialize( COM_HANDLE ComPortNum ) { NATIVE_PROFILE_PAL_COM(); switch(ExtractTransport(ComPortNum)) { case USART_TRANSPORT: return USART_Uninitialize( ConvertCOM_ComPort(ComPortNum) ); case USB_TRANSPORT: USB_CloseStream( ConvertCOM_UsbStream(ComPortNum) ); return USB_Uninitialize( ConvertCOM_UsbController(ComPortNum) ); case SOCKET_TRANSPORT: return SOCKETS_Uninitialize(ConvertCOM_SockPort(ComPortNum)); } return FALSE; }
int DebuggerPort_Write( COM_HANDLE ComPortNum, const char* Data, size_t size ) { NATIVE_PROFILE_PAL_COM(); UINT32 transport = ExtractTransport(ComPortNum); const char* dataTmp = Data; INT32 totWrite = 0; int retries = 100; while(size > 0 && retries--) { int ret = 0; switch(transport) { case USART_TRANSPORT: ret = USART_Write( ConvertCOM_ComPort( ComPortNum ), dataTmp, size ); break; case USB_TRANSPORT: ret = USB_Write( ConvertCOM_UsbStream( ComPortNum ), dataTmp, size ); break; case SOCKET_TRANSPORT: ret = SOCKETS_Write( ConvertCOM_SockPort(ComPortNum), dataTmp, size ); break; } if(ret < 0) { break; } else if(ret == 0) { // if interrupts are off and our buffer is full then there is nothing we can do if(!INTERRUPTS_ENABLED_STATE()) break; Events_WaitForEvents(0, 1); } else { retries = 50; // reset retries size -= ret; dataTmp += ret; totWrite += ret; } } return totWrite; }
BOOL DebuggerPort_Initialize( COM_HANDLE ComPortNum ) { NATIVE_PROFILE_PAL_COM(); switch(ExtractTransport(ComPortNum)) { case USART_TRANSPORT: return USART_Initialize( ConvertCOM_ComPort(ComPortNum), HalSystemConfig.USART_DefaultBaudRate, USART_PARITY_NONE, 8, USART_STOP_BITS_ONE, USART_FLOW_NONE ); case USB_TRANSPORT: if(USB_CONFIG_ERR_OK != USB_Configure( ConvertCOM_UsbController(ComPortNum), NULL )) return FALSE; if(!USB_Initialize( ConvertCOM_UsbController(ComPortNum) )) return FALSE; return USB_OpenStream( ConvertCOM_UsbStream(ComPortNum), USB_DEBUG_EP_WRITE, USB_DEBUG_EP_READ ); case SOCKET_TRANSPORT: return SOCKETS_Initialize(ConvertCOM_SockPort(ComPortNum)); } return FALSE; }
void I2C_HAL_XACTION::Signal( UINT8 state, BOOL signal ) { NATIVE_PROFILE_PAL_COM(); ASSERT_IRQ_MUST_BE_OFF(); m_status = state; // this will automatically remove this node from the I2C_Driver // list and place it in the global continuation list if(signal) Enqueue(); // stop the flow if the transaction was not cancelled // in whihc case the Stop command would have been issued already if(!(m_status & c_Status_Cancelled)) { I2C_Internal_XActionStop(); } }
BOOL SSL_ExitContext( INT32 sslContextHandle ) { NATIVE_PROFILE_PAL_COM(); BOOL ret; if((sslContextHandle >= ARRAYSIZE(g_SSL_Driver.m_sslContextArray)) || (sslContextHandle < 0) || (g_SSL_Driver.m_sslContextArray[sslContextHandle].SslContext == NULL)) { return FALSE; } ret = (0 == secure_sslexit(g_SSL_Driver.m_sslContextArray[sslContextHandle].SslContext)); memset(&g_SSL_Driver.m_sslContextArray[sslContextHandle], 0, sizeof(g_SSL_Driver.m_sslContextArray[sslContextHandle])); g_SSL_Driver.m_sslContextCount --; return ret; }
void I2C_HAL_XACTION_UNIT::Initialize( I2C_WORD* src, I2C_WORD* dst, size_t size, BOOL fRead ) { NATIVE_PROFILE_PAL_COM(); m_bytesToTransfer = size; m_bytesTransferred = 0; m_fRead = fRead; m_dataQueue.Initialize( dst, size ); if(!fRead) { I2C_WORD* slot; while((slot = m_dataQueue.Push()) != NULL) { *slot = *src++; } } }
BOOL I2C_Driver::Enqueue( I2C_HAL_XACTION* xAction ) { NATIVE_PROFILE_PAL_COM(); ASSERT(xAction); if(xAction == NULL) return FALSE; GLOBAL_LOCK(irq); xAction->SetCallback( I2C_Driver::CompletedCallback ); xAction->SetState( I2C_HAL_XACTION::c_Status_Scheduled ); g_I2C_Driver.m_xActions.LinkAtBack( xAction ); StartNext(); return TRUE; }
void I2C_Driver::CompletedCallback( void* arg ) { NATIVE_PROFILE_PAL_COM(); I2C_HAL_XACTION* xAction = (I2C_HAL_XACTION*)arg; // is the transaction is the last of a series of related // transactions then free the bus for whoever comes next if(( xAction->m_current == (xAction->m_numXActionUnits)) || xAction->CheckState( I2C_HAL_XACTION::c_Status_Aborted | I2C_HAL_XACTION::c_Status_Cancelled )) { // signal the waiting thread; since continuations are executed one at a time for every round // of the scheduler there is no need to check for lost events on the waiting thread Events_Set( SYSTEM_EVENT_I2C_XACTION ); StartNext(); } }
BOOL SSL_Uninitialize() { NATIVE_PROFILE_PAL_COM(); BOOL result = TRUE; for(int i = 0; i<ARRAYSIZE(g_SSL_Driver.m_sslContextArray); i++) { if(g_SSL_Driver.m_sslContextArray[i].SslContext != NULL) { SSL_ExitContext( i ); } } secure_exit(); g_SSL_Driver.m_sslContextCount = 0; return result; }
int DebuggerPort_Read( COM_HANDLE ComPortNum, char* Data, size_t size ) { NATIVE_PROFILE_PAL_COM(); int ret = 0; switch(ExtractTransport(ComPortNum)) { case USART_TRANSPORT: ret = USART_Read( ConvertCOM_ComPort( ComPortNum ), Data, size ); break; case USB_TRANSPORT: ret = USB_Read( ConvertCOM_UsbStream( ComPortNum ), Data, size ); break; case SOCKET_TRANSPORT: ret = SOCKETS_Read( ConvertCOM_SockPort(ComPortNum), Data, size ); break; } return ret; }
BOOL I2C_Driver::Uninitialize() { NATIVE_PROFILE_PAL_COM(); GLOBAL_LOCK(irq); if(!g_I2C_Driver.m_initialized) { return FALSE; } else { I2C_Internal_Uninitialize(); g_I2C_Driver.m_initialized = FALSE; while(g_I2C_Driver.m_xActions.ExtractFirstNode()); return TRUE; } }
BOOL I2C_Driver::Initialize() { NATIVE_PROFILE_PAL_COM(); GLOBAL_LOCK(irq); // initialize the PAL driver only once if(!g_I2C_Driver.m_initialized) { g_I2C_Driver.m_xActions.Initialize(); g_I2C_Driver.m_initialized = TRUE; } // give always a chance to the HAL driver to initialize // this will resurrect the GPIO pins in case some other // entity has been using them if(!I2C_Internal_Initialize()) return FALSE; return TRUE; }
void SSL_GetTime(DATE_TIME_INFO* pdt) { NATIVE_PROFILE_PAL_COM(); if(pdt == NULL) return; if(g_SSL_Driver.m_pfnGetTimeFuncPtr != NULL) { g_SSL_Driver.m_pfnGetTimeFuncPtr(pdt); } else { pdt->year = 2009; pdt->month = 1; pdt->day = 1; pdt->hour = 0; pdt->minute = 0; pdt->second = 0; pdt->msec = 0; pdt->dlsTime = 0; pdt->tzOffset = -8 * 60 * 60; } }
BOOL SSL_AddCertificateAuthority( int sslContextHandle, const char* certificate, int cert_len, const char* szCertPwd ) { NATIVE_PROFILE_PAL_COM(); SSL_Driver::SSL_Context *ctx; RTCertificate *rtCert; if((sslContextHandle >= ARRAYSIZE(g_SSL_Driver.m_sslContextArray)) || (sslContextHandle < 0) || (g_SSL_Driver.m_sslContextArray[sslContextHandle].m_certificateCount >= SSL_Driver::c_MaxCertificatesPerContext)) { return FALSE; } ctx = &g_SSL_Driver.m_sslContextArray[sslContextHandle]; rtCert = &ctx->m_certificates[ctx->m_certificateCount]; ctx->m_certificateCount++; rtCert->cert = (X509Certificate)certificate; rtCert->size = cert_len; return TRUE; }