testing errors

Get things working before scaling it up

Makefile

@@ -2,6 +2,6 @@ daemon:
 	gcc guestfs-inspectd.c -o guestfs-inspectd `pkg-config libguestfs libczmq --cflags --libs`
 
 client:
-	gcc guestfs-inspect.c -o guestfs-inspect `pkg-config libguestfs libczmq --cflags --libs`
+	gcc -g guestfs-inspect.c -o guestfs-inspect `pkg-config libguestfs libczmq --cflags --libs`
 
 build: daemon client

guestfs-inspect.c

@@ -8,6 +8,7 @@
 #define STREQ(a, b) (strcmp((a), (b)) == 0)
 
 void print_help(char *);
+enum guestfs_inspect_command_const parse_command(char *);
 
 int main(int argc, char **argv) {
   if (argc == 1) {
@@ -18,7 +19,51 @@ int main(int argc, char **argv) {
   char *ep = endpoint();
   zsock_t *daemon = zsock_new_req(ep);
   free(ep);
-  
+
+  struct guestfs_inpsect_command *command = malloc(sizeof(struct guestfs_inpsect_command));
+  command->name = calloc(strlen(argv[1]) + 1, sizeof(char));
+  strcpy(command->name, argv[1]);
+  command->command = parse_command(argv[2]);
+
+  switch (command->command) {
+  case GUESTFS_COMMAND_LS:
+    command->args.ls.paths_length = 1;
+    command->args.ls.paths = calloc(1, sizeof(char *));
+    command->args.ls.paths[0] = calloc(strlen(argv[3] + 1), sizeof(char));
+    strcpy(command->args.ls.paths[0], argv[3]);
+    break;
+  case GUESTFS_COMMAND_CAT:
+    command->args.cat.paths_length = 1;
+    command->args.cat.paths = calloc(1, sizeof(char *));
+    command->args.cat.paths[0] = calloc(strlen(argv[3] + 1), sizeof(char));
+    strcpy(command->args.cat.paths[0], argv[3]);
+    break;
+  }
+
+  zmsg_t *msg = command_to_zmsg(command);
+  zmsg_send(&msg, daemon);
+  zmsg_t *rep = zmsg_recv(daemon);
+
+  char *res = NULL;
+  // process reply
+  switch (command->command) {
+  case GUESTFS_COMMAND_LS:
+    res = zmsg_popstr(rep);
+    printf("Res:\n%s\n", res);
+    free(res);
+    break;
+  case GUESTFS_COMMAND_CAT:
+    res = zmsg_popstr(rep);
+    printf("Res:\n%s\n", res);
+    free(res);
+    break;
+  }
+
+  zmsg_destroy(&msg);
+  zmsg_destroy(&rep);
+  zsock_destroy(&daemon);
+  command_destroy(&command);
+
   return EXIT_SUCCESS;
 }
 
@@ -28,3 +73,13 @@ void print_help(char *name) {
   printf("  ls  <path>\n");
   printf("  cat <path>\n");
 }
+
+enum guestfs_inspect_command_const parse_command(char *input) {
+  if (STREQ(input, "ls")) {
+    return GUESTFS_COMMAND_LS;
+  } else if (STREQ(input, "cat")) {
+    return GUESTFS_COMMAND_CAT;
+  }
+
+  exit(EXIT_FAILURE);
+}

guestfs-inspectd.c

@@ -3,6 +3,7 @@
 #include <string.h>
 #include <czmq.h>
 #include <zactor.h>
+#include <zmsg.h>
 #include <guestfs.h>
 
 #include "libguestfs-inspect.h"
@@ -28,6 +29,7 @@ static int count_mountpoints(char *const *argv) {
 
 static void cat_file(guestfs_h *g, char *file_path, char **file_content, size_t *file_size) {
   if (guestfs_is_file_opts(g, file_path, GUESTFS_IS_FILE_OPTS_FOLLOWSYMLINKS, 1, -1) > 0) {
+    printf("path:: %s\n", file_path);
     (*file_content) = guestfs_read_file(g, file_path, file_size);
     if ((*file_content) == NULL) {
       exit(EXIT_FAILURE);
@@ -36,32 +38,29 @@ static void cat_file(guestfs_h *g, char *file_path, char **file_content, size_t
   return;
 }
 
-static void init_guestfs(guestfs_h **g, char *disk_path) {
+static void init_guestfs(guestfs_h *g, char *disk_path) {
   char **roots, **mountpoints;
   char *root;
   size_t i, j;
 
-  //char *file_content;
-  //size_t file_size;
-
   // Create a connection handle
-  (*g) = guestfs_create();
+  g = guestfs_create();
   if (g == NULL) {
     exit(EXIT_FAILURE);
   }
 
   // Adding disk_path to connection handle
-  if (guestfs_add_drive_opts((*g), disk_path, GUESTFS_ADD_DRIVE_OPTS_READONLY, 1, -1) == -1) {
+  if (guestfs_add_drive_opts(g, disk_path, GUESTFS_ADD_DRIVE_OPTS_READONLY, 1, -1) == -1) {
     exit(EXIT_FAILURE);
   }
 
   // Launching connection handle
-  if (guestfs_launch((*g)) == -1) {
+  if (guestfs_launch(g) == -1) {
     exit(EXIT_FAILURE);
   }
 
   // Pulling rootfs information
-  roots = guestfs_inspect_os((*g));
+  roots = guestfs_inspect_os(g);
   if (roots == NULL) {
     exit(EXIT_FAILURE);
   }
@@ -69,14 +68,14 @@ static void init_guestfs(guestfs_h **g, char *disk_path) {
   // Looping through roots to mount mountpoints
   for (j = 0; roots[j] != NULL; j++) {
     root = roots[j];
-    mountpoints = guestfs_inspect_get_mountpoints((*g), root);
+    mountpoints = guestfs_inspect_get_mountpoints(g, root);
     if (mountpoints == NULL) {
       exit(EXIT_FAILURE);
     }
     // Sorting mountpoints to be in {'${device_path}', '${mount_path}'} format
     qsort(mountpoints, count_mountpoints(mountpoints) / 2, 2 * sizeof (char*), compare_key_len);
       for (i = 0; mountpoints[i] != NULL; i += 2) {
-        guestfs_mount_ro((*g), mountpoints[i+1], mountpoints[i]);
+        guestfs_mount_ro(g, mountpoints[i+1], mountpoints[i]);
         free(mountpoints[i]);
         free(mountpoints[i+1]);
       }
@@ -84,14 +83,15 @@ static void init_guestfs(guestfs_h **g, char *disk_path) {
       free(root);
   }
   free(roots);
+
+  printf("Finished initializing guestfs\n");
 }
 
 static void *worker_task(zsock_t *pipe, char *disk_path) {
   guestfs_h *g = NULL;
 
-  init_guestfs(&g, disk_path);
+  //init_guestfs(g, disk_path);
 
-  /*
   // ZeroMQ Opens here
   zsock_signal(pipe, 0);
   while (true) {
@@ -102,12 +102,42 @@ static void *worker_task(zsock_t *pipe, char *disk_path) {
     // Process message
 
     // do something here
+    printf("Received a message in the worker\n");
+
+    printf("Size: %zu\tContent size: %zu\n", zmsg_size(msg), zmsg_content_size(msg));
+    struct guestfs_inpsect_command *command = zmsg_to_command(msg);
+    zmsg_t *reply = zmsg_new();
+    if (!reply) {
+      printf("wuddahec\n");
+      exit(EXIT_FAILURE);
+    }
+
+    switch (command->command) {
+    case GUESTFS_COMMAND_LS:
+      zmsg_pushstr(reply, "From worker!");
+      break;
+    case GUESTFS_COMMAND_CAT:
+      char *res;
+      size_t s;
+      puts("catting file...");
+      //cat_file(g, command->args.cat.paths[0], &res, &s);
+      init_guestfs(g, disk_path);
+      printf("STATUS::%d\n", guestfs_get_state(g));
+      if(guestfs_is_file_opts(g, "/etc/os-release", GUESTFS_IS_FILE_OPTS_FOLLOWSYMLINKS, 1, -1) > 0) {
+        res = guestfs_read_file(g, "/etc/os-release", &s);
+      }
+      puts("Done catting file contents...");
+      zmsg_addmem(reply, res, s);
+      break;
+    }
 
     // Sending reply
-    zmsg_send(&msg, pipe);
+    zmsg_send(&reply, pipe);    
+
+    command_destroy(&command);
     zmsg_destroy(&msg);
+    zmsg_destroy(&reply);
   }
-  */
 
   guestfs_close(g);
   exit(EXIT_SUCCESS);
@@ -119,45 +149,17 @@ int main(int argc, char **argv) {
     return EXIT_FAILURE;
   }
 
-  const int worker_count = argc - 1;
-
-  // One worker per disk image.
-  struct {
-    char *name;
-    zactor_t *worker;
-  } worker_map[worker_count];
-
-  for (int i = 0; i < worker_count; i++) {
-    char *path = strtok(argv[i+1], ":");
-    worker_map[i].name = strtok(NULL, ":");
-    worker_map[i].worker = zactor_new(worker_task, path);
-  }
+  char *path = strtok(argv[1], ":");
+  char *name = strtok(NULL, ":");
+  printf("name: '%s'\n", name);
 
   char *ep = endpoint();
-  zsock_t *frontend = zsock_new_router(ep);
+  printf("ep: %s\n", ep);
+  zsock_t *worker = zsock_new_rep(ep);
   free(ep);
 
-  while (true) {
-    zmsg_t *msg = zmsg_recv(frontend);
+  worker_task(worker, path);
 
-    if (!msg) break;
-
-    // Find the worker with the given name.
-    zactor_t *worker = NULL;
-    struct guestfs_inpsect_command *cmd = (struct guestfs_inpsect_command *) zmsg_last(msg);
-    for (int i = 0; i < worker_count; i++) {
-      if (STREQ(cmd->name, worker_map[i].name)) {
-        worker = worker_map[i].name;
-        break;
-      }
-    }
-    if (worker) {
-      zmsg_send(&msg, zactor_sock(worker));
-    } else {
-      // The name specified does not exist.
-      printf("There is no drive with the name %s\n.", cmd->name);
-    }
-  }
   return EXIT_SUCCESS;
 }
 

libguestfs-inspect.h

@@ -1,4 +1,6 @@
-enum guestfs_inspect_command {
+#include <czmq.h>
+
+enum guestfs_inspect_command_const {
   GUESTFS_COMMAND_LS,
   /* GUESTFS_COMMAND_TOUCH, */
   /* GUESTFS_COMMAND_MKDIR, */
@@ -6,19 +8,21 @@ enum guestfs_inspect_command {
 };
 
 struct guestfs_ls_args {
-  size_t path_length;
-  char path[];
+  size_t paths_length;
+  char **paths;
+};
+struct guestfs_cat_args {
+  size_t paths_length;
+  char **paths;  
 };
-struct guestfs_cat_args {};
 
 struct guestfs_inpsect_command {
-  enum guestfs_inspect_command command;
+  char *name;
+  enum guestfs_inspect_command_const command;
   union {
     struct guestfs_ls_args ls;
     struct guestfs_cat_args cat;
   } args;
-  size_t name_length;
-  char name[];
 };
 
 static char *endpoint() {
@@ -29,3 +33,84 @@ static char *endpoint() {
   return res;
 }
 
+static zmsg_t *command_to_zmsg(struct guestfs_inpsect_command *command) {
+  zmsg_t *res = zmsg_new();
+
+  zmsg_addstr(res, command->name);
+  zmsg_addmem(res, &(command->command), sizeof(command->command));
+
+  switch (command->command) {
+  case GUESTFS_COMMAND_LS:
+    zmsg_addmem(res, &(command->args.ls.paths_length), sizeof(command->args.ls.paths_length));
+
+    for (size_t i = 0; i < (command->args.ls.paths_length); i++) {
+      zmsg_addstr(res, command->args.ls.paths[i]);
+    }
+    break;
+  case GUESTFS_COMMAND_CAT:
+    zmsg_addmem(res, &(command->args.cat.paths_length), sizeof(command->args.cat.paths_length));
+
+    for (size_t i = 0; i < (command->args.cat.paths_length); i++) {
+      zmsg_addstr(res, command->args.cat.paths[i]);
+    }
+    break;
+  }
+
+  return res;
+}
+
+static struct guestfs_inpsect_command *zmsg_to_command(zmsg_t *msg) {
+  struct guestfs_inpsect_command *res = malloc(sizeof(struct guestfs_inpsect_command));
+
+  res->name = zmsg_popstr(msg);
+  zframe_t *next = zmsg_pop(msg);
+  res->command = *(zframe_data(next));
+  free(next);
+  
+  switch (res->command) {
+  case GUESTFS_COMMAND_LS:
+    next = zmsg_pop(msg);
+    res->args.ls.paths_length = *(zframe_data(next));
+    free(next);
+
+    res->args.ls.paths = calloc(res->args.ls.paths_length, sizeof(char *));
+
+    for (size_t i = 0; i < res->args.ls.paths_length; i++) {
+      res->args.ls.paths[i] = zmsg_popstr(msg);
+    }
+    break;
+  case GUESTFS_COMMAND_CAT:
+    next = zmsg_pop(msg);
+    res->args.cat.paths_length = *(zframe_data(next));
+    free(next);
+
+    res->args.cat.paths = calloc(res->args.cat.paths_length, sizeof(char *));
+
+    for (size_t i = 0; i < res->args.cat.paths_length; i++) {
+      res->args.cat.paths[i] = zmsg_popstr(msg);
+    }
+    break;
+  }
+  return res;
+}
+
+static void command_destroy(struct guestfs_inpsect_command **c) {
+  free((*c)->name);
+  switch ((*c)->command) {
+  case GUESTFS_COMMAND_LS:
+    for (size_t i = 0; i < (*c)->args.ls.paths_length; i++) {
+      free((*c)->args.ls.paths[i]);
+    }
+    free((*c)->args.ls.paths);
+    break;
+  case GUESTFS_COMMAND_CAT:
+    for (size_t i = 0; i < (*c)->args.cat.paths_length; i++) {
+      free((*c)->args.cat.paths[i]);
+    }
+    free((*c)->args.cat.paths);
+    break;
+  }
+  
+  free(*c);
+  *c = NULL;
+}