/**************************************************************************
Function: dts_stby_global_filtering_policy_change
Purpose: Change in the Global Filtering policy will affect the entire system
This function will set the filtering policies of all the nodes and
all the services which are currently present in the node and the
service registration table respectively.
The above changes are for stby DTS only.
Input: cb : DTS_CB pointer
param_id : Parameter for which change is done.
Returns: NCSCC_RC_SUCCESSS/NCSCC_RC_FAILURE
Notes:
**************************************************************************/
static uns32 dts_stby_global_filtering_policy_change(DTS_CB *cb)
{
uns32 status = NCSCC_RC_SUCCESS;
SVC_KEY nt_key;
DTS_SVC_REG_TBL *service = NULL;
/* Search through registration table, Set all the policies,
* configure all the DTA's using this policy. */
service = (DTS_SVC_REG_TBL *)ncs_patricia_tree_getnext(&cb->svc_tbl, NULL);
while (service != NULL) {
/* Setup key for new search */
/* Network order key added */
nt_key.node = m_NCS_OS_HTONL(service->my_key.node);
nt_key.ss_svc_id = m_NCS_OS_HTONL(service->my_key.ss_svc_id);
/* Set the Node Policy as per the Global Policy */
if (cb->cli_bit_map == osafDtsvGlobalLoggingState_ID)
service->svc_policy.enable = cb->g_policy.g_policy.enable;
if (cb->cli_bit_map == osafDtsvGlobalCategoryBitMap_ID)
service->svc_policy.category_bit_map = cb->g_policy.g_policy.category_bit_map;
if (cb->cli_bit_map == osafDtsvGlobalSeverityBitMap_ID)
service->svc_policy.severity_bit_map = cb->g_policy.g_policy.severity_bit_map;
if (cb->cli_bit_map == osafDtsvGlobalMessageLogging_ID) {
service->device.new_file = TRUE;
}
service = (DTS_SVC_REG_TBL *)ncs_patricia_tree_getnext(&cb->svc_tbl, (const uns8 *)&nt_key);
} /* end of while */
return status;
}
/****************************************************************************\
* Function: dtsv_ckpt_add_rmv_updt_dts_log
*
* Purpose: Add new entry to device's DTS_FILE_LIST if action is ADD,
* remove if action is to remove.
*
* Input: cb - CB pointer.
* su - Decoded structur.
* action - ADD/RMV/UPDT
*
* Returns: NCSCC_RC_SUCCESS/NCSCC_RC_FAILURE.
*
* NOTES:
*
\**************************************************************************/
uns32 dtsv_ckpt_add_rmv_updt_dts_log(DTS_CB *cb, DTS_LOG_CKPT_DATA *data, NCS_MBCSV_ACT_TYPE action)
{
DTS_SVC_REG_TBL *svc = NULL;
OP_DEVICE *device = NULL;
SVC_KEY nt_key;
if (data == NULL)
return m_DTS_DBG_SINK(NCSCC_RC_FAILURE, "dtsv_ckpt_add_rmv_updt_dts_log: NULL pointer passed");
/* Network order key added */
nt_key.node = m_NCS_OS_HTONL(data->key.node);
nt_key.ss_svc_id = m_NCS_OS_HTONL(data->key.ss_svc_id);
m_DTS_LK(&cb->lock);
m_LOG_DTS_LOCK(DTS_LK_LOCKED, &cb->lock);
if (data->key.node == 0) /*global policy device */
device = &cb->g_policy.device;
else if (data->key.ss_svc_id == 0) { /*node policy device */
if ((svc = (DTS_SVC_REG_TBL *)ncs_patricia_tree_get(&cb->svc_tbl, (const uns8 *)&nt_key)) == NULL) {
m_DTS_UNLK(&cb->lock);
m_LOG_DTS_LOCK(DTS_LK_UNLOCKED, &cb->lock);
return m_DTS_DBG_SINK(NCSCC_RC_FAILURE,
"dtsv_ckpt_add_rmv_updt_dts_log: Node entry doesn't exist");
}
device = &svc->device;
} else { /*service policy device */
if ((svc = (DTS_SVC_REG_TBL *)ncs_patricia_tree_get(&cb->svc_tbl, (const uns8 *)&nt_key)) == NULL) {
m_DTS_UNLK(&cb->lock);
m_LOG_DTS_LOCK(DTS_LK_UNLOCKED, &cb->lock);
return m_DTS_DBG_SINK(NCSCC_RC_FAILURE,
"dtsv_ckpt_add_rmv_updt_dts_log: Service entry doesn't exist");
}
device = &svc->device;
}
switch (action) {
case NCS_MBCSV_ACT_ADD:
break;
case NCS_MBCSV_ACT_RMV:
{
m_LOG_DTS_LOGDEL(data->key.node, data->key.ss_svc_id, device->log_file_list.num_of_files);
m_DTS_RMV_LL_ENTRY(device);
}
break;
default:
/* Log error */
m_DTS_UNLK(&cb->lock);
m_LOG_DTS_LOCK(DTS_LK_UNLOCKED, &cb->lock);
return NCSCC_RC_FAILURE;
}
m_DTS_UNLK(&cb->lock);
m_LOG_DTS_LOCK(DTS_LK_UNLOCKED, &cb->lock);
return NCSCC_RC_SUCCESS;
}
/**************************************************************************
Function: ncs_ip_addr_to_octdata
Purpose: This function will convert the IP_ADDR to octet data.
Input:
uns8 *o_oct_data : IP address in the form of octet data
in nwk order
NCS_IP_ADDR *i_addr : IP address (assuming that "type" is
already filled.
NCS_BOOL is_nwk_order : Byte order of IP address (Applicable only for
IPv4 address.)
Return : Length of the IP address in octets.
Notes:
**************************************************************************/
uns16 ncs_ip_addr_to_octdata(uns8 *o_oct_data, NCS_IP_ADDR *i_addr, NCS_BOOL is_nwk_order)
{
NCS_IPV4_ADDR *v4_addrNet = 0;
uns16 len = 0;
switch (i_addr->type) {
case NCS_IP_ADDR_TYPE_IPV4:
v4_addrNet = (NCS_IPV4_ADDR *)o_oct_data;
if (is_nwk_order)
*v4_addrNet = i_addr->info.v4;
else
*v4_addrNet = m_NCS_OS_HTONL(i_addr->info.v4);
len = 4;
break;
#if(NCS_IPV6 == 1)
case NCS_IP_ADDR_TYPE_IPV6:
memcpy(o_oct_data, &i_addr->info.v6.m_ipv6_addr, NCS_IPV6_ADDR_UNS8_CNT);
len = NCS_IPV6_ADDR_UNS8_CNT;
break;
#endif
default:
break;
}
return len;
}
/****************************************************************************
* Name : dts_set_dta_up_down
*
* Description : Function marks DTA as up or down on receiving the up down
* event from the DTA.
*
* Arguments : node_id - Node ID of the node where DTA resides.
* adest - DTA destination address.
* up_down - Flag indicating whether DTA is up or down.
*
* Return Values : NCSCC_RC_SUCCESS/NCSCC_RC_FAILURE.
*
* Notes : None.
*****************************************************************************/
void dts_set_dta_up_down(NODE_ID node_id, MDS_DEST adest, NCS_BOOL up_down)
{
DTS_CB *inst = &dts_cb;
SVC_KEY key, nt_key;
DTS_SVC_REG_TBL *svc;
DTA_DEST_LIST *dta, *dta_ptr;
SVC_ENTRY *svc_entry;
/*MDS_DEST dta_key; */
OP_DEVICE *dev;
/* Network order key added */
nt_key.node = m_NCS_OS_HTONL(node_id);
nt_key.ss_svc_id = 0;
/* Check if node with node_id already exists. If it doesn't, return */
if ((svc = (DTS_SVC_REG_TBL *)ncs_patricia_tree_get(&inst->svc_tbl, (const uns8 *)&nt_key)) == NULL) {
m_DTS_DBG_SINK(NCSCC_RC_FAILURE, "dts_set_dta_up_down: No svc node exists in patricia tree");
return;
}
if ((dta = (DTA_DEST_LIST *)ncs_patricia_tree_get(&inst->dta_list, (const uns8 *)&adest)) != NULL) {
/* Adjust the pointer to DTA with the offset */
dta = (DTA_DEST_LIST *)((long)dta - DTA_DEST_LIST_OFFSET);
dta->dta_up = up_down;
if (up_down == FALSE) {
m_LOG_DTS_EVT(DTS_EV_DTA_DOWN, 0, m_NCS_NODE_ID_FROM_MDS_DEST(dta->dta_addr),
(uns32)(dta->dta_addr));
/* go through the svc_list of DTA removing DTA frm all those svcs */
svc_entry = dta->svc_list;
while (svc_entry != NULL) {
svc = svc_entry->svc;
if (svc == NULL) {
svc_entry = svc_entry->next_in_dta_entry;
continue;
}
key = svc->my_key;
if ((dta_ptr = (DTA_DEST_LIST *)dts_find_dta(svc, &dta->dta_addr)) != NULL) {
/* Remove dta entry frm svc->v_cd_list */
if ((dta_ptr = (DTA_DEST_LIST *)dts_dequeue_dta(svc, dta_ptr)) == NULL) {
m_DTS_DBG_SINK(NCSCC_RC_FAILURE,
"dts_set_dta_up_down: Unable to remove dta entry frm svc->v_cd_list");
break;
}
m_LOG_DTS_EVT(DTS_EV_SVC_DTA_RMV, svc->my_key.ss_svc_id, svc->my_key.node,
(uns32)(dta_ptr->dta_addr));
/* Versioning support - Remove spec entry corresponding to the
* DTA from svc's spec_list.
* Note: Even when spec's use_count becomes 0 don't call unload
* of library here. Unload will be called only in case of
* service unregister.
*/
if (dts_del_spec_frm_svc(svc, adest, NULL) != NCSCC_RC_SUCCESS)
m_DTS_DBG_SINK(NCSCC_RC_FAILURE,
"dts_set_dta_up_down: Unable to remove spec entry");
/* Point to the next svc in DTA svc_list */
svc_entry = svc_entry->next_in_dta_entry;
/*Remove svc entry frm dta->svc_list */
if ((svc = (DTS_SVC_REG_TBL *)dts_del_svc_frm_dta(dta_ptr, svc)) == NULL) {
m_DTS_DBG_SINK(NCSCC_RC_FAILURE,
"dts_set_dta_up_down: Unable to remove svc from dta->svc_list");
break;
}
m_LOG_DTS_EVT(DTS_EV_DTA_SVC_RMV, svc->my_key.ss_svc_id, svc->my_key.node,
(uns32)(dta_ptr->dta_addr));
if (svc->dta_count == 0) {
dts_circular_buffer_free(&svc->device.cir_buffer);
dev = &svc->device;
/* Cleanup the DTS_FILE_LIST datastructure for svc */
m_DTS_FREE_FILE_LIST(dev);
if ((TRUE == svc->device.file_open) && (svc->device.svc_fh != NULL)) {
fclose(svc->device.svc_fh);
svc->device.svc_fh = NULL;
svc->device.file_open = FALSE;
svc->device.new_file = TRUE;
svc->device.cur_file_size = 0;
}
/* Cleanup the console devices associated with the node */
m_DTS_RMV_ALL_CONS(dev);
ncs_patricia_tree_del(&inst->svc_tbl, (NCS_PATRICIA_NODE *)svc);
m_LOG_DTS_EVT(DTS_EV_SVC_DEREG_SUCCESSFUL, key.ss_svc_id, key.node,
(uns32)(dta_ptr->dta_addr));
if (NULL != svc)
m_MMGR_FREE_SVC_REG_TBL(svc);
}
} /*end of if */
else {
m_DTS_DBG_SINK(NCSCC_RC_FAILURE,
"dts_set_dta_up_down: dta entry missing in svc->v_cd_list");
/* hop to the next service */
svc_entry = svc_entry->next_in_dta_entry;
}
} /* end of while */
/*At the end of while loop svc_list shud point to NULL */
dta->svc_list = NULL;
if (ncs_patricia_tree_del(&inst->dta_list, (NCS_PATRICIA_NODE *)&dta->node) != NCSCC_RC_SUCCESS) {
m_LOG_DTS_EVT(DTS_EV_DTA_DEST_RMV_FAIL, 0, m_NCS_NODE_ID_FROM_MDS_DEST(dta->dta_addr),
(uns32)(dta->dta_addr));
m_DTS_DBG_SINK(NCSCC_RC_FAILURE,
"dts_set_dta_up_down: Unable to remove DTA entry frm patricia tree");
return;
}
m_LOG_DTS_EVT(DTS_EV_DTA_DEST_RMV_SUCC, 0, m_NCS_NODE_ID_FROM_MDS_DEST(dta->dta_addr),
(uns32)(dta->dta_addr));
/* Send Async update (REMOVE) for DTA_DEST_LIST */
m_DTSV_SEND_CKPT_UPDT_ASYNC(inst, NCS_MBCSV_ACT_RMV, (MBCSV_REO_HDL)(long)dta,
DTSV_CKPT_DTA_DEST_LIST_CONFIG);
if (NULL != dta)
m_MMGR_FREE_VCARD_TBL(dta);
}
/* end of up_down == FALSE */
else if ((TRUE == up_down) && (TRUE == dta->updt_req)) {
/* send filter config msg for all svcs for this dta */
m_LOG_DTS_EVT(DTS_EV_DTA_UP, 0, m_NCS_NODE_ID_FROM_MDS_DEST(dta->dta_addr),
(uns32)(dta->dta_addr));
svc_entry = dta->svc_list;
while (svc_entry != NULL) {
dts_send_filter_config_msg(inst, svc_entry->svc, dta);
dta->updt_req = FALSE;
svc_entry = svc_entry->next_in_dta_entry;
}
}
}
/* end of if dta = ncs_patricia_tree_get() */
else {
/*Nothing to do */
}
}
/****************************************************************************
* Name : eds_proc_publish_msg
*
* Description : This is the function which is called when eds receives a
* EDSV_EDA_PUBLISH message.
*
* Arguments : msg - Message that was posted to the EDS Mail box.
*
* Return Values : NCSCC_RC_SUCCESS/NCSCC_RC_FAILURE
*
* Notes : None.
*****************************************************************************/
static uint32_t eds_proc_publish_msg(EDS_CB *cb, EDSV_EDS_EVT *evt)
{
uint32_t rc = NCSCC_RC_SUCCESS;
uint32_t async_rc = NCSCC_RC_SUCCESS;
uint32_t copen_id_Net;
SaTimeT publish_time = 0; /* placeholder for now */
MDS_SEND_PRIORITY_TYPE prio;
EDS_WORKLIST *wp;
CHAN_OPEN_REC *co;
SUBSC_REC *subrec;
EDSV_MSG msg;
time_t time_of_day;
EDSV_EDA_PUBLISH_PARAM *publish_param;
uint32_t retd_evt_chan_open_id = 0;
EDS_CKPT_DATA ckpt;
publish_param = &(evt->info.msg.info.api_info.param).publish;
TRACE_ENTER2("agent dest: %" PRIx64, evt->fr_dest);
/* Get worklist ptr for this chan */
wp = eds_get_worklist_entry(cb->eds_work_list, publish_param->chan_id);
if (!wp) {
TRACE_LEAVE();
return (NCSCC_RC_FAILURE);
}
/* Set the publish time here */
m_NCS_OS_GET_TIME_STAMP(time_of_day);
/* convert time_t to SaTimeT */
publish_time = (SaTimeT)time_of_day;
eds_publish_log_event(wp, publish_param, publish_time);
/** If this event needs to be retained then
** we need to validate the publisher's copen
** id and retain the event
**/
if (publish_param->retention_time > 0) {
/* Grab the chan_open_rec for this id */
copen_id_Net = m_NCS_OS_HTONL(publish_param->chan_open_id);
if (NULL == (co = (CHAN_OPEN_REC *)ncs_patricia_tree_get(&wp->chan_open_rec, (uint8_t *)&copen_id_Net))) {
TRACE_LEAVE2("patricia get failed");
return (NCSCC_RC_FAILURE);
}
rc = eds_store_retained_event(cb, wp, co, publish_param, publish_time);
if (rc != NCSCC_RC_SUCCESS) {
TRACE_LEAVE();
return (NCSCC_RC_FAILURE);
} else
/** store the parent channel's event id
**/
retd_evt_chan_open_id = co->chan_open_id;
}
/** Let's try to publish
** this event now
**/
/* Go through all chan_open_rec's under this channel */
co = (CHAN_OPEN_REC *)ncs_patricia_tree_getnext(&wp->chan_open_rec, (uint8_t *)0);
while (co) {
subrec = co->subsc_rec_head;
while (subrec) { /* while subscriptions... */
/* Does the patterns/filters match? */
if (eds_pattern_match(publish_param->pattern_array, subrec->filters)) {
/* Fill in the event record to send */
m_EDS_EDSV_DELIVER_EVENT_CB_MSG_FILL(msg,
co->reg_id,
subrec->subscript_id,
subrec->chan_id,
subrec->chan_open_id,
publish_param->pattern_array,
publish_param->priority,
publish_param->publisher_name,
publish_time,
publish_param->retention_time,
publish_param->event_id,
retd_evt_chan_open_id,
publish_param->data_len, publish_param->data)
/* Determine evt to MDS priority mapping */
prio = edsv_map_ais_prio_to_mds_snd_prio(publish_param->priority);
/* Send the event. Only once per match/per open_id */
if (NCSCC_RC_SUCCESS != (rc = eds_mds_msg_send(cb, &msg, &co->chan_opener_dest,
NULL, prio))) {
LOG_ER("Event Publish(MDS send) failed. From publisher dest: %" PRIx64
", To subscriber dest: %" PRIx64 ",on Node_id: %u", evt->fr_dest,
co->chan_opener_dest, m_NCS_NODE_ID_FROM_MDS_DEST(co->chan_opener_dest));
}
break;
}
subrec = subrec->next;
}
co = (CHAN_OPEN_REC *)ncs_patricia_tree_getnext(&wp->chan_open_rec, (uint8_t *)&co->copen_id_Net);
}
/** If this event has been retained, send an async update &
** transfer memory ownership here.
**/
if (0 != retd_evt_chan_open_id) {
/* Send an Async update to STANDBY EDS peer */
if (cb->ha_state == SA_AMF_HA_ACTIVE) {
memset(&ckpt, 0, sizeof(ckpt));
m_EDSV_FILL_ASYNC_UPDATE_RETAIN_EVT(ckpt, publish_param, publish_time)
async_rc = send_async_update(cb, &ckpt, NCS_MBCSV_ACT_ADD);
if (async_rc != NCSCC_RC_SUCCESS)
TRACE("Async Update Send Failed for Publish");
}
/* Now give the patternarray & data ownership to the reten record */
publish_param->pattern_array = NULL;
publish_param->data_len = 0;
publish_param->data = NULL;
}
/* End retd event chan open id */
TRACE_LEAVE();
return rc;
}
/****************************************************************************\
* Function: dtsv_ckpt_add_rmv_updt_dta_dest
*
* Purpose: Add new DTA entry if action is ADD, remove node from the tree if
* action is to remove and update data if request is to update.
*
* Input: cb - CB pointer.
* avnd - Decoded structur.
* action - ADD/RMV/UPDT
* key - SVC_KEY of the service associated with DTA being added/updated
*
* Returns: NCSCC_RC_SUCCESS/NCSCC_RC_FAILURE.
*
* NOTES: ADD will add to the Patricia tree. ADD also modifies svc_reg patricia
* tree by adding to svc_reg's v_cd_list.
* UPDT is not used.
* RMV will remove dta frm patricia tree and modify svc_reg patricia tree * only on DTA going down.
* Service de-regs are handled by svc_reg async updates.
*
* As per this IR param key is not passed in network order
\**************************************************************************/
uns32 dtsv_ckpt_add_rmv_updt_dta_dest(DTS_CB *cb, DTA_DEST_LIST *dtadest, NCS_MBCSV_ACT_TYPE action, SVC_KEY key)
{
uns32 status = NCSCC_RC_SUCCESS;
DTA_DEST_LIST *to_reg = NULL, *del_reg = NULL;
DTS_SVC_REG_TBL *svc = NULL;
OP_DEVICE *device = NULL;
MDS_DEST dta_key;
SVC_ENTRY *svc_entry = NULL;
SVC_KEY svc_key = {0, 0}, nt_key = {0, 0};
if (dtadest == NULL) {
return m_DTS_DBG_SINK(NCSCC_RC_FAILURE, "dtsv_ckpt_add_rmv_updt_dta_dest: DTA_DEST_LIST ptr is NULL");
}
dta_key = dtadest->dta_addr;
switch (action) {
case NCS_MBCSV_ACT_ADD:
{
SYSF_ASCII_SPECS *spec_entry = NULL;
ASCII_SPEC_INDEX spec_key;
SPEC_ENTRY *per_dta_svc_spec = NULL;
ASCII_SPEC_LIB *lib_hdl = NULL;
/* Network order key added */
nt_key.node = m_NCS_OS_HTONL(key.node);
nt_key.ss_svc_id = m_NCS_OS_HTONL(key.ss_svc_id);
m_DTS_LK(&cb->lock);
m_LOG_DTS_LOCK(DTS_LK_LOCKED, &cb->lock);
/* Find svc entry in svc_tbl patricia tree */
if ((svc =
(DTS_SVC_REG_TBL *)ncs_patricia_tree_get(&cb->svc_tbl, (const uns8 *)&nt_key)) == NULL) {
m_DTS_UNLK(&cb->lock);
m_LOG_DTS_LOCK(DTS_LK_UNLOCKED, &cb->lock);
m_LOG_DTS_EVT(DTS_EV_SVC_REG_NOTFOUND, key.ss_svc_id, key.node, (uns32)dta_key);
/*Service should have already been added to patricia tree */
return m_DTS_DBG_SINK(NCSCC_RC_FAILURE,
"dtsv_ckpt_add_rmv_updt_dta_dest: No service entry in Patricia Tree");
/*For cold-sync also, svc_reg cold sync has to happen prior to this */
}
/* Check if dta is already present in dta_dest patricia tree */
if ((to_reg =
(DTA_DEST_LIST *)ncs_patricia_tree_get(&cb->dta_list, (const uns8 *)&dta_key)) == NULL) {
to_reg = m_MMGR_ALLOC_VCARD_TBL;
if (to_reg == NULL) {
m_DTS_UNLK(&cb->lock);
m_LOG_DTS_LOCK(DTS_LK_UNLOCKED, &cb->lock);
return m_DTS_DBG_SINK(NCSCC_RC_FAILURE,
"dtsv_ckpt_add_rmv_updt_dta_dest: Memory allocation failed");
}
memset(to_reg, '\0', sizeof(DTA_DEST_LIST));
/* Update the fields of DTA_DEST_LIST */
to_reg->dta_addr = dtadest->dta_addr;
to_reg->dta_up = dtadest->dta_up;
to_reg->updt_req = dtadest->updt_req;
to_reg->dta_num_svcs = 0;
/*ncs_create_queue(&to_reg->svc_list); */
to_reg->node.key_info = (uns8 *)&to_reg->dta_addr;
to_reg->svc_list = NULL;
if (ncs_patricia_tree_add(&cb->dta_list, (NCS_PATRICIA_NODE *)&to_reg->node) !=
NCSCC_RC_SUCCESS) {
m_DTS_UNLK(&cb->lock);
m_LOG_DTS_LOCK(DTS_LK_UNLOCKED, &cb->lock);
m_LOG_DTS_EVT(DTS_EV_DTA_DEST_ADD_FAIL, 0, m_NCS_NODE_ID_FROM_MDS_DEST(dta_key),
(uns32)dta_key);
if (NULL != to_reg)
m_MMGR_FREE_VCARD_TBL(to_reg);
return m_DTS_DBG_SINK(NCSCC_RC_FAILURE,
"dtsv_ckpt_add_rmv_updt_dta_dest: Failed to add DTA list in Patricia tree");
}
m_LOG_DTS_EVT(DTS_EV_DTA_DEST_ADD_SUCC, 0, m_NCS_NODE_ID_FROM_MDS_DEST(dta_key),
(uns32)dta_key);
} else {
/* Not an error condition - DTA entry might already exist */
/* Adjust the pointer to to_reg with the offset */
to_reg = (DTA_DEST_LIST *)((long)to_reg - DTA_DEST_LIST_OFFSET);
/* Also check if dta-svc relationship already exists */
/* If it does then just break frm this case & return */
if (dts_find_dta(svc, &dta_key) != NULL) {
m_DTS_UNLK(&cb->lock);
m_LOG_DTS_LOCK(DTS_LK_UNLOCKED, &cb->lock);
return status;
}
}
/* If svc entry found, just add it to the dta */
dts_add_svc_to_dta(to_reg, svc);
m_LOG_DTS_EVT(DTS_EV_DTA_SVC_ADD, key.ss_svc_id, key.node, (uns32)dta_key);
/* Now add dta into the svc->v_cd_list */
dts_enqueue_dta(svc, to_reg);
m_LOG_DTS_EVT(DTS_EV_SVC_DTA_ADD, key.ss_svc_id, key.node, (uns32)dta_key);
/* Version support : Call to function to load ASCII_SPEC
* library. This function will load all versioning enabled
* ASCII_SPEC libraries.
*/
/* First check whether CB last_spec_loaded has valid svc_name or not
* If not, then break else continue to load library
*/
if (*cb->last_spec_loaded.svc_name == 0) {
m_DTS_UNLK(&cb->lock);
m_LOG_DTS_LOCK(DTS_LK_UNLOCKED, &cb->lock);
break;
}
lib_hdl =
(ASCII_SPEC_LIB *)dts_ascii_spec_load(cb->last_spec_loaded.svc_name,
cb->last_spec_loaded.version, 1);
/* memset the spec_key first before filling it up */
memset(&spec_key, '\0', sizeof(ASCII_SPEC_INDEX));
spec_key.svc_id = svc->ntwk_key.ss_svc_id;
spec_key.ss_ver = cb->last_spec_loaded.version;
/*Check if ASCII_SPEC table for this service is already loaded.
* If no, read the config file */
if ((spec_entry =
(SYSF_ASCII_SPECS *)ncs_patricia_tree_get(&cb->svcid_asciispec_tree,
(const uns8 *)&spec_key)) == NULL) {
/* If ASCII_SPEC table is versioning enabled, this means
* service name & version specified was incorrect.
*/
dts_log(NCSFL_SEV_ERROR, "\n Service cribbing : %d\n", svc->my_key.ss_svc_id);
fflush(stdout);
m_DTS_DBG_SINK(NCSCC_RC_FAILURE,
"dtsv_ckpt_add_rmv_updt_dta_dest: ASCII_SPEC library couldn't be loaded. Check service name & version no. across ASCII_SPEC tables, registration parameters & library name.");
} else {
/* Add an ASCII_SPEC entry for each service registration.
* So any log message will directly index to this entry and
* get the relevant spec pointer to use.
*/
per_dta_svc_spec = m_MMGR_ALLOC_DTS_SVC_SPEC;
if (per_dta_svc_spec == NULL) {
m_DTS_UNLK(&cb->lock);
m_LOG_DTS_EVT(DTS_EV_DTA_DEST_ADD_FAIL, 0, m_NCS_NODE_ID_FROM_MDS_DEST(dta_key),
(uns32)dta_key);
/* Do rest of cleanup, cleaning service regsitration table etc */
return m_DTS_DBG_SINK(NCSCC_RC_FAILURE,
"dtsv_ckpt_add_rmv_updt_dta_dest: Memory allocation failed");
}
memset(per_dta_svc_spec, '\0', sizeof(SPEC_ENTRY));
per_dta_svc_spec->dta_addr = dta_key;
per_dta_svc_spec->spec_struct = spec_entry;
per_dta_svc_spec->lib_struct = lib_hdl;
strcpy(per_dta_svc_spec->svc_name, cb->last_spec_loaded.svc_name);
/* Add to the svc reg tbl's spec list */
per_dta_svc_spec->next_spec_entry = svc->spec_list; /* point next to the rest of list */
svc->spec_list = per_dta_svc_spec; /*Add new struct to start of list */
/* Increment use count */
spec_entry->use_count++;
}
m_DTS_UNLK(&cb->lock);
m_LOG_DTS_LOCK(DTS_LK_UNLOCKED, &cb->lock);
}
break;
/* Yet not using UPDT for DTA_DEST_LIST */
case NCS_MBCSV_ACT_UPDATE:
{
m_DTS_LK(&cb->lock);
m_LOG_DTS_LOCK(DTS_LK_LOCKED, &cb->lock);
if ((to_reg =
(DTA_DEST_LIST *)ncs_patricia_tree_get(&cb->dta_list, (const uns8 *)&dta_key)) == NULL) {
m_DTS_UNLK(&cb->lock);
m_LOG_DTS_LOCK(DTS_LK_UNLOCKED, &cb->lock);
return m_DTS_DBG_SINK(NCSCC_RC_FAILURE,
"dtsv_ckpt_add_rmv_updt_dta_dest: NCS_MBCSV_ACT_UPDATE - DTA entry does not exist in Patricia Tree");
}
to_reg = (DTA_DEST_LIST *)((long)to_reg - DTA_DEST_LIST_OFFSET);
to_reg->dta_addr = dtadest->dta_addr;
to_reg->dta_up = dtadest->dta_up;
to_reg->updt_req = dtadest->updt_req;
m_DTS_UNLK(&cb->lock);
m_LOG_DTS_LOCK(DTS_LK_UNLOCKED, &cb->lock);
}
break;
case NCS_MBCSV_ACT_RMV:
{
m_DTS_LK(&cb->lock);
m_LOG_DTS_LOCK(DTS_LK_LOCKED, &cb->lock);
if ((to_reg =
(DTA_DEST_LIST *)ncs_patricia_tree_get(&cb->dta_list, (const uns8 *)&dta_key)) != NULL) {
to_reg = (DTA_DEST_LIST *)((long)to_reg - DTA_DEST_LIST_OFFSET);
svc_entry = to_reg->svc_list;
/* Remove dta entry frm the svc->v_cd_lists for all svcs */
while (svc_entry != NULL) {
svc = svc_entry->svc;
if (svc != NULL) {
svc_key = svc->my_key;
/* Network order key added */
nt_key = svc->ntwk_key;
}
if ((svc =
(DTS_SVC_REG_TBL *)ncs_patricia_tree_get(&cb->svc_tbl,
(const uns8 *)&nt_key)) == NULL) {
m_DTS_UNLK(&cb->lock);
m_LOG_DTS_LOCK(DTS_LK_UNLOCKED, &cb->lock);
m_LOG_DTS_EVT(DTS_EV_SVC_REG_NOTFOUND, svc_key.ss_svc_id, svc_key.node,
(uns32)to_reg->dta_addr);
return m_DTS_DBG_SINK(NCSCC_RC_FAILURE,
"dtsv_ckpt_add_rmv_updt_dta_dest: Service entry not found in Patricia tree");
}
/* remove dta from svc->v_cd_list */
if ((del_reg = (DTA_DEST_LIST *)dts_dequeue_dta(svc, to_reg)) == NULL) {
m_LOG_DTS_EVT(DTS_EV_SVC_DTA_RMV_FAIL, svc_key.ss_svc_id, svc_key.node,
(uns32)to_reg->dta_addr);
/* Don't return failure, continue rmeoving service frm dta */
m_DTS_DBG_SINK(NCSCC_RC_FAILURE,
"dtsv_ckpt_add_rmv_updt_dta_dest: Failed to remove dta entry frm svc->v_cd_list");
} else
m_LOG_DTS_EVT(DTS_EV_SVC_DTA_RMV, svc_key.ss_svc_id, svc_key.node,
(uns32)to_reg->dta_addr);
/* Versioning support: Remove spec entry corresponding to the
* DTA from svc's spec_list.
*/
if (dts_del_spec_frm_svc(svc, dta_key, NULL) != NCSCC_RC_SUCCESS) {
m_DTS_DBG_SINK(NCSCC_RC_FAILURE,
"dtsv_ckpt_add_rmv_updt_dta_dest: Unable to remove spec entry");
}
/*Point to next entry before deleting svc frm svc_list */
svc_entry = svc_entry->next_in_dta_entry;
/* remove svc from dta->svc_list */
if ((svc = (DTS_SVC_REG_TBL *)dts_del_svc_frm_dta(to_reg, svc)) == NULL) {
m_LOG_DTS_EVT(DTS_EV_DTA_SVC_RMV_FAIL, svc_key.ss_svc_id, svc_key.node,
(uns32)to_reg->dta_addr);
/* Don't return, continue */
m_DTS_DBG_SINK(NCSCC_RC_FAILURE,
"dtsv_ckpt_add_rmv_updt_dta_dest: Failed to delete svc from dta->svc_list");
} else
m_LOG_DTS_EVT(DTS_EV_DTA_SVC_RMV, svc_key.ss_svc_id, svc_key.node,
(uns32)to_reg->dta_addr);
/* Check if svc entry is required or not */
if (svc->dta_count == 0) {
if (&svc->device.cir_buffer != NULL)
dts_circular_buffer_free(&svc->device.cir_buffer);
device = &svc->device;
m_DTS_FREE_FILE_LIST(device);
ncs_patricia_tree_del(&cb->svc_tbl, (NCS_PATRICIA_NODE *)svc);
m_LOG_DTS_EVT(DTS_EV_SVC_REG_ENT_RMVD, svc_key.ss_svc_id, svc_key.node,
(uns32)to_reg->dta_addr);
if (svc != NULL)
m_MMGR_FREE_SVC_REG_TBL(svc);
}
} /*end of while svc!=NULL */
/* Now delete the dta entry */
if (to_reg->svc_list == NULL) {
ncs_patricia_tree_del(&cb->dta_list, (NCS_PATRICIA_NODE *)&to_reg->node);
m_LOG_DTS_EVT(DTS_EV_DTA_DEST_RMV_SUCC, 0,
m_NCS_NODE_ID_FROM_MDS_DEST(to_reg->dta_addr),
(uns32)to_reg->dta_addr);
if (NULL != to_reg)
m_MMGR_FREE_VCARD_TBL(to_reg);
}
} else {
/* Not an error condition */
}
m_DTS_UNLK(&cb->lock);
m_LOG_DTS_LOCK(DTS_LK_UNLOCKED, &cb->lock);
}
break;
default:
/* Log error */
status = NCSCC_RC_FAILURE;
}
return status;
}
/****************************************************************************\
* Function: dtsv_ckpt_add_rmv_updt_svc_reg
*
* Purpose: Add new entry if action is ADD, remove from the table if
* action is to remove and update data if request is to update.
*
* Input: cb - CB pointer.
* svcreg - pointer to SVC REG table structure.
* action - ADD/RMV/UPDT
*
* Returns: NCSCC_RC_SUCCESS/NCSCC_RC_FAILURE.
*
* NOTES: ADD takes care of forming the node entry for DTS_SVC_REG_TBL as well
* as forming the individual service node.
* ADD just adds svc_reg to DTA Patricia tree.
* Hence, DTS_SVC_REG_TBL Async update(ADD) needs to be sent after
* modification on the DTA Patricia tree in active DTS.
* UPDT takes care of the changes in policy/filtering settings.
* DTS_SVC_REG_TBL ADD happens before DTA_DEST_LIST ADD.
* DTS_SVC_REG_TBL RMV takes care of removing svc entries from all DTAs
* in its v_cd_list.
\**************************************************************************/
uns32 dtsv_ckpt_add_rmv_updt_svc_reg(DTS_CB *cb, DTS_SVC_REG_TBL *svcreg,
NCS_MBCSV_ACT_TYPE action)
{
uns32 status = NCSCC_RC_SUCCESS;
DTS_SVC_REG_TBL *svc_ptr = NULL, *node_reg_ptr = NULL;
DTA_DEST_LIST *to_reg = NULL;
SVC_KEY nt_key, key;
OP_DEVICE *device = NULL;
DTA_ENTRY *dta_entry = NULL;
MDS_DEST *vkey = NULL;
switch (action) {
case NCS_MBCSV_ACT_ADD:
{
/*
* add new SVC_REG entry into pat tree.
*/
key.node = svcreg->my_key.node;
key.ss_svc_id = 0;
/* Network order key added */
nt_key.node = m_NCS_OS_HTONL(svcreg->my_key.node);
nt_key.ss_svc_id = 0;
m_DTS_LK(&cb->lock);
m_LOG_DTS_LOCK(DTS_LK_LOCKED, &cb->lock);
/* Check whether the Node exist in the node registration table
* if yes, do nothing else create new entry in table and
* fill the datastructure*/
if ((node_reg_ptr =
(DTS_SVC_REG_TBL *)ncs_patricia_tree_get(&cb->svc_tbl, (const uns8 *)&nt_key)) == NULL) {
node_reg_ptr = m_MMGR_ALLOC_SVC_REG_TBL;
if (node_reg_ptr == NULL) {
m_DTS_UNLK(&cb->lock);
m_LOG_DTS_LOCK(DTS_LK_UNLOCKED, &cb->lock);
return m_DTS_DBG_SINK(NCSCC_RC_FAILURE,
"dtsv_ckpt_add_rmv_updt_svc_reg: Memory allocation failed");
}
memset(node_reg_ptr, '\0', sizeof(DTS_SVC_REG_TBL));
/* Check for NULL value of svcreg parameter, if not NULL
Copy the attributes of the node passed by decoder */
node_reg_ptr->my_key.node = key.node;
node_reg_ptr->my_key.ss_svc_id = 0;
/* Network order key added */
node_reg_ptr->ntwk_key = nt_key;
node_reg_ptr->node.key_info = (uns8 *)&node_reg_ptr->ntwk_key;
node_reg_ptr->v_cd_list = NULL;
node_reg_ptr->dta_count = 0;
node_reg_ptr->my_node = node_reg_ptr;
if (svcreg->my_key.ss_svc_id == 0) { /*updt for node entry */
/*cold sync update for node entry, set attributes accordingly */
m_DTS_SET_SVC_REG_TBL(node_reg_ptr, svcreg);
} else {
/*async update for new svc_reg, so initialize node param */
node_reg_ptr->per_node_logging = NODE_LOGGING;
/* Copy attributes of node policy & op device */
node_reg_ptr->svc_policy.enable = NODE_ENABLE;
node_reg_ptr->svc_policy.category_bit_map = NODE_CATEGORY_FILTER;
node_reg_ptr->svc_policy.severity_bit_map = NODE_SEVERITY_FILTER;
node_reg_ptr->svc_policy.log_dev = NODE_LOG_DEV;
node_reg_ptr->svc_policy.log_file_size = NODE_LOGFILE_SIZE;
node_reg_ptr->svc_policy.file_log_fmt = NODE_FILE_LOG_FMT;
node_reg_ptr->svc_policy.cir_buff_size = NODE_CIR_BUFF_SIZE;
node_reg_ptr->svc_policy.buff_log_fmt = NODE_BUFF_LOG_FMT;
node_reg_ptr->device.new_file = TRUE;
node_reg_ptr->device.file_open = FALSE;
node_reg_ptr->device.last_rec_id = 0;
}
/* Add the node to the patricia tree */
if (ncs_patricia_tree_add(&cb->svc_tbl, (NCS_PATRICIA_NODE *)node_reg_ptr) !=
NCSCC_RC_SUCCESS) {
/* Attempt to add node was unsuccessful */
if (NULL != node_reg_ptr)
m_MMGR_FREE_SVC_REG_TBL(node_reg_ptr);
m_DTS_UNLK(&cb->lock);
m_LOG_DTS_LOCK(DTS_LK_UNLOCKED, &cb->lock);
m_LOG_DTS_SVCREG_ADD_FAIL(DTS_EV_SVC_REG_ENT_ADD_FAIL, key.ss_svc_id, key.node,
0);
m_LOG_DTS_EVT(DTS_EV_SVC_REG_FAILED, key.ss_svc_id, key.node, 0);
return m_DTS_DBG_SINK(NCSCC_RC_FAILURE,
"dtsv_ckpt_add_rmv_updt_svc_reg : Failed to add node registration in Patricia tree");
}
m_LOG_DTS_EVT(DTS_EV_SVC_REG_ENT_ADD, key.ss_svc_id, key.node, 0);
}
/*end of creating new entry for node */
key.ss_svc_id = svcreg->my_key.ss_svc_id;
/* Network order key added */
nt_key.ss_svc_id = m_NCS_OS_HTONL(svcreg->my_key.ss_svc_id);
/* Check whether the Service exist in the service registration
* table. If yes, then add the DTA v-card in the v-card queue.
* If NO then create new entry in the table. Initialize it with
* the default.Enqueue the v-card in the v-card table. */
if ((svc_ptr =
(DTS_SVC_REG_TBL *)ncs_patricia_tree_get(&cb->svc_tbl, (const uns8 *)&nt_key)) != NULL) {
/* Do nothing */
m_LOG_DTS_EVT(DTS_EV_SVC_ALREADY_REG, key.ss_svc_id, key.node, 0);
} /* end of if svc_ptr */
else {
/* Add to patricia tree; then create link list and add the new
* element to it */
svc_ptr = m_MMGR_ALLOC_SVC_REG_TBL;
if (svc_ptr == NULL) {
m_DTS_UNLK(&cb->lock);
m_LOG_DTS_LOCK(DTS_LK_UNLOCKED, &cb->lock);
return m_DTS_DBG_SINK(NCSCC_RC_FAILURE,
"dtsv_ckpt_add_rmv_updt_svc_reg : Memory allocation failed");
}
memset(svc_ptr, '\0', sizeof(DTS_SVC_REG_TBL));
svc_ptr->my_key.ss_svc_id = key.ss_svc_id;
svc_ptr->my_key.node = key.node;
/* Network order key added */
svc_ptr->ntwk_key = nt_key;
svc_ptr->node.key_info = (uns8 *)&svc_ptr->ntwk_key;
svc_ptr->v_cd_list = NULL;
svc_ptr->dta_count = 0;
svc_ptr->my_node = node_reg_ptr;
m_DTS_SET_SVC_REG_TBL(svc_ptr, svcreg);
if (ncs_patricia_tree_add(&cb->svc_tbl, (NCS_PATRICIA_NODE *)svc_ptr) !=
NCSCC_RC_SUCCESS) {
/* Attempt to add node was unsuccessful */
if (NULL != svc_ptr)
m_MMGR_FREE_SVC_REG_TBL(svc_ptr);
m_DTS_UNLK(&cb->lock);
m_LOG_DTS_LOCK(DTS_LK_UNLOCKED, &cb->lock);
m_LOG_DTS_SVCREG_ADD_FAIL(DTS_EV_SVC_REG_ENT_ADD_FAIL, key.ss_svc_id, key.node,
0);
m_LOG_DTS_EVT(DTS_EV_SVC_REG_FAILED, key.ss_svc_id, key.node, 0);
return m_DTS_DBG_SINK(NCSCC_RC_FAILURE,
"dtsv_ckpt_add_rmv_updt_svc_reg : Failed to add service entry in patricia tree");
}
m_LOG_DTS_EVT(DTS_EV_SVC_REG_ENT_ADD, key.ss_svc_id, key.node, 0);
svc_ptr->device.last_rec_id = svcreg->device.last_rec_id;
m_LOG_DTS_EVT(DTS_EV_SVC_REG_SUCCESSFUL, key.ss_svc_id, key.node, 0);
} /*end of else */
m_DTS_UNLK(&cb->lock);
m_LOG_DTS_LOCK(DTS_LK_UNLOCKED, &cb->lock);
}
break;
case NCS_MBCSV_ACT_UPDATE:
{
if (NULL != svcreg) {
key = svcreg->my_key;
/* Network order key added */
nt_key.node = m_NCS_OS_HTONL(key.node);
nt_key.ss_svc_id = m_NCS_OS_HTONL(key.ss_svc_id);
m_DTS_LK(&cb->lock);
m_LOG_DTS_LOCK(DTS_LK_LOCKED, &cb->lock);
if (svcreg->my_key.ss_svc_id == 0) { /*Node policy change */
/* update the policy for all services in the node */
if ((svc_ptr =
(DTS_SVC_REG_TBL *)ncs_patricia_tree_get(&cb->svc_tbl,
(const uns8 *)&nt_key)) == NULL) {
m_DTS_UNLK(&cb->lock);
m_LOG_DTS_LOCK(DTS_LK_UNLOCKED, &cb->lock);
m_LOG_DTS_EVT(DTS_EV_SVC_REG_NOTFOUND, key.ss_svc_id, key.node, 0);
return m_DTS_DBG_SINK(NCSCC_RC_FAILURE,
"dtsv_ckpt_add_rmv_updt_svc_reg : Node entry not found in the patricia tree");
}
/* Update this node first */
m_DTS_SET_SVC_REG_TBL(svc_ptr, svcreg);
m_LOG_DTS_EVT(DTS_EV_SVC_REG_ENT_UPDT, key.ss_svc_id, key.node, 0);
if (cb->cli_bit_map != 0) {
while ((svc_ptr != NULL) && (svc_ptr->my_key.node == key.node)) {
switch (cb->cli_bit_map) {
case osafDtsvNodeMessageLogging_ID:
if (svcreg->per_node_logging == FALSE)
svc_ptr->device.new_file = TRUE;
break;
case osafDtsvNodeCategoryBitMap_ID:
svc_ptr->svc_policy.category_bit_map =
svcreg->svc_policy.category_bit_map;
break;
case osafDtsvNodeLoggingState_ID:
svc_ptr->svc_policy.enable =
svcreg->svc_policy.enable;
break;
case osafDtsvNodeSeverityBitMap_ID:
svc_ptr->svc_policy.severity_bit_map =
svcreg->svc_policy.severity_bit_map;
break;
default:
/* Do nothing, it should not hit this */
break;
} /*end of switch */
nt_key = svc_ptr->ntwk_key;
/*m_DTS_SET_SVC_REG_TBL(svc_ptr, svcreg); */
m_LOG_DTS_EVT(DTS_EV_SVC_REG_ENT_UPDT, key.ss_svc_id, key.node,
0);
svc_ptr =
(DTS_SVC_REG_TBL *)dts_get_next_svc_entry(&cb->svc_tbl,
(SVC_KEY *)
&nt_key);
} /*end of while */
/* Re-set the cli_bit_map for subsequent policy changes */
cb->cli_bit_map = 0;
} /*end of if cli_bit_map */
} else { /*Service policy change */
if ((svc_ptr =
(DTS_SVC_REG_TBL *)ncs_patricia_tree_get(&cb->svc_tbl,
(const uns8 *)&nt_key)) == NULL) {
m_DTS_UNLK(&cb->lock);
m_LOG_DTS_LOCK(DTS_LK_UNLOCKED, &cb->lock);
m_LOG_DTS_EVT(DTS_EV_SVC_REG_NOTFOUND, key.ss_svc_id, key.node, 0);
return m_DTS_DBG_SINK(NCSCC_RC_FAILURE,
"dtsv_ckpt_add_rmv_updt_svc_reg : Service entry not found in the patricia tree");
} else {
m_DTS_SET_SVC_REG_TBL(svc_ptr, svcreg);
m_LOG_DTS_EVT(DTS_EV_SVC_REG_ENT_UPDT, key.ss_svc_id, key.node, 0);
}
}
m_DTS_UNLK(&cb->lock);
m_LOG_DTS_LOCK(DTS_LK_UNLOCKED, &cb->lock);
} else {
return NCSCC_RC_FAILURE;
}
}
break;
case NCS_MBCSV_ACT_RMV:
{
SPEC_CKPT spec_info;
if (NULL != svcreg) {
key.node = svcreg->my_key.node;
key.ss_svc_id = svcreg->my_key.ss_svc_id;
/* Network order key added */
nt_key.node = m_NCS_OS_HTONL(key.node);
nt_key.ss_svc_id = m_NCS_OS_HTONL(key.ss_svc_id);
m_DTS_LK(&cb->lock);
m_LOG_DTS_LOCK(DTS_LK_LOCKED, &cb->lock);
if ((svc_ptr =
(DTS_SVC_REG_TBL *)ncs_patricia_tree_get(&cb->svc_tbl,
(const uns8 *)&nt_key)) == NULL) {
m_DTS_UNLK(&cb->lock);
m_LOG_DTS_LOCK(DTS_LK_UNLOCKED, &cb->lock);
m_LOG_DTS_EVT(DTS_EV_SVC_REG_NOTFOUND, key.ss_svc_id, key.node, 0);
/* Return Success, since svc is already not present */
return m_DTS_DBG_SINK(NCSCC_RC_SUCCESS,
"dtsv_ckpt_add_rmv_updt_svc_reg : Service entry not found in patricia tree");
}
/*The DTA to be removed from svc_reg->v_cd_list is stored in
* DTS_CB's svc_rmv_mds_dest.
* If svc_rmv_mds_dest is 0, then the svc->dta_count should already
* be zero else there's an error.
* If svc_rmv_mds_dest is not zero, then it is async update for
* svc unregister. In this case, remove the DTA with MDS_DEST
* the same as cb->svc_rmv_mds_dest from
* svc_ptr->v-cd_list, also remove svc entry from dta->svc_list.
*/
if (cb->svc_rmv_mds_dest == 0) {
if (svc_ptr->dta_count == 0) {
if (&svc_ptr->device.cir_buffer != NULL)
dts_circular_buffer_free(&svc_ptr->device.cir_buffer);
device = &svc_ptr->device;
/* Cleanup the DTS_FILE_LIST datastructure for svc */
m_DTS_FREE_FILE_LIST(device);
ncs_patricia_tree_del(&cb->svc_tbl, (NCS_PATRICIA_NODE *)svc_ptr);
m_LOG_DTS_EVT(DTS_EV_SVC_REG_ENT_RMVD, key.ss_svc_id, key.node, 0);
if (NULL != svc_ptr)
m_MMGR_FREE_SVC_REG_TBL(svc_ptr);
m_DTS_UNLK(&cb->lock);
m_LOG_DTS_LOCK(DTS_LK_UNLOCKED, &cb->lock);
return NCSCC_RC_SUCCESS;
} else {
m_LOG_DTS_EVT(DTS_EV_SVC_DEREG_FAILED, key.ss_svc_id, key.node, 0);
m_DTS_UNLK(&cb->lock);
m_LOG_DTS_LOCK(DTS_LK_UNLOCKED, &cb->lock);
return m_DTS_DBG_SINK(NCSCC_RC_FAILURE,
"dtsv_ckpt_add_rmv_updt_svc_reg: Either MDS_DEST for async update is wrong or database is inconsistent");
}
} /*end of if(cb->svc_rmv_mds_dest == 0) */
else {
vkey = &cb->svc_rmv_mds_dest;
dta_entry = svc_ptr->v_cd_list;
/* iterate through v_cd_list to find the dta to be removed */
while (dta_entry != NULL) {
to_reg = dta_entry->dta;
/* Point to next dta entry before deletion */
dta_entry = dta_entry->next_in_svc_entry;
/*Check if the MDS_DEST for the dta to be removed matches */
if (dts_find_reg(vkey, to_reg) == TRUE) {
if ((svc_ptr =
(DTS_SVC_REG_TBL *)dts_del_svc_frm_dta(to_reg,
svc_ptr)) == NULL) {
m_DTS_UNLK(&cb->lock);
m_LOG_DTS_LOCK(DTS_LK_UNLOCKED, &cb->lock);
m_LOG_DTS_EVT(DTS_EV_DTA_SVC_RMV_FAIL, key.ss_svc_id,
key.node, (uns32)to_reg->dta_addr);
m_LOG_DTS_EVT(DTS_EV_SVC_DEREG_FAILED, key.ss_svc_id,
key.node, (uns32)to_reg->dta_addr);
return m_DTS_DBG_SINK(NCSCC_RC_FAILURE,
"dtsv_ckpt_add_rmv_updt_svc_reg: Unable to remove svc reg entry from dta's list");
}
m_LOG_DTS_EVT(DTS_EV_DTA_SVC_RMV, key.ss_svc_id, key.node,
(uns32)to_reg->dta_addr);
/* Remove dta entry frm svc_ptr->v_cd_list */
if ((to_reg =
(DTA_DEST_LIST *)dts_dequeue_dta(svc_ptr,
to_reg)) == NULL) {
m_DTS_UNLK(&cb->lock);
m_LOG_DTS_LOCK(DTS_LK_UNLOCKED, &cb->lock);
m_LOG_DTS_EVT(DTS_EV_SVC_DTA_RMV_FAIL, key.ss_svc_id,
key.node, (uns32)to_reg->dta_addr);
m_LOG_DTS_EVT(DTS_EV_SVC_DEREG_FAILED, key.ss_svc_id,
key.node, (uns32)to_reg->dta_addr);
return m_DTS_DBG_SINK(NCSCC_RC_FAILURE,
"dtsv_ckpt_add_rmv_updt_svc_reg: Unable to remove adest entry");
}
m_LOG_DTS_EVT(DTS_EV_SVC_DTA_RMV, key.ss_svc_id, key.node,
(uns32)to_reg->dta_addr);
memset(&spec_info, '\0', sizeof(SPEC_CKPT));
/* Versioning support : Remove spec entry corresponding to
* the DTA from svc's spec_list. */
if (dts_del_spec_frm_svc(svc_ptr, *vkey, &spec_info) !=
NCSCC_RC_SUCCESS) {
m_DTS_DBG_SINK(NCSCC_RC_FAILURE,
"dtsv_ckpt_add_rmv_updt_svc_reg: Unable to remove spec entry");
}
/* Call function to unload the ASCII_SPEC library if
* use_count of the library has become 0.
*/
dts_ascii_spec_load(spec_info.svc_name, spec_info.version, 0);
/* If dta svc queue is empty delete dta frm patricia tree */
if (to_reg->svc_list == NULL) {
/*ncs_destroy_queue(&to_reg->svc_list); */
ncs_patricia_tree_del(&cb->dta_list,
(NCS_PATRICIA_NODE *)
&to_reg->node);
m_LOG_DTS_EVT(DTS_EV_DTA_DEST_RMV_SUCC, 0, key.node,
(uns32)to_reg->dta_addr);
if (NULL != to_reg)
m_MMGR_FREE_VCARD_TBL(to_reg);
}
/*Since the dta is found and deleted exit the while loop */
break;
} /*end of if(dts_find_reg() == TRUE) */
} /*end of while */
} /*end of else (cb->svc_rmv_mds_dest == 0) */
/* Do NOT attempt deletion of service entries while
* it's still syncing with Active DTS esp. if its still yet to
* get the data for DTA LIST. Because until then SVC<->DTA
* mapping won't be established.
* In that case all services which have dta_count = 0 will be
* cleaned at the end of completion of DTA list data-sync.
*/
if ((cb->in_sync == FALSE) && (cb->cold_sync_done < DTSV_CKPT_DTA_DEST_LIST_CONFIG)) {
/* Whatever is needed has been done so return success */
m_DTS_UNLK(&cb->lock);
m_LOG_DTS_LOCK(DTS_LK_UNLOCKED, &cb->lock);
m_LOG_DTS_EVT(DTS_EV_SVC_DEREG_SUCCESSFUL, key.ss_svc_id, key.node, 0);
return NCSCC_RC_SUCCESS;
}
/* Delete svc entry when dta_count is zero
*/
else if (svc_ptr->dta_count == 0) {
/* No need of policy handles */
/* Now delete the svc entry from the patricia tree */
/*ncshm_destroy_hdl(NCS_SERVICE_ID_DTSV, svc_ptr->svc_hdl);
m_LOG_DTS_EVT(DTS_EV_SVC_POLCY_HDL_DES, key.ss_svc_id, key.node, 0); */
if (&svc_ptr->device.cir_buffer != NULL)
dts_circular_buffer_free(&svc_ptr->device.cir_buffer);
device = &svc_ptr->device;
/* Cleanup the DTS_FILE_LIST datastructure for svc */
m_DTS_FREE_FILE_LIST(device);
ncs_patricia_tree_del(&cb->svc_tbl, (NCS_PATRICIA_NODE *)svc_ptr);
m_LOG_DTS_EVT(DTS_EV_SVC_REG_ENT_RMVD, key.ss_svc_id, key.node, 0);
if (NULL != svc_ptr)
m_MMGR_FREE_SVC_REG_TBL(svc_ptr);
}
m_DTS_UNLK(&cb->lock);
m_LOG_DTS_LOCK(DTS_LK_UNLOCKED, &cb->lock);
m_LOG_DTS_EVT(DTS_EV_SVC_DEREG_SUCCESSFUL, key.ss_svc_id, key.node, 0);
} else {
return NCSCC_RC_FAILURE;
}
}
break;
default:
/* Log error */
return NCSCC_RC_FAILURE;
}
return status;
}
