qd_field_iterator_t *qdr_terminus_dnp_address(qdr_terminus_t *term) { pn_data_t *props = term->properties; if (!props) return 0; pn_data_rewind(props); if (pn_data_next(props) && pn_data_enter(props) && pn_data_next(props)) { pn_bytes_t sym = pn_data_get_symbol(props); if (sym.start && strcmp(QD_DYNAMIC_NODE_PROPERTY_ADDRESS, sym.start) == 0) { if (pn_data_next(props)) { pn_bytes_t val = pn_data_get_string(props); if (val.start && *val.start != '\0') return qd_field_iterator_binary(val.start, val.size); } } } return 0; }
void DataReader::readOne(pn_data_t* data) { qpid::amqp::Descriptor descriptor(0); bool described = pn_data_is_described(data); if (described) { pn_data_enter(data); pn_data_next(data); if (pn_data_type(data) == PN_ULONG) { descriptor = qpid::amqp::Descriptor(pn_data_get_ulong(data)); } else if (pn_data_type(data) == PN_SYMBOL) { descriptor = qpid::amqp::Descriptor(convert(pn_data_get_symbol(data))); } else { QPID_LOG(notice, "Ignoring descriptor of type " << pn_data_type(data)); } pn_data_next(data); } switch (pn_data_type(data)) { case PN_NULL: reader.onNull(described ? &descriptor : 0); break; case PN_BOOL: reader.onBoolean(pn_data_get_bool(data), described ? &descriptor : 0); break; case PN_UBYTE: reader.onUByte(pn_data_get_ubyte(data), described ? &descriptor : 0); break; case PN_BYTE: reader.onByte(pn_data_get_byte(data), described ? &descriptor : 0); break; case PN_USHORT: reader.onUShort(pn_data_get_ushort(data), described ? &descriptor : 0); break; case PN_SHORT: reader.onShort(pn_data_get_short(data), described ? &descriptor : 0); break; case PN_UINT: reader.onUInt(pn_data_get_uint(data), described ? &descriptor : 0); break; case PN_INT: reader.onInt(pn_data_get_int(data), described ? &descriptor : 0); break; case PN_CHAR: pn_data_get_char(data); break; case PN_ULONG: reader.onULong(pn_data_get_ulong(data), described ? &descriptor : 0); break; case PN_LONG: reader.onLong(pn_data_get_long(data), described ? &descriptor : 0); break; case PN_TIMESTAMP: reader.onTimestamp(pn_data_get_timestamp(data), described ? &descriptor : 0); break; case PN_FLOAT: reader.onFloat(pn_data_get_float(data), described ? &descriptor : 0); break; case PN_DOUBLE: reader.onDouble(pn_data_get_double(data), described ? &descriptor : 0); break; case PN_DECIMAL32: pn_data_get_decimal32(data); break; case PN_DECIMAL64: pn_data_get_decimal64(data); break; case PN_DECIMAL128: pn_data_get_decimal128(data); break; case PN_UUID: reader.onUuid(convert(pn_data_get_uuid(data)), described ? &descriptor : 0); break; case PN_BINARY: reader.onBinary(convert(pn_data_get_binary(data)), described ? &descriptor : 0); break; case PN_STRING: reader.onString(convert(pn_data_get_string(data)), described ? &descriptor : 0); break; case PN_SYMBOL: reader.onSymbol(convert(pn_data_get_symbol(data)), described ? &descriptor : 0); break; case PN_DESCRIBED: break; case PN_ARRAY: readArray(data, described ? &descriptor : 0); break; case PN_LIST: readList(data, described ? &descriptor : 0); break; case PN_MAP: readMap(data, described ? &descriptor : 0); break; } if (described) pn_data_exit(data); }
mama_status qpidBridgeMsgCodec_unpack (msgBridge bridgeMessage, mamaMsg target, pn_message_t* protonMessage) { pn_data_t* properties = NULL; pn_data_t* body = NULL; mama_status status = MAMA_STATUS_OK; qpidMsgType type = QPID_MSG_PUB_SUB; pn_bytes_t prop; pn_atom_t firstAtom; if (NULL == bridgeMessage || NULL == protonMessage) { return MAMA_STATUS_NULL_ARG; } /* grab the body */ body = pn_message_body (protonMessage); /* Ensure position is at the start */ pn_data_rewind (body); /* Skip over the initial null atom */ pn_data_next (body); /* Grab the first atom and see what it is - PN_LIST = qpid */ firstAtom = pn_data_get_atom (body); /* If this is a proton message */ if (PN_LIST == firstAtom.type) { status = mamaMsgImpl_setMsgBuffer (target, (void*) protonMessage, sizeof (pn_message_t*), MAMA_PAYLOAD_QPID); } /* If this looks like another MAMA payload type */ else if (PN_BINARY == firstAtom.type) { mamaPayloadType payloadType = MAMA_PAYLOAD_UNKNOWN; if (firstAtom.u.as_bytes.size == 0) { mama_log (MAMA_LOG_LEVEL_ERROR, "qpidBridgeMamaMsgImpl_unpack(): " "Binary blob of zero length found - not processing"); return MAMA_STATUS_INVALID_ARG; } /* The payload type is the first character */ payloadType = (mamaPayloadType) firstAtom.u.as_bytes.start[0]; /* Use byte buffer to populate MAMA message */ status = mamaMsgImpl_setMsgBuffer ( target, (void*) firstAtom.u.as_bytes.start, (mama_size_t) firstAtom.u.as_bytes.size, payloadType); if (MAMA_STATUS_OK != status) { mama_log (MAMA_LOG_LEVEL_ERROR, "qpidBridgeMamaMsgImpl_unpack(): " "Could not set msg buffer. Cannot unpack (%s).", mamaStatus_stringForStatus (status)); return status; } } /* If this looks like something we cannot handle */ else { mama_log (MAMA_LOG_LEVEL_ERROR, "qpidBridgeMamaMsgImpl_unpack(): " "Unable to unpack data received: incompatible format %s", pn_type_name (firstAtom.type)); } /* Get the properties */ properties = pn_message_properties (protonMessage); /* Ensure position is at the start */ pn_data_rewind (properties); /* Skip over the initial null atom */ pn_data_next (properties); /* Main container should be a list to allow expansion */ pn_data_get_list (properties); pn_data_enter (properties); /* Get the message type out */ pn_data_next (properties); type = (qpidMsgType) pn_data_get_ubyte (properties); qpidBridgeMamaMsgImpl_setMsgType (bridgeMessage, type); switch (type) { case QPID_MSG_INBOX_REQUEST: /* Move onto inbox name and extract / copy */ pn_data_next (properties); prop = pn_data_get_string (properties); status = qpidBridgeMamaMsgImpl_setInboxName (bridgeMessage, prop.start); if (MAMA_STATUS_OK != status) { return status; } /* Move onto reply to url and extract / copy */ pn_data_next (properties); prop = pn_data_get_string (properties); status = qpidBridgeMamaMsgImpl_setReplyTo (bridgeMessage, prop.start); if (MAMA_STATUS_OK != status) { return status; } break; case QPID_MSG_INBOX_RESPONSE: /* Move onto target subject and extract / copy */ pn_data_next (properties); prop = pn_data_get_string (properties); status = qpidBridgeMamaMsgImpl_setTargetSubject (bridgeMessage, prop.start); if (MAMA_STATUS_OK != status) { return status; } break; /* The following message types require no further meta data */ case QPID_MSG_TERMINATE: case QPID_MSG_SUB_REQUEST: case QPID_MSG_PUB_SUB: default: break; } pn_data_exit (properties); return status; }
int main(int argc, char** argv) { Options_t opts; int rc; pn_message_t *response_msg = pn_message(); check( response_msg, "Failed to allocate a Message"); pn_message_t *request_msg = pn_message(); check( request_msg, "Failed to allocate a Message"); pn_messenger_t *messenger = pn_messenger( 0 ); check( messenger, "Failed to allocate a Messenger"); parse_options( argc, argv, &opts ); // no need to track outstanding messages pn_messenger_set_outgoing_window( messenger, 0 ); pn_messenger_set_incoming_window( messenger, 0 ); pn_messenger_set_timeout( messenger, opts.timeout ); if (opts.gateway_addr) { LOG( "routing all messages via %s\n", opts.gateway_addr ); rc = pn_messenger_route( messenger, "*", opts.gateway_addr ); check( rc == 0, "pn_messenger_route() failed" ); } pn_messenger_start(messenger); char *reply_to = NULL; if (opts.reply_to) { LOG("subscribing to %s for replies\n", opts.reply_to); pn_messenger_subscribe(messenger, opts.reply_to); reply_to = _strdup(opts.reply_to); check( reply_to, "Out of memory" ); #if 1 // need to 'fix' the reply-to for use in the message itself: // no '~' is allowed in that case char *tilde = strstr( reply_to, "://~" ); if (tilde) { tilde += 3; // overwrite '~' memmove( tilde, tilde + 1, strlen( tilde + 1 ) + 1 ); } #endif } // Create a request message // const char *command = opts.new_fortune ? "set" : "get"; build_request_message( request_msg, opts.send_bad_msg ? "bad-command" : command, opts.address, reply_to, opts.new_fortune, opts.ttl ); // set a unique identifier for this message, so remote can // de-duplicate when we re-transmit uuid_t uuid; uuid_generate(uuid); char uuid_str[37]; uuid_unparse_upper(uuid, uuid_str); pn_data_put_string( pn_message_id( request_msg ), pn_bytes( sizeof(uuid_str), uuid_str )); // set the correlation id so we can ensure the response matches // our request. (re-use uuid just 'cause it's easy!) pn_data_put_string( pn_message_correlation_id( request_msg ), pn_bytes( sizeof(uuid_str), uuid_str )); int send_count = 0; bool done = false; // keep re-transmitting until something arrives do { LOG("sending request message...\n"); rc = pn_messenger_put( messenger, request_msg ); check(rc == 0, "pn_messenger_put() failed"); send_count++; if (opts.retry) opts.retry--; LOG("waiting for response...\n"); rc = pn_messenger_recv( messenger, -1 ); if (rc == PN_TIMEOUT) { LOG( "Timed-out waiting for a response, retransmitting...\n" ); pn_message_set_delivery_count( request_msg, send_count ); } else { check(rc == 0, "pn_messenger_recv() failed\n"); while (pn_messenger_incoming( messenger ) > 0) { rc = pn_messenger_get( messenger, response_msg ); check(rc == 0, "pn_messenger_get() failed"); LOG("response received!\n"); // validate the correlation id pn_bytes_t cid = pn_data_get_string( pn_message_correlation_id( response_msg ) ); if (cid.size == 0 || strncmp( uuid_str, cid.start, cid.size )) { LOG( "Correlation Id mismatch! Ignoring this response!\n" ); } else { process_reply( messenger, response_msg ); done = true; } } } } while (!done && opts.retry); if (!done) { fprintf( stderr, "Retries exhausted, no response received from server!\n" ); } rc = pn_messenger_stop(messenger); check(rc == 0, "pn_messenger_stop() failed"); pn_messenger_free(messenger); pn_message_free( response_msg ); pn_message_free( request_msg ); if (reply_to) free(reply_to); return 0; }