Parses return values and returned errors properly.

[libguestfs.git] / src / guestfs-actions.c

diff --git a/src/guestfs-actions.c b/src/guestfs-actions.c
index db701ef..fd7a0b9 100644 (file)
--- a/src/guestfs-actions.c
+++ b/src/guestfs-actions.c
@@ -20,15 +20,28 @@
  */
 
 struct mount_rv {
-  int err_code; /* 0 or -1 */
-  char err_str[256];
+  int cb_done;  /* flag to indicate callback was called */
+  struct guestfs_message_header hdr;
+  struct guestfs_message_error err;
 };
 
 static void mount_cb (guestfs_h *g, void *data, XDR *xdr)
 {
   struct mount_rv *rv = (struct mount_rv *) data;
 
-  /* XXX */ rv.code = 0;
+  if (!xdr_guestfs_message_header (xdr, &rv->hdr)) {
+    error (g, "guestfs_mount: failed to parse reply header");
+    return;
+  }
+  if (rv->hdr.status == GUESTFS_STATUS_ERROR) {
+    if (!xdr_guestfs_message_error (xdr, &rv->err)) {
+      error (g, "guestfs_mount: failed to parse reply error");
+      return;
+    }
+    goto done;
+  }
+ done:
+  rv->cb_done = 1;
   main_loop.main_loop_quit (g);
 }
 
@@ -38,6 +51,7 @@ int guestfs_mount (guestfs_h *g,
 {
   struct guestfs_mount_args args;
   struct mount_rv rv;
+  int serial;
 
   if (g->state != READY) {
     error (g, "guestfs_mount called from the wrong state, %d != READY",
@@ -45,23 +59,32 @@ int guestfs_mount (guestfs_h *g,
     return -1;
   }
 
+  memset (&rv, 0, sizeof rv);
+
+
   args.device = (char *) device;
   args.mountpoint = (char *) mountpoint;
-  if (dispatch (g, (xdrproc_t) xdr_guestfs_mount_args, (char *) &args) == -1)
+  serial = dispatch (g, GUESTFS_PROC_MOUNT,
+                     (xdrproc_t) xdr_guestfs_mount_args, (char *) &args);
+  if (serial == -1)
     return -1;
 
-  rv.err_code = 42;
+  rv.cb_done = 0;
   g->reply_cb_internal = mount_cb;
   g->reply_cb_internal_data = &rv;
   main_loop.main_loop_run (g);
   g->reply_cb_internal = NULL;
   g->reply_cb_internal_data = NULL;
-  if (rv.err_code == 42) { /* callback wasn't called */
+  if (!rv.cb_done) {
     error (g, "guestfs_mount failed, see earlier error messages");
     return -1;
   }
-  else if (rv.err_code == -1) { /* error from remote end */
-    error (g, "%s", rv.err_str);
+
+  if (check_reply_header (g, &rv.hdr, GUESTFS_PROC_MOUNT, serial) == -1)
+    return -1;
+
+  if (rv.hdr.status == GUESTFS_STATUS_ERROR) {
+    error (g, "%s", rv.err.error);
     return -1;
   }
 
@@ -69,39 +92,64 @@ int guestfs_mount (guestfs_h *g,
 }
 
 struct sync_rv {
-  int err_code; /* 0 or -1 */
-  char err_str[256];
+  int cb_done;  /* flag to indicate callback was called */
+  struct guestfs_message_header hdr;
+  struct guestfs_message_error err;
 };
 
 static void sync_cb (guestfs_h *g, void *data, XDR *xdr)
 {
   struct sync_rv *rv = (struct sync_rv *) data;
 
-  /* XXX */ rv.code = 0;
+  if (!xdr_guestfs_message_header (xdr, &rv->hdr)) {
+    error (g, "guestfs_sync: failed to parse reply header");
+    return;
+  }
+  if (rv->hdr.status == GUESTFS_STATUS_ERROR) {
+    if (!xdr_guestfs_message_error (xdr, &rv->err)) {
+      error (g, "guestfs_sync: failed to parse reply error");
+      return;
+    }
+    goto done;
+  }
+ done:
+  rv->cb_done = 1;
   main_loop.main_loop_quit (g);
 }
 
 int guestfs_sync (guestfs_h *g)
 {
   struct sync_rv rv;
+  int serial;
 
   if (g->state != READY) {
     error (g, "guestfs_sync called from the wrong state, %d != READY",
       g->state);
     return -1;
   }
-  rv.err_code = 42;
+
+  memset (&rv, 0, sizeof rv);
+
+  serial = dispatch (g, GUESTFS_PROC_SYNC, NULL, NULL);
+  if (serial == -1)
+    return -1;
+
+  rv.cb_done = 0;
   g->reply_cb_internal = sync_cb;
   g->reply_cb_internal_data = &rv;
   main_loop.main_loop_run (g);
   g->reply_cb_internal = NULL;
   g->reply_cb_internal_data = NULL;
-  if (rv.err_code == 42) { /* callback wasn't called */
+  if (!rv.cb_done) {
     error (g, "guestfs_sync failed, see earlier error messages");
     return -1;
   }
-  else if (rv.err_code == -1) { /* error from remote end */
-    error (g, "%s", rv.err_str);
+
+  if (check_reply_header (g, &rv.hdr, GUESTFS_PROC_SYNC, serial) == -1)
+    return -1;
+
+  if (rv.hdr.status == GUESTFS_STATUS_ERROR) {
+    error (g, "%s", rv.err.error);
     return -1;
   }
 
@@ -109,15 +157,28 @@ int guestfs_sync (guestfs_h *g)
 }
 
 struct touch_rv {
-  int err_code; /* 0 or -1 */
-  char err_str[256];
+  int cb_done;  /* flag to indicate callback was called */
+  struct guestfs_message_header hdr;
+  struct guestfs_message_error err;
 };
 
 static void touch_cb (guestfs_h *g, void *data, XDR *xdr)
 {
   struct touch_rv *rv = (struct touch_rv *) data;
 
-  /* XXX */ rv.code = 0;
+  if (!xdr_guestfs_message_header (xdr, &rv->hdr)) {
+    error (g, "guestfs_touch: failed to parse reply header");
+    return;
+  }
+  if (rv->hdr.status == GUESTFS_STATUS_ERROR) {
+    if (!xdr_guestfs_message_error (xdr, &rv->err)) {
+      error (g, "guestfs_touch: failed to parse reply error");
+      return;
+    }
+    goto done;
+  }
+ done:
+  rv->cb_done = 1;
   main_loop.main_loop_quit (g);
 }
 
@@ -126,6 +187,7 @@ int guestfs_touch (guestfs_h *g,
 {
   struct guestfs_touch_args args;
   struct touch_rv rv;
+  int serial;
 
   if (g->state != READY) {
     error (g, "guestfs_touch called from the wrong state, %d != READY",
@@ -133,22 +195,31 @@ int guestfs_touch (guestfs_h *g,
     return -1;
   }
 
+  memset (&rv, 0, sizeof rv);
+
+
   args.path = (char *) path;
-  if (dispatch (g, (xdrproc_t) xdr_guestfs_touch_args, (char *) &args) == -1)
+  serial = dispatch (g, GUESTFS_PROC_TOUCH,
+                     (xdrproc_t) xdr_guestfs_touch_args, (char *) &args);
+  if (serial == -1)
     return -1;
 
-  rv.err_code = 42;
+  rv.cb_done = 0;
   g->reply_cb_internal = touch_cb;
   g->reply_cb_internal_data = &rv;
   main_loop.main_loop_run (g);
   g->reply_cb_internal = NULL;
   g->reply_cb_internal_data = NULL;
-  if (rv.err_code == 42) { /* callback wasn't called */
+  if (!rv.cb_done) {
     error (g, "guestfs_touch failed, see earlier error messages");
     return -1;
   }
-  else if (rv.err_code == -1) { /* error from remote end */
-    error (g, "%s", rv.err_str);
+
+  if (check_reply_header (g, &rv.hdr, GUESTFS_PROC_TOUCH, serial) == -1)
+    return -1;
+
+  if (rv.hdr.status == GUESTFS_STATUS_ERROR) {
+    error (g, "%s", rv.err.error);
     return -1;
   }