bool
get_message_timestamp ( pn_message_t * msg, double * timestamp )
{
pn_data_t * annotations = pn_message_annotations ( msg );
pn_data_rewind ( annotations );
pn_data_next ( annotations );
if ( PN_MAP == pn_data_type ( annotations ) )
{
int len = pn_data_get_map ( annotations );
pn_data_enter ( annotations );
for (int i = 0; i < len; i += 2 )
{
pn_data_next ( annotations );
pn_type_t type = pn_data_type ( annotations );
if ( PN_STRING == type )
{
pn_bytes_t string = pn_data_get_symbol ( annotations );
if ( ! strncmp ( "timestamp", string.start, string.size ) )
{
pn_data_next ( annotations );
type = pn_data_type ( annotations );
if ( type == PN_DOUBLE )
{
* timestamp = pn_data_get_double ( annotations );
return true;
}
}
}
}
}
return false;
}
static void AMQP_opened_handler(qd_router_t *router, qd_connection_t *conn, bool inbound)
{
qdr_connection_role_t role = 0;
int cost = 1;
int remote_cost = 1;
bool strip_annotations_in = false;
bool strip_annotations_out = false;
int link_capacity = 1;
const char *name = 0;
uint64_t connection_id = qd_connection_connection_id(conn);
pn_connection_t *pn_conn = qd_connection_pn(conn);
qd_router_connection_get_config(conn, &role, &cost, &name,
&strip_annotations_in, &strip_annotations_out, &link_capacity);
if (role == QDR_ROLE_INTER_ROUTER) {
//
// Check the remote properties for an inter-router cost value.
//
pn_data_t *props = pn_conn ? pn_connection_remote_properties(pn_conn) : 0;
if (props) {
pn_data_rewind(props);
pn_data_next(props);
if (props && pn_data_type(props) == PN_MAP) {
pn_data_enter(props);
while (pn_data_next(props)) {
if (pn_data_type(props) == PN_SYMBOL) {
pn_bytes_t sym = pn_data_get_symbol(props);
if (sym.size == strlen(QD_CONNECTION_PROPERTY_COST_KEY) &&
strcmp(sym.start, QD_CONNECTION_PROPERTY_COST_KEY) == 0) {
pn_data_next(props);
if (pn_data_type(props) == PN_INT)
remote_cost = pn_data_get_int(props);
break;
}
}
}
}
}
//
// Use the larger of the local and remote costs for this connection
//
if (remote_cost > cost)
cost = remote_cost;
}
qdr_connection_t *qdrc = qdr_connection_opened(router->router_core, inbound, role, cost, connection_id, name,
pn_connection_remote_container(pn_conn),
strip_annotations_in, strip_annotations_out, link_capacity);
qd_connection_set_context(conn, qdrc);
qdr_connection_set_context(qdrc, conn);
}
void DataReader::read(pn_data_t* data)
{
/*
while (pn_data_next(data)) {
readOne(data);
}
*/
do {
readOne(data);
} while (pn_data_next(data));
}
void DataReader::readMap(pn_data_t* data, const qpid::amqp::Descriptor* descriptor)
{
size_t count = pn_data_get_map(data);
reader.onStartMap(count, qpid::amqp::CharSequence(), descriptor);
pn_data_enter(data);
for (size_t i = 0; i < count && pn_data_next(data); ++i) {
read(data);
}
pn_data_exit(data);
reader.onEndMap(count, descriptor);
}
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;
}
bool qdr_terminus_has_capability(qdr_terminus_t *term, const char *capability)
{
pn_data_t *cap = term->capabilities;
pn_data_rewind(cap);
pn_data_next(cap);
if (cap && pn_data_type(cap) == PN_SYMBOL) {
pn_bytes_t sym = pn_data_get_symbol(cap);
if (sym.size == strlen(capability) && strcmp(sym.start, capability) == 0)
return true;
}
return false;
}
void DataReader::readList(pn_data_t* data, const qpid::amqp::Descriptor* descriptor)
{
size_t count = pn_data_get_list(data);
bool skip = reader.onStartList(count, qpid::amqp::CharSequence(), qpid::amqp::CharSequence(), descriptor);
if (!skip) {
pn_data_enter(data);
for (size_t i = 0; i < count && pn_data_next(data); ++i) {
read(data);
}
pn_data_exit(data);
reader.onEndList(count, descriptor);
}
}
// Received client side
int pn_do_mechanisms(pn_transport_t *transport, uint8_t frame_type, uint16_t channel, pn_data_t *args, const pn_bytes_t *payload)
{
pni_sasl_t *sasl = transport->sasl;
// If we already pretended we got the ANONYMOUS mech then ignore
if (sasl->last_state==SASL_PRETEND_OUTCOME) return 0;
// This scanning relies on pn_data_scan leaving the pn_data_t cursors
// where they are after finishing the scan
int err = pn_data_scan(args, "D.[@[");
if (err) return err;
pn_string_t *mechs = pn_string("");
// Now keep checking for end of array and pull a symbol
while(pn_data_next(args)) {
pn_bytes_t s = pn_data_get_symbol(args);
if (pni_included_mech(transport->sasl->included_mechanisms, s)) {
pn_string_addf(mechs, "%*s ", (int)s.size, s.start);
}
}
if (pn_string_size(mechs)) {
pn_string_buffer(mechs)[pn_string_size(mechs)-1] = 0;
}
if (pni_init_client(transport) &&
pni_process_mechanisms(transport, pn_string_get(mechs))) {
pni_sasl_set_desired_state(transport, SASL_POSTED_INIT);
} else {
sasl->outcome = PN_SASL_PERM;
pni_sasl_set_desired_state(transport, SASL_RECVED_OUTCOME_FAIL);
}
pn_free(mechs);
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;
}
bool data::next() { return pn_data_next(pn_object()); }