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);
}
static void test_build_map_odd(void)
{
pn_map_t *m = build_map(0, 0.75,
pn_string("key"),
pn_string("value"),
pn_string("key2"),
pn_string("value2"),
pn_string("key3"),
END);
assert(pn_map_size(m) == 3);
pn_string_t *key = pn_string(NULL);
pn_string_set(key, "key");
assert(pn_strequals(pn_string_get((pn_string_t *) pn_map_get(m, key)),
"value"));
pn_string_set(key, "key2");
assert(pn_strequals(pn_string_get((pn_string_t *) pn_map_get(m, key)),
"value2"));
pn_string_set(key, "key3");
assert(pn_map_get(m, key) == NULL);
pn_free(m);
pn_free(key);
}
int pn_transform_apply(pn_transform_t *transform, const char *src,
pn_string_t *dst)
{
for (size_t i = 0; i < pn_list_size(transform->rules); i++)
{
pn_rule_t *rule = (pn_rule_t *) pn_list_get(transform->rules, i);
if (pni_match(&transform->matcher, pn_string_get(rule->pattern), src)) {
transform->matched = true;
if (!pn_string_get(rule->substitution)) {
return pn_string_set(dst, NULL);
}
while (true) {
size_t capacity = pn_string_capacity(dst);
size_t n = pni_substitute(&transform->matcher,
pn_string_get(rule->substitution),
pn_string_buffer(dst), capacity);
int err = pn_string_resize(dst, n);
if (err) return err;
if (n <= capacity) {
return 0;
}
}
}
}
transform->matched = false;
return pn_string_set(dst, src);
}
const char *pn_subscription_address(pn_subscription_t *sub)
{
assert(sub);
while (!pn_string_get(sub->address)) {
int err = pni_messenger_work(sub->messenger);
if (err < 0) {
return NULL;
}
}
return pn_string_get(sub->address);
}
void test_inspect(void *o, const char *expected)
{
pn_string_t *dst = pn_string(NULL);
pn_inspect(o, dst);
assert(pn_strequals(pn_string_get(dst), expected));
pn_free(dst);
}
pn_ssl_t *pn_ssl(pn_transport_t *transport)
{
if (!transport) return NULL;
if (transport->ssl) return (pn_ssl_t *) transport;
pni_ssl_t *ssl = (pni_ssl_t *) calloc(1, sizeof(pni_ssl_t));
if (!ssl) return NULL;
ssl->out_size = APP_BUF_SIZE;
uint32_t max_frame = pn_transport_get_max_frame(transport);
ssl->in_size = max_frame ? max_frame : APP_BUF_SIZE;
ssl->outbuf = (char *)malloc(ssl->out_size);
if (!ssl->outbuf) {
free(ssl);
return NULL;
}
ssl->inbuf = (char *)malloc(ssl->in_size);
if (!ssl->inbuf) {
free(ssl->outbuf);
free(ssl);
return NULL;
}
transport->ssl = ssl;
// Set up hostname from any bound connection
if (transport->connection) {
if (pn_string_size(transport->connection->hostname)) {
pn_ssl_set_peer_hostname((pn_ssl_t *) transport, pn_string_get(transport->connection->hostname));
}
}
return (pn_ssl_t *) transport;
}
static void test_stringn(const char *value, size_t size)
{
pn_string_t *strn = pn_stringn(value, size);
assert(equals(pn_string_get(strn), value));
assert(pn_string_size(strn) == size);
pn_string_t *strsetn = pn_string(NULL);
pn_string_setn(strsetn, value, size);
assert(equals(pn_string_get(strsetn), value));
assert(pn_string_size(strsetn) == size);
assert(pn_hashcode(strn) == pn_hashcode(strsetn));
assert(!pn_compare(strn, strsetn));
pn_free(strn);
pn_free(strsetn);
}
/** Return the string form of a URL. */
PN_EXTERN const char *pn_url_str(pn_url_t *url) {
if (pn_string_get(url->str) == NULL) {
pn_string_set(url->str, "");
if (url->scheme) pn_string_addf(url->str, "%s://", url->scheme);
if (url->username) pni_urlencode(url->str, url->username);
if (url->password) {
pn_string_addf(url->str, ":");
pni_urlencode(url->str, url->password);
}
if (url->username || url->password) pn_string_addf(url->str, "@");
if (url->host) {
if (strchr(url->host, ':')) pn_string_addf(url->str, "[%s]", url->host);
else pn_string_addf(url->str, "%s", url->host);
}
if (url->port) pn_string_addf(url->str, ":%s", url->port);
if (url->path) pn_string_addf(url->str, "/%s", url->path);
}
return pn_string_get(url->str);
}
static void test_build_list(void)
{
pn_list_t *l = build_list(0,
pn_string("one"),
pn_string("two"),
pn_string("three"),
END);
assert(pn_list_size(l) == 3);
assert(pn_strequals(pn_string_get((pn_string_t *) pn_list_get(l, 0)),
"one"));
assert(pn_strequals(pn_string_get((pn_string_t *) pn_list_get(l, 1)),
"two"));
assert(pn_strequals(pn_string_get((pn_string_t *) pn_list_get(l, 2)),
"three"));
pn_free(l);
}
int pn_post_frame(pn_dispatcher_t *disp, uint16_t ch, const char *fmt, ...)
{
va_list ap;
va_start(ap, fmt);
pn_data_clear(disp->output_args);
int err = pn_data_vfill(disp->output_args, fmt, ap);
va_end(ap);
if (err) {
pn_transport_logf(disp->transport,
"error posting frame: %s, %s: %s", fmt, pn_code(err),
pn_error_text(pn_data_error(disp->output_args)));
return PN_ERR;
}
pn_do_trace(disp, ch, OUT, disp->output_args, disp->output_payload, disp->output_size);
encode_performatives:
pn_buffer_clear( disp->frame );
pn_bytes_t buf = pn_buffer_bytes( disp->frame );
buf.size = pn_buffer_available( disp->frame );
ssize_t wr = pn_data_encode( disp->output_args, buf.start, buf.size );
if (wr < 0) {
if (wr == PN_OVERFLOW) {
pn_buffer_ensure( disp->frame, pn_buffer_available( disp->frame ) * 2 );
goto encode_performatives;
}
pn_transport_logf(disp->transport,
"error posting frame: %s", pn_code(wr));
return PN_ERR;
}
pn_frame_t frame = {disp->frame_type};
frame.channel = ch;
frame.payload = buf.start;
frame.size = wr;
size_t n;
while (!(n = pn_write_frame(disp->output + disp->available,
disp->capacity - disp->available, frame))) {
disp->capacity *= 2;
disp->output = (char *) realloc(disp->output, disp->capacity);
}
disp->output_frames_ct += 1;
if (disp->trace & PN_TRACE_RAW) {
pn_string_set(disp->scratch, "RAW: \"");
pn_quote(disp->scratch, disp->output + disp->available, n);
pn_string_addf(disp->scratch, "\"");
pn_transport_log(disp->transport, pn_string_get(disp->scratch));
}
disp->available += n;
return 0;
}
int pni_subscription_set_address(pn_subscription_t *sub, const char *address)
{
assert(sub);
if (!address) return 0;
bool absolute = strncmp(address, "amqp:", 5) == 0;
if (absolute) {
return pn_string_set(sub->address, address);
} else {
pn_string_set(sub->address, "");
bool scheme = pn_string_get(sub->scheme);
if (scheme) {
int e = pn_string_addf(sub->address, "%s:", pn_string_get(sub->scheme));
if (e) return e;
}
if (pn_string_get(sub->host)) {
int e = pn_string_addf(sub->address, scheme ? "//%s" : "%s", pn_string_get(sub->host));
if (e) return e;
}
if (pn_string_get(sub->port)) {
int e = pn_string_addf(sub->address, ":%s", pn_string_get(sub->port));
if (e) return e;
}
return pn_string_addf(sub->address, "/%s", address);
}
}
int pn_dispatch_frame(pn_dispatcher_t *disp, pn_frame_t frame)
{
if (frame.size == 0) { // ignore null frames
if (disp->trace & PN_TRACE_FRM)
pn_transport_logf(disp->transport, "%u <- (EMPTY FRAME)\n", frame.channel);
return 0;
}
ssize_t dsize = pn_data_decode(disp->args, frame.payload, frame.size);
if (dsize < 0) {
pn_string_format(disp->scratch,
"Error decoding frame: %s %s\n", pn_code(dsize),
pn_error_text(pn_data_error(disp->args)));
pn_quote(disp->scratch, frame.payload, frame.size);
pn_transport_log(disp->transport, pn_string_get(disp->scratch));
return dsize;
}
disp->channel = frame.channel;
// XXX: assuming numeric
uint64_t lcode;
bool scanned;
int e = pn_data_scan(disp->args, "D?L.", &scanned, &lcode);
if (e) {
pn_transport_log(disp->transport, "Scan error");
return e;
}
if (!scanned) {
pn_transport_log(disp->transport, "Error dispatching frame");
return PN_ERR;
}
uint8_t code = lcode;
disp->code = code;
disp->size = frame.size - dsize;
if (disp->size)
disp->payload = frame.payload + dsize;
pn_do_trace(disp, disp->channel, IN, disp->args, disp->payload, disp->size);
pn_action_t *action = disp->actions[code];
int err = action(disp);
disp->channel = 0;
disp->code = 0;
pn_data_clear(disp->args);
disp->size = 0;
disp->payload = NULL;
return err;
}
static void test_string(const char *value)
{
size_t size = value ? strlen(value) : 0;
pn_string_t *str = pn_string(value);
assert(equals(pn_string_get(str), value));
assert(pn_string_size(str) == size);
pn_string_t *strn = pn_stringn(value, size);
assert(equals(pn_string_get(strn), value));
assert(pn_string_size(strn) == size);
pn_string_t *strset = pn_string(NULL);
pn_string_set(strset, value);
assert(equals(pn_string_get(strset), value));
assert(pn_string_size(strset) == size);
pn_string_t *strsetn = pn_string(NULL);
pn_string_setn(strsetn, value, size);
assert(equals(pn_string_get(strsetn), value));
assert(pn_string_size(strsetn) == size);
assert(pn_hashcode(str) == pn_hashcode(strn));
assert(pn_hashcode(str) == pn_hashcode(strset));
assert(pn_hashcode(str) == pn_hashcode(strsetn));
assert(!pn_compare(str, str));
assert(!pn_compare(str, strn));
assert(!pn_compare(str, strset));
assert(!pn_compare(str, strsetn));
pn_free(str);
pn_free(strn);
pn_free(strset);
pn_free(strsetn);
}
static void pn_do_trace(pn_dispatcher_t *disp, uint16_t ch, pn_dir_t dir,
pn_data_t *args, const char *payload, size_t size)
{
if (disp->trace & PN_TRACE_FRM) {
pn_string_format(disp->scratch, "%u %s ", ch, dir == OUT ? "->" : "<-");
pn_inspect(args, disp->scratch);
if (size) {
char buf[1024];
int e = pn_quote_data(buf, 1024, payload, size);
pn_string_addf(disp->scratch, " (%" PN_ZU ") \"%s\"%s", size, buf,
e == PN_OVERFLOW ? "... (truncated)" : "");
}
pn_transport_log(disp->transport, pn_string_get(disp->scratch));
}
}
// 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;
}
int pn_post_transfer_frame(pn_dispatcher_t *disp, uint16_t ch,
uint32_t handle,
pn_sequence_t id,
const pn_bytes_t *tag,
uint32_t message_format,
bool settled,
bool more,
pn_sequence_t frame_limit)
{
bool more_flag = more;
int framecount = 0;
// create preformatives, assuming 'more' flag need not change
compute_performatives:
pn_data_clear(disp->output_args);
int err = pn_data_fill(disp->output_args, "DL[IIzIoo]", TRANSFER,
handle, id, tag->size, tag->start,
message_format,
settled, more_flag);
if (err) {
pn_transport_logf(disp->transport,
"error posting transfer frame: %s: %s", pn_code(err),
pn_error_text(pn_data_error(disp->output_args)));
return PN_ERR;
}
do { // send as many frames as possible without changing the 'more' flag...
encode_performatives:
pn_buffer_clear( disp->frame );
pn_bytes_t buf = pn_buffer_bytes( disp->frame );
buf.size = pn_buffer_available( disp->frame );
ssize_t wr = pn_data_encode(disp->output_args, buf.start, buf.size);
if (wr < 0) {
if (wr == PN_OVERFLOW) {
pn_buffer_ensure( disp->frame, pn_buffer_available( disp->frame ) * 2 );
goto encode_performatives;
}
pn_transport_logf(disp->transport, "error posting frame: %s", pn_code(wr));
return PN_ERR;
}
buf.size = wr;
// check if we need to break up the outbound frame
size_t available = disp->output_size;
if (disp->remote_max_frame) {
if ((available + buf.size) > disp->remote_max_frame - 8) {
available = disp->remote_max_frame - 8 - buf.size;
if (more_flag == false) {
more_flag = true;
goto compute_performatives; // deal with flag change
}
} else if (more_flag == true && more == false) {
// caller has no more, and this is the last frame
more_flag = false;
goto compute_performatives;
}
}
if (pn_buffer_available( disp->frame ) < (available + buf.size)) {
// not enough room for payload - try again...
pn_buffer_ensure( disp->frame, available + buf.size );
goto encode_performatives;
}
pn_do_trace(disp, ch, OUT, disp->output_args, disp->output_payload, available);
memmove( buf.start + buf.size, disp->output_payload, available);
disp->output_payload += available;
disp->output_size -= available;
buf.size += available;
pn_frame_t frame = {disp->frame_type};
frame.channel = ch;
frame.payload = buf.start;
frame.size = buf.size;
size_t n;
while (!(n = pn_write_frame(disp->output + disp->available,
disp->capacity - disp->available, frame))) {
disp->capacity *= 2;
disp->output = (char *) realloc(disp->output, disp->capacity);
}
disp->output_frames_ct += 1;
framecount++;
if (disp->trace & PN_TRACE_RAW) {
pn_string_set(disp->scratch, "RAW: \"");
pn_quote(disp->scratch, disp->output + disp->available, n);
pn_string_addf(disp->scratch, "\"");
pn_transport_log(disp->transport, pn_string_get(disp->scratch));
}
disp->available += n;
} while (disp->output_size > 0 && framecount < frame_limit);
disp->output_payload = NULL;
return framecount;
}
const char *pn_subscription_scheme(pn_subscription_t *sub)
{
assert(sub);
return pn_string_get(sub->scheme);
}
void sender_dispatch(pn_handler_t *h, pn_event_t *event, pn_event_type_t type)
{
sender_context_t *sc = sender_context(h);
switch (type) {
case PN_CONNECTION_INIT:
{
pn_connection_t *conn = pn_event_connection(event);
pn_connection_set_container(conn, pn_string_get(sc->container_id));
pn_connection_set_hostname(conn, pn_string_get(sc->hostname));
pn_connection_open(conn);
pn_session_t *ssn = pn_session(conn);
pn_session_open(ssn);
pn_link_t *snd = pn_sender(ssn, "sender");
const char *path = pn_url_get_path(sc->send_url);
if (path && strlen(path)) {
pn_terminus_set_address(pn_link_target(snd), path);
pn_terminus_set_address(pn_link_source(snd), path);
}
pn_link_open(snd);
}
break;
case PN_LINK_FLOW:
{
pn_link_t *snd = pn_event_link(event);
while (pn_link_credit(snd) > 0 && sc->sent < sc->opts->msg_count) {
if (sc->sent == 0)
statistics_start(sc->stats);
char tag[8];
void *ptr = &tag;
*((uint64_t *) ptr) = sc->sent;
pn_delivery_t *dlv = pn_delivery(snd, pn_dtag(tag, 8));
// setup the message to send
pn_message_t *msg = sc->message;
pn_message_set_address(msg, sc->opts->targets.addresses[0]);
sc->id.u.as_ulong = sc->sent;
pn_message_set_correlation_id(msg, sc->id);
pn_message_set_creation_time(msg, msgr_now());
size_t size = sc->encoded_data_size;
int err = pn_message_encode(msg, sc->encoded_data, &size);
check(err == 0, "message encoding error");
pn_link_send(snd, sc->encoded_data, size);
pn_delivery_settle(dlv);
sc->sent++;
}
if (sc->sent == sc->opts->msg_count && !sc->opts->get_replies) {
pn_link_close(snd);
pn_connection_t *conn = pn_event_connection(event);
pn_connection_close(conn);
}
}
break;
case PN_LINK_INIT:
{
pn_link_t *link = pn_event_link(event);
if (pn_link_is_receiver(link)) {
// Response messages link. Could manage credit and deliveries in this handler but
// a dedicated handler also works.
pn_handler_t *replyto = replyto_handler(sc);
pn_flowcontroller_t *fc = pn_flowcontroller(1024);
pn_handler_add(replyto, fc);
pn_decref(fc);
pn_handshaker_t *handshaker = pn_handshaker();
pn_handler_add(replyto, handshaker);
pn_decref(handshaker);
pn_record_t *record = pn_link_attachments(link);
pn_record_set_handler(record, replyto);
pn_decref(replyto);
}
}
break;
case PN_CONNECTION_LOCAL_CLOSE:
{
statistics_report(sc->stats, sc->sent, sc->received);
}
break;
default:
break;
}
}
