ClRcT
clNameContextCkptNameUnpack(ClBufferHandleT  inMsg)
{
    ClRcT             rc      = CL_OK;
    ClUint32T         key     = 0;
    ClUint32T         size    = 0;
    ClUint32T         count   = 0;
    ClIocNodeAddressT localAddr = 0;
    ClIocNodeAddressT masterAddr = 0;

    CL_NAME_DEBUG_TRACE(("Enter"));
    rc = clXdrUnmarshallClUint32T(inMsg, &size);
    if( CL_OK != rc )
    {
        CL_DEBUG_PRINT(CL_DEBUG_ERROR,
                ("clXdrUnmarshallClUint32T(): rc[0x %x]", rc));
        return rc;
    }    
    clLogDebug("SVR", "CKP", "Num of contexts: %d", size);
    for( count = 0; count < size; count++)
    {    
        rc = clXdrUnmarshallClUint32T(inMsg, &key);
        if( CL_OK != rc )
        {
            return rc;
        }    
        if( (key > CL_NS_DEFAULT_GLOBAL_CONTEXT) && 
            (key < CL_NS_BASE_NODELOCAL_CONTEXT) )
        {
            localAddr = clIocLocalAddressGet();
            rc = clCpmMasterAddressGet(&masterAddr);
            if (rc != CL_OK)
            {
                CL_DEBUG_PRINT(CL_DEBUG_ERROR,("clCpmMasterAddressGet failed with rc 0x%x",rc));
                return rc;
            }

            if( masterAddr == localAddr )
            {
                rc = clNameSvcCtxRecreate(key);
                if( CL_OK != rc )
                {
                    return rc;
                }    
            }    
        }    
        else
        {    
            rc = clNameSvcCtxRecreate(key);
            if( CL_OK != rc )
            {
                return rc;
            }    
        } 
    }
    
    CL_NAME_DEBUG_TRACE(("Exit"));
    return rc;
}    
static PyObject* GetMasterNode(PyObject *self)
{
    ClIocNodeAddressT nodeAddr=0;
    ClRcT   rc = CL_OK;
    char buf[256] = "";
    

    rc = clCpmMasterAddressGet(&nodeAddr);
    if (rc != CL_OK) {
        DbgLog("Error while getting master address");
        return NULL;
    }

    snprintf(buf,256,"%d",nodeAddr);
    
    PyObject* ret = PyRun_String(buf,Py_eval_input,emptyDict,emptyDict);
    
    return ret;
}
static ClRcT clAmsTriggerFault(ClAmsEntityT *pEntity,
                               ClAmsRecoveryT recommendedRecovery)
{
    ClErrorReportT errorReport = {{0}};
    ClIocNodeAddressT master;
    ClRcT rc = clCpmMasterAddressGet(&master);
    if(rc != CL_OK)
    {
        clLogError("TRIGGER", "RECOVERY", "Master address get returned [%#x]", rc);
        goto out;
    }
    memcpy(&errorReport.compName, &pEntity->name, sizeof(errorReport.compName));
    /*
     *Patch comp name as CPM expects unpatched name before patching it up for AMS :-)
     */
    errorReport.compName.length -= 1;
    errorReport.recommendedRecovery = recommendedRecovery;
    errorReport.handle = 0;
    rc = clCpmClientRMDAsyncNew(master,
                                CPM_COMPONENT_FAILURE_REPORT,
                                (ClUint8T *) &errorReport,
                                sizeof(ClErrorReportT),
                                NULL,
                                NULL,
                                CL_RMD_CALL_ATMOST_ONCE,
                                0,
                                0,
                                0,
                                MARSHALL_FN(ClErrorReportT, 4, 0, 0));
    if(rc != CL_OK)
    {
        clLogError("TRIGGER", "RECOVERY",
                   "Fault report RMD returned [%#x]", rc);
        goto out;
    }

    out:
    return rc;
}
ClRcT clCkptMasterAddressesSet()
{
    ClRcT rc = CL_OK;
#ifdef CL_CKPT_GMS 
    /*
     * GMS available.
     */
     
    /* 
     * Contact GMS to get master and backup master addresses.
     */
    ClGmsClusterNotificationBufferT notBuffer;
    memset((void*)&notBuffer , 0, sizeof(notBuffer));
    memset( &notBuffer , '\0' ,sizeof(ClGmsClusterNotificationBufferT));
    
    /*
     * Initialize the gms client library.
     */
    rc = clGmsInitialize(&gCkptSvr->gmsHdl, &ckptGmsCallbacks,
                        &gVersion);
    CKPT_ERR_CHECK(CL_CKPT_SVR,CL_LOG_SEV_ERROR,
    (" clCkptMasterAddressesSet failed rc[0x %x]\n",rc),
        rc);
        
    /* 
     * Register for current track and track changes.
     */
    rc = clGmsClusterTrack(gCkptSvr->gmsHdl, 
                           CL_GMS_TRACK_CHANGES|CL_GMS_TRACK_CURRENT, 
                           &notBuffer);
                           
    /*
     * Call the track change callback function. This is needed for getting
     * current track information.
     */
    if(rc == CL_OK && notBuffer.leader &&
       notBuffer.leader != CL_GMS_INVALID_NODE_ID)
    {
        _clCkptAddressesUpdate(&notBuffer);
    }

    if (notBuffer.notification != NULL)
      clHeapFree(notBuffer.notification);

#else
    /*
     * GMS unavailable.
     */

     /*
      * Select cpm master as ckpt master. Deputy will be unspecified.
      */
    clCpmMasterAddressGet(&gCkptSvr->masterInfo.masterAddr);
    gCkptSvr->masterInfo.deputyAddr = -1;

    /*
     * Update the TL with ckpt master address.
     */
    if(gCkptSvr->masterInfo.masterAddr == gCkptSvr->localAddr )
    {
        ClIocTLInfoT tlInfo = {0};
        ClUint32T    compId = 0; 
        SaNameT      name   = {0};
 
        clCpmComponentNameGet(gCkptSvr->amfHdl, &name);
        clCpmComponentIdGet(gCkptSvr->amfHdl, &name, &compId);
        tlInfo.compId                   = compId;
        gCkptSvr->masterInfo.compId     = compId;
        ckptOwnLogicalAddressGet(&tlInfo.logicalAddr);
        tlInfo.contextType              = CL_IOC_TL_GLOBAL_SCOPE;
        tlInfo.physicalAddr.nodeAddress = clIocLocalAddressGet();
        tlInfo.physicalAddr.portId      = CL_IOC_CKPT_PORT;
        tlInfo.haState                  = CL_IOC_TL_ACTIVE;
        rc = clIocTransparencyRegister(&tlInfo);
    }
#endif
#ifdef CL_CKPT_GMS 
exitOnError:
#endif
    {
        return rc;
    }
}
ClRcT clCpmSlotInfoGet(ClCpmSlotInfoFieldIdT flag, ClCpmSlotInfoT *slotInfo)
{
    ClRcT rc = CL_OK;
    ClIocNodeAddressT masterIocAddress = 0;
    ClCpmSlotInfoRecvT  slotInfoRecv = { CL_CPM_SLOT_ID};
    ClUint32T           bufSize = 0;
    
    /* make a SYNC RMD to CPM/G master */
    
    rc = clCpmMasterAddressGet(&masterIocAddress);
    if (rc != CL_OK)
        goto failure;

    slotInfoRecv.flag = flag;
    switch(slotInfoRecv.flag)
    {
        case CL_CPM_SLOT_ID:
        {
            slotInfoRecv.slotId = slotInfo->slotId;
            break;
        }
        case CL_CPM_IOC_ADDRESS:
        {
            slotInfoRecv.nodeIocAddress = slotInfo->nodeIocAddress;
            break;
        }
#ifdef USE_COR        
        case CL_CPM_NODE_MOID:
        {
            slotInfoRecv.nodeMoIdStr.length = 0;
            slotInfoRecv.nodeMoIdStr.value[0] = 0;                
            rc = clCorMoIdToMoIdNameGet(&slotInfo->nodeMoId, &slotInfoRecv.nodeMoIdStr);
            CPM_CLIENT_CHECK(CL_LOG_SEV_ERROR,("MoIdToMoIdNameGet Failed, rc=[0x%x]\n", rc), rc);
            break;
        }
#endif        
        case CL_CPM_NODENAME:
        {
            memcpy(&slotInfoRecv.nodeName, &slotInfo->nodeName, sizeof(SaNameT));
            break;
        }
        default:
        {
            rc = CL_CPM_RC(CL_ERR_INVALID_PARAMETER);
            clLogError(CPM_LOG_AREA_CPM,CL_LOG_CONTEXT_UNSPECIFIED,
                       "Invalid flag passed, rc=[0x%x]\n", rc);
            goto failure;
            break;
        }
    }

    rc = clCpmClientRMDSyncNew(masterIocAddress, CPM_SLOT_INFO_GET,
                               (ClUint8T *) &slotInfoRecv, sizeof(ClUint32T),
                               (ClUint8T *) &slotInfoRecv, &bufSize,
                               CL_RMD_CALL_NEED_REPLY, 0, 0, 0,
                               MARSHALL_FN(ClCpmSlotInfoRecvT, 4, 0, 0),
                               UNMARSHALL_FN(ClCpmSlotInfoRecvT, 4, 0, 0));
    
    CPM_CLIENT_CHECK(CL_LOG_SEV_ERROR, ("Unable to find information about given entity, rc=[0x%x]\n", rc), rc);

    switch(slotInfoRecv.flag)
    {
        case CL_CPM_SLOT_ID:
        {
            slotInfo->nodeIocAddress = slotInfoRecv.nodeIocAddress;
#ifdef USE_COR        
            rc = clCorMoIdNameToMoIdGet(&slotInfoRecv.nodeMoIdStr, &slotInfo->nodeMoId);
            CPM_CLIENT_CHECK(CL_LOG_SEV_ERROR,
                    ("MoIdNameToMoIdGet Failed, rc=[0x%x]\n", rc), rc);
#endif            
            memcpy(&slotInfo->nodeName, &slotInfoRecv.nodeName, sizeof(SaNameT));

            break;
        }
        case CL_CPM_IOC_ADDRESS:
        {
            slotInfo->slotId = slotInfoRecv.slotId;
#ifdef USE_COR  
            rc = clCorMoIdNameToMoIdGet(&slotInfoRecv.nodeMoIdStr, &slotInfo->nodeMoId);
            CPM_CLIENT_CHECK(CL_LOG_SEV_ERROR,
                    ("MoIdNameToMoIdGet Failed, rc=[0x%x]\n", rc), rc);
#endif
            memcpy(&slotInfo->nodeName, &slotInfoRecv.nodeName, sizeof(SaNameT));

            break;
        }
        case CL_CPM_NODE_MOID:
        {
            slotInfo->slotId = slotInfoRecv.slotId;
            
            slotInfo->nodeIocAddress = slotInfoRecv.nodeIocAddress;
            
            memcpy(&slotInfo->nodeName, &slotInfoRecv.nodeName, sizeof(SaNameT));

            break;
        }
        case CL_CPM_NODENAME:
        {
            slotInfo->slotId = slotInfoRecv.slotId;

            slotInfo->nodeIocAddress = slotInfoRecv.nodeIocAddress;
#ifdef USE_COR 
            rc = clCorMoIdNameToMoIdGet(&slotInfoRecv.nodeMoIdStr, &slotInfo->nodeMoId);
            CPM_CLIENT_CHECK(CL_LOG_SEV_ERROR,
                    ("MoIdNameToMoIdGet Failed, rc=[0x%x]\n", rc), rc);
#endif
            break;
        }
        default:
        {
            rc = CL_CPM_RC(CL_ERR_INVALID_PARAMETER);
            clLogError(CPM_LOG_AREA_CPM,CL_LOG_CONTEXT_UNSPECIFIED,
                       "Invalid flag passed, rc=[0x%x]\n", rc);
            goto failure;
            break;
        }
    }

    return rc;

failure:
    return rc;
}