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;
1114 struct aug_init_rv {
1115 int cb_done; /* flag to indicate callback was called */
1116 struct guestfs_message_header hdr;
1117 struct guestfs_message_error err;
1120 static void aug_init_cb (guestfs_h *g, void *data, XDR *xdr)
1122 struct aug_init_rv *rv = (struct aug_init_rv *) data;
1124 if (!xdr_guestfs_message_header (xdr, &rv->hdr)) {
1125 error (g, "guestfs_aug_init: failed to parse reply header");
1128 if (rv->hdr.status == GUESTFS_STATUS_ERROR) {
1129 if (!xdr_guestfs_message_error (xdr, &rv->err)) {
1130 error (g, "guestfs_aug_init: failed to parse reply error");
1137 main_loop.main_loop_quit (g);
1140 int guestfs_aug_init (guestfs_h *g,
1144 struct guestfs_aug_init_args args;
1145 struct aug_init_rv rv;
1148 if (g->state != READY) {
1149 error (g, "guestfs_aug_init called from the wrong state, %d != READY",
1154 memset (&rv, 0, sizeof rv);
1156 args.root = (char *) root;
1158 serial = dispatch (g, GUESTFS_PROC_AUG_INIT,
1159 (xdrproc_t) xdr_guestfs_aug_init_args, (char *) &args);
1164 g->reply_cb_internal = aug_init_cb;
1165 g->reply_cb_internal_data = &rv;
1166 main_loop.main_loop_run (g);
1167 g->reply_cb_internal = NULL;
1168 g->reply_cb_internal_data = NULL;
1170 error (g, "guestfs_aug_init failed, see earlier error messages");
1174 if (check_reply_header (g, &rv.hdr, GUESTFS_PROC_AUG_INIT, serial) == -1)
1177 if (rv.hdr.status == GUESTFS_STATUS_ERROR) {
1178 error (g, "%s", rv.err.error);
1185 struct aug_close_rv {
1186 int cb_done; /* flag to indicate callback was called */
1187 struct guestfs_message_header hdr;
1188 struct guestfs_message_error err;
1191 static void aug_close_cb (guestfs_h *g, void *data, XDR *xdr)
1193 struct aug_close_rv *rv = (struct aug_close_rv *) data;
1195 if (!xdr_guestfs_message_header (xdr, &rv->hdr)) {
1196 error (g, "guestfs_aug_close: failed to parse reply header");
1199 if (rv->hdr.status == GUESTFS_STATUS_ERROR) {
1200 if (!xdr_guestfs_message_error (xdr, &rv->err)) {
1201 error (g, "guestfs_aug_close: failed to parse reply error");
1208 main_loop.main_loop_quit (g);
1211 int guestfs_aug_close (guestfs_h *g)
1213 struct aug_close_rv rv;
1216 if (g->state != READY) {
1217 error (g, "guestfs_aug_close called from the wrong state, %d != READY",
1222 memset (&rv, 0, sizeof rv);
1224 serial = dispatch (g, GUESTFS_PROC_AUG_CLOSE, NULL, NULL);
1229 g->reply_cb_internal = aug_close_cb;
1230 g->reply_cb_internal_data = &rv;
1231 main_loop.main_loop_run (g);
1232 g->reply_cb_internal = NULL;
1233 g->reply_cb_internal_data = NULL;
1235 error (g, "guestfs_aug_close failed, see earlier error messages");
1239 if (check_reply_header (g, &rv.hdr, GUESTFS_PROC_AUG_CLOSE, serial) == -1)
1242 if (rv.hdr.status == GUESTFS_STATUS_ERROR) {
1243 error (g, "%s", rv.err.error);
1250 struct aug_defvar_rv {
1251 int cb_done; /* flag to indicate callback was called */
1252 struct guestfs_message_header hdr;
1253 struct guestfs_message_error err;
1254 struct guestfs_aug_defvar_ret ret;
1257 static void aug_defvar_cb (guestfs_h *g, void *data, XDR *xdr)
1259 struct aug_defvar_rv *rv = (struct aug_defvar_rv *) data;
1261 if (!xdr_guestfs_message_header (xdr, &rv->hdr)) {
1262 error (g, "guestfs_aug_defvar: failed to parse reply header");
1265 if (rv->hdr.status == GUESTFS_STATUS_ERROR) {
1266 if (!xdr_guestfs_message_error (xdr, &rv->err)) {
1267 error (g, "guestfs_aug_defvar: failed to parse reply error");
1272 if (!xdr_guestfs_aug_defvar_ret (xdr, &rv->ret)) {
1273 error (g, "guestfs_aug_defvar: failed to parse reply");
1278 main_loop.main_loop_quit (g);
1281 int guestfs_aug_defvar (guestfs_h *g,
1285 struct guestfs_aug_defvar_args args;
1286 struct aug_defvar_rv rv;
1289 if (g->state != READY) {
1290 error (g, "guestfs_aug_defvar called from the wrong state, %d != READY",
1295 memset (&rv, 0, sizeof rv);
1297 args.name = (char *) name;
1298 args.expr = expr ? (char **) &expr : NULL;
1299 serial = dispatch (g, GUESTFS_PROC_AUG_DEFVAR,
1300 (xdrproc_t) xdr_guestfs_aug_defvar_args, (char *) &args);
1305 g->reply_cb_internal = aug_defvar_cb;
1306 g->reply_cb_internal_data = &rv;
1307 main_loop.main_loop_run (g);
1308 g->reply_cb_internal = NULL;
1309 g->reply_cb_internal_data = NULL;
1311 error (g, "guestfs_aug_defvar failed, see earlier error messages");
1315 if (check_reply_header (g, &rv.hdr, GUESTFS_PROC_AUG_DEFVAR, serial) == -1)
1318 if (rv.hdr.status == GUESTFS_STATUS_ERROR) {
1319 error (g, "%s", rv.err.error);
1323 return rv.ret.nrnodes;
1326 struct aug_defnode_rv {
1327 int cb_done; /* flag to indicate callback was called */
1328 struct guestfs_message_header hdr;
1329 struct guestfs_message_error err;
1330 struct guestfs_aug_defnode_ret ret;
1333 static void aug_defnode_cb (guestfs_h *g, void *data, XDR *xdr)
1335 struct aug_defnode_rv *rv = (struct aug_defnode_rv *) data;
1337 if (!xdr_guestfs_message_header (xdr, &rv->hdr)) {
1338 error (g, "guestfs_aug_defnode: failed to parse reply header");
1341 if (rv->hdr.status == GUESTFS_STATUS_ERROR) {
1342 if (!xdr_guestfs_message_error (xdr, &rv->err)) {
1343 error (g, "guestfs_aug_defnode: failed to parse reply error");
1348 if (!xdr_guestfs_aug_defnode_ret (xdr, &rv->ret)) {
1349 error (g, "guestfs_aug_defnode: failed to parse reply");
1354 main_loop.main_loop_quit (g);
1357 struct guestfs_int_bool *guestfs_aug_defnode (guestfs_h *g,
1362 struct guestfs_aug_defnode_args args;
1363 struct aug_defnode_rv rv;
1366 if (g->state != READY) {
1367 error (g, "guestfs_aug_defnode called from the wrong state, %d != READY",
1372 memset (&rv, 0, sizeof rv);
1374 args.name = (char *) name;
1375 args.expr = (char *) expr;
1376 args.val = (char *) val;
1377 serial = dispatch (g, GUESTFS_PROC_AUG_DEFNODE,
1378 (xdrproc_t) xdr_guestfs_aug_defnode_args, (char *) &args);
1383 g->reply_cb_internal = aug_defnode_cb;
1384 g->reply_cb_internal_data = &rv;
1385 main_loop.main_loop_run (g);
1386 g->reply_cb_internal = NULL;
1387 g->reply_cb_internal_data = NULL;
1389 error (g, "guestfs_aug_defnode failed, see earlier error messages");
1393 if (check_reply_header (g, &rv.hdr, GUESTFS_PROC_AUG_DEFNODE, serial) == -1)
1396 if (rv.hdr.status == GUESTFS_STATUS_ERROR) {
1397 error (g, "%s", rv.err.error);
1401 /* caller with free this */
1402 return safe_memdup (g, &rv.ret, sizeof (rv.ret));
1406 int cb_done; /* flag to indicate callback was called */
1407 struct guestfs_message_header hdr;
1408 struct guestfs_message_error err;
1409 struct guestfs_aug_get_ret ret;
1412 static void aug_get_cb (guestfs_h *g, void *data, XDR *xdr)
1414 struct aug_get_rv *rv = (struct aug_get_rv *) data;
1416 if (!xdr_guestfs_message_header (xdr, &rv->hdr)) {
1417 error (g, "guestfs_aug_get: failed to parse reply header");
1420 if (rv->hdr.status == GUESTFS_STATUS_ERROR) {
1421 if (!xdr_guestfs_message_error (xdr, &rv->err)) {
1422 error (g, "guestfs_aug_get: failed to parse reply error");
1427 if (!xdr_guestfs_aug_get_ret (xdr, &rv->ret)) {
1428 error (g, "guestfs_aug_get: failed to parse reply");
1433 main_loop.main_loop_quit (g);
1436 char *guestfs_aug_get (guestfs_h *g,
1439 struct guestfs_aug_get_args args;
1440 struct aug_get_rv rv;
1443 if (g->state != READY) {
1444 error (g, "guestfs_aug_get called from the wrong state, %d != READY",
1449 memset (&rv, 0, sizeof rv);
1451 args.path = (char *) path;
1452 serial = dispatch (g, GUESTFS_PROC_AUG_GET,
1453 (xdrproc_t) xdr_guestfs_aug_get_args, (char *) &args);
1458 g->reply_cb_internal = aug_get_cb;
1459 g->reply_cb_internal_data = &rv;
1460 main_loop.main_loop_run (g);
1461 g->reply_cb_internal = NULL;
1462 g->reply_cb_internal_data = NULL;
1464 error (g, "guestfs_aug_get failed, see earlier error messages");
1468 if (check_reply_header (g, &rv.hdr, GUESTFS_PROC_AUG_GET, serial) == -1)
1471 if (rv.hdr.status == GUESTFS_STATUS_ERROR) {
1472 error (g, "%s", rv.err.error);
1476 return rv.ret.val; /* caller will free */
1480 int cb_done; /* flag to indicate callback was called */
1481 struct guestfs_message_header hdr;
1482 struct guestfs_message_error err;
1485 static void aug_set_cb (guestfs_h *g, void *data, XDR *xdr)
1487 struct aug_set_rv *rv = (struct aug_set_rv *) data;
1489 if (!xdr_guestfs_message_header (xdr, &rv->hdr)) {
1490 error (g, "guestfs_aug_set: failed to parse reply header");
1493 if (rv->hdr.status == GUESTFS_STATUS_ERROR) {
1494 if (!xdr_guestfs_message_error (xdr, &rv->err)) {
1495 error (g, "guestfs_aug_set: failed to parse reply error");
1502 main_loop.main_loop_quit (g);
1505 int guestfs_aug_set (guestfs_h *g,
1509 struct guestfs_aug_set_args args;
1510 struct aug_set_rv rv;
1513 if (g->state != READY) {
1514 error (g, "guestfs_aug_set called from the wrong state, %d != READY",
1519 memset (&rv, 0, sizeof rv);
1521 args.path = (char *) path;
1522 args.val = (char *) val;
1523 serial = dispatch (g, GUESTFS_PROC_AUG_SET,
1524 (xdrproc_t) xdr_guestfs_aug_set_args, (char *) &args);
1529 g->reply_cb_internal = aug_set_cb;
1530 g->reply_cb_internal_data = &rv;
1531 main_loop.main_loop_run (g);
1532 g->reply_cb_internal = NULL;
1533 g->reply_cb_internal_data = NULL;
1535 error (g, "guestfs_aug_set failed, see earlier error messages");
1539 if (check_reply_header (g, &rv.hdr, GUESTFS_PROC_AUG_SET, serial) == -1)
1542 if (rv.hdr.status == GUESTFS_STATUS_ERROR) {
1543 error (g, "%s", rv.err.error);
1550 struct aug_insert_rv {
1551 int cb_done; /* flag to indicate callback was called */
1552 struct guestfs_message_header hdr;
1553 struct guestfs_message_error err;
1556 static void aug_insert_cb (guestfs_h *g, void *data, XDR *xdr)
1558 struct aug_insert_rv *rv = (struct aug_insert_rv *) data;
1560 if (!xdr_guestfs_message_header (xdr, &rv->hdr)) {
1561 error (g, "guestfs_aug_insert: failed to parse reply header");
1564 if (rv->hdr.status == GUESTFS_STATUS_ERROR) {
1565 if (!xdr_guestfs_message_error (xdr, &rv->err)) {
1566 error (g, "guestfs_aug_insert: failed to parse reply error");
1573 main_loop.main_loop_quit (g);
1576 int guestfs_aug_insert (guestfs_h *g,
1581 struct guestfs_aug_insert_args args;
1582 struct aug_insert_rv rv;
1585 if (g->state != READY) {
1586 error (g, "guestfs_aug_insert called from the wrong state, %d != READY",
1591 memset (&rv, 0, sizeof rv);
1593 args.path = (char *) path;
1594 args.label = (char *) label;
1595 args.before = before;
1596 serial = dispatch (g, GUESTFS_PROC_AUG_INSERT,
1597 (xdrproc_t) xdr_guestfs_aug_insert_args, (char *) &args);
1602 g->reply_cb_internal = aug_insert_cb;
1603 g->reply_cb_internal_data = &rv;
1604 main_loop.main_loop_run (g);
1605 g->reply_cb_internal = NULL;
1606 g->reply_cb_internal_data = NULL;
1608 error (g, "guestfs_aug_insert failed, see earlier error messages");
1612 if (check_reply_header (g, &rv.hdr, GUESTFS_PROC_AUG_INSERT, serial) == -1)
1615 if (rv.hdr.status == GUESTFS_STATUS_ERROR) {
1616 error (g, "%s", rv.err.error);
1624 int cb_done; /* flag to indicate callback was called */
1625 struct guestfs_message_header hdr;
1626 struct guestfs_message_error err;
1627 struct guestfs_aug_rm_ret ret;
1630 static void aug_rm_cb (guestfs_h *g, void *data, XDR *xdr)
1632 struct aug_rm_rv *rv = (struct aug_rm_rv *) data;
1634 if (!xdr_guestfs_message_header (xdr, &rv->hdr)) {
1635 error (g, "guestfs_aug_rm: failed to parse reply header");
1638 if (rv->hdr.status == GUESTFS_STATUS_ERROR) {
1639 if (!xdr_guestfs_message_error (xdr, &rv->err)) {
1640 error (g, "guestfs_aug_rm: failed to parse reply error");
1645 if (!xdr_guestfs_aug_rm_ret (xdr, &rv->ret)) {
1646 error (g, "guestfs_aug_rm: failed to parse reply");
1651 main_loop.main_loop_quit (g);
1654 int guestfs_aug_rm (guestfs_h *g,
1657 struct guestfs_aug_rm_args args;
1658 struct aug_rm_rv rv;
1661 if (g->state != READY) {
1662 error (g, "guestfs_aug_rm called from the wrong state, %d != READY",
1667 memset (&rv, 0, sizeof rv);
1669 args.path = (char *) path;
1670 serial = dispatch (g, GUESTFS_PROC_AUG_RM,
1671 (xdrproc_t) xdr_guestfs_aug_rm_args, (char *) &args);
1676 g->reply_cb_internal = aug_rm_cb;
1677 g->reply_cb_internal_data = &rv;
1678 main_loop.main_loop_run (g);
1679 g->reply_cb_internal = NULL;
1680 g->reply_cb_internal_data = NULL;
1682 error (g, "guestfs_aug_rm failed, see earlier error messages");
1686 if (check_reply_header (g, &rv.hdr, GUESTFS_PROC_AUG_RM, serial) == -1)
1689 if (rv.hdr.status == GUESTFS_STATUS_ERROR) {
1690 error (g, "%s", rv.err.error);
1694 return rv.ret.nrnodes;
1698 int cb_done; /* flag to indicate callback was called */
1699 struct guestfs_message_header hdr;
1700 struct guestfs_message_error err;
1703 static void aug_mv_cb (guestfs_h *g, void *data, XDR *xdr)
1705 struct aug_mv_rv *rv = (struct aug_mv_rv *) data;
1707 if (!xdr_guestfs_message_header (xdr, &rv->hdr)) {
1708 error (g, "guestfs_aug_mv: failed to parse reply header");
1711 if (rv->hdr.status == GUESTFS_STATUS_ERROR) {
1712 if (!xdr_guestfs_message_error (xdr, &rv->err)) {
1713 error (g, "guestfs_aug_mv: failed to parse reply error");
1720 main_loop.main_loop_quit (g);
1723 int guestfs_aug_mv (guestfs_h *g,
1727 struct guestfs_aug_mv_args args;
1728 struct aug_mv_rv rv;
1731 if (g->state != READY) {
1732 error (g, "guestfs_aug_mv called from the wrong state, %d != READY",
1737 memset (&rv, 0, sizeof rv);
1739 args.src = (char *) src;
1740 args.dest = (char *) dest;
1741 serial = dispatch (g, GUESTFS_PROC_AUG_MV,
1742 (xdrproc_t) xdr_guestfs_aug_mv_args, (char *) &args);
1747 g->reply_cb_internal = aug_mv_cb;
1748 g->reply_cb_internal_data = &rv;
1749 main_loop.main_loop_run (g);
1750 g->reply_cb_internal = NULL;
1751 g->reply_cb_internal_data = NULL;
1753 error (g, "guestfs_aug_mv failed, see earlier error messages");
1757 if (check_reply_header (g, &rv.hdr, GUESTFS_PROC_AUG_MV, serial) == -1)
1760 if (rv.hdr.status == GUESTFS_STATUS_ERROR) {
1761 error (g, "%s", rv.err.error);
1768 struct aug_match_rv {
1769 int cb_done; /* flag to indicate callback was called */
1770 struct guestfs_message_header hdr;
1771 struct guestfs_message_error err;
1772 struct guestfs_aug_match_ret ret;
1775 static void aug_match_cb (guestfs_h *g, void *data, XDR *xdr)
1777 struct aug_match_rv *rv = (struct aug_match_rv *) data;
1779 if (!xdr_guestfs_message_header (xdr, &rv->hdr)) {
1780 error (g, "guestfs_aug_match: failed to parse reply header");
1783 if (rv->hdr.status == GUESTFS_STATUS_ERROR) {
1784 if (!xdr_guestfs_message_error (xdr, &rv->err)) {
1785 error (g, "guestfs_aug_match: failed to parse reply error");
1790 if (!xdr_guestfs_aug_match_ret (xdr, &rv->ret)) {
1791 error (g, "guestfs_aug_match: failed to parse reply");
1796 main_loop.main_loop_quit (g);
1799 char **guestfs_aug_match (guestfs_h *g,
1802 struct guestfs_aug_match_args args;
1803 struct aug_match_rv rv;
1806 if (g->state != READY) {
1807 error (g, "guestfs_aug_match called from the wrong state, %d != READY",
1812 memset (&rv, 0, sizeof rv);
1814 args.path = (char *) path;
1815 serial = dispatch (g, GUESTFS_PROC_AUG_MATCH,
1816 (xdrproc_t) xdr_guestfs_aug_match_args, (char *) &args);
1821 g->reply_cb_internal = aug_match_cb;
1822 g->reply_cb_internal_data = &rv;
1823 main_loop.main_loop_run (g);
1824 g->reply_cb_internal = NULL;
1825 g->reply_cb_internal_data = NULL;
1827 error (g, "guestfs_aug_match failed, see earlier error messages");
1831 if (check_reply_header (g, &rv.hdr, GUESTFS_PROC_AUG_MATCH, serial) == -1)
1834 if (rv.hdr.status == GUESTFS_STATUS_ERROR) {
1835 error (g, "%s", rv.err.error);
1839 /* caller will free this, but we need to add a NULL entry */
1840 rv.ret.matches.matches_val = safe_realloc (g, rv.ret.matches.matches_val,
1841 sizeof (char *) * (rv.ret.matches.matches_len + 1));
1842 rv.ret.matches.matches_val[rv.ret.matches.matches_len] = NULL;
1843 return rv.ret.matches.matches_val;
1846 struct aug_save_rv {
1847 int cb_done; /* flag to indicate callback was called */
1848 struct guestfs_message_header hdr;
1849 struct guestfs_message_error err;
1852 static void aug_save_cb (guestfs_h *g, void *data, XDR *xdr)
1854 struct aug_save_rv *rv = (struct aug_save_rv *) data;
1856 if (!xdr_guestfs_message_header (xdr, &rv->hdr)) {
1857 error (g, "guestfs_aug_save: failed to parse reply header");
1860 if (rv->hdr.status == GUESTFS_STATUS_ERROR) {
1861 if (!xdr_guestfs_message_error (xdr, &rv->err)) {
1862 error (g, "guestfs_aug_save: failed to parse reply error");
1869 main_loop.main_loop_quit (g);
1872 int guestfs_aug_save (guestfs_h *g)
1874 struct aug_save_rv rv;
1877 if (g->state != READY) {
1878 error (g, "guestfs_aug_save called from the wrong state, %d != READY",
1883 memset (&rv, 0, sizeof rv);
1885 serial = dispatch (g, GUESTFS_PROC_AUG_SAVE, NULL, NULL);
1890 g->reply_cb_internal = aug_save_cb;
1891 g->reply_cb_internal_data = &rv;
1892 main_loop.main_loop_run (g);
1893 g->reply_cb_internal = NULL;
1894 g->reply_cb_internal_data = NULL;
1896 error (g, "guestfs_aug_save failed, see earlier error messages");
1900 if (check_reply_header (g, &rv.hdr, GUESTFS_PROC_AUG_SAVE, serial) == -1)
1903 if (rv.hdr.status == GUESTFS_STATUS_ERROR) {
1904 error (g, "%s", rv.err.error);
1911 struct aug_load_rv {
1912 int cb_done; /* flag to indicate callback was called */
1913 struct guestfs_message_header hdr;
1914 struct guestfs_message_error err;
1917 static void aug_load_cb (guestfs_h *g, void *data, XDR *xdr)
1919 struct aug_load_rv *rv = (struct aug_load_rv *) data;
1921 if (!xdr_guestfs_message_header (xdr, &rv->hdr)) {
1922 error (g, "guestfs_aug_load: failed to parse reply header");
1925 if (rv->hdr.status == GUESTFS_STATUS_ERROR) {
1926 if (!xdr_guestfs_message_error (xdr, &rv->err)) {
1927 error (g, "guestfs_aug_load: failed to parse reply error");
1934 main_loop.main_loop_quit (g);
1937 int guestfs_aug_load (guestfs_h *g)
1939 struct aug_load_rv rv;
1942 if (g->state != READY) {
1943 error (g, "guestfs_aug_load called from the wrong state, %d != READY",
1948 memset (&rv, 0, sizeof rv);
1950 serial = dispatch (g, GUESTFS_PROC_AUG_LOAD, NULL, NULL);
1955 g->reply_cb_internal = aug_load_cb;
1956 g->reply_cb_internal_data = &rv;
1957 main_loop.main_loop_run (g);
1958 g->reply_cb_internal = NULL;
1959 g->reply_cb_internal_data = NULL;
1961 error (g, "guestfs_aug_load failed, see earlier error messages");
1965 if (check_reply_header (g, &rv.hdr, GUESTFS_PROC_AUG_LOAD, serial) == -1)
1968 if (rv.hdr.status == GUESTFS_STATUS_ERROR) {
1969 error (g, "%s", rv.err.error);