yes i try i

Dockerfile

@@ -1,6 +1,11 @@
-FROM debian
+FROM debian as builder
 
 RUN apt update && apt upgrade -y
 RUN apt install -y libczmq-dev libguestfs-dev gcc valgrind gdb make pkg-config
 
+COPY . /opt
 WORKDIR /opt
+
+FROM builder as compile
+
+RUN make

Makefile

@@ -1,4 +1,5 @@
 build: daemon client
+debug: daemon-debug client-debug
 
 daemon:
 	gcc -ggdb3 -Wall guestfs-inspectd.c libguestfs-inspect.c -o guestfs-inspectd `pkg-config libguestfs libczmq --cflags --libs`

guestfs-inspectd.c

@@ -94,21 +94,20 @@ static void worker_task(zsock_t *pipe, char *disk_path) {
 
   g = init_guestfs(disk_path);
 
+  zsock_t *worker = zsock_new_dealer("inproc://workers");
+
   // ZeroMQ Opens here
   zsock_signal(pipe, 0);
+
   while (true) {
     zmsg_t *msg = zmsg_recv(pipe);
     if (!msg) {
       break;
     }
-    // Process message
-
-    // do something here
     printf("Received a message in the worker\n");
+    zframe_t *client_id = zmsg_pop(msg);
 
-    printf("Size: %zu\tContent size: %zu\n", zmsg_size(msg), zmsg_content_size(msg));
     struct guestfs_inpsect_command *command = guestfs_inspect_zmsg_to_command(msg);
-    printf("Size OF:: %zu\n", (sizeof(struct guestfs_inpsect_command)));
     zmsg_t *reply = zmsg_new();
     if (!reply) {
       printf("wuddahec\n");
@@ -116,75 +115,139 @@ static void worker_task(zsock_t *pipe, char *disk_path) {
     }
 
     switch (command->command) {
-    case GUESTFS_COMMAND_LS:
+      case GUESTFS_COMMAND_LS: printf("Enter ls command\n");
         zmsg_pushstr(reply, "From worker! -- not implemented");
         break;
-    case GUESTFS_COMMAND_CAT:
-      char *res;
-      size_t s;
-      puts("catting file...");
+      case GUESTFS_COMMAND_CAT: printf("Entering cat command\n");
+        char *res = NULL;
+        size_t s = 0;
         cat_file(g, command->args.cat.paths[0], &res, &s);
-      puts("Done catting file contents...");
         zmsg_addmem(reply, res, s);
         free(res);
         break;
+      default:
+	zmsg_pushstr(reply, "Unknown command");
+	break;
     }
 
     // Sending reply
-    zmsg_send(&reply, pipe);
+    zmsg_pushstr(reply, "");
+    zmsg_prepend(reply, &client_id);
+    zmsg_send(&reply, worker);
 
     guestfs_inspect_command_destroy(&command);
+    zframe_destroy(&client_id);
     zmsg_destroy(&msg);
     zmsg_destroy(&reply);
   }
 
+  zsock_destroy(&worker);
   guestfs_close(g);
   exit(EXIT_SUCCESS);
 }
 
+typedef struct {
+  char *name;
+  zactor_t *worker;
+} zactor_worker_map;
+
+void mapping_zactor_worker(char *name, zactor_t *worker, zactor_worker_map **map, size_t mapper_size) {
+
+  map[mapper_size - 1] = malloc(sizeof(zactor_worker_map));
+  (*map[mapper_size - 1]).name = strdup(name);
+  (*map[mapper_size - 1]).worker = worker;
+  printf("Registering inside mapper %s :: %p\n", name, worker);
+  return;
+}
+
+zactor_t * zactor_worker_lookup(char *name, zactor_worker_map **map, size_t mapper_size) {
+  size_t i = 0;
+  printf("inside lookup::%zu\n", mapper_size);
+  for (i = 0; i < mapper_size; i++) {
+    if (strcmp((*map[i]).name, name) == 0) {
+	printf("found at %zu\n", i);
+    	printf("found %p\n", map[i]->worker);
+	return map[i]->worker;
+    }
+  }
+  return NULL;
+}
+
 int main(int argc, char **argv) {
   if (argc < 2) {
     printf("Usage: %s <disk-path>:<name> ...\n", argv[0]);
     return EXIT_FAILURE;
   }
 
-  char *path = strtok(argv[1], ":");
-  char *name = strtok(NULL, ":");
-  printf("name: '%s'\n", name);
-  zactor_t *worker = zactor_new(worker_task, path);
+  // Zactor setup
+  size_t worker_map_size = 0;
+  zactor_worker_map **worker_map = malloc(sizeof(zactor_worker_map *) * worker_map_size);
 
+  for (int i = 0; i < argc - 1; i++) {
+    worker_map_size++;
+    worker_map = realloc(worker_map, sizeof(zactor_worker_map *) * worker_map_size);
+    char *path = strtok(argv[i+1], ":");
+    char *name = strtok(NULL, ":");
+    printf("--- Registering\n");
+    printf("name: '%s'\n", name);
+    printf("path: '%s'\n", path);
+    mapping_zactor_worker(name, zactor_new((void *)worker_task, path), worker_map, worker_map_size);
+  }
+
+  // Setup daemon ipc endpoint
   char *ep = guestfs_inspect_endpoint();
   printf("ep: %s\n", ep);
 
+  // Setup ZMQ routers
   zsock_t *frontend = zsock_new(ZMQ_ROUTER);
   zsock_bind(frontend, ep);
   free(ep);
 
+  zsock_t *backend = zsock_new(ZMQ_ROUTER);
+  zsock_bind(backend, "inproc://workers");
+
+  for (int i = 0; i < worker_map_size; i++) {
+    printf("Found:: %s :: %p\n", worker_map[i]->name, worker_map[i]->worker);
+  }
+
+  // Connecting frontend to backend
+  zpoller_t *poller = zpoller_new(frontend, backend, NULL);
+
   while (true) {
-    zmsg_t *msg = zmsg_recv(frontend);
-    if (!msg) {
+    void *sock = zpoller_wait(poller, -1);
+    if (!sock) {
       break;
     }
 
+    if (sock == frontend) {
+	zmsg_t *msg = zmsg_recv(frontend);
 	// reply id
-    char *id = zmsg_popstr(msg);
-    // null frame
+	zframe_t *identity = zmsg_pop(msg);
+	// Null frame
 	zmsg_pop(msg);
         struct guestfs_inpsect_command *c = guestfs_inspect_zmsg_to_command(msg);
 
-    if (STREQ(name, c->name)) {
+        zactor_t *zactor_tmp = zactor_worker_lookup(c->name, worker_map, worker_map_size);
+	if (zactor_tmp != NULL) {
           // send request to worker
-      printf("name equal\n");
-      zactor_send(worker, &msg);
-      
+	  zmsg_prepend(msg, &identity);
+	  zactor_send(zactor_tmp, &msg);
         } else {
-      printf("name not equal\n");
+	  // add failure responce
         }
 
-    /* zmsg_t *reply = zmsg_recv(frontend); */
+	zactor_tmp = NULL;
+	guestfs_inspect_command_destroy(&c);
+	zmsg_destroy(&msg);
+	zframe_destroy(&identity);
+    } else if (sock == backend) {
+	zmsg_t *msg = zmsg_recv(backend);
+	zmsg_pop(msg); // Removing backend id
+    	zmsg_send(&msg, frontend);
+	zmsg_destroy(&msg);
     }
-  
-  zactor_destroy(&worker);
+  }
+  //zactor_destroy(&worker);
   return EXIT_SUCCESS;
 }