#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 (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 stdout_event (struct guestfs_main_loop *ml, guestfs_h *g, void *data, int watch, int fd, int events);
+static void sock_read_event (struct guestfs_main_loop *ml, guestfs_h *g, void *data, int watch, int fd, int events);
+static void sock_write_event (struct guestfs_main_loop *ml, guestfs_h *g, void *data, int watch, int fd, int events);
static void close_handles (void);
-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);
-static int select_add_timeout (guestfs_h *g, int interval, guestfs_handle_timeout_cb cb, void *data);
-static int select_remove_timeout (guestfs_h *g, int timer);
-static void select_main_loop_run (guestfs_h *g);
-static void select_main_loop_quit (guestfs_h *g);
+static int select_add_handle (guestfs_main_loop *ml, guestfs_h *g, int fd, int events, guestfs_handle_event_cb cb, void *data);
+static int select_remove_handle (guestfs_main_loop *ml, guestfs_h *g, int watch);
+static int select_add_timeout (guestfs_main_loop *ml, guestfs_h *g, int interval, guestfs_handle_timeout_cb cb, void *data);
+static int select_remove_timeout (guestfs_main_loop *ml, guestfs_h *g, int timer);
+static int select_main_loop_run (guestfs_main_loop *ml, guestfs_h *g);
+static int select_main_loop_quit (guestfs_main_loop *ml, guestfs_h *g);
-#define UNIX_PATH_MAX 108
+/* Default select-based main loop. */
+struct select_handle_cb_data {
+ guestfs_handle_event_cb cb;
+ guestfs_h *g;
+ void *data;
+};
-/* Also in guestfsd.c */
-#define VMCHANNEL_PORT 6666
-#define VMCHANNEL_ADDR "10.0.2.4"
+struct select_main_loop {
+ /* NB. These fields must be the same as in struct guestfs_main_loop: */
+ guestfs_add_handle_cb add_handle;
+ guestfs_remove_handle_cb remove_handle;
+ guestfs_add_timeout_cb add_timeout;
+ guestfs_remove_timeout_cb remove_timeout;
+ guestfs_main_loop_run_cb main_loop_run;
+ guestfs_main_loop_quit_cb main_loop_quit;
+
+ /* Additional private data: */
+ int is_running;
+
+ fd_set rset;
+ fd_set wset;
+ fd_set xset;
+
+ int max_fd;
+ int nr_fds;
+ struct select_handle_cb_data *handle_cb_data;
+};
-/* Current main loop. */
-static guestfs_main_loop main_loop = {
+/* Default main loop. */
+static struct select_main_loop default_main_loop = {
.add_handle = select_add_handle,
.remove_handle = select_remove_handle,
.add_timeout = select_add_timeout,
.remove_timeout = select_remove_timeout,
.main_loop_run = select_main_loop_run,
.main_loop_quit = select_main_loop_quit,
+
+ /* XXX hopefully .rset, .wset, .xset are initialized to the empty
+ * set by the normal action of everything being initialized to zero.
+ */
+ .is_running = 0,
+ .max_fd = -1,
+ .nr_fds = 0,
+ .handle_cb_data = NULL,
};
+#define UNIX_PATH_MAX 108
+
+/* Also in guestfsd.c */
+#define VMCHANNEL_PORT 6666
+#define VMCHANNEL_ADDR "10.0.2.4"
+
/* GuestFS handle and connection. */
enum state { CONFIG, LAUNCHING, READY, BUSY, NO_HANDLE };
const char *path;
+ char *last_error;
+
/* Callbacks. */
guestfs_abort_cb abort_cb;
guestfs_error_handler_cb error_cb;
void * error_cb_data;
+ guestfs_send_cb send_cb;
+ void * send_cb_data;
guestfs_reply_cb reply_cb;
void * reply_cb_data;
guestfs_log_message_cb log_message_cb;
guestfs_launch_done_cb launch_done_cb;
void * launch_done_cb_data;
- /* These callbacks are called before 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_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;
/* Messages sent and received from the daemon. */
char *msg_in;
g->path = str != NULL ? str : GUESTFS_DEFAULT_PATH;
/* XXX We should probably make QEMU configurable as well. */
+ g->main_loop = guestfs_get_default_main_loop ();
+
/* Start with large serial numbers so they are easy to spot
* inside the protocol.
*/
}
/* release mutex (XXX) */
+ free (g->last_error);
free (g);
}
while (handles) guestfs_close (handles);
}
+const char *
+guestfs_last_error (guestfs_h *g)
+{
+ return g->last_error;
+}
+
+static void
+set_last_error (guestfs_h *g, const char *msg)
+{
+ free (g->last_error);
+ g->last_error = strdup (msg);
+}
+
static void
default_error_cb (guestfs_h *g, void *data, const char *msg)
{
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;
- if (!g->error_cb) return;
-
va_start (args, fs);
vasprintf (&msg, fs, args);
va_end (args);
- g->error_cb (g, g->error_cb_data, msg);
+ if (g->error_cb) g->error_cb (g, g->error_cb_data, msg);
+ set_last_error (g, 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;
int err = errno;
- if (!g->error_cb) return;
-
va_start (args, fs);
vasprintf (&msg, fs, args);
va_end (args);
strcat (msg, ": ");
strcat (msg, buf);
- g->error_cb (g, g->error_cb_data, msg);
+ if (g->error_cb) g->error_cb (g, g->error_cb_data, msg);
+ set_last_error (g, 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)
{
return g->error_cb;
}
-void
+int
guestfs_set_verbose (guestfs_h *g, int v)
{
- g->verbose = v;
+ g->verbose = !!v;
+ return 0;
}
int
return g->verbose;
}
-void
+int
guestfs_set_autosync (guestfs_h *g, int a)
{
- g->autosync = a;
+ g->autosync = !!a;
+ return 0;
}
int
return g->autosync;
}
-void
+int
guestfs_set_path (guestfs_h *g, const char *path)
{
if (path == NULL)
g->path = GUESTFS_DEFAULT_PATH;
else
g->path = path;
+ return 0;
}
const char *
g->msg_out_pos = 0;
g->stdout_watch =
- main_loop.add_handle (g, g->fd[1],
- GUESTFS_HANDLE_READABLE,
- stdout_event, g);
+ g->main_loop->add_handle (g->main_loop, g, g->fd[1],
+ GUESTFS_HANDLE_READABLE,
+ stdout_event, NULL);
if (g->stdout_watch == -1) {
error (g, "could not watch qemu stdout");
goto cleanup3;
}
- g->sock_watch =
- main_loop.add_handle (g, g->sock,
- GUESTFS_HANDLE_READABLE,
- sock_read_event, g);
- 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;
cleanup3:
if (g->stdout_watch >= 0)
- main_loop.remove_handle (g, g->stdout_watch);
+ g->main_loop->remove_handle (g->main_loop, g, g->stdout_watch);
if (g->sock_watch >= 0)
- main_loop.remove_handle (g, g->sock_watch);
+ g->main_loop->remove_handle (g->main_loop, g, g->sock_watch);
cleanup2:
close (g->sock);
static void
finish_wait_ready (guestfs_h *g, void *vp)
{
+ if (g->verbose)
+ fprintf (stderr, "finish_wait_ready called, %p, vp = %p\n", g, vp);
+
*((int *)vp) = 1;
- main_loop.main_loop_quit (g);
+ g->main_loop->main_loop_quit (g->main_loop, g);
}
int
guestfs_wait_ready (guestfs_h *g)
{
- int r = 0;
+ int finished = 0, r;
if (g->state == READY) return 0;
return -1;
}
- g->launch_done_cb_internal = finish_wait_ready;
- g->launch_done_cb_internal_data = &r;
- main_loop.main_loop_run (g);
- g->launch_done_cb_internal = NULL;
- g->launch_done_cb_internal_data = NULL;
+ 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 = NULL;
+ g->launch_done_cb_data = NULL;
+
+ if (r == -1) return -1;
- if (r != 1) {
+ if (finished != 1) {
error (g, "guestfs_wait_ready failed, see earlier error messages");
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.
*/
static void
-stdout_event (void *data, int watch, int fd, int events)
+stdout_event (struct guestfs_main_loop *ml, guestfs_h *g, void *data,
+ int watch, int fd, int events)
{
- guestfs_h *g = (guestfs_h *) data;
char buf[4096];
int n;
/*kill (g->pid, SIGTERM);*/
waitpid (g->pid, NULL, 0);
if (g->stdout_watch >= 0)
- main_loop.remove_handle (g, g->stdout_watch);
+ g->main_loop->remove_handle (g->main_loop, g, g->stdout_watch);
if (g->sock_watch >= 0)
- main_loop.remove_handle (g, g->sock_watch);
+ g->main_loop->remove_handle (g->main_loop, g, g->sock_watch);
close (g->fd[0]);
close (g->fd[1]);
close (g->sock);
* guestfsd (daemon inside the guest) communication socket.
*/
static void
-sock_read_event (void *data, int watch, int fd, int events)
+sock_read_event (struct guestfs_main_loop *ml, guestfs_h *g, void *data,
+ int watch, int fd, int events)
{
- guestfs_h *g = (guestfs_h *) data;
XDR xdr;
unsigned len;
int n;
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. */
* guestfsd (daemon inside the guest) communication socket.
*/
static void
-sock_write_event (void *data, int watch, int fd, int events)
+sock_write_event (struct guestfs_main_loop *ml, guestfs_h *g, void *data,
+ int watch, int fd, int events)
{
- guestfs_h *g = (guestfs_h *) data;
int n;
if (g->verbose)
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 (main_loop.remove_handle (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 =
- main_loop.add_handle (g, g->sock,
- GUESTFS_HANDLE_READABLE,
- sock_read_event, g);
+ 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 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.
+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 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 (main_loop.remove_handle (g, g->sock_watch) == -1) {
- error (g, "remove_handle failed in dispatch");
+ if (guestfs__switch_to_sending (g) == -1)
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");
+
+ 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;
}
-/* 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)
+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. */
+int
+guestfs__send_file_sync (guestfs_h *g, const char *filename)
{
- if (hdr->prog != GUESTFS_PROGRAM) {
- error (g, "wrong program (%d/%d)", hdr->prog, GUESTFS_PROGRAM);
+ 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_sync (g);
+ /* Daemon sees cancellation and won't reply, so caller can
+ * just return here.
+ */
return -1;
}
- if (hdr->vers != GUESTFS_PROTOCOL_VERSION) {
- error (g, "wrong protocol version (%d/%d)",
- hdr->vers, GUESTFS_PROTOCOL_VERSION);
- return -1;
+
+ /* Send file in chunked encoding. */
+ while (!cancel && (r = read (fd, buf, sizeof buf)) > 0) {
+ if (send_file_data_sync (g, buf, r) == -1)
+ return -1;
}
- if (hdr->direction != GUESTFS_DIRECTION_REPLY) {
- error (g, "unexpected message direction (%d/%d)",
- hdr->direction, GUESTFS_DIRECTION_REPLY);
+
+ if (cancel) {
+ send_file_cancellation_sync (g);
return -1;
}
- if (hdr->proc != proc_nr) {
- error (g, "unexpected procedure number (%d/%d)", hdr->proc, proc_nr);
+
+ if (r == -1) {
+ perrorf (g, "read: %s", filename);
+ send_file_cancellation_sync (g);
return -1;
}
- if (hdr->serial != serial) {
- error (g, "unexpected serial (%d/%d)", hdr->serial, serial);
+
+ /* 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 0;
+ return send_file_complete_sync (g);
}
-/* The high-level actions are autogenerated by generator.ml. Include
- * them here.
- */
-#include "guestfs-actions.c"
+/* 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);
+}
-/* 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_lvm_pv_list (struct guestfs_lvm_pv_list *x)
+/* Send a cancellation message. */
+static int
+send_file_cancellation_sync (guestfs_h *g)
{
- xdr_free ((xdrproc_t) xdr_guestfs_lvm_int_pv_list, (char *) x);
- free (x);
+ char buf[1];
+ return send_file_chunk_sync (g, 1, buf, 0);
}
-void
-guestfs_free_lvm_vg_list (struct guestfs_lvm_vg_list *x)
+/* Send a file complete chunk. */
+static int
+send_file_complete_sync (guestfs_h *g)
{
- xdr_free ((xdrproc_t) xdr_guestfs_lvm_int_vg_list, (char *) x);
- free (x);
+ char buf[1];
+ return send_file_chunk_sync (g, 0, buf, 0);
}
-void
-guestfs_free_lvm_lv_list (struct guestfs_lvm_lv_list *x)
+/* 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)
{
- xdr_free ((xdrproc_t) xdr_guestfs_lvm_int_lv_list, (char *) x);
- free (x);
+ 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;
+ }
+
+ /* Serialize the chunk. */
+ chunk.cancel = cancel;
+ chunk.data.data_len = len;
+ chunk.data.data_val = (char *) buf;
+
+ data = safe_malloc (g, GUESTFS_MAX_CHUNK_SIZE + 48);
+ xdrmem_create (&xdr, data, GUESTFS_MAX_CHUNK_SIZE + 48, XDR_ENCODE);
+ if (xdr_guestfs_chunk (&xdr, &chunk)) {
+ error (g, "xdr_guestfs_chunk failed");
+ free (data);
+ return -1;
+ }
+
+ datalen = xdr_getpos (&xdr);
+ xdr_destroy (&xdr);
+
+ data = safe_realloc (g, data, datalen);
+ g->msg_out = data;
+ g->msg_out_size = datalen;
+ g->msg_out_pos = 0;
+
+ 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;
+ g->state = READY;
+ return -1;
}
-/* This is the default main loop implementation, using select(2). */
+/* 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);
-struct handle_cb_data {
- guestfs_handle_event_cb cb;
- void *data;
-};
+int
+guestfs__receive_file_sync (guestfs_h *g, const char *filename)
+{
+ void *buf;
+ int fd, r;
+
+ fd = open (filename, O_WRONLY|O_CREAT|O_TRUNC|O_NOCTTY);
+ if (fd == -1) {
+ perrorf (g, "open: %s", filename);
+ 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 (r == -1) {
+ error (g, "%s: error in chunked encoding", filename);
+ return -1;
+ }
+
+ if (close (fd) == -1) {
+ perrorf (g, "close: %s", filename);
+ return -1;
+ }
-static fd_set rset;
-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;
+ return 0;
+}
+
+struct receive_file_ctx {
+ int code;
+ void **buf;
+};
static void
-select_init (void)
+receive_file_cb (guestfs_h *g, void *data, XDR *xdr)
{
- if (!select_init_done) {
- FD_ZERO (&rset);
- FD_ZERO (&wset);
- FD_ZERO (&xset);
+ guestfs_main_loop *ml = guestfs_get_main_loop (g);
+ struct receive_file_ctx *ctx = (struct receive_file_ctx *) data;
+ guestfs_chunk chunk;
- select_init_done = 1;
+ ml->main_loop_quit (ml, g);
+
+ 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 */
+}
+
+/* Receive a chunk of file data. */
+static int
+receive_file_data_sync (guestfs_h *g, void **buf)
+{
+ 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). */
+
static int
-select_add_handle (guestfs_h *g, int fd, int events,
+select_add_handle (guestfs_main_loop *mlv, guestfs_h *g, int fd, int events,
guestfs_handle_event_cb cb, void *data)
{
- select_init ();
+ 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, &rset) || FD_ISSET (fd, &wset) || FD_ISSET (fd, &xset)) {
+ 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 ((events & GUESTFS_HANDLE_READABLE))
- FD_SET (fd, &rset);
+ FD_SET (fd, &ml->rset);
if ((events & GUESTFS_HANDLE_WRITABLE))
- FD_SET (fd, &wset);
+ FD_SET (fd, &ml->wset);
if ((events & GUESTFS_HANDLE_HANGUP) || (events & GUESTFS_HANDLE_ERROR))
- FD_SET (fd, &xset);
+ FD_SET (fd, &ml->xset);
- if (fd > max_fd) {
- max_fd = fd;
- handle_cb_data = safe_realloc (g, handle_cb_data,
- sizeof (struct handle_cb_data) * (max_fd+1));
+ 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));
}
- handle_cb_data[fd].cb = cb;
- handle_cb_data[fd].data = data;
+ ml->handle_cb_data[fd].cb = cb;
+ ml->handle_cb_data[fd].g = g;
+ ml->handle_cb_data[fd].data = data;
- nr_fds++;
+ 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_h *g, int fd)
+select_remove_handle (guestfs_main_loop *mlv, guestfs_h *g, int fd)
{
- select_init ();
+ 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, &rset) && !FD_ISSET (fd, &wset) && !FD_ISSET (fd, &xset)) {
+ 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, &rset);
- FD_CLR (fd, &wset);
- FD_CLR (fd, &xset);
+ FD_CLR (fd, &ml->rset);
+ FD_CLR (fd, &ml->wset);
+ FD_CLR (fd, &ml->xset);
- if (fd == max_fd) {
- max_fd--;
- handle_cb_data = safe_realloc (g, handle_cb_data,
- sizeof (struct handle_cb_data) * (max_fd+1));
+ 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));
}
- nr_fds--;
+ ml->nr_fds--;
return 0;
}
static int
-select_add_timeout (guestfs_h *g, int interval,
+select_add_timeout (guestfs_main_loop *mlv, guestfs_h *g, int interval,
guestfs_handle_timeout_cb cb, void *data)
{
- select_init ();
+ //struct select_main_loop *ml = (struct select_main_loop *) mlv;
abort (); /* XXX not implemented yet */
}
static int
-select_remove_timeout (guestfs_h *g, int timer)
+select_remove_timeout (guestfs_main_loop *mlv, guestfs_h *g, int timer)
{
- select_init ();
+ //struct select_main_loop *ml = (struct select_main_loop *) mlv;
abort (); /* XXX not implemented yet */
}
-/* Note that main loops can be nested. */
-static int level = 0;
-
-static void
-select_main_loop_run (guestfs_h *g)
+/* 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)
{
- int old_level, fd, r, events;
+ struct select_main_loop *ml = (struct select_main_loop *) mlv;
+ int fd, r, events;
fd_set rset2, wset2, xset2;
- select_init ();
+ if (ml->is_running) {
+ error (g, "select_main_loop_run: this cannot be called recursively");
+ return -1;
+ }
- old_level = level++;
- while (level > old_level) {
- if (nr_fds == 0) {
- level = old_level;
+ ml->is_running = 1;
+
+ while (ml->is_running) {
+ if (ml->nr_fds == 0)
break;
- }
- rset2 = rset;
- wset2 = wset;
- xset2 = xset;
- r = select (max_fd+1, &rset2, &wset2, &xset2, NULL);
+ rset2 = ml->rset;
+ wset2 = ml->wset;
+ xset2 = ml->xset;
+ r = select (ml->max_fd+1, &rset2, &wset2, &xset2, NULL);
if (r == -1) {
perrorf (g, "select");
- level = old_level;
- break;
+ ml->is_running = 0;
+ return -1;
}
- for (fd = 0; r > 0 && fd <= max_fd; ++fd) {
+ for (fd = 0; r > 0 && fd <= ml->max_fd; ++fd) {
events = 0;
if (FD_ISSET (fd, &rset2))
events |= GUESTFS_HANDLE_READABLE;
events |= GUESTFS_HANDLE_ERROR | GUESTFS_HANDLE_HANGUP;
if (events) {
r--;
- handle_cb_data[fd].cb (handle_cb_data[fd].data,
- fd, fd, events);
+ 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 void
-select_main_loop_quit (guestfs_h *g)
+static int
+select_main_loop_quit (guestfs_main_loop *mlv, guestfs_h *g)
{
- select_init ();
+ struct select_main_loop *ml = (struct select_main_loop *) mlv;
- if (level == 0) {
- error (g, "cannot quit, we are not in a main loop");
- return;
+ if (!ml->is_running) {
+ error (g, "cannot quit, we are not running in a main loop");
+ return -1;
}
- level--;
+ ml->is_running = 0;
+ return 0;
}