-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)
-{
- char buffer[GUESTFS_MESSAGE_MAX];
- struct guestfs_message_header hdr;
- XDR xdr;
- unsigned 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;
- }
-
- /* 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;
-
- xdrmem_create (&xdr, g->msg_out, 4, XDR_ENCODE);
- xdr_uint32_t (&xdr, &len);
-
- memcpy (g->msg_out + 4, buffer, 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)) > 0) {
- 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)