#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, ...);
-static void *safe_malloc (guestfs_h *g, size_t nbytes);
-static void *safe_realloc (guestfs_h *g, void *ptr, int nbytes);
-static char *safe_strdup (guestfs_h *g, const char *str);
-static void *safe_memdup (guestfs_h *g, void *ptr, size_t size);
+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);
+
+#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
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);
guestfs_launch_done_cb launch_done_cb;
void * launch_done_cb_data;
- /* These callbacks are called before send_cb, reply_cb and
- * launch_done_cb, and are used to implement the high-level
- * API without needing to interfere with callbacks that the
- * user might have set.
- */
- guestfs_send_cb send_cb_internal;
- void * send_cb_internal_data;
- guestfs_reply_cb reply_cb_internal;
- void * reply_cb_internal_data;
- guestfs_launch_done_cb launch_done_cb_internal;
- void * launch_done_cb_internal_data;
-
/* Main loop used by this handle. */
guestfs_main_loop *main_loop;
g->path = str != NULL ? str : GUESTFS_DEFAULT_PATH;
/* XXX We should probably make QEMU configurable as well. */
- g->main_loop = (guestfs_main_loop *) &default_main_loop;
+ g->main_loop = guestfs_get_default_main_loop ();
/* Start with large serial numbers so they are easy to spot
* inside the protocol.
fprintf (stderr, "libguestfs: error: %s\n", msg);
}
-static void
-error (guestfs_h *g, const char *fs, ...)
+void
+guestfs_error (guestfs_h *g, const char *fs, ...)
{
va_list args;
char *msg;
free (msg);
}
-static void
-perrorf (guestfs_h *g, const char *fs, ...)
+void
+guestfs_perrorf (guestfs_h *g, const char *fs, ...)
{
va_list args;
char *msg;
free (msg);
}
-static void *
-safe_malloc (guestfs_h *g, size_t nbytes)
+void *
+guestfs_safe_malloc (guestfs_h *g, size_t nbytes)
{
void *ptr = malloc (nbytes);
if (!ptr) g->abort_cb ();
return ptr;
}
-static void *
-safe_realloc (guestfs_h *g, void *ptr, int nbytes)
+void *
+guestfs_safe_realloc (guestfs_h *g, void *ptr, int nbytes)
{
void *p = realloc (ptr, nbytes);
if (!p) g->abort_cb ();
return p;
}
-static char *
-safe_strdup (guestfs_h *g, const char *str)
+char *
+guestfs_safe_strdup (guestfs_h *g, const char *str)
{
char *s = strdup (str);
if (!s) g->abort_cb ();
return s;
}
-static void *
-safe_memdup (guestfs_h *g, void *ptr, size_t size)
+void *
+guestfs_safe_memdup (guestfs_h *g, void *ptr, size_t size)
{
void *p = malloc (size);
if (!p) g->abort_cb ();
return p;
}
+static int
+xwrite (int fd, const void *buf, size_t len)
+{
+ int r;
+
+ while (len > 0) {
+ r = write (fd, buf, len);
+ if (r == -1) {
+ perror ("write");
+ return -1;
+ }
+ buf += r;
+ len -= r;
+ }
+
+ return 0;
+}
+
void
guestfs_set_out_of_memory_handler (guestfs_h *g, guestfs_abort_cb cb)
{
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");
+ if (guestfs__switch_to_receiving (g) == -1)
goto cleanup3;
- }
g->state = LAUNCHING;
return 0;
return -1;
}
- g->launch_done_cb_internal = finish_wait_ready;
- g->launch_done_cb_internal_data = &finished;
+ 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_internal = NULL;
- g->launch_done_cb_internal_data = NULL;
+ g->launch_done_cb = NULL;
+ g->launch_done_cb_data = NULL;
if (r == -1) return -1;
return 0;
}
+/* Access current state. */
+int
+guestfs_is_config (guestfs_h *g)
+{
+ return g->state == CONFIG;
+}
+
+int
+guestfs_is_launching (guestfs_h *g)
+{
+ return g->state == LAUNCHING;
+}
+
+int
+guestfs_is_ready (guestfs_h *g)
+{
+ return g->state == READY;
+}
+
+int
+guestfs_is_busy (guestfs_h *g)
+{
+ return g->state == BUSY;
+}
+
+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)
+{
+ xdr_free ((xdrproc_t) xdr_guestfs_lvm_int_lv_list, (char *) x);
+ free (x);
+}
+
/* 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.
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);
}
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.
- */
+ /* Push the message up to the higher layer. */
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);
+ if (g->reply_cb)
+ g->reply_cb (g, g->reply_cb_data, &xdr);
cleanup:
/* Free the message buffer if it's grown excessively large. */
fprintf (stderr, "sock_write_event: done writing, switching back to reading events\n");
free (g->msg_out);
+ g->msg_out = NULL;
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;
+ /* 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 in sock_write_event");
- return;
+ error (g, "add_handle failed");
+ return -1;
}
+
+ return 0;
}
-/* 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.
+/* 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 int
-dispatch (guestfs_h *g, int proc_nr, xdrproc_t xdrp, char *args)
+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 != READY) {
error (g, "dispatch: state %d != READY", g->state);
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");
+ if (guestfs__switch_to_sending (g) == -1)
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");
+
+ 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 -1;
}
-#if 0
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);
-static int
-send_file (guestfs_h *g, const char *filename)
+/* Synchronously send a file. */
+int
+guestfs__send_file_sync (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);
+ send_file_cancellation_sync (g);
/* Daemon sees cancellation and won't reply, so caller can
* just return here.
*/
/* Send file in chunked encoding. */
while (!cancel && (r = read (fd, buf, sizeof buf)) > 0) {
- if (send_file_data (g, buf, r) == -1)
+ if (send_file_data_sync (g, buf, r) == -1)
return -1;
}
if (cancel) {
- send_file_cancellation (g);
+ send_file_cancellation_sync (g);
return -1;
}
if (r == -1) {
perrorf (g, "read: %s", filename);
- send_file_cancellation (g);
+ send_file_cancellation_sync (g);
return -1;
}
*/
if (close (fd) == -1) {
perrorf (g, "close: %s", filename);
- send_file_cancellation (g);
+ send_file_cancellation_sync (g);
return -1;
}
- return send_file_complete (g);
+ return send_file_complete_sync (g);
}
-/* Send a chunk, cancellation or end of file, wait for it to go. */
+/* Send a chunk of file data. */
static int
-send_file_chunk (guestfs_h *g, int cancel, const char *buf, size_t len)
+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)
+{
+ char buf[1];
+ return send_file_chunk_sync (g, 1, buf, 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
+send_file_chunk_sync (guestfs_h *g, int cancel, const char *buf, size_t len)
{
void *data;
+ unsigned datalen;
+ 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: state %d != READY", g->state);
return -1;
}
- chunkdatalen = xdr_getpos (&xdr);
- xdr_destroy (&xdr);
-
- len = xdr_getpos (&xdr);
+ datalen = xdr_getpos (&xdr);
xdr_destroy (&xdr);
- data = safe_realloc (g, data, len);
+ data = safe_realloc (g, data, datalen);
g->msg_out = data;
- g->msg_out_size = len;
+ g->msg_out_size = datalen;
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");
+ if (guestfs__switch_to_sending (g) == -1)
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");
+
+ 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 -1;
}
-/* Send a chunk of file data. */
-static int
-send_file_data (guestfs_h *g, const char *buf, size_t len)
-{
- return send_file_chunk (g, 0, buf, len);
-}
-
-/* Send a cancellation message. */
-static int
-send_file_cancellation (guestfs_h *g)
-{
- char buf[1];
- return send_file_chunk (g, 1, buf, 0);
-}
+/* Synchronously receive a file.
+ * XXX No way to cancel file receives. We would need to send an
+ * error to the daemon and have it see this and stop sending.
+ */
+static int receive_file_data_sync (guestfs_h *g, void **buf);
-/* Send a file complete chunk. */
-static int
-send_file_complete (guestfs_h *g)
+int
+guestfs__receive_file_sync (guestfs_h *g, const char *filename)
{
- char buf[0];
- return send_file_chunk (g, 0, buf, 0);
-}
-#endif
+ void *buf;
+ int fd, r;
-/* Check the return message from a call for validity. */
-static int
-check_reply_header (guestfs_h *g,
- const struct guestfs_message_header *hdr,
- int proc_nr, int serial)
-{
- if (hdr->prog != GUESTFS_PROGRAM) {
- error (g, "wrong program (%d/%d)", hdr->prog, GUESTFS_PROGRAM);
- return -1;
- }
- if (hdr->vers != GUESTFS_PROTOCOL_VERSION) {
- error (g, "wrong protocol version (%d/%d)",
- hdr->vers, GUESTFS_PROTOCOL_VERSION);
+ fd = open (filename, O_WRONLY|O_CREAT|O_TRUNC|O_NOCTTY);
+ if (fd == -1) {
+ perrorf (g, "open: %s", filename);
return -1;
}
- if (hdr->direction != GUESTFS_DIRECTION_REPLY) {
- error (g, "unexpected message direction (%d/%d)",
- hdr->direction, GUESTFS_DIRECTION_REPLY);
- return -1;
+
+ /* Receive the file in chunked encoding. */
+ while ((r = receive_file_data_sync (g, &buf)) > 0) {
+ if (xwrite (fd, buf, r) == -1) {
+ free (buf);
+ return -1;
+ }
+ free (buf);
}
- if (hdr->proc != proc_nr) {
- error (g, "unexpected procedure number (%d/%d)", hdr->proc, proc_nr);
+
+ if (r == -1) {
+ error (g, "%s: error in chunked encoding", filename);
return -1;
}
- if (hdr->serial != serial) {
- error (g, "unexpected serial (%d/%d)", hdr->serial, serial);
+
+ if (close (fd) == -1) {
+ perrorf (g, "close: %s", filename);
return -1;
}
return 0;
}
-/* The high-level actions are autogenerated by generator.ml. Include
- * them here.
- */
-#include "guestfs-actions.c"
+struct receive_file_ctx {
+ int code;
+ void **buf;
+};
-/* 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)
+static void
+receive_file_cb (guestfs_h *g, void *data, XDR *xdr)
{
- free (x);
-}
+ guestfs_main_loop *ml = guestfs_get_main_loop (g);
+ struct receive_file_ctx *ctx = (struct receive_file_ctx *) data;
+ guestfs_chunk chunk;
-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);
-}
+ ml->main_loop_quit (ml, g);
-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);
+ if (!xdr_guestfs_chunk (xdr, &chunk)) {
+ error (g, "failed to parse file chunk");
+ ctx->code = -1;
+ return;
+ }
+ if (chunk.cancel) {
+ error (g, "file receive cancelled by daemon");
+ ctx->code = -2;
+ return;
+ }
+ if (chunk.data.data_len == 0) { /* end of transfer */
+ ctx->code = 0;
+ return;
+ }
+
+ ctx->code = chunk.data.data_len;
+ *ctx->buf = chunk.data.data_val; /* caller frees */
}
-void
-guestfs_free_lvm_lv_list (struct guestfs_lvm_lv_list *x)
+/* Receive a chunk of file data. */
+static int
+receive_file_data_sync (guestfs_h *g, void **buf)
{
- xdr_free ((xdrproc_t) xdr_guestfs_lvm_int_lv_list, (char *) x);
- free (x);
+ struct receive_file_ctx ctx;
+ guestfs_main_loop *ml = guestfs_get_main_loop (g);
+
+ ctx.code = -3;
+ ctx.buf = buf;
+
+ guestfs_set_reply_callback (g, receive_file_cb, &ctx);
+ (void) ml->main_loop_run (ml, g);
+ guestfs_set_reply_callback (g, NULL, NULL);
+ switch (ctx.code) {
+ case 0: /* end of file */
+ return 0;
+ case -1: case -2:
+ return -1;
+ case -3:
+ error (g, "failed to call receive_file_cb");
+ return -1;
+ default: /* received n bytes of data */
+ return ctx.code;
+ }
}
/* This is the default main loop implementation, using select(2). */
git.annexia.org / libguestfs.git / blobdiff