- /* 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;
- }
-
- return 0;
-}
-
-int
-guestfs__switch_to_receiving (guestfs_h *g)
-{
- if (g->sock_watch >= 0) {
- if (g->main_loop->remove_handle (g->main_loop, g, g->sock_watch) == -1) {
- error (g, _("remove_handle failed"));
- g->sock_watch = -1;
- return -1;
- }
- }
-
- g->sock_watch =
- g->main_loop->add_handle (g->main_loop, g, g->sock,
- GUESTFS_HANDLE_READABLE,
- sock_read_event, NULL);
- if (g->sock_watch == -1) {
- error (g, _("add_handle failed"));
- return -1;
- }
-
- return 0;
-}
-
-/* Dispatch a call (len + header + args) to the remote daemon,
- * synchronously (ie. using the guest's main loop to wait until
- * it has been sent). Returns -1 for error, or the serial
- * number of the message.
- */
-static void
-send_cb (guestfs_h *g, void *data)
-{
- guestfs_main_loop *ml = guestfs_get_main_loop (g);
-
- *((int *)data) = 1;
- ml->main_loop_quit (ml, g);
-}
-
-int
-guestfs__send_sync (guestfs_h *g, int proc_nr,
- xdrproc_t xdrp, char *args)
-{
- 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)
-{
- 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, "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 (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;
-
- 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);
- }
- }
- }
-
- 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;