1 /* libguestfs generated file
2 * WARNING: THIS FILE IS GENERATED BY 'src/generator.ml'.
3 * ANY CHANGES YOU MAKE TO THIS FILE WILL BE LOST.
5 * Copyright (C) 2009 Red Hat Inc.
7 * This library is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2 of the License, or (at your option) any later version.
12 * This library is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with this library; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
26 #include "guestfs_protocol.h"
28 #define error guestfs_error
29 #define perrorf guestfs_perrorf
30 #define safe_malloc guestfs_safe_malloc
31 #define safe_realloc guestfs_safe_realloc
32 #define safe_strdup guestfs_safe_strdup
33 #define safe_memdup guestfs_safe_memdup
35 /* Check the return message from a call for validity. */
37 check_reply_header (guestfs_h *g,
38 const struct guestfs_message_header *hdr,
39 int proc_nr, int serial)
41 if (hdr->prog != GUESTFS_PROGRAM) {
42 error (g, "wrong program (%d/%d)", hdr->prog, GUESTFS_PROGRAM);
45 if (hdr->vers != GUESTFS_PROTOCOL_VERSION) {
46 error (g, "wrong protocol version (%d/%d)",
47 hdr->vers, GUESTFS_PROTOCOL_VERSION);
50 if (hdr->direction != GUESTFS_DIRECTION_REPLY) {
51 error (g, "unexpected message direction (%d/%d)",
52 hdr->direction, GUESTFS_DIRECTION_REPLY);
55 if (hdr->proc != proc_nr) {
56 error (g, "unexpected procedure number (%d/%d)", hdr->proc, proc_nr);
59 if (hdr->serial != serial) {
60 error (g, "unexpected serial (%d/%d)", hdr->serial, serial);
67 /* Check we are in the right state to run a high-level action. */
69 check_state (guestfs_h *g, const char *caller)
71 if (!guestfs_is_ready (g)) {
72 if (guestfs_is_config (g))
73 error (g, "%s: call launch() before using this function",
75 else if (guestfs_is_launching (g))
76 error (g, "%s: call wait_ready() before using this function",
79 error (g, "%s called from the wrong state, %d != READY",
80 caller, guestfs_get_state (g));
88 struct guestfs_message_header hdr;
89 struct guestfs_message_error err;
92 static void mount_cb (guestfs_h *g, void *data, XDR *xdr)
94 guestfs_main_loop *ml = guestfs_get_main_loop (g);
95 struct mount_state *state = (struct mount_state *) data;
97 if (!xdr_guestfs_message_header (xdr, &state->hdr)) {
98 error (g, "guestfs_mount: failed to parse reply header");
101 if (state->hdr.status == GUESTFS_STATUS_ERROR) {
102 if (!xdr_guestfs_message_error (xdr, &state->err)) {
103 error (g, "guestfs_mount: failed to parse reply error");
110 ml->main_loop_quit (ml, g);
113 int guestfs_mount (guestfs_h *g,
115 const char *mountpoint)
117 struct guestfs_mount_args args;
118 struct mount_state state;
119 guestfs_main_loop *ml = guestfs_get_main_loop (g);
122 if (check_state (g, "guestfs_mount") == -1) return -1;
124 memset (&state, 0, sizeof state);
126 args.device = (char *) device;
127 args.mountpoint = (char *) mountpoint;
128 serial = guestfs_send (g, GUESTFS_PROC_MOUNT,
129 (xdrproc_t) xdr_guestfs_mount_args, (char *) &args);
134 guestfs_set_reply_callback (g, mount_cb, &state);
135 (void) ml->main_loop_run (ml, g);
136 guestfs_set_reply_callback (g, NULL, NULL);
137 if (!state.cb_state) {
138 error (g, "guestfs_mount failed, see earlier error messages");
142 if (check_reply_header (g, &state.hdr, GUESTFS_PROC_MOUNT, serial) == -1)
145 if (state.hdr.status == GUESTFS_STATUS_ERROR) {
146 error (g, "%s", state.err.error_message);
155 struct guestfs_message_header hdr;
156 struct guestfs_message_error err;
159 static void sync_cb (guestfs_h *g, void *data, XDR *xdr)
161 guestfs_main_loop *ml = guestfs_get_main_loop (g);
162 struct sync_state *state = (struct sync_state *) data;
164 if (!xdr_guestfs_message_header (xdr, &state->hdr)) {
165 error (g, "guestfs_sync: failed to parse reply header");
168 if (state->hdr.status == GUESTFS_STATUS_ERROR) {
169 if (!xdr_guestfs_message_error (xdr, &state->err)) {
170 error (g, "guestfs_sync: failed to parse reply error");
177 ml->main_loop_quit (ml, g);
180 int guestfs_sync (guestfs_h *g)
182 struct sync_state state;
183 guestfs_main_loop *ml = guestfs_get_main_loop (g);
186 if (check_state (g, "guestfs_sync") == -1) return -1;
188 memset (&state, 0, sizeof state);
190 serial = guestfs_send (g, GUESTFS_PROC_SYNC, NULL, NULL);
195 guestfs_set_reply_callback (g, sync_cb, &state);
196 (void) ml->main_loop_run (ml, g);
197 guestfs_set_reply_callback (g, NULL, NULL);
198 if (!state.cb_state) {
199 error (g, "guestfs_sync failed, see earlier error messages");
203 if (check_reply_header (g, &state.hdr, GUESTFS_PROC_SYNC, serial) == -1)
206 if (state.hdr.status == GUESTFS_STATUS_ERROR) {
207 error (g, "%s", state.err.error_message);
216 struct guestfs_message_header hdr;
217 struct guestfs_message_error err;
220 static void touch_cb (guestfs_h *g, void *data, XDR *xdr)
222 guestfs_main_loop *ml = guestfs_get_main_loop (g);
223 struct touch_state *state = (struct touch_state *) data;
225 if (!xdr_guestfs_message_header (xdr, &state->hdr)) {
226 error (g, "guestfs_touch: failed to parse reply header");
229 if (state->hdr.status == GUESTFS_STATUS_ERROR) {
230 if (!xdr_guestfs_message_error (xdr, &state->err)) {
231 error (g, "guestfs_touch: failed to parse reply error");
238 ml->main_loop_quit (ml, g);
241 int guestfs_touch (guestfs_h *g,
244 struct guestfs_touch_args args;
245 struct touch_state state;
246 guestfs_main_loop *ml = guestfs_get_main_loop (g);
249 if (check_state (g, "guestfs_touch") == -1) return -1;
251 memset (&state, 0, sizeof state);
253 args.path = (char *) path;
254 serial = guestfs_send (g, GUESTFS_PROC_TOUCH,
255 (xdrproc_t) xdr_guestfs_touch_args, (char *) &args);
260 guestfs_set_reply_callback (g, touch_cb, &state);
261 (void) ml->main_loop_run (ml, g);
262 guestfs_set_reply_callback (g, NULL, NULL);
263 if (!state.cb_state) {
264 error (g, "guestfs_touch failed, see earlier error messages");
268 if (check_reply_header (g, &state.hdr, GUESTFS_PROC_TOUCH, serial) == -1)
271 if (state.hdr.status == GUESTFS_STATUS_ERROR) {
272 error (g, "%s", state.err.error_message);
281 struct guestfs_message_header hdr;
282 struct guestfs_message_error err;
283 struct guestfs_cat_ret ret;
286 static void cat_cb (guestfs_h *g, void *data, XDR *xdr)
288 guestfs_main_loop *ml = guestfs_get_main_loop (g);
289 struct cat_state *state = (struct cat_state *) data;
291 if (!xdr_guestfs_message_header (xdr, &state->hdr)) {
292 error (g, "guestfs_cat: failed to parse reply header");
295 if (state->hdr.status == GUESTFS_STATUS_ERROR) {
296 if (!xdr_guestfs_message_error (xdr, &state->err)) {
297 error (g, "guestfs_cat: failed to parse reply error");
302 if (!xdr_guestfs_cat_ret (xdr, &state->ret)) {
303 error (g, "guestfs_cat: failed to parse reply");
308 ml->main_loop_quit (ml, g);
311 char *guestfs_cat (guestfs_h *g,
314 struct guestfs_cat_args args;
315 struct cat_state state;
316 guestfs_main_loop *ml = guestfs_get_main_loop (g);
319 if (check_state (g, "guestfs_cat") == -1) return NULL;
321 memset (&state, 0, sizeof state);
323 args.path = (char *) path;
324 serial = guestfs_send (g, GUESTFS_PROC_CAT,
325 (xdrproc_t) xdr_guestfs_cat_args, (char *) &args);
330 guestfs_set_reply_callback (g, cat_cb, &state);
331 (void) ml->main_loop_run (ml, g);
332 guestfs_set_reply_callback (g, NULL, NULL);
333 if (!state.cb_state) {
334 error (g, "guestfs_cat failed, see earlier error messages");
338 if (check_reply_header (g, &state.hdr, GUESTFS_PROC_CAT, serial) == -1)
341 if (state.hdr.status == GUESTFS_STATUS_ERROR) {
342 error (g, "%s", state.err.error_message);
346 return state.ret.content; /* caller will free */
351 struct guestfs_message_header hdr;
352 struct guestfs_message_error err;
353 struct guestfs_ll_ret ret;
356 static void ll_cb (guestfs_h *g, void *data, XDR *xdr)
358 guestfs_main_loop *ml = guestfs_get_main_loop (g);
359 struct ll_state *state = (struct ll_state *) data;
361 if (!xdr_guestfs_message_header (xdr, &state->hdr)) {
362 error (g, "guestfs_ll: failed to parse reply header");
365 if (state->hdr.status == GUESTFS_STATUS_ERROR) {
366 if (!xdr_guestfs_message_error (xdr, &state->err)) {
367 error (g, "guestfs_ll: failed to parse reply error");
372 if (!xdr_guestfs_ll_ret (xdr, &state->ret)) {
373 error (g, "guestfs_ll: failed to parse reply");
378 ml->main_loop_quit (ml, g);
381 char *guestfs_ll (guestfs_h *g,
382 const char *directory)
384 struct guestfs_ll_args args;
385 struct ll_state state;
386 guestfs_main_loop *ml = guestfs_get_main_loop (g);
389 if (check_state (g, "guestfs_ll") == -1) return NULL;
391 memset (&state, 0, sizeof state);
393 args.directory = (char *) directory;
394 serial = guestfs_send (g, GUESTFS_PROC_LL,
395 (xdrproc_t) xdr_guestfs_ll_args, (char *) &args);
400 guestfs_set_reply_callback (g, ll_cb, &state);
401 (void) ml->main_loop_run (ml, g);
402 guestfs_set_reply_callback (g, NULL, NULL);
403 if (!state.cb_state) {
404 error (g, "guestfs_ll failed, see earlier error messages");
408 if (check_reply_header (g, &state.hdr, GUESTFS_PROC_LL, serial) == -1)
411 if (state.hdr.status == GUESTFS_STATUS_ERROR) {
412 error (g, "%s", state.err.error_message);
416 return state.ret.listing; /* caller will free */
421 struct guestfs_message_header hdr;
422 struct guestfs_message_error err;
423 struct guestfs_ls_ret ret;
426 static void ls_cb (guestfs_h *g, void *data, XDR *xdr)
428 guestfs_main_loop *ml = guestfs_get_main_loop (g);
429 struct ls_state *state = (struct ls_state *) data;
431 if (!xdr_guestfs_message_header (xdr, &state->hdr)) {
432 error (g, "guestfs_ls: failed to parse reply header");
435 if (state->hdr.status == GUESTFS_STATUS_ERROR) {
436 if (!xdr_guestfs_message_error (xdr, &state->err)) {
437 error (g, "guestfs_ls: failed to parse reply error");
442 if (!xdr_guestfs_ls_ret (xdr, &state->ret)) {
443 error (g, "guestfs_ls: failed to parse reply");
448 ml->main_loop_quit (ml, g);
451 char **guestfs_ls (guestfs_h *g,
452 const char *directory)
454 struct guestfs_ls_args args;
455 struct ls_state state;
456 guestfs_main_loop *ml = guestfs_get_main_loop (g);
459 if (check_state (g, "guestfs_ls") == -1) return NULL;
461 memset (&state, 0, sizeof state);
463 args.directory = (char *) directory;
464 serial = guestfs_send (g, GUESTFS_PROC_LS,
465 (xdrproc_t) xdr_guestfs_ls_args, (char *) &args);
470 guestfs_set_reply_callback (g, ls_cb, &state);
471 (void) ml->main_loop_run (ml, g);
472 guestfs_set_reply_callback (g, NULL, NULL);
473 if (!state.cb_state) {
474 error (g, "guestfs_ls failed, see earlier error messages");
478 if (check_reply_header (g, &state.hdr, GUESTFS_PROC_LS, serial) == -1)
481 if (state.hdr.status == GUESTFS_STATUS_ERROR) {
482 error (g, "%s", state.err.error_message);
486 /* caller will free this, but we need to add a NULL entry */
487 state.ret.listing.listing_val =
488 safe_realloc (g, state.ret.listing.listing_val,
489 sizeof (char *) * (state.ret.listing.listing_len + 1));
490 state.ret.listing.listing_val[state.ret.listing.listing_len] = NULL;
491 return state.ret.listing.listing_val;
494 struct list_devices_state {
496 struct guestfs_message_header hdr;
497 struct guestfs_message_error err;
498 struct guestfs_list_devices_ret ret;
501 static void list_devices_cb (guestfs_h *g, void *data, XDR *xdr)
503 guestfs_main_loop *ml = guestfs_get_main_loop (g);
504 struct list_devices_state *state = (struct list_devices_state *) data;
506 if (!xdr_guestfs_message_header (xdr, &state->hdr)) {
507 error (g, "guestfs_list_devices: failed to parse reply header");
510 if (state->hdr.status == GUESTFS_STATUS_ERROR) {
511 if (!xdr_guestfs_message_error (xdr, &state->err)) {
512 error (g, "guestfs_list_devices: failed to parse reply error");
517 if (!xdr_guestfs_list_devices_ret (xdr, &state->ret)) {
518 error (g, "guestfs_list_devices: failed to parse reply");
523 ml->main_loop_quit (ml, g);
526 char **guestfs_list_devices (guestfs_h *g)
528 struct list_devices_state state;
529 guestfs_main_loop *ml = guestfs_get_main_loop (g);
532 if (check_state (g, "guestfs_list_devices") == -1) return NULL;
534 memset (&state, 0, sizeof state);
536 serial = guestfs_send (g, GUESTFS_PROC_LIST_DEVICES, NULL, NULL);
541 guestfs_set_reply_callback (g, list_devices_cb, &state);
542 (void) ml->main_loop_run (ml, g);
543 guestfs_set_reply_callback (g, NULL, NULL);
544 if (!state.cb_state) {
545 error (g, "guestfs_list_devices failed, see earlier error messages");
549 if (check_reply_header (g, &state.hdr, GUESTFS_PROC_LIST_DEVICES, serial) == -1)
552 if (state.hdr.status == GUESTFS_STATUS_ERROR) {
553 error (g, "%s", state.err.error_message);
557 /* caller will free this, but we need to add a NULL entry */
558 state.ret.devices.devices_val =
559 safe_realloc (g, state.ret.devices.devices_val,
560 sizeof (char *) * (state.ret.devices.devices_len + 1));
561 state.ret.devices.devices_val[state.ret.devices.devices_len] = NULL;
562 return state.ret.devices.devices_val;
565 struct list_partitions_state {
567 struct guestfs_message_header hdr;
568 struct guestfs_message_error err;
569 struct guestfs_list_partitions_ret ret;
572 static void list_partitions_cb (guestfs_h *g, void *data, XDR *xdr)
574 guestfs_main_loop *ml = guestfs_get_main_loop (g);
575 struct list_partitions_state *state = (struct list_partitions_state *) data;
577 if (!xdr_guestfs_message_header (xdr, &state->hdr)) {
578 error (g, "guestfs_list_partitions: failed to parse reply header");
581 if (state->hdr.status == GUESTFS_STATUS_ERROR) {
582 if (!xdr_guestfs_message_error (xdr, &state->err)) {
583 error (g, "guestfs_list_partitions: failed to parse reply error");
588 if (!xdr_guestfs_list_partitions_ret (xdr, &state->ret)) {
589 error (g, "guestfs_list_partitions: failed to parse reply");
594 ml->main_loop_quit (ml, g);
597 char **guestfs_list_partitions (guestfs_h *g)
599 struct list_partitions_state state;
600 guestfs_main_loop *ml = guestfs_get_main_loop (g);
603 if (check_state (g, "guestfs_list_partitions") == -1) return NULL;
605 memset (&state, 0, sizeof state);
607 serial = guestfs_send (g, GUESTFS_PROC_LIST_PARTITIONS, NULL, NULL);
612 guestfs_set_reply_callback (g, list_partitions_cb, &state);
613 (void) ml->main_loop_run (ml, g);
614 guestfs_set_reply_callback (g, NULL, NULL);
615 if (!state.cb_state) {
616 error (g, "guestfs_list_partitions failed, see earlier error messages");
620 if (check_reply_header (g, &state.hdr, GUESTFS_PROC_LIST_PARTITIONS, serial) == -1)
623 if (state.hdr.status == GUESTFS_STATUS_ERROR) {
624 error (g, "%s", state.err.error_message);
628 /* caller will free this, but we need to add a NULL entry */
629 state.ret.partitions.partitions_val =
630 safe_realloc (g, state.ret.partitions.partitions_val,
631 sizeof (char *) * (state.ret.partitions.partitions_len + 1));
632 state.ret.partitions.partitions_val[state.ret.partitions.partitions_len] = NULL;
633 return state.ret.partitions.partitions_val;
638 struct guestfs_message_header hdr;
639 struct guestfs_message_error err;
640 struct guestfs_pvs_ret ret;
643 static void pvs_cb (guestfs_h *g, void *data, XDR *xdr)
645 guestfs_main_loop *ml = guestfs_get_main_loop (g);
646 struct pvs_state *state = (struct pvs_state *) data;
648 if (!xdr_guestfs_message_header (xdr, &state->hdr)) {
649 error (g, "guestfs_pvs: failed to parse reply header");
652 if (state->hdr.status == GUESTFS_STATUS_ERROR) {
653 if (!xdr_guestfs_message_error (xdr, &state->err)) {
654 error (g, "guestfs_pvs: failed to parse reply error");
659 if (!xdr_guestfs_pvs_ret (xdr, &state->ret)) {
660 error (g, "guestfs_pvs: failed to parse reply");
665 ml->main_loop_quit (ml, g);
668 char **guestfs_pvs (guestfs_h *g)
670 struct pvs_state state;
671 guestfs_main_loop *ml = guestfs_get_main_loop (g);
674 if (check_state (g, "guestfs_pvs") == -1) return NULL;
676 memset (&state, 0, sizeof state);
678 serial = guestfs_send (g, GUESTFS_PROC_PVS, NULL, NULL);
683 guestfs_set_reply_callback (g, pvs_cb, &state);
684 (void) ml->main_loop_run (ml, g);
685 guestfs_set_reply_callback (g, NULL, NULL);
686 if (!state.cb_state) {
687 error (g, "guestfs_pvs failed, see earlier error messages");
691 if (check_reply_header (g, &state.hdr, GUESTFS_PROC_PVS, serial) == -1)
694 if (state.hdr.status == GUESTFS_STATUS_ERROR) {
695 error (g, "%s", state.err.error_message);
699 /* caller will free this, but we need to add a NULL entry */
700 state.ret.physvols.physvols_val =
701 safe_realloc (g, state.ret.physvols.physvols_val,
702 sizeof (char *) * (state.ret.physvols.physvols_len + 1));
703 state.ret.physvols.physvols_val[state.ret.physvols.physvols_len] = NULL;
704 return state.ret.physvols.physvols_val;
709 struct guestfs_message_header hdr;
710 struct guestfs_message_error err;
711 struct guestfs_vgs_ret ret;
714 static void vgs_cb (guestfs_h *g, void *data, XDR *xdr)
716 guestfs_main_loop *ml = guestfs_get_main_loop (g);
717 struct vgs_state *state = (struct vgs_state *) data;
719 if (!xdr_guestfs_message_header (xdr, &state->hdr)) {
720 error (g, "guestfs_vgs: failed to parse reply header");
723 if (state->hdr.status == GUESTFS_STATUS_ERROR) {
724 if (!xdr_guestfs_message_error (xdr, &state->err)) {
725 error (g, "guestfs_vgs: failed to parse reply error");
730 if (!xdr_guestfs_vgs_ret (xdr, &state->ret)) {
731 error (g, "guestfs_vgs: failed to parse reply");
736 ml->main_loop_quit (ml, g);
739 char **guestfs_vgs (guestfs_h *g)
741 struct vgs_state state;
742 guestfs_main_loop *ml = guestfs_get_main_loop (g);
745 if (check_state (g, "guestfs_vgs") == -1) return NULL;
747 memset (&state, 0, sizeof state);
749 serial = guestfs_send (g, GUESTFS_PROC_VGS, NULL, NULL);
754 guestfs_set_reply_callback (g, vgs_cb, &state);
755 (void) ml->main_loop_run (ml, g);
756 guestfs_set_reply_callback (g, NULL, NULL);
757 if (!state.cb_state) {
758 error (g, "guestfs_vgs failed, see earlier error messages");
762 if (check_reply_header (g, &state.hdr, GUESTFS_PROC_VGS, serial) == -1)
765 if (state.hdr.status == GUESTFS_STATUS_ERROR) {
766 error (g, "%s", state.err.error_message);
770 /* caller will free this, but we need to add a NULL entry */
771 state.ret.volgroups.volgroups_val =
772 safe_realloc (g, state.ret.volgroups.volgroups_val,
773 sizeof (char *) * (state.ret.volgroups.volgroups_len + 1));
774 state.ret.volgroups.volgroups_val[state.ret.volgroups.volgroups_len] = NULL;
775 return state.ret.volgroups.volgroups_val;
780 struct guestfs_message_header hdr;
781 struct guestfs_message_error err;
782 struct guestfs_lvs_ret ret;
785 static void lvs_cb (guestfs_h *g, void *data, XDR *xdr)
787 guestfs_main_loop *ml = guestfs_get_main_loop (g);
788 struct lvs_state *state = (struct lvs_state *) data;
790 if (!xdr_guestfs_message_header (xdr, &state->hdr)) {
791 error (g, "guestfs_lvs: failed to parse reply header");
794 if (state->hdr.status == GUESTFS_STATUS_ERROR) {
795 if (!xdr_guestfs_message_error (xdr, &state->err)) {
796 error (g, "guestfs_lvs: failed to parse reply error");
801 if (!xdr_guestfs_lvs_ret (xdr, &state->ret)) {
802 error (g, "guestfs_lvs: failed to parse reply");
807 ml->main_loop_quit (ml, g);
810 char **guestfs_lvs (guestfs_h *g)
812 struct lvs_state state;
813 guestfs_main_loop *ml = guestfs_get_main_loop (g);
816 if (check_state (g, "guestfs_lvs") == -1) return NULL;
818 memset (&state, 0, sizeof state);
820 serial = guestfs_send (g, GUESTFS_PROC_LVS, NULL, NULL);
825 guestfs_set_reply_callback (g, lvs_cb, &state);
826 (void) ml->main_loop_run (ml, g);
827 guestfs_set_reply_callback (g, NULL, NULL);
828 if (!state.cb_state) {
829 error (g, "guestfs_lvs failed, see earlier error messages");
833 if (check_reply_header (g, &state.hdr, GUESTFS_PROC_LVS, serial) == -1)
836 if (state.hdr.status == GUESTFS_STATUS_ERROR) {
837 error (g, "%s", state.err.error_message);
841 /* caller will free this, but we need to add a NULL entry */
842 state.ret.logvols.logvols_val =
843 safe_realloc (g, state.ret.logvols.logvols_val,
844 sizeof (char *) * (state.ret.logvols.logvols_len + 1));
845 state.ret.logvols.logvols_val[state.ret.logvols.logvols_len] = NULL;
846 return state.ret.logvols.logvols_val;
849 struct pvs_full_state {
851 struct guestfs_message_header hdr;
852 struct guestfs_message_error err;
853 struct guestfs_pvs_full_ret ret;
856 static void pvs_full_cb (guestfs_h *g, void *data, XDR *xdr)
858 guestfs_main_loop *ml = guestfs_get_main_loop (g);
859 struct pvs_full_state *state = (struct pvs_full_state *) data;
861 if (!xdr_guestfs_message_header (xdr, &state->hdr)) {
862 error (g, "guestfs_pvs_full: failed to parse reply header");
865 if (state->hdr.status == GUESTFS_STATUS_ERROR) {
866 if (!xdr_guestfs_message_error (xdr, &state->err)) {
867 error (g, "guestfs_pvs_full: failed to parse reply error");
872 if (!xdr_guestfs_pvs_full_ret (xdr, &state->ret)) {
873 error (g, "guestfs_pvs_full: failed to parse reply");
878 ml->main_loop_quit (ml, g);
881 struct guestfs_lvm_pv_list *guestfs_pvs_full (guestfs_h *g)
883 struct pvs_full_state state;
884 guestfs_main_loop *ml = guestfs_get_main_loop (g);
887 if (check_state (g, "guestfs_pvs_full") == -1) return NULL;
889 memset (&state, 0, sizeof state);
891 serial = guestfs_send (g, GUESTFS_PROC_PVS_FULL, NULL, NULL);
896 guestfs_set_reply_callback (g, pvs_full_cb, &state);
897 (void) ml->main_loop_run (ml, g);
898 guestfs_set_reply_callback (g, NULL, NULL);
899 if (!state.cb_state) {
900 error (g, "guestfs_pvs_full failed, see earlier error messages");
904 if (check_reply_header (g, &state.hdr, GUESTFS_PROC_PVS_FULL, serial) == -1)
907 if (state.hdr.status == GUESTFS_STATUS_ERROR) {
908 error (g, "%s", state.err.error_message);
912 /* caller will free this */
913 return safe_memdup (g, &state.ret.physvols, sizeof (state.ret.physvols));
916 struct vgs_full_state {
918 struct guestfs_message_header hdr;
919 struct guestfs_message_error err;
920 struct guestfs_vgs_full_ret ret;
923 static void vgs_full_cb (guestfs_h *g, void *data, XDR *xdr)
925 guestfs_main_loop *ml = guestfs_get_main_loop (g);
926 struct vgs_full_state *state = (struct vgs_full_state *) data;
928 if (!xdr_guestfs_message_header (xdr, &state->hdr)) {
929 error (g, "guestfs_vgs_full: failed to parse reply header");
932 if (state->hdr.status == GUESTFS_STATUS_ERROR) {
933 if (!xdr_guestfs_message_error (xdr, &state->err)) {
934 error (g, "guestfs_vgs_full: failed to parse reply error");
939 if (!xdr_guestfs_vgs_full_ret (xdr, &state->ret)) {
940 error (g, "guestfs_vgs_full: failed to parse reply");
945 ml->main_loop_quit (ml, g);
948 struct guestfs_lvm_vg_list *guestfs_vgs_full (guestfs_h *g)
950 struct vgs_full_state state;
951 guestfs_main_loop *ml = guestfs_get_main_loop (g);
954 if (check_state (g, "guestfs_vgs_full") == -1) return NULL;
956 memset (&state, 0, sizeof state);
958 serial = guestfs_send (g, GUESTFS_PROC_VGS_FULL, NULL, NULL);
963 guestfs_set_reply_callback (g, vgs_full_cb, &state);
964 (void) ml->main_loop_run (ml, g);
965 guestfs_set_reply_callback (g, NULL, NULL);
966 if (!state.cb_state) {
967 error (g, "guestfs_vgs_full failed, see earlier error messages");
971 if (check_reply_header (g, &state.hdr, GUESTFS_PROC_VGS_FULL, serial) == -1)
974 if (state.hdr.status == GUESTFS_STATUS_ERROR) {
975 error (g, "%s", state.err.error_message);
979 /* caller will free this */
980 return safe_memdup (g, &state.ret.volgroups, sizeof (state.ret.volgroups));
983 struct lvs_full_state {
985 struct guestfs_message_header hdr;
986 struct guestfs_message_error err;
987 struct guestfs_lvs_full_ret ret;
990 static void lvs_full_cb (guestfs_h *g, void *data, XDR *xdr)
992 guestfs_main_loop *ml = guestfs_get_main_loop (g);
993 struct lvs_full_state *state = (struct lvs_full_state *) data;
995 if (!xdr_guestfs_message_header (xdr, &state->hdr)) {
996 error (g, "guestfs_lvs_full: failed to parse reply header");
999 if (state->hdr.status == GUESTFS_STATUS_ERROR) {
1000 if (!xdr_guestfs_message_error (xdr, &state->err)) {
1001 error (g, "guestfs_lvs_full: failed to parse reply error");
1006 if (!xdr_guestfs_lvs_full_ret (xdr, &state->ret)) {
1007 error (g, "guestfs_lvs_full: failed to parse reply");
1011 state->cb_state = 1;
1012 ml->main_loop_quit (ml, g);
1015 struct guestfs_lvm_lv_list *guestfs_lvs_full (guestfs_h *g)
1017 struct lvs_full_state state;
1018 guestfs_main_loop *ml = guestfs_get_main_loop (g);
1021 if (check_state (g, "guestfs_lvs_full") == -1) return NULL;
1023 memset (&state, 0, sizeof state);
1025 serial = guestfs_send (g, GUESTFS_PROC_LVS_FULL, NULL, NULL);
1030 guestfs_set_reply_callback (g, lvs_full_cb, &state);
1031 (void) ml->main_loop_run (ml, g);
1032 guestfs_set_reply_callback (g, NULL, NULL);
1033 if (!state.cb_state) {
1034 error (g, "guestfs_lvs_full failed, see earlier error messages");
1038 if (check_reply_header (g, &state.hdr, GUESTFS_PROC_LVS_FULL, serial) == -1)
1041 if (state.hdr.status == GUESTFS_STATUS_ERROR) {
1042 error (g, "%s", state.err.error_message);
1046 /* caller will free this */
1047 return safe_memdup (g, &state.ret.logvols, sizeof (state.ret.logvols));
1050 struct read_lines_state {
1052 struct guestfs_message_header hdr;
1053 struct guestfs_message_error err;
1054 struct guestfs_read_lines_ret ret;
1057 static void read_lines_cb (guestfs_h *g, void *data, XDR *xdr)
1059 guestfs_main_loop *ml = guestfs_get_main_loop (g);
1060 struct read_lines_state *state = (struct read_lines_state *) data;
1062 if (!xdr_guestfs_message_header (xdr, &state->hdr)) {
1063 error (g, "guestfs_read_lines: failed to parse reply header");
1066 if (state->hdr.status == GUESTFS_STATUS_ERROR) {
1067 if (!xdr_guestfs_message_error (xdr, &state->err)) {
1068 error (g, "guestfs_read_lines: failed to parse reply error");
1073 if (!xdr_guestfs_read_lines_ret (xdr, &state->ret)) {
1074 error (g, "guestfs_read_lines: failed to parse reply");
1078 state->cb_state = 1;
1079 ml->main_loop_quit (ml, g);
1082 char **guestfs_read_lines (guestfs_h *g,
1085 struct guestfs_read_lines_args args;
1086 struct read_lines_state state;
1087 guestfs_main_loop *ml = guestfs_get_main_loop (g);
1090 if (check_state (g, "guestfs_read_lines") == -1) return NULL;
1092 memset (&state, 0, sizeof state);
1094 args.path = (char *) path;
1095 serial = guestfs_send (g, GUESTFS_PROC_READ_LINES,
1096 (xdrproc_t) xdr_guestfs_read_lines_args, (char *) &args);
1101 guestfs_set_reply_callback (g, read_lines_cb, &state);
1102 (void) ml->main_loop_run (ml, g);
1103 guestfs_set_reply_callback (g, NULL, NULL);
1104 if (!state.cb_state) {
1105 error (g, "guestfs_read_lines failed, see earlier error messages");
1109 if (check_reply_header (g, &state.hdr, GUESTFS_PROC_READ_LINES, serial) == -1)
1112 if (state.hdr.status == GUESTFS_STATUS_ERROR) {
1113 error (g, "%s", state.err.error_message);
1117 /* caller will free this, but we need to add a NULL entry */
1118 state.ret.lines.lines_val =
1119 safe_realloc (g, state.ret.lines.lines_val,
1120 sizeof (char *) * (state.ret.lines.lines_len + 1));
1121 state.ret.lines.lines_val[state.ret.lines.lines_len] = NULL;
1122 return state.ret.lines.lines_val;
1125 struct aug_init_state {
1127 struct guestfs_message_header hdr;
1128 struct guestfs_message_error err;
1131 static void aug_init_cb (guestfs_h *g, void *data, XDR *xdr)
1133 guestfs_main_loop *ml = guestfs_get_main_loop (g);
1134 struct aug_init_state *state = (struct aug_init_state *) data;
1136 if (!xdr_guestfs_message_header (xdr, &state->hdr)) {
1137 error (g, "guestfs_aug_init: failed to parse reply header");
1140 if (state->hdr.status == GUESTFS_STATUS_ERROR) {
1141 if (!xdr_guestfs_message_error (xdr, &state->err)) {
1142 error (g, "guestfs_aug_init: failed to parse reply error");
1148 state->cb_state = 1;
1149 ml->main_loop_quit (ml, g);
1152 int guestfs_aug_init (guestfs_h *g,
1156 struct guestfs_aug_init_args args;
1157 struct aug_init_state state;
1158 guestfs_main_loop *ml = guestfs_get_main_loop (g);
1161 if (check_state (g, "guestfs_aug_init") == -1) return -1;
1163 memset (&state, 0, sizeof state);
1165 args.root = (char *) root;
1167 serial = guestfs_send (g, GUESTFS_PROC_AUG_INIT,
1168 (xdrproc_t) xdr_guestfs_aug_init_args, (char *) &args);
1173 guestfs_set_reply_callback (g, aug_init_cb, &state);
1174 (void) ml->main_loop_run (ml, g);
1175 guestfs_set_reply_callback (g, NULL, NULL);
1176 if (!state.cb_state) {
1177 error (g, "guestfs_aug_init failed, see earlier error messages");
1181 if (check_reply_header (g, &state.hdr, GUESTFS_PROC_AUG_INIT, serial) == -1)
1184 if (state.hdr.status == GUESTFS_STATUS_ERROR) {
1185 error (g, "%s", state.err.error_message);
1192 struct aug_close_state {
1194 struct guestfs_message_header hdr;
1195 struct guestfs_message_error err;
1198 static void aug_close_cb (guestfs_h *g, void *data, XDR *xdr)
1200 guestfs_main_loop *ml = guestfs_get_main_loop (g);
1201 struct aug_close_state *state = (struct aug_close_state *) data;
1203 if (!xdr_guestfs_message_header (xdr, &state->hdr)) {
1204 error (g, "guestfs_aug_close: failed to parse reply header");
1207 if (state->hdr.status == GUESTFS_STATUS_ERROR) {
1208 if (!xdr_guestfs_message_error (xdr, &state->err)) {
1209 error (g, "guestfs_aug_close: failed to parse reply error");
1215 state->cb_state = 1;
1216 ml->main_loop_quit (ml, g);
1219 int guestfs_aug_close (guestfs_h *g)
1221 struct aug_close_state state;
1222 guestfs_main_loop *ml = guestfs_get_main_loop (g);
1225 if (check_state (g, "guestfs_aug_close") == -1) return -1;
1227 memset (&state, 0, sizeof state);
1229 serial = guestfs_send (g, GUESTFS_PROC_AUG_CLOSE, NULL, NULL);
1234 guestfs_set_reply_callback (g, aug_close_cb, &state);
1235 (void) ml->main_loop_run (ml, g);
1236 guestfs_set_reply_callback (g, NULL, NULL);
1237 if (!state.cb_state) {
1238 error (g, "guestfs_aug_close failed, see earlier error messages");
1242 if (check_reply_header (g, &state.hdr, GUESTFS_PROC_AUG_CLOSE, serial) == -1)
1245 if (state.hdr.status == GUESTFS_STATUS_ERROR) {
1246 error (g, "%s", state.err.error_message);
1253 struct aug_defvar_state {
1255 struct guestfs_message_header hdr;
1256 struct guestfs_message_error err;
1257 struct guestfs_aug_defvar_ret ret;
1260 static void aug_defvar_cb (guestfs_h *g, void *data, XDR *xdr)
1262 guestfs_main_loop *ml = guestfs_get_main_loop (g);
1263 struct aug_defvar_state *state = (struct aug_defvar_state *) data;
1265 if (!xdr_guestfs_message_header (xdr, &state->hdr)) {
1266 error (g, "guestfs_aug_defvar: failed to parse reply header");
1269 if (state->hdr.status == GUESTFS_STATUS_ERROR) {
1270 if (!xdr_guestfs_message_error (xdr, &state->err)) {
1271 error (g, "guestfs_aug_defvar: failed to parse reply error");
1276 if (!xdr_guestfs_aug_defvar_ret (xdr, &state->ret)) {
1277 error (g, "guestfs_aug_defvar: failed to parse reply");
1281 state->cb_state = 1;
1282 ml->main_loop_quit (ml, g);
1285 int guestfs_aug_defvar (guestfs_h *g,
1289 struct guestfs_aug_defvar_args args;
1290 struct aug_defvar_state state;
1291 guestfs_main_loop *ml = guestfs_get_main_loop (g);
1294 if (check_state (g, "guestfs_aug_defvar") == -1) return -1;
1296 memset (&state, 0, sizeof state);
1298 args.name = (char *) name;
1299 args.expr = expr ? (char **) &expr : NULL;
1300 serial = guestfs_send (g, GUESTFS_PROC_AUG_DEFVAR,
1301 (xdrproc_t) xdr_guestfs_aug_defvar_args, (char *) &args);
1306 guestfs_set_reply_callback (g, aug_defvar_cb, &state);
1307 (void) ml->main_loop_run (ml, g);
1308 guestfs_set_reply_callback (g, NULL, NULL);
1309 if (!state.cb_state) {
1310 error (g, "guestfs_aug_defvar failed, see earlier error messages");
1314 if (check_reply_header (g, &state.hdr, GUESTFS_PROC_AUG_DEFVAR, serial) == -1)
1317 if (state.hdr.status == GUESTFS_STATUS_ERROR) {
1318 error (g, "%s", state.err.error_message);
1322 return state.ret.nrnodes;
1325 struct aug_defnode_state {
1327 struct guestfs_message_header hdr;
1328 struct guestfs_message_error err;
1329 struct guestfs_aug_defnode_ret ret;
1332 static void aug_defnode_cb (guestfs_h *g, void *data, XDR *xdr)
1334 guestfs_main_loop *ml = guestfs_get_main_loop (g);
1335 struct aug_defnode_state *state = (struct aug_defnode_state *) data;
1337 if (!xdr_guestfs_message_header (xdr, &state->hdr)) {
1338 error (g, "guestfs_aug_defnode: failed to parse reply header");
1341 if (state->hdr.status == GUESTFS_STATUS_ERROR) {
1342 if (!xdr_guestfs_message_error (xdr, &state->err)) {
1343 error (g, "guestfs_aug_defnode: failed to parse reply error");
1348 if (!xdr_guestfs_aug_defnode_ret (xdr, &state->ret)) {
1349 error (g, "guestfs_aug_defnode: failed to parse reply");
1353 state->cb_state = 1;
1354 ml->main_loop_quit (ml, g);
1357 struct guestfs_int_bool *guestfs_aug_defnode (guestfs_h *g,
1362 struct guestfs_aug_defnode_args args;
1363 struct aug_defnode_state state;
1364 guestfs_main_loop *ml = guestfs_get_main_loop (g);
1367 if (check_state (g, "guestfs_aug_defnode") == -1) return NULL;
1369 memset (&state, 0, sizeof state);
1371 args.name = (char *) name;
1372 args.expr = (char *) expr;
1373 args.val = (char *) val;
1374 serial = guestfs_send (g, GUESTFS_PROC_AUG_DEFNODE,
1375 (xdrproc_t) xdr_guestfs_aug_defnode_args, (char *) &args);
1380 guestfs_set_reply_callback (g, aug_defnode_cb, &state);
1381 (void) ml->main_loop_run (ml, g);
1382 guestfs_set_reply_callback (g, NULL, NULL);
1383 if (!state.cb_state) {
1384 error (g, "guestfs_aug_defnode failed, see earlier error messages");
1388 if (check_reply_header (g, &state.hdr, GUESTFS_PROC_AUG_DEFNODE, serial) == -1)
1391 if (state.hdr.status == GUESTFS_STATUS_ERROR) {
1392 error (g, "%s", state.err.error_message);
1396 /* caller with free this */
1397 return safe_memdup (g, &state.ret, sizeof (state.ret));
1400 struct aug_get_state {
1402 struct guestfs_message_header hdr;
1403 struct guestfs_message_error err;
1404 struct guestfs_aug_get_ret ret;
1407 static void aug_get_cb (guestfs_h *g, void *data, XDR *xdr)
1409 guestfs_main_loop *ml = guestfs_get_main_loop (g);
1410 struct aug_get_state *state = (struct aug_get_state *) data;
1412 if (!xdr_guestfs_message_header (xdr, &state->hdr)) {
1413 error (g, "guestfs_aug_get: failed to parse reply header");
1416 if (state->hdr.status == GUESTFS_STATUS_ERROR) {
1417 if (!xdr_guestfs_message_error (xdr, &state->err)) {
1418 error (g, "guestfs_aug_get: failed to parse reply error");
1423 if (!xdr_guestfs_aug_get_ret (xdr, &state->ret)) {
1424 error (g, "guestfs_aug_get: failed to parse reply");
1428 state->cb_state = 1;
1429 ml->main_loop_quit (ml, g);
1432 char *guestfs_aug_get (guestfs_h *g,
1435 struct guestfs_aug_get_args args;
1436 struct aug_get_state state;
1437 guestfs_main_loop *ml = guestfs_get_main_loop (g);
1440 if (check_state (g, "guestfs_aug_get") == -1) return NULL;
1442 memset (&state, 0, sizeof state);
1444 args.path = (char *) path;
1445 serial = guestfs_send (g, GUESTFS_PROC_AUG_GET,
1446 (xdrproc_t) xdr_guestfs_aug_get_args, (char *) &args);
1451 guestfs_set_reply_callback (g, aug_get_cb, &state);
1452 (void) ml->main_loop_run (ml, g);
1453 guestfs_set_reply_callback (g, NULL, NULL);
1454 if (!state.cb_state) {
1455 error (g, "guestfs_aug_get failed, see earlier error messages");
1459 if (check_reply_header (g, &state.hdr, GUESTFS_PROC_AUG_GET, serial) == -1)
1462 if (state.hdr.status == GUESTFS_STATUS_ERROR) {
1463 error (g, "%s", state.err.error_message);
1467 return state.ret.val; /* caller will free */
1470 struct aug_set_state {
1472 struct guestfs_message_header hdr;
1473 struct guestfs_message_error err;
1476 static void aug_set_cb (guestfs_h *g, void *data, XDR *xdr)
1478 guestfs_main_loop *ml = guestfs_get_main_loop (g);
1479 struct aug_set_state *state = (struct aug_set_state *) data;
1481 if (!xdr_guestfs_message_header (xdr, &state->hdr)) {
1482 error (g, "guestfs_aug_set: failed to parse reply header");
1485 if (state->hdr.status == GUESTFS_STATUS_ERROR) {
1486 if (!xdr_guestfs_message_error (xdr, &state->err)) {
1487 error (g, "guestfs_aug_set: failed to parse reply error");
1493 state->cb_state = 1;
1494 ml->main_loop_quit (ml, g);
1497 int guestfs_aug_set (guestfs_h *g,
1501 struct guestfs_aug_set_args args;
1502 struct aug_set_state state;
1503 guestfs_main_loop *ml = guestfs_get_main_loop (g);
1506 if (check_state (g, "guestfs_aug_set") == -1) return -1;
1508 memset (&state, 0, sizeof state);
1510 args.path = (char *) path;
1511 args.val = (char *) val;
1512 serial = guestfs_send (g, GUESTFS_PROC_AUG_SET,
1513 (xdrproc_t) xdr_guestfs_aug_set_args, (char *) &args);
1518 guestfs_set_reply_callback (g, aug_set_cb, &state);
1519 (void) ml->main_loop_run (ml, g);
1520 guestfs_set_reply_callback (g, NULL, NULL);
1521 if (!state.cb_state) {
1522 error (g, "guestfs_aug_set failed, see earlier error messages");
1526 if (check_reply_header (g, &state.hdr, GUESTFS_PROC_AUG_SET, serial) == -1)
1529 if (state.hdr.status == GUESTFS_STATUS_ERROR) {
1530 error (g, "%s", state.err.error_message);
1537 struct aug_insert_state {
1539 struct guestfs_message_header hdr;
1540 struct guestfs_message_error err;
1543 static void aug_insert_cb (guestfs_h *g, void *data, XDR *xdr)
1545 guestfs_main_loop *ml = guestfs_get_main_loop (g);
1546 struct aug_insert_state *state = (struct aug_insert_state *) data;
1548 if (!xdr_guestfs_message_header (xdr, &state->hdr)) {
1549 error (g, "guestfs_aug_insert: failed to parse reply header");
1552 if (state->hdr.status == GUESTFS_STATUS_ERROR) {
1553 if (!xdr_guestfs_message_error (xdr, &state->err)) {
1554 error (g, "guestfs_aug_insert: failed to parse reply error");
1560 state->cb_state = 1;
1561 ml->main_loop_quit (ml, g);
1564 int guestfs_aug_insert (guestfs_h *g,
1569 struct guestfs_aug_insert_args args;
1570 struct aug_insert_state state;
1571 guestfs_main_loop *ml = guestfs_get_main_loop (g);
1574 if (check_state (g, "guestfs_aug_insert") == -1) return -1;
1576 memset (&state, 0, sizeof state);
1578 args.path = (char *) path;
1579 args.label = (char *) label;
1580 args.before = before;
1581 serial = guestfs_send (g, GUESTFS_PROC_AUG_INSERT,
1582 (xdrproc_t) xdr_guestfs_aug_insert_args, (char *) &args);
1587 guestfs_set_reply_callback (g, aug_insert_cb, &state);
1588 (void) ml->main_loop_run (ml, g);
1589 guestfs_set_reply_callback (g, NULL, NULL);
1590 if (!state.cb_state) {
1591 error (g, "guestfs_aug_insert failed, see earlier error messages");
1595 if (check_reply_header (g, &state.hdr, GUESTFS_PROC_AUG_INSERT, serial) == -1)
1598 if (state.hdr.status == GUESTFS_STATUS_ERROR) {
1599 error (g, "%s", state.err.error_message);
1606 struct aug_rm_state {
1608 struct guestfs_message_header hdr;
1609 struct guestfs_message_error err;
1610 struct guestfs_aug_rm_ret ret;
1613 static void aug_rm_cb (guestfs_h *g, void *data, XDR *xdr)
1615 guestfs_main_loop *ml = guestfs_get_main_loop (g);
1616 struct aug_rm_state *state = (struct aug_rm_state *) data;
1618 if (!xdr_guestfs_message_header (xdr, &state->hdr)) {
1619 error (g, "guestfs_aug_rm: failed to parse reply header");
1622 if (state->hdr.status == GUESTFS_STATUS_ERROR) {
1623 if (!xdr_guestfs_message_error (xdr, &state->err)) {
1624 error (g, "guestfs_aug_rm: failed to parse reply error");
1629 if (!xdr_guestfs_aug_rm_ret (xdr, &state->ret)) {
1630 error (g, "guestfs_aug_rm: failed to parse reply");
1634 state->cb_state = 1;
1635 ml->main_loop_quit (ml, g);
1638 int guestfs_aug_rm (guestfs_h *g,
1641 struct guestfs_aug_rm_args args;
1642 struct aug_rm_state state;
1643 guestfs_main_loop *ml = guestfs_get_main_loop (g);
1646 if (check_state (g, "guestfs_aug_rm") == -1) return -1;
1648 memset (&state, 0, sizeof state);
1650 args.path = (char *) path;
1651 serial = guestfs_send (g, GUESTFS_PROC_AUG_RM,
1652 (xdrproc_t) xdr_guestfs_aug_rm_args, (char *) &args);
1657 guestfs_set_reply_callback (g, aug_rm_cb, &state);
1658 (void) ml->main_loop_run (ml, g);
1659 guestfs_set_reply_callback (g, NULL, NULL);
1660 if (!state.cb_state) {
1661 error (g, "guestfs_aug_rm failed, see earlier error messages");
1665 if (check_reply_header (g, &state.hdr, GUESTFS_PROC_AUG_RM, serial) == -1)
1668 if (state.hdr.status == GUESTFS_STATUS_ERROR) {
1669 error (g, "%s", state.err.error_message);
1673 return state.ret.nrnodes;
1676 struct aug_mv_state {
1678 struct guestfs_message_header hdr;
1679 struct guestfs_message_error err;
1682 static void aug_mv_cb (guestfs_h *g, void *data, XDR *xdr)
1684 guestfs_main_loop *ml = guestfs_get_main_loop (g);
1685 struct aug_mv_state *state = (struct aug_mv_state *) data;
1687 if (!xdr_guestfs_message_header (xdr, &state->hdr)) {
1688 error (g, "guestfs_aug_mv: failed to parse reply header");
1691 if (state->hdr.status == GUESTFS_STATUS_ERROR) {
1692 if (!xdr_guestfs_message_error (xdr, &state->err)) {
1693 error (g, "guestfs_aug_mv: failed to parse reply error");
1699 state->cb_state = 1;
1700 ml->main_loop_quit (ml, g);
1703 int guestfs_aug_mv (guestfs_h *g,
1707 struct guestfs_aug_mv_args args;
1708 struct aug_mv_state state;
1709 guestfs_main_loop *ml = guestfs_get_main_loop (g);
1712 if (check_state (g, "guestfs_aug_mv") == -1) return -1;
1714 memset (&state, 0, sizeof state);
1716 args.src = (char *) src;
1717 args.dest = (char *) dest;
1718 serial = guestfs_send (g, GUESTFS_PROC_AUG_MV,
1719 (xdrproc_t) xdr_guestfs_aug_mv_args, (char *) &args);
1724 guestfs_set_reply_callback (g, aug_mv_cb, &state);
1725 (void) ml->main_loop_run (ml, g);
1726 guestfs_set_reply_callback (g, NULL, NULL);
1727 if (!state.cb_state) {
1728 error (g, "guestfs_aug_mv failed, see earlier error messages");
1732 if (check_reply_header (g, &state.hdr, GUESTFS_PROC_AUG_MV, serial) == -1)
1735 if (state.hdr.status == GUESTFS_STATUS_ERROR) {
1736 error (g, "%s", state.err.error_message);
1743 struct aug_match_state {
1745 struct guestfs_message_header hdr;
1746 struct guestfs_message_error err;
1747 struct guestfs_aug_match_ret ret;
1750 static void aug_match_cb (guestfs_h *g, void *data, XDR *xdr)
1752 guestfs_main_loop *ml = guestfs_get_main_loop (g);
1753 struct aug_match_state *state = (struct aug_match_state *) data;
1755 if (!xdr_guestfs_message_header (xdr, &state->hdr)) {
1756 error (g, "guestfs_aug_match: failed to parse reply header");
1759 if (state->hdr.status == GUESTFS_STATUS_ERROR) {
1760 if (!xdr_guestfs_message_error (xdr, &state->err)) {
1761 error (g, "guestfs_aug_match: failed to parse reply error");
1766 if (!xdr_guestfs_aug_match_ret (xdr, &state->ret)) {
1767 error (g, "guestfs_aug_match: failed to parse reply");
1771 state->cb_state = 1;
1772 ml->main_loop_quit (ml, g);
1775 char **guestfs_aug_match (guestfs_h *g,
1778 struct guestfs_aug_match_args args;
1779 struct aug_match_state state;
1780 guestfs_main_loop *ml = guestfs_get_main_loop (g);
1783 if (check_state (g, "guestfs_aug_match") == -1) return NULL;
1785 memset (&state, 0, sizeof state);
1787 args.path = (char *) path;
1788 serial = guestfs_send (g, GUESTFS_PROC_AUG_MATCH,
1789 (xdrproc_t) xdr_guestfs_aug_match_args, (char *) &args);
1794 guestfs_set_reply_callback (g, aug_match_cb, &state);
1795 (void) ml->main_loop_run (ml, g);
1796 guestfs_set_reply_callback (g, NULL, NULL);
1797 if (!state.cb_state) {
1798 error (g, "guestfs_aug_match failed, see earlier error messages");
1802 if (check_reply_header (g, &state.hdr, GUESTFS_PROC_AUG_MATCH, serial) == -1)
1805 if (state.hdr.status == GUESTFS_STATUS_ERROR) {
1806 error (g, "%s", state.err.error_message);
1810 /* caller will free this, but we need to add a NULL entry */
1811 state.ret.matches.matches_val =
1812 safe_realloc (g, state.ret.matches.matches_val,
1813 sizeof (char *) * (state.ret.matches.matches_len + 1));
1814 state.ret.matches.matches_val[state.ret.matches.matches_len] = NULL;
1815 return state.ret.matches.matches_val;
1818 struct aug_save_state {
1820 struct guestfs_message_header hdr;
1821 struct guestfs_message_error err;
1824 static void aug_save_cb (guestfs_h *g, void *data, XDR *xdr)
1826 guestfs_main_loop *ml = guestfs_get_main_loop (g);
1827 struct aug_save_state *state = (struct aug_save_state *) data;
1829 if (!xdr_guestfs_message_header (xdr, &state->hdr)) {
1830 error (g, "guestfs_aug_save: failed to parse reply header");
1833 if (state->hdr.status == GUESTFS_STATUS_ERROR) {
1834 if (!xdr_guestfs_message_error (xdr, &state->err)) {
1835 error (g, "guestfs_aug_save: failed to parse reply error");
1841 state->cb_state = 1;
1842 ml->main_loop_quit (ml, g);
1845 int guestfs_aug_save (guestfs_h *g)
1847 struct aug_save_state state;
1848 guestfs_main_loop *ml = guestfs_get_main_loop (g);
1851 if (check_state (g, "guestfs_aug_save") == -1) return -1;
1853 memset (&state, 0, sizeof state);
1855 serial = guestfs_send (g, GUESTFS_PROC_AUG_SAVE, NULL, NULL);
1860 guestfs_set_reply_callback (g, aug_save_cb, &state);
1861 (void) ml->main_loop_run (ml, g);
1862 guestfs_set_reply_callback (g, NULL, NULL);
1863 if (!state.cb_state) {
1864 error (g, "guestfs_aug_save failed, see earlier error messages");
1868 if (check_reply_header (g, &state.hdr, GUESTFS_PROC_AUG_SAVE, serial) == -1)
1871 if (state.hdr.status == GUESTFS_STATUS_ERROR) {
1872 error (g, "%s", state.err.error_message);
1879 struct aug_load_state {
1881 struct guestfs_message_header hdr;
1882 struct guestfs_message_error err;
1885 static void aug_load_cb (guestfs_h *g, void *data, XDR *xdr)
1887 guestfs_main_loop *ml = guestfs_get_main_loop (g);
1888 struct aug_load_state *state = (struct aug_load_state *) data;
1890 if (!xdr_guestfs_message_header (xdr, &state->hdr)) {
1891 error (g, "guestfs_aug_load: failed to parse reply header");
1894 if (state->hdr.status == GUESTFS_STATUS_ERROR) {
1895 if (!xdr_guestfs_message_error (xdr, &state->err)) {
1896 error (g, "guestfs_aug_load: failed to parse reply error");
1902 state->cb_state = 1;
1903 ml->main_loop_quit (ml, g);
1906 int guestfs_aug_load (guestfs_h *g)
1908 struct aug_load_state state;
1909 guestfs_main_loop *ml = guestfs_get_main_loop (g);
1912 if (check_state (g, "guestfs_aug_load") == -1) return -1;
1914 memset (&state, 0, sizeof state);
1916 serial = guestfs_send (g, GUESTFS_PROC_AUG_LOAD, NULL, NULL);
1921 guestfs_set_reply_callback (g, aug_load_cb, &state);
1922 (void) ml->main_loop_run (ml, g);
1923 guestfs_set_reply_callback (g, NULL, NULL);
1924 if (!state.cb_state) {
1925 error (g, "guestfs_aug_load failed, see earlier error messages");
1929 if (check_reply_header (g, &state.hdr, GUESTFS_PROC_AUG_LOAD, serial) == -1)
1932 if (state.hdr.status == GUESTFS_STATUS_ERROR) {
1933 error (g, "%s", state.err.error_message);
1940 struct aug_ls_state {
1942 struct guestfs_message_header hdr;
1943 struct guestfs_message_error err;
1944 struct guestfs_aug_ls_ret ret;
1947 static void aug_ls_cb (guestfs_h *g, void *data, XDR *xdr)
1949 guestfs_main_loop *ml = guestfs_get_main_loop (g);
1950 struct aug_ls_state *state = (struct aug_ls_state *) data;
1952 if (!xdr_guestfs_message_header (xdr, &state->hdr)) {
1953 error (g, "guestfs_aug_ls: failed to parse reply header");
1956 if (state->hdr.status == GUESTFS_STATUS_ERROR) {
1957 if (!xdr_guestfs_message_error (xdr, &state->err)) {
1958 error (g, "guestfs_aug_ls: failed to parse reply error");
1963 if (!xdr_guestfs_aug_ls_ret (xdr, &state->ret)) {
1964 error (g, "guestfs_aug_ls: failed to parse reply");
1968 state->cb_state = 1;
1969 ml->main_loop_quit (ml, g);
1972 char **guestfs_aug_ls (guestfs_h *g,
1975 struct guestfs_aug_ls_args args;
1976 struct aug_ls_state state;
1977 guestfs_main_loop *ml = guestfs_get_main_loop (g);
1980 if (check_state (g, "guestfs_aug_ls") == -1) return NULL;
1982 memset (&state, 0, sizeof state);
1984 args.path = (char *) path;
1985 serial = guestfs_send (g, GUESTFS_PROC_AUG_LS,
1986 (xdrproc_t) xdr_guestfs_aug_ls_args, (char *) &args);
1991 guestfs_set_reply_callback (g, aug_ls_cb, &state);
1992 (void) ml->main_loop_run (ml, g);
1993 guestfs_set_reply_callback (g, NULL, NULL);
1994 if (!state.cb_state) {
1995 error (g, "guestfs_aug_ls failed, see earlier error messages");
1999 if (check_reply_header (g, &state.hdr, GUESTFS_PROC_AUG_LS, serial) == -1)
2002 if (state.hdr.status == GUESTFS_STATUS_ERROR) {
2003 error (g, "%s", state.err.error_message);
2007 /* caller will free this, but we need to add a NULL entry */
2008 state.ret.matches.matches_val =
2009 safe_realloc (g, state.ret.matches.matches_val,
2010 sizeof (char *) * (state.ret.matches.matches_len + 1));
2011 state.ret.matches.matches_val[state.ret.matches.matches_len] = NULL;
2012 return state.ret.matches.matches_val;
2017 struct guestfs_message_header hdr;
2018 struct guestfs_message_error err;
2021 static void rm_cb (guestfs_h *g, void *data, XDR *xdr)
2023 guestfs_main_loop *ml = guestfs_get_main_loop (g);
2024 struct rm_state *state = (struct rm_state *) data;
2026 if (!xdr_guestfs_message_header (xdr, &state->hdr)) {
2027 error (g, "guestfs_rm: failed to parse reply header");
2030 if (state->hdr.status == GUESTFS_STATUS_ERROR) {
2031 if (!xdr_guestfs_message_error (xdr, &state->err)) {
2032 error (g, "guestfs_rm: failed to parse reply error");
2038 state->cb_state = 1;
2039 ml->main_loop_quit (ml, g);
2042 int guestfs_rm (guestfs_h *g,
2045 struct guestfs_rm_args args;
2046 struct rm_state state;
2047 guestfs_main_loop *ml = guestfs_get_main_loop (g);
2050 if (check_state (g, "guestfs_rm") == -1) return -1;
2052 memset (&state, 0, sizeof state);
2054 args.path = (char *) path;
2055 serial = guestfs_send (g, GUESTFS_PROC_RM,
2056 (xdrproc_t) xdr_guestfs_rm_args, (char *) &args);
2061 guestfs_set_reply_callback (g, rm_cb, &state);
2062 (void) ml->main_loop_run (ml, g);
2063 guestfs_set_reply_callback (g, NULL, NULL);
2064 if (!state.cb_state) {
2065 error (g, "guestfs_rm failed, see earlier error messages");
2069 if (check_reply_header (g, &state.hdr, GUESTFS_PROC_RM, serial) == -1)
2072 if (state.hdr.status == GUESTFS_STATUS_ERROR) {
2073 error (g, "%s", state.err.error_message);
2080 struct rmdir_state {
2082 struct guestfs_message_header hdr;
2083 struct guestfs_message_error err;
2086 static void rmdir_cb (guestfs_h *g, void *data, XDR *xdr)
2088 guestfs_main_loop *ml = guestfs_get_main_loop (g);
2089 struct rmdir_state *state = (struct rmdir_state *) data;
2091 if (!xdr_guestfs_message_header (xdr, &state->hdr)) {
2092 error (g, "guestfs_rmdir: failed to parse reply header");
2095 if (state->hdr.status == GUESTFS_STATUS_ERROR) {
2096 if (!xdr_guestfs_message_error (xdr, &state->err)) {
2097 error (g, "guestfs_rmdir: failed to parse reply error");
2103 state->cb_state = 1;
2104 ml->main_loop_quit (ml, g);
2107 int guestfs_rmdir (guestfs_h *g,
2110 struct guestfs_rmdir_args args;
2111 struct rmdir_state state;
2112 guestfs_main_loop *ml = guestfs_get_main_loop (g);
2115 if (check_state (g, "guestfs_rmdir") == -1) return -1;
2117 memset (&state, 0, sizeof state);
2119 args.path = (char *) path;
2120 serial = guestfs_send (g, GUESTFS_PROC_RMDIR,
2121 (xdrproc_t) xdr_guestfs_rmdir_args, (char *) &args);
2126 guestfs_set_reply_callback (g, rmdir_cb, &state);
2127 (void) ml->main_loop_run (ml, g);
2128 guestfs_set_reply_callback (g, NULL, NULL);
2129 if (!state.cb_state) {
2130 error (g, "guestfs_rmdir failed, see earlier error messages");
2134 if (check_reply_header (g, &state.hdr, GUESTFS_PROC_RMDIR, serial) == -1)
2137 if (state.hdr.status == GUESTFS_STATUS_ERROR) {
2138 error (g, "%s", state.err.error_message);
2145 struct rm_rf_state {
2147 struct guestfs_message_header hdr;
2148 struct guestfs_message_error err;
2151 static void rm_rf_cb (guestfs_h *g, void *data, XDR *xdr)
2153 guestfs_main_loop *ml = guestfs_get_main_loop (g);
2154 struct rm_rf_state *state = (struct rm_rf_state *) data;
2156 if (!xdr_guestfs_message_header (xdr, &state->hdr)) {
2157 error (g, "guestfs_rm_rf: failed to parse reply header");
2160 if (state->hdr.status == GUESTFS_STATUS_ERROR) {
2161 if (!xdr_guestfs_message_error (xdr, &state->err)) {
2162 error (g, "guestfs_rm_rf: failed to parse reply error");
2168 state->cb_state = 1;
2169 ml->main_loop_quit (ml, g);
2172 int guestfs_rm_rf (guestfs_h *g,
2175 struct guestfs_rm_rf_args args;
2176 struct rm_rf_state state;
2177 guestfs_main_loop *ml = guestfs_get_main_loop (g);
2180 if (check_state (g, "guestfs_rm_rf") == -1) return -1;
2182 memset (&state, 0, sizeof state);
2184 args.path = (char *) path;
2185 serial = guestfs_send (g, GUESTFS_PROC_RM_RF,
2186 (xdrproc_t) xdr_guestfs_rm_rf_args, (char *) &args);
2191 guestfs_set_reply_callback (g, rm_rf_cb, &state);
2192 (void) ml->main_loop_run (ml, g);
2193 guestfs_set_reply_callback (g, NULL, NULL);
2194 if (!state.cb_state) {
2195 error (g, "guestfs_rm_rf failed, see earlier error messages");
2199 if (check_reply_header (g, &state.hdr, GUESTFS_PROC_RM_RF, serial) == -1)
2202 if (state.hdr.status == GUESTFS_STATUS_ERROR) {
2203 error (g, "%s", state.err.error_message);
2210 struct mkdir_state {
2212 struct guestfs_message_header hdr;
2213 struct guestfs_message_error err;
2216 static void mkdir_cb (guestfs_h *g, void *data, XDR *xdr)
2218 guestfs_main_loop *ml = guestfs_get_main_loop (g);
2219 struct mkdir_state *state = (struct mkdir_state *) data;
2221 if (!xdr_guestfs_message_header (xdr, &state->hdr)) {
2222 error (g, "guestfs_mkdir: failed to parse reply header");
2225 if (state->hdr.status == GUESTFS_STATUS_ERROR) {
2226 if (!xdr_guestfs_message_error (xdr, &state->err)) {
2227 error (g, "guestfs_mkdir: failed to parse reply error");
2233 state->cb_state = 1;
2234 ml->main_loop_quit (ml, g);
2237 int guestfs_mkdir (guestfs_h *g,
2240 struct guestfs_mkdir_args args;
2241 struct mkdir_state state;
2242 guestfs_main_loop *ml = guestfs_get_main_loop (g);
2245 if (check_state (g, "guestfs_mkdir") == -1) return -1;
2247 memset (&state, 0, sizeof state);
2249 args.path = (char *) path;
2250 serial = guestfs_send (g, GUESTFS_PROC_MKDIR,
2251 (xdrproc_t) xdr_guestfs_mkdir_args, (char *) &args);
2256 guestfs_set_reply_callback (g, mkdir_cb, &state);
2257 (void) ml->main_loop_run (ml, g);
2258 guestfs_set_reply_callback (g, NULL, NULL);
2259 if (!state.cb_state) {
2260 error (g, "guestfs_mkdir failed, see earlier error messages");
2264 if (check_reply_header (g, &state.hdr, GUESTFS_PROC_MKDIR, serial) == -1)
2267 if (state.hdr.status == GUESTFS_STATUS_ERROR) {
2268 error (g, "%s", state.err.error_message);
2275 struct mkdir_p_state {
2277 struct guestfs_message_header hdr;
2278 struct guestfs_message_error err;
2281 static void mkdir_p_cb (guestfs_h *g, void *data, XDR *xdr)
2283 guestfs_main_loop *ml = guestfs_get_main_loop (g);
2284 struct mkdir_p_state *state = (struct mkdir_p_state *) data;
2286 if (!xdr_guestfs_message_header (xdr, &state->hdr)) {
2287 error (g, "guestfs_mkdir_p: failed to parse reply header");
2290 if (state->hdr.status == GUESTFS_STATUS_ERROR) {
2291 if (!xdr_guestfs_message_error (xdr, &state->err)) {
2292 error (g, "guestfs_mkdir_p: failed to parse reply error");
2298 state->cb_state = 1;
2299 ml->main_loop_quit (ml, g);
2302 int guestfs_mkdir_p (guestfs_h *g,
2305 struct guestfs_mkdir_p_args args;
2306 struct mkdir_p_state state;
2307 guestfs_main_loop *ml = guestfs_get_main_loop (g);
2310 if (check_state (g, "guestfs_mkdir_p") == -1) return -1;
2312 memset (&state, 0, sizeof state);
2314 args.path = (char *) path;
2315 serial = guestfs_send (g, GUESTFS_PROC_MKDIR_P,
2316 (xdrproc_t) xdr_guestfs_mkdir_p_args, (char *) &args);
2321 guestfs_set_reply_callback (g, mkdir_p_cb, &state);
2322 (void) ml->main_loop_run (ml, g);
2323 guestfs_set_reply_callback (g, NULL, NULL);
2324 if (!state.cb_state) {
2325 error (g, "guestfs_mkdir_p failed, see earlier error messages");
2329 if (check_reply_header (g, &state.hdr, GUESTFS_PROC_MKDIR_P, serial) == -1)
2332 if (state.hdr.status == GUESTFS_STATUS_ERROR) {
2333 error (g, "%s", state.err.error_message);
2340 struct chmod_state {
2342 struct guestfs_message_header hdr;
2343 struct guestfs_message_error err;
2346 static void chmod_cb (guestfs_h *g, void *data, XDR *xdr)
2348 guestfs_main_loop *ml = guestfs_get_main_loop (g);
2349 struct chmod_state *state = (struct chmod_state *) data;
2351 if (!xdr_guestfs_message_header (xdr, &state->hdr)) {
2352 error (g, "guestfs_chmod: failed to parse reply header");
2355 if (state->hdr.status == GUESTFS_STATUS_ERROR) {
2356 if (!xdr_guestfs_message_error (xdr, &state->err)) {
2357 error (g, "guestfs_chmod: failed to parse reply error");
2363 state->cb_state = 1;
2364 ml->main_loop_quit (ml, g);
2367 int guestfs_chmod (guestfs_h *g,
2371 struct guestfs_chmod_args args;
2372 struct chmod_state state;
2373 guestfs_main_loop *ml = guestfs_get_main_loop (g);
2376 if (check_state (g, "guestfs_chmod") == -1) return -1;
2378 memset (&state, 0, sizeof state);
2381 args.path = (char *) path;
2382 serial = guestfs_send (g, GUESTFS_PROC_CHMOD,
2383 (xdrproc_t) xdr_guestfs_chmod_args, (char *) &args);
2388 guestfs_set_reply_callback (g, chmod_cb, &state);
2389 (void) ml->main_loop_run (ml, g);
2390 guestfs_set_reply_callback (g, NULL, NULL);
2391 if (!state.cb_state) {
2392 error (g, "guestfs_chmod failed, see earlier error messages");
2396 if (check_reply_header (g, &state.hdr, GUESTFS_PROC_CHMOD, serial) == -1)
2399 if (state.hdr.status == GUESTFS_STATUS_ERROR) {
2400 error (g, "%s", state.err.error_message);
2407 struct chown_state {
2409 struct guestfs_message_header hdr;
2410 struct guestfs_message_error err;
2413 static void chown_cb (guestfs_h *g, void *data, XDR *xdr)
2415 guestfs_main_loop *ml = guestfs_get_main_loop (g);
2416 struct chown_state *state = (struct chown_state *) data;
2418 if (!xdr_guestfs_message_header (xdr, &state->hdr)) {
2419 error (g, "guestfs_chown: failed to parse reply header");
2422 if (state->hdr.status == GUESTFS_STATUS_ERROR) {
2423 if (!xdr_guestfs_message_error (xdr, &state->err)) {
2424 error (g, "guestfs_chown: failed to parse reply error");
2430 state->cb_state = 1;
2431 ml->main_loop_quit (ml, g);
2434 int guestfs_chown (guestfs_h *g,
2439 struct guestfs_chown_args args;
2440 struct chown_state state;
2441 guestfs_main_loop *ml = guestfs_get_main_loop (g);
2444 if (check_state (g, "guestfs_chown") == -1) return -1;
2446 memset (&state, 0, sizeof state);
2450 args.path = (char *) path;
2451 serial = guestfs_send (g, GUESTFS_PROC_CHOWN,
2452 (xdrproc_t) xdr_guestfs_chown_args, (char *) &args);
2457 guestfs_set_reply_callback (g, chown_cb, &state);
2458 (void) ml->main_loop_run (ml, g);
2459 guestfs_set_reply_callback (g, NULL, NULL);
2460 if (!state.cb_state) {
2461 error (g, "guestfs_chown failed, see earlier error messages");
2465 if (check_reply_header (g, &state.hdr, GUESTFS_PROC_CHOWN, serial) == -1)
2468 if (state.hdr.status == GUESTFS_STATUS_ERROR) {
2469 error (g, "%s", state.err.error_message);
2476 struct exists_state {
2478 struct guestfs_message_header hdr;
2479 struct guestfs_message_error err;
2480 struct guestfs_exists_ret ret;
2483 static void exists_cb (guestfs_h *g, void *data, XDR *xdr)
2485 guestfs_main_loop *ml = guestfs_get_main_loop (g);
2486 struct exists_state *state = (struct exists_state *) data;
2488 if (!xdr_guestfs_message_header (xdr, &state->hdr)) {
2489 error (g, "guestfs_exists: failed to parse reply header");
2492 if (state->hdr.status == GUESTFS_STATUS_ERROR) {
2493 if (!xdr_guestfs_message_error (xdr, &state->err)) {
2494 error (g, "guestfs_exists: failed to parse reply error");
2499 if (!xdr_guestfs_exists_ret (xdr, &state->ret)) {
2500 error (g, "guestfs_exists: failed to parse reply");
2504 state->cb_state = 1;
2505 ml->main_loop_quit (ml, g);
2508 int guestfs_exists (guestfs_h *g,
2511 struct guestfs_exists_args args;
2512 struct exists_state state;
2513 guestfs_main_loop *ml = guestfs_get_main_loop (g);
2516 if (check_state (g, "guestfs_exists") == -1) return -1;
2518 memset (&state, 0, sizeof state);
2520 args.path = (char *) path;
2521 serial = guestfs_send (g, GUESTFS_PROC_EXISTS,
2522 (xdrproc_t) xdr_guestfs_exists_args, (char *) &args);
2527 guestfs_set_reply_callback (g, exists_cb, &state);
2528 (void) ml->main_loop_run (ml, g);
2529 guestfs_set_reply_callback (g, NULL, NULL);
2530 if (!state.cb_state) {
2531 error (g, "guestfs_exists failed, see earlier error messages");
2535 if (check_reply_header (g, &state.hdr, GUESTFS_PROC_EXISTS, serial) == -1)
2538 if (state.hdr.status == GUESTFS_STATUS_ERROR) {
2539 error (g, "%s", state.err.error_message);
2543 return state.ret.existsflag;
2546 struct is_file_state {
2548 struct guestfs_message_header hdr;
2549 struct guestfs_message_error err;
2550 struct guestfs_is_file_ret ret;
2553 static void is_file_cb (guestfs_h *g, void *data, XDR *xdr)
2555 guestfs_main_loop *ml = guestfs_get_main_loop (g);
2556 struct is_file_state *state = (struct is_file_state *) data;
2558 if (!xdr_guestfs_message_header (xdr, &state->hdr)) {
2559 error (g, "guestfs_is_file: failed to parse reply header");
2562 if (state->hdr.status == GUESTFS_STATUS_ERROR) {
2563 if (!xdr_guestfs_message_error (xdr, &state->err)) {
2564 error (g, "guestfs_is_file: failed to parse reply error");
2569 if (!xdr_guestfs_is_file_ret (xdr, &state->ret)) {
2570 error (g, "guestfs_is_file: failed to parse reply");
2574 state->cb_state = 1;
2575 ml->main_loop_quit (ml, g);
2578 int guestfs_is_file (guestfs_h *g,
2581 struct guestfs_is_file_args args;
2582 struct is_file_state state;
2583 guestfs_main_loop *ml = guestfs_get_main_loop (g);
2586 if (check_state (g, "guestfs_is_file") == -1) return -1;
2588 memset (&state, 0, sizeof state);
2590 args.path = (char *) path;
2591 serial = guestfs_send (g, GUESTFS_PROC_IS_FILE,
2592 (xdrproc_t) xdr_guestfs_is_file_args, (char *) &args);
2597 guestfs_set_reply_callback (g, is_file_cb, &state);
2598 (void) ml->main_loop_run (ml, g);
2599 guestfs_set_reply_callback (g, NULL, NULL);
2600 if (!state.cb_state) {
2601 error (g, "guestfs_is_file failed, see earlier error messages");
2605 if (check_reply_header (g, &state.hdr, GUESTFS_PROC_IS_FILE, serial) == -1)
2608 if (state.hdr.status == GUESTFS_STATUS_ERROR) {
2609 error (g, "%s", state.err.error_message);
2613 return state.ret.fileflag;
2616 struct is_dir_state {
2618 struct guestfs_message_header hdr;
2619 struct guestfs_message_error err;
2620 struct guestfs_is_dir_ret ret;
2623 static void is_dir_cb (guestfs_h *g, void *data, XDR *xdr)
2625 guestfs_main_loop *ml = guestfs_get_main_loop (g);
2626 struct is_dir_state *state = (struct is_dir_state *) data;
2628 if (!xdr_guestfs_message_header (xdr, &state->hdr)) {
2629 error (g, "guestfs_is_dir: failed to parse reply header");
2632 if (state->hdr.status == GUESTFS_STATUS_ERROR) {
2633 if (!xdr_guestfs_message_error (xdr, &state->err)) {
2634 error (g, "guestfs_is_dir: failed to parse reply error");
2639 if (!xdr_guestfs_is_dir_ret (xdr, &state->ret)) {
2640 error (g, "guestfs_is_dir: failed to parse reply");
2644 state->cb_state = 1;
2645 ml->main_loop_quit (ml, g);
2648 int guestfs_is_dir (guestfs_h *g,
2651 struct guestfs_is_dir_args args;
2652 struct is_dir_state state;
2653 guestfs_main_loop *ml = guestfs_get_main_loop (g);
2656 if (check_state (g, "guestfs_is_dir") == -1) return -1;
2658 memset (&state, 0, sizeof state);
2660 args.path = (char *) path;
2661 serial = guestfs_send (g, GUESTFS_PROC_IS_DIR,
2662 (xdrproc_t) xdr_guestfs_is_dir_args, (char *) &args);
2667 guestfs_set_reply_callback (g, is_dir_cb, &state);
2668 (void) ml->main_loop_run (ml, g);
2669 guestfs_set_reply_callback (g, NULL, NULL);
2670 if (!state.cb_state) {
2671 error (g, "guestfs_is_dir failed, see earlier error messages");
2675 if (check_reply_header (g, &state.hdr, GUESTFS_PROC_IS_DIR, serial) == -1)
2678 if (state.hdr.status == GUESTFS_STATUS_ERROR) {
2679 error (g, "%s", state.err.error_message);
2683 return state.ret.dirflag;
2686 struct pvcreate_state {
2688 struct guestfs_message_header hdr;
2689 struct guestfs_message_error err;
2692 static void pvcreate_cb (guestfs_h *g, void *data, XDR *xdr)
2694 guestfs_main_loop *ml = guestfs_get_main_loop (g);
2695 struct pvcreate_state *state = (struct pvcreate_state *) data;
2697 if (!xdr_guestfs_message_header (xdr, &state->hdr)) {
2698 error (g, "guestfs_pvcreate: failed to parse reply header");
2701 if (state->hdr.status == GUESTFS_STATUS_ERROR) {
2702 if (!xdr_guestfs_message_error (xdr, &state->err)) {
2703 error (g, "guestfs_pvcreate: failed to parse reply error");
2709 state->cb_state = 1;
2710 ml->main_loop_quit (ml, g);
2713 int guestfs_pvcreate (guestfs_h *g,
2716 struct guestfs_pvcreate_args args;
2717 struct pvcreate_state state;
2718 guestfs_main_loop *ml = guestfs_get_main_loop (g);
2721 if (check_state (g, "guestfs_pvcreate") == -1) return -1;
2723 memset (&state, 0, sizeof state);
2725 args.device = (char *) device;
2726 serial = guestfs_send (g, GUESTFS_PROC_PVCREATE,
2727 (xdrproc_t) xdr_guestfs_pvcreate_args, (char *) &args);
2732 guestfs_set_reply_callback (g, pvcreate_cb, &state);
2733 (void) ml->main_loop_run (ml, g);
2734 guestfs_set_reply_callback (g, NULL, NULL);
2735 if (!state.cb_state) {
2736 error (g, "guestfs_pvcreate failed, see earlier error messages");
2740 if (check_reply_header (g, &state.hdr, GUESTFS_PROC_PVCREATE, serial) == -1)
2743 if (state.hdr.status == GUESTFS_STATUS_ERROR) {
2744 error (g, "%s", state.err.error_message);
2751 struct vgcreate_state {
2753 struct guestfs_message_header hdr;
2754 struct guestfs_message_error err;
2757 static void vgcreate_cb (guestfs_h *g, void *data, XDR *xdr)
2759 guestfs_main_loop *ml = guestfs_get_main_loop (g);
2760 struct vgcreate_state *state = (struct vgcreate_state *) data;
2762 if (!xdr_guestfs_message_header (xdr, &state->hdr)) {
2763 error (g, "guestfs_vgcreate: failed to parse reply header");
2766 if (state->hdr.status == GUESTFS_STATUS_ERROR) {
2767 if (!xdr_guestfs_message_error (xdr, &state->err)) {
2768 error (g, "guestfs_vgcreate: failed to parse reply error");
2774 state->cb_state = 1;
2775 ml->main_loop_quit (ml, g);
2778 int guestfs_vgcreate (guestfs_h *g,
2779 const char *volgroup,
2780 char * const* const physvols)
2782 struct guestfs_vgcreate_args args;
2783 struct vgcreate_state state;
2784 guestfs_main_loop *ml = guestfs_get_main_loop (g);
2787 if (check_state (g, "guestfs_vgcreate") == -1) return -1;
2789 memset (&state, 0, sizeof state);
2791 args.volgroup = (char *) volgroup;
2792 args.physvols.physvols_val = (char **) physvols;
2793 for (args.physvols.physvols_len = 0; physvols[args.physvols.physvols_len]; args.physvols.physvols_len++) ;
2794 serial = guestfs_send (g, GUESTFS_PROC_VGCREATE,
2795 (xdrproc_t) xdr_guestfs_vgcreate_args, (char *) &args);
2800 guestfs_set_reply_callback (g, vgcreate_cb, &state);
2801 (void) ml->main_loop_run (ml, g);
2802 guestfs_set_reply_callback (g, NULL, NULL);
2803 if (!state.cb_state) {
2804 error (g, "guestfs_vgcreate failed, see earlier error messages");
2808 if (check_reply_header (g, &state.hdr, GUESTFS_PROC_VGCREATE, serial) == -1)
2811 if (state.hdr.status == GUESTFS_STATUS_ERROR) {
2812 error (g, "%s", state.err.error_message);
2819 struct lvcreate_state {
2821 struct guestfs_message_header hdr;
2822 struct guestfs_message_error err;
2825 static void lvcreate_cb (guestfs_h *g, void *data, XDR *xdr)
2827 guestfs_main_loop *ml = guestfs_get_main_loop (g);
2828 struct lvcreate_state *state = (struct lvcreate_state *) data;
2830 if (!xdr_guestfs_message_header (xdr, &state->hdr)) {
2831 error (g, "guestfs_lvcreate: failed to parse reply header");
2834 if (state->hdr.status == GUESTFS_STATUS_ERROR) {
2835 if (!xdr_guestfs_message_error (xdr, &state->err)) {
2836 error (g, "guestfs_lvcreate: failed to parse reply error");
2842 state->cb_state = 1;
2843 ml->main_loop_quit (ml, g);
2846 int guestfs_lvcreate (guestfs_h *g,
2848 const char *volgroup,
2851 struct guestfs_lvcreate_args args;
2852 struct lvcreate_state state;
2853 guestfs_main_loop *ml = guestfs_get_main_loop (g);
2856 if (check_state (g, "guestfs_lvcreate") == -1) return -1;
2858 memset (&state, 0, sizeof state);
2860 args.logvol = (char *) logvol;
2861 args.volgroup = (char *) volgroup;
2862 args.mbytes = mbytes;
2863 serial = guestfs_send (g, GUESTFS_PROC_LVCREATE,
2864 (xdrproc_t) xdr_guestfs_lvcreate_args, (char *) &args);
2869 guestfs_set_reply_callback (g, lvcreate_cb, &state);
2870 (void) ml->main_loop_run (ml, g);
2871 guestfs_set_reply_callback (g, NULL, NULL);
2872 if (!state.cb_state) {
2873 error (g, "guestfs_lvcreate failed, see earlier error messages");
2877 if (check_reply_header (g, &state.hdr, GUESTFS_PROC_LVCREATE, serial) == -1)
2880 if (state.hdr.status == GUESTFS_STATUS_ERROR) {
2881 error (g, "%s", state.err.error_message);
2890 struct guestfs_message_header hdr;
2891 struct guestfs_message_error err;
2894 static void mkfs_cb (guestfs_h *g, void *data, XDR *xdr)
2896 guestfs_main_loop *ml = guestfs_get_main_loop (g);
2897 struct mkfs_state *state = (struct mkfs_state *) data;
2899 if (!xdr_guestfs_message_header (xdr, &state->hdr)) {
2900 error (g, "guestfs_mkfs: failed to parse reply header");
2903 if (state->hdr.status == GUESTFS_STATUS_ERROR) {
2904 if (!xdr_guestfs_message_error (xdr, &state->err)) {
2905 error (g, "guestfs_mkfs: failed to parse reply error");
2911 state->cb_state = 1;
2912 ml->main_loop_quit (ml, g);
2915 int guestfs_mkfs (guestfs_h *g,
2919 struct guestfs_mkfs_args args;
2920 struct mkfs_state state;
2921 guestfs_main_loop *ml = guestfs_get_main_loop (g);
2924 if (check_state (g, "guestfs_mkfs") == -1) return -1;
2926 memset (&state, 0, sizeof state);
2928 args.fstype = (char *) fstype;
2929 args.device = (char *) device;
2930 serial = guestfs_send (g, GUESTFS_PROC_MKFS,
2931 (xdrproc_t) xdr_guestfs_mkfs_args, (char *) &args);
2936 guestfs_set_reply_callback (g, mkfs_cb, &state);
2937 (void) ml->main_loop_run (ml, g);
2938 guestfs_set_reply_callback (g, NULL, NULL);
2939 if (!state.cb_state) {
2940 error (g, "guestfs_mkfs failed, see earlier error messages");
2944 if (check_reply_header (g, &state.hdr, GUESTFS_PROC_MKFS, serial) == -1)
2947 if (state.hdr.status == GUESTFS_STATUS_ERROR) {
2948 error (g, "%s", state.err.error_message);
2955 struct sfdisk_state {
2957 struct guestfs_message_header hdr;
2958 struct guestfs_message_error err;
2961 static void sfdisk_cb (guestfs_h *g, void *data, XDR *xdr)
2963 guestfs_main_loop *ml = guestfs_get_main_loop (g);
2964 struct sfdisk_state *state = (struct sfdisk_state *) data;
2966 if (!xdr_guestfs_message_header (xdr, &state->hdr)) {
2967 error (g, "guestfs_sfdisk: failed to parse reply header");
2970 if (state->hdr.status == GUESTFS_STATUS_ERROR) {
2971 if (!xdr_guestfs_message_error (xdr, &state->err)) {
2972 error (g, "guestfs_sfdisk: failed to parse reply error");
2978 state->cb_state = 1;
2979 ml->main_loop_quit (ml, g);
2982 int guestfs_sfdisk (guestfs_h *g,
2987 char * const* const lines)
2989 struct guestfs_sfdisk_args args;
2990 struct sfdisk_state state;
2991 guestfs_main_loop *ml = guestfs_get_main_loop (g);
2994 if (check_state (g, "guestfs_sfdisk") == -1) return -1;
2996 memset (&state, 0, sizeof state);
2998 args.device = (char *) device;
3001 args.sectors = sectors;
3002 args.lines.lines_val = (char **) lines;
3003 for (args.lines.lines_len = 0; lines[args.lines.lines_len]; args.lines.lines_len++) ;
3004 serial = guestfs_send (g, GUESTFS_PROC_SFDISK,
3005 (xdrproc_t) xdr_guestfs_sfdisk_args, (char *) &args);
3010 guestfs_set_reply_callback (g, sfdisk_cb, &state);
3011 (void) ml->main_loop_run (ml, g);
3012 guestfs_set_reply_callback (g, NULL, NULL);
3013 if (!state.cb_state) {
3014 error (g, "guestfs_sfdisk failed, see earlier error messages");
3018 if (check_reply_header (g, &state.hdr, GUESTFS_PROC_SFDISK, serial) == -1)
3021 if (state.hdr.status == GUESTFS_STATUS_ERROR) {
3022 error (g, "%s", state.err.error_message);
3029 struct write_file_state {
3031 struct guestfs_message_header hdr;
3032 struct guestfs_message_error err;
3035 static void write_file_cb (guestfs_h *g, void *data, XDR *xdr)
3037 guestfs_main_loop *ml = guestfs_get_main_loop (g);
3038 struct write_file_state *state = (struct write_file_state *) data;
3040 if (!xdr_guestfs_message_header (xdr, &state->hdr)) {
3041 error (g, "guestfs_write_file: failed to parse reply header");
3044 if (state->hdr.status == GUESTFS_STATUS_ERROR) {
3045 if (!xdr_guestfs_message_error (xdr, &state->err)) {
3046 error (g, "guestfs_write_file: failed to parse reply error");
3052 state->cb_state = 1;
3053 ml->main_loop_quit (ml, g);
3056 int guestfs_write_file (guestfs_h *g,
3058 const char *content,
3061 struct guestfs_write_file_args args;
3062 struct write_file_state state;
3063 guestfs_main_loop *ml = guestfs_get_main_loop (g);
3066 if (check_state (g, "guestfs_write_file") == -1) return -1;
3068 memset (&state, 0, sizeof state);
3070 args.path = (char *) path;
3071 args.content = (char *) content;
3073 serial = guestfs_send (g, GUESTFS_PROC_WRITE_FILE,
3074 (xdrproc_t) xdr_guestfs_write_file_args, (char *) &args);
3079 guestfs_set_reply_callback (g, write_file_cb, &state);
3080 (void) ml->main_loop_run (ml, g);
3081 guestfs_set_reply_callback (g, NULL, NULL);
3082 if (!state.cb_state) {
3083 error (g, "guestfs_write_file failed, see earlier error messages");
3087 if (check_reply_header (g, &state.hdr, GUESTFS_PROC_WRITE_FILE, serial) == -1)
3090 if (state.hdr.status == GUESTFS_STATUS_ERROR) {
3091 error (g, "%s", state.err.error_message);
3098 struct umount_state {
3100 struct guestfs_message_header hdr;
3101 struct guestfs_message_error err;
3104 static void umount_cb (guestfs_h *g, void *data, XDR *xdr)
3106 guestfs_main_loop *ml = guestfs_get_main_loop (g);
3107 struct umount_state *state = (struct umount_state *) data;
3109 if (!xdr_guestfs_message_header (xdr, &state->hdr)) {
3110 error (g, "guestfs_umount: failed to parse reply header");
3113 if (state->hdr.status == GUESTFS_STATUS_ERROR) {
3114 if (!xdr_guestfs_message_error (xdr, &state->err)) {
3115 error (g, "guestfs_umount: failed to parse reply error");
3121 state->cb_state = 1;
3122 ml->main_loop_quit (ml, g);
3125 int guestfs_umount (guestfs_h *g,
3126 const char *pathordevice)
3128 struct guestfs_umount_args args;
3129 struct umount_state state;
3130 guestfs_main_loop *ml = guestfs_get_main_loop (g);
3133 if (check_state (g, "guestfs_umount") == -1) return -1;
3135 memset (&state, 0, sizeof state);
3137 args.pathordevice = (char *) pathordevice;
3138 serial = guestfs_send (g, GUESTFS_PROC_UMOUNT,
3139 (xdrproc_t) xdr_guestfs_umount_args, (char *) &args);
3144 guestfs_set_reply_callback (g, umount_cb, &state);
3145 (void) ml->main_loop_run (ml, g);
3146 guestfs_set_reply_callback (g, NULL, NULL);
3147 if (!state.cb_state) {
3148 error (g, "guestfs_umount failed, see earlier error messages");
3152 if (check_reply_header (g, &state.hdr, GUESTFS_PROC_UMOUNT, serial) == -1)
3155 if (state.hdr.status == GUESTFS_STATUS_ERROR) {
3156 error (g, "%s", state.err.error_message);
3163 struct mounts_state {
3165 struct guestfs_message_header hdr;
3166 struct guestfs_message_error err;
3167 struct guestfs_mounts_ret ret;
3170 static void mounts_cb (guestfs_h *g, void *data, XDR *xdr)
3172 guestfs_main_loop *ml = guestfs_get_main_loop (g);
3173 struct mounts_state *state = (struct mounts_state *) data;
3175 if (!xdr_guestfs_message_header (xdr, &state->hdr)) {
3176 error (g, "guestfs_mounts: failed to parse reply header");
3179 if (state->hdr.status == GUESTFS_STATUS_ERROR) {
3180 if (!xdr_guestfs_message_error (xdr, &state->err)) {
3181 error (g, "guestfs_mounts: failed to parse reply error");
3186 if (!xdr_guestfs_mounts_ret (xdr, &state->ret)) {
3187 error (g, "guestfs_mounts: failed to parse reply");
3191 state->cb_state = 1;
3192 ml->main_loop_quit (ml, g);
3195 char **guestfs_mounts (guestfs_h *g)
3197 struct mounts_state state;
3198 guestfs_main_loop *ml = guestfs_get_main_loop (g);
3201 if (check_state (g, "guestfs_mounts") == -1) return NULL;
3203 memset (&state, 0, sizeof state);
3205 serial = guestfs_send (g, GUESTFS_PROC_MOUNTS, NULL, NULL);
3210 guestfs_set_reply_callback (g, mounts_cb, &state);
3211 (void) ml->main_loop_run (ml, g);
3212 guestfs_set_reply_callback (g, NULL, NULL);
3213 if (!state.cb_state) {
3214 error (g, "guestfs_mounts failed, see earlier error messages");
3218 if (check_reply_header (g, &state.hdr, GUESTFS_PROC_MOUNTS, serial) == -1)
3221 if (state.hdr.status == GUESTFS_STATUS_ERROR) {
3222 error (g, "%s", state.err.error_message);
3226 /* caller will free this, but we need to add a NULL entry */
3227 state.ret.devices.devices_val =
3228 safe_realloc (g, state.ret.devices.devices_val,
3229 sizeof (char *) * (state.ret.devices.devices_len + 1));
3230 state.ret.devices.devices_val[state.ret.devices.devices_len] = NULL;
3231 return state.ret.devices.devices_val;
3234 struct umount_all_state {
3236 struct guestfs_message_header hdr;
3237 struct guestfs_message_error err;
3240 static void umount_all_cb (guestfs_h *g, void *data, XDR *xdr)
3242 guestfs_main_loop *ml = guestfs_get_main_loop (g);
3243 struct umount_all_state *state = (struct umount_all_state *) data;
3245 if (!xdr_guestfs_message_header (xdr, &state->hdr)) {
3246 error (g, "guestfs_umount_all: failed to parse reply header");
3249 if (state->hdr.status == GUESTFS_STATUS_ERROR) {
3250 if (!xdr_guestfs_message_error (xdr, &state->err)) {
3251 error (g, "guestfs_umount_all: failed to parse reply error");
3257 state->cb_state = 1;
3258 ml->main_loop_quit (ml, g);
3261 int guestfs_umount_all (guestfs_h *g)
3263 struct umount_all_state state;
3264 guestfs_main_loop *ml = guestfs_get_main_loop (g);
3267 if (check_state (g, "guestfs_umount_all") == -1) return -1;
3269 memset (&state, 0, sizeof state);
3271 serial = guestfs_send (g, GUESTFS_PROC_UMOUNT_ALL, NULL, NULL);
3276 guestfs_set_reply_callback (g, umount_all_cb, &state);
3277 (void) ml->main_loop_run (ml, g);
3278 guestfs_set_reply_callback (g, NULL, NULL);
3279 if (!state.cb_state) {
3280 error (g, "guestfs_umount_all failed, see earlier error messages");
3284 if (check_reply_header (g, &state.hdr, GUESTFS_PROC_UMOUNT_ALL, serial) == -1)
3287 if (state.hdr.status == GUESTFS_STATUS_ERROR) {
3288 error (g, "%s", state.err.error_message);
3295 struct lvm_remove_all_state {
3297 struct guestfs_message_header hdr;
3298 struct guestfs_message_error err;
3301 static void lvm_remove_all_cb (guestfs_h *g, void *data, XDR *xdr)
3303 guestfs_main_loop *ml = guestfs_get_main_loop (g);
3304 struct lvm_remove_all_state *state = (struct lvm_remove_all_state *) data;
3306 if (!xdr_guestfs_message_header (xdr, &state->hdr)) {
3307 error (g, "guestfs_lvm_remove_all: failed to parse reply header");
3310 if (state->hdr.status == GUESTFS_STATUS_ERROR) {
3311 if (!xdr_guestfs_message_error (xdr, &state->err)) {
3312 error (g, "guestfs_lvm_remove_all: failed to parse reply error");
3318 state->cb_state = 1;
3319 ml->main_loop_quit (ml, g);
3322 int guestfs_lvm_remove_all (guestfs_h *g)
3324 struct lvm_remove_all_state state;
3325 guestfs_main_loop *ml = guestfs_get_main_loop (g);
3328 if (check_state (g, "guestfs_lvm_remove_all") == -1) return -1;
3330 memset (&state, 0, sizeof state);
3332 serial = guestfs_send (g, GUESTFS_PROC_LVM_REMOVE_ALL, NULL, NULL);
3337 guestfs_set_reply_callback (g, lvm_remove_all_cb, &state);
3338 (void) ml->main_loop_run (ml, g);
3339 guestfs_set_reply_callback (g, NULL, NULL);
3340 if (!state.cb_state) {
3341 error (g, "guestfs_lvm_remove_all failed, see earlier error messages");
3345 if (check_reply_header (g, &state.hdr, GUESTFS_PROC_LVM_REMOVE_ALL, serial) == -1)
3348 if (state.hdr.status == GUESTFS_STATUS_ERROR) {
3349 error (g, "%s", state.err.error_message);
3358 struct guestfs_message_header hdr;
3359 struct guestfs_message_error err;
3360 struct guestfs_file_ret ret;
3363 static void file_cb (guestfs_h *g, void *data, XDR *xdr)
3365 guestfs_main_loop *ml = guestfs_get_main_loop (g);
3366 struct file_state *state = (struct file_state *) data;
3368 if (!xdr_guestfs_message_header (xdr, &state->hdr)) {
3369 error (g, "guestfs_file: failed to parse reply header");
3372 if (state->hdr.status == GUESTFS_STATUS_ERROR) {
3373 if (!xdr_guestfs_message_error (xdr, &state->err)) {
3374 error (g, "guestfs_file: failed to parse reply error");
3379 if (!xdr_guestfs_file_ret (xdr, &state->ret)) {
3380 error (g, "guestfs_file: failed to parse reply");
3384 state->cb_state = 1;
3385 ml->main_loop_quit (ml, g);
3388 char *guestfs_file (guestfs_h *g,
3391 struct guestfs_file_args args;
3392 struct file_state state;
3393 guestfs_main_loop *ml = guestfs_get_main_loop (g);
3396 if (check_state (g, "guestfs_file") == -1) return NULL;
3398 memset (&state, 0, sizeof state);
3400 args.path = (char *) path;
3401 serial = guestfs_send (g, GUESTFS_PROC_FILE,
3402 (xdrproc_t) xdr_guestfs_file_args, (char *) &args);
3407 guestfs_set_reply_callback (g, file_cb, &state);
3408 (void) ml->main_loop_run (ml, g);
3409 guestfs_set_reply_callback (g, NULL, NULL);
3410 if (!state.cb_state) {
3411 error (g, "guestfs_file failed, see earlier error messages");
3415 if (check_reply_header (g, &state.hdr, GUESTFS_PROC_FILE, serial) == -1)
3418 if (state.hdr.status == GUESTFS_STATUS_ERROR) {
3419 error (g, "%s", state.err.error_message);
3423 return state.ret.description; /* caller will free */
3426 struct command_state {
3428 struct guestfs_message_header hdr;
3429 struct guestfs_message_error err;
3430 struct guestfs_command_ret ret;
3433 static void command_cb (guestfs_h *g, void *data, XDR *xdr)
3435 guestfs_main_loop *ml = guestfs_get_main_loop (g);
3436 struct command_state *state = (struct command_state *) data;
3438 if (!xdr_guestfs_message_header (xdr, &state->hdr)) {
3439 error (g, "guestfs_command: failed to parse reply header");
3442 if (state->hdr.status == GUESTFS_STATUS_ERROR) {
3443 if (!xdr_guestfs_message_error (xdr, &state->err)) {
3444 error (g, "guestfs_command: failed to parse reply error");
3449 if (!xdr_guestfs_command_ret (xdr, &state->ret)) {
3450 error (g, "guestfs_command: failed to parse reply");
3454 state->cb_state = 1;
3455 ml->main_loop_quit (ml, g);
3458 char *guestfs_command (guestfs_h *g,
3459 char * const* const arguments)
3461 struct guestfs_command_args args;
3462 struct command_state state;
3463 guestfs_main_loop *ml = guestfs_get_main_loop (g);
3466 if (check_state (g, "guestfs_command") == -1) return NULL;
3468 memset (&state, 0, sizeof state);
3470 args.arguments.arguments_val = (char **) arguments;
3471 for (args.arguments.arguments_len = 0; arguments[args.arguments.arguments_len]; args.arguments.arguments_len++) ;
3472 serial = guestfs_send (g, GUESTFS_PROC_COMMAND,
3473 (xdrproc_t) xdr_guestfs_command_args, (char *) &args);
3478 guestfs_set_reply_callback (g, command_cb, &state);
3479 (void) ml->main_loop_run (ml, g);
3480 guestfs_set_reply_callback (g, NULL, NULL);
3481 if (!state.cb_state) {
3482 error (g, "guestfs_command failed, see earlier error messages");
3486 if (check_reply_header (g, &state.hdr, GUESTFS_PROC_COMMAND, serial) == -1)
3489 if (state.hdr.status == GUESTFS_STATUS_ERROR) {
3490 error (g, "%s", state.err.error_message);
3494 return state.ret.output; /* caller will free */
3497 struct command_lines_state {
3499 struct guestfs_message_header hdr;
3500 struct guestfs_message_error err;
3501 struct guestfs_command_lines_ret ret;
3504 static void command_lines_cb (guestfs_h *g, void *data, XDR *xdr)
3506 guestfs_main_loop *ml = guestfs_get_main_loop (g);
3507 struct command_lines_state *state = (struct command_lines_state *) data;
3509 if (!xdr_guestfs_message_header (xdr, &state->hdr)) {
3510 error (g, "guestfs_command_lines: failed to parse reply header");
3513 if (state->hdr.status == GUESTFS_STATUS_ERROR) {
3514 if (!xdr_guestfs_message_error (xdr, &state->err)) {
3515 error (g, "guestfs_command_lines: failed to parse reply error");
3520 if (!xdr_guestfs_command_lines_ret (xdr, &state->ret)) {
3521 error (g, "guestfs_command_lines: failed to parse reply");
3525 state->cb_state = 1;
3526 ml->main_loop_quit (ml, g);
3529 char **guestfs_command_lines (guestfs_h *g,
3530 char * const* const arguments)
3532 struct guestfs_command_lines_args args;
3533 struct command_lines_state state;
3534 guestfs_main_loop *ml = guestfs_get_main_loop (g);
3537 if (check_state (g, "guestfs_command_lines") == -1) return NULL;
3539 memset (&state, 0, sizeof state);
3541 args.arguments.arguments_val = (char **) arguments;
3542 for (args.arguments.arguments_len = 0; arguments[args.arguments.arguments_len]; args.arguments.arguments_len++) ;
3543 serial = guestfs_send (g, GUESTFS_PROC_COMMAND_LINES,
3544 (xdrproc_t) xdr_guestfs_command_lines_args, (char *) &args);
3549 guestfs_set_reply_callback (g, command_lines_cb, &state);
3550 (void) ml->main_loop_run (ml, g);
3551 guestfs_set_reply_callback (g, NULL, NULL);
3552 if (!state.cb_state) {
3553 error (g, "guestfs_command_lines failed, see earlier error messages");
3557 if (check_reply_header (g, &state.hdr, GUESTFS_PROC_COMMAND_LINES, serial) == -1)
3560 if (state.hdr.status == GUESTFS_STATUS_ERROR) {
3561 error (g, "%s", state.err.error_message);
3565 /* caller will free this, but we need to add a NULL entry */
3566 state.ret.lines.lines_val =
3567 safe_realloc (g, state.ret.lines.lines_val,
3568 sizeof (char *) * (state.ret.lines.lines_len + 1));
3569 state.ret.lines.lines_val[state.ret.lines.lines_len] = NULL;
3570 return state.ret.lines.lines_val;
3575 struct guestfs_message_header hdr;
3576 struct guestfs_message_error err;
3577 struct guestfs_stat_ret ret;
3580 static void stat_cb (guestfs_h *g, void *data, XDR *xdr)
3582 guestfs_main_loop *ml = guestfs_get_main_loop (g);
3583 struct stat_state *state = (struct stat_state *) data;
3585 if (!xdr_guestfs_message_header (xdr, &state->hdr)) {
3586 error (g, "guestfs_stat: failed to parse reply header");
3589 if (state->hdr.status == GUESTFS_STATUS_ERROR) {
3590 if (!xdr_guestfs_message_error (xdr, &state->err)) {
3591 error (g, "guestfs_stat: failed to parse reply error");
3596 if (!xdr_guestfs_stat_ret (xdr, &state->ret)) {
3597 error (g, "guestfs_stat: failed to parse reply");
3601 state->cb_state = 1;
3602 ml->main_loop_quit (ml, g);
3605 struct guestfs_stat *guestfs_stat (guestfs_h *g,
3608 struct guestfs_stat_args args;
3609 struct stat_state state;
3610 guestfs_main_loop *ml = guestfs_get_main_loop (g);
3613 if (check_state (g, "guestfs_stat") == -1) return NULL;
3615 memset (&state, 0, sizeof state);
3617 args.path = (char *) path;
3618 serial = guestfs_send (g, GUESTFS_PROC_STAT,
3619 (xdrproc_t) xdr_guestfs_stat_args, (char *) &args);
3624 guestfs_set_reply_callback (g, stat_cb, &state);
3625 (void) ml->main_loop_run (ml, g);
3626 guestfs_set_reply_callback (g, NULL, NULL);
3627 if (!state.cb_state) {
3628 error (g, "guestfs_stat failed, see earlier error messages");
3632 if (check_reply_header (g, &state.hdr, GUESTFS_PROC_STAT, serial) == -1)
3635 if (state.hdr.status == GUESTFS_STATUS_ERROR) {
3636 error (g, "%s", state.err.error_message);
3640 /* caller will free this */
3641 return safe_memdup (g, &state.ret.statbuf, sizeof (state.ret.statbuf));
3644 struct lstat_state {
3646 struct guestfs_message_header hdr;
3647 struct guestfs_message_error err;
3648 struct guestfs_lstat_ret ret;
3651 static void lstat_cb (guestfs_h *g, void *data, XDR *xdr)
3653 guestfs_main_loop *ml = guestfs_get_main_loop (g);
3654 struct lstat_state *state = (struct lstat_state *) data;
3656 if (!xdr_guestfs_message_header (xdr, &state->hdr)) {
3657 error (g, "guestfs_lstat: failed to parse reply header");
3660 if (state->hdr.status == GUESTFS_STATUS_ERROR) {
3661 if (!xdr_guestfs_message_error (xdr, &state->err)) {
3662 error (g, "guestfs_lstat: failed to parse reply error");
3667 if (!xdr_guestfs_lstat_ret (xdr, &state->ret)) {
3668 error (g, "guestfs_lstat: failed to parse reply");
3672 state->cb_state = 1;
3673 ml->main_loop_quit (ml, g);
3676 struct guestfs_stat *guestfs_lstat (guestfs_h *g,
3679 struct guestfs_lstat_args args;
3680 struct lstat_state state;
3681 guestfs_main_loop *ml = guestfs_get_main_loop (g);
3684 if (check_state (g, "guestfs_lstat") == -1) return NULL;
3686 memset (&state, 0, sizeof state);
3688 args.path = (char *) path;
3689 serial = guestfs_send (g, GUESTFS_PROC_LSTAT,
3690 (xdrproc_t) xdr_guestfs_lstat_args, (char *) &args);
3695 guestfs_set_reply_callback (g, lstat_cb, &state);
3696 (void) ml->main_loop_run (ml, g);
3697 guestfs_set_reply_callback (g, NULL, NULL);
3698 if (!state.cb_state) {
3699 error (g, "guestfs_lstat failed, see earlier error messages");
3703 if (check_reply_header (g, &state.hdr, GUESTFS_PROC_LSTAT, serial) == -1)
3706 if (state.hdr.status == GUESTFS_STATUS_ERROR) {
3707 error (g, "%s", state.err.error_message);
3711 /* caller will free this */
3712 return safe_memdup (g, &state.ret.statbuf, sizeof (state.ret.statbuf));
3715 struct statvfs_state {
3717 struct guestfs_message_header hdr;
3718 struct guestfs_message_error err;
3719 struct guestfs_statvfs_ret ret;
3722 static void statvfs_cb (guestfs_h *g, void *data, XDR *xdr)
3724 guestfs_main_loop *ml = guestfs_get_main_loop (g);
3725 struct statvfs_state *state = (struct statvfs_state *) data;
3727 if (!xdr_guestfs_message_header (xdr, &state->hdr)) {
3728 error (g, "guestfs_statvfs: failed to parse reply header");
3731 if (state->hdr.status == GUESTFS_STATUS_ERROR) {
3732 if (!xdr_guestfs_message_error (xdr, &state->err)) {
3733 error (g, "guestfs_statvfs: failed to parse reply error");
3738 if (!xdr_guestfs_statvfs_ret (xdr, &state->ret)) {
3739 error (g, "guestfs_statvfs: failed to parse reply");
3743 state->cb_state = 1;
3744 ml->main_loop_quit (ml, g);
3747 struct guestfs_statvfs *guestfs_statvfs (guestfs_h *g,
3750 struct guestfs_statvfs_args args;
3751 struct statvfs_state state;
3752 guestfs_main_loop *ml = guestfs_get_main_loop (g);
3755 if (check_state (g, "guestfs_statvfs") == -1) return NULL;
3757 memset (&state, 0, sizeof state);
3759 args.path = (char *) path;
3760 serial = guestfs_send (g, GUESTFS_PROC_STATVFS,
3761 (xdrproc_t) xdr_guestfs_statvfs_args, (char *) &args);
3766 guestfs_set_reply_callback (g, statvfs_cb, &state);
3767 (void) ml->main_loop_run (ml, g);
3768 guestfs_set_reply_callback (g, NULL, NULL);
3769 if (!state.cb_state) {
3770 error (g, "guestfs_statvfs failed, see earlier error messages");
3774 if (check_reply_header (g, &state.hdr, GUESTFS_PROC_STATVFS, serial) == -1)
3777 if (state.hdr.status == GUESTFS_STATUS_ERROR) {
3778 error (g, "%s", state.err.error_message);
3782 /* caller will free this */
3783 return safe_memdup (g, &state.ret.statbuf, sizeof (state.ret.statbuf));
3786 struct tune2fs_l_state {
3788 struct guestfs_message_header hdr;
3789 struct guestfs_message_error err;
3790 struct guestfs_tune2fs_l_ret ret;
3793 static void tune2fs_l_cb (guestfs_h *g, void *data, XDR *xdr)
3795 guestfs_main_loop *ml = guestfs_get_main_loop (g);
3796 struct tune2fs_l_state *state = (struct tune2fs_l_state *) data;
3798 if (!xdr_guestfs_message_header (xdr, &state->hdr)) {
3799 error (g, "guestfs_tune2fs_l: failed to parse reply header");
3802 if (state->hdr.status == GUESTFS_STATUS_ERROR) {
3803 if (!xdr_guestfs_message_error (xdr, &state->err)) {
3804 error (g, "guestfs_tune2fs_l: failed to parse reply error");
3809 if (!xdr_guestfs_tune2fs_l_ret (xdr, &state->ret)) {
3810 error (g, "guestfs_tune2fs_l: failed to parse reply");
3814 state->cb_state = 1;
3815 ml->main_loop_quit (ml, g);
3818 char **guestfs_tune2fs_l (guestfs_h *g,
3821 struct guestfs_tune2fs_l_args args;
3822 struct tune2fs_l_state state;
3823 guestfs_main_loop *ml = guestfs_get_main_loop (g);
3826 if (check_state (g, "guestfs_tune2fs_l") == -1) return NULL;
3828 memset (&state, 0, sizeof state);
3830 args.device = (char *) device;
3831 serial = guestfs_send (g, GUESTFS_PROC_TUNE2FS_L,
3832 (xdrproc_t) xdr_guestfs_tune2fs_l_args, (char *) &args);
3837 guestfs_set_reply_callback (g, tune2fs_l_cb, &state);
3838 (void) ml->main_loop_run (ml, g);
3839 guestfs_set_reply_callback (g, NULL, NULL);
3840 if (!state.cb_state) {
3841 error (g, "guestfs_tune2fs_l failed, see earlier error messages");
3845 if (check_reply_header (g, &state.hdr, GUESTFS_PROC_TUNE2FS_L, serial) == -1)
3848 if (state.hdr.status == GUESTFS_STATUS_ERROR) {
3849 error (g, "%s", state.err.error_message);
3853 /* caller will free this, but we need to add a NULL entry */
3854 state.ret.superblock.superblock_val =
3855 safe_realloc (g, state.ret.superblock.superblock_val,
3856 sizeof (char *) * (state.ret.superblock.superblock_len + 1));
3857 state.ret.superblock.superblock_val[state.ret.superblock.superblock_len] = NULL;
3858 return state.ret.superblock.superblock_val;
3861 struct blockdev_setro_state {
3863 struct guestfs_message_header hdr;
3864 struct guestfs_message_error err;
3867 static void blockdev_setro_cb (guestfs_h *g, void *data, XDR *xdr)
3869 guestfs_main_loop *ml = guestfs_get_main_loop (g);
3870 struct blockdev_setro_state *state = (struct blockdev_setro_state *) data;
3872 if (!xdr_guestfs_message_header (xdr, &state->hdr)) {
3873 error (g, "guestfs_blockdev_setro: failed to parse reply header");
3876 if (state->hdr.status == GUESTFS_STATUS_ERROR) {
3877 if (!xdr_guestfs_message_error (xdr, &state->err)) {
3878 error (g, "guestfs_blockdev_setro: failed to parse reply error");
3884 state->cb_state = 1;
3885 ml->main_loop_quit (ml, g);
3888 int guestfs_blockdev_setro (guestfs_h *g,
3891 struct guestfs_blockdev_setro_args args;
3892 struct blockdev_setro_state state;
3893 guestfs_main_loop *ml = guestfs_get_main_loop (g);
3896 if (check_state (g, "guestfs_blockdev_setro") == -1) return -1;
3898 memset (&state, 0, sizeof state);
3900 args.device = (char *) device;
3901 serial = guestfs_send (g, GUESTFS_PROC_BLOCKDEV_SETRO,
3902 (xdrproc_t) xdr_guestfs_blockdev_setro_args, (char *) &args);
3907 guestfs_set_reply_callback (g, blockdev_setro_cb, &state);
3908 (void) ml->main_loop_run (ml, g);
3909 guestfs_set_reply_callback (g, NULL, NULL);
3910 if (!state.cb_state) {
3911 error (g, "guestfs_blockdev_setro failed, see earlier error messages");
3915 if (check_reply_header (g, &state.hdr, GUESTFS_PROC_BLOCKDEV_SETRO, serial) == -1)
3918 if (state.hdr.status == GUESTFS_STATUS_ERROR) {
3919 error (g, "%s", state.err.error_message);
3926 struct blockdev_setrw_state {
3928 struct guestfs_message_header hdr;
3929 struct guestfs_message_error err;
3932 static void blockdev_setrw_cb (guestfs_h *g, void *data, XDR *xdr)
3934 guestfs_main_loop *ml = guestfs_get_main_loop (g);
3935 struct blockdev_setrw_state *state = (struct blockdev_setrw_state *) data;
3937 if (!xdr_guestfs_message_header (xdr, &state->hdr)) {
3938 error (g, "guestfs_blockdev_setrw: failed to parse reply header");
3941 if (state->hdr.status == GUESTFS_STATUS_ERROR) {
3942 if (!xdr_guestfs_message_error (xdr, &state->err)) {
3943 error (g, "guestfs_blockdev_setrw: failed to parse reply error");
3949 state->cb_state = 1;
3950 ml->main_loop_quit (ml, g);
3953 int guestfs_blockdev_setrw (guestfs_h *g,
3956 struct guestfs_blockdev_setrw_args args;
3957 struct blockdev_setrw_state state;
3958 guestfs_main_loop *ml = guestfs_get_main_loop (g);
3961 if (check_state (g, "guestfs_blockdev_setrw") == -1) return -1;
3963 memset (&state, 0, sizeof state);
3965 args.device = (char *) device;
3966 serial = guestfs_send (g, GUESTFS_PROC_BLOCKDEV_SETRW,
3967 (xdrproc_t) xdr_guestfs_blockdev_setrw_args, (char *) &args);
3972 guestfs_set_reply_callback (g, blockdev_setrw_cb, &state);
3973 (void) ml->main_loop_run (ml, g);
3974 guestfs_set_reply_callback (g, NULL, NULL);
3975 if (!state.cb_state) {
3976 error (g, "guestfs_blockdev_setrw failed, see earlier error messages");
3980 if (check_reply_header (g, &state.hdr, GUESTFS_PROC_BLOCKDEV_SETRW, serial) == -1)
3983 if (state.hdr.status == GUESTFS_STATUS_ERROR) {
3984 error (g, "%s", state.err.error_message);
3991 struct blockdev_getro_state {
3993 struct guestfs_message_header hdr;
3994 struct guestfs_message_error err;
3995 struct guestfs_blockdev_getro_ret ret;
3998 static void blockdev_getro_cb (guestfs_h *g, void *data, XDR *xdr)
4000 guestfs_main_loop *ml = guestfs_get_main_loop (g);
4001 struct blockdev_getro_state *state = (struct blockdev_getro_state *) data;
4003 if (!xdr_guestfs_message_header (xdr, &state->hdr)) {
4004 error (g, "guestfs_blockdev_getro: failed to parse reply header");
4007 if (state->hdr.status == GUESTFS_STATUS_ERROR) {
4008 if (!xdr_guestfs_message_error (xdr, &state->err)) {
4009 error (g, "guestfs_blockdev_getro: failed to parse reply error");
4014 if (!xdr_guestfs_blockdev_getro_ret (xdr, &state->ret)) {
4015 error (g, "guestfs_blockdev_getro: failed to parse reply");
4019 state->cb_state = 1;
4020 ml->main_loop_quit (ml, g);
4023 int guestfs_blockdev_getro (guestfs_h *g,
4026 struct guestfs_blockdev_getro_args args;
4027 struct blockdev_getro_state state;
4028 guestfs_main_loop *ml = guestfs_get_main_loop (g);
4031 if (check_state (g, "guestfs_blockdev_getro") == -1) return -1;
4033 memset (&state, 0, sizeof state);
4035 args.device = (char *) device;
4036 serial = guestfs_send (g, GUESTFS_PROC_BLOCKDEV_GETRO,
4037 (xdrproc_t) xdr_guestfs_blockdev_getro_args, (char *) &args);
4042 guestfs_set_reply_callback (g, blockdev_getro_cb, &state);
4043 (void) ml->main_loop_run (ml, g);
4044 guestfs_set_reply_callback (g, NULL, NULL);
4045 if (!state.cb_state) {
4046 error (g, "guestfs_blockdev_getro failed, see earlier error messages");
4050 if (check_reply_header (g, &state.hdr, GUESTFS_PROC_BLOCKDEV_GETRO, serial) == -1)
4053 if (state.hdr.status == GUESTFS_STATUS_ERROR) {
4054 error (g, "%s", state.err.error_message);
4058 return state.ret.ro;
4061 struct blockdev_getss_state {
4063 struct guestfs_message_header hdr;
4064 struct guestfs_message_error err;
4065 struct guestfs_blockdev_getss_ret ret;
4068 static void blockdev_getss_cb (guestfs_h *g, void *data, XDR *xdr)
4070 guestfs_main_loop *ml = guestfs_get_main_loop (g);
4071 struct blockdev_getss_state *state = (struct blockdev_getss_state *) data;
4073 if (!xdr_guestfs_message_header (xdr, &state->hdr)) {
4074 error (g, "guestfs_blockdev_getss: failed to parse reply header");
4077 if (state->hdr.status == GUESTFS_STATUS_ERROR) {
4078 if (!xdr_guestfs_message_error (xdr, &state->err)) {
4079 error (g, "guestfs_blockdev_getss: failed to parse reply error");
4084 if (!xdr_guestfs_blockdev_getss_ret (xdr, &state->ret)) {
4085 error (g, "guestfs_blockdev_getss: failed to parse reply");
4089 state->cb_state = 1;
4090 ml->main_loop_quit (ml, g);
4093 int guestfs_blockdev_getss (guestfs_h *g,
4096 struct guestfs_blockdev_getss_args args;
4097 struct blockdev_getss_state state;
4098 guestfs_main_loop *ml = guestfs_get_main_loop (g);
4101 if (check_state (g, "guestfs_blockdev_getss") == -1) return -1;
4103 memset (&state, 0, sizeof state);
4105 args.device = (char *) device;
4106 serial = guestfs_send (g, GUESTFS_PROC_BLOCKDEV_GETSS,
4107 (xdrproc_t) xdr_guestfs_blockdev_getss_args, (char *) &args);
4112 guestfs_set_reply_callback (g, blockdev_getss_cb, &state);
4113 (void) ml->main_loop_run (ml, g);
4114 guestfs_set_reply_callback (g, NULL, NULL);
4115 if (!state.cb_state) {
4116 error (g, "guestfs_blockdev_getss failed, see earlier error messages");
4120 if (check_reply_header (g, &state.hdr, GUESTFS_PROC_BLOCKDEV_GETSS, serial) == -1)
4123 if (state.hdr.status == GUESTFS_STATUS_ERROR) {
4124 error (g, "%s", state.err.error_message);
4128 return state.ret.sectorsize;
4131 struct blockdev_getbsz_state {
4133 struct guestfs_message_header hdr;
4134 struct guestfs_message_error err;
4135 struct guestfs_blockdev_getbsz_ret ret;
4138 static void blockdev_getbsz_cb (guestfs_h *g, void *data, XDR *xdr)
4140 guestfs_main_loop *ml = guestfs_get_main_loop (g);
4141 struct blockdev_getbsz_state *state = (struct blockdev_getbsz_state *) data;
4143 if (!xdr_guestfs_message_header (xdr, &state->hdr)) {
4144 error (g, "guestfs_blockdev_getbsz: failed to parse reply header");
4147 if (state->hdr.status == GUESTFS_STATUS_ERROR) {
4148 if (!xdr_guestfs_message_error (xdr, &state->err)) {
4149 error (g, "guestfs_blockdev_getbsz: failed to parse reply error");
4154 if (!xdr_guestfs_blockdev_getbsz_ret (xdr, &state->ret)) {
4155 error (g, "guestfs_blockdev_getbsz: failed to parse reply");
4159 state->cb_state = 1;
4160 ml->main_loop_quit (ml, g);
4163 int guestfs_blockdev_getbsz (guestfs_h *g,
4166 struct guestfs_blockdev_getbsz_args args;
4167 struct blockdev_getbsz_state state;
4168 guestfs_main_loop *ml = guestfs_get_main_loop (g);
4171 if (check_state (g, "guestfs_blockdev_getbsz") == -1) return -1;
4173 memset (&state, 0, sizeof state);
4175 args.device = (char *) device;
4176 serial = guestfs_send (g, GUESTFS_PROC_BLOCKDEV_GETBSZ,
4177 (xdrproc_t) xdr_guestfs_blockdev_getbsz_args, (char *) &args);
4182 guestfs_set_reply_callback (g, blockdev_getbsz_cb, &state);
4183 (void) ml->main_loop_run (ml, g);
4184 guestfs_set_reply_callback (g, NULL, NULL);
4185 if (!state.cb_state) {
4186 error (g, "guestfs_blockdev_getbsz failed, see earlier error messages");
4190 if (check_reply_header (g, &state.hdr, GUESTFS_PROC_BLOCKDEV_GETBSZ, serial) == -1)
4193 if (state.hdr.status == GUESTFS_STATUS_ERROR) {
4194 error (g, "%s", state.err.error_message);
4198 return state.ret.blocksize;
4201 struct blockdev_setbsz_state {
4203 struct guestfs_message_header hdr;
4204 struct guestfs_message_error err;
4207 static void blockdev_setbsz_cb (guestfs_h *g, void *data, XDR *xdr)
4209 guestfs_main_loop *ml = guestfs_get_main_loop (g);
4210 struct blockdev_setbsz_state *state = (struct blockdev_setbsz_state *) data;
4212 if (!xdr_guestfs_message_header (xdr, &state->hdr)) {
4213 error (g, "guestfs_blockdev_setbsz: failed to parse reply header");
4216 if (state->hdr.status == GUESTFS_STATUS_ERROR) {
4217 if (!xdr_guestfs_message_error (xdr, &state->err)) {
4218 error (g, "guestfs_blockdev_setbsz: failed to parse reply error");
4224 state->cb_state = 1;
4225 ml->main_loop_quit (ml, g);
4228 int guestfs_blockdev_setbsz (guestfs_h *g,
4232 struct guestfs_blockdev_setbsz_args args;
4233 struct blockdev_setbsz_state state;
4234 guestfs_main_loop *ml = guestfs_get_main_loop (g);
4237 if (check_state (g, "guestfs_blockdev_setbsz") == -1) return -1;
4239 memset (&state, 0, sizeof state);
4241 args.device = (char *) device;
4242 args.blocksize = blocksize;
4243 serial = guestfs_send (g, GUESTFS_PROC_BLOCKDEV_SETBSZ,
4244 (xdrproc_t) xdr_guestfs_blockdev_setbsz_args, (char *) &args);
4249 guestfs_set_reply_callback (g, blockdev_setbsz_cb, &state);
4250 (void) ml->main_loop_run (ml, g);
4251 guestfs_set_reply_callback (g, NULL, NULL);
4252 if (!state.cb_state) {
4253 error (g, "guestfs_blockdev_setbsz failed, see earlier error messages");
4257 if (check_reply_header (g, &state.hdr, GUESTFS_PROC_BLOCKDEV_SETBSZ, serial) == -1)
4260 if (state.hdr.status == GUESTFS_STATUS_ERROR) {
4261 error (g, "%s", state.err.error_message);
4268 struct blockdev_getsz_state {
4270 struct guestfs_message_header hdr;
4271 struct guestfs_message_error err;
4272 struct guestfs_blockdev_getsz_ret ret;
4275 static void blockdev_getsz_cb (guestfs_h *g, void *data, XDR *xdr)
4277 guestfs_main_loop *ml = guestfs_get_main_loop (g);
4278 struct blockdev_getsz_state *state = (struct blockdev_getsz_state *) data;
4280 if (!xdr_guestfs_message_header (xdr, &state->hdr)) {
4281 error (g, "guestfs_blockdev_getsz: failed to parse reply header");
4284 if (state->hdr.status == GUESTFS_STATUS_ERROR) {
4285 if (!xdr_guestfs_message_error (xdr, &state->err)) {
4286 error (g, "guestfs_blockdev_getsz: failed to parse reply error");
4291 if (!xdr_guestfs_blockdev_getsz_ret (xdr, &state->ret)) {
4292 error (g, "guestfs_blockdev_getsz: failed to parse reply");
4296 state->cb_state = 1;
4297 ml->main_loop_quit (ml, g);
4300 int64_t guestfs_blockdev_getsz (guestfs_h *g,
4303 struct guestfs_blockdev_getsz_args args;
4304 struct blockdev_getsz_state state;
4305 guestfs_main_loop *ml = guestfs_get_main_loop (g);
4308 if (check_state (g, "guestfs_blockdev_getsz") == -1) return -1;
4310 memset (&state, 0, sizeof state);
4312 args.device = (char *) device;
4313 serial = guestfs_send (g, GUESTFS_PROC_BLOCKDEV_GETSZ,
4314 (xdrproc_t) xdr_guestfs_blockdev_getsz_args, (char *) &args);
4319 guestfs_set_reply_callback (g, blockdev_getsz_cb, &state);
4320 (void) ml->main_loop_run (ml, g);
4321 guestfs_set_reply_callback (g, NULL, NULL);
4322 if (!state.cb_state) {
4323 error (g, "guestfs_blockdev_getsz failed, see earlier error messages");
4327 if (check_reply_header (g, &state.hdr, GUESTFS_PROC_BLOCKDEV_GETSZ, serial) == -1)
4330 if (state.hdr.status == GUESTFS_STATUS_ERROR) {
4331 error (g, "%s", state.err.error_message);
4335 return state.ret.sizeinsectors;
4338 struct blockdev_getsize64_state {
4340 struct guestfs_message_header hdr;
4341 struct guestfs_message_error err;
4342 struct guestfs_blockdev_getsize64_ret ret;
4345 static void blockdev_getsize64_cb (guestfs_h *g, void *data, XDR *xdr)
4347 guestfs_main_loop *ml = guestfs_get_main_loop (g);
4348 struct blockdev_getsize64_state *state = (struct blockdev_getsize64_state *) data;
4350 if (!xdr_guestfs_message_header (xdr, &state->hdr)) {
4351 error (g, "guestfs_blockdev_getsize64: failed to parse reply header");
4354 if (state->hdr.status == GUESTFS_STATUS_ERROR) {
4355 if (!xdr_guestfs_message_error (xdr, &state->err)) {
4356 error (g, "guestfs_blockdev_getsize64: failed to parse reply error");
4361 if (!xdr_guestfs_blockdev_getsize64_ret (xdr, &state->ret)) {
4362 error (g, "guestfs_blockdev_getsize64: failed to parse reply");
4366 state->cb_state = 1;
4367 ml->main_loop_quit (ml, g);
4370 int64_t guestfs_blockdev_getsize64 (guestfs_h *g,
4373 struct guestfs_blockdev_getsize64_args args;
4374 struct blockdev_getsize64_state state;
4375 guestfs_main_loop *ml = guestfs_get_main_loop (g);
4378 if (check_state (g, "guestfs_blockdev_getsize64") == -1) return -1;
4380 memset (&state, 0, sizeof state);
4382 args.device = (char *) device;
4383 serial = guestfs_send (g, GUESTFS_PROC_BLOCKDEV_GETSIZE64,
4384 (xdrproc_t) xdr_guestfs_blockdev_getsize64_args, (char *) &args);
4389 guestfs_set_reply_callback (g, blockdev_getsize64_cb, &state);
4390 (void) ml->main_loop_run (ml, g);
4391 guestfs_set_reply_callback (g, NULL, NULL);
4392 if (!state.cb_state) {
4393 error (g, "guestfs_blockdev_getsize64 failed, see earlier error messages");
4397 if (check_reply_header (g, &state.hdr, GUESTFS_PROC_BLOCKDEV_GETSIZE64, serial) == -1)
4400 if (state.hdr.status == GUESTFS_STATUS_ERROR) {
4401 error (g, "%s", state.err.error_message);
4405 return state.ret.sizeinbytes;
4408 struct blockdev_flushbufs_state {
4410 struct guestfs_message_header hdr;
4411 struct guestfs_message_error err;
4414 static void blockdev_flushbufs_cb (guestfs_h *g, void *data, XDR *xdr)
4416 guestfs_main_loop *ml = guestfs_get_main_loop (g);
4417 struct blockdev_flushbufs_state *state = (struct blockdev_flushbufs_state *) data;
4419 if (!xdr_guestfs_message_header (xdr, &state->hdr)) {
4420 error (g, "guestfs_blockdev_flushbufs: failed to parse reply header");
4423 if (state->hdr.status == GUESTFS_STATUS_ERROR) {
4424 if (!xdr_guestfs_message_error (xdr, &state->err)) {
4425 error (g, "guestfs_blockdev_flushbufs: failed to parse reply error");
4431 state->cb_state = 1;
4432 ml->main_loop_quit (ml, g);
4435 int guestfs_blockdev_flushbufs (guestfs_h *g,
4438 struct guestfs_blockdev_flushbufs_args args;
4439 struct blockdev_flushbufs_state state;
4440 guestfs_main_loop *ml = guestfs_get_main_loop (g);
4443 if (check_state (g, "guestfs_blockdev_flushbufs") == -1) return -1;
4445 memset (&state, 0, sizeof state);
4447 args.device = (char *) device;
4448 serial = guestfs_send (g, GUESTFS_PROC_BLOCKDEV_FLUSHBUFS,
4449 (xdrproc_t) xdr_guestfs_blockdev_flushbufs_args, (char *) &args);
4454 guestfs_set_reply_callback (g, blockdev_flushbufs_cb, &state);
4455 (void) ml->main_loop_run (ml, g);
4456 guestfs_set_reply_callback (g, NULL, NULL);
4457 if (!state.cb_state) {
4458 error (g, "guestfs_blockdev_flushbufs failed, see earlier error messages");
4462 if (check_reply_header (g, &state.hdr, GUESTFS_PROC_BLOCKDEV_FLUSHBUFS, serial) == -1)
4465 if (state.hdr.status == GUESTFS_STATUS_ERROR) {
4466 error (g, "%s", state.err.error_message);
4473 struct blockdev_rereadpt_state {
4475 struct guestfs_message_header hdr;
4476 struct guestfs_message_error err;
4479 static void blockdev_rereadpt_cb (guestfs_h *g, void *data, XDR *xdr)
4481 guestfs_main_loop *ml = guestfs_get_main_loop (g);
4482 struct blockdev_rereadpt_state *state = (struct blockdev_rereadpt_state *) data;
4484 if (!xdr_guestfs_message_header (xdr, &state->hdr)) {
4485 error (g, "guestfs_blockdev_rereadpt: failed to parse reply header");
4488 if (state->hdr.status == GUESTFS_STATUS_ERROR) {
4489 if (!xdr_guestfs_message_error (xdr, &state->err)) {
4490 error (g, "guestfs_blockdev_rereadpt: failed to parse reply error");
4496 state->cb_state = 1;
4497 ml->main_loop_quit (ml, g);
4500 int guestfs_blockdev_rereadpt (guestfs_h *g,
4503 struct guestfs_blockdev_rereadpt_args args;
4504 struct blockdev_rereadpt_state state;
4505 guestfs_main_loop *ml = guestfs_get_main_loop (g);
4508 if (check_state (g, "guestfs_blockdev_rereadpt") == -1) return -1;
4510 memset (&state, 0, sizeof state);
4512 args.device = (char *) device;
4513 serial = guestfs_send (g, GUESTFS_PROC_BLOCKDEV_REREADPT,
4514 (xdrproc_t) xdr_guestfs_blockdev_rereadpt_args, (char *) &args);
4519 guestfs_set_reply_callback (g, blockdev_rereadpt_cb, &state);
4520 (void) ml->main_loop_run (ml, g);
4521 guestfs_set_reply_callback (g, NULL, NULL);
4522 if (!state.cb_state) {
4523 error (g, "guestfs_blockdev_rereadpt failed, see earlier error messages");
4527 if (check_reply_header (g, &state.hdr, GUESTFS_PROC_BLOCKDEV_REREADPT, serial) == -1)
4530 if (state.hdr.status == GUESTFS_STATUS_ERROR) {
4531 error (g, "%s", state.err.error_message);