自学教程：C++ CL_LOG_DEBUG_ERROR函数代码示例

ClRcTclLogCompEntryUnpackNAdd(ClBufferHandleT        msg,                         ClLogStreamOwnerDataT  *pStreamOwnerData){    ClRcT             rc        = CL_OK;    ClLogCompKeyT     compKey   = {0};    ClLogCompKeyT     *pCompKey = NULL;    ClLogSOCompDataT  compData  = {0};    ClLogSOCompDataT  *pData    = NULL;    CL_LOG_DEBUG_TRACE(("Enter"));    rc = VDECL_VER(clXdrUnmarshallClLogCompKeyT, 4, 0, 0)(msg, &compKey);    if( CL_OK != rc )    {        CL_LOG_DEBUG_ERROR(("VDECL_VER(clXdrUnmarshallClLogCompKeyT, 4, 0, 0)(): rc[0x %x]", rc));        return rc;    }    rc = VDECL_VER(clXdrUnmarshallClLogSOCompDataT, 4, 0, 0)(msg, &compData);    if( CL_OK != rc )    {        CL_LOG_DEBUG_ERROR(("VDECL_VER(clXdrUnmarshallClLogSOCompDataT, 4, 0, 0)(): rc[0x %x]", rc));            return rc;    }    pCompKey = (ClLogCompKeyT*)clHeapCalloc(1, sizeof(ClLogCompKeyT));    if( NULL == pCompKey )    {        CL_LOG_DEBUG_ERROR(( "clHeapCalloc()"));        return CL_LOG_RC(CL_ERR_NO_MEMORY);    }        *pCompKey = compKey;    CL_LOG_DEBUG_VERBOSE(("compKey.nodeAddress: %u", compKey.nodeAddr));    CL_LOG_DEBUG_VERBOSE(("compKey.compId     : %u", compKey.compId));    pData = (ClLogSOCompDataT*)clHeapCalloc(1, sizeof(ClLogSOCompDataT));    if( NULL == pData )    {        CL_LOG_DEBUG_ERROR(( "clHeapCalloc()"));        clHeapFree(pCompKey);        return CL_LOG_RC(CL_ERR_NO_MEMORY);    }        *pData = compData;    CL_LOG_DEBUG_VERBOSE(("compData.refCount    : %u", pData->refCount));    CL_LOG_DEBUG_VERBOSE(("compData.ackerCnt    : %u", pData->ackerCnt));    CL_LOG_DEBUG_VERBOSE(("compData.nonAckerCnt : %u", pData->nonAckerCnt));    rc = clCntNodeAdd(pStreamOwnerData->hCompTable,                       (ClCntKeyHandleT) pCompKey,                      (ClCntDataHandleT) pData, NULL);    if( CL_OK != rc )    {        CL_LOG_DEBUG_ERROR(( "clCntNodeAdd(): rc[0x %x]", rc));        clHeapFree(pData);        clHeapFree(pCompKey);    }    CL_LOG_DEBUG_TRACE(("Exit"));    return CL_OK;}

ClRcTclLogSOLocalStateRecover(ClHandleT       hLibCkpt,                          ClLogSOEoDataT  *pSoEoEntry){    ClRcT                  rc              = CL_OK;    CL_LOG_DEBUG_TRACE(("Enter"));    /* internally calls the deserializer, clLogSODsIdMapRecreate() */    CL_LOG_DEBUG_TRACE(("clLogSODsIdMapRecreate: %s  %d/n",                gSOLocalCkptName.value, CL_LOG_DSID_START));    rc = clCkptLibraryCkptDataSetRead(hLibCkpt,                                       (SaNameT *) &gSOLocalCkptName,                                      CL_LOG_DSID_START,                                       CL_HANDLE_INVALID_VALUE);    if( CL_ERR_NOT_EXIST == CL_GET_ERROR_CODE(rc) )    {        return CL_OK;    }        if( CL_OK != rc )    {        CL_LOG_DEBUG_ERROR(("clCkptLibraryCkptDataSetRead(): rc[0x %x]", rc));        return rc;    }        rc = clBitmapWalkUnlocked(pSoEoEntry->hDsIdMap,                               clLogSOLocalStreamEntryRecover, NULL);    if( CL_OK != rc )    {        /* What do we do, revert back or proceed */        CL_LOG_DEBUG_ERROR(("clBitmapWalkUnlocked(): rc[0x %x]", rc));    }                CL_LOG_DEBUG_TRACE(("Exit"));    return rc;}

ClRcTclLogStreamOwnerEntrySerialiser(ClUint32T  dsId,                                ClAddrT    *pBuffer,                                ClUint32T  *pSize,                                ClPtrT     cookie){    ClRcT      rc          = CL_OK;    ClBufferHandleT  msg = (ClBufferHandleT) cookie;    CL_LOG_DEBUG_TRACE(("Enter"));    rc = clBufferLengthGet(msg, pSize);    if( CL_OK != rc )    {        CL_LOG_DEBUG_ERROR(("clBufferLengthGet(): rc[0x %x]", rc));        return rc;    }    *pBuffer = (ClAddrT)clHeapCalloc(*pSize, sizeof(ClUint8T));    if( NULL == *pBuffer )    {        CL_LOG_DEBUG_ERROR(("clHeapCalloc()"));        return rc;    }        rc = clBufferNBytesRead(msg, (ClUint8T *) *pBuffer, pSize);     if( CL_OK != rc )    {        CL_LOG_DEBUG_ERROR(("clBufferNBytesRead(): rc[0x %x]", rc));        clHeapFree(*pBuffer);        return rc;    }            CL_LOG_DEBUG_TRACE(("Exit"));    return rc;}    

ClRcTclLogBitmapPack(ClBitmapHandleT  hBitmap,                ClBufferHandleT  msg){    ClRcT                   rc        = CL_OK;    ClUint32T  nBytes   = 0;    ClUint8T   *pBitMap = NULL;    CL_LOG_DEBUG_TRACE(("Enter"));    rc = clBitmap2BufferGet(hBitmap, &nBytes, &pBitMap);    if( CL_OK != rc )    {        CL_LOG_DEBUG_ERROR(("clBitmap2PositionListGet(): rc[0x %x]", rc));        return rc;    }        rc = clXdrMarshallClUint32T(&nBytes, msg, 0);    if( CL_OK != rc )    {        CL_LOG_DEBUG_ERROR(("clXdrMarshallClUint32T(): rc[0x %x]", rc));        clHeapFree(pBitMap);        return rc;    }    rc = clXdrMarshallArrayClUint8T(pBitMap, nBytes, msg, 0);    if( CL_OK != rc )    {        CL_LOG_DEBUG_ERROR(("clXdrMarshallArrayClUint8T(): rc[0x %x]", rc));    }    clHeapFree(pBitMap);        CL_LOG_DEBUG_TRACE(("Exit"));        return rc;    }    

ClRcTclLogClntStreamDataCleanup(ClLogClntStreamDataT *pData){    ClRcT  rc = CL_OK;    CL_LOG_DEBUG_TRACE(("Enter"));    rc = clBitmapDestroy(pData->hStreamBitmap);    if( CL_OK != rc )    {        CL_LOG_DEBUG_ERROR(("clBitmapDestroy(): rc[0x %x]", rc));    }#ifdef VXWORKS_BUILD    clLogClientStreamMutexDestroy(pData);    clLogClientStreamFlusherMutexDestroy(pData);#endif    rc = clOsalMunmap_L(pData->pStreamHeader, pData->pStreamHeader->shmSize);    if( CL_OK != rc )    {        CL_LOG_DEBUG_ERROR(("clOsalMunmap(): rc[0x %x]", rc));    }    clHeapFree(pData->shmName.pValue);    CL_LOG_DEBUG_TRACE(("Exit"));    return rc;}

ClRcTclLogStreamOwnerLocalCkptCreate(ClCkptSvcHdlT   hLibInit) {        ClRcT    rc       = CL_OK;    CL_LOG_DEBUG_TRACE(("Enter"));    rc = clCkptLibraryCkptCreate(hLibInit, (SaNameT *) &gSOLocalCkptName);    if( CL_OK != rc )    {        CL_LOG_DEBUG_ERROR(("clCkptLibraryCreate(): rc[0x %x]", rc));        return rc;    }        rc = clCkptLibraryCkptDataSetCreate(hLibInit,                                         (SaNameT *) &gSOLocalCkptName,                                         CL_LOG_DSID_START, 0, 0,                                        clLogSODsIdMapPack,                                        clLogSODsIdMapRecreate);    if( CL_OK != rc )    {        CL_LOG_DEBUG_ERROR(("clCkptLibraryCkptDataSetCreate(): rc[0x %x]", rc));        CL_LOG_CLEANUP(clCkptLibraryCkptDelete(hLibInit,                                                (SaNameT *) &gSOLocalCkptName),                       CL_OK);    }                CL_LOG_DEBUG_TRACE(("Checkpoint is created: %s  %d /n",                gSOLocalCkptName.value, CL_LOG_DSID_START));    CL_LOG_DEBUG_TRACE(("Exit"));    return rc;}    

static ClRcTclLogSvrCkptCreate(ClLogSvrEoDataT        *pSvrEoEntry,                   ClLogSvrCommonEoDataT  *pSvrCommonEoEntry){    ClRcT  rc = CL_OK;    CL_LOG_DEBUG_TRACE(("Enter"));    rc = clCkptLibraryCkptCreate(pSvrCommonEoEntry->hLibCkpt,                                 (SaNameT *) &gSvrLocalCkptName);    if( CL_OK != rc )    {        CL_LOG_DEBUG_ERROR(("clCkptLibraryCkptCreate(): rc[0x %x]", rc));        return rc;    }    rc = clCkptLibraryCkptDataSetCreate(pSvrCommonEoEntry->hLibCkpt,                                        (SaNameT *) &gSvrLocalCkptName,                                        CL_LOG_DSID_START, 0, 0,                                        clLogSvrDsIdMapPack,                                        clLogSvrDsIdMapRecreate);    if( CL_OK != rc )    {        CL_LOG_DEBUG_ERROR(("clCkptLibraryCkptDelete(): rc[0x %x]", rc));        clCkptLibraryCkptDelete(pSvrCommonEoEntry->hLibCkpt,                                (SaNameT *) &gSvrLocalCkptName);    }    CL_LOG_DEBUG_TRACE(("Exit"));    return rc;}

voidclLogStreamOwnerDataDump(ClCharT **retval){    ClRcT                  rc              = CL_OK;    ClDebugPrintHandleT    msg             = 0;    ClLogSOEoDataT         *pSoEoEntry     = NULL;    ClLogSvrCommonEoDataT  *pCommonEoEntry = NULL;    CL_LOG_DEBUG_TRACE(("Enter"));        clDebugPrintInitialize(&msg);    rc = clLogStreamOwnerEoEntryGet(&pSoEoEntry, &pCommonEoEntry);    if( CL_OK != rc )    {        return ;    }        rc = clLogSOLock(pSoEoEntry, CL_LOG_STREAM_GLOBAL);    if( CL_OK != rc )    {        return ;    }    clLogStreamOwnerEoDataPrint(pSoEoEntry, &msg);    if( CL_HANDLE_INVALID_VALUE != pSoEoEntry->hGStreamOwnerTable )    {        rc = clCntWalk(pSoEoEntry->hGStreamOwnerTable, clLogSOTableWalkForPrint,                 &msg, 0);        if( CL_OK != rc )        {            CL_LOG_DEBUG_ERROR(("clCntWalk(): rc[0x %x]", rc));            CL_LOG_CLEANUP(clLogSOUnlock(pSoEoEntry, CL_LOG_STREAM_GLOBAL), CL_OK);            return ;        }    }    CL_LOG_CLEANUP(clLogSOUnlock(pSoEoEntry, CL_LOG_STREAM_GLOBAL), CL_OK);    rc = clLogSOLock(pSoEoEntry, CL_LOG_STREAM_LOCAL);    if( CL_OK != rc )    {        return ;    }    if( CL_HANDLE_INVALID_VALUE != pSoEoEntry->hLStreamOwnerTable )    {        rc = clCntWalk(pSoEoEntry->hLStreamOwnerTable, clLogSOTableWalkForPrint,                 &msg, 0);        if( CL_OK != rc )        {            CL_LOG_DEBUG_ERROR(("clCntWalk(): rc[0x %x]", rc));            CL_LOG_CLEANUP(clLogSOUnlock(pSoEoEntry, CL_LOG_STREAM_LOCAL), CL_OK);            return ;        }    }    CL_LOG_CLEANUP(clLogSOUnlock(pSoEoEntry, CL_LOG_STREAM_LOCAL), CL_OK);    clDebugPrintFinalize(&msg, retval);    CL_LOG_DEBUG_TRACE(("Exit"));    return ;}

ClRcTclLogCompTablePack(ClCntKeyHandleT   key,                   ClCntDataHandleT  data,                   ClCntArgHandleT   arg,                   ClUint32T         size){    ClRcT             rc        = CL_OK;    ClLogCompKeyT     *pCompKey = (ClLogCompKeyT *) key;    ClLogSOCompDataT  *pData    = (ClLogSOCompDataT *) data;    ClBufferHandleT   msg       = (ClBufferHandleT) arg;    CL_LOG_DEBUG_TRACE(("Enter"));    rc = VDECL_VER(clXdrMarshallClLogCompKeyT, 4, 0, 0)(pCompKey, msg, 0);    if( CL_OK != rc )    {        CL_LOG_DEBUG_ERROR(("clXdrMarshallClUint32T(): rc[0x %x]", rc));        return rc;    }        rc = VDECL_VER(clXdrMarshallClLogSOCompDataT, 4, 0, 0)(pData, msg, 0);    if( CL_OK != rc )    {        CL_LOG_DEBUG_ERROR(("clXdrMarshallClUint32T(): rc[0x %x]", rc));            return rc;    }        CL_LOG_DEBUG_TRACE(("Exit"));    return CL_OK;}    

static ClRcTclLogMasterFileKeyPack(ClLogFileKeyT    *pFileKey,                       ClBufferHandleT  hFileEntryBuf){    ClRcT rc = CL_OK;    CL_LOG_DEBUG_TRACE(("Enter"));    rc = clXdrMarshallClStringT(&pFileKey->fileLocation, hFileEntryBuf, 0);    if( CL_OK != rc )    {        CL_LOG_DEBUG_ERROR(("clXdrMarshallClStringT(): rc[0x %x]", rc));        return rc;    }    rc = clXdrMarshallClStringT(&pFileKey->fileName, hFileEntryBuf, 0);    if( CL_OK != rc )    {        CL_LOG_DEBUG_ERROR(("clXdrMarshallClStringT(): rc[0x %x]", rc));        return rc;    }    CL_LOG_DEBUG_TRACE(("Exit"));    return rc;}

static ClRcT fileEntryRecoverBaseVersion(ClLogMasterEoDataT *pMasterEoEntry,        ClBufferHandleT hFileEntryBuf){    ClRcT rc = CL_OK;    ClLogFileKeyT        fileKey       = {{0}};    ClLogFileKeyT        *pFileKey     = NULL;    ClLogFileDataT       *pFileData    = NULL;    rc = clLogMasterFileKeyUnpack(&fileKey, hFileEntryBuf);    if( CL_OK != rc )    {        return rc;    }    clLogInfo(CL_LOG_AREA_MASTER, CL_LOG_CTX_CKPT_READ,              "Recreating files fileName: %.*s fileLocation: %.*s",              fileKey.fileName.length, fileKey.fileName.pValue,              fileKey.fileLocation.length, fileKey.fileLocation.pValue);    rc = clLogFileKeyCreate(&fileKey.fileName, &fileKey.fileLocation,                            pMasterEoEntry->maxFiles, &pFileKey);    if( CL_OK != rc )    {        clHeapFree(fileKey.fileName.pValue);        clHeapFree(fileKey.fileLocation.pValue);        return rc;    }    clHeapFree(fileKey.fileName.pValue);    clHeapFree(fileKey.fileLocation.pValue);    /* find out the filelocation is available */    pFileData = (ClLogFileDataT*) clHeapCalloc(1, sizeof(ClLogFileDataT));    if( NULL == pFileData )    {        CL_LOG_DEBUG_ERROR(("clHeapCalloc()"));        clLogFileKeyDestroy(pFileKey);        return rc;    }    pFileData->nActiveStreams = 0;    rc = clLogMasterFileDataRecreate(pFileData, hFileEntryBuf);    if( CL_OK != rc )    {        clLogFileKeyDestroy(pFileKey);        return rc;    }    rc = clCntNodeAdd(pMasterEoEntry->hMasterFileTable,                      (ClCntKeyHandleT) pFileKey,                      (ClCntDataHandleT) pFileData, NULL);    if( CL_OK != rc )    {        CL_LOG_DEBUG_ERROR(("clCntNodeAdd()"));        CL_LOG_CLEANUP(clCntDelete(pFileData->hStreamTable), CL_OK); //FIXME        clHeapFree(pFileData);        clLogFileKeyDestroy(pFileKey);        return rc;    }    return rc;}

static ClRcTclLogSvrCompTablePack(ClCntKeyHandleT   key,                      ClCntDataHandleT  data,                      ClCntArgHandleT   arg,                      ClUint32T         size){    ClRcT               rc          = CL_OK;    ClLogSvrCompKeyT    *pCompKey   = (ClLogSvrCompKeyT *)key;    ClLogSvrCompDataT   *pCompData  = (ClLogSvrCompDataT *)data;    ClBufferHandleT     msg         = *(ClBufferHandleT *)arg;    CL_LOG_DEBUG_TRACE(("Enter"));    rc = clXdrMarshallClUint32T(&(pCompKey->componentId), msg, 0);    if( CL_OK != rc )    {        CL_LOG_DEBUG_ERROR(("clXdrMarshallClUint32T(): rc[0x %x]", rc));        return rc;    }    rc = clXdrMarshallClUint32T(&(pCompData->refCount), msg, 0);    if( CL_OK != rc )    {        CL_LOG_DEBUG_ERROR(("clXdrMarshallClUint32T(): rc[0x %x]", rc));        return rc;    }    rc = clXdrMarshallClUint32T(&(pCompData->portId), msg, 0);    if( CL_OK != rc )    {        CL_LOG_DEBUG_ERROR(("clXdrMarshallClUint32T(): rc[0x %x]", rc));        return rc;    }    CL_LOG_DEBUG_TRACE(("Exit"));    return CL_OK;}

static ClRcTclLogSvrSOFGResponseProcess(ClLogFilterT  *pStreamFilter,                            ClPtrT        pCookie){    ClRcT                  rc                 = CL_OK;    ClLogSvrEoDataT        *pSvrEoEntry       = NULL;    ClCntNodeHandleT       hStreamOwnerNode   = (ClCntNodeHandleT) pCookie;    ClLogSvrStreamDataT    *pStreamData       = NULL;    ClLogSvrCommonEoDataT  *pSvrCommonEoEntry = NULL;    CL_LOG_DEBUG_TRACE(("Enter"));    rc = clLogSvrEoEntryGet(&pSvrEoEntry, &pSvrCommonEoEntry);    if( CL_OK != rc )    {        return rc;    }    rc = clOsalMutexLock_L(&pSvrEoEntry->svrStreamTableLock);    if( CL_OK != rc )    {        return rc;    }    rc = clCntNodeUserDataGet(pSvrEoEntry->hSvrStreamTable, hStreamOwnerNode,                              (ClCntDataHandleT *) &pStreamData);    if( CL_OK != rc )    {        CL_LOG_DEBUG_ERROR(("clCntNodeUserDataGet(): rc[0x %x]", rc));        CL_LOG_CLEANUP(clOsalMutexUnlock_L(&pSvrEoEntry->svrStreamTableLock), CL_OK);        return rc;    }    rc = clLogServerStreamMutexLock(pStreamData);    if( CL_OK != rc )    {        CL_LOG_DEBUG_ERROR(("clOsalMutexLock(): rc[0x %x]/n", rc));        CL_LOG_CLEANUP(clOsalMutexUnlock_L(&pSvrEoEntry->svrStreamTableLock), CL_OK);        return rc;    }    CL_LOG_CLEANUP(clOsalMutexUnlock_L(&pSvrEoEntry->svrStreamTableLock), CL_OK);    /*     * Log Server will not intimate the client about this filter update,     * as it is recreating the state for itself and filter may or may     * not have been updated during that transient period.     */    rc = clLogFilterAssign(pStreamData->pStreamHeader, pStreamFilter);    if( CL_OK != rc )    {        CL_LOG_DEBUG_ERROR(("clLogFilterAssign(): rc[0x %x]/n", rc));    }    CL_LOG_CLEANUP(clLogServerStreamMutexUnlock(pStreamData),CL_OK);    CL_LOG_DEBUG_TRACE(("Exit"));    return rc;}

static ClRcTclLogMasterFileDataRecreate(ClLogFileDataT   *pFileData,                            ClBufferHandleT  hFileEntryBuf){    ClRcT                  rc              = CL_OK;    ClUint32T              cntSize         = 0;    ClLogSvrCommonEoDataT  *pCommonEoEntry = NULL;    ClUint32T              count           = 0;    CL_LOG_DEBUG_TRACE(("Enter"));    rc = clLogMasterEoEntryGet(NULL, &pCommonEoEntry);    if( CL_OK != rc )    {        return rc;    }    rc = VDECL_VER(clXdrUnmarshallClLogStreamAttrIDLT, 4, 0, 0)(hFileEntryBuf,            &(pFileData->streamAttr));    if( CL_OK != rc )    {        CL_LOG_DEBUG_ERROR((                               "clXdrUnmarshallClLogStreamAttributesT(): rc[0x %x]", rc));        return rc;    }    rc = clXdrUnmarshallClUint32T(hFileEntryBuf, &cntSize);    if( CL_OK != rc )    {        CL_LOG_DEBUG_ERROR(("clXdrUnmarshallClUint32T(): rc[0x %x]", rc));        return rc;    }    rc = clCntHashtblCreate(pCommonEoEntry->maxStreams,                            clLogStreamKeyCompare, clLogStreamHashFn,                            clLogMasterStreamEntryDeleteCb,                            clLogMasterStreamEntryDeleteCb, CL_CNT_UNIQUE_KEY,                            &(pFileData->hStreamTable));    if( CL_OK != rc )    {        CL_LOG_DEBUG_ERROR(("clCntHashtbleCreate(): rc[0x %x]/n", rc));        return rc;    }    for(count = 0; count < cntSize; count++)    {        rc = clLogMasterStreamTableRecreate(pCommonEoEntry, hFileEntryBuf,                                            pFileData);        if( CL_OK != rc )        {            /* Just keep on create as much as u can */        }    }    CL_LOG_DEBUG_TRACE(("Exit"));    return rc;}

static ClRcTclLogSvrDsIdMapRecreate(ClUint32T  dsId,                        ClAddrT    pBuffer,                        ClUint32T  buffSize,                        ClPtrT     pCookie){    ClRcT            rc           = CL_OK;    ClLogSvrEoDataT  *pSvrEoEntry = NULL;    ClBufferHandleT  inMsg        = CL_HANDLE_INVALID_VALUE;    CL_LOG_DEBUG_TRACE(("Enter"));    CL_LOG_PARAM_CHK((NULL == pBuffer), CL_LOG_RC(CL_ERR_NULL_POINTER));    CL_LOG_PARAM_CHK((CL_LOG_DSID_START != dsId),                     CL_LOG_RC(CL_ERR_INVALID_PARAMETER));    rc = clLogSvrEoEntryGet(&pSvrEoEntry, NULL);    if( CL_OK != rc )    {        return rc;    }    rc = clBufferCreate(&inMsg);    if( CL_OK != rc )    {        CL_LOG_DEBUG_ERROR(("clBufferCreate(): rc[0x %x]", rc));        return rc;    }    rc = clBufferNBytesWrite(inMsg, (ClUint8T *) pBuffer, buffSize);    if( CL_OK != rc )    {        CL_LOG_DEBUG_ERROR(("clBufferNBytesWrite(): rc[0x %x]", rc));        CL_LOG_CLEANUP(clBufferDelete(&inMsg), CL_OK);        return rc;    }    rc = clXdrUnmarshallClUint32T(inMsg, &pSvrEoEntry->nextDsId);    if( CL_OK != rc )    {        CL_LOG_DEBUG_ERROR(("clXdrUnmarshallClUint32T(): rc[0x %x]/n", rc));        CL_LOG_CLEANUP(clBufferDelete(&inMsg), CL_OK);        return rc;    }    CL_LOG_DEBUG_VERBOSE(("DsIdCnt: %d", pSvrEoEntry->nextDsId));    rc = clLogBitmapUnpack(inMsg, pSvrEoEntry->hDsIdMap);    if( CL_OK != rc )    {        CL_LOG_DEBUG_ERROR(("clLogBitmapUnpack(): rc[0x %x]", rc));        CL_LOG_CLEANUP(clBufferDelete(&inMsg), CL_OK);        return rc;    }    CL_LOG_CLEANUP(clBufferDelete(&inMsg), CL_OK);    CL_LOG_DEBUG_TRACE(("Exit"));    return rc;}

ClRcTclLogSvrEoDataInit(ClLogSvrEoDataT        *pSvrEoEntry,                   ClLogSvrCommonEoDataT  *pSvrCommonEoEntry){    ClRcT               rc = CL_OK;    CL_LOG_DEBUG_TRACE(("Enter"));    pSvrEoEntry->hSvrStreamTable = CL_HANDLE_INVALID_VALUE;    pSvrEoEntry->nextDsId        = CL_LOG_DSID_START;    rc = clOsalMutexInit_L(&pSvrEoEntry->svrStreamTableLock);    if( CL_OK != rc )    {        CL_LOG_DEBUG_ERROR(("clOsalMutexCreate(): rc[0x %x]", rc));        return rc;    }    rc = clBitmapCreate(&pSvrEoEntry->hDsIdMap, pSvrCommonEoEntry->maxStreams);    if( CL_OK != rc )    {        CL_LOG_DEBUG_ERROR(("clBitmapCreate(): rc[0x %x]", rc));        CL_LOG_CLEANUP(clOsalMutexDestroy_L(&pSvrEoEntry->svrStreamTableLock),                       CL_OK);        return rc;    }    rc = clHandleDatabaseCreate(NULL, &pSvrEoEntry->hFlusherDB);     if( CL_OK != rc )    {        CL_LOG_DEBUG_ERROR(("clHandleDatabaseCreate(): rc[0x %x]", rc));        CL_LOG_CLEANUP(clBitmapDestroy(pSvrEoEntry->hDsIdMap), CL_OK);        CL_LOG_CLEANUP(clOsalMutexDestroy_L(&pSvrEoEntry->svrStreamTableLock),                       CL_OK);        return rc;    }    rc = clLogConfigDataGet(NULL, NULL, NULL, &pSvrEoEntry->maxFlushLimit);    if( CL_OK != rc )    {        CL_LOG_DEBUG_ERROR(("clLogConfigDataGet(): rc[0x %x]", rc));        CL_LOG_CLEANUP(clHandleDatabaseDestroy(pSvrEoEntry->hFlusherDB), CL_OK);        CL_LOG_CLEANUP(clBitmapDestroy(pSvrEoEntry->hDsIdMap), CL_OK);        CL_LOG_CLEANUP(clOsalMutexDestroy_L(&pSvrEoEntry->svrStreamTableLock),                       CL_OK);        return rc;    }    pSvrEoEntry->hCpm           = CL_HANDLE_INVALID_VALUE;        pSvrEoEntry->logCompId      = 0;    pSvrEoEntry->gmsInit        = CL_FALSE;     pSvrEoEntry->evtInit        = CL_FALSE;     pSvrEoEntry->ckptInit       = CL_FALSE;     pSvrEoEntry->logInit        = CL_FALSE;    pSvrEoEntry->hTimer         = CL_FALSE;    CL_LOG_DEBUG_TRACE(("Exit"));    return rc;}

static ClRcTclLogSvrStreamEntryRecover(ClBitmapHandleT  hBitmap,                           ClUint32T        dsId,                           void             *pCookie){    ClRcT                  rc                 = CL_OK;    ClLogSvrEoDataT        *pSvrEoEntry       = NULL;    ClLogSvrCommonEoDataT  *pSvrCommonEoEntry = NULL;    ClBoolT dataSetExists = CL_TRUE;    CL_LOG_DEBUG_TRACE(("Enter"));    rc = clLogSvrEoEntryGet(&pSvrEoEntry, &pSvrCommonEoEntry);    if( CL_OK != rc )    {        CL_LOG_DEBUG_ERROR(("clLogSvrEoEntryGet(): rc[0x %x]", rc));        return rc;    }    rc = clCkptLibraryDoesDatasetExist(pSvrCommonEoEntry->hLibCkpt,                                       (SaNameT *)&gSvrLocalCkptName,                                       dsId, &dataSetExists);    if(rc != CL_OK || !dataSetExists)    {        CL_LOG_DEBUG_ERROR(("Dataset [%u] doesnt exist. Continuing", dsId));        return CL_OK;    }    rc = clCkptLibraryCkptDataSetCreate(pSvrCommonEoEntry->hLibCkpt,                                        (SaNameT *) &gSvrLocalCkptName,                                        dsId, 0, 0,                                        clLogSvrStreamEntryPack,                                        clLogSvrStreamEntryRecreate);    if( CL_OK != rc )    {        CL_LOG_DEBUG_ERROR(("clCkptLibraryCkptDataSetCreate(): rc[0x %x]",                            rc));        return rc;    }    /* this will internaly call deserializer, clLogSvrStreamEntryRecreate() */    rc = clCkptLibraryCkptDataSetRead(pSvrCommonEoEntry->hLibCkpt,                                      (SaNameT *) &gSvrLocalCkptName, dsId,                                      CL_HANDLE_INVALID_VALUE);    if( CL_OK != rc )    {        CL_LOG_DEBUG_ERROR(("clCkptLibraryCkptDataSetRead(): rc[0x %x]", rc));        CL_LOG_DEBUG_ERROR(("Unable to recover data from this dsId: %u. "                            "Continuing", dsId));        return CL_OK;    }    CL_LOG_DEBUG_TRACE(("Exit"));    return rc;}

ClRcTclLogMasterCompData2BufferGet(ClLogCompDataT  *pCompData,                              ClUint8T        **ppBuffer,                              ClUint32T       *pDataSize){    ClRcT            rc  = CL_OK;    ClBufferHandleT  msg = CL_HANDLE_INVALID_VALUE;    CL_LOG_DEBUG_TRACE(("Enter"));    rc = clBufferCreate(&msg);    if(CL_OK != rc )    {        CL_LOG_DEBUG_ERROR(("clBufferCreate(): rc[0x %x]", rc));        return rc;    }    rc = VDECL_VER(clXdrMarshallClLogCompDataT, 4, 0, 0)(pCompData, msg, 0);    if( CL_OK != rc )    {        CL_LOG_DEBUG_ERROR(("clLogMarshallClLogCompDataT(): rc[0x %x]", rc));        CL_LOG_CLEANUP(clBufferDelete(&msg), CL_OK);        return rc;    }    rc = clBufferLengthGet(msg, pDataSize);    if( CL_OK != rc )    {        CL_LOG_DEBUG_ERROR(("clBufferLengthGet(): rc[0x %x]", rc));        CL_LOG_CLEANUP(clBufferDelete(&msg), CL_OK);        return rc;    }    *ppBuffer = (ClUint8T*) clHeapCalloc(*pDataSize, sizeof(ClUint8T));    if( NULL == *ppBuffer )    {        CL_LOG_DEBUG_ERROR(("clHeapCalloc()"));        CL_LOG_CLEANUP(clBufferDelete(&msg), CL_OK);        return CL_LOG_RC(CL_ERR_NO_MEMORY);    }    rc = clBufferNBytesRead(msg, *ppBuffer, pDataSize);    if( CL_OK != rc )    {        CL_LOG_DEBUG_ERROR(("clBufferNBytesRead(): rc[0x %x]", rc));        clHeapFree(*ppBuffer);        CL_LOG_CLEANUP(clBufferDelete(&msg), CL_OK);        return rc;    }    CL_LOG_CLEANUP(clBufferDelete(&msg), CL_OK);    CL_LOG_DEBUG_TRACE(("Exit"));    return CL_OK;}

static ClRcTclLogMasterFileEntryRecover(ClLogMasterEoDataT      *pMasterEoEntry,                            ClCkptIOVectorElementT  *pIoVector,                            ClUint32T               *pErrIndex){    ClRcT                rc            = CL_OK;    ClBufferHandleT      hFileEntryBuf = CL_HANDLE_INVALID_VALUE;    ClVersionT version = {0};    CL_LOG_DEBUG_TRACE(("Enter: size %lld", pIoVector->readSize));    rc = clBufferCreate(&hFileEntryBuf);    if( CL_OK != rc )    {        CL_LOG_DEBUG_ERROR(("clBufferCreate(): rc[0x %x]", rc));        return rc;    }    rc = clBufferNBytesWrite(hFileEntryBuf, (ClUint8T*) pIoVector->dataBuffer, pIoVector->readSize);    if( CL_OK != rc )    {        CL_LOG_DEBUG_ERROR(("clBufferNBytesWrite(): rc[0x %x]", rc));        CL_LOG_CLEANUP(clBufferDelete(&hFileEntryBuf), CL_OK);        return rc;    }    rc = clXdrUnmarshallClVersionT(hFileEntryBuf, &version);    if( CL_OK != rc )    {        CL_LOG_DEBUG_ERROR(("clXdrUnmarshallClVersionT(): rc[%#x]", rc));        CL_LOG_CLEANUP(clBufferDelete(&hFileEntryBuf), CL_OK);        return rc;    }    switch(CL_VERSION_CODE(version.releaseCode, version.majorVersion, version.minorVersion))    {    case CL_VERSION_CODE(CL_RELEASE_VERSION, CL_MAJOR_VERSION, CL_MINOR_VERSION):    {        rc = fileEntryRecoverBaseVersion(pMasterEoEntry, hFileEntryBuf);    }    break;    default:        rc = CL_LOG_RC(CL_ERR_VERSION_MISMATCH);        clLogError("FILE", "RECOVER", "Version [%d.%d.%d] unsupported",                   version.releaseCode, version.majorVersion, version.minorVersion);        break;    }    CL_LOG_CLEANUP(clBufferDelete(&hFileEntryBuf), CL_OK);    CL_LOG_DEBUG_TRACE(("Exit"));    return rc;}

ClRcTclLogSODsIdMapRecreate(ClUint32T  dsId,                       ClAddrT    pBuffer,                       ClUint32T  size,                           ClPtrT      cookie){    ClRcT                   rc        = CL_OK;    ClBufferHandleT        msg            = CL_HANDLE_INVALID_VALUE;    ClLogSOEoDataT         *pSoEoEntry    = NULL;     ClLogSvrCommonEoDataT  *pCommonEoData = NULL;    CL_LOG_DEBUG_TRACE(("Enter"));    CL_LOG_PARAM_CHK((CL_LOG_SO_DSID_START != dsId),                     CL_LOG_RC(CL_ERR_INVALID_PARAMETER));    CL_LOG_PARAM_CHK((NULL == pBuffer), CL_LOG_RC(CL_ERR_NULL_POINTER));    rc = clLogStreamOwnerEoEntryGet(&pSoEoEntry, &pCommonEoData);    if( CL_OK != rc )    {        return rc;    }        rc = clBufferCreate(&msg);    if( CL_OK != rc )    {        CL_LOG_DEBUG_ERROR(("clBufferCreate(): rc[0x %x]", rc));        return rc;    }    rc = clBufferNBytesWrite(msg, (ClUint8T *) pBuffer, size);     if( CL_OK != rc )    {        CL_LOG_DEBUG_ERROR(("clBufferNBytesRead(): rc[0x %x]", rc));        CL_LOG_CLEANUP(clBufferDelete(&msg), CL_OK);        return rc;    }    rc = clXdrUnmarshallClUint32T(msg, &pSoEoEntry->dsIdCnt);    if( CL_OK != rc )    {       CL_LOG_DEBUG_ERROR(("clXdrUnmarshallClUint32T(): rc[0x %x]", rc));       CL_LOG_CLEANUP(clBufferDelete(&msg), CL_OK);        return rc;    }        CL_LOG_DEBUG_VERBOSE(("dsIdCnt : %d", pSoEoEntry->dsIdCnt));    rc = clLogBitmapUnpack(msg, pSoEoEntry->hDsIdMap);    CL_LOG_CLEANUP(clBufferDelete(&msg), CL_OK);    CL_LOG_DEBUG_TRACE(("Exit: rc[0x %x]", rc));    return rc;}    

ClRcTclLogMasterCompTableStateRecover(ClLogMasterEoDataT  *pMasterEoEntry,                                 ClUint8T            *pBuffer,                                 ClUint32T           dataSize){    ClRcT            rc       = CL_OK;    ClBufferHandleT  msg      = CL_HANDLE_INVALID_VALUE;    ClUint32T versionCode = 0;    CL_LOG_DEBUG_TRACE(("Enter"));    rc = clBufferCreate(&msg);    if(CL_OK != rc )    {        CL_LOG_DEBUG_ERROR(("clBufferCreate(): rc[0x %x]", rc));        return rc;    }    rc = clBufferNBytesWrite(msg, pBuffer, dataSize);    if( CL_OK != rc )    {        CL_LOG_DEBUG_ERROR(("clBufferNBytesWrite(): rc[0x %x]", rc));        CL_LOG_CLEANUP(clBufferDelete(&msg), CL_OK);        return rc;    }    rc = clXdrUnmarshallClUint32T(msg, &versionCode);    if( CL_OK != rc)    {        CL_LOG_DEBUG_ERROR(("clXdrUnmarshallClUint32T(): rc[%#x]", rc));        CL_LOG_CLEANUP(clBufferDelete(&msg), CL_OK);        return rc;    }    switch(versionCode)    {    case CL_VERSION_CODE(CL_RELEASE_VERSION, CL_MAJOR_VERSION, CL_MINOR_VERSION):    {        rc = compTableStateRecoverBaseVersion(msg);    }    break;    default:        clLogError("COMP", "TBL-RECOVER", "Version [%d.%d.%d] is not supported",                   CL_VERSION_RELEASE(versionCode), CL_VERSION_MAJOR(versionCode),                   CL_VERSION_MINOR(versionCode));        rc = CL_LOG_RC(CL_ERR_VERSION_MISMATCH);    }    clBufferDelete(&msg);    return rc;}

ClRcTclLogSvrCkptGet(ClLogSvrEoDataT        *pSvrEoEntry,                ClLogSvrCommonEoDataT  *pSvrCommonEoEntry,                ClBoolT                *pLogRestart){    ClRcT    rc         = CL_OK;    ClBoolT  ckptExists = CL_FALSE;    CL_LOG_DEBUG_TRACE(("Enter"));    *pLogRestart = CL_FALSE;    rc = clCkptLibraryDoesCkptExist(pSvrCommonEoEntry->hLibCkpt,                                    (SaNameT *) &gSvrLocalCkptName,                                    &ckptExists);    if( CL_OK != rc )    {        CL_LOG_DEBUG_ERROR(("clCkptLibraryDoesCkptExist(): rc[0x %x]", rc));        return rc;    }    rc = clLogSvrCkptCreate(pSvrEoEntry, pSvrCommonEoEntry);    if(CL_OK != rc)    {        return rc;    }    if( CL_TRUE == ckptExists )/*Log Service restart*/    {        *pLogRestart = CL_TRUE;        rc = clLogSvrStateRecover(pSvrEoEntry, pSvrCommonEoEntry);        if( CL_OK != rc )        {            /*             * Just restart incase there were no streamowners checkpointed in the first place             */            if(CL_GET_ERROR_CODE(rc) == CL_ERR_NOT_EXIST)            {                rc = CL_OK;                *pLogRestart = CL_FALSE;            }            else            {                CL_LOG_DEBUG_ERROR(("clCkptLibraryDoesCkptExist(): rc[0x %x]", rc));                return rc;            }        }    }    CL_LOG_DEBUG_TRACE(("Exit"));    return rc;}

ClRcTclLogSvrCkptDataSetDelete(ClUint32T         dsId){    ClRcT                  rc                 = CL_OK;    ClLogSvrCommonEoDataT  *pSvrCommonEoEntry = NULL;    ClLogSvrEoDataT        *pSvrEoEntry       = NULL;    CL_LOG_DEBUG_TRACE(("Enter"));    rc = clLogSvrEoEntryGet(&pSvrEoEntry, &pSvrCommonEoEntry);    if( CL_OK != rc )    {        CL_LOG_DEBUG_ERROR(("clLogSvrEoEntryGet(): rc[0x %x]", rc));        return rc;    }    if( CL_LOG_DSID_START >= dsId )    {        CL_LOG_DEBUG_ERROR(("Invalid DataSet ID/n "));        return CL_LOG_RC(CL_ERR_INVALID_STATE);/*FIXME*/    }    rc = clBitmapBitClear(pSvrEoEntry->hDsIdMap, dsId);    if( CL_OK != rc )    {        CL_LOG_DEBUG_ERROR(("clCkptLibraryCkptDataSetDelete(): rc[0x %x]", rc));        return rc;    }    rc = clCkptLibraryCkptDataSetDelete(pSvrCommonEoEntry->hLibCkpt,                                        (SaNameT *) &gSvrLocalCkptName,                                        dsId);    if( CL_OK != rc )    {        CL_LOG_DEBUG_ERROR(("clCkptLibraryCkptDataSetDelete(): rc[0x %x]", rc));        return rc;    }    rc = clCkptLibraryCkptDataSetWrite(pSvrCommonEoEntry->hLibCkpt,                                       (SaNameT *) &gSvrLocalCkptName,                                       CL_LOG_DSID_START,                                       pSvrEoEntry);    if( CL_OK != rc )    {        CL_LOG_DEBUG_ERROR(("clCkptLibraryCkptDataSetWrite(): rc[0x %x]", rc));    }    CL_LOG_DEBUG_TRACE(("Exit"));    return rc;}

static ClRcTclLogSvrStreamEntryRecreate(ClUint32T  dsId,                            ClAddrT    pBuffer,                            ClUint32T  buffSize,                            ClPtrT     cookie){    ClRcT                  rc                 = CL_OK;    ClLogSvrEoDataT        *pSvrEoEntry       = NULL;    ClBufferHandleT        inMsg              = CL_HANDLE_INVALID_VALUE;    ClLogSvrCommonEoDataT  *pSvrCommonEoEntry = NULL;    CL_LOG_DEBUG_TRACE(("Enter"));    CL_LOG_PARAM_CHK((NULL == pBuffer), CL_LOG_RC(CL_ERR_NULL_POINTER));    rc = clLogSvrEoEntryGet(&pSvrEoEntry, &pSvrCommonEoEntry);    if( CL_OK != rc )    {        return rc;    }    rc = clBufferCreate(&inMsg);    if( CL_OK != rc )    {        CL_LOG_DEBUG_ERROR(("clBufferCreate(): rc[0x %x]", rc));        return rc;    }    rc = clBufferNBytesWrite(inMsg, (ClUint8T *) pBuffer, buffSize);    if( CL_OK != rc )    {        CL_LOG_DEBUG_ERROR(("clBufferNBytesWrite(): rc[0x %x]", rc));        CL_LOG_CLEANUP(clBufferDelete(&inMsg), CL_OK);        return rc;    }    rc = clLogSvrStreamEntryUnpackNAdd(pSvrEoEntry, pSvrCommonEoEntry, inMsg, dsId);    if( CL_OK != rc )    {        CL_LOG_CLEANUP(clBufferDelete(&inMsg), CL_OK);        return rc;    }    CL_LOG_CLEANUP(clBufferDelete(&inMsg), CL_OK);    CL_LOG_DEBUG_TRACE(("Exit"));    return rc;}

/* - clLogClntIdlHandleInitialize * - Initializes the IDL handle for use in calls to the server */ClRcTclLogClntIdlHandleInitialize(ClIocAddressT  destAddr,                             ClIdlHandleT   *phLogIdl){    ClRcT            rc      = CL_OK;    ClIdlHandleObjT  idlObj  = CL_IDL_HANDLE_INVALID_VALUE;    ClIdlAddressT    address = {0};    CL_LOG_DEBUG_TRACE(("Enter"));    address.addressType        = CL_IDL_ADDRESSTYPE_IOC;    address.address.iocAddress = destAddr;    idlObj.address             = address;    idlObj.flags               = CL_RMD_CALL_DO_NOT_OPTIMIZE;    idlObj.options.timeout     = CL_LOG_CLIENT_DEFULT_TIMEOUT;     idlObj.options.priority    = CL_RMD_DEFAULT_PRIORITY;    idlObj.options.retries     = CL_LOG_CLIENT_DEFAULT_RETRIES;     rc = clIdlHandleInitialize(&idlObj, phLogIdl);    if( CL_OK != rc )    {        CL_LOG_DEBUG_ERROR(("clIdlHandleInitialize(): rc[0x %x]", rc));        return rc;    }    CL_LOG_DEBUG_TRACE(("Exit"));    return rc;}

ClRcTclLogStreamOwnerFilterInfoUnpack(ClBufferHandleT        msg,                                 ClLogStreamOwnerDataT  *pStreamOwnerData){    ClRcT  rc = CL_OK;    CL_LOG_DEBUG_TRACE(("Enter"));    rc = clXdrUnmarshallClUint16T(msg,                                   &pStreamOwnerData->streamFilter.severityFilter);    if( CL_OK != rc )    {        CL_LOG_DEBUG_ERROR(("clXdrMarshallClUint16T(): rc[0x %x]", rc));        return rc;    }    rc = clLogBitmapUnpack(msg, pStreamOwnerData->streamFilter.hMsgIdMap);    if( CL_OK != rc )    {        return rc;    }    rc = clLogBitmapUnpack(msg, pStreamOwnerData->streamFilter.hCompIdMap);    if( CL_OK != rc )    {        return rc;    }    CL_LOG_DEBUG_TRACE(("Exit"));    return rc;}

ClRcTclLogStreamOwnerCkptDsIdDelete(ClLogSOEoDataT  *pSoEoEntry,                               ClUint32T       dsId) {    ClRcT           rc      = CL_OK;     ClLogSvrCommonEoDataT  *pCommonEoData = NULL;    CL_LOG_DEBUG_TRACE(("Enter"));    rc = clLogStreamOwnerEoEntryGet(NULL, &pCommonEoData);    if( CL_OK != rc )    {        return rc;    }        rc = clBitmapBitClear(pSoEoEntry->hDsIdMap, dsId);    if( CL_OK != rc )    {        CL_LOG_DEBUG_ERROR(("clBitmapBitClear(): rc[0x %x]", rc));        return rc;    }        CL_LOG_CLEANUP(clCkptLibraryCkptDataSetDelete(pCommonEoData->hLibCkpt,                                                  (SaNameT *) &gSOLocalCkptName, dsId),                  CL_OK);    CL_LOG_CLEANUP(clCkptLibraryCkptDataSetWrite(pCommonEoData->hLibCkpt,                                                  (SaNameT *) &gSOLocalCkptName,                                                 CL_LOG_SO_DSID_START,                                                 pSoEoEntry),                 CL_OK);    CL_LOG_DEBUG_TRACE(("Exit"));    return rc;}    

voidclLogSvrSOFGResponse(ClIdlHandleT  hLogIdl,                     SaNameT       *pStreamName,                     SaNameT       *pStreamScopeNode,                     ClLogFilterT  *pStreamFilter,                     ClRcT         retCode,                     ClPtrT        pCookie){    ClRcT  rc = CL_OK;    CL_LOG_DEBUG_TRACE(("Enter"));    CL_ASSERT( NULL != pCookie );    if( CL_OK != retCode )    {        CL_LOG_DEBUG_ERROR(("clLogSvrSOFGResponse(): rc[0x %x]", retCode));        return ;    }    rc = clLogSvrSOFGResponseProcess(pStreamFilter, pCookie);    clHeapFree(pStreamFilter->pMsgIdSet);    clHeapFree(pStreamFilter->pCompIdSet);    CL_LOG_DEBUG_TRACE(("Exit"));    (void)rc;    return ;}

static ClRcTclLogMasterFileEntrySecIdGet(ClLogFileKeyT     *pFileKey,                             ClCkptSectionIdT  *pSecId){    ClRcT rc = CL_OK;    CL_LOG_DEBUG_TRACE(("Enter: namelen: %u locationlen: %u",                        pFileKey->fileName.length,                        pFileKey->fileLocation.length));    CL_LOG_PARAM_CHK((NULL == pFileKey->fileName.pValue),                     CL_LOG_RC(CL_ERR_NULL_POINTER));    CL_LOG_PARAM_CHK((NULL == pFileKey->fileLocation.pValue),                     CL_LOG_RC(CL_ERR_NULL_POINTER));    CL_LOG_PARAM_CHK((NULL == pSecId), CL_LOG_RC(CL_ERR_NULL_POINTER));    /*     * ClString: Assuming length includes NULL terminator also.     * So we idLen will include 2 more than the characters.     * One we will use for / so we need to decrement it by 1     */    pSecId->idLen = pFileKey->fileName.length + pFileKey->fileLocation.length + 1;    pSecId->id    = (ClUint8T*) clHeapCalloc(pSecId->idLen, sizeof(ClCharT));    if( NULL == pSecId->id )    {        CL_LOG_DEBUG_ERROR(("clHeapCalloc()"));        return CL_LOG_RC(CL_ERR_NO_MEMORY);    }    snprintf((ClCharT *) pSecId->id, pSecId->idLen, "%s/%s", pFileKey->fileLocation.pValue,             pFileKey->fileName.pValue);    CL_LOG_DEBUG_TRACE(("Exit [%*s]", pSecId->idLen, pSecId->id));    return rc;}

ClRcTclLogClntStreamListUnpack(ClUint32T         numStreams,                          ClUint32T         buffLen,                          ClUint8T          *pBuffer,                          ClLogStreamInfoT  **ppLogStreams){    ClRcT            rc  = CL_OK;    ClBufferHandleT  msg = CL_HANDLE_INVALID_VALUE;    CL_LOG_DEBUG_TRACE(("Enter"));    *ppLogStreams = clHeapCalloc(numStreams, sizeof(ClLogStreamInfoT));    if( NULL == *ppLogStreams )    {        CL_LOG_DEBUG_ERROR(("clHeapCalloc()"));        return CL_LOG_RC(CL_ERR_NO_MEMORY);    }    rc = clBufferCreate(&msg);    if( CL_OK != rc )    {        CL_LOG_DEBUG_ERROR(("clBufferCreate(): rc[0x %x]", rc));        clHeapFree(*ppLogStreams);        return rc;    }    rc = clBufferNBytesWrite(msg, pBuffer, buffLen);    if( CL_OK != rc )    {        CL_LOG_DEBUG_ERROR(("clBufferNBytesWrite(): rc[0x %x]", rc));        CL_LOG_CLEANUP(clBufferDelete(&msg), CL_OK);        clHeapFree(*ppLogStreams);        return rc;    }    rc = clLogClntStreamListGet(msg, *ppLogStreams);    if( CL_OK != rc )    {        CL_LOG_CLEANUP(clBufferDelete(&msg), CL_OK);        clHeapFree(*ppLogStreams);        return rc;    }    CL_LOG_CLEANUP(clBufferDelete(&msg), CL_OK);       CL_LOG_DEBUG_TRACE(("Exit"));    return rc;}