/*******************************************************************************
Feature  API: alarmClockCkptRead

Description : 

This API will not attempt to validate arguments, the thinking being that 
this is a volitional act by the invoker of this API to ensure that invalid 
parameters can be handled gracefully by the subsystem

Arguments In: 
    1. ClCkptHdlT : ckpt handle
    2. section number
    3. data to read
    4. size of data to read 

Return Value:
    ClInt32Teger 0 if success, non zero if failure
*******************************************************************************/
ClRcT
alarmClockCkptRead (
    ClCkptHdlT     ckpt_hdl,
    ClInt32T       section_num,
    void*          data,
    ClInt32T       data_size )
{
    ClRcT       ret_code = CL_OK;
    ClUint32T   error_index;
    ClCharT     section_id_name[ CL_MAX_NAME_LENGTH ];
    ClCkptIOVectorElementT  io_vector;

    /*
     * Check if its in sync through hot standby update before reading
     */
    if((g_hot_standby & __HOT_STANDBY_ACTIVE))
        return CL_ERR_NO_OP;

    sprintf(section_id_name, "s%05d", section_num);
    io_vector.sectionId.id = (ClUint8T*)section_id_name;
    io_vector.sectionId.idLen = strlen(section_id_name);

    /* assign other fields of the IoVector
     */
    io_vector.dataBuffer  = data;
    io_vector.dataSize    = data_size;
    io_vector.dataOffset  = 0;
    io_vector.readSize    = 0;

    ret_code = clCkptCheckpointRead(ckpt_hdl, &io_vector, 1, &error_index );
    if (ret_code != CL_OK)
    {
        alarmClockLogWrite(CL_LOG_SEV_ERROR, 
                           "alarmClockCkptRead(pid=%d): (error_index=%d) "
                           "Failed to read section [%s]: 0x%x\n", 
                           getpid(), error_index, 
                           section_id_name, ret_code); 
        return ret_code;
    }
    else
    {
        if ( io_vector.readSize != data_size )
        {
            alarmClockLogWrite(CL_LOG_SEV_ERROR, 
                    "alarmClockCkptRead(pid=%d): read %d bytes; expected %d bytes\n", 
                   getpid(), (ClInt32T)io_vector.readSize, data_size);
        }
        else
        {
            alarmClockLogWrite(CL_LOG_SEV_DEBUG, 
                "alarmClockCkptRead(pid=%d): read %d bytes from %s\n", 
                getpid(), data_size, section_id_name); 
        }
    }

    return ret_code;
}
ClRcT
clTestCkptRead_withTime(ClCkptHdlT  ckptHdl,
               ClUint32T   numSections)
{
    ClRcT           rc = CL_OK;
    ClUint32T       i = 0, j = 0;
    ClCkptIOVectorElementT  iov[numSections];
    ClUint32T               readIdx = 0;
    ClUint32T         timeDelay[] = {1000000, 100000, 10000, 1000, 100, 10 , 0};

    memset(iov, 0, numSections * sizeof(ClCkptIOVectorElementT));
    for( i = 0; i < numSections; i++ )
    {
        if( numSections != 1 )
        {
            iov[i].sectionId.id = clHeapCalloc(1, 15);
            if( NULL == iov[i].sectionId.id )
            {   
                return CL_OK;
            }
            snprintf( (ClCharT *) iov[i].sectionId.id,15, "section%d", i);
            iov[i].sectionId.idLen = strlen((ClCharT *) iov[i].sectionId.id) + 1;
        }
        iov[i].dataSize = 0;
        iov[i].dataBuffer = NULL;
        iov[i].readSize = 0;
        iov[i].dataOffset = 0;
    }
    for( i = 0; i < (sizeof(timeDelay) / sizeof(sizeof(timeDelay[0]))); i++ )
    {
        for( j = 0; j < 1000; j++ )
        {
            rc = clCkptCheckpointRead(ckptHdl, iov, numSections, &readIdx); 
            for( i = 0; i < numSections; i++ )
            {
                clHeapFree(iov[i].dataBuffer);
                iov[i].dataBuffer = NULL; 
            }
            usleep(timeDelay[i]);
        }
    }
    for( i = 0; i < numSections; i++ )
    {
        if( NULL != iov[i].sectionId.id ) 
        {
            clHeapFree(iov[i].sectionId.id);
        }
    }
    return CL_OK;
}
ClRcT
clTestCheckpointReadWithOffSet(ClCkptHdlT  ckptHdl,
               ClUint32T   numSections)
{
    ClRcT           rc = CL_OK;
    ClUint32T       i = 0;
    ClCkptIOVectorElementT  iov[numSections];
    ClUint32T               readIdx = 0;

    memset(iov, 0, numSections * sizeof(ClCkptIOVectorElementT));
    for( i = 0; i < numSections; i++ )
    {
        if( numSections != 1 )
        {
            iov[i].sectionId.id = clHeapCalloc(1, 15);
            if( NULL == iov[i].sectionId.id )
            {   
                return CL_OK;
            }
            snprintf( (ClCharT *) iov[i].sectionId.id, 15,"section%d", i);
            iov[i].sectionId.idLen = strlen((ClCharT *) iov[i].sectionId.id) + 1;
        }
        iov[i].dataSize = 30;
        if( NULL != (iov[i].dataBuffer = clHeapCalloc(1, iov[i].dataSize)) )
        {
            iov[i].dataBuffer = NULL;
        }
        iov[i].readSize = 0;
        iov[i].dataOffset = 20;
    }
            rc = clCkptCheckpointRead(ckptHdl, iov, numSections, &readIdx); 
            if( CL_OK != rc )
            {
                return rc;
            }
    for( i = 0; i < numSections; i++ )
    {
        if( NULL != iov[i].sectionId.id ) 
        {
            clHeapFree(iov[i].sectionId.id);
        }
            clHeapFree(iov[i].dataBuffer);
    }
    return CL_OK;
}
ClRcT
clTestCkptRead(ClCkptHdlT  ckptHdl,
               ClUint32T   numSections,
               ClTimeT *pTime)
      
{
    ClRcT           rc = CL_OK;
    ClUint32T       i = 0;
    ClCkptIOVectorElementT  iov[numSections];
    ClUint32T               readIdx = 0;
    ClTimeT oldTime = 0;
    ClTimeT newTime = 0;
    ClCkptSectionIdT  defaultSecId = CL_CKPT_DEFAULT_SECTION_ID;

    memset(iov, 0, numSections * sizeof(ClCkptIOVectorElementT));
    for( i = 0; i < numSections; i++ )
    {
        if( numSections != 1 )
        {
            iov[i].sectionId.id = clHeapCalloc(1, 15);
            if( NULL == iov[i].sectionId.id )
            {   
                return CL_OK;
            }
            snprintf( (ClCharT *) iov[i].sectionId.id, 15,"section%d", i);
            iov[i].sectionId.idLen = strlen((ClCharT *) iov[i].sectionId.id) + 1;
        }
        else
        {
            iov[i].sectionId = defaultSecId;
        }
        iov[i].dataSize = 0;
        iov[i].dataBuffer = NULL;
        iov[i].readSize = 0;
        iov[i].dataOffset = 0;
    }
    if( numSections == 1 )
    {
        oldTime = clOsalStopWatchTimeGet();
        for( i = 0; i < 100; i++ )
        {
            rc = clCkptCheckpointRead(ckptHdl, &iov[0], numSections, &readIdx); 
        }
        newTime = clOsalStopWatchTimeGet();
    }
    else
    {
        oldTime = clOsalStopWatchTimeGet();
        rc = clCkptCheckpointRead(ckptHdl, iov, numSections, &readIdx); 
        newTime = clOsalStopWatchTimeGet();
    }

    *pTime = newTime - oldTime;

    for( i = 0; i < numSections; i++ )
    {
        clHeapFree(iov[i].dataBuffer);
        if( NULL != iov[i].sectionId.id ) 
        {
            clHeapFree(iov[i].sectionId.id);
        }
    }
    return CL_OK;
}
/*******************************************************************************
Feature  API: clTcCkptRead

Description : 

This API will not attempt to validate arguments, the thinking being that 
this is a volitional act by the invoker of this API to ensure that invalid 
parameters can be handled gracefully by the subsystem

Arguments In: 
	1. ClTcCkptDataT : contains the ckpt handle
	2. Section Name Prefix; if NULL no section names; if not NULL then the 
	                        section names will range from 
							<section_name_Prefix>1 to <section_name_prefix>9999
	3. section number
	4. data to read
	5. size of data to read 

Arguments Out:
	1. ClTcCkptDataT : returns time taken to read the section

Return Value:
	integer 0 if success, non zero if failure
*******************************************************************************/
int clTcCkptRead (
	ClTcCkptDataT* ckpt_data,
	const char*	   section_name_prefix,
	int			   section_num,
	void*		   data,
	int			   data_size )
{
	ClRcT 					ret_code = CL_OK;
	ClUint32T				error_index;
#if GO_TO_SECTION_DIRECTLY
	ClCharT					section_id_name[ CL_MAX_NAME_LENGTH ];
#endif
    ClCkptIOVectorElementT  io_vector;
    ClTimeT startTime = 0;
    ClTimeT endTime = 0;
    ClTimeT time_taken_us = 0;

	/* we either iterate through the sections until
	 * we get to the section of interest; or go directly
	 * to the section, assuming a known section Id; 
	 * the former is more general purpose and will be used here
	 */
#if GO_TO_SECTION_DIRECTLY
	if ( section_name_prefix != NULL )
	{
		snprintf(section_id_name,CL_MAX_NAME_LENGTH, "%s%05d", section_name_prefix, section_num);
	}
	else
	{
		snprintf(section_id_name,CL_MAX_NAME_LENGTH, "s%05d", section_num);
	}

	io_vector.sectionId.id = (ClUint8T*)section_id_name;
	io_vector.sectionId.idLen = strlen(section_id_name);
#else
	ret_code = clTcIterToSectionId(ckpt_data, section_num, &io_vector.sectionId);
	if (ret_code != CL_OK)
	{
		printf("clTcCkptRead: Failed to get section id: 0x%x\n", ret_code); 
		return ret_code;
	}
#endif

	/* assign other fields of the IoVector
	 */
	io_vector.dataBuffer  = NULL;
	io_vector.dataSize	  = data_size;
	io_vector.dataOffset  = 0;
	io_vector.readSize	  = 0;

	/* time check 1 start 
 	 */
	startTime = clOsalStopWatchTimeGet();
	ret_code = clCkptCheckpointRead((ClCkptHdlT)ckpt_data->ckpt_hdl,
									&io_vector, 1, &error_index );
	/* time check 1 end 
	 */
    endTime = clOsalStopWatchTimeGet();
	time_taken_us = endTime - startTime;

	ckpt_data->time_taken_ms = 0;
	ckpt_data->time_taken_us  = time_taken_us;

	if (ret_code != CL_OK)
	{
		printf("clTcCkptRead: Failed to read: 0x%x\n", ret_code); 
		return ret_code;
	}
	else
	{
		if ( io_vector.readSize != data_size )
		{
			printf("clTcCkptRead: Read %d bytes; expected %d bytes\n", 
				   (int)io_vector.readSize, data_size);
		}

		if (data_size <= io_vector.readSize)
		{
			memcpy(data, io_vector.dataBuffer, data_size);
		}
		else
		{
			memcpy(data, io_vector.dataBuffer, io_vector.readSize);
		}

		/* Free up buffer allocated by Ckpt Service
		 */
		clHeapFree(io_vector.dataBuffer);
	}

	return ret_code;
}
ClRcT
clLogMasterStateRecover(ClLogSvrCommonEoDataT  *pCommonEoEntry,
                        ClLogMasterEoDataT    *pMasterEoEntry,
                        ClBoolT switchover)
{
    ClRcT                             rc             = CL_OK;
    ClHandleT                         hSecIter       = CL_HANDLE_INVALID_VALUE;
    ClCkptSectionDescriptorT          secDescriptor  = {{0}};
    ClCkptIOVectorElementT            ioVector       = {{0}};
    ClUint32T                         errIndex       = 0;
    ClCkptSectionCreationAttributesT  secAttr        = {0};
    ClBoolT                           logReadFlag    = CL_FALSE;

    CL_LOG_DEBUG_TRACE(("Enter"));

    rc = clLogMasterEoEntrySet(pMasterEoEntry);
    if( CL_OK != rc )
    {
        CL_LOG_DEBUG_ERROR(("clLogMasterEoEntrySet(): rc[0x %x]", rc));
        return rc;
    }

    if(switchover)
    {
        rc = clCkptActiveReplicaSetSwitchOver(pMasterEoEntry->hCkpt);
    }
    else
    {
        rc = clCkptActiveReplicaSet(pMasterEoEntry->hCkpt);
    }
    if (CL_OK != rc)
    {
        CL_LOG_DEBUG_ERROR(("clCkptActiveReplicaSet(): rc[%#x],switchover flag [%d]", rc, switchover));
        return rc;
    }

    rc = clCkptSectionIterationInitialize(pMasterEoEntry->hCkpt,
                                          CL_CKPT_SECTIONS_ANY,
                                          CL_TIME_END, &hSecIter);
    if( CL_OK != rc )
    {
        CL_LOG_DEBUG_ERROR(("clCkptSectionIterationInitialize(): rc[0x %x]",
                            rc));
        return rc;
    }

    do
    {
        rc = clCkptSectionIterationNext(hSecIter, &secDescriptor);
        if( CL_OK != rc)
        {
            break;
        }

        logReadFlag         = CL_TRUE;
        if( pCommonEoEntry->masterAddr == clIocLocalAddressGet() )
        {
            ioVector.sectionId  = secDescriptor.sectionId;
            ioVector.dataBuffer = NULL;
            ioVector.dataSize   = 0;
            ioVector.readSize   = 0;
            ioVector.dataOffset = 0;
            clLogNotice(CL_LOG_AREA_MASTER, CL_LOG_CTX_CKPT_READ,
                        "Got section [%.*s] to be read",
                        secDescriptor.sectionId.idLen, secDescriptor.sectionId.id);
            if( 0 != strncmp((ClCharT *) ioVector.sectionId.id,
                             (ClCharT *) gLogMasterCompDataSectionId.id,
                             gLogMasterCompDataSectionId.idLen) )
            {
                rc = clCkptCheckpointRead(pMasterEoEntry->hCkpt, &ioVector, 1,
                                          &errIndex);
                if( CL_OK == rc ) /* create whatever we can */
                {
                    if( 0 == strncmp((ClCharT *) ioVector.sectionId.id,
                                     (ClCharT *) gLogMasterDefaultSectionId.id,
                                     gLogMasterDefaultSectionId.idLen) )
                    {
                        rc = clLogMasterEoEntryRecover(pMasterEoEntry, &ioVector,
                                                       &errIndex);
                        if( CL_OK != rc )
                        {
                            clHeapFree(ioVector.dataBuffer);
                            clHeapFree(ioVector.sectionId.id);
                            break; /* break out of the loop, can't continue */
                        }
                        clHeapFree(ioVector.dataBuffer);
                    }
                    else
                    {
                        /* create whatever we can */
                        clLogMasterFileEntryRecover(pMasterEoEntry, &ioVector,
                                                    &errIndex);
                        clHeapFree(ioVector.dataBuffer);
                    }
                }
            }
            clHeapFree(secDescriptor.sectionId.id);
        }
        else
        {
            return rc;
        }
    } while( (rc == CL_OK) );

    CL_LOG_CLEANUP(clCkptSectionIterationFinalize(hSecIter), CL_OK);

    if( CL_TRUE == logReadFlag )
    {
        ioVector.sectionId  = gLogMasterCompDataSectionId;
        ioVector.dataBuffer = NULL;
        ioVector.dataSize   = 0;
        ioVector.readSize   = 0;
        ioVector.dataOffset = 0;
        rc = clCkptCheckpointRead(pMasterEoEntry->hCkpt, &ioVector, 1, &errIndex);
        if( CL_OK != rc )
        {
            CL_LOG_DEBUG_ERROR(("clCkptCheckpointRead():rc[0x %x]", rc));
            return rc;
        }
        rc = clLogMasterCompTableStateRecover(pMasterEoEntry, (ClUint8T*) ioVector.dataBuffer,
                                              ioVector.readSize);
        if( CL_OK != rc )
        {
            CL_LOG_DEBUG_ERROR(("Unable to recreate the state of compTable"));
        }
        clHeapFree(ioVector.dataBuffer);
    }
    else
    {
        secAttr.sectionId      = &gLogMasterDefaultSectionId;
        secAttr.expirationTime = CL_TIME_END;
        rc = clCkptSectionCreate(pMasterEoEntry->hCkpt, &secAttr, NULL, 0);
        if( CL_OK != rc )
        {
            CL_LOG_DEBUG_ERROR(("clCkptSectionCreate(): rc[0x %x]", rc));
            return rc;
        }
        secAttr.sectionId      = &gLogMasterCompDataSectionId;
        secAttr.expirationTime = CL_TIME_END;
        rc = clCkptSectionCreate(pMasterEoEntry->hCkpt, &secAttr, NULL,
                                 0);
        if( CL_OK != rc )
        {
            CL_LOG_DEBUG_ERROR(("clCkptSectionCreate(): rc[0x %x]", rc));
            CL_LOG_CLEANUP(clCkptSectionDelete(pMasterEoEntry->hCkpt,
                                               &gLogMasterDefaultSectionId),
                           CL_OK);
        }
    }

    CL_LOG_DEBUG_TRACE(("Exit"));
    return CL_OK;
}
SaAisErrorT saCkptCheckpointRead(SaCkptCheckpointHandleT checkpointHandle,
                                 SaCkptIOVectorElementT  *pIoVector,
                                 SaUint32T               numberOfElements,
                                 SaUint32T              *erroneousVectorIndex)
{
    ClRcT                   rc          = CL_OK;
    SaAisErrorT             safRc       = SA_AIS_OK;
    ClCkptIOVectorElementT *pTempVec    = NULL;
    SaCkptIOVectorElementT *pTempOutVec = NULL;
    ClCkptIOVectorElementT *pInVector   = NULL; 
    ClUint32T               count       = 0;

    /*
     * Validate the input parameters.
     */
    if(pIoVector == NULL) return SA_AIS_ERR_INVALID_PARAM;

    /*
     * Copy the iovector in clovis format.
     */
    pTempVec = (ClCkptIOVectorElementT *)pIoVector;
    if(pIoVector != NULL)
    { 
        pInVector = (ClCkptIOVectorElementT *)clHeapAllocate(
                    sizeof(ClCkptIOVectorElementT) * numberOfElements); 
        if(pInVector == NULL)
        {
            safRc = SA_AIS_ERR_NO_MEMORY;
            return safRc;
        }
        
        memset(pInVector, '\0',
              sizeof(ClCkptIOVectorElementT) * numberOfElements);
        pTempVec    = pInVector;
        pTempOutVec = pIoVector;
        for(count = 0; count < numberOfElements; count ++)
        {
            pInVector->sectionId.idLen = pIoVector->sectionId.idLen;
            pInVector->sectionId.id = (ClUint8T *) clHeapAllocate(
                                pIoVector->sectionId.idLen);
            if(pInVector->sectionId.id == NULL)
            {
                safRc = SA_AIS_ERR_NO_MEMORY;
                return safRc;
            }
            memset(pInVector->sectionId.id,'\0',pInVector->sectionId.idLen);
            memcpy(pInVector->sectionId.id, pIoVector->sectionId.id, 
                   pInVector->sectionId.idLen);
            pInVector->dataBuffer = (ClUint8T*)pIoVector->dataBuffer;
            pInVector->dataSize   = pIoVector->dataSize;
            pInVector->dataOffset = pIoVector->dataOffset;
            pInVector->readSize   = pIoVector->readSize;    
            pInVector++;
            pIoVector++;
        }
    }
    
    /*
     * Call the corresponding ckpt client library function.
     */
    rc = clCkptCheckpointRead( (ClCkptHdlT) checkpointHandle,
            pTempVec,
            (ClUint32T) numberOfElements,
            (ClUint32T *)erroneousVectorIndex);
            
    if(pTempVec != NULL)
    { 
        pInVector = pTempVec;
        pIoVector = pTempOutVec;
        for(count = 0; count < numberOfElements; count++)
        {
            pIoVector->dataBuffer = pInVector->dataBuffer; 
            pIoVector->readSize = pInVector->readSize;
            clHeapFree(pInVector->sectionId.id);
            pInVector++;
            pIoVector++;
        }
        clHeapFree(pTempVec);
    }
    pIoVector = pTempOutVec;

    /*
     * Translate the clovis error type to SAF error type.
     */
    clErrorTxlate(rc, &safRc);
    
    return safRc;
}
ClRcT
clLogStreamOwnerGlobalEntryRecover(ClLogSOEoDataT            *pSoEoEntry,
                                   ClCkptSectionDescriptorT  *pSecDescriptor)
{
    ClRcT                   rc     = CL_OK;
    ClCkptIOVectorElementT  ioVector       = {{0}};
    ClUint32T               errIndex       = 0;
    ClLogSvrCommonEoDataT   *pCommonEoData = NULL;
    ClUint32T               versionCode = 0;

    CL_LOG_DEBUG_TRACE(("Enter"));

    rc = clLogStreamOwnerEoEntryGet(NULL, &pCommonEoData);
    if( CL_OK != rc )
    {
        return rc;
    }
    
    ioVector.sectionId  = pSecDescriptor->sectionId; 
    ioVector.dataBuffer = NULL;
    ioVector.dataSize   = 0;
    ioVector.readSize   = 0;
    ioVector.dataOffset = 0;
    rc = clCkptCheckpointRead(pSoEoEntry->hCkpt, &ioVector, 1, &errIndex);
    if( CL_OK != rc )
    {
        CL_LOG_DEBUG_ERROR(("clCkptCheckpointRead(): rc[0x %x]", rc));
        return rc;
    }

    if(ioVector.readSize <= sizeof(versionCode))
    {
        CL_LOG_DEBUG_ERROR(("Global stream recovery failed because of inconsistent ckpt "
                            "data of size [%lld]",
                            ioVector.readSize));
        clHeapFree(ioVector.dataBuffer);
        return CL_LOG_RC(CL_ERR_INVALID_STATE);
    }

    ioVector.readSize -= sizeof(versionCode);
    versionCode = ntohl(*(ClUint32T*)ioVector.dataBuffer);
    switch(versionCode)
    {
    case CL_VERSION_CODE(CL_RELEASE_VERSION, CL_MAJOR_VERSION, CL_MINOR_VERSION):
        {
            rc = clLogSOStreamEntryRecreate(0, 
                                            (ClAddrT)( (ClUint8T*)ioVector.dataBuffer + sizeof(versionCode)),
                                            ioVector.readSize,
                                            CL_HANDLE_INVALID_VALUE);
        }
        break;
    default:
        rc = CL_LOG_RC(CL_ERR_VERSION_MISMATCH);
        clLogError("GLOBAL", "RECOVER", "Version unsupported [%d.%d.%d]",
                   CL_VERSION_RELEASE(versionCode), CL_VERSION_MAJOR(versionCode),
                   CL_VERSION_MINOR(versionCode));
        break;
    }

    clHeapFree(ioVector.dataBuffer);

    CL_LOG_DEBUG_TRACE(("Exit"));
    return rc;
}    
ClRcT clCachedCkptSynch(ClCachedCkptSvcInfoT *serviceInfo, ClBoolT isEmpty)
{
    ClRcT                             rc             = CL_OK;
    ClHandleT                         hSecIter       = CL_HANDLE_INVALID_VALUE;
    ClCkptSectionDescriptorT          secDescriptor  = {{0}};
    ClCkptIOVectorElementT            ioVector       = {{0}};
    ClUint32T                         errIndex       = 0;

    rc = clCkptSectionIterationInitialize(serviceInfo->ckptHandle,
                                          CL_CKPT_SECTIONS_ANY,
                                          CL_TIME_END, &hSecIter);
    if( CL_OK != rc )
    {
        clLogError("CCK", "SYNC", "clCkptSectionIterationInitialize(): rc [0x%x].",rc);
        return rc;
    }

    do
    {
        rc = clCkptSectionIterationNext(hSecIter, &secDescriptor);
        if( CL_OK != rc)
        {
            break;
        }

        ioVector.sectionId  = secDescriptor.sectionId;
        ioVector.dataBuffer = NULL;
        ioVector.dataSize   = 0;
        ioVector.readSize   = 0;
        ioVector.dataOffset = 0;

        rc = clCkptCheckpointRead(serviceInfo->ckptHandle, &ioVector, 1,
                                  &errIndex);
        if( CL_OK == rc )
        {
            ClUint8T *ckptedData, *copyData;
            ClUint32T network_byte_order;
            ClCachedCkptDataT sectionData;

            ckptedData = (ClUint8T*) ioVector.dataBuffer;
            copyData = ckptedData;

            memset(&sectionData.sectionName, 0, sizeof (SaNameT));
            sectionData.sectionName.length = ioVector.sectionId.idLen;
            memcpy(sectionData.sectionName.value, ioVector.sectionId.id, sectionData.sectionName.length);

            memcpy(&network_byte_order, copyData, sizeof(ClUint32T));
            sectionData.sectionAddress.iocPhyAddress.nodeAddress = (ClUint32T) ntohl((ClUint32T)network_byte_order);
            copyData = copyData + sizeof(ClUint32T);

            memcpy(&network_byte_order, copyData, sizeof(ClUint32T));
            sectionData.sectionAddress.iocPhyAddress.portId = (ClUint32T) ntohl((ClUint32T)network_byte_order);
            copyData = copyData + sizeof(ClUint32T);

            sectionData.data = copyData;
            sectionData.dataSize = ioVector.readSize - sizeof(ClIocAddressT);

            if (isEmpty)
                clCacheEntryAdd(serviceInfo, (ClCachedCkptDataT *)&sectionData);
            else
                clCacheEntryUpdate(serviceInfo, (ClCachedCkptDataT *)&sectionData);

            clHeapFree(ioVector.dataBuffer);
        }

        clHeapFree(secDescriptor.sectionId.id);
    } while( (rc == CL_OK) );

    rc = clCkptSectionIterationFinalize(hSecIter);
    if( CL_OK != rc )
    {
        clLogError("CCK", "SYNC", "clCkptSectionIterationFinalize(): rc [0x%x].",rc);
        return rc;
    }

    return CL_OK;
}