X-Git-Url: http://git.annexia.org/?p=libguestfs.git;a=blobdiff_plain;f=src%2Fguestfs.c;h=0d54d65ad87d94446ababe6dc8a1eed528654eff;hp=e18021f7f26d8c29bbbbbf20c2e3bb6d36099767;hb=f1b48465f7e051527ff84370de7f312a706e604b;hpb=b6233d1fff5d9a6bbc61e7123a57bdd7d8cbc792 diff --git a/src/guestfs.c b/src/guestfs.c index e18021f..0d54d65 100644 --- a/src/guestfs.c +++ b/src/guestfs.c @@ -1,5 +1,5 @@ /* libguestfs - * Copyright (C) 2009 Red Hat Inc. + * Copyright (C) 2009 Red Hat Inc. * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public @@ -19,14 +19,23 @@ #include #define _BSD_SOURCE /* for mkdtemp, usleep */ +#define _GNU_SOURCE /* for vasprintf, GNU strerror_r, strchrnul */ #include #include #include +#include #include #include #include #include +#include +#include +#include +#include + +#include +#include #ifdef HAVE_ERRNO_H #include @@ -49,73 +58,305 @@ #endif #include "guestfs.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)) +#else +#define _(str) str +#define N_(str) str +#endif + +#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, +}; + +#define UNIX_PATH_MAX 108 -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); +/* 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. */ + pid_t pid; /* Qemu PID. */ + pid_t recoverypid; /* Recovery process 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 *qemu_help, *qemu_version; /* Output of qemu -help, qemu -version. */ char **cmdline; /* Qemu command line. */ int cmdline_size; - guestfs_abort_fn abort_fn; - int exit_on_error; int verbose; + int autosync; + + char *path; /* Path to kernel, initrd. */ + char *qemu; /* Qemu binary. */ + char *append; /* Append to kernel command line. */ + + int memsize; /* Size of RAM (megabytes). */ + + int selinux; /* selinux enabled? */ + + 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; + unsigned int msg_in_size, msg_in_allocated; + char *msg_out; + unsigned 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 ? strdup (str) : strdup (GUESTFS_DEFAULT_PATH); + if (!g->path) goto error; + + str = getenv ("LIBGUESTFS_QEMU"); + g->qemu = str != NULL ? strdup (str) : strdup (QEMU); + if (!g->qemu) goto error; - g->tmpdir = NULL; + str = getenv ("LIBGUESTFS_APPEND"); + if (str) { + g->append = strdup (str); + if (!g->append) goto error; + } + + /* Choose a suitable memory size. Previously we tried to choose + * a minimal memory size, but this isn't really necessary since + * recent QEMU and KVM don't do anything nasty like locking + * memory into core any more. Thus we can safely choose a + * large, generous amount of memory, and it'll just get swapped + * on smaller systems. + */ + str = getenv ("LIBGUESTFS_MEMSIZE"); + if (str) { + if (sscanf (str, "%d", &g->memsize) != 1 || g->memsize <= 256) { + fprintf (stderr, "libguestfs: non-numeric or too small value for LIBGUESTFS_MEMSIZE\n"); + goto error; + } + } else + g->memsize = 500; - 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; + + error: + free (g->path); + free (g->qemu); + free (g->append); + free (g); + return NULL; } 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_umount_all (g); + 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); + + /* 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; + + /* Remove tmpfiles. */ if (g->tmpdir) { snprintf (filename, sizeof filename, "%s/sock", g->tmpdir); unlink (filename); - snprintf (filename, sizeof filename, "%s/qemu.log", g->tmpdir); + snprintf (filename, sizeof filename, "%s/initrd", g->tmpdir); + unlink (filename); + + snprintf (filename, sizeof filename, "%s/kernel", g->tmpdir); unlink (filename); rmdir (g->tmpdir); @@ -123,114 +364,251 @@ guestfs_free (guestfs_h *g) 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->msg_in); + free (g->msg_out); + free (g->last_error); + free (g->path); + free (g->qemu); + free (g->append); + free (g->qemu_help); + free (g->qemu_version); 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); + int err = vasprintf (&msg, fs, args); va_end (args); - fputc ('\n', stderr); - if (g->exit_on_error) exit (1); - return -1; + if (err < 0) return; + + 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]; - int err = errno; + char *msg; + int errnum = errno; - fprintf (stderr, "libguestfs: "); va_start (args, fs); - vfprintf (stderr, fs, args); + int err = vasprintf (&msg, fs, args); va_end (args); - strerror_r (err, buf, sizeof buf); - fprintf (stderr, ": %s\n", buf); - if (g->exit_on_error) exit (1); - return -1; + if (err < 0) return; + +#ifndef _GNU_SOURCE + char buf[256]; + strerror_r (errnum, buf, sizeof buf); +#else + char _buf[256]; + char *buf; + buf = strerror_r (errnum, _buf, sizeof _buf); +#endif + + 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 (nbytes > 0 && !ptr) g->abort_cb (); return ptr; } -static void * -safe_realloc (guestfs_h *g, void *ptr, int nbytes) +/* Return 1 if an array of N objects, each of size S, cannot exist due + to size arithmetic overflow. S must be positive and N must be + nonnegative. This is a macro, not an inline function, so that it + works correctly even when SIZE_MAX < N. + + By gnulib convention, SIZE_MAX represents overflow in size + calculations, so the conservative dividend to use here is + SIZE_MAX - 1, since SIZE_MAX might represent an overflowed value. + However, malloc (SIZE_MAX) fails on all known hosts where + sizeof (ptrdiff_t) <= sizeof (size_t), so do not bother to test for + exactly-SIZE_MAX allocations on such hosts; this avoids a test and + branch when S is known to be 1. */ +# define xalloc_oversized(n, s) \ + ((size_t) (sizeof (ptrdiff_t) <= sizeof (size_t) ? -1 : -2) / (s) < (n)) + +/* Technically we should add an autoconf test for this, testing for the desired + functionality, like what's done in gnulib, but for now, this is fine. */ +#define HAVE_GNU_CALLOC (__GLIBC__ >= 2) + +/* Allocate zeroed memory for N elements of S bytes, with error + checking. S must be nonzero. */ +void * +guestfs_safe_calloc (guestfs_h *g, size_t n, size_t s) +{ + /* From gnulib's calloc function in xmalloc.c. */ + void *p; + /* Test for overflow, since some calloc implementations don't have + proper overflow checks. But omit overflow and size-zero tests if + HAVE_GNU_CALLOC, since GNU calloc catches overflow and never + returns NULL if successful. */ + if ((! HAVE_GNU_CALLOC && xalloc_oversized (n, s)) + || (! (p = calloc (n, s)) && (HAVE_GNU_CALLOC || n != 0))) + g->abort_cb (); + return p; +} + +void * +guestfs_safe_realloc (guestfs_h *g, void *ptr, int nbytes) { void *p = realloc (ptr, nbytes); - if (!p) g->abort_fn (); + if (nbytes > 0 && !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 *v_buf, size_t len) +{ + const char *buf = v_buf; + 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 *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; + 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,26 +617,156 @@ 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) +{ + free (g->path); + g->path = NULL; + + g->path = + path == NULL ? + safe_strdup (g, GUESTFS_DEFAULT_PATH) : safe_strdup (g, path); + return 0; +} + +const char * +guestfs_get_path (guestfs_h *g) +{ + return g->path; +} + +int +guestfs_set_qemu (guestfs_h *g, const char *qemu) +{ + free (g->qemu); + g->qemu = NULL; + + g->qemu = qemu == NULL ? safe_strdup (g, QEMU) : safe_strdup (g, qemu); + return 0; +} + +const char * +guestfs_get_qemu (guestfs_h *g) +{ + return g->qemu; +} + +int +guestfs_set_append (guestfs_h *g, const char *append) +{ + free (g->append); + g->append = NULL; + + g->append = append ? safe_strdup (g, append) : NULL; + return 0; +} + +const char * +guestfs_get_append (guestfs_h *g) +{ + return g->append; +} + +int +guestfs_set_memsize (guestfs_h *g, int memsize) +{ + g->memsize = memsize; + return 0; +} + +int +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) { - if (g->pid >= 0) - return error (g, "command line cannot be altered after qemu subprocess launched"); + 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; +} + +/* Add a string to the current command line. */ +static void +incr_cmdline_size (guestfs_h *g) +{ + 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; } int guestfs_config (guestfs_h *g, - const char *qemu_param, const char *qemu_value) + 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. @@ -267,11 +775,12 @@ guestfs_config (guestfs_h *g, strcmp (qemu_param, "-initrd") == 0 || strcmp (qemu_param, "-nographic") == 0 || strcmp (qemu_param, "-serial") == 0 || - 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; @@ -285,224 +794,1920 @@ guestfs_config (guestfs_h *g, int guestfs_add_drive (guestfs_h *g, const char *filename) { - int len = strlen (filename) + 64; + size_t 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,media=disk", filename); + /* 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; + } + } return guestfs_config (g, "-drive", buf); } int -guestfs_add_cdrom (guestfs_h *g, const char *filename) +guestfs_add_drive_ro (guestfs_h *g, const char *filename) { - int len = strlen (filename) + 64; + size_t 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,if=ide,index=1,media=cdrom", filename); + snprintf (buf, len, "file=%s,snapshot=on,if=%s", filename, DRIVE_IF); return guestfs_config (g, "-drive", buf); } int -guestfs_launch (guestfs_h *g) +guestfs_add_cdrom (guestfs_h *g, const char *filename) { - 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"; - char unixsock[256]; - char vmchannel[256]; - char tmpfile[256]; - - /* XXX Choose which qemu to run. */ - /* XXX Choose initrd, etc. */ - - /* Make the temporary directory containing the logfile and 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 (strchr (filename, ',') != NULL) { + error (g, _("filename cannot contain ',' (comma) character")); + return -1; + } - snprintf (unixsock, sizeof unixsock, "%s/sock", g->tmpdir); + if (access (filename, F_OK) == -1) { + perrorf (g, "%s", filename); + return -1; } - r = fork (); - if (r == -1) - return perrorf (g, "fork"); + return guestfs_config (g, "-cdrom", filename); +} - if (r > 0) { /* Parent (library). */ - g->pid = r; +/* Returns true iff file is contained in dir. */ +static int +dir_contains_file (const char *dir, const char *file) +{ + int dirlen = strlen (dir); + int filelen = strlen (file); + int len = dirlen+filelen+2; + char path[len]; - /* 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; + snprintf (path, len, "%s/%s", dir, file); + return access (path, F_OK) == 0; +} - g->cmdline = realloc (g->cmdline, sizeof (char *) * (g->cmdline_size + 14)); - if (g->cmdline == NULL) { - perror ("realloc"); - _exit (1); - } +/* Returns true iff every listed file is contained in 'dir'. */ +static int +dir_contains_files (const char *dir, ...) +{ + va_list args; + const char *file; - 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; - - if (g->verbose) { - fprintf (stderr, "Running %s", qemu); - for (i = 0; g->cmdline[i]; ++i) - fprintf (stderr, " %s", g->cmdline[i]); - fprintf (stderr, "\n"); + va_start (args, dir); + while ((file = va_arg (args, const char *)) != NULL) { + if (!dir_contains_file (dir, file)) { + va_end (args); + return 0; } - - /* Set up stdin, stdout. Messages should go to the logfile. */ - 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);*/ - - execv (qemu, g->cmdline); /* Run qemu. */ - perror (qemu); - _exit (1); } - - return 0; + va_end (args); + return 1; } -#define UNIX_PATH_MAX 108 +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"; +static const char *supermin_name = + "initramfs." REPO "." host_cpu ".supermin.img"; +static const char *supermin_hostfiles_name = + "initramfs." REPO "." host_cpu ".supermin.hostfiles"; int -guestfs_wait_ready (guestfs_h *g) +guestfs_launch (guestfs_h *g) { - int r, i, lsock; + const char *tmpdir; + char dir_template[PATH_MAX]; + int r, pmore; + size_t len; + int wfd[2], rfd[2]; + int tries; + char *path, *pelem, *pend; + char *kernel = NULL, *initrd = NULL; + char unixsock[256]; struct sockaddr_un addr; - if (guestfs_ready (g)) return 0; - - /* Launch the subprocess, if there isn't one already. */ - if (g->pid == -1) { - if (guestfs_launch (g) != 0) - return -1; - } - - if (g->sock >= 0) { - close (g->sock); - g->sock = -1; - } - - lsock = socket (AF_UNIX, SOCK_STREAM, 0); - if (lsock == -1) - return perrorf (g, "socket"); +#ifdef P_tmpdir + tmpdir = P_tmpdir; +#else + tmpdir = "/tmp"; +#endif - addr.sun_family = AF_UNIX; - snprintf (addr.sun_path, UNIX_PATH_MAX, "%s/sock", g->tmpdir); + tmpdir = getenv ("TMPDIR") ? : tmpdir; + snprintf (dir_template, sizeof dir_template, "%s/libguestfsXXXXXX", tmpdir); - if (bind (lsock, (struct sockaddr *) &addr, sizeof addr) == -1) { - perrorf (g, "bind"); - close (lsock); + /* Configured? */ + if (!g->cmdline) { + error (g, _("you must call guestfs_add_drive before guestfs_launch")); return -1; } - if (listen (lsock, 1) == -1) { - perrorf (g, "listen"); - close (lsock); + if (g->state != CONFIG) { + error (g, _("qemu has already been launched")); return -1; } - if (fcntl (lsock, F_SETFL, O_NONBLOCK) == -1) { - perrorf (g, "set socket non-blocking"); - close (lsock); - return -1; + /* Make the temporary directory. */ + if (!g->tmpdir) { + g->tmpdir = safe_strdup (g, dir_template); + if (mkdtemp (g->tmpdir) == NULL) { + perrorf (g, _("%s: cannot create temporary directory"), dir_template); + goto cleanup0; + } } - /* 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. + /* First search g->path for the supermin appliance, and try to + * synthesize a kernel and initrd from that. If it fails, we + * try the path search again looking for a backup ordinary + * appliance. */ - 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; - } - - r = accept (lsock, NULL, 0); - if (r >= 0) { - g->sock = r; - fcntl (g->sock, F_SETFL, O_NONBLOCK); - close (lsock); - return 0; + pelem = path = safe_strdup (g, g->path); + do { + pend = strchrnul (pelem, ':'); + pmore = *pend == ':'; + *pend = '\0'; + len = pend - pelem; + + /* Empty element of "." means cwd. */ + if (len == 0 || (len == 1 && *pelem == '.')) { + if (g->verbose) + 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; + } } - if (errno == EAGAIN) { - sleep (1); - continue; + /* Look at /supermin* etc. */ + else { + if (g->verbose) + 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; + } } - perrorf (g, "accept"); - close (lsock); - guestfs_kill_subprocess (g); - return -1; + + pelem = pend + 1; + } while (pmore); + + free (path); + + if (kernel == NULL || initrd == NULL) { + /* 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 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 /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; + } + } + + 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; + } + + /* Get qemu help text and version. */ + if (test_qemu (g) == -1) + goto cleanup0; + + /* Make the vmchannel socket. */ + snprintf (unixsock, sizeof unixsock, "%s/sock", g->tmpdir); + unlink (unixsock); + + if (pipe (wfd) == -1 || pipe (rfd) == -1) { + perrorf (g, "pipe"); + goto cleanup0; + } + + r = fork (); + if (r == -1) { + perrorf (g, "fork"); + close (wfd[0]); + close (wfd[1]); + close (rfd[0]); + close (rfd[1]); + goto cleanup0; + } + + if (r == 0) { /* Child (qemu). */ + char vmchannel[256]; + char append[256]; + char memsize_str[256]; + + /* Set up the full command line. Do this in the subprocess so we + * don't need to worry about cleaning up. + */ + g->cmdline[0] = g->qemu; + +#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, + 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); + + add_cmdline (g, "-m"); + add_cmdline (g, memsize_str); + add_cmdline (g, "-no-reboot"); /* Force exit instead of reboot on panic */ + 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"); + +#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, "nic,model=" NET_IF ",vlan=0"); + + /* These options recommended by KVM developers to improve reliability. */ + if (qemu_supports (g, "-no-hpet")) + add_cmdline (g, "-no-hpet"); + + if (qemu_supports (g, "-rtc-td-hack")) + add_cmdline (g, "-rtc-td-hack"); + + /* Finish off the command line. */ + incr_cmdline_size (g); + g->cmdline[g->cmdline_size-1] = NULL; + + if (g->verbose) + print_cmdline (g); + + /* Set up stdin, stdout. */ + close (0); + close (1); + close (wfd[1]); + close (rfd[0]); + + int fail = 0; + fail |= dup (wfd[0]); + fail |= dup (rfd[1]); + close (wfd[0]); + close (rfd[1]); + + if (fail) { + perror ("dup failed"); + _exit (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 (g->qemu, g->cmdline); /* Run qemu. */ + perror (g->qemu); + _exit (1); + } + + /* Parent (library). */ + g->pid = r; + + free (kernel); + kernel = NULL; + free (initrd); + initrd = NULL; + + /* Fork the recovery process off which will kill qemu if the parent + * process fails to do so (eg. if the parent segfaults). + */ + r = fork (); + if (r == 0) { + pid_t qemu_pid = g->pid; + pid_t parent_pid = getppid (); + + /* Writing to argv is hideously complicated and error prone. See: + * http://anoncvs.postgresql.org/cvsweb.cgi/pgsql/src/backend/utils/misc/ps_status.c?rev=1.33.2.1;content-type=text%2Fplain + */ + + /* Loop around waiting for one or both of the other processes to + * disappear. It's fair to say this is very hairy. The PIDs that + * we are looking at might be reused by another process. We are + * effectively polling. Is the cure worse than the disease? + */ + for (;;) { + if (kill (qemu_pid, 0) == -1) /* qemu's gone away, we aren't needed */ + _exit (0); + if (kill (parent_pid, 0) == -1) { + /* Parent's gone away, qemu still around, so kill qemu. */ + kill (qemu_pid, 9); + _exit (0); + } + sleep (2); + } + } + + /* Don't worry, if the fork failed, this will be -1. The recovery + * process isn't essential. + */ + g->recoverypid = 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; + /* Always sleep at least once to give qemu a small chance to start up. */ + usleep (10000); + while (tries > 0) { + 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--; + usleep (100000); + } + + 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); + if (g->recoverypid > 0) kill (g->recoverypid, 9); + waitpid (g->pid, NULL, 0); + if (g->recoverypid > 0) waitpid (g->recoverypid, NULL, 0); + g->fd[0] = -1; + g->fd[1] = -1; + g->sock = -1; + g->pid = 0; + g->recoverypid = 0; + g->start_t = 0; + g->stdout_watch = -1; + g->sock_watch = -1; + + cleanup0: + free (kernel); + free (initrd); + 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 + * kernel and initrd (only initrd is built). The work is done by + * an external script. We just tell it where to put the result. + */ +static int +build_supermin_appliance (guestfs_h *g, const char *path, + char **kernel, char **initrd) +{ + char cmd[4096]; + int r, len; + + len = strlen (g->tmpdir); + *kernel = safe_malloc (g, len + 8); + snprintf (*kernel, len+8, "%s/kernel", g->tmpdir); + *initrd = safe_malloc (g, len + 8); + 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); + + r = system (cmd); + if (r == -1 || WEXITSTATUS(r) != 0) { + error (g, _("external command failed: %s"), cmd); + free (*kernel); + free (*initrd); + *kernel = *initrd = NULL; + return -1; + } + + return 0; +} + +static int read_all (guestfs_h *g, FILE *fp, char **ret); + +/* Test qemu binary (or wrapper) runs, and do 'qemu -help' and + * 'qemu -version' so we know what options this qemu supports and + * the version. + */ +static int +test_qemu (guestfs_h *g) +{ + char cmd[1024]; + FILE *fp; + + free (g->qemu_help); + free (g->qemu_version); + g->qemu_help = NULL; + g->qemu_version = NULL; + + snprintf (cmd, sizeof cmd, "'%s' -help", g->qemu); + + fp = popen (cmd, "r"); + /* qemu -help should always work (qemu -version OTOH wasn't + * supported by qemu 0.9). If this command doesn't work then it + * probably indicates that the qemu binary is missing. + */ + if (!fp) { + /* XXX This error is never printed, even if the qemu binary + * doesn't exist. Why? + */ + error: + perrorf (g, _("%s: command failed: If qemu is located on a non-standard path, try setting the LIBGUESTFS_QEMU environment variable."), cmd); + return -1; + } + + if (read_all (g, fp, &g->qemu_help) == -1) + goto error; + + if (pclose (fp) == -1) + goto error; + + snprintf (cmd, sizeof cmd, "'%s' -version 2>/dev/null", g->qemu); + + fp = popen (cmd, "r"); + if (fp) { + /* Intentionally ignore errors. */ + read_all (g, fp, &g->qemu_version); + pclose (fp); + } + + return 0; +} + +static int +read_all (guestfs_h *g, FILE *fp, char **ret) +{ + int r, n = 0; + char *p; + + again: + if (feof (fp)) { + *ret = safe_realloc (g, *ret, n + 1); + (*ret)[n] = '\0'; + return n; + } + + *ret = safe_realloc (g, *ret, n + BUFSIZ); + p = &(*ret)[n]; + r = fread (p, 1, BUFSIZ, fp); + if (ferror (fp)) { + perrorf (g, "read"); + return -1; + } + n += r; + goto again; +} + +/* Test if option is supported by qemu command line (just by grepping + * the help text). + */ +static int +qemu_supports (guestfs_h *g, const char *option) +{ + return g->qemu_help && strstr (g->qemu_help, option) != NULL; +} + +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 finished = 0, r; + + if (g->state == READY) return 0; + + if (g->state == BUSY) { + error (g, _("qemu has finished launching already")); + return -1; + } + + if (g->state != LAUNCHING) { + error (g, _("qemu has not been launched yet")); + return -1; + } + + 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; + + if (r == -1) return -1; + + if (finished != 1) { + error (g, _("guestfs_wait_ready failed, see earlier error messages")); + return -1; + } + + /* 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; + } + + return 0; +} + +int +guestfs_kill_subprocess (guestfs_h *g) +{ + if (g->state == CONFIG) { + error (g, _("no subprocess to kill")); + return -1; + } + + if (g->verbose) + fprintf (stderr, "sending SIGTERM to process %d\n", g->pid); + + kill (g->pid, SIGTERM); + if (g->recoverypid > 0) kill (g->recoverypid, 9); + + return 0; +} + +/* Access current state. */ +int +guestfs_is_config (guestfs_h *g) +{ + return g->state == CONFIG; +} + +int +guestfs_is_launching (guestfs_h *g) +{ + 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; +} + +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; +} + +int +guestfs_end_busy (guestfs_h *g) +{ + switch (g->state) + { + case BUSY: + g->state = READY; + break; + 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; +} + +/* 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. + */ +static void +child_cleanup (guestfs_h *g) +{ + if (g->verbose) + fprintf (stderr, "stdout_event: %p: child process died\n", g); + /*kill (g->pid, SIGTERM);*/ + if (g->recoverypid > 0) kill (g->recoverypid, 9); + waitpid (g->pid, NULL, 0); + if (g->recoverypid > 0) waitpid (g->recoverypid, 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->recoverypid = 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); +} + +/* 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. */ + child_cleanup (g); + return; + } + + if (n == -1) { + if (errno != EINTR && errno != EAGAIN) + perrorf (g, "read"); + return; + } + + /* In verbose mode, copy all log messages to stderr. */ + if (g->verbose) + 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) + 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; + u_int32_t 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. */ + child_cleanup (g); + return; + } + + if (n == -1) { + if (errno != EINTR && 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 0 + 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"); + } + } +#endif + + /* 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); + else + /* This message (probably) should never be printed. */ + fprintf (stderr, "libguesfs: sock_read_event: !!! dropped message !!!\n"); + + 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, err; + + 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) { + err = errno; + if (err != EAGAIN) + perrorf (g, "write"); + if (err == EPIPE) /* Disconnected from guest (RHBZ#508713). */ + child_cleanup (g); + 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; } - close (lsock); - return error (g, "timeout waiting for guest to become ready"); + return 0; } int -guestfs_ready (guestfs_h *g) +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) { - return - g->pid >= 0 && - kill (g->pid, 0) == 0 && - g->sock >= 0 /* && - guestfs_ping_daemon (g) >= 0 */; + guestfs_main_loop *ml = guestfs_get_main_loop (g); + + *((int *)data) = 1; + ml->main_loop_quit (ml, g); } int -guestfs_kill_subprocess (guestfs_h *g) +guestfs__send_sync (guestfs_h *g, int proc_nr, + xdrproc_t xdrp, char *args) +{ + struct guestfs_message_header hdr; + XDR xdr; + u_int32_t 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; + } + + /* This is probably an internal error. Or perhaps we should just + * free the buffer anyway? + */ + if (g->msg_out != NULL) { + error (g, _("guestfs__send_sync: msg_out should be NULL")); + return -1; + } + + /* We have to allocate this message buffer on the heap because + * it is quite large (although will be mostly unused). We + * can't allocate it on the stack because in some environments + * we have quite limited stack space available, notably when + * running in the JVM. + */ + g->msg_out = safe_malloc (g, GUESTFS_MESSAGE_MAX + 4); + xdrmem_create (&xdr, g->msg_out + 4, GUESTFS_MESSAGE_MAX, XDR_ENCODE); + + /* 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; + + if (!xdr_guestfs_message_header (&xdr, &hdr)) { + error (g, _("xdr_guestfs_message_header failed")); + goto cleanup1; + } + + /* 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")); + goto cleanup1; + } + } + + /* Get the actual length of the message, resize the buffer to match + * the actual length, and write the length word at the beginning. + */ + len = xdr_getpos (&xdr); + xdr_destroy (&xdr); + + g->msg_out = safe_realloc (g, g->msg_out, 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); + + 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); + if (r == -1 && (errno == EINTR || errno == EAGAIN)) + continue; + if (r <= 0) break; + 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 buflen) { - if (g->pid >= 0) { + u_int32_t len; + 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; + } + + /* This is probably an internal error. Or perhaps we should just + * free the buffer anyway? + */ + if (g->msg_out != NULL) { + error (g, _("guestfs__send_sync: msg_out should be NULL")); + return -1; + } + + /* Did the daemon send a cancellation message? */ + if (check_for_daemon_cancellation (g)) { if (g->verbose) - fprintf (stderr, "sending SIGINT to pid %d\n", g->pid); + fprintf (stderr, "got daemon cancellation\n"); + return -2; + } + + /* Allocate the chunk buffer. Don't use the stack to avoid + * excessive stack usage and unnecessary copies. + */ + g->msg_out = safe_malloc (g, GUESTFS_MAX_CHUNK_SIZE + 4 + 48); + xdrmem_create (&xdr, g->msg_out + 4, GUESTFS_MAX_CHUNK_SIZE + 48, XDR_ENCODE); + + /* Serialize the chunk. */ + chunk.cancel = cancel; + chunk.data.data_len = buflen; + chunk.data.data_val = (char *) buf; + + if (!xdr_guestfs_chunk (&xdr, &chunk)) { + error (g, _("xdr_guestfs_chunk failed (buf = %p, buflen = %zu)"), + buf, buflen); + xdr_destroy (&xdr); + goto cleanup1; + } + + len = xdr_getpos (&xdr); + xdr_destroy (&xdr); + + /* Reduce the size of the outgoing message buffer to the real length. */ + g->msg_out = safe_realloc (g, g->msg_out, 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); + + 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. */ + +/* Returns -1 = error, 0 = EOF, 1 = more data */ +static int receive_file_data_sync (guestfs_h *g, void **buf, size_t *len); + +int +guestfs__receive_file_sync (guestfs_h *g, const char *filename) +{ + void *buf; + int fd, r; + size_t len; + + 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, &len)) >= 0) { + if (xwrite (fd, buf, len) == -1) { + perrorf (g, "%s: write", filename); + free (buf); + goto cancel; + } + free (buf); + if (r == 0) break; /* End of file. */ + } + + 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; + + 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); + + if (xwrite (g->sock, fbuf, sizeof fbuf) == -1) { + perrorf (g, _("write to daemon socket")); + return -1; + } + + while ((r = receive_file_data_sync (g, NULL, NULL)) > 0) + ; /* just discard it */ + + return -1; +} + +/* Note that the reply callback can be called multiple times before + * the main loop quits and we get back to the synchronous code. So + * we have to be prepared to save multiple chunks on a list here. + */ +struct receive_file_ctx { + int count; /* 0 if receive_file_cb not called, or + * else count number of chunks. + */ + guestfs_chunk *chunks; /* Array of chunks. */ +}; + +static void +free_chunks (struct receive_file_ctx *ctx) +{ + int i; + + for (i = 0; i < ctx->count; ++i) + free (ctx->chunks[i].data.data_val); + + free (ctx->chunks); +} + +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; + + if (ctx->count == -1) /* Parse error occurred previously. */ + return; + + ml->main_loop_quit (ml, g); + + memset (&chunk, 0, sizeof chunk); + + if (!xdr_guestfs_chunk (xdr, &chunk)) { + error (g, _("failed to parse file chunk")); + free_chunks (ctx); + ctx->chunks = NULL; + ctx->count = -1; + return; + } + + /* Copy the chunk to the list. */ + ctx->chunks = safe_realloc (g, ctx->chunks, + sizeof (guestfs_chunk) * (ctx->count+1)); + ctx->chunks[ctx->count] = chunk; + ctx->count++; +} + +/* Receive a chunk of file data. */ +/* Returns -1 = error, 0 = EOF, 1 = more data */ +static int +receive_file_data_sync (guestfs_h *g, void **buf, size_t *len_r) +{ + struct receive_file_ctx ctx; + guestfs_main_loop *ml = guestfs_get_main_loop (g); + int i; + size_t len; + + ctx.count = 0; + ctx.chunks = NULL; + + guestfs_set_reply_callback (g, receive_file_cb, &ctx); + (void) ml->main_loop_run (ml, g); + guestfs_set_reply_callback (g, NULL, NULL); + + if (ctx.count == 0) { + error (g, _("receive_file_data_sync: reply callback not called\n")); + return -1; + } + + if (ctx.count == -1) { + error (g, _("receive_file_data_sync: parse error in reply callback\n")); + /* callback already freed the chunks */ + return -1; + } + + if (g->verbose) + fprintf (stderr, "receive_file_data_sync: got %d chunks\n", ctx.count); + + /* Process each chunk in the list. */ + if (buf) *buf = NULL; /* Accumulate data in this buffer. */ + len = 0; + + for (i = 0; i < ctx.count; ++i) { + if (ctx.chunks[i].cancel) { + error (g, _("file receive cancelled by daemon")); + free_chunks (&ctx); + if (buf) free (*buf); + if (len_r) *len_r = 0; + return -1; + } + + if (ctx.chunks[i].data.data_len == 0) { /* end of transfer */ + free_chunks (&ctx); + if (len_r) *len_r = len; + return 0; + } + + if (buf) { + *buf = safe_realloc (g, *buf, len + 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; + } + + if (len_r) *len_r = len; + free_chunks (&ctx); + return 1; +} + +/* 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; - kill (g->pid, SIGINT); - wait_subprocess (g); + 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 +__attribute__((noreturn)) +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 +__attribute__((noreturn)) +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) { + if (errno == EINTR || errno == EAGAIN) + continue; + 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); + } + } } - cleanup_fds (g); + 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; }