X-Git-Url: http://git.annexia.org/?p=libguestfs.git;a=blobdiff_plain;f=src%2Fguestfs.c;h=98d99b84200d91bfeba356f1898a746ce525291d;hp=350d84817157a25f61f2dbc5bdac0688063d1902;hb=f04ee08806ec7bd313e9d54f48f2eb911fcb3067;hpb=447dae7df43e8a98da59d94f1aef9895e087aa13

diff --git a/src/guestfs.c b/src/guestfs.c
index 350d848..98d99b8 100644
--- a/src/guestfs.c
+++ b/src/guestfs.c
@@ -19,7 +19,6 @@
 #include <config.h>
 
 #define _BSD_SOURCE /* for mkdtemp, usleep */
-#define _GNU_SOURCE /* for vasprintf, GNU strerror_r, strchrnul */
 
 #include <stdio.h>
 #include <stdlib.h>
@@ -58,15 +57,17 @@
 #endif
 
 #include "guestfs.h"
+#include "guestfs-internal-actions.h"
 #include "guestfs_protocol.h"
+#include "ignore-value.h"
 
 #ifdef HAVE_GETTEXT
 #include "gettext.h"
 #define _(str) dgettext(PACKAGE, (str))
-#define N_(str) dgettext(PACKAGE, (str))
+//#define N_(str) dgettext(PACKAGE, (str))
 #else
 #define _(str) str
-#define N_(str) str
+//#define N_(str) str
 #endif
 
 #define error guestfs_error
@@ -74,7 +75,7 @@
 #define safe_malloc guestfs_safe_malloc
 #define safe_realloc guestfs_safe_realloc
 #define safe_strdup guestfs_safe_strdup
-#define safe_memdup guestfs_safe_memdup
+//#define safe_memdup guestfs_safe_memdup
 
 static void default_error_cb (guestfs_h *g, void *data, const char *msg);
 static void stdout_event (struct guestfs_main_loop *ml, guestfs_h *g, void *data, int watch, int fd, int events);
@@ -169,6 +170,7 @@ struct guestfs_h
   int cmdline_size;
 
   int verbose;
+  int trace;
   int autosync;
 
   char *path;			/* Path to kernel, initrd. */
@@ -177,6 +179,8 @@ struct guestfs_h
 
   int memsize;			/* Size of RAM (megabytes). */
 
+  int selinux;                  /* selinux enabled? */
+
   char *last_error;
 
   /* Callbacks. */
@@ -199,9 +203,9 @@ struct guestfs_h
 
   /* Messages sent and received from the daemon. */
   char *msg_in;
-  int msg_in_size, msg_in_allocated;
+  unsigned int msg_in_size, msg_in_allocated;
   char *msg_out;
-  int msg_out_size, msg_out_pos;
+  unsigned int msg_out_size, msg_out_pos;
 
   int msg_next_serial;
 };
@@ -235,6 +239,9 @@ guestfs_create (void)
   str = getenv ("LIBGUESTFS_DEBUG");
   g->verbose = str != NULL && strcmp (str, "1") == 0;
 
+  str = getenv ("LIBGUESTFS_TRACE");
+  g->trace = str != NULL && strcmp (str, "1") == 0;
+
   str = getenv ("LIBGUESTFS_PATH");
   g->path = str != NULL ? strdup (str) : strdup (GUESTFS_DEFAULT_PATH);
   if (!g->path) goto error;
@@ -327,6 +334,29 @@ guestfs_close (guestfs_h *g)
   if (g->state != CONFIG)
     guestfs_kill_subprocess (g);
 
+  /* Close any sockets and deregister any handlers. */
+  if (g->stdout_watch >= 0)
+    g->main_loop->remove_handle (g->main_loop, g, g->stdout_watch);
+  if (g->sock_watch >= 0)
+    g->main_loop->remove_handle (g->main_loop, g, g->sock_watch);
+  g->stdout_watch = -1;
+  g->sock_watch = -1;
+
+  if (g->fd[0] >= 0)
+    close (g->fd[0]);
+  if (g->fd[1] >= 0)
+    close (g->fd[1]);
+  if (g->sock >= 0)
+    close (g->sock);
+  g->fd[0] = -1;
+  g->fd[1] = -1;
+  g->sock = -1;
+
+  /* Wait for subprocess(es) to exit. */
+  waitpid (g->pid, NULL, 0);
+  if (g->recoverypid > 0) waitpid (g->recoverypid, NULL, 0);
+
+  /* Remove tmpfiles. */
   if (g->tmpdir) {
     snprintf (filename, sizeof filename, "%s/sock", g->tmpdir);
     unlink (filename);
@@ -421,19 +451,21 @@ guestfs_perrorf (guestfs_h *g, const char *fs, ...)
 {
   va_list args;
   char *msg;
-  int err = errno;
+  int errnum = errno;
 
   va_start (args, fs);
-  vasprintf (&msg, fs, args);
+  int err = vasprintf (&msg, fs, args);
   va_end (args);
 
+  if (err < 0) return;
+
 #ifndef _GNU_SOURCE
   char buf[256];
-  strerror_r (err, buf, sizeof buf);
+  strerror_r (errnum, buf, sizeof buf);
 #else
   char _buf[256];
   char *buf;
-  buf = strerror_r (err, _buf, sizeof _buf);
+  buf = strerror_r (errnum, _buf, sizeof _buf);
 #endif
 
   msg = safe_realloc (g, msg, strlen (msg) + 2 + strlen (buf) + 1);
@@ -516,8 +548,9 @@ guestfs_safe_memdup (guestfs_h *g, void *ptr, size_t size)
 }
 
 static int
-xwrite (int fd, const void *buf, size_t len)
+xwrite (int fd, const void *v_buf, size_t len)
 {
+  const char *buf = v_buf;
   int r;
 
   while (len > 0) {
@@ -533,15 +566,16 @@ xwrite (int fd, const void *buf, size_t len)
 }
 
 static int
-xread (int fd, void *buf, size_t len)
+xread (int fd, void *v_buf, size_t len)
 {
+  char *buf = v_buf;
   int r;
 
   while (len > 0) {
     r = read (fd, buf, len);
     if (r == -1) {
       if (errno == EINTR || errno == EAGAIN)
-	continue;
+        continue;
       return -1;
     }
 
@@ -579,33 +613,33 @@ guestfs_get_error_handler (guestfs_h *g, void **data_rtn)
 }
 
 int
-guestfs_set_verbose (guestfs_h *g, int v)
+guestfs__set_verbose (guestfs_h *g, int v)
 {
   g->verbose = !!v;
   return 0;
 }
 
 int
-guestfs_get_verbose (guestfs_h *g)
+guestfs__get_verbose (guestfs_h *g)
 {
   return g->verbose;
 }
 
 int
-guestfs_set_autosync (guestfs_h *g, int a)
+guestfs__set_autosync (guestfs_h *g, int a)
 {
   g->autosync = !!a;
   return 0;
 }
 
 int
-guestfs_get_autosync (guestfs_h *g)
+guestfs__get_autosync (guestfs_h *g)
 {
   return g->autosync;
 }
 
 int
-guestfs_set_path (guestfs_h *g, const char *path)
+guestfs__set_path (guestfs_h *g, const char *path)
 {
   free (g->path);
   g->path = NULL;
@@ -617,13 +651,13 @@ guestfs_set_path (guestfs_h *g, const char *path)
 }
 
 const char *
-guestfs_get_path (guestfs_h *g)
+guestfs__get_path (guestfs_h *g)
 {
   return g->path;
 }
 
 int
-guestfs_set_qemu (guestfs_h *g, const char *qemu)
+guestfs__set_qemu (guestfs_h *g, const char *qemu)
 {
   free (g->qemu);
   g->qemu = NULL;
@@ -633,13 +667,13 @@ guestfs_set_qemu (guestfs_h *g, const char *qemu)
 }
 
 const char *
-guestfs_get_qemu (guestfs_h *g)
+guestfs__get_qemu (guestfs_h *g)
 {
   return g->qemu;
 }
 
 int
-guestfs_set_append (guestfs_h *g, const char *append)
+guestfs__set_append (guestfs_h *g, const char *append)
 {
   free (g->append);
   g->append = NULL;
@@ -649,24 +683,74 @@ guestfs_set_append (guestfs_h *g, const char *append)
 }
 
 const char *
-guestfs_get_append (guestfs_h *g)
+guestfs__get_append (guestfs_h *g)
 {
   return g->append;
 }
 
 int
-guestfs_set_memsize (guestfs_h *g, int memsize)
+guestfs__set_memsize (guestfs_h *g, int memsize)
 {
   g->memsize = memsize;
   return 0;
 }
 
 int
-guestfs_get_memsize (guestfs_h *g)
+guestfs__get_memsize (guestfs_h *g)
 {
   return g->memsize;
 }
 
+int
+guestfs__set_selinux (guestfs_h *g, int selinux)
+{
+  g->selinux = selinux;
+  return 0;
+}
+
+int
+guestfs__get_selinux (guestfs_h *g)
+{
+  return g->selinux;
+}
+
+int
+guestfs__get_pid (guestfs_h *g)
+{
+  if (g->pid > 0)
+    return g->pid;
+  else {
+    error (g, "get_pid: no qemu subprocess");
+    return -1;
+  }
+}
+
+struct guestfs_version *
+guestfs__version (guestfs_h *g)
+{
+  struct guestfs_version *r;
+
+  r = safe_malloc (g, sizeof *r);
+  r->major = PACKAGE_VERSION_MAJOR;
+  r->minor = PACKAGE_VERSION_MINOR;
+  r->release = PACKAGE_VERSION_RELEASE;
+  r->extra = safe_strdup (g, PACKAGE_VERSION_EXTRA);
+  return r;
+}
+
+int
+guestfs__set_trace (guestfs_h *g, int t)
+{
+  g->trace = !!t;
+  return 0;
+}
+
+int
+guestfs__get_trace (guestfs_h *g)
+{
+  return g->trace;
+}
+
 /* Add a string to the current command line. */
 static void
 incr_cmdline_size (guestfs_h *g)
@@ -697,8 +781,8 @@ add_cmdline (guestfs_h *g, const char *str)
 }
 
 int
-guestfs_config (guestfs_h *g,
-		const char *qemu_param, const char *qemu_value)
+guestfs__config (guestfs_h *g,
+                 const char *qemu_param, const char *qemu_value)
 {
   if (qemu_param[0] != '-') {
     error (g, _("guestfs_config: parameter must begin with '-' character"));
@@ -729,7 +813,7 @@ guestfs_config (guestfs_h *g,
 }
 
 int
-guestfs_add_drive (guestfs_h *g, const char *filename)
+guestfs__add_drive (guestfs_h *g, const char *filename)
 {
   size_t len = strlen (filename) + 64;
   char buf[len];
@@ -739,19 +823,36 @@ guestfs_add_drive (guestfs_h *g, const char *filename)
     return -1;
   }
 
-  if (access (filename, F_OK) == -1) {
-    perrorf (g, "%s", filename);
-    return -1;
+  /* cache=off improves reliability in the event of a host crash.
+   *
+   * However this option causes qemu to try to open the file with
+   * O_DIRECT.  This fails on some filesystem types (notably tmpfs).
+   * So we check if we can open the file with or without O_DIRECT,
+   * and use cache=off (or not) accordingly.
+   *
+   * This test also checks for the presence of the file, which
+   * is a documented semantic of this interface.
+   */
+  int fd = open (filename, O_RDONLY|O_DIRECT);
+  if (fd >= 0) {
+    close (fd);
+    snprintf (buf, len, "file=%s,cache=off,if=" DRIVE_IF, filename);
+  } else {
+    fd = open (filename, O_RDONLY);
+    if (fd >= 0) {
+      close (fd);
+      snprintf (buf, len, "file=%s,if=" DRIVE_IF, filename);
+    } else {
+      perrorf (g, "%s", filename);
+      return -1;
+    }
   }
 
-  /* cache=off improves reliability in the event of a host crash. */
-  snprintf (buf, len, "file=%s,cache=off,if=%s", filename, DRIVE_IF);
-
   return guestfs_config (g, "-drive", buf);
 }
 
 int
-guestfs_add_drive_ro (guestfs_h *g, const char *filename)
+guestfs__add_drive_ro (guestfs_h *g, const char *filename)
 {
   size_t len = strlen (filename) + 64;
   char buf[len];
@@ -772,7 +873,7 @@ guestfs_add_drive_ro (guestfs_h *g, const char *filename)
 }
 
 int
-guestfs_add_cdrom (guestfs_h *g, const char *filename)
+guestfs__add_cdrom (guestfs_h *g, const char *filename)
 {
   if (strchr (filename, ',') != NULL) {
     error (g, _("filename cannot contain ',' (comma) character"));
@@ -821,6 +922,7 @@ dir_contains_files (const char *dir, ...)
 static int build_supermin_appliance (guestfs_h *g, const char *path, char **kernel, char **initrd);
 static int test_qemu (guestfs_h *g);
 static int qemu_supports (guestfs_h *g, const char *option);
+static void print_cmdline (guestfs_h *g);
 
 static const char *kernel_name = "vmlinuz." REPO "." host_cpu;
 static const char *initrd_name = "initramfs." REPO "." host_cpu ".img";
@@ -830,10 +932,11 @@ static const char *supermin_hostfiles_name =
   "initramfs." REPO "." host_cpu ".supermin.hostfiles";
 
 int
-guestfs_launch (guestfs_h *g)
+guestfs__launch (guestfs_h *g)
 {
-  static const char *dir_template = "/tmp/libguestfsXXXXXX";
-  int r, i, pmore;
+  const char *tmpdir;
+  char dir_template[PATH_MAX];
+  int r, pmore;
   size_t len;
   int wfd[2], rfd[2];
   int tries;
@@ -842,6 +945,15 @@ guestfs_launch (guestfs_h *g)
   char unixsock[256];
   struct sockaddr_un addr;
 
+#ifdef P_tmpdir
+  tmpdir = P_tmpdir;
+#else
+  tmpdir = "/tmp";
+#endif
+
+  tmpdir = getenv ("TMPDIR") ? : tmpdir;
+  snprintf (dir_template, sizeof dir_template, "%s/libguestfsXXXXXX", tmpdir);
+
   /* Configured? */
   if (!g->cmdline) {
     error (g, _("you must call guestfs_add_drive before guestfs_launch"));
@@ -877,27 +989,27 @@ guestfs_launch (guestfs_h *g)
     /* Empty element of "." means cwd. */
     if (len == 0 || (len == 1 && *pelem == '.')) {
       if (g->verbose)
-	fprintf (stderr,
-		 "looking for supermin appliance in current directory\n");
+        fprintf (stderr,
+                 "looking for supermin appliance in current directory\n");
       if (dir_contains_files (".",
-			      supermin_name, supermin_hostfiles_name,
-			      "kmod.whitelist", NULL)) {
-	if (build_supermin_appliance (g, ".", &kernel, &initrd) == -1)
-	  return -1;
-	break;
+                              supermin_name, supermin_hostfiles_name,
+                              "kmod.whitelist", NULL)) {
+        if (build_supermin_appliance (g, ".", &kernel, &initrd) == -1)
+          return -1;
+        break;
       }
     }
     /* Look at <path>/supermin* etc. */
     else {
       if (g->verbose)
-	fprintf (stderr, "looking for supermin appliance in %s\n", pelem);
+        fprintf (stderr, "looking for supermin appliance in %s\n", pelem);
 
       if (dir_contains_files (pelem,
-			      supermin_name, supermin_hostfiles_name,
-			      "kmod.whitelist", NULL)) {
-	if (build_supermin_appliance (g, pelem, &kernel, &initrd) == -1)
-	  return -1;
-	break;
+                              supermin_name, supermin_hostfiles_name,
+                              "kmod.whitelist", NULL)) {
+        if (build_supermin_appliance (g, pelem, &kernel, &initrd) == -1)
+          return -1;
+        break;
       }
     }
 
@@ -917,27 +1029,27 @@ guestfs_launch (guestfs_h *g)
 
       /* Empty element or "." means cwd. */
       if (len == 0 || (len == 1 && *pelem == '.')) {
-	if (g->verbose)
-	  fprintf (stderr,
-		   "looking for appliance in current directory\n");
-	if (dir_contains_files (".", kernel_name, initrd_name, NULL)) {
-	  kernel = safe_strdup (g, kernel_name);
-	  initrd = safe_strdup (g, initrd_name);
-	  break;
-	}
+        if (g->verbose)
+          fprintf (stderr,
+                   "looking for appliance in current directory\n");
+        if (dir_contains_files (".", kernel_name, initrd_name, NULL)) {
+          kernel = safe_strdup (g, kernel_name);
+          initrd = safe_strdup (g, initrd_name);
+          break;
+        }
       }
       /* Look at <path>/kernel etc. */
       else {
-	if (g->verbose)
-	  fprintf (stderr, "looking for appliance in %s\n", pelem);
-
-	if (dir_contains_files (pelem, kernel_name, initrd_name, NULL)) {
-	  kernel = safe_malloc (g, len + strlen (kernel_name) + 2);
-	  initrd = safe_malloc (g, len + strlen (initrd_name) + 2);
-	  sprintf (kernel, "%s/%s", pelem, kernel_name);
-	  sprintf (initrd, "%s/%s", pelem, initrd_name);
-	  break;
-	}
+        if (g->verbose)
+          fprintf (stderr, "looking for appliance in %s\n", pelem);
+
+        if (dir_contains_files (pelem, kernel_name, initrd_name, NULL)) {
+          kernel = safe_malloc (g, len + strlen (kernel_name) + 2);
+          initrd = safe_malloc (g, len + strlen (initrd_name) + 2);
+          sprintf (kernel, "%s/%s", pelem, kernel_name);
+          sprintf (initrd, "%s/%s", pelem, initrd_name);
+          break;
+        }
       }
 
       pelem = pend + 1;
@@ -948,7 +1060,7 @@ guestfs_launch (guestfs_h *g)
 
   if (kernel == NULL || initrd == NULL) {
     error (g, _("cannot find %s or %s on LIBGUESTFS_PATH (current path = %s)"),
-	   kernel_name, initrd_name, g->path);
+           kernel_name, initrd_name, g->path);
     goto cleanup0;
   }
 
@@ -985,17 +1097,25 @@ guestfs_launch (guestfs_h *g)
      */
     g->cmdline[0] = g->qemu;
 
-    /* Construct the -net channel parameter for qemu. */
-    snprintf (vmchannel, sizeof vmchannel,
-	      "channel,%d:unix:%s,server,nowait",
-	      VMCHANNEL_PORT, unixsock);
+#define LINUX_CMDLINE							\
+    "panic=1 "         /* force kernel to panic if daemon exits */	\
+    "console=ttyS0 "   /* serial console */				\
+    "udevtimeout=300 " /* good for very slow systems (RHBZ#480319) */	\
+    "noapic "          /* workaround for RHBZ#502058 - ok if not SMP */ \
+    "acpi=off "        /* we don't need ACPI, turn it off */		\
+    "cgroup_disable=memory " /* saves us about 5 MB of RAM */
 
     /* Linux kernel command line. */
     snprintf (append, sizeof append,
-	      "panic=1 console=ttyS0 guestfs=%s:%d%s%s%s",
-	      VMCHANNEL_ADDR, VMCHANNEL_PORT,
-	      g->verbose ? " guestfs_verbose=1" : "",
-	      g->append ? " " : "", g->append ? g->append : "");
+              LINUX_CMDLINE
+              "guestfs=%s:%d "
+              "%s"              /* (selinux) */
+              "%s"              /* (verbose) */
+              "%s",             /* (append) */
+              VMCHANNEL_ADDR, VMCHANNEL_PORT,
+              g->selinux ? "selinux=1 enforcing=0 " : "selinux=0 ",
+              g->verbose ? "guestfs_verbose=1 " : " ",
+              g->append ? g->append : "");
 
     snprintf (memsize_str, sizeof memsize_str, "%d", g->memsize);
 
@@ -1011,12 +1131,40 @@ guestfs_launch (guestfs_h *g)
     add_cmdline (g, "-nographic");
     add_cmdline (g, "-serial");
     add_cmdline (g, "stdio");
+
+#if 0
+    /* Doesn't work.  See:
+     * http://lists.gnu.org/archive/html/qemu-devel/2009-07/threads.html
+     * Subject "guestfwd option doesn't allow supplementary ,server,nowait"
+     */
+    if (qemu_supports (g, "guestfwd")) {
+      /* New-style -net user,guestfwd=... syntax for vmchannel.  See:
+       * http://git.savannah.gnu.org/cgit/qemu.git/commit/?id=c92ef6a22d3c71538fcc48fb61ad353f7ba03b62
+       */
+      snprintf (vmchannel, sizeof vmchannel,
+                "user,vlan=0,net=10.0.2.0/8,guestfwd=tcp:%s:%d-unix:%s,server,nowait",
+                VMCHANNEL_ADDR, VMCHANNEL_PORT, unixsock);
+
+      add_cmdline (g, "-net");
+      add_cmdline (g, vmchannel);
+    } else {
+#endif
+      /* Not guestfwd.  HOPEFULLY this qemu uses the older -net channel
+       * syntax, or if not then we'll get a quick failure.
+       */
+      snprintf (vmchannel, sizeof vmchannel,
+                "channel,%d:unix:%s,server,nowait",
+                VMCHANNEL_PORT, unixsock);
+
+      add_cmdline (g, "-net");
+      add_cmdline (g, vmchannel);
+      add_cmdline (g, "-net");
+      add_cmdline (g, "user,vlan=0,net=10.0.2.0/8");
+#if 0
+    }
+#endif
     add_cmdline (g, "-net");
-    add_cmdline (g, vmchannel);
-    add_cmdline (g, "-net");
-    add_cmdline (g, "user,vlan=0");
-    add_cmdline (g, "-net");
-    add_cmdline (g, "nic,model=virtio,vlan=0");
+    add_cmdline (g, "nic,model=" NET_IF ",vlan=0");
 
     /* These options recommended by KVM developers to improve reliability. */
     if (qemu_supports (g, "-no-hpet"))
@@ -1029,20 +1177,23 @@ guestfs_launch (guestfs_h *g)
     incr_cmdline_size (g);
     g->cmdline[g->cmdline_size-1] = NULL;
 
-    if (g->verbose) {
-      fprintf (stderr, "%s", g->qemu);
-      for (i = 0; g->cmdline[i]; ++i)
-	fprintf (stderr, " %s", g->cmdline[i]);
-      fprintf (stderr, "\n");
-    }
+    if (g->verbose)
+      print_cmdline (g);
 
     /* Set up stdin, stdout. */
     close (0);
     close (1);
     close (wfd[1]);
     close (rfd[0]);
-    dup (wfd[0]);
-    dup (rfd[1]);
+
+    if (dup (wfd[0]) == -1) {
+    dup_failed:
+      perror ("dup failed");
+      _exit (1);
+    }
+    if (dup (rfd[1]) == -1)
+      goto dup_failed;
+
     close (wfd[0]);
     close (rfd[1]);
 
@@ -1085,11 +1236,11 @@ guestfs_launch (guestfs_h *g)
      */
     for (;;) {
       if (kill (qemu_pid, 0) == -1) /* qemu's gone away, we aren't needed */
-	_exit (0);
+        _exit (0);
       if (kill (parent_pid, 0) == -1) {
-	/* Parent's gone away, qemu still around, so kill qemu. */
-	kill (qemu_pid, 9);
-	_exit (0);
+        /* Parent's gone away, qemu still around, so kill qemu. */
+        kill (qemu_pid, 9);
+        _exit (0);
       }
       sleep (2);
     }
@@ -1170,8 +1321,8 @@ guestfs_launch (guestfs_h *g)
 
   g->stdout_watch =
     g->main_loop->add_handle (g->main_loop, g, g->fd[1],
-			      GUESTFS_HANDLE_READABLE,
-			      stdout_event, NULL);
+                              GUESTFS_HANDLE_READABLE,
+                              stdout_event, NULL);
   if (g->stdout_watch == -1) {
     error (g, _("could not watch qemu stdout"));
     goto cleanup3;
@@ -1214,6 +1365,33 @@ guestfs_launch (guestfs_h *g)
   return -1;
 }
 
+/* This function is used to print the qemu command line before it gets
+ * executed, when in verbose mode.
+ */
+static void
+print_cmdline (guestfs_h *g)
+{
+  int i = 0;
+  int needs_quote;
+
+  while (g->cmdline[i]) {
+    if (g->cmdline[i][0] == '-') /* -option starts a new line */
+      fprintf (stderr, " \\\n   ");
+
+    if (i > 0) fputc (' ', stderr);
+
+    /* Does it need shell quoting?  This only deals with simple cases. */
+    needs_quote = strcspn (g->cmdline[i], " ") != strlen (g->cmdline[i]);
+
+    if (needs_quote) fputc ('\'', stderr);
+    fprintf (stderr, "%s", g->cmdline[i]);
+    if (needs_quote) fputc ('\'', stderr);
+    i++;
+  }
+
+  fputc ('\n', stderr);
+}
+
 /* This function does the hard work of building the supermin appliance
  * on the fly.  'path' is the directory containing the control files.
  * 'kernel' and 'initrd' are where we will return the names of the
@@ -1222,7 +1400,7 @@ guestfs_launch (guestfs_h *g)
  */
 static int
 build_supermin_appliance (guestfs_h *g, const char *path,
-			  char **kernel, char **initrd)
+                          char **kernel, char **initrd)
 {
   char cmd[4096];
   int r, len;
@@ -1234,10 +1412,10 @@ build_supermin_appliance (guestfs_h *g, const char *path,
   snprintf (*initrd, len+8, "%s/initrd", g->tmpdir);
 
   snprintf (cmd, sizeof cmd,
-	    "PATH='%s':$PATH "
-	    "libguestfs-supermin-helper '%s' %s %s",
-	    path,
-	    path, *kernel, *initrd);
+            "PATH='%s':$PATH "
+            "libguestfs-supermin-helper '%s' %s %s",
+            path,
+            path, *kernel, *initrd);
 
   r = system (cmd);
   if (r == -1 || WEXITSTATUS(r) != 0) {
@@ -1346,7 +1524,7 @@ finish_wait_ready (guestfs_h *g, void *vp)
 }
 
 int
-guestfs_wait_ready (guestfs_h *g)
+guestfs__wait_ready (guestfs_h *g)
 {
   int finished = 0, r;
 
@@ -1389,7 +1567,7 @@ guestfs_wait_ready (guestfs_h *g)
 }
 
 int
-guestfs_kill_subprocess (guestfs_h *g)
+guestfs__kill_subprocess (guestfs_h *g)
 {
   if (g->state == CONFIG) {
     error (g, _("no subprocess to kill"));
@@ -1407,41 +1585,41 @@ guestfs_kill_subprocess (guestfs_h *g)
 
 /* Access current state. */
 int
-guestfs_is_config (guestfs_h *g)
+guestfs__is_config (guestfs_h *g)
 {
   return g->state == CONFIG;
 }
 
 int
-guestfs_is_launching (guestfs_h *g)
+guestfs__is_launching (guestfs_h *g)
 {
   return g->state == LAUNCHING;
 }
 
 int
-guestfs_is_ready (guestfs_h *g)
+guestfs__is_ready (guestfs_h *g)
 {
   return g->state == READY;
 }
 
 int
-guestfs_is_busy (guestfs_h *g)
+guestfs__is_busy (guestfs_h *g)
 {
   return g->state == BUSY;
 }
 
 int
-guestfs_get_state (guestfs_h *g)
+guestfs__get_state (guestfs_h *g)
 {
   return g->state;
 }
 
 int
-guestfs_set_ready (guestfs_h *g)
+guestfs__set_ready (guestfs_h *g)
 {
   if (g->state != BUSY) {
     error (g, _("guestfs_set_ready: called when in state %d != BUSY"),
-	   g->state);
+           g->state);
     return -1;
   }
   g->state = READY;
@@ -1449,11 +1627,11 @@ guestfs_set_ready (guestfs_h *g)
 }
 
 int
-guestfs_set_busy (guestfs_h *g)
+guestfs__set_busy (guestfs_h *g)
 {
   if (g->state != READY) {
     error (g, _("guestfs_set_busy: called when in state %d != READY"),
-	   g->state);
+           g->state);
     return -1;
   }
   g->state = BUSY;
@@ -1461,7 +1639,7 @@ guestfs_set_busy (guestfs_h *g)
 }
 
 int
-guestfs_end_busy (guestfs_h *g)
+guestfs__end_busy (guestfs_h *g)
 {
   switch (g->state)
     {
@@ -1471,52 +1649,16 @@ guestfs_end_busy (guestfs_h *g)
     case CONFIG:
     case READY:
       break;
+
     case LAUNCHING:
     case NO_HANDLE:
+    default:
       error (g, _("guestfs_end_busy: called when in state %d"), g->state);
       return -1;
     }
   return 0;
 }
 
-/* Structure-freeing functions.  These rely on the fact that the
- * structure format is identical to the XDR format.  See note in
- * generator.ml.
- */
-void
-guestfs_free_int_bool (struct guestfs_int_bool *x)
-{
-  free (x);
-}
-
-void
-guestfs_free_lvm_pv_list (struct guestfs_lvm_pv_list *x)
-{
-  xdr_free ((xdrproc_t) xdr_guestfs_lvm_int_pv_list, (char *) x);
-  free (x);
-}
-
-void
-guestfs_free_lvm_vg_list (struct guestfs_lvm_vg_list *x)
-{
-  xdr_free ((xdrproc_t) xdr_guestfs_lvm_int_vg_list, (char *) x);
-  free (x);
-}
-
-void
-guestfs_free_lvm_lv_list (struct guestfs_lvm_lv_list *x)
-{
-  xdr_free ((xdrproc_t) xdr_guestfs_lvm_int_lv_list, (char *) x);
-  free (x);
-}
-
-void
-guestfs_free_dirent_list (struct guestfs_dirent_list *x)
-{
-  xdr_free ((xdrproc_t) xdr_guestfs_int_dirent_list, (char *) x);
-  free (x);
-}
-
 /* We don't know if stdout_event or sock_read_event will be the
  * first to receive EOF if the qemu process dies.  This function
  * has the common cleanup code for both.
@@ -1556,7 +1698,7 @@ child_cleanup (guestfs_h *g)
  */
 static void
 stdout_event (struct guestfs_main_loop *ml, guestfs_h *g, void *data,
-	      int watch, int fd, int events)
+              int watch, int fd, int events)
 {
   char buf[4096];
   int n;
@@ -1564,8 +1706,8 @@ stdout_event (struct guestfs_main_loop *ml, guestfs_h *g, void *data,
 #if 0
   if (g->verbose)
     fprintf (stderr,
-	     "stdout_event: %p g->state = %d, fd = %d, events = 0x%x\n",
-	     g, g->state, fd, events);
+             "stdout_event: %p g->state = %d, fd = %d, events = 0x%x\n",
+             g, g->state, fd, events);
 #endif
 
   if (g->fd[1] != fd) {
@@ -1588,7 +1730,7 @@ stdout_event (struct guestfs_main_loop *ml, guestfs_h *g, void *data,
 
   /* In verbose mode, copy all log messages to stderr. */
   if (g->verbose)
-    write (2, buf, n);
+    ignore_value (write (STDERR_FILENO, buf, n));
 
   /* It's an actual log message, send it upwards if anyone is listening. */
   if (g->log_message_cb)
@@ -1600,7 +1742,7 @@ stdout_event (struct guestfs_main_loop *ml, guestfs_h *g, void *data,
  */
 static void
 sock_read_event (struct guestfs_main_loop *ml, guestfs_h *g, void *data,
-		 int watch, int fd, int events)
+                 int watch, int fd, int events)
 {
   XDR xdr;
   u_int32_t len;
@@ -1608,8 +1750,8 @@ sock_read_event (struct guestfs_main_loop *ml, guestfs_h *g, void *data,
 
   if (g->verbose)
     fprintf (stderr,
-	     "sock_read_event: %p g->state = %d, fd = %d, events = 0x%x\n",
-	     g, g->state, fd, events);
+             "sock_read_event: %p g->state = %d, fd = %d, events = 0x%x\n",
+             g, g->state, fd, events);
 
   if (g->sock != fd) {
     error (g, _("sock_read_event: internal error: %d != %d"), g->sock, fd);
@@ -1621,7 +1763,7 @@ sock_read_event (struct guestfs_main_loop *ml, guestfs_h *g, void *data,
     g->msg_in = safe_realloc (g, g->msg_in, g->msg_in_allocated);
   }
   n = read (g->sock, g->msg_in + g->msg_in_size,
-	    g->msg_in_allocated - g->msg_in_size);
+            g->msg_in_allocated - g->msg_in_size);
   if (n == 0) {
     /* Disconnected. */
     child_cleanup (g);
@@ -1653,14 +1795,14 @@ sock_read_event (struct guestfs_main_loop *ml, guestfs_h *g, void *data,
   if (len == GUESTFS_LAUNCH_FLAG) {
     if (g->state != LAUNCHING)
       error (g, _("received magic signature from guestfsd, but in state %d"),
-	     g->state);
+             g->state);
     else if (g->msg_in_size != 4)
       error (g, _("received magic signature from guestfsd, but msg size is %d"),
-	     g->msg_in_size);
+             g->msg_in_size);
     else {
       g->state = READY;
       if (g->launch_done_cb)
-	g->launch_done_cb (g, g->launch_done_cb_data);
+        g->launch_done_cb (g, g->launch_done_cb_data);
     }
 
     goto cleanup;
@@ -1681,7 +1823,7 @@ sock_read_event (struct guestfs_main_loop *ml, guestfs_h *g, void *data,
    */
   if (len > GUESTFS_MESSAGE_MAX) {
     error (g, _("message length (%u) > maximum possible size (%d)"),
-	   len, GUESTFS_MESSAGE_MAX);
+           len, GUESTFS_MESSAGE_MAX);
     goto cleanup;
   }
 
@@ -1695,17 +1837,17 @@ sock_read_event (struct guestfs_main_loop *ml, guestfs_h *g, void *data,
     for (i = 0; i < g->msg_in_size; i += 16) {
       printf ("%04x: ", i);
       for (j = i; j < MIN (i+16, g->msg_in_size); ++j)
-	printf ("%02x ", (unsigned char) g->msg_in[j]);
+        printf ("%02x ", (unsigned char) g->msg_in[j]);
       for (; j < i+16; ++j)
-	printf ("   ");
+        printf ("   ");
       printf ("|");
       for (j = i; j < MIN (i+16, g->msg_in_size); ++j)
-	if (isprint (g->msg_in[j]))
-	  printf ("%c", g->msg_in[j]);
-	else
-	  printf (".");
+        if (isprint (g->msg_in[j]))
+          printf ("%c", g->msg_in[j]);
+        else
+          printf (".");
       for (; j < i+16; ++j)
-	printf (" ");
+        printf (" ");
       printf ("|\n");
     }
   }
@@ -1743,14 +1885,14 @@ sock_read_event (struct guestfs_main_loop *ml, guestfs_h *g, void *data,
  */
 static void
 sock_write_event (struct guestfs_main_loop *ml, guestfs_h *g, void *data,
-		  int watch, int fd, int events)
+                  int watch, int fd, int events)
 {
   int n, err;
 
   if (g->verbose)
     fprintf (stderr,
-	     "sock_write_event: %p g->state = %d, fd = %d, events = 0x%x\n",
-	     g, g->state, fd, events);
+             "sock_write_event: %p g->state = %d, fd = %d, events = 0x%x\n",
+             g, g->state, fd, events);
 
   if (g->sock != fd) {
     error (g, _("sock_write_event: internal error: %d != %d"), g->sock, fd);
@@ -1764,10 +1906,10 @@ sock_write_event (struct guestfs_main_loop *ml, guestfs_h *g, void *data,
 
   if (g->verbose)
     fprintf (stderr, "sock_write_event: writing %d bytes ...\n",
-	     g->msg_out_size - g->msg_out_pos);
+             g->msg_out_size - g->msg_out_pos);
 
   n = write (g->sock, g->msg_out + g->msg_out_pos,
-	     g->msg_out_size - g->msg_out_pos);
+             g->msg_out_size - g->msg_out_pos);
   if (n == -1) {
     err = errno;
     if (err != EAGAIN)
@@ -1800,7 +1942,7 @@ sock_write_event (struct guestfs_main_loop *ml, guestfs_h *g, void *data,
 
 void
 guestfs_set_send_callback (guestfs_h *g,
-			   guestfs_send_cb cb, void *opaque)
+                           guestfs_send_cb cb, void *opaque)
 {
   g->send_cb = cb;
   g->send_cb_data = opaque;
@@ -1808,7 +1950,7 @@ guestfs_set_send_callback (guestfs_h *g,
 
 void
 guestfs_set_reply_callback (guestfs_h *g,
-			    guestfs_reply_cb cb, void *opaque)
+                            guestfs_reply_cb cb, void *opaque)
 {
   g->reply_cb = cb;
   g->reply_cb_data = opaque;
@@ -1816,7 +1958,7 @@ guestfs_set_reply_callback (guestfs_h *g,
 
 void
 guestfs_set_log_message_callback (guestfs_h *g,
-				  guestfs_log_message_cb cb, void *opaque)
+                                  guestfs_log_message_cb cb, void *opaque)
 {
   g->log_message_cb = cb;
   g->log_message_cb_data = opaque;
@@ -1824,7 +1966,7 @@ guestfs_set_log_message_callback (guestfs_h *g,
 
 void
 guestfs_set_subprocess_quit_callback (guestfs_h *g,
-				      guestfs_subprocess_quit_cb cb, void *opaque)
+                                      guestfs_subprocess_quit_cb cb, void *opaque)
 {
   g->subprocess_quit_cb = cb;
   g->subprocess_quit_cb_data = opaque;
@@ -1832,7 +1974,7 @@ guestfs_set_subprocess_quit_callback (guestfs_h *g,
 
 void
 guestfs_set_launch_done_callback (guestfs_h *g,
-				  guestfs_launch_done_cb cb, void *opaque)
+                                  guestfs_launch_done_cb cb, void *opaque)
 {
   g->launch_done_cb = cb;
   g->launch_done_cb_data = opaque;
@@ -1873,8 +2015,8 @@ guestfs__switch_to_sending (guestfs_h *g)
 
   g->sock_watch =
     g->main_loop->add_handle (g->main_loop, g, g->sock,
-			      GUESTFS_HANDLE_WRITABLE,
-			      sock_write_event, NULL);
+                              GUESTFS_HANDLE_WRITABLE,
+                              sock_write_event, NULL);
   if (g->sock_watch == -1) {
     error (g, _("add_handle failed"));
     return -1;
@@ -1896,8 +2038,8 @@ guestfs__switch_to_receiving (guestfs_h *g)
 
   g->sock_watch =
     g->main_loop->add_handle (g->main_loop, g, g->sock,
-			      GUESTFS_HANDLE_READABLE,
-			      sock_read_event, NULL);
+                              GUESTFS_HANDLE_READABLE,
+                              sock_read_event, NULL);
   if (g->sock_watch == -1) {
     error (g, _("add_handle failed"));
     return -1;
@@ -1922,7 +2064,7 @@ send_cb (guestfs_h *g, void *data)
 
 int
 guestfs__send_sync (guestfs_h *g, int proc_nr,
-		    xdrproc_t xdrp, char *args)
+                    xdrproc_t xdrp, char *args)
 {
   struct guestfs_message_header hdr;
   XDR xdr;
@@ -2047,7 +2189,7 @@ guestfs__send_file_sync (guestfs_h *g, const char *filename)
     err = send_file_data_sync (g, buf, r);
     if (err < 0) {
       if (err == -2)		/* daemon sent cancellation */
-	send_file_cancellation_sync (g);
+        send_file_cancellation_sync (g);
       return err;
     }
   }
@@ -2144,7 +2286,7 @@ send_file_chunk_sync (guestfs_h *g, int cancel, const char *buf, size_t buflen)
 
   if (!xdr_guestfs_chunk (&xdr, &chunk)) {
     error (g, _("xdr_guestfs_chunk failed (buf = %p, buflen = %zu)"),
-	   buf, buflen);
+           buf, buflen);
     xdr_destroy (&xdr);
     goto cleanup1;
   }
@@ -2220,7 +2362,7 @@ check_for_daemon_cancellation (guestfs_h *g)
 
   if (flag != GUESTFS_CANCEL_FLAG) {
     error (g, _("check_for_daemon_cancellation: read 0x%x from daemon, expected 0x%x\n"),
-	   flag, GUESTFS_CANCEL_FLAG);
+           flag, GUESTFS_CANCEL_FLAG);
     return 0;
   }
 
@@ -2276,6 +2418,10 @@ guestfs__receive_file_sync (guestfs_h *g, const char *filename)
   char fbuf[4];
   uint32_t flag = GUESTFS_CANCEL_FLAG;
 
+  if (g->verbose)
+    fprintf (stderr, "%s: waiting for daemon to acknowledge cancellation\n",
+             __func__);
+
   xdrmem_create (&xdr, fbuf, sizeof fbuf, XDR_ENCODE);
   xdr_uint32_t (&xdr, &flag);
   xdr_destroy (&xdr);
@@ -2285,7 +2431,7 @@ guestfs__receive_file_sync (guestfs_h *g, const char *filename)
     return -1;
   }
 
-  while ((r = receive_file_data_sync (g, NULL, NULL)) > 0)
+  while (receive_file_data_sync (g, NULL, NULL) > 0)
     ;				/* just discard it */
 
   return -1;
@@ -2297,8 +2443,8 @@ guestfs__receive_file_sync (guestfs_h *g, const char *filename)
  */
 struct receive_file_ctx {
   int count;			/* 0 if receive_file_cb not called, or
-				 * else count number of chunks.
-				 */
+                                 * else count number of chunks.
+                                 */
   guestfs_chunk *chunks;	/* Array of chunks. */
 };
 
@@ -2337,7 +2483,7 @@ receive_file_cb (guestfs_h *g, void *data, XDR *xdr)
 
   /* Copy the chunk to the list. */
   ctx->chunks = safe_realloc (g, ctx->chunks,
-			      sizeof (guestfs_chunk) * (ctx->count+1));
+                              sizeof (guestfs_chunk) * (ctx->count+1));
   ctx->chunks[ctx->count] = chunk;
   ctx->count++;
 }
@@ -2394,8 +2540,8 @@ receive_file_data_sync (guestfs_h *g, void **buf, size_t *len_r)
 
     if (buf) {
       *buf = safe_realloc (g, *buf, len + ctx.chunks[i].data.data_len);
-      memcpy (*buf+len, ctx.chunks[i].data.data_val,
-	      ctx.chunks[i].data.data_len);
+      memcpy (((char *)*buf)+len, ctx.chunks[i].data.data_val,
+              ctx.chunks[i].data.data_len);
     }
     len += ctx.chunks[i].data.data_len;
   }
@@ -2409,7 +2555,7 @@ receive_file_data_sync (guestfs_h *g, void **buf, size_t *len_r)
 
 static int
 select_add_handle (guestfs_main_loop *mlv, guestfs_h *g, int fd, int events,
-		   guestfs_handle_event_cb cb, void *data)
+                   guestfs_handle_event_cb cb, void *data)
 {
   struct select_main_loop *ml = (struct select_main_loop *) mlv;
 
@@ -2419,9 +2565,9 @@ select_add_handle (guestfs_main_loop *mlv, guestfs_h *g, int fd, int events,
   }
 
   if ((events & ~(GUESTFS_HANDLE_READABLE |
-		  GUESTFS_HANDLE_WRITABLE |
-		  GUESTFS_HANDLE_HANGUP |
-		  GUESTFS_HANDLE_ERROR)) != 0) {
+                  GUESTFS_HANDLE_WRITABLE |
+                  GUESTFS_HANDLE_HANGUP |
+                  GUESTFS_HANDLE_ERROR)) != 0) {
     error (g, _("set of events (0x%x) contains unknown events"), events);
     return -1;
   }
@@ -2454,7 +2600,7 @@ select_add_handle (guestfs_main_loop *mlv, guestfs_h *g, int fd, int events,
     ml->max_fd = fd;
     ml->handle_cb_data =
       safe_realloc (g, ml->handle_cb_data,
-		    sizeof (struct select_handle_cb_data) * (ml->max_fd+1));
+                    sizeof (struct select_handle_cb_data) * (ml->max_fd+1));
   }
   ml->handle_cb_data[fd].cb = cb;
   ml->handle_cb_data[fd].g = g;
@@ -2491,7 +2637,7 @@ select_remove_handle (guestfs_main_loop *mlv, guestfs_h *g, int fd)
     ml->max_fd--;
     ml->handle_cb_data =
       safe_realloc (g, ml->handle_cb_data,
-		    sizeof (struct select_handle_cb_data) * (ml->max_fd+1));
+                    sizeof (struct select_handle_cb_data) * (ml->max_fd+1));
   }
 
   ml->nr_fds--;
@@ -2500,8 +2646,9 @@ select_remove_handle (guestfs_main_loop *mlv, guestfs_h *g, int fd)
 }
 
 static int
+__attribute__((noreturn))
 select_add_timeout (guestfs_main_loop *mlv, guestfs_h *g, int interval,
-		    guestfs_handle_timeout_cb cb, void *data)
+                    guestfs_handle_timeout_cb cb, void *data)
 {
   //struct select_main_loop *ml = (struct select_main_loop *) mlv;
 
@@ -2509,6 +2656,7 @@ select_add_timeout (guestfs_main_loop *mlv, guestfs_h *g, int interval,
 }
 
 static int
+__attribute__((noreturn))
 select_remove_timeout (guestfs_main_loop *mlv, guestfs_h *g, int timer)
 {
   //struct select_main_loop *ml = (struct select_main_loop *) mlv;
@@ -2544,7 +2692,7 @@ select_main_loop_run (guestfs_main_loop *mlv, guestfs_h *g)
     r = select (ml->max_fd+1, &rset2, &wset2, &xset2, NULL);
     if (r == -1) {
       if (errno == EINTR || errno == EAGAIN)
-	continue;
+        continue;
       perrorf (g, "select");
       ml->is_running = 0;
       return -1;
@@ -2553,17 +2701,17 @@ select_main_loop_run (guestfs_main_loop *mlv, guestfs_h *g)
     for (fd = 0; r > 0 && fd <= ml->max_fd; ++fd) {
       events = 0;
       if (FD_ISSET (fd, &rset2))
-	events |= GUESTFS_HANDLE_READABLE;
+        events |= GUESTFS_HANDLE_READABLE;
       if (FD_ISSET (fd, &wset2))
-	events |= GUESTFS_HANDLE_WRITABLE;
+        events |= GUESTFS_HANDLE_WRITABLE;
       if (FD_ISSET (fd, &xset2))
-	events |= GUESTFS_HANDLE_ERROR | GUESTFS_HANDLE_HANGUP;
+        events |= GUESTFS_HANDLE_ERROR | GUESTFS_HANDLE_HANGUP;
       if (events) {
-	r--;
-	ml->handle_cb_data[fd].cb ((guestfs_main_loop *) ml,
-				   ml->handle_cb_data[fd].g,
-				   ml->handle_cb_data[fd].data,
-				   fd, fd, events);
+        r--;
+        ml->handle_cb_data[fd].cb ((guestfs_main_loop *) ml,
+                                   ml->handle_cb_data[fd].g,
+                                   ml->handle_cb_data[fd].data,
+                                   fd, fd, events);
       }
     }
   }