static self_t *
s_self_new (zsock_t *pipe, zcertstore_t *certstore)
{
self_t *self = (self_t *) zmalloc (sizeof (self_t));
assert (self);
if (certstore) {
self->certstore = certstore;
self->allow_any = false;
}
self->pipe = pipe;
self->whitelist = zhashx_new ();
assert (self->whitelist);
self->blacklist = zhashx_new ();
// Create ZAP handler and get ready for requests
assert (self->blacklist);
self->handler = zsock_new (ZMQ_REP);
assert (self->handler);
int rc = zsock_bind (self->handler, ZAP_ENDPOINT);
assert (rc == 0);
self->poller = zpoller_new (self->pipe, self->handler, NULL);
assert (self->poller);
return self;
}
static int
server_initialize (server_t *self)
{
self->mailbox = zactor_new (mlm_mailbox_simple, NULL);
assert (self->mailbox);
self->streams = zhashx_new ();
assert (self->streams);
self->services = zhashx_new ();
assert (self->services);
self->clients = zhashx_new ();
assert (self->clients);
zhashx_set_destructor (self->streams, (czmq_destructor *) s_stream_destroy);
zhashx_set_destructor (self->services, (czmq_destructor *) s_service_destroy);
return 0;
}
zhashx_t *
zhashx_dup (zhashx_t *self)
{
if (!self)
return NULL;
zhashx_t *copy = zhashx_new ();
if (copy) {
copy->destructor = self->destructor;
copy->duplicator = self->duplicator;
uint index;
size_t limit = primes [self->prime_index];
for (index = 0; index < limit; index++) {
item_t *item = self->items [index];
while (item) {
if (zhashx_insert (copy, item->key, item->value)) {
zhashx_destroy (©);
break;
}
item = item->next;
}
}
}
return copy;
}
JNIEXPORT jlong JNICALL
Java_org_zeromq_czmq_Zhashx__1_1new (JNIEnv *env, jclass c)
{
// Disable CZMQ signal handling; allow Java to deal with it
zsys_handler_set (NULL);
jlong new_ = (jlong) (intptr_t) zhashx_new ();
return new_;
}
static int
server_initialize (server_t *self)
{
self->mailbox = zactor_new (mlm_mailbox_bounded, NULL);
assert (self->mailbox);
self->streams = zhashx_new ();
assert (self->streams);
self->services = zhashx_new ();
assert (self->services);
self->clients = zhashx_new ();
assert (self->clients);
zhashx_set_destructor (self->streams, (czmq_destructor *) s_stream_destroy);
zhashx_set_destructor (self->services, (czmq_destructor *) s_service_destroy);
zhashx_set_destructor (self->clients, (czmq_destructor *) s_client_local_destroy);
self->service_queue_cfg = mlm_msgq_cfg_new ("mlm_server/service/queue");
assert (self->service_queue_cfg);
return 0;
}
zhashx_t *
zhashx_unpack (zframe_t *frame)
{
zhashx_t *self = zhashx_new ();
if (!self)
return NULL;
assert (frame);
if (zframe_size (frame) < 4)
return self; // Arguable...
byte *needle = zframe_data (frame);
byte *ceiling = needle + zframe_size (frame);
size_t nbr_items = ntohl (*(uint32_t *) needle);
needle += 4;
while (nbr_items && needle < ceiling) {
// Get key as string
size_t key_size = *needle++;
if (needle + key_size <= ceiling) {
char key [256];
memcpy (key, needle, key_size);
key [key_size] = 0;
needle += key_size;
// Get value as longstr
if (needle + 4 <= ceiling) {
size_t value_size = ntohl (*(uint32_t *) needle);
needle += 4;
// Be wary of malformed frames
if (needle + value_size <= ceiling) {
char *value = (char *) zmalloc (value_size + 1);
if (!value) {
zhashx_destroy (&self);
return NULL;
}
memcpy (value, needle, value_size);
value [value_size] = 0;
needle += value_size;
// Hash takes ownership of value
if (zhashx_insert (self, key, value)) {
zhashx_destroy (&self);
break;
}
}
}
}
}
// Hash will free values in destructor
if (self)
zhashx_autofree (self);
return self;
}
static int
server_initialize (server_t *self)
{
self->xrap = (service_t *) zmalloc (sizeof (service_t));
assert (self->xrap);
self->xrap->get_routes = ztrie_new ('/');
self->xrap->post_routes = ztrie_new ('/');
self->xrap->put_routes = ztrie_new ('/');
self->xrap->delete_routes = ztrie_new ('/');
self->clients = zhashx_new ();
assert (self->clients);
return 0;
}
static self_t *
s_self_new (zsock_t *pipe)
{
self_t *self = (self_t *) zmalloc (sizeof (self_t));
int rc = -1;
if (self) {
self->pipe = pipe;
self->whitelist = zhashx_new ();
if (self->whitelist)
self->blacklist = zhashx_new ();
// Create ZAP handler and get ready for requests
if (self->blacklist)
self->handler = zsock_new (ZMQ_REP);
if (self->handler)
rc = zsock_bind (self->handler, ZAP_ENDPOINT);
if (rc == 0)
self->poller = zpoller_new (self->pipe, self->handler, NULL);
if (!self->poller)
s_self_destroy (&self);
}
return self;
}
zgtask_tree_t *
zgtask_tree_new (char *name, zgtask_tree_t *parent)
{
zgtask_tree_t *self = (zgtask_tree_t *) zmalloc (sizeof (zgtask_tree_t));
assert (self);
// Initialize properties
self->name = strdup (name);
self->data = zhashx_new ();
self->parent = parent;
self->child = 0;
self->brother = 0;
return self;
}
static int
server_initialize (server_t *self)
{
// Default timeout for clients is one second; the caller can
// override this with a SET message.
engine_configure (self, "server/timeout", "1000");
self->message = zgossip_msg_new ();
self->remotes = zlistx_new ();
assert (self->remotes);
zlistx_set_destructor (self->remotes, (czmq_destructor *) zsock_destroy_);
self->tuples = zhashx_new ();
assert (self->tuples);
return 0;
}
zcertstore_t *
zcertstore_new (const char *location)
{
zcertstore_t *self = (zcertstore_t *) zmalloc (sizeof (zcertstore_t));
assert (self);
self->certs = zhashx_new ();
assert (self->certs);
zhashx_set_destructor (self->certs, (czmq_destructor *) zcert_destroy);
if (location) {
self->location = strdup (location);
assert (self->location);
s_load_certs_from_disk (self);
}
return self;
}
zhashx_t *
ztrie_hit_parameters (ztrie_t *self)
{
assert (self);
if (self->match) {
zhashx_t *route_parameters = zhashx_new ();
ztrie_node_t *node = self->match;
while (node) {
int index;
for (index = 0; index < node->parameter_count; index++)
zhashx_insert (route_parameters,
node->parameter_names [index],
(void *) node->parameter_values [index]);
node = node->parent;
}
return route_parameters;
}
return NULL;
}
static int
server_initialize (server_t *self)
{
// Default timeout for clients is one second; the caller can
// override this with a SET message.
engine_configure (self, "server/timeout", "1000");
self->message = zgossip_msg_new ();
self->remotes = zlistx_new ();
assert (self->remotes);
zlistx_set_destructor (self->remotes, (czmq_destructor *) zsock_destroy);
self->tuples = zhashx_new ();
assert (self->tuples);
#ifdef CZMQ_BUILD_DRAFT_API
self->zap_domain = strdup(CZMQ_ZGOSSIP_ZAP_DOMAIN);
#endif
return 0;
}
zcertstore_t *
zcertstore_new (const char *location)
{
zcertstore_t *self = (zcertstore_t *) zmalloc (sizeof (zcertstore_t));
assert (self);
self->certs = zhashx_new ();
assert (self->certs);
zhashx_set_destructor (self->certs, (czmq_destructor *) zcert_destroy);
if (location) {
disk_loader_state *state = (disk_loader_state *) zmalloc (sizeof (disk_loader_state));
state->location = strdup (location);
assert (state->location);
state->modified = 0;
state->count = 0;
state->cursize = 0;
zcertstore_set_loader (self, s_disk_loader, s_disk_loader_state_destroy, (void *)state);
}
return self;
}
zcertstore_t *
zcertstore_new (const char *location)
{
zcertstore_t *self = (zcertstore_t *) zmalloc (sizeof (zcertstore_t));
if (!self)
return NULL;
self->certs = zhashx_new ();
if (self->certs) {
zhashx_set_destructor (self->certs, (czmq_destructor *) zcert_destroy);
if (location) {
self->location = strdup (location);
if (!self->location) {
zcertstore_destroy (&self);
return NULL;
}
s_load_certs_from_disk (self);
}
}
else
zcertstore_destroy (&self);
return self;
}
void
zhashx_test (int verbose)
{
printf (" * zhashx: ");
// @selftest
zhashx_t *hash = zhashx_new ();
assert (hash);
assert (zhashx_size (hash) == 0);
assert (zhashx_first (hash) == NULL);
assert (zhashx_cursor (hash) == NULL);
// Insert some items
int rc;
rc = zhashx_insert (hash, "DEADBEEF", "dead beef");
char *item = (char *) zhashx_first (hash);
assert (streq ((char *) zhashx_cursor (hash), "DEADBEEF"));
assert (streq (item, "dead beef"));
assert (rc == 0);
rc = zhashx_insert (hash, "ABADCAFE", "a bad cafe");
assert (rc == 0);
rc = zhashx_insert (hash, "C0DEDBAD", "coded bad");
assert (rc == 0);
rc = zhashx_insert (hash, "DEADF00D", "dead food");
assert (rc == 0);
assert (zhashx_size (hash) == 4);
// Look for existing items
item = (char *) zhashx_lookup (hash, "DEADBEEF");
assert (streq (item, "dead beef"));
item = (char *) zhashx_lookup (hash, "ABADCAFE");
assert (streq (item, "a bad cafe"));
item = (char *) zhashx_lookup (hash, "C0DEDBAD");
assert (streq (item, "coded bad"));
item = (char *) zhashx_lookup (hash, "DEADF00D");
assert (streq (item, "dead food"));
// Look for non-existent items
item = (char *) zhashx_lookup (hash, "foo");
assert (item == NULL);
// Try to insert duplicate items
rc = zhashx_insert (hash, "DEADBEEF", "foo");
assert (rc == -1);
item = (char *) zhashx_lookup (hash, "DEADBEEF");
assert (streq (item, "dead beef"));
// Some rename tests
// Valid rename, key is now LIVEBEEF
rc = zhashx_rename (hash, "DEADBEEF", "LIVEBEEF");
assert (rc == 0);
item = (char *) zhashx_lookup (hash, "LIVEBEEF");
assert (streq (item, "dead beef"));
// Trying to rename an unknown item to a non-existent key
rc = zhashx_rename (hash, "WHATBEEF", "NONESUCH");
assert (rc == -1);
// Trying to rename an unknown item to an existing key
rc = zhashx_rename (hash, "WHATBEEF", "LIVEBEEF");
assert (rc == -1);
item = (char *) zhashx_lookup (hash, "LIVEBEEF");
assert (streq (item, "dead beef"));
// Trying to rename an existing item to another existing item
rc = zhashx_rename (hash, "LIVEBEEF", "ABADCAFE");
assert (rc == -1);
item = (char *) zhashx_lookup (hash, "LIVEBEEF");
assert (streq (item, "dead beef"));
item = (char *) zhashx_lookup (hash, "ABADCAFE");
assert (streq (item, "a bad cafe"));
// Test keys method
zlistx_t *keys = zhashx_keys (hash);
assert (zlistx_size (keys) == 4);
zlistx_destroy (&keys);
zlistx_t *values = zhashx_values(hash);
assert (zlistx_size (values) == 4);
zlistx_destroy (&values);
// Test dup method
zhashx_t *copy = zhashx_dup (hash);
assert (zhashx_size (copy) == 4);
item = (char *) zhashx_lookup (copy, "LIVEBEEF");
assert (item);
assert (streq (item, "dead beef"));
zhashx_destroy (©);
// Test pack/unpack methods
zframe_t *frame = zhashx_pack (hash);
copy = zhashx_unpack (frame);
zframe_destroy (&frame);
assert (zhashx_size (copy) == 4);
item = (char *) zhashx_lookup (copy, "LIVEBEEF");
assert (item);
assert (streq (item, "dead beef"));
zhashx_destroy (©);
// Test save and load
zhashx_comment (hash, "This is a test file");
zhashx_comment (hash, "Created by %s", "czmq_selftest");
zhashx_save (hash, ".cache");
copy = zhashx_new ();
assert (copy);
zhashx_load (copy, ".cache");
item = (char *) zhashx_lookup (copy, "LIVEBEEF");
assert (item);
assert (streq (item, "dead beef"));
zhashx_destroy (©);
zsys_file_delete (".cache");
// Delete a item
zhashx_delete (hash, "LIVEBEEF");
item = (char *) zhashx_lookup (hash, "LIVEBEEF");
assert (item == NULL);
assert (zhashx_size (hash) == 3);
// Check that the queue is robust against random usage
struct {
char name [100];
bool exists;
} testset [200];
memset (testset, 0, sizeof (testset));
int testmax = 200, testnbr, iteration;
srandom ((unsigned) time (NULL));
for (iteration = 0; iteration < 25000; iteration++) {
testnbr = randof (testmax);
if (testset [testnbr].exists) {
item = (char *) zhashx_lookup (hash, testset [testnbr].name);
assert (item);
zhashx_delete (hash, testset [testnbr].name);
testset [testnbr].exists = false;
}
else {
sprintf (testset [testnbr].name, "%x-%x", rand (), rand ());
if (zhashx_insert (hash, testset [testnbr].name, "") == 0)
testset [testnbr].exists = true;
}
}
// Test 10K lookups
for (iteration = 0; iteration < 10000; iteration++)
item = (char *) zhashx_lookup (hash, "DEADBEEFABADCAFE");
// Destructor should be safe to call twice
zhashx_destroy (&hash);
zhashx_destroy (&hash);
assert (hash == NULL);
// Test autofree; automatically copies and frees string values
hash = zhashx_new ();
assert (hash);
zhashx_autofree (hash);
char value [255];
strcpy (value, "This is a string");
rc = zhashx_insert (hash, "key1", value);
assert (rc == 0);
strcpy (value, "Ring a ding ding");
rc = zhashx_insert (hash, "key2", value);
assert (rc == 0);
assert (streq ((char *) zhashx_lookup (hash, "key1"), "This is a string"));
assert (streq ((char *) zhashx_lookup (hash, "key2"), "Ring a ding ding"));
zhashx_destroy (&hash);
// @end
printf ("OK\n");
}
static int
s_self_handle_pipe (self_t *self)
{
// Get the whole message off the pipe in one go
zmsg_t *request = zmsg_recv (self->pipe);
if (!request)
return -1; // Interrupted
char *command = zmsg_popstr (request);
if (self->verbose)
zsys_info ("zauth: API command=%s", command);
if (streq (command, "ALLOW")) {
char *address = zmsg_popstr (request);
while (address) {
if (self->verbose)
zsys_info ("zauth: - whitelisting ipaddress=%s", address);
zhashx_insert (self->whitelist, address, "OK");
zstr_free (&address);
address = zmsg_popstr (request);
}
zsock_signal (self->pipe, 0);
}
else
if (streq (command, "DENY")) {
char *address = zmsg_popstr (request);
while (address) {
if (self->verbose)
zsys_info ("zauth: - blacklisting ipaddress=%s", address);
zhashx_insert (self->blacklist, address, "OK");
zstr_free (&address);
address = zmsg_popstr (request);
}
zsock_signal (self->pipe, 0);
}
else
if (streq (command, "PLAIN")) {
// Get password file and load into zhash table
// If the file doesn't exist we'll get an empty table
char *filename = zmsg_popstr (request);
zhashx_destroy (&self->passwords);
self->passwords = zhashx_new ();
if (zhashx_load (self->passwords, filename) && self->verbose)
zsys_info ("zauth: could not load file=%s", filename);
zstr_free (&filename);
zsock_signal (self->pipe, 0);
}
else
if (streq (command, "CURVE")) {
// If location is CURVE_ALLOW_ANY, allow all clients. Otherwise
// treat location as a directory that holds the certificates.
char *location = zmsg_popstr (request);
if (streq (location, CURVE_ALLOW_ANY))
self->allow_any = true;
else {
zcertstore_destroy (&self->certstore);
// FIXME: what if this fails?
self->certstore = zcertstore_new (location);
self->allow_any = false;
}
zstr_free (&location);
zsock_signal (self->pipe, 0);
}
else
if (streq (command, "GSSAPI"))
// GSSAPI authentication is not yet implemented here
zsock_signal (self->pipe, 0);
else
if (streq (command, "VERBOSE")) {
self->verbose = true;
zsock_signal (self->pipe, 0);
}
else
if (streq (command, "$TERM"))
self->terminated = true;
else {
zsys_error ("zauth: - invalid command: %s", command);
assert (false);
}
zstr_free (&command);
zmsg_destroy (&request);
return 0;
}
///
// Create a new, empty hash container
QZhashx::QZhashx (QObject *qObjParent) : QObject (qObjParent)
{
this->self = zhashx_new ();
}
