sample worker task

.gitignore

@@ -2,4 +2,3 @@ guestfs-inspect
 guestfs-inspectd
 *~
 *.qcow2
-venv/

Dockerfile

@@ -1,11 +1,3 @@
-FROM debian as builder
+FROM debian
 
-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
+RUN apt update && apt upgrade -y && apt install -y libczmq-dev libguestfs-dev gcc valgrind gdb make

Makefile

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

README.md

@@ -1,17 +0,0 @@
-# Edda
-
-```
-
-   ,ggggggg,
- ,dP""""""Y8b         8I          8I
- d8'    a  Y8         8I          8I
- 88     "Y8P'         8I          8I
- `8baaaa              8I          8I
-,d8P""""        ,gggg,8I    ,gggg,8I    ,gggg,gg
-d8"            dP"  "Y8I   dP"  "Y8I   dP"  "Y8I
-Y8,           i8'    ,8I  i8'    ,8I  i8'    ,8I
-`Yba,,_____, ,d8,   ,d8b,,d8,   ,d8b,,d8,   ,d8b,
-  `"Y8888888 P"Y8888P"`Y8P"Y8888P"`Y8P"Y8888P"`Y8
-
-```
-

client.py

@@ -1,21 +0,0 @@
-import zmq
-
-context = zmq.Context()
-socket = context.socket(zmq.REQ)
-socket.connect('ipc:///run/user/1000/guestfs-inspect.sock')
-
-tt = 1
-tt_size = 1
-
-message = "test"
-socket.send(message.encode('utf-8'), flags=zmq.SNDMORE)
-socket.send(tt.to_bytes(4, 'little'), flags=zmq.SNDMORE)
-socket.send(tt_size.to_bytes(8, 'little'), flags=zmq.SNDMORE)
-socket.send('/etc/os-release'.encode('utf-8'), flags=zmq.SNDMORE)
-socket.send(''.encode('utf-8'))
-
-message = socket.recv()
-print(message.decode('utf-8'))
-
-socket.close()
-context.destroy()

guestfs-inspect.c

@@ -1,85 +0,0 @@
-#include <stdio.h>
-#include <stdlib.h>
-#include <czmq.h>
-#include <guestfs.h>
-
-#include "libguestfs-inspect.h"
-
-#define STREQ(a, b) (strcmp((a), (b)) == 0)
-
-void print_help(char *);
-enum guestfs_inspect_command_const parse_command(const char *);
-
-int main(int argc, char **argv) {
-  if (argc == 1) {
-    print_help(argv[0]);
-    return EXIT_SUCCESS;
-  }
-
-  char *ep = guestfs_inspect_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 = guestfs_inspect_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);
-  guestfs_inspect_command_destroy(&command);
-
-  return EXIT_SUCCESS;
-}
-
-void print_help(char *name) {
-  printf("Usage: %s [name] [command] <arguments>\n", name);
-  printf("Commands:\n");
-  printf("  ls  <path>\n");
-  printf("  cat <path>\n");
-}
-
-enum guestfs_inspect_command_const parse_command(const 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

@@ -2,321 +2,105 @@
 #include <stdlib.h>
 #include <string.h>
 #include <czmq.h>
-#include <zmsg.h>
 #include <zactor.h>
 #include <guestfs.h>
-#include <time.h>
-
-#include "libguestfs-inspect.h"
-
-#define STREQ(a, b) (strcmp((a), (b)) == 0)
-
-static void worker_task(zsock_t*, const char*);
-
-static int compare_key_len(const void*, const void*);
-static int count_mountpoints(char *const *argv);
 
 static int compare_key_len(const void *p1, const void *p2) {
-  const char *key1 = *(char* const*) p1;
-  const char *key2 = *(char* const*) p2;
-  return strlen(key1) - strlen(key2);
-}
-
-static void print_intro() {
-  printf("\n"
-"\n"
-"   ,ggggggg,\n"
-" ,dP\"\"\"\"\"\"Y8b         8I          8I\n"
-" d8'    a  Y8         8I          8I\n"
-" 88     \"Y8P\'         8I          8I\n"
-" `8baaaa              8I          8I\n"
-",d8P\"\"\"\"        ,gggg,8I    ,gggg,8I    ,gggg,gg\n"
-"d8\"            dP\"  \"Y8I   dP\"  \"Y8I   dP\"  \"Y8I\n"
-"Y8,           i8'    ,8I  i8'    ,8I  i8'    ,8I\n"
-"`Yba,,_____, ,d8,   ,d8b,,d8,   ,d8b,,d8,   ,d8b,\n"
-"  `\"Y8888888 P\"Y8888P\"`Y8P\"Y8888P\"`Y8P\"Y8888P\"`Y8\n"
-"\n");
-
+        const char *key1 = *(char* const*) p1;
+        const char *key2 = *(char* const*) p2;
+        return strlen(key1) - strlen(key2);
 }
 
 static int count_mountpoints(char *const *argv) {
-  size_t c;
-  for (c = 0; argv[c]; c++) {}
-  return c;
+        size_t c;
+        for (c = 0; argv[c]; c++) {}
+        return c;
 }
 
-static void cat_file(guestfs_h *g, const char *file_path, char **file_content, size_t *file_size) {
-  assert((*file_content) == NULL);
-  if (guestfs_is_file_opts(g, file_path, GUESTFS_IS_FILE_OPTS_FOLLOWSYMLINKS, 1, -1) > 0) {
-    (*file_content) = guestfs_read_file(g, file_path, file_size);
-    if ((*file_content) == NULL) {
-      exit(EXIT_FAILURE);
-    }
-  }
-  return;
+static void worker_task(char *disk_path, char *file_path) {
+        guestfs_h *g;
+        char **roots, **mountpoints;
+        char *root;
+        size_t i, j;
+
+        char *file_content;
+        size_t file_size;
+
+        g = guestfs_create();
+        if (g == NULL) {
+                exit(EXIT_FAILURE);
+        }
+
+        if (guestfs_add_drive_opts(g, disk_path,
+                                   GUESTFS_ADD_DRIVE_OPTS_READONLY, 1,
+                                   -1) == -1) {
+                exit(EXIT_FAILURE);
+        }
+
+        if (guestfs_launch(g) == -1) {
+                exit(EXIT_FAILURE);
+        }
+
+        roots = guestfs_inspect_os(g);
+
+        if (roots == NULL) {
+                exit(EXIT_FAILURE);
+        }
+
+        for (j = 0; roots[j] != NULL; j++) {
+                root = roots[j];
+                mountpoints = guestfs_inspect_get_mountpoints(g, root);
+                if (mountpoints == NULL) {
+                        exit(EXIT_FAILURE);
+                }
+                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]);
+                        free(mountpoints[i]);
+                        free(mountpoints[i+1]);
+                }
+                free(mountpoints);
+
+                if (guestfs_is_file_opts(g, file_path, GUESTFS_IS_FILE_OPTS_FOLLOWSYMLINKS, 1, -1) > 0) {
+                        printf("--- %s ---\n", file_path);
+                        file_content = guestfs_read_file(g, file_path, &file_size);
+                        if (file_content == NULL) {
+                                exit(EXIT_FAILURE);
+                        }
+                        printf("%s\n", file_content);
+                        free(file_content);
+                }
+        }
+
+        return;
 }
 
-static guestfs_h* init_guestfs(const char *disk_path) {
-  guestfs_h *g = NULL;
-  char **roots, **mountpoints;
-  char *root;
-  size_t i, j;
-
-  // Create a connection handle
-  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) {
-    exit(EXIT_FAILURE);
-  }
-
-  // Launching connection handle
-  if (guestfs_launch(g) == -1) {
-    exit(EXIT_FAILURE);
-  }
-
-  // Pulling rootfs information
-  roots = guestfs_inspect_os(g);
-  if (roots == NULL) {
-    exit(EXIT_FAILURE);
-  }
-
-  // Looping through roots to mount mountpoints
-  for (j = 0; roots[j] != NULL; j++) {
-    root = roots[j];
-    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]);
-        free(mountpoints[i]);
-        free(mountpoints[i+1]);
-      }
-      free(mountpoints);
-      free(root);
-  }
-  free(roots);
-  return g;
-}
-
-static void worker_task(zsock_t *pipe, const char *disk_path) {
-  guestfs_h *g;
-  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;
-    }
-
-    zframe_t *client_id = zmsg_pop(msg);
-    // Checking for term message
-    if (zframe_streq(client_id, "$TERM")) {
-      zframe_destroy(&client_id);
-      zmsg_destroy(&msg);
-      break;
-    }
-
-    struct guestfs_inpsect_command *command = guestfs_inspect_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! -- not implemented");
-        break;
-      case GUESTFS_COMMAND_CAT:;
-        char *res = NULL;
-        size_t s = 0;
-        cat_file(g, command->args.cat.paths[0], &res, &s);
-        zmsg_addmem(reply, res, s);
-        free(res);
-        break;
-      default:;
-        zmsg_pushstr(reply, "Unknown command");
-        break;
-    }
-
-    // Sending reply
-    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);
-  }
-
-  guestfs_shutdown(g);
-  guestfs_close(g);
-  zsock_destroy(&worker);
-  exit(EXIT_SUCCESS);
-}
-
-typedef struct {
-  char *name;
-  zactor_t *worker;
-} zactor_worker_map;
-
-char *strdup(const char *);
-void mapping_zactor_worker(const 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;
-  return;
-}
-
-zactor_t * zactor_worker_lookup(char *name, zactor_worker_map **map, size_t mapper_size) {
-  size_t i = 0;
-  for (i = 0; i < mapper_size; i++) {
-    if (strcmp((*map[i]).name, name) == 0) {
-	    return map[i]->worker;
-    }
-  }
-  return NULL;
-}
-
-static void log_message(const char *message) {
-  time_t ltime;
-  struct tm *result;
-  char *stime;
-
-  ltime = time(NULL);
-  result = localtime(&ltime);
-  stime = asctime(result);
-  strtok(stime, "\n");
-  printf("[%s] %s\n", stime, message);
-}
+char *endpoint(void);
 
 int main(int argc, char **argv) {
   if (argc < 2) {
-    printf("Usage: %s <disk-path>:<name> ...\n", argv[0]);
-    exit(EXIT_FAILURE);
+    printf("Usage: %s <disk-path> ...\n", argv[0]);
+    return EXIT_FAILURE;
   }
 
-  print_intro();
+  const int worker_count = argc - 1;
 
-  // Zactor setup
-  size_t worker_map_size = 0;
-  zactor_worker_map **worker_map = NULL;
+  // One worker per disk image.
+  zactor_t *workers[worker_count];
 
-  log_message("Starting Workers");
-
-  for (int i = 0; i < argc - 1; i++) {
-    worker_map_size++;
-    worker_map = realloc(worker_map, sizeof(zactor_worker_map *) * worker_map_size);
+  for (int i = 0; i < worker_count; i++) {
     char *path = strtok(argv[i+1], ":");
     char *name = strtok(NULL, ":");
-    mapping_zactor_worker(name, zactor_new((void *)worker_task, path), worker_map, worker_map_size);
+    workers[i] = zactor_new(worker_task, (void *) &((struct { char* path; char *name; }) {.path = path, .name = name}));
   }
 
-  if (worker_map == NULL) {
-    log_message("Worker map was empty");
-    exit(EXIT_FAILURE);
-  }
-
-  // Setup daemon ipc endpoint
-  char *ep = guestfs_inspect_endpoint();
-  // Setting up endpoint log message
-  char *ep_log = (char *)malloc((strlen(ep) * sizeof(char)) + 32);
-
-  // Sending endpoint log message
-  sprintf(ep_log, "Endpoint: %s", ep); // NOLINT
-  log_message(ep_log);
-  free(ep_log);
-
-  // Setup ZMQ routers
-  zsock_t *frontend = zsock_new(ZMQ_ROUTER);
-  zsock_bind(frontend, "%s", ep);
-  free(ep);
-
-  zsock_t *backend = zsock_new(ZMQ_ROUTER);
-  zsock_bind(backend, "inproc://workers");
-
-  // Connecting frontend to backend
-  zpoller_t *poller = zpoller_new(frontend, backend, NULL);
-  assert(poller);
-
-  log_message("Server listening for requests");
-
-  zframe_t *message_pop = NULL;
-
-  while (true) {
-    void *sock = zpoller_wait(poller, -1);
-
-    if (!sock) {
-      break;
-    }
-
-    if (sock == frontend) {
-      zmsg_t *msg = zmsg_recv(frontend);
-      // reply id
-      zframe_t *identity = zmsg_pop(msg);
-      // Null frame
-      message_pop = zmsg_pop(msg);
-      // Destroy immediately
-      zframe_destroy(&message_pop);
-
-      struct guestfs_inpsect_command *c = guestfs_inspect_zmsg_to_command(msg);
-      if (c == NULL) {
-        log_message("Error creating inspect command");
-        zmsg_destroy(&msg);
-        zframe_destroy(&identity);
-        continue;
-      }
-
-      zactor_t *zactor_tmp = zactor_worker_lookup(c->name, worker_map, worker_map_size);
-      if (zactor_tmp != NULL) {
-        // send request to worker
-        zmsg_prepend(msg, &identity);
-        zactor_send(zactor_tmp, &msg);
-      } else {
-        // add failure response
-      }
-
-      zactor_tmp = NULL;
-      guestfs_inspect_command_destroy(&c);
-      zmsg_destroy(&msg);
-      zframe_destroy(&identity);
-    } else if (sock == backend) {
-      zmsg_t *msg = zmsg_recv(backend);
-      message_pop = zmsg_pop(msg); // Removing backend id
-      // Destroy immediately
-      zframe_destroy(&message_pop);
-      zmsg_send(&msg, frontend);
-      zmsg_destroy(&msg);
-    } else {
-      log_message("Socket found from unknown zsock");
-    }
-  }
-
-  log_message("Cleaning up workers");
-  // Cleanup
-  for (size_t i = 0; i < worker_map_size; i++) {
-    zactor_destroy(&worker_map[i]->worker);
-    free(worker_map[i]->name);
-    free(worker_map[i]);
-  }
-
-  free(worker_map);
-  zpoller_destroy(&poller);
-  zsock_destroy(&frontend);
-  zsock_destroy(&backend);
-  exit(EXIT_SUCCESS);
+  return EXIT_SUCCESS;
 }
 
+char *endpoint() {
+  // TODO: This should be based on GUESTFS_INSPECT_ENDPOINT, or XDG_RUNTIME_DIR if the former is not set, and default to a sensible path if neither are set.
+  const char* ep = "ipc:///tmp/guestfs-inspect.sock";
+  char *res = malloc(strlen(ep) + 1);
+  strcpy(res, ep);
+  return res;
+}

libguestfs-inspect.c

@@ -1,122 +0,0 @@
-#include <czmq.h>
-
-#include "libguestfs-inspect.h"
-
-char *guestfs_inspect_endpoint() {
-  const char *guestfs_inspect_endpoint = getenv("GUESTFS_INSPECT_ENDPOINT");
-  const char *socket_file_name = "/guestfs-inspect.sock";
-  char *res = NULL;
-  if (guestfs_inspect_endpoint) {
-    res = malloc(strlen(guestfs_inspect_endpoint) + 1);
-    strcpy(res, guestfs_inspect_endpoint);
-  } else {
-    const char *xdg_runtime_dir = getenv("XDG_RUNTIME_DIR");
-    if (xdg_runtime_dir) {
-      res = malloc(strlen(xdg_runtime_dir) + strlen(socket_file_name) + strlen("ipc://") + 1);
-      strcpy(res, "ipc://");
-      strcat(res, xdg_runtime_dir);
-      strcat(res, socket_file_name);
-    } else {
-      const char *tmp_dir = "/tmp";
-      res = malloc(strlen(tmp_dir) + strlen(socket_file_name) + strlen("ipc://") + 1);
-      strcpy(res, "ipc://");
-      strcat(res, tmp_dir);
-      strcat(res, socket_file_name);
-    }
-  }
-  return res;
-}
-
-zmsg_t *guestfs_inspect_command_to_zmsg(const 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;
-}
-
-struct guestfs_inpsect_command *guestfs_inspect_zmsg_to_command(zmsg_t *external_msg) {
-  // This way we do not modify the argument we are given.
-  zmsg_t *msg = zmsg_dup(external_msg);
-  struct guestfs_inpsect_command *res = malloc(sizeof(struct guestfs_inpsect_command));
-
-  if (!(zmsg_size(msg) > 2)) {
-    free(res);
-    zmsg_destroy(&msg);
-    return NULL;
-  }
-
-  res->name = zmsg_popstr(msg);
-  zframe_t *next = zmsg_pop(msg);
-  res->command = *(zframe_data(next));
-  zframe_destroy(&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;
-  default:
-    printf("Command not found\n");
-  }
-  zmsg_destroy(&msg);
-
-  return res;
-}
-
-void guestfs_inspect_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;
-}

libguestfs-inspect.h

@@ -1,36 +0,0 @@
-#ifndef LIBGUESTFS_INSPECT_H
-#define LIBGUESTFS_INSPECT_H
-
-#include <czmq.h>
-
-enum guestfs_inspect_command_const {
-  GUESTFS_COMMAND_LS,
-  /* GUESTFS_COMMAND_TOUCH, */
-  /* GUESTFS_COMMAND_MKDIR, */
-  GUESTFS_COMMAND_CAT
-};
-
-struct guestfs_ls_args {
-  size_t paths_length;
-  char **paths;
-};
-struct guestfs_cat_args {
-  size_t paths_length;
-  char **paths;  
-};
-
-struct guestfs_inpsect_command {
-  char *name;
-  enum guestfs_inspect_command_const command;
-  union {
-    struct guestfs_ls_args ls;
-    struct guestfs_cat_args cat;
-  } args;
-};
-
-char *guestfs_inspect_endpoint(void);
-zmsg_t *guestfs_inspect_command_to_zmsg(const struct guestfs_inpsect_command *command);
-struct guestfs_inpsect_command *guestfs_inspect_zmsg_to_command(zmsg_t *msg);
-void guestfs_inspect_command_destroy(struct guestfs_inpsect_command **c);
-
-#endif // LIBGUESTFS_INSPECT_H