void qdr_core_free(qdr_core_t *core)
{
//
// Stop and join the thread
//
core->running = false;
sys_cond_signal(core->action_cond);
sys_thread_join(core->thread);
//
// Free the core resources
//
sys_thread_free(core->thread);
sys_cond_free(core->action_cond);
sys_mutex_free(core->action_lock);
sys_mutex_free(core->work_lock);
sys_mutex_free(core->id_lock);
qd_timer_free(core->work_timer);
//we can't call qdr_core_unsubscribe on the subscriptions because the action processing thread has
//already been shut down. But, all the action would have done at this point is free the subscriptions
//so we just do that directly.
free(core->agent_subscription_mobile);
free(core->agent_subscription_local);
for (int i = 0; i <= QD_TREATMENT_LINK_BALANCED; ++i) {
if (core->forwarders[i]) {
free(core->forwarders[i]);
}
}
qdr_address_t *addr = 0;
while ( (addr = DEQ_HEAD(core->addrs)) ) {
qdr_core_remove_address(core, addr);
}
qdr_address_config_t *addr_config = 0;
while ( (addr_config = DEQ_HEAD(core->addr_config))) {
qdr_core_remove_address_config(core, addr_config);
}
qd_hash_free(core->addr_hash);
qd_hash_free(core->conn_id_hash);
//TODO what about the actual connection identifier objects?
qdr_node_t *rnode = 0;
while ( (rnode = DEQ_HEAD(core->routers)) ) {
qdr_router_node_free(core, rnode);
}
if (core->query_lock) sys_mutex_free(core->query_lock);
if (core->routers_by_mask_bit) free(core->routers_by_mask_bit);
if (core->control_links_by_mask_bit) free(core->control_links_by_mask_bit);
if (core->data_links_by_mask_bit) free(core->data_links_by_mask_bit);
if (core->neighbor_free_mask) qd_bitmask_free(core->neighbor_free_mask);
free(core);
}
void report_mem_leak(void)
{
unsigned short index;
MEM_LEAK * leak_info;
char *info;
sys_mutex_lock(&mem_mutex);
printf("ptr_start =%p\n",ptr_start);
info = (char *)zalloc(name_length);
if(info) {
for(leak_info = ptr_start; leak_info != NULL; leak_info = leak_info->next)
{
printf("%p\n",leak_info);
sprintf(info, "address : %p\n", leak_info->mem_info.address);
printf("%s\n",info);
sprintf(info, "size : %d bytes\n", leak_info->mem_info.size);
printf("%s\n",info);
snprintf(info,name_length,"file : %s\n", leak_info->mem_info.file_name);
printf("%s\n",info);
sprintf(info, "line : %d\n", leak_info->mem_info.line);
printf("%s\n",info);
}
clear();
free(info);
}
sys_mutex_unlock(&mem_mutex);
sys_mutex_free(&mem_mutex);
}
void qd_message_free(qd_message_t *in_msg)
{
if (!in_msg) return;
uint32_t rc;
qd_message_pvt_t *msg = (qd_message_pvt_t*) in_msg;
qd_buffer_list_free_buffers(&msg->ma_to_override);
qd_buffer_list_free_buffers(&msg->ma_trace);
qd_buffer_list_free_buffers(&msg->ma_ingress);
qd_message_content_t *content = msg->content;
sys_mutex_lock(content->lock);
rc = --content->ref_count;
sys_mutex_unlock(content->lock);
if (rc == 0) {
if (content->parsed_message_annotations)
qd_parse_free(content->parsed_message_annotations);
qd_buffer_t *buf = DEQ_HEAD(content->buffers);
while (buf) {
DEQ_REMOVE_HEAD(content->buffers);
qd_buffer_free(buf);
buf = DEQ_HEAD(content->buffers);
}
sys_mutex_free(content->lock);
free_qd_message_content_t(content);
}
free_qd_message_t((qd_message_t*) msg);
}
void qd_connection_manager_free(qd_connection_manager_t *cm)
{
if (!cm) return;
qd_config_listener_t *cl = DEQ_HEAD(cm->config_listeners);
while (cl) {
DEQ_REMOVE_HEAD(cm->config_listeners);
qd_server_config_free(&cl->configuration);
qd_config_listener_free(cm, cl);
cl = DEQ_HEAD(cm->config_listeners);
}
qd_config_connector_t *cc = DEQ_HEAD(cm->config_connectors);
while (cc) {
DEQ_REMOVE_HEAD(cm->config_connectors);
qd_server_config_free(&cc->configuration);
qd_config_connector_free(cm, cc);
cc = DEQ_HEAD(cm->config_connectors);
}
qd_config_ssl_profile_t *sslp = DEQ_HEAD(cm->config_ssl_profiles);
while (sslp) {
qd_config_ssl_profile_free(cm, sslp);
sslp = DEQ_HEAD(cm->config_ssl_profiles);
}
sys_mutex_free(cm->ssl_profile_lock);
}
void qd_python_finalize(void)
{
sys_mutex_free(ilock);
Py_DECREF(dispatch_module);
dispatch_module = 0;
PyGC_Collect();
Py_Finalize();
}
int server_tests(qd_dispatch_t *_qd)
{
int result = 0;
test_lock = sys_mutex();
qd = _qd;
TEST_CASE(test_user_fd, 0);
sys_mutex_free(test_lock);
return result;
}
static void
pollmgr_refptr_delete(struct pollmgr_refptr *rp)
{
if (rp == NULL) {
return;
}
LWIP_ASSERT1(rp->strong == 0);
LWIP_ASSERT1(rp->weak == 0);
sys_mutex_free(&rp->lock);
free(rp);
}
void qdr_core_free(qdr_core_t *core)
{
//
// Stop and join the thread
//
core->running = false;
sys_cond_signal(core->action_cond);
sys_thread_join(core->thread);
//
// Free the core resources
//
qdr_core_unsubscribe(core->agent_subscription_mobile);
qdr_core_unsubscribe(core->agent_subscription_local);
sys_thread_free(core->thread);
sys_cond_free(core->action_cond);
sys_mutex_free(core->action_lock);
sys_mutex_free(core->work_lock);
sys_mutex_free(core->id_lock);
qd_timer_free(core->work_timer);
free(core);
}
void qd_router_free(qd_router_t *router)
{
if (!router) return;
qd_container_set_default_node_type(router->qd, 0, 0, QD_DIST_BOTH);
qdr_core_free(router->router_core);
qd_tracemask_free(router->tracemask);
qd_timer_free(router->timer);
sys_mutex_free(router->lock);
qd_router_configure_free(router);
qd_router_python_free(router);
free(router);
free(node_id);
free(direct_prefix);
}
void qd_container_free(qd_container_t *container)
{
if (!container) return;
if (container->default_node)
qd_container_destroy_node(container->default_node);
qd_node_t *node = DEQ_HEAD(container->nodes);
while (node) {
qd_container_destroy_node(node);
node = DEQ_HEAD(container->nodes);
}
qdc_node_type_t *nt = DEQ_HEAD(container->node_type_list);
while (nt) {
DEQ_REMOVE_HEAD(container->node_type_list);
free(nt);
nt = DEQ_HEAD(container->node_type_list);
}
qd_hash_free(container->node_map);
qd_hash_free(container->node_type_map);
sys_mutex_free(container->lock);
free(container);
}
void qdr_core_free(qdr_core_t *core)
{
//
// Stop and join the thread
//
core->running = false;
sys_cond_signal(core->action_cond);
sys_thread_join(core->thread);
// Drain the general work lists
qdr_general_handler(core);
//
// Free the core resources
//
sys_thread_free(core->thread);
sys_cond_free(core->action_cond);
sys_mutex_free(core->action_lock);
sys_mutex_free(core->work_lock);
sys_mutex_free(core->id_lock);
qd_timer_free(core->work_timer);
//we can't call qdr_core_unsubscribe on the subscriptions because the action processing thread has
//already been shut down. But, all the action would have done at this point is free the subscriptions
//so we just do that directly.
free(core->agent_subscription_mobile);
free(core->agent_subscription_local);
for (int i = 0; i <= QD_TREATMENT_LINK_BALANCED; ++i) {
if (core->forwarders[i]) {
free(core->forwarders[i]);
}
}
qdr_link_route_t *link_route = 0;
while ( (link_route = DEQ_HEAD(core->link_routes))) {
DEQ_REMOVE_HEAD(core->link_routes);
qdr_core_delete_link_route(core, link_route);
}
qdr_auto_link_t *auto_link = 0;
while ( (auto_link = DEQ_HEAD(core->auto_links))) {
DEQ_REMOVE_HEAD(core->auto_links);
qdr_core_delete_auto_link(core, auto_link);
}
qdr_exchange_free_all(core);
qdr_address_t *addr = 0;
while ( (addr = DEQ_HEAD(core->addrs)) ) {
qdr_core_remove_address(core, addr);
}
qdr_address_config_t *addr_config = 0;
while ( (addr_config = DEQ_HEAD(core->addr_config))) {
qdr_core_remove_address_config(core, addr_config);
}
qd_hash_free(core->addr_hash);
qd_parse_tree_free(core->addr_parse_tree);
qd_parse_tree_free(core->link_route_tree[QD_INCOMING]);
qd_parse_tree_free(core->link_route_tree[QD_OUTGOING]);
qdr_node_t *rnode = 0;
while ( (rnode = DEQ_HEAD(core->routers)) ) {
qdr_router_node_free(core, rnode);
}
qdr_link_t *link = DEQ_HEAD(core->open_links);
while (link) {
DEQ_REMOVE_HEAD(core->open_links);
if (link->core_endpoint)
qdrc_endpoint_do_cleanup_CT(core, link->core_endpoint);
qdr_del_link_ref(&link->conn->links, link, QDR_LINK_LIST_CLASS_CONNECTION);
qdr_del_link_ref(&link->conn->links_with_work[link->priority], link, QDR_LINK_LIST_CLASS_WORK);
free(link->name);
free(link->disambiguated_name);
free(link->terminus_addr);
free(link->ingress_histogram);
free(link->insert_prefix);
free(link->strip_prefix);
link->name = 0;
free_qdr_link_t(link);
link = DEQ_HEAD(core->open_links);
}
qdr_connection_t *conn = DEQ_HEAD(core->open_connections);
while (conn) {
DEQ_REMOVE_HEAD(core->open_connections);
if (conn->conn_id) {
qdr_del_connection_ref(&conn->conn_id->connection_refs, conn);
qdr_route_check_id_for_deletion_CT(core, conn->conn_id);
}
qdr_connection_work_t *work = DEQ_HEAD(conn->work_list);
while (work) {
DEQ_REMOVE_HEAD(conn->work_list);
qdr_connection_work_free_CT(work);
work = DEQ_HEAD(conn->work_list);
}
qdr_connection_free(conn);
conn = DEQ_HEAD(core->open_connections);
}
// at this point all the conn identifiers have been freed
qd_hash_free(core->conn_id_hash);
qdr_modules_finalize(core);
if (core->query_lock) sys_mutex_free(core->query_lock);
if (core->routers_by_mask_bit) free(core->routers_by_mask_bit);
if (core->control_links_by_mask_bit) free(core->control_links_by_mask_bit);
if (core->data_links_by_mask_bit) free(core->data_links_by_mask_bit);
if (core->neighbor_free_mask) qd_bitmask_free(core->neighbor_free_mask);
free(core);
}
void dx_router_free(dx_router_t *router)
{
dx_container_set_default_node_type(router->dx, 0, 0, DX_DIST_BOTH);
sys_mutex_free(router->lock);
free(router);
}