X-Git-Url: http://git.annexia.org/?p=libguestfs.git;a=blobdiff_plain;f=src%2Fguestfs.c;h=df13d517cfe75754cb81ccae630c1dc7234d7429;hp=cc33e670dc4313616d87f2786192edb3717251e2;hb=12cf22ade46ba07aa162a311d3369096292d6d02;hpb=ef499de8946cf4b8120ef7917b2e5d7f9115041f diff --git a/src/guestfs.c b/src/guestfs.c index cc33e67..df13d51 100644 --- a/src/guestfs.c +++ b/src/guestfs.c @@ -1,5 +1,5 @@ /* libguestfs - * Copyright (C) 2009 Red Hat Inc. + * Copyright (C) 2009-2010 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,17 +19,22 @@ #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 +#include + #include #include @@ -53,146 +58,23 @@ #include #endif -#include "guestfs.h" -#include "guestfs_protocol.h" +#include +#include -void guestfs_error (guestfs_h *g, const char *fs, ...); -void guestfs_perrorf (guestfs_h *g, const char *fs, ...); -void *guestfs_safe_malloc (guestfs_h *g, size_t nbytes); -void *guestfs_safe_realloc (guestfs_h *g, void *ptr, int nbytes); -char *guestfs_safe_strdup (guestfs_h *g, const char *str); -void *guestfs_safe_memdup (guestfs_h *g, void *ptr, size_t size); +#include "c-ctype.h" +#include "glthread/lock.h" +#include "hash.h" +#include "hash-pjw.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 +#include "guestfs.h" +#include "guestfs-internal.h" +#include "guestfs-internal-actions.h" +#include "guestfs_protocol.h" 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 - -/* 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 -{ - 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 socket. */ - - char **cmdline; /* Qemu command line. */ - int cmdline_size; - - int verbose; - int autosync; - - const char *path; - - 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; -}; - +gl_lock_define_initialized (static, handles_lock); static guestfs_h *handles = NULL; static int atexit_handler_set = 0; @@ -212,43 +94,76 @@ guestfs_create (void) g->fd[0] = -1; g->fd[1] = -1; g->sock = -1; - g->stdout_watch = -1; - g->sock_watch = -1; g->abort_cb = abort; g->error_cb = default_error_cb; g->error_cb_data = NULL; + g->recovery_proc = 1; + g->autosync = 1; + str = getenv ("LIBGUESTFS_DEBUG"); - g->verbose = str != NULL && strcmp (str, "1") == 0; + g->verbose = str != NULL && STREQ (str, "1"); + + str = getenv ("LIBGUESTFS_TRACE"); + g->trace = str != NULL && STREQ (str, "1"); str = getenv ("LIBGUESTFS_PATH"); - g->path = str != NULL ? str : GUESTFS_DEFAULT_PATH; - /* XXX We should probably make QEMU configurable as well. */ + 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; + + str = getenv ("LIBGUESTFS_APPEND"); + if (str) { + g->append = strdup (str); + if (!g->append) goto error; + } - g->main_loop = guestfs_get_default_main_loop (); + /* 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; /* 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) */ + /* Link the handles onto a global list. */ + gl_lock_lock (handles_lock); g->next = handles; handles = g; if (!atexit_handler_set) { atexit (close_handles); atexit_handler_set = 1; } - /* release mutex (XXX) */ + gl_lock_unlock (handles_lock); 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 @@ -260,16 +175,24 @@ guestfs_close (guestfs_h *g) if (g->state == NO_HANDLE) { /* Not safe to call 'error' here, so ... */ - fprintf (stderr, "guestfs_close: called twice on the same handle\n"); + 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); + /* Run user close callback before anything else. */ + if (g->close_cb) + g->close_cb (g, g->close_cb_data); + + guestfs___free_inspect_info (g); + /* Try to sync if autosync flag is set. */ - if (g->autosync && g->state == READY) + if (g->autosync && g->state == READY) { + guestfs_umount_all (g); guestfs_sync (g); + } /* Remove any handlers that might be called back before we kill the * subprocess. @@ -279,6 +202,22 @@ guestfs_close (guestfs_h *g) if (g->state != CONFIG) guestfs_kill_subprocess (g); + /* Close sockets. */ + if (g->fd[0] >= 0) + close (g->fd[0]); + if (g->fd[1] >= 0) + close (g->fd[1]); + if (g->sock >= 0) + close (g->sock); + g->fd[0] = -1; + g->fd[1] = -1; + g->sock = -1; + + /* Wait for subprocess(es) to exit. */ + waitpid (g->pid, NULL, 0); + if (g->recoverypid > 0) waitpid (g->recoverypid, NULL, 0); + + /* Remove tmpfiles. */ if (g->tmpdir) { snprintf (filename, sizeof filename, "%s/sock", g->tmpdir); unlink (filename); @@ -297,7 +236,7 @@ guestfs_close (guestfs_h *g) /* Mark the handle as dead before freeing it. */ g->state = NO_HANDLE; - /* acquire mutex (XXX) */ + gl_lock_lock (handles_lock); if (handles == g) handles = g->next; else { @@ -305,9 +244,16 @@ guestfs_close (guestfs_h *g) ; gg->next = g->next; } - /* release mutex (XXX) */ + gl_lock_unlock (handles_lock); + if (g->pda) + hash_free (g->pda); free (g->last_error); + free (g->path); + free (g->qemu); + free (g->append); + free (g->qemu_help); + free (g->qemu_version); free (g); } @@ -334,7 +280,7 @@ set_last_error (guestfs_h *g, const char *msg) static void default_error_cb (guestfs_h *g, void *data, const char *msg) { - fprintf (stderr, "libguestfs: error: %s\n", msg); + fprintf (stderr, _("libguestfs: error: %s\n"), msg); } void @@ -344,9 +290,11 @@ guestfs_error (guestfs_h *g, const char *fs, ...) char *msg; va_start (args, fs); - vasprintf (&msg, fs, args); + int err = vasprintf (&msg, fs, args); va_end (args); + if (err < 0) return; + if (g->error_cb) g->error_cb (g, g->error_cb_data, msg); set_last_error (g, msg); @@ -358,19 +306,21 @@ guestfs_perrorf (guestfs_h *g, const char *fs, ...) { va_list args; char *msg; - int err = errno; + int errnum = errno; va_start (args, fs); - vasprintf (&msg, fs, args); + int err = vasprintf (&msg, fs, args); va_end (args); -#ifndef _GNU_SOURCE + if (err < 0) return; + +#if !defined(_GNU_SOURCE) || defined(__APPLE__) char buf[256]; - strerror_r (err, buf, sizeof buf); + strerror_r (errnum, buf, sizeof buf); #else char _buf[256]; char *buf; - buf = strerror_r (err, _buf, sizeof _buf); + buf = strerror_r (errnum, _buf, sizeof _buf); #endif msg = safe_realloc (g, msg, strlen (msg) + 2 + strlen (buf) + 1); @@ -387,15 +337,55 @@ void * guestfs_safe_malloc (guestfs_h *g, size_t nbytes) { void *ptr = malloc (nbytes); - if (!ptr) g->abort_cb (); + if (nbytes > 0 && !ptr) g->abort_cb (); return ptr; } +/* 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. */ +#if defined(__GLIBC__) +#define HAVE_GNU_CALLOC (__GLIBC__ >= 2) +#else +#define HAVE_GNU_CALLOC 0 +#endif + +/* 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_cb (); + if (nbytes > 0 && !p) g->abort_cb (); return p; } @@ -407,6 +397,14 @@ guestfs_safe_strdup (guestfs_h *g, const char *str) return s; } +char * +guestfs_safe_strndup (guestfs_h *g, const char *str, size_t n) +{ + char *s = strndup (str, n); + if (!s) g->abort_cb (); + return s; +} + void * guestfs_safe_memdup (guestfs_h *g, void *ptr, size_t size) { @@ -443,842 +441,186 @@ guestfs_get_error_handler (guestfs_h *g, void **data_rtn) } int -guestfs_set_verbose (guestfs_h *g, int v) +guestfs__set_verbose (guestfs_h *g, int v) { g->verbose = !!v; return 0; } int -guestfs_get_verbose (guestfs_h *g) +guestfs__get_verbose (guestfs_h *g) { return g->verbose; } int -guestfs_set_autosync (guestfs_h *g, int a) +guestfs__set_autosync (guestfs_h *g, int a) { g->autosync = !!a; return 0; } int -guestfs_get_autosync (guestfs_h *g) +guestfs__get_autosync (guestfs_h *g) { return g->autosync; } int -guestfs_set_path (guestfs_h *g, const char *path) +guestfs__set_path (guestfs_h *g, const char *path) { - if (path == NULL) - g->path = GUESTFS_DEFAULT_PATH; - else - g->path = 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) +guestfs__get_path (guestfs_h *g) { return g->path; } -/* Add a string to the current command line. */ -static void -incr_cmdline_size (guestfs_h *g) +int +guestfs__set_qemu (guestfs_h *g, const char *qemu) { - 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; - } + free (g->qemu); + g->qemu = NULL; - g->cmdline_size++; - g->cmdline = safe_realloc (g, g->cmdline, sizeof (char *) * g->cmdline_size); + g->qemu = qemu == NULL ? safe_strdup (g, QEMU) : safe_strdup (g, qemu); + return 0; } -static int -add_cmdline (guestfs_h *g, const char *str) +const char * +guestfs__get_qemu (guestfs_h *g) { - 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; + return g->qemu; } int -guestfs_config (guestfs_h *g, - const char *qemu_param, const char *qemu_value) +guestfs__set_append (guestfs_h *g, const char *append) { - 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. - */ - if (strcmp (qemu_param, "-kernel") == 0 || - 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) { - error (g, "guestfs_config: parameter '%s' isn't allowed", qemu_param); - return -1; - } - - if (add_cmdline (g, qemu_param) != 0) return -1; - - if (qemu_value != NULL) { - if (add_cmdline (g, qemu_value) != 0) return -1; - } + free (g->append); + g->append = NULL; + g->append = append ? safe_strdup (g, append) : NULL; return 0; } -int -guestfs_add_drive (guestfs_h *g, const char *filename) +const char * +guestfs__get_append (guestfs_h *g) { - int len = strlen (filename) + 64; - char buf[len]; - - 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", filename); - - return guestfs_config (g, "-drive", buf); + return g->append; } int -guestfs_add_cdrom (guestfs_h *g, const char *filename) +guestfs__set_memsize (guestfs_h *g, int memsize) { - 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; - } - - return guestfs_config (g, "-cdrom", filename); + g->memsize = memsize; + return 0; } int -guestfs_launch (guestfs_h *g) +guestfs__get_memsize (guestfs_h *g) { - static const char *dir_template = "/tmp/libguestfsXXXXXX"; - int r, i, len, pmore; - 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]; - struct sockaddr_un addr; - - /* 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 /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; - } - - /* Make the temporary directory containing the socket. */ - 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; - } - } - - 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]; - - /* 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; - - /* Construct the -net channel parameter for qemu. */ - snprintf (vmchannel, sizeof vmchannel, - "channel,%d:unix:%s,server,nowait", - VMCHANNEL_PORT, unixsock); - - /* Linux kernel command line. */ - snprintf (append, sizeof append, - "console=ttyS0 guestfs=%s:%d", VMCHANNEL_ADDR, VMCHANNEL_PORT); - - add_cmdline (g, "-m"); - add_cmdline (g, "384"); /* XXX Choose best size. */ - add_cmdline (g, "-no-kqemu"); /* Avoids a warning. */ - 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,vlan=0"); - incr_cmdline_size (g); - g->cmdline[g->cmdline_size-1] = NULL; - - if (g->verbose) { - fprintf (stderr, "%s", QEMU); - for (i = 0; g->cmdline[i]; ++i) - fprintf (stderr, " %s", g->cmdline[i]); - fprintf (stderr, "\n"); - } - - /* Set up stdin, stdout. */ - close (0); - close (1); - 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); - _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; - } - - 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, "could not watch daemon communications socket"); - 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; + return g->memsize; } -static void -finish_wait_ready (guestfs_h *g, void *vp) +int +guestfs__set_selinux (guestfs_h *g, int selinux) { - 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); + g->selinux = selinux; + return 0; } int -guestfs_wait_ready (guestfs_h *g) +guestfs__get_selinux (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; + return g->selinux; } int -guestfs_kill_subprocess (guestfs_h *g) +guestfs__get_pid (guestfs_h *g) { - if (g->state == CONFIG) { - error (g, "no subprocess to kill"); + if (g->pid > 0) + return g->pid; + else { + error (g, "get_pid: no qemu subprocess"); return -1; } - - if (g->verbose) - fprintf (stderr, "sending SIGTERM to process %d\n", g->pid); - - kill (g->pid, SIGTERM); - - return 0; } -/* Access current state. */ -int -guestfs_is_config (guestfs_h *g) +struct guestfs_version * +guestfs__version (guestfs_h *g) { - return g->state == CONFIG; -} + struct guestfs_version *r; -int -guestfs_is_launching (guestfs_h *g) -{ - return g->state == LAUNCHING; + r = safe_malloc (g, sizeof *r); + r->major = PACKAGE_VERSION_MAJOR; + r->minor = PACKAGE_VERSION_MINOR; + r->release = PACKAGE_VERSION_RELEASE; + r->extra = safe_strdup (g, PACKAGE_VERSION_EXTRA); + return r; } int -guestfs_is_ready (guestfs_h *g) +guestfs__set_trace (guestfs_h *g, int t) { - return g->state == READY; + g->trace = !!t; + return 0; } int -guestfs_is_busy (guestfs_h *g) +guestfs__get_trace (guestfs_h *g) { - return g->state == BUSY; + return g->trace; } int -guestfs_get_state (guestfs_h *g) -{ - return g->state; -} - -/* 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) +guestfs__set_direct (guestfs_h *g, int d) { - xdr_free ((xdrproc_t) xdr_guestfs_lvm_int_lv_list, (char *) x); - free (x); + g->direct = !!d; + return 0; } -/* 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) +int +guestfs__get_direct (guestfs_h *g) { - 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); + return g->direct; } -/* 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) +int +guestfs__set_recovery_proc (guestfs_h *g, int f) { - 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? */ - 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 == 0xf5f55ff5) { - 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; - } - - /* 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. */ - - /* This should not happen, and if it does it probably means we've - * lost all hope of synchronization. - */ - if (g->msg_in_size-4 > len) { - error (g, "len = %d, but msg_in_size-4 = %d", len, g->msg_in_size-4); - goto cleanup; - } - - /* 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. */ - g->state = READY; - if (g->reply_cb) - g->reply_cb (g, g->reply_cb_data, &xdr); - - 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); + g->recovery_proc = !!f; + return 0; } -/* 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 +guestfs__get_recovery_proc (guestfs_h *g) { - 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, switching back to reading events\n"); - - free (g->msg_out); - g->msg_out_pos = g->msg_out_size = 0; - - if (g->main_loop->remove_handle (g->main_loop, g, g->sock_watch) == -1) { - error (g, "remove_handle failed in sock_write_event"); - return; - } - 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 in sock_write_event"); - return; - } + return g->recovery_proc; } -void -guestfs_set_send_callback (guestfs_h *g, - guestfs_send_cb cb, void *opaque) +int +guestfs__set_network (guestfs_h *g, int v) { - g->send_cb = cb; - g->send_cb_data = opaque; + g->enable_network = !!v; + return 0; } -void -guestfs_set_reply_callback (guestfs_h *g, - guestfs_reply_cb cb, void *opaque) +int +guestfs__get_network (guestfs_h *g) { - g->reply_cb = cb; - g->reply_cb_data = opaque; + return g->enable_network; } void guestfs_set_log_message_callback (guestfs_h *g, - guestfs_log_message_cb cb, void *opaque) + guestfs_log_message_cb cb, void *opaque) { g->log_message_cb = cb; g->log_message_cb_data = opaque; @@ -1286,7 +628,7 @@ guestfs_set_log_message_callback (guestfs_h *g, void guestfs_set_subprocess_quit_callback (guestfs_h *g, - guestfs_subprocess_quit_cb cb, void *opaque) + guestfs_subprocess_quit_cb cb, void *opaque) { g->subprocess_quit_cb = cb; g->subprocess_quit_cb_data = opaque; @@ -1294,424 +636,128 @@ guestfs_set_subprocess_quit_callback (guestfs_h *g, void guestfs_set_launch_done_callback (guestfs_h *g, - guestfs_launch_done_cb cb, void *opaque) + guestfs_launch_done_cb cb, void *opaque) { g->launch_done_cb = cb; g->launch_done_cb_data = opaque; } -/* 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) +guestfs_set_close_callback (guestfs_h *g, + guestfs_close_cb cb, void *opaque) { - return g->main_loop; + g->close_cb = cb; + g->close_cb_data = opaque; } -guestfs_main_loop * -guestfs_get_default_main_loop (void) +void +guestfs_set_progress_callback (guestfs_h *g, + guestfs_progress_cb cb, void *opaque) { - return (guestfs_main_loop *) &default_main_loop; + g->progress_cb = cb; + g->progress_cb_data = opaque; } -/* Dispatch a call (len + header + args) to the remote daemon. This - * function just queues the call in msg_out, to be sent when we next - * enter the main loop. Returns -1 for error, or the message serial - * number. +/* Note the private data area is allocated lazily, since the vast + * majority of callers will never use it. This means g->pda is + * likely to be NULL. */ -int -guestfs_send (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++; - - if (g->state != READY) { - error (g, "dispatch: state %d != READY", 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; - g->state = BUSY; - - xdrmem_create (&xdr, g->msg_out, 4, XDR_ENCODE); - if (!xdr_uint32_t (&xdr, &len)) { - error (g, "xdr_uint32_t failed in dispatch"); - goto cleanup1; - } - - memcpy (g->msg_out + 4, buffer, len); - - /* Change the handle to sock_write_event. */ - if (g->main_loop->remove_handle (g->main_loop, g, g->sock_watch) == -1) { - error (g, "remove_handle failed in dispatch"); - goto cleanup1; - } - 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 in dispatch"); - goto cleanup1; - } - - return serial; - - cleanup1: - free (g->msg_out); - g->msg_out = NULL; - g->msg_out_size = 0; - g->state = READY; - return -1; -} - -#if 0 -static int cancel = 0; /* XXX Implement file cancellation. */ - -static int -send_file (guestfs_h *g, const char *filename) -{ - char buf[GUESTFS_MAX_CHUNK_SIZE]; - int fd, r; - - fd = open (filename, O_RDONLY); - if (fd == -1) { - perrorf (g, "open: %s", filename); - send_file_cancellation (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) { - if (send_file_data (g, buf, r) == -1) - return -1; - } - - if (cancel) { - send_file_cancellation (g); - return -1; - } - - if (r == -1) { - perrorf (g, "read: %s", filename); - send_file_cancellation (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 (g); - return -1; - } - - return send_file_complete (g); -} - -/* Send a chunk, cancellation or end of file, wait for it to go. */ -static int -send_file_chunk (guestfs_h *g, int cancel, const char *buf, size_t len) -{ - void *data; - guestfs_chunk chunk; - XDR xdr; - - if (g->state != BUSY) { - error (g, "send_file_chunk: state %d != READY", g->state); - return -1; - } - - /* Serialize the chunk. */ - chunk.cancel = cancel; - chunk.data.data_len = len; - chunk.data.data_val = (char *) buf; - - data = safe_malloc (g, GUESTFS_MAX_CHUNK_SIZE + 48); - xdrmem_create (&xdr, data, GUESTFS_MAX_CHUNK_SIZE + 48, XDR_ENCODE); - if (xdr_guestfs_chunk (&xdr, &chunk)) { - error (g, "xdr_guestfs_chunk failed"); - free (data); - return -1; - } - - chunkdatalen = xdr_getpos (&xdr); - xdr_destroy (&xdr); - - len = xdr_getpos (&xdr); - xdr_destroy (&xdr); - - data = safe_realloc (g, data, len); - g->msg_out = data; - g->msg_out_size = len; - g->msg_out_pos = 0; - - /* Change the handle to sock_write_event. */ - if (g->main_loop->remove_handle (g->main_loop, g, g->sock_watch) == -1) { - error (g, "remove_handle failed in dispatch"); - goto cleanup1; - } - 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 in dispatch"); - goto cleanup1; - } - - return 0; - - cleanup1: - free (g->msg_out); - g->msg_out = NULL; - g->msg_out_size = 0; - g->state = READY; - return -1; -} +struct pda_entry { + char *key; /* key */ + void *data; /* opaque user data pointer */ +}; -/* Send a chunk of file data. */ -static int -send_file_data (guestfs_h *g, const char *buf, size_t len) +static size_t +hasher (void const *x, size_t table_size) { - return send_file_chunk (g, 0, buf, len); + struct pda_entry const *p = x; + return hash_pjw (p->key, table_size); } -/* Send a cancellation message. */ -static int -send_file_cancellation (guestfs_h *g) +static bool +comparator (void const *x, void const *y) { - char buf[1]; - return send_file_chunk (g, 1, buf, 0); + struct pda_entry const *a = x; + struct pda_entry const *b = y; + return STREQ (a->key, b->key); } -/* Send a file complete chunk. */ -static int -send_file_complete (guestfs_h *g) -{ - char buf[0]; - return send_file_chunk (g, 0, buf, 0); -} -#endif - -/* 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) +static void +freer (void *x) { - 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 (x) { + struct pda_entry *p = x; + free (p->key); + free (p); } - - 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) +void +guestfs_set_private (guestfs_h *g, const char *key, 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 (g->pda == NULL) { + g->pda = hash_initialize (16, NULL, hasher, comparator, freer); + if (g->pda == NULL) + g->abort_cb (); } - 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)); - } + struct pda_entry *new_entry = safe_malloc (g, sizeof *new_entry); + new_entry->key = safe_strdup (g, key); + new_entry->data = data; - ml->nr_fds--; + struct pda_entry *old_entry = hash_delete (g->pda, new_entry); + freer (old_entry); - return 0; + struct pda_entry *entry = hash_insert (g->pda, new_entry); + if (entry == NULL) + g->abort_cb (); + assert (entry == new_entry); } -static int -select_add_timeout (guestfs_main_loop *mlv, guestfs_h *g, int interval, - guestfs_handle_timeout_cb cb, void *data) +static inline char * +bad_cast (char const *s) { - //struct select_main_loop *ml = (struct select_main_loop *) mlv; - - abort (); /* XXX not implemented yet */ + return (char *) s; } -static int -select_remove_timeout (guestfs_main_loop *mlv, guestfs_h *g, int timer) +void * +guestfs_get_private (guestfs_h *g, const char *key) { - //struct select_main_loop *ml = (struct select_main_loop *) mlv; + if (g->pda == NULL) + return NULL; /* no keys have been set */ - abort (); /* XXX not implemented yet */ + const struct pda_entry k = { .key = bad_cast (key) }; + struct pda_entry *entry = hash_lookup (g->pda, &k); + if (entry) + return entry->data; + else + return NULL; } -/* The 'g' parameter is just used for error reporting. Events - * for multiple handles can be dispatched by running the main - * loop. +/* When tracing, be careful how we print BufferIn parameters which + * usually contain large amounts of binary data (RHBZ#646822). */ -static int -select_main_loop_run (guestfs_main_loop *mlv, guestfs_h *g) +void +guestfs___print_BufferIn (FILE *out, const char *buf, size_t buf_size) { - 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; - } + size_t i; + size_t orig_size = buf_size; - ml->is_running = 1; + if (buf_size > 256) + buf_size = 256; - 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; - } + fputc ('"', out); - 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); - } - } + for (i = 0; i < buf_size; ++i) { + if (c_isprint (buf[i])) + fputc (buf[i], out); + else + fprintf (out, "\\x%02x", (unsigned char) buf[i]); } - ml->is_running = 0; - return 0; -} + fputc ('"', out); -static int -select_main_loop_quit (guestfs_main_loop *mlv, guestfs_h *g) -{ - struct select_main_loop *ml = (struct select_main_loop *) mlv; - - if (!ml->is_running) { - error (g, "cannot quit, we are not running in a main loop"); - return -1; - } - - ml->is_running = 0; - return 0; + if (orig_size > buf_size) + fprintf (out, + _(""), orig_size); }