zmsg_t * zmsg_load (zmsg_t *self, FILE *file) { assert (file); if (!self) self = zmsg_new (); if (!self) return NULL; while (true) { size_t frame_size; size_t rc = fread (&frame_size, sizeof (frame_size), 1, file); if (rc == 1) { zframe_t *frame = zframe_new (NULL, frame_size); rc = fread (zframe_data (frame), frame_size, 1, file); if (frame_size > 0 && rc != 1) { zframe_destroy (&frame); break; // Unable to read properly, quit } zmsg_append (self, &frame); } else break; // Unable to read properly, quit } if (!zmsg_size (self)) { zmsg_destroy (&self); self = NULL; } return self; }
END_TEST // -------------------------------------------------------------------------- /// _pop () multiple times. Mainly used to test the garbage collection. START_TEST(test_msg_pop_successively) { sam_selftest_introduce ("test_msg_pop_successively"); zmsg_t *zmsg = zmsg_new (); zmsg_pushstr (zmsg, "three"); zmsg_pushstr (zmsg, "two"); zmsg_pushstr (zmsg, "one"); char payload = '0'; zframe_t *frame = zframe_new (&payload, sizeof (payload)); zmsg_push (zmsg, frame); sam_msg_t *msg = sam_msg_new (&zmsg); zframe_t *zero; char *one; int rc = sam_msg_pop (msg, "fs", &zero, &one); ck_assert_int_eq (rc, 0); ck_assert_int_eq (sam_msg_size (msg), 2); char *two, *three; rc = sam_msg_pop (msg, "ss", &two, &three); ck_assert_int_eq (rc, 0); ck_assert_int_eq (sam_msg_size (msg), 0); sam_msg_destroy (&msg); }
int main (int argc, char *argv []) { if (argc == 1) { printf ("I: syntax: %s <endpoint> ...\n", argv [0]); exit (EXIT_SUCCESS); } // Create new freelance client object flclient_t *client = flclient_new (); // Connect to each endpoint int argn; for (argn = 1; argn < argc; argn++) flclient_connect (client, argv [argn]); // Send a bunch of name resolution 'requests', measure time int requests = 10000; uint64_t start = s_clock (); while (requests--) { zmsg_t *request = zmsg_new ("random name"); zmsg_t *reply = flclient_request (client, &request); if (!reply) { printf ("E: name service not available, aborting\n"); exit (EXIT_FAILURE); } zmsg_destroy (&reply); } printf ("Average round trip cost: %d usec\n", (int) (s_clock () - start) / 10); flclient_destroy (&client); return 0; }
END_TEST // -------------------------------------------------------------------------- /// Try to _pop () a char pointer. START_TEST(test_msg_pop_s) { sam_selftest_introduce ("test_msg_pop_s"); zmsg_t *zmsg = zmsg_new (); char *str = "hi!"; int rc = zmsg_pushstr (zmsg, str); ck_assert_int_eq (rc, 0); sam_msg_t *msg = sam_msg_new (&zmsg); ck_assert_int_eq (sam_msg_size (msg), 1); char *ref; rc = sam_msg_pop (msg, "s", &ref); ck_assert_int_eq (rc, 0); ck_assert_str_eq (ref, str); ck_assert_int_eq (sam_msg_size (msg), 0); sam_msg_destroy (&msg); }
END_TEST // -------------------------------------------------------------------------- /// Try to _get () a void pointer. START_TEST(test_msg_get_p) { sam_selftest_introduce ("test_msg_get_p"); zmsg_t *zmsg = zmsg_new (); void *ptr = (void *) 0xfabfab; int rc = zmsg_pushmem (zmsg, &ptr, sizeof (ptr)); ck_assert_int_eq (rc, 0); sam_msg_t *msg = sam_msg_new (&zmsg); ck_assert_int_eq (sam_msg_size (msg), 1); void *ref; rc = sam_msg_get (msg, "p", &ref); ck_assert_int_eq (rc, 0); ck_assert_int_eq (sam_msg_size (msg), 1); ck_assert (ref == ptr); // check idempotency of _get () ref = NULL; rc = sam_msg_get (msg, "p", &ref); ck_assert_int_eq (rc, 0); ck_assert_int_eq (sam_msg_size (msg), 1); ck_assert (ref == ptr); sam_msg_destroy (&msg); }
END_TEST // -------------------------------------------------------------------------- /// Try to _get () a zlist_t * without any values START_TEST(test_msg_get_l_empty) { sam_selftest_introduce ("test_msg_get_l_empty"); zmsg_t *zmsg = zmsg_new (); if (zmsg_pushstr (zmsg, "0")) { ck_abort_msg ("could not build zmsg"); } sam_msg_t *msg = sam_msg_new (&zmsg); ck_assert_int_eq (sam_msg_size (msg), 1); zlist_t *list; int rc = sam_msg_get (msg, "l", &list); ck_assert_int_eq (rc, 0); ck_assert_int_eq (sam_msg_size (msg), 1); ck_assert_int_eq (zlist_size (list), 0); zlist_destroy (&list); sam_msg_destroy (&msg); }
static zmsg_t * server_method (server_t *self, const char *method, zmsg_t *msg) { // Connect to a remote zmsg_t *reply = NULL; if (streq (method, "CONNECT")) { char *endpoint = zmsg_popstr (msg); assert (endpoint); server_connect (self, endpoint); zstr_free (&endpoint); } else if (streq (method, "PUBLISH")) { char *key = zmsg_popstr (msg); char *value = zmsg_popstr (msg); server_accept (self, key, value); zstr_free (&key); zstr_free (&value); } else if (streq (method, "STATUS")) { // Return number of tuples we have stored reply = zmsg_new (); assert (reply); zmsg_addstr (reply, "STATUS"); zmsg_addstrf (reply, "%d", (int) zhash_size (self->tuples)); } else zsys_error ("unknown zgossip method '%s'", method); return reply; }
END_TEST // -------------------------------------------------------------------------- /// Try to _get () a char pointer. START_TEST(test_msg_get_s) { sam_selftest_introduce ("test_msg_get_s"); zmsg_t *zmsg = zmsg_new (); char *str = "hi!"; int rc = zmsg_pushstr (zmsg, str); ck_assert_int_eq (rc, 0); sam_msg_t *msg = sam_msg_new (&zmsg); ck_assert_int_eq (sam_msg_size (msg), 1); char *ref; rc = sam_msg_get (msg, "s", &ref); ck_assert_int_eq (rc, 0); ck_assert_int_eq (sam_msg_size (msg), 1); ck_assert_str_eq (ref, str); free (ref); // check idempotency of _get () ref = NULL; rc = sam_msg_get (msg, "s", &ref); ck_assert_int_eq (rc, 0); ck_assert_int_eq (sam_msg_size (msg), 1); ck_assert_str_eq (ref, str); free (ref); sam_msg_destroy (&msg); }
static int s_zap_request_reply (zap_request_t *self, char *status_code, char *status_text, unsigned char *metadata, size_t metasize) { if (self->verbose) zsys_info ("zauth: - ZAP reply status_code=%s status_text=%s", status_code, status_text); zmsg_t *msg = zmsg_new (); int rc = zmsg_addstr(msg, "1.0"); assert (rc == 0); rc = zmsg_addstr(msg, self->sequence); assert (rc == 0); rc = zmsg_addstr(msg, status_code); assert (rc == 0); rc = zmsg_addstr(msg, status_text); assert (rc == 0); rc = zmsg_addstr(msg, ""); assert (rc == 0); rc = zmsg_addmem(msg, metadata, metasize); assert (rc == 0); rc = zmsg_send(&msg, self->handler); assert (rc == 0); return 0; }
static void * client_task (void *args) { void *context = zmq_init (1); void *client = zmq_socket (context, ZMQ_XREQ); // Generate printable identity for the client char identity [5]; sprintf (identity, "%04X", randof (0x10000)); zmq_setsockopt (client, ZMQ_IDENTITY, identity, strlen (identity)); zmq_connect (client, "tcp://localhost:5570"); zmq_pollitem_t items [] = { { client, 0, ZMQ_POLLIN, 0 } }; int request_nbr = 0; while (1) { // Tick once per second, pulling in arriving messages int centitick; for (centitick = 0; centitick < 100; centitick++) { zmq_poll (items, 1, 10000); if (items [0].revents & ZMQ_POLLIN) { zmsg_t *zmsg = zmsg_recv (client); printf ("%s: %s\n", identity, zmsg_body (zmsg)); zmsg_destroy (&zmsg); } } zmsg_t *zmsg = zmsg_new (); zmsg_body_fmt (zmsg, "request #%d", ++request_nbr); zmsg_send (&zmsg, client); } // Clean up and end task properly zmq_close (client); zmq_term (context); return (NULL); }
static void handle_mmi (client_t *self, const char *service_name) { const char *result = "501"; zmsg_t *mmibody = mdp_msg_get_body(self->message); if(mmibody) { if(strstr(service_name, "mmi.service")) { char *svc_lookup = zmsg_popstr(mmibody); if(svc_lookup) { service_t *service = (service_t *) zhash_lookup(self->server->services, svc_lookup); result = service && service->workers ? "200" : "404"; zstr_free(&svc_lookup); } } zmsg_destroy(&mmibody); } // Set routing id, messageid, service, body mdp_msg_t *client_msg = mdp_msg_new(); mdp_msg_set_routing_id(client_msg, mdp_msg_routing_id(self->message)); mdp_msg_set_id(client_msg, MDP_MSG_CLIENT_FINAL); mdp_msg_set_service(client_msg, service_name); zmsg_t *rep_body = zmsg_new(); zmsg_pushstr(rep_body, result); mdp_msg_set_body(client_msg, &rep_body); mdp_msg_send(client_msg, self->server->router); mdp_msg_destroy(&client_msg); }
void send_czmq (char *buf, int len) { zctx_t *zctx; void *zs; zmsg_t *zmsg; if (!(zctx = zctx_new ())) log_err_exit ("C: zctx_new"); if (lopt) /* zctx linger default = 0 (flush none) */ zctx_set_linger (zctx, linger); if (!(zs = zsocket_new (zctx, ZMQ_DEALER))) log_err_exit ("C: zsocket_new"); //if (lopt) // doesn't work here // zsocket_set_linger (zs, linger); if (iopt) zsocket_set_immediate (zs, imm); //zsocket_set_sndhwm (zs, 0); /* unlimited */ if (zsocket_connect (zs, "%s", uri) < 0) log_err_exit ("C: zsocket_connect"); if (!(zmsg = zmsg_new ())) oom (); if (zmsg_pushmem (zmsg, buf, bufsize) < 0) oom (); if (zmsg_send (&zmsg, zs) < 0) log_err_exit ("C: zmsg_send"); if (sleep_usec > 0) usleep (sleep_usec); zctx_destroy (&zctx); }
zmsg_t * zmsg_recv (void *source) { assert (source); zmsg_t *self = zmsg_new (); if (!self) return NULL; while (true) { zframe_t *frame = zframe_recv (source); if (!frame) { if (errno == EINTR && zlist_head (self->frames)) continue; else { zmsg_destroy (&self); break; // Interrupted or terminated } } if (zmsg_append (self, &frame)) { zmsg_destroy (&self); break; } if (!zsock_rcvmore (source)) break; // Last message frame } return self; }
zmsg_t* kosmonaut_request(kosmonaut_t* self, char* request) { if (!request || !self) return NULL; zmq_pollitem_t items[] = {{self->req, 0, ZMQ_POLLOUT|ZMQ_POLLIN, 0}}; zmsg_t* res = NULL; zmsg_t* req = NULL; pthread_mutex_lock(&self->tmtx); int rc = zmq_poll(items, 1, REQUEST_TIMEOUT * ZMQ_POLL_MSEC); if (rc == 0 && items[0].revents & ZMQ_POLLOUT) { req = zmsg_new(); zmsg_addstr(req, request); zmsg_send(&req, self->req); zmsg_destroy(&req); rc = zmq_poll(items, 1, RESPONSE_TIMEOUT * ZMQ_POLL_MSEC); if (rc == 0 && items[0].revents & ZMQ_POLLIN) { res = zmsg_recv(self->req); } } pthread_mutex_lock(&self->tmtx); return res; }
static void _devio_destroy_smio_all (devio_t *self) { #if 0 unsigned i; for (i = 0; i < self->nnodes; ++i) { /* This cannot fail at this point... but it can */ zmsg_t *msg = zmsg_new (); /* An empty message means to selfdestruct */ zmsg_pushstr (msg, ""); zmsg_send (&msg, self->pipes [i]); } #endif /* Get all hash keys */ zlist_t *hash_keys = zhash_keys (self->sm_io_h); ASSERT_ALLOC (hash_keys, err_hash_keys_alloc); char *hash_item = zlist_first (hash_keys); /* Iterate over all keys removing each of one */ for (; hash_item != NULL; hash_item = zlist_next (hash_keys)) { /* FIXME: Usage of stroul fucntion for reconverting the string * into a uint32_t */ _devio_destroy_smio (self, (uint32_t) strtoul (hash_item, (char **) NULL, 16)); } zlist_destroy (&hash_keys); err_hash_keys_alloc: return; }
END_TEST // -------------------------------------------------------------------------- /// Test _free (). START_TEST(test_msg_free) { sam_selftest_introduce ("test_msg_free"); zmsg_t *zmsg = zmsg_new (); int rc = zmsg_pushstr (zmsg, "one"); ck_assert_int_eq (rc, 0); rc = zmsg_pushstr (zmsg, "two"); ck_assert_int_eq (rc, 0); sam_msg_t *msg = sam_msg_new (&zmsg); ck_assert_int_eq (sam_msg_size (msg), 2); char *pic_str; rc = sam_msg_pop (msg, "s", &pic_str); ck_assert_int_eq (rc, 0); ck_assert_int_eq (sam_msg_size (msg), 1); ck_assert_str_eq (pic_str, "two"); sam_msg_free (msg); rc = sam_msg_pop (msg, "s", &pic_str); ck_assert_int_eq (rc, 0); ck_assert_int_eq (sam_msg_size (msg), 0); ck_assert_str_eq (pic_str, "one"); sam_msg_destroy (&msg); }
static void _devio_destroy_smio (devio_t *self, uint32_t smio_id) { assert (self); /* Stringify ID */ char *key_c = halutils_stringify_key (smio_id); ASSERT_ALLOC (key_c, err_key_alloc); /* Lookup SMIO reference in hash table */ void *pipe = zhash_lookup (self->sm_io_h, key_c); ASSERT_TEST (pipe != NULL, "Could not find SMIO registered with this ID", err_hash_lookup); /* Send message to SMIO informing it to destroy itself */ /* This cannot fail at this point... but it can */ zmsg_t *send_msg = zmsg_new (); ASSERT_ALLOC (send_msg, err_msg_alloc); /* An empty message means to selfdestruct */ zmsg_pushstr (send_msg, ""); int zerr = zmsg_send (&send_msg, pipe); ASSERT_TEST (zerr == 0, "Could not send self-destruct message to SMIO instance", err_send_msg); /* Finally, remove the pipe from hash */ zhash_delete (self->sm_io_h, key_c); err_send_msg: zmsg_destroy (&send_msg); err_msg_alloc: err_hash_lookup: free (key_c); err_key_alloc: return; }
END_TEST // -------------------------------------------------------------------------- /// Try to _get () a zframe pointer. START_TEST(test_msg_get_f) { sam_selftest_introduce ("test_msg_get_f"); zmsg_t *zmsg = zmsg_new (); char payload = 'a'; zframe_t *frame = zframe_new (&payload, sizeof (payload)); int rc = zmsg_push (zmsg, frame); ck_assert_int_eq (rc, 0); sam_msg_t *msg = sam_msg_new (&zmsg); ck_assert_int_eq (sam_msg_size (msg), 1); zframe_t *ref; rc = sam_msg_get (msg, "f", &ref); ck_assert_int_eq (rc, 0); ck_assert_int_eq (sam_msg_size (msg), 1); ck_assert (zframe_eq (ref, frame)); zframe_destroy (&ref); // check idempotency of _get () rc = sam_msg_get (msg, "f", &ref); ck_assert_int_eq (rc, 0); ck_assert_int_eq (sam_msg_size (msg), 1); ck_assert (zframe_eq (ref, frame)); zframe_destroy (&ref); sam_msg_destroy (&msg); }
int mdp_client_send (mdp_client_t **self_p, void *socket) { assert (socket); assert (self_p); assert (*self_p); mdp_client_t *self = *self_p; // If we're sending to a ROUTER, we send the address first zmsg_t *msg = zmsg_new (); if (zsocket_type (socket) == ZMQ_ROUTER) { assert (self->address); zmsg_add (msg, self->address); self->address = NULL; // Owned by msg now } // Send header fields zmsg_addstr (msg, ""); zmsg_addstr (msg, "MDPC01"); // All messages have the same structure zmsg_addstr (msg, self->service); zmsg_add (msg, self->body); self->body = NULL; // Send the message and destroy mdp_client object int rc = zmsg_send (&msg, socket); mdp_client_destroy (self_p); return rc; }
END_TEST // -------------------------------------------------------------------------- /// Try to _pop () an integer. START_TEST(test_msg_pop_i) { sam_selftest_introduce ("test_msg_pop_i"); zmsg_t *zmsg = zmsg_new (); char *nbr = "1337"; int rc = zmsg_pushstr (zmsg, nbr); ck_assert_int_eq (rc, 0); sam_msg_t *msg = sam_msg_new (&zmsg); ck_assert_int_eq (sam_msg_size (msg), 1); int ref; rc = sam_msg_pop (msg, "i", &ref); ck_assert_int_eq (rc, 0); ck_assert_int_eq (ref, atoi (nbr)); ck_assert_int_eq (sam_msg_size (msg), 0); sam_msg_destroy (&msg); }
static void s_check_directory (s_agent_t *self) { // Get latest snapshot and build a patches list for any changes // All patches are built using a virtual path starting at "/" zdir_t *dir = zdir_new (self->path, NULL); zlist_t *patches = zdir_diff (self->dir, dir, "/"); // Drop old directory and replace with latest version zdir_destroy (&self->dir); self->dir = dir; while (zlist_size (patches)) { zdir_patch_t *patch = (zdir_patch_t *) zlist_pop (patches); if (zdir_patch_op (patch) == patch_create) { // Shout new files to DROPS group // Stupidest possible approach: send whole file as one frame // Truncate file at arbitrary limit of 10MB zfile_t *file = zdir_patch_file (patch); if (zfile_input (file) == 0) { zchunk_t *chunk = zfile_read (file, 10 * 1024 * 1024, 0); assert (chunk); zmsg_t *msg = zmsg_new (); zmsg_addstr (msg, "CREATE"); zmsg_addstr (msg, zdir_patch_vpath (patch)); zmsg_add (msg, zframe_new (zchunk_data (chunk), zchunk_size (chunk))); zchunk_destroy (&chunk); zyre_shout (self->zyre, "DROPS", &msg); } } zdir_patch_destroy (&patch); } zlist_destroy (&patches); }
END_TEST // -------------------------------------------------------------------------- /// Try to skip a value in _get () with '?'. START_TEST(test_msg_get_skipped) { sam_selftest_introduce ("test_msg_get_skipped"); zmsg_t *zmsg = zmsg_new (); int rc = zmsg_pushstr (zmsg, "foo"); ck_assert_int_eq (rc, 0); sam_msg_t *msg = sam_msg_new (&zmsg); ck_assert_int_eq (sam_msg_size (msg), 1); rc = sam_msg_get (msg, "?"); ck_assert_int_eq (rc, 0); ck_assert_int_eq (sam_msg_size (msg), 1); // check idempotency of _get () rc = sam_msg_get (msg, "?"); ck_assert_int_eq (rc, 0); ck_assert_int_eq (sam_msg_size (msg), 1); sam_msg_destroy (&msg); }
END_TEST // -------------------------------------------------------------------------- /// Test duplicating a sam_msg instance. START_TEST(test_msg_dup) { sam_selftest_introduce ("test_msg_dup"); zmsg_t *zmsg = zmsg_new (); zmsg_pushstr (zmsg, "payload"); sam_msg_t *msg = sam_msg_new (&zmsg); ck_assert_int_eq (sam_msg_size (msg), 1); sam_msg_t *dup = sam_msg_dup (msg); sam_msg_destroy (&msg); char *payload; sam_msg_pop (dup, "s", &payload); ck_assert_str_eq (payload, "payload"); sam_msg_destroy (&dup); }
static void zmqwriter (flux_reactor_t *r, flux_watcher_t *w, int revents, void *arg) { void *sock = flux_zmq_watcher_get_zsock (w); static int count = 0; if (revents & FLUX_POLLERR) { fprintf (stderr, "%s: FLUX_POLLERR is set\n", __FUNCTION__); goto error; } if (revents & FLUX_POLLOUT) { uint8_t blob[64]; zmsg_t *zmsg = zmsg_new (); if (!zmsg || zmsg_addmem (zmsg, blob, sizeof (blob)) < 0) { fprintf (stderr, "%s: failed to create message: %s\n", __FUNCTION__, strerror (errno)); goto error; } if (zmsg_send (&zmsg, sock) < 0) { fprintf (stderr, "%s: zmsg_send: %s\n", __FUNCTION__, strerror (errno)); goto error; } count++; if (count == zmqwriter_msgcount) flux_watcher_stop (w); } return; error: flux_reactor_stop_error (r); }
END_TEST // -------------------------------------------------------------------------- /// Try to _pop () a zframe pointer. START_TEST(test_msg_pop_f) { sam_selftest_introduce ("test_msg_pop_f"); zmsg_t *zmsg = zmsg_new (); char payload = 'a'; zframe_t *frame = zframe_new (&payload, sizeof (payload)), *ref = zframe_dup (frame); int rc = zmsg_push (zmsg, frame); ck_assert_int_eq (rc, 0); sam_msg_t *msg = sam_msg_new (&zmsg); ck_assert_int_eq (sam_msg_size (msg), 1); zframe_t *popped; rc = sam_msg_pop (msg, "f", &popped); ck_assert_int_eq (rc, 0); ck_assert (zframe_eq (ref, popped)); ck_assert_int_eq (sam_msg_size (msg), 0); zframe_destroy (&ref); sam_msg_destroy (&msg); }
void val_msg(void* line_in, char * msg, int k) { zmsg_t * n = zmsg_new(); zmsg_pushstr(n, "foo"); // pushmem appears to copy the data. zmsg_pushmem(n, &k,sizeof(int)); zmsg_send(&n, line_in); }
END_TEST // -------------------------------------------------------------------------- /// Test successive _size () calls in combination with _pop (). START_TEST(test_msg_size_successively) { sam_selftest_introduce ("test_msg_size_successively"); zmsg_t *zmsg = zmsg_new (); zmsg_pushstr (zmsg, "something"); zmsg_pushstr (zmsg, "something"); sam_msg_t *msg = sam_msg_new (&zmsg); ck_assert_int_eq (sam_msg_size (msg), 2); char *buf; int rc = sam_msg_pop (msg, "s", &buf); ck_assert_int_eq (rc, 0); ck_assert_int_eq (sam_msg_size (msg), 1); sam_msg_free (msg); rc = sam_msg_pop (msg, "s", &buf); ck_assert_int_eq (rc, 0); ck_assert_int_eq (sam_msg_size (msg), 0); sam_msg_destroy (&msg); }
void read_serial(void * cvoid, zctx_t * context, void * pipe) { char * buf; serialconfig_t * config = (serialconfig_t*)cvoid; FILE * in = config->in; // fopen("/dev/ttyO1", "r"); size_t nbytes=2047; // Prepare our context and publisher buf = (char *) malloc(nbytes+1) ; fprintf(stderr, "bound\n"); // first line is always garbage getline(&buf, &nbytes, in); child_handshake(pipe); zsocket_destroy(context, pipe); void* socket = zsocket_new(context, ZMQ_PUB); zsocket_bind(socket, "inproc://raw_serial"); while ( getline(&buf, &nbytes, in) != -1 ) { #ifdef DEBUG puts("line:"); puts(buf); #endif zmsg_t * msg = zmsg_new(); zmsg_pushstr(msg, buf); // does buf need to be copied? zmsg_send(&msg, socket); } fprintf(stderr, "error reading from stdin\n"); zsocket_destroy(context, socket); }
int main (void) { // Create new freelance client object flcliapi_t *client = flcliapi_new (); // Connect to several endpoints flcliapi_connect (client, "tcp://localhost:5555"); flcliapi_connect (client, "tcp://localhost:5556"); flcliapi_connect (client, "tcp://localhost:5557"); // Send a bunch of name resolution 'requests', measure time int requests = 1000; uint64_t start = zclock_time (); while (requests--) { zmsg_t *request = zmsg_new (); zmsg_addstr (request, "random name"); zmsg_t *reply = flcliapi_request (client, &request); if (!reply) { printf ("E: name service not available, aborting\n"); break; } zmsg_destroy (&reply); } printf ("Average round trip cost: %d usec\n", (int) (zclock_time () - start) / 10); flcliapi_destroy (&client); return 0; }
static ssize_t _thsafe_zmq_client_read_generic (smio_t *self, loff_t offs, uint8_t *data, uint32_t size) { assert (self); ssize_t ret_size = -1; zmsg_t *send_msg = zmsg_new (); ASSERT_ALLOC(send_msg, err_msg_alloc); uint32_t opcode; DBE_DEBUG (DBG_MSG | DBG_LVL_TRACE, "[smio_thsafe_client:zmq] Calling _thsafe_read_generic\n"); switch (size) { case THSAFE_READ_16_DSIZE: opcode = THSAFE_READ_16; break; case THSAFE_READ_32_DSIZE: opcode = THSAFE_READ_32; break; case THSAFE_READ_64_DSIZE: opcode = THSAFE_READ_64; break; default: opcode = THSAFE_READ_32; } /* Message is: * frame 0: READ<size> opcode * frame 1: offset */ int zerr = zmsg_addmem (send_msg, &opcode, sizeof (opcode)); ASSERT_TEST(zerr == 0, "Could not add READ opcode in message", err_add_opcode); zerr = zmsg_addmem (send_msg, &offs, sizeof (offs)); ASSERT_TEST(zerr == 0, "Could not add offset in message", err_add_offset); DBE_DEBUG (DBG_MSG | DBG_LVL_TRACE, "[smio_thsafe_client:zmq] Sending message:\n"); #ifdef LOCAL_MSG_DBG zmsg_print (send_msg); #endif zerr = zmsg_send (&send_msg, self->pipe); ASSERT_TEST(zerr == 0, "Could not send message", err_send_msg); /* Message is: * frame 0: reply code * frame 1: return code * frame 2: data */ ret_size = _thsafe_zmq_client_recv_read (self, data, size); err_send_msg: err_add_offset: err_add_opcode: zmsg_destroy (&send_msg); err_msg_alloc: return ret_size; }