int pn_messenger_tsync(pn_messenger_t *messenger, bool (*predicate)(pn_messenger_t *), int timeout)
{
for (int i = 0; i < messenger->size; i++) {
pn_connector_process(messenger->connectors[i]);
}
struct timeval now;
if (gettimeofday(&now, NULL)) pn_fatal("gettimeofday failed\n");
long int deadline = millis(now) + timeout;
bool pred;
while (true) {
pred = predicate(messenger);
int remaining = deadline - millis(now);
if (pred || (timeout >= 0 && remaining < 0)) break;
pn_driver_wait(messenger->driver, remaining);
pn_listener_t *l;
while ((l = pn_driver_listener(messenger->driver))) {
pn_connector_t *c = pn_listener_accept(l);
pn_sasl_t *sasl = pn_connector_sasl(c);
pn_sasl_mechanisms(sasl, "ANONYMOUS");
pn_sasl_server(sasl);
pn_sasl_done(sasl, PN_SASL_OK);
pn_connection_t *conn = pn_connection();
pn_connection_set_container(conn, messenger->name);
pn_connector_set_connection(c, conn);
messenger->connectors[messenger->size++] = c;
}
pn_connector_t *c;
while ((c = pn_driver_connector(messenger->driver))) {
pn_connector_process(c);
pn_connection_t *conn = pn_connector_connection(c);
pn_messenger_endpoints(messenger, conn);
if (pn_connector_closed(c)) {
for (int i = 0; i < messenger->size; i++) {
if (c == messenger->connectors[i]) {
memmove(messenger->connectors + i, messenger->connectors + i + 1, messenger->size - i - 1);
messenger->size--;
pn_connector_free(c);
pn_messenger_reclaim(messenger, conn);
pn_connection_free(conn);
pn_messenger_flow(messenger);
break;
}
}
} else {
pn_connector_process(c);
}
}
if (timeout >= 0) {
if (gettimeofday(&now, NULL)) pn_fatal("gettimeofday failed\n");
}
}
return pred ? 0 : PN_TIMEOUT;
}
void auth_server_handler(pn_connector_t *cxtr)
{
pn_sasl_t *sasl = pn_connector_sasl(cxtr);
pn_sasl_state_t state = pn_sasl_state(sasl);
nx_connection_t *ctx = (nx_connection_t*) pn_connector_context(cxtr);
while (state == PN_SASL_CONF || state == PN_SASL_STEP) {
if (state == PN_SASL_CONF) {
pn_sasl_mechanisms(sasl, "ANONYMOUS");
pn_sasl_server(sasl);
} else if (state == PN_SASL_STEP) {
const char* mechanisms = pn_sasl_remote_mechanisms(sasl);
if (strcmp(mechanisms, "ANONYMOUS") == 0)
pn_sasl_done(sasl, PN_SASL_OK);
else
pn_sasl_done(sasl, PN_SASL_AUTH);
}
state = pn_sasl_state(sasl);
}
if (state == PN_SASL_PASS) {
ctx->state = CONN_STATE_OPENING;
} else if (state == PN_SASL_FAIL) {
ctx->state = CONN_STATE_FAILED;
}
}
void auth_client_handler(pn_connector_t *cxtr)
{
pn_sasl_t *sasl = pn_connector_sasl(cxtr);
pn_sasl_state_t state = pn_sasl_state(sasl);
nx_connection_t *ctx = (nx_connection_t*) pn_connector_context(cxtr);
if (state == PN_SASL_CONF) {
pn_sasl_mechanisms(sasl, "ANONYMOUS");
pn_sasl_client(sasl);
}
state = pn_sasl_state(sasl);
if (state == PN_SASL_PASS) {
ctx->state = CONN_STATE_OPENING;
} else if (state == PN_SASL_FAIL) {
ctx->state = CONN_STATE_FAILED;
}
}
pn_connection_t *pn_messenger_domain(pn_messenger_t *messenger, const char *domain)
{
char buf[domain ? strlen(domain) + 1 : 1];
if (domain) {
strcpy(buf, domain);
} else {
buf[0] = '\0';
}
char *user = NULL;
char *pass = NULL;
char *host = "0.0.0.0";
char *port = "5672";
parse_url(buf, &user, &pass, &host, &port);
for (int i = 0; i < messenger->size; i++) {
pn_connection_t *connection = pn_connector_connection(messenger->connectors[i]);
const char *container = pn_connection_remote_container(connection);
const char *hostname = pn_connection_hostname(connection);
if (pn_streq(container, domain) || pn_streq(hostname, domain))
return connection;
}
pn_connector_t *connector = pn_connector(messenger->driver, host, port, NULL);
if (!connector) return NULL;
messenger->connectors[messenger->size++] = connector;
pn_sasl_t *sasl = pn_connector_sasl(connector);
if (user) {
pn_sasl_plain(sasl, user, pass);
} else {
pn_sasl_mechanisms(sasl, "ANONYMOUS");
pn_sasl_client(sasl);
}
pn_connection_t *connection = pn_connection();
pn_connection_set_container(connection, messenger->name);
pn_connection_set_hostname(connection, domain);
pn_connection_open(connection);
pn_connector_set_connection(connector, connection);
return connection;
}
bool
get_sasl_over_with ( pn_connector_t * connector )
{
pn_sasl_t *sasl = pn_connector_sasl ( connector );
while ( pn_sasl_state(sasl) != PN_SASL_PASS )
{
switch ( pn_sasl_state(sasl))
{
case PN_SASL_IDLE:
return false;
break;
case PN_SASL_CONF:
pn_sasl_mechanisms(sasl, "PLAIN ANONYMOUS");
pn_sasl_server(sasl);
break;
case PN_SASL_STEP:
{
char response [ MY_BUF_SIZE ];
pn_sasl_recv(sasl, response, pn_sasl_pending(sasl) );
pn_sasl_done(sasl, PN_SASL_OK);
pn_connector_set_connection(connector, pn_connection());
}
break;
case PN_SASL_PASS:
break;
case PN_SASL_FAIL:
return false;
break;
}
}
return true;
}
void client_callback(pn_connector_t *ctor)
{
struct client_context *ctx = pn_connector_context(ctor);
if (pn_connector_closed(ctor)) {
ctx->done = true;
}
pn_sasl_t *sasl = pn_connector_sasl(ctor);
while (pn_sasl_state(sasl) != PN_SASL_PASS) {
pn_sasl_state_t st = pn_sasl_state(sasl);
switch (st) {
case PN_SASL_IDLE:
return;
case PN_SASL_CONF:
if (ctx->mechanism && !strcmp(ctx->mechanism, "PLAIN")) {
pn_sasl_plain(sasl, ctx->username, ctx->password);
} else {
pn_sasl_mechanisms(sasl, ctx->mechanism);
pn_sasl_client(sasl);
}
break;
case PN_SASL_STEP:
if (pn_sasl_pending(sasl)) {
fprintf(stderr, "challenge failed\n");
ctx->done = true;
}
return;
case PN_SASL_FAIL:
fprintf(stderr, "authentication failed\n");
ctx->done = true;
return;
case PN_SASL_PASS:
break;
}
}
pn_connection_t *connection = pn_connector_connection(ctor);
char tagstr[1024];
char msg[ctx->size];
char data[ctx->size + 16];
for (int i = 0; i < ctx->size; i++) {
msg[i] = 'x';
}
size_t ndata = pn_message_data(data, ctx->size + 16, msg, ctx->size);
if (!ctx->init) {
ctx->init = true;
char container[1024];
if (gethostname(container, 1024)) pn_fatal("hostname lookup failed");
pn_connection_set_container(connection, container);
pn_connection_set_hostname(connection, ctx->hostname);
pn_session_t *ssn = pn_session(connection);
pn_connection_open(connection);
pn_session_open(ssn);
if (ctx->send_count) {
pn_link_t *snd = pn_sender(ssn, "sender");
pn_set_target(snd, ctx->address);
pn_link_open(snd);
char buf[16];
for (int i = 0; i < ctx->send_count; i++) {
sprintf(buf, "%x", i);
pn_delivery(snd, pn_dtag(buf, strlen(buf)));
}
}
if (ctx->recv_count) {
pn_link_t *rcv = pn_receiver(ssn, "receiver");
pn_set_source(rcv, ctx->address);
pn_link_open(rcv);
pn_flow(rcv, ctx->recv_count < ctx->high ? ctx->recv_count : ctx->high);
}
}
pn_delivery_t *delivery = pn_work_head(connection);
while (delivery)
{
pn_delivery_tag_t tag = pn_delivery_tag(delivery);
pn_quote_data(tagstr, 1024, tag.bytes, tag.size);
pn_link_t *link = pn_link(delivery);
if (pn_writable(delivery)) {
pn_send(link, data, ndata);
if (pn_advance(link)) {
if (!ctx->quiet) printf("sent delivery: %s\n", tagstr);
}
} else if (pn_readable(delivery)) {
if (!ctx->quiet) {
printf("received delivery: %s\n", tagstr);
printf(" payload = \"");
}
while (true) {
size_t n = pn_recv(link, msg, 1024);
if (n == PN_EOS) {
pn_advance(link);
pn_disposition(delivery, PN_ACCEPTED);
pn_settle(delivery);
if (!--ctx->recv_count) {
pn_link_close(link);
}
break;
} else if (!ctx->quiet) {
pn_print_data(msg, n);
}
}
if (!ctx->quiet) printf("\"\n");
if (pn_credit(link) < ctx->low && pn_credit(link) < ctx->recv_count) {
pn_flow(link, (ctx->recv_count < ctx->high ? ctx->recv_count : ctx->high) - pn_credit(link));
}
}
if (pn_updated(delivery)) {
if (!ctx->quiet) printf("disposition for %s: %u\n", tagstr, pn_remote_disposition(delivery));
pn_clear(delivery);
pn_settle(delivery);
if (!--ctx->send_count) {
pn_link_close(link);
}
}
delivery = pn_work_next(delivery);
}
if (!ctx->send_count && !ctx->recv_count) {
printf("closing\n");
// XXX: how do we close the session?
//pn_close((pn_endpoint_t *) ssn);
pn_connection_close(connection);
}
if (pn_connection_state(connection) == (PN_LOCAL_CLOSED | PN_REMOTE_CLOSED)) {
ctx->done = true;
}
}
void server_callback(pn_connector_t *ctor)
{
pn_sasl_t *sasl = pn_connector_sasl(ctor);
while (pn_sasl_state(sasl) != PN_SASL_PASS) {
switch (pn_sasl_state(sasl)) {
case PN_SASL_IDLE:
return;
case PN_SASL_CONF:
pn_sasl_mechanisms(sasl, "PLAIN ANONYMOUS");
pn_sasl_server(sasl);
break;
case PN_SASL_STEP:
{
size_t n = pn_sasl_pending(sasl);
char iresp[n];
pn_sasl_recv(sasl, iresp, n);
printf("%s", pn_sasl_remote_mechanisms(sasl));
printf(" response = ");
pn_print_data(iresp, n);
printf("\n");
pn_sasl_done(sasl, PN_SASL_OK);
pn_connector_set_connection(ctor, pn_connection());
}
break;
case PN_SASL_PASS:
break;
case PN_SASL_FAIL:
return;
}
}
pn_connection_t *conn = pn_connector_connection(ctor);
struct server_context *ctx = pn_connector_context(ctor);
char tagstr[1024];
char msg[10*1024];
char data[ctx->size + 16];
for (int i = 0; i < ctx->size; i++) {
msg[i] = 'x';
}
size_t ndata = pn_message_data(data, ctx->size + 16, msg, ctx->size);
if (pn_connection_state(conn) == (PN_LOCAL_UNINIT | PN_REMOTE_ACTIVE)) {
pn_connection_open(conn);
}
pn_session_t *ssn = pn_session_head(conn, PN_LOCAL_UNINIT | PN_REMOTE_ACTIVE);
while (ssn) {
pn_session_open(ssn);
ssn = pn_session_next(ssn, PN_LOCAL_UNINIT | PN_REMOTE_ACTIVE);
}
pn_link_t *link = pn_link_head(conn, PN_LOCAL_UNINIT | PN_REMOTE_ACTIVE);
while (link) {
printf("%s, %s\n", pn_remote_source(link), pn_remote_target(link));
pn_set_source(link, pn_remote_source(link));
pn_set_target(link, pn_remote_target(link));
pn_link_open(link);
if (pn_is_receiver(link)) {
pn_flow(link, 100);
} else {
pn_delivery(link, pn_dtag("blah", 4));
}
link = pn_link_next(link, PN_LOCAL_UNINIT | PN_REMOTE_ACTIVE);
}
pn_delivery_t *delivery = pn_work_head(conn);
while (delivery)
{
pn_delivery_tag_t tag = pn_delivery_tag(delivery);
pn_quote_data(tagstr, 1024, tag.bytes, tag.size);
pn_link_t *link = pn_link(delivery);
if (pn_readable(delivery)) {
if (!ctx->quiet) {
printf("received delivery: %s\n", tagstr);
printf(" payload = \"");
}
while (true) {
ssize_t n = pn_recv(link, msg, 1024);
if (n == PN_EOS) {
pn_advance(link);
pn_disposition(delivery, PN_ACCEPTED);
break;
} else if (!ctx->quiet) {
pn_print_data(msg, n);
}
}
if (!ctx->quiet) printf("\"\n");
if (pn_credit(link) < 50) pn_flow(link, 100);
} else if (pn_writable(delivery)) {
pn_send(link, data, ndata);
if (pn_advance(link)) {
if (!ctx->quiet) printf("sent delivery: %s\n", tagstr);
char tagbuf[16];
sprintf(tagbuf, "%i", ctx->count++);
pn_delivery(link, pn_dtag(tagbuf, strlen(tagbuf)));
}
}
if (pn_updated(delivery)) {
if (!ctx->quiet) printf("disposition for %s: %u\n", tagstr, pn_remote_disposition(delivery));
pn_settle(delivery);
}
delivery = pn_work_next(delivery);
}
if (pn_connection_state(conn) == (PN_LOCAL_ACTIVE | PN_REMOTE_CLOSED)) {
pn_connection_close(conn);
}
ssn = pn_session_head(conn, PN_LOCAL_ACTIVE | PN_REMOTE_CLOSED);
while (ssn) {
pn_session_close(ssn);
ssn = pn_session_next(ssn, PN_LOCAL_ACTIVE | PN_REMOTE_CLOSED);
}
link = pn_link_head(conn, PN_LOCAL_ACTIVE | PN_REMOTE_CLOSED);
while (link) {
pn_link_close(link);
link = pn_link_next(link, PN_LOCAL_ACTIVE | PN_REMOTE_CLOSED);
}
}
