static char *test_parser_errors(void *context) { int idx = 0; static char error[1024]; while (err_vectors[idx].data) { qd_iterator_t *field = qd_iterator_binary(err_vectors[idx].data, err_vectors[idx].length, ITER_VIEW_ALL); qd_parsed_field_t *parsed = qd_parse(field); if (qd_parse_ok(parsed)) { qd_parse_free(parsed); qd_iterator_free(field); sprintf(error, "(%d) Unexpected Parse Success", idx); return error; } if (strcmp(qd_parse_error(parsed), err_vectors[idx].expected_error) != 0) { qd_parse_free(parsed); qd_iterator_free(field); sprintf(error, "(%d) Error: Expected %s, Got %s", idx, err_vectors[idx].expected_error, qd_parse_error(parsed)); return error; } qd_parse_free(parsed); qd_iterator_free(field); idx++; } return 0; }
qd_parsed_field_t *qd_message_message_annotations(qd_message_t *in_msg) { qd_message_pvt_t *msg = (qd_message_pvt_t*) in_msg; qd_message_content_t *content = msg->content; if (content->parsed_message_annotations) return content->parsed_message_annotations; qd_field_iterator_t *ma = qd_message_field_iterator(in_msg, QD_FIELD_MESSAGE_ANNOTATION); if (ma == 0) return 0; content->parsed_message_annotations = qd_parse(ma); if (content->parsed_message_annotations == 0 || !qd_parse_ok(content->parsed_message_annotations) || !qd_parse_is_map(content->parsed_message_annotations)) { qd_field_iterator_free(ma); qd_parse_free(content->parsed_message_annotations); content->parsed_message_annotations = 0; return 0; } qd_field_iterator_free(ma); return content->parsed_message_annotations; }
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); }
// Parse an iterator to a python object. static PyObject *py_iter_parse(qd_field_iterator_t *iter) { qd_parsed_field_t *parsed=0; if (iter && (parsed = qd_parse(iter))) { if (!qd_parse_ok(parsed)) { qd_error(QD_ERROR_MESSAGE, qd_parse_error(parsed)); qd_parse_free(parsed); return 0; } PyObject *value = qd_field_to_py(parsed); qd_parse_free(parsed); if (!value) qd_error_py(); return value; } qd_error(QD_ERROR_MESSAGE, "Failed to parse message field"); return 0; }
static char *test_parser_fixed_scalars(void *context) { int idx = 0; static char error[1024]; while (fs_vectors[idx].data) { qd_field_iterator_t *field = qd_field_iterator_binary(fs_vectors[idx].data, fs_vectors[idx].length); qd_parsed_field_t *parsed = qd_parse(field); if (!qd_parse_ok(parsed)) return "Unexpected Parse Error"; if (qd_parse_tag(parsed) != fs_vectors[idx].expected_tag) { sprintf(error, "(%d) Tag: Expected %02x, Got %02x", idx, fs_vectors[idx].expected_tag, qd_parse_tag(parsed)); return error; } if (fs_vectors[idx].check_uint && qd_parse_as_uint(parsed) != fs_vectors[idx].expected_ulong) { sprintf(error, "(%d) UINT: Expected %"PRIx64", Got %"PRIx32, idx, fs_vectors[idx].expected_ulong, qd_parse_as_uint(parsed)); return error; } if (fs_vectors[idx].check_ulong && qd_parse_as_ulong(parsed) != fs_vectors[idx].expected_ulong) { sprintf(error, "(%d) ULONG: Expected %"PRIx64", Got %"PRIx64, idx, fs_vectors[idx].expected_ulong, qd_parse_as_ulong(parsed)); return error; } if (fs_vectors[idx].check_int && qd_parse_as_int(parsed) != fs_vectors[idx].expected_long) { sprintf(error, "(%d) INT: Expected %"PRIx64", Got %"PRIx32, idx, fs_vectors[idx].expected_long, qd_parse_as_int(parsed)); return error; } if (fs_vectors[idx].check_long && qd_parse_as_long(parsed) != fs_vectors[idx].expected_long) { sprintf(error, "(%d) LONG: Expected %"PRIx64", Got %"PRIx64, idx, fs_vectors[idx].expected_long, qd_parse_as_long(parsed)); return error; } idx++; qd_field_iterator_free(field); qd_parse_free(parsed); } return 0; }
/** * * Handler for the management agent. * */ void qdr_management_agent_on_message(void *context, qd_message_t *msg, int unused_link_id, int unused_cost) { qdr_core_t *core = (qdr_core_t*) context; qd_field_iterator_t *app_properties_iter = qd_message_field_iterator(msg, QD_FIELD_APPLICATION_PROPERTIES); qd_router_entity_type_t entity_type = 0; qd_router_operation_type_t operation_type = 0; qd_field_iterator_t *identity_iter = 0; qd_field_iterator_t *name_iter = 0; int32_t count = 0; int32_t offset = 0; qd_parsed_field_t *properties_fld = qd_parse(app_properties_iter); if (qd_can_handle_request(properties_fld, &entity_type, &operation_type, &identity_iter, &name_iter, &count, &offset)) { switch (operation_type) { case QD_ROUTER_OPERATION_QUERY: qd_core_agent_query_handler(core, entity_type, operation_type, msg, &count, &offset); break; case QD_ROUTER_OPERATION_CREATE: qd_core_agent_create_handler(core, msg, entity_type, operation_type, name_iter); break; case QD_ROUTER_OPERATION_READ: qd_core_agent_read_handler(core, msg, entity_type, operation_type, identity_iter, name_iter); break; case QD_ROUTER_OPERATION_UPDATE: qd_core_agent_update_handler(core, msg, entity_type, operation_type, identity_iter, name_iter); break; case QD_ROUTER_OPERATION_DELETE: qd_core_agent_delete_handler(core, msg, entity_type, operation_type, identity_iter, name_iter); break; } } else { // // The C management agent is not going to handle this request. Forward it off to Python. // qdr_send_to2(core, msg, MANAGEMENT_INTERNAL, false, false); } qd_field_iterator_free(app_properties_iter); qd_parse_free(properties_fld); }
static void qd_core_agent_query_handler(qdr_core_t *core, qd_router_entity_type_t entity_type, qd_router_operation_type_t operation_type, qd_message_t *msg, int *count, int *offset) { // // Add the Body. // qd_composed_field_t *field = qd_compose(QD_PERFORMATIVE_BODY_AMQP_VALUE, 0); // Start a map in the body. Look for the end map in the callback function, qd_manage_response_handler. qd_compose_start_map(field); //add a "attributeNames" key qd_compose_insert_string(field, ATTRIBUTE_NAMES); // Call local function that creates and returns a local qd_management_context_t object containing the values passed in. qd_management_context_t *ctx = qd_management_context(qd_message(), msg, field, 0, core, operation_type, (*count)); // Grab the attribute names from the incoming message body. The attribute names will be used later on in the response. qd_parsed_field_t *attribute_names_parsed_field = 0; qd_field_iterator_t *body_iter = qd_message_field_iterator(msg, QD_FIELD_BODY); qd_parsed_field_t *body = qd_parse(body_iter); if (body != 0 && qd_parse_is_map(body)) { attribute_names_parsed_field = qd_parse_value_by_key(body, ATTRIBUTE_NAMES); } // Set the callback function. qdr_manage_handler(core, qd_manage_response_handler); ctx->query = qdr_manage_query(core, ctx, entity_type, attribute_names_parsed_field, field); //Add the attribute names qdr_query_add_attribute_names(ctx->query); //this adds a list of attribute names like ["attribute1", "attribute2", "attribute3", "attribute4",] qd_compose_insert_string(field, results); //add a "results" key qd_compose_start_list(field); //start the list for results qdr_query_get_first(ctx->query, (*offset)); qd_field_iterator_free(body_iter); qd_parse_free(body); }
static void qdr_manage_update_CT(qdr_core_t *core, qdr_action_t *action, bool discard) { qd_field_iterator_t *identity = action->args.agent.identity; qd_field_iterator_t *name = action->args.agent.name; qdr_query_t *query = action->args.agent.query; qd_parsed_field_t *in_body = action->args.agent.in_body; switch (query->entity_type) { case QD_ROUTER_CONFIG_ADDRESS: break; case QD_ROUTER_CONFIG_LINK_ROUTE: break; case QD_ROUTER_CONFIG_AUTO_LINK: break; case QD_ROUTER_CONNECTION: break; case QD_ROUTER_LINK: qdra_link_update_CT(core, name, identity, query, in_body); break; case QD_ROUTER_ADDRESS: break; case QD_ROUTER_EXCHANGE: break; case QD_ROUTER_BINDING: break; } qd_parse_free(in_body); }
void qd_parse_free(qd_parsed_field_t *field) { if (!field) return; assert(field->parent == 0); if (field->raw_iter) qd_iterator_free(field->raw_iter); if (field->typed_iter) qd_iterator_free(field->typed_iter); qd_parsed_field_t *sub_field = DEQ_HEAD(field->children); while (sub_field) { qd_parsed_field_t *next = DEQ_NEXT(sub_field); DEQ_REMOVE_HEAD(field->children); sub_field->parent = 0; qd_parse_free(sub_field); sub_field = next; } free_qd_parsed_field_t(field); }
const char *qd_parse_annotations_v1( bool strip_anno_in, qd_iterator_t *ma_iter_in, qd_parsed_field_t **ma_ingress, qd_parsed_field_t **ma_phase, qd_parsed_field_t **ma_to_override, qd_parsed_field_t **ma_trace, qd_iterator_pointer_t *blob_pointer, uint32_t *blob_item_count) { // Do full parse qd_iterator_reset(ma_iter_in); qd_parsed_turbo_list_t annos; uint32_t user_entries; uint32_t user_bytes; const char * parse_error = qd_parse_turbo(ma_iter_in, &annos, &user_entries, &user_bytes); if (parse_error) { return parse_error; } qd_parsed_turbo_t *anno; if (!strip_anno_in) { anno = DEQ_HEAD(annos); while (anno) { qd_iterator_t *key_iter = qd_iterator_buffer(anno->bufptr.buffer, anno->bufptr.cursor - qd_buffer_base(anno->bufptr.buffer), anno->size, ITER_VIEW_ALL); assert(key_iter); qd_parsed_field_t *key_field = qd_parse(key_iter); assert(key_field); qd_iterator_t *iter = qd_parse_raw(key_field); assert(iter); qd_parsed_turbo_t *anno_val = DEQ_NEXT(anno); assert(anno_val); qd_iterator_t *val_iter = qd_iterator_buffer(anno_val->bufptr.buffer, anno_val->bufptr.cursor - qd_buffer_base(anno_val->bufptr.buffer), anno_val->size, ITER_VIEW_ALL); assert(val_iter); qd_parsed_field_t *val_field = qd_parse(val_iter); assert(val_field); // Hoist the key name out of the buffers into a normal char array char key_name[QD_MA_MAX_KEY_LEN + 1]; (void)qd_iterator_strncpy(iter, key_name, QD_MA_MAX_KEY_LEN + 1); // transfer ownership of the extracted value to the message if (!strcmp(key_name, QD_MA_TRACE)) { *ma_trace = val_field; } else if (!strcmp(key_name, QD_MA_INGRESS)) { *ma_ingress = val_field; } else if (!strcmp(key_name, QD_MA_TO)) { *ma_to_override = val_field; } else if (!strcmp(key_name, QD_MA_PHASE)) { *ma_phase = val_field; } else { // TODO: this key had the QD_MA_PREFIX but it does not match // one of the actual fields. qd_parse_free(val_field); } qd_iterator_free(key_iter); qd_parse_free(key_field); qd_iterator_free(val_iter); // val_field is usually handed over to message_private and is freed anno = DEQ_NEXT(anno_val); } } anno = DEQ_HEAD(annos); while (anno) { DEQ_REMOVE_HEAD(annos); free_qd_parsed_turbo_t(anno); anno = DEQ_HEAD(annos); } // Adjust size of user annotation blob by the size of the router // annotations blob_pointer->remaining = user_bytes; assert(blob_pointer->remaining >= 0); *blob_item_count = user_entries; assert(*blob_item_count >= 0); return 0; }
static char *test_parser_fixed_scalars(void *context) { int idx = 0; qd_iterator_t *field = NULL; qd_parsed_field_t *parsed = NULL; static char error[1024]; error[0] = 0; while (fs_vectors[idx].data) { field = qd_iterator_binary(fs_vectors[idx].data, fs_vectors[idx].length, ITER_VIEW_ALL); parsed = qd_parse(field); qd_iterator_t *typed_iter = qd_parse_typed(parsed); int length = qd_iterator_length(typed_iter); if (length != fs_vectors[idx].length) { strcpy(error, "Length of typed iterator does not match actual length"); break; } if (!qd_parse_ok(parsed)) { strcpy(error, "Unexpected Parse Error"); break; } if (qd_parse_tag(parsed) != fs_vectors[idx].expected_tag) { sprintf(error, "(%d) Tag: Expected %02x, Got %02x", idx, fs_vectors[idx].expected_tag, qd_parse_tag(parsed)); break; } if (fs_vectors[idx].check_uint && qd_parse_as_uint(parsed) != fs_vectors[idx].expected_ulong) { sprintf(error, "(%d) UINT: Expected %"PRIx64", Got %"PRIx32, idx, fs_vectors[idx].expected_ulong, qd_parse_as_uint(parsed)); break; } if (fs_vectors[idx].check_ulong && qd_parse_as_ulong(parsed) != fs_vectors[idx].expected_ulong) { sprintf(error, "(%d) ULONG: Expected %"PRIx64", Got %"PRIx64, idx, fs_vectors[idx].expected_ulong, qd_parse_as_ulong(parsed)); break; } if (fs_vectors[idx].check_int && qd_parse_as_int(parsed) != fs_vectors[idx].expected_long) { sprintf(error, "(%d) INT: Expected %"PRIx64", Got %"PRIx32, idx, fs_vectors[idx].expected_long, qd_parse_as_int(parsed)); break; } if (fs_vectors[idx].check_long && qd_parse_as_long(parsed) != fs_vectors[idx].expected_long) { sprintf(error, "(%d) LONG: Expected %"PRIx64", Got %"PRIx64, idx, fs_vectors[idx].expected_long, qd_parse_as_long(parsed)); break; } idx++; qd_iterator_free(field); field = 0; qd_parse_free(parsed); parsed = 0; } qd_iterator_free(field); qd_parse_free(parsed); return *error ? error : 0; }
static char *test_tracemask(void *context) { qd_bitmask_t *bm = NULL; qd_tracemask_t *tm = qd_tracemask(); qd_buffer_list_t list; static char error[1024]; error[0] = 0; qd_iterator_set_address(false, "0", "ROUTER"); qd_tracemask_add_router(tm, "amqp:/_topo/0/Router.A", 0); qd_tracemask_add_router(tm, "amqp:/_topo/0/Router.B", 1); qd_tracemask_add_router(tm, "amqp:/_topo/0/Router.C", 2); qd_tracemask_add_router(tm, "amqp:/_topo/0/Router.D", 3); qd_tracemask_add_router(tm, "amqp:/_topo/0/Router.E", 4); qd_tracemask_add_router(tm, "amqp:/_topo/0/Router.F", 5); qd_tracemask_set_link(tm, 0, 4); qd_tracemask_set_link(tm, 3, 10); qd_tracemask_set_link(tm, 4, 3); qd_tracemask_set_link(tm, 5, 2); qd_composed_field_t *comp = qd_compose_subfield(0); qd_compose_start_list(comp); qd_compose_insert_string(comp, "0/Router.A"); qd_compose_insert_string(comp, "0/Router.D"); qd_compose_insert_string(comp, "0/Router.E"); qd_compose_end_list(comp); DEQ_INIT(list); qd_compose_take_buffers(comp, &list); qd_compose_free(comp); int length = 0; qd_buffer_t *buf = DEQ_HEAD(list); while (buf) { length += qd_buffer_size(buf); buf = DEQ_NEXT(buf); } qd_iterator_t *iter = qd_iterator_buffer(DEQ_HEAD(list), 0, length, ITER_VIEW_ALL); qd_parsed_field_t *pf = qd_parse(iter); qd_iterator_free(iter); int ingress = -1; bm = qd_tracemask_create(tm, pf, &ingress); if (qd_bitmask_cardinality(bm) != 3) { sprintf(error, "Expected cardinality of 3, got %d", qd_bitmask_cardinality(bm)); goto cleanup; } if (ingress != 0) { sprintf(error, "(A) Expected ingress index of 0, got %d", ingress); goto cleanup; } int total = 0; int bit, c; for (QD_BITMASK_EACH(bm, bit, c)) { total += bit; } if (total != 17) { sprintf(error, "Expected total bit value of 17, got %d", total); goto cleanup; } qd_bitmask_free(bm); bm = 0; qd_tracemask_del_router(tm, 3); qd_tracemask_remove_link(tm, 0); ingress = -1; bm = qd_tracemask_create(tm, pf, &ingress); qd_parse_free(pf); pf = 0; if (qd_bitmask_cardinality(bm) != 1) { sprintf(error, "Expected cardinality of 1, got %d", qd_bitmask_cardinality(bm)); goto cleanup; } if (ingress != 0) { sprintf(error, "(B) Expected ingress index of 0, got %d", ingress); goto cleanup; } total = 0; for (QD_BITMASK_EACH(bm, bit, c)) { total += bit; } if (total != 3) { sprintf(error, "Expected total bit value of 3, got %d", total); // fallthrough } cleanup: qd_parse_free(pf); qd_tracemask_free(tm); qd_bitmask_free(bm); for (qd_buffer_t *buf = DEQ_HEAD(list); buf; buf = DEQ_HEAD(list)) { DEQ_REMOVE_HEAD(list); qd_buffer_free(buf); } return *error ? error : 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 char *test_integer_conversion(void *context) { const struct fs_vector_t { const char *data; int length; uint8_t parse_as; bool expect_fail; int64_t expected_int; uint64_t expected_uint; } fs_vectors[] = { // can successfully convert 64 bit values that are valid in the 32bit range {"\x80\x00\x00\x00\x00\xff\xff\xff\xff", 9, QD_AMQP_UINT, false, 0, UINT32_MAX}, {"\x80\x00\x00\x00\x00\x00\x00\x00\x00", 9, QD_AMQP_UINT, false, 0, 0}, {"\x80\x00\x00\x00\x00\x00\x00\x00\x01", 9, QD_AMQP_UINT, false, 0, 1}, {"\x81\x00\x00\x00\x00\x7f\xff\xff\xff", 9, QD_AMQP_INT, false, INT32_MAX, 0}, {"\x81\xFF\xFF\xFF\xFF\x80\x00\x00\x00", 9, QD_AMQP_INT, false, INT32_MIN, 0}, {"\x81\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF", 9, QD_AMQP_INT, false, -1, 0}, // signed/unsigned conversions {"\x70\x7F\xFF\xFF\xFF", 5, QD_AMQP_INT, false, INT32_MAX, 0}, {"\x71\x7F\xFF\xFF\xFF", 5, QD_AMQP_UINT, false, 0, INT32_MAX}, {"\x80\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF", 9, QD_AMQP_LONG, false, INT64_MAX, 0}, {"\x81\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF", 9, QD_AMQP_ULONG, false,0, INT64_MAX}, {"\x50\x7F", 2, QD_AMQP_INT, false, INT8_MAX, 0}, {"\x60\x7F\xFF", 3, QD_AMQP_INT, false, INT16_MAX, 0}, {"\x53\x7F", 2, QD_AMQP_INT, false, INT8_MAX, 0}, {"\x55\x7F", 2, QD_AMQP_UINT, false, 0, INT8_MAX}, {"\x51\x7F", 2, QD_AMQP_UINT, false, 0, INT8_MAX}, {"\x61\x7F\xFF", 3, QD_AMQP_UINT, false, 0, INT16_MAX}, // strings {"\xa1\x02 1", 4, QD_AMQP_UINT, false, 0, 1}, {"\xa1\x02-1", 4, QD_AMQP_INT, false, -1, 0}, {"\xa1\x14" "18446744073709551615", 22, QD_AMQP_ULONG,false, 0, UINT64_MAX}, {"\xa1\x14" "-9223372036854775808", 22, QD_AMQP_LONG, false, INT64_MIN, 0}, {"\xa1\x13" "9223372036854775807", 21, QD_AMQP_LONG, false, INT64_MAX, 0}, {"\xa3\x13" "9223372036854775807", 21, QD_AMQP_LONG, false, INT64_MAX, 0}, // cannot convert 64 bit values that are outside the 32bit range as int32 {"\x80\x00\x00\x00\x01\x00\x00\x00\x00", 9, QD_AMQP_UINT, true, 0, 0}, {"\x81\x00\x00\x00\x00\x80\x00\x00\x00", 9, QD_AMQP_INT, true, 0, 0}, {"\x81\xFF\xFF\xFF\xFF\x7F\xFF\xFF\xFF", 9, QD_AMQP_INT, true, 0, 0}, // bad signed/unsigned conversions {"\x80\x80\x00\x00\x00\x00\x00\x00\x00", 9, QD_AMQP_LONG, true, 0, 0}, {"\x81\x80\x00\x00\x00\x00\x00\x00\x00", 9, QD_AMQP_ULONG, true, 0, 0}, {"\x70\x80\x00\x00\x00", 5, QD_AMQP_LONG, true, 0, 0}, {"\x71\x80\x00\x00\x00", 5, QD_AMQP_ULONG, true, 0, 0}, {"\x55\x80", 2, QD_AMQP_UINT, true, 0, 0}, {"\x51\x80", 2, QD_AMQP_UINT, true, 0, 0}, {"\x54\x80", 2, QD_AMQP_UINT, true, 0, 0}, {"\x61\x80\x00", 3, QD_AMQP_UINT, true, 0, 0}, {"\x53\x80", 2, QD_AMQP_INT, true, 0, 0}, {"\x52\x80", 2, QD_AMQP_INT, true, 0, 0}, {"\x50\x80", 2, QD_AMQP_LONG, true, 0, 0}, {"\x60\x80", 2, QD_AMQP_LONG, true, 0, 0}, {NULL}, }; char *error = NULL; for (int i = 0; fs_vectors[i].data && !error; ++i) { qd_iterator_t *data_iter = qd_iterator_binary(fs_vectors[i].data, fs_vectors[i].length, ITER_VIEW_ALL); qd_parsed_field_t *field = qd_parse(data_iter); if (!qd_parse_ok(field)) { error = "unexpected parse error"; qd_iterator_free(data_iter); qd_parse_free(field); break; } bool equal = false; switch (fs_vectors[i].parse_as) { case QD_AMQP_UINT: { uint32_t tmp = qd_parse_as_uint(field); equal = (tmp == fs_vectors[i].expected_uint); break; } case QD_AMQP_ULONG: { uint64_t tmp = qd_parse_as_ulong(field); equal = (tmp == fs_vectors[i].expected_uint); break; } case QD_AMQP_INT: { int32_t tmp = qd_parse_as_int(field); equal = (tmp == fs_vectors[i].expected_int); break; } case QD_AMQP_LONG: { int64_t tmp = qd_parse_as_long(field); equal = (tmp == fs_vectors[i].expected_int); break; } } if (!qd_parse_ok(field)) { if (!fs_vectors[i].expect_fail) { error = "unexpected conversion/parse error"; } } else if (fs_vectors[i].expect_fail) { error = "Conversion did not fail as expected"; } else if (!equal) { error = "unexpected converted value"; } qd_iterator_free(data_iter); qd_parse_free(field); } return error; }