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); }