X-Git-Url: http://git.annexia.org/?a=blobdiff_plain;f=src%2Fguestfs.c;h=309cd15b56799d0891e7c7c40a956f630a807176;hb=40ca9a57829f2e82362e391d7d998bf33c8bd671;hp=a827157b4c9ae8a4b7f2e52ab05108d9ed6e53e1;hpb=88f69eb03160a62d38a361a5ad68c6ba1e767a20;p=libguestfs.git diff --git a/src/guestfs.c b/src/guestfs.c index a827157..309cd15 100644 --- a/src/guestfs.c +++ b/src/guestfs.c @@ -29,6 +29,9 @@ #include #include #include +#include +#include +#include #ifdef HAVE_ERRNO_H #include @@ -50,9 +53,8 @@ #include #endif -#include - #include "guestfs.h" +#include "guestfs_protocol.h" static void error (guestfs_h *g, const char *fs, ...); static void perrorf (guestfs_h *g, const char *fs, ...); @@ -63,7 +65,7 @@ static char *safe_strdup (guestfs_h *g, const char *str); static void default_error_cb (guestfs_h *g, void *data, const char *msg); static void stdout_event (void *data, int watch, int fd, int events); static void sock_read_event (void *data, int watch, int fd, int events); -//static void sock_write_event (void *data, int watch, int fd, int events); +static void sock_write_event (void *data, int watch, int fd, int events); static int select_add_handle (guestfs_h *g, int fd, int events, guestfs_handle_event_cb cb, void *data); static int select_remove_handle (guestfs_h *g, int watch); @@ -74,6 +76,7 @@ static void select_main_loop_quit (guestfs_h *g); #define UNIX_PATH_MAX 108 +/* Also in guestfsd.c */ #define VMCHANNEL_PORT 6666 #define VMCHANNEL_ADDR "10.0.2.4" @@ -131,6 +134,14 @@ struct guestfs_h void * reply_cb_internal_data; guestfs_launch_done_cb launch_done_cb_internal; void * launch_done_cb_internal_data; + + /* 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; }; guestfs_h * @@ -206,7 +217,7 @@ guestfs_close (guestfs_h *g) static void default_error_cb (guestfs_h *g, void *data, const char *msg) { - fprintf (stderr, "libguestfs: %s\n", msg); + fprintf (stderr, "libguestfs: error: %s\n", msg); } static void @@ -445,6 +456,7 @@ guestfs_launch (guestfs_h *g) } snprintf (unixsock, sizeof unixsock, "%s/sock", g->tmpdir); + unlink (unixsock); if (pipe (wfd) == -1 || pipe (rfd) == -1) { perrorf (g, "pipe"); @@ -578,7 +590,8 @@ guestfs_launch (guestfs_h *g) if ((r == -1 && errno == EINPROGRESS) || r == 0) goto connected; - perrorf (g, "connect"); + if (errno != ENOENT) + perrorf (g, "connect"); tries--; } @@ -587,6 +600,15 @@ guestfs_launch (guestfs_h *g) 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 = main_loop.add_handle (g, g->fd[1], GUESTFS_HANDLE_READABLE, @@ -598,9 +620,7 @@ guestfs_launch (guestfs_h *g) g->sock_watch = main_loop.add_handle (g, g->sock, - GUESTFS_HANDLE_READABLE | - GUESTFS_HANDLE_HANGUP | - GUESTFS_HANDLE_ERROR, + GUESTFS_HANDLE_READABLE, sock_read_event, g); if (g->sock_watch == -1) { error (g, "could not watch daemon communications socket"); @@ -769,16 +789,269 @@ stdout_event (void *data, int watch, int fd, int events) static void sock_read_event (void *data, int watch, int fd, int events) { - /*guestfs_h *g = (guestfs_h *) data;*/ + guestfs_h *g = (guestfs_h *) data; + 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_internal) + g->launch_done_cb_internal (g, g->launch_done_cb_internal_data); + 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 < 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 > len) { + error (g, "len = %d, but msg_in_size = %d", len, g->msg_in_size); + goto cleanup; + } + + /* Not in the expected state. */ + if (g->state != BUSY) + error (g, "state %d != BUSY", g->state); + + /* Push the message up to the higher layer. Note that unlike + * launch_done_cb / launch_done_cb_internal, we only call at + * most one of the callback functions here. + */ + g->state = READY; + if (g->reply_cb_internal) + g->reply_cb_internal (g, g->reply_cb_internal_data, &xdr); + else if (g->reply_cb) + g->reply_cb (g, g->reply_cb, &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); } +/* The function is called whenever we can write something on the + * guestfsd (daemon inside the guest) communication socket. + */ +static void +sock_write_event (void *data, int watch, int fd, int events) +{ + guestfs_h *g = (guestfs_h *) data; + 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", n); + + free (g->msg_out); + g->msg_out_pos = g->msg_out_size = 0; + + if (main_loop.remove_handle (g, g->sock_watch) == -1) { + error (g, "remove_handle failed in sock_write_event"); + return; + } + g->sock_watch = + main_loop.add_handle (g, g->sock, + GUESTFS_HANDLE_READABLE, + sock_read_event, g); + if (g->sock_watch == -1) { + error (g, "add_handle failed in sock_write_event"); + return; + } +} + +/* Dispatch a call 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. + */ +static int +dispatch (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 (main_loop.remove_handle (g, g->sock_watch) == -1) { + error (g, "remove_handle failed in dispatch"); + goto cleanup1; + } + g->sock_watch = + main_loop.add_handle (g, g->sock, + GUESTFS_HANDLE_WRITABLE, + sock_write_event, g); + 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; +} + +/* The high-level actions are autogenerated by generator.ml. Include + * them here. + */ +#include "guestfs-actions.c" + /* This is the default main loop implementation, using select(2). */ struct handle_cb_data { @@ -791,6 +1064,7 @@ static fd_set wset; static fd_set xset; static int select_init_done = 0; static int max_fd = -1; +static int nr_fds = 0; static struct handle_cb_data *handle_cb_data = NULL; static void @@ -854,6 +1128,8 @@ select_add_handle (guestfs_h *g, int fd, int events, handle_cb_data[fd].cb = cb; handle_cb_data[fd].data = data; + nr_fds++; + /* Any integer >= 0 can be the handle, and this is as good as any ... */ return fd; } @@ -883,6 +1159,8 @@ select_remove_handle (guestfs_h *g, int fd) sizeof (struct handle_cb_data) * (max_fd+1)); } + nr_fds--; + return 0; } @@ -916,6 +1194,11 @@ select_main_loop_run (guestfs_h *g) old_level = level++; while (level > old_level) { + if (nr_fds == 0) { + level = old_level; + break; + } + rset2 = rset; wset2 = wset; xset2 = xset;