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
23 int cb_done; /* flag to indicate callback was called */
24 struct guestfs_message_header hdr;
25 struct guestfs_message_error err;
28 static void mount_cb (guestfs_h *g, void *data, XDR *xdr)
30 struct mount_rv *rv = (struct mount_rv *) data;
32 if (!xdr_guestfs_message_header (xdr, &rv->hdr)) {
33 error (g, "guestfs_mount: failed to parse reply header");
36 if (rv->hdr.status == GUESTFS_STATUS_ERROR) {
37 if (!xdr_guestfs_message_error (xdr, &rv->err)) {
38 error (g, "guestfs_mount: failed to parse reply error");
45 main_loop.main_loop_quit (g);
48 int guestfs_mount (guestfs_h *g,
50 const char *mountpoint)
52 struct guestfs_mount_args args;
56 if (g->state != READY) {
57 error (g, "guestfs_mount called from the wrong state, %d != READY",
62 memset (&rv, 0, sizeof rv);
64 args.device = (char *) device;
65 args.mountpoint = (char *) mountpoint;
66 serial = dispatch (g, GUESTFS_PROC_MOUNT,
67 (xdrproc_t) xdr_guestfs_mount_args, (char *) &args);
72 g->reply_cb_internal = mount_cb;
73 g->reply_cb_internal_data = &rv;
74 main_loop.main_loop_run (g);
75 g->reply_cb_internal = NULL;
76 g->reply_cb_internal_data = NULL;
78 error (g, "guestfs_mount failed, see earlier error messages");
82 if (check_reply_header (g, &rv.hdr, GUESTFS_PROC_MOUNT, serial) == -1)
85 if (rv.hdr.status == GUESTFS_STATUS_ERROR) {
86 error (g, "%s", rv.err.error);
94 int cb_done; /* flag to indicate callback was called */
95 struct guestfs_message_header hdr;
96 struct guestfs_message_error err;
99 static void sync_cb (guestfs_h *g, void *data, XDR *xdr)
101 struct sync_rv *rv = (struct sync_rv *) data;
103 if (!xdr_guestfs_message_header (xdr, &rv->hdr)) {
104 error (g, "guestfs_sync: failed to parse reply header");
107 if (rv->hdr.status == GUESTFS_STATUS_ERROR) {
108 if (!xdr_guestfs_message_error (xdr, &rv->err)) {
109 error (g, "guestfs_sync: failed to parse reply error");
116 main_loop.main_loop_quit (g);
119 int guestfs_sync (guestfs_h *g)
124 if (g->state != READY) {
125 error (g, "guestfs_sync called from the wrong state, %d != READY",
130 memset (&rv, 0, sizeof rv);
132 serial = dispatch (g, GUESTFS_PROC_SYNC, NULL, NULL);
137 g->reply_cb_internal = sync_cb;
138 g->reply_cb_internal_data = &rv;
139 main_loop.main_loop_run (g);
140 g->reply_cb_internal = NULL;
141 g->reply_cb_internal_data = NULL;
143 error (g, "guestfs_sync failed, see earlier error messages");
147 if (check_reply_header (g, &rv.hdr, GUESTFS_PROC_SYNC, serial) == -1)
150 if (rv.hdr.status == GUESTFS_STATUS_ERROR) {
151 error (g, "%s", rv.err.error);
159 int cb_done; /* flag to indicate callback was called */
160 struct guestfs_message_header hdr;
161 struct guestfs_message_error err;
164 static void touch_cb (guestfs_h *g, void *data, XDR *xdr)
166 struct touch_rv *rv = (struct touch_rv *) data;
168 if (!xdr_guestfs_message_header (xdr, &rv->hdr)) {
169 error (g, "guestfs_touch: failed to parse reply header");
172 if (rv->hdr.status == GUESTFS_STATUS_ERROR) {
173 if (!xdr_guestfs_message_error (xdr, &rv->err)) {
174 error (g, "guestfs_touch: failed to parse reply error");
181 main_loop.main_loop_quit (g);
184 int guestfs_touch (guestfs_h *g,
187 struct guestfs_touch_args args;
191 if (g->state != READY) {
192 error (g, "guestfs_touch called from the wrong state, %d != READY",
197 memset (&rv, 0, sizeof rv);
199 args.path = (char *) path;
200 serial = dispatch (g, GUESTFS_PROC_TOUCH,
201 (xdrproc_t) xdr_guestfs_touch_args, (char *) &args);
206 g->reply_cb_internal = touch_cb;
207 g->reply_cb_internal_data = &rv;
208 main_loop.main_loop_run (g);
209 g->reply_cb_internal = NULL;
210 g->reply_cb_internal_data = NULL;
212 error (g, "guestfs_touch failed, see earlier error messages");
216 if (check_reply_header (g, &rv.hdr, GUESTFS_PROC_TOUCH, serial) == -1)
219 if (rv.hdr.status == GUESTFS_STATUS_ERROR) {
220 error (g, "%s", rv.err.error);
228 int cb_done; /* flag to indicate callback was called */
229 struct guestfs_message_header hdr;
230 struct guestfs_message_error err;
231 struct guestfs_cat_ret ret;
234 static void cat_cb (guestfs_h *g, void *data, XDR *xdr)
236 struct cat_rv *rv = (struct cat_rv *) data;
238 if (!xdr_guestfs_message_header (xdr, &rv->hdr)) {
239 error (g, "guestfs_cat: failed to parse reply header");
242 if (rv->hdr.status == GUESTFS_STATUS_ERROR) {
243 if (!xdr_guestfs_message_error (xdr, &rv->err)) {
244 error (g, "guestfs_cat: failed to parse reply error");
249 if (!xdr_guestfs_cat_ret (xdr, &rv->ret)) {
250 error (g, "guestfs_cat: failed to parse reply");
255 main_loop.main_loop_quit (g);
258 char *guestfs_cat (guestfs_h *g,
261 struct guestfs_cat_args args;
265 if (g->state != READY) {
266 error (g, "guestfs_cat called from the wrong state, %d != READY",
271 memset (&rv, 0, sizeof rv);
273 args.path = (char *) path;
274 serial = dispatch (g, GUESTFS_PROC_CAT,
275 (xdrproc_t) xdr_guestfs_cat_args, (char *) &args);
280 g->reply_cb_internal = cat_cb;
281 g->reply_cb_internal_data = &rv;
282 main_loop.main_loop_run (g);
283 g->reply_cb_internal = NULL;
284 g->reply_cb_internal_data = NULL;
286 error (g, "guestfs_cat failed, see earlier error messages");
290 if (check_reply_header (g, &rv.hdr, GUESTFS_PROC_CAT, serial) == -1)
293 if (rv.hdr.status == GUESTFS_STATUS_ERROR) {
294 error (g, "%s", rv.err.error);
298 return rv.ret.content; /* caller will free */
302 int cb_done; /* flag to indicate callback was called */
303 struct guestfs_message_header hdr;
304 struct guestfs_message_error err;
305 struct guestfs_ll_ret ret;
308 static void ll_cb (guestfs_h *g, void *data, XDR *xdr)
310 struct ll_rv *rv = (struct ll_rv *) data;
312 if (!xdr_guestfs_message_header (xdr, &rv->hdr)) {
313 error (g, "guestfs_ll: failed to parse reply header");
316 if (rv->hdr.status == GUESTFS_STATUS_ERROR) {
317 if (!xdr_guestfs_message_error (xdr, &rv->err)) {
318 error (g, "guestfs_ll: failed to parse reply error");
323 if (!xdr_guestfs_ll_ret (xdr, &rv->ret)) {
324 error (g, "guestfs_ll: failed to parse reply");
329 main_loop.main_loop_quit (g);
332 char *guestfs_ll (guestfs_h *g,
333 const char *directory)
335 struct guestfs_ll_args args;
339 if (g->state != READY) {
340 error (g, "guestfs_ll called from the wrong state, %d != READY",
345 memset (&rv, 0, sizeof rv);
347 args.directory = (char *) directory;
348 serial = dispatch (g, GUESTFS_PROC_LL,
349 (xdrproc_t) xdr_guestfs_ll_args, (char *) &args);
354 g->reply_cb_internal = ll_cb;
355 g->reply_cb_internal_data = &rv;
356 main_loop.main_loop_run (g);
357 g->reply_cb_internal = NULL;
358 g->reply_cb_internal_data = NULL;
360 error (g, "guestfs_ll failed, see earlier error messages");
364 if (check_reply_header (g, &rv.hdr, GUESTFS_PROC_LL, serial) == -1)
367 if (rv.hdr.status == GUESTFS_STATUS_ERROR) {
368 error (g, "%s", rv.err.error);
372 return rv.ret.listing; /* caller will free */
376 int cb_done; /* flag to indicate callback was called */
377 struct guestfs_message_header hdr;
378 struct guestfs_message_error err;
379 struct guestfs_ls_ret ret;
382 static void ls_cb (guestfs_h *g, void *data, XDR *xdr)
384 struct ls_rv *rv = (struct ls_rv *) data;
386 if (!xdr_guestfs_message_header (xdr, &rv->hdr)) {
387 error (g, "guestfs_ls: failed to parse reply header");
390 if (rv->hdr.status == GUESTFS_STATUS_ERROR) {
391 if (!xdr_guestfs_message_error (xdr, &rv->err)) {
392 error (g, "guestfs_ls: failed to parse reply error");
397 if (!xdr_guestfs_ls_ret (xdr, &rv->ret)) {
398 error (g, "guestfs_ls: failed to parse reply");
403 main_loop.main_loop_quit (g);
406 char **guestfs_ls (guestfs_h *g,
407 const char *directory)
409 struct guestfs_ls_args args;
413 if (g->state != READY) {
414 error (g, "guestfs_ls called from the wrong state, %d != READY",
419 memset (&rv, 0, sizeof rv);
421 args.directory = (char *) directory;
422 serial = dispatch (g, GUESTFS_PROC_LS,
423 (xdrproc_t) xdr_guestfs_ls_args, (char *) &args);
428 g->reply_cb_internal = ls_cb;
429 g->reply_cb_internal_data = &rv;
430 main_loop.main_loop_run (g);
431 g->reply_cb_internal = NULL;
432 g->reply_cb_internal_data = NULL;
434 error (g, "guestfs_ls failed, see earlier error messages");
438 if (check_reply_header (g, &rv.hdr, GUESTFS_PROC_LS, serial) == -1)
441 if (rv.hdr.status == GUESTFS_STATUS_ERROR) {
442 error (g, "%s", rv.err.error);
446 /* caller will free this, but we need to add a NULL entry */
447 rv.ret.listing.listing_val = safe_realloc (g, rv.ret.listing.listing_val,
448 sizeof (char *) * (rv.ret.listing.listing_len + 1));
449 rv.ret.listing.listing_val[rv.ret.listing.listing_len] = NULL;
450 return rv.ret.listing.listing_val;
453 struct list_devices_rv {
454 int cb_done; /* flag to indicate callback was called */
455 struct guestfs_message_header hdr;
456 struct guestfs_message_error err;
457 struct guestfs_list_devices_ret ret;
460 static void list_devices_cb (guestfs_h *g, void *data, XDR *xdr)
462 struct list_devices_rv *rv = (struct list_devices_rv *) data;
464 if (!xdr_guestfs_message_header (xdr, &rv->hdr)) {
465 error (g, "guestfs_list_devices: failed to parse reply header");
468 if (rv->hdr.status == GUESTFS_STATUS_ERROR) {
469 if (!xdr_guestfs_message_error (xdr, &rv->err)) {
470 error (g, "guestfs_list_devices: failed to parse reply error");
475 if (!xdr_guestfs_list_devices_ret (xdr, &rv->ret)) {
476 error (g, "guestfs_list_devices: failed to parse reply");
481 main_loop.main_loop_quit (g);
484 char **guestfs_list_devices (guestfs_h *g)
486 struct list_devices_rv rv;
489 if (g->state != READY) {
490 error (g, "guestfs_list_devices called from the wrong state, %d != READY",
495 memset (&rv, 0, sizeof rv);
497 serial = dispatch (g, GUESTFS_PROC_LIST_DEVICES, NULL, NULL);
502 g->reply_cb_internal = list_devices_cb;
503 g->reply_cb_internal_data = &rv;
504 main_loop.main_loop_run (g);
505 g->reply_cb_internal = NULL;
506 g->reply_cb_internal_data = NULL;
508 error (g, "guestfs_list_devices failed, see earlier error messages");
512 if (check_reply_header (g, &rv.hdr, GUESTFS_PROC_LIST_DEVICES, serial) == -1)
515 if (rv.hdr.status == GUESTFS_STATUS_ERROR) {
516 error (g, "%s", rv.err.error);
520 /* caller will free this, but we need to add a NULL entry */
521 rv.ret.devices.devices_val = safe_realloc (g, rv.ret.devices.devices_val,
522 sizeof (char *) * (rv.ret.devices.devices_len + 1));
523 rv.ret.devices.devices_val[rv.ret.devices.devices_len] = NULL;
524 return rv.ret.devices.devices_val;
527 struct list_partitions_rv {
528 int cb_done; /* flag to indicate callback was called */
529 struct guestfs_message_header hdr;
530 struct guestfs_message_error err;
531 struct guestfs_list_partitions_ret ret;
534 static void list_partitions_cb (guestfs_h *g, void *data, XDR *xdr)
536 struct list_partitions_rv *rv = (struct list_partitions_rv *) data;
538 if (!xdr_guestfs_message_header (xdr, &rv->hdr)) {
539 error (g, "guestfs_list_partitions: failed to parse reply header");
542 if (rv->hdr.status == GUESTFS_STATUS_ERROR) {
543 if (!xdr_guestfs_message_error (xdr, &rv->err)) {
544 error (g, "guestfs_list_partitions: failed to parse reply error");
549 if (!xdr_guestfs_list_partitions_ret (xdr, &rv->ret)) {
550 error (g, "guestfs_list_partitions: failed to parse reply");
555 main_loop.main_loop_quit (g);
558 char **guestfs_list_partitions (guestfs_h *g)
560 struct list_partitions_rv rv;
563 if (g->state != READY) {
564 error (g, "guestfs_list_partitions called from the wrong state, %d != READY",
569 memset (&rv, 0, sizeof rv);
571 serial = dispatch (g, GUESTFS_PROC_LIST_PARTITIONS, NULL, NULL);
576 g->reply_cb_internal = list_partitions_cb;
577 g->reply_cb_internal_data = &rv;
578 main_loop.main_loop_run (g);
579 g->reply_cb_internal = NULL;
580 g->reply_cb_internal_data = NULL;
582 error (g, "guestfs_list_partitions failed, see earlier error messages");
586 if (check_reply_header (g, &rv.hdr, GUESTFS_PROC_LIST_PARTITIONS, serial) == -1)
589 if (rv.hdr.status == GUESTFS_STATUS_ERROR) {
590 error (g, "%s", rv.err.error);
594 /* caller will free this, but we need to add a NULL entry */
595 rv.ret.partitions.partitions_val = safe_realloc (g, rv.ret.partitions.partitions_val,
596 sizeof (char *) * (rv.ret.partitions.partitions_len + 1));
597 rv.ret.partitions.partitions_val[rv.ret.partitions.partitions_len] = NULL;
598 return rv.ret.partitions.partitions_val;
602 int cb_done; /* flag to indicate callback was called */
603 struct guestfs_message_header hdr;
604 struct guestfs_message_error err;
605 struct guestfs_pvs_ret ret;
608 static void pvs_cb (guestfs_h *g, void *data, XDR *xdr)
610 struct pvs_rv *rv = (struct pvs_rv *) data;
612 if (!xdr_guestfs_message_header (xdr, &rv->hdr)) {
613 error (g, "guestfs_pvs: failed to parse reply header");
616 if (rv->hdr.status == GUESTFS_STATUS_ERROR) {
617 if (!xdr_guestfs_message_error (xdr, &rv->err)) {
618 error (g, "guestfs_pvs: failed to parse reply error");
623 if (!xdr_guestfs_pvs_ret (xdr, &rv->ret)) {
624 error (g, "guestfs_pvs: failed to parse reply");
629 main_loop.main_loop_quit (g);
632 char **guestfs_pvs (guestfs_h *g)
637 if (g->state != READY) {
638 error (g, "guestfs_pvs called from the wrong state, %d != READY",
643 memset (&rv, 0, sizeof rv);
645 serial = dispatch (g, GUESTFS_PROC_PVS, NULL, NULL);
650 g->reply_cb_internal = pvs_cb;
651 g->reply_cb_internal_data = &rv;
652 main_loop.main_loop_run (g);
653 g->reply_cb_internal = NULL;
654 g->reply_cb_internal_data = NULL;
656 error (g, "guestfs_pvs failed, see earlier error messages");
660 if (check_reply_header (g, &rv.hdr, GUESTFS_PROC_PVS, serial) == -1)
663 if (rv.hdr.status == GUESTFS_STATUS_ERROR) {
664 error (g, "%s", rv.err.error);
668 /* caller will free this, but we need to add a NULL entry */
669 rv.ret.physvols.physvols_val = safe_realloc (g, rv.ret.physvols.physvols_val,
670 sizeof (char *) * (rv.ret.physvols.physvols_len + 1));
671 rv.ret.physvols.physvols_val[rv.ret.physvols.physvols_len] = NULL;
672 return rv.ret.physvols.physvols_val;
676 int cb_done; /* flag to indicate callback was called */
677 struct guestfs_message_header hdr;
678 struct guestfs_message_error err;
679 struct guestfs_vgs_ret ret;
682 static void vgs_cb (guestfs_h *g, void *data, XDR *xdr)
684 struct vgs_rv *rv = (struct vgs_rv *) data;
686 if (!xdr_guestfs_message_header (xdr, &rv->hdr)) {
687 error (g, "guestfs_vgs: failed to parse reply header");
690 if (rv->hdr.status == GUESTFS_STATUS_ERROR) {
691 if (!xdr_guestfs_message_error (xdr, &rv->err)) {
692 error (g, "guestfs_vgs: failed to parse reply error");
697 if (!xdr_guestfs_vgs_ret (xdr, &rv->ret)) {
698 error (g, "guestfs_vgs: failed to parse reply");
703 main_loop.main_loop_quit (g);
706 char **guestfs_vgs (guestfs_h *g)
711 if (g->state != READY) {
712 error (g, "guestfs_vgs called from the wrong state, %d != READY",
717 memset (&rv, 0, sizeof rv);
719 serial = dispatch (g, GUESTFS_PROC_VGS, NULL, NULL);
724 g->reply_cb_internal = vgs_cb;
725 g->reply_cb_internal_data = &rv;
726 main_loop.main_loop_run (g);
727 g->reply_cb_internal = NULL;
728 g->reply_cb_internal_data = NULL;
730 error (g, "guestfs_vgs failed, see earlier error messages");
734 if (check_reply_header (g, &rv.hdr, GUESTFS_PROC_VGS, serial) == -1)
737 if (rv.hdr.status == GUESTFS_STATUS_ERROR) {
738 error (g, "%s", rv.err.error);
742 /* caller will free this, but we need to add a NULL entry */
743 rv.ret.volgroups.volgroups_val = safe_realloc (g, rv.ret.volgroups.volgroups_val,
744 sizeof (char *) * (rv.ret.volgroups.volgroups_len + 1));
745 rv.ret.volgroups.volgroups_val[rv.ret.volgroups.volgroups_len] = NULL;
746 return rv.ret.volgroups.volgroups_val;
750 int cb_done; /* flag to indicate callback was called */
751 struct guestfs_message_header hdr;
752 struct guestfs_message_error err;
753 struct guestfs_lvs_ret ret;
756 static void lvs_cb (guestfs_h *g, void *data, XDR *xdr)
758 struct lvs_rv *rv = (struct lvs_rv *) data;
760 if (!xdr_guestfs_message_header (xdr, &rv->hdr)) {
761 error (g, "guestfs_lvs: failed to parse reply header");
764 if (rv->hdr.status == GUESTFS_STATUS_ERROR) {
765 if (!xdr_guestfs_message_error (xdr, &rv->err)) {
766 error (g, "guestfs_lvs: failed to parse reply error");
771 if (!xdr_guestfs_lvs_ret (xdr, &rv->ret)) {
772 error (g, "guestfs_lvs: failed to parse reply");
777 main_loop.main_loop_quit (g);
780 char **guestfs_lvs (guestfs_h *g)
785 if (g->state != READY) {
786 error (g, "guestfs_lvs called from the wrong state, %d != READY",
791 memset (&rv, 0, sizeof rv);
793 serial = dispatch (g, GUESTFS_PROC_LVS, NULL, NULL);
798 g->reply_cb_internal = lvs_cb;
799 g->reply_cb_internal_data = &rv;
800 main_loop.main_loop_run (g);
801 g->reply_cb_internal = NULL;
802 g->reply_cb_internal_data = NULL;
804 error (g, "guestfs_lvs failed, see earlier error messages");
808 if (check_reply_header (g, &rv.hdr, GUESTFS_PROC_LVS, serial) == -1)
811 if (rv.hdr.status == GUESTFS_STATUS_ERROR) {
812 error (g, "%s", rv.err.error);
816 /* caller will free this, but we need to add a NULL entry */
817 rv.ret.logvols.logvols_val = safe_realloc (g, rv.ret.logvols.logvols_val,
818 sizeof (char *) * (rv.ret.logvols.logvols_len + 1));
819 rv.ret.logvols.logvols_val[rv.ret.logvols.logvols_len] = NULL;
820 return rv.ret.logvols.logvols_val;
824 int cb_done; /* flag to indicate callback was called */
825 struct guestfs_message_header hdr;
826 struct guestfs_message_error err;
827 struct guestfs_pvs_full_ret ret;
830 static void pvs_full_cb (guestfs_h *g, void *data, XDR *xdr)
832 struct pvs_full_rv *rv = (struct pvs_full_rv *) data;
834 if (!xdr_guestfs_message_header (xdr, &rv->hdr)) {
835 error (g, "guestfs_pvs_full: failed to parse reply header");
838 if (rv->hdr.status == GUESTFS_STATUS_ERROR) {
839 if (!xdr_guestfs_message_error (xdr, &rv->err)) {
840 error (g, "guestfs_pvs_full: failed to parse reply error");
845 if (!xdr_guestfs_pvs_full_ret (xdr, &rv->ret)) {
846 error (g, "guestfs_pvs_full: failed to parse reply");
851 main_loop.main_loop_quit (g);
854 struct guestfs_lvm_pv_list *guestfs_pvs_full (guestfs_h *g)
856 struct pvs_full_rv rv;
859 if (g->state != READY) {
860 error (g, "guestfs_pvs_full called from the wrong state, %d != READY",
865 memset (&rv, 0, sizeof rv);
867 serial = dispatch (g, GUESTFS_PROC_PVS_FULL, NULL, NULL);
872 g->reply_cb_internal = pvs_full_cb;
873 g->reply_cb_internal_data = &rv;
874 main_loop.main_loop_run (g);
875 g->reply_cb_internal = NULL;
876 g->reply_cb_internal_data = NULL;
878 error (g, "guestfs_pvs_full failed, see earlier error messages");
882 if (check_reply_header (g, &rv.hdr, GUESTFS_PROC_PVS_FULL, serial) == -1)
885 if (rv.hdr.status == GUESTFS_STATUS_ERROR) {
886 error (g, "%s", rv.err.error);
890 /* caller will free this */
891 return safe_memdup (g, &rv.ret.physvols, sizeof (rv.ret.physvols));
895 int cb_done; /* flag to indicate callback was called */
896 struct guestfs_message_header hdr;
897 struct guestfs_message_error err;
898 struct guestfs_vgs_full_ret ret;
901 static void vgs_full_cb (guestfs_h *g, void *data, XDR *xdr)
903 struct vgs_full_rv *rv = (struct vgs_full_rv *) data;
905 if (!xdr_guestfs_message_header (xdr, &rv->hdr)) {
906 error (g, "guestfs_vgs_full: failed to parse reply header");
909 if (rv->hdr.status == GUESTFS_STATUS_ERROR) {
910 if (!xdr_guestfs_message_error (xdr, &rv->err)) {
911 error (g, "guestfs_vgs_full: failed to parse reply error");
916 if (!xdr_guestfs_vgs_full_ret (xdr, &rv->ret)) {
917 error (g, "guestfs_vgs_full: failed to parse reply");
922 main_loop.main_loop_quit (g);
925 struct guestfs_lvm_vg_list *guestfs_vgs_full (guestfs_h *g)
927 struct vgs_full_rv rv;
930 if (g->state != READY) {
931 error (g, "guestfs_vgs_full called from the wrong state, %d != READY",
936 memset (&rv, 0, sizeof rv);
938 serial = dispatch (g, GUESTFS_PROC_VGS_FULL, NULL, NULL);
943 g->reply_cb_internal = vgs_full_cb;
944 g->reply_cb_internal_data = &rv;
945 main_loop.main_loop_run (g);
946 g->reply_cb_internal = NULL;
947 g->reply_cb_internal_data = NULL;
949 error (g, "guestfs_vgs_full failed, see earlier error messages");
953 if (check_reply_header (g, &rv.hdr, GUESTFS_PROC_VGS_FULL, serial) == -1)
956 if (rv.hdr.status == GUESTFS_STATUS_ERROR) {
957 error (g, "%s", rv.err.error);
961 /* caller will free this */
962 return safe_memdup (g, &rv.ret.volgroups, sizeof (rv.ret.volgroups));
966 int cb_done; /* flag to indicate callback was called */
967 struct guestfs_message_header hdr;
968 struct guestfs_message_error err;
969 struct guestfs_lvs_full_ret ret;
972 static void lvs_full_cb (guestfs_h *g, void *data, XDR *xdr)
974 struct lvs_full_rv *rv = (struct lvs_full_rv *) data;
976 if (!xdr_guestfs_message_header (xdr, &rv->hdr)) {
977 error (g, "guestfs_lvs_full: failed to parse reply header");
980 if (rv->hdr.status == GUESTFS_STATUS_ERROR) {
981 if (!xdr_guestfs_message_error (xdr, &rv->err)) {
982 error (g, "guestfs_lvs_full: failed to parse reply error");
987 if (!xdr_guestfs_lvs_full_ret (xdr, &rv->ret)) {
988 error (g, "guestfs_lvs_full: failed to parse reply");
993 main_loop.main_loop_quit (g);
996 struct guestfs_lvm_lv_list *guestfs_lvs_full (guestfs_h *g)
998 struct lvs_full_rv rv;
1001 if (g->state != READY) {
1002 error (g, "guestfs_lvs_full called from the wrong state, %d != READY",
1007 memset (&rv, 0, sizeof rv);
1009 serial = dispatch (g, GUESTFS_PROC_LVS_FULL, NULL, NULL);
1014 g->reply_cb_internal = lvs_full_cb;
1015 g->reply_cb_internal_data = &rv;
1016 main_loop.main_loop_run (g);
1017 g->reply_cb_internal = NULL;
1018 g->reply_cb_internal_data = NULL;
1020 error (g, "guestfs_lvs_full failed, see earlier error messages");
1024 if (check_reply_header (g, &rv.hdr, GUESTFS_PROC_LVS_FULL, serial) == -1)
1027 if (rv.hdr.status == GUESTFS_STATUS_ERROR) {
1028 error (g, "%s", rv.err.error);
1032 /* caller will free this */
1033 return safe_memdup (g, &rv.ret.logvols, sizeof (rv.ret.logvols));
1036 struct read_lines_rv {
1037 int cb_done; /* flag to indicate callback was called */
1038 struct guestfs_message_header hdr;
1039 struct guestfs_message_error err;
1040 struct guestfs_read_lines_ret ret;
1043 static void read_lines_cb (guestfs_h *g, void *data, XDR *xdr)
1045 struct read_lines_rv *rv = (struct read_lines_rv *) data;
1047 if (!xdr_guestfs_message_header (xdr, &rv->hdr)) {
1048 error (g, "guestfs_read_lines: failed to parse reply header");
1051 if (rv->hdr.status == GUESTFS_STATUS_ERROR) {
1052 if (!xdr_guestfs_message_error (xdr, &rv->err)) {
1053 error (g, "guestfs_read_lines: failed to parse reply error");
1058 if (!xdr_guestfs_read_lines_ret (xdr, &rv->ret)) {
1059 error (g, "guestfs_read_lines: failed to parse reply");
1064 main_loop.main_loop_quit (g);
1067 char **guestfs_read_lines (guestfs_h *g,
1070 struct guestfs_read_lines_args args;
1071 struct read_lines_rv rv;
1074 if (g->state != READY) {
1075 error (g, "guestfs_read_lines called from the wrong state, %d != READY",
1080 memset (&rv, 0, sizeof rv);
1082 args.path = (char *) path;
1083 serial = dispatch (g, GUESTFS_PROC_READ_LINES,
1084 (xdrproc_t) xdr_guestfs_read_lines_args, (char *) &args);
1089 g->reply_cb_internal = read_lines_cb;
1090 g->reply_cb_internal_data = &rv;
1091 main_loop.main_loop_run (g);
1092 g->reply_cb_internal = NULL;
1093 g->reply_cb_internal_data = NULL;
1095 error (g, "guestfs_read_lines failed, see earlier error messages");
1099 if (check_reply_header (g, &rv.hdr, GUESTFS_PROC_READ_LINES, serial) == -1)
1102 if (rv.hdr.status == GUESTFS_STATUS_ERROR) {
1103 error (g, "%s", rv.err.error);
1107 /* caller will free this, but we need to add a NULL entry */
1108 rv.ret.lines.lines_val = safe_realloc (g, rv.ret.lines.lines_val,
1109 sizeof (char *) * (rv.ret.lines.lines_len + 1));
1110 rv.ret.lines.lines_val[rv.ret.lines.lines_len] = NULL;
1111 return rv.ret.lines.lines_val;