qd_link_t *qd_link(qd_node_t *node, qd_connection_t *conn, qd_direction_t dir, const char* name) { qd_link_t *link = new_qd_link_t(); link->pn_sess = pn_session(qd_connection_pn(conn)); pn_session_set_incoming_capacity(link->pn_sess, 1000000); if (dir == QD_OUTGOING) link->pn_link = pn_sender(link->pn_sess, name); else link->pn_link = pn_receiver(link->pn_sess, name); link->direction = dir; link->context = node->context; link->node = node; link->drain_mode = pn_link_get_drain(link->pn_link); link->remote_snd_settle_mode = pn_link_remote_snd_settle_mode(link->pn_link); link->close_sess_with_link = true; // // Keep the borrowed references // pn_incref(link->pn_link); pn_incref(link->pn_sess); pn_link_set_context(link->pn_link, link); pn_session_open(link->pn_sess); return link; }
receiver session::open_receiver(const std::string &addr, const link_options &lo) { receiver rcv = pn_receiver(pn_object(), next_link_name(connection()).c_str()); rcv.local_source().address(addr); rcv.open(lo); return rcv; }
receiver session::open_receiver(const std::string &addr, const receiver_options &ro) { std::string name = ro.get_name() ? *ro.get_name() : next_link_name(connection()); pn_link_t *lnk = pn_receiver(pn_object(), name.c_str()); pn_terminus_set_address(pn_link_source(lnk), addr.c_str()); receiver rcv(make_wrapper<receiver>(lnk)); rcv.open(ro); return rcv; }
pn_link_t *pn_messenger_link(pn_messenger_t *messenger, const char *address, bool sender) { char buf[(address ? strlen(address) : 0) + 1]; if (address) { strcpy(buf, address); } else { buf[0] = '\0'; } char *domain; char *name; parse_address(address ? buf : NULL, &domain, &name); pn_connection_t *connection = pn_messenger_domain(messenger, domain); if (!connection) return NULL; pn_link_t *link = pn_link_head(connection, PN_LOCAL_ACTIVE); while (link) { if (pn_is_sender(link) == sender) { const char *terminus = pn_is_sender(link) ? pn_target(link) : pn_source(link); if (pn_streq(name, terminus)) return link; } link = pn_link_next(link, PN_LOCAL_ACTIVE); } pn_session_t *ssn = pn_session(connection); pn_session_open(ssn); link = sender ? pn_sender(ssn, "sender-xxx") : pn_receiver(ssn, "receiver-xxx"); // XXX if (sender) { pn_set_target(link, name); pn_set_source(link, name); } else { pn_set_target(link, name); pn_set_source(link, name); } pn_link_open(link); return link; }
void Interconnect::process() { QPID_LOG(trace, id << " processing interconnect"); if (closeRequested) { close(); } else { if ((pn_connection_state(connection) & UNINIT) == UNINIT) { QPID_LOG_CAT(debug, model, id << " interconnect open initiated"); pn_connection_set_container(connection, getBroker().getFederationTag().c_str()); setProperties(connection); pn_connection_open(connection); out.connectionEstablished(); setInterconnectDomain(domain); } if (!isOpened && (pn_connection_state(connection) & PN_REMOTE_ACTIVE)) { QPID_LOG_CAT(debug, model, id << " interconnect open completed, attaching link"); isOpened = true; readPeerProperties(); const char* containerid(pn_connection_remote_container(connection)); if (containerid) { setContainerId(std::string(containerid)); } opened(); getBroker().getConnectionObservers().opened(*this); pn_session_t* s = pn_session(connection); pn_session_open(s); boost::shared_ptr<Session> ssn(new Session(s, *this, out)); sessions[s] = ssn; pn_link_t* l = incoming ? pn_receiver(s, name.c_str()) : pn_sender(s, name.c_str()); pn_link_open(l); ssn->attach(l, source, target, relay); } Connection::process(); } }
receiver session::create_receiver(const std::string& name) { return pn_receiver(pn_object(), set_name(name, this).c_str()); }
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; } }