return -1;
}
- read_reply:
guestfs__switch_to_receiving (g);
ctx.cb_sequence = 0;
guestfs_set_reply_callback (g, mount_reply_cb, &ctx);
return -1;
}
- read_reply:
guestfs__switch_to_receiving (g);
ctx.cb_sequence = 0;
guestfs_set_reply_callback (g, sync_reply_cb, &ctx);
return -1;
}
- read_reply:
guestfs__switch_to_receiving (g);
ctx.cb_sequence = 0;
guestfs_set_reply_callback (g, touch_reply_cb, &ctx);
return NULL;
}
- read_reply:
guestfs__switch_to_receiving (g);
ctx.cb_sequence = 0;
guestfs_set_reply_callback (g, cat_reply_cb, &ctx);
return NULL;
}
- read_reply:
guestfs__switch_to_receiving (g);
ctx.cb_sequence = 0;
guestfs_set_reply_callback (g, ll_reply_cb, &ctx);
return NULL;
}
- read_reply:
guestfs__switch_to_receiving (g);
ctx.cb_sequence = 0;
guestfs_set_reply_callback (g, ls_reply_cb, &ctx);
return NULL;
}
- read_reply:
guestfs__switch_to_receiving (g);
ctx.cb_sequence = 0;
guestfs_set_reply_callback (g, list_devices_reply_cb, &ctx);
return NULL;
}
- read_reply:
guestfs__switch_to_receiving (g);
ctx.cb_sequence = 0;
guestfs_set_reply_callback (g, list_partitions_reply_cb, &ctx);
return NULL;
}
- read_reply:
guestfs__switch_to_receiving (g);
ctx.cb_sequence = 0;
guestfs_set_reply_callback (g, pvs_reply_cb, &ctx);
return NULL;
}
- read_reply:
guestfs__switch_to_receiving (g);
ctx.cb_sequence = 0;
guestfs_set_reply_callback (g, vgs_reply_cb, &ctx);
return NULL;
}
- read_reply:
guestfs__switch_to_receiving (g);
ctx.cb_sequence = 0;
guestfs_set_reply_callback (g, lvs_reply_cb, &ctx);
return NULL;
}
- read_reply:
guestfs__switch_to_receiving (g);
ctx.cb_sequence = 0;
guestfs_set_reply_callback (g, pvs_full_reply_cb, &ctx);
return NULL;
}
- read_reply:
guestfs__switch_to_receiving (g);
ctx.cb_sequence = 0;
guestfs_set_reply_callback (g, vgs_full_reply_cb, &ctx);
return NULL;
}
- read_reply:
guestfs__switch_to_receiving (g);
ctx.cb_sequence = 0;
guestfs_set_reply_callback (g, lvs_full_reply_cb, &ctx);
return NULL;
}
- read_reply:
guestfs__switch_to_receiving (g);
ctx.cb_sequence = 0;
guestfs_set_reply_callback (g, read_lines_reply_cb, &ctx);
return -1;
}
- read_reply:
guestfs__switch_to_receiving (g);
ctx.cb_sequence = 0;
guestfs_set_reply_callback (g, aug_init_reply_cb, &ctx);
return -1;
}
- read_reply:
guestfs__switch_to_receiving (g);
ctx.cb_sequence = 0;
guestfs_set_reply_callback (g, aug_close_reply_cb, &ctx);
return -1;
}
- read_reply:
guestfs__switch_to_receiving (g);
ctx.cb_sequence = 0;
guestfs_set_reply_callback (g, aug_defvar_reply_cb, &ctx);
return NULL;
}
- read_reply:
guestfs__switch_to_receiving (g);
ctx.cb_sequence = 0;
guestfs_set_reply_callback (g, aug_defnode_reply_cb, &ctx);
return NULL;
}
- read_reply:
guestfs__switch_to_receiving (g);
ctx.cb_sequence = 0;
guestfs_set_reply_callback (g, aug_get_reply_cb, &ctx);
return -1;
}
- read_reply:
guestfs__switch_to_receiving (g);
ctx.cb_sequence = 0;
guestfs_set_reply_callback (g, aug_set_reply_cb, &ctx);
return -1;
}
- read_reply:
guestfs__switch_to_receiving (g);
ctx.cb_sequence = 0;
guestfs_set_reply_callback (g, aug_insert_reply_cb, &ctx);
return -1;
}
- read_reply:
guestfs__switch_to_receiving (g);
ctx.cb_sequence = 0;
guestfs_set_reply_callback (g, aug_rm_reply_cb, &ctx);
return -1;
}
- read_reply:
guestfs__switch_to_receiving (g);
ctx.cb_sequence = 0;
guestfs_set_reply_callback (g, aug_mv_reply_cb, &ctx);
return NULL;
}
- read_reply:
guestfs__switch_to_receiving (g);
ctx.cb_sequence = 0;
guestfs_set_reply_callback (g, aug_match_reply_cb, &ctx);
return -1;
}
- read_reply:
guestfs__switch_to_receiving (g);
ctx.cb_sequence = 0;
guestfs_set_reply_callback (g, aug_save_reply_cb, &ctx);
return -1;
}
- read_reply:
guestfs__switch_to_receiving (g);
ctx.cb_sequence = 0;
guestfs_set_reply_callback (g, aug_load_reply_cb, &ctx);
return NULL;
}
- read_reply:
guestfs__switch_to_receiving (g);
ctx.cb_sequence = 0;
guestfs_set_reply_callback (g, aug_ls_reply_cb, &ctx);
return -1;
}
- read_reply:
guestfs__switch_to_receiving (g);
ctx.cb_sequence = 0;
guestfs_set_reply_callback (g, rm_reply_cb, &ctx);
return -1;
}
- read_reply:
guestfs__switch_to_receiving (g);
ctx.cb_sequence = 0;
guestfs_set_reply_callback (g, rmdir_reply_cb, &ctx);
return -1;
}
- read_reply:
guestfs__switch_to_receiving (g);
ctx.cb_sequence = 0;
guestfs_set_reply_callback (g, rm_rf_reply_cb, &ctx);
return -1;
}
- read_reply:
guestfs__switch_to_receiving (g);
ctx.cb_sequence = 0;
guestfs_set_reply_callback (g, mkdir_reply_cb, &ctx);
return -1;
}
- read_reply:
guestfs__switch_to_receiving (g);
ctx.cb_sequence = 0;
guestfs_set_reply_callback (g, mkdir_p_reply_cb, &ctx);
return -1;
}
- read_reply:
guestfs__switch_to_receiving (g);
ctx.cb_sequence = 0;
guestfs_set_reply_callback (g, chmod_reply_cb, &ctx);
return -1;
}
- read_reply:
guestfs__switch_to_receiving (g);
ctx.cb_sequence = 0;
guestfs_set_reply_callback (g, chown_reply_cb, &ctx);
return -1;
}
- read_reply:
guestfs__switch_to_receiving (g);
ctx.cb_sequence = 0;
guestfs_set_reply_callback (g, exists_reply_cb, &ctx);
return -1;
}
- read_reply:
guestfs__switch_to_receiving (g);
ctx.cb_sequence = 0;
guestfs_set_reply_callback (g, is_file_reply_cb, &ctx);
return -1;
}
- read_reply:
guestfs__switch_to_receiving (g);
ctx.cb_sequence = 0;
guestfs_set_reply_callback (g, is_dir_reply_cb, &ctx);
return -1;
}
- read_reply:
guestfs__switch_to_receiving (g);
ctx.cb_sequence = 0;
guestfs_set_reply_callback (g, pvcreate_reply_cb, &ctx);
return -1;
}
- read_reply:
guestfs__switch_to_receiving (g);
ctx.cb_sequence = 0;
guestfs_set_reply_callback (g, vgcreate_reply_cb, &ctx);
return -1;
}
- read_reply:
guestfs__switch_to_receiving (g);
ctx.cb_sequence = 0;
guestfs_set_reply_callback (g, lvcreate_reply_cb, &ctx);
return -1;
}
- read_reply:
guestfs__switch_to_receiving (g);
ctx.cb_sequence = 0;
guestfs_set_reply_callback (g, mkfs_reply_cb, &ctx);
return -1;
}
- read_reply:
guestfs__switch_to_receiving (g);
ctx.cb_sequence = 0;
guestfs_set_reply_callback (g, sfdisk_reply_cb, &ctx);
return -1;
}
- read_reply:
guestfs__switch_to_receiving (g);
ctx.cb_sequence = 0;
guestfs_set_reply_callback (g, write_file_reply_cb, &ctx);
return -1;
}
- read_reply:
guestfs__switch_to_receiving (g);
ctx.cb_sequence = 0;
guestfs_set_reply_callback (g, umount_reply_cb, &ctx);
return NULL;
}
- read_reply:
guestfs__switch_to_receiving (g);
ctx.cb_sequence = 0;
guestfs_set_reply_callback (g, mounts_reply_cb, &ctx);
return -1;
}
- read_reply:
guestfs__switch_to_receiving (g);
ctx.cb_sequence = 0;
guestfs_set_reply_callback (g, umount_all_reply_cb, &ctx);
return -1;
}
- read_reply:
guestfs__switch_to_receiving (g);
ctx.cb_sequence = 0;
guestfs_set_reply_callback (g, lvm_remove_all_reply_cb, &ctx);
return NULL;
}
- read_reply:
guestfs__switch_to_receiving (g);
ctx.cb_sequence = 0;
guestfs_set_reply_callback (g, file_reply_cb, &ctx);
return NULL;
}
- read_reply:
guestfs__switch_to_receiving (g);
ctx.cb_sequence = 0;
guestfs_set_reply_callback (g, command_reply_cb, &ctx);
return NULL;
}
- read_reply:
guestfs__switch_to_receiving (g);
ctx.cb_sequence = 0;
guestfs_set_reply_callback (g, command_lines_reply_cb, &ctx);
return NULL;
}
- read_reply:
guestfs__switch_to_receiving (g);
ctx.cb_sequence = 0;
guestfs_set_reply_callback (g, stat_reply_cb, &ctx);
return NULL;
}
- read_reply:
guestfs__switch_to_receiving (g);
ctx.cb_sequence = 0;
guestfs_set_reply_callback (g, lstat_reply_cb, &ctx);
return NULL;
}
- read_reply:
guestfs__switch_to_receiving (g);
ctx.cb_sequence = 0;
guestfs_set_reply_callback (g, statvfs_reply_cb, &ctx);
return NULL;
}
- read_reply:
guestfs__switch_to_receiving (g);
ctx.cb_sequence = 0;
guestfs_set_reply_callback (g, tune2fs_l_reply_cb, &ctx);
return -1;
}
- read_reply:
guestfs__switch_to_receiving (g);
ctx.cb_sequence = 0;
guestfs_set_reply_callback (g, blockdev_setro_reply_cb, &ctx);
return -1;
}
- read_reply:
guestfs__switch_to_receiving (g);
ctx.cb_sequence = 0;
guestfs_set_reply_callback (g, blockdev_setrw_reply_cb, &ctx);
return -1;
}
- read_reply:
guestfs__switch_to_receiving (g);
ctx.cb_sequence = 0;
guestfs_set_reply_callback (g, blockdev_getro_reply_cb, &ctx);
return -1;
}
- read_reply:
guestfs__switch_to_receiving (g);
ctx.cb_sequence = 0;
guestfs_set_reply_callback (g, blockdev_getss_reply_cb, &ctx);
return -1;
}
- read_reply:
guestfs__switch_to_receiving (g);
ctx.cb_sequence = 0;
guestfs_set_reply_callback (g, blockdev_getbsz_reply_cb, &ctx);
return -1;
}
- read_reply:
guestfs__switch_to_receiving (g);
ctx.cb_sequence = 0;
guestfs_set_reply_callback (g, blockdev_setbsz_reply_cb, &ctx);
return -1;
}
- read_reply:
guestfs__switch_to_receiving (g);
ctx.cb_sequence = 0;
guestfs_set_reply_callback (g, blockdev_getsz_reply_cb, &ctx);
return -1;
}
- read_reply:
guestfs__switch_to_receiving (g);
ctx.cb_sequence = 0;
guestfs_set_reply_callback (g, blockdev_getsize64_reply_cb, &ctx);
return -1;
}
- read_reply:
guestfs__switch_to_receiving (g);
ctx.cb_sequence = 0;
guestfs_set_reply_callback (g, blockdev_flushbufs_reply_cb, &ctx);
return -1;
}
- read_reply:
guestfs__switch_to_receiving (g);
ctx.cb_sequence = 0;
guestfs_set_reply_callback (g, blockdev_rereadpt_reply_cb, &ctx);
return -1;
}
- read_reply:
guestfs__switch_to_receiving (g);
ctx.cb_sequence = 0;
guestfs_set_reply_callback (g, download_reply_cb, &ctx);
return NULL;
}
- read_reply:
guestfs__switch_to_receiving (g);
ctx.cb_sequence = 0;
guestfs_set_reply_callback (g, checksum_reply_cb, &ctx);
return ctx.ret.checksum; /* caller will free */
}
+struct tar_in_ctx {
+ /* This flag is set by the callbacks, so we know we've done
+ * the callbacks as expected, and in the right sequence.
+ * 0 = not called, 1 = send called,
+ * 1001 = reply called.
+ */
+ int cb_sequence;
+ struct guestfs_message_header hdr;
+ struct guestfs_message_error err;
+};
+
+static void tar_in_reply_cb (guestfs_h *g, void *data, XDR *xdr)
+{
+ guestfs_main_loop *ml = guestfs_get_main_loop (g);
+ struct tar_in_ctx *ctx = (struct tar_in_ctx *) data;
+
+ ml->main_loop_quit (ml, g);
+
+ if (!xdr_guestfs_message_header (xdr, &ctx->hdr)) {
+ error (g, "%s: failed to parse reply header", "guestfs_tar_in");
+ return;
+ }
+ if (ctx->hdr.status == GUESTFS_STATUS_ERROR) {
+ if (!xdr_guestfs_message_error (xdr, &ctx->err)) {
+ error (g, "%s: failed to parse reply error", "guestfs_tar_in");
+ return;
+ }
+ goto done;
+ }
+ done:
+ ctx->cb_sequence = 1001;
+}
+
+int guestfs_tar_in (guestfs_h *g,
+ const char *tarfile,
+ const char *directory)
+{
+ struct guestfs_tar_in_args args;
+ struct tar_in_ctx ctx;
+ guestfs_main_loop *ml = guestfs_get_main_loop (g);
+ int serial;
+
+ if (check_state (g, "guestfs_tar_in") == -1) return -1;
+ guestfs_set_busy (g);
+
+ memset (&ctx, 0, sizeof ctx);
+
+ args.directory = (char *) directory;
+ serial = guestfs__send_sync (g, GUESTFS_PROC_TAR_IN,
+ (xdrproc_t) xdr_guestfs_tar_in_args, (char *) &args);
+ if (serial == -1) {
+ guestfs_set_ready (g);
+ return -1;
+ }
+
+ {
+ int r;
+
+ r = guestfs__send_file_sync (g, tarfile);
+ if (r == -1) {
+ guestfs_set_ready (g);
+ return -1;
+ }
+ if (r == -2) /* daemon cancelled */
+ goto read_reply;
+ }
+
+ read_reply:
+ guestfs__switch_to_receiving (g);
+ ctx.cb_sequence = 0;
+ guestfs_set_reply_callback (g, tar_in_reply_cb, &ctx);
+ (void) ml->main_loop_run (ml, g);
+ guestfs_set_reply_callback (g, NULL, NULL);
+ if (ctx.cb_sequence != 1001) {
+ error (g, "%s reply failed, see earlier error messages", "guestfs_tar_in");
+ guestfs_set_ready (g);
+ return -1;
+ }
+
+ if (check_reply_header (g, &ctx.hdr, GUESTFS_PROC_TAR_IN, serial) == -1) {
+ guestfs_set_ready (g);
+ return -1;
+ }
+
+ if (ctx.hdr.status == GUESTFS_STATUS_ERROR) {
+ error (g, "%s", ctx.err.error_message);
+ guestfs_set_ready (g);
+ return -1;
+ }
+
+ guestfs_set_ready (g);
+ return 0;
+}
+
+struct tar_out_ctx {
+ /* This flag is set by the callbacks, so we know we've done
+ * the callbacks as expected, and in the right sequence.
+ * 0 = not called, 1 = send called,
+ * 1001 = reply called.
+ */
+ int cb_sequence;
+ struct guestfs_message_header hdr;
+ struct guestfs_message_error err;
+};
+
+static void tar_out_reply_cb (guestfs_h *g, void *data, XDR *xdr)
+{
+ guestfs_main_loop *ml = guestfs_get_main_loop (g);
+ struct tar_out_ctx *ctx = (struct tar_out_ctx *) data;
+
+ ml->main_loop_quit (ml, g);
+
+ if (!xdr_guestfs_message_header (xdr, &ctx->hdr)) {
+ error (g, "%s: failed to parse reply header", "guestfs_tar_out");
+ return;
+ }
+ if (ctx->hdr.status == GUESTFS_STATUS_ERROR) {
+ if (!xdr_guestfs_message_error (xdr, &ctx->err)) {
+ error (g, "%s: failed to parse reply error", "guestfs_tar_out");
+ return;
+ }
+ goto done;
+ }
+ done:
+ ctx->cb_sequence = 1001;
+}
+
+int guestfs_tar_out (guestfs_h *g,
+ const char *directory,
+ const char *tarfile)
+{
+ struct guestfs_tar_out_args args;
+ struct tar_out_ctx ctx;
+ guestfs_main_loop *ml = guestfs_get_main_loop (g);
+ int serial;
+
+ if (check_state (g, "guestfs_tar_out") == -1) return -1;
+ guestfs_set_busy (g);
+
+ memset (&ctx, 0, sizeof ctx);
+
+ args.directory = (char *) directory;
+ serial = guestfs__send_sync (g, GUESTFS_PROC_TAR_OUT,
+ (xdrproc_t) xdr_guestfs_tar_out_args, (char *) &args);
+ if (serial == -1) {
+ guestfs_set_ready (g);
+ return -1;
+ }
+
+ guestfs__switch_to_receiving (g);
+ ctx.cb_sequence = 0;
+ guestfs_set_reply_callback (g, tar_out_reply_cb, &ctx);
+ (void) ml->main_loop_run (ml, g);
+ guestfs_set_reply_callback (g, NULL, NULL);
+ if (ctx.cb_sequence != 1001) {
+ error (g, "%s reply failed, see earlier error messages", "guestfs_tar_out");
+ guestfs_set_ready (g);
+ return -1;
+ }
+
+ if (check_reply_header (g, &ctx.hdr, GUESTFS_PROC_TAR_OUT, serial) == -1) {
+ guestfs_set_ready (g);
+ return -1;
+ }
+
+ if (ctx.hdr.status == GUESTFS_STATUS_ERROR) {
+ error (g, "%s", ctx.err.error_message);
+ guestfs_set_ready (g);
+ return -1;
+ }
+
+ if (guestfs__receive_file_sync (g, tarfile) == -1) {
+ guestfs_set_ready (g);
+ return -1;
+ }
+
+ guestfs_set_ready (g);
+ return 0;
+}
+
+struct tgz_in_ctx {
+ /* This flag is set by the callbacks, so we know we've done
+ * the callbacks as expected, and in the right sequence.
+ * 0 = not called, 1 = send called,
+ * 1001 = reply called.
+ */
+ int cb_sequence;
+ struct guestfs_message_header hdr;
+ struct guestfs_message_error err;
+};
+
+static void tgz_in_reply_cb (guestfs_h *g, void *data, XDR *xdr)
+{
+ guestfs_main_loop *ml = guestfs_get_main_loop (g);
+ struct tgz_in_ctx *ctx = (struct tgz_in_ctx *) data;
+
+ ml->main_loop_quit (ml, g);
+
+ if (!xdr_guestfs_message_header (xdr, &ctx->hdr)) {
+ error (g, "%s: failed to parse reply header", "guestfs_tgz_in");
+ return;
+ }
+ if (ctx->hdr.status == GUESTFS_STATUS_ERROR) {
+ if (!xdr_guestfs_message_error (xdr, &ctx->err)) {
+ error (g, "%s: failed to parse reply error", "guestfs_tgz_in");
+ return;
+ }
+ goto done;
+ }
+ done:
+ ctx->cb_sequence = 1001;
+}
+
+int guestfs_tgz_in (guestfs_h *g,
+ const char *tarball,
+ const char *directory)
+{
+ struct guestfs_tgz_in_args args;
+ struct tgz_in_ctx ctx;
+ guestfs_main_loop *ml = guestfs_get_main_loop (g);
+ int serial;
+
+ if (check_state (g, "guestfs_tgz_in") == -1) return -1;
+ guestfs_set_busy (g);
+
+ memset (&ctx, 0, sizeof ctx);
+
+ args.directory = (char *) directory;
+ serial = guestfs__send_sync (g, GUESTFS_PROC_TGZ_IN,
+ (xdrproc_t) xdr_guestfs_tgz_in_args, (char *) &args);
+ if (serial == -1) {
+ guestfs_set_ready (g);
+ return -1;
+ }
+
+ {
+ int r;
+
+ r = guestfs__send_file_sync (g, tarball);
+ if (r == -1) {
+ guestfs_set_ready (g);
+ return -1;
+ }
+ if (r == -2) /* daemon cancelled */
+ goto read_reply;
+ }
+
+ read_reply:
+ guestfs__switch_to_receiving (g);
+ ctx.cb_sequence = 0;
+ guestfs_set_reply_callback (g, tgz_in_reply_cb, &ctx);
+ (void) ml->main_loop_run (ml, g);
+ guestfs_set_reply_callback (g, NULL, NULL);
+ if (ctx.cb_sequence != 1001) {
+ error (g, "%s reply failed, see earlier error messages", "guestfs_tgz_in");
+ guestfs_set_ready (g);
+ return -1;
+ }
+
+ if (check_reply_header (g, &ctx.hdr, GUESTFS_PROC_TGZ_IN, serial) == -1) {
+ guestfs_set_ready (g);
+ return -1;
+ }
+
+ if (ctx.hdr.status == GUESTFS_STATUS_ERROR) {
+ error (g, "%s", ctx.err.error_message);
+ guestfs_set_ready (g);
+ return -1;
+ }
+
+ guestfs_set_ready (g);
+ return 0;
+}
+
+struct tgz_out_ctx {
+ /* This flag is set by the callbacks, so we know we've done
+ * the callbacks as expected, and in the right sequence.
+ * 0 = not called, 1 = send called,
+ * 1001 = reply called.
+ */
+ int cb_sequence;
+ struct guestfs_message_header hdr;
+ struct guestfs_message_error err;
+};
+
+static void tgz_out_reply_cb (guestfs_h *g, void *data, XDR *xdr)
+{
+ guestfs_main_loop *ml = guestfs_get_main_loop (g);
+ struct tgz_out_ctx *ctx = (struct tgz_out_ctx *) data;
+
+ ml->main_loop_quit (ml, g);
+
+ if (!xdr_guestfs_message_header (xdr, &ctx->hdr)) {
+ error (g, "%s: failed to parse reply header", "guestfs_tgz_out");
+ return;
+ }
+ if (ctx->hdr.status == GUESTFS_STATUS_ERROR) {
+ if (!xdr_guestfs_message_error (xdr, &ctx->err)) {
+ error (g, "%s: failed to parse reply error", "guestfs_tgz_out");
+ return;
+ }
+ goto done;
+ }
+ done:
+ ctx->cb_sequence = 1001;
+}
+
+int guestfs_tgz_out (guestfs_h *g,
+ const char *directory,
+ const char *tarball)
+{
+ struct guestfs_tgz_out_args args;
+ struct tgz_out_ctx ctx;
+ guestfs_main_loop *ml = guestfs_get_main_loop (g);
+ int serial;
+
+ if (check_state (g, "guestfs_tgz_out") == -1) return -1;
+ guestfs_set_busy (g);
+
+ memset (&ctx, 0, sizeof ctx);
+
+ args.directory = (char *) directory;
+ serial = guestfs__send_sync (g, GUESTFS_PROC_TGZ_OUT,
+ (xdrproc_t) xdr_guestfs_tgz_out_args, (char *) &args);
+ if (serial == -1) {
+ guestfs_set_ready (g);
+ return -1;
+ }
+
+ guestfs__switch_to_receiving (g);
+ ctx.cb_sequence = 0;
+ guestfs_set_reply_callback (g, tgz_out_reply_cb, &ctx);
+ (void) ml->main_loop_run (ml, g);
+ guestfs_set_reply_callback (g, NULL, NULL);
+ if (ctx.cb_sequence != 1001) {
+ error (g, "%s reply failed, see earlier error messages", "guestfs_tgz_out");
+ guestfs_set_ready (g);
+ return -1;
+ }
+
+ if (check_reply_header (g, &ctx.hdr, GUESTFS_PROC_TGZ_OUT, serial) == -1) {
+ guestfs_set_ready (g);
+ return -1;
+ }
+
+ if (ctx.hdr.status == GUESTFS_STATUS_ERROR) {
+ error (g, "%s", ctx.err.error_message);
+ guestfs_set_ready (g);
+ return -1;
+ }
+
+ if (guestfs__receive_file_sync (g, tarball) == -1) {
+ guestfs_set_ready (g);
+ return -1;
+ }
+
+ guestfs_set_ready (g);
+ return 0;
+}
+
+struct mount_ro_ctx {
+ /* This flag is set by the callbacks, so we know we've done
+ * the callbacks as expected, and in the right sequence.
+ * 0 = not called, 1 = send called,
+ * 1001 = reply called.
+ */
+ int cb_sequence;
+ struct guestfs_message_header hdr;
+ struct guestfs_message_error err;
+};
+
+static void mount_ro_reply_cb (guestfs_h *g, void *data, XDR *xdr)
+{
+ guestfs_main_loop *ml = guestfs_get_main_loop (g);
+ struct mount_ro_ctx *ctx = (struct mount_ro_ctx *) data;
+
+ ml->main_loop_quit (ml, g);
+
+ if (!xdr_guestfs_message_header (xdr, &ctx->hdr)) {
+ error (g, "%s: failed to parse reply header", "guestfs_mount_ro");
+ return;
+ }
+ if (ctx->hdr.status == GUESTFS_STATUS_ERROR) {
+ if (!xdr_guestfs_message_error (xdr, &ctx->err)) {
+ error (g, "%s: failed to parse reply error", "guestfs_mount_ro");
+ return;
+ }
+ goto done;
+ }
+ done:
+ ctx->cb_sequence = 1001;
+}
+
+int guestfs_mount_ro (guestfs_h *g,
+ const char *device,
+ const char *mountpoint)
+{
+ struct guestfs_mount_ro_args args;
+ struct mount_ro_ctx ctx;
+ guestfs_main_loop *ml = guestfs_get_main_loop (g);
+ int serial;
+
+ if (check_state (g, "guestfs_mount_ro") == -1) return -1;
+ guestfs_set_busy (g);
+
+ memset (&ctx, 0, sizeof ctx);
+
+ args.device = (char *) device;
+ args.mountpoint = (char *) mountpoint;
+ serial = guestfs__send_sync (g, GUESTFS_PROC_MOUNT_RO,
+ (xdrproc_t) xdr_guestfs_mount_ro_args, (char *) &args);
+ if (serial == -1) {
+ guestfs_set_ready (g);
+ return -1;
+ }
+
+ guestfs__switch_to_receiving (g);
+ ctx.cb_sequence = 0;
+ guestfs_set_reply_callback (g, mount_ro_reply_cb, &ctx);
+ (void) ml->main_loop_run (ml, g);
+ guestfs_set_reply_callback (g, NULL, NULL);
+ if (ctx.cb_sequence != 1001) {
+ error (g, "%s reply failed, see earlier error messages", "guestfs_mount_ro");
+ guestfs_set_ready (g);
+ return -1;
+ }
+
+ if (check_reply_header (g, &ctx.hdr, GUESTFS_PROC_MOUNT_RO, serial) == -1) {
+ guestfs_set_ready (g);
+ return -1;
+ }
+
+ if (ctx.hdr.status == GUESTFS_STATUS_ERROR) {
+ error (g, "%s", ctx.err.error_message);
+ guestfs_set_ready (g);
+ return -1;
+ }
+
+ guestfs_set_ready (g);
+ return 0;
+}
+
+struct mount_options_ctx {
+ /* This flag is set by the callbacks, so we know we've done
+ * the callbacks as expected, and in the right sequence.
+ * 0 = not called, 1 = send called,
+ * 1001 = reply called.
+ */
+ int cb_sequence;
+ struct guestfs_message_header hdr;
+ struct guestfs_message_error err;
+};
+
+static void mount_options_reply_cb (guestfs_h *g, void *data, XDR *xdr)
+{
+ guestfs_main_loop *ml = guestfs_get_main_loop (g);
+ struct mount_options_ctx *ctx = (struct mount_options_ctx *) data;
+
+ ml->main_loop_quit (ml, g);
+
+ if (!xdr_guestfs_message_header (xdr, &ctx->hdr)) {
+ error (g, "%s: failed to parse reply header", "guestfs_mount_options");
+ return;
+ }
+ if (ctx->hdr.status == GUESTFS_STATUS_ERROR) {
+ if (!xdr_guestfs_message_error (xdr, &ctx->err)) {
+ error (g, "%s: failed to parse reply error", "guestfs_mount_options");
+ return;
+ }
+ goto done;
+ }
+ done:
+ ctx->cb_sequence = 1001;
+}
+
+int guestfs_mount_options (guestfs_h *g,
+ const char *options,
+ const char *device,
+ const char *mountpoint)
+{
+ struct guestfs_mount_options_args args;
+ struct mount_options_ctx ctx;
+ guestfs_main_loop *ml = guestfs_get_main_loop (g);
+ int serial;
+
+ if (check_state (g, "guestfs_mount_options") == -1) return -1;
+ guestfs_set_busy (g);
+
+ memset (&ctx, 0, sizeof ctx);
+
+ args.options = (char *) options;
+ args.device = (char *) device;
+ args.mountpoint = (char *) mountpoint;
+ serial = guestfs__send_sync (g, GUESTFS_PROC_MOUNT_OPTIONS,
+ (xdrproc_t) xdr_guestfs_mount_options_args, (char *) &args);
+ if (serial == -1) {
+ guestfs_set_ready (g);
+ return -1;
+ }
+
+ guestfs__switch_to_receiving (g);
+ ctx.cb_sequence = 0;
+ guestfs_set_reply_callback (g, mount_options_reply_cb, &ctx);
+ (void) ml->main_loop_run (ml, g);
+ guestfs_set_reply_callback (g, NULL, NULL);
+ if (ctx.cb_sequence != 1001) {
+ error (g, "%s reply failed, see earlier error messages", "guestfs_mount_options");
+ guestfs_set_ready (g);
+ return -1;
+ }
+
+ if (check_reply_header (g, &ctx.hdr, GUESTFS_PROC_MOUNT_OPTIONS, serial) == -1) {
+ guestfs_set_ready (g);
+ return -1;
+ }
+
+ if (ctx.hdr.status == GUESTFS_STATUS_ERROR) {
+ error (g, "%s", ctx.err.error_message);
+ guestfs_set_ready (g);
+ return -1;
+ }
+
+ guestfs_set_ready (g);
+ return 0;
+}
+
+struct mount_vfs_ctx {
+ /* This flag is set by the callbacks, so we know we've done
+ * the callbacks as expected, and in the right sequence.
+ * 0 = not called, 1 = send called,
+ * 1001 = reply called.
+ */
+ int cb_sequence;
+ struct guestfs_message_header hdr;
+ struct guestfs_message_error err;
+};
+
+static void mount_vfs_reply_cb (guestfs_h *g, void *data, XDR *xdr)
+{
+ guestfs_main_loop *ml = guestfs_get_main_loop (g);
+ struct mount_vfs_ctx *ctx = (struct mount_vfs_ctx *) data;
+
+ ml->main_loop_quit (ml, g);
+
+ if (!xdr_guestfs_message_header (xdr, &ctx->hdr)) {
+ error (g, "%s: failed to parse reply header", "guestfs_mount_vfs");
+ return;
+ }
+ if (ctx->hdr.status == GUESTFS_STATUS_ERROR) {
+ if (!xdr_guestfs_message_error (xdr, &ctx->err)) {
+ error (g, "%s: failed to parse reply error", "guestfs_mount_vfs");
+ return;
+ }
+ goto done;
+ }
+ done:
+ ctx->cb_sequence = 1001;
+}
+
+int guestfs_mount_vfs (guestfs_h *g,
+ const char *options,
+ const char *vfstype,
+ const char *device,
+ const char *mountpoint)
+{
+ struct guestfs_mount_vfs_args args;
+ struct mount_vfs_ctx ctx;
+ guestfs_main_loop *ml = guestfs_get_main_loop (g);
+ int serial;
+
+ if (check_state (g, "guestfs_mount_vfs") == -1) return -1;
+ guestfs_set_busy (g);
+
+ memset (&ctx, 0, sizeof ctx);
+
+ args.options = (char *) options;
+ args.vfstype = (char *) vfstype;
+ args.device = (char *) device;
+ args.mountpoint = (char *) mountpoint;
+ serial = guestfs__send_sync (g, GUESTFS_PROC_MOUNT_VFS,
+ (xdrproc_t) xdr_guestfs_mount_vfs_args, (char *) &args);
+ if (serial == -1) {
+ guestfs_set_ready (g);
+ return -1;
+ }
+
+ guestfs__switch_to_receiving (g);
+ ctx.cb_sequence = 0;
+ guestfs_set_reply_callback (g, mount_vfs_reply_cb, &ctx);
+ (void) ml->main_loop_run (ml, g);
+ guestfs_set_reply_callback (g, NULL, NULL);
+ if (ctx.cb_sequence != 1001) {
+ error (g, "%s reply failed, see earlier error messages", "guestfs_mount_vfs");
+ guestfs_set_ready (g);
+ return -1;
+ }
+
+ if (check_reply_header (g, &ctx.hdr, GUESTFS_PROC_MOUNT_VFS, serial) == -1) {
+ guestfs_set_ready (g);
+ return -1;
+ }
+
+ if (ctx.hdr.status == GUESTFS_STATUS_ERROR) {
+ error (g, "%s", ctx.err.error_message);
+ guestfs_set_ready (g);
+ return -1;
+ }
+
+ guestfs_set_ready (g);
+ return 0;
+}
+
+struct debug_ctx {
+ /* This flag is set by the callbacks, so we know we've done
+ * the callbacks as expected, and in the right sequence.
+ * 0 = not called, 1 = send called,
+ * 1001 = reply called.
+ */
+ int cb_sequence;
+ struct guestfs_message_header hdr;
+ struct guestfs_message_error err;
+ struct guestfs_debug_ret ret;
+};
+
+static void debug_reply_cb (guestfs_h *g, void *data, XDR *xdr)
+{
+ guestfs_main_loop *ml = guestfs_get_main_loop (g);
+ struct debug_ctx *ctx = (struct debug_ctx *) data;
+
+ ml->main_loop_quit (ml, g);
+
+ if (!xdr_guestfs_message_header (xdr, &ctx->hdr)) {
+ error (g, "%s: failed to parse reply header", "guestfs_debug");
+ return;
+ }
+ if (ctx->hdr.status == GUESTFS_STATUS_ERROR) {
+ if (!xdr_guestfs_message_error (xdr, &ctx->err)) {
+ error (g, "%s: failed to parse reply error", "guestfs_debug");
+ return;
+ }
+ goto done;
+ }
+ if (!xdr_guestfs_debug_ret (xdr, &ctx->ret)) {
+ error (g, "%s: failed to parse reply", "guestfs_debug");
+ return;
+ }
+ done:
+ ctx->cb_sequence = 1001;
+}
+
+char *guestfs_debug (guestfs_h *g,
+ const char *subcmd,
+ char * const* const extraargs)
+{
+ struct guestfs_debug_args args;
+ struct debug_ctx ctx;
+ guestfs_main_loop *ml = guestfs_get_main_loop (g);
+ int serial;
+
+ if (check_state (g, "guestfs_debug") == -1) return NULL;
+ guestfs_set_busy (g);
+
+ memset (&ctx, 0, sizeof ctx);
+
+ args.subcmd = (char *) subcmd;
+ args.extraargs.extraargs_val = (char **) extraargs;
+ for (args.extraargs.extraargs_len = 0; extraargs[args.extraargs.extraargs_len]; args.extraargs.extraargs_len++) ;
+ serial = guestfs__send_sync (g, GUESTFS_PROC_DEBUG,
+ (xdrproc_t) xdr_guestfs_debug_args, (char *) &args);
+ if (serial == -1) {
+ guestfs_set_ready (g);
+ return NULL;
+ }
+
+ guestfs__switch_to_receiving (g);
+ ctx.cb_sequence = 0;
+ guestfs_set_reply_callback (g, debug_reply_cb, &ctx);
+ (void) ml->main_loop_run (ml, g);
+ guestfs_set_reply_callback (g, NULL, NULL);
+ if (ctx.cb_sequence != 1001) {
+ error (g, "%s reply failed, see earlier error messages", "guestfs_debug");
+ guestfs_set_ready (g);
+ return NULL;
+ }
+
+ if (check_reply_header (g, &ctx.hdr, GUESTFS_PROC_DEBUG, serial) == -1) {
+ guestfs_set_ready (g);
+ return NULL;
+ }
+
+ if (ctx.hdr.status == GUESTFS_STATUS_ERROR) {
+ error (g, "%s", ctx.err.error_message);
+ guestfs_set_ready (g);
+ return NULL;
+ }
+
+ guestfs_set_ready (g);
+ return ctx.ret.result; /* caller will free */
+}
+