static void qdr_del_router_CT(qdr_core_t *core, qdr_action_t *action, bool discard)
{
int router_maskbit = action->args.route_table.router_maskbit;
if (router_maskbit >= qd_bitmask_width() || router_maskbit < 0) {
qd_log(core->log, QD_LOG_CRITICAL, "del_router: Router maskbit out of range: %d", router_maskbit);
return;
}
if (core->routers_by_mask_bit[router_maskbit] == 0) {
qd_log(core->log, QD_LOG_CRITICAL, "del_router: Deleting nonexistent router: %d", router_maskbit);
return;
}
qdr_node_t *rnode = core->routers_by_mask_bit[router_maskbit];
qdr_address_t *oaddr = rnode->owning_addr;
assert(oaddr);
//
// Unlink the router node from the address record
//
qd_bitmask_clear_bit(oaddr->rnodes, router_maskbit);
qd_bitmask_clear_bit(core->router_addr_T->rnodes, router_maskbit);
qd_bitmask_clear_bit(core->routerma_addr_T->rnodes, router_maskbit);
rnode->ref_count -= 3;
//
// While the router node has a non-zero reference count, look for addresses
// to unlink the node from.
//
qdr_address_t *addr = DEQ_HEAD(core->addrs);
while (addr && rnode->ref_count > 0) {
if (qd_bitmask_clear_bit(addr->rnodes, router_maskbit))
//
// If the cleared bit was originally set, decrement the ref count
//
rnode->ref_count--;
addr = DEQ_NEXT(addr);
}
assert(rnode->ref_count == 0);
//
// Free the router node and the owning address records.
//
qd_bitmask_free(rnode->valid_origins);
DEQ_REMOVE(core->routers, rnode);
free_qdr_node_t(rnode);
qd_hash_remove_by_handle(core->addr_hash, oaddr->hash_handle);
DEQ_REMOVE(core->addrs, oaddr);
qd_hash_handle_free(oaddr->hash_handle);
core->routers_by_mask_bit[router_maskbit] = 0;
free_qdr_address_t(oaddr);
}
void qdr_route_del_auto_link_CT(qdr_core_t *core, qdr_auto_link_t *al)
{
//
// Disassociate from the connection identifier. Check to see if the identifier
// should be removed.
//
qdr_conn_identifier_t *cid = al->conn_id;
if (cid) {
qdr_connection_ref_t * cref = DEQ_HEAD(cid->connection_refs);
while (cref) {
qdr_auto_link_deactivate_CT(core, al, cref->conn);
cref = DEQ_NEXT(cref);
}
DEQ_REMOVE_N(REF, cid->auto_link_refs, al);
qdr_route_check_id_for_deletion_CT(core, cid);
}
//
// Disassociate the auto link from its address. Check to see if the address
// should be removed.
//
qdr_address_t *addr = al->addr;
if (addr && --addr->ref_count == 0)
qdr_check_addr_CT(core, addr, false);
//
// Remove the auto link from the core list.
//
DEQ_REMOVE(core->auto_links, al);
free(al->name);
free(al->external_addr);
free_qdr_auto_link_t(al);
}
void qdr_core_delete_link_route(qdr_core_t *core, qdr_link_route_t *lr)
{
DEQ_REMOVE(core->link_routes, lr);
free(lr->name);
free(lr->pattern);
free_qdr_link_route_t(lr);
}
void qdr_route_del_link_route_CT(qdr_core_t *core, qdr_link_route_t *lr)
{
//
// Disassociate from the connection identifier. Check to see if the identifier
// should be removed.
//
qdr_conn_identifier_t *cid = lr->conn_id;
if (cid) {
if (!!cid->open_connection)
qdr_link_route_deactivate_CT(core, lr, cid->open_connection);
DEQ_REMOVE_N(REF, cid->link_route_refs, lr);
qdr_route_check_id_for_deletion_CT(core, cid);
}
//
// Disassociate the link route from its address. Check to see if the address
// should be removed.
//
qdr_address_t *addr = lr->addr;
if (addr && --addr->ref_count == 0)
qdr_check_addr_CT(core, addr, false);
//
// Remove the link route from the core list.
//
DEQ_REMOVE(core->link_routes, lr);
free(lr->name);
free_qdr_link_route_t(lr);
}
void qdr_core_remove_address(qdr_core_t *core, qdr_address_t *addr)
{
// Remove the address from the list, hash index, and parse tree
DEQ_REMOVE(core->addrs, addr);
if (addr->hash_handle) {
const char *a_str = (const char *)qd_hash_key_by_handle(addr->hash_handle);
if (QDR_IS_LINK_ROUTE(a_str[0])) {
qd_iterator_t *iter = qd_iterator_string(a_str, ITER_VIEW_ALL);
qdr_link_route_unmap_pattern_CT(core, iter);
qd_iterator_free(iter);
}
qd_hash_remove_by_handle(core->addr_hash, addr->hash_handle);
qd_hash_handle_free(addr->hash_handle);
}
// Free resources associated with this address
qd_bitmask_free(addr->rnodes);
if (addr->treatment == QD_TREATMENT_ANYCAST_CLOSEST) {
qd_bitmask_free(addr->closest_remotes);
}
else if (addr->treatment == QD_TREATMENT_ANYCAST_BALANCED) {
free(addr->outstanding_deliveries);
}
free_qdr_address_t(addr);
}
void qdr_router_node_free(qdr_core_t *core, qdr_node_t *rnode)
{
qd_bitmask_free(rnode->valid_origins);
DEQ_REMOVE(core->routers, rnode);
core->routers_by_mask_bit[rnode->mask_bit] = 0;
core->cost_epoch++;
free_qdr_node_t(rnode);
}
void qdr_del_link_ref(qdr_link_ref_list_t *ref_list, qdr_link_t *link, int cls)
{
if (link->ref[cls]) {
DEQ_REMOVE(*ref_list, link->ref[cls]);
free_qdr_link_ref_t(link->ref[cls]);
link->ref[cls] = 0;
}
}
void qd_connection_manager_delete_connector(qd_dispatch_t *qd, void *impl)
{
qd_config_connector_t *cc = (qd_config_connector_t*)impl;
if(cc) {
DEQ_REMOVE(qd->connection_manager->config_connectors, cc);
qd_config_connector_free(cc);
}
}
void qd_connection_manager_delete_listener(qd_dispatch_t *qd, void *impl)
{
qd_config_listener_t *cl = (qd_config_listener_t*)impl;
if(cl) {
qd_server_listener_close(cl->listener);
DEQ_REMOVE(qd->connection_manager->config_listeners, cl);
qd_config_listener_free(cl);
}
}
bool qdr_del_link_ref(qdr_link_ref_list_t *ref_list, qdr_link_t *link, int cls)
{
if (link->ref[cls]) {
DEQ_REMOVE(*ref_list, link->ref[cls]);
free_qdr_link_ref_t(link->ref[cls]);
link->ref[cls] = 0;
return true;
}
return false;
}
qd_error_t qd_hash_remove_by_handle2(qd_hash_t *h, qd_hash_handle_t *handle, unsigned char **key)
{
if (!handle)
return QD_ERROR_NOT_FOUND;
*key = handle->item->key;
DEQ_REMOVE(handle->bucket->items, handle->item);
free_qd_hash_item_t(handle->item);
h->size--;
return QD_ERROR_NONE;
}
/**
* Link Detached Handler
*/
static int router_link_detach_handler(void* context, dx_link_t *link, int closed)
{
dx_router_t *router = (dx_router_t*) context;
pn_link_t *pn_link = dx_link_pn(link);
const char *r_tgt = pn_terminus_get_address(pn_link_remote_target(pn_link));
dx_link_item_t *item;
sys_mutex_lock(router->lock);
if (pn_link_is_sender(pn_link)) {
item = DEQ_HEAD(router->out_links);
dx_field_iterator_t *iter = dx_field_iterator_string(r_tgt, ITER_VIEW_NO_HOST);
dx_router_link_t *rlink;
if (iter) {
int result = hash_retrieve(router->out_hash, iter, (void*) &rlink);
if (result == 0) {
dx_field_iterator_reset(iter, ITER_VIEW_NO_HOST);
hash_remove(router->out_hash, iter);
free_dx_router_link_t(rlink);
dx_log(module, LOG_TRACE, "Removed local address: %s", r_tgt);
}
dx_field_iterator_free(iter);
}
}
else
item = DEQ_HEAD(router->in_links);
while (item) {
if (item->link == link) {
if (pn_link_is_sender(pn_link))
DEQ_REMOVE(router->out_links, item);
else
DEQ_REMOVE(router->in_links, item);
free_dx_link_item_t(item);
break;
}
item = item->next;
}
sys_mutex_unlock(router->lock);
return 0;
}
void qdr_core_remove_address(qdr_core_t *core, qdr_address_t *addr)
{
qdr_address_config_t *config = addr->config;
if (config && --config->ref_count == 0)
free_address_config(config);
// Remove the address from the list, hash index, and parse tree
DEQ_REMOVE(core->addrs, addr);
if (addr->hash_handle) {
const char *a_str = (const char *)qd_hash_key_by_handle(addr->hash_handle);
if (QDR_IS_LINK_ROUTE(a_str[0])) {
qd_iterator_t *iter = qd_iterator_string(a_str, ITER_VIEW_ALL);
qdr_link_route_unmap_pattern_CT(core, iter);
qd_iterator_free(iter);
}
qd_hash_remove_by_handle(core->addr_hash, addr->hash_handle);
qd_hash_handle_free(addr->hash_handle);
}
// Free resources associated with this address
DEQ_APPEND(addr->rlinks, addr->inlinks);
qdr_link_ref_t *lref = DEQ_HEAD(addr->rlinks);
while (lref) {
qdr_link_t *link = lref->link;
assert(link->owning_addr == addr);
link->owning_addr = 0;
qdr_del_link_ref(&addr->rlinks, link, QDR_LINK_LIST_CLASS_ADDRESS);
lref = DEQ_HEAD(addr->rlinks);
}
qd_bitmask_free(addr->rnodes);
if (addr->treatment == QD_TREATMENT_ANYCAST_CLOSEST) {
qd_bitmask_free(addr->closest_remotes);
}
else if (addr->treatment == QD_TREATMENT_ANYCAST_BALANCED) {
free(addr->outstanding_deliveries);
}
qdr_connection_ref_t *cr = DEQ_HEAD(addr->conns);
while (cr) {
qdr_del_connection_ref(&addr->conns, cr->conn);
cr = DEQ_HEAD(addr->conns);
}
if (!!addr->fallback) {
addr->fallback->fallback_for = 0;
qdr_check_addr_CT(core, addr->fallback);
}
free(addr->add_prefix);
free(addr->del_prefix);
free_qdr_address_t(addr);
}
void qd_connection_manager_delete_listener(qd_dispatch_t *qd, void *impl)
{
qd_listener_t *li = (qd_listener_t*) impl;
if (li) {
if (li->pn_listener) {
pn_listener_close(li->pn_listener);
}
DEQ_REMOVE(qd->connection_manager->listeners, li);
qd_listener_decref(li);
}
}
static bool config_sasl_plugin_free(qd_connection_manager_t *cm, qd_config_sasl_plugin_t *sasl_plugin)
{
DEQ_REMOVE(cm->config_sasl_plugins, sasl_plugin);
free(sasl_plugin->name);
free(sasl_plugin->auth_service);
free(sasl_plugin->sasl_init_hostname);
free(sasl_plugin->auth_ssl_profile);
free(sasl_plugin);
return true;
}
void qdr_del_connection_ref(qdr_connection_ref_list_t *ref_list, qdr_connection_t *conn)
{
qdr_connection_ref_t *ref = DEQ_HEAD(*ref_list);
while (ref) {
if (ref->conn == conn) {
DEQ_REMOVE(*ref_list, ref);
free_qdr_connection_ref_t(ref);
break;
}
ref = DEQ_NEXT(ref);
}
}
static void qdr_unsubscribe_CT(qdr_core_t *core, qdr_action_t *action, bool discard)
{
qdr_subscription_t *sub = action->args.io.subscription;
if (!discard) {
DEQ_REMOVE(sub->addr->subscriptions, sub);
sub->addr = 0;
qdr_check_addr_CT(sub->core, sub->addr, false);
}
free(sub);
}
// Must hold the log_source_lock
static void log_sink_free_lh(log_sink_t* sink) {
if (!sink) return;
assert(sink->refcount);
if (--sink->refcount == 0) {
DEQ_REMOVE(sink_list, sink);
free(sink->name);
if (sink->file && sink->file != stderr)
fclose(sink->file);
if (sink->syslog) closelog();
free(sink);
}
}
void qd_connection_manager_delete_connector(qd_dispatch_t *qd, void *impl)
{
qd_connector_t *ct = (qd_connector_t*) impl;
if (ct) {
sys_mutex_lock(ct->lock);
if (ct->ctx && ct->ctx->pn_conn) {
qd_connection_invoke_deferred(ct->ctx, deferred_close, ct->ctx->pn_conn);
}
sys_mutex_unlock(ct->lock);
DEQ_REMOVE(qd->connection_manager->connectors, ct);
qd_connector_decref(ct);
}
}
void qdr_core_remove_address_config(qdr_core_t *core, qdr_address_config_t *addr)
{
qd_iterator_t *pattern = qd_iterator_string(addr->pattern, ITER_VIEW_ALL);
// Remove the address from the list and the parse tree
DEQ_REMOVE(core->addr_config, addr);
qd_parse_tree_remove_pattern(core->addr_parse_tree, pattern);
addr->ref_count--;
if (addr->ref_count == 0)
free_address_config(addr);
qd_iterator_free(pattern);
}
void qdr_del_node_ref(qdr_router_ref_list_t *ref_list, qdr_node_t *rnode)
{
qdr_router_ref_t *ref = DEQ_HEAD(*ref_list);
while (ref) {
if (ref->router == rnode) {
DEQ_REMOVE(*ref_list, ref);
free_qdr_router_ref_t(ref);
rnode->ref_count--;
break;
}
ref = DEQ_NEXT(ref);
}
}
void qdr_core_remove_address_config(qdr_core_t *core, qdr_address_config_t *addr)
{
// Remove the address from the list and the hash index.
qd_hash_remove_by_handle(core->addr_hash, addr->hash_handle);
DEQ_REMOVE(core->addr_config, addr);
// Free resources associated with this address.
if (addr->name) {
free(addr->name);
}
qd_hash_handle_free(addr->hash_handle);
free_qdr_address_config_t(addr);
}
void qdr_core_remove_address_config(qdr_core_t *core, qdr_address_config_t *addr)
{
qd_iterator_t *pattern = qd_iterator_string(addr->pattern, ITER_VIEW_ALL);
// Remove the address from the list and the parse tree
DEQ_REMOVE(core->addr_config, addr);
qd_parse_tree_remove_pattern(core->addr_parse_tree, pattern);
// Free resources associated with this address.
if (addr->name) {
free(addr->name);
}
qd_iterator_free(pattern);
free(addr->pattern);
free_qdr_address_config_t(addr);
}
void qd_container_destroy_node(qd_node_t *node)
{
qd_container_t *container = node->container;
if (node->name) {
qd_field_iterator_t *iter = qd_field_iterator_string(node->name);
sys_mutex_lock(container->lock);
qd_hash_remove(container->node_map, iter);
DEQ_REMOVE(container->nodes, node);
sys_mutex_unlock(container->lock);
qd_field_iterator_free(iter);
free(node->name);
}
free_qd_node_t(node);
}
void qdr_core_remove_address(qdr_core_t *core, qdr_address_t *addr)
{
// Remove the address from the list and hash index
qd_hash_remove_by_handle(core->addr_hash, addr->hash_handle);
DEQ_REMOVE(core->addrs, addr);
// Free resources associated with this address
qd_hash_handle_free(addr->hash_handle);
qd_bitmask_free(addr->rnodes);
if (addr->treatment == QD_TREATMENT_ANYCAST_CLOSEST) {
qd_bitmask_free(addr->closest_remotes);
}
else if (addr->treatment == QD_TREATMENT_ANYCAST_BALANCED) {
free(addr->outstanding_deliveries);
}
free_qdr_address_t(addr);
}
static bool config_ssl_profile_free(qd_connection_manager_t *cm, qd_config_ssl_profile_t *ssl_profile)
{
DEQ_REMOVE(cm->config_ssl_profiles, ssl_profile);
free(ssl_profile->name);
free(ssl_profile->ssl_password);
free(ssl_profile->ssl_trusted_certificate_db);
free(ssl_profile->ssl_trusted_certificates);
free(ssl_profile->ssl_uid_format);
free(ssl_profile->ssl_display_name_file);
free(ssl_profile->ssl_certificate_file);
free(ssl_profile->ssl_private_key_file);
free(ssl_profile->ciphers);
free(ssl_profile);
return true;
}
bool qd_config_ssl_profile_free(qd_connection_manager_t *cm, qd_config_ssl_profile_t *ssl_profile)
{
if (sys_atomic_get(&ssl_profile->ref_count) != 0) {
return false;
}
DEQ_REMOVE(cm->config_ssl_profiles, ssl_profile);
free(ssl_profile->name);
free(ssl_profile->ssl_password);
free(ssl_profile->ssl_trusted_certificate_db);
free(ssl_profile->ssl_trusted_certificates);
free(ssl_profile->ssl_uid_format);
free(ssl_profile->ssl_display_name_file);
free(ssl_profile->ssl_certificate_file);
free(ssl_profile->ssl_private_key_file);
free(ssl_profile);
return true;
}
int hash_remove(hash_t *h, nx_field_iterator_t *key)
{
unsigned long idx = hash_function(key) & h->bucket_mask;
hash_item_t *item = DEQ_HEAD(h->buckets[idx].items);
while (item) {
if (nx_field_iterator_equal(key, item->key))
break;
item = item->next;
}
if (item) {
free(item->key);
DEQ_REMOVE(h->buckets[idx].items, item);
free_hash_item_t(item);
h->size--;
return 0;
}
return -1;
}
qd_error_t qd_hash_remove(qd_hash_t *h, qd_field_iterator_t *key)
{
uint32_t idx = qd_iterator_hash_function(key) & h->bucket_mask;
qd_hash_item_t *item = DEQ_HEAD(h->buckets[idx].items);
while (item) {
if (qd_field_iterator_equal(key, item->key))
break;
item = item->next;
}
if (item) {
free(item->key);
DEQ_REMOVE(h->buckets[idx].items, item);
free_qd_hash_item_t(item);
h->size--;
return QD_ERROR_NONE;
}
return QD_ERROR_NOT_FOUND;
}
static void qd_log_entry_free_lh(qd_log_entry_t* entry) {
DEQ_REMOVE(entries, entry);
free(entry->file);
free_qd_log_entry_t(entry);
}
