#include "CDSRefTable.h"
#include <stdlib.h>
#include <string.h>
#include <time.h>
#include <sys/sysctl.h> // for struct kinfo_proc and sysctl()
#include <syslog.h> // for syslog() to log calls
#include "PrivateTypes.h"
DSMutexSemaphore *gFWTableMutex = nil;
dsBool gLogFWRefCalls = false;
CDSRefTable::CDSRefTable ( RefFWDeallocateProc *deallocProc )
{
fTableCount = 0;
fRefCount = 0;
::memset( fRefTables, 0, sizeof( fRefTables ) );
if ( gFWTableMutex == nil )
{
gFWTableMutex = new DSMutexSemaphore();
if ( gFWTableMutex == nil ) throw((sInt32)eMemoryAllocError);
}
fDeallocProc = deallocProc;
}
CDSRefTable::~CDSRefTable ( void )
{
uInt32 i = 1;
uInt32 j = 1;
for ( i = 1; i <= kMaxFWTables; i++ ) {
if ( fRefTables[ i ] != nil )
{
for (j=0; j< kMaxFWTableItems; j++)
{
if (fRefTables[ i ]->fTableData[j] != nil)
{
free(fRefTables[ i ]->fTableData[j]);
fRefTables[ i ]->fTableData[j] = nil;
}
}
free( fRefTables[ i ] ); fRefTables[ i ] = nil;
}
}
if ( gFWTableMutex != nil )
{
delete( gFWTableMutex );
gFWTableMutex = nil;
}
}
tDirStatus CDSRefTable::VerifyReference ( tDirReference inDirRef,
uInt32 inType,
sInt32 inPID )
{
tDirStatus siResult = eDSNoErr;
sFWRefEntry *refData = nil;
sPIDFWInfo *pPIDInfo = nil;
siResult = GetReference( inDirRef, &refData );
if ( siResult == eDSNoErr )
{
if ( refData->fType != inType )
{
siResult = eDSInvalidRefType;
}
else
{
siResult = eDSInvalidRefType;
if (refData->fPID == inPID)
{
siResult = eDSNoErr;
}
else
{
pPIDInfo = refData->fChildPID;
while ( (pPIDInfo != nil) && (siResult != eDSNoErr) )
{
if (pPIDInfo->fPID == inPID)
{
siResult = eDSNoErr;
}
pPIDInfo = pPIDInfo->fNext;
}
}
}
}
return( siResult );
}
tDirStatus CDSRefTable::VerifyDirRef ( tDirReference inDirRef,
sInt32 inPID )
{
tDirStatus siResult = eDSDirSrvcNotOpened;
if ( gFWRefTable != nil )
{
siResult = gFWRefTable->VerifyReference( inDirRef, eDirectoryRefType, inPID );
}
return( siResult );
}
tDirStatus CDSRefTable::VerifyNodeRef ( tDirNodeReference inDirNodeRef,
sInt32 inPID )
{
tDirStatus siResult = eDSDirSrvcNotOpened;
if ( gFWRefTable != nil )
{
siResult = gFWRefTable->VerifyReference( inDirNodeRef, eNodeRefType, inPID );
}
return( siResult );
}
tDirStatus CDSRefTable::VerifyRecordRef ( tRecordReference inRecordRef,
sInt32 inPID )
{
tDirStatus siResult = eDSDirSrvcNotOpened;
if ( gFWRefTable != nil )
{
siResult = gFWRefTable->VerifyReference( inRecordRef, eRecordRefType, inPID );
}
return( siResult );
}
tDirStatus CDSRefTable::VerifyAttrListRef ( tAttributeListRef inAttributeListRef,
sInt32 inPID )
{
tDirStatus siResult = eDSDirSrvcNotOpened;
if ( gFWRefTable != nil )
{
siResult = gFWRefTable->VerifyReference( inAttributeListRef, eAttrListRefType, inPID );
}
return( siResult );
}
tDirStatus CDSRefTable::VerifyAttrValueRef ( tAttributeValueListRef inAttributeValueListRef,
sInt32 inPID )
{
tDirStatus siResult = eDSDirSrvcNotOpened;
if ( gFWRefTable != nil )
{
siResult = gFWRefTable->VerifyReference( inAttributeValueListRef, eAttrValueListRefType, inPID );
}
return( siResult );
}
tDirStatus CDSRefTable::NewDirRef ( uInt32 *outNewRef, sInt32 inPID )
{
tDirStatus siResult = eDSDirSrvcNotOpened;
if ( gFWRefTable != nil )
{
siResult = gFWRefTable->GetNewRef( outNewRef, 0, eDirectoryRefType, inPID );
}
return( siResult );
}
tDirStatus CDSRefTable::NewNodeRef ( uInt32 *outNewRef,
uInt32 inParentID,
sInt32 inPID )
{
tDirStatus siResult = eDSDirSrvcNotOpened;
if ( gFWRefTable != nil )
{
siResult = gFWRefTable->GetNewRef( outNewRef, inParentID, eNodeRefType, inPID );
}
return( siResult );
}
tDirStatus CDSRefTable::NewRecordRef ( uInt32 *outNewRef,
uInt32 inParentID,
sInt32 inPID )
{
tDirStatus siResult = eDSDirSrvcNotOpened;
if ( gFWRefTable != nil )
{
siResult = gFWRefTable->GetNewRef( outNewRef, inParentID, eRecordRefType, inPID );
}
return( siResult );
}
tDirStatus CDSRefTable::NewAttrListRef ( uInt32 *outNewRef,
uInt32 inParentID,
sInt32 inPID )
{
tDirStatus siResult = eDSDirSrvcNotOpened;
if ( gFWRefTable != nil )
{
siResult = gFWRefTable->GetNewRef( outNewRef, inParentID, eAttrListRefType, inPID );
}
return( siResult );
}
tDirStatus CDSRefTable::NewAttrValueRef ( uInt32 *outNewRef,
uInt32 inParentID,
sInt32 inPID )
{
tDirStatus siResult = eDSDirSrvcNotOpened;
if ( gFWRefTable != nil )
{
siResult = gFWRefTable->GetNewRef( outNewRef, inParentID, eAttrValueListRefType, inPID );
}
return( siResult );
}
tDirStatus CDSRefTable::RemoveDirRef ( uInt32 inDirRef, sInt32 inPID )
{
tDirStatus siResult = eDSDirSrvcNotOpened;
if ( gFWRefTable != nil )
{
siResult = gFWRefTable->RemoveRef( inDirRef, eDirectoryRefType, inPID );
}
return( siResult );
}
tDirStatus CDSRefTable::RemoveNodeRef ( uInt32 inNodeRef, sInt32 inPID )
{
tDirStatus siResult = eDSDirSrvcNotOpened;
if ( gFWRefTable != nil )
{
siResult = gFWRefTable->RemoveRef( inNodeRef, eNodeRefType, inPID );
}
return( siResult );
}
tDirStatus CDSRefTable::RemoveRecordRef ( uInt32 inRecRef, sInt32 inPID )
{
tDirStatus siResult = eDSDirSrvcNotOpened;
if ( gFWRefTable != nil )
{
siResult = gFWRefTable->RemoveRef( inRecRef, eRecordRefType, inPID );
}
return( siResult );
}
tDirStatus CDSRefTable::RemoveAttrListRef ( uInt32 inAttrListRef, sInt32 inPID )
{
tDirStatus siResult = eDSDirSrvcNotOpened;
if ( gFWRefTable != nil )
{
siResult = gFWRefTable->RemoveRef( inAttrListRef, eAttrListRefType, inPID );
}
return( siResult );
}
tDirStatus CDSRefTable::RemoveAttrValueRef ( uInt32 inAttrValueRef, sInt32 inPID )
{
tDirStatus siResult = eDSDirSrvcNotOpened;
if ( gFWRefTable != nil )
{
siResult = gFWRefTable->RemoveRef( inAttrValueRef, eAttrValueListRefType, inPID );
}
return( siResult );
}
sFWRefEntry* CDSRefTable::GetTableRef ( uInt32 inRefNum )
{
uInt32 uiSlot = 0;
uInt32 uiRefNum = (inRefNum & 0x00FFFFFF);
uInt32 uiTableNum = (inRefNum & 0xFF000000) >> 24;
sRefFWTable *pTable = nil;
sFWRefEntry *pOutEntry = nil;
gFWTableMutex->Wait();
try
{
pTable = GetThisTable( uiTableNum );
if ( pTable == nil ) throw( (sInt32)eDSInvalidReference );
uiSlot = uiRefNum % kMaxFWTableItems;
if ( pTable->fTableData != nil)
{
if ( pTable->fTableData[ uiSlot ] != nil )
{
if ( uiRefNum == pTable->fTableData[ uiSlot ]->fRefNum )
{
pOutEntry = pTable->fTableData[ uiSlot ];
}
}
}
}
catch( sInt32 err )
{
}
gFWTableMutex->Signal();
return( pOutEntry );
}
sRefFWTable* CDSRefTable::GetNextTable ( sRefFWTable *inTable )
{
uInt32 uiTblNum = 0;
sRefFWTable *pOutTable = nil;
gFWTableMutex->Wait();
try
{
if ( inTable == nil )
{
if ( fRefTables[ 1 ] == nil )
{
fRefTables[ 1 ] = (sRefFWTable *)::calloc( sizeof( sRefFWTable ), sizeof( char ) );
if ( fRefTables[ 1 ] == nil ) throw((sInt32)eMemoryAllocError);
fRefTables[ 1 ]->fTableNum = 1;
fTableCount = 1;
}
pOutTable = fRefTables[ 1 ];
}
else
{
uiTblNum = inTable->fTableNum + 1;
if (uiTblNum > kMaxFWTables) throw( (sInt32)eDSInvalidReference );
if ( fRefTables[ uiTblNum ] == nil )
{
fTableCount = uiTblNum;
fRefTables[ uiTblNum ] = (sRefFWTable *)::calloc( sizeof( sRefFWTable ), sizeof( char ) );
if ( fRefTables[ uiTblNum ] == nil ) throw((sInt32)eMemoryAllocError);
if (uiTblNum == 0) throw( (sInt32)eDSInvalidReference );
fRefTables[ uiTblNum ]->fTableNum = uiTblNum;
}
pOutTable = fRefTables[ uiTblNum ];
}
}
catch( sInt32 err )
{
}
gFWTableMutex->Signal();
return( pOutTable );
}
sRefFWTable* CDSRefTable::GetThisTable ( uInt32 inTableNum )
{
sRefFWTable *pOutTable = nil;
gFWTableMutex->Wait();
pOutTable = fRefTables[ inTableNum ];
gFWTableMutex->Signal();
return( pOutTable );
}
tDirStatus CDSRefTable::GetNewRef ( uInt32 *outRef,
uInt32 inParentID,
eRefTypes inType,
sInt32 inPID )
{
bool done = false;
tDirStatus outResult = eDSNoErr;
sRefFWTable *pCurTable = nil;
uInt32 uiRefNum = 0;
uInt32 uiCntr = 0;
uInt32 uiSlot = 0;
uInt32 uiTableNum = 0;
gFWTableMutex->Wait();
try
{
*outRef = 0;
while ( !done )
{
pCurTable = GetNextTable( pCurTable );
if ( pCurTable == nil ) throw( (sInt32)eDSRefTableCSBPAllocError );
if ( pCurTable->fItemCnt < kMaxFWTableItems )
{
uiCntr = 0;
uiTableNum = pCurTable->fTableNum;
while ( (uiCntr < kMaxFWTableItems) && !done ) {
if ( (pCurTable->fCurRefNum == 0) ||
(pCurTable->fCurRefNum > 0x000FFFFF) )
{
pCurTable->fCurRefNum = 1;
}
uiRefNum = pCurTable->fCurRefNum++;
uiRefNum += 0x00300000;
uiSlot = uiRefNum % kMaxFWTableItems;
if ( pCurTable->fTableData[ uiSlot ] == nil )
{
pCurTable->fTableData[ uiSlot ] = (sFWRefEntry *)::calloc( sizeof( sFWRefEntry ), sizeof( char ) );
if ( pCurTable->fTableData[ uiSlot ] == nil ) throw( (sInt32)eDSRefTableCSBPAllocError );
pCurTable->fTableData[ uiSlot ]->fRefNum = uiRefNum;
pCurTable->fTableData[ uiSlot ]->fType = inType;
pCurTable->fTableData[ uiSlot ]->fParentID = inParentID;
pCurTable->fTableData[ uiSlot ]->fPID = inPID;
pCurTable->fTableData[ uiSlot ]->fOffset = 0;
pCurTable->fTableData[ uiSlot ]->fBufTag = 0;
pCurTable->fTableData[ uiSlot ]->fChildren = nil;
pCurTable->fTableData[ uiSlot ]->fChildPID = nil;
uiTableNum = (uiTableNum << 24);
uiRefNum = uiRefNum | uiTableNum;
*outRef = uiRefNum;
pCurTable->fItemCnt++;
fRefCount++;
outResult = eDSNoErr;
done = true;
}
uiCntr++; }
}
}
if ( inParentID != 0 )
{
outResult = LinkToParent( *outRef, inType, inParentID, inPID );
}
}
catch( sInt32 err )
{
outResult = (tDirStatus)err;
}
gFWTableMutex->Signal();
return( outResult );
}
tDirStatus CDSRefTable::LinkToParent ( uInt32 inRefNum, uInt32 inType, uInt32 inParentID, sInt32 inPID )
{
tDirStatus dsResult = eDSNoErr;
sFWRefEntry *pCurrRef = nil;
sListFWInfo *pChildInfo = nil;
gFWTableMutex->Wait();
try
{
pCurrRef = GetTableRef( inParentID );
if ( pCurrRef == nil ) throw( (sInt32)eDSInvalidReference );
pChildInfo = (sListFWInfo *)::calloc( sizeof( sListFWInfo ), sizeof( char ) );
if ( pChildInfo == nil ) throw( (sInt32)eDSRefTableCSBPAllocError );
pChildInfo->fRefNum = inRefNum;
pChildInfo->fType = inType;
pChildInfo->fPID = inPID;
pChildInfo->fNext = pCurrRef->fChildren;
pCurrRef->fChildren = pChildInfo;
}
catch( sInt32 err )
{
dsResult = (tDirStatus)err;
}
gFWTableMutex->Signal();
return( dsResult );
}
tDirStatus CDSRefTable::UnlinkFromParent ( uInt32 inRefNum )
{
tDirStatus dsResult = eDSNoErr;
uInt32 i = 1;
uInt32 parentID = 0;
sFWRefEntry *pCurrRef = nil;
sFWRefEntry *pParentRef = nil;
sListFWInfo *pCurrChild = nil;
sListFWInfo *pPrevChild = nil;
gFWTableMutex->Wait();
try
{
pCurrRef = GetTableRef( inRefNum );
if ( pCurrRef == nil ) throw( (sInt32)eDSInvalidReference );
parentID = pCurrRef->fParentID;
if ( parentID != 0 )
{
pParentRef = GetTableRef( parentID );
if ( pParentRef == nil ) throw( (sInt32)eDSInvalidReference );
pCurrChild = pParentRef->fChildren;
pPrevChild = pParentRef->fChildren;
while ( pCurrChild != nil )
{
if ( pCurrChild->fRefNum == inRefNum )
{
if ( i == 1 )
{
pParentRef->fChildren = pCurrChild->fNext;
}
else
{
pPrevChild->fNext = pCurrChild->fNext;
}
free( pCurrChild );
pCurrChild = nil;
break;
}
pPrevChild = pCurrChild;
pCurrChild = pCurrChild->fNext;
i++;
}
}
}
catch( sInt32 err )
{
dsResult = (tDirStatus)err;
}
gFWTableMutex->Signal();
return( dsResult );
}
tDirStatus CDSRefTable::GetReference ( uInt32 inRefNum, sFWRefEntry **outRefData )
{
tDirStatus dsResult = eDSNoErr;
sFWRefEntry *pCurrRef = nil;
gFWTableMutex->Wait();
try
{
pCurrRef = GetTableRef( inRefNum );
if ( pCurrRef == nil ) throw( (sInt32)eDSInvalidReference );
*outRefData = pCurrRef;
}
catch( sInt32 err )
{
dsResult = (tDirStatus)err;
}
gFWTableMutex->Signal();
return( dsResult );
}
tDirStatus CDSRefTable::RemoveRef ( uInt32 inRefNum, uInt32 inType, sInt32 inPID )
{
tDirStatus dsResult = eDSNoErr;
sFWRefEntry *pCurrRef = nil;
sRefFWTable *pTable = nil;
uInt32 uiSlot = 0;
uInt32 uiTableNum = (inRefNum & 0xFF000000) >> 24;
uInt32 uiRefNum = (inRefNum & 0x00FFFFFF);
bool doFree = false;
sPIDFWInfo *pPIDInfo = nil;
sPIDFWInfo *pPrevPIDInfo = nil;
gFWTableMutex->Wait();
try
{
dsResult = VerifyReference( inRefNum, inType, inPID );
if ( dsResult == eDSNoErr )
{
pTable = GetThisTable( uiTableNum );
if ( pTable == nil ) throw( (sInt32)eDSInvalidReference );
uiSlot = uiRefNum % kMaxFWTableItems;
if ( inType != eDirectoryRefType ) {
dsResult = UnlinkFromParent( inRefNum );
if ( dsResult != eDSNoErr ) throw( (sInt32)dsResult );
}
pCurrRef = GetTableRef( inRefNum ); if ( pCurrRef == nil ) throw( (sInt32)eDSInvalidReference );
if (inType != pCurrRef->fType) throw( (sInt32)eDSInvalidReference );
if ( pCurrRef->fChildren != nil )
{
gFWTableMutex->Signal();
RemoveChildren( pCurrRef->fChildren, inPID );
gFWTableMutex->Wait();
}
if (pCurrRef->fPID == inPID)
{
pCurrRef->fPID = -1;
if (pCurrRef->fChildPID == nil)
{
doFree = true;
}
}
else
{
pPIDInfo = pCurrRef->fChildPID;
pPrevPIDInfo = pCurrRef->fChildPID;
while (pPIDInfo != nil)
{
if (pPIDInfo->fPID == inPID)
{
if (pPIDInfo == pCurrRef->fChildPID)
{
pCurrRef->fChildPID = pCurrRef->fChildPID->fNext;
free(pPIDInfo);
pPIDInfo = pCurrRef->fChildPID;
pPrevPIDInfo = pCurrRef->fChildPID;
}
else
{
pPrevPIDInfo->fNext = pPIDInfo->fNext;
free(pPIDInfo);
pPIDInfo = pPrevPIDInfo->fNext;
}
}
else
{
pPrevPIDInfo = pPIDInfo;
pPIDInfo = pPIDInfo->fNext;
}
}
if ( (pCurrRef->fPID == -1) && (pCurrRef->fChildPID == nil) )
{
doFree = true;
}
}
if (doFree)
{
if ( pTable->fTableData[ uiSlot ] != nil )
{
if ( uiRefNum == pTable->fTableData[ uiSlot ]->fRefNum )
{
pCurrRef = pTable->fTableData[ uiSlot ];
pTable->fTableData[ uiSlot ] = nil;
pTable->fItemCnt--;
fRefCount--;
if (fDeallocProc != nil)
{
gFWTableMutex->Signal();
dsResult = (tDirStatus)(*fDeallocProc)(inRefNum, pCurrRef);
gFWTableMutex->Wait();
}
if ( (pCurrRef->fBufTag == 'DbgA') || (pCurrRef->fBufTag == 'DbgB') )
{
if (inType == eAttrListRefType)
{
syslog(LOG_CRIT, "DS:dsCloseAttributeList:CDSRefTable::RemoveAttrListRef ref = %d", inRefNum);
}
else if (inType == eAttrValueListRefType)
{
syslog(LOG_CRIT, "DS:dsCloseAttributeValueList:CDSRefTable::RemoveAttrValueRef ref = %d", inRefNum);
}
}
free(pCurrRef);
pCurrRef = nil;
}
}
}
}
}
catch( sInt32 err )
{
dsResult = (tDirStatus)err;
}
gFWTableMutex->Signal();
return( dsResult );
}
void CDSRefTable::RemoveChildren ( sListFWInfo *inChildList, sInt32 inPID )
{
sListFWInfo *pCurrChild = nil;
sListFWInfo *pNextChild = nil;
gFWTableMutex->Wait();
try
{
pCurrChild = inChildList;
while ( pCurrChild != nil )
{
pNextChild = pCurrChild->fNext;
if ( pCurrChild->fPID == inPID )
{
gFWTableMutex->Signal();
RemoveRef( pCurrChild->fRefNum, pCurrChild->fType, inPID );
gFWTableMutex->Wait();
}
pCurrChild = pNextChild;
}
}
catch( sInt32 err )
{
}
gFWTableMutex->Signal();
}
tDirStatus CDSRefTable:: AddChildPIDToRef ( uInt32 inRefNum, uInt32 inParentPID, sInt32 inChildPID )
{
tDirStatus dsResult = eDSNoErr;
sFWRefEntry *pCurrRef = nil;
sPIDFWInfo *pChildPIDInfo = nil;
gFWTableMutex->Wait();
try
{
dsResult = gFWRefTable->VerifyReference( inRefNum, eNodeRefType, inParentPID );
if ( dsResult != eDSNoErr ) throw( (sInt32)dsResult );
pCurrRef = gFWRefTable->GetTableRef( inRefNum );
if ( pCurrRef == nil ) throw( (sInt32)eDSInvalidReference );
pChildPIDInfo = (sPIDFWInfo *)::calloc( 1, sizeof( sPIDFWInfo ) );
if ( pChildPIDInfo == nil ) throw( (sInt32)eDSRefTableCSBPAllocError );
pChildPIDInfo->fPID = inChildPID;
pChildPIDInfo->fNext = pCurrRef->fChildPID;
pCurrRef->fChildPID = pChildPIDInfo;
}
catch( sInt32 err )
{
dsResult = (tDirStatus)err;
}
gFWTableMutex->Signal();
return( dsResult );
}
tDirStatus CDSRefTable::GetOffset ( uInt32 inRefNum, uInt32 inType, uInt32* outOffset, sInt32 inPID )
{
tDirStatus siResult = eDSDirSrvcNotOpened;
sFWRefEntry *pCurrRef = nil;
if (gFWRefTable != nil)
{
siResult = gFWRefTable->VerifyReference( inRefNum, inType, inPID );
if (siResult == eDSNoErr)
{
pCurrRef = gFWRefTable->GetTableRef( inRefNum );
siResult = eDSInvalidReference;
if ( pCurrRef != nil )
{
*outOffset = pCurrRef->fOffset;
siResult = eDSNoErr;
}
}
}
return( siResult );
}
tDirStatus CDSRefTable::SetOffset ( uInt32 inRefNum, uInt32 inType, uInt32 inOffset, sInt32 inPID )
{
tDirStatus siResult = eDSDirSrvcNotOpened;
sFWRefEntry *pCurrRef = nil;
if (gFWRefTable != nil)
{
siResult = gFWRefTable->VerifyReference( inRefNum, inType, inPID );
if (siResult == eDSNoErr)
{
pCurrRef = gFWRefTable->GetTableRef( inRefNum );
siResult = eDSInvalidReference;
if ( pCurrRef != nil )
{
pCurrRef->fOffset = inOffset;
siResult = eDSNoErr;
}
}
}
return( siResult );
}
tDirStatus CDSRefTable::GetBufTag ( uInt32 inRefNum, uInt32 inType, uInt32* outBufTag, sInt32 inPID )
{
tDirStatus siResult = eDSDirSrvcNotOpened;
sFWRefEntry *pCurrRef = nil;
if (gFWRefTable != nil)
{
siResult = gFWRefTable->VerifyReference( inRefNum, inType, inPID );
if (siResult == eDSNoErr)
{
pCurrRef = gFWRefTable->GetTableRef( inRefNum );
siResult = eDSInvalidReference;
if ( pCurrRef != nil )
{
*outBufTag = pCurrRef->fBufTag;
siResult = eDSNoErr;
}
}
}
return( siResult );
}
tDirStatus CDSRefTable::SetBufTag ( uInt32 inRefNum, uInt32 inType, uInt32 inBufTag, sInt32 inPID )
{
tDirStatus siResult = eDSDirSrvcNotOpened;
sFWRefEntry *pCurrRef = nil;
if (gFWRefTable != nil)
{
siResult = gFWRefTable->VerifyReference( inRefNum, inType, inPID );
if (siResult == eDSNoErr)
{
pCurrRef = gFWRefTable->GetTableRef( inRefNum );
siResult = eDSInvalidReference;
if ( pCurrRef != nil )
{
pCurrRef->fBufTag = inBufTag;
if ( (inBufTag == 'DbgA') || (inBufTag == 'DbgB') )
{
if ( (inType == eAttrListRefType) || (inType == eAttrValueListRefType) )
{
uInt32 aRefCount = gFWRefTable->GetRefCount();
if ( ((aRefCount % 25) == 0) && (aRefCount > 100) )
{
syslog(LOG_CRIT, "DS:CDSRefTable::ClientSideRefCountExceedingReasonableValue Ref Count = %d", aRefCount);
}
}
}
siResult = eDSNoErr;
}
}
}
return( siResult );
}
uInt32 CDSRefTable::GetRefCount ( void )
{
return( fRefCount );
}