New APIs: guestfs_first_private, guestfs_next_private to walk over

[libguestfs.git] / src / guestfs.c

diff --git a/src/guestfs.c b/src/guestfs.c
index 75228d3..97762ca 100644 (file)
--- a/src/guestfs.c
+++ b/src/guestfs.c
@@ -189,10 +189,8 @@ guestfs_close (guestfs_h *g)
   guestfs___free_inspect_info (g);
 
   /* Try to sync if autosync flag is set. */
-  if (g->autosync && g->state == READY) {
-    guestfs_umount_all (g);
-    guestfs_sync (g);
-  }
+  if (g->autosync && g->state == READY)
+    guestfs_internal_autosync (g);
 
   /* Remove any handlers that might be called back before we kill the
    * subprocess.
@@ -214,7 +212,7 @@ guestfs_close (guestfs_h *g)
   g->sock = -1;
 
   /* Wait for subprocess(es) to exit. */
-  waitpid (g->pid, NULL, 0);
+  if (g->pid > 0) waitpid (g->pid, NULL, 0);
   if (g->recoverypid > 0) waitpid (g->recoverypid, NULL, 0);
 
   /* Remove tmpfiles. */
@@ -647,6 +645,51 @@ guestfs__get_network (guestfs_h *g)
   return g->enable_network;
 }
 
+int
+guestfs__set_attach_method (guestfs_h *g, const char *method)
+{
+  if (STREQ (method, "appliance")) {
+    g->attach_method = ATTACH_METHOD_APPLIANCE;
+    free (g->attach_method_arg);
+    g->attach_method_arg = NULL;
+  }
+  else if (STRPREFIX (method, "unix:") && strlen (method) > 5) {
+    g->attach_method = ATTACH_METHOD_UNIX;
+    free (g->attach_method_arg);
+    g->attach_method_arg = safe_strdup (g, method + 5);
+    /* Note that we don't check the path exists until launch is called. */
+  }
+  else {
+    error (g, "invalid attach method: %s", method);
+    return -1;
+  }
+
+  return 0;
+}
+
+char *
+guestfs__get_attach_method (guestfs_h *g)
+{
+  char *ret;
+
+  switch (g->attach_method) {
+  case ATTACH_METHOD_APPLIANCE:
+    ret = safe_strdup (g, "appliance");
+    break;
+
+  case ATTACH_METHOD_UNIX:
+    ret = safe_malloc (g, strlen (g->attach_method_arg) + 5 + 1);
+    strcpy (ret, "unix:");
+    strcat (ret, g->attach_method_arg);
+    break;
+
+  default: /* keep GCC happy - this is not reached */
+    abort ();
+  }
+
+  return ret;
+}
+
 void
 guestfs_set_log_message_callback (guestfs_h *g,
                                   guestfs_log_message_cb cb, void *opaque)
@@ -763,6 +806,47 @@ guestfs_get_private (guestfs_h *g, const char *key)
     return NULL;
 }
 
+/* Iterator. */
+void *
+guestfs_first_private (guestfs_h *g, const char **key_rtn)
+{
+  if (g->pda == NULL)
+    return NULL;
+
+  g->pda_next = hash_get_first (g->pda);
+
+  /* Ignore any keys with NULL data pointers. */
+  while (g->pda_next && g->pda_next->data == NULL)
+    g->pda_next = hash_get_next (g->pda, g->pda_next);
+
+  if (g->pda_next == NULL)
+    return NULL;
+
+  *key_rtn = g->pda_next->key;
+  return g->pda_next->data;
+}
+
+void *
+guestfs_next_private (guestfs_h *g, const char **key_rtn)
+{
+  if (g->pda == NULL)
+    return NULL;
+
+  if (g->pda_next == NULL)
+    return NULL;
+
+  /* Walk to the next key with a non-NULL data pointer. */
+  do {
+    g->pda_next = hash_get_next (g->pda, g->pda_next);
+  } while (g->pda_next && g->pda_next->data == NULL);
+
+  if (g->pda_next == NULL)
+    return NULL;
+
+  *key_rtn = g->pda_next->key;
+  return g->pda_next->data;
+}
+
 /* When tracing, be careful how we print BufferIn parameters which
  * usually contain large amounts of binary data (RHBZ#646822).
  */
@@ -792,6 +876,12 @@ guestfs___print_BufferIn (FILE *out, const char *buf, size_t buf_size)
 }
 
 void
+guestfs___print_BufferOut (FILE *out, const char *buf, size_t buf_size)
+{
+  guestfs___print_BufferIn (out, buf, buf_size);
+}
+
+void
 guestfs___free_string_list (char **argv)
 {
   size_t i;