ClRcT clDebugVersionCheck(ClVersionT *pVersion) { ClRcT rc = CL_OK; if(pVersion == NULL) { rc = CL_ERR_NULL_POINTER; return rc; } rc = clVersionVerify(&versionDatabase,pVersion); if(rc != CL_OK) { return rc; } return rc; }
ClRcT clTxnVersionVerify(ClVersionT *pVersion) { ClRcT rc = CL_OK; CL_FUNC_ENTER(); if (NULL == pVersion) { CL_FUNC_EXIT(); return CL_TXN_RC(CL_ERR_NULL_POINTER); } rc = clVersionVerify (&clTxnMgmtVersionDb, pVersion); if (CL_OK != rc) { CL_DEBUG_PRINT(CL_DEBUG_ERROR, ("Un-supported version. rc:0x%x\n", rc)); rc = CL_TXN_RC(rc); } CL_FUNC_EXIT(); return (rc); }
ClRcT clAmsSAInitialize( CL_OUT ClAmsClientHandleT *amsHandle, CL_IN const ClAmsSAClientCallbacksT *amsClientCallbacks, CL_INOUT ClVersionT *version ) { ClRcT rc = CL_OK; clAmsClientInitializeRequestT req; clAmsClientInitializeResponseT *res = NULL; struct ams_instance *ams_instance = NULL; if (amsHandle == NULL || version == NULL) { return CL_AMS_RC(CL_ERR_NULL_POINTER); } /* * Initialize the library and database */ if ((rc = check_lib_init()) != CL_OK) goto error; /* * Verify the version information */ if (( rc = clVersionVerify ( &version_database, version)) != CL_OK) goto error; /* * Create the handle */ if ((rc = clHandleCreate ( handle_database, sizeof(struct ams_instance), amsHandle)) != CL_OK) goto error; /* * Check-Out the handle */ if ((rc = clHandleCheckout( handle_database, *amsHandle, (void *)&ams_instance)) != CL_OK) goto error; /* * Initialize instance entry */ if (amsClientCallbacks) { memcpy(&ams_instance->callbacks, amsClientCallbacks, sizeof(ClAmsSAClientCallbacksT)); } else { memset(&ams_instance->callbacks, 0, sizeof(ClAmsSAClientCallbacksT)); } if ( ( rc = clOsalMutexCreate(&ams_instance->response_mutex)) != CL_OK ) goto error; /* * Inform the server */ req.handle = *amsHandle; if ( (rc = cl_ams_client_initialize( &req, &res)) != CL_OK) goto error; /* * Decrement handle use count and return */ if ((rc = clHandleCheckin( handle_database, *amsHandle)) != CL_OK) goto error; clHeapFree((void*)res); res = NULL; return CL_OK; error: clHeapFree((void*)res); res = NULL; return CL_AMS_RC(rc); }
/*----------------------------------------------------------------------------- * Initialize API *---------------------------------------------------------------------------*/ ClRcT clGmsInitialize( CL_OUT ClGmsHandleT* const gmsHandle, CL_IN const ClGmsCallbacksT* const gmsCallbacks, CL_INOUT ClVersionT* const version) { struct gms_instance *gms_instance_ptr = NULL; ClRcT rc = CL_OK; ClGmsClientInitRequestT req = {{0}}; ClGmsClientInitResponseT *res = NULL; /* Step 0: Check readiness of library */ rc = check_lib_init(); if (rc != CL_OK) { return CL_GMS_RC(CL_ERR_NOT_INITIALIZED); } /* Step 1: Checking inputs */ CL_ASSERT(gmsHandle != NULL); CL_ASSERT(version != NULL); #if 0 if ((gmsHandle == NULL) || (version == NULL)) { return CL_GMS_RC(CL_ERR_NULL_POINTER); } #endif *gmsHandle = CL_HANDLE_INVALID_VALUE; /* Step 2: Verifying version match */ rc = clVersionVerify (&version_database, version); if (rc != CL_OK) { return CL_GMS_RC(CL_ERR_VERSION_MISMATCH); } /* Step 3: Obtain unique handle */ rc = clHandleCreate(gmsHandleDb, sizeof(struct gms_instance), gmsHandle); CL_ASSERT(rc == CL_OK); #if 0 if (rc != CL_OK) { rc = CL_GMS_RC(CL_ERR_NO_RESOURCE); goto error_no_destroy; } #endif clLogInfo("GMS","CLT","GMS client handle is [%llX]",*gmsHandle); rc = clHandleCheckout(gmsHandleDb, *gmsHandle, (void **)&gms_instance_ptr); CL_ASSERT(rc == CL_OK); CL_ASSERT(gms_instance_ptr != NULL); #if 0 if(rc != CL_OK) { goto error_destroy; } if (gms_instance_ptr == NULL) { clHandleCheckin(gmsHandleDb, *gmsHandle); rc = CL_GMS_RC(CL_ERR_NULL_POINTER); goto error_destroy; } #endif rc = clGmsMutexCreate(&gms_instance_ptr->response_mutex); CL_ASSERT(rc == CL_OK); #if 0 if(rc != CL_OK) { clHandleCheckin(gmsHandleDb, *gmsHandle); goto error_destroy; } #endif /* Step 4: Negotiate version with the server */ req.clientVersion.releaseCode = version->releaseCode; req.clientVersion.majorVersion= version->majorVersion; req.clientVersion.minorVersion= version->minorVersion; rc = cl_gms_clientlib_initialize_rmd(&req, 0x0 ,&res ); if(rc != CL_OK ) { clLogError(GEN,NA,"cl_gms_clientlib_initialize_rmd failed with rc:0x%x ",rc); clGmsMutexDelete(gms_instance_ptr->response_mutex); gms_instance_ptr->response_mutex = 0; clHandleCheckin(gmsHandleDb, *gmsHandle); rc = CL_GMS_RC(rc); goto error_destroy; } /* Step 5: Initialize instance entry */ if (gmsCallbacks) { memcpy(&gms_instance_ptr->callbacks, gmsCallbacks, sizeof(ClGmsCallbacksT)); } else { memset(&gms_instance_ptr->callbacks, 0, sizeof(ClGmsCallbacksT)); } memset(&gms_instance_ptr->cluster_notification_buffer, 0, sizeof(ClGmsClusterNotificationBufferT)); memset(&gms_instance_ptr->group_notification_buffer, 0, sizeof(ClGmsGroupNotificationBufferT)); /* Step 6: Decrement handle use count and return */ if ((clHandleCheckin(gmsHandleDb, *gmsHandle)) != CL_OK) { clLogError(GEN,DB, "\nclHandleCheckin failed"); } clHeapFree(res); return CL_OK; error_destroy: clHandleDestroy(gmsHandleDb, *gmsHandle); *gmsHandle = CL_HANDLE_INVALID_VALUE; //error_no_destroy: return rc; }
* closest value of the version supported filled in the version as out parameter. */ ClRcT clFaultVersionVerify(ClVersionT *version) { ClRcT rc = CL_OK; if(version == NULL) { clLogError(FAULT_LOG_AREA_FAULT,FAULT_LOG_CTX_VERSION,"NULL pointer passed as version \ address.with rc: 0x%x", rc); return CL_ERR_NULL_POINTER; } CL_FUNC_ENTER(); rc = clVersionVerify(&gFaultClientToServerVersionDb,version); if(rc != CL_OK) { clLogError(FAULT_LOG_AREA_FAULT,FAULT_LOG_CTX_VERSION,"The Cor Version is not supported. 0x%x", rc); return CL_FAULT_ERR_VERSION_UNSUPPORTED; } CL_FUNC_EXIT(); return rc; } ClRcT clFaultReport(SaNameT *compName, ClCorMOIdPtrT hMoId, ClAlarmStateT alarmState, ClAlarmCategoryTypeT category,
/** * This function receives control message from transaction-manager for coordinating * for a given transaction-job. Parameters identify transaction-job and the control * information necessary to execute the next step. */ ClRcT VDECL(clTxnAgentCntrlMsgReceive)( CL_IN ClEoDataT eoArg, CL_IN ClBufferHandleT inMsg, CL_IN ClBufferHandleT outMsg) { ClRcT rc = CL_OK; ClTxnMessageHeaderT msgHeader = {{0}}; ClTxnMessageHeaderIDLT msgHeadIDL = {{0}}; CL_FUNC_ENTER(); rc = VDECL_VER(clXdrUnmarshallClTxnMessageHeaderIDLT, 4, 0, 0)(inMsg, &msgHeadIDL); if(CL_OK != rc) { clLogError("AGT", NULL, "Error in unmarshalling msgHeadIDL, rc [0x%x]", rc); return rc; } _clTxnCopyIDLToMsgHead(&msgHeader, &msgHeadIDL); CL_ASSERT(msgHeader.msgCount); /* Check/Validate server version */ rc = clVersionVerify (&clTxnMgmtVersionDb, &(msgHeader.version)); if (CL_OK != rc) { CL_DEBUG_PRINT(CL_DEBUG_ERROR, ("Un-supported version. rc:0x%x\n", rc)); CL_FUNC_EXIT(); return (CL_GET_ERROR_CODE(rc)); } clLogDebug("AGT", NULL, "Receiving control-msg from txn-manager"); /* Based on msg-type, - If this is TXN_DEFN, then extract the txn and job-defn and do initialize. Respond CL_OK, if everything is fine. - If this is TXN_CMD, then for each txn and job (if mentioned), execute and intended operation - If TXN_STATUS_CHANGE, take action accordingly */ switch (msgHeader.msgType) { case CL_TXN_MSG_MGR_CMD: rc = _clTxnAgentProcessMgrCmd(inMsg, outMsg, &msgHeader); break; case CL_TXN_MSG_CLIENT_REQ_TO_AGNT: rc = _clTxnAgentProcessClientCmd(inMsg, outMsg, &msgHeader); break; case CL_TXN_MSG_COMP_STATUS_UPDATE: rc = CL_ERR_NOT_IMPLEMENTED; break; default: CL_DEBUG_PRINT(CL_DEBUG_ERROR, ("Invalid msg-type received 0x%x\n", msgHeader.msgType)); rc = CL_ERR_INVALID_PARAMETER; break; } /* This is to be replaced by clTxnCommIfcReadMessage(). clTxnCommIfcReadMessage() * writes to the outMsgHdl which is either received by the client or server depending * on where the async request came from */ #if 0 rc = clTxnCommIfcAllSessionClose(); if (CL_OK != rc) { CL_DEBUG_PRINT(CL_DEBUG_ERROR, ("Failed to process received msg. rc:0x%x\n", rc)); /* FIXME: Do logging */ rc = CL_GET_ERROR_CODE(rc); } #endif CL_FUNC_EXIT(); return (rc); }
ClRcT VDECL(clDebugGetContext)(ClEoDataT data, ClBufferHandleT inMsgHdl, ClBufferHandleT outMsgHdl) { ClRcT rc = CL_OK; ClDebugObjT *pDebugObj = (ClDebugObjT *) data; ClVersionT version = {0}; ClIocPhysicalAddressT srcAddr = {0}; if ((NULL == pDebugObj) || (0 == outMsgHdl) || (0 == inMsgHdl)) { clLogWrite(CL_LOG_HANDLE_APP,CL_LOG_WARNING,CL_DEBUG_LIB_CLIENT, CL_LOG_MESSAGE_1_INVALID_PARAMETER,"Invalid debugObj"); return CL_DEBUG_RC(CL_ERR_INVALID_PARAMETER); } /* * Enable the comp status for the debug client to avoid * response failures from node representative in case the bit isnt enabled for cases when * the comp arrival from peer noderep. reaches late. */ if(clRmdSourceAddressGet(&srcAddr) == CL_OK) clIocCompStatusEnable(srcAddr); rc = clXdrUnmarshallClVersionT(inMsgHdl,&version); if (CL_OK != rc) { return rc; } rc = clVersionVerify(&versionDatabase,&version); if (CL_OK != rc) { clXdrMarshallClVersionT(&version,outMsgHdl,0); return rc; } rc = clXdrMarshallArrayClCharT(pDebugObj->compName, CL_DEBUG_COMP_NAME_LEN, outMsgHdl,0); if (CL_OK != rc) { return rc; } rc = clXdrMarshallArrayClCharT(pDebugObj->compPrompt, CL_DEBUG_COMP_PROMPT_LEN, outMsgHdl,0); if (CL_OK != rc) { return rc; } rc = clXdrMarshallClUint32T((&pDebugObj->numFunc), outMsgHdl,0); if (CL_OK != rc) { return rc; } rc = clHandleWalk(pDebugObj->hDebugFnDB, clDebugContexDetailsPack, (ClPtrT) outMsgHdl); if( CL_OK != rc ) { return rc; } return rc; }
ClRcT VDECL(clDebugInvoke)(ClEoDataT data, ClBufferHandleT inMsgHdl, ClBufferHandleT outMsgHdl) { ClRcT rc = CL_OK; ClUint32T i = 0; ClUint32T argc = 0; ClCharT *argv[MAX_ARGS]; ClCharT argBuf[(MAX_ARG_BUF_LEN+1) * MAX_ARGS]; /* +1 for NULL termination */ ClDebugObjT *pDebugObj = (ClDebugObjT*) data; ClCharT *resp = NULL; ClVersionT version = {0}; ClDebugInvokeCookieT invokeCookie = {0}; ClDebugDeferContextT deferContext = {0}; ClRcT retCode = CL_OK; if ((NULL == pDebugObj) || (0 == outMsgHdl)) { clLogWrite( CL_LOG_HANDLE_APP,CL_LOG_CRITICAL,CL_DEBUG_LIB_CLIENT, CL_LOG_MESSAGE_0_MEMORY_ALLOCATION_FAILED); return CL_DEBUG_RC(CL_ERR_INVALID_PARAMETER); } rc = clXdrUnmarshallClVersionT(inMsgHdl,&version); if (CL_OK != rc) { return rc; } rc = clVersionVerify(&versionDatabase,&version); if (CL_OK != rc) { clXdrMarshallClVersionT(&version,outMsgHdl,0); return rc; } rc = clXdrUnmarshallClUint32T(inMsgHdl, &argc); if (CL_OK != rc) { return rc; } if (argc > MAX_ARGS) { DEBUG_CHECK("\r\n too many arguments"); goto L1; } for (i = 0; i < argc; i++) { ClUint32T stringLength = 0; argv[i] = &argBuf[i * (MAX_ARG_BUF_LEN+1)]; rc = clXdrUnmarshallClUint32T(inMsgHdl,&stringLength); if (CL_OK != rc) { return rc; } if (stringLength > MAX_ARG_BUF_LEN) { DEBUG_CHECK("\r\n argument too big"); goto L1; } rc = clXdrUnmarshallArrayClCharT(inMsgHdl,argv[i],stringLength); if (CL_OK != rc) { return rc; } argv[i][stringLength] = '\0'; } if (!strncasecmp(argv[0], "help", 4) && (argc > 1)) { argv[0] = argv[1]; argc = 0; } invokeCookie.pCommandName = argv[0]; invokeCookie.pFuncEntry = NULL; rc = clHandleWalk(pDebugObj->hDebugFnDB, clDebugFuncInvokeCallback, (void *) &invokeCookie); if( CL_DBG_INFO_CMD_FOUND == rc ) { /* this is the indication for command found */ rc = CL_OK; } if( CL_OK != rc ) { DEBUG_CHECK("\r\ncommand not found"); goto L1; } if (invokeCookie.pFuncEntry && invokeCookie.pFuncEntry->fpCallback) { deferContext.outMsgHdl = outMsgHdl; deferContext.defer = CL_FALSE; clOsalTaskDataSet(pDebugObj->debugTaskKey, (ClOsalTaskDataT)&deferContext); rc = invokeCookie.pFuncEntry->fpCallback(argc, argv, &resp); } else { DEBUG_CHECK("\r\ncommand not found"); } L1: retCode = rc; rc = CL_OK; if (!resp) { resp = clHeapAllocate(1); if (resp) resp[0]= '\0'; } if (NULL != resp) { /* * Marshall the response to the out buffer if we aren't deferred. */ if(!deferContext.defer) rc = clDebugResponseMarshall(resp, retCode, outMsgHdl); clHeapFree(resp); resp = NULL; } return rc; }
static void gms_exec_message_handler ( void *message, unsigned int nodeid) { mar_req_header_t header = {0}; struct VDECL(req_exec_gms_nodejoin) req_exec_gms_nodejoin = {{0}}; ClGmsViewNodeT *node = NULL; ClRcT rc = CL_OK; ClGmsClusterMemberT thisGmsClusterNode = {0}; char nodeIp[256 * INTERFACE_MAX] = ""; int isLocalMsg = 0; int verCode = 0; ClBufferHandleT bufferHandle = NULL; /* Get the ip address string for the given nodeId */ strncpy(nodeIp, get_node_ip(nodeid), (256 * INTERFACE_MAX)-1); if (strcmp(nodeIp, totemip_print(this_ip)) == 0) { isLocalMsg = 1; } /* Unmarshall the incoming message */ rc = clBufferCreate(&bufferHandle); if (rc != CL_OK) { clLogError(OPN,AIS, "Failed to create buffer while unmarshalling the received message. rc 0x%x",rc); return; } memcpy(&header, message, sizeof(mar_req_header_t)); rc = clBufferNBytesWrite(bufferHandle, (ClUint8T *)message+sizeof(mar_req_header_t), header.size-sizeof(mar_req_header_t)); if (rc != CL_OK) { clLogError(OPN,AIS, "Failed to retrieve data from buffer. rc 0x%x",rc); goto out_delete; } rc = unmarshallReqExecGmsNodeJoin(bufferHandle, &req_exec_gms_nodejoin); if (rc != CL_OK) { clLogError(OPN,AIS,"Failed to unmarshall the data. rc 0x%x",rc); goto out_delete; } verCode = CL_VERSION_CODE(req_exec_gms_nodejoin.version.releaseCode, req_exec_gms_nodejoin.version.majorVersion, req_exec_gms_nodejoin.version.minorVersion); clLog(DBG,OPN,AIS, "Received a %d message from version [%d.%d.%d].",req_exec_gms_nodejoin.gmsMessageType, req_exec_gms_nodejoin.version.releaseCode, req_exec_gms_nodejoin.version.majorVersion, req_exec_gms_nodejoin.version.minorVersion); /* Verify version */ if (verCode > CL_VERSION_CODE(curVer.releaseCode, curVer.majorVersion, curVer.minorVersion)) { /* I received a message from higher version and it dont know * how to decode it. So it discarding it. */ clLog(NOTICE,OPN,AIS, "Version mismatch detected. Discarding the message "); goto out_delete; } // message type & message data clLog(DBG,OPN,AIS,"message type %d from groupId %d!\n", req_exec_gms_nodejoin.gmsMessageType, req_exec_gms_nodejoin.gmsGroupId); /* This message is from same version. So processing it */ switch (req_exec_gms_nodejoin.gmsMessageType) { case CL_GMS_CLUSTER_JOIN_MSG: { ClUint32T minVersion = CL_VERSION_CODE(5, 0, 0); clLog(DBG,OPN,AIS, "Received multicast message for cluster join from ioc node [%#x:%#x]", req_exec_gms_nodejoin.specificMessage.gmsClusterNode.nodeAddress.iocPhyAddress.nodeAddress, req_exec_gms_nodejoin.specificMessage.gmsClusterNode.nodeAddress.iocPhyAddress.portId); clNodeCacheMinVersionGet(NULL, &minVersion); if(minVersion >= CL_VERSION_CODE(5, 0, 0) && gAspNativeLeaderElection) { clLog(DBG, OPN, AIS, "Skipping multicast join since node cache view is used to form the cluster ring"); goto out_delete; } node = (ClGmsViewNodeT *) clHeapAllocate(sizeof(ClGmsViewNodeT)); if (node == NULL) { clLog (ERROR,OPN,AIS, "clHeapAllocate failed"); goto out_delete; } else { rc = clVersionVerify( &(gmsGlobalInfo.config.versionsSupported), &(req_exec_gms_nodejoin.specificMessage.gmsClusterNode.gmsVersion) ); ringVersion.releaseCode = req_exec_gms_nodejoin.specificMessage.gmsClusterNode.gmsVersion.releaseCode; ringVersion.majorVersion= req_exec_gms_nodejoin.specificMessage.gmsClusterNode.gmsVersion.majorVersion; ringVersion.minorVersion= req_exec_gms_nodejoin.specificMessage.gmsClusterNode.gmsVersion.minorVersion; if(rc != CL_OK) { ringVersionCheckPassed = CL_FALSE; /* copy the ring version */ clGmsCsLeave( &joinCs ); clLog (ERROR,OPN,AIS, "Server Version Mismatch detected for this join message"); break; } _clGmsGetThisNodeInfo(&thisGmsClusterNode); if( thisGmsClusterNode.nodeId != req_exec_gms_nodejoin.specificMessage.gmsClusterNode.nodeId) { /* TODO This will never happen... */ clGmsCsLeave( &joinCs ); } node->viewMember.clusterMember = req_exec_gms_nodejoin.specificMessage.gmsClusterNode; /* If this is local join, then update the IP address */ if (thisGmsClusterNode.nodeId == req_exec_gms_nodejoin.specificMessage.gmsClusterNode.nodeId) { memcpy(&node->viewMember.clusterMember.nodeIpAddress, &myAddress, sizeof(ClGmsNodeAddressT)); } rc = _clGmsEngineClusterJoin(req_exec_gms_nodejoin.gmsGroupId, req_exec_gms_nodejoin.specificMessage.gmsClusterNode.nodeId, node); } } break; case CL_GMS_CLUSTER_EJECT_MSG: clLog (DBG,OPN,AIS, "Received cluster eject multicast message from ioc node [%#x:%#x]", req_exec_gms_nodejoin.specificMessage.gmsClusterNode.nodeAddress.iocPhyAddress.nodeAddress, req_exec_gms_nodejoin.specificMessage.gmsClusterNode.nodeAddress.iocPhyAddress.portId); /* inform the member about the eject by invoking the ejection * callback registered with the reason UKNOWN */ /* The below logic is same for the leave as well so we just * fall through the case */ _clGmsGetThisNodeInfo(&thisGmsClusterNode); if( req_exec_gms_nodejoin.specificMessage.gmsClusterNode.nodeId == thisGmsClusterNode.nodeId) { rc = _clGmsCallClusterMemberEjectCallBack( req_exec_gms_nodejoin.ejectReason); if( rc != CL_OK ) { clLog(ERROR,OPN,AIS,"_clGmsCallEjectCallBack failed with" "rc:0x%x",rc); } } case CL_GMS_CLUSTER_LEAVE_MSG: clLog(DBG,OPN,AIS, "Received cluster leave multicast message from ioc node [%#x:%#x]", req_exec_gms_nodejoin.specificMessage.gmsClusterNode.nodeAddress.iocPhyAddress.nodeAddress, req_exec_gms_nodejoin.specificMessage.gmsClusterNode.nodeAddress.iocPhyAddress.portId); rc = _clGmsEngineClusterLeave(req_exec_gms_nodejoin.gmsGroupId, req_exec_gms_nodejoin.specificMessage.gmsClusterNode.nodeId); break; case CL_GMS_GROUP_CREATE_MSG: clLog(DBG,OPN,AIS, "Received group create multicast message from ioc node [%#x:%#x]", req_exec_gms_nodejoin.specificMessage.groupMessage.gmsGroupNode.memberAddress.iocPhyAddress.nodeAddress, req_exec_gms_nodejoin.specificMessage.groupMessage.gmsGroupNode.memberAddress.iocPhyAddress.portId); rc = _clGmsEngineGroupCreate(req_exec_gms_nodejoin.specificMessage.groupMessage.groupData.groupName, req_exec_gms_nodejoin.specificMessage.groupMessage.groupData.groupParams, req_exec_gms_nodejoin.contextHandle, isLocalMsg); break; case CL_GMS_GROUP_DESTROY_MSG: clLog(DBG,OPN,AIS, "Received group destroy multicast message from ioc node [%#x:%#x]", req_exec_gms_nodejoin.specificMessage.groupMessage.gmsGroupNode.memberAddress.iocPhyAddress.nodeAddress, req_exec_gms_nodejoin.specificMessage.groupMessage.gmsGroupNode.memberAddress.iocPhyAddress.portId); rc = _clGmsEngineGroupDestroy(req_exec_gms_nodejoin.specificMessage.groupMessage.groupData.groupId, req_exec_gms_nodejoin.specificMessage.groupMessage.groupData.groupName, req_exec_gms_nodejoin.contextHandle, isLocalMsg); break; case CL_GMS_GROUP_JOIN_MSG: clLog(DBG,OPN,AIS, "Received group join multicast message from ioc node [%#x:%#x]", req_exec_gms_nodejoin.specificMessage.groupMessage.gmsGroupNode.memberAddress.iocPhyAddress.nodeAddress, req_exec_gms_nodejoin.specificMessage.groupMessage.gmsGroupNode.memberAddress.iocPhyAddress.portId); node = (ClGmsViewNodeT *) clHeapAllocate(sizeof(ClGmsViewNodeT)); if (!node) { log_printf (LOG_LEVEL_NOTICE, "clHeapAllocate failed"); goto out_delete; } else { /* FIXME: Need to verify version */ memcpy(&node->viewMember.groupMember,&req_exec_gms_nodejoin.specificMessage.groupMessage.gmsGroupNode, sizeof(ClGmsGroupMemberT)); memcpy(&node->viewMember.groupData, &req_exec_gms_nodejoin.specificMessage.groupMessage.groupData, sizeof(ClGmsGroupInfoT)); rc = _clGmsEngineGroupJoin(req_exec_gms_nodejoin.specificMessage.groupMessage.groupData.groupId, node, req_exec_gms_nodejoin.contextHandle, isLocalMsg); } break; case CL_GMS_GROUP_LEAVE_MSG: clLog(DBG,OPN,AIS, "Received group leave multicast message from ioc node [%#x:%#x]", req_exec_gms_nodejoin.specificMessage.groupMessage.gmsGroupNode.memberAddress.iocPhyAddress.nodeAddress, req_exec_gms_nodejoin.specificMessage.groupMessage.gmsGroupNode.memberAddress.iocPhyAddress.portId); rc = _clGmsEngineGroupLeave(req_exec_gms_nodejoin.specificMessage.groupMessage.groupData.groupId, req_exec_gms_nodejoin.specificMessage.groupMessage.gmsGroupNode.memberId, req_exec_gms_nodejoin.contextHandle, isLocalMsg); break; case CL_GMS_COMP_DEATH: clLog(DBG,OPN,AIS, "Received comp death multicast message"); rc = _clGmsRemoveMemberOnCompDeath(req_exec_gms_nodejoin.specificMessage.groupMessage.gmsGroupNode.memberId); break; case CL_GMS_LEADER_ELECT_MSG: clLog(DBG,OPN,AIS, "Received leader elect multicast message from ioc node [%#x:%#x]", req_exec_gms_nodejoin.specificMessage.gmsClusterNode.nodeAddress.iocPhyAddress.nodeAddress, req_exec_gms_nodejoin.specificMessage.gmsClusterNode.nodeAddress.iocPhyAddress.portId); rc = _clGmsEnginePreferredLeaderElect(req_exec_gms_nodejoin.specificMessage.gmsClusterNode, req_exec_gms_nodejoin.contextHandle, isLocalMsg); break; case CL_GMS_SYNC_MESSAGE: clLog(DBG,OPN,AIS, "Received gms synch multicast message"); rc = _clGmsEngineGroupInfoSync((ClGmsGroupSyncNotificationT *)(req_exec_gms_nodejoin.dataPtr)); clHeapFree(((ClGmsGroupSyncNotificationT *)req_exec_gms_nodejoin.dataPtr)->groupInfoList); clHeapFree(((ClGmsGroupSyncNotificationT *)req_exec_gms_nodejoin.dataPtr)->groupMemberList); clHeapFree(req_exec_gms_nodejoin.dataPtr); break; case CL_GMS_GROUP_MCAST_MSG: _clGmsEngineMcastMessageHandler( &(req_exec_gms_nodejoin.specificMessage.mcastMessage.groupInfo.gmsGroupNode), &(req_exec_gms_nodejoin.specificMessage.mcastMessage.groupInfo.groupData), req_exec_gms_nodejoin.specificMessage.mcastMessage.userDataSize, req_exec_gms_nodejoin.dataPtr); break; default: clLogMultiline(ERROR,OPN,AIS, "Openais GMS wrapper received Message wih invalid [MsgType=%x]. \n" "This could be because of multicast port clashes.", req_exec_gms_nodejoin.gmsMessageType); goto out_delete; } clLog(TRACE,OPN,AIS, "Processed the received message. Returning"); out_delete: clBufferDelete(&bufferHandle); }