int pn_messenger_put(pn_messenger_t *messenger, pn_message_t *msg)
{
if (!messenger) return PN_ARG_ERR;
if (!msg) return pn_error_set(messenger->error, PN_ARG_ERR, "null message");
outward_munge(messenger, msg);
const char *address = pn_message_get_address(msg);
pn_link_t *sender = pn_messenger_target(messenger, address);
if (!sender)
return pn_error_format(messenger->error, PN_ERR,
"unable to send to address: %s (%s)", address,
pn_driver_error(messenger->driver));
// XXX: proper tag
char tag[8];
void *ptr = &tag;
uint64_t next = messenger->next_tag++;
*((uint32_t *) ptr) = next;
pn_delivery(sender, pn_dtag(tag, 8));
size_t size = 1024;
// XXX: max message size
while (size < 16*1024) {
char encoded[size];
int err = pn_message_encode(msg, encoded, &size);
if (err == PN_OVERFLOW) {
size *= 2;
} else if (err) {
return err;
} else {
ssize_t n = pn_send(sender, encoded, size);
if (n < 0) {
return n;
} else {
pn_advance(sender);
pn_messenger_tsync(messenger, false_pred, 0);
return 0;
}
}
}
return PN_ERR;
}
static char* test_send_to_messenger(void *context)
{
nx_allocator_initialize(nx_allocator_default_config());
nx_message_t *msg = nx_allocate_message();
nx_message_compose_1(msg, "test_addr_0", 0);
nx_buffer_t *buf = DEQ_HEAD(msg->buffers);
if (buf == 0) return "Expected a buffer in the test message";
pn_message_t *pn_msg = pn_message();
int result = pn_message_decode(pn_msg, (const char*) nx_buffer_base(buf), nx_buffer_size(buf));
if (result != 0) return "Error in pn_message_decode";
if (strcmp(pn_message_get_address(pn_msg), "test_addr_0") != 0)
return "Address mismatch in received message";
pn_message_free(pn_msg);
nx_free_message(msg);
nx_allocator_finalize();
return 0;
}
std::string message::address() const {
const char* addr = pn_message_get_address(pn_msg());
return addr ? std::string(addr) : std::string();
}
int main(int argc, char** argv)
{
char* certificate = NULL;
char* privatekey = NULL;
char* password = NULL;
char* address = (char *) "amqp://~0.0.0.0";
int c;
pn_message_t * message;
pn_messenger_t * messenger;
message = pn_message();
messenger = pn_messenger(NULL);
opterr = 0;
while((c = getopt(argc, argv, "hc:k:p:")) != -1)
{
switch(c)
{
case 'h':
usage();
break;
case 'c': certificate = optarg; break;
case 'k': privatekey = optarg; break;
case 'p': password = optarg; break;
case '?':
if(optopt == 'c' ||
optopt == 'k' ||
optopt == 'p')
{
fprintf(stderr, "Option -%c requires an argument.\n", optopt);
}
else if(isprint(optopt))
{
fprintf(stderr, "Unknown option `-%c'.\n", optopt);
}
else
{
fprintf(stderr, "Unknown option character `\\x%x'.\n", optopt);
}
return 1;
default:
abort();
}
}
if (optind < argc)
{
address = argv[optind];
}
/* load the various command line options if they're set */
if(certificate)
{
pn_messenger_set_certificate(messenger, certificate);
}
if(privatekey)
{
pn_messenger_set_private_key(messenger, privatekey);
}
if(password)
{
pn_messenger_set_password(messenger, password);
}
pn_messenger_start(messenger);
check(messenger);
pn_messenger_subscribe(messenger, address);
check(messenger);
for(;;)
{
pn_messenger_recv(messenger, 1024);
check(messenger);
while(pn_messenger_incoming(messenger))
{
pn_messenger_get(messenger, message);
check(messenger);
{
char buffer[1024];
size_t buffsize = sizeof(buffer);
const char* subject = pn_message_get_subject(message);
pn_data_t *body = pn_message_body(message);
pn_data_format(body, buffer, &buffsize);
printf("Address: %s\n", pn_message_get_address(message));
printf("Subject: %s\n", subject ? subject : "(no subject)");
printf("Content: %s\n", buffer);
}
}
}
return 0;
}