char *qdr_field_copy(qdr_field_t *field)
{
if (!field || !field->iterator)
return 0;
return (char*) qd_field_iterator_copy(field->iterator);
}
void qdr_error_copy(qdr_error_t *from, pn_condition_t *to)
{
if (from->name) {
unsigned char *name = qd_field_iterator_copy(from->name->iterator);
pn_condition_set_name(to, (char*) name);
free(name);
}
if (from->description) {
unsigned char *desc = qd_field_iterator_copy(from->description->iterator);
pn_condition_set_description(to, (char*) desc);
free(desc);
}
if (from->info)
pn_data_copy(pn_condition_info(to), from->info);
}
// Copy a string value from an iterator as a python object.
static PyObject *py_iter_copy(qd_field_iterator_t *iter)
{
unsigned char *bytes = 0;
PyObject *value = 0;
(void)(iter && (bytes = qd_field_iterator_copy(iter)) && (value = PyString_FromString((char*)bytes)));
if (bytes) free(bytes);
return value;
}
qdr_auto_link_t *qdr_route_add_auto_link_CT(qdr_core_t *core,
qd_field_iterator_t *name,
qd_parsed_field_t *addr_field,
qd_direction_t dir,
int phase,
qd_parsed_field_t *conn_id,
bool is_container)
{
qdr_auto_link_t *al = new_qdr_auto_link_t();
//
// Set up the auto_link structure
//
ZERO(al);
al->identity = qdr_identifier(core);
al->name = name ? (char*) qd_field_iterator_copy(name) : 0;
al->dir = dir;
al->phase = phase;
al->state = QDR_AUTO_LINK_STATE_INACTIVE;
//
// Find or create an address for the auto_link destination
//
qd_field_iterator_t *iter = qd_parse_raw(addr_field);
qd_address_iterator_reset_view(iter, ITER_VIEW_ADDRESS_HASH);
qd_address_iterator_set_phase(iter, (char) phase + '0');
qd_hash_retrieve(core->addr_hash, iter, (void*) &al->addr);
if (!al->addr) {
al->addr = qdr_address_CT(core, qdr_treatment_for_address_CT(core, iter, 0, 0));
DEQ_INSERT_TAIL(core->addrs, al->addr);
qd_hash_insert(core->addr_hash, iter, al->addr, &al->addr->hash_handle);
}
al->addr->ref_count++;
//
// Find or create a connection identifier structure for this auto_link
//
if (conn_id) {
al->conn_id = qdr_route_declare_id_CT(core, qd_parse_raw(conn_id), is_container);
DEQ_INSERT_TAIL_N(REF, al->conn_id->auto_link_refs, al);
if (al->conn_id->open_connection)
qdr_auto_link_activate_CT(core, al, al->conn_id->open_connection);
}
//
// Add the auto_link to the core list
//
DEQ_INSERT_TAIL(core->auto_links, al);
return al;
}
qdr_link_route_t *qdr_route_add_link_route_CT(qdr_core_t *core,
qd_field_iterator_t *name,
qd_parsed_field_t *prefix_field,
qd_parsed_field_t *conn_id,
bool is_container,
qd_address_treatment_t treatment,
qd_direction_t dir)
{
qdr_link_route_t *lr = new_qdr_link_route_t();
//
// Set up the link_route structure
//
ZERO(lr);
lr->identity = qdr_identifier(core);
lr->name = name ? (char*) qd_field_iterator_copy(name) : 0;
lr->dir = dir;
lr->treatment = treatment;
//
// Find or create an address for link-attach routing
//
qd_field_iterator_t *iter = qd_parse_raw(prefix_field);
qd_address_iterator_reset_view(iter, ITER_VIEW_ADDRESS_HASH);
qd_address_iterator_override_prefix(iter, dir == QD_INCOMING ? 'C' : 'D');
qd_hash_retrieve(core->addr_hash, iter, (void*) &lr->addr);
if (!lr->addr) {
lr->addr = qdr_address_CT(core, treatment);
DEQ_INSERT_TAIL(core->addrs, lr->addr);
qd_hash_insert(core->addr_hash, iter, lr->addr, &lr->addr->hash_handle);
}
lr->addr->ref_count++;
//
// Find or create a connection identifier structure for this link route
//
if (conn_id) {
lr->conn_id = qdr_route_declare_id_CT(core, qd_parse_raw(conn_id), is_container);
DEQ_INSERT_TAIL_N(REF, lr->conn_id->link_route_refs, lr);
if (lr->conn_id->open_connection)
qdr_link_route_activate_CT(core, lr, lr->conn_id->open_connection);
}
//
// Add the link route to the core list
//
DEQ_INSERT_TAIL(core->link_routes, lr);
return lr;
}
static qd_hash_item_t *qd_hash_internal_insert(qd_hash_t *h, qd_field_iterator_t *key, int *exists, qd_hash_handle_t **handle)
{
unsigned long 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) {
*exists = 1;
if (handle)
*handle = 0;
return item;
}
item = new_qd_hash_item_t();
if (!item)
return 0;
DEQ_ITEM_INIT(item);
item->key = qd_field_iterator_copy(key);
DEQ_INSERT_TAIL(h->buckets[idx].items, item);
h->size++;
*exists = 0;
//
// If a pointer to a handle-pointer was supplied, create a handle for this item.
//
if (handle) {
*handle = new_qd_hash_handle_t();
(*handle)->bucket = &h->buckets[idx];
(*handle)->item = item;
}
return item;
}
void qdr_terminus_copy(qdr_terminus_t *from, pn_terminus_t *to)
{
if (!from)
return;
if (from->address) {
qd_address_iterator_reset_view(from->address->iterator, ITER_VIEW_ALL);
unsigned char *addr = qd_field_iterator_copy(from->address->iterator);
pn_terminus_set_address(to, (char*) addr);
free(addr);
}
pn_terminus_set_durability(to, from->durability);
pn_terminus_set_expiry_policy(to, from->expiry_policy);
pn_terminus_set_timeout(to, from->timeout);
pn_terminus_set_dynamic(to, from->dynamic);
pn_terminus_set_distribution_mode(to, from->distribution_mode);
pn_data_copy(pn_terminus_properties(to), from->properties);
pn_data_copy(pn_terminus_filter(to), from->filter);
pn_data_copy(pn_terminus_outcomes(to), from->outcomes);
pn_data_copy(pn_terminus_capabilities(to), from->capabilities);
}
static void qdr_subscribe_CT(qdr_core_t *core, qdr_action_t *action, bool discard)
{
qdr_field_t *address = action->args.io.address;
qdr_subscription_t *sub = action->args.io.subscription;
if (!discard) {
char aclass = action->args.io.address_class;
char phase = action->args.io.address_phase;
qdr_address_t *addr = 0;
char *astring = (char*) qd_field_iterator_copy(address->iterator);
qd_log(core->log, QD_LOG_INFO, "In-process subscription %c/%s", aclass, astring);
free(astring);
qd_address_iterator_override_prefix(address->iterator, aclass);
if (aclass == 'M')
qd_address_iterator_set_phase(address->iterator, phase);
qd_address_iterator_reset_view(address->iterator, ITER_VIEW_ADDRESS_HASH);
qd_hash_retrieve(core->addr_hash, address->iterator, (void**) &addr);
if (!addr) {
addr = qdr_address_CT(core, action->args.io.treatment);
qd_hash_insert(core->addr_hash, address->iterator, addr, &addr->hash_handle);
DEQ_ITEM_INIT(addr);
DEQ_INSERT_TAIL(core->addrs, addr);
}
sub->addr = addr;
DEQ_ITEM_INIT(sub);
DEQ_INSERT_TAIL(addr->subscriptions, sub);
qdr_addr_start_inlinks_CT(core, addr);
} else
free(sub);
qdr_field_free(address);
}
