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);
}
// 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;
}
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);
}
int pn_quote(pn_string_t *dst, const char *src, size_t size)
{
while (true) {
size_t str_size = pn_string_size(dst);
char *str = pn_string_buffer(dst) + str_size;
size_t capacity = pn_string_capacity(dst) - str_size;
ssize_t ssize = pn_quote_data(str, capacity, src, size);
if (ssize == PN_OVERFLOW) {
int err = pn_string_grow(dst, (str_size + capacity) ? 2*(str_size + capacity) : 16);
if (err) return err;
} else if (ssize >= 0) {
return pn_string_resize(dst, str_size + ssize);
} else {
return ssize;
}
}
}
