X-Git-Url: http://git.annexia.org/?p=libguestfs.git;a=blobdiff_plain;f=src%2Fguestfs.c;h=4dc8dec7c98c46f7eb338b270aa1fd18c400b54d;hp=e18021f7f26d8c29bbbbbf20c2e3bb6d36099767;hb=5f8c46db05966a6e31b696d629fd3f74e4fb6c71;hpb=b6233d1fff5d9a6bbc61e7123a57bdd7d8cbc792

diff --git a/src/guestfs.c b/src/guestfs.c
index e18021f..4dc8dec 100644
--- a/src/guestfs.c
+++ b/src/guestfs.c
@@ -19,6 +19,7 @@
 #include <config.h>
 
 #define _BSD_SOURCE /* for mkdtemp, usleep */
+#define _GNU_SOURCE /* for vasprintf, GNU strerror_r, strchrnul */
 
 #include <stdio.h>
 #include <stdlib.h>
@@ -27,6 +28,12 @@
 #include <ctype.h>
 #include <string.h>
 #include <fcntl.h>
+#include <time.h>
+#include <sys/stat.h>
+#include <sys/select.h>
+
+#include <rpc/types.h>
+#include <rpc/xdr.h>
 
 #ifdef HAVE_ERRNO_H
 #include <errno.h>
@@ -49,188 +56,429 @@
 #endif
 
 #include "guestfs.h"
+#include "guestfs_protocol.h"
+
+#define error guestfs_error
+#define perrorf guestfs_perrorf
+#define safe_malloc guestfs_safe_malloc
+#define safe_realloc guestfs_safe_realloc
+#define safe_strdup guestfs_safe_strdup
+#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);
+static void sock_read_event (struct guestfs_main_loop *ml, guestfs_h *g, void *data, int watch, int fd, int events);
+static void sock_write_event (struct guestfs_main_loop *ml, guestfs_h *g, void *data, int watch, int fd, int events);
+
+static void close_handles (void);
+
+static int select_add_handle (guestfs_main_loop *ml, guestfs_h *g, int fd, int events, guestfs_handle_event_cb cb, void *data);
+static int select_remove_handle (guestfs_main_loop *ml, guestfs_h *g, int watch);
+static int select_add_timeout (guestfs_main_loop *ml, guestfs_h *g, int interval, guestfs_handle_timeout_cb cb, void *data);
+static int select_remove_timeout (guestfs_main_loop *ml, guestfs_h *g, int timer);
+static int select_main_loop_run (guestfs_main_loop *ml, guestfs_h *g);
+static int select_main_loop_quit (guestfs_main_loop *ml, guestfs_h *g);
+
+/* Default select-based main loop. */
+struct select_handle_cb_data {
+  guestfs_handle_event_cb cb;
+  guestfs_h *g;
+  void *data;
+};
+
+struct select_main_loop {
+  /* NB. These fields must be the same as in struct guestfs_main_loop: */
+  guestfs_add_handle_cb add_handle;
+  guestfs_remove_handle_cb remove_handle;
+  guestfs_add_timeout_cb add_timeout;
+  guestfs_remove_timeout_cb remove_timeout;
+  guestfs_main_loop_run_cb main_loop_run;
+  guestfs_main_loop_quit_cb main_loop_quit;
+
+  /* Additional private data: */
+  int is_running;
+
+  fd_set rset;
+  fd_set wset;
+  fd_set xset;
+
+  int max_fd;
+  int nr_fds;
+  struct select_handle_cb_data *handle_cb_data;
+};
+
+/* Default main loop. */
+static struct select_main_loop default_main_loop = {
+  .add_handle = select_add_handle,
+  .remove_handle = select_remove_handle,
+  .add_timeout = select_add_timeout,
+  .remove_timeout = select_remove_timeout,
+  .main_loop_run = select_main_loop_run,
+  .main_loop_quit = select_main_loop_quit,
+
+  /* XXX hopefully .rset, .wset, .xset are initialized to the empty
+   * set by the normal action of everything being initialized to zero.
+   */
+  .is_running = 0,
+  .max_fd = -1,
+  .nr_fds = 0,
+  .handle_cb_data = NULL,
+};
 
-static int error (guestfs_h *g, const char *fs, ...);
-static int perrorf (guestfs_h *g, const char *fs, ...);
-static void *safe_malloc (guestfs_h *g, int nbytes);
-static void *safe_realloc (guestfs_h *g, void *ptr, int nbytes);
-static char *safe_strdup (guestfs_h *g, const char *str);
+#define UNIX_PATH_MAX 108
+
+/* Also in guestfsd.c */
+#define VMCHANNEL_PORT 6666
+#define VMCHANNEL_ADDR "10.0.2.4"
 
 /* GuestFS handle and connection. */
+enum state { CONFIG, LAUNCHING, READY, BUSY, NO_HANDLE };
+
 struct guestfs_h
 {
-  /* All these socks/pids are -1 if not connected. */
+  struct guestfs_h *next;	/* Linked list of open handles. */
+
+  /* State: see the state machine diagram in the man page guestfs(3). */
+  enum state state;
+
+  int fd[2];			/* Stdin/stdout of qemu. */
   int sock;			/* Daemon communications socket. */
   int pid;			/* Qemu PID. */
+  time_t start_t;		/* The time when we started qemu. */
+
+  int stdout_watch;		/* Watches qemu stdout for log messages. */
+  int sock_watch;		/* Watches daemon comm socket. */
 
-  char *tmpdir;			/* Temporary directory containing logfile
-				 * and socket.  Cleaned up unless there is
-				 * an error.
-				 */
+  char *tmpdir;			/* Temporary directory containing socket. */
 
   char **cmdline;		/* Qemu command line. */
   int cmdline_size;
 
-  guestfs_abort_fn abort_fn;
-  int exit_on_error;
   int verbose;
+  int autosync;
+
+  const char *path;
+  const char *qemu;
+
+  char *last_error;
+
+  /* Callbacks. */
+  guestfs_abort_cb           abort_cb;
+  guestfs_error_handler_cb   error_cb;
+  void *                     error_cb_data;
+  guestfs_send_cb            send_cb;
+  void *                     send_cb_data;
+  guestfs_reply_cb           reply_cb;
+  void *                     reply_cb_data;
+  guestfs_log_message_cb     log_message_cb;
+  void *                     log_message_cb_data;
+  guestfs_subprocess_quit_cb subprocess_quit_cb;
+  void *                     subprocess_quit_cb_data;
+  guestfs_launch_done_cb     launch_done_cb;
+  void *                     launch_done_cb_data;
+
+  /* Main loop used by this handle. */
+  guestfs_main_loop *main_loop;
+
+  /* Messages sent and received from the daemon. */
+  char *msg_in;
+  int msg_in_size, msg_in_allocated;
+  char *msg_out;
+  int msg_out_size, msg_out_pos;
+
+  int msg_next_serial;
 };
 
+static guestfs_h *handles = NULL;
+static int atexit_handler_set = 0;
+
 guestfs_h *
 guestfs_create (void)
 {
   guestfs_h *g;
+  const char *str;
 
   g = malloc (sizeof (*g));
   if (!g) return NULL;
 
+  memset (g, 0, sizeof (*g));
+
+  g->state = CONFIG;
+
+  g->fd[0] = -1;
+  g->fd[1] = -1;
   g->sock = -1;
-  g->pid = -1;
+  g->stdout_watch = -1;
+  g->sock_watch = -1;
+
+  g->abort_cb = abort;
+  g->error_cb = default_error_cb;
+  g->error_cb_data = NULL;
+
+  str = getenv ("LIBGUESTFS_DEBUG");
+  g->verbose = str != NULL && strcmp (str, "1") == 0;
+
+  str = getenv ("LIBGUESTFS_PATH");
+  g->path = str != NULL ? str : GUESTFS_DEFAULT_PATH;
 
-  g->tmpdir = NULL;
+  str = getenv ("LIBGUESTFS_QEMU");
+  g->qemu = str != NULL ? str : QEMU;
 
-  g->abort_fn = abort;		/* Have to set these before safe_malloc. */
-  g->exit_on_error = 0;
-  g->verbose = getenv ("LIBGUESTFS_VERBOSE") != NULL;
+  g->main_loop = guestfs_get_default_main_loop ();
+
+  /* Start with large serial numbers so they are easy to spot
+   * inside the protocol.
+   */
+  g->msg_next_serial = 0x00123400;
+
+  /* Link the handles onto a global list.  This is the one area
+   * where the library needs to be made thread-safe. (XXX)
+   */
+  /* acquire mutex (XXX) */
+  g->next = handles;
+  handles = g;
+  if (!atexit_handler_set) {
+    atexit (close_handles);
+    atexit_handler_set = 1;
+  }
+  /* release mutex (XXX) */
 
-  g->cmdline = safe_malloc (g, sizeof (char *) * 1);
-  g->cmdline_size = 1;
-  g->cmdline[0] = NULL;		/* This is chosen by guestfs_launch. */
+  if (g->verbose)
+    fprintf (stderr, "new guestfs handle %p\n", g);
 
   return g;
 }
 
 void
-guestfs_free (guestfs_h *g)
+guestfs_close (guestfs_h *g)
 {
   int i;
   char filename[256];
+  guestfs_h *gg;
+
+  if (g->state == NO_HANDLE) {
+    /* Not safe to call 'error' here, so ... */
+    fprintf (stderr, "guestfs_close: called twice on the same handle\n");
+    return;
+  }
+
+  if (g->verbose)
+    fprintf (stderr, "closing guestfs handle %p (state %d)\n", g, g->state);
 
-  if (g->pid) guestfs_kill_subprocess (g);
+  /* Try to sync if autosync flag is set. */
+  if (g->autosync && g->state == READY)
+    guestfs_sync (g);
 
-  /* The assumption is that programs calling this have successfully
-   * used qemu, so delete the logfile and socket directory.
+  /* Remove any handlers that might be called back before we kill the
+   * subprocess.
    */
+  g->log_message_cb = NULL;
+
+  if (g->state != CONFIG)
+    guestfs_kill_subprocess (g);
+
   if (g->tmpdir) {
     snprintf (filename, sizeof filename, "%s/sock", g->tmpdir);
     unlink (filename);
 
-    snprintf (filename, sizeof filename, "%s/qemu.log", g->tmpdir);
-    unlink (filename);
-
     rmdir (g->tmpdir);
 
     free (g->tmpdir);
   }
 
-  for (i = 0; i < g->cmdline_size; ++i)
-    free (g->cmdline[i]);
-  free (g->cmdline);
+  if (g->cmdline) {
+    for (i = 0; i < g->cmdline_size; ++i)
+      free (g->cmdline[i]);
+    free (g->cmdline);
+  }
+
+  /* Mark the handle as dead before freeing it. */
+  g->state = NO_HANDLE;
+
+  /* acquire mutex (XXX) */
+  if (handles == g)
+    handles = g->next;
+  else {
+    for (gg = handles; gg->next != g; gg = gg->next)
+      ;
+    gg->next = g->next;
+  }
+  /* release mutex (XXX) */
 
+  free (g->last_error);
   free (g);
 }
 
-/* Cleanup fds and sockets, assuming the subprocess is dead already. */
+/* Close all open handles (called from atexit(3)). */
 static void
-cleanup_fds (guestfs_h *g)
+close_handles (void)
 {
-  if (g->sock >= 0) close (g->sock);
-  g->sock = -1;
+  while (handles) guestfs_close (handles);
+}
+
+const char *
+guestfs_last_error (guestfs_h *g)
+{
+  return g->last_error;
 }
 
-/* Wait for subprocess to exit. */
 static void
-wait_subprocess (guestfs_h *g)
+set_last_error (guestfs_h *g, const char *msg)
 {
-  if (g->pid >= 0) waitpid (g->pid, NULL, 0);
-  g->pid = -1;
+  free (g->last_error);
+  g->last_error = strdup (msg);
 }
 
-static int
-error (guestfs_h *g, const char *fs, ...)
+static void
+default_error_cb (guestfs_h *g, void *data, const char *msg)
+{
+  fprintf (stderr, "libguestfs: error: %s\n", msg);
+}
+
+void
+guestfs_error (guestfs_h *g, const char *fs, ...)
 {
   va_list args;
+  char *msg;
 
-  fprintf (stderr, "libguestfs: ");
   va_start (args, fs);
-  vfprintf (stderr, fs, args);
+  vasprintf (&msg, fs, args);
   va_end (args);
-  fputc ('\n', stderr);
 
-  if (g->exit_on_error) exit (1);
-  return -1;
+  if (g->error_cb) g->error_cb (g, g->error_cb_data, msg);
+  set_last_error (g, msg);
+
+  free (msg);
 }
 
-static int
-perrorf (guestfs_h *g, const char *fs, ...)
+void
+guestfs_perrorf (guestfs_h *g, const char *fs, ...)
 {
   va_list args;
-  char buf[256];
+  char *msg;
   int err = errno;
 
-  fprintf (stderr, "libguestfs: ");
   va_start (args, fs);
-  vfprintf (stderr, fs, args);
+  vasprintf (&msg, fs, args);
   va_end (args);
+
+#ifndef _GNU_SOURCE
+  char buf[256];
   strerror_r (err, buf, sizeof buf);
-  fprintf (stderr, ": %s\n", buf);
+#else
+  char _buf[256];
+  char *buf;
+  buf = strerror_r (err, _buf, sizeof _buf);
+#endif
 
-  if (g->exit_on_error) exit (1);
-  return -1;
+  msg = safe_realloc (g, msg, strlen (msg) + 2 + strlen (buf) + 1);
+  strcat (msg, ": ");
+  strcat (msg, buf);
+
+  if (g->error_cb) g->error_cb (g, g->error_cb_data, msg);
+  set_last_error (g, msg);
+
+  free (msg);
 }
 
-static void *
-safe_malloc (guestfs_h *g, int nbytes)
+void *
+guestfs_safe_malloc (guestfs_h *g, size_t nbytes)
 {
   void *ptr = malloc (nbytes);
-  if (!ptr) g->abort_fn ();
+  if (!ptr) g->abort_cb ();
   return ptr;
 }
 
-static void *
-safe_realloc (guestfs_h *g, void *ptr, int nbytes)
+void *
+guestfs_safe_realloc (guestfs_h *g, void *ptr, int nbytes)
 {
   void *p = realloc (ptr, nbytes);
-  if (!p) g->abort_fn ();
+  if (!p) g->abort_cb ();
   return p;
 }
 
-static char *
-safe_strdup (guestfs_h *g, const char *str)
+char *
+guestfs_safe_strdup (guestfs_h *g, const char *str)
 {
   char *s = strdup (str);
-  if (!s) g->abort_fn ();
+  if (!s) g->abort_cb ();
   return s;
 }
 
+void *
+guestfs_safe_memdup (guestfs_h *g, void *ptr, size_t size)
+{
+  void *p = malloc (size);
+  if (!p) g->abort_cb ();
+  memcpy (p, ptr, size);
+  return p;
+}
+
+static int
+xwrite (int fd, const void *buf, size_t len)
+{
+  int r;
+
+  while (len > 0) {
+    r = write (fd, buf, len);
+    if (r == -1)
+      return -1;
+
+    buf += r;
+    len -= r;
+  }
+
+  return 0;
+}
+
+static int
+xread (int fd, void *buf, size_t len)
+{
+  int r;
+
+  while (len > 0) {
+    r = read (fd, buf, len);
+    if (r == -1)
+      return -1;
+
+    buf += r;
+    len -= r;
+  }
+
+  return 0;
+}
+
 void
-guestfs_set_out_of_memory_handler (guestfs_h *g, guestfs_abort_fn a)
+guestfs_set_out_of_memory_handler (guestfs_h *g, guestfs_abort_cb cb)
 {
-  g->abort_fn = a;
+  g->abort_cb = cb;
 }
 
-guestfs_abort_fn
+guestfs_abort_cb
 guestfs_get_out_of_memory_handler (guestfs_h *g)
 {
-  return g->abort_fn;
+  return g->abort_cb;
 }
 
 void
-guestfs_set_exit_on_error (guestfs_h *g, int e)
+guestfs_set_error_handler (guestfs_h *g, guestfs_error_handler_cb cb, void *data)
 {
-  g->exit_on_error = e;
+  g->error_cb = cb;
+  g->error_cb_data = data;
 }
 
-int
-guestfs_get_exit_on_error (guestfs_h *g)
+guestfs_error_handler_cb
+guestfs_get_error_handler (guestfs_h *g, void **data_rtn)
 {
-  return g->exit_on_error;
+  if (data_rtn) *data_rtn = g->error_cb_data;
+  return g->error_cb;
 }
 
-void
+int
 guestfs_set_verbose (guestfs_h *g, int v)
 {
-  g->verbose = v;
+  g->verbose = !!v;
+  return 0;
 }
 
 int
@@ -239,17 +487,76 @@ guestfs_get_verbose (guestfs_h *g)
   return g->verbose;
 }
 
-/* Add an escaped string to the current command line. */
-static int
-add_cmdline (guestfs_h *g, const char *str)
+int
+guestfs_set_autosync (guestfs_h *g, int a)
+{
+  g->autosync = !!a;
+  return 0;
+}
+
+int
+guestfs_get_autosync (guestfs_h *g)
+{
+  return g->autosync;
+}
+
+int
+guestfs_set_path (guestfs_h *g, const char *path)
+{
+  if (path == NULL)
+    g->path = GUESTFS_DEFAULT_PATH;
+  else
+    g->path = path;
+  return 0;
+}
+
+const char *
+guestfs_get_path (guestfs_h *g)
+{
+  return g->path;
+}
+
+int
+guestfs_set_qemu (guestfs_h *g, const char *qemu)
+{
+  if (qemu == NULL)
+    g->qemu = QEMU;
+  else
+    g->qemu = qemu;
+  return 0;
+}
+
+const char *
+guestfs_get_qemu (guestfs_h *g)
+{
+  return g->qemu;
+}
+
+/* Add a string to the current command line. */
+static void
+incr_cmdline_size (guestfs_h *g)
 {
-  if (g->pid >= 0)
-    return error (g, "command line cannot be altered after qemu subprocess launched");
+  if (g->cmdline == NULL) {
+    /* g->cmdline[0] is reserved for argv[0], set in guestfs_launch. */
+    g->cmdline_size = 1;
+    g->cmdline = safe_malloc (g, sizeof (char *));
+    g->cmdline[0] = NULL;
+  }
 
   g->cmdline_size++;
   g->cmdline = safe_realloc (g, g->cmdline, sizeof (char *) * g->cmdline_size);
-  g->cmdline[g->cmdline_size-1] = safe_strdup (g, str);
+}
+
+static int
+add_cmdline (guestfs_h *g, const char *str)
+{
+  if (g->state != CONFIG) {
+    error (g, "command line cannot be altered after qemu subprocess launched");
+    return -1;
+  }
 
+  incr_cmdline_size (g);
+  g->cmdline[g->cmdline_size-1] = safe_strdup (g, str);
   return 0;
 }
 
@@ -257,8 +564,10 @@ int
 guestfs_config (guestfs_h *g,
 		const char *qemu_param, const char *qemu_value)
 {
-  if (qemu_param[0] != '-')
-    return error (g, "guestfs_config: parameter must begin with '-' character");
+  if (qemu_param[0] != '-') {
+    error (g, "guestfs_config: parameter must begin with '-' character");
+    return -1;
+  }
 
   /* A bit fascist, but the user will probably break the extra
    * parameters that we add if they try to set any of these.
@@ -270,8 +579,10 @@ guestfs_config (guestfs_h *g,
       strcmp (qemu_param, "-vnc") == 0 ||
       strcmp (qemu_param, "-full-screen") == 0 ||
       strcmp (qemu_param, "-std-vga") == 0 ||
-      strcmp (qemu_param, "-vnc") == 0)
-    return error (g, "guestfs_config: parameter '%s' isn't allowed");
+      strcmp (qemu_param, "-vnc") == 0) {
+    error (g, "guestfs_config: parameter '%s' isn't allowed", qemu_param);
+    return -1;
+  }
 
   if (add_cmdline (g, qemu_param) != 0) return -1;
 
@@ -288,10 +599,17 @@ guestfs_add_drive (guestfs_h *g, const char *filename)
   int len = strlen (filename) + 64;
   char buf[len];
 
-  if (strchr (filename, ',') != NULL)
-    return error (g, "filename cannot contain ',' (comma) character");
+  if (strchr (filename, ',') != NULL) {
+    error (g, "filename cannot contain ',' (comma) character");
+    return -1;
+  }
+
+  if (access (filename, F_OK) == -1) {
+    perrorf (g, "%s", filename);
+    return -1;
+  }
 
-  snprintf (buf, len, "file=%s,media=disk", filename);
+  snprintf (buf, len, "file=%s", filename);
 
   return guestfs_config (g, "-drive", buf);
 }
@@ -299,210 +617,1460 @@ guestfs_add_drive (guestfs_h *g, const char *filename)
 int
 guestfs_add_cdrom (guestfs_h *g, const char *filename)
 {
-  int len = strlen (filename) + 64;
-  char buf[len];
-
-  if (strchr (filename, ',') != NULL)
-    return error (g, "filename cannot contain ',' (comma) character");
+  if (strchr (filename, ',') != NULL) {
+    error (g, "filename cannot contain ',' (comma) character");
+    return -1;
+  }
 
-  snprintf (buf, len, "file=%s,if=ide,index=1,media=cdrom", filename);
+  if (access (filename, F_OK) == -1) {
+    perrorf (g, "%s", filename);
+    return -1;
+  }
 
-  return guestfs_config (g, "-drive", buf);
+  return guestfs_config (g, "-cdrom", filename);
 }
 
 int
 guestfs_launch (guestfs_h *g)
 {
   static const char *dir_template = "/tmp/libguestfsXXXXXX";
-  int r, i;
-  const char *qemu = QEMU;	/* XXX */
-  const char *kernel = "/boot/vmlinuz-2.6.27.15-170.2.24.fc10.x86_64";
-  const char *initrd = "/boot/initrd-2.6.27.15-170.2.24.fc10.x86_64.img";
+  int r, i, len, pmore, memsize;
+  int wfd[2], rfd[2];
+  int tries;
+  const char *kernel_name = "vmlinuz." REPO "." host_cpu;
+  const char *initrd_name = "initramfs." REPO "." host_cpu ".img";
+  char *path, *pelem, *pend;
+  char *kernel = NULL, *initrd = NULL;
   char unixsock[256];
-  char vmchannel[256];
-  char tmpfile[256];
+  struct sockaddr_un addr;
+  struct stat statbuf;
+
+  /* Configured? */
+  if (!g->cmdline) {
+    error (g, "you must call guestfs_add_drive before guestfs_launch");
+    return -1;
+  }
+
+  if (g->state != CONFIG) {
+    error (g, "qemu has already been launched");
+    return -1;
+  }
+
+  /* Search g->path for the kernel and initrd. */
+  pelem = path = safe_strdup (g, g->path);
+  do {
+    pend = strchrnul (pelem, ':');
+    pmore = *pend == ':';
+    *pend = '\0';
+    len = pend - pelem;
+
+    /* Empty element or "." means cwd. */
+    if (len == 0 || (len == 1 && *pelem == '.')) {
+      if (g->verbose)
+	fprintf (stderr,
+		 "looking for kernel and initrd in current directory\n");
+      if (access (kernel_name, F_OK) == 0 && access (initrd_name, F_OK) == 0) {
+	kernel = safe_strdup (g, kernel_name);
+	initrd = safe_strdup (g, initrd_name);
+	break;
+      }
+    }
+    /* Look at <path>/kernel etc. */
+    else {
+      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);
+
+      if (g->verbose)
+	fprintf (stderr, "looking for %s and %s\n", kernel, initrd);
+
+      if (access (kernel, F_OK) == 0 && access (initrd, F_OK) == 0)
+	break;
+      free (kernel);
+      free (initrd);
+      kernel = initrd = NULL;
+    }
+
+    pelem = pend + 1;
+  } while (pmore);
+
+  free (path);
+
+  if (kernel == NULL || initrd == NULL) {
+    error (g, "cannot find %s or %s on LIBGUESTFS_PATH (current path = %s)",
+	   kernel_name, initrd_name, g->path);
+    goto cleanup0;
+  }
+
+  /* Choose a suitable memory size (in MB).  This is more art
+   * than science, but you can help by doing
+   *   ./configure --enable-debug-command
+   * and then running:
+   *   debug sh free
+   *   debug mem ''
+   * and seeing how much free memory is left for particular
+   * configurations.
+   *
+   * It's also helpful to report both the compressed and uncompressed
+   * size of the initramfs (ls -lh initramfs*.img; du -sh initramfs).
+   *
+   * XXX KVM virtio balloon driver?
+   */
+  if (stat (initrd, &statbuf) != -1) {
+    /* Approximate size of the initramfs after it is decompressed
+     * in kernel memory.  The compression factor is ~2.5-3.
+     */
+    memsize = 3 * statbuf.st_size / 1024 / 1024;
+
+    /* Approximate size used by the kernel. */
+    memsize += 10;
+
+    /* Want to give userspace some room, so: */
+    memsize += 128;
 
-  /* XXX Choose which qemu to run. */
-  /* XXX Choose initrd, etc. */
+#if AC_SIZEOF_LONG == 8
+    /* On 64 bit, assume some overhead. */
+    memsize += 32;
+#endif
+  } else
+    memsize = 512;
+  
 
-  /* Make the temporary directory containing the logfile and socket. */
+  /* Make the temporary directory containing the socket. */
   if (!g->tmpdir) {
     g->tmpdir = safe_strdup (g, dir_template);
-    if (mkdtemp (g->tmpdir) == NULL)
-      return perrorf (g, "%s: cannot create temporary directory", dir_template);
+    if (mkdtemp (g->tmpdir) == NULL) {
+      perrorf (g, "%s: cannot create temporary directory", dir_template);
+      goto cleanup0;
+    }
+  }
+
+  snprintf (unixsock, sizeof unixsock, "%s/sock", g->tmpdir);
+  unlink (unixsock);
 
-    snprintf (unixsock, sizeof unixsock, "%s/sock", g->tmpdir);
+  if (pipe (wfd) == -1 || pipe (rfd) == -1) {
+    perrorf (g, "pipe");
+    goto cleanup0;
   }
 
   r = fork ();
-  if (r == -1)
-    return perrorf (g, "fork");
+  if (r == -1) {
+    perrorf (g, "fork");
+    close (wfd[0]);
+    close (wfd[1]);
+    close (rfd[0]);
+    close (rfd[1]);
+    goto cleanup0;
+  }
 
-  if (r > 0) {			/* Parent (library). */
-    g->pid = r;
+  if (r == 0) {			/* Child (qemu). */
+    char vmchannel[256];
+    char append[256];
+    char memsize_str[256];
 
-    /* If qemu is going to die during startup, give it a tiny amount of
-     * time to print the error message.
-     */
-    usleep (10000);
-  } else {			/* Child (qemu). */
     /* Set up the full command line.  Do this in the subprocess so we
      * don't need to worry about cleaning up.
      */
-    g->cmdline[0] = (char *) qemu;
-
-    g->cmdline = realloc (g->cmdline, sizeof (char *) * (g->cmdline_size + 14));
-    if (g->cmdline == NULL) {
-      perror ("realloc");
-      _exit (1);
-    }
+    g->cmdline[0] = (char *) g->qemu;
 
+    /* Construct the -net channel parameter for qemu. */
     snprintf (vmchannel, sizeof vmchannel,
-	      "channel,%d:unix:%s,server,nowait", 666, unixsock);
-
-    g->cmdline[g->cmdline_size   ] = "-kernel";
-    g->cmdline[g->cmdline_size+ 1] = (char *) kernel;
-    g->cmdline[g->cmdline_size+ 2] = "-initrd";
-    g->cmdline[g->cmdline_size+ 3] = (char *) initrd;
-    g->cmdline[g->cmdline_size+ 4] = "-append";
-    g->cmdline[g->cmdline_size+ 5] = "console=ttyS0";
-    g->cmdline[g->cmdline_size+ 6] = "-nographic";
-    g->cmdline[g->cmdline_size+ 7] = "-serial";
-    g->cmdline[g->cmdline_size+ 8] = "stdio";
-    g->cmdline[g->cmdline_size+ 9] = "-net";
-    g->cmdline[g->cmdline_size+10] = vmchannel;
-    g->cmdline[g->cmdline_size+11] = "-net";
-    g->cmdline[g->cmdline_size+12] = "user,vlan0";
-    g->cmdline[g->cmdline_size+13] = NULL;
+	      "channel,%d:unix:%s,server,nowait",
+	      VMCHANNEL_PORT, unixsock);
+
+    /* Linux kernel command line. */
+    snprintf (append, sizeof append,
+	      "console=ttyS0 guestfs=%s:%d%s",
+	      VMCHANNEL_ADDR, VMCHANNEL_PORT,
+	      g->verbose ? " guestfs_verbose=1" : "");
+
+    snprintf (memsize_str, sizeof memsize_str, "%d", memsize);
+
+    add_cmdline (g, "-m");
+    add_cmdline (g, memsize_str);
+#if 0
+    add_cmdline (g, "-no-kqemu"); /* Avoids a warning. */
+#endif
+    add_cmdline (g, "-kernel");
+    add_cmdline (g, (char *) kernel);
+    add_cmdline (g, "-initrd");
+    add_cmdline (g, (char *) initrd);
+    add_cmdline (g, "-append");
+    add_cmdline (g, append);
+    add_cmdline (g, "-nographic");
+    add_cmdline (g, "-serial");
+    add_cmdline (g, "stdio");
+    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=rtl8139,vlan=0");
+    incr_cmdline_size (g);
+    g->cmdline[g->cmdline_size-1] = NULL;
 
     if (g->verbose) {
-      fprintf (stderr, "Running %s", qemu);
+      fprintf (stderr, "%s", g->qemu);
       for (i = 0; g->cmdline[i]; ++i)
 	fprintf (stderr, " %s", g->cmdline[i]);
       fprintf (stderr, "\n");
     }
 
-    /* Set up stdin, stdout.  Messages should go to the logfile. */
+    /* Set up stdin, stdout. */
     close (0);
     close (1);
-    open ("/dev/null", O_RDONLY);
-    snprintf (tmpfile, sizeof tmpfile, "%s/qemu.log", g->tmpdir);
-    open (tmpfile, O_WRONLY|O_CREAT|O_APPEND, 0644);
-    /*dup2 (1, 2);*/
+    close (wfd[1]);
+    close (rfd[0]);
+    dup (wfd[0]);
+    dup (rfd[1]);
+    close (wfd[0]);
+    close (rfd[1]);
+
+#if 0
+    /* Set up a new process group, so we can signal this process
+     * and all subprocesses (eg. if qemu is really a shell script).
+     */
+    setpgid (0, 0);
+#endif
 
-    execv (qemu, g->cmdline);	/* Run qemu. */
-    perror (qemu);
+    execv (g->qemu, g->cmdline); /* Run qemu. */
+    perror (g->qemu);
     _exit (1);
   }
 
+  /* Parent (library). */
+  g->pid = r;
+
+  /* Start the clock ... */
+  time (&g->start_t);
+
+  /* Close the other ends of the pipe. */
+  close (wfd[0]);
+  close (rfd[1]);
+
+  if (fcntl (wfd[1], F_SETFL, O_NONBLOCK) == -1 ||
+      fcntl (rfd[0], F_SETFL, O_NONBLOCK) == -1) {
+    perrorf (g, "fcntl");
+    goto cleanup1;
+  }
+
+  g->fd[0] = wfd[1];		/* stdin of child */
+  g->fd[1] = rfd[0];		/* stdout of child */
+
+  /* Open the Unix socket.  The vmchannel implementation that got
+   * merged with qemu sucks in a number of ways.  Both ends do
+   * connect(2), which means that no one knows what, if anything, is
+   * connected to the other end, or if it becomes disconnected.  Even
+   * worse, we have to wait some indeterminate time for qemu to create
+   * the socket and connect to it (which happens very early in qemu's
+   * start-up), so any code that uses vmchannel is inherently racy.
+   * Hence this silly loop.
+   */
+  g->sock = socket (AF_UNIX, SOCK_STREAM, 0);
+  if (g->sock == -1) {
+    perrorf (g, "socket");
+    goto cleanup1;
+  }
+
+  if (fcntl (g->sock, F_SETFL, O_NONBLOCK) == -1) {
+    perrorf (g, "fcntl");
+    goto cleanup2;
+  }
+
+  addr.sun_family = AF_UNIX;
+  strncpy (addr.sun_path, unixsock, UNIX_PATH_MAX);
+  addr.sun_path[UNIX_PATH_MAX-1] = '\0';
+
+  tries = 100;
+  while (tries > 0) {
+    /* Always sleep at least once to give qemu a small chance to start up. */
+    usleep (10000);
+
+    r = connect (g->sock, (struct sockaddr *) &addr, sizeof addr);
+    if ((r == -1 && errno == EINPROGRESS) || r == 0)
+      goto connected;
+
+    if (errno != ENOENT)
+      perrorf (g, "connect");
+    tries--;
+  }
+
+  error (g, "failed to connect to vmchannel socket");
+  goto cleanup2;
+
+ connected:
+  /* Watch the file descriptors. */
+  free (g->msg_in);
+  g->msg_in = NULL;
+  g->msg_in_size = g->msg_in_allocated = 0;
+
+  free (g->msg_out);
+  g->msg_out = NULL;
+  g->msg_out_size = 0;
+  g->msg_out_pos = 0;
+
+  g->stdout_watch =
+    g->main_loop->add_handle (g->main_loop, g, g->fd[1],
+			      GUESTFS_HANDLE_READABLE,
+			      stdout_event, NULL);
+  if (g->stdout_watch == -1) {
+    error (g, "could not watch qemu stdout");
+    goto cleanup3;
+  }
+
+  if (guestfs__switch_to_receiving (g) == -1)
+    goto cleanup3;
+
+  g->state = LAUNCHING;
   return 0;
+
+ cleanup3:
+  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);
+
+ cleanup2:
+  close (g->sock);
+
+ cleanup1:
+  close (wfd[1]);
+  close (rfd[0]);
+  kill (g->pid, 9);
+  waitpid (g->pid, NULL, 0);
+  g->fd[0] = -1;
+  g->fd[1] = -1;
+  g->sock = -1;
+  g->pid = 0;
+  g->start_t = 0;
+  g->stdout_watch = -1;
+  g->sock_watch = -1;
+
+ cleanup0:
+  free (kernel);
+  free (initrd);
+  return -1;
 }
 
-#define UNIX_PATH_MAX 108
+static void
+finish_wait_ready (guestfs_h *g, void *vp)
+{
+  if (g->verbose)
+    fprintf (stderr, "finish_wait_ready called, %p, vp = %p\n", g, vp);
+
+  *((int *)vp) = 1;
+  g->main_loop->main_loop_quit (g->main_loop, g);
+}
 
 int
 guestfs_wait_ready (guestfs_h *g)
 {
-  int r, i, lsock;
-  struct sockaddr_un addr;
+  int finished = 0, r;
 
-  if (guestfs_ready (g)) return 0;
+  if (g->state == READY) return 0;
 
-  /* Launch the subprocess, if there isn't one already. */
-  if (g->pid == -1) {
-    if (guestfs_launch (g) != 0)
-      return -1;
+  if (g->state == BUSY) {
+    error (g, "qemu has finished launching already");
+    return -1;
   }
 
-  if (g->sock >= 0) {
-    close (g->sock);
-    g->sock = -1;
+  if (g->state != LAUNCHING) {
+    error (g, "qemu has not been launched yet");
+    return -1;
   }
 
-  lsock = socket (AF_UNIX, SOCK_STREAM, 0);
-  if (lsock == -1)
-    return perrorf (g, "socket");
+  g->launch_done_cb = finish_wait_ready;
+  g->launch_done_cb_data = &finished;
+  r = g->main_loop->main_loop_run (g->main_loop, g);
+  g->launch_done_cb = NULL;
+  g->launch_done_cb_data = NULL;
 
-  addr.sun_family = AF_UNIX;
-  snprintf (addr.sun_path, UNIX_PATH_MAX, "%s/sock", g->tmpdir);
+  if (r == -1) return -1;
 
-  if (bind (lsock, (struct sockaddr *) &addr, sizeof addr) == -1) {
-    perrorf (g, "bind");
-    close (lsock);
+  if (finished != 1) {
+    error (g, "guestfs_wait_ready failed, see earlier error messages");
     return -1;
   }
 
-  if (listen (lsock, 1) == -1) {
-    perrorf (g, "listen");
-    close (lsock);
+  /* This is possible in some really strange situations, such as
+   * guestfsd starts up OK but then qemu immediately exits.  Check for
+   * it because the caller is probably expecting to be able to send
+   * commands after this function returns.
+   */
+  if (g->state != READY) {
+    error (g, "qemu launched and contacted daemon, but state != READY");
     return -1;
   }
 
-  if (fcntl (lsock, F_SETFL, O_NONBLOCK) == -1) {
-    perrorf (g, "set socket non-blocking");
-    close (lsock);
+  return 0;
+}
+
+int
+guestfs_kill_subprocess (guestfs_h *g)
+{
+  if (g->state == CONFIG) {
+    error (g, "no subprocess to kill");
     return -1;
   }
 
-  /* Wait until the daemon running inside the guest connects to the
-   * Unix socket, which indicates it's alive.  Qemu might exit in the
-   * meantime if there is a problem.  More problematically qemu might
-   * hang, which we can only detect by timeout.
-   */
-  for (i = 0; i < 30; ++i) {
-    r = waitpid (g->pid, NULL, WNOHANG);
-
-    if (r > 0 || (r == -1 && errno == ECHILD)) {
-      error (g, "qemu subprocess exited unexpectedly during initialization");
-      g->pid = -1;
-      cleanup_fds (g);
-      close (lsock);
-      return -1;
-    }
+  if (g->verbose)
+    fprintf (stderr, "sending SIGTERM to process %d\n", g->pid);
 
-    r = accept (lsock, NULL, 0);
-    if (r >= 0) {
-      g->sock = r;
-      fcntl (g->sock, F_SETFL, O_NONBLOCK);
-      close (lsock);
-      return 0;
-    }
-    if (errno == EAGAIN) {
-      sleep (1);
-      continue;
-    }
-    perrorf (g, "accept");
-    close (lsock);
-    guestfs_kill_subprocess (g);
-    return -1;
-  }
+  kill (g->pid, SIGTERM);
 
-  close (lsock);
-  return error (g, "timeout waiting for guest to become ready");
+  return 0;
 }
 
+/* Access current state. */
 int
-guestfs_ready (guestfs_h *g)
+guestfs_is_config (guestfs_h *g)
 {
-  return
-    g->pid >= 0 &&
-    kill (g->pid, 0) == 0 &&
-    g->sock >= 0 /* &&
-    guestfs_ping_daemon (g) >= 0 */;
+  return g->state == CONFIG;
 }
 
 int
-guestfs_kill_subprocess (guestfs_h *g)
+guestfs_is_launching (guestfs_h *g)
 {
-  if (g->pid >= 0) {
-    if (g->verbose)
-      fprintf (stderr, "sending SIGINT to pid %d\n", g->pid);
+  return g->state == LAUNCHING;
+}
+
+int
+guestfs_is_ready (guestfs_h *g)
+{
+  return g->state == READY;
+}
+
+int
+guestfs_is_busy (guestfs_h *g)
+{
+  return g->state == BUSY;
+}
+
+int
+guestfs_get_state (guestfs_h *g)
+{
+  return g->state;
+}
+
+int
+guestfs_set_ready (guestfs_h *g)
+{
+  if (g->state != BUSY) {
+    error (g, "guestfs_set_ready: called when in state %d != BUSY", g->state);
+    return -1;
+  }
+  g->state = READY;
+  return 0;
+}
 
-    kill (g->pid, SIGINT);
-    wait_subprocess (g);
+int
+guestfs_set_busy (guestfs_h *g)
+{
+  if (g->state != READY) {
+    error (g, "guestfs_set_busy: called when in state %d != READY", g->state);
+    return -1;
   }
+  g->state = BUSY;
+  return 0;
+}
 
-  cleanup_fds (g);
+/* 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);
+}
+
+/* This function is called whenever qemu prints something on stdout.
+ * Qemu's stdout is also connected to the guest's serial console, so
+ * we see kernel messages here too.
+ */
+static void
+stdout_event (struct guestfs_main_loop *ml, guestfs_h *g, void *data,
+	      int watch, int fd, int events)
+{
+  char buf[4096];
+  int n;
+
+#if 0
+  if (g->verbose)
+    fprintf (stderr,
+	     "stdout_event: %p g->state = %d, fd = %d, events = 0x%x\n",
+	     g, g->state, fd, events);
+#endif
+
+  if (g->fd[1] != fd) {
+    error (g, "stdout_event: internal error: %d != %d", g->fd[1], fd);
+    return;
+  }
+
+  n = read (fd, buf, sizeof buf);
+  if (n == 0) {
+    /* Hopefully this indicates the qemu child process has died. */
+    if (g->verbose)
+      fprintf (stderr, "stdout_event: %p: child process died\n", g);
+    /*kill (g->pid, SIGTERM);*/
+    waitpid (g->pid, NULL, 0);
+    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);
+    close (g->fd[0]);
+    close (g->fd[1]);
+    close (g->sock);
+    g->fd[0] = -1;
+    g->fd[1] = -1;
+    g->sock = -1;
+    g->pid = 0;
+    g->start_t = 0;
+    g->stdout_watch = -1;
+    g->sock_watch = -1;
+    g->state = CONFIG;
+    if (g->subprocess_quit_cb)
+      g->subprocess_quit_cb (g, g->subprocess_quit_cb_data);
+    return;
+  }
+
+  if (n == -1) {
+    if (errno != EAGAIN)
+      perrorf (g, "read");
+    return;
+  }
+
+  /* In verbose mode, copy all log messages to stderr. */
+  if (g->verbose)
+    write (2, buf, n);
+
+  /* It's an actual log message, send it upwards if anyone is listening. */
+  if (g->log_message_cb)
+    g->log_message_cb (g, g->log_message_cb_data, buf, n);
+}
+
+/* The function is called whenever we can read something on the
+ * guestfsd (daemon inside the guest) communication socket.
+ */
+static void
+sock_read_event (struct guestfs_main_loop *ml, guestfs_h *g, void *data,
+		 int watch, int fd, int events)
+{
+  XDR xdr;
+  unsigned len;
+  int n;
+
+  if (g->verbose)
+    fprintf (stderr,
+	     "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);
+    return;
+  }
+
+  if (g->msg_in_size <= g->msg_in_allocated) {
+    g->msg_in_allocated += 4096;
+    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);
+  if (n == 0)
+    /* Disconnected?  Ignore it because stdout_watch will get called
+     * and will do the cleanup.
+     */
+    return;
+
+  if (n == -1) {
+    if (errno != EAGAIN)
+      perrorf (g, "read");
+    return;
+  }
+
+  g->msg_in_size += n;
+
+  /* Have we got enough of a message to be able to process it yet? */
+ again:
+  if (g->msg_in_size < 4) return;
+
+  xdrmem_create (&xdr, g->msg_in, g->msg_in_size, XDR_DECODE);
+  if (!xdr_uint32_t (&xdr, &len)) {
+    error (g, "can't decode length word");
+    goto cleanup;
+  }
+
+  /* Length is normally the length of the message, but when guestfsd
+   * starts up it sends a "magic" value (longer than any possible
+   * message).  Check for this.
+   */
+  if (len == GUESTFS_LAUNCH_FLAG) {
+    if (g->state != LAUNCHING)
+      error (g, "received magic signature from guestfsd, but in state %d",
+	     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);
+    else {
+      g->state = READY;
+      if (g->launch_done_cb)
+	g->launch_done_cb (g, g->launch_done_cb_data);
+    }
+
+    goto cleanup;
+  }
+
+  /* This can happen if a cancellation happens right at the end
+   * of us sending a FileIn parameter to the daemon.  Discard.  The
+   * daemon should send us an error message next.
+   */
+  if (len == GUESTFS_CANCEL_FLAG) {
+    g->msg_in_size -= 4;
+    memmove (g->msg_in, g->msg_in+4, g->msg_in_size);
+    goto again;
+  }
+
+  /* If this happens, it's pretty bad and we've probably lost
+   * synchronization.
+   */
+  if (len > GUESTFS_MESSAGE_MAX) {
+    error (g, "message length (%u) > maximum possible size (%d)",
+	   len, GUESTFS_MESSAGE_MAX);
+    goto cleanup;
+  }
+
+  if (g->msg_in_size-4 < len) return; /* Need more of this message. */
+
+  /* Got the full message, begin processing it. */
+  if (g->verbose) {
+    int i, j;
+
+    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]);
+      for (; j < i+16; ++j)
+	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 (".");
+      for (; j < i+16; ++j)
+	printf (" ");
+      printf ("|\n");
+    }
+  }
+
+  /* Not in the expected state. */
+  if (g->state != BUSY)
+    error (g, "state %d != BUSY", g->state);
+
+  /* Push the message up to the higher layer. */
+  if (g->reply_cb)
+    g->reply_cb (g, g->reply_cb_data, &xdr);
+
+  g->msg_in_size -= len + 4;
+  memmove (g->msg_in, g->msg_in+len+4, g->msg_in_size);
+  if (g->msg_in_size > 0) goto again;
+
+ cleanup:
+  /* Free the message buffer if it's grown excessively large. */
+  if (g->msg_in_allocated > 65536) {
+    free (g->msg_in);
+    g->msg_in = NULL;
+    g->msg_in_size = g->msg_in_allocated = 0;
+  } else
+    g->msg_in_size = 0;
+
+  xdr_destroy (&xdr);
+}
+
+/* The function is called whenever we can write something on the
+ * guestfsd (daemon inside the guest) communication socket.
+ */
+static void
+sock_write_event (struct guestfs_main_loop *ml, guestfs_h *g, void *data,
+		  int watch, int fd, int events)
+{
+  int n;
+
+  if (g->verbose)
+    fprintf (stderr,
+	     "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);
+    return;
+  }
+
+  if (g->state != BUSY) {
+    error (g, "sock_write_event: state %d != BUSY", g->state);
+    return;
+  }
+
+  if (g->verbose)
+    fprintf (stderr, "sock_write_event: writing %d bytes ...\n",
+	     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);
+  if (n == -1) {
+    if (errno != EAGAIN)
+      perrorf (g, "write");
+    return;
+  }
+
+  if (g->verbose)
+    fprintf (stderr, "sock_write_event: wrote %d bytes\n", n);
+
+  g->msg_out_pos += n;
+
+  /* More to write? */
+  if (g->msg_out_pos < g->msg_out_size)
+    return;
+
+  if (g->verbose)
+    fprintf (stderr, "sock_write_event: done writing, calling send_cb\n");
+
+  free (g->msg_out);
+  g->msg_out = NULL;
+  g->msg_out_pos = g->msg_out_size = 0;
+
+  /* Done writing, call the higher layer. */
+  if (g->send_cb)
+    g->send_cb (g, g->send_cb_data);
+}
+
+void
+guestfs_set_send_callback (guestfs_h *g,
+			   guestfs_send_cb cb, void *opaque)
+{
+  g->send_cb = cb;
+  g->send_cb_data = opaque;
+}
+
+void
+guestfs_set_reply_callback (guestfs_h *g,
+			    guestfs_reply_cb cb, void *opaque)
+{
+  g->reply_cb = cb;
+  g->reply_cb_data = opaque;
+}
+
+void
+guestfs_set_log_message_callback (guestfs_h *g,
+				  guestfs_log_message_cb cb, void *opaque)
+{
+  g->log_message_cb = cb;
+  g->log_message_cb_data = opaque;
+}
+
+void
+guestfs_set_subprocess_quit_callback (guestfs_h *g,
+				      guestfs_subprocess_quit_cb cb, void *opaque)
+{
+  g->subprocess_quit_cb = cb;
+  g->subprocess_quit_cb_data = opaque;
+}
+
+void
+guestfs_set_launch_done_callback (guestfs_h *g,
+				  guestfs_launch_done_cb cb, void *opaque)
+{
+  g->launch_done_cb = cb;
+  g->launch_done_cb_data = opaque;
+}
+
+/* Access to the handle's main loop and the default main loop. */
+void
+guestfs_set_main_loop (guestfs_h *g, guestfs_main_loop *main_loop)
+{
+  g->main_loop = main_loop;
+}
+
+guestfs_main_loop *
+guestfs_get_main_loop (guestfs_h *g)
+{
+  return g->main_loop;
+}
+
+guestfs_main_loop *
+guestfs_get_default_main_loop (void)
+{
+  return (guestfs_main_loop *) &default_main_loop;
+}
+
+/* Change the daemon socket handler so that we are now writing.
+ * This sets the handle to sock_write_event.
+ */
+int
+guestfs__switch_to_sending (guestfs_h *g)
+{
+  if (g->sock_watch >= 0) {
+    if (g->main_loop->remove_handle (g->main_loop, g, g->sock_watch) == -1) {
+      error (g, "remove_handle failed");
+      g->sock_watch = -1;
+      return -1;
+    }
+  }
+
+  g->sock_watch =
+    g->main_loop->add_handle (g->main_loop, g, g->sock,
+			      GUESTFS_HANDLE_WRITABLE,
+			      sock_write_event, NULL);
+  if (g->sock_watch == -1) {
+    error (g, "add_handle failed");
+    return -1;
+  }
+
+  return 0;
+}
+
+int
+guestfs__switch_to_receiving (guestfs_h *g)
+{
+  if (g->sock_watch >= 0) {
+    if (g->main_loop->remove_handle (g->main_loop, g, g->sock_watch) == -1) {
+      error (g, "remove_handle failed");
+      g->sock_watch = -1;
+      return -1;
+    }
+  }
+
+  g->sock_watch =
+    g->main_loop->add_handle (g->main_loop, g, g->sock,
+			      GUESTFS_HANDLE_READABLE,
+			      sock_read_event, NULL);
+  if (g->sock_watch == -1) {
+    error (g, "add_handle failed");
+    return -1;
+  }
+
+  return 0;
+}
+
+/* Dispatch a call (len + header + args) to the remote daemon,
+ * synchronously (ie. using the guest's main loop to wait until
+ * it has been sent).  Returns -1 for error, or the serial
+ * number of the message.
+ */
+static void
+send_cb (guestfs_h *g, void *data)
+{
+  guestfs_main_loop *ml = guestfs_get_main_loop (g);
+
+  *((int *)data) = 1;
+  ml->main_loop_quit (ml, g);
+}
+
+int
+guestfs__send_sync (guestfs_h *g, int proc_nr,
+		    xdrproc_t xdrp, char *args)
+{
+  char buffer[GUESTFS_MESSAGE_MAX];
+  struct guestfs_message_header hdr;
+  XDR xdr;
+  unsigned len;
+  int serial = g->msg_next_serial++;
+  int sent;
+  guestfs_main_loop *ml = guestfs_get_main_loop (g);
+
+  if (g->state != BUSY) {
+    error (g, "guestfs__send_sync: state %d != BUSY", g->state);
+    return -1;
+  }
+
+  /* Serialize the header. */
+  hdr.prog = GUESTFS_PROGRAM;
+  hdr.vers = GUESTFS_PROTOCOL_VERSION;
+  hdr.proc = proc_nr;
+  hdr.direction = GUESTFS_DIRECTION_CALL;
+  hdr.serial = serial;
+  hdr.status = GUESTFS_STATUS_OK;
+
+  xdrmem_create (&xdr, buffer, sizeof buffer, XDR_ENCODE);
+  if (!xdr_guestfs_message_header (&xdr, &hdr)) {
+    error (g, "xdr_guestfs_message_header failed");
+    return -1;
+  }
+
+  /* Serialize the args.  If any, because some message types
+   * have no parameters.
+   */
+  if (xdrp) {
+    if (!(*xdrp) (&xdr, args)) {
+      error (g, "dispatch failed to marshal args");
+      return -1;
+    }
+  }
+
+  len = xdr_getpos (&xdr);
+  xdr_destroy (&xdr);
+
+  /* Allocate the outgoing message buffer. */
+  g->msg_out = safe_malloc (g, len + 4);
+
+  g->msg_out_size = len + 4;
+  g->msg_out_pos = 0;
+
+  xdrmem_create (&xdr, g->msg_out, 4, XDR_ENCODE);
+  xdr_uint32_t (&xdr, &len);
+
+  memcpy (g->msg_out + 4, buffer, len);
+
+  if (guestfs__switch_to_sending (g) == -1)
+    goto cleanup1;
+
+  sent = 0;
+  guestfs_set_send_callback (g, send_cb, &sent);
+  if (ml->main_loop_run (ml, g) == -1)
+    goto cleanup1;
+  if (sent != 1) {
+    error (g, "send failed, see earlier error messages");
+    goto cleanup1;
+  }
+
+  return serial;
+
+ cleanup1:
+  free (g->msg_out);
+  g->msg_out = NULL;
+  g->msg_out_size = 0;
+  return -1;
+}
+
+static int cancel = 0; /* XXX Implement file cancellation. */
+static int send_file_chunk_sync (guestfs_h *g, int cancel, const char *buf, size_t len);
+static int send_file_data_sync (guestfs_h *g, const char *buf, size_t len);
+static int send_file_cancellation_sync (guestfs_h *g);
+static int send_file_complete_sync (guestfs_h *g);
+
+/* Synchronously send a file.
+ * Returns:
+ *   0 OK
+ *   -1 error
+ *   -2 daemon cancelled (we must read the error message)
+ */
+int
+guestfs__send_file_sync (guestfs_h *g, const char *filename)
+{
+  char buf[GUESTFS_MAX_CHUNK_SIZE];
+  int fd, r, err;
+
+  fd = open (filename, O_RDONLY);
+  if (fd == -1) {
+    perrorf (g, "open: %s", filename);
+    send_file_cancellation_sync (g);
+    /* Daemon sees cancellation and won't reply, so caller can
+     * just return here.
+     */
+    return -1;
+  }
+
+  /* Send file in chunked encoding. */
+  while (!cancel && (r = read (fd, buf, sizeof buf)) > 0) {
+    err = send_file_data_sync (g, buf, r);
+    if (err < 0) {
+      if (err == -2)		/* daemon sent cancellation */
+	send_file_cancellation_sync (g);
+      return err;
+    }
+  }
+
+  if (cancel) {			/* cancel from either end */
+    send_file_cancellation_sync (g);
+    return -1;
+  }
+
+  if (r == -1) {
+    perrorf (g, "read: %s", filename);
+    send_file_cancellation_sync (g);
+    return -1;
+  }
+
+  /* End of file, but before we send that, we need to close
+   * the file and check for errors.
+   */
+  if (close (fd) == -1) {
+    perrorf (g, "close: %s", filename);
+    send_file_cancellation_sync (g);
+    return -1;
+  }
+
+  return send_file_complete_sync (g);
+}
+
+/* Send a chunk of file data. */
+static int
+send_file_data_sync (guestfs_h *g, const char *buf, size_t len)
+{
+  return send_file_chunk_sync (g, 0, buf, len);
+}
+
+/* Send a cancellation message. */
+static int
+send_file_cancellation_sync (guestfs_h *g)
+{
+  return send_file_chunk_sync (g, 1, NULL, 0);
+}
+
+/* Send a file complete chunk. */
+static int
+send_file_complete_sync (guestfs_h *g)
+{
+  char buf[1];
+  return send_file_chunk_sync (g, 0, buf, 0);
+}
+
+/* Send a chunk, cancellation or end of file, synchronously (ie. wait
+ * for it to go).
+ */
+static int check_for_daemon_cancellation (guestfs_h *g);
+
+static int
+send_file_chunk_sync (guestfs_h *g, int cancel, const char *buf, size_t len)
+{
+  char data[GUESTFS_MAX_CHUNK_SIZE + 48];
+  unsigned datalen;
+  int sent;
+  guestfs_chunk chunk;
+  XDR xdr;
+  guestfs_main_loop *ml = guestfs_get_main_loop (g);
+
+  if (g->state != BUSY) {
+    error (g, "send_file_chunk_sync: state %d != READY", g->state);
+    return -1;
+  }
+
+  /* Did the daemon send a cancellation message? */
+  if (check_for_daemon_cancellation (g)) {
+    if (g->verbose)
+      fprintf (stderr, "got daemon cancellation\n");
+    return -2;
+  }
+
+  /* Serialize the chunk. */
+  chunk.cancel = cancel;
+  chunk.data.data_len = len;
+  chunk.data.data_val = (char *) buf;
+
+  if (g->verbose)
+    fprintf (stderr,
+	     "library sending chunk cancel = %d, len = %zu, buf = %p\n",
+	     cancel, len, buf);
+
+  xdrmem_create (&xdr, data, sizeof data, XDR_ENCODE);
+  if (!xdr_guestfs_chunk (&xdr, &chunk)) {
+    error (g, "xdr_guestfs_chunk failed (buf = %p, len = %zu)", buf, len);
+    xdr_destroy (&xdr);
+    return -1;
+  }
+
+  datalen = xdr_getpos (&xdr);
+  xdr_destroy (&xdr);
+
+  /* Allocate outgoing message buffer. */
+  g->msg_out = safe_malloc (g, datalen + 4);
+  g->msg_out_size = datalen + 4;
+  g->msg_out_pos = 0;
+
+  xdrmem_create (&xdr, g->msg_out, 4, XDR_ENCODE);
+  xdr_uint32_t (&xdr, &datalen);
+
+  memcpy (g->msg_out + 4, data, datalen);
+
+  if (guestfs__switch_to_sending (g) == -1)
+    goto cleanup1;
+
+  sent = 0;
+  guestfs_set_send_callback (g, send_cb, &sent);
+  if (ml->main_loop_run (ml, g) == -1)
+    goto cleanup1;
+  if (sent != 1) {
+    error (g, "send file chunk failed, see earlier error messages");
+    goto cleanup1;
+  }
+
+  return 0;
+
+ cleanup1:
+  free (g->msg_out);
+  g->msg_out = NULL;
+  g->msg_out_size = 0;
+  return -1;
+}
+
+/* At this point we are sending FileIn file(s) to the guest, and not
+ * expecting to read anything, so if we do read anything, it must be
+ * a cancellation message.  This checks for this case without blocking.
+ */
+static int
+check_for_daemon_cancellation (guestfs_h *g)
+{
+  fd_set rset;
+  struct timeval tv;
+  int r;
+  char buf[4];
+  uint32_t flag;
+  XDR xdr;
+
+  FD_ZERO (&rset);
+  FD_SET (g->sock, &rset);
+  tv.tv_sec = 0;
+  tv.tv_usec = 0;
+  r = select (g->sock+1, &rset, NULL, NULL, &tv);
+  if (r == -1) {
+    perrorf (g, "select");
+    return 0;
+  }
+  if (r == 0)
+    return 0;
+
+  /* Read the message from the daemon. */
+  r = xread (g->sock, buf, sizeof buf);
+  if (r == -1) {
+    perrorf (g, "read");
+    return 0;
+  }
+
+  xdrmem_create (&xdr, buf, sizeof buf, XDR_DECODE);
+  xdr_uint32_t (&xdr, &flag);
+  xdr_destroy (&xdr);
+
+  if (flag != GUESTFS_CANCEL_FLAG) {
+    error (g, "check_for_daemon_cancellation: read 0x%x from daemon, expected 0x%x\n",
+	   flag, GUESTFS_CANCEL_FLAG);
+    return 0;
+  }
+
+  return 1;
+}
+
+/* Synchronously receive a file. */
+
+static int receive_file_data_sync (guestfs_h *g, void **buf);
+
+int
+guestfs__receive_file_sync (guestfs_h *g, const char *filename)
+{
+  void *buf;
+  int fd, r;
+
+  fd = open (filename, O_WRONLY|O_CREAT|O_TRUNC|O_NOCTTY, 0666);
+  if (fd == -1) {
+    perrorf (g, "open: %s", filename);
+    goto cancel;
+  }
+
+  /* Receive the file in chunked encoding. */
+  while ((r = receive_file_data_sync (g, &buf)) > 0) {
+    if (xwrite (fd, buf, r) == -1) {
+      perrorf (g, "%s: write", filename);
+      free (buf);
+      goto cancel;
+    }
+    free (buf);
+  }
+
+  if (r == -1) {
+    error (g, "%s: error in chunked encoding", filename);
+    return -1;
+  }
+
+  if (close (fd) == -1) {
+    perrorf (g, "close: %s", filename);
+    return -1;
+  }
+
+  return 0;
+
+ cancel: ;
+  /* Send cancellation message to daemon, then wait until it
+   * cancels (just throwing away data).
+   */
+  XDR xdr;
+  char fbuf[4];
+  uint32_t flag = GUESTFS_CANCEL_FLAG;
+
+  xdrmem_create (&xdr, fbuf, sizeof fbuf, XDR_ENCODE);
+  xdr_uint32_t (&xdr, &flag);
+  xdr_destroy (&xdr);
+
+  if (xwrite (g->sock, fbuf, sizeof fbuf) == -1) {
+    perrorf (g, "write to daemon socket");
+    return -1;
+  }
+
+  while ((r = receive_file_data_sync (g, &buf)) > 0)
+    free (buf);			/* just discard it */
+
+  return -1;
+}
+
+struct receive_file_ctx {
+  int code;
+  void **buf;
+};
+
+static void
+receive_file_cb (guestfs_h *g, void *data, XDR *xdr)
+{
+  guestfs_main_loop *ml = guestfs_get_main_loop (g);
+  struct receive_file_ctx *ctx = (struct receive_file_ctx *) data;
+  guestfs_chunk chunk;
+
+  ml->main_loop_quit (ml, g);
+
+  memset (&chunk, 0, sizeof chunk);
+
+  if (!xdr_guestfs_chunk (xdr, &chunk)) {
+    error (g, "failed to parse file chunk");
+    ctx->code = -1;
+    return;
+  }
+  if (chunk.cancel) {
+    error (g, "file receive cancelled by daemon");
+    ctx->code = -2;
+    return;
+  }
+  if (chunk.data.data_len == 0) { /* end of transfer */
+    ctx->code = 0;
+    return;
+  }
+
+  ctx->code = chunk.data.data_len;
+  *ctx->buf = chunk.data.data_val; /* caller frees */
+}
+
+/* Receive a chunk of file data. */
+static int
+receive_file_data_sync (guestfs_h *g, void **buf)
+{
+  struct receive_file_ctx ctx;
+  guestfs_main_loop *ml = guestfs_get_main_loop (g);
+
+  ctx.code = -3;
+  ctx.buf = buf;
+
+  guestfs_set_reply_callback (g, receive_file_cb, &ctx);
+  (void) ml->main_loop_run (ml, g);
+  guestfs_set_reply_callback (g, NULL, NULL);
+
+  if (g->verbose)
+    fprintf (stderr, "receive_file_data_sync: code %d\n", ctx.code);
+
+  switch (ctx.code) {
+  case 0:			/* end of file */
+    return 0;
+  case -1: case -2:
+    return -1;
+  case -3:
+    error (g, "failed to call receive_file_cb");
+    return -1;
+  default:			/* received n bytes of data */
+    return ctx.code;
+  }
+}
+
+/* This is the default main loop implementation, using select(2). */
+
+static int
+select_add_handle (guestfs_main_loop *mlv, guestfs_h *g, int fd, int events,
+		   guestfs_handle_event_cb cb, void *data)
+{
+  struct select_main_loop *ml = (struct select_main_loop *) mlv;
+
+  if (fd < 0 || fd >= FD_SETSIZE) {
+    error (g, "fd %d is out of range", fd);
+    return -1;
+  }
+
+  if ((events & ~(GUESTFS_HANDLE_READABLE |
+		  GUESTFS_HANDLE_WRITABLE |
+		  GUESTFS_HANDLE_HANGUP |
+		  GUESTFS_HANDLE_ERROR)) != 0) {
+    error (g, "set of events (0x%x) contains unknown events", events);
+    return -1;
+  }
+
+  if (events == 0) {
+    error (g, "set of events is empty");
+    return -1;
+  }
+
+  if (FD_ISSET (fd, &ml->rset) ||
+      FD_ISSET (fd, &ml->wset) ||
+      FD_ISSET (fd, &ml->xset)) {
+    error (g, "fd %d is already registered", fd);
+    return -1;
+  }
+
+  if (cb == NULL) {
+    error (g, "callback is NULL");
+    return -1;
+  }
+
+  if ((events & GUESTFS_HANDLE_READABLE))
+    FD_SET (fd, &ml->rset);
+  if ((events & GUESTFS_HANDLE_WRITABLE))
+    FD_SET (fd, &ml->wset);
+  if ((events & GUESTFS_HANDLE_HANGUP) || (events & GUESTFS_HANDLE_ERROR))
+    FD_SET (fd, &ml->xset);
+
+  if (fd > ml->max_fd) {
+    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));
+  }
+  ml->handle_cb_data[fd].cb = cb;
+  ml->handle_cb_data[fd].g = g;
+  ml->handle_cb_data[fd].data = data;
+
+  ml->nr_fds++;
+
+  /* Any integer >= 0 can be the handle, and this is as good as any ... */
+  return fd;
+}
+
+static int
+select_remove_handle (guestfs_main_loop *mlv, guestfs_h *g, int fd)
+{
+  struct select_main_loop *ml = (struct select_main_loop *) mlv;
+
+  if (fd < 0 || fd >= FD_SETSIZE) {
+    error (g, "fd %d is out of range", fd);
+    return -1;
+  }
+
+  if (!FD_ISSET (fd, &ml->rset) &&
+      !FD_ISSET (fd, &ml->wset) &&
+      !FD_ISSET (fd, &ml->xset)) {
+    error (g, "fd %d was not registered", fd);
+    return -1;
+  }
+
+  FD_CLR (fd, &ml->rset);
+  FD_CLR (fd, &ml->wset);
+  FD_CLR (fd, &ml->xset);
+
+  if (fd == ml->max_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));
+  }
+
+  ml->nr_fds--;
+
+  return 0;
+}
+
+static int
+select_add_timeout (guestfs_main_loop *mlv, guestfs_h *g, int interval,
+		    guestfs_handle_timeout_cb cb, void *data)
+{
+  //struct select_main_loop *ml = (struct select_main_loop *) mlv;
+
+  abort ();			/* XXX not implemented yet */
+}
+
+static int
+select_remove_timeout (guestfs_main_loop *mlv, guestfs_h *g, int timer)
+{
+  //struct select_main_loop *ml = (struct select_main_loop *) mlv;
+
+  abort ();			/* XXX not implemented yet */
+}
+
+/* The 'g' parameter is just used for error reporting.  Events
+ * for multiple handles can be dispatched by running the main
+ * loop.
+ */
+static int
+select_main_loop_run (guestfs_main_loop *mlv, guestfs_h *g)
+{
+  struct select_main_loop *ml = (struct select_main_loop *) mlv;
+  int fd, r, events;
+  fd_set rset2, wset2, xset2;
+
+  if (ml->is_running) {
+    error (g, "select_main_loop_run: this cannot be called recursively");
+    return -1;
+  }
+
+  ml->is_running = 1;
+
+  while (ml->is_running) {
+    if (ml->nr_fds == 0)
+      break;
+
+    rset2 = ml->rset;
+    wset2 = ml->wset;
+    xset2 = ml->xset;
+    r = select (ml->max_fd+1, &rset2, &wset2, &xset2, NULL);
+    if (r == -1) {
+      perrorf (g, "select");
+      ml->is_running = 0;
+      return -1;
+    }
+
+    for (fd = 0; r > 0 && fd <= ml->max_fd; ++fd) {
+      events = 0;
+      if (FD_ISSET (fd, &rset2))
+	events |= GUESTFS_HANDLE_READABLE;
+      if (FD_ISSET (fd, &wset2))
+	events |= GUESTFS_HANDLE_WRITABLE;
+      if (FD_ISSET (fd, &xset2))
+	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);
+      }
+    }
+  }
+
+  ml->is_running = 0;
+  return 0;
+}
+
+static int
+select_main_loop_quit (guestfs_main_loop *mlv, guestfs_h *g)
+{
+  struct select_main_loop *ml = (struct select_main_loop *) mlv;
+
+  /* Note that legitimately ml->is_running can be zero when
+   * this function is called.
+   */
 
+  ml->is_running = 0;
   return 0;
 }