/****************************************************************************
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 : avnd_mds_flat_ava_dec
Description : This routine is invoked to (flat) decode AvA message.
Arguments : cb - ptr to the AvND control block
dec_info - ptr to the MDS decode info
Return Values : NCSCC_RC_SUCCESS/NCSCC_RC_FAILURE
Notes : None.
******************************************************************************/
uns32 avnd_mds_flat_ava_dec(AVND_CB *cb, MDS_CALLBACK_DEC_INFO *dec_info)
{
AVSV_NDA_AVA_MSG *ava_msg = 0;
uns32 rc = NCSCC_RC_SUCCESS;
/* alloc memory for ava-msg */
ava_msg = calloc(1, sizeof(AVSV_NDA_AVA_MSG));
if (!ava_msg) {
rc = NCSCC_RC_FAILURE;
goto err;
}
/* decode the msg */
rc = ncs_decode_n_octets_from_uba(dec_info->io_uba, (uns8 *)ava_msg, sizeof(AVSV_NDA_AVA_MSG));
if (NCSCC_RC_SUCCESS != rc)
goto err;
/* decode over successfully */
dec_info->o_msg = (NCSCONTEXT)ava_msg;
return rc;
err:
/* free ava-msg */
if (ava_msg)
avsv_nda_ava_msg_free(ava_msg);
dec_info->o_msg = 0;
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;
}
/****************************************************************************
* 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_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 : 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;
}
