X-Git-Url: http://git.annexia.org/?a=blobdiff_plain;f=src%2Fguestfs.c;h=bbcf7a6934ea5c7ef22a12d84288dc5eb9555c82;hb=8d0068a752ee8e6bc223de5cb7cac5d190a8855e;hp=a827157b4c9ae8a4b7f2e52ab05108d9ed6e53e1;hpb=88f69eb03160a62d38a361a5ad68c6ba1e767a20;p=libguestfs.git diff --git a/src/guestfs.c b/src/guestfs.c index a827157..bbcf7a6 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,8 +53,6 @@ #include #endif -#include - #include "guestfs.h" static void error (guestfs_h *g, const char *fs, ...); @@ -74,6 +75,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 +133,12 @@ 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; }; guestfs_h * @@ -206,7 +214,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 +453,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"); @@ -587,6 +596,14 @@ 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->stdout_watch = main_loop.add_handle (g, g->fd[1], GUESTFS_HANDLE_READABLE, @@ -769,14 +786,106 @@ 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_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 (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); } /* This is the default main loop implementation, using select(2). */ @@ -791,6 +900,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 +964,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 +995,8 @@ select_remove_handle (guestfs_h *g, int fd) sizeof (struct handle_cb_data) * (max_fd+1)); } + nr_fds--; + return 0; } @@ -916,6 +1030,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;