CROUTER_NODE *crouter_node_vec_find(CROUTER_NODE_VEC *crouter_node_vec, const UINT32 des_tcid)
{
UINT32 pos;
CVECTOR_LOCK(CROUTER_NODE_VEC_NODES(crouter_node_vec), LOC_CROUTER_0033);
for(pos = 0; pos < cvector_size(CROUTER_NODE_VEC_NODES(crouter_node_vec)); pos ++)
{
CROUTER_NODE *crouter_node;
crouter_node = (CROUTER_NODE *)cvector_get_no_lock(CROUTER_NODE_VEC_NODES(crouter_node_vec), pos);
if(NULL_PTR == crouter_node)
{
continue;
}
if(des_tcid == CROUTER_NODE_DES_TCID(crouter_node))
{
CVECTOR_UNLOCK(CROUTER_NODE_VEC_NODES(crouter_node_vec), LOC_CROUTER_0034);
return (crouter_node);
}
}
CVECTOR_UNLOCK(CROUTER_NODE_VEC_NODES(crouter_node_vec), LOC_CROUTER_0035);
return (NULL_PTR);
}
EC_BOOL taskcfgchk_net_all(LOG *log, const TASK_CFG *task_cfg)
{
UINT32 pos;
CVECTOR_LOCK(TASK_CFG_TASKS_CFG_VEC(task_cfg), LOC_TASKCFGCHK_0015);
for(pos = 0; pos < cvector_size(TASK_CFG_TASKS_CFG_VEC(task_cfg)); pos ++)
{
TASKS_CFG *tasks_cfg;
TASK_CFG *des_task_cfg;
tasks_cfg = (TASKS_CFG *)cvector_get_no_lock(TASK_CFG_TASKS_CFG_VEC(task_cfg), pos);
if(NULL_PTR == tasks_cfg)
{
continue;
}
sys_log(log, "[TASKCFGCHK] ------------------------------ check tcid %s, maski %s, maske %s ----------------------------------\n",
TASKS_CFG_TCID_STR(tasks_cfg),
TASKS_CFG_MASKI_STR(tasks_cfg),
TASKS_CFG_MASKE_STR(tasks_cfg)
);
des_task_cfg = task_cfg_new();
task_cfg_filter(task_cfg, TASKS_CFG_TCID(tasks_cfg), des_task_cfg);
task_cfg_print_xml(log, des_task_cfg, 0);
task_cfg_free(des_task_cfg);
}
return (EC_TRUE);
}
static EC_BOOL taskcfgchk_conn_test(const TASK_CFG *task_cfg, const TASKS_CFG *local_tasks_cfg, const UINT32 remote_tcid)
{
UINT32 pos;
CVECTOR_LOCK(TASK_CFG_TASKS_CFG_VEC(task_cfg), LOC_TASKCFGCHK_0008);
for(pos = 0; pos < cvector_size(TASK_CFG_TASKS_CFG_VEC(task_cfg)); pos ++)
{
TASKS_CFG *remote_tasks_cfg;
remote_tasks_cfg = (TASKS_CFG *)cvector_get_no_lock(TASK_CFG_TASKS_CFG_VEC(task_cfg), pos);
if(NULL_PTR == remote_tasks_cfg)
{
continue;
}
if(
(remote_tcid == TASKS_CFG_TCID(remote_tasks_cfg))
&&
(
EC_TRUE == tasks_cfg_is_intranet(local_tasks_cfg, remote_tasks_cfg)
|| EC_TRUE == tasks_cfg_is_externet(local_tasks_cfg, remote_tasks_cfg)
|| EC_TRUE == tasks_cfg_is_lannet(local_tasks_cfg, remote_tasks_cfg)
|| EC_TRUE == tasks_cfg_is_dbgnet(local_tasks_cfg, remote_tasks_cfg)
|| EC_TRUE == tasks_cfg_is_monnet(local_tasks_cfg, remote_tasks_cfg)
)
)
{
CVECTOR_UNLOCK(TASK_CFG_TASKS_CFG_VEC(task_cfg), LOC_TASKCFGCHK_0009);
return (EC_TRUE);
}
}
CVECTOR_UNLOCK(TASK_CFG_TASKS_CFG_VEC(task_cfg), LOC_TASKCFGCHK_0010);
return (EC_FALSE);
}
EC_BOOL taskcfgchk_route_print(LOG *log, const TASK_CFG *task_cfg, const UINT32 tcid, const UINT32 maski, const UINT32 maske)
{
TASKS_CFG *tasks_cfg;
UINT32 pos;
tasks_cfg = task_cfg_searchs(task_cfg, tcid, maski, maske);
if(NULL_PTR == tasks_cfg)
{
sys_log(log, "error:taskcfgchk_route_print: no tasks cfg for tcid %s maski %s, maske %s\n",
c_word_to_ipv4(tcid), c_word_to_ipv4(maski), c_word_to_ipv4(maske));
return (EC_FALSE);
}
CVECTOR_LOCK(TASKS_CFG_TASKR_CFG_VEC(tasks_cfg), LOC_TASKCFGCHK_0003);
for(pos = 0; pos < cvector_size(TASKS_CFG_TASKR_CFG_VEC(tasks_cfg)); pos ++)
{
TASKR_CFG *taskr_cfg;
taskr_cfg = (TASKR_CFG *)cvector_get_no_lock(TASKS_CFG_TASKR_CFG_VEC(tasks_cfg), pos);
if(NULL_PTR == taskr_cfg)
{
continue;
}
sys_log(log, "[TASKCFGCHK] route No. %ld: des_tcid = %s, maskr = %s, next_tcid = %s\n", pos,
TASKR_CFG_DES_TCID_STR(taskr_cfg),
TASKR_CFG_MASKR_STR(taskr_cfg),
TASKR_CFG_NEXT_TCID_STR(taskr_cfg));
}
CVECTOR_UNLOCK(TASKS_CFG_TASKR_CFG_VEC(tasks_cfg), LOC_TASKCFGCHK_0004);
return (EC_TRUE);
}
EC_BOOL crouter_node_vec_rmv(CROUTER_NODE_VEC *crouter_node_vec, const UINT32 des_tcid, const UINT32 next_hop_tcid)
{
UINT32 crouter_node_pos;
CROUTER_NODE *crouter_node;
CVECTOR_LOCK(CROUTER_NODE_VEC_NODES(crouter_node_vec), LOC_CROUTER_0026);
crouter_node_pos = crouter_node_vec_search_no_lock(crouter_node_vec, des_tcid);
if(CVECTOR_ERR_POS == crouter_node_pos)
{
CVECTOR_UNLOCK(CROUTER_NODE_VEC_NODES(crouter_node_vec), LOC_CROUTER_0027);
sys_log(LOGSTDOUT, "error:crouter_node_vec_rmv: no route to des tcid %s\n", c_word_to_ipv4(des_tcid));
return (EC_FALSE);
}
crouter_node = crouter_node_vec_get_no_lock(crouter_node_vec, crouter_node_pos);
crouter_node_rmv_next_hop_by_tcid(crouter_node, next_hop_tcid);
/*update crouter_node_vec if necessary*/
if(EC_TRUE == crouter_node_is_empty(crouter_node))
{
crouter_node_vec_erase_no_lock(crouter_node_vec, crouter_node_pos);
crouter_node_free(crouter_node);
CVECTOR_UNLOCK(CROUTER_NODE_VEC_NODES(crouter_node_vec), LOC_CROUTER_0028);
sys_log(LOGSTDOUT, "crouter_node_vec_rmv: no more route to des tcid %s, free whole croute node\n", c_word_to_ipv4(des_tcid));
return (EC_TRUE);
}
CVECTOR_UNLOCK(CROUTER_NODE_VEC_NODES(crouter_node_vec), LOC_CROUTER_0029);
return (EC_TRUE);
}
TASKS_NODE * crouter_node_min_load_next_hop(const CROUTER_NODE *crouter_node)
{
UINT32 pos;
UINT32 min_load;
TASKS_NODE *min_tasks_node;
min_load = ((UINT32)-1);
min_tasks_node = NULL_PTR;
CVECTOR_LOCK(CROUTER_NODE_NEXT_HOPS(crouter_node), LOC_CROUTER_0015);
for(pos = 0; pos < cvector_size(CROUTER_NODE_NEXT_HOPS(crouter_node)); pos ++)
{
TASKS_NODE *tasks_node;
UINT32 cur_load;
tasks_node = (TASKS_NODE *)cvector_get_no_lock(CROUTER_NODE_NEXT_HOPS(crouter_node), pos);
if(NULL_PTR == tasks_node)
{
continue;
}
cur_load = TASKS_NODE_LOAD(tasks_node);/*replace it when TASKS_NOE implement load*/
if(min_load > cur_load)
{
min_load = cur_load;
min_tasks_node = tasks_node;
}
}
CVECTOR_UNLOCK(CROUTER_NODE_NEXT_HOPS(crouter_node), LOC_CROUTER_0016);
return (min_tasks_node);
}
EC_BOOL taskcfgchk_conn_print(LOG *log, const TASK_CFG *task_cfg, const UINT32 tcid, const UINT32 maski, const UINT32 maske, const UINT32 remote_tcid)
{
TASKS_CFG *local_tasks_cfg;
UINT32 pos;
local_tasks_cfg = task_cfg_searchs(task_cfg, tcid, maski, maske);
if(NULL_PTR == local_tasks_cfg)
{
sys_log(log, "error:taskcfgchk_conn_print: no tasks cfg for tcid %s maski %s, maske %s\n",
c_word_to_ipv4(tcid), c_word_to_ipv4(maski), c_word_to_ipv4(maske));
return (EC_FALSE);
}
CVECTOR_LOCK(TASK_CFG_TASKS_CFG_VEC(task_cfg), LOC_TASKCFGCHK_0005);
for(pos = 0; pos < cvector_size(TASK_CFG_TASKS_CFG_VEC(task_cfg)); pos ++)
{
TASKS_CFG *remote_tasks_cfg;
remote_tasks_cfg = (TASKS_CFG *)cvector_get_no_lock(TASK_CFG_TASKS_CFG_VEC(task_cfg), pos);
if(NULL_PTR == remote_tasks_cfg)
{
continue;
}
if(
(remote_tcid == TASKS_CFG_TCID(remote_tasks_cfg))
&&
(
EC_TRUE == tasks_cfg_is_intranet(local_tasks_cfg, remote_tasks_cfg)
|| EC_TRUE == tasks_cfg_is_externet(local_tasks_cfg, remote_tasks_cfg)
|| EC_TRUE == tasks_cfg_is_lannet(local_tasks_cfg, remote_tasks_cfg)
|| EC_TRUE == tasks_cfg_is_dbgnet(local_tasks_cfg, remote_tasks_cfg)
|| EC_TRUE == tasks_cfg_is_monnet(local_tasks_cfg, remote_tasks_cfg)
)
)
{
sys_log(log, "[TASKCFGCHK] tcid %s maski %s maske %s --> tcid %s maski %s maske %s\n",
TASKS_CFG_TCID_STR(local_tasks_cfg),
TASKS_CFG_MASKI_STR(local_tasks_cfg),
TASKS_CFG_MASKE_STR(local_tasks_cfg),
TASKS_CFG_TCID_STR(remote_tasks_cfg),
TASKS_CFG_MASKI_STR(remote_tasks_cfg),
TASKS_CFG_MASKE_STR(remote_tasks_cfg)
);
CVECTOR_UNLOCK(TASK_CFG_TASKS_CFG_VEC(task_cfg), LOC_TASKCFGCHK_0006);
return (EC_TRUE);
}
}
CVECTOR_UNLOCK(TASK_CFG_TASKS_CFG_VEC(task_cfg), LOC_TASKCFGCHK_0007);
return (EC_FALSE);
}
CROUTER_NODE *crouter_node_vec_add(CROUTER_NODE_VEC *crouter_node_vec, const CVECTOR *tasks_node_work, const UINT32 des_tcid, const UINT32 next_hop_tcid)
{
TASKS_NODE *next_hop_tasks_node;
CROUTER_NODE *crouter_node;
next_hop_tasks_node = tasks_work_search_tasks_node_by_tcid(tasks_node_work, next_hop_tcid);
if(NULL_PTR == next_hop_tasks_node)
{
sys_log(LOGSTDOUT, "error:crouter_node_vec_add: next hop tcid %s does not exist\n", c_word_to_ipv4(next_hop_tcid));
return (NULL_PTR);
}
CVECTOR_LOCK(CROUTER_NODE_VEC_NODES(crouter_node_vec), LOC_CROUTER_0021);
crouter_node = crouter_node_vec_find_no_lock(crouter_node_vec, des_tcid);
if(NULL_PTR == crouter_node)
{
crouter_node = crouter_node_create(des_tcid, next_hop_tasks_node);
if(NULL_PTR == crouter_node)
{
CVECTOR_UNLOCK(CROUTER_NODE_VEC_NODES(crouter_node_vec), LOC_CROUTER_0022);
sys_log(LOGSTDOUT, "error:crouter_node_vec_add: failed to create route (des tcid %s, next hop tcid %s)\n",
c_word_to_ipv4(des_tcid), TASKS_NODE_TCID_STR(next_hop_tasks_node));
return (NULL_PTR);
}
cvector_push_no_lock(CROUTER_NODE_VEC_NODES(crouter_node_vec), (void *)crouter_node);
CVECTOR_UNLOCK(CROUTER_NODE_VEC_NODES(crouter_node_vec), LOC_CROUTER_0023);
return (crouter_node);
}
if(CVECTOR_ERR_POS == crouter_node_add_next_hop(crouter_node, next_hop_tasks_node))
{
CVECTOR_UNLOCK(CROUTER_NODE_VEC_NODES(crouter_node_vec), LOC_CROUTER_0024);
sys_log(LOGSTDOUT, "error:crouter_node_vec_add: failed to add route (des tcid %s, next hop tcid %s)\n",
c_word_to_ipv4(des_tcid), c_word_to_ipv4(next_hop_tcid));
return (NULL_PTR);
}
CVECTOR_UNLOCK(CROUTER_NODE_VEC_NODES(crouter_node_vec), LOC_CROUTER_0025);
return (crouter_node);
}
TASKS_NODE *crouter_node_find_next_hop_by_tcid(CROUTER_NODE *crouter_node, const UINT32 next_hop_tcid)
{
UINT32 pos;
CVECTOR_LOCK(CROUTER_NODE_NEXT_HOPS(crouter_node), LOC_CROUTER_0012);
for(pos = 0; pos < cvector_size(CROUTER_NODE_NEXT_HOPS(crouter_node)); pos ++)
{
TASKS_NODE *tasks_node;
tasks_node = (TASKS_NODE *)cvector_get_no_lock(CROUTER_NODE_NEXT_HOPS(crouter_node), pos);
if(NULL_PTR == tasks_node)
{
continue;
}
if(next_hop_tcid == TASKS_NODE_TCID(tasks_node))
{
CVECTOR_UNLOCK(CROUTER_NODE_NEXT_HOPS(crouter_node), LOC_CROUTER_0013);
return (tasks_node);
}
}
CVECTOR_UNLOCK(CROUTER_NODE_NEXT_HOPS(crouter_node), LOC_CROUTER_0014);
return (NULL_PTR);
}
void crouter_node_print_in_plain(LOG *log, const CROUTER_NODE *crouter_node, UINT32 *index)
{
UINT32 pos;
CVECTOR_LOCK(CROUTER_NODE_NEXT_HOPS(crouter_node), LOC_CROUTER_0007);
for(pos = 0; pos < cvector_size(CROUTER_NODE_NEXT_HOPS(crouter_node)); pos ++)
{
TASKS_NODE *tasks_node;
tasks_node = (TASKS_NODE *)cvector_get_no_lock(CROUTER_NODE_NEXT_HOPS(crouter_node), pos);
if(NULL_PTR == tasks_node)
{
sys_log(log, "Route No. %ld: des tcid %s, next hop [%ld]: (null)\n",
(*index) ++, CROUTER_NODE_DES_TCID_STR(crouter_node), pos);
continue;
}
sys_log(log, "Route No. %ld: des tcid %s, next hop [%ld]: ",
(*index) ++, CROUTER_NODE_DES_TCID_STR(crouter_node), pos);
tasks_node_print_in_plain(log, tasks_node);
}
CVECTOR_UNLOCK(CROUTER_NODE_NEXT_HOPS(crouter_node), LOC_CROUTER_0008);
return;
}
EC_BOOL taskcfgchk_net_print(LOG *log, const TASK_CFG *task_cfg, const UINT32 tcid, const UINT32 maski, const UINT32 maske)
{
TASKS_CFG *local_tasks_cfg;
UINT32 pos;
local_tasks_cfg = task_cfg_searchs(task_cfg, tcid, maski, maske);
if(NULL_PTR == local_tasks_cfg)
{
sys_log(log, "error:taskcfgchk_net_print: no tasks cfg for tcid %s maski %s, maske %s\n",
c_word_to_ipv4(tcid), c_word_to_ipv4(maski), c_word_to_ipv4(maske));
return (EC_FALSE);
}
CVECTOR_LOCK(TASK_CFG_TASKS_CFG_VEC(task_cfg), LOC_TASKCFGCHK_0001);
for(pos = 0; pos < cvector_size(TASK_CFG_TASKS_CFG_VEC(task_cfg)); pos ++)
{
TASKS_CFG *remote_tasks_cfg;
remote_tasks_cfg = (TASKS_CFG *)cvector_get_no_lock(TASK_CFG_TASKS_CFG_VEC(task_cfg), pos);
if(NULL_PTR == remote_tasks_cfg)
{
continue;
}
if(EC_TRUE == tasks_cfg_is_intranet(local_tasks_cfg, remote_tasks_cfg))
{
sys_log(log, "[TASKCFGCHK][I]tcid = %s, maski = %s, maske = %s, srvipaddr = %s, srvport = %ld\n",
TASKS_CFG_TCID_STR(remote_tasks_cfg),
TASKS_CFG_MASKI_STR(remote_tasks_cfg),
TASKS_CFG_MASKE_STR(remote_tasks_cfg),
TASKS_CFG_SRVIPADDR_STR(remote_tasks_cfg),
TASKS_CFG_SRVPORT(remote_tasks_cfg));
}
if(EC_TRUE == tasks_cfg_is_externet(local_tasks_cfg, remote_tasks_cfg))
{
sys_log(log, "[TASKCFGCHK][E]tcid = %s, maski = %s, maske = %s, srvipaddr = %s, srvport = %ld\n",
TASKS_CFG_TCID_STR(remote_tasks_cfg),
TASKS_CFG_MASKI_STR(remote_tasks_cfg),
TASKS_CFG_MASKE_STR(remote_tasks_cfg),
TASKS_CFG_SRVIPADDR_STR(remote_tasks_cfg),
TASKS_CFG_SRVPORT(remote_tasks_cfg));
}
if(EC_TRUE == tasks_cfg_is_lannet(local_tasks_cfg, remote_tasks_cfg))
{
sys_log(log, "[TASKCFGCHK][L]tcid = %s, maski = %s, maske = %s, srvipaddr = %s, srvport = %ld\n",
TASKS_CFG_TCID_STR(remote_tasks_cfg),
TASKS_CFG_MASKI_STR(remote_tasks_cfg),
TASKS_CFG_MASKE_STR(remote_tasks_cfg),
TASKS_CFG_SRVIPADDR_STR(remote_tasks_cfg),
TASKS_CFG_SRVPORT(remote_tasks_cfg));
}
if(EC_TRUE == tasks_cfg_is_dbgnet(local_tasks_cfg, remote_tasks_cfg))
{
sys_log(log, "[TASKCFGCHK][D]tcid = %s, maski = %s, maske = %s, srvipaddr = %s, srvport = %ld\n",
TASKS_CFG_TCID_STR(remote_tasks_cfg),
TASKS_CFG_MASKI_STR(remote_tasks_cfg),
TASKS_CFG_MASKE_STR(remote_tasks_cfg),
TASKS_CFG_SRVIPADDR_STR(remote_tasks_cfg),
TASKS_CFG_SRVPORT(remote_tasks_cfg));
}
if(EC_TRUE == tasks_cfg_is_monnet(local_tasks_cfg, remote_tasks_cfg))
{
sys_log(log, "[TASKCFGCHK][D]tcid = %s, maski = %s, maske = %s, srvipaddr = %s, srvport = %ld\n",
TASKS_CFG_TCID_STR(remote_tasks_cfg),
TASKS_CFG_MASKI_STR(remote_tasks_cfg),
TASKS_CFG_MASKE_STR(remote_tasks_cfg),
TASKS_CFG_SRVIPADDR_STR(remote_tasks_cfg),
TASKS_CFG_SRVPORT(remote_tasks_cfg));
}
}
CVECTOR_UNLOCK(TASK_CFG_TASKS_CFG_VEC(task_cfg), LOC_TASKCFGCHK_0002);
return (EC_TRUE);
}
static EC_BOOL taskcfgchk_route_test(LOG *log, const TASK_CFG *task_cfg, TASKS_CFG *src_tasks_cfg, const UINT32 des_tcid, const UINT32 max_hops)
{
UINT32 pos;
if(EC_TRUE == taskcfgchk_conn_test(task_cfg, src_tasks_cfg, des_tcid))
{
sys_log(log, "[TASKCFGCHK] %s ==> %s [SUCC]\n", TASKS_CFG_TCID_STR(src_tasks_cfg), c_word_to_ipv4(des_tcid));
return (EC_TRUE);
}
if(0 == max_hops)
{
sys_log(log, "[TASKCFGCHK] ==> %s [STOP]\n", TASKS_CFG_TCID_STR(src_tasks_cfg));
return (EC_FALSE);
}
CVECTOR_LOCK(TASKS_CFG_TASKR_CFG_VEC(src_tasks_cfg), LOC_TASKCFGCHK_0011);
for(pos = 0; pos < cvector_size(TASKS_CFG_TASKR_CFG_VEC(src_tasks_cfg)); pos ++)
{
TASKR_CFG *taskr_cfg;
UINT32 taskr_cfg_mask;
taskr_cfg = (TASKR_CFG *)cvector_get_no_lock(TASKS_CFG_TASKR_CFG_VEC(src_tasks_cfg), pos);
if(NULL_PTR == taskr_cfg)
{
continue;
}
taskr_cfg_mask = TASKR_CFG_MASKR(taskr_cfg);
/*when des_tcid belong to the intranet of taskr_cfg, i.e., belong to the route*/
if((des_tcid & taskr_cfg_mask) == (TASKR_CFG_DES_TCID(taskr_cfg) & taskr_cfg_mask))
{
TASKS_CFG *rt_tasks_cfg;
dbg_log(SEC_0057_TASKCFGCHK, 5)(LOGSTDNULL, "[TASKCFGCHK] %s & %s == %s & %s\n",
c_word_to_ipv4(des_tcid), c_word_to_ipv4(taskr_cfg_mask),
TASKR_CFG_DES_TCID_STR(taskr_cfg), c_word_to_ipv4(taskr_cfg_mask)
);
rt_tasks_cfg = task_cfg_searchs(task_cfg, TASKR_CFG_NEXT_TCID(taskr_cfg), CMPI_ANY_MASK, CMPI_ANY_MASK);
if(NULL_PTR == rt_tasks_cfg)
{
continue;
}
sys_log(log, "[TASKCFGCHK] %s ==> %s\n", TASKS_CFG_TCID_STR(src_tasks_cfg), TASKR_CFG_NEXT_TCID_STR(taskr_cfg));
CVECTOR_UNLOCK(TASKS_CFG_TASKR_CFG_VEC(src_tasks_cfg), LOC_TASKCFGCHK_0012);
if(EC_TRUE == taskcfgchk_route_test(log, task_cfg, rt_tasks_cfg, des_tcid, max_hops - 1))/*recursively*/
{
return (EC_TRUE);
}
CVECTOR_LOCK(TASKS_CFG_TASKR_CFG_VEC(src_tasks_cfg), LOC_TASKCFGCHK_0013);
}
else
{
dbg_log(SEC_0057_TASKCFGCHK, 5)(LOGSTDNULL, "[TASKCFGCHK] %s & %s != %s & %s\n",
c_word_to_ipv4(des_tcid), c_word_to_ipv4(taskr_cfg_mask),
TASKR_CFG_DES_TCID_STR(taskr_cfg), c_word_to_ipv4(taskr_cfg_mask)
);
}
}
CVECTOR_UNLOCK(TASKS_CFG_TASKR_CFG_VEC(src_tasks_cfg), LOC_TASKCFGCHK_0014);
return (EC_FALSE);
}
