EC_BOOL ipv4_pool_unset(IPV4_POOL *ipv4_pool, const uint32_t ipv4_addr)
{
UINT32 bit_pos;
if((IPV4_POOL_SUBNET(ipv4_pool) & IPV4_POOL_MASK(ipv4_pool)) != (ipv4_addr & IPV4_POOL_MASK(ipv4_pool)))
{
dbg_log(SEC_0027_IPV4POOL, 0)(LOGSTDOUT, "error:ipv4_pool_unset: ipv4 addr %s not belong to subnet %s, mask %s\n",
c_word_to_ipv4(ipv4_addr),
c_word_to_ipv4(IPV4_POOL_SUBNET(ipv4_pool)),
c_word_to_ipv4(IPV4_POOL_MASK(ipv4_pool))
);
return (EC_FALSE);
}
IPV4_POOL_CRWLOCK_WRLOCK(ipv4_pool, LOC_IPV4POOL_0021);
bit_pos = ((ipv4_addr & (~ IPV4_POOL_MASK(ipv4_pool))) & 0xffffffff);
if(EC_FALSE == cbitmap_unset(IPV4_POOL_CBITMAP(ipv4_pool), bit_pos))
{
dbg_log(SEC_0027_IPV4POOL, 0)(LOGSTDOUT, "error:ipv4_pool_unset: unset ipv4 addr %s failed\n", c_word_to_ipv4(ipv4_addr));
IPV4_POOL_CRWLOCK_UNLOCK(ipv4_pool, LOC_IPV4POOL_0022);
return (EC_FALSE);
}
IPV4_POOL_CRWLOCK_UNLOCK(ipv4_pool, LOC_IPV4POOL_0023);
return (EC_TRUE);
}
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);
}
CROUTER_NODE *crouter_node_vec_add_no_lock(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_no_lock: next hop tcid %s does not exist\n", c_word_to_ipv4(next_hop_tcid));
return (NULL_PTR);
}
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)
{
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);
return (crouter_node);
}
if(CVECTOR_ERR_POS == crouter_node_add_next_hop(crouter_node, next_hop_tasks_node))
{
sys_log(LOGSTDOUT, "error:crouter_node_vec_add_no_lock: 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);
}
return (crouter_node);
}
void ipv4_pool_print(LOG *log, const IPV4_POOL *ipv4_pool)
{
sys_log(log, "ipv4 pool %lx: subnet %s, mask %s\n",
ipv4_pool,
c_word_to_ipv4(IPV4_POOL_SUBNET(ipv4_pool)),
c_word_to_ipv4(IPV4_POOL_MASK(ipv4_pool))
);
cbitmap_print(log, IPV4_POOL_CBITMAP(ipv4_pool));
return;
}
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);
}
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);
}
/*e.g. ipv4_subnet from "192.168.231.0", ipv4_mask from "255.255.255.0"*/
IPV4_POOL *ipv4_pool_new(const uint32_t ipv4_subnet, const uint32_t ipv4_mask)
{
IPV4_POOL *ipv4_pool;
ipv4_pool = (IPV4_POOL *)SAFE_MALLOC(sizeof(IPV4_POOL), LOC_IPV4POOL_0001);
if(NULL_PTR != ipv4_pool)
{
if(EC_FALSE == ipv4_pool_init(ipv4_pool, ipv4_subnet, ipv4_mask))
{
dbg_log(SEC_0027_IPV4POOL, 0)(LOGSTDOUT, "error:ipv4_pool_new: init ipv4 pool with subnet %s, mask %s failed\n",
c_word_to_ipv4(ipv4_subnet), c_word_to_ipv4(ipv4_mask));
SAFE_FREE(ipv4_pool, LOC_IPV4POOL_0002);
return (NULL_PTR);
}
}
return (ipv4_pool);
}
EC_BOOL taskcfgchk_route_trace(LOG *log, const TASK_CFG *task_cfg, const UINT32 src_tcid, const UINT32 src_maski, const UINT32 src_maske, const UINT32 des_tcid, const UINT32 max_hops)
{
TASKS_CFG *src_tasks_cfg;
src_tasks_cfg = task_cfg_searchs(task_cfg, src_tcid, src_maski, src_maske);
if(NULL_PTR == src_tasks_cfg)
{
sys_log(log, "error:taskcfgchk_route_trace: no tasks cfg for src tcid %s maski %s, maske %s\n",
c_word_to_ipv4(src_tcid), c_word_to_ipv4(src_maski), c_word_to_ipv4(src_maske));
return (EC_FALSE);
}
if(EC_FALSE == taskcfgchk_route_test(log, task_cfg, src_tasks_cfg, des_tcid, max_hops))
{
sys_log(log, "[TASKCFGCHK] ==> %s [FAIL]\n", c_word_to_ipv4(des_tcid));
return (EC_FALSE);
}
return (EC_TRUE);
}
/*when thread accept one client connection, then process it and close the connection when reaching end*/
EC_BOOL cextsrv_thread(CEXTSRV *cextsrv)
{
for(;;)
{
CEXTCLNT cextclnt;
int cextclnt_sockfd;
UINT32 cextclnt_ipaddr;
cextclnt_init(&cextclnt);
dbg_log(SEC_0069_CEXTSRV, 9)(LOGSTDOUT, "[DEBUG] cextsrv_thread: accept blocking...\n");
CEXTSRV_CMUTEX_LOCK(cextsrv, LOC_CEXTSRV_0020);
if(EC_FALSE == csocket_accept(CEXTSRV_SOCKFD(cextsrv), &cextclnt_sockfd, CSOCKET_IS_BLOCK_MODE, &cextclnt_ipaddr))
{
CEXTSRV_CMUTEX_UNLOCK(cextsrv, LOC_CEXTSRV_0021);
dbg_log(SEC_0069_CEXTSRV, 0)(LOGSTDOUT, "error:cextsrv_thread: accept on sockfd %d failed\n", CEXTSRV_SOCKFD(cextsrv));
continue;
}
CEXTSRV_CMUTEX_UNLOCK(cextsrv, LOC_CEXTSRV_0022);
dbg_log(SEC_0069_CEXTSRV, 9)(LOGSTDOUT, "[DEBUG] cextsrv_thread: accept successfully\n");
CEXTCLNT_SOCKFD(&cextclnt) = cextclnt_sockfd;
CEXTCLNT_IPADDR(&cextclnt) = cextclnt_ipaddr;
dbg_log(SEC_0069_CEXTSRV, 9)(LOGSTDOUT, "[DEBUG] cextsrv_thread: accept connection from client %s on sockfd %d\n",
c_word_to_ipv4(CEXTCLNT_IPADDR(&cextclnt)), CEXTCLNT_SOCKFD(&cextclnt));
if(EC_FALSE == cextsrv_process(cextsrv, &cextclnt))
{
dbg_log(SEC_0069_CEXTSRV, 0)(LOGSTDOUT, "error:cextsrv_thread: process request from client %s on client sockfd %d failed\n",
c_word_to_ipv4(CEXTCLNT_IPADDR(&cextclnt)), CEXTCLNT_SOCKFD(&cextclnt));
cextclnt_clean(&cextclnt);
continue;
}
//cextclnt_clean(&cextclnt);/*each client sockfd connecting and processing only once time!*/
}
return (EC_TRUE);
}
/*srv may not create connection pool*/
CSOCKET_CNODE *cconnp_mgr_try_reserve(CCONNP_MGR *cconnp_mgr, const UINT32 srv_tcid, const UINT32 srv_ipaddr, const UINT32 srv_port)
{
CCONNP *cconnp;
CSOCKET_CNODE *csocket_cnode;
cconnp = cconnp_mgr_search(cconnp_mgr, srv_tcid, srv_ipaddr, srv_port);
if(NULL_PTR == cconnp)
{
dbg_log(SEC_0154_CCONNP, 1)(LOGSTDOUT, "warn:cconnp_mgr_try_reserve: not found cconnp srv %s:%ld, tcid %s\n",
c_word_to_ipv4(srv_ipaddr), srv_port,
c_word_to_ipv4(srv_tcid));
return (NULL_PTR);
}
csocket_cnode = cconnp_reserve(cconnp);
if(NULL_PTR == csocket_cnode)
{
dbg_log(SEC_0154_CCONNP, 0)(LOGSTDOUT, "error:cconnp_mgr_try_reserve: reserve socket from cconnp srv %s:%ld, tcid %s failed\n",
c_word_to_ipv4(srv_ipaddr), srv_port,
c_word_to_ipv4(srv_tcid));
return (NULL_PTR);
}
dbg_log(SEC_0154_CCONNP, 9)(LOGSTDOUT, "[DEBUG] cconnp_mgr_try_reserve: reserve sockfd %d from cconnp srv %s:%ld, tcid %s done\n",
CSOCKET_CNODE_SOCKFD(csocket_cnode),
c_word_to_ipv4(srv_ipaddr), srv_port,
c_word_to_ipv4(srv_tcid));
return (csocket_cnode);
}
EC_BOOL ipv4_pool_reserve(IPV4_POOL *ipv4_pool, uint32_t *ipv4_addr)
{
UINT32 bit_pos;
uint32_t reserved_ipv4_addr;
uint32_t reserved_ipv4_addr_tail;
IPV4_POOL_CRWLOCK_WRLOCK(ipv4_pool, LOC_IPV4POOL_0011);
do
{
if(EC_FALSE == cbitmap_reserve(IPV4_POOL_CBITMAP(ipv4_pool), &bit_pos))
{
dbg_log(SEC_0027_IPV4POOL, 0)(LOGSTDOUT, "error:ipv4_pool_reserve: reserve from cbitmap failed\n");
IPV4_POOL_CRWLOCK_UNLOCK(ipv4_pool, LOC_IPV4POOL_0012);
return (EC_FALSE);
}
if(bit_pos & (~((UINT32)0xffffffff)))/*confirm high bits is zero*/
{
dbg_log(SEC_0027_IPV4POOL, 0)(LOGSTDOUT, "error:ipv4_pool_reserve: reserved %ld from cbitmap is invalid\n", bit_pos);
cbitmap_release(IPV4_POOL_CBITMAP(ipv4_pool), bit_pos);
IPV4_POOL_CRWLOCK_UNLOCK(ipv4_pool, LOC_IPV4POOL_0013);
return (EC_FALSE);
}
reserved_ipv4_addr = ((IPV4_POOL_SUBNET(ipv4_pool) & IPV4_POOL_MASK(ipv4_pool)) | bit_pos);
reserved_ipv4_addr_tail = (reserved_ipv4_addr & 0x000000ff);/*discard special ipv4 addr*/
}while(0 == reserved_ipv4_addr_tail || 0xff == reserved_ipv4_addr_tail || 0xfe == reserved_ipv4_addr_tail);
(*ipv4_addr) = reserved_ipv4_addr;
dbg_log(SEC_0027_IPV4POOL, 9)(LOGSTDOUT, "[DEBUG] ipv4_pool_reserve: subnet %s, mask %s, bit_pos %ld => %s\n",
c_word_to_ipv4(IPV4_POOL_SUBNET(ipv4_pool)),
c_word_to_ipv4(IPV4_POOL_MASK(ipv4_pool)),
bit_pos,
c_word_to_ipv4(*ipv4_addr)
);
IPV4_POOL_CRWLOCK_UNLOCK(ipv4_pool, LOC_IPV4POOL_0014);
return (EC_TRUE);
}
CROUTER_NODE *crouter_node_create(const UINT32 des_tcid, const TASKS_NODE *next_hop_tasks_node)
{
CROUTER_NODE *crouter_node;
crouter_node = crouter_node_new(des_tcid);
if(NULL_PTR == crouter_node)
{
sys_log(LOGSTDOUT, "error:crouter_node_create: failed to alloc crouter node for des tcid %s\n", c_word_to_ipv4(des_tcid));
return (NULL_PTR);
}
if(CVECTOR_ERR_POS == cvector_push(CROUTER_NODE_NEXT_HOPS(crouter_node), (void *)next_hop_tasks_node))
{
sys_log(LOGSTDOUT, "error:crouter_node_create: failed to add route (des tcid %s, next hop tcid %s)\n",
c_word_to_ipv4(des_tcid), TASKS_NODE_TCID_STR(next_hop_tasks_node));
crouter_node_free(crouter_node);
return (NULL_PTR);
}
return (crouter_node);
}
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);
}
CEXTSRV * cextsrv_start(const UINT32 srv_ipaddr, const UINT32 srv_port)
{
CEXTSRV *cextsrv;
int srv_sockfd;
if(EC_FALSE == csocket_srv_start(srv_ipaddr, srv_port, CSOCKET_IS_BLOCK_MODE, &srv_sockfd))
{
dbg_log(SEC_0069_CEXTSRV, 0)(LOGSTDERR, "error:cextsrv_start: failed to listen on port %ld\n", srv_port);
return (NULL_PTR);
}
cextsrv = cextsrv_new(srv_ipaddr, srv_port, srv_sockfd);
if(NULL_PTR == cextsrv)
{
dbg_log(SEC_0069_CEXTSRV, 0)(LOGSTDOUT, "error:cextsrv_start: new cextsrv failed, close srv sockfd %d\n", srv_sockfd);
csocket_close(srv_sockfd);
return (NULL_PTR);
}
dbg_log(SEC_0069_CEXTSRV, 5)(LOGSTDOUT, "cextsrv_start: start srv sockfd %d on port %s:%ld\n", srv_sockfd, c_word_to_ipv4(srv_ipaddr), srv_port);
return (cextsrv);
}
EC_BOOL ipv4_pool_init(IPV4_POOL *ipv4_pool, const uint32_t ipv4_subnet, const uint32_t ipv4_mask)
{
UINT32 ipv4_addr_max_num;
IPV4_POOL_SUBNET(ipv4_pool) = (ipv4_subnet & ipv4_mask);
IPV4_POOL_MASK(ipv4_pool) = ipv4_mask;
IPV4_POOL_INIT_CRWLOCK(ipv4_pool, LOC_IPV4POOL_0003);
ipv4_addr_max_num = (~ipv4_mask) + 1;
dbg_log(SEC_0027_IPV4POOL, 9)(LOGSTDOUT, "[DEBUG] ipv4_pool_init: subnet %s, mask %s, ipv4 addr max num %ld\n",
c_word_to_ipv4(IPV4_POOL_SUBNET(ipv4_pool)),
c_word_to_ipv4(IPV4_POOL_MASK(ipv4_pool)),
ipv4_addr_max_num);
if(EC_FALSE == cbitmap_init(IPV4_POOL_CBITMAP(ipv4_pool), ipv4_addr_max_num))
{
dbg_log(SEC_0027_IPV4POOL, 0)(LOGSTDOUT, "error:ipv4_pool_init: init cbitmap with ipv4 addr max num %ld failed\n", ipv4_addr_max_num);
IPV4_POOL_CLEAN_CRWLOCK(ipv4_pool, LOC_IPV4POOL_0004);
return (EC_FALSE);
}
CBITMAP_MAX_BITS(IPV4_POOL_CBITMAP(ipv4_pool)) = ipv4_addr_max_num; /*for safe purpose*/
#if 0
/*ignore some ipaddr*/
#if 0
ipv4_addr = 0;
bit_pos = (ipv4_addr & (~ IPV4_POOL_MASK(ipv4_pool)));
if(EC_FALSE == cbitmap_set(IPV4_POOL_CBITMAP(ipv4_pool), bit_pos))
{
dbg_log(SEC_0027_IPV4POOL, 0)(LOGSTDOUT, "error:ipv4_pool_init: cbitmap set ipv4 %s failed\n", c_word_to_ipv4(ipv4_addr));
IPV4_POOL_CLEAN_CRWLOCK(ipv4_pool, LOC_IPV4POOL_0005);
cbitmap_clean(IPV4_POOL_CBITMAP(ipv4_pool));
return (EC_FALSE);
}
dbg_log(SEC_0027_IPV4POOL, 9)(LOGSTDOUT, "[DEBUG] ipv4_pool_init: ignore ipv4 %s\n", c_word_to_ipv4(ipv4_addr));
#endif
#if 1
ipv4_addr = (ipv4_subnet & 0xffffff00);
bit_pos = (ipv4_addr & (~ IPV4_POOL_MASK(ipv4_pool)));
if(EC_FALSE == cbitmap_set(IPV4_POOL_CBITMAP(ipv4_pool), bit_pos))
{
dbg_log(SEC_0027_IPV4POOL, 0)(LOGSTDOUT, "error:ipv4_pool_init: cbitmap set ipv4 %s failed\n", c_word_to_ipv4(ipv4_addr));
IPV4_POOL_CLEAN_CRWLOCK(ipv4_pool, LOC_IPV4POOL_0006);
cbitmap_clean(IPV4_POOL_CBITMAP(ipv4_pool));
return (EC_FALSE);
}
dbg_log(SEC_0027_IPV4POOL, 9)(LOGSTDOUT, "[DEBUG] ipv4_pool_init: ignore ipv4 %s\n", c_word_to_ipv4(ipv4_addr));
#endif
ipv4_addr = (IPV4_POOL_SUBNET(ipv4_pool) | ((~ipv4_mask) & 0xffffffff));
bit_pos = (ipv4_addr & (~ IPV4_POOL_MASK(ipv4_pool)));
if(bit_pos < CBITMAP_MAX_BITS(IPV4_POOL_CBITMAP(ipv4_pool)) && EC_FALSE == cbitmap_set(IPV4_POOL_CBITMAP(ipv4_pool), bit_pos))
{
dbg_log(SEC_0027_IPV4POOL, 0)(LOGSTDOUT, "error:ipv4_pool_init: cbitmap set ipv4 %s failed\n", c_word_to_ipv4(ipv4_addr));
IPV4_POOL_CLEAN_CRWLOCK(ipv4_pool, LOC_IPV4POOL_0007);
cbitmap_clean(IPV4_POOL_CBITMAP(ipv4_pool));
return (EC_FALSE);
}
dbg_log(SEC_0027_IPV4POOL, 9)(LOGSTDOUT, "[DEBUG] ipv4_pool_init: ignore ipv4 %s\n", c_word_to_ipv4(ipv4_addr));
ipv4_addr = (IPV4_POOL_SUBNET(ipv4_pool) | ((~ipv4_mask) & 0xfffffffe));
bit_pos = (ipv4_addr & (~ IPV4_POOL_MASK(ipv4_pool)));
if(bit_pos < CBITMAP_MAX_BITS(IPV4_POOL_CBITMAP(ipv4_pool)) && EC_FALSE == cbitmap_set(IPV4_POOL_CBITMAP(ipv4_pool), bit_pos))
{
dbg_log(SEC_0027_IPV4POOL, 0)(LOGSTDOUT, "error:ipv4_pool_init: cbitmap set ipv4 %s failed\n", c_word_to_ipv4(ipv4_addr));
IPV4_POOL_CLEAN_CRWLOCK(ipv4_pool, LOC_IPV4POOL_0008);
cbitmap_clean(IPV4_POOL_CBITMAP(ipv4_pool));
return (EC_FALSE);
}
dbg_log(SEC_0027_IPV4POOL, 9)(LOGSTDOUT, "[DEBUG] ipv4_pool_init: ignore ipv4 %s\n", c_word_to_ipv4(ipv4_addr));
#endif
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);
}
int main_csolr(int argc, char **argv)
{
UINT32 this_tcid;
UINT32 this_comm;
UINT32 this_rank;
task_brd_default_init(argc, argv);
if(EC_FALSE == task_brd_default_check_validity())
{
dbg_log(SEC_0137_DEMO, 0)(LOGSTDOUT, "error:main: validity checking failed\n");
task_brd_default_abort();
return (-1);
}
this_tcid = task_brd_default_get_tcid();
this_comm = task_brd_default_get_comm();
this_rank = task_brd_default_get_rank();
if (EC_TRUE == task_brd_check_is_dbg_tcid(this_tcid) && CMPI_DBG_RANK == this_rank)
{
do_cmd_default();
}
else if (EC_TRUE == task_brd_check_is_monitor_tcid(this_tcid) && CMPI_MON_RANK == this_rank)
{
void * mod_mgr_def;
mod_mgr_def = mod_mgr_new(CMPI_ERROR_MODI, LOAD_BALANCING_LOOP);
mod_mgr_default_init(mod_mgr_def, CMPI_ANY_TCID, CMPI_ANY_RANK);
//mod_mgr_excl(this_tcid, CMPI_ANY_COMM, this_rank, CMPI_ANY_MODI, mod_mgr_def);
dbg_log(SEC_0137_DEMO, 5)(LOGSTDOUT, "======================================================================\n");
dbg_log(SEC_0137_DEMO, 5)(LOGSTDOUT, " mod_mgr_default_init finished \n");
dbg_log(SEC_0137_DEMO, 5)(LOGSTDOUT, "======================================================================\n");
mod_mgr_print(LOGSTDOUT, mod_mgr_def);
//test_case_61(mod_mgr_def);
//test_case_62(mod_mgr_def);
//test_case_63(mod_mgr_def);
//test_case_64(mod_mgr_def);
//test_case_66(mod_mgr_def);
//test_case_67(mod_mgr_def);
mod_mgr_free(mod_mgr_def);
do_slave_wait_default();
}
#if 0
/*fwd rank entrance*/
else if (CMPI_FWD_RANK == this_rank)
{
dbg_log(SEC_0137_DEMO, 5)(LOGSTDOUT,"======================================================================\n");
dbg_log(SEC_0137_DEMO, 5)(LOGSTDOUT," taskc_mgr in (tcid %s, rank %ld) \n", c_word_to_ipv4(this_tcid), this_rank);
super_show_work_client(task_brd_default_get_super(), LOGSTDOUT);/*debug only*/
dbg_log(SEC_0137_DEMO, 5)(LOGSTDOUT,"======================================================================\n");
do_slave_wait_default();
}
#endif
/*user define the master process*/
else if (c_ipv4_to_word("10.10.10.1") == this_tcid && 1 == this_rank)
{
UINT32 csolr_md_id;
csolr_md_id = csolr_start();
task_brd_default_start_csolr_srv(csolr_md_id, task_brd_default_get_srv_ipaddr(), 58111);
csolr_add_mod(csolr_md_id, c_ipv4_to_word("10.10.10.1"));
csolr_add_mod(csolr_md_id, c_ipv4_to_word("10.10.10.2"));
do_slave_wait_default();
}
else if (c_ipv4_to_word("10.10.10.2") == this_tcid && 1 == this_rank)
{
UINT32 csolr_md_id;
csolr_md_id = csolr_start();
task_brd_default_start_csolr_srv(csolr_md_id, task_brd_default_get_srv_ipaddr(), 58112);
csolr_add_mod(csolr_md_id, c_ipv4_to_word("10.10.10.1"));
csolr_add_mod(csolr_md_id, c_ipv4_to_word("10.10.10.2"));
do_slave_wait_default();
}
#if 1
/*fwd rank entrance*/
else if (CMPI_FWD_RANK == this_rank)
{
dbg_log(SEC_0137_DEMO, 5)(LOGSTDOUT,"======================================================================\n");
dbg_log(SEC_0137_DEMO, 5)(LOGSTDOUT," taskc_mgr in (tcid %s, rank %ld) \n", c_word_to_ipv4(this_tcid), this_rank);
super_show_work_client(task_brd_default_get_super(), LOGSTDOUT);/*debug only*/
dbg_log(SEC_0137_DEMO, 5)(LOGSTDOUT,"======================================================================\n");
do_slave_wait_default();
}
#endif
/*work process*/
else
{
do_slave_wait_default();
}
return (0);
}
int main_udp(int argc, char **argv)
{
UINT32 this_tcid;
UINT32 this_comm;
UINT32 this_rank;
task_brd_default_init(argc, argv);
if(EC_FALSE == task_brd_default_check_validity())
{
sys_log(LOGSTDOUT, "error:main_trans: validity checking failed\n");
task_brd_default_abort();
return (-1);
}
this_tcid = task_brd_default_get_tcid();
this_comm = task_brd_default_get_comm();
this_rank = task_brd_default_get_rank();
if (EC_TRUE == task_brd_check_is_dbg_tcid(this_tcid) && CMPI_DBG_RANK == this_rank)
{
do_cmd_default();
}
else if (EC_TRUE == task_brd_check_is_monitor_tcid(this_tcid) && CMPI_MON_RANK == this_rank)
{
void * mod_mgr_def;
mod_mgr_def = mod_mgr_new(CMPI_ERROR_MODI, LOAD_BALANCING_LOOP);
mod_mgr_default_init(mod_mgr_def, CMPI_ANY_TCID, CMPI_ANY_RANK);
//mod_mgr_excl(this_tcid, CMPI_ANY_COMM, this_rank, CMPI_ANY_MODI, mod_mgr_def);
sys_log(LOGSTDOUT, "======================================================================\n");
sys_log(LOGSTDOUT, " mod_mgr_default_init finished \n");
sys_log(LOGSTDOUT, "======================================================================\n");
mod_mgr_print(LOGSTDOUT, mod_mgr_def);
mod_mgr_free(mod_mgr_def);
do_slave_wait_default();
}
/*fwd rank entrance*/
else if (c_ipv4_to_word("10.10.10.1") == this_tcid && CMPI_FWD_RANK == this_rank)
{
int sockfd;
const char *mcast_ipaddr_str = "239.2.11.71";/*239.0.0.0бл239.255.255.255*/
UINT32 mcast_ipaddr;
UINT32 mcast_port = 8888;
mcast_ipaddr = c_ipv4_to_word(mcast_ipaddr_str);
if(EC_FALSE == csocket_start_udp_mcast_recver(mcast_ipaddr, mcast_port, &sockfd))
{
sys_log(LOGCONSOLE, "error:start udp server %s:%ld failed\n", mcast_ipaddr_str, mcast_port);
}
else
{
UINT8 data[256];
UINT32 dlen;
sys_log(LOGCONSOLE, "start udp server %s:%ld\n", mcast_ipaddr_str, mcast_port);
for(;EC_TRUE == csocket_udp_mcast_recvfrom(sockfd, mcast_ipaddr, mcast_port, data, sizeof(data)/sizeof(data[0]), &dlen);)
{
sys_log(LOGCONSOLE, "[DEBUG] recv udp data: %.*s\n", dlen, (char *)data);
}
csocket_stop_udp_mcast_recver(sockfd, mcast_ipaddr);
}
do_slave_wait_default();
}
else if (c_ipv4_to_word("10.10.10.7") == this_tcid && CMPI_FWD_RANK == this_rank)
{
int sockfd;
const char *mcast_ipaddr_str = "239.2.11.71";
UINT32 mcast_ipaddr;
UINT32 mcast_port = 8888;
UINT32 loop;
mcast_ipaddr = c_ipv4_to_word(mcast_ipaddr_str);
csocket_start_udp_mcast_sender(mcast_ipaddr, mcast_port, &sockfd);
for(loop = 0; loop < 5; loop ++)
{
UINT8 data[256];
UINT32 dlen;
snprintf((char *)data, sizeof(data)/sizeof(data[0]), "[loop %ld] hello world!", loop);
dlen = strlen((char *)data);
//dlen = sizeof(data)/sizeof(data[0]);
if(EC_FALSE == csocket_udp_mcast_sendto(sockfd, mcast_ipaddr, mcast_port, data, dlen))
{
sys_log(LOGSTDOUT, "error:send udp data to %s:%ld failed\n", mcast_ipaddr_str, mcast_port);
break;
}
sys_log(LOGCONSOLE, "send udp data: %.*s\n", dlen, (char *)data);
c_sleep(5);
}
csocket_stop_udp_mcast_sender(sockfd, c_ipv4_to_word(mcast_ipaddr_str));
do_slave_wait_default();
}
else if (CMPI_FWD_RANK == this_rank)
{
sys_log(LOGSTDOUT,"======================================================================\n");
sys_log(LOGSTDOUT," taskc_mgr in (tcid %s, rank %ld) \n", c_word_to_ipv4(this_tcid), this_rank);
super_show_work_client(task_brd_default_get_super(), LOGSTDOUT);/*debug only*/
sys_log(LOGSTDOUT,"======================================================================\n");
do_slave_wait_default();
}
/*work process*/
else
{
do_slave_wait_default();
}
return (0);
}
int main_cscore0(int argc, char **argv)
{
UINT32 this_tcid;
UINT32 this_comm;
UINT32 this_rank;
task_brd_default_init(argc, argv);
if(EC_FALSE == task_brd_default_check_validity())
{
dbg_log(SEC_0137_DEMO, 0)(LOGSTDOUT, "error:main_cscore: validity checking failed\n");
task_brd_default_abort();
return (-1);
}
this_tcid = task_brd_default_get_tcid();
this_comm = task_brd_default_get_comm();
this_rank = task_brd_default_get_rank();
if (EC_TRUE == task_brd_check_is_dbg_tcid(this_tcid) && CMPI_DBG_RANK == this_rank)
{
do_cmd_default();
}
else if (EC_TRUE == task_brd_check_is_monitor_tcid(this_tcid) && CMPI_MON_RANK == this_rank)
{
void * mod_mgr_def;
mod_mgr_def = mod_mgr_new(CMPI_ERROR_MODI, LOAD_BALANCING_LOOP);
mod_mgr_default_init(mod_mgr_def, CMPI_ANY_TCID, CMPI_ANY_RANK);
//mod_mgr_excl(this_tcid, CMPI_ANY_COMM, this_rank, CMPI_ANY_MODI, mod_mgr_def);
dbg_log(SEC_0137_DEMO, 5)(LOGSTDOUT, "======================================================================\n");
dbg_log(SEC_0137_DEMO, 5)(LOGSTDOUT, " mod_mgr_default_init finished \n");
dbg_log(SEC_0137_DEMO, 5)(LOGSTDOUT, "======================================================================\n");
mod_mgr_print(LOGSTDOUT, mod_mgr_def);
mod_mgr_free(mod_mgr_def);
do_slave_wait_default();
}
else if (c_ipv4_to_word("10.10.10.1") == this_tcid && 1 == this_rank)
{
UINT32 cbgt_md_id;
CSTRING *cbgt_db_root_dir;
CBYTES root_table_name;
cbgt_db_root_dir = task_brd_default_get_hsbgt_root_table_dir();
ASSERT(NULL_PTR != cbgt_db_root_dir);
cbytes_mount(&root_table_name, strlen("root"), (UINT8 *)"root");
cbgt_md_id = cbgt_start(CBGT_TYPE_ROOT_SERVER, CBGT_ROOT_TABLE_ID, &root_table_name, NULL_PTR, cbgt_db_root_dir, CBGT_O_RDWR | CBGT_O_CREAT);
test_case_cbgt_create_table_on_root(cbgt_md_id,
CSCORE_MD_DEFAULT_TABLE_NAME,
1,
CSCORE_MD_DEFAULT_COLF_NAME
);
ASSERT(ERR_MODULE_ID != cbgt_md_id);
dbg_log(SEC_0137_DEMO, 9)(LOGSTDOUT, "[DEBUG] main_cbgt: ============================ root server started ====================\n");
do_slave_wait_default();
}
/*fwd rank entrance*/
else if (c_ipv4_to_word("10.10.10.2") == this_tcid && 1 == this_rank)
{
UINT32 cscore_md_id;
dbg_log(SEC_0137_DEMO, 5)(LOGSTDOUT,"======================================================================\n");
dbg_log(SEC_0137_DEMO, 5)(LOGSTDOUT," taskc_mgr in (tcid %s, rank %ld) \n", c_word_to_ipv4(this_tcid), this_rank);
super_show_work_client(task_brd_default_get_super(), LOGSTDOUT);/*debug only*/
dbg_log(SEC_0137_DEMO, 5)(LOGSTDOUT,"======================================================================\n");
cscore_md_id = cscore_start();
ASSERT(ERR_MODULE_ID != cscore_md_id );
dbg_log(SEC_0137_DEMO, 9)(LOGSTDOUT, "[DEBUG] main_cscore: cscore_md_id = %ld\n", cscore_md_id);
//test_case_cscore_001(cscore_md_id);
//test_case_cscore_002(cscore_md_id);
//test_case_cscore_003(cscore_md_id);
//test_case_cscore_004(cscore_md_id);
test_case_cscore_005(cscore_md_id);
cscore_end(cscore_md_id);
do_slave_wait_default();
}
/*work process*/
else
{
do_slave_wait_default();
}
return (0);
}
int main_trans(int argc, char **argv)
{
UINT32 this_tcid;
UINT32 this_comm;
UINT32 this_rank;
task_brd_default_init(argc, argv);
if(EC_FALSE == task_brd_default_check_validity())
{
sys_log(LOGSTDOUT, "error:main_trans: validity checking failed\n");
task_brd_default_abort();
return (-1);
}
this_tcid = task_brd_default_get_tcid();
this_comm = task_brd_default_get_comm();
this_rank = task_brd_default_get_rank();
if (EC_TRUE == task_brd_check_is_dbg_tcid(this_tcid) && CMPI_DBG_RANK == this_rank)
{
do_cmd_default();
}
else if (EC_TRUE == task_brd_check_is_monitor_tcid(this_tcid) && CMPI_MON_RANK == this_rank)
{
void * mod_mgr_def;
mod_mgr_def = mod_mgr_new(CMPI_ERROR_MODI, LOAD_BALANCING_LOOP);
mod_mgr_default_init(mod_mgr_def, CMPI_ANY_TCID, CMPI_ANY_RANK);
//mod_mgr_excl(this_tcid, CMPI_ANY_COMM, this_rank, CMPI_ANY_MODI, mod_mgr_def);
sys_log(LOGSTDOUT, "======================================================================\n");
sys_log(LOGSTDOUT, " mod_mgr_default_init finished \n");
sys_log(LOGSTDOUT, "======================================================================\n");
mod_mgr_print(LOGSTDOUT, mod_mgr_def);
mod_mgr_free(mod_mgr_def);
do_slave_wait_default();
}
/*fwd rank entrance*/
else if (c_ipv4_to_word("10.10.10.2") == this_tcid && CMPI_FWD_RANK == this_rank)
{
CSTRING *src_fname;
CSTRING *des_fname;
UINT32 des_tcid;
src_fname = cstring_new((UINT8 *)"/home/ezhocha/bgn/bin/CentOS_4.4_DVD.iso", 0);
des_fname = cstring_new((UINT8 *)"/home/ezhocha/bgn/bin/CentOS_4.4_DVD_des.iso", 0);
des_tcid = c_ipv4_to_word("10.10.10.1");
super_transfer(0, src_fname, des_tcid, des_fname);
do_slave_wait_default();
}
else if (CMPI_FWD_RANK == this_rank)
{
sys_log(LOGSTDOUT,"======================================================================\n");
sys_log(LOGSTDOUT," taskc_mgr in (tcid %s, rank %ld) \n", c_word_to_ipv4(this_tcid), this_rank);
super_show_work_client(task_brd_default_get_super(), LOGSTDOUT);/*debug only*/
sys_log(LOGSTDOUT,"======================================================================\n");
do_slave_wait_default();
}
/*work process*/
else
{
do_slave_wait_default();
}
return (0);
}
static void print_tcid(LOG *log, const UINT32 tcid)
{
sys_log(log, "%s\n", c_word_to_ipv4(tcid));
return;
}
int main_csession(int argc, char **argv)
{
UINT32 this_tcid;
UINT32 this_comm;
UINT32 this_rank;
task_brd_default_init(argc, argv);
if(EC_FALSE == task_brd_default_check_validity())
{
sys_log(LOGSTDOUT, "error:main_csession: validity checking failed\n");
task_brd_default_abort();
return (-1);
}
this_tcid = task_brd_default_get_tcid();
this_comm = task_brd_default_get_comm();
this_rank = task_brd_default_get_rank();
if (EC_TRUE == task_brd_check_is_dbg_tcid(this_tcid) && CMPI_DBG_RANK == this_rank)
{
do_cmd_default();
}
else if (EC_TRUE == task_brd_check_is_monitor_tcid(this_tcid) && CMPI_MON_RANK == this_rank)
{
void * mod_mgr_def;
mod_mgr_def = mod_mgr_new(CMPI_ERROR_MODI, LOAD_BALANCING_LOOP);
mod_mgr_default_init(mod_mgr_def, CMPI_ANY_TCID, CMPI_ANY_RANK);
//mod_mgr_excl(this_tcid, CMPI_ANY_COMM, this_rank, CMPI_ANY_MODI, mod_mgr_def);
sys_log(LOGSTDOUT, "======================================================================\n");
sys_log(LOGSTDOUT, " mod_mgr_default_init finished \n");
sys_log(LOGSTDOUT, "======================================================================\n");
mod_mgr_print(LOGSTDOUT, mod_mgr_def);
mod_mgr_free(mod_mgr_def);
do_slave_wait_default();
}
/*fwd rank entrance*/
else if (CMPI_FWD_RANK == this_rank)
{
UINT32 csession_md_id;
sys_log(LOGSTDOUT,"======================================================================\n");
sys_log(LOGSTDOUT," taskc_mgr in (tcid %s, rank %ld) \n", c_word_to_ipv4(this_tcid), this_rank);
super_show_work_client(task_brd_default_get_super(), LOGSTDOUT);/*debug only*/
sys_log(LOGSTDOUT,"======================================================================\n");
csession_md_id = csession_start();
sys_log(LOGSTDOUT, "[DEBUG] main_csession: csession_md_id = %ld\n", csession_md_id);
do_slave_wait_default();
}
/*work process*/
else
{
do_slave_wait_default();
}
return (0);
}
CSRV * csrv_start(const UINT32 srv_ipaddr, const UINT32 srv_port, const UINT32 md_id,
const uint32_t timeout_nsec,
CSRV_INIT_CSOCKET_CNODE init_csocket_cnode,
CSRV_ADD_CSOCKET_CNODE add_csocket_cnode,
CSRV_DEL_CSOCKET_CNODE del_csocket_cnode,
CSRV_RD_HANDLER_FUNC rd_handler,
CSRV_WR_HANDLER_FUNC wr_handler,
CSRV_TIMEOUT_HANDLER_FUNC timeout_handler,
CSRV_COMPLETE_HANDLER_FUNC complete_handler,
CSRV_CLOSE_HANDLER_FUNC close_handler
)
{
CSRV *csrv;
int srv_sockfd;
int srv_unix_sockfd;
if(ERR_MODULE_ID == md_id)
{
dbg_log(SEC_0112_CSRV, 0)(LOGSTDOUT, "error:csrv_start: md id is invalid\n");
return (NULL_PTR);
}
if(EC_FALSE == csocket_listen(srv_ipaddr, srv_port, &srv_sockfd))
{
dbg_log(SEC_0112_CSRV, 0)(LOGSTDERR, "error:csrv_start: failed to listen on %s:%ld\n",
c_word_to_ipv4(srv_ipaddr), srv_port);
return (NULL_PTR);
}
srv_unix_sockfd = CMPI_ERROR_SOCKFD;
#if 0
if(EC_FALSE == csocket_unix_listen(srv_ipaddr, srv_port, &srv_unix_sockfd))
{
dbg_log(SEC_0112_CSRV, 0)(LOGSTDERR, "error:csrv_start: failed to listen on unix@%s:%ld\n",
c_word_to_ipv4(srv_ipaddr), srv_port);
}
#endif
csrv = csrv_new();
if(NULL_PTR == csrv)
{
dbg_log(SEC_0112_CSRV, 0)(LOGSTDOUT, "error:csrv_start: new csrv failed, close srv sockfd %d\n", srv_sockfd);
csocket_close(srv_sockfd);
return (NULL_PTR);
}
CSRV_IPADDR(csrv) = srv_ipaddr;
CSRV_PORT(csrv) = srv_port;
CSRV_SOCKFD(csrv) = srv_sockfd;
CSRV_UNIX_SOCKFD(csrv) = srv_unix_sockfd;
CSRV_MD_ID(csrv) = md_id;
CSRV_TIMEOUT_NSEC(csrv) = timeout_nsec;
CSRV_INIT_CSOCKET_CNODE(csrv) = NULL_PTR;
CSRV_ADD_CSOCKET_CNODE(csrv) = add_csocket_cnode;
CSRV_DEL_CSOCKET_CNODE(csrv) = del_csocket_cnode;
CSRV_RD_EVENT_HANDLER(csrv) = rd_handler;
CSRV_WR_EVENT_HANDLER(csrv) = wr_handler;
CSRV_TIMEOUT_HANDLER(csrv) = timeout_handler;
CSRV_COMPLETE_HANDLER(csrv) = complete_handler;
CSRV_CLOSE_HANDLER(csrv) = close_handler;
CSRV_CSSL_NODE(csrv) = NULL_PTR;
#if (SWITCH_ON == TASK_BRD_CEPOLL_SWITCH)
cepoll_set_event(task_brd_default_get_cepoll(),
CSRV_SOCKFD(csrv),
CEPOLL_RD_EVENT,
(CEPOLL_EVENT_HANDLER)csrv_accept,
(void *)csrv);
#if 0
if(CMPI_ERROR_SOCKFD != CSRV_UNIX_SOCKFD(csrv))
{
cepoll_set_event(task_brd_default_get_cepoll(),
CSRV_UNIX_SOCKFD(csrv),
CEPOLL_RD_EVENT,
(CEPOLL_EVENT_HANDLER)csrv_unix_accept,
(void *)csrv);
}
#endif
#endif/*(SWITCH_ON == TASK_BRD_CEPOLL_SWITCH)*/
dbg_log(SEC_0112_CSRV, 5)(LOGSTDOUT, "csrv_start: start srv sockfd %d on port %s:%ld\n",
srv_sockfd, c_word_to_ipv4(srv_ipaddr), srv_port);
return (csrv);
}
