/****************************************************************************
* Function Name: dts_ipaddr_decode
* Purpose: Decodes the IP address.
*****************************************************************************/
uns32 decode_ip_address(NCS_UBAID *uba, NCS_IP_ADDR *ipa)
{
uns8 *data = NULL;
uns8 data_buff[sizeof(NCS_IP_ADDR)];
data = ncs_dec_flatten_space(uba, data_buff, sizeof(uns8));
if (data == NULL) {
return m_DTS_DBG_SINK(NCSCC_RC_FAILURE, "decode_ip_address: Decode flatten space failed");
}
ipa->type = ncs_decode_8bit(&data);
ncs_dec_skip_space(uba, sizeof(uns8));
if (ipa->type == NCS_IP_ADDR_TYPE_IPV4) {
data = ncs_dec_flatten_space(uba, data_buff, sizeof(uns32));
ipa->info.v4 = ncs_decode_32bit(&data);
ncs_dec_skip_space(uba, sizeof(uns32));
}
#if (NCS_IPV6 == 1)
else if (ipa->type == NCS_IP_ADDR_TYPE_IPV6) {
data = ncs_dec_flatten_space(uba, data_buff, NCS_IPV6_ADDR_UNS8_CNT);
if (data == NULL) {
return m_DTS_DBG_SINK(NCSCC_RC_FAILURE, "decode_ip_address: Decode flatten space failed");
}
memcpy((uns8 *)&ipa->info.v6, data, NCS_IPV6_ADDR_UNS8_CNT);
ncs_dec_skip_space(uba, NCS_IPV6_ADDR_UNS8_CNT);
}
#endif
else {
return NCSCC_RC_FAILURE;
}
return NCSCC_RC_SUCCESS;
}
/****************************************************************************
Name : eda_dec_chan_open_cbk_msg
Description : This routine decodes a channel open callback message
Arguments : NCS_UBAID *msg,
EDSV_MSG *msg
Return Values : uint32_t
Notes : None.
******************************************************************************/
static uint32_t eda_dec_chan_open_cbk_msg(NCS_UBAID *uba, EDSV_MSG *msg)
{
uint8_t *p8;
int32_t total_bytes = 0;
EDSV_EDA_CHAN_OPEN_CBK_PARAM *param = &msg->info.cbk_info.param.chan_open_cbk;
uint8_t local_data[256];
if (uba == NULL) {
TRACE_4("uba is NULL");
return 0;
}
/* chan_name_len */
p8 = ncs_dec_flatten_space(uba, local_data, 2);
param->chan_name.length = ncs_decode_16bit(&p8);
ncs_dec_skip_space(uba, 2);
total_bytes += 2;
/* chan_name */
ncs_decode_n_octets_from_uba(uba, param->chan_name.value, (uint32_t)param->chan_name.length);
total_bytes += (uint32_t)param->chan_name.length;
/* chan_id, chan_open_id, chan_open_flags, eda_chan_hdl, error */
p8 = ncs_dec_flatten_space(uba, local_data, 17);
param->chan_id = ncs_decode_32bit(&p8);
param->chan_open_id = ncs_decode_32bit(&p8);
param->chan_open_flags = ncs_decode_8bit(&p8);
param->eda_chan_hdl = ncs_decode_32bit(&p8);
param->error = ncs_decode_32bit(&p8);
ncs_dec_skip_space(uba, 17);
total_bytes += 17;
return total_bytes;
}
/************************************************************************************
* Name :glsv_gld_mbcsv_dec_sync_resp
*
* Description : Decode the message at Standby for cold sync and update the database
* Arguments : NCS_MBCSV_CB_ARG - MBCSv callback argument
*
* Return Values : Success / Error
*************************************************************************************/
static uint32_t glsv_gld_mbcsv_dec_sync_resp(GLSV_GLD_CB *gld_cb, NCS_MBCSV_CB_ARG *arg)
{
uint8_t *ptr, num_of_ckpts, data[16];
GLSV_GLD_A2S_RSC_DETAILS *rsc_info;
uint32_t count = 0, rc = NCSCC_RC_SUCCESS, num_of_async_upd;
EDU_ERR ederror = 0;
GLSV_A2S_NODE_LIST *node_list, *tmp1_node_list;
TRACE_ENTER();
if (arg->info.decode.i_uba.ub == NULL) { /* There is no data */
goto end;
}
/* Allocate memory */
rsc_info = m_MMGR_ALLOC_GLSV_GLD_A2S_RSC_DETAILS;
if (rsc_info == NULL) {
LOG_CR("Rsc info alloc failed: Error %s", strerror(errno));
assert(0);
}
memset(rsc_info, 0, sizeof(GLSV_GLD_A2S_RSC_DETAILS));
/* 1. Decode the 1st uint8_t region , we will get the num of ckpts */
ptr = ncs_dec_flatten_space(&arg->info.decode.i_uba, data, sizeof(uint8_t));
num_of_ckpts = ncs_decode_8bit(&ptr);
ncs_dec_skip_space(&arg->info.decode.i_uba, sizeof(uint8_t));
/* Decode the data */
while (count < num_of_ckpts) {
rc = m_NCS_EDU_EXEC(&gld_cb->edu_hdl, glsv_edp_gld_evt_a2s_rsc_details, &arg->info.decode.i_uba,
EDP_OP_TYPE_DEC, &rsc_info, &ederror);
if (rc != NCSCC_RC_SUCCESS) {
goto end;
}
rc = gld_sb_proc_data_rsp(gld_cb, rsc_info);
count++;
memset(rsc_info, 0, sizeof(GLSV_GLD_A2S_RSC_DETAILS));
}
/* Get the async update count */
ptr = ncs_dec_flatten_space(&arg->info.decode.i_uba, data, sizeof(uint32_t));
num_of_async_upd = ncs_decode_32bit(&ptr);
gld_cb->gld_async_cnt = num_of_async_upd;
/* New code */
node_list = rsc_info->node_list;
while (node_list != NULL) {
tmp1_node_list = node_list;
node_list = node_list->next;
m_MMGR_FREE_GLSV_NODE_LIST(tmp1_node_list);
}
m_MMGR_FREE_GLSV_GLD_A2S_RSC_DETAILS(rsc_info);
end:
TRACE_LEAVE();
return rc;
}
/***************************************************************************
* Name : fm_fm_mds_dec
*
* Description : To decode GFM related messages
*
* Arguments : Ptr to the MDS callback info struct MDS_CALLBACK_DEC_INFO
*
* Return Values : NCSCC_RC_FAILURE/NCSCC_RC_SUCCESS
*
* Notes : None.
***************************************************************************/
static uint32_t fm_fm_mds_dec(MDS_CALLBACK_DEC_INFO *dec_info)
{
GFM_GFM_MSG *msg;
NCS_UBAID *uba;
uint8_t *data;
uint8_t data_buff[256];
if (NULL == dec_info->io_uba) {
return m_LEAP_DBG_SINK(NCSCC_RC_FAILURE);
}
msg = m_MMGR_ALLOC_FM_FM_MSG;
if (NULL == msg)
return m_LEAP_DBG_SINK(NCSCC_RC_FAILURE);
memset(msg, 0, sizeof(GFM_GFM_MSG));
dec_info->o_msg = msg;
uba = dec_info->io_uba;
data = ncs_dec_flatten_space(uba, data_buff, sizeof(uint8_t));
if (NULL == data)
return m_LEAP_DBG_SINK(NCSCC_RC_FAILURE);
msg->msg_type = (GFM_GFM_MSG_TYPE)ncs_decode_8bit(&data);
ncs_dec_skip_space(uba, sizeof(uint8_t));
switch (msg->msg_type) {
case GFM_GFM_EVT_NODE_INFO_EXCHANGE:
data = ncs_dec_flatten_space(uba, data_buff, 2 * sizeof(uint32_t));
if (data == NULL) {
return m_LEAP_DBG_SINK(NCSCC_RC_FAILURE);
}
msg->info.node_info.node_id = (uint32_t)ncs_decode_32bit(&data);
msg->info.node_info.node_name.length = (uint32_t)ncs_decode_32bit(&data);
ncs_dec_skip_space(uba, 2 * sizeof(uint32_t));
ncs_decode_n_octets_from_uba(uba, msg->info.node_info.node_name.value,
msg->info.node_info.node_name.length);
break;
default:
syslog(LOG_INFO, "fm_fm_mds_dec: Invalid msg for decoding.");
return m_LEAP_DBG_SINK(NCSCC_RC_FAILURE);
break;
}
return NCSCC_RC_SUCCESS;
}
/*********************************************************************************
* Name :glsv_gld_mbcsv_dec_warm_sync_resp
*
* Description : To decode the message at the warm sync at the standby
* Arguments : NCS_MBCSV_CB_ARG - MBCSv callback argument
*
* Return Values : Success / Error
*********************************************************************************/
static uint32_t glsv_gld_mbcsv_dec_warm_sync_resp(GLSV_GLD_CB *gld_cb, NCS_MBCSV_CB_ARG *arg)
{
uint32_t num_of_async_upd, rc = NCSCC_RC_SUCCESS;
uint8_t data[16], *ptr;
NCS_MBCSV_ARG ncs_arg;
TRACE_ENTER();
/*TBD check for the validity of gld_cb arg */
memset(&ncs_arg, '\0', sizeof(NCS_MBCSV_ARG));
ptr = ncs_dec_flatten_space(&arg->info.decode.i_uba, data, sizeof(int32_t));
num_of_async_upd = ncs_decode_32bit(&ptr);
ncs_dec_skip_space(&arg->info.decode.i_uba, 4);
if (gld_cb->gld_async_cnt == num_of_async_upd) {
goto end;
} else {
gld_cb_destroy(gld_cb);
ncs_arg.i_op = NCS_MBCSV_OP_SEND_DATA_REQ;
ncs_arg.i_mbcsv_hdl = gld_cb->mbcsv_handle;
ncs_arg.info.send_data_req.i_ckpt_hdl = gld_cb->o_ckpt_hdl;
rc = ncs_mbcsv_svc(&ncs_arg);
if (rc != NCSCC_RC_SUCCESS) {
/* Log */
/* TBD */
goto end;
}
}
end:
TRACE_LEAVE();
return rc;
}
static uns32 msg_decode(MDS_CALLBACK_DEC_INFO *dec_info)
{
uns32 rc = NCSCC_RC_SUCCESS;
struct rde_msg *msg;
NCS_UBAID *uba;
uns8 *data;
uns8 data_buff[256];
if (dec_info->i_fr_svc_id != NCSMDS_SVC_ID_RDE) {
rc = NCSCC_RC_FAILURE;
goto done;
}
if (dec_info->i_msg_fmt_ver != 1) {
rc = NCSCC_RC_FAILURE;
goto done;
}
msg = malloc(sizeof(*msg));
assert(msg);
dec_info->o_msg = msg;
uba = dec_info->io_uba;
data = ncs_dec_flatten_space(uba, data_buff, sizeof(uns32));
assert(data);
msg->type = ncs_decode_32bit(&data);
ncs_dec_skip_space(uba, sizeof(uns32));
switch (msg->type) {
case RDE_MSG_PEER_INFO_REQ:
case RDE_MSG_PEER_INFO_RESP:
data = ncs_dec_flatten_space(uba, data_buff, sizeof(uns32));
assert(data);
msg->info.peer_info.ha_role = ncs_decode_32bit(&data);
ncs_dec_skip_space(uba, sizeof(uns32));
break;
default:
assert(0);
break;
}
done:
return rc;
}
/****************************************************************************
Name : cpa_mds_dec
Description : This function decodes an events sent to CPA.
Arguments : cb : CPA control Block.
info : Info for decoding
Return Values : NCSCC_RC_SUCCESS/NCSCC_RC_FAILURE
Notes : None.
******************************************************************************/
static uint32_t cpa_mds_dec(CPA_CB *cb, MDS_CALLBACK_DEC_INFO *dec_info)
{
CPSV_EVT *msg_ptr = NULL;
EDU_ERR ederror = 0;
uint32_t rc = NCSCC_RC_SUCCESS;
uint8_t local_data[20];
uint8_t *pstream;
bool is_valid_msg_fmt = false;
TRACE_ENTER();
if (dec_info->i_fr_svc_id == NCSMDS_SVC_ID_CPND) {
is_valid_msg_fmt = m_NCS_MSG_FORMAT_IS_VALID(dec_info->i_msg_fmt_ver,
CPA_WRT_CPND_SUBPART_VER_MIN,
CPA_WRT_CPND_SUBPART_VER_MAX, cpa_cpnd_msg_fmt_table);
} else if (dec_info->i_fr_svc_id == NCSMDS_SVC_ID_CPD) {
is_valid_msg_fmt = m_NCS_MSG_FORMAT_IS_VALID(dec_info->i_msg_fmt_ver,
CPA_WRT_CPD_SUBPART_VER_MIN,
CPA_WRT_CPD_SUBPART_VER_MAX, cpa_cpd_msg_fmt_table);
}
if (is_valid_msg_fmt) {
msg_ptr = m_MMGR_ALLOC_CPSV_EVT(NCS_SERVICE_ID_CPA);
if (!msg_ptr)
return NCSCC_RC_FAILURE;
memset(msg_ptr, 0, sizeof(CPSV_EVT));
dec_info->o_msg = (NCSCONTEXT)msg_ptr;
pstream = ncs_dec_flatten_space(dec_info->io_uba, local_data, 8);
msg_ptr->type = ncs_decode_32bit(&pstream);
if (msg_ptr->type == CPSV_EVT_TYPE_CPA) {
/* For Events Write/Read Call EDU VER_EXEC*/
rc = m_NCS_EDU_VER_EXEC(&cb->edu_hdl, FUNC_NAME(CPSV_EVT),
dec_info->io_uba, EDP_OP_TYPE_DEC,
(CPSV_EVT **)&dec_info->o_msg, &ederror, dec_info->i_msg_fmt_ver);
goto free;
/* if(msg_ptr->info.cpa.type == CPA_EVT_ND2A_CKPT_DATA_RSP) */
}
/* if( msg_ptr->type == CPSV_EVT_TYPE_CPA) */
/* For all Other Cases Other Than CPA( Read / Write Rsp Follow EDU rules */
rc = m_NCS_EDU_EXEC(&cb->edu_hdl, FUNC_NAME(CPSV_EVT),
dec_info->io_uba, EDP_OP_TYPE_DEC, (CPSV_EVT **)&dec_info->o_msg, &ederror);
free:
if (rc != NCSCC_RC_SUCCESS) {
m_MMGR_FREE_CPSV_EVT(dec_info->o_msg, NCS_SERVICE_ID_CPA);
}
TRACE_LEAVE();
return rc;
} else {
TRACE_4("CPA:Processing failed for mds_dec ");
TRACE_LEAVE();
return NCSCC_RC_FAILURE;
}
}
/****************************************************************************
Name : cpa_mds_dec
Description : This function decodes an events sent to CPA.
Arguments : cb : CPA control Block.
info : Info for decoding
Return Values : NCSCC_RC_SUCCESS/NCSCC_RC_FAILURE
Notes : None.
******************************************************************************/
static uns32 cpa_mds_dec(CPA_CB *cb, MDS_CALLBACK_DEC_INFO *dec_info)
{
CPSV_EVT *msg_ptr = NULL;
EDU_ERR ederror = 0;
uns32 rc = NCSCC_RC_SUCCESS;
uns8 local_data[20];
uns8 *pstream;
NCS_BOOL is_valid_msg_fmt = FALSE;
if (dec_info->i_fr_svc_id == NCSMDS_SVC_ID_CPND) {
is_valid_msg_fmt = m_NCS_MSG_FORMAT_IS_VALID(dec_info->i_msg_fmt_ver,
CPA_WRT_CPND_SUBPART_VER_MIN,
CPA_WRT_CPND_SUBPART_VER_MAX, cpa_cpnd_msg_fmt_table);
} else if (dec_info->i_fr_svc_id == NCSMDS_SVC_ID_CPD) {
is_valid_msg_fmt = m_NCS_MSG_FORMAT_IS_VALID(dec_info->i_msg_fmt_ver,
CPA_WRT_CPD_SUBPART_VER_MIN,
CPA_WRT_CPD_SUBPART_VER_MAX, cpa_cpd_msg_fmt_table);
}
if (is_valid_msg_fmt) {
msg_ptr = m_MMGR_ALLOC_CPSV_EVT(NCS_SERVICE_ID_CPA);
if (!msg_ptr)
return NCSCC_RC_FAILURE;
memset(msg_ptr, 0, sizeof(CPSV_EVT));
dec_info->o_msg = (NCSCONTEXT)msg_ptr;
pstream = ncs_dec_flatten_space(dec_info->io_uba, local_data, 8);
msg_ptr->type = ncs_decode_32bit(&pstream);
if (msg_ptr->type == CPSV_EVT_TYPE_CPA) {
msg_ptr->info.cpa.type = ncs_decode_32bit(&pstream);
if (msg_ptr->info.cpa.type == CPA_EVT_ND2A_CKPT_DATA_RSP) {
ncs_dec_skip_space(dec_info->io_uba, 8);
rc = cpsv_data_access_rsp_decode(&msg_ptr->info.cpa.info.sec_data_rsp,
dec_info->io_uba);
goto free;
}
/* if(msg_ptr->info.cpa.type == CPA_EVT_ND2A_CKPT_DATA_RSP) */
}
/* if( msg_ptr->type == CPSV_EVT_TYPE_CPA) */
/* For all Other Cases Other Than CPA( Read / Write Rsp Follow EDU rules */
rc = m_NCS_EDU_EXEC(&cb->edu_hdl, FUNC_NAME(CPSV_EVT),
dec_info->io_uba, EDP_OP_TYPE_DEC, (CPSV_EVT **)&dec_info->o_msg, &ederror);
free:
if (rc != NCSCC_RC_SUCCESS) {
m_MMGR_FREE_CPSV_EVT(dec_info->o_msg, NCS_SERVICE_ID_CPA);
}
return rc;
} else {
m_LOG_CPA_CCL(CPA_PROC_FAILED, NCSFL_LC_CKPT_MGMT, NCSFL_SEV_INFO, "mds_dec", __FILE__, __LINE__);
return NCSCC_RC_FAILURE;
}
}
/****************************************************************************
Name : lga_dec_write_ckb_msg
Description : This routine decodes an initialize sync response message
Arguments : NCS_UBAID *msg,
LGSV_MSG *msg
Return Values : uint32_t
Notes : None.
******************************************************************************/
static uint32_t lga_dec_write_cbk_msg(NCS_UBAID *uba, lgsv_msg_t *msg)
{
uint8_t *p8;
uint32_t total_bytes = 0;
lgsv_write_log_callback_ind_t *param = &msg->info.cbk_info.write_cbk;
uint8_t local_data[100];
osafassert(uba != NULL);
p8 = ncs_dec_flatten_space(uba, local_data, 4);
param->error = ncs_decode_32bit(&p8);
ncs_dec_skip_space(uba, 4);
total_bytes += 4;
return total_bytes;
}
/****************************************************************************
Name : lga_dec_finalize_rsp_msg
Description : This routine decodes an finalize sync response message
Arguments : NCS_UBAID *msg,
LGSV_MSG *msg
Return Values : uint32_t
Notes : None.
******************************************************************************/
static uint32_t lga_dec_finalize_rsp_msg(NCS_UBAID *uba, lgsv_msg_t *msg)
{
uint8_t *p8;
uint32_t total_bytes = 0;
lgsv_finalize_rsp_t *param = &msg->info.api_resp_info.param.finalize_rsp;
uint8_t local_data[100];
osafassert(uba != NULL);
p8 = ncs_dec_flatten_space(uba, local_data, 4);
param->client_id = ncs_decode_32bit(&p8);
ncs_dec_skip_space(uba, 4);
total_bytes += 4;
return total_bytes;
}
/****************************************************************************
Name : ntfa_dec_reader_finalize_rsp_msg
Description : This routine decodes an reader_finalize sync response message
Arguments : NCS_UBAID *msg,
NTFSV_MSG *msg
Return Values : uns32
Notes : None.
******************************************************************************/
static uns32 ntfa_dec_reader_finalize_rsp_msg(NCS_UBAID *uba, ntfsv_msg_t *msg)
{
uns8 *p8;
uns32 total_bytes = 0;
ntfsv_reader_finalize_rsp_t *param = &msg->info.api_resp_info.param.reader_finalize_rsp;
uns8 local_data[4];
assert(uba != NULL);
p8 = ncs_dec_flatten_space(uba, local_data, 4);
param->reader_id = ncs_decode_32bit(&p8);
ncs_dec_skip_space(uba, 4);
total_bytes += 4;
return total_bytes;
}
/****************************************************************************
Name : ntfa_dec_send_not_rsp_msg
Description : This routine decodes a notification send response message
Arguments : NCS_UBAID *msg,
NTFSV_MSG *msg
Return Values : uns32
Notes : None.
******************************************************************************/
static uns32 ntfa_dec_send_not_rsp_msg(NCS_UBAID *uba, ntfsv_msg_t *msg)
{
uns8 *p8;
uns32 total_bytes = 0;
ntfsv_send_not_rsp_t *param = &msg->info.api_resp_info.param.send_not_rsp;
uns8 local_data[8];
assert(uba != NULL);
/* chan_id */
p8 = ncs_dec_flatten_space(uba, local_data, 8);
param->notificationId = ncs_decode_64bit(&p8);
ncs_dec_skip_space(uba, 8);
total_bytes += 8;
return total_bytes;
}
/****************************************************************************
Name : lga_dec_lstr_open_sync_rsp_msg
Description : This routine decodes a log stream open sync response message
Arguments : NCS_UBAID *msg,
LGSV_MSG *msg
Return Values : uint32_t
Notes : None.
******************************************************************************/
static uint32_t lga_dec_lstr_open_sync_rsp_msg(NCS_UBAID *uba, lgsv_msg_t *msg)
{
uint8_t *p8;
uint32_t total_bytes = 0;
lgsv_stream_open_rsp_t *param = &msg->info.api_resp_info.param.lstr_open_rsp;
uint8_t local_data[100];
osafassert(uba != NULL);
/* chan_id */
p8 = ncs_dec_flatten_space(uba, local_data, 4);
param->lstr_id = ncs_decode_32bit(&p8);
ncs_dec_skip_space(uba, 4);
total_bytes += 4;
return total_bytes;
}
static uint32_t eda_dec_clm_status_cbk_msg(NCS_UBAID *uba, EDSV_MSG *msg)
{
uint8_t *p8;
int32_t total_bytes = 0;
EDSV_EDA_CLM_STATUS_CBK_PARAM *param = &msg->info.cbk_info.param.clm_status_cbk;
uint8_t local_data[256];
if (uba == NULL) {
TRACE_4("uba is NULL");
return 0;
}
/* ClmNodeStatus */
p8 = ncs_dec_flatten_space(uba, local_data, 2);
param->node_status = ncs_decode_16bit(&p8);
ncs_dec_skip_space(uba, 2);
total_bytes += 2;
return total_bytes;
}
/****************************************************************************
* Function Name: dts_log_str_decode
* Purpose: Decodes the flexlog string.
*****************************************************************************/
uns32 dts_log_str_decode(NCS_UBAID *uba, char **str)
{
uns32 length = 0;
uns8 *data = NULL;
uns8 data_buff[DTS_MAX_SIZE_DATA];
data = ncs_dec_flatten_space(uba, data_buff, sizeof(uns32));
if (data == NULL) {
return m_DTS_DBG_SINK(NCSCC_RC_FAILURE, "dts_log_str_decode: Decode flatten space failed");
}
length = ncs_decode_32bit(&data);
ncs_dec_skip_space(uba, sizeof(uns32));
*str = m_MMGR_ALLOC_OCT(length);
if (*str == NULL)
return m_DTS_DBG_SINK(NCSCC_RC_FAILURE, "dts_log_str_decode: Memory allocation failed");
memset(*str, '\0', length);
ncs_decode_n_octets_from_uba(uba, (uns8 *)*str, length);
return NCSCC_RC_SUCCESS;
}
/*****************************************************************************
* Function Name: dts_log_msg_decode
* Purpose: decodes a NCSDTS_FLTR from a ubaid
****************************************************************************/
uns32 dts_log_msg_decode(NCSFL_NORMAL *logmsg, NCS_UBAID *uba)
{
uns8 *data = NULL;
uns8 data_buff[DTS_MAX_SIZE_DATA];
if (uba == NULL)
return m_DTS_DBG_SINK(NCSCC_RC_FAILURE, "dts_log_msg_decode: User buffer is NULL");
if (logmsg == NULL)
return m_DTS_DBG_SINK(NCSCC_RC_FAILURE, "dts_log_msg_decode: Message to be decoded is NULL");
data = ncs_dec_flatten_space(uba, data_buff, DTS_LOG_MSG_HDR_SIZE);
if (data == NULL)
return m_DTS_DBG_SINK(NCSCC_RC_FAILURE, "dts_log_msg_decode: ncs_dec_flatten_space returns NULL");
logmsg->hdr.time.seconds = ncs_decode_32bit(&data);
logmsg->hdr.time.millisecs = ncs_decode_32bit(&data);
logmsg->hdr.vr_id = ncs_decode_16bit(&data);
logmsg->hdr.ss_id = ncs_decode_32bit(&data);
logmsg->hdr.inst_id = ncs_decode_32bit(&data);
logmsg->hdr.severity = ncs_decode_8bit(&data);
logmsg->hdr.category = ncs_decode_32bit(&data);
logmsg->hdr.fmat_id = ncs_decode_8bit(&data);
ncs_dec_skip_space(uba, DTS_LOG_MSG_HDR_SIZE);
/* Check for any mem failure in dts_log_str_decode */
if (dts_log_str_decode(uba, &logmsg->hdr.fmat_type) == NCSCC_RC_FAILURE)
return m_DTS_DBG_SINK(NCSCC_RC_FAILURE,
"dts_log_msg_decode: dts_log_str_decode returned memory alloc failure");
memcpy(&logmsg->uba, uba, sizeof(NCS_UBAID));
return NCSCC_RC_SUCCESS;
}
/****************************************************************************
Name : eda_dec_delv_evt_cbk_msg
Description : This routine decodes a deliver event callback message
Arguments : NCS_UBAID *msg,
EDSV_MSG *msg
Return Values : uint32_t
Notes : None.
******************************************************************************/
static uint32_t eda_dec_delv_evt_cbk_msg(NCS_UBAID *uba, EDSV_MSG *msg)
{
uint8_t *p8;
uint32_t x;
uint32_t fake_value;
uint64_t num_patterns;
uint32_t total_bytes = 0;
SaEvtEventPatternT *pattern_ptr;
EDSV_EDA_EVT_DELIVER_CBK_PARAM *param = &msg->info.cbk_info.param.evt_deliver_cbk;
uint8_t local_data[1024];
if (uba == NULL) {
TRACE_4("uba is NULL");
return 0;
}
/* sub_id, chan_id, chan_open_id */
p8 = ncs_dec_flatten_space(uba, local_data, 12);
param->sub_id = ncs_decode_32bit(&p8);
param->chan_id = ncs_decode_32bit(&p8);
param->chan_open_id = ncs_decode_32bit(&p8);
ncs_dec_skip_space(uba, 12);
total_bytes += 12;
/* Decode the patterns.
* Must allocate space for these.
*/
/* patternsNumber */
p8 = ncs_dec_flatten_space(uba, local_data, 8);
num_patterns = ncs_decode_64bit(&p8);
ncs_dec_skip_space(uba, 8);
total_bytes += 8;
param->pattern_array = m_MMGR_ALLOC_EVENT_PATTERN_ARRAY;
if (!param->pattern_array) {
TRACE_4("malloc failed for pattern array");
return 0;
}
param->pattern_array->patternsNumber = num_patterns;
if (num_patterns) {
param->pattern_array->patterns = m_MMGR_ALLOC_EVENT_PATTERNS((uint32_t)num_patterns);
if (!param->pattern_array->patterns) {
TRACE_4("malloc failed for patternarray->patterns");
return 0;
}
} else {
param->pattern_array->patterns = NULL;
}
pattern_ptr = param->pattern_array->patterns;
for (x = 0; x < param->pattern_array->patternsNumber; x++) {
/* patternSize */
p8 = ncs_dec_flatten_space(uba, local_data, 8);
pattern_ptr->patternSize = ncs_decode_64bit(&p8);
ncs_dec_skip_space(uba, 8);
total_bytes += 8;
/* For zero length patterns, fake decode zero */
if (pattern_ptr->patternSize == 0) {
p8 = ncs_dec_flatten_space(uba, local_data, 4);
fake_value = ncs_decode_32bit(&p8);
TRACE("pattern size: %u", fake_value);
/* Do so the free routine is happy */
pattern_ptr->pattern = m_MMGR_ALLOC_EDSV_EVENT_DATA(0);
ncs_dec_skip_space(uba, 4);
total_bytes += 4;
} else {
/* pattern */
pattern_ptr->pattern = m_MMGR_ALLOC_EDSV_EVENT_DATA((uint32_t)pattern_ptr->patternSize);
if (!pattern_ptr->pattern) {
TRACE_4("malloc failed for event data");
return 0;
}
ncs_decode_n_octets_from_uba(uba, pattern_ptr->pattern, (uint32_t)pattern_ptr->patternSize);
total_bytes += (uint32_t)pattern_ptr->patternSize;
}
pattern_ptr++;
}
/* priority */
p8 = ncs_dec_flatten_space(uba, local_data, 1);
param->priority = ncs_decode_8bit(&p8);
ncs_dec_skip_space(uba, 1);
total_bytes += 1;
/* publisher_name length */
p8 = ncs_dec_flatten_space(uba, local_data, 2);
param->publisher_name.length = ncs_decode_16bit(&p8);
ncs_dec_skip_space(uba, 2);
total_bytes += 2;
/* publisher_name */
ncs_decode_n_octets_from_uba(uba, param->publisher_name.value, (uint32_t)param->publisher_name.length);
total_bytes += (uint32_t)param->publisher_name.length;
/* publish_time, eda_event_id */
p8 = ncs_dec_flatten_space(uba, local_data, 24);
param->publish_time = ncs_decode_64bit(&p8);
param->retention_time = ncs_decode_64bit(&p8);
param->eda_event_id = ncs_decode_32bit(&p8);
param->ret_evt_ch_oid = ncs_decode_32bit(&p8);
ncs_dec_skip_space(uba, 24);
total_bytes += 24;
/* data_len */
p8 = ncs_dec_flatten_space(uba, local_data, 8);
param->data_len = ncs_decode_64bit(&p8);
ncs_dec_skip_space(uba, 8);
total_bytes += 8;
/* data */
if ((uint32_t)param->data_len) {
param->data = m_MMGR_ALLOC_EDSV_EVENT_DATA((uint32_t)param->data_len);
if (!param->data) {
TRACE_4("malloc failedi for event data");
return 0;
}
ncs_decode_n_octets_from_uba(uba, param->data, (uint32_t)param->data_len);
} else
param->data = NULL;
total_bytes += (uint32_t)param->data_len;
return total_bytes;
}
/****************************************************************************
Name : ntfa_mds_dec
Description : This is a callback routine that is invoked to decode NTFS
messages.
Arguments : pointer to struct ncsmds_callback_info
Return Values : NCSCC_RC_SUCCESS/NCSCC_RC_FAILURE
Notes : None.
******************************************************************************/
static uns32 ntfa_mds_dec(struct ncsmds_callback_info *info)
{
uns8 *p8;
ntfsv_msg_t *msg;
NCS_UBAID *uba = info->info.dec.io_uba;
uns8 local_data[12];
uns32 total_bytes = 0;
TRACE_ENTER();
if (0 == m_NCS_MSG_FORMAT_IS_VALID(info->info.dec.i_msg_fmt_ver,
NTFA_WRT_NTFS_SUBPART_VER_AT_MIN_MSG_FMT,
NTFA_WRT_NTFS_SUBPART_VER_AT_MAX_MSG_FMT, NTFA_WRT_NTFS_MSG_FMT_ARRAY)) {
TRACE("Invalid message format!!!\n");
TRACE_LEAVE();
return NCSCC_RC_FAILURE;
}
/** Allocate a new msg in both sync/async cases
**/
if (NULL == (msg = calloc(1, sizeof(ntfsv_msg_t)))) {
TRACE("calloc failed\n");
return NCSCC_RC_FAILURE;
}
info->info.dec.o_msg = (uns8 *)msg;
p8 = ncs_dec_flatten_space(uba, local_data, 4);
msg->type = ncs_decode_32bit(&p8);
ncs_dec_skip_space(uba, 4);
total_bytes += 4;
switch (msg->type) {
case NTFSV_NTFA_API_RESP_MSG:
{
p8 = ncs_dec_flatten_space(uba, local_data, 8);
msg->info.api_resp_info.type = ncs_decode_32bit(&p8);
msg->info.api_resp_info.rc = ncs_decode_32bit(&p8);
ncs_dec_skip_space(uba, 8);
total_bytes += 8;
TRACE_2("NTFSV_NTFA_API_RESP_MSG rc = %d", (int)msg->info.api_resp_info.rc);
switch (msg->info.api_resp_info.type) {
case NTFSV_INITIALIZE_RSP:
total_bytes += ntfa_dec_initialize_rsp_msg(uba, msg);
break;
case NTFSV_SUBSCRIBE_RSP:
total_bytes += ntfa_dec_subscribe_rsp_msg(uba, msg);
break;
case NTFSV_UNSUBSCRIBE_RSP: /* Only header sent from server */
break;
case NTFSV_SEND_NOT_RSP:
total_bytes += ntfa_dec_send_not_rsp_msg(uba, msg);
break;
case NTFSV_READER_INITIALIZE_RSP:
total_bytes += ntfa_dec_reader_initialize_rsp_msg(uba, msg);
break;
case NTFSV_READER_FINALIZE_RSP:
total_bytes += ntfa_dec_reader_finalize_rsp_msg(uba, msg);
break;
case NTFSV_READ_NEXT_RSP:
total_bytes += ntfa_dec_read_next_rsp_msg(uba, msg);
break;
case NTFSV_FINALIZE_RSP:
break;
default:
TRACE_2("Unknown API RSP type %d", msg->info.api_resp_info.type);
break;
}
}
break;
case NTFSV_NTFS_CBK_MSG:
{
p8 = ncs_dec_flatten_space(uba, local_data, 12);
msg->info.cbk_info.type = ncs_decode_32bit(&p8);
msg->info.cbk_info.ntfs_client_id = ncs_decode_32bit(&p8);
msg->info.cbk_info.subscriptionId = ncs_decode_32bit(&p8);
ncs_dec_skip_space(uba, 12);
total_bytes += 12;
TRACE_2("NTFSV_NTFS_CBK_MSG");
switch (msg->info.cbk_info.type) {
case NTFSV_NOTIFICATION_CALLBACK:
/* TODO: use notificationAlloc here? */
msg->info.cbk_info.param.notification_cbk = calloc(1, sizeof(ntfsv_send_not_req_t));
if (NULL == msg->info.cbk_info.param.notification_cbk) {
TRACE_1("could not allocate memory");
return 0;
}
TRACE_2("decode notification cbk message");
total_bytes += ntfa_dec_not_send_cbk_msg(uba, msg);
break;
case NTFSV_DISCARDED_CALLBACK:
TRACE_2("decode discarded cbk message");
total_bytes += ntfa_dec_not_discard_cbk_msg(uba, msg);
break;
default:
TRACE_2("Unknown callback type = %d!", msg->info.cbk_info.type);
break;
}
}
break;
default:
TRACE("Unknown MSG type %d", msg->type);
break;
}
TRACE_LEAVE();
return NCSCC_RC_SUCCESS;
}
/****************************************************************************
* Function Name: dts_mds_dec
* Purpose: decode a DTS message coming in
****************************************************************************/
uns32 dts_mds_dec(MDS_CLIENT_HDL yr_svc_hdl, NCSCONTEXT *msg,
SS_SVC_ID to_svc, NCS_UBAID *uba, MDS_CLIENT_MSG_FORMAT_VER msg_fmat_ver)
{
uns8 *data = NULL;
DTSV_MSG *mm;
uns8 data_buff[DTSV_DTA_DTS_HDR_SIZE];
uns32 lenn = 0;
if ((msg_fmat_ver < DTS_MDS_MIN_MSG_FMAT_VER_SUPPORT) || (msg_fmat_ver > DTS_MDS_MAX_MSG_FMAT_VER_SUPPORT))
return m_DTS_DBG_SINK(NCSCC_RC_FAILURE,
"dts_mds_dec: Message format version is not within acceptable range");
if (uba == NULL)
return m_DTS_DBG_SINK(NCSCC_RC_FAILURE, "dts_mds_dec: DTS decode: user buffer is NULL");
if (msg == NULL)
return m_DTS_DBG_SINK(NCSCC_RC_FAILURE, "dts_mds_dec: DTS decode: Message is NULL");
mm = m_MMGR_ALLOC_DTSV_MSG;
if (mm == NULL) {
return m_DTS_DBG_SINK(NCSCC_RC_FAILURE, "dts_mds_dec: DTS decode: Failed to allocate DTSV message");
}
memset(mm, '\0', sizeof(DTSV_MSG));
*msg = mm;
data = ncs_dec_flatten_space(uba, data_buff, DTSV_DTA_DTS_HDR_SIZE);
if (data == NULL) {
m_MMGR_FREE_DTSV_MSG(mm);
return m_DTS_DBG_SINK(NCSCC_RC_FAILURE, "dts_mds_dec: DTS decode: ncs_dec_flatten_space returns NULL");
}
mm->vrid = ncs_decode_16bit(&data);
mm->msg_type = ncs_decode_8bit(&data);
ncs_dec_skip_space(uba, DTSV_DTA_DTS_HDR_SIZE);
switch (mm->msg_type) {
case DTA_REGISTER_SVC:
{
data = ncs_dec_flatten_space(uba, data_buff, sizeof(SS_SVC_ID));
if (data == NULL) {
m_MMGR_FREE_DTSV_MSG(mm);
return m_DTS_DBG_SINK(NCSCC_RC_FAILURE,
"dts_mds_dec: DTS decode: ncs_dec_flatten_space returns NULL");
}
mm->data.data.reg.svc_id = ncs_decode_32bit(&data);
ncs_dec_skip_space(uba, sizeof(SS_SVC_ID));
/* Decode the version no. */
data = ncs_dec_flatten_space(uba, data_buff, sizeof(uns16));
if (data == NULL) {
m_MMGR_FREE_DTSV_MSG(mm);
return m_DTS_DBG_SINK(NCSCC_RC_FAILURE,
"dts_mds_dec: DTS decode: ncs_dec_flatten_space returns NULL");
}
mm->data.data.reg.version = ncs_decode_16bit(&data);
ncs_dec_skip_space(uba, sizeof(uns16));
/* Decode the service name */
data = ncs_dec_flatten_space(uba, data_buff, sizeof(uns32));
if (data == NULL) {
m_MMGR_FREE_DTSV_MSG(mm);
return m_DTS_DBG_SINK(NCSCC_RC_FAILURE,
"dts_mds_dec: DTS decode: ncs_dec_flatten_space returns NULL");
}
lenn = ncs_decode_32bit(&data);
ncs_dec_skip_space(uba, sizeof(uns32));
if (lenn == 0) {
/* No need to decode any further. no service name specified */
} else if (lenn < DTSV_SVC_NAME_MAX) { /* Check valid len of svc_name */
ncs_decode_n_octets_from_uba(uba, (uns8 *)mm->data.data.reg.svc_name, lenn);
} else { /* Discard this message */
m_MMGR_FREE_DTSV_MSG(mm);
return m_DTS_DBG_SINK(NCSCC_RC_FAILURE,
"dts_mds_dec: Length of service name decoded in register message exceeds limits");
}
break;
}
case DTA_UNREGISTER_SVC:
{
data = ncs_dec_flatten_space(uba, data_buff, sizeof(SS_SVC_ID));
if (data == NULL) {
m_MMGR_FREE_DTSV_MSG(mm);
return m_DTS_DBG_SINK(NCSCC_RC_FAILURE,
"dts_mds_dec: DTS decode: ncs_dec_flatten_space returns NULL");
}
mm->data.data.unreg.svc_id = ncs_decode_32bit(&data);
ncs_dec_skip_space(uba, sizeof(SS_SVC_ID));
/* Decode the version no. */
data = ncs_dec_flatten_space(uba, data_buff, sizeof(uns16));
if (data == NULL) {
m_MMGR_FREE_DTSV_MSG(mm);
return m_DTS_DBG_SINK(NCSCC_RC_FAILURE,
"dts_mds_dec: DTS decode: ncs_dec_flatten_space returns NULL");
}
mm->data.data.unreg.version = ncs_decode_16bit(&data);
ncs_dec_skip_space(uba, sizeof(uns16));
/* Decode the service name */
data = ncs_dec_flatten_space(uba, data_buff, sizeof(uns32));
if (data == NULL) {
m_MMGR_FREE_DTSV_MSG(mm);
return m_DTS_DBG_SINK(NCSCC_RC_FAILURE,
"dts_mds_dec: DTS decode: ncs_dec_flatten_space returns NULL");
}
lenn = ncs_decode_32bit(&data);
ncs_dec_skip_space(uba, sizeof(uns32));
if (lenn == 0) {
/* No need to decode any further. no service name specified */
}
if (lenn < DTSV_SVC_NAME_MAX) { /* Check valid len of svc_name */
ncs_decode_n_octets_from_uba(uba, (uns8 *)mm->data.data.unreg.svc_name, lenn);
} else { /* Discard this message */
m_MMGR_FREE_DTSV_MSG(mm);
return m_DTS_DBG_SINK(NCSCC_RC_FAILURE,
"dts_mds_dec: Length of service name decoded in unregister msg exceeds limits");
}
break;
}
case DTA_LOG_DATA:
{
/* Versioning changes : Set the msg_fmat_ver field of DTA_LOG_MSG
* according to the message format version from MDS callback.
*/
mm->data.data.msg.msg_fmat_ver = msg_fmat_ver;
/* Check for any mem failure in dts_log_str_decode */
if (dts_log_msg_decode(&mm->data.data.msg.log_msg, uba) == NCSCC_RC_FAILURE) {
m_MMGR_FREE_DTSV_MSG(mm);
return m_DTS_DBG_SINK(NCSCC_RC_FAILURE,
"dts_mds_dec: dts_log_msg_decode returned failure");
}
break;
}
#if (DTA_FLOW == 1)
case DTA_FLOW_CONTROL:
case DTS_CONGESTION_HIT:
case DTS_CONGESTION_CLEAR:
/* Do Nothing */
break;
#endif
default:
m_MMGR_FREE_DTSV_MSG(mm);
return m_DTS_DBG_SINK(NCSCC_RC_FAILURE, "dts_mds_dec: Wrong message type is received");
}
return NCSCC_RC_SUCCESS;
}
/****************************************************************************
Name : lga_mds_dec
Description : This is a callback routine that is invoked to decode LGS
messages.
Arguments : pointer to struct ncsmds_callback_info
Return Values : NCSCC_RC_SUCCESS/NCSCC_RC_FAILURE
Notes : None.
******************************************************************************/
static uint32_t lga_mds_dec(struct ncsmds_callback_info *info)
{
uint8_t *p8;
lgsv_msg_t *msg;
NCS_UBAID *uba = info->info.dec.io_uba;
uint8_t local_data[20];
uint32_t total_bytes = 0;
TRACE_ENTER();
if (0 == m_NCS_MSG_FORMAT_IS_VALID(info->info.dec.i_msg_fmt_ver,
LGA_WRT_LGS_SUBPART_VER_AT_MIN_MSG_FMT,
LGA_WRT_LGS_SUBPART_VER_AT_MAX_MSG_FMT, LGA_WRT_LGS_MSG_FMT_ARRAY)) {
TRACE("Invalid message format!!!\n");
TRACE_LEAVE();
return NCSCC_RC_FAILURE;
}
/** Allocate a new msg in both sync/async cases
**/
if (NULL == (msg = calloc(1, sizeof(lgsv_msg_t)))) {
TRACE("calloc failed\n");
return NCSCC_RC_FAILURE;
}
info->info.dec.o_msg = (uint8_t *)msg;
p8 = ncs_dec_flatten_space(uba, local_data, 4);
msg->type = ncs_decode_32bit(&p8);
ncs_dec_skip_space(uba, 4);
total_bytes += 4;
switch (msg->type) {
case LGSV_LGA_API_RESP_MSG:
{
p8 = ncs_dec_flatten_space(uba, local_data, 8);
msg->info.api_resp_info.type = ncs_decode_32bit(&p8);
msg->info.api_resp_info.rc = ncs_decode_32bit(&p8);
ncs_dec_skip_space(uba, 8);
total_bytes += 8;
TRACE_2("LGSV_LGA_API_RESP_MSG");
switch (msg->info.api_resp_info.type) {
case LGSV_INITIALIZE_RSP:
total_bytes += lga_dec_initialize_rsp_msg(uba, msg);
break;
case LGSV_FINALIZE_RSP:
total_bytes += lga_dec_finalize_rsp_msg(uba, msg);
break;
case LGSV_STREAM_OPEN_RSP:
total_bytes += lga_dec_lstr_open_sync_rsp_msg(uba, msg);
break;
case LGSV_STREAM_CLOSE_RSP:
total_bytes += lga_dec_lstr_close_rsp_msg(uba, msg);
break;
default:
TRACE_2("Unknown API RSP type %d", msg->info.api_resp_info.type);
break;
}
}
break;
case LGSV_LGS_CBK_MSG:
{
p8 = ncs_dec_flatten_space(uba, local_data, 16);
msg->info.cbk_info.type = ncs_decode_32bit(&p8);
msg->info.cbk_info.lgs_client_id = ncs_decode_32bit(&p8);
msg->info.cbk_info.inv = ncs_decode_64bit(&p8);
ncs_dec_skip_space(uba, 16);
total_bytes += 16;
TRACE_2("LGSV_LGS_CBK_MSG");
switch (msg->info.cbk_info.type) {
case LGSV_WRITE_LOG_CALLBACK_IND:
TRACE_2("decode writelog message");
total_bytes += lga_dec_write_cbk_msg(uba, msg);
break;
default:
TRACE_2("Unknown callback type = %d!", msg->info.cbk_info.type);
break;
}
}
break;
default:
TRACE("Unknown MSG type %d", msg->type);
break;
}
TRACE_LEAVE();
return NCSCC_RC_SUCCESS;
}
/***********************************************************************************
* Name : glsv_gld_mbcsv_dec_async_update
*
* Description : To decode the async update at the Standby, so the first field is decoded which will tell the type
and based on the event, a corresponding action will be taken
* Arguments : NCS_MBCSV_CB_ARG - MBCSv callback argument
*
* Return Values : Success / Error
***********************************************************************************/
static uint32_t glsv_gld_mbcsv_dec_async_update(GLSV_GLD_CB *gld_cb, NCS_MBCSV_CB_ARG *arg)
{
uint8_t *ptr, data[16];
GLSV_GLD_A2S_CKPT_EVT *a2s_evt;
uint32_t evt_type, rc = NCSCC_RC_SUCCESS;
EDU_ERR ederror = 0;
GLSV_A2S_RSC_OPEN_INFO *rsc_info = NULL;
GLSV_A2S_RSC_DETAILS *rsc_details = NULL;
GLSV_A2S_GLND_MDS_INFO *node_details = NULL;
TRACE_ENTER();
a2s_evt = m_MMGR_ALLOC_GLSV_GLD_A2S_EVT;
if (a2s_evt == NULL) {
LOG_CR("A2S event alloc failed: Error %s", strerror(errno));
assert(0);
}
memset(a2s_evt, 0, sizeof(GLSV_GLD_A2S_CKPT_EVT));
/* To store the value of Async Update received */
gld_cb->gld_async_cnt++;
/* in the decode.i_uba , the 1st parameter is the Type , so first decode only the first field and based on the type then decode the entire message */
ptr = ncs_dec_flatten_space(&arg->info.decode.i_uba, data, sizeof(uint8_t));
evt_type = ncs_decode_8bit(&ptr);
a2s_evt->evt_type = evt_type;
ncs_dec_skip_space(&arg->info.decode.i_uba, sizeof(uint8_t));
switch (evt_type) {
case GLSV_GLD_EVT_RSC_OPEN:
rsc_info = &a2s_evt->info.rsc_open_info;
/* The contents are decoded from i_uba a2s_evt */
rc = m_NCS_EDU_EXEC(&gld_cb->edu_hdl, glsv_edp_gld_a2s_evt_rsc_open_info, &arg->info.decode.i_uba,
EDP_OP_TYPE_DEC, &rsc_info, &ederror);
if (rc != NCSCC_RC_SUCCESS) {
LOG_ER("EDU exec async rsc open evt failed");
rc = NCSCC_RC_FAILURE;
goto end;
}
rc = gld_process_standby_evt(gld_cb, a2s_evt);
if (rc != NCSCC_RC_SUCCESS) {
LOG_ER("GLD standby rsc open evt failed");
goto end;
}
break;
case GLSV_GLD_EVT_RSC_CLOSE:
rsc_details = &a2s_evt->info.rsc_details;
/* The contents are decoded from i_uba to a2s_evt */
rc = m_NCS_EDU_EXEC(&gld_cb->edu_hdl, glsv_edp_gld_a2s_evt_rsc_details,
&arg->info.decode.i_uba, EDP_OP_TYPE_DEC, &rsc_details, &ederror);
if (rc != NCSCC_RC_SUCCESS) {
LOG_ER("EDU exec async rsc close evt failed");
rc = NCSCC_RC_FAILURE;
goto end;
}
rc = gld_process_standby_evt(gld_cb, a2s_evt);
if (rc != NCSCC_RC_SUCCESS) {
LOG_ER("GLD standby rsc close evt failed");
rc = NCSCC_RC_FAILURE;
goto end;
}
break;
case GLSV_GLD_EVT_SET_ORPHAN:
rsc_details = &a2s_evt->info.rsc_details;
/* The contents are decoded from i_uba to a2s_evt */
rc = m_NCS_EDU_EXEC(&gld_cb->edu_hdl, glsv_edp_gld_a2s_evt_rsc_details, &arg->info.decode.i_uba,
EDP_OP_TYPE_DEC, &rsc_details, &ederror);
if (rc != NCSCC_RC_SUCCESS) {
LOG_ER("EDU exec aysnc set orphan evt failed");
rc = NCSCC_RC_FAILURE;
goto end;
}
rc = gld_process_standby_evt(gld_cb, a2s_evt);
if (rc != NCSCC_RC_SUCCESS) {
LOG_ER("GLD standby rsc set orphan evt failed");
rc = NCSCC_RC_FAILURE;
goto end;
}
break;
case GLSV_GLD_EVT_GLND_DOWN:
case GLSV_GLD_EVT_GLND_OPERATIONAL:
node_details = &a2s_evt->info.glnd_mds_info;
/* The contents are decoded from i_uba to a2s_evt */
rc = m_NCS_EDU_EXEC(&gld_cb->edu_hdl, glsv_edp_gld_a2s_evt_glnd_mds_info, &arg->info.decode.i_uba,
EDP_OP_TYPE_DEC, &node_details, &ederror);
if (rc != NCSCC_RC_SUCCESS) {
LOG_ER("EDU exec async glnd down evt failed");
rc = NCSCC_RC_FAILURE;
goto end;
}
rc = gld_process_standby_evt(gld_cb, a2s_evt);
if (rc != NCSCC_RC_SUCCESS) {
LOG_ER("GLD standby glnd down evt failed");
rc = NCSCC_RC_FAILURE;
goto end;
}
break;
default:
m_MMGR_FREE_GLSV_GLD_A2S_EVT(a2s_evt);
rc = NCSCC_RC_FAILURE;
goto end;
}
end:
TRACE_LEAVE();
return rc;
}
