pn_handler_t *connection_handler(global_context_t *gc)
{
pn_handler_t *h = pn_handler_new(connection_dispatch, sizeof(connection_context_t), connection_cleanup);
connection_context_t *cc = connection_context(h);
connection_context_init(cc, gc);
return h;
}
pn_handler_t *replyto_handler(sender_context_t *sc)
{
pn_handler_t *h = pn_handler_new(replyto_dispatch, sizeof(sender_context_t *), replyto_cleanup);
sender_context_t **p = (sender_context_t **) pn_handler_mem(h);
*p = sc;
return h;
}
pn_handler_t *sender_handler(Options_t *opts, Statistics_t *stats)
{
pn_handler_t *h = pn_handler_new(sender_dispatch, sizeof(sender_context_t), sender_cleanup);
sender_context_t *sc = sender_context(h);
sender_context_init(sc, opts, stats);
return h;
}
pn_handler_t *listener_handler(Options_t *opts, Statistics_t *stats)
{
pn_handler_t *h = pn_handler_new(listener_dispatch, sizeof(global_context_t), listener_cleanup);
global_context_t *gc = global_context(h);
global_context_init(gc, opts, stats);
gc->listener_handler = h;
return h;
}
// create a new handler for the engine and set up the protocolState
static rsRetVal _new_handler(pn_handler_t **handler,
pn_reactor_t *reactor,
dispatch_t *dispatch,
configSettings_t *config,
threadIPC_t *ipc)
{
DEFiRet;
*handler = pn_handler_new(dispatch, sizeof(protocolState_t), _del_handler);
CHKmalloc(*handler);
pn_handler_add(*handler, pn_handshaker());
protocolState_t *pState = PROTOCOL_STATE(*handler);
memset(pState, 0, sizeof(protocolState_t));
pState->buffer_size = 64; // will grow if not enough
pState->encode_buffer = (char *)malloc(pState->buffer_size);
CHKmalloc(pState->encode_buffer);
pState->reactor = reactor;
pState->stopped = false;
// these are _references_, don't free them:
pState->config = config;
pState->ipc = ipc;
finalize_it:
RETiRet;
}
pn_handshaker_t *pn_handshaker(void) {
pn_handler_t *handler = pn_handler_new(pn_handshaker_dispatch, sizeof(pni_handshaker_t), pn_handshaker_finalize);
pni_handshaker_t *handshaker = pni_handshaker(handler);
handshaker->handlers = NULL;
return handler;
}
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;
}
