// get the link route by either name or id static qdr_link_route_t *_find_link_route_CT(qdr_connection_t *conn, qd_iterator_t *name, qd_iterator_t *identity) { qdr_link_route_t *lr = NULL; // if both id and name provided, prefer id // if (identity) { char buf[64]; uint64_t id = 0; assert(qd_iterator_length(identity) < sizeof(buf)); qd_iterator_strncpy(identity, buf, sizeof(buf)); if (sscanf(buf, "%"SCNu64, &id) != 1) { return NULL; } lr = DEQ_HEAD(conn->conn_link_routes); while (lr) { if (id == lr->identity) break; lr = DEQ_NEXT(lr); } } else if (name) { lr = DEQ_HEAD(conn->conn_link_routes); while (lr) { if (qd_iterator_equal(name, (unsigned char *)lr->name)) break; lr = DEQ_NEXT(lr); } } return lr; }
static char* test_view_address_hash_override(void *context) { struct {const char *addr; const char *view;} cases[] = { {"amqp:/link-target", "Clink-target"}, {"amqp:/domain/link-target", "Cdomain/link-target"}, {"domain/link-target", "Cdomain/link-target"}, {"bbc79fb3-e1fd-4a08-92b2-9a2de232b558", "Cbbc79fb3-e1fd-4a08-92b2-9a2de232b558"}, {0, 0} }; int idx; for (idx = 0; cases[idx].addr; idx++) { qd_iterator_t *iter = qd_iterator_string(cases[idx].addr, ITER_VIEW_ADDRESS_HASH); qd_iterator_annotate_prefix(iter, 'C'); if (!qd_iterator_equal(iter, (unsigned char*) cases[idx].view)) { char *got = (char*) qd_iterator_copy(iter); snprintf(fail_text, FAIL_TEXT_SIZE, "Addr '%s' failed. Expected '%s', got '%s'", cases[idx].addr, cases[idx].view, got); return fail_text; } qd_iterator_free(iter); } return 0; }
static char* test_view_address_with_space(void *context) { struct {const char *addr; const char *view;} cases[] = { {"amqp:/link-target", "M0test.vhost.link-target"}, {"amqp:/domain/link-target", "M0test.vhost.domain/link-target"}, {"domain/link-target", "M0test.vhost.domain/link-target"}, {"bbc79fb3-e1fd-4a08-92b2-9a2de232b558", "M0test.vhost.bbc79fb3-e1fd-4a08-92b2-9a2de232b558"}, {0, 0} }; int idx; for (idx = 0; cases[idx].addr; idx++) { qd_iterator_t *iter = qd_iterator_string(cases[idx].addr, ITER_VIEW_ADDRESS_HASH); qd_iterator_annotate_space(iter, "test.vhost.", 11); if (!qd_iterator_equal(iter, (unsigned char*) cases[idx].view)) { char *got = (char*) qd_iterator_copy(iter); snprintf(fail_text, FAIL_TEXT_SIZE, "Addr '%s' failed. Expected '%s', got '%s'", cases[idx].addr, cases[idx].view, got); return fail_text; } if (qd_iterator_length(iter) != strlen(cases[idx].view)) { snprintf(fail_text, FAIL_TEXT_SIZE, "Addr '%s' failed. Length %d, iter_length returned %d", cases[idx].addr, (int) strlen(cases[idx].view), (int) qd_iterator_length(iter)); return fail_text; } qd_iterator_free(iter); } return 0; }
static char* test_view_global_no_host(void *context) { qd_iterator_t *iter = qd_iterator_string("global/sub", ITER_VIEW_ALL); if (!qd_iterator_equal(iter, (unsigned char*) "global/sub")) return "ITER_VIEW_ALL failed"; qd_iterator_reset_view(iter, ITER_VIEW_ADDRESS_NO_HOST); if (!qd_iterator_equal(iter, (unsigned char*) "global/sub")) return "ITER_VIEW_ADDRESS_NO_HOST failed"; qd_iterator_reset_view(iter, ITER_VIEW_ADDRESS_HASH); if (!qd_iterator_equal(iter, (unsigned char*) "M0global/sub")) return "ITER_VIEW_ADDRESS_HASH failed"; qd_iterator_free(iter); return 0; }
static char* view_address_hash(void *context, qd_iterator_t *iter, const char *addr, const char *view) { qd_iterator_annotate_phase(iter, '1'); if (!qd_iterator_equal(iter, (unsigned char*) view)) { char *got = (char*) qd_iterator_copy(iter); snprintf(fail_text, FAIL_TEXT_SIZE, "Addr '%s' failed. Expected '%s', got '%s'", addr, view, got); return fail_text; } return 0; }
static char *test_sub_iterator(void *context) { qd_iterator_t *iter = qd_iterator_string("test_sub_iterator", ITER_VIEW_ALL); qd_iterator_t *sub1 = qd_iterator_sub(iter, qd_iterator_remaining(iter)); qd_iterator_advance(iter, 5); qd_iterator_t *sub2 = qd_iterator_sub(iter, qd_iterator_remaining(iter)); qd_iterator_t *sub3 = qd_iterator_sub(iter, 3); if (!qd_iterator_equal(sub1, (unsigned char*) "test_sub_iterator")) return "Sub Iterator failed - 1"; if (!qd_iterator_equal(sub2, (unsigned char*) "sub_iterator")) return "Sub Iterator failed - 2"; if (!qd_iterator_equal(sub3, (unsigned char*) "sub")) return "Sub Iterator failed - 3"; qd_iterator_free(iter); qd_iterator_free(sub1); qd_iterator_free(sub2); qd_iterator_free(sub3); return 0; }
static char *test_trim(void *context) { qd_iterator_t *iter = qd_iterator_string("testing.trim", ITER_VIEW_ALL); qd_iterator_trim_view(iter, 7); if (!qd_iterator_equal(iter, (unsigned char*) "testing")) return "Trim on ITER_VIEW_ALL failed (1)"; qd_iterator_reset_view(iter, ITER_VIEW_ALL); if (!qd_iterator_equal(iter, (unsigned char*) "testing.trim")) return "Trim on ITER_VIEW_ALL failed (2)"; qd_iterator_advance(iter, 4); qd_iterator_trim_view(iter, 5); if (!qd_iterator_equal(iter, (unsigned char*) "ing.t")) return "Trim on ITER_VIEW_ALL failed (3)"; qd_iterator_reset_view(iter, ITER_VIEW_ADDRESS_HASH); qd_iterator_trim_view(iter, 9); if (!qd_iterator_equal(iter, (unsigned char*) "M0testing")) return "Trim on ITER_VIEW_ADDRESS_HASH failed"; qd_iterator_reset(iter); qd_iterator_annotate_space(iter, "my_space.", 9); qd_iterator_trim_view(iter, 18); if (!qd_iterator_equal(iter, (unsigned char*) "M0my_space.testing")) return "Trim on ITER_VIEW_ADDRESS_HASH (with space 1) failed"; qd_iterator_reset(iter); qd_iterator_trim_view(iter, 10); if (!qd_iterator_equal(iter, (unsigned char*) "M0my_space")) return "Trim on ITER_VIEW_ADDRESS_HASH (in space 1) failed"; qd_iterator_reset(iter); qd_iterator_trim_view(iter, 2); if (!qd_iterator_equal(iter, (unsigned char*) "M0")) return "Trim on ITER_VIEW_ADDRESS_HASH (in annotation 1) failed"; qd_iterator_reset(iter); qd_iterator_trim_view(iter, 1); if (!qd_iterator_equal(iter, (unsigned char*) "M")) return "Trim on ITER_VIEW_ADDRESS_HASH (in annotation 2) failed"; qd_iterator_free(iter); return 0; }
qd_parsed_field_t *qd_parse_value_by_key(qd_parsed_field_t *field, const char *key) { uint32_t count = qd_parse_sub_count(field); for (uint32_t idx = 0; idx < count; idx++) { qd_parsed_field_t *sub = qd_parse_sub_key(field, idx); if (!sub) return 0; qd_iterator_t *iter = qd_parse_raw(sub); if (!iter) return 0; if (qd_iterator_equal(iter, (const unsigned char*) key)) { return qd_parse_sub_value(field, idx); } } return 0; }
static char* test_view_node_hash(void *context) { struct {const char *addr; const char *view;} cases[] = { {"area/router", "Aarea"}, {"my-area/router", "Rrouter"}, {"my-area/my-router", "Rmy-router"}, {0, 0} }; int idx; for (idx = 0; cases[idx].addr; idx++) { qd_iterator_t *iter = qd_iterator_string(cases[idx].addr, ITER_VIEW_NODE_HASH); if (!qd_iterator_equal(iter, (unsigned char*) cases[idx].view)) { char *got = (char*) qd_iterator_copy(iter); snprintf(fail_text, FAIL_TEXT_SIZE, "Addr '%s' failed. Expected '%s', got '%s'", cases[idx].addr, cases[idx].view, got); return fail_text; qd_iterator_free(iter); } qd_iterator_free(iter); } return 0; }
static char *test_map(void *context) { static char error[1000]; const char *data = "\xd1\x00\x00\x00\x2d\x00\x00\x00\x06" // map32, 6 items "\xa3\x05\x66irst\xa1\x0evalue_of_first" // (23) "first":"value_of_first" "\xa3\x06second\x52\x20" // (10) "second":32 "\xa3\x05third\x41"; // (8) "third":true int data_len = 50; qd_iterator_t *data_iter = qd_iterator_binary(data, data_len, ITER_VIEW_ALL); qd_parsed_field_t *field = qd_parse(data_iter); if (!qd_parse_ok(field)) { snprintf(error, 1000, "Parse failed: %s", qd_parse_error(field)); qd_iterator_free(data_iter); qd_parse_free(field); return error; } if (!qd_parse_is_map(field)) { qd_iterator_free(data_iter); qd_parse_free(field); return "Expected field to be a map"; } uint32_t count = qd_parse_sub_count(field); if (count != 3) { snprintf(error, 1000, "Expected sub-count==3, got %"PRIu32, count); qd_iterator_free(data_iter); qd_parse_free(field); return error; } qd_parsed_field_t *key_field = qd_parse_sub_key(field, 0); qd_iterator_t *key_iter = qd_parse_raw(key_field); qd_iterator_t *typed_iter = qd_parse_typed(key_field); if (!qd_iterator_equal(key_iter, (unsigned char*) "first")) { unsigned char *result = qd_iterator_copy(key_iter); snprintf(error, 1000, "First key: expected 'first', got '%s'", result); free (result); return error; } if (!qd_iterator_equal(typed_iter, (unsigned char*) "\xa3\x05\x66irst")) return "Incorrect typed iterator on first-key"; qd_parsed_field_t *val_field = qd_parse_sub_value(field, 0); qd_iterator_t *val_iter = qd_parse_raw(val_field); typed_iter = qd_parse_typed(val_field); if (!qd_iterator_equal(val_iter, (unsigned char*) "value_of_first")) { unsigned char *result = qd_iterator_copy(val_iter); snprintf(error, 1000, "First value: expected 'value_of_first', got '%s'", result); free (result); return error; } if (!qd_iterator_equal(typed_iter, (unsigned char*) "\xa1\x0evalue_of_first")) return "Incorrect typed iterator on first-key"; key_field = qd_parse_sub_key(field, 1); key_iter = qd_parse_raw(key_field); if (!qd_iterator_equal(key_iter, (unsigned char*) "second")) { unsigned char *result = qd_iterator_copy(key_iter); snprintf(error, 1000, "Second key: expected 'second', got '%s'", result); free (result); return error; } val_field = qd_parse_sub_value(field, 1); if (qd_parse_as_uint(val_field) != 32) { snprintf(error, 1000, "Second value: expected 32, got %"PRIu32, qd_parse_as_uint(val_field)); return error; } key_field = qd_parse_sub_key(field, 2); key_iter = qd_parse_raw(key_field); if (!qd_iterator_equal(key_iter, (unsigned char*) "third")) { unsigned char *result = qd_iterator_copy(key_iter); snprintf(error, 1000, "Third key: expected 'third', got '%s'", result); free (result); return error; } val_field = qd_parse_sub_value(field, 2); if (!qd_parse_as_bool(val_field)) { snprintf(error, 1000, "Third value: expected true"); return error; } qd_iterator_free(data_iter); qd_parse_free(field); return 0; }
static qd_iterator_t *router_annotate_message(qd_router_t *router, qd_parsed_field_t *in_ma, qd_message_t *msg, qd_bitmask_t **link_exclusions, bool strip_inbound_annotations) { qd_iterator_t *ingress_iter = 0; qd_parsed_field_t *trace = 0; qd_parsed_field_t *ingress = 0; qd_parsed_field_t *to = 0; qd_parsed_field_t *phase = 0; *link_exclusions = 0; if (in_ma && !strip_inbound_annotations) { uint32_t count = qd_parse_sub_count(in_ma); bool done = false; for (uint32_t idx = 0; idx < count && !done; idx++) { qd_parsed_field_t *sub = qd_parse_sub_key(in_ma, idx); if (!sub) continue; qd_iterator_t *iter = qd_parse_raw(sub); if (!iter) continue; if (qd_iterator_equal(iter, (unsigned char*) QD_MA_TRACE)) { trace = qd_parse_sub_value(in_ma, idx); } else if (qd_iterator_equal(iter, (unsigned char*) QD_MA_INGRESS)) { ingress = qd_parse_sub_value(in_ma, idx); } else if (qd_iterator_equal(iter, (unsigned char*) QD_MA_TO)) { to = qd_parse_sub_value(in_ma, idx); } else if (qd_iterator_equal(iter, (unsigned char*) QD_MA_PHASE)) { phase = qd_parse_sub_value(in_ma, idx); } done = trace && ingress && to && phase; } } // // QD_MA_TRACE: // If there is a trace field, append this router's ID to the trace. // If the router ID is already in the trace the msg has looped. // qd_composed_field_t *trace_field = qd_compose_subfield(0); qd_compose_start_list(trace_field); if (trace) { if (qd_parse_is_list(trace)) { // // Create a link-exclusion map for the items in the trace. This map will // contain a one-bit for each link that leads to a neighbor router that // the message has already passed through. // *link_exclusions = qd_tracemask_create(router->tracemask, trace); // // Append this router's ID to the trace. // uint32_t idx = 0; qd_parsed_field_t *trace_item = qd_parse_sub_value(trace, idx); while (trace_item) { qd_iterator_t *iter = qd_parse_raw(trace_item); qd_iterator_reset_view(iter, ITER_VIEW_ALL); qd_compose_insert_string_iterator(trace_field, iter); idx++; trace_item = qd_parse_sub_value(trace, idx); } } } qd_compose_insert_string(trace_field, node_id); qd_compose_end_list(trace_field); qd_message_set_trace_annotation(msg, trace_field); // // QD_MA_TO: // Preserve the existing value. // if (to) { qd_composed_field_t *to_field = qd_compose_subfield(0); qd_compose_insert_string_iterator(to_field, qd_parse_raw(to)); qd_message_set_to_override_annotation(msg, to_field); } // // QD_MA_PHASE: // Preserve the existing value. // if (phase) { int phase_val = qd_parse_as_int(phase); qd_message_set_phase_annotation(msg, phase_val); } // // QD_MA_INGRESS: // If there is no ingress field, annotate the ingress as // this router else keep the original field. // qd_composed_field_t *ingress_field = qd_compose_subfield(0); if (ingress && qd_parse_is_scalar(ingress)) { ingress_iter = qd_parse_raw(ingress); qd_compose_insert_string_iterator(ingress_field, ingress_iter); } else qd_compose_insert_string(ingress_field, node_id); qd_message_set_ingress_annotation(msg, ingress_field); // // Return the iterator to the ingress field _if_ it was present. // If we added the ingress, return NULL. // return ingress_iter; }
/** * Inbound Delivery Handler */ static void AMQP_rx_handler(void* context, qd_link_t *link, pn_delivery_t *pnd) { qd_router_t *router = (qd_router_t*) context; pn_link_t *pn_link = qd_link_pn(link); qdr_link_t *rlink = (qdr_link_t*) qd_link_get_context(link); qdr_delivery_t *delivery = 0; qd_message_t *msg; // // Receive the message into a local representation. If the returned message // pointer is NULL, we have not yet received a complete message. // // Note: In the link-routing case, consider cutting the message through. There's // no reason to wait for the whole message to be received before starting to // send it. // msg = qd_message_receive(pnd); if (!msg) return; // // Consume the delivery. // pn_link_advance(pn_link); // // If there's no router link, free the message and finish. It's likely that the link // is closing. // if (!rlink) { qd_message_free(msg); return; } // // Handle the link-routed case // if (qdr_link_is_routed(rlink)) { pn_delivery_tag_t dtag = pn_delivery_tag(pnd); delivery = qdr_link_deliver_to_routed_link(rlink, msg, pn_delivery_settled(pnd), (uint8_t*) dtag.start, dtag.size); if (delivery) { if (pn_delivery_settled(pnd)) pn_delivery_settle(pnd); else { pn_delivery_set_context(pnd, delivery); qdr_delivery_set_context(delivery, pnd); qdr_delivery_incref(delivery); } } return; } // // Determine if the incoming link is anonymous. If the link is addressed, // there are some optimizations we can take advantage of. // bool anonymous_link = qdr_link_is_anonymous(rlink); // // Determine if the user of this connection is allowed to proxy the // user_id of messages. A message user_id is proxied when the // property value differs from the authenticated user name of the connection. // If the user is not allowed to proxy the user_id then the message user_id // must be blank or it must be equal to the connection user name. // bool check_user = false; qd_connection_t *conn = qd_link_connection(link); if (conn->policy_settings) check_user = !conn->policy_settings->allowUserIdProxy; // // Validate the content of the delivery as an AMQP message. This is done partially, only // to validate that we can find the fields we need to route the message. // // If the link is anonymous, we must validate through the message properties to find the // 'to' field. If the link is not anonymous, we don't need the 'to' field as we will be // using the address from the link target. // qd_message_depth_t validation_depth = (anonymous_link || check_user) ? QD_DEPTH_PROPERTIES : QD_DEPTH_MESSAGE_ANNOTATIONS; bool valid_message = qd_message_check(msg, validation_depth); if (valid_message) { if (check_user) { // This connection must not allow proxied user_id qd_iterator_t *userid_iter = qd_message_field_iterator(msg, QD_FIELD_USER_ID); if (userid_iter) { // The user_id property has been specified if (qd_iterator_remaining(userid_iter) > 0) { // user_id property in message is not blank if (!qd_iterator_equal(userid_iter, (const unsigned char *)conn->user_id)) { // This message is rejected: attempted user proxy is disallowed qd_log(router->log_source, QD_LOG_DEBUG, "Message rejected due to user_id proxy violation. User:%s", conn->user_id); pn_link_flow(pn_link, 1); pn_delivery_update(pnd, PN_REJECTED); pn_delivery_settle(pnd); qd_message_free(msg); qd_iterator_free(userid_iter); return; } } qd_iterator_free(userid_iter); } } qd_parsed_field_t *in_ma = qd_message_message_annotations(msg); qd_bitmask_t *link_exclusions; bool strip = qdr_link_strip_annotations_in(rlink); qd_iterator_t *ingress_iter = router_annotate_message(router, in_ma, msg, &link_exclusions, strip); if (anonymous_link) { qd_iterator_t *addr_iter = 0; int phase = 0; // // If the message has delivery annotations, get the to-override field from the annotations. // if (in_ma) { qd_parsed_field_t *ma_to = qd_parse_value_by_key(in_ma, QD_MA_TO); if (ma_to) { addr_iter = qd_iterator_dup(qd_parse_raw(ma_to)); phase = qd_message_get_phase_annotation(msg); } } // // Still no destination address? Use the TO field from the message properties. // if (!addr_iter) addr_iter = qd_message_field_iterator(msg, QD_FIELD_TO); if (addr_iter) { qd_iterator_reset_view(addr_iter, ITER_VIEW_ADDRESS_HASH); if (phase > 0) qd_iterator_annotate_phase(addr_iter, '0' + (char) phase); delivery = qdr_link_deliver_to(rlink, msg, ingress_iter, addr_iter, pn_delivery_settled(pnd), link_exclusions); } } else { const char *term_addr = pn_terminus_get_address(qd_link_remote_target(link)); if (!term_addr) term_addr = pn_terminus_get_address(qd_link_source(link)); if (term_addr) { qd_composed_field_t *to_override = qd_compose_subfield(0); qd_compose_insert_string(to_override, term_addr); qd_message_set_to_override_annotation(msg, to_override); int phase = qdr_link_phase(rlink); if (phase != 0) qd_message_set_phase_annotation(msg, phase); } delivery = qdr_link_deliver(rlink, msg, ingress_iter, pn_delivery_settled(pnd), link_exclusions); } if (delivery) { if (pn_delivery_settled(pnd)) pn_delivery_settle(pnd); else { pn_delivery_set_context(pnd, delivery); qdr_delivery_set_context(delivery, pnd); qdr_delivery_incref(delivery); } } else { // // The message is now and will always be unroutable because there is no address. // pn_link_flow(pn_link, 1); pn_delivery_update(pnd, PN_REJECTED); pn_delivery_settle(pnd); qd_message_free(msg); } // // Rules for delivering messages: // // For addressed (non-anonymous) links: // to-override must be set (done in the core?) // uses qdr_link_deliver to hand over to the core // // For anonymous links: // If there's a to-override in the annotations, use that address // Or, use the 'to' field in the message properties // } else { // // Message is invalid. Reject the message and don't involve the router core. // pn_link_flow(pn_link, 1); pn_delivery_update(pnd, PN_REJECTED); pn_delivery_settle(pnd); qd_message_free(msg); } }