RBOOL
rpHostCommonPlatformLib_stop
(
)
{
if( 0 == rInterlocked_decrement32( &g_hcpContext.isRunning ) )
{
stopBeacons();
stopAllModules();
rpal_memory_free( g_hcpContext.primaryUrl );
rpal_memory_free( g_hcpContext.secondaryUrl );
if( NULL != g_hcpContext.enrollmentToken &&
0 != g_hcpContext.enrollmentTokenSize )
{
rpal_memory_free( g_hcpContext.enrollmentToken );
}
freeKeys();
#ifdef RPAL_PLATFORM_WINDOWS
SetConsoleCtrlHandler( (PHANDLER_ROUTINE)ctrlHandler, FALSE );
#endif
rMutex_free( g_hcpContext.cloudConnectionMutex );
rEvent_free( g_hcpContext.isCloudOnline );
g_hcpContext.cloudConnectionMutex = NULL;
g_hcpContext.isCloudOnline = NULL;
rpal_Context_cleanup();
rpal_Context_deinitialize();
// If the default crashContext is still present, remove it since
// we are shutting down properly. If it's non-default leave it since
// somehow we may have had a higher order crash we want to keep
// track of but we are still leaving through our normal code path.
if( 1 == getCrashContextSize() )
{
rpal_debug_info( "clearing default crash context" );
cleanCrashContext();
}
}
else
{
rInterlocked_increment32( &g_hcpContext.isRunning );
}
rpal_debug_info( "finished stopping hcp" );
return TRUE;
}
RVOID
rpal_Context_deinitialize
(
)
{
if( g_rpal_is_root_context )
{
if( 0 == rInterlocked_decrement32( &g_rpal_nrecursiveInit ) )
{
free( g_rpal_context );
}
}
}
RPRIVATE
RU32
RPAL_THREAD_FUNC thread_quitAndCleanup
(
RPVOID context
)
{
UNREFERENCED_PARAMETER( context );
if( 0 == rInterlocked_decrement32( &g_hcpContext.isRunning ) )
{
rpal_thread_sleep( MSEC_FROM_SEC( 1 ) );
stopAllModules();
stopBeacons();
if( NULL != g_hcpContext.enrollmentToken &&
0 != g_hcpContext.enrollmentTokenSize )
{
rpal_memory_free( g_hcpContext.enrollmentToken );
}
// If the default crashContext is still present, remove it since
// we are shutting down properly. If it's non-default leave it since
// somehow we may have had a higher order crash we want to keep
// track of but we are still leaving through our normal code path.
if( 1 == getCrashContextSize() )
{
cleanCrashContext();
}
rpal_Context_cleanup();
rpal_Context_deinitialize();
}
else
{
rInterlocked_increment32( &g_hcpContext.isRunning );
}
return 0;
}
RBOOL
rEvent_wait
(
rEvent ev,
RU32 timeout
)
{
RBOOL isSuccess = FALSE;
_rEvent* volatile evt = (_rEvent*)ev;
if( rpal_memory_isValid( ev ) )
{
#ifdef RPAL_PLATFORM_WINDOWS
rInterlocked_increment32( &evt->waitCount );
if( WAIT_OBJECT_0 == WaitForSingleObject( evt->hEvent, timeout ) )
{
isSuccess = TRUE;
}
rInterlocked_decrement32( &evt->waitCount );
#elif defined( RPAL_PLATFORM_LINUX ) || defined( RPAL_PLATFORM_MACOSX )
struct timespec abs_time;
struct timeval cur_time;
struct timezone ts;
int err = 0;
gettimeofday( &cur_time, &ts );
abs_time.tv_sec = cur_time.tv_sec;
abs_time.tv_nsec = cur_time.tv_usec * 1000;
abs_time.tv_sec += ( timeout / 1000 );
abs_time.tv_nsec += ( ( timeout % 1000 ) * 1000000 );
if( abs_time.tv_nsec >= 1000000000 )
{
abs_time.tv_sec += ( abs_time.tv_nsec / 1000000000 );
abs_time.tv_nsec = abs_time.tv_nsec % 1000000000;
}
if( 0 == pthread_mutex_lock( &evt->hMutex ) )
{
if( evt->isOn )
{
if( !evt->isManualReset )
{
evt->isOn = FALSE;
}
isSuccess = TRUE;
}
else
{
// This is extremely convoluted and unintuitive... what else did you expect since
// it turns out a _wait can wakeup randomly because "signals" without letting you
// know. So we need to wrap the entire thing in a loop and manually look for a flag.
while( 0 == err && !evt->isOn )
{
if( RINFINITE != timeout )
{
err = pthread_cond_timedwait( &evt->hCond, &evt->hMutex, &abs_time );
}
else
{
err = pthread_cond_wait( &evt->hCond, &evt->hMutex );
}
}
if( evt->isOn )
{
if( !evt->isManualReset )
{
evt->isOn = FALSE;
}
isSuccess = TRUE;
}
}
pthread_mutex_unlock( &evt->hMutex );
}
#endif
}
return isSuccess;
}
RBOOL
rpHostCommonPlatformLib_launch
(
RU8 configHint,
RPNCHAR primaryHomeUrl,
RPNCHAR secondaryHomeUrl
)
{
RBOOL isInitSuccessful = FALSE;
rSequence staticConfig = NULL;
RPCHAR tmpStr = NULL;
rSequence tmpSeq = NULL;
RPU8 tmpBuffer = NULL;
RU32 tmpSize = 0;
RU16 tmpPort = 0;
rpal_debug_info( "launching hcp" );
#ifdef RPAL_PLATFORM_WINDOWS
if( setGlobalCrashHandler() &&
SetConsoleCtrlHandler( (PHANDLER_ROUTINE)ctrlHandler, TRUE ) )
{
rpal_debug_info( "global crash handler set" );
}
else
{
rpal_debug_warning( "error setting global crash handler" );
}
#endif
if( 1 == rInterlocked_increment32( &g_hcpContext.isRunning ) )
{
if( rpal_initialize( NULL, RPAL_COMPONENT_HCP ) )
{
CryptoLib_init();
if( NULL == ( g_hcpContext.cloudConnectionMutex = rMutex_create() ) ||
NULL == ( g_hcpContext.isCloudOnline = rEvent_create( TRUE ) ) )
{
rMutex_free( g_hcpContext.cloudConnectionMutex );
rpal_debug_error( "could not create cloud connection mutex or event" );
return FALSE;
}
g_hcpContext.currentId.raw = g_idTemplate.raw;
// We attempt to load some initial config from the serialized
// rSequence that can be patched in this binary.
if( NULL != ( staticConfig = getStaticConfig() ) )
{
if( rSequence_getSTRINGA( staticConfig, RP_TAGS_HCP_PRIMARY_URL, &tmpStr ) &&
rSequence_getRU16( staticConfig, RP_TAGS_HCP_PRIMARY_PORT, &tmpPort ) )
{
g_hcpContext.primaryUrl = rpal_string_strdupA( tmpStr );
g_hcpContext.primaryPort = tmpPort;
rpal_debug_info( "loading primary url from static config" );
}
if( rSequence_getSTRINGA( staticConfig, RP_TAGS_HCP_SECONDARY_URL, &tmpStr ) &&
rSequence_getRU16( staticConfig, RP_TAGS_HCP_SECONDARY_PORT, &tmpPort ) )
{
g_hcpContext.secondaryUrl = rpal_string_strdupA( tmpStr );
g_hcpContext.secondaryPort = tmpPort;
rpal_debug_info( "loading secondary url from static config" );
}
if( rSequence_getSEQUENCE( staticConfig, RP_TAGS_HCP_ID, &tmpSeq ) )
{
g_hcpContext.currentId = seqToHcpId( tmpSeq );
rpal_debug_info( "loading default id from static config" );
}
if( rSequence_getBUFFER( staticConfig, RP_TAGS_HCP_C2_PUBLIC_KEY, &tmpBuffer, &tmpSize ) )
{
setC2PublicKey( rpal_memory_duplicate( tmpBuffer, tmpSize ) );
rpal_debug_info( "loading c2 public key from static config" );
}
if( rSequence_getBUFFER( staticConfig, RP_TAGS_HCP_ROOT_PUBLIC_KEY, &tmpBuffer, &tmpSize ) )
{
setRootPublicKey( rpal_memory_duplicate( tmpBuffer, tmpSize ) );
rpal_debug_info( "loading root public key from static config" );
}
if( rSequence_getSTRINGA( staticConfig, RP_TAGS_HCP_DEPLOYMENT_KEY, &tmpStr ) )
{
g_hcpContext.deploymentKey = rpal_string_strdupA( tmpStr );
rpal_debug_info( "loading deployment key from static config" );
}
rSequence_free( staticConfig );
}
// Now we will override the defaults (if present) with command
// line parameters.
if( NULL != primaryHomeUrl &&
0 != rpal_string_strlen( primaryHomeUrl ) )
{
if( NULL != g_hcpContext.primaryUrl )
{
rpal_memory_free( g_hcpContext.primaryUrl );
g_hcpContext.primaryUrl = NULL;
}
g_hcpContext.primaryUrl = rpal_string_ntoa( primaryHomeUrl );
}
if( NULL != secondaryHomeUrl &&
0 != rpal_string_strlen( secondaryHomeUrl ) )
{
if( NULL != g_hcpContext.secondaryUrl )
{
rpal_memory_free( g_hcpContext.secondaryUrl );
g_hcpContext.secondaryUrl = NULL;
}
g_hcpContext.secondaryUrl = rpal_string_ntoa( secondaryHomeUrl );
}
g_hcpContext.enrollmentToken = NULL;
g_hcpContext.enrollmentTokenSize = 0;
getStoreConf(); /* Sets the agent ID platform. */
// Set the current configId
g_hcpContext.currentId.id.configId = configHint;
if( startBeacons() )
{
isInitSuccessful = TRUE;
}
else
{
rpal_debug_warning( "error starting beacons" );
}
CryptoLib_deinit();
}
else
{
rpal_debug_warning( "hcp platform could not init rpal" );
}
}
else
{
rInterlocked_decrement32( &g_hcpContext.isRunning );
rpal_debug_info( "hcp already launched" );
}
return isInitSuccessful;
}
