static zmsg_t *
server_method (server_t *self, const char *method, zmsg_t *msg)
{
if (streq (method, "CLIENTLIST")) {
zmsg_t *reply = zmsg_new ();
zmsg_addstr (reply, "CLIENTLIST");
void *item = zhashx_first (self->clients);
while (item) {
zmsg_addstr (reply, (const char *) zhashx_cursor (self->clients));
item = (void *) zhashx_next (self->clients);
}
return reply;
}
if (streq (method, "STREAMLIST")) {
zmsg_t *reply = zmsg_new();
zmsg_addstr (reply, "STREAMLIST");
stream_t *stream = (stream_t *) zhashx_first (self->streams);
while (stream) {
zmsg_addstr (reply, stream->name);
stream = (stream_t *) zhashx_next (self->streams);
}
return reply;
}
if (streq (method, "SLOW_TEST_MODE")) {
// selftest: Tell all stream engines to enable SLOW_TEST_MODE
stream_t *stream = (stream_t *) zhashx_first (self->streams);
while (stream) {
zsock_send (stream->actor, "s", method);
stream = (stream_t *) zhashx_next (self->streams);
}
return NULL;
}
return NULL;
}
static void
server_connect (server_t *self, const char *endpoint)
{
zsock_t *remote = zsock_new (ZMQ_DEALER);
assert (remote); // No recovery if exhausted
// Never block on sending; we use an infinite HWM and buffer as many
// messages as needed in outgoing pipes. Note that the maximum number
// is the overall tuple set size.
zsock_set_unbounded (remote);
if (zsock_connect (remote, "%s", endpoint)) {
zsys_warning ("bad zgossip endpoint '%s'", endpoint);
zsock_destroy (&remote);
return;
}
// Send HELLO and then PUBLISH for each tuple we have
zgossip_msg_t *gossip = zgossip_msg_new ();
zgossip_msg_set_id (gossip, ZGOSSIP_MSG_HELLO);
zgossip_msg_send (gossip, remote);
tuple_t *tuple = (tuple_t *) zhashx_first (self->tuples);
while (tuple) {
zgossip_msg_set_id (gossip, ZGOSSIP_MSG_PUBLISH);
zgossip_msg_set_key (gossip, tuple->key);
zgossip_msg_set_value (gossip, tuple->value);
zgossip_msg_send (gossip, remote);
tuple = (tuple_t *) zhashx_next (self->tuples);
}
// Now monitor this remote for incoming messages
zgossip_msg_destroy (&gossip);
engine_handle_socket (self, remote, remote_handler);
zlistx_add_end (self->remotes, remote);
}
static void
deregister_the_client (client_t *self)
{
// If the client never sent CONNECTION_OPEN then self->address was
// never set, so avoid trying to dereference it. Nothing needs to
// be cleaned up.
if (self->address) {
if (*self->address)
zsys_info ("client %u address='%s' - de-registering", self->unique_id, self->address);
// Cancel all stream subscriptions
stream_t *stream = (stream_t *) zlistx_detach (self->readers, NULL);
while (stream) {
zsock_send (stream->actor, "sp", "CANCEL", self);
stream = (stream_t *) zlistx_detach (self->readers, NULL);
}
// Cancel all service offerings
service_t *service = (service_t *) zhashx_first (self->server->services);
while (service) {
offer_t *offer = (offer_t *) zlistx_first (service->offers);
while (offer) {
if (offer->client == self)
zlistx_delete (service->offers, zlistx_cursor (service->offers));
offer = (offer_t *) zlistx_next (service->offers);
}
service = (service_t *) zhashx_next (self->server->services);
}
if (*self->address)
zhashx_delete (self->server->clients, self->address);
}
mlm_proto_set_status_code (self->message, MLM_PROTO_SUCCESS);
}
static void
deregister_the_client (client_t *self)
{
if (*self->address)
zsys_info ("client address='%s' - de-registering", self->address);
// Cancel all stream subscriptions
stream_t *stream = (stream_t *) zlistx_detach (self->readers, NULL);
while (stream) {
zsock_send (stream->actor, "sp", "CANCEL", self);
stream = (stream_t *) zlistx_detach (self->readers, NULL);
}
// Cancel all service offerings
service_t *service = (service_t *) zhashx_first (self->server->services);
while (service) {
offer_t *offer = (offer_t *) zlistx_first (service->offers);
while (offer) {
if (offer->client == self)
zlistx_delete (service->offers, zlistx_cursor (service->offers));
offer = (offer_t *) zlistx_next (service->offers);
}
service = (service_t *) zhashx_next (self->server->services);
}
if (*self->address)
zhashx_delete (self->server->clients, self->address);
mlm_proto_set_status_code (self->message, MLM_PROTO_SUCCESS);
}
void *
zhashx_first (zhashx_t *self)
{
assert (self);
// Point to before or at first item
self->cursor_index = 0;
self->cursor_item = self->items [self->cursor_index];
// Now scan forwards to find it, leave cursor after item
return zhashx_next (self);
}
static void
get_next_tuple (client_t *self)
{
tuple_t *tuple = (tuple_t *) zhashx_next (self->server->tuples);
if (tuple) {
zgossip_msg_set_key (self->message, tuple->key);
zgossip_msg_set_value (self->message, tuple->value);
engine_set_next_event (self, ok_event);
}
else
engine_set_next_event (self, finished_event);
}
void
zcertstore_fprint (zcertstore_t *self, FILE *file)
{
if (self->location)
fprintf (file, "Certificate store at %s:\n", self->location);
else
fprintf (file, "Certificate store\n");
zcert_t *cert = (zcert_t *) zhashx_first (self->certs);
while (cert) {
zcert_fprint (cert, file);
cert = (zcert_t *) zhashx_next (self->certs);
}
}
void
zcertstore_print (zcertstore_t *self)
{
if (self->location)
zsys_info ("zcertstore: certificates at location=%s:", self->location);
else
zsys_info ("zcertstore: certificates in memory");
zcert_t *cert = (zcert_t *) zhashx_first (self->certs);
while (cert) {
zcert_print (cert);
cert = (zcert_t *) zhashx_next (self->certs);
}
}
server_connect (server_t *self, const char *endpoint)
#endif
{
zsock_t *remote = zsock_new (ZMQ_DEALER);
assert (remote); // No recovery if exhausted
#ifdef CZMQ_BUILD_DRAFT_API
// DRAFT-API: Security
if (public_key){
zcert_t *cert = zcert_new_from_txt (self->public_key, self->secret_key);
zcert_apply(cert, remote);
zsock_set_curve_serverkey (remote, public_key);
#ifndef ZMQ_CURVE
// legacy ZMQ support
// inline incase the underlying assert is removed
bool ZMQ_CURVE = false;
#endif
assert (zsock_mechanism (remote) == ZMQ_CURVE);
zcert_destroy(&cert);
}
#endif
// Never block on sending; we use an infinite HWM and buffer as many
// messages as needed in outgoing pipes. Note that the maximum number
// is the overall tuple set size.
zsock_set_unbounded (remote);
if (zsock_connect (remote, "%s", endpoint)) {
zsys_warning ("bad zgossip endpoint '%s'", endpoint);
zsock_destroy (&remote);
return;
}
// Send HELLO and then PUBLISH for each tuple we have
zgossip_msg_t *gossip = zgossip_msg_new ();
zgossip_msg_set_id (gossip, ZGOSSIP_MSG_HELLO);
zgossip_msg_send (gossip, remote);
tuple_t *tuple = (tuple_t *) zhashx_first (self->tuples);
while (tuple) {
zgossip_msg_set_id (gossip, ZGOSSIP_MSG_PUBLISH);
zgossip_msg_set_key (gossip, tuple->key);
zgossip_msg_set_value (gossip, tuple->value);
zgossip_msg_send (gossip, remote);
tuple = (tuple_t *) zhashx_next (self->tuples);
}
// Now monitor this remote for incoming messages
zgossip_msg_destroy (&gossip);
engine_handle_socket (self, remote, remote_handler);
zlistx_add_end (self->remotes, remote);
}
JNIEXPORT jlong JNICALL
Java_org_zeromq_czmq_Zhashx__1_1next (JNIEnv *env, jclass c, jlong self)
{
jlong next_ = (jlong) (intptr_t) zhashx_next ((zhashx_t *) (intptr_t) self);
return next_;
}
///
// Simple iterator; returns next item in hash table, in no given order,
// or NULL if the last item was already returned. Use this together with
// zhashx_first() to process all items in a hash table. If you need the
// items in sorted order, use zhashx_keys() and then zlistx_sort(). To
// access the key for this item use zhashx_cursor(). NOTE: do NOT modify
// the table while iterating.
void * QZhashx::next ()
{
void * rv = zhashx_next (self);
return rv;
}
