SaAisErrorT saAmfProtectionGroupTrackStop ( SaAmfHandleT amfHandle, const SaNameT *csiName) { struct amfInstance *amfInstance; struct req_lib_amf_protectiongrouptrackstop req_lib_amf_protectiongrouptrackstop; struct res_lib_amf_protectiongrouptrackstop res_lib_amf_protectiongrouptrackstop; struct iovec iov; SaAisErrorT error; error = hdb_error_to_sa(hdb_handle_get (&amfHandleDatabase, amfHandle, (void *)&amfInstance)); if (error != SA_AIS_OK) { return (error); } req_lib_amf_protectiongrouptrackstop.header.size = sizeof (struct req_lib_amf_protectiongrouptrackstop); req_lib_amf_protectiongrouptrackstop.header.id = MESSAGE_REQ_AMF_PROTECTIONGROUPTRACKSTOP; memcpy (&req_lib_amf_protectiongrouptrackstop.csiName, csiName, sizeof (SaNameT)); iov.iov_base = (void *)&req_lib_amf_protectiongrouptrackstop, iov.iov_len = sizeof (struct req_lib_amf_protectiongrouptrackstop), error = coroipcc_msg_send_reply_receive (amfInstance->handle, &iov, 1, &res_lib_amf_protectiongrouptrackstop, sizeof (struct res_lib_amf_protectiongrouptrackstop)); hdb_handle_put (&amfHandleDatabase, amfHandle); return (error == SA_AIS_OK ? res_lib_amf_protectiongrouptrackstop.header.error : error); }
SaAisErrorT saAmfComponentErrorClear ( SaAmfHandleT amfHandle, const SaNameT *compName, SaNtfIdentifierT ntfIdentifier) { struct amfInstance *amfInstance; struct req_lib_amf_componenterrorclear req_lib_amf_componenterrorclear; struct res_lib_amf_componenterrorclear res_lib_amf_componenterrorclear; struct iovec iov; SaAisErrorT error; error = hdb_error_to_sa(hdb_handle_get (&amfHandleDatabase, amfHandle, (void *)&amfInstance)); if (error != SA_AIS_OK) { return (error); } req_lib_amf_componenterrorclear.header.id = MESSAGE_REQ_AMF_COMPONENTERRORCLEAR; req_lib_amf_componenterrorclear.header.size = sizeof (struct req_lib_amf_componenterrorclear); memcpy (&req_lib_amf_componenterrorclear.compName, compName, sizeof (SaNameT)); iov.iov_base = (void *)&req_lib_amf_componenterrorclear; iov.iov_len = sizeof (struct req_lib_amf_componenterrorclear); error = coroipcc_msg_send_reply_receive (amfInstance->handle, &iov, 1, &res_lib_amf_componenterrorclear, sizeof (struct res_lib_amf_componenterrorclear)); hdb_handle_put (&amfHandleDatabase, amfHandle); return (error == SA_AIS_OK ? res_lib_amf_componenterrorclear.header.error : error); }
gboolean get_ais_nodeid(uint32_t * id, char **uname) { struct iovec iov; int retries = 0; int rc = CS_OK; cs_ipc_header_response_t header; struct crm_ais_nodeid_resp_s answer; header.error = CS_OK; header.id = crm_class_nodeid; header.size = sizeof(cs_ipc_header_response_t); CRM_CHECK(id != NULL, return FALSE); CRM_CHECK(uname != NULL, return FALSE); iov.iov_base = &header; iov.iov_len = header.size; retry: errno = 0; rc = coroipcc_msg_send_reply_receive(ais_ipc_handle, &iov, 1, &answer, sizeof(answer)); if (rc == CS_OK) { CRM_CHECK(answer.header.size == sizeof(struct crm_ais_nodeid_resp_s), crm_err("Odd message: id=%d, size=%d, error=%d", answer.header.id, answer.header.size, answer.header.error)); CRM_CHECK(answer.header.id == crm_class_nodeid, crm_err("Bad response id: %d", answer.header.id)); } if ((rc == CS_ERR_TRY_AGAIN || rc == CS_ERR_QUEUE_FULL) && retries < 20) { retries++; crm_info("Peer overloaded: Re-sending message (Attempt %d of 20)", retries); sleep(retries); /* Proportional back off */ goto retry; } if (rc != CS_OK) { crm_err("Sending nodeid request: FAILED (rc=%d): %s", rc, ais_error2text(rc)); return FALSE; } else if (answer.header.error != CS_OK) { crm_err("Bad response from peer: (rc=%d): %s", rc, ais_error2text(rc)); return FALSE; } crm_info("Server details: id=%u uname=%s cname=%s", answer.id, answer.uname, answer.cname); *id = answer.id; *uname = strdup(answer.uname); ais_cluster_name = strdup(answer.cname); return TRUE; }
evs_error_t evs_membership_get ( evs_handle_t handle, unsigned int *local_nodeid, unsigned int *member_list, size_t *member_list_entries) { evs_error_t error; struct evs_inst *evs_inst; struct iovec iov; struct req_lib_evs_membership_get req_lib_evs_membership_get; struct res_lib_evs_membership_get res_lib_evs_membership_get; error = hdb_error_to_cs(hdb_handle_get (&evs_handle_t_db, handle, (void *)&evs_inst)); if (error != CS_OK) { return (error); } req_lib_evs_membership_get.header.size = sizeof (struct req_lib_evs_membership_get); req_lib_evs_membership_get.header.id = MESSAGE_REQ_EVS_MEMBERSHIP_GET; iov.iov_base = (void *)&req_lib_evs_membership_get; iov.iov_len = sizeof (struct req_lib_evs_membership_get); error = coroipcc_msg_send_reply_receive (evs_inst->handle, &iov, 1, &res_lib_evs_membership_get, sizeof (struct res_lib_evs_membership_get)); if (error != CS_OK) { goto error_exit; } error = res_lib_evs_membership_get.header.error; /* * Copy results to caller */ if (local_nodeid) { *local_nodeid = res_lib_evs_membership_get.local_nodeid; } *member_list_entries = MIN (*member_list_entries, res_lib_evs_membership_get.member_list_entries); if (member_list) { memcpy (member_list, &res_lib_evs_membership_get.member_list, *member_list_entries * sizeof (struct in_addr)); } error_exit: hdb_handle_put (&evs_handle_t_db, handle); return (error); }
evs_error_t evs_mcast_groups ( evs_handle_t handle, evs_guarantee_t guarantee, const struct evs_group *groups, size_t group_entries, const struct iovec *iovec, unsigned int iov_len) { int i; evs_error_t error; struct evs_inst *evs_inst; struct iovec iov[64]; /* FIXME: what if iov_len > 62 ? use malloc */ struct req_lib_evs_mcast_groups req_lib_evs_mcast_groups; struct res_lib_evs_mcast_groups res_lib_evs_mcast_groups; size_t msg_len = 0; error = hdb_error_to_cs(hdb_handle_get (&evs_handle_t_db, handle, (void *)&evs_inst)); if (error != CS_OK) { return (error); } for (i = 0; i < iov_len; i++) { msg_len += iovec[i].iov_len; } req_lib_evs_mcast_groups.header.size = sizeof (struct req_lib_evs_mcast_groups) + (group_entries * sizeof (struct evs_group)) + msg_len; req_lib_evs_mcast_groups.header.id = MESSAGE_REQ_EVS_MCAST_GROUPS; req_lib_evs_mcast_groups.guarantee = guarantee; req_lib_evs_mcast_groups.msg_len = msg_len; req_lib_evs_mcast_groups.group_entries = group_entries; iov[0].iov_base = (void *)&req_lib_evs_mcast_groups; iov[0].iov_len = sizeof (struct req_lib_evs_mcast_groups); iov[1].iov_base = (void *) groups; /* cast away const */ iov[1].iov_len = (group_entries * sizeof (struct evs_group)); memcpy (&iov[2], iovec, iov_len * sizeof (struct iovec)); error = coroipcc_msg_send_reply_receive (evs_inst->handle, iov, iov_len + 2, &res_lib_evs_mcast_groups, sizeof (struct res_lib_evs_mcast_groups)); if (error != CS_OK) { goto error_exit; } error = res_lib_evs_mcast_groups.header.error; error_exit: hdb_handle_put (&evs_handle_t_db, handle); return (error); }
evs_error_t evs_mcast_joined ( evs_handle_t handle, evs_guarantee_t guarantee, const struct iovec *iovec, unsigned int iov_len) { int i; evs_error_t error; struct evs_inst *evs_inst; struct iovec iov[64]; struct req_lib_evs_mcast_joined req_lib_evs_mcast_joined; struct res_lib_evs_mcast_joined res_lib_evs_mcast_joined; size_t msg_len = 0; error = hdb_error_to_cs(hdb_handle_get (&evs_handle_t_db, handle, (void *)&evs_inst)); if (error != CS_OK) { return (error); } for (i = 0; i < iov_len; i++ ) { msg_len += iovec[i].iov_len; } req_lib_evs_mcast_joined.header.size = sizeof (struct req_lib_evs_mcast_joined) + msg_len; req_lib_evs_mcast_joined.header.id = MESSAGE_REQ_EVS_MCAST_JOINED; req_lib_evs_mcast_joined.guarantee = guarantee; req_lib_evs_mcast_joined.msg_len = msg_len; iov[0].iov_base = (void *)&req_lib_evs_mcast_joined; iov[0].iov_len = sizeof (struct req_lib_evs_mcast_joined); memcpy (&iov[1], iovec, iov_len * sizeof (struct iovec)); error = coroipcc_msg_send_reply_receive (evs_inst->handle, iov, iov_len + 1, &res_lib_evs_mcast_joined, sizeof (struct res_lib_evs_mcast_joined)); if (error != CS_OK) { goto error_exit; } error = res_lib_evs_mcast_joined.header.error; error_exit: hdb_handle_put (&evs_handle_t_db, handle); return (error); }
cs_error_t coroipcc_zcb_alloc ( hdb_handle_t handle, void **buffer, size_t size, size_t header_size) { struct ipc_instance *ipc_instance; void *buf = NULL; char path[PATH_MAX]; unsigned int res; mar_req_coroipcc_zc_alloc_t req_coroipcc_zc_alloc; coroipc_response_header_t res_coroipcs_zc_alloc; size_t map_size; struct iovec iovec; struct coroipcs_zc_header *hdr; res = hdb_error_to_cs (hdb_handle_get (&ipc_hdb, handle, (void **)&ipc_instance)); if (res != CS_OK) { return (res); } map_size = size + header_size + sizeof (struct coroipcs_zc_header); res = memory_map (path, "corosync_zerocopy-XXXXXX", &buf, map_size); assert (res != -1); req_coroipcc_zc_alloc.header.size = sizeof (mar_req_coroipcc_zc_alloc_t); req_coroipcc_zc_alloc.header.id = ZC_ALLOC_HEADER; req_coroipcc_zc_alloc.map_size = map_size; strcpy (req_coroipcc_zc_alloc.path_to_file, path); iovec.iov_base = (void *)&req_coroipcc_zc_alloc; iovec.iov_len = sizeof (mar_req_coroipcc_zc_alloc_t); res = coroipcc_msg_send_reply_receive ( handle, &iovec, 1, &res_coroipcs_zc_alloc, sizeof (coroipc_response_header_t)); hdr = (struct coroipcs_zc_header *)buf; hdr->map_size = map_size; *buffer = ((char *)buf) + sizeof (struct coroipcs_zc_header); hdb_handle_put (&ipc_hdb, handle); return (res); }
SaAisErrorT saAmfComponentRegister ( SaAmfHandleT amfHandle, const SaNameT *compName, const SaNameT *proxyCompName) { struct amfInstance *amfInstance; SaAisErrorT error; struct req_lib_amf_componentregister req_lib_amf_componentregister; struct res_lib_amf_componentregister res_lib_amf_componentregister; struct iovec iov; error = hdb_error_to_sa(hdb_handle_get (&amfHandleDatabase, amfHandle, (void *)&amfInstance)); if (error != SA_AIS_OK) { return (error); } req_lib_amf_componentregister.header.size = sizeof (struct req_lib_amf_componentregister); req_lib_amf_componentregister.header.id = MESSAGE_REQ_AMF_COMPONENTREGISTER; memcpy (&req_lib_amf_componentregister.compName, compName, sizeof (SaNameT)); if (proxyCompName) { memcpy (&req_lib_amf_componentregister.proxyCompName, proxyCompName, sizeof (SaNameT)); } else { memset (&req_lib_amf_componentregister.proxyCompName, 0, sizeof (SaNameT)); } iov.iov_base = (void *)&req_lib_amf_componentregister; iov.iov_len = sizeof (struct req_lib_amf_componentregister); error = coroipcc_msg_send_reply_receive (amfInstance->handle, &iov, 1, &res_lib_amf_componentregister, sizeof (struct res_lib_amf_componentregister)); hdb_handle_put (&amfHandleDatabase, amfHandle); if (res_lib_amf_componentregister.header.error == SA_AIS_OK) { amfInstance->compRegistered = 1; memcpy (&amfInstance->compName, compName, sizeof (SaNameT)); } return (error == SA_AIS_OK ? res_lib_amf_componentregister.header.error : error); }
SaAisErrorT saAmfComponentErrorReport ( SaAmfHandleT amfHandle, const SaNameT *erroneousComponent, SaTimeT errorDetectionTime, SaAmfRecommendedRecoveryT recommendedRecovery, SaNtfIdentifierT ntfIdentifier) { struct amfInstance *amfInstance; struct req_lib_amf_componenterrorreport req_lib_amf_componenterrorreport; struct res_lib_amf_componenterrorreport res_lib_amf_componenterrorreport; struct iovec iov; SaAisErrorT error; error = hdb_error_to_sa(hdb_handle_get (&amfHandleDatabase, amfHandle, (void *)&amfInstance)); if (error != SA_AIS_OK) { return (error); } req_lib_amf_componenterrorreport.header.id = MESSAGE_REQ_AMF_COMPONENTERRORREPORT; req_lib_amf_componenterrorreport.header.size = sizeof (struct req_lib_amf_componenterrorreport); memcpy (&req_lib_amf_componenterrorreport.erroneousComponent, erroneousComponent, sizeof (SaNameT)); req_lib_amf_componenterrorreport.errorDetectionTime = errorDetectionTime; req_lib_amf_componenterrorreport.recommendedRecovery = recommendedRecovery; iov.iov_base = (void *)&req_lib_amf_componenterrorreport; iov.iov_len = sizeof (struct req_lib_amf_componenterrorreport); error = coroipcc_msg_send_reply_receive (amfInstance->handle, &iov, 1, &res_lib_amf_componenterrorreport, sizeof (struct res_lib_amf_componenterrorreport)); error = res_lib_amf_componenterrorreport.header.error; hdb_handle_put (&amfHandleDatabase, amfHandle); return (error == SA_AIS_OK ? res_lib_amf_componenterrorreport.header.error : error); }
SaAisErrorT saAmfPmStart ( SaAmfHandleT amfHandle, const SaNameT *compName, SaUint64T processId, SaInt32T descendentsTreeDepth, SaAmfPmErrorsT pmErrors, SaAmfRecommendedRecoveryT recommendedRecovery) { struct req_lib_amf_pmstart req_lib_amf_pmstart; struct res_lib_amf_pmstart res_lib_amf_pmstart; struct amfInstance *amfInstance; SaAisErrorT error; struct iovec iov; error = hdb_error_to_sa(hdb_handle_get (&amfHandleDatabase, amfHandle, (void *)&amfInstance)); if (error != SA_AIS_OK) { return (error); } req_lib_amf_pmstart.header.size = sizeof (struct req_lib_amf_pmstart); req_lib_amf_pmstart.header.id = MESSAGE_REQ_AMF_PMSTART; memcpy (&req_lib_amf_pmstart.compName, compName, sizeof (SaNameT)); req_lib_amf_pmstart.processId = processId; req_lib_amf_pmstart.descendentsTreeDepth = descendentsTreeDepth; req_lib_amf_pmstart.pmErrors = pmErrors; req_lib_amf_pmstart.recommendedRecovery = recommendedRecovery; iov.iov_base = (void *)&req_lib_amf_pmstart; iov.iov_len = sizeof (struct req_lib_amf_pmstart); error = coroipcc_msg_send_reply_receive (amfInstance->handle, &iov, 1, &res_lib_amf_pmstart, sizeof (struct res_lib_amf_pmstart)); hdb_handle_put (&amfHandleDatabase, amfHandle); return (error == SA_AIS_OK ? res_lib_amf_pmstart.header.error : error); }
SaAisErrorT saAmfHealthcheckStart ( SaAmfHandleT amfHandle, const SaNameT *compName, const SaAmfHealthcheckKeyT *healthcheckKey, SaAmfHealthcheckInvocationT invocationType, SaAmfRecommendedRecoveryT recommendedRecovery) { struct req_lib_amf_healthcheckstart req_lib_amf_healthcheckstart; struct res_lib_amf_healthcheckstart res_lib_amf_healthcheckstart; struct amfInstance *amfInstance; SaAisErrorT error; struct iovec iov; error = hdb_error_to_sa(hdb_handle_get (&amfHandleDatabase, amfHandle, (void *)&amfInstance)); if (error != SA_AIS_OK) { return (error); } req_lib_amf_healthcheckstart.header.size = sizeof (struct req_lib_amf_healthcheckstart); req_lib_amf_healthcheckstart.header.id = MESSAGE_REQ_AMF_HEALTHCHECKSTART; memcpy (&req_lib_amf_healthcheckstart.compName, compName, sizeof (SaNameT)); memcpy (&req_lib_amf_healthcheckstart.healthcheckKey, healthcheckKey, sizeof (SaAmfHealthcheckKeyT)); req_lib_amf_healthcheckstart.invocationType = invocationType; req_lib_amf_healthcheckstart.recommendedRecovery = recommendedRecovery; iov.iov_base = (void *)&req_lib_amf_healthcheckstart; iov.iov_len = sizeof (struct req_lib_amf_healthcheckstart); error = coroipcc_msg_send_reply_receive (amfInstance->handle, &iov, 1, &res_lib_amf_healthcheckstart, sizeof (struct res_lib_amf_healthcheckstart)); hdb_handle_put (&amfHandleDatabase, amfHandle); return (error == SA_AIS_OK ? res_lib_amf_healthcheckstart.header.error : error); }
SaAisErrorT saAmfHAStateGet ( SaAmfHandleT amfHandle, const SaNameT *compName, const SaNameT *csiName, SaAmfHAStateT *haState) { struct amfInstance *amfInstance; struct req_lib_amf_hastateget req_lib_amf_hastateget; struct res_lib_amf_hastateget res_lib_amf_hastateget; struct iovec iov; SaAisErrorT error; error = hdb_error_to_sa(hdb_handle_get (&amfHandleDatabase, amfHandle, (void *)&amfInstance)); if (error != SA_AIS_OK) { return (error); } iov.iov_base = (void *)&req_lib_amf_hastateget, iov.iov_len = sizeof (struct req_lib_amf_hastateget), req_lib_amf_hastateget.header.id = MESSAGE_REQ_AMF_HASTATEGET; req_lib_amf_hastateget.header.size = sizeof (struct req_lib_amf_hastateget); memcpy (&req_lib_amf_hastateget.compName, compName, sizeof (SaNameT)); memcpy (&req_lib_amf_hastateget.csiName, csiName, sizeof (SaNameT)); error = coroipcc_msg_send_reply_receive (amfInstance->handle, &iov, 1, &res_lib_amf_hastateget, sizeof (struct res_lib_amf_hastateget)); hdb_handle_put (&amfHandleDatabase, amfHandle); if (res_lib_amf_hastateget.header.error == SA_AIS_OK) { memcpy (haState, &res_lib_amf_hastateget.haState, sizeof (SaAmfHAStateT)); } return (error == SA_AIS_OK ? res_lib_amf_hastateget.header.error : error); }
SaAisErrorT saAmfPmStop ( SaAmfHandleT amfHandle, const SaNameT *compName, SaAmfPmStopQualifierT stopQualifier, SaInt64T processId, SaAmfPmErrorsT pmErrors) { struct req_lib_amf_pmstop req_lib_amf_pmstop; struct res_lib_amf_pmstop res_lib_amf_pmstop; struct amfInstance *amfInstance; SaAisErrorT error; struct iovec iov; error = hdb_error_to_sa(hdb_handle_get (&amfHandleDatabase, amfHandle, (void *)&amfInstance)); if (error != SA_AIS_OK) { return (error); } req_lib_amf_pmstop.header.size = sizeof (struct req_lib_amf_pmstop); req_lib_amf_pmstop.header.id = MESSAGE_REQ_AMF_PMSTOP; memcpy (&req_lib_amf_pmstop.compName, compName, sizeof (SaNameT)); req_lib_amf_pmstop.stopQualifier = stopQualifier; req_lib_amf_pmstop.processId = processId; req_lib_amf_pmstop.pmErrors = pmErrors; iov.iov_base = (void *)&req_lib_amf_pmstop; iov.iov_len = sizeof (struct req_lib_amf_pmstop); error = coroipcc_msg_send_reply_receive (amfInstance->handle, &iov, 1, &res_lib_amf_pmstop, sizeof (struct res_lib_amf_pmstop)); hdb_handle_put (&amfHandleDatabase, amfHandle); return (error == SA_AIS_OK ? res_lib_amf_pmstop.header.error : error); return (SA_AIS_OK); }
evs_error_t evs_leave ( evs_handle_t handle, const struct evs_group *groups, size_t group_entries) { evs_error_t error; struct evs_inst *evs_inst; struct iovec iov[2]; struct req_lib_evs_leave req_lib_evs_leave; struct res_lib_evs_leave res_lib_evs_leave; error = hdb_error_to_cs(hdb_handle_get (&evs_handle_t_db, handle, (void *)&evs_inst)); if (error != CS_OK) { return (error); } req_lib_evs_leave.header.size = sizeof (struct req_lib_evs_leave) + (group_entries * sizeof (struct evs_group)); req_lib_evs_leave.header.id = MESSAGE_REQ_EVS_LEAVE; req_lib_evs_leave.group_entries = group_entries; iov[0].iov_base = (void *)&req_lib_evs_leave; iov[0].iov_len = sizeof (struct req_lib_evs_leave); iov[1].iov_base = (void *) groups; /* cast away const */ iov[1].iov_len = (group_entries * sizeof (struct evs_group)); error = coroipcc_msg_send_reply_receive (evs_inst->handle, iov, 2, &res_lib_evs_leave, sizeof (struct res_lib_evs_leave)); if (error != CS_OK) { goto error_exit; } error = res_lib_evs_leave.header.error; error_exit: hdb_handle_put (&evs_handle_t_db, handle); return (error); }
SaAisErrorT saAmfHealthcheckConfirm ( SaAmfHandleT amfHandle, const SaNameT *compName, const SaAmfHealthcheckKeyT *healthcheckKey, SaAisErrorT healthcheckResult) { struct req_lib_amf_healthcheckconfirm req_lib_amf_healthcheckconfirm; struct res_lib_amf_healthcheckconfirm res_lib_amf_healthcheckconfirm; struct amfInstance *amfInstance; SaAisErrorT error; struct iovec iov; error = hdb_error_to_sa(hdb_handle_get (&amfHandleDatabase, amfHandle, (void *)&amfInstance)); if (error != SA_AIS_OK) { return (error); } req_lib_amf_healthcheckconfirm.header.size = sizeof (struct req_lib_amf_healthcheckconfirm); req_lib_amf_healthcheckconfirm.header.id = MESSAGE_REQ_AMF_HEALTHCHECKCONFIRM; memcpy (&req_lib_amf_healthcheckconfirm.compName, compName, sizeof (SaNameT)); memcpy (&req_lib_amf_healthcheckconfirm.healthcheckKey, healthcheckKey, sizeof (SaAmfHealthcheckKeyT)); req_lib_amf_healthcheckconfirm.healthcheckResult = healthcheckResult; iov.iov_base = (void *)&req_lib_amf_healthcheckconfirm; iov.iov_len = sizeof (struct req_lib_amf_healthcheckconfirm); error = coroipcc_msg_send_reply_receive (amfInstance->handle, &iov, 1, &res_lib_amf_healthcheckconfirm, sizeof (struct res_lib_amf_healthcheckconfirm)); hdb_handle_put (&amfHandleDatabase, amfHandle); return (error == SA_AIS_OK ? res_lib_amf_healthcheckconfirm.header.error : error); }
SaAisErrorT saAmfProtectionGroupTrack ( SaAmfHandleT amfHandle, const SaNameT *csiName, SaUint8T trackFlags, SaAmfProtectionGroupNotificationBufferT *notificationBuffer) { struct amfInstance *amfInstance; struct req_lib_amf_protectiongrouptrack req_lib_amf_protectiongrouptrack; struct res_lib_amf_protectiongrouptrack res_lib_amf_protectiongrouptrack; struct iovec iov; SaAisErrorT error; req_lib_amf_protectiongrouptrack.header.size = sizeof (struct req_lib_amf_protectiongrouptrack); req_lib_amf_protectiongrouptrack.header.id = MESSAGE_REQ_AMF_PROTECTIONGROUPTRACK; memcpy (&req_lib_amf_protectiongrouptrack.csiName, csiName, sizeof (SaNameT)); req_lib_amf_protectiongrouptrack.trackFlags = trackFlags; req_lib_amf_protectiongrouptrack.notificationBufferAddress = (SaAmfProtectionGroupNotificationBufferT *)notificationBuffer; error = hdb_error_to_sa(hdb_handle_get (&amfHandleDatabase, amfHandle, (void *)&amfInstance)); if (error != SA_AIS_OK) { return (error); } iov.iov_base = (void *)&req_lib_amf_protectiongrouptrack; iov.iov_len = sizeof (struct req_lib_amf_protectiongrouptrack); error = coroipcc_msg_send_reply_receive (amfInstance->handle, &iov, 1, &res_lib_amf_protectiongrouptrack, sizeof (struct res_lib_amf_protectiongrouptrack)); hdb_handle_put (&amfHandleDatabase, amfHandle); return (error == SA_AIS_OK ? res_lib_amf_protectiongrouptrack.header.error : error); }
cs_error_t coroipcc_zcb_free ( hdb_handle_t handle, void *buffer) { struct ipc_instance *ipc_instance; mar_req_coroipcc_zc_free_t req_coroipcc_zc_free; coroipc_response_header_t res_coroipcs_zc_free; struct iovec iovec; unsigned int res; struct coroipcs_zc_header *header = (struct coroipcs_zc_header *)((char *)buffer - sizeof (struct coroipcs_zc_header)); res = hdb_error_to_cs (hdb_handle_get (&ipc_hdb, handle, (void **)&ipc_instance)); if (res != CS_OK) { return (res); } req_coroipcc_zc_free.header.size = sizeof (mar_req_coroipcc_zc_free_t); req_coroipcc_zc_free.header.id = ZC_FREE_HEADER; req_coroipcc_zc_free.map_size = header->map_size; req_coroipcc_zc_free.server_address = header->server_address; iovec.iov_base = (void *)&req_coroipcc_zc_free; iovec.iov_len = sizeof (mar_req_coroipcc_zc_free_t); res = coroipcc_msg_send_reply_receive ( handle, &iovec, 1, &res_coroipcs_zc_free, sizeof (coroipc_response_header_t)); munmap ((void *)header, header->map_size); hdb_handle_put (&ipc_hdb, handle); return (res); }
SaAisErrorT saAmfResponse ( SaAmfHandleT amfHandle, SaInvocationT invocation, SaAisErrorT error) { struct amfInstance *amfInstance; struct req_lib_amf_response req_lib_amf_response; struct res_lib_amf_response res_lib_amf_response; struct iovec iov; SaAisErrorT errorResult; errorResult = hdb_error_to_sa(hdb_handle_get (&amfHandleDatabase, amfHandle, (void *)&amfInstance)); if (errorResult != SA_AIS_OK) { return (errorResult); } req_lib_amf_response.header.id = MESSAGE_REQ_AMF_RESPONSE; req_lib_amf_response.header.size = sizeof (struct req_lib_amf_response); req_lib_amf_response.invocation = invocation; req_lib_amf_response.error = error; iov.iov_base = (void *)&req_lib_amf_response; iov.iov_len = sizeof (struct req_lib_amf_response); errorResult = coroipcc_msg_send_reply_receive ( amfInstance->handle, &iov, 1, &res_lib_amf_response, sizeof (struct res_lib_amf_response)); hdb_handle_put (&amfHandleDatabase, amfHandle); return (errorResult == SA_AIS_OK ? res_lib_amf_response.header.error : errorResult); }
cs_error_t coroipcc_zcb_msg_send_reply_receive ( hdb_handle_t handle, void *msg, void *res_msg, size_t res_len) { struct ipc_instance *ipc_instance; mar_req_coroipcc_zc_execute_t req_coroipcc_zc_execute; struct coroipcs_zc_header *hdr; struct iovec iovec; cs_error_t res; res = hdb_error_to_cs (hdb_handle_get (&ipc_hdb, handle, (void **)&ipc_instance)); if (res != CS_OK) { return (res); } hdr = (struct coroipcs_zc_header *)(((char *)msg) - sizeof (struct coroipcs_zc_header)); req_coroipcc_zc_execute.header.size = sizeof (mar_req_coroipcc_zc_execute_t); req_coroipcc_zc_execute.header.id = ZC_EXECUTE_HEADER; req_coroipcc_zc_execute.server_address = hdr->server_address; iovec.iov_base = (void *)&req_coroipcc_zc_execute; iovec.iov_len = sizeof (mar_req_coroipcc_zc_execute_t); res = coroipcc_msg_send_reply_receive ( handle, &iovec, 1, res_msg, res_len); hdb_handle_put (&ipc_hdb, handle); return (res); }
SaAisErrorT saAmfCSIQuiescingComplete ( SaAmfHandleT amfHandle, SaInvocationT invocation, SaAisErrorT error) { struct req_lib_amf_csiquiescingcomplete req_lib_amf_csiquiescingcomplete; struct res_lib_amf_csiquiescingcomplete res_lib_amf_csiquiescingcomplete; struct amfInstance *amfInstance; struct iovec iov; SaAisErrorT errorResult; error = hdb_error_to_sa(hdb_handle_get (&amfHandleDatabase, amfHandle, (void *)&amfInstance)); if (error != SA_AIS_OK) { return (error); } req_lib_amf_csiquiescingcomplete.header.size = sizeof (struct req_lib_amf_csiquiescingcomplete); req_lib_amf_csiquiescingcomplete.header.id = MESSAGE_REQ_AMF_CSIQUIESCINGCOMPLETE; req_lib_amf_csiquiescingcomplete.invocation = invocation; req_lib_amf_csiquiescingcomplete.error = error; iov.iov_base = (void *)&req_lib_amf_csiquiescingcomplete; iov.iov_len = sizeof (struct req_lib_amf_csiquiescingcomplete); errorResult = coroipcc_msg_send_reply_receive (amfInstance->handle, &iov, 1, &res_lib_amf_csiquiescingcomplete, sizeof (struct res_lib_amf_csiquiescingcomplete)); hdb_handle_put (&amfHandleDatabase, amfHandle); return (errorResult == SA_AIS_OK ? res_lib_amf_csiquiescingcomplete.header.error : errorResult); }