/**************************************************************************** Desc: ****************************************************************************/ RCODE F_IOBufferMgr::setupBufferMgr( FLMUINT uiMaxBuffers, FLMUINT uiMaxBytes, FLMBOOL bReuseBuffers) { RCODE rc = NE_FLM_OK; f_assert( uiMaxBuffers); f_assert( uiMaxBytes); if( RC_BAD( rc = f_mutexCreate( &m_hMutex))) { goto Exit; } #if !defined( FLM_UNIX) && !defined( FLM_NLM) if( RC_BAD( rc = f_semCreate( &m_hAvailSem))) { goto Exit; } #endif m_uiMaxBuffers = uiMaxBuffers; m_uiMaxBufferBytes = uiMaxBytes; m_bReuseBuffers = bReuseBuffers; Exit: return( rc); }
FINLINE int _sema_wait( sema_t * pSem) { int iErr = 0; pthread_mutex_lock( &pSem->lock); while( !pSem->count) { if( (iErr = pthread_cond_wait( &pSem->cond, &pSem->lock)) != 0) { if( iErr == EINTR) { iErr = 0; } else { f_assert( 0); goto Exit; } } } pSem->count--; f_assert( pSem->count >= 0); Exit: pthread_mutex_unlock( &pSem->lock); return( iErr); }
/**************************************************************************** Desc: ****************************************************************************/ void F_IOBuffer::notifyComplete( RCODE completionRc) { f_assert( m_bPending); m_bPending = FALSE; m_bCompleted = TRUE; m_completionRc = completionRc; m_uiEndTime = FLM_GET_TIMER(); m_uiElapsedTime = FLM_TIMER_UNITS_TO_MILLI( FLM_ELAPSED_TIME( m_uiEndTime, m_uiStartTime)); if( m_fnCompletion) { m_fnCompletion( this, m_pvData); m_fnCompletion = NULL; m_pvData = NULL; } if( m_pBufferMgr) { f_assert( m_eList == MGR_LIST_PENDING); f_mutexLock( m_pBufferMgr->m_hMutex); m_pBufferMgr->unlinkFromList( this); m_pBufferMgr->linkToList( &m_pBufferMgr->m_pFirstUsed, this); if( RC_OK( m_pBufferMgr->m_completionRc) && RC_BAD( completionRc)) { m_pBufferMgr->m_completionRc = completionRc; } f_mutexUnlock( m_pBufferMgr->m_hMutex); } }
/**************************************************************************** Desc: ****************************************************************************/ void F_IOBufferMgr::linkToList( F_IOBuffer ** ppListHead, F_IOBuffer * pIOBuffer) { f_assertMutexLocked( m_hMutex); f_assert( pIOBuffer->m_eList == MGR_LIST_NONE); pIOBuffer->m_pPrev = NULL; if( (pIOBuffer->m_pNext = *ppListHead) != NULL) { (*ppListHead)->m_pPrev = pIOBuffer; } *ppListHead = pIOBuffer; if( ppListHead == &m_pFirstPending) { f_assert( !pIOBuffer->m_bPending); pIOBuffer->m_eList = MGR_LIST_PENDING; } else if( ppListHead == &m_pFirstUsed) { pIOBuffer->m_eList = MGR_LIST_USED; } else { pIOBuffer->m_eList = MGR_LIST_AVAIL; } }
void FLMAPI f_mutexLock( F_MUTEX hMutex) { F_INTERLOCK * pInterlock = (F_INTERLOCK *)hMutex; #ifdef FLM_DEBUG if( pInterlock->locked) { f_assert( pInterlock->uiThreadId != _threadid); } #endif while( f_atomicExchange( &pInterlock->locked, 1) != 0) { #ifdef FLM_DEBUG f_atomicInc( &pInterlock->waitCount); #endif Sleep( 0); } #ifdef FLM_DEBUG f_assert( pInterlock->uiThreadId == 0); pInterlock->uiThreadId = _threadid; f_atomicInc( &pInterlock->lockedCount); #endif }
bool TestExtOptions::test_assert() { f_assert(true); try { f_assert(false); } catch (Assertion e) { return Count(true); } return Count(true); }
void FLMAPI f_assertMutexLocked( F_MUTEX hMutex) { #ifdef FLM_DEBUG f_assert( ((F_INTERLOCK *)hMutex)->locked == 1); f_assert( ((F_INTERLOCK *)hMutex)->uiThreadId == _threadid); #else F_UNREFERENCED_PARM( hMutex); #endif }
void FLMAPI f_mutexUnlock( F_MUTEX hMutex) { F_INTERLOCK * pInterlock = (F_INTERLOCK *)hMutex; f_assert( pInterlock->locked == 1); #ifdef FLM_DEBUG f_assert( pInterlock->uiThreadId == _threadid); pInterlock->uiThreadId = 0; #endif f_atomicExchange( &pInterlock->locked, 0); }
/**************************************************************************** Desc: ****************************************************************************/ RCODE FLMAPI f_rwlockAcquire( F_RWLOCK hReadWriteLock, F_SEM hSem, FLMBOOL bWriter) { RCODE rc = NE_FLM_OK; F_RWLOCK_IMP * pReadWriteLock = (F_RWLOCK_IMP *)hReadWriteLock; FLMBOOL bMutexLocked = FALSE; f_mutexLock( pReadWriteLock->hMutex); bMutexLocked = TRUE; if( bWriter) { if( pReadWriteLock->iRefCnt != 0) { rc = f_notifyWait( pReadWriteLock->hMutex, hSem, (void *)((FLMINT)bWriter), &pReadWriteLock->pNotifyList); } if( RC_OK( rc)) { f_assert( !pReadWriteLock->iRefCnt); pReadWriteLock->iRefCnt = -1; pReadWriteLock->uiWriteThread = f_threadId(); } } else { if( pReadWriteLock->iRefCnt < 0 || pReadWriteLock->pNotifyList) { rc = f_notifyWait( pReadWriteLock->hMutex, hSem, (void *)((FLMINT)bWriter), &pReadWriteLock->pNotifyList); } if( RC_OK( rc)) { pReadWriteLock->iRefCnt++; } } f_assert( RC_BAD( rc) || pReadWriteLock->iRefCnt); if( bMutexLocked) { f_mutexUnlock( pReadWriteLock->hMutex); } return( rc); }
int tr069_load_cookie(tr069_rpc_mgr *rpc_handle) { tr069_debug("\n"); tr069_interface_mgr *interface_handle = NULL; VOID_T *curl_handle = NULL; interface_handle = rpc_handle->tr069_handle->interface_handle; f_assert(NULL != interface_handle); curl_handle = interface_handle->curl_handle; f_assert(NULL != curl_handle); curl_easy_setopt(curl_handle, CURLOPT_COOKIEFILE, N_STB_PARAM_PATH "/cookie.txt"); return FV_OK; }
int tr069_clr_req_cookie(tr069_rpc_mgr *rpc_handle) { tr069_debug("\n"); tr069_interface_mgr *interface_handle = NULL; VOID_T *curl_handle = NULL; interface_handle = rpc_handle->tr069_handle->interface_handle; f_assert(NULL != interface_handle); curl_handle = interface_handle->curl_handle; f_assert(NULL != curl_handle); curl_easy_setopt(curl_handle, CURLOPT_COOKIE, ""); return FV_OK; }
/**************************************************************************** Desc: Retrieves the value associated with the specified name from the list of INI_STRUCTs ****************************************************************************/ FLMBOOL FTKAPI F_IniFile::getParam( const char * pszParamName, FLMUINT * puiParamVal) { FLMBOOL bFound = FALSE; INI_LINE * pLine = NULL; f_assert( m_bReady); pLine = findParam( pszParamName); if( !pLine) { goto Exit; } if( !pLine->pszParamValue) { goto Exit; } fromAscii( puiParamVal, pLine->pszParamValue); bFound = TRUE; Exit: return( bFound); }
int tr069_clear_cookie(tr069_rpc_mgr *rpc_handle) { tr069_debug("\n"); tr069_interface_mgr *interface_handle = NULL; VOID_T *curl_handle = NULL; interface_handle = rpc_handle->tr069_handle->interface_handle; f_assert(NULL != interface_handle); curl_handle = interface_handle->curl_handle; f_assert(NULL != curl_handle); curl_easy_setopt(curl_handle, CURLOPT_COOKIESESSION, 1); curl_easy_setopt(curl_handle, CURLOPT_COOKIELIST, "ALL"); curl_easy_setopt(curl_handle, CURLOPT_COOKIELIST, "FLUSH"); return FV_OK; }
/**************************************************************************** Desc: Stores a new value for the specified name (or creates a new name/value pair) in the list of INI_STRUCTs ****************************************************************************/ RCODE FTKAPI F_IniFile::setParam( const char * pszParamName, const char * pszParamVal) { RCODE rc = NE_FLM_OK; INI_LINE * pLine; f_assert( m_bReady); // If the parameter exists in the list, just store the new value. // Othewise, create a new INI_LINE and add it to the list pLine = findParam( pszParamName); if( !pLine) { if( RC_BAD( rc = setParamCommon( &pLine, pszParamName))) { goto Exit; } } if( RC_BAD( rc = toAscii( &pLine->pszParamValue, pszParamVal))) { goto Exit; } Exit: return( rc); }
/**************************************************************************** Desc: Retrieves the value associated with the specified name from the list of INI_STRUCTs ****************************************************************************/ FLMBOOL FTKAPI F_IniFile::getParam( const char * pszParamName, char ** ppszParamVal) { FLMBOOL bFound = FALSE; INI_LINE * pLine = NULL; f_assert( m_bReady); *ppszParamVal = NULL; pLine = findParam( pszParamName); if( !pLine) { goto Exit; } if( pLine->pszParamValue == NULL) { goto Exit; } *ppszParamVal = pLine->pszParamValue; bFound = TRUE; Exit: return( bFound); }
/**************************************************************************** Desc: Retrieves the value associated with the specified name from the list of INI_STRUCTs ****************************************************************************/ FLMBOOL FTKAPI F_IniFile::getParam( const char * pszParamName, FLMBOOL * pbParamVal) // Out: The value associated with name { FLMBOOL bFound = FALSE; INI_LINE * pLine = NULL; f_assert( m_bReady); pLine = findParam( pszParamName); if( !pLine) { goto Exit; } if( !pLine->pszParamValue) { goto Exit; } fromAscii( pbParamVal, pLine->pszParamValue); bFound = TRUE; Exit: return( bFound); }
RCODE f_semWait( F_SEM hSem, FLMUINT uiTimeout) { RCODE rc = NE_FLM_OK; f_assert( hSem != F_SEM_NULL); // Catch the F_WAITFOREVER flag so we can directly call _sema_wait // instead of passing F_WAITFOREVER through to _sema_timedwait. // Note that on AIX the datatype of the uiTimeout (in the timespec // struct) is surprisingly a signed int, which makes this catch // essential. if( uiTimeout == F_WAITFOREVER) { if( _sema_wait( (sema_t *)hSem)) { rc = RC_SET( NE_FLM_ERROR_WAITING_ON_SEMAPHORE); } } else { if( _sema_timedwait( (sema_t *)hSem, (unsigned int)uiTimeout)) { rc = RC_SET( NE_FLM_WAIT_TIMEOUT); } } return( rc); }
FINLINE int _sema_wait( sema_t * pSem) { int iErr = 0; for( ;;) { if( (iErr = sema_wait( pSem)) != 0) { if( iErr == EINTR) { iErr = 0; continue; } else { f_assert( 0); goto Exit; } } break; } Exit: return( iErr); }
RCODE f_semCreate( F_SEM * phSem) { RCODE rc = NE_FLM_OK; f_assert( phSem != NULL); if( RC_BAD( rc = f_alloc( sizeof( sema_t), phSem))) { goto Exit; } #if defined( FLM_SOLARIS) if( sema_init( (sema_t *)*phSem, 0, USYNC_THREAD, NULL) < 0) #else if( sema_init( (sema_t *)*phSem) < 0) #endif { f_free( phSem); *phSem = F_SEM_NULL; rc = RC_SET( NE_FLM_COULD_NOT_CREATE_SEMAPHORE); goto Exit; } Exit: return( rc); }
/**************************************************************************** Desc: ****************************************************************************/ void FTKAPI F_IOBuffer::clearPending( void) { f_assert( m_bPending); if( m_pBufferMgr) { f_assert( m_eList == MGR_LIST_PENDING); f_mutexLock( m_pBufferMgr->m_hMutex); m_pBufferMgr->unlinkFromList( this); m_pBufferMgr->linkToList( &m_pBufferMgr->m_pFirstUsed, this); f_mutexUnlock( m_pBufferMgr->m_hMutex); } m_bPending = FALSE; m_uiStartTime = 0; }
/**************************************************************************** Desc: ****************************************************************************/ F_MultiFileHdl::~F_MultiFileHdl() { if( m_bOpen) { closeFile(); } f_assert( !m_pLockFileHdl); }
/**************************************************************************** Desc: ****************************************************************************/ RCODE FLMAPI f_rwlockPromote( F_RWLOCK hReadWriteLock, F_SEM hSem) { RCODE rc = NE_FLM_OK; F_RWLOCK_IMP * pReadWriteLock = (F_RWLOCK_IMP *)hReadWriteLock; FLMBOOL bMutexLocked = FALSE; f_mutexLock( pReadWriteLock->hMutex); bMutexLocked = TRUE; if( pReadWriteLock->iRefCnt <= 0) { rc = RC_SET_AND_ASSERT( NE_FLM_ILLEGAL_OP); goto Exit; } pReadWriteLock->iRefCnt--; if( pReadWriteLock->iRefCnt != 0) { rc = f_notifyWait( pReadWriteLock->hMutex, hSem, (void *)TRUE, &pReadWriteLock->pNotifyList); } if( RC_OK( rc)) { f_assert( !pReadWriteLock->iRefCnt); pReadWriteLock->iRefCnt = -1; pReadWriteLock->uiWriteThread = f_threadId(); } Exit: f_assert( RC_BAD( rc) || pReadWriteLock->iRefCnt); if( bMutexLocked) { f_mutexUnlock( pReadWriteLock->hMutex); } return( rc); }
int sema_signal( sema_t * pSem) { pthread_mutex_lock( &pSem->lock); pSem->count++; f_assert( pSem->count > 0); pthread_cond_signal( &pSem->cond); pthread_mutex_unlock( &pSem->lock); return( 0); }
void FLMAPI f_mutexDestroy( F_MUTEX * phMutex) { f_assert( phMutex != NULL); if (*phMutex != F_MUTEX_NULL) { free( *phMutex); *phMutex = F_MUTEX_NULL; } }
/**************************************************************************** Desc: ****************************************************************************/ RCODE FLMAPI f_rwlockRelease( F_RWLOCK hReadWriteLock) { RCODE rc = NE_FLM_OK; F_RWLOCK_IMP * pReadWriteLock = (F_RWLOCK_IMP *)hReadWriteLock; FLMBOOL bMutexLocked = FALSE; f_mutexLock( pReadWriteLock->hMutex); bMutexLocked = TRUE; if( pReadWriteLock->iRefCnt > 0) { pReadWriteLock->iRefCnt--; } else if( pReadWriteLock->iRefCnt == -1) { f_assert( pReadWriteLock->uiWriteThread == f_threadId()); pReadWriteLock->iRefCnt = 0; } else { rc = RC_SET_AND_ASSERT( NE_FLM_ILLEGAL_OP); goto Exit; } if( !pReadWriteLock->iRefCnt && pReadWriteLock->pNotifyList) { f_rwlockNotify( pReadWriteLock); } Exit: f_assert( RC_BAD( rc) || pReadWriteLock->iRefCnt >= 0); if( bMutexLocked) { f_mutexUnlock( pReadWriteLock->hMutex); } return( rc); }
void f_semDestroy( F_SEM * phSem) { f_assert( phSem != NULL); if (*phSem != F_SEM_NULL) { sema_destroy( (sema_t *)*phSem); f_free( phSem); *phSem = F_SEM_NULL; } }
RCODE FLMAPI f_mutexCreate( F_MUTEX * phMutex) { RCODE rc = NE_FLM_OK; pthread_mutexattr_t * pMutexAttr = NULL; f_assert( phMutex != NULL); // NOTE: Cannot call f_alloc because the memory initialization needs // to be able to set up mutexes. if ((*phMutex = (F_MUTEX)malloc( sizeof( pthread_mutex_t))) == F_MUTEX_NULL) { rc = RC_SET( NE_FLM_MEM); goto Exit; } #if defined( FLM_DEBUG) && defined( FLM_LINUX) { pthread_mutexattr_t mutexAttr; if( !pthread_mutexattr_init( &mutexAttr)) { pMutexAttr = &mutexAttr; pthread_mutexattr_settype( pMutexAttr, PTHREAD_MUTEX_ERRORCHECK_NP); } } #endif if( pthread_mutex_init( (pthread_mutex_t *)*phMutex, pMutexAttr) != 0) { // NOTE: Cannot call f_free because we had to use malloc up above due // to the fact that the memory subsystem uses a mutex before itis // completely ready to go. free( *phMutex); *phMutex = F_MUTEX_NULL; rc = RC_SET( NE_FLM_COULD_NOT_CREATE_MUTEX); goto Exit; } Exit: if( pMutexAttr) { pthread_mutexattr_destroy( pMutexAttr); } return( rc); }
/**************************************************************************** Desc: ****************************************************************************/ F_IOBufferMgr::~F_IOBufferMgr() { f_assert( !m_pFirstPending); f_assert( !m_pFirstUsed); f_assert( !m_pAvailNotify); while( m_pFirstAvail) { m_pFirstAvail->Release(); } if( m_hMutex != F_MUTEX_NULL) { f_mutexDestroy( &m_hMutex); } #if !defined( FLM_UNIX) && !defined( FLM_NLM) if( m_hAvailSem != F_SEM_NULL) { f_semDestroy( &m_hAvailSem); } #endif }
/**************************************************************************** Desc: ****************************************************************************/ void FTKAPI F_IOBuffer::setPending( void) { f_assert( !m_bPending); if( m_pBufferMgr) { f_assert( m_eList == MGR_LIST_USED); f_mutexLock( m_pBufferMgr->m_hMutex); m_pBufferMgr->unlinkFromList( this); m_pBufferMgr->linkToList( &m_pBufferMgr->m_pFirstPending, this); f_mutexUnlock( m_pBufferMgr->m_hMutex); } #ifndef FLM_UNIX f_assert( !m_pAsyncClient || f_semGetSignalCount( ((F_FileAsyncClient *)m_pAsyncClient)->m_hSem) == 0); #endif m_bPending = TRUE; m_uiStartTime = FLM_GET_TIMER(); m_uiEndTime = 0; }
/**************************************************************************** Desc: Sets a character's type flag in the character lookup table ****************************************************************************/ void F_XML::setCharFlag( FLMUNICODE uLowChar, FLMUNICODE uHighChar, FLMUINT16 ui16Flag) { FLMUINT uiLoop; f_assert( uLowChar <= uHighChar); for( uiLoop = (FLMUINT)uLowChar; uiLoop <= (FLMUINT)uHighChar; uiLoop++) { m_pCharTable[ uiLoop].ucFlags |= (FLMBYTE)ui16Flag; } }