void sender_context_init(sender_context_t *sc, Options_t *opts, Statistics_t *stats) { sc->opts = opts; sc->stats = stats; sc->sent = 0; sc->received = 0; sc->id.type = PN_ULONG; sc->reply_message = 0; // 4096 extra bytes should easily cover the message metadata sc->encoded_data_size = sc->opts->msg_size + 4096; sc->encoded_data = (char *)calloc(1, sc->encoded_data_size); check(sc->encoded_data, "failed to allocate encoding buffer"); sc->container_id = pn_string("reactor-send"); // prefer uuid-like name sc->reply_message = (sc->opts->get_replies) ? pn_message() : 0; sc->message = pn_message(); check(sc->message, "failed to allocate a message"); pn_string_t *rpto = pn_string("amqp://"); pn_string_addf(rpto, "%s", pn_string_get(sc->container_id)); pn_message_set_reply_to(sc->message, pn_string_get(rpto)); pn_free(rpto); pn_data_t *body = pn_message_body(sc->message); // borrow the encoding buffer this one time char *data = sc->encoded_data; pn_data_put_binary(body, pn_bytes(sc->opts->msg_size, data)); check(sc->opts->targets.count > 0, "no specified address"); sc->send_url = pn_url_parse(sc->opts->targets.addresses[0]); const char *host = pn_url_get_host(sc->send_url); const char *port = pn_url_get_port(sc->send_url); sc->hostname = pn_string(host); if (port && strlen(port)) pn_string_addf(sc->hostname, ":%s", port); }
void global_context_init ( global_context_t *gc, Options_t *o, Statistics_t *s ) { gc->opts = o; gc->stats = s; gc->sent = 0; gc->received = 0; gc->encoded_data_size = 0; gc->encoded_data = 0; gc->message = pn_message(); check(gc->message, "failed to allocate a message"); gc->connections = 0; gc->active_connections = pn_list(PN_OBJECT, 0); gc->acceptor = 0; gc->shutting_down = false; gc->listener_handler = 0; gc->quiesce_count = 0; gc->total_latency = 0; char report_filename[1000]; sprintf ( report_filename, "%s/report.txt", gc->opts->results_dir ); if ( ! (gc->report_fp = fopen ( report_filename, "w" )) ) { fprintf ( stderr, "reactor-recv error: can't open report file |%s|\n", report_filename ); exit ( 1 ); } }
void process_flow(ldp_connection_t *conn, pn_event_t *event) { fprintf(stderr, "flow event %s\n", pn_event_type_name(pn_event_type(event))); pn_link_t *sender = pn_event_link(event); pn_message_t *message = pn_message(); pn_message_set_address(message, "amqp://foo/bar"); pn_data_t *body = pn_message_body(message); char *msgtext = "hello world!"; pn_data_put_string(body, pn_bytes(strlen(msgtext), msgtext)); pn_buffer_t *buffer = pn_buffer(1000); char *encoded = pn_buffer_bytes(buffer).start; size_t size = pn_buffer_capacity(buffer); int err = pn_message_encode(message, encoded, &size); if (err) { fprintf(stderr, "trouble encoding message\n"); } else { char tag[8]; static uint64_t next_tag; *((uint64_t*)tag) = ++next_tag; pn_delivery_t *d = pn_delivery(sender, pn_dtag(tag, 8)); pn_link_send(sender, encoded, size); pn_link_advance(sender); } pn_buffer_free(buffer); pn_message_free(message); }
static char* test_receive_from_messenger(void *context) { nx_allocator_initialize(nx_allocator_default_config()); pn_message_t *pn_msg = pn_message(); pn_message_set_address(pn_msg, "test_addr_1"); nx_buffer_t *buf = nx_allocate_buffer(); size_t size = nx_buffer_capacity(buf); int result = pn_message_encode(pn_msg, (char*) nx_buffer_cursor(buf), &size); if (result != 0) return "Error in pn_message_encode"; nx_buffer_insert(buf, size); nx_message_t *msg = nx_allocate_message(); DEQ_INSERT_TAIL(msg->buffers, buf); int valid = nx_message_check(msg, NX_DEPTH_ALL); if (!valid) return "nx_message_check returns 'invalid'"; nx_field_iterator_t *iter = nx_message_field_to(msg); if (iter == 0) return "Expected an iterator for the 'to' field"; if (!nx_field_iterator_equal(iter, (unsigned char*) "test_addr_1")) return "Mismatched 'to' field contents"; pn_message_free(pn_msg); nx_free_message(msg); nx_allocator_finalize(); return 0; }
static char* test_insufficient_check_depth(void *context) { nx_allocator_initialize(nx_allocator_default_config()); pn_message_t *pn_msg = pn_message(); pn_message_set_address(pn_msg, "test_addr_2"); nx_buffer_t *buf = nx_allocate_buffer(); size_t size = nx_buffer_capacity(buf); int result = pn_message_encode(pn_msg, (char*) nx_buffer_cursor(buf), &size); if (result != 0) return "Error in pn_message_encode"; nx_buffer_insert(buf, size); nx_message_t *msg = nx_allocate_message(); DEQ_INSERT_TAIL(msg->buffers, buf); int valid = nx_message_check(msg, NX_DEPTH_DELIVERY_ANNOTATIONS); if (!valid) return "nx_message_check returns 'invalid'"; nx_field_iterator_t *iter = nx_message_field_to(msg); if (iter) return "Expected no iterator for the 'to' field"; nx_free_message(msg); nx_allocator_finalize(); return 0; }
static void test_overflow_error(void) { pn_message_t *message = pn_message(); char buf[6]; size_t size = 6; int err = pn_message_encode(message, buf, &size); assert(err == PN_OVERFLOW); assert(pn_message_errno(message) == 0); pn_message_free(message); }
void global_context_init(global_context_t *gc, Options_t *o, Statistics_t *s) { gc->opts = o; gc->stats = s; gc->sent = 0; gc->received = 0; gc->encoded_data_size = 0; gc->encoded_data = 0; gc->message = pn_message(); check(gc->message, "failed to allocate a message"); gc->connections = 0; gc->active_connections = pn_list(PN_OBJECT, 0); gc->acceptor = 0; gc->shutting_down = false; gc->listener_handler = 0; gc->quiesce_count = 0; }
/* Test sending/receiving a message in chunks */ static void test_message_stream(test_t *t) { test_proactor_t tps[] ={ test_proactor(t, message_stream_handler), test_proactor(t, message_stream_handler) }; pn_proactor_t *client = tps[0].proactor; pn_listener_t *l = test_listen(&tps[1], ""); struct message_stream_context ctx = { 0 }; tps[0].handler.context = &ctx; tps[1].handler.context = &ctx; /* Encode a large (not very) message to send in chunks */ char *body = (char*)malloc(BODY); memset(body, 'x', BODY); pn_message_t *m = pn_message(); pn_data_put_binary(pn_message_body(m), pn_bytes(BODY, body)); free(body); ctx.size = message_encode(m, &ctx.send_buf); pn_message_free(m); pn_connection_t *c = pn_connection(); pn_proactor_connect2(client, c, NULL, listener_info(l).connect); pn_session_t *ssn = pn_session(c); pn_session_open(ssn); pn_link_t *snd = pn_sender(ssn, "x"); pn_link_open(snd); TEST_PROACTORS_RUN_UNTIL(tps, PN_LINK_FLOW); /* Send and receive the message in chunks */ do { pn_connection_wake(c); /* Initiate send/receive of one chunk */ do { /* May be multiple receives for one send */ TEST_PROACTORS_RUN_UNTIL(tps, PN_DELIVERY); } while (ctx.received < ctx.sent); } while (!ctx.complete); TEST_CHECK(t, ctx.received == ctx.size); TEST_CHECK(t, ctx.sent == ctx.size); TEST_CHECK(t, !memcmp(ctx.send_buf.start, ctx.recv_buf.start, ctx.size)); free(ctx.send_buf.start); free(ctx.recv_buf.start); TEST_PROACTORS_DESTROY(tps); }
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; }
void amqp::Sender::send(IMessage const &message, Address const &address) { pn_data_t *pnmessage_body = NULL; pn_message_t *pnmessage = pn_message(); if (pnmessage == NULL) { throw std::exception("ERROR: Message could not be created."); } pn_message_set_address(pnmessage, address.toString().c_str()); _addMetaToMessage(pnmessage, message); pnmessage_body = pn_message_body(pnmessage); pn_data_put_binary(pnmessage_body, pn_bytes(message.getSize(), message.getBytes())); pn_messenger_put(m_messenger, pnmessage); if (isError()) { _throwError(); } // To avoid traffic flud and speed up the solution better to use blocking scokets in tracking mode if (isTraking()) { Log("Sending messages to %s\n", address.toString().c_str()); m_tracker = pn_messenger_outgoing_tracker(m_messenger); pn_messenger_send(m_messenger, -1); // sync } else { pn_messenger_send(m_messenger, 1); // async } if (isError()) { _throwError(); } _checkTracking(); pn_message_free(pnmessage); }
int sendMessage(pn_messenger_t * messenger) { //char * address = (char *) "amqps://{SAS Key Name}:{SAS key}@{namespace name}.servicebus.windows.net/{event hub name}"; char * address = (char *) "amqps://*****:*****@kelvin-flight.servicebus.windows.net/example"; char * msgtext = (char *) "Hello from C!"; pn_message_t * message; pn_data_t * body; message = pn_message(); pn_message_set_address(message, address); pn_message_set_content_type(message, (char*) "application/octect-stream"); pn_message_set_inferred(message, true); body = pn_message_body(message); pn_data_put_binary(body, pn_bytes(strlen(msgtext), msgtext)); pn_messenger_put(messenger, message); check(messenger); pn_messenger_send(messenger, 1); check(messenger); pn_message_free(message); }
int main(int argc, char** argv) { Options_t opts; Statistics_t stats; uint64_t sent = 0; uint64_t received = 0; int target_index = 0; int rc; pn_message_t *message = 0; pn_message_t *reply_message = 0; pn_messenger_t *messenger = 0; parse_options( argc, argv, &opts ); messenger = pn_messenger( opts.name ); if (opts.certificate) { rc = pn_messenger_set_certificate(messenger, opts.certificate); check( rc == 0, "Failed to set certificate" ); } if (opts.privatekey) { rc = pn_messenger_set_private_key(messenger, opts.privatekey); check( rc == 0, "Failed to set private key" ); } if (opts.password) { rc = pn_messenger_set_password(messenger, opts.password); free(opts.password); check( rc == 0, "Failed to set password" ); } if (opts.ca_db) { rc = pn_messenger_set_trusted_certificates(messenger, opts.ca_db); check( rc == 0, "Failed to set trusted CA database" ); } if (opts.outgoing_window) { pn_messenger_set_outgoing_window( messenger, opts.outgoing_window ); } pn_messenger_set_timeout( messenger, opts.timeout ); pn_messenger_start(messenger); message = pn_message(); check(message, "failed to allocate a message"); pn_message_set_reply_to(message, "~"); pn_data_t *body = pn_message_body(message); char *data = (char *)calloc(1, opts.msg_size); pn_data_put_binary(body, pn_bytes(opts.msg_size, data)); free(data); pn_atom_t id; id.type = PN_ULONG; #if 0 // TODO: how do we effectively benchmark header processing overhead??? pn_data_t *props = pn_message_properties(message); pn_data_put_map(props); pn_data_enter(props); // //pn_data_put_string(props, pn_bytes(6, "string")); //pn_data_put_string(props, pn_bytes(10, "this is awkward")); // //pn_data_put_string(props, pn_bytes(4, "long")); pn_data_put_long(props, 12345); // //pn_data_put_string(props, pn_bytes(9, "timestamp")); pn_data_put_timestamp(props, (pn_timestamp_t) 54321); pn_data_exit(props); #endif const int get_replies = opts.get_replies; if (get_replies) { // disable the timeout so that pn_messenger_recv() won't block reply_message = pn_message(); check(reply_message, "failed to allocate a message"); } statistics_start( &stats ); while (!opts.msg_count || (sent < opts.msg_count)) { // setup the message to send pn_message_set_address(message, opts.targets.addresses[target_index]); target_index = NEXT_ADDRESS(opts.targets, target_index); id.u.as_ulong = sent; pn_message_set_correlation_id( message, id ); pn_message_set_creation_time( message, msgr_now() ); pn_messenger_put(messenger, message); sent++; if (opts.send_batch && (pn_messenger_outgoing(messenger) >= (int)opts.send_batch)) { if (get_replies) { while (received < sent) { // this will also transmit any pending sent messages received += process_replies( messenger, reply_message, &stats, opts.recv_count ); } } else { LOG("Calling pn_messenger_send()\n"); rc = pn_messenger_send(messenger, -1); check((rc == 0 || rc == PN_TIMEOUT), "pn_messenger_send() failed"); } } check_messenger(messenger); } LOG("Messages received=%llu sent=%llu\n", received, sent); if (get_replies) { // wait for the last of the replies while (received < sent) { int count = process_replies( messenger, reply_message, &stats, opts.recv_count ); check( count > 0 || (opts.timeout == 0), "Error: timed out waiting for reply messages\n"); received += count; LOG("Messages received=%llu sent=%llu\n", received, sent); } } else if (pn_messenger_outgoing(messenger) > 0) { LOG("Calling pn_messenger_send()\n"); rc = pn_messenger_send(messenger, -1); check(rc == 0, "pn_messenger_send() failed"); } rc = pn_messenger_stop(messenger); check(rc == 0, "pn_messenger_stop() failed"); check_messenger(messenger); statistics_report( &stats, sent, received ); pn_messenger_free(messenger); pn_message_free(message); if (reply_message) pn_message_free( reply_message ); addresses_free( &opts.targets ); return 0; }
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; }
mama_status qpidBridgeMamaPublisher_createByIndex (publisherBridge* result, mamaTransport tport, int tportIndex, const char* topic, const char* source, const char* root, mamaPublisher parent) { qpidPublisherBridge* impl = NULL; qpidTransportBridge* transport = NULL; mama_status status = MAMA_STATUS_OK; const char* outgoingAddress = NULL; const char* uuid = NULL; if (NULL == result || NULL == tport || NULL == parent) { return MAMA_STATUS_NULL_ARG; } transport = qpidBridgeMamaTransportImpl_getTransportBridge (tport); if (NULL == transport) { mama_log (MAMA_LOG_LEVEL_SEVERE, "qpidBridgeMamaPublisher_createByIndex(): " "Could not find transport."); return MAMA_STATUS_NULL_ARG; } impl = (qpidPublisherBridge*) calloc (1, sizeof (qpidPublisherBridge)); if (NULL == impl) { mama_log (MAMA_LOG_LEVEL_ERROR, "qpidBridgeMamaPublisher_createByIndex(): " "Could not allocate mem publisher."); return MAMA_STATUS_NOMEM; } /* Initialize the publisher members */ impl->mTransport = transport; impl->mParent = parent; /* Create an underlying bridge message with no parent to be used in sends */ status = qpidBridgeMamaMsgImpl_createMsgOnly (&impl->mMamaBridgeMsg); if (MAMA_STATUS_OK != status) { mama_log (MAMA_LOG_LEVEL_ERROR, "qpidBridgeMamaPublisher_createByIndex(): " "Could not create qpid bridge message for publisher: %s.", mamaStatus_stringForStatus (status)); free (impl); return MAMA_STATUS_NOMEM; } /* Get the outgoing address format string */ outgoingAddress = qpidBridgeMamaTransportImpl_getOutgoingAddress ( (transportBridge) impl->mTransport); /* Get the transport UUID which is unique to the transport in case we need * it during format string expansion */ uuid = qpidBridgeMamaTransportImpl_getUuid ( (transportBridge) impl->mTransport); /* Collapse subject key to single string based on supplied values * * _MD requests do not use the topic on the wire as the responder may not * necessarily be listening for requests on that topic until the first * request comes in. */ if (NULL != root && 0 == strcmp (root, MAMA_ROOT_MARKET_DATA)) { qpidBridgeCommon_generateSubjectKey (root, source, NULL, &impl->mSubject); } else { qpidBridgeCommon_generateSubjectKey (root, source, topic, &impl->mSubject); } /* Parse the collapsed string to extract the standardized values */ qpidBridgeCommon_parseSubjectKey (impl->mSubject, &impl->mRoot, &impl->mSource, &impl->mTopic, (transportBridge) impl->mTransport); if (NULL != outgoingAddress) { /* Generate subject URI based on standardized values */ qpidBridgeCommon_generateSubjectUri (outgoingAddress, impl->mRoot, impl->mSource, impl->mTopic, uuid, &impl->mUri); } /* Create a reusable proton message */ impl->mQpidRawMsg = pn_message (); /* Populate the publisherBridge pointer with the publisher implementation */ *result = (publisherBridge) impl; return status; }
int main(int argc, char** argv) { const char *address = "localhost"; const char *msgtext = "Hello World!"; const char *container = "SendExample"; int c; pn_message_t *message = NULL; pn_data_t *body = NULL; pn_reactor_t *reactor = NULL; pn_url_t *url = NULL; pn_connection_t *conn = NULL; /* Create a handler for the connection's events. event_handler() will be * called for each event and delete_handler will be called when the * connection is released. The handler will allocate an app_data_t * instance which can be accessed when the event_handler is called. */ pn_handler_t *handler = pn_handler_new(event_handler, sizeof(app_data_t), delete_handler); /* set up the application data with defaults */ app_data_t *app_data = GET_APP_DATA(handler); memset(app_data, 0, sizeof(app_data_t)); app_data->count = 1; app_data->target = "examples"; /* Attach the pn_handshaker() handler. This handler deals with endpoint * events from the peer so we don't have to. */ { pn_handler_t *handshaker = pn_handshaker(); pn_handler_add(handler, handshaker); pn_decref(handshaker); } /* command line options */ opterr = 0; while((c = getopt(argc, argv, "i:a:c:t:nhq")) != -1) { switch(c) { case 'h': usage(); break; case 'a': address = optarg; break; case 'c': app_data->count = atoi(optarg); if (app_data->count < 1) usage(); break; case 't': app_data->target = optarg; break; case 'n': app_data->anon = 1; break; case 'i': container = optarg; break; case 'q': quiet = 1; break; default: usage(); break; } } if (optind < argc) msgtext = argv[optind]; // create a single message and pre-encode it so we only have to do that // once. All transmits will use the same pre-encoded message simply for // speed. // message = pn_message(); pn_message_set_address(message, app_data->target); body = pn_message_body(message); pn_data_clear(body); // This message's body contains a single string if (pn_data_fill(body, "S", msgtext)) { fprintf(stderr, "Error building message!\n"); exit(1); } pn_data_rewind(body); { // encode the message, expanding the encode buffer as needed // size_t len = 128; char *buf = (char *)malloc(len); int rc = 0; do { rc = pn_message_encode(message, buf, &len); if (rc == PN_OVERFLOW) { free(buf); len *= 2; buf = (char *)malloc(len); } } while (rc == PN_OVERFLOW); app_data->msg_len = len; app_data->msg_data = buf; } pn_decref(message); // message no longer needed reactor = pn_reactor(); url = pn_url_parse(address); if (url == NULL) { fprintf(stderr, "Invalid host address %s\n", address); exit(1); } conn = pn_reactor_connection_to_host(reactor, pn_url_get_host(url), pn_url_get_port(url), handler); pn_decref(url); pn_decref(handler); // the container name should be unique for each client pn_connection_set_container(conn, container); // wait up to 5 seconds for activity before returning from // pn_reactor_process() pn_reactor_set_timeout(reactor, 5000); pn_reactor_start(reactor); while (pn_reactor_process(reactor)) { /* Returns 'true' until the connection is shut down. * pn_reactor_process() will return true at least once every 5 seconds * (due to the timeout). If no timeout was configured, * pn_reactor_process() returns as soon as it finishes processing all * pending I/O and events. Once the connection has closed, * pn_reactor_process() will return false. */ } pn_decref(reactor); return 0; }
int main(int argc, char** argv) { Options_t opts; Statistics_t stats; uint64_t sent = 0; uint64_t received = 0; int forwarding_index = 0; int rc; pn_message_t *message; pn_messenger_t *messenger; parse_options( argc, argv, &opts ); const int forward = opts.forwarding_targets.count != 0; message = pn_message(); messenger = pn_messenger( opts.name ); /* load the various command line options if they're set */ if (opts.certificate) { rc = pn_messenger_set_certificate(messenger, opts.certificate); check_messenger(messenger); check( rc == 0, "Failed to set certificate" ); } if (opts.privatekey) { rc = pn_messenger_set_private_key(messenger, opts.privatekey); check_messenger(messenger); check( rc == 0, "Failed to set private key" ); } if (opts.password) { rc = pn_messenger_set_password(messenger, opts.password); check_messenger(messenger); check( rc == 0, "Failed to set password" ); } if (opts.ca_db) { rc = pn_messenger_set_trusted_certificates(messenger, opts.ca_db); check_messenger(messenger); check( rc == 0, "Failed to set trusted CA database" ); } if (opts.incoming_window) { // RAFI: seems to cause receiver to hang: pn_messenger_set_incoming_window( messenger, opts.incoming_window ); } pn_messenger_set_timeout( messenger, opts.timeout ); pn_messenger_start(messenger); check_messenger(messenger); int i; for (i = 0; i < opts.subscriptions.count; i++) { pn_messenger_subscribe(messenger, opts.subscriptions.addresses[i]); check_messenger(messenger); LOG("Subscribing to '%s'\n", opts.subscriptions.addresses[i]); } // hack to let test scripts know when the receivers are ready (so // that the senders may be started) if (opts.ready_text) { fprintf(stdout, "%s\n", opts.ready_text); fflush(stdout); } while (!opts.msg_count || received < opts.msg_count) { LOG("Calling pn_messenger_recv(%d)\n", opts.recv_count); rc = pn_messenger_recv(messenger, opts.recv_count); check_messenger(messenger); check(rc == 0 || (opts.timeout == 0 && rc == PN_TIMEOUT), "pn_messenger_recv() failed"); // start the timer only after receiving the first msg if (received == 0) statistics_start( &stats ); LOG("Messages on incoming queue: %d\n", pn_messenger_incoming(messenger)); while (pn_messenger_incoming(messenger)) { pn_messenger_get(messenger, message); check_messenger(messenger); received++; // TODO: header decoding? // uint64_t id = pn_message_get_correlation_id( message ).u.as_ulong; statistics_msg_received( &stats, message ); if (opts.reply) { const char *reply_addr = pn_message_get_reply_to( message ); if (reply_addr) { LOG("Replying to: %s\n", reply_addr ); pn_message_set_address( message, reply_addr ); pn_message_set_creation_time( message, msgr_now() ); pn_messenger_put(messenger, message); sent++; } } if (forward) { const char *forward_addr = opts.forwarding_targets.addresses[forwarding_index]; forwarding_index = NEXT_ADDRESS(opts.forwarding_targets, forwarding_index); LOG("Forwarding to: %s\n", forward_addr ); pn_message_set_address( message, forward_addr ); pn_message_set_reply_to( message, NULL ); // else points to origin sender pn_message_set_creation_time( message, msgr_now() ); pn_messenger_put(messenger, message); sent++; } } LOG("Messages received=%llu sent=%llu\n", received, sent); } // this will flush any pending sends if (pn_messenger_outgoing(messenger) > 0) { LOG("Calling pn_messenger_send()\n"); rc = pn_messenger_send(messenger, -1); check_messenger(messenger); check(rc == 0, "pn_messenger_send() failed"); } rc = pn_messenger_stop(messenger); check(rc == 0, "pn_messenger_stop() failed"); check_messenger(messenger); statistics_report( &stats, sent, received ); pn_messenger_free(messenger); pn_message_free(message); addresses_free( &opts.subscriptions ); addresses_free( &opts.forwarding_targets ); return 0; }
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; }