static int pn_buffer_set_bytes(pn_buffer_t **buf, pn_bytes_t bytes)
{
if (!*buf) {
*buf = pn_buffer(64);
}
int err = pn_buffer_clear(*buf);
if (err) return err;
return pn_buffer_append(*buf, bytes.start, bytes.size);
}
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 buffer(int argc, char **argv)
{
pn_buffer_t *buf = pn_buffer(16);
pn_buffer_append(buf, "abcd", 4);
pn_buffer_print(buf); printf("\n");
pn_buffer_prepend(buf, "012", 3);
pn_buffer_print(buf); printf("\n");
pn_buffer_prepend(buf, "z", 1);
pn_buffer_print(buf); printf("\n");
pn_buffer_append(buf, "efg", 3);
pn_buffer_print(buf); printf("\n");
pn_buffer_append(buf, "hijklm", 6);
pn_buffer_print(buf); printf("\n");
pn_buffer_defrag(buf);
pn_buffer_print(buf); printf("\n");
pn_buffer_trim(buf, 1, 1);
pn_buffer_print(buf); printf("\n");
pn_buffer_trim(buf, 4, 0);
pn_buffer_print(buf); printf("\n");
pn_buffer_clear(buf);
pn_buffer_print(buf); printf("\n");
pn_buffer_free(buf);
pn_data_t *data = pn_data(16);
int err = pn_data_fill(data, "Ds[iSi]", "desc", 1, "two", 3);
if (err) {
printf("%s\n", pn_code(err));
}
pn_data_print(data); printf("\n");
pn_bytes_t str;
err = pn_data_scan(data, "D.[.S.]", &str);
if (err) {
printf("%s\n", pn_code(err));
} else {
printf("%.*s\n", (int) str.size, str.start);
}
pn_data_clear(data);
pn_data_fill(data, "DL[SIonn?DL[S]?DL[S]nnI]", ATTACH, "asdf", 1, true,
true, SOURCE, "queue",
true, TARGET, "queue",
0);
pn_data_print(data); printf("\n");
pn_data_free(data);
return 0;
}
static int pn_buffer_set_strn(pn_buffer_t **buf, const char *str, size_t size)
{
if (!*buf) {
*buf = pn_buffer(64);
}
int err = pn_buffer_clear(*buf);
if (err) return err;
err = pn_buffer_append(*buf, str, size);
if (err) return err;
if (str && str[size-1]) {
return pn_buffer_append(*buf, "\0", 1);
} else {
return 0;
}
}
void pn_message_clear(pn_message_t *msg)
{
msg->durable = false;
msg->priority = PN_DEFAULT_PRIORITY;
msg->ttl = 0;
msg->first_acquirer = false;
msg->delivery_count = 0;
msg->id.type = PN_NULL;
if (msg->user_id) pn_buffer_clear(msg->user_id);
if (msg->address) pn_buffer_clear(msg->address);
if (msg->subject) pn_buffer_clear(msg->subject);
if (msg->reply_to) pn_buffer_clear(msg->reply_to);
msg->correlation_id.type = PN_NULL;
if (msg->content_type) pn_buffer_clear(msg->content_type);
if (msg->content_encoding) pn_buffer_clear(msg->content_encoding);
msg->expiry_time = 0;
msg->creation_time = 0;
if (msg->group_id) pn_buffer_clear(msg->group_id);
msg->group_sequence = 0;
if (msg->reply_to_group_id) pn_buffer_clear(msg->reply_to_group_id);
if (msg->data) pn_data_clear(msg->data);
if (msg->body) pn_data_clear(msg->body);
}
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;
}