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 ssize_t pn_input_read_sasl_encrypt(pn_transport_t* transport, unsigned int layer, const char* bytes, size_t available)
{
pn_buffer_t *in = transport->sasl->decoded_buffer;
const size_t max_buffer = transport->sasl->max_encrypt_size;
for (size_t processed = 0; processed<available;) {
pn_bytes_t decoded = pn_bytes(0, NULL);
size_t decode_size = (available-processed)<=max_buffer?(available-processed):max_buffer;
ssize_t size = pni_sasl_impl_decode(transport, pn_bytes(decode_size, bytes+processed), &decoded);
if (size<0) return size;
if (size>0) {
size = pn_buffer_append(in, decoded.start, decoded.size);
if (size) return size;
}
processed += decode_size;
}
pn_bytes_t decoded = pn_buffer_bytes(in);
size_t processed_size = 0;
while (processed_size < decoded.size) {
ssize_t size = pni_passthru_layer.process_input(transport, layer, decoded.start+processed_size, decoded.size-processed_size);
if (size==0) break;
if (size<0) return size;
pn_buffer_trim(in, size, 0);
processed_size += size;
}
return available;
}
static ssize_t pn_output_write_sasl_encrypt(pn_transport_t* transport, unsigned int layer, char* bytes, size_t available)
{
ssize_t clear_size = pni_passthru_layer.process_output(transport, layer, bytes, available );
if (clear_size<0) return clear_size;
const ssize_t max_buffer = transport->sasl->max_encrypt_size;
pn_buffer_t *out = transport->sasl->encoded_buffer;
for (ssize_t processed = 0; processed<clear_size;) {
pn_bytes_t encoded = pn_bytes(0, NULL);
ssize_t encode_size = (clear_size-processed)<=max_buffer?(clear_size-processed):max_buffer;
ssize_t size = pni_sasl_impl_encode(transport, pn_bytes(encode_size, bytes+processed), &encoded);
if (size<0) return size;
if (size>0) {
size = pn_buffer_append(out, encoded.start, encoded.size);
if (size) return size;
}
processed += encode_size;
}
ssize_t size = pn_buffer_get(out, 0, available, bytes);
pn_buffer_trim(out, size, 0);
return size;
}
