d76010dfc2abf62584b6532357eb54c5765ced83
[libguestfs.git] / src / guestfs-actions.c
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.
4  *
5  * Copyright (C) 2009 Red Hat Inc.
6  *
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.
11  *
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.
16  *
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
20  */
21
22 #include <stdio.h>
23 #include <stdlib.h>
24
25 #include "guestfs.h"
26 #include "guestfs_protocol.h"
27
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
34
35 /* Check the return message from a call for validity. */
36 static int
37 check_reply_header (guestfs_h *g,
38                     const struct guestfs_message_header *hdr,
39                     int proc_nr, int serial)
40 {
41   if (hdr->prog != GUESTFS_PROGRAM) {
42     error (g, "wrong program (%d/%d)", hdr->prog, GUESTFS_PROGRAM);
43     return -1;
44   }
45   if (hdr->vers != GUESTFS_PROTOCOL_VERSION) {
46     error (g, "wrong protocol version (%d/%d)",
47            hdr->vers, GUESTFS_PROTOCOL_VERSION);
48     return -1;
49   }
50   if (hdr->direction != GUESTFS_DIRECTION_REPLY) {
51     error (g, "unexpected message direction (%d/%d)",
52            hdr->direction, GUESTFS_DIRECTION_REPLY);
53     return -1;
54   }
55   if (hdr->proc != proc_nr) {
56     error (g, "unexpected procedure number (%d/%d)", hdr->proc, proc_nr);
57     return -1;
58   }
59   if (hdr->serial != serial) {
60     error (g, "unexpected serial (%d/%d)", hdr->serial, serial);
61     return -1;
62   }
63
64   return 0;
65 }
66
67 /* Check we are in the right state to run a high-level action. */
68 static int
69 check_state (guestfs_h *g, const char *caller)
70 {
71   if (!guestfs_is_ready (g)) {
72     if (guestfs_is_config (g))
73       error (g, "%s: call launch() before using this function",
74         caller);
75     else if (guestfs_is_launching (g))
76       error (g, "%s: call wait_ready() before using this function",
77         caller);
78     else
79       error (g, "%s called from the wrong state, %d != READY",
80         caller, guestfs_get_state (g));
81     return -1;
82   }
83   return 0;
84 }
85
86 struct mount_ctx {
87   /* This flag is set by the callbacks, so we know we've done
88    * the callbacks as expected, and in the right sequence.
89    * 0 = not called, 1 = send called,
90    * 1001 = reply called.
91    */
92   int cb_sequence;
93   struct guestfs_message_header hdr;
94   struct guestfs_message_error err;
95 };
96
97 static void mount_reply_cb (guestfs_h *g, void *data, XDR *xdr)
98 {
99   guestfs_main_loop *ml = guestfs_get_main_loop (g);
100   struct mount_ctx *ctx = (struct mount_ctx *) data;
101
102   ml->main_loop_quit (ml, g);
103
104   if (!xdr_guestfs_message_header (xdr, &ctx->hdr)) {
105     error (g, "%s: failed to parse reply header", "guestfs_mount");
106     return;
107   }
108   if (ctx->hdr.status == GUESTFS_STATUS_ERROR) {
109     if (!xdr_guestfs_message_error (xdr, &ctx->err)) {
110       error (g, "%s: failed to parse reply error", "guestfs_mount");
111       return;
112     }
113     goto done;
114   }
115  done:
116   ctx->cb_sequence = 1001;
117 }
118
119 int guestfs_mount (guestfs_h *g,
120                 const char *device,
121                 const char *mountpoint)
122 {
123   struct guestfs_mount_args args;
124   struct mount_ctx ctx;
125   guestfs_main_loop *ml = guestfs_get_main_loop (g);
126   int serial;
127
128   if (check_state (g, "guestfs_mount") == -1) return -1;
129
130   memset (&ctx, 0, sizeof ctx);
131
132   args.device = (char *) device;
133   args.mountpoint = (char *) mountpoint;
134   serial = guestfs__send_sync (g, GUESTFS_PROC_MOUNT,
135         (xdrproc_t) xdr_guestfs_mount_args, (char *) &args);
136   if (serial == -1)
137     return -1;
138
139   guestfs__switch_to_receiving (g);
140   ctx.cb_sequence = 0;
141   guestfs_set_reply_callback (g, mount_reply_cb, &ctx);
142   (void) ml->main_loop_run (ml, g);
143   guestfs_set_reply_callback (g, NULL, NULL);
144   if (ctx.cb_sequence != 1001) {
145     error (g, "%s reply failed, see earlier error messages", "guestfs_mount");
146     return -1;
147   }
148
149   if (check_reply_header (g, &ctx.hdr, GUESTFS_PROC_MOUNT, serial) == -1)
150     return -1;
151
152   if (ctx.hdr.status == GUESTFS_STATUS_ERROR) {
153     error (g, "%s", ctx.err.error_message);
154     return -1;
155   }
156
157   return 0;
158 }
159
160 struct sync_ctx {
161   /* This flag is set by the callbacks, so we know we've done
162    * the callbacks as expected, and in the right sequence.
163    * 0 = not called, 1 = send called,
164    * 1001 = reply called.
165    */
166   int cb_sequence;
167   struct guestfs_message_header hdr;
168   struct guestfs_message_error err;
169 };
170
171 static void sync_reply_cb (guestfs_h *g, void *data, XDR *xdr)
172 {
173   guestfs_main_loop *ml = guestfs_get_main_loop (g);
174   struct sync_ctx *ctx = (struct sync_ctx *) data;
175
176   ml->main_loop_quit (ml, g);
177
178   if (!xdr_guestfs_message_header (xdr, &ctx->hdr)) {
179     error (g, "%s: failed to parse reply header", "guestfs_sync");
180     return;
181   }
182   if (ctx->hdr.status == GUESTFS_STATUS_ERROR) {
183     if (!xdr_guestfs_message_error (xdr, &ctx->err)) {
184       error (g, "%s: failed to parse reply error", "guestfs_sync");
185       return;
186     }
187     goto done;
188   }
189  done:
190   ctx->cb_sequence = 1001;
191 }
192
193 int guestfs_sync (guestfs_h *g)
194 {
195   struct sync_ctx ctx;
196   guestfs_main_loop *ml = guestfs_get_main_loop (g);
197   int serial;
198
199   if (check_state (g, "guestfs_sync") == -1) return -1;
200
201   memset (&ctx, 0, sizeof ctx);
202
203   serial = guestfs__send_sync (g, GUESTFS_PROC_SYNC, NULL, NULL);
204   if (serial == -1)
205     return -1;
206
207   guestfs__switch_to_receiving (g);
208   ctx.cb_sequence = 0;
209   guestfs_set_reply_callback (g, sync_reply_cb, &ctx);
210   (void) ml->main_loop_run (ml, g);
211   guestfs_set_reply_callback (g, NULL, NULL);
212   if (ctx.cb_sequence != 1001) {
213     error (g, "%s reply failed, see earlier error messages", "guestfs_sync");
214     return -1;
215   }
216
217   if (check_reply_header (g, &ctx.hdr, GUESTFS_PROC_SYNC, serial) == -1)
218     return -1;
219
220   if (ctx.hdr.status == GUESTFS_STATUS_ERROR) {
221     error (g, "%s", ctx.err.error_message);
222     return -1;
223   }
224
225   return 0;
226 }
227
228 struct touch_ctx {
229   /* This flag is set by the callbacks, so we know we've done
230    * the callbacks as expected, and in the right sequence.
231    * 0 = not called, 1 = send called,
232    * 1001 = reply called.
233    */
234   int cb_sequence;
235   struct guestfs_message_header hdr;
236   struct guestfs_message_error err;
237 };
238
239 static void touch_reply_cb (guestfs_h *g, void *data, XDR *xdr)
240 {
241   guestfs_main_loop *ml = guestfs_get_main_loop (g);
242   struct touch_ctx *ctx = (struct touch_ctx *) data;
243
244   ml->main_loop_quit (ml, g);
245
246   if (!xdr_guestfs_message_header (xdr, &ctx->hdr)) {
247     error (g, "%s: failed to parse reply header", "guestfs_touch");
248     return;
249   }
250   if (ctx->hdr.status == GUESTFS_STATUS_ERROR) {
251     if (!xdr_guestfs_message_error (xdr, &ctx->err)) {
252       error (g, "%s: failed to parse reply error", "guestfs_touch");
253       return;
254     }
255     goto done;
256   }
257  done:
258   ctx->cb_sequence = 1001;
259 }
260
261 int guestfs_touch (guestfs_h *g,
262                 const char *path)
263 {
264   struct guestfs_touch_args args;
265   struct touch_ctx ctx;
266   guestfs_main_loop *ml = guestfs_get_main_loop (g);
267   int serial;
268
269   if (check_state (g, "guestfs_touch") == -1) return -1;
270
271   memset (&ctx, 0, sizeof ctx);
272
273   args.path = (char *) path;
274   serial = guestfs__send_sync (g, GUESTFS_PROC_TOUCH,
275         (xdrproc_t) xdr_guestfs_touch_args, (char *) &args);
276   if (serial == -1)
277     return -1;
278
279   guestfs__switch_to_receiving (g);
280   ctx.cb_sequence = 0;
281   guestfs_set_reply_callback (g, touch_reply_cb, &ctx);
282   (void) ml->main_loop_run (ml, g);
283   guestfs_set_reply_callback (g, NULL, NULL);
284   if (ctx.cb_sequence != 1001) {
285     error (g, "%s reply failed, see earlier error messages", "guestfs_touch");
286     return -1;
287   }
288
289   if (check_reply_header (g, &ctx.hdr, GUESTFS_PROC_TOUCH, serial) == -1)
290     return -1;
291
292   if (ctx.hdr.status == GUESTFS_STATUS_ERROR) {
293     error (g, "%s", ctx.err.error_message);
294     return -1;
295   }
296
297   return 0;
298 }
299
300 struct cat_ctx {
301   /* This flag is set by the callbacks, so we know we've done
302    * the callbacks as expected, and in the right sequence.
303    * 0 = not called, 1 = send called,
304    * 1001 = reply called.
305    */
306   int cb_sequence;
307   struct guestfs_message_header hdr;
308   struct guestfs_message_error err;
309   struct guestfs_cat_ret ret;
310 };
311
312 static void cat_reply_cb (guestfs_h *g, void *data, XDR *xdr)
313 {
314   guestfs_main_loop *ml = guestfs_get_main_loop (g);
315   struct cat_ctx *ctx = (struct cat_ctx *) data;
316
317   ml->main_loop_quit (ml, g);
318
319   if (!xdr_guestfs_message_header (xdr, &ctx->hdr)) {
320     error (g, "%s: failed to parse reply header", "guestfs_cat");
321     return;
322   }
323   if (ctx->hdr.status == GUESTFS_STATUS_ERROR) {
324     if (!xdr_guestfs_message_error (xdr, &ctx->err)) {
325       error (g, "%s: failed to parse reply error", "guestfs_cat");
326       return;
327     }
328     goto done;
329   }
330   if (!xdr_guestfs_cat_ret (xdr, &ctx->ret)) {
331     error (g, "%s: failed to parse reply", "guestfs_cat");
332     return;
333   }
334  done:
335   ctx->cb_sequence = 1001;
336 }
337
338 char *guestfs_cat (guestfs_h *g,
339                 const char *path)
340 {
341   struct guestfs_cat_args args;
342   struct cat_ctx ctx;
343   guestfs_main_loop *ml = guestfs_get_main_loop (g);
344   int serial;
345
346   if (check_state (g, "guestfs_cat") == -1) return NULL;
347
348   memset (&ctx, 0, sizeof ctx);
349
350   args.path = (char *) path;
351   serial = guestfs__send_sync (g, GUESTFS_PROC_CAT,
352         (xdrproc_t) xdr_guestfs_cat_args, (char *) &args);
353   if (serial == -1)
354     return NULL;
355
356   guestfs__switch_to_receiving (g);
357   ctx.cb_sequence = 0;
358   guestfs_set_reply_callback (g, cat_reply_cb, &ctx);
359   (void) ml->main_loop_run (ml, g);
360   guestfs_set_reply_callback (g, NULL, NULL);
361   if (ctx.cb_sequence != 1001) {
362     error (g, "%s reply failed, see earlier error messages", "guestfs_cat");
363     return NULL;
364   }
365
366   if (check_reply_header (g, &ctx.hdr, GUESTFS_PROC_CAT, serial) == -1)
367     return NULL;
368
369   if (ctx.hdr.status == GUESTFS_STATUS_ERROR) {
370     error (g, "%s", ctx.err.error_message);
371     return NULL;
372   }
373
374   return ctx.ret.content; /* caller will free */
375 }
376
377 struct ll_ctx {
378   /* This flag is set by the callbacks, so we know we've done
379    * the callbacks as expected, and in the right sequence.
380    * 0 = not called, 1 = send called,
381    * 1001 = reply called.
382    */
383   int cb_sequence;
384   struct guestfs_message_header hdr;
385   struct guestfs_message_error err;
386   struct guestfs_ll_ret ret;
387 };
388
389 static void ll_reply_cb (guestfs_h *g, void *data, XDR *xdr)
390 {
391   guestfs_main_loop *ml = guestfs_get_main_loop (g);
392   struct ll_ctx *ctx = (struct ll_ctx *) data;
393
394   ml->main_loop_quit (ml, g);
395
396   if (!xdr_guestfs_message_header (xdr, &ctx->hdr)) {
397     error (g, "%s: failed to parse reply header", "guestfs_ll");
398     return;
399   }
400   if (ctx->hdr.status == GUESTFS_STATUS_ERROR) {
401     if (!xdr_guestfs_message_error (xdr, &ctx->err)) {
402       error (g, "%s: failed to parse reply error", "guestfs_ll");
403       return;
404     }
405     goto done;
406   }
407   if (!xdr_guestfs_ll_ret (xdr, &ctx->ret)) {
408     error (g, "%s: failed to parse reply", "guestfs_ll");
409     return;
410   }
411  done:
412   ctx->cb_sequence = 1001;
413 }
414
415 char *guestfs_ll (guestfs_h *g,
416                 const char *directory)
417 {
418   struct guestfs_ll_args args;
419   struct ll_ctx ctx;
420   guestfs_main_loop *ml = guestfs_get_main_loop (g);
421   int serial;
422
423   if (check_state (g, "guestfs_ll") == -1) return NULL;
424
425   memset (&ctx, 0, sizeof ctx);
426
427   args.directory = (char *) directory;
428   serial = guestfs__send_sync (g, GUESTFS_PROC_LL,
429         (xdrproc_t) xdr_guestfs_ll_args, (char *) &args);
430   if (serial == -1)
431     return NULL;
432
433   guestfs__switch_to_receiving (g);
434   ctx.cb_sequence = 0;
435   guestfs_set_reply_callback (g, ll_reply_cb, &ctx);
436   (void) ml->main_loop_run (ml, g);
437   guestfs_set_reply_callback (g, NULL, NULL);
438   if (ctx.cb_sequence != 1001) {
439     error (g, "%s reply failed, see earlier error messages", "guestfs_ll");
440     return NULL;
441   }
442
443   if (check_reply_header (g, &ctx.hdr, GUESTFS_PROC_LL, serial) == -1)
444     return NULL;
445
446   if (ctx.hdr.status == GUESTFS_STATUS_ERROR) {
447     error (g, "%s", ctx.err.error_message);
448     return NULL;
449   }
450
451   return ctx.ret.listing; /* caller will free */
452 }
453
454 struct ls_ctx {
455   /* This flag is set by the callbacks, so we know we've done
456    * the callbacks as expected, and in the right sequence.
457    * 0 = not called, 1 = send called,
458    * 1001 = reply called.
459    */
460   int cb_sequence;
461   struct guestfs_message_header hdr;
462   struct guestfs_message_error err;
463   struct guestfs_ls_ret ret;
464 };
465
466 static void ls_reply_cb (guestfs_h *g, void *data, XDR *xdr)
467 {
468   guestfs_main_loop *ml = guestfs_get_main_loop (g);
469   struct ls_ctx *ctx = (struct ls_ctx *) data;
470
471   ml->main_loop_quit (ml, g);
472
473   if (!xdr_guestfs_message_header (xdr, &ctx->hdr)) {
474     error (g, "%s: failed to parse reply header", "guestfs_ls");
475     return;
476   }
477   if (ctx->hdr.status == GUESTFS_STATUS_ERROR) {
478     if (!xdr_guestfs_message_error (xdr, &ctx->err)) {
479       error (g, "%s: failed to parse reply error", "guestfs_ls");
480       return;
481     }
482     goto done;
483   }
484   if (!xdr_guestfs_ls_ret (xdr, &ctx->ret)) {
485     error (g, "%s: failed to parse reply", "guestfs_ls");
486     return;
487   }
488  done:
489   ctx->cb_sequence = 1001;
490 }
491
492 char **guestfs_ls (guestfs_h *g,
493                 const char *directory)
494 {
495   struct guestfs_ls_args args;
496   struct ls_ctx ctx;
497   guestfs_main_loop *ml = guestfs_get_main_loop (g);
498   int serial;
499
500   if (check_state (g, "guestfs_ls") == -1) return NULL;
501
502   memset (&ctx, 0, sizeof ctx);
503
504   args.directory = (char *) directory;
505   serial = guestfs__send_sync (g, GUESTFS_PROC_LS,
506         (xdrproc_t) xdr_guestfs_ls_args, (char *) &args);
507   if (serial == -1)
508     return NULL;
509
510   guestfs__switch_to_receiving (g);
511   ctx.cb_sequence = 0;
512   guestfs_set_reply_callback (g, ls_reply_cb, &ctx);
513   (void) ml->main_loop_run (ml, g);
514   guestfs_set_reply_callback (g, NULL, NULL);
515   if (ctx.cb_sequence != 1001) {
516     error (g, "%s reply failed, see earlier error messages", "guestfs_ls");
517     return NULL;
518   }
519
520   if (check_reply_header (g, &ctx.hdr, GUESTFS_PROC_LS, serial) == -1)
521     return NULL;
522
523   if (ctx.hdr.status == GUESTFS_STATUS_ERROR) {
524     error (g, "%s", ctx.err.error_message);
525     return NULL;
526   }
527
528   /* caller will free this, but we need to add a NULL entry */
529   ctx.ret.listing.listing_val =
530     safe_realloc (g, ctx.ret.listing.listing_val,
531                   sizeof (char *) * (ctx.ret.listing.listing_len + 1));
532   ctx.ret.listing.listing_val[ctx.ret.listing.listing_len] = NULL;
533   return ctx.ret.listing.listing_val;
534 }
535
536 struct list_devices_ctx {
537   /* This flag is set by the callbacks, so we know we've done
538    * the callbacks as expected, and in the right sequence.
539    * 0 = not called, 1 = send called,
540    * 1001 = reply called.
541    */
542   int cb_sequence;
543   struct guestfs_message_header hdr;
544   struct guestfs_message_error err;
545   struct guestfs_list_devices_ret ret;
546 };
547
548 static void list_devices_reply_cb (guestfs_h *g, void *data, XDR *xdr)
549 {
550   guestfs_main_loop *ml = guestfs_get_main_loop (g);
551   struct list_devices_ctx *ctx = (struct list_devices_ctx *) data;
552
553   ml->main_loop_quit (ml, g);
554
555   if (!xdr_guestfs_message_header (xdr, &ctx->hdr)) {
556     error (g, "%s: failed to parse reply header", "guestfs_list_devices");
557     return;
558   }
559   if (ctx->hdr.status == GUESTFS_STATUS_ERROR) {
560     if (!xdr_guestfs_message_error (xdr, &ctx->err)) {
561       error (g, "%s: failed to parse reply error", "guestfs_list_devices");
562       return;
563     }
564     goto done;
565   }
566   if (!xdr_guestfs_list_devices_ret (xdr, &ctx->ret)) {
567     error (g, "%s: failed to parse reply", "guestfs_list_devices");
568     return;
569   }
570  done:
571   ctx->cb_sequence = 1001;
572 }
573
574 char **guestfs_list_devices (guestfs_h *g)
575 {
576   struct list_devices_ctx ctx;
577   guestfs_main_loop *ml = guestfs_get_main_loop (g);
578   int serial;
579
580   if (check_state (g, "guestfs_list_devices") == -1) return NULL;
581
582   memset (&ctx, 0, sizeof ctx);
583
584   serial = guestfs__send_sync (g, GUESTFS_PROC_LIST_DEVICES, NULL, NULL);
585   if (serial == -1)
586     return NULL;
587
588   guestfs__switch_to_receiving (g);
589   ctx.cb_sequence = 0;
590   guestfs_set_reply_callback (g, list_devices_reply_cb, &ctx);
591   (void) ml->main_loop_run (ml, g);
592   guestfs_set_reply_callback (g, NULL, NULL);
593   if (ctx.cb_sequence != 1001) {
594     error (g, "%s reply failed, see earlier error messages", "guestfs_list_devices");
595     return NULL;
596   }
597
598   if (check_reply_header (g, &ctx.hdr, GUESTFS_PROC_LIST_DEVICES, serial) == -1)
599     return NULL;
600
601   if (ctx.hdr.status == GUESTFS_STATUS_ERROR) {
602     error (g, "%s", ctx.err.error_message);
603     return NULL;
604   }
605
606   /* caller will free this, but we need to add a NULL entry */
607   ctx.ret.devices.devices_val =
608     safe_realloc (g, ctx.ret.devices.devices_val,
609                   sizeof (char *) * (ctx.ret.devices.devices_len + 1));
610   ctx.ret.devices.devices_val[ctx.ret.devices.devices_len] = NULL;
611   return ctx.ret.devices.devices_val;
612 }
613
614 struct list_partitions_ctx {
615   /* This flag is set by the callbacks, so we know we've done
616    * the callbacks as expected, and in the right sequence.
617    * 0 = not called, 1 = send called,
618    * 1001 = reply called.
619    */
620   int cb_sequence;
621   struct guestfs_message_header hdr;
622   struct guestfs_message_error err;
623   struct guestfs_list_partitions_ret ret;
624 };
625
626 static void list_partitions_reply_cb (guestfs_h *g, void *data, XDR *xdr)
627 {
628   guestfs_main_loop *ml = guestfs_get_main_loop (g);
629   struct list_partitions_ctx *ctx = (struct list_partitions_ctx *) data;
630
631   ml->main_loop_quit (ml, g);
632
633   if (!xdr_guestfs_message_header (xdr, &ctx->hdr)) {
634     error (g, "%s: failed to parse reply header", "guestfs_list_partitions");
635     return;
636   }
637   if (ctx->hdr.status == GUESTFS_STATUS_ERROR) {
638     if (!xdr_guestfs_message_error (xdr, &ctx->err)) {
639       error (g, "%s: failed to parse reply error", "guestfs_list_partitions");
640       return;
641     }
642     goto done;
643   }
644   if (!xdr_guestfs_list_partitions_ret (xdr, &ctx->ret)) {
645     error (g, "%s: failed to parse reply", "guestfs_list_partitions");
646     return;
647   }
648  done:
649   ctx->cb_sequence = 1001;
650 }
651
652 char **guestfs_list_partitions (guestfs_h *g)
653 {
654   struct list_partitions_ctx ctx;
655   guestfs_main_loop *ml = guestfs_get_main_loop (g);
656   int serial;
657
658   if (check_state (g, "guestfs_list_partitions") == -1) return NULL;
659
660   memset (&ctx, 0, sizeof ctx);
661
662   serial = guestfs__send_sync (g, GUESTFS_PROC_LIST_PARTITIONS, NULL, NULL);
663   if (serial == -1)
664     return NULL;
665
666   guestfs__switch_to_receiving (g);
667   ctx.cb_sequence = 0;
668   guestfs_set_reply_callback (g, list_partitions_reply_cb, &ctx);
669   (void) ml->main_loop_run (ml, g);
670   guestfs_set_reply_callback (g, NULL, NULL);
671   if (ctx.cb_sequence != 1001) {
672     error (g, "%s reply failed, see earlier error messages", "guestfs_list_partitions");
673     return NULL;
674   }
675
676   if (check_reply_header (g, &ctx.hdr, GUESTFS_PROC_LIST_PARTITIONS, serial) == -1)
677     return NULL;
678
679   if (ctx.hdr.status == GUESTFS_STATUS_ERROR) {
680     error (g, "%s", ctx.err.error_message);
681     return NULL;
682   }
683
684   /* caller will free this, but we need to add a NULL entry */
685   ctx.ret.partitions.partitions_val =
686     safe_realloc (g, ctx.ret.partitions.partitions_val,
687                   sizeof (char *) * (ctx.ret.partitions.partitions_len + 1));
688   ctx.ret.partitions.partitions_val[ctx.ret.partitions.partitions_len] = NULL;
689   return ctx.ret.partitions.partitions_val;
690 }
691
692 struct pvs_ctx {
693   /* This flag is set by the callbacks, so we know we've done
694    * the callbacks as expected, and in the right sequence.
695    * 0 = not called, 1 = send called,
696    * 1001 = reply called.
697    */
698   int cb_sequence;
699   struct guestfs_message_header hdr;
700   struct guestfs_message_error err;
701   struct guestfs_pvs_ret ret;
702 };
703
704 static void pvs_reply_cb (guestfs_h *g, void *data, XDR *xdr)
705 {
706   guestfs_main_loop *ml = guestfs_get_main_loop (g);
707   struct pvs_ctx *ctx = (struct pvs_ctx *) data;
708
709   ml->main_loop_quit (ml, g);
710
711   if (!xdr_guestfs_message_header (xdr, &ctx->hdr)) {
712     error (g, "%s: failed to parse reply header", "guestfs_pvs");
713     return;
714   }
715   if (ctx->hdr.status == GUESTFS_STATUS_ERROR) {
716     if (!xdr_guestfs_message_error (xdr, &ctx->err)) {
717       error (g, "%s: failed to parse reply error", "guestfs_pvs");
718       return;
719     }
720     goto done;
721   }
722   if (!xdr_guestfs_pvs_ret (xdr, &ctx->ret)) {
723     error (g, "%s: failed to parse reply", "guestfs_pvs");
724     return;
725   }
726  done:
727   ctx->cb_sequence = 1001;
728 }
729
730 char **guestfs_pvs (guestfs_h *g)
731 {
732   struct pvs_ctx ctx;
733   guestfs_main_loop *ml = guestfs_get_main_loop (g);
734   int serial;
735
736   if (check_state (g, "guestfs_pvs") == -1) return NULL;
737
738   memset (&ctx, 0, sizeof ctx);
739
740   serial = guestfs__send_sync (g, GUESTFS_PROC_PVS, NULL, NULL);
741   if (serial == -1)
742     return NULL;
743
744   guestfs__switch_to_receiving (g);
745   ctx.cb_sequence = 0;
746   guestfs_set_reply_callback (g, pvs_reply_cb, &ctx);
747   (void) ml->main_loop_run (ml, g);
748   guestfs_set_reply_callback (g, NULL, NULL);
749   if (ctx.cb_sequence != 1001) {
750     error (g, "%s reply failed, see earlier error messages", "guestfs_pvs");
751     return NULL;
752   }
753
754   if (check_reply_header (g, &ctx.hdr, GUESTFS_PROC_PVS, serial) == -1)
755     return NULL;
756
757   if (ctx.hdr.status == GUESTFS_STATUS_ERROR) {
758     error (g, "%s", ctx.err.error_message);
759     return NULL;
760   }
761
762   /* caller will free this, but we need to add a NULL entry */
763   ctx.ret.physvols.physvols_val =
764     safe_realloc (g, ctx.ret.physvols.physvols_val,
765                   sizeof (char *) * (ctx.ret.physvols.physvols_len + 1));
766   ctx.ret.physvols.physvols_val[ctx.ret.physvols.physvols_len] = NULL;
767   return ctx.ret.physvols.physvols_val;
768 }
769
770 struct vgs_ctx {
771   /* This flag is set by the callbacks, so we know we've done
772    * the callbacks as expected, and in the right sequence.
773    * 0 = not called, 1 = send called,
774    * 1001 = reply called.
775    */
776   int cb_sequence;
777   struct guestfs_message_header hdr;
778   struct guestfs_message_error err;
779   struct guestfs_vgs_ret ret;
780 };
781
782 static void vgs_reply_cb (guestfs_h *g, void *data, XDR *xdr)
783 {
784   guestfs_main_loop *ml = guestfs_get_main_loop (g);
785   struct vgs_ctx *ctx = (struct vgs_ctx *) data;
786
787   ml->main_loop_quit (ml, g);
788
789   if (!xdr_guestfs_message_header (xdr, &ctx->hdr)) {
790     error (g, "%s: failed to parse reply header", "guestfs_vgs");
791     return;
792   }
793   if (ctx->hdr.status == GUESTFS_STATUS_ERROR) {
794     if (!xdr_guestfs_message_error (xdr, &ctx->err)) {
795       error (g, "%s: failed to parse reply error", "guestfs_vgs");
796       return;
797     }
798     goto done;
799   }
800   if (!xdr_guestfs_vgs_ret (xdr, &ctx->ret)) {
801     error (g, "%s: failed to parse reply", "guestfs_vgs");
802     return;
803   }
804  done:
805   ctx->cb_sequence = 1001;
806 }
807
808 char **guestfs_vgs (guestfs_h *g)
809 {
810   struct vgs_ctx ctx;
811   guestfs_main_loop *ml = guestfs_get_main_loop (g);
812   int serial;
813
814   if (check_state (g, "guestfs_vgs") == -1) return NULL;
815
816   memset (&ctx, 0, sizeof ctx);
817
818   serial = guestfs__send_sync (g, GUESTFS_PROC_VGS, NULL, NULL);
819   if (serial == -1)
820     return NULL;
821
822   guestfs__switch_to_receiving (g);
823   ctx.cb_sequence = 0;
824   guestfs_set_reply_callback (g, vgs_reply_cb, &ctx);
825   (void) ml->main_loop_run (ml, g);
826   guestfs_set_reply_callback (g, NULL, NULL);
827   if (ctx.cb_sequence != 1001) {
828     error (g, "%s reply failed, see earlier error messages", "guestfs_vgs");
829     return NULL;
830   }
831
832   if (check_reply_header (g, &ctx.hdr, GUESTFS_PROC_VGS, serial) == -1)
833     return NULL;
834
835   if (ctx.hdr.status == GUESTFS_STATUS_ERROR) {
836     error (g, "%s", ctx.err.error_message);
837     return NULL;
838   }
839
840   /* caller will free this, but we need to add a NULL entry */
841   ctx.ret.volgroups.volgroups_val =
842     safe_realloc (g, ctx.ret.volgroups.volgroups_val,
843                   sizeof (char *) * (ctx.ret.volgroups.volgroups_len + 1));
844   ctx.ret.volgroups.volgroups_val[ctx.ret.volgroups.volgroups_len] = NULL;
845   return ctx.ret.volgroups.volgroups_val;
846 }
847
848 struct lvs_ctx {
849   /* This flag is set by the callbacks, so we know we've done
850    * the callbacks as expected, and in the right sequence.
851    * 0 = not called, 1 = send called,
852    * 1001 = reply called.
853    */
854   int cb_sequence;
855   struct guestfs_message_header hdr;
856   struct guestfs_message_error err;
857   struct guestfs_lvs_ret ret;
858 };
859
860 static void lvs_reply_cb (guestfs_h *g, void *data, XDR *xdr)
861 {
862   guestfs_main_loop *ml = guestfs_get_main_loop (g);
863   struct lvs_ctx *ctx = (struct lvs_ctx *) data;
864
865   ml->main_loop_quit (ml, g);
866
867   if (!xdr_guestfs_message_header (xdr, &ctx->hdr)) {
868     error (g, "%s: failed to parse reply header", "guestfs_lvs");
869     return;
870   }
871   if (ctx->hdr.status == GUESTFS_STATUS_ERROR) {
872     if (!xdr_guestfs_message_error (xdr, &ctx->err)) {
873       error (g, "%s: failed to parse reply error", "guestfs_lvs");
874       return;
875     }
876     goto done;
877   }
878   if (!xdr_guestfs_lvs_ret (xdr, &ctx->ret)) {
879     error (g, "%s: failed to parse reply", "guestfs_lvs");
880     return;
881   }
882  done:
883   ctx->cb_sequence = 1001;
884 }
885
886 char **guestfs_lvs (guestfs_h *g)
887 {
888   struct lvs_ctx ctx;
889   guestfs_main_loop *ml = guestfs_get_main_loop (g);
890   int serial;
891
892   if (check_state (g, "guestfs_lvs") == -1) return NULL;
893
894   memset (&ctx, 0, sizeof ctx);
895
896   serial = guestfs__send_sync (g, GUESTFS_PROC_LVS, NULL, NULL);
897   if (serial == -1)
898     return NULL;
899
900   guestfs__switch_to_receiving (g);
901   ctx.cb_sequence = 0;
902   guestfs_set_reply_callback (g, lvs_reply_cb, &ctx);
903   (void) ml->main_loop_run (ml, g);
904   guestfs_set_reply_callback (g, NULL, NULL);
905   if (ctx.cb_sequence != 1001) {
906     error (g, "%s reply failed, see earlier error messages", "guestfs_lvs");
907     return NULL;
908   }
909
910   if (check_reply_header (g, &ctx.hdr, GUESTFS_PROC_LVS, serial) == -1)
911     return NULL;
912
913   if (ctx.hdr.status == GUESTFS_STATUS_ERROR) {
914     error (g, "%s", ctx.err.error_message);
915     return NULL;
916   }
917
918   /* caller will free this, but we need to add a NULL entry */
919   ctx.ret.logvols.logvols_val =
920     safe_realloc (g, ctx.ret.logvols.logvols_val,
921                   sizeof (char *) * (ctx.ret.logvols.logvols_len + 1));
922   ctx.ret.logvols.logvols_val[ctx.ret.logvols.logvols_len] = NULL;
923   return ctx.ret.logvols.logvols_val;
924 }
925
926 struct pvs_full_ctx {
927   /* This flag is set by the callbacks, so we know we've done
928    * the callbacks as expected, and in the right sequence.
929    * 0 = not called, 1 = send called,
930    * 1001 = reply called.
931    */
932   int cb_sequence;
933   struct guestfs_message_header hdr;
934   struct guestfs_message_error err;
935   struct guestfs_pvs_full_ret ret;
936 };
937
938 static void pvs_full_reply_cb (guestfs_h *g, void *data, XDR *xdr)
939 {
940   guestfs_main_loop *ml = guestfs_get_main_loop (g);
941   struct pvs_full_ctx *ctx = (struct pvs_full_ctx *) data;
942
943   ml->main_loop_quit (ml, g);
944
945   if (!xdr_guestfs_message_header (xdr, &ctx->hdr)) {
946     error (g, "%s: failed to parse reply header", "guestfs_pvs_full");
947     return;
948   }
949   if (ctx->hdr.status == GUESTFS_STATUS_ERROR) {
950     if (!xdr_guestfs_message_error (xdr, &ctx->err)) {
951       error (g, "%s: failed to parse reply error", "guestfs_pvs_full");
952       return;
953     }
954     goto done;
955   }
956   if (!xdr_guestfs_pvs_full_ret (xdr, &ctx->ret)) {
957     error (g, "%s: failed to parse reply", "guestfs_pvs_full");
958     return;
959   }
960  done:
961   ctx->cb_sequence = 1001;
962 }
963
964 struct guestfs_lvm_pv_list *guestfs_pvs_full (guestfs_h *g)
965 {
966   struct pvs_full_ctx ctx;
967   guestfs_main_loop *ml = guestfs_get_main_loop (g);
968   int serial;
969
970   if (check_state (g, "guestfs_pvs_full") == -1) return NULL;
971
972   memset (&ctx, 0, sizeof ctx);
973
974   serial = guestfs__send_sync (g, GUESTFS_PROC_PVS_FULL, NULL, NULL);
975   if (serial == -1)
976     return NULL;
977
978   guestfs__switch_to_receiving (g);
979   ctx.cb_sequence = 0;
980   guestfs_set_reply_callback (g, pvs_full_reply_cb, &ctx);
981   (void) ml->main_loop_run (ml, g);
982   guestfs_set_reply_callback (g, NULL, NULL);
983   if (ctx.cb_sequence != 1001) {
984     error (g, "%s reply failed, see earlier error messages", "guestfs_pvs_full");
985     return NULL;
986   }
987
988   if (check_reply_header (g, &ctx.hdr, GUESTFS_PROC_PVS_FULL, serial) == -1)
989     return NULL;
990
991   if (ctx.hdr.status == GUESTFS_STATUS_ERROR) {
992     error (g, "%s", ctx.err.error_message);
993     return NULL;
994   }
995
996   /* caller will free this */
997   return safe_memdup (g, &ctx.ret.physvols, sizeof (ctx.ret.physvols));
998 }
999
1000 struct vgs_full_ctx {
1001   /* This flag is set by the callbacks, so we know we've done
1002    * the callbacks as expected, and in the right sequence.
1003    * 0 = not called, 1 = send called,
1004    * 1001 = reply called.
1005    */
1006   int cb_sequence;
1007   struct guestfs_message_header hdr;
1008   struct guestfs_message_error err;
1009   struct guestfs_vgs_full_ret ret;
1010 };
1011
1012 static void vgs_full_reply_cb (guestfs_h *g, void *data, XDR *xdr)
1013 {
1014   guestfs_main_loop *ml = guestfs_get_main_loop (g);
1015   struct vgs_full_ctx *ctx = (struct vgs_full_ctx *) data;
1016
1017   ml->main_loop_quit (ml, g);
1018
1019   if (!xdr_guestfs_message_header (xdr, &ctx->hdr)) {
1020     error (g, "%s: failed to parse reply header", "guestfs_vgs_full");
1021     return;
1022   }
1023   if (ctx->hdr.status == GUESTFS_STATUS_ERROR) {
1024     if (!xdr_guestfs_message_error (xdr, &ctx->err)) {
1025       error (g, "%s: failed to parse reply error", "guestfs_vgs_full");
1026       return;
1027     }
1028     goto done;
1029   }
1030   if (!xdr_guestfs_vgs_full_ret (xdr, &ctx->ret)) {
1031     error (g, "%s: failed to parse reply", "guestfs_vgs_full");
1032     return;
1033   }
1034  done:
1035   ctx->cb_sequence = 1001;
1036 }
1037
1038 struct guestfs_lvm_vg_list *guestfs_vgs_full (guestfs_h *g)
1039 {
1040   struct vgs_full_ctx ctx;
1041   guestfs_main_loop *ml = guestfs_get_main_loop (g);
1042   int serial;
1043
1044   if (check_state (g, "guestfs_vgs_full") == -1) return NULL;
1045
1046   memset (&ctx, 0, sizeof ctx);
1047
1048   serial = guestfs__send_sync (g, GUESTFS_PROC_VGS_FULL, NULL, NULL);
1049   if (serial == -1)
1050     return NULL;
1051
1052   guestfs__switch_to_receiving (g);
1053   ctx.cb_sequence = 0;
1054   guestfs_set_reply_callback (g, vgs_full_reply_cb, &ctx);
1055   (void) ml->main_loop_run (ml, g);
1056   guestfs_set_reply_callback (g, NULL, NULL);
1057   if (ctx.cb_sequence != 1001) {
1058     error (g, "%s reply failed, see earlier error messages", "guestfs_vgs_full");
1059     return NULL;
1060   }
1061
1062   if (check_reply_header (g, &ctx.hdr, GUESTFS_PROC_VGS_FULL, serial) == -1)
1063     return NULL;
1064
1065   if (ctx.hdr.status == GUESTFS_STATUS_ERROR) {
1066     error (g, "%s", ctx.err.error_message);
1067     return NULL;
1068   }
1069
1070   /* caller will free this */
1071   return safe_memdup (g, &ctx.ret.volgroups, sizeof (ctx.ret.volgroups));
1072 }
1073
1074 struct lvs_full_ctx {
1075   /* This flag is set by the callbacks, so we know we've done
1076    * the callbacks as expected, and in the right sequence.
1077    * 0 = not called, 1 = send called,
1078    * 1001 = reply called.
1079    */
1080   int cb_sequence;
1081   struct guestfs_message_header hdr;
1082   struct guestfs_message_error err;
1083   struct guestfs_lvs_full_ret ret;
1084 };
1085
1086 static void lvs_full_reply_cb (guestfs_h *g, void *data, XDR *xdr)
1087 {
1088   guestfs_main_loop *ml = guestfs_get_main_loop (g);
1089   struct lvs_full_ctx *ctx = (struct lvs_full_ctx *) data;
1090
1091   ml->main_loop_quit (ml, g);
1092
1093   if (!xdr_guestfs_message_header (xdr, &ctx->hdr)) {
1094     error (g, "%s: failed to parse reply header", "guestfs_lvs_full");
1095     return;
1096   }
1097   if (ctx->hdr.status == GUESTFS_STATUS_ERROR) {
1098     if (!xdr_guestfs_message_error (xdr, &ctx->err)) {
1099       error (g, "%s: failed to parse reply error", "guestfs_lvs_full");
1100       return;
1101     }
1102     goto done;
1103   }
1104   if (!xdr_guestfs_lvs_full_ret (xdr, &ctx->ret)) {
1105     error (g, "%s: failed to parse reply", "guestfs_lvs_full");
1106     return;
1107   }
1108  done:
1109   ctx->cb_sequence = 1001;
1110 }
1111
1112 struct guestfs_lvm_lv_list *guestfs_lvs_full (guestfs_h *g)
1113 {
1114   struct lvs_full_ctx ctx;
1115   guestfs_main_loop *ml = guestfs_get_main_loop (g);
1116   int serial;
1117
1118   if (check_state (g, "guestfs_lvs_full") == -1) return NULL;
1119
1120   memset (&ctx, 0, sizeof ctx);
1121
1122   serial = guestfs__send_sync (g, GUESTFS_PROC_LVS_FULL, NULL, NULL);
1123   if (serial == -1)
1124     return NULL;
1125
1126   guestfs__switch_to_receiving (g);
1127   ctx.cb_sequence = 0;
1128   guestfs_set_reply_callback (g, lvs_full_reply_cb, &ctx);
1129   (void) ml->main_loop_run (ml, g);
1130   guestfs_set_reply_callback (g, NULL, NULL);
1131   if (ctx.cb_sequence != 1001) {
1132     error (g, "%s reply failed, see earlier error messages", "guestfs_lvs_full");
1133     return NULL;
1134   }
1135
1136   if (check_reply_header (g, &ctx.hdr, GUESTFS_PROC_LVS_FULL, serial) == -1)
1137     return NULL;
1138
1139   if (ctx.hdr.status == GUESTFS_STATUS_ERROR) {
1140     error (g, "%s", ctx.err.error_message);
1141     return NULL;
1142   }
1143
1144   /* caller will free this */
1145   return safe_memdup (g, &ctx.ret.logvols, sizeof (ctx.ret.logvols));
1146 }
1147
1148 struct read_lines_ctx {
1149   /* This flag is set by the callbacks, so we know we've done
1150    * the callbacks as expected, and in the right sequence.
1151    * 0 = not called, 1 = send called,
1152    * 1001 = reply called.
1153    */
1154   int cb_sequence;
1155   struct guestfs_message_header hdr;
1156   struct guestfs_message_error err;
1157   struct guestfs_read_lines_ret ret;
1158 };
1159
1160 static void read_lines_reply_cb (guestfs_h *g, void *data, XDR *xdr)
1161 {
1162   guestfs_main_loop *ml = guestfs_get_main_loop (g);
1163   struct read_lines_ctx *ctx = (struct read_lines_ctx *) data;
1164
1165   ml->main_loop_quit (ml, g);
1166
1167   if (!xdr_guestfs_message_header (xdr, &ctx->hdr)) {
1168     error (g, "%s: failed to parse reply header", "guestfs_read_lines");
1169     return;
1170   }
1171   if (ctx->hdr.status == GUESTFS_STATUS_ERROR) {
1172     if (!xdr_guestfs_message_error (xdr, &ctx->err)) {
1173       error (g, "%s: failed to parse reply error", "guestfs_read_lines");
1174       return;
1175     }
1176     goto done;
1177   }
1178   if (!xdr_guestfs_read_lines_ret (xdr, &ctx->ret)) {
1179     error (g, "%s: failed to parse reply", "guestfs_read_lines");
1180     return;
1181   }
1182  done:
1183   ctx->cb_sequence = 1001;
1184 }
1185
1186 char **guestfs_read_lines (guestfs_h *g,
1187                 const char *path)
1188 {
1189   struct guestfs_read_lines_args args;
1190   struct read_lines_ctx ctx;
1191   guestfs_main_loop *ml = guestfs_get_main_loop (g);
1192   int serial;
1193
1194   if (check_state (g, "guestfs_read_lines") == -1) return NULL;
1195
1196   memset (&ctx, 0, sizeof ctx);
1197
1198   args.path = (char *) path;
1199   serial = guestfs__send_sync (g, GUESTFS_PROC_READ_LINES,
1200         (xdrproc_t) xdr_guestfs_read_lines_args, (char *) &args);
1201   if (serial == -1)
1202     return NULL;
1203
1204   guestfs__switch_to_receiving (g);
1205   ctx.cb_sequence = 0;
1206   guestfs_set_reply_callback (g, read_lines_reply_cb, &ctx);
1207   (void) ml->main_loop_run (ml, g);
1208   guestfs_set_reply_callback (g, NULL, NULL);
1209   if (ctx.cb_sequence != 1001) {
1210     error (g, "%s reply failed, see earlier error messages", "guestfs_read_lines");
1211     return NULL;
1212   }
1213
1214   if (check_reply_header (g, &ctx.hdr, GUESTFS_PROC_READ_LINES, serial) == -1)
1215     return NULL;
1216
1217   if (ctx.hdr.status == GUESTFS_STATUS_ERROR) {
1218     error (g, "%s", ctx.err.error_message);
1219     return NULL;
1220   }
1221
1222   /* caller will free this, but we need to add a NULL entry */
1223   ctx.ret.lines.lines_val =
1224     safe_realloc (g, ctx.ret.lines.lines_val,
1225                   sizeof (char *) * (ctx.ret.lines.lines_len + 1));
1226   ctx.ret.lines.lines_val[ctx.ret.lines.lines_len] = NULL;
1227   return ctx.ret.lines.lines_val;
1228 }
1229
1230 struct aug_init_ctx {
1231   /* This flag is set by the callbacks, so we know we've done
1232    * the callbacks as expected, and in the right sequence.
1233    * 0 = not called, 1 = send called,
1234    * 1001 = reply called.
1235    */
1236   int cb_sequence;
1237   struct guestfs_message_header hdr;
1238   struct guestfs_message_error err;
1239 };
1240
1241 static void aug_init_reply_cb (guestfs_h *g, void *data, XDR *xdr)
1242 {
1243   guestfs_main_loop *ml = guestfs_get_main_loop (g);
1244   struct aug_init_ctx *ctx = (struct aug_init_ctx *) data;
1245
1246   ml->main_loop_quit (ml, g);
1247
1248   if (!xdr_guestfs_message_header (xdr, &ctx->hdr)) {
1249     error (g, "%s: failed to parse reply header", "guestfs_aug_init");
1250     return;
1251   }
1252   if (ctx->hdr.status == GUESTFS_STATUS_ERROR) {
1253     if (!xdr_guestfs_message_error (xdr, &ctx->err)) {
1254       error (g, "%s: failed to parse reply error", "guestfs_aug_init");
1255       return;
1256     }
1257     goto done;
1258   }
1259  done:
1260   ctx->cb_sequence = 1001;
1261 }
1262
1263 int guestfs_aug_init (guestfs_h *g,
1264                 const char *root,
1265                 int flags)
1266 {
1267   struct guestfs_aug_init_args args;
1268   struct aug_init_ctx ctx;
1269   guestfs_main_loop *ml = guestfs_get_main_loop (g);
1270   int serial;
1271
1272   if (check_state (g, "guestfs_aug_init") == -1) return -1;
1273
1274   memset (&ctx, 0, sizeof ctx);
1275
1276   args.root = (char *) root;
1277   args.flags = flags;
1278   serial = guestfs__send_sync (g, GUESTFS_PROC_AUG_INIT,
1279         (xdrproc_t) xdr_guestfs_aug_init_args, (char *) &args);
1280   if (serial == -1)
1281     return -1;
1282
1283   guestfs__switch_to_receiving (g);
1284   ctx.cb_sequence = 0;
1285   guestfs_set_reply_callback (g, aug_init_reply_cb, &ctx);
1286   (void) ml->main_loop_run (ml, g);
1287   guestfs_set_reply_callback (g, NULL, NULL);
1288   if (ctx.cb_sequence != 1001) {
1289     error (g, "%s reply failed, see earlier error messages", "guestfs_aug_init");
1290     return -1;
1291   }
1292
1293   if (check_reply_header (g, &ctx.hdr, GUESTFS_PROC_AUG_INIT, serial) == -1)
1294     return -1;
1295
1296   if (ctx.hdr.status == GUESTFS_STATUS_ERROR) {
1297     error (g, "%s", ctx.err.error_message);
1298     return -1;
1299   }
1300
1301   return 0;
1302 }
1303
1304 struct aug_close_ctx {
1305   /* This flag is set by the callbacks, so we know we've done
1306    * the callbacks as expected, and in the right sequence.
1307    * 0 = not called, 1 = send called,
1308    * 1001 = reply called.
1309    */
1310   int cb_sequence;
1311   struct guestfs_message_header hdr;
1312   struct guestfs_message_error err;
1313 };
1314
1315 static void aug_close_reply_cb (guestfs_h *g, void *data, XDR *xdr)
1316 {
1317   guestfs_main_loop *ml = guestfs_get_main_loop (g);
1318   struct aug_close_ctx *ctx = (struct aug_close_ctx *) data;
1319
1320   ml->main_loop_quit (ml, g);
1321
1322   if (!xdr_guestfs_message_header (xdr, &ctx->hdr)) {
1323     error (g, "%s: failed to parse reply header", "guestfs_aug_close");
1324     return;
1325   }
1326   if (ctx->hdr.status == GUESTFS_STATUS_ERROR) {
1327     if (!xdr_guestfs_message_error (xdr, &ctx->err)) {
1328       error (g, "%s: failed to parse reply error", "guestfs_aug_close");
1329       return;
1330     }
1331     goto done;
1332   }
1333  done:
1334   ctx->cb_sequence = 1001;
1335 }
1336
1337 int guestfs_aug_close (guestfs_h *g)
1338 {
1339   struct aug_close_ctx ctx;
1340   guestfs_main_loop *ml = guestfs_get_main_loop (g);
1341   int serial;
1342
1343   if (check_state (g, "guestfs_aug_close") == -1) return -1;
1344
1345   memset (&ctx, 0, sizeof ctx);
1346
1347   serial = guestfs__send_sync (g, GUESTFS_PROC_AUG_CLOSE, NULL, NULL);
1348   if (serial == -1)
1349     return -1;
1350
1351   guestfs__switch_to_receiving (g);
1352   ctx.cb_sequence = 0;
1353   guestfs_set_reply_callback (g, aug_close_reply_cb, &ctx);
1354   (void) ml->main_loop_run (ml, g);
1355   guestfs_set_reply_callback (g, NULL, NULL);
1356   if (ctx.cb_sequence != 1001) {
1357     error (g, "%s reply failed, see earlier error messages", "guestfs_aug_close");
1358     return -1;
1359   }
1360
1361   if (check_reply_header (g, &ctx.hdr, GUESTFS_PROC_AUG_CLOSE, serial) == -1)
1362     return -1;
1363
1364   if (ctx.hdr.status == GUESTFS_STATUS_ERROR) {
1365     error (g, "%s", ctx.err.error_message);
1366     return -1;
1367   }
1368
1369   return 0;
1370 }
1371
1372 struct aug_defvar_ctx {
1373   /* This flag is set by the callbacks, so we know we've done
1374    * the callbacks as expected, and in the right sequence.
1375    * 0 = not called, 1 = send called,
1376    * 1001 = reply called.
1377    */
1378   int cb_sequence;
1379   struct guestfs_message_header hdr;
1380   struct guestfs_message_error err;
1381   struct guestfs_aug_defvar_ret ret;
1382 };
1383
1384 static void aug_defvar_reply_cb (guestfs_h *g, void *data, XDR *xdr)
1385 {
1386   guestfs_main_loop *ml = guestfs_get_main_loop (g);
1387   struct aug_defvar_ctx *ctx = (struct aug_defvar_ctx *) data;
1388
1389   ml->main_loop_quit (ml, g);
1390
1391   if (!xdr_guestfs_message_header (xdr, &ctx->hdr)) {
1392     error (g, "%s: failed to parse reply header", "guestfs_aug_defvar");
1393     return;
1394   }
1395   if (ctx->hdr.status == GUESTFS_STATUS_ERROR) {
1396     if (!xdr_guestfs_message_error (xdr, &ctx->err)) {
1397       error (g, "%s: failed to parse reply error", "guestfs_aug_defvar");
1398       return;
1399     }
1400     goto done;
1401   }
1402   if (!xdr_guestfs_aug_defvar_ret (xdr, &ctx->ret)) {
1403     error (g, "%s: failed to parse reply", "guestfs_aug_defvar");
1404     return;
1405   }
1406  done:
1407   ctx->cb_sequence = 1001;
1408 }
1409
1410 int guestfs_aug_defvar (guestfs_h *g,
1411                 const char *name,
1412                 const char *expr)
1413 {
1414   struct guestfs_aug_defvar_args args;
1415   struct aug_defvar_ctx ctx;
1416   guestfs_main_loop *ml = guestfs_get_main_loop (g);
1417   int serial;
1418
1419   if (check_state (g, "guestfs_aug_defvar") == -1) return -1;
1420
1421   memset (&ctx, 0, sizeof ctx);
1422
1423   args.name = (char *) name;
1424   args.expr = expr ? (char **) &expr : NULL;
1425   serial = guestfs__send_sync (g, GUESTFS_PROC_AUG_DEFVAR,
1426         (xdrproc_t) xdr_guestfs_aug_defvar_args, (char *) &args);
1427   if (serial == -1)
1428     return -1;
1429
1430   guestfs__switch_to_receiving (g);
1431   ctx.cb_sequence = 0;
1432   guestfs_set_reply_callback (g, aug_defvar_reply_cb, &ctx);
1433   (void) ml->main_loop_run (ml, g);
1434   guestfs_set_reply_callback (g, NULL, NULL);
1435   if (ctx.cb_sequence != 1001) {
1436     error (g, "%s reply failed, see earlier error messages", "guestfs_aug_defvar");
1437     return -1;
1438   }
1439
1440   if (check_reply_header (g, &ctx.hdr, GUESTFS_PROC_AUG_DEFVAR, serial) == -1)
1441     return -1;
1442
1443   if (ctx.hdr.status == GUESTFS_STATUS_ERROR) {
1444     error (g, "%s", ctx.err.error_message);
1445     return -1;
1446   }
1447
1448   return ctx.ret.nrnodes;
1449 }
1450
1451 struct aug_defnode_ctx {
1452   /* This flag is set by the callbacks, so we know we've done
1453    * the callbacks as expected, and in the right sequence.
1454    * 0 = not called, 1 = send called,
1455    * 1001 = reply called.
1456    */
1457   int cb_sequence;
1458   struct guestfs_message_header hdr;
1459   struct guestfs_message_error err;
1460   struct guestfs_aug_defnode_ret ret;
1461 };
1462
1463 static void aug_defnode_reply_cb (guestfs_h *g, void *data, XDR *xdr)
1464 {
1465   guestfs_main_loop *ml = guestfs_get_main_loop (g);
1466   struct aug_defnode_ctx *ctx = (struct aug_defnode_ctx *) data;
1467
1468   ml->main_loop_quit (ml, g);
1469
1470   if (!xdr_guestfs_message_header (xdr, &ctx->hdr)) {
1471     error (g, "%s: failed to parse reply header", "guestfs_aug_defnode");
1472     return;
1473   }
1474   if (ctx->hdr.status == GUESTFS_STATUS_ERROR) {
1475     if (!xdr_guestfs_message_error (xdr, &ctx->err)) {
1476       error (g, "%s: failed to parse reply error", "guestfs_aug_defnode");
1477       return;
1478     }
1479     goto done;
1480   }
1481   if (!xdr_guestfs_aug_defnode_ret (xdr, &ctx->ret)) {
1482     error (g, "%s: failed to parse reply", "guestfs_aug_defnode");
1483     return;
1484   }
1485  done:
1486   ctx->cb_sequence = 1001;
1487 }
1488
1489 struct guestfs_int_bool *guestfs_aug_defnode (guestfs_h *g,
1490                 const char *name,
1491                 const char *expr,
1492                 const char *val)
1493 {
1494   struct guestfs_aug_defnode_args args;
1495   struct aug_defnode_ctx ctx;
1496   guestfs_main_loop *ml = guestfs_get_main_loop (g);
1497   int serial;
1498
1499   if (check_state (g, "guestfs_aug_defnode") == -1) return NULL;
1500
1501   memset (&ctx, 0, sizeof ctx);
1502
1503   args.name = (char *) name;
1504   args.expr = (char *) expr;
1505   args.val = (char *) val;
1506   serial = guestfs__send_sync (g, GUESTFS_PROC_AUG_DEFNODE,
1507         (xdrproc_t) xdr_guestfs_aug_defnode_args, (char *) &args);
1508   if (serial == -1)
1509     return NULL;
1510
1511   guestfs__switch_to_receiving (g);
1512   ctx.cb_sequence = 0;
1513   guestfs_set_reply_callback (g, aug_defnode_reply_cb, &ctx);
1514   (void) ml->main_loop_run (ml, g);
1515   guestfs_set_reply_callback (g, NULL, NULL);
1516   if (ctx.cb_sequence != 1001) {
1517     error (g, "%s reply failed, see earlier error messages", "guestfs_aug_defnode");
1518     return NULL;
1519   }
1520
1521   if (check_reply_header (g, &ctx.hdr, GUESTFS_PROC_AUG_DEFNODE, serial) == -1)
1522     return NULL;
1523
1524   if (ctx.hdr.status == GUESTFS_STATUS_ERROR) {
1525     error (g, "%s", ctx.err.error_message);
1526     return NULL;
1527   }
1528
1529   /* caller with free this */
1530   return safe_memdup (g, &ctx.ret, sizeof (ctx.ret));
1531 }
1532
1533 struct aug_get_ctx {
1534   /* This flag is set by the callbacks, so we know we've done
1535    * the callbacks as expected, and in the right sequence.
1536    * 0 = not called, 1 = send called,
1537    * 1001 = reply called.
1538    */
1539   int cb_sequence;
1540   struct guestfs_message_header hdr;
1541   struct guestfs_message_error err;
1542   struct guestfs_aug_get_ret ret;
1543 };
1544
1545 static void aug_get_reply_cb (guestfs_h *g, void *data, XDR *xdr)
1546 {
1547   guestfs_main_loop *ml = guestfs_get_main_loop (g);
1548   struct aug_get_ctx *ctx = (struct aug_get_ctx *) data;
1549
1550   ml->main_loop_quit (ml, g);
1551
1552   if (!xdr_guestfs_message_header (xdr, &ctx->hdr)) {
1553     error (g, "%s: failed to parse reply header", "guestfs_aug_get");
1554     return;
1555   }
1556   if (ctx->hdr.status == GUESTFS_STATUS_ERROR) {
1557     if (!xdr_guestfs_message_error (xdr, &ctx->err)) {
1558       error (g, "%s: failed to parse reply error", "guestfs_aug_get");
1559       return;
1560     }
1561     goto done;
1562   }
1563   if (!xdr_guestfs_aug_get_ret (xdr, &ctx->ret)) {
1564     error (g, "%s: failed to parse reply", "guestfs_aug_get");
1565     return;
1566   }
1567  done:
1568   ctx->cb_sequence = 1001;
1569 }
1570
1571 char *guestfs_aug_get (guestfs_h *g,
1572                 const char *path)
1573 {
1574   struct guestfs_aug_get_args args;
1575   struct aug_get_ctx ctx;
1576   guestfs_main_loop *ml = guestfs_get_main_loop (g);
1577   int serial;
1578
1579   if (check_state (g, "guestfs_aug_get") == -1) return NULL;
1580
1581   memset (&ctx, 0, sizeof ctx);
1582
1583   args.path = (char *) path;
1584   serial = guestfs__send_sync (g, GUESTFS_PROC_AUG_GET,
1585         (xdrproc_t) xdr_guestfs_aug_get_args, (char *) &args);
1586   if (serial == -1)
1587     return NULL;
1588
1589   guestfs__switch_to_receiving (g);
1590   ctx.cb_sequence = 0;
1591   guestfs_set_reply_callback (g, aug_get_reply_cb, &ctx);
1592   (void) ml->main_loop_run (ml, g);
1593   guestfs_set_reply_callback (g, NULL, NULL);
1594   if (ctx.cb_sequence != 1001) {
1595     error (g, "%s reply failed, see earlier error messages", "guestfs_aug_get");
1596     return NULL;
1597   }
1598
1599   if (check_reply_header (g, &ctx.hdr, GUESTFS_PROC_AUG_GET, serial) == -1)
1600     return NULL;
1601
1602   if (ctx.hdr.status == GUESTFS_STATUS_ERROR) {
1603     error (g, "%s", ctx.err.error_message);
1604     return NULL;
1605   }
1606
1607   return ctx.ret.val; /* caller will free */
1608 }
1609
1610 struct aug_set_ctx {
1611   /* This flag is set by the callbacks, so we know we've done
1612    * the callbacks as expected, and in the right sequence.
1613    * 0 = not called, 1 = send called,
1614    * 1001 = reply called.
1615    */
1616   int cb_sequence;
1617   struct guestfs_message_header hdr;
1618   struct guestfs_message_error err;
1619 };
1620
1621 static void aug_set_reply_cb (guestfs_h *g, void *data, XDR *xdr)
1622 {
1623   guestfs_main_loop *ml = guestfs_get_main_loop (g);
1624   struct aug_set_ctx *ctx = (struct aug_set_ctx *) data;
1625
1626   ml->main_loop_quit (ml, g);
1627
1628   if (!xdr_guestfs_message_header (xdr, &ctx->hdr)) {
1629     error (g, "%s: failed to parse reply header", "guestfs_aug_set");
1630     return;
1631   }
1632   if (ctx->hdr.status == GUESTFS_STATUS_ERROR) {
1633     if (!xdr_guestfs_message_error (xdr, &ctx->err)) {
1634       error (g, "%s: failed to parse reply error", "guestfs_aug_set");
1635       return;
1636     }
1637     goto done;
1638   }
1639  done:
1640   ctx->cb_sequence = 1001;
1641 }
1642
1643 int guestfs_aug_set (guestfs_h *g,
1644                 const char *path,
1645                 const char *val)
1646 {
1647   struct guestfs_aug_set_args args;
1648   struct aug_set_ctx ctx;
1649   guestfs_main_loop *ml = guestfs_get_main_loop (g);
1650   int serial;
1651
1652   if (check_state (g, "guestfs_aug_set") == -1) return -1;
1653
1654   memset (&ctx, 0, sizeof ctx);
1655
1656   args.path = (char *) path;
1657   args.val = (char *) val;
1658   serial = guestfs__send_sync (g, GUESTFS_PROC_AUG_SET,
1659         (xdrproc_t) xdr_guestfs_aug_set_args, (char *) &args);
1660   if (serial == -1)
1661     return -1;
1662
1663   guestfs__switch_to_receiving (g);
1664   ctx.cb_sequence = 0;
1665   guestfs_set_reply_callback (g, aug_set_reply_cb, &ctx);
1666   (void) ml->main_loop_run (ml, g);
1667   guestfs_set_reply_callback (g, NULL, NULL);
1668   if (ctx.cb_sequence != 1001) {
1669     error (g, "%s reply failed, see earlier error messages", "guestfs_aug_set");
1670     return -1;
1671   }
1672
1673   if (check_reply_header (g, &ctx.hdr, GUESTFS_PROC_AUG_SET, serial) == -1)
1674     return -1;
1675
1676   if (ctx.hdr.status == GUESTFS_STATUS_ERROR) {
1677     error (g, "%s", ctx.err.error_message);
1678     return -1;
1679   }
1680
1681   return 0;
1682 }
1683
1684 struct aug_insert_ctx {
1685   /* This flag is set by the callbacks, so we know we've done
1686    * the callbacks as expected, and in the right sequence.
1687    * 0 = not called, 1 = send called,
1688    * 1001 = reply called.
1689    */
1690   int cb_sequence;
1691   struct guestfs_message_header hdr;
1692   struct guestfs_message_error err;
1693 };
1694
1695 static void aug_insert_reply_cb (guestfs_h *g, void *data, XDR *xdr)
1696 {
1697   guestfs_main_loop *ml = guestfs_get_main_loop (g);
1698   struct aug_insert_ctx *ctx = (struct aug_insert_ctx *) data;
1699
1700   ml->main_loop_quit (ml, g);
1701
1702   if (!xdr_guestfs_message_header (xdr, &ctx->hdr)) {
1703     error (g, "%s: failed to parse reply header", "guestfs_aug_insert");
1704     return;
1705   }
1706   if (ctx->hdr.status == GUESTFS_STATUS_ERROR) {
1707     if (!xdr_guestfs_message_error (xdr, &ctx->err)) {
1708       error (g, "%s: failed to parse reply error", "guestfs_aug_insert");
1709       return;
1710     }
1711     goto done;
1712   }
1713  done:
1714   ctx->cb_sequence = 1001;
1715 }
1716
1717 int guestfs_aug_insert (guestfs_h *g,
1718                 const char *path,
1719                 const char *label,
1720                 int before)
1721 {
1722   struct guestfs_aug_insert_args args;
1723   struct aug_insert_ctx ctx;
1724   guestfs_main_loop *ml = guestfs_get_main_loop (g);
1725   int serial;
1726
1727   if (check_state (g, "guestfs_aug_insert") == -1) return -1;
1728
1729   memset (&ctx, 0, sizeof ctx);
1730
1731   args.path = (char *) path;
1732   args.label = (char *) label;
1733   args.before = before;
1734   serial = guestfs__send_sync (g, GUESTFS_PROC_AUG_INSERT,
1735         (xdrproc_t) xdr_guestfs_aug_insert_args, (char *) &args);
1736   if (serial == -1)
1737     return -1;
1738
1739   guestfs__switch_to_receiving (g);
1740   ctx.cb_sequence = 0;
1741   guestfs_set_reply_callback (g, aug_insert_reply_cb, &ctx);
1742   (void) ml->main_loop_run (ml, g);
1743   guestfs_set_reply_callback (g, NULL, NULL);
1744   if (ctx.cb_sequence != 1001) {
1745     error (g, "%s reply failed, see earlier error messages", "guestfs_aug_insert");
1746     return -1;
1747   }
1748
1749   if (check_reply_header (g, &ctx.hdr, GUESTFS_PROC_AUG_INSERT, serial) == -1)
1750     return -1;
1751
1752   if (ctx.hdr.status == GUESTFS_STATUS_ERROR) {
1753     error (g, "%s", ctx.err.error_message);
1754     return -1;
1755   }
1756
1757   return 0;
1758 }
1759
1760 struct aug_rm_ctx {
1761   /* This flag is set by the callbacks, so we know we've done
1762    * the callbacks as expected, and in the right sequence.
1763    * 0 = not called, 1 = send called,
1764    * 1001 = reply called.
1765    */
1766   int cb_sequence;
1767   struct guestfs_message_header hdr;
1768   struct guestfs_message_error err;
1769   struct guestfs_aug_rm_ret ret;
1770 };
1771
1772 static void aug_rm_reply_cb (guestfs_h *g, void *data, XDR *xdr)
1773 {
1774   guestfs_main_loop *ml = guestfs_get_main_loop (g);
1775   struct aug_rm_ctx *ctx = (struct aug_rm_ctx *) data;
1776
1777   ml->main_loop_quit (ml, g);
1778
1779   if (!xdr_guestfs_message_header (xdr, &ctx->hdr)) {
1780     error (g, "%s: failed to parse reply header", "guestfs_aug_rm");
1781     return;
1782   }
1783   if (ctx->hdr.status == GUESTFS_STATUS_ERROR) {
1784     if (!xdr_guestfs_message_error (xdr, &ctx->err)) {
1785       error (g, "%s: failed to parse reply error", "guestfs_aug_rm");
1786       return;
1787     }
1788     goto done;
1789   }
1790   if (!xdr_guestfs_aug_rm_ret (xdr, &ctx->ret)) {
1791     error (g, "%s: failed to parse reply", "guestfs_aug_rm");
1792     return;
1793   }
1794  done:
1795   ctx->cb_sequence = 1001;
1796 }
1797
1798 int guestfs_aug_rm (guestfs_h *g,
1799                 const char *path)
1800 {
1801   struct guestfs_aug_rm_args args;
1802   struct aug_rm_ctx ctx;
1803   guestfs_main_loop *ml = guestfs_get_main_loop (g);
1804   int serial;
1805
1806   if (check_state (g, "guestfs_aug_rm") == -1) return -1;
1807
1808   memset (&ctx, 0, sizeof ctx);
1809
1810   args.path = (char *) path;
1811   serial = guestfs__send_sync (g, GUESTFS_PROC_AUG_RM,
1812         (xdrproc_t) xdr_guestfs_aug_rm_args, (char *) &args);
1813   if (serial == -1)
1814     return -1;
1815
1816   guestfs__switch_to_receiving (g);
1817   ctx.cb_sequence = 0;
1818   guestfs_set_reply_callback (g, aug_rm_reply_cb, &ctx);
1819   (void) ml->main_loop_run (ml, g);
1820   guestfs_set_reply_callback (g, NULL, NULL);
1821   if (ctx.cb_sequence != 1001) {
1822     error (g, "%s reply failed, see earlier error messages", "guestfs_aug_rm");
1823     return -1;
1824   }
1825
1826   if (check_reply_header (g, &ctx.hdr, GUESTFS_PROC_AUG_RM, serial) == -1)
1827     return -1;
1828
1829   if (ctx.hdr.status == GUESTFS_STATUS_ERROR) {
1830     error (g, "%s", ctx.err.error_message);
1831     return -1;
1832   }
1833
1834   return ctx.ret.nrnodes;
1835 }
1836
1837 struct aug_mv_ctx {
1838   /* This flag is set by the callbacks, so we know we've done
1839    * the callbacks as expected, and in the right sequence.
1840    * 0 = not called, 1 = send called,
1841    * 1001 = reply called.
1842    */
1843   int cb_sequence;
1844   struct guestfs_message_header hdr;
1845   struct guestfs_message_error err;
1846 };
1847
1848 static void aug_mv_reply_cb (guestfs_h *g, void *data, XDR *xdr)
1849 {
1850   guestfs_main_loop *ml = guestfs_get_main_loop (g);
1851   struct aug_mv_ctx *ctx = (struct aug_mv_ctx *) data;
1852
1853   ml->main_loop_quit (ml, g);
1854
1855   if (!xdr_guestfs_message_header (xdr, &ctx->hdr)) {
1856     error (g, "%s: failed to parse reply header", "guestfs_aug_mv");
1857     return;
1858   }
1859   if (ctx->hdr.status == GUESTFS_STATUS_ERROR) {
1860     if (!xdr_guestfs_message_error (xdr, &ctx->err)) {
1861       error (g, "%s: failed to parse reply error", "guestfs_aug_mv");
1862       return;
1863     }
1864     goto done;
1865   }
1866  done:
1867   ctx->cb_sequence = 1001;
1868 }
1869
1870 int guestfs_aug_mv (guestfs_h *g,
1871                 const char *src,
1872                 const char *dest)
1873 {
1874   struct guestfs_aug_mv_args args;
1875   struct aug_mv_ctx ctx;
1876   guestfs_main_loop *ml = guestfs_get_main_loop (g);
1877   int serial;
1878
1879   if (check_state (g, "guestfs_aug_mv") == -1) return -1;
1880
1881   memset (&ctx, 0, sizeof ctx);
1882
1883   args.src = (char *) src;
1884   args.dest = (char *) dest;
1885   serial = guestfs__send_sync (g, GUESTFS_PROC_AUG_MV,
1886         (xdrproc_t) xdr_guestfs_aug_mv_args, (char *) &args);
1887   if (serial == -1)
1888     return -1;
1889
1890   guestfs__switch_to_receiving (g);
1891   ctx.cb_sequence = 0;
1892   guestfs_set_reply_callback (g, aug_mv_reply_cb, &ctx);
1893   (void) ml->main_loop_run (ml, g);
1894   guestfs_set_reply_callback (g, NULL, NULL);
1895   if (ctx.cb_sequence != 1001) {
1896     error (g, "%s reply failed, see earlier error messages", "guestfs_aug_mv");
1897     return -1;
1898   }
1899
1900   if (check_reply_header (g, &ctx.hdr, GUESTFS_PROC_AUG_MV, serial) == -1)
1901     return -1;
1902
1903   if (ctx.hdr.status == GUESTFS_STATUS_ERROR) {
1904     error (g, "%s", ctx.err.error_message);
1905     return -1;
1906   }
1907
1908   return 0;
1909 }
1910
1911 struct aug_match_ctx {
1912   /* This flag is set by the callbacks, so we know we've done
1913    * the callbacks as expected, and in the right sequence.
1914    * 0 = not called, 1 = send called,
1915    * 1001 = reply called.
1916    */
1917   int cb_sequence;
1918   struct guestfs_message_header hdr;
1919   struct guestfs_message_error err;
1920   struct guestfs_aug_match_ret ret;
1921 };
1922
1923 static void aug_match_reply_cb (guestfs_h *g, void *data, XDR *xdr)
1924 {
1925   guestfs_main_loop *ml = guestfs_get_main_loop (g);
1926   struct aug_match_ctx *ctx = (struct aug_match_ctx *) data;
1927
1928   ml->main_loop_quit (ml, g);
1929
1930   if (!xdr_guestfs_message_header (xdr, &ctx->hdr)) {
1931     error (g, "%s: failed to parse reply header", "guestfs_aug_match");
1932     return;
1933   }
1934   if (ctx->hdr.status == GUESTFS_STATUS_ERROR) {
1935     if (!xdr_guestfs_message_error (xdr, &ctx->err)) {
1936       error (g, "%s: failed to parse reply error", "guestfs_aug_match");
1937       return;
1938     }
1939     goto done;
1940   }
1941   if (!xdr_guestfs_aug_match_ret (xdr, &ctx->ret)) {
1942     error (g, "%s: failed to parse reply", "guestfs_aug_match");
1943     return;
1944   }
1945  done:
1946   ctx->cb_sequence = 1001;
1947 }
1948
1949 char **guestfs_aug_match (guestfs_h *g,
1950                 const char *path)
1951 {
1952   struct guestfs_aug_match_args args;
1953   struct aug_match_ctx ctx;
1954   guestfs_main_loop *ml = guestfs_get_main_loop (g);
1955   int serial;
1956
1957   if (check_state (g, "guestfs_aug_match") == -1) return NULL;
1958
1959   memset (&ctx, 0, sizeof ctx);
1960
1961   args.path = (char *) path;
1962   serial = guestfs__send_sync (g, GUESTFS_PROC_AUG_MATCH,
1963         (xdrproc_t) xdr_guestfs_aug_match_args, (char *) &args);
1964   if (serial == -1)
1965     return NULL;
1966
1967   guestfs__switch_to_receiving (g);
1968   ctx.cb_sequence = 0;
1969   guestfs_set_reply_callback (g, aug_match_reply_cb, &ctx);
1970   (void) ml->main_loop_run (ml, g);
1971   guestfs_set_reply_callback (g, NULL, NULL);
1972   if (ctx.cb_sequence != 1001) {
1973     error (g, "%s reply failed, see earlier error messages", "guestfs_aug_match");
1974     return NULL;
1975   }
1976
1977   if (check_reply_header (g, &ctx.hdr, GUESTFS_PROC_AUG_MATCH, serial) == -1)
1978     return NULL;
1979
1980   if (ctx.hdr.status == GUESTFS_STATUS_ERROR) {
1981     error (g, "%s", ctx.err.error_message);
1982     return NULL;
1983   }
1984
1985   /* caller will free this, but we need to add a NULL entry */
1986   ctx.ret.matches.matches_val =
1987     safe_realloc (g, ctx.ret.matches.matches_val,
1988                   sizeof (char *) * (ctx.ret.matches.matches_len + 1));
1989   ctx.ret.matches.matches_val[ctx.ret.matches.matches_len] = NULL;
1990   return ctx.ret.matches.matches_val;
1991 }
1992
1993 struct aug_save_ctx {
1994   /* This flag is set by the callbacks, so we know we've done
1995    * the callbacks as expected, and in the right sequence.
1996    * 0 = not called, 1 = send called,
1997    * 1001 = reply called.
1998    */
1999   int cb_sequence;
2000   struct guestfs_message_header hdr;
2001   struct guestfs_message_error err;
2002 };
2003
2004 static void aug_save_reply_cb (guestfs_h *g, void *data, XDR *xdr)
2005 {
2006   guestfs_main_loop *ml = guestfs_get_main_loop (g);
2007   struct aug_save_ctx *ctx = (struct aug_save_ctx *) data;
2008
2009   ml->main_loop_quit (ml, g);
2010
2011   if (!xdr_guestfs_message_header (xdr, &ctx->hdr)) {
2012     error (g, "%s: failed to parse reply header", "guestfs_aug_save");
2013     return;
2014   }
2015   if (ctx->hdr.status == GUESTFS_STATUS_ERROR) {
2016     if (!xdr_guestfs_message_error (xdr, &ctx->err)) {
2017       error (g, "%s: failed to parse reply error", "guestfs_aug_save");
2018       return;
2019     }
2020     goto done;
2021   }
2022  done:
2023   ctx->cb_sequence = 1001;
2024 }
2025
2026 int guestfs_aug_save (guestfs_h *g)
2027 {
2028   struct aug_save_ctx ctx;
2029   guestfs_main_loop *ml = guestfs_get_main_loop (g);
2030   int serial;
2031
2032   if (check_state (g, "guestfs_aug_save") == -1) return -1;
2033
2034   memset (&ctx, 0, sizeof ctx);
2035
2036   serial = guestfs__send_sync (g, GUESTFS_PROC_AUG_SAVE, NULL, NULL);
2037   if (serial == -1)
2038     return -1;
2039
2040   guestfs__switch_to_receiving (g);
2041   ctx.cb_sequence = 0;
2042   guestfs_set_reply_callback (g, aug_save_reply_cb, &ctx);
2043   (void) ml->main_loop_run (ml, g);
2044   guestfs_set_reply_callback (g, NULL, NULL);
2045   if (ctx.cb_sequence != 1001) {
2046     error (g, "%s reply failed, see earlier error messages", "guestfs_aug_save");
2047     return -1;
2048   }
2049
2050   if (check_reply_header (g, &ctx.hdr, GUESTFS_PROC_AUG_SAVE, serial) == -1)
2051     return -1;
2052
2053   if (ctx.hdr.status == GUESTFS_STATUS_ERROR) {
2054     error (g, "%s", ctx.err.error_message);
2055     return -1;
2056   }
2057
2058   return 0;
2059 }
2060
2061 struct aug_load_ctx {
2062   /* This flag is set by the callbacks, so we know we've done
2063    * the callbacks as expected, and in the right sequence.
2064    * 0 = not called, 1 = send called,
2065    * 1001 = reply called.
2066    */
2067   int cb_sequence;
2068   struct guestfs_message_header hdr;
2069   struct guestfs_message_error err;
2070 };
2071
2072 static void aug_load_reply_cb (guestfs_h *g, void *data, XDR *xdr)
2073 {
2074   guestfs_main_loop *ml = guestfs_get_main_loop (g);
2075   struct aug_load_ctx *ctx = (struct aug_load_ctx *) data;
2076
2077   ml->main_loop_quit (ml, g);
2078
2079   if (!xdr_guestfs_message_header (xdr, &ctx->hdr)) {
2080     error (g, "%s: failed to parse reply header", "guestfs_aug_load");
2081     return;
2082   }
2083   if (ctx->hdr.status == GUESTFS_STATUS_ERROR) {
2084     if (!xdr_guestfs_message_error (xdr, &ctx->err)) {
2085       error (g, "%s: failed to parse reply error", "guestfs_aug_load");
2086       return;
2087     }
2088     goto done;
2089   }
2090  done:
2091   ctx->cb_sequence = 1001;
2092 }
2093
2094 int guestfs_aug_load (guestfs_h *g)
2095 {
2096   struct aug_load_ctx ctx;
2097   guestfs_main_loop *ml = guestfs_get_main_loop (g);
2098   int serial;
2099
2100   if (check_state (g, "guestfs_aug_load") == -1) return -1;
2101
2102   memset (&ctx, 0, sizeof ctx);
2103
2104   serial = guestfs__send_sync (g, GUESTFS_PROC_AUG_LOAD, NULL, NULL);
2105   if (serial == -1)
2106     return -1;
2107
2108   guestfs__switch_to_receiving (g);
2109   ctx.cb_sequence = 0;
2110   guestfs_set_reply_callback (g, aug_load_reply_cb, &ctx);
2111   (void) ml->main_loop_run (ml, g);
2112   guestfs_set_reply_callback (g, NULL, NULL);
2113   if (ctx.cb_sequence != 1001) {
2114     error (g, "%s reply failed, see earlier error messages", "guestfs_aug_load");
2115     return -1;
2116   }
2117
2118   if (check_reply_header (g, &ctx.hdr, GUESTFS_PROC_AUG_LOAD, serial) == -1)
2119     return -1;
2120
2121   if (ctx.hdr.status == GUESTFS_STATUS_ERROR) {
2122     error (g, "%s", ctx.err.error_message);
2123     return -1;
2124   }
2125
2126   return 0;
2127 }
2128
2129 struct aug_ls_ctx {
2130   /* This flag is set by the callbacks, so we know we've done
2131    * the callbacks as expected, and in the right sequence.
2132    * 0 = not called, 1 = send called,
2133    * 1001 = reply called.
2134    */
2135   int cb_sequence;
2136   struct guestfs_message_header hdr;
2137   struct guestfs_message_error err;
2138   struct guestfs_aug_ls_ret ret;
2139 };
2140
2141 static void aug_ls_reply_cb (guestfs_h *g, void *data, XDR *xdr)
2142 {
2143   guestfs_main_loop *ml = guestfs_get_main_loop (g);
2144   struct aug_ls_ctx *ctx = (struct aug_ls_ctx *) data;
2145
2146   ml->main_loop_quit (ml, g);
2147
2148   if (!xdr_guestfs_message_header (xdr, &ctx->hdr)) {
2149     error (g, "%s: failed to parse reply header", "guestfs_aug_ls");
2150     return;
2151   }
2152   if (ctx->hdr.status == GUESTFS_STATUS_ERROR) {
2153     if (!xdr_guestfs_message_error (xdr, &ctx->err)) {
2154       error (g, "%s: failed to parse reply error", "guestfs_aug_ls");
2155       return;
2156     }
2157     goto done;
2158   }
2159   if (!xdr_guestfs_aug_ls_ret (xdr, &ctx->ret)) {
2160     error (g, "%s: failed to parse reply", "guestfs_aug_ls");
2161     return;
2162   }
2163  done:
2164   ctx->cb_sequence = 1001;
2165 }
2166
2167 char **guestfs_aug_ls (guestfs_h *g,
2168                 const char *path)
2169 {
2170   struct guestfs_aug_ls_args args;
2171   struct aug_ls_ctx ctx;
2172   guestfs_main_loop *ml = guestfs_get_main_loop (g);
2173   int serial;
2174
2175   if (check_state (g, "guestfs_aug_ls") == -1) return NULL;
2176
2177   memset (&ctx, 0, sizeof ctx);
2178
2179   args.path = (char *) path;
2180   serial = guestfs__send_sync (g, GUESTFS_PROC_AUG_LS,
2181         (xdrproc_t) xdr_guestfs_aug_ls_args, (char *) &args);
2182   if (serial == -1)
2183     return NULL;
2184
2185   guestfs__switch_to_receiving (g);
2186   ctx.cb_sequence = 0;
2187   guestfs_set_reply_callback (g, aug_ls_reply_cb, &ctx);
2188   (void) ml->main_loop_run (ml, g);
2189   guestfs_set_reply_callback (g, NULL, NULL);
2190   if (ctx.cb_sequence != 1001) {
2191     error (g, "%s reply failed, see earlier error messages", "guestfs_aug_ls");
2192     return NULL;
2193   }
2194
2195   if (check_reply_header (g, &ctx.hdr, GUESTFS_PROC_AUG_LS, serial) == -1)
2196     return NULL;
2197
2198   if (ctx.hdr.status == GUESTFS_STATUS_ERROR) {
2199     error (g, "%s", ctx.err.error_message);
2200     return NULL;
2201   }
2202
2203   /* caller will free this, but we need to add a NULL entry */
2204   ctx.ret.matches.matches_val =
2205     safe_realloc (g, ctx.ret.matches.matches_val,
2206                   sizeof (char *) * (ctx.ret.matches.matches_len + 1));
2207   ctx.ret.matches.matches_val[ctx.ret.matches.matches_len] = NULL;
2208   return ctx.ret.matches.matches_val;
2209 }
2210
2211 struct rm_ctx {
2212   /* This flag is set by the callbacks, so we know we've done
2213    * the callbacks as expected, and in the right sequence.
2214    * 0 = not called, 1 = send called,
2215    * 1001 = reply called.
2216    */
2217   int cb_sequence;
2218   struct guestfs_message_header hdr;
2219   struct guestfs_message_error err;
2220 };
2221
2222 static void rm_reply_cb (guestfs_h *g, void *data, XDR *xdr)
2223 {
2224   guestfs_main_loop *ml = guestfs_get_main_loop (g);
2225   struct rm_ctx *ctx = (struct rm_ctx *) data;
2226
2227   ml->main_loop_quit (ml, g);
2228
2229   if (!xdr_guestfs_message_header (xdr, &ctx->hdr)) {
2230     error (g, "%s: failed to parse reply header", "guestfs_rm");
2231     return;
2232   }
2233   if (ctx->hdr.status == GUESTFS_STATUS_ERROR) {
2234     if (!xdr_guestfs_message_error (xdr, &ctx->err)) {
2235       error (g, "%s: failed to parse reply error", "guestfs_rm");
2236       return;
2237     }
2238     goto done;
2239   }
2240  done:
2241   ctx->cb_sequence = 1001;
2242 }
2243
2244 int guestfs_rm (guestfs_h *g,
2245                 const char *path)
2246 {
2247   struct guestfs_rm_args args;
2248   struct rm_ctx ctx;
2249   guestfs_main_loop *ml = guestfs_get_main_loop (g);
2250   int serial;
2251
2252   if (check_state (g, "guestfs_rm") == -1) return -1;
2253
2254   memset (&ctx, 0, sizeof ctx);
2255
2256   args.path = (char *) path;
2257   serial = guestfs__send_sync (g, GUESTFS_PROC_RM,
2258         (xdrproc_t) xdr_guestfs_rm_args, (char *) &args);
2259   if (serial == -1)
2260     return -1;
2261
2262   guestfs__switch_to_receiving (g);
2263   ctx.cb_sequence = 0;
2264   guestfs_set_reply_callback (g, rm_reply_cb, &ctx);
2265   (void) ml->main_loop_run (ml, g);
2266   guestfs_set_reply_callback (g, NULL, NULL);
2267   if (ctx.cb_sequence != 1001) {
2268     error (g, "%s reply failed, see earlier error messages", "guestfs_rm");
2269     return -1;
2270   }
2271
2272   if (check_reply_header (g, &ctx.hdr, GUESTFS_PROC_RM, serial) == -1)
2273     return -1;
2274
2275   if (ctx.hdr.status == GUESTFS_STATUS_ERROR) {
2276     error (g, "%s", ctx.err.error_message);
2277     return -1;
2278   }
2279
2280   return 0;
2281 }
2282
2283 struct rmdir_ctx {
2284   /* This flag is set by the callbacks, so we know we've done
2285    * the callbacks as expected, and in the right sequence.
2286    * 0 = not called, 1 = send called,
2287    * 1001 = reply called.
2288    */
2289   int cb_sequence;
2290   struct guestfs_message_header hdr;
2291   struct guestfs_message_error err;
2292 };
2293
2294 static void rmdir_reply_cb (guestfs_h *g, void *data, XDR *xdr)
2295 {
2296   guestfs_main_loop *ml = guestfs_get_main_loop (g);
2297   struct rmdir_ctx *ctx = (struct rmdir_ctx *) data;
2298
2299   ml->main_loop_quit (ml, g);
2300
2301   if (!xdr_guestfs_message_header (xdr, &ctx->hdr)) {
2302     error (g, "%s: failed to parse reply header", "guestfs_rmdir");
2303     return;
2304   }
2305   if (ctx->hdr.status == GUESTFS_STATUS_ERROR) {
2306     if (!xdr_guestfs_message_error (xdr, &ctx->err)) {
2307       error (g, "%s: failed to parse reply error", "guestfs_rmdir");
2308       return;
2309     }
2310     goto done;
2311   }
2312  done:
2313   ctx->cb_sequence = 1001;
2314 }
2315
2316 int guestfs_rmdir (guestfs_h *g,
2317                 const char *path)
2318 {
2319   struct guestfs_rmdir_args args;
2320   struct rmdir_ctx ctx;
2321   guestfs_main_loop *ml = guestfs_get_main_loop (g);
2322   int serial;
2323
2324   if (check_state (g, "guestfs_rmdir") == -1) return -1;
2325
2326   memset (&ctx, 0, sizeof ctx);
2327
2328   args.path = (char *) path;
2329   serial = guestfs__send_sync (g, GUESTFS_PROC_RMDIR,
2330         (xdrproc_t) xdr_guestfs_rmdir_args, (char *) &args);
2331   if (serial == -1)
2332     return -1;
2333
2334   guestfs__switch_to_receiving (g);
2335   ctx.cb_sequence = 0;
2336   guestfs_set_reply_callback (g, rmdir_reply_cb, &ctx);
2337   (void) ml->main_loop_run (ml, g);
2338   guestfs_set_reply_callback (g, NULL, NULL);
2339   if (ctx.cb_sequence != 1001) {
2340     error (g, "%s reply failed, see earlier error messages", "guestfs_rmdir");
2341     return -1;
2342   }
2343
2344   if (check_reply_header (g, &ctx.hdr, GUESTFS_PROC_RMDIR, serial) == -1)
2345     return -1;
2346
2347   if (ctx.hdr.status == GUESTFS_STATUS_ERROR) {
2348     error (g, "%s", ctx.err.error_message);
2349     return -1;
2350   }
2351
2352   return 0;
2353 }
2354
2355 struct rm_rf_ctx {
2356   /* This flag is set by the callbacks, so we know we've done
2357    * the callbacks as expected, and in the right sequence.
2358    * 0 = not called, 1 = send called,
2359    * 1001 = reply called.
2360    */
2361   int cb_sequence;
2362   struct guestfs_message_header hdr;
2363   struct guestfs_message_error err;
2364 };
2365
2366 static void rm_rf_reply_cb (guestfs_h *g, void *data, XDR *xdr)
2367 {
2368   guestfs_main_loop *ml = guestfs_get_main_loop (g);
2369   struct rm_rf_ctx *ctx = (struct rm_rf_ctx *) data;
2370
2371   ml->main_loop_quit (ml, g);
2372
2373   if (!xdr_guestfs_message_header (xdr, &ctx->hdr)) {
2374     error (g, "%s: failed to parse reply header", "guestfs_rm_rf");
2375     return;
2376   }
2377   if (ctx->hdr.status == GUESTFS_STATUS_ERROR) {
2378     if (!xdr_guestfs_message_error (xdr, &ctx->err)) {
2379       error (g, "%s: failed to parse reply error", "guestfs_rm_rf");
2380       return;
2381     }
2382     goto done;
2383   }
2384  done:
2385   ctx->cb_sequence = 1001;
2386 }
2387
2388 int guestfs_rm_rf (guestfs_h *g,
2389                 const char *path)
2390 {
2391   struct guestfs_rm_rf_args args;
2392   struct rm_rf_ctx ctx;
2393   guestfs_main_loop *ml = guestfs_get_main_loop (g);
2394   int serial;
2395
2396   if (check_state (g, "guestfs_rm_rf") == -1) return -1;
2397
2398   memset (&ctx, 0, sizeof ctx);
2399
2400   args.path = (char *) path;
2401   serial = guestfs__send_sync (g, GUESTFS_PROC_RM_RF,
2402         (xdrproc_t) xdr_guestfs_rm_rf_args, (char *) &args);
2403   if (serial == -1)
2404     return -1;
2405
2406   guestfs__switch_to_receiving (g);
2407   ctx.cb_sequence = 0;
2408   guestfs_set_reply_callback (g, rm_rf_reply_cb, &ctx);
2409   (void) ml->main_loop_run (ml, g);
2410   guestfs_set_reply_callback (g, NULL, NULL);
2411   if (ctx.cb_sequence != 1001) {
2412     error (g, "%s reply failed, see earlier error messages", "guestfs_rm_rf");
2413     return -1;
2414   }
2415
2416   if (check_reply_header (g, &ctx.hdr, GUESTFS_PROC_RM_RF, serial) == -1)
2417     return -1;
2418
2419   if (ctx.hdr.status == GUESTFS_STATUS_ERROR) {
2420     error (g, "%s", ctx.err.error_message);
2421     return -1;
2422   }
2423
2424   return 0;
2425 }
2426
2427 struct mkdir_ctx {
2428   /* This flag is set by the callbacks, so we know we've done
2429    * the callbacks as expected, and in the right sequence.
2430    * 0 = not called, 1 = send called,
2431    * 1001 = reply called.
2432    */
2433   int cb_sequence;
2434   struct guestfs_message_header hdr;
2435   struct guestfs_message_error err;
2436 };
2437
2438 static void mkdir_reply_cb (guestfs_h *g, void *data, XDR *xdr)
2439 {
2440   guestfs_main_loop *ml = guestfs_get_main_loop (g);
2441   struct mkdir_ctx *ctx = (struct mkdir_ctx *) data;
2442
2443   ml->main_loop_quit (ml, g);
2444
2445   if (!xdr_guestfs_message_header (xdr, &ctx->hdr)) {
2446     error (g, "%s: failed to parse reply header", "guestfs_mkdir");
2447     return;
2448   }
2449   if (ctx->hdr.status == GUESTFS_STATUS_ERROR) {
2450     if (!xdr_guestfs_message_error (xdr, &ctx->err)) {
2451       error (g, "%s: failed to parse reply error", "guestfs_mkdir");
2452       return;
2453     }
2454     goto done;
2455   }
2456  done:
2457   ctx->cb_sequence = 1001;
2458 }
2459
2460 int guestfs_mkdir (guestfs_h *g,
2461                 const char *path)
2462 {
2463   struct guestfs_mkdir_args args;
2464   struct mkdir_ctx ctx;
2465   guestfs_main_loop *ml = guestfs_get_main_loop (g);
2466   int serial;
2467
2468   if (check_state (g, "guestfs_mkdir") == -1) return -1;
2469
2470   memset (&ctx, 0, sizeof ctx);
2471
2472   args.path = (char *) path;
2473   serial = guestfs__send_sync (g, GUESTFS_PROC_MKDIR,
2474         (xdrproc_t) xdr_guestfs_mkdir_args, (char *) &args);
2475   if (serial == -1)
2476     return -1;
2477
2478   guestfs__switch_to_receiving (g);
2479   ctx.cb_sequence = 0;
2480   guestfs_set_reply_callback (g, mkdir_reply_cb, &ctx);
2481   (void) ml->main_loop_run (ml, g);
2482   guestfs_set_reply_callback (g, NULL, NULL);
2483   if (ctx.cb_sequence != 1001) {
2484     error (g, "%s reply failed, see earlier error messages", "guestfs_mkdir");
2485     return -1;
2486   }
2487
2488   if (check_reply_header (g, &ctx.hdr, GUESTFS_PROC_MKDIR, serial) == -1)
2489     return -1;
2490
2491   if (ctx.hdr.status == GUESTFS_STATUS_ERROR) {
2492     error (g, "%s", ctx.err.error_message);
2493     return -1;
2494   }
2495
2496   return 0;
2497 }
2498
2499 struct mkdir_p_ctx {
2500   /* This flag is set by the callbacks, so we know we've done
2501    * the callbacks as expected, and in the right sequence.
2502    * 0 = not called, 1 = send called,
2503    * 1001 = reply called.
2504    */
2505   int cb_sequence;
2506   struct guestfs_message_header hdr;
2507   struct guestfs_message_error err;
2508 };
2509
2510 static void mkdir_p_reply_cb (guestfs_h *g, void *data, XDR *xdr)
2511 {
2512   guestfs_main_loop *ml = guestfs_get_main_loop (g);
2513   struct mkdir_p_ctx *ctx = (struct mkdir_p_ctx *) data;
2514
2515   ml->main_loop_quit (ml, g);
2516
2517   if (!xdr_guestfs_message_header (xdr, &ctx->hdr)) {
2518     error (g, "%s: failed to parse reply header", "guestfs_mkdir_p");
2519     return;
2520   }
2521   if (ctx->hdr.status == GUESTFS_STATUS_ERROR) {
2522     if (!xdr_guestfs_message_error (xdr, &ctx->err)) {
2523       error (g, "%s: failed to parse reply error", "guestfs_mkdir_p");
2524       return;
2525     }
2526     goto done;
2527   }
2528  done:
2529   ctx->cb_sequence = 1001;
2530 }
2531
2532 int guestfs_mkdir_p (guestfs_h *g,
2533                 const char *path)
2534 {
2535   struct guestfs_mkdir_p_args args;
2536   struct mkdir_p_ctx ctx;
2537   guestfs_main_loop *ml = guestfs_get_main_loop (g);
2538   int serial;
2539
2540   if (check_state (g, "guestfs_mkdir_p") == -1) return -1;
2541
2542   memset (&ctx, 0, sizeof ctx);
2543
2544   args.path = (char *) path;
2545   serial = guestfs__send_sync (g, GUESTFS_PROC_MKDIR_P,
2546         (xdrproc_t) xdr_guestfs_mkdir_p_args, (char *) &args);
2547   if (serial == -1)
2548     return -1;
2549
2550   guestfs__switch_to_receiving (g);
2551   ctx.cb_sequence = 0;
2552   guestfs_set_reply_callback (g, mkdir_p_reply_cb, &ctx);
2553   (void) ml->main_loop_run (ml, g);
2554   guestfs_set_reply_callback (g, NULL, NULL);
2555   if (ctx.cb_sequence != 1001) {
2556     error (g, "%s reply failed, see earlier error messages", "guestfs_mkdir_p");
2557     return -1;
2558   }
2559
2560   if (check_reply_header (g, &ctx.hdr, GUESTFS_PROC_MKDIR_P, serial) == -1)
2561     return -1;
2562
2563   if (ctx.hdr.status == GUESTFS_STATUS_ERROR) {
2564     error (g, "%s", ctx.err.error_message);
2565     return -1;
2566   }
2567
2568   return 0;
2569 }
2570
2571 struct chmod_ctx {
2572   /* This flag is set by the callbacks, so we know we've done
2573    * the callbacks as expected, and in the right sequence.
2574    * 0 = not called, 1 = send called,
2575    * 1001 = reply called.
2576    */
2577   int cb_sequence;
2578   struct guestfs_message_header hdr;
2579   struct guestfs_message_error err;
2580 };
2581
2582 static void chmod_reply_cb (guestfs_h *g, void *data, XDR *xdr)
2583 {
2584   guestfs_main_loop *ml = guestfs_get_main_loop (g);
2585   struct chmod_ctx *ctx = (struct chmod_ctx *) data;
2586
2587   ml->main_loop_quit (ml, g);
2588
2589   if (!xdr_guestfs_message_header (xdr, &ctx->hdr)) {
2590     error (g, "%s: failed to parse reply header", "guestfs_chmod");
2591     return;
2592   }
2593   if (ctx->hdr.status == GUESTFS_STATUS_ERROR) {
2594     if (!xdr_guestfs_message_error (xdr, &ctx->err)) {
2595       error (g, "%s: failed to parse reply error", "guestfs_chmod");
2596       return;
2597     }
2598     goto done;
2599   }
2600  done:
2601   ctx->cb_sequence = 1001;
2602 }
2603
2604 int guestfs_chmod (guestfs_h *g,
2605                 int mode,
2606                 const char *path)
2607 {
2608   struct guestfs_chmod_args args;
2609   struct chmod_ctx ctx;
2610   guestfs_main_loop *ml = guestfs_get_main_loop (g);
2611   int serial;
2612
2613   if (check_state (g, "guestfs_chmod") == -1) return -1;
2614
2615   memset (&ctx, 0, sizeof ctx);
2616
2617   args.mode = mode;
2618   args.path = (char *) path;
2619   serial = guestfs__send_sync (g, GUESTFS_PROC_CHMOD,
2620         (xdrproc_t) xdr_guestfs_chmod_args, (char *) &args);
2621   if (serial == -1)
2622     return -1;
2623
2624   guestfs__switch_to_receiving (g);
2625   ctx.cb_sequence = 0;
2626   guestfs_set_reply_callback (g, chmod_reply_cb, &ctx);
2627   (void) ml->main_loop_run (ml, g);
2628   guestfs_set_reply_callback (g, NULL, NULL);
2629   if (ctx.cb_sequence != 1001) {
2630     error (g, "%s reply failed, see earlier error messages", "guestfs_chmod");
2631     return -1;
2632   }
2633
2634   if (check_reply_header (g, &ctx.hdr, GUESTFS_PROC_CHMOD, serial) == -1)
2635     return -1;
2636
2637   if (ctx.hdr.status == GUESTFS_STATUS_ERROR) {
2638     error (g, "%s", ctx.err.error_message);
2639     return -1;
2640   }
2641
2642   return 0;
2643 }
2644
2645 struct chown_ctx {
2646   /* This flag is set by the callbacks, so we know we've done
2647    * the callbacks as expected, and in the right sequence.
2648    * 0 = not called, 1 = send called,
2649    * 1001 = reply called.
2650    */
2651   int cb_sequence;
2652   struct guestfs_message_header hdr;
2653   struct guestfs_message_error err;
2654 };
2655
2656 static void chown_reply_cb (guestfs_h *g, void *data, XDR *xdr)
2657 {
2658   guestfs_main_loop *ml = guestfs_get_main_loop (g);
2659   struct chown_ctx *ctx = (struct chown_ctx *) data;
2660
2661   ml->main_loop_quit (ml, g);
2662
2663   if (!xdr_guestfs_message_header (xdr, &ctx->hdr)) {
2664     error (g, "%s: failed to parse reply header", "guestfs_chown");
2665     return;
2666   }
2667   if (ctx->hdr.status == GUESTFS_STATUS_ERROR) {
2668     if (!xdr_guestfs_message_error (xdr, &ctx->err)) {
2669       error (g, "%s: failed to parse reply error", "guestfs_chown");
2670       return;
2671     }
2672     goto done;
2673   }
2674  done:
2675   ctx->cb_sequence = 1001;
2676 }
2677
2678 int guestfs_chown (guestfs_h *g,
2679                 int owner,
2680                 int group,
2681                 const char *path)
2682 {
2683   struct guestfs_chown_args args;
2684   struct chown_ctx ctx;
2685   guestfs_main_loop *ml = guestfs_get_main_loop (g);
2686   int serial;
2687
2688   if (check_state (g, "guestfs_chown") == -1) return -1;
2689
2690   memset (&ctx, 0, sizeof ctx);
2691
2692   args.owner = owner;
2693   args.group = group;
2694   args.path = (char *) path;
2695   serial = guestfs__send_sync (g, GUESTFS_PROC_CHOWN,
2696         (xdrproc_t) xdr_guestfs_chown_args, (char *) &args);
2697   if (serial == -1)
2698     return -1;
2699
2700   guestfs__switch_to_receiving (g);
2701   ctx.cb_sequence = 0;
2702   guestfs_set_reply_callback (g, chown_reply_cb, &ctx);
2703   (void) ml->main_loop_run (ml, g);
2704   guestfs_set_reply_callback (g, NULL, NULL);
2705   if (ctx.cb_sequence != 1001) {
2706     error (g, "%s reply failed, see earlier error messages", "guestfs_chown");
2707     return -1;
2708   }
2709
2710   if (check_reply_header (g, &ctx.hdr, GUESTFS_PROC_CHOWN, serial) == -1)
2711     return -1;
2712
2713   if (ctx.hdr.status == GUESTFS_STATUS_ERROR) {
2714     error (g, "%s", ctx.err.error_message);
2715     return -1;
2716   }
2717
2718   return 0;
2719 }
2720
2721 struct exists_ctx {
2722   /* This flag is set by the callbacks, so we know we've done
2723    * the callbacks as expected, and in the right sequence.
2724    * 0 = not called, 1 = send called,
2725    * 1001 = reply called.
2726    */
2727   int cb_sequence;
2728   struct guestfs_message_header hdr;
2729   struct guestfs_message_error err;
2730   struct guestfs_exists_ret ret;
2731 };
2732
2733 static void exists_reply_cb (guestfs_h *g, void *data, XDR *xdr)
2734 {
2735   guestfs_main_loop *ml = guestfs_get_main_loop (g);
2736   struct exists_ctx *ctx = (struct exists_ctx *) data;
2737
2738   ml->main_loop_quit (ml, g);
2739
2740   if (!xdr_guestfs_message_header (xdr, &ctx->hdr)) {
2741     error (g, "%s: failed to parse reply header", "guestfs_exists");
2742     return;
2743   }
2744   if (ctx->hdr.status == GUESTFS_STATUS_ERROR) {
2745     if (!xdr_guestfs_message_error (xdr, &ctx->err)) {
2746       error (g, "%s: failed to parse reply error", "guestfs_exists");
2747       return;
2748     }
2749     goto done;
2750   }
2751   if (!xdr_guestfs_exists_ret (xdr, &ctx->ret)) {
2752     error (g, "%s: failed to parse reply", "guestfs_exists");
2753     return;
2754   }
2755  done:
2756   ctx->cb_sequence = 1001;
2757 }
2758
2759 int guestfs_exists (guestfs_h *g,
2760                 const char *path)
2761 {
2762   struct guestfs_exists_args args;
2763   struct exists_ctx ctx;
2764   guestfs_main_loop *ml = guestfs_get_main_loop (g);
2765   int serial;
2766
2767   if (check_state (g, "guestfs_exists") == -1) return -1;
2768
2769   memset (&ctx, 0, sizeof ctx);
2770
2771   args.path = (char *) path;
2772   serial = guestfs__send_sync (g, GUESTFS_PROC_EXISTS,
2773         (xdrproc_t) xdr_guestfs_exists_args, (char *) &args);
2774   if (serial == -1)
2775     return -1;
2776
2777   guestfs__switch_to_receiving (g);
2778   ctx.cb_sequence = 0;
2779   guestfs_set_reply_callback (g, exists_reply_cb, &ctx);
2780   (void) ml->main_loop_run (ml, g);
2781   guestfs_set_reply_callback (g, NULL, NULL);
2782   if (ctx.cb_sequence != 1001) {
2783     error (g, "%s reply failed, see earlier error messages", "guestfs_exists");
2784     return -1;
2785   }
2786
2787   if (check_reply_header (g, &ctx.hdr, GUESTFS_PROC_EXISTS, serial) == -1)
2788     return -1;
2789
2790   if (ctx.hdr.status == GUESTFS_STATUS_ERROR) {
2791     error (g, "%s", ctx.err.error_message);
2792     return -1;
2793   }
2794
2795   return ctx.ret.existsflag;
2796 }
2797
2798 struct is_file_ctx {
2799   /* This flag is set by the callbacks, so we know we've done
2800    * the callbacks as expected, and in the right sequence.
2801    * 0 = not called, 1 = send called,
2802    * 1001 = reply called.
2803    */
2804   int cb_sequence;
2805   struct guestfs_message_header hdr;
2806   struct guestfs_message_error err;
2807   struct guestfs_is_file_ret ret;
2808 };
2809
2810 static void is_file_reply_cb (guestfs_h *g, void *data, XDR *xdr)
2811 {
2812   guestfs_main_loop *ml = guestfs_get_main_loop (g);
2813   struct is_file_ctx *ctx = (struct is_file_ctx *) data;
2814
2815   ml->main_loop_quit (ml, g);
2816
2817   if (!xdr_guestfs_message_header (xdr, &ctx->hdr)) {
2818     error (g, "%s: failed to parse reply header", "guestfs_is_file");
2819     return;
2820   }
2821   if (ctx->hdr.status == GUESTFS_STATUS_ERROR) {
2822     if (!xdr_guestfs_message_error (xdr, &ctx->err)) {
2823       error (g, "%s: failed to parse reply error", "guestfs_is_file");
2824       return;
2825     }
2826     goto done;
2827   }
2828   if (!xdr_guestfs_is_file_ret (xdr, &ctx->ret)) {
2829     error (g, "%s: failed to parse reply", "guestfs_is_file");
2830     return;
2831   }
2832  done:
2833   ctx->cb_sequence = 1001;
2834 }
2835
2836 int guestfs_is_file (guestfs_h *g,
2837                 const char *path)
2838 {
2839   struct guestfs_is_file_args args;
2840   struct is_file_ctx ctx;
2841   guestfs_main_loop *ml = guestfs_get_main_loop (g);
2842   int serial;
2843
2844   if (check_state (g, "guestfs_is_file") == -1) return -1;
2845
2846   memset (&ctx, 0, sizeof ctx);
2847
2848   args.path = (char *) path;
2849   serial = guestfs__send_sync (g, GUESTFS_PROC_IS_FILE,
2850         (xdrproc_t) xdr_guestfs_is_file_args, (char *) &args);
2851   if (serial == -1)
2852     return -1;
2853
2854   guestfs__switch_to_receiving (g);
2855   ctx.cb_sequence = 0;
2856   guestfs_set_reply_callback (g, is_file_reply_cb, &ctx);
2857   (void) ml->main_loop_run (ml, g);
2858   guestfs_set_reply_callback (g, NULL, NULL);
2859   if (ctx.cb_sequence != 1001) {
2860     error (g, "%s reply failed, see earlier error messages", "guestfs_is_file");
2861     return -1;
2862   }
2863
2864   if (check_reply_header (g, &ctx.hdr, GUESTFS_PROC_IS_FILE, serial) == -1)
2865     return -1;
2866
2867   if (ctx.hdr.status == GUESTFS_STATUS_ERROR) {
2868     error (g, "%s", ctx.err.error_message);
2869     return -1;
2870   }
2871
2872   return ctx.ret.fileflag;
2873 }
2874
2875 struct is_dir_ctx {
2876   /* This flag is set by the callbacks, so we know we've done
2877    * the callbacks as expected, and in the right sequence.
2878    * 0 = not called, 1 = send called,
2879    * 1001 = reply called.
2880    */
2881   int cb_sequence;
2882   struct guestfs_message_header hdr;
2883   struct guestfs_message_error err;
2884   struct guestfs_is_dir_ret ret;
2885 };
2886
2887 static void is_dir_reply_cb (guestfs_h *g, void *data, XDR *xdr)
2888 {
2889   guestfs_main_loop *ml = guestfs_get_main_loop (g);
2890   struct is_dir_ctx *ctx = (struct is_dir_ctx *) data;
2891
2892   ml->main_loop_quit (ml, g);
2893
2894   if (!xdr_guestfs_message_header (xdr, &ctx->hdr)) {
2895     error (g, "%s: failed to parse reply header", "guestfs_is_dir");
2896     return;
2897   }
2898   if (ctx->hdr.status == GUESTFS_STATUS_ERROR) {
2899     if (!xdr_guestfs_message_error (xdr, &ctx->err)) {
2900       error (g, "%s: failed to parse reply error", "guestfs_is_dir");
2901       return;
2902     }
2903     goto done;
2904   }
2905   if (!xdr_guestfs_is_dir_ret (xdr, &ctx->ret)) {
2906     error (g, "%s: failed to parse reply", "guestfs_is_dir");
2907     return;
2908   }
2909  done:
2910   ctx->cb_sequence = 1001;
2911 }
2912
2913 int guestfs_is_dir (guestfs_h *g,
2914                 const char *path)
2915 {
2916   struct guestfs_is_dir_args args;
2917   struct is_dir_ctx ctx;
2918   guestfs_main_loop *ml = guestfs_get_main_loop (g);
2919   int serial;
2920
2921   if (check_state (g, "guestfs_is_dir") == -1) return -1;
2922
2923   memset (&ctx, 0, sizeof ctx);
2924
2925   args.path = (char *) path;
2926   serial = guestfs__send_sync (g, GUESTFS_PROC_IS_DIR,
2927         (xdrproc_t) xdr_guestfs_is_dir_args, (char *) &args);
2928   if (serial == -1)
2929     return -1;
2930
2931   guestfs__switch_to_receiving (g);
2932   ctx.cb_sequence = 0;
2933   guestfs_set_reply_callback (g, is_dir_reply_cb, &ctx);
2934   (void) ml->main_loop_run (ml, g);
2935   guestfs_set_reply_callback (g, NULL, NULL);
2936   if (ctx.cb_sequence != 1001) {
2937     error (g, "%s reply failed, see earlier error messages", "guestfs_is_dir");
2938     return -1;
2939   }
2940
2941   if (check_reply_header (g, &ctx.hdr, GUESTFS_PROC_IS_DIR, serial) == -1)
2942     return -1;
2943
2944   if (ctx.hdr.status == GUESTFS_STATUS_ERROR) {
2945     error (g, "%s", ctx.err.error_message);
2946     return -1;
2947   }
2948
2949   return ctx.ret.dirflag;
2950 }
2951
2952 struct pvcreate_ctx {
2953   /* This flag is set by the callbacks, so we know we've done
2954    * the callbacks as expected, and in the right sequence.
2955    * 0 = not called, 1 = send called,
2956    * 1001 = reply called.
2957    */
2958   int cb_sequence;
2959   struct guestfs_message_header hdr;
2960   struct guestfs_message_error err;
2961 };
2962
2963 static void pvcreate_reply_cb (guestfs_h *g, void *data, XDR *xdr)
2964 {
2965   guestfs_main_loop *ml = guestfs_get_main_loop (g);
2966   struct pvcreate_ctx *ctx = (struct pvcreate_ctx *) data;
2967
2968   ml->main_loop_quit (ml, g);
2969
2970   if (!xdr_guestfs_message_header (xdr, &ctx->hdr)) {
2971     error (g, "%s: failed to parse reply header", "guestfs_pvcreate");
2972     return;
2973   }
2974   if (ctx->hdr.status == GUESTFS_STATUS_ERROR) {
2975     if (!xdr_guestfs_message_error (xdr, &ctx->err)) {
2976       error (g, "%s: failed to parse reply error", "guestfs_pvcreate");
2977       return;
2978     }
2979     goto done;
2980   }
2981  done:
2982   ctx->cb_sequence = 1001;
2983 }
2984
2985 int guestfs_pvcreate (guestfs_h *g,
2986                 const char *device)
2987 {
2988   struct guestfs_pvcreate_args args;
2989   struct pvcreate_ctx ctx;
2990   guestfs_main_loop *ml = guestfs_get_main_loop (g);
2991   int serial;
2992
2993   if (check_state (g, "guestfs_pvcreate") == -1) return -1;
2994
2995   memset (&ctx, 0, sizeof ctx);
2996
2997   args.device = (char *) device;
2998   serial = guestfs__send_sync (g, GUESTFS_PROC_PVCREATE,
2999         (xdrproc_t) xdr_guestfs_pvcreate_args, (char *) &args);
3000   if (serial == -1)
3001     return -1;
3002
3003   guestfs__switch_to_receiving (g);
3004   ctx.cb_sequence = 0;
3005   guestfs_set_reply_callback (g, pvcreate_reply_cb, &ctx);
3006   (void) ml->main_loop_run (ml, g);
3007   guestfs_set_reply_callback (g, NULL, NULL);
3008   if (ctx.cb_sequence != 1001) {
3009     error (g, "%s reply failed, see earlier error messages", "guestfs_pvcreate");
3010     return -1;
3011   }
3012
3013   if (check_reply_header (g, &ctx.hdr, GUESTFS_PROC_PVCREATE, serial) == -1)
3014     return -1;
3015
3016   if (ctx.hdr.status == GUESTFS_STATUS_ERROR) {
3017     error (g, "%s", ctx.err.error_message);
3018     return -1;
3019   }
3020
3021   return 0;
3022 }
3023
3024 struct vgcreate_ctx {
3025   /* This flag is set by the callbacks, so we know we've done
3026    * the callbacks as expected, and in the right sequence.
3027    * 0 = not called, 1 = send called,
3028    * 1001 = reply called.
3029    */
3030   int cb_sequence;
3031   struct guestfs_message_header hdr;
3032   struct guestfs_message_error err;
3033 };
3034
3035 static void vgcreate_reply_cb (guestfs_h *g, void *data, XDR *xdr)
3036 {
3037   guestfs_main_loop *ml = guestfs_get_main_loop (g);
3038   struct vgcreate_ctx *ctx = (struct vgcreate_ctx *) data;
3039
3040   ml->main_loop_quit (ml, g);
3041
3042   if (!xdr_guestfs_message_header (xdr, &ctx->hdr)) {
3043     error (g, "%s: failed to parse reply header", "guestfs_vgcreate");
3044     return;
3045   }
3046   if (ctx->hdr.status == GUESTFS_STATUS_ERROR) {
3047     if (!xdr_guestfs_message_error (xdr, &ctx->err)) {
3048       error (g, "%s: failed to parse reply error", "guestfs_vgcreate");
3049       return;
3050     }
3051     goto done;
3052   }
3053  done:
3054   ctx->cb_sequence = 1001;
3055 }
3056
3057 int guestfs_vgcreate (guestfs_h *g,
3058                 const char *volgroup,
3059                 char * const* const physvols)
3060 {
3061   struct guestfs_vgcreate_args args;
3062   struct vgcreate_ctx ctx;
3063   guestfs_main_loop *ml = guestfs_get_main_loop (g);
3064   int serial;
3065
3066   if (check_state (g, "guestfs_vgcreate") == -1) return -1;
3067
3068   memset (&ctx, 0, sizeof ctx);
3069
3070   args.volgroup = (char *) volgroup;
3071   args.physvols.physvols_val = (char **) physvols;
3072   for (args.physvols.physvols_len = 0; physvols[args.physvols.physvols_len]; args.physvols.physvols_len++) ;
3073   serial = guestfs__send_sync (g, GUESTFS_PROC_VGCREATE,
3074         (xdrproc_t) xdr_guestfs_vgcreate_args, (char *) &args);
3075   if (serial == -1)
3076     return -1;
3077
3078   guestfs__switch_to_receiving (g);
3079   ctx.cb_sequence = 0;
3080   guestfs_set_reply_callback (g, vgcreate_reply_cb, &ctx);
3081   (void) ml->main_loop_run (ml, g);
3082   guestfs_set_reply_callback (g, NULL, NULL);
3083   if (ctx.cb_sequence != 1001) {
3084     error (g, "%s reply failed, see earlier error messages", "guestfs_vgcreate");
3085     return -1;
3086   }
3087
3088   if (check_reply_header (g, &ctx.hdr, GUESTFS_PROC_VGCREATE, serial) == -1)
3089     return -1;
3090
3091   if (ctx.hdr.status == GUESTFS_STATUS_ERROR) {
3092     error (g, "%s", ctx.err.error_message);
3093     return -1;
3094   }
3095
3096   return 0;
3097 }
3098
3099 struct lvcreate_ctx {
3100   /* This flag is set by the callbacks, so we know we've done
3101    * the callbacks as expected, and in the right sequence.
3102    * 0 = not called, 1 = send called,
3103    * 1001 = reply called.
3104    */
3105   int cb_sequence;
3106   struct guestfs_message_header hdr;
3107   struct guestfs_message_error err;
3108 };
3109
3110 static void lvcreate_reply_cb (guestfs_h *g, void *data, XDR *xdr)
3111 {
3112   guestfs_main_loop *ml = guestfs_get_main_loop (g);
3113   struct lvcreate_ctx *ctx = (struct lvcreate_ctx *) data;
3114
3115   ml->main_loop_quit (ml, g);
3116
3117   if (!xdr_guestfs_message_header (xdr, &ctx->hdr)) {
3118     error (g, "%s: failed to parse reply header", "guestfs_lvcreate");
3119     return;
3120   }
3121   if (ctx->hdr.status == GUESTFS_STATUS_ERROR) {
3122     if (!xdr_guestfs_message_error (xdr, &ctx->err)) {
3123       error (g, "%s: failed to parse reply error", "guestfs_lvcreate");
3124       return;
3125     }
3126     goto done;
3127   }
3128  done:
3129   ctx->cb_sequence = 1001;
3130 }
3131
3132 int guestfs_lvcreate (guestfs_h *g,
3133                 const char *logvol,
3134                 const char *volgroup,
3135                 int mbytes)
3136 {
3137   struct guestfs_lvcreate_args args;
3138   struct lvcreate_ctx ctx;
3139   guestfs_main_loop *ml = guestfs_get_main_loop (g);
3140   int serial;
3141
3142   if (check_state (g, "guestfs_lvcreate") == -1) return -1;
3143
3144   memset (&ctx, 0, sizeof ctx);
3145
3146   args.logvol = (char *) logvol;
3147   args.volgroup = (char *) volgroup;
3148   args.mbytes = mbytes;
3149   serial = guestfs__send_sync (g, GUESTFS_PROC_LVCREATE,
3150         (xdrproc_t) xdr_guestfs_lvcreate_args, (char *) &args);
3151   if (serial == -1)
3152     return -1;
3153
3154   guestfs__switch_to_receiving (g);
3155   ctx.cb_sequence = 0;
3156   guestfs_set_reply_callback (g, lvcreate_reply_cb, &ctx);
3157   (void) ml->main_loop_run (ml, g);
3158   guestfs_set_reply_callback (g, NULL, NULL);
3159   if (ctx.cb_sequence != 1001) {
3160     error (g, "%s reply failed, see earlier error messages", "guestfs_lvcreate");
3161     return -1;
3162   }
3163
3164   if (check_reply_header (g, &ctx.hdr, GUESTFS_PROC_LVCREATE, serial) == -1)
3165     return -1;
3166
3167   if (ctx.hdr.status == GUESTFS_STATUS_ERROR) {
3168     error (g, "%s", ctx.err.error_message);
3169     return -1;
3170   }
3171
3172   return 0;
3173 }
3174
3175 struct mkfs_ctx {
3176   /* This flag is set by the callbacks, so we know we've done
3177    * the callbacks as expected, and in the right sequence.
3178    * 0 = not called, 1 = send called,
3179    * 1001 = reply called.
3180    */
3181   int cb_sequence;
3182   struct guestfs_message_header hdr;
3183   struct guestfs_message_error err;
3184 };
3185
3186 static void mkfs_reply_cb (guestfs_h *g, void *data, XDR *xdr)
3187 {
3188   guestfs_main_loop *ml = guestfs_get_main_loop (g);
3189   struct mkfs_ctx *ctx = (struct mkfs_ctx *) data;
3190
3191   ml->main_loop_quit (ml, g);
3192
3193   if (!xdr_guestfs_message_header (xdr, &ctx->hdr)) {
3194     error (g, "%s: failed to parse reply header", "guestfs_mkfs");
3195     return;
3196   }
3197   if (ctx->hdr.status == GUESTFS_STATUS_ERROR) {
3198     if (!xdr_guestfs_message_error (xdr, &ctx->err)) {
3199       error (g, "%s: failed to parse reply error", "guestfs_mkfs");
3200       return;
3201     }
3202     goto done;
3203   }
3204  done:
3205   ctx->cb_sequence = 1001;
3206 }
3207
3208 int guestfs_mkfs (guestfs_h *g,
3209                 const char *fstype,
3210                 const char *device)
3211 {
3212   struct guestfs_mkfs_args args;
3213   struct mkfs_ctx ctx;
3214   guestfs_main_loop *ml = guestfs_get_main_loop (g);
3215   int serial;
3216
3217   if (check_state (g, "guestfs_mkfs") == -1) return -1;
3218
3219   memset (&ctx, 0, sizeof ctx);
3220
3221   args.fstype = (char *) fstype;
3222   args.device = (char *) device;
3223   serial = guestfs__send_sync (g, GUESTFS_PROC_MKFS,
3224         (xdrproc_t) xdr_guestfs_mkfs_args, (char *) &args);
3225   if (serial == -1)
3226     return -1;
3227
3228   guestfs__switch_to_receiving (g);
3229   ctx.cb_sequence = 0;
3230   guestfs_set_reply_callback (g, mkfs_reply_cb, &ctx);
3231   (void) ml->main_loop_run (ml, g);
3232   guestfs_set_reply_callback (g, NULL, NULL);
3233   if (ctx.cb_sequence != 1001) {
3234     error (g, "%s reply failed, see earlier error messages", "guestfs_mkfs");
3235     return -1;
3236   }
3237
3238   if (check_reply_header (g, &ctx.hdr, GUESTFS_PROC_MKFS, serial) == -1)
3239     return -1;
3240
3241   if (ctx.hdr.status == GUESTFS_STATUS_ERROR) {
3242     error (g, "%s", ctx.err.error_message);
3243     return -1;
3244   }
3245
3246   return 0;
3247 }
3248
3249 struct sfdisk_ctx {
3250   /* This flag is set by the callbacks, so we know we've done
3251    * the callbacks as expected, and in the right sequence.
3252    * 0 = not called, 1 = send called,
3253    * 1001 = reply called.
3254    */
3255   int cb_sequence;
3256   struct guestfs_message_header hdr;
3257   struct guestfs_message_error err;
3258 };
3259
3260 static void sfdisk_reply_cb (guestfs_h *g, void *data, XDR *xdr)
3261 {
3262   guestfs_main_loop *ml = guestfs_get_main_loop (g);
3263   struct sfdisk_ctx *ctx = (struct sfdisk_ctx *) data;
3264
3265   ml->main_loop_quit (ml, g);
3266
3267   if (!xdr_guestfs_message_header (xdr, &ctx->hdr)) {
3268     error (g, "%s: failed to parse reply header", "guestfs_sfdisk");
3269     return;
3270   }
3271   if (ctx->hdr.status == GUESTFS_STATUS_ERROR) {
3272     if (!xdr_guestfs_message_error (xdr, &ctx->err)) {
3273       error (g, "%s: failed to parse reply error", "guestfs_sfdisk");
3274       return;
3275     }
3276     goto done;
3277   }
3278  done:
3279   ctx->cb_sequence = 1001;
3280 }
3281
3282 int guestfs_sfdisk (guestfs_h *g,
3283                 const char *device,
3284                 int cyls,
3285                 int heads,
3286                 int sectors,
3287                 char * const* const lines)
3288 {
3289   struct guestfs_sfdisk_args args;
3290   struct sfdisk_ctx ctx;
3291   guestfs_main_loop *ml = guestfs_get_main_loop (g);
3292   int serial;
3293
3294   if (check_state (g, "guestfs_sfdisk") == -1) return -1;
3295
3296   memset (&ctx, 0, sizeof ctx);
3297
3298   args.device = (char *) device;
3299   args.cyls = cyls;
3300   args.heads = heads;
3301   args.sectors = sectors;
3302   args.lines.lines_val = (char **) lines;
3303   for (args.lines.lines_len = 0; lines[args.lines.lines_len]; args.lines.lines_len++) ;
3304   serial = guestfs__send_sync (g, GUESTFS_PROC_SFDISK,
3305         (xdrproc_t) xdr_guestfs_sfdisk_args, (char *) &args);
3306   if (serial == -1)
3307     return -1;
3308
3309   guestfs__switch_to_receiving (g);
3310   ctx.cb_sequence = 0;
3311   guestfs_set_reply_callback (g, sfdisk_reply_cb, &ctx);
3312   (void) ml->main_loop_run (ml, g);
3313   guestfs_set_reply_callback (g, NULL, NULL);
3314   if (ctx.cb_sequence != 1001) {
3315     error (g, "%s reply failed, see earlier error messages", "guestfs_sfdisk");
3316     return -1;
3317   }
3318
3319   if (check_reply_header (g, &ctx.hdr, GUESTFS_PROC_SFDISK, serial) == -1)
3320     return -1;
3321
3322   if (ctx.hdr.status == GUESTFS_STATUS_ERROR) {
3323     error (g, "%s", ctx.err.error_message);
3324     return -1;
3325   }
3326
3327   return 0;
3328 }
3329
3330 struct write_file_ctx {
3331   /* This flag is set by the callbacks, so we know we've done
3332    * the callbacks as expected, and in the right sequence.
3333    * 0 = not called, 1 = send called,
3334    * 1001 = reply called.
3335    */
3336   int cb_sequence;
3337   struct guestfs_message_header hdr;
3338   struct guestfs_message_error err;
3339 };
3340
3341 static void write_file_reply_cb (guestfs_h *g, void *data, XDR *xdr)
3342 {
3343   guestfs_main_loop *ml = guestfs_get_main_loop (g);
3344   struct write_file_ctx *ctx = (struct write_file_ctx *) data;
3345
3346   ml->main_loop_quit (ml, g);
3347
3348   if (!xdr_guestfs_message_header (xdr, &ctx->hdr)) {
3349     error (g, "%s: failed to parse reply header", "guestfs_write_file");
3350     return;
3351   }
3352   if (ctx->hdr.status == GUESTFS_STATUS_ERROR) {
3353     if (!xdr_guestfs_message_error (xdr, &ctx->err)) {
3354       error (g, "%s: failed to parse reply error", "guestfs_write_file");
3355       return;
3356     }
3357     goto done;
3358   }
3359  done:
3360   ctx->cb_sequence = 1001;
3361 }
3362
3363 int guestfs_write_file (guestfs_h *g,
3364                 const char *path,
3365                 const char *content,
3366                 int size)
3367 {
3368   struct guestfs_write_file_args args;
3369   struct write_file_ctx ctx;
3370   guestfs_main_loop *ml = guestfs_get_main_loop (g);
3371   int serial;
3372
3373   if (check_state (g, "guestfs_write_file") == -1) return -1;
3374
3375   memset (&ctx, 0, sizeof ctx);
3376
3377   args.path = (char *) path;
3378   args.content = (char *) content;
3379   args.size = size;
3380   serial = guestfs__send_sync (g, GUESTFS_PROC_WRITE_FILE,
3381         (xdrproc_t) xdr_guestfs_write_file_args, (char *) &args);
3382   if (serial == -1)
3383     return -1;
3384
3385   guestfs__switch_to_receiving (g);
3386   ctx.cb_sequence = 0;
3387   guestfs_set_reply_callback (g, write_file_reply_cb, &ctx);
3388   (void) ml->main_loop_run (ml, g);
3389   guestfs_set_reply_callback (g, NULL, NULL);
3390   if (ctx.cb_sequence != 1001) {
3391     error (g, "%s reply failed, see earlier error messages", "guestfs_write_file");
3392     return -1;
3393   }
3394
3395   if (check_reply_header (g, &ctx.hdr, GUESTFS_PROC_WRITE_FILE, serial) == -1)
3396     return -1;
3397
3398   if (ctx.hdr.status == GUESTFS_STATUS_ERROR) {
3399     error (g, "%s", ctx.err.error_message);
3400     return -1;
3401   }
3402
3403   return 0;
3404 }
3405
3406 struct umount_ctx {
3407   /* This flag is set by the callbacks, so we know we've done
3408    * the callbacks as expected, and in the right sequence.
3409    * 0 = not called, 1 = send called,
3410    * 1001 = reply called.
3411    */
3412   int cb_sequence;
3413   struct guestfs_message_header hdr;
3414   struct guestfs_message_error err;
3415 };
3416
3417 static void umount_reply_cb (guestfs_h *g, void *data, XDR *xdr)
3418 {
3419   guestfs_main_loop *ml = guestfs_get_main_loop (g);
3420   struct umount_ctx *ctx = (struct umount_ctx *) data;
3421
3422   ml->main_loop_quit (ml, g);
3423
3424   if (!xdr_guestfs_message_header (xdr, &ctx->hdr)) {
3425     error (g, "%s: failed to parse reply header", "guestfs_umount");
3426     return;
3427   }
3428   if (ctx->hdr.status == GUESTFS_STATUS_ERROR) {
3429     if (!xdr_guestfs_message_error (xdr, &ctx->err)) {
3430       error (g, "%s: failed to parse reply error", "guestfs_umount");
3431       return;
3432     }
3433     goto done;
3434   }
3435  done:
3436   ctx->cb_sequence = 1001;
3437 }
3438
3439 int guestfs_umount (guestfs_h *g,
3440                 const char *pathordevice)
3441 {
3442   struct guestfs_umount_args args;
3443   struct umount_ctx ctx;
3444   guestfs_main_loop *ml = guestfs_get_main_loop (g);
3445   int serial;
3446
3447   if (check_state (g, "guestfs_umount") == -1) return -1;
3448
3449   memset (&ctx, 0, sizeof ctx);
3450
3451   args.pathordevice = (char *) pathordevice;
3452   serial = guestfs__send_sync (g, GUESTFS_PROC_UMOUNT,
3453         (xdrproc_t) xdr_guestfs_umount_args, (char *) &args);
3454   if (serial == -1)
3455     return -1;
3456
3457   guestfs__switch_to_receiving (g);
3458   ctx.cb_sequence = 0;
3459   guestfs_set_reply_callback (g, umount_reply_cb, &ctx);
3460   (void) ml->main_loop_run (ml, g);
3461   guestfs_set_reply_callback (g, NULL, NULL);
3462   if (ctx.cb_sequence != 1001) {
3463     error (g, "%s reply failed, see earlier error messages", "guestfs_umount");
3464     return -1;
3465   }
3466
3467   if (check_reply_header (g, &ctx.hdr, GUESTFS_PROC_UMOUNT, serial) == -1)
3468     return -1;
3469
3470   if (ctx.hdr.status == GUESTFS_STATUS_ERROR) {
3471     error (g, "%s", ctx.err.error_message);
3472     return -1;
3473   }
3474
3475   return 0;
3476 }
3477
3478 struct mounts_ctx {
3479   /* This flag is set by the callbacks, so we know we've done
3480    * the callbacks as expected, and in the right sequence.
3481    * 0 = not called, 1 = send called,
3482    * 1001 = reply called.
3483    */
3484   int cb_sequence;
3485   struct guestfs_message_header hdr;
3486   struct guestfs_message_error err;
3487   struct guestfs_mounts_ret ret;
3488 };
3489
3490 static void mounts_reply_cb (guestfs_h *g, void *data, XDR *xdr)
3491 {
3492   guestfs_main_loop *ml = guestfs_get_main_loop (g);
3493   struct mounts_ctx *ctx = (struct mounts_ctx *) data;
3494
3495   ml->main_loop_quit (ml, g);
3496
3497   if (!xdr_guestfs_message_header (xdr, &ctx->hdr)) {
3498     error (g, "%s: failed to parse reply header", "guestfs_mounts");
3499     return;
3500   }
3501   if (ctx->hdr.status == GUESTFS_STATUS_ERROR) {
3502     if (!xdr_guestfs_message_error (xdr, &ctx->err)) {
3503       error (g, "%s: failed to parse reply error", "guestfs_mounts");
3504       return;
3505     }
3506     goto done;
3507   }
3508   if (!xdr_guestfs_mounts_ret (xdr, &ctx->ret)) {
3509     error (g, "%s: failed to parse reply", "guestfs_mounts");
3510     return;
3511   }
3512  done:
3513   ctx->cb_sequence = 1001;
3514 }
3515
3516 char **guestfs_mounts (guestfs_h *g)
3517 {
3518   struct mounts_ctx ctx;
3519   guestfs_main_loop *ml = guestfs_get_main_loop (g);
3520   int serial;
3521
3522   if (check_state (g, "guestfs_mounts") == -1) return NULL;
3523
3524   memset (&ctx, 0, sizeof ctx);
3525
3526   serial = guestfs__send_sync (g, GUESTFS_PROC_MOUNTS, NULL, NULL);
3527   if (serial == -1)
3528     return NULL;
3529
3530   guestfs__switch_to_receiving (g);
3531   ctx.cb_sequence = 0;
3532   guestfs_set_reply_callback (g, mounts_reply_cb, &ctx);
3533   (void) ml->main_loop_run (ml, g);
3534   guestfs_set_reply_callback (g, NULL, NULL);
3535   if (ctx.cb_sequence != 1001) {
3536     error (g, "%s reply failed, see earlier error messages", "guestfs_mounts");
3537     return NULL;
3538   }
3539
3540   if (check_reply_header (g, &ctx.hdr, GUESTFS_PROC_MOUNTS, serial) == -1)
3541     return NULL;
3542
3543   if (ctx.hdr.status == GUESTFS_STATUS_ERROR) {
3544     error (g, "%s", ctx.err.error_message);
3545     return NULL;
3546   }
3547
3548   /* caller will free this, but we need to add a NULL entry */
3549   ctx.ret.devices.devices_val =
3550     safe_realloc (g, ctx.ret.devices.devices_val,
3551                   sizeof (char *) * (ctx.ret.devices.devices_len + 1));
3552   ctx.ret.devices.devices_val[ctx.ret.devices.devices_len] = NULL;
3553   return ctx.ret.devices.devices_val;
3554 }
3555
3556 struct umount_all_ctx {
3557   /* This flag is set by the callbacks, so we know we've done
3558    * the callbacks as expected, and in the right sequence.
3559    * 0 = not called, 1 = send called,
3560    * 1001 = reply called.
3561    */
3562   int cb_sequence;
3563   struct guestfs_message_header hdr;
3564   struct guestfs_message_error err;
3565 };
3566
3567 static void umount_all_reply_cb (guestfs_h *g, void *data, XDR *xdr)
3568 {
3569   guestfs_main_loop *ml = guestfs_get_main_loop (g);
3570   struct umount_all_ctx *ctx = (struct umount_all_ctx *) data;
3571
3572   ml->main_loop_quit (ml, g);
3573
3574   if (!xdr_guestfs_message_header (xdr, &ctx->hdr)) {
3575     error (g, "%s: failed to parse reply header", "guestfs_umount_all");
3576     return;
3577   }
3578   if (ctx->hdr.status == GUESTFS_STATUS_ERROR) {
3579     if (!xdr_guestfs_message_error (xdr, &ctx->err)) {
3580       error (g, "%s: failed to parse reply error", "guestfs_umount_all");
3581       return;
3582     }
3583     goto done;
3584   }
3585  done:
3586   ctx->cb_sequence = 1001;
3587 }
3588
3589 int guestfs_umount_all (guestfs_h *g)
3590 {
3591   struct umount_all_ctx ctx;
3592   guestfs_main_loop *ml = guestfs_get_main_loop (g);
3593   int serial;
3594
3595   if (check_state (g, "guestfs_umount_all") == -1) return -1;
3596
3597   memset (&ctx, 0, sizeof ctx);
3598
3599   serial = guestfs__send_sync (g, GUESTFS_PROC_UMOUNT_ALL, NULL, NULL);
3600   if (serial == -1)
3601     return -1;
3602
3603   guestfs__switch_to_receiving (g);
3604   ctx.cb_sequence = 0;
3605   guestfs_set_reply_callback (g, umount_all_reply_cb, &ctx);
3606   (void) ml->main_loop_run (ml, g);
3607   guestfs_set_reply_callback (g, NULL, NULL);
3608   if (ctx.cb_sequence != 1001) {
3609     error (g, "%s reply failed, see earlier error messages", "guestfs_umount_all");
3610     return -1;
3611   }
3612
3613   if (check_reply_header (g, &ctx.hdr, GUESTFS_PROC_UMOUNT_ALL, serial) == -1)
3614     return -1;
3615
3616   if (ctx.hdr.status == GUESTFS_STATUS_ERROR) {
3617     error (g, "%s", ctx.err.error_message);
3618     return -1;
3619   }
3620
3621   return 0;
3622 }
3623
3624 struct lvm_remove_all_ctx {
3625   /* This flag is set by the callbacks, so we know we've done
3626    * the callbacks as expected, and in the right sequence.
3627    * 0 = not called, 1 = send called,
3628    * 1001 = reply called.
3629    */
3630   int cb_sequence;
3631   struct guestfs_message_header hdr;
3632   struct guestfs_message_error err;
3633 };
3634
3635 static void lvm_remove_all_reply_cb (guestfs_h *g, void *data, XDR *xdr)
3636 {
3637   guestfs_main_loop *ml = guestfs_get_main_loop (g);
3638   struct lvm_remove_all_ctx *ctx = (struct lvm_remove_all_ctx *) data;
3639
3640   ml->main_loop_quit (ml, g);
3641
3642   if (!xdr_guestfs_message_header (xdr, &ctx->hdr)) {
3643     error (g, "%s: failed to parse reply header", "guestfs_lvm_remove_all");
3644     return;
3645   }
3646   if (ctx->hdr.status == GUESTFS_STATUS_ERROR) {
3647     if (!xdr_guestfs_message_error (xdr, &ctx->err)) {
3648       error (g, "%s: failed to parse reply error", "guestfs_lvm_remove_all");
3649       return;
3650     }
3651     goto done;
3652   }
3653  done:
3654   ctx->cb_sequence = 1001;
3655 }
3656
3657 int guestfs_lvm_remove_all (guestfs_h *g)
3658 {
3659   struct lvm_remove_all_ctx ctx;
3660   guestfs_main_loop *ml = guestfs_get_main_loop (g);
3661   int serial;
3662
3663   if (check_state (g, "guestfs_lvm_remove_all") == -1) return -1;
3664
3665   memset (&ctx, 0, sizeof ctx);
3666
3667   serial = guestfs__send_sync (g, GUESTFS_PROC_LVM_REMOVE_ALL, NULL, NULL);
3668   if (serial == -1)
3669     return -1;
3670
3671   guestfs__switch_to_receiving (g);
3672   ctx.cb_sequence = 0;
3673   guestfs_set_reply_callback (g, lvm_remove_all_reply_cb, &ctx);
3674   (void) ml->main_loop_run (ml, g);
3675   guestfs_set_reply_callback (g, NULL, NULL);
3676   if (ctx.cb_sequence != 1001) {
3677     error (g, "%s reply failed, see earlier error messages", "guestfs_lvm_remove_all");
3678     return -1;
3679   }
3680
3681   if (check_reply_header (g, &ctx.hdr, GUESTFS_PROC_LVM_REMOVE_ALL, serial) == -1)
3682     return -1;
3683
3684   if (ctx.hdr.status == GUESTFS_STATUS_ERROR) {
3685     error (g, "%s", ctx.err.error_message);
3686     return -1;
3687   }
3688
3689   return 0;
3690 }
3691
3692 struct file_ctx {
3693   /* This flag is set by the callbacks, so we know we've done
3694    * the callbacks as expected, and in the right sequence.
3695    * 0 = not called, 1 = send called,
3696    * 1001 = reply called.
3697    */
3698   int cb_sequence;
3699   struct guestfs_message_header hdr;
3700   struct guestfs_message_error err;
3701   struct guestfs_file_ret ret;
3702 };
3703
3704 static void file_reply_cb (guestfs_h *g, void *data, XDR *xdr)
3705 {
3706   guestfs_main_loop *ml = guestfs_get_main_loop (g);
3707   struct file_ctx *ctx = (struct file_ctx *) data;
3708
3709   ml->main_loop_quit (ml, g);
3710
3711   if (!xdr_guestfs_message_header (xdr, &ctx->hdr)) {
3712     error (g, "%s: failed to parse reply header", "guestfs_file");
3713     return;
3714   }
3715   if (ctx->hdr.status == GUESTFS_STATUS_ERROR) {
3716     if (!xdr_guestfs_message_error (xdr, &ctx->err)) {
3717       error (g, "%s: failed to parse reply error", "guestfs_file");
3718       return;
3719     }
3720     goto done;
3721   }
3722   if (!xdr_guestfs_file_ret (xdr, &ctx->ret)) {
3723     error (g, "%s: failed to parse reply", "guestfs_file");
3724     return;
3725   }
3726  done:
3727   ctx->cb_sequence = 1001;
3728 }
3729
3730 char *guestfs_file (guestfs_h *g,
3731                 const char *path)
3732 {
3733   struct guestfs_file_args args;
3734   struct file_ctx ctx;
3735   guestfs_main_loop *ml = guestfs_get_main_loop (g);
3736   int serial;
3737
3738   if (check_state (g, "guestfs_file") == -1) return NULL;
3739
3740   memset (&ctx, 0, sizeof ctx);
3741
3742   args.path = (char *) path;
3743   serial = guestfs__send_sync (g, GUESTFS_PROC_FILE,
3744         (xdrproc_t) xdr_guestfs_file_args, (char *) &args);
3745   if (serial == -1)
3746     return NULL;
3747
3748   guestfs__switch_to_receiving (g);
3749   ctx.cb_sequence = 0;
3750   guestfs_set_reply_callback (g, file_reply_cb, &ctx);
3751   (void) ml->main_loop_run (ml, g);
3752   guestfs_set_reply_callback (g, NULL, NULL);
3753   if (ctx.cb_sequence != 1001) {
3754     error (g, "%s reply failed, see earlier error messages", "guestfs_file");
3755     return NULL;
3756   }
3757
3758   if (check_reply_header (g, &ctx.hdr, GUESTFS_PROC_FILE, serial) == -1)
3759     return NULL;
3760
3761   if (ctx.hdr.status == GUESTFS_STATUS_ERROR) {
3762     error (g, "%s", ctx.err.error_message);
3763     return NULL;
3764   }
3765
3766   return ctx.ret.description; /* caller will free */
3767 }
3768
3769 struct command_ctx {
3770   /* This flag is set by the callbacks, so we know we've done
3771    * the callbacks as expected, and in the right sequence.
3772    * 0 = not called, 1 = send called,
3773    * 1001 = reply called.
3774    */
3775   int cb_sequence;
3776   struct guestfs_message_header hdr;
3777   struct guestfs_message_error err;
3778   struct guestfs_command_ret ret;
3779 };
3780
3781 static void command_reply_cb (guestfs_h *g, void *data, XDR *xdr)
3782 {
3783   guestfs_main_loop *ml = guestfs_get_main_loop (g);
3784   struct command_ctx *ctx = (struct command_ctx *) data;
3785
3786   ml->main_loop_quit (ml, g);
3787
3788   if (!xdr_guestfs_message_header (xdr, &ctx->hdr)) {
3789     error (g, "%s: failed to parse reply header", "guestfs_command");
3790     return;
3791   }
3792   if (ctx->hdr.status == GUESTFS_STATUS_ERROR) {
3793     if (!xdr_guestfs_message_error (xdr, &ctx->err)) {
3794       error (g, "%s: failed to parse reply error", "guestfs_command");
3795       return;
3796     }
3797     goto done;
3798   }
3799   if (!xdr_guestfs_command_ret (xdr, &ctx->ret)) {
3800     error (g, "%s: failed to parse reply", "guestfs_command");
3801     return;
3802   }
3803  done:
3804   ctx->cb_sequence = 1001;
3805 }
3806
3807 char *guestfs_command (guestfs_h *g,
3808                 char * const* const arguments)
3809 {
3810   struct guestfs_command_args args;
3811   struct command_ctx ctx;
3812   guestfs_main_loop *ml = guestfs_get_main_loop (g);
3813   int serial;
3814
3815   if (check_state (g, "guestfs_command") == -1) return NULL;
3816
3817   memset (&ctx, 0, sizeof ctx);
3818
3819   args.arguments.arguments_val = (char **) arguments;
3820   for (args.arguments.arguments_len = 0; arguments[args.arguments.arguments_len]; args.arguments.arguments_len++) ;
3821   serial = guestfs__send_sync (g, GUESTFS_PROC_COMMAND,
3822         (xdrproc_t) xdr_guestfs_command_args, (char *) &args);
3823   if (serial == -1)
3824     return NULL;
3825
3826   guestfs__switch_to_receiving (g);
3827   ctx.cb_sequence = 0;
3828   guestfs_set_reply_callback (g, command_reply_cb, &ctx);
3829   (void) ml->main_loop_run (ml, g);
3830   guestfs_set_reply_callback (g, NULL, NULL);
3831   if (ctx.cb_sequence != 1001) {
3832     error (g, "%s reply failed, see earlier error messages", "guestfs_command");
3833     return NULL;
3834   }
3835
3836   if (check_reply_header (g, &ctx.hdr, GUESTFS_PROC_COMMAND, serial) == -1)
3837     return NULL;
3838
3839   if (ctx.hdr.status == GUESTFS_STATUS_ERROR) {
3840     error (g, "%s", ctx.err.error_message);
3841     return NULL;
3842   }
3843
3844   return ctx.ret.output; /* caller will free */
3845 }
3846
3847 struct command_lines_ctx {
3848   /* This flag is set by the callbacks, so we know we've done
3849    * the callbacks as expected, and in the right sequence.
3850    * 0 = not called, 1 = send called,
3851    * 1001 = reply called.
3852    */
3853   int cb_sequence;
3854   struct guestfs_message_header hdr;
3855   struct guestfs_message_error err;
3856   struct guestfs_command_lines_ret ret;
3857 };
3858
3859 static void command_lines_reply_cb (guestfs_h *g, void *data, XDR *xdr)
3860 {
3861   guestfs_main_loop *ml = guestfs_get_main_loop (g);
3862   struct command_lines_ctx *ctx = (struct command_lines_ctx *) data;
3863
3864   ml->main_loop_quit (ml, g);
3865
3866   if (!xdr_guestfs_message_header (xdr, &ctx->hdr)) {
3867     error (g, "%s: failed to parse reply header", "guestfs_command_lines");
3868     return;
3869   }
3870   if (ctx->hdr.status == GUESTFS_STATUS_ERROR) {
3871     if (!xdr_guestfs_message_error (xdr, &ctx->err)) {
3872       error (g, "%s: failed to parse reply error", "guestfs_command_lines");
3873       return;
3874     }
3875     goto done;
3876   }
3877   if (!xdr_guestfs_command_lines_ret (xdr, &ctx->ret)) {
3878     error (g, "%s: failed to parse reply", "guestfs_command_lines");
3879     return;
3880   }
3881  done:
3882   ctx->cb_sequence = 1001;
3883 }
3884
3885 char **guestfs_command_lines (guestfs_h *g,
3886                 char * const* const arguments)
3887 {
3888   struct guestfs_command_lines_args args;
3889   struct command_lines_ctx ctx;
3890   guestfs_main_loop *ml = guestfs_get_main_loop (g);
3891   int serial;
3892
3893   if (check_state (g, "guestfs_command_lines") == -1) return NULL;
3894
3895   memset (&ctx, 0, sizeof ctx);
3896
3897   args.arguments.arguments_val = (char **) arguments;
3898   for (args.arguments.arguments_len = 0; arguments[args.arguments.arguments_len]; args.arguments.arguments_len++) ;
3899   serial = guestfs__send_sync (g, GUESTFS_PROC_COMMAND_LINES,
3900         (xdrproc_t) xdr_guestfs_command_lines_args, (char *) &args);
3901   if (serial == -1)
3902     return NULL;
3903
3904   guestfs__switch_to_receiving (g);
3905   ctx.cb_sequence = 0;
3906   guestfs_set_reply_callback (g, command_lines_reply_cb, &ctx);
3907   (void) ml->main_loop_run (ml, g);
3908   guestfs_set_reply_callback (g, NULL, NULL);
3909   if (ctx.cb_sequence != 1001) {
3910     error (g, "%s reply failed, see earlier error messages", "guestfs_command_lines");
3911     return NULL;
3912   }
3913
3914   if (check_reply_header (g, &ctx.hdr, GUESTFS_PROC_COMMAND_LINES, serial) == -1)
3915     return NULL;
3916
3917   if (ctx.hdr.status == GUESTFS_STATUS_ERROR) {
3918     error (g, "%s", ctx.err.error_message);
3919     return NULL;
3920   }
3921
3922   /* caller will free this, but we need to add a NULL entry */
3923   ctx.ret.lines.lines_val =
3924     safe_realloc (g, ctx.ret.lines.lines_val,
3925                   sizeof (char *) * (ctx.ret.lines.lines_len + 1));
3926   ctx.ret.lines.lines_val[ctx.ret.lines.lines_len] = NULL;
3927   return ctx.ret.lines.lines_val;
3928 }
3929
3930 struct stat_ctx {
3931   /* This flag is set by the callbacks, so we know we've done
3932    * the callbacks as expected, and in the right sequence.
3933    * 0 = not called, 1 = send called,
3934    * 1001 = reply called.
3935    */
3936   int cb_sequence;
3937   struct guestfs_message_header hdr;
3938   struct guestfs_message_error err;
3939   struct guestfs_stat_ret ret;
3940 };
3941
3942 static void stat_reply_cb (guestfs_h *g, void *data, XDR *xdr)
3943 {
3944   guestfs_main_loop *ml = guestfs_get_main_loop (g);
3945   struct stat_ctx *ctx = (struct stat_ctx *) data;
3946
3947   ml->main_loop_quit (ml, g);
3948
3949   if (!xdr_guestfs_message_header (xdr, &ctx->hdr)) {
3950     error (g, "%s: failed to parse reply header", "guestfs_stat");
3951     return;
3952   }
3953   if (ctx->hdr.status == GUESTFS_STATUS_ERROR) {
3954     if (!xdr_guestfs_message_error (xdr, &ctx->err)) {
3955       error (g, "%s: failed to parse reply error", "guestfs_stat");
3956       return;
3957     }
3958     goto done;
3959   }
3960   if (!xdr_guestfs_stat_ret (xdr, &ctx->ret)) {
3961     error (g, "%s: failed to parse reply", "guestfs_stat");
3962     return;
3963   }
3964  done:
3965   ctx->cb_sequence = 1001;
3966 }
3967
3968 struct guestfs_stat *guestfs_stat (guestfs_h *g,
3969                 const char *path)
3970 {
3971   struct guestfs_stat_args args;
3972   struct stat_ctx ctx;
3973   guestfs_main_loop *ml = guestfs_get_main_loop (g);
3974   int serial;
3975
3976   if (check_state (g, "guestfs_stat") == -1) return NULL;
3977
3978   memset (&ctx, 0, sizeof ctx);
3979
3980   args.path = (char *) path;
3981   serial = guestfs__send_sync (g, GUESTFS_PROC_STAT,
3982         (xdrproc_t) xdr_guestfs_stat_args, (char *) &args);
3983   if (serial == -1)
3984     return NULL;
3985
3986   guestfs__switch_to_receiving (g);
3987   ctx.cb_sequence = 0;
3988   guestfs_set_reply_callback (g, stat_reply_cb, &ctx);
3989   (void) ml->main_loop_run (ml, g);
3990   guestfs_set_reply_callback (g, NULL, NULL);
3991   if (ctx.cb_sequence != 1001) {
3992     error (g, "%s reply failed, see earlier error messages", "guestfs_stat");
3993     return NULL;
3994   }
3995
3996   if (check_reply_header (g, &ctx.hdr, GUESTFS_PROC_STAT, serial) == -1)
3997     return NULL;
3998
3999   if (ctx.hdr.status == GUESTFS_STATUS_ERROR) {
4000     error (g, "%s", ctx.err.error_message);
4001     return NULL;
4002   }
4003
4004   /* caller will free this */
4005   return safe_memdup (g, &ctx.ret.statbuf, sizeof (ctx.ret.statbuf));
4006 }
4007
4008 struct lstat_ctx {
4009   /* This flag is set by the callbacks, so we know we've done
4010    * the callbacks as expected, and in the right sequence.
4011    * 0 = not called, 1 = send called,
4012    * 1001 = reply called.
4013    */
4014   int cb_sequence;
4015   struct guestfs_message_header hdr;
4016   struct guestfs_message_error err;
4017   struct guestfs_lstat_ret ret;
4018 };
4019
4020 static void lstat_reply_cb (guestfs_h *g, void *data, XDR *xdr)
4021 {
4022   guestfs_main_loop *ml = guestfs_get_main_loop (g);
4023   struct lstat_ctx *ctx = (struct lstat_ctx *) data;
4024
4025   ml->main_loop_quit (ml, g);
4026
4027   if (!xdr_guestfs_message_header (xdr, &ctx->hdr)) {
4028     error (g, "%s: failed to parse reply header", "guestfs_lstat");
4029     return;
4030   }
4031   if (ctx->hdr.status == GUESTFS_STATUS_ERROR) {
4032     if (!xdr_guestfs_message_error (xdr, &ctx->err)) {
4033       error (g, "%s: failed to parse reply error", "guestfs_lstat");
4034       return;
4035     }
4036     goto done;
4037   }
4038   if (!xdr_guestfs_lstat_ret (xdr, &ctx->ret)) {
4039     error (g, "%s: failed to parse reply", "guestfs_lstat");
4040     return;
4041   }
4042  done:
4043   ctx->cb_sequence = 1001;
4044 }
4045
4046 struct guestfs_stat *guestfs_lstat (guestfs_h *g,
4047                 const char *path)
4048 {
4049   struct guestfs_lstat_args args;
4050   struct lstat_ctx ctx;
4051   guestfs_main_loop *ml = guestfs_get_main_loop (g);
4052   int serial;
4053
4054   if (check_state (g, "guestfs_lstat") == -1) return NULL;
4055
4056   memset (&ctx, 0, sizeof ctx);
4057
4058   args.path = (char *) path;
4059   serial = guestfs__send_sync (g, GUESTFS_PROC_LSTAT,
4060         (xdrproc_t) xdr_guestfs_lstat_args, (char *) &args);
4061   if (serial == -1)
4062     return NULL;
4063
4064   guestfs__switch_to_receiving (g);
4065   ctx.cb_sequence = 0;
4066   guestfs_set_reply_callback (g, lstat_reply_cb, &ctx);
4067   (void) ml->main_loop_run (ml, g);
4068   guestfs_set_reply_callback (g, NULL, NULL);
4069   if (ctx.cb_sequence != 1001) {
4070     error (g, "%s reply failed, see earlier error messages", "guestfs_lstat");
4071     return NULL;
4072   }
4073
4074   if (check_reply_header (g, &ctx.hdr, GUESTFS_PROC_LSTAT, serial) == -1)
4075     return NULL;
4076
4077   if (ctx.hdr.status == GUESTFS_STATUS_ERROR) {
4078     error (g, "%s", ctx.err.error_message);
4079     return NULL;
4080   }
4081
4082   /* caller will free this */
4083   return safe_memdup (g, &ctx.ret.statbuf, sizeof (ctx.ret.statbuf));
4084 }
4085
4086 struct statvfs_ctx {
4087   /* This flag is set by the callbacks, so we know we've done
4088    * the callbacks as expected, and in the right sequence.
4089    * 0 = not called, 1 = send called,
4090    * 1001 = reply called.
4091    */
4092   int cb_sequence;
4093   struct guestfs_message_header hdr;
4094   struct guestfs_message_error err;
4095   struct guestfs_statvfs_ret ret;
4096 };
4097
4098 static void statvfs_reply_cb (guestfs_h *g, void *data, XDR *xdr)
4099 {
4100   guestfs_main_loop *ml = guestfs_get_main_loop (g);
4101   struct statvfs_ctx *ctx = (struct statvfs_ctx *) data;
4102
4103   ml->main_loop_quit (ml, g);
4104
4105   if (!xdr_guestfs_message_header (xdr, &ctx->hdr)) {
4106     error (g, "%s: failed to parse reply header", "guestfs_statvfs");
4107     return;
4108   }
4109   if (ctx->hdr.status == GUESTFS_STATUS_ERROR) {
4110     if (!xdr_guestfs_message_error (xdr, &ctx->err)) {
4111       error (g, "%s: failed to parse reply error", "guestfs_statvfs");
4112       return;
4113     }
4114     goto done;
4115   }
4116   if (!xdr_guestfs_statvfs_ret (xdr, &ctx->ret)) {
4117     error (g, "%s: failed to parse reply", "guestfs_statvfs");
4118     return;
4119   }
4120  done:
4121   ctx->cb_sequence = 1001;
4122 }
4123
4124 struct guestfs_statvfs *guestfs_statvfs (guestfs_h *g,
4125                 const char *path)
4126 {
4127   struct guestfs_statvfs_args args;
4128   struct statvfs_ctx ctx;
4129   guestfs_main_loop *ml = guestfs_get_main_loop (g);
4130   int serial;
4131
4132   if (check_state (g, "guestfs_statvfs") == -1) return NULL;
4133
4134   memset (&ctx, 0, sizeof ctx);
4135
4136   args.path = (char *) path;
4137   serial = guestfs__send_sync (g, GUESTFS_PROC_STATVFS,
4138         (xdrproc_t) xdr_guestfs_statvfs_args, (char *) &args);
4139   if (serial == -1)
4140     return NULL;
4141
4142   guestfs__switch_to_receiving (g);
4143   ctx.cb_sequence = 0;
4144   guestfs_set_reply_callback (g, statvfs_reply_cb, &ctx);
4145   (void) ml->main_loop_run (ml, g);
4146   guestfs_set_reply_callback (g, NULL, NULL);
4147   if (ctx.cb_sequence != 1001) {
4148     error (g, "%s reply failed, see earlier error messages", "guestfs_statvfs");
4149     return NULL;
4150   }
4151
4152   if (check_reply_header (g, &ctx.hdr, GUESTFS_PROC_STATVFS, serial) == -1)
4153     return NULL;
4154
4155   if (ctx.hdr.status == GUESTFS_STATUS_ERROR) {
4156     error (g, "%s", ctx.err.error_message);
4157     return NULL;
4158   }
4159
4160   /* caller will free this */
4161   return safe_memdup (g, &ctx.ret.statbuf, sizeof (ctx.ret.statbuf));
4162 }
4163
4164 struct tune2fs_l_ctx {
4165   /* This flag is set by the callbacks, so we know we've done
4166    * the callbacks as expected, and in the right sequence.
4167    * 0 = not called, 1 = send called,
4168    * 1001 = reply called.
4169    */
4170   int cb_sequence;
4171   struct guestfs_message_header hdr;
4172   struct guestfs_message_error err;
4173   struct guestfs_tune2fs_l_ret ret;
4174 };
4175
4176 static void tune2fs_l_reply_cb (guestfs_h *g, void *data, XDR *xdr)
4177 {
4178   guestfs_main_loop *ml = guestfs_get_main_loop (g);
4179   struct tune2fs_l_ctx *ctx = (struct tune2fs_l_ctx *) data;
4180
4181   ml->main_loop_quit (ml, g);
4182
4183   if (!xdr_guestfs_message_header (xdr, &ctx->hdr)) {
4184     error (g, "%s: failed to parse reply header", "guestfs_tune2fs_l");
4185     return;
4186   }
4187   if (ctx->hdr.status == GUESTFS_STATUS_ERROR) {
4188     if (!xdr_guestfs_message_error (xdr, &ctx->err)) {
4189       error (g, "%s: failed to parse reply error", "guestfs_tune2fs_l");
4190       return;
4191     }
4192     goto done;
4193   }
4194   if (!xdr_guestfs_tune2fs_l_ret (xdr, &ctx->ret)) {
4195     error (g, "%s: failed to parse reply", "guestfs_tune2fs_l");
4196     return;
4197   }
4198  done:
4199   ctx->cb_sequence = 1001;
4200 }
4201
4202 char **guestfs_tune2fs_l (guestfs_h *g,
4203                 const char *device)
4204 {
4205   struct guestfs_tune2fs_l_args args;
4206   struct tune2fs_l_ctx ctx;
4207   guestfs_main_loop *ml = guestfs_get_main_loop (g);
4208   int serial;
4209
4210   if (check_state (g, "guestfs_tune2fs_l") == -1) return NULL;
4211
4212   memset (&ctx, 0, sizeof ctx);
4213
4214   args.device = (char *) device;
4215   serial = guestfs__send_sync (g, GUESTFS_PROC_TUNE2FS_L,
4216         (xdrproc_t) xdr_guestfs_tune2fs_l_args, (char *) &args);
4217   if (serial == -1)
4218     return NULL;
4219
4220   guestfs__switch_to_receiving (g);
4221   ctx.cb_sequence = 0;
4222   guestfs_set_reply_callback (g, tune2fs_l_reply_cb, &ctx);
4223   (void) ml->main_loop_run (ml, g);
4224   guestfs_set_reply_callback (g, NULL, NULL);
4225   if (ctx.cb_sequence != 1001) {
4226     error (g, "%s reply failed, see earlier error messages", "guestfs_tune2fs_l");
4227     return NULL;
4228   }
4229
4230   if (check_reply_header (g, &ctx.hdr, GUESTFS_PROC_TUNE2FS_L, serial) == -1)
4231     return NULL;
4232
4233   if (ctx.hdr.status == GUESTFS_STATUS_ERROR) {
4234     error (g, "%s", ctx.err.error_message);
4235     return NULL;
4236   }
4237
4238   /* caller will free this, but we need to add a NULL entry */
4239   ctx.ret.superblock.superblock_val =
4240     safe_realloc (g, ctx.ret.superblock.superblock_val,
4241                   sizeof (char *) * (ctx.ret.superblock.superblock_len + 1));
4242   ctx.ret.superblock.superblock_val[ctx.ret.superblock.superblock_len] = NULL;
4243   return ctx.ret.superblock.superblock_val;
4244 }
4245
4246 struct blockdev_setro_ctx {
4247   /* This flag is set by the callbacks, so we know we've done
4248    * the callbacks as expected, and in the right sequence.
4249    * 0 = not called, 1 = send called,
4250    * 1001 = reply called.
4251    */
4252   int cb_sequence;
4253   struct guestfs_message_header hdr;
4254   struct guestfs_message_error err;
4255 };
4256
4257 static void blockdev_setro_reply_cb (guestfs_h *g, void *data, XDR *xdr)
4258 {
4259   guestfs_main_loop *ml = guestfs_get_main_loop (g);
4260   struct blockdev_setro_ctx *ctx = (struct blockdev_setro_ctx *) data;
4261
4262   ml->main_loop_quit (ml, g);
4263
4264   if (!xdr_guestfs_message_header (xdr, &ctx->hdr)) {
4265     error (g, "%s: failed to parse reply header", "guestfs_blockdev_setro");
4266     return;
4267   }
4268   if (ctx->hdr.status == GUESTFS_STATUS_ERROR) {
4269     if (!xdr_guestfs_message_error (xdr, &ctx->err)) {
4270       error (g, "%s: failed to parse reply error", "guestfs_blockdev_setro");
4271       return;
4272     }
4273     goto done;
4274   }
4275  done:
4276   ctx->cb_sequence = 1001;
4277 }
4278
4279 int guestfs_blockdev_setro (guestfs_h *g,
4280                 const char *device)
4281 {
4282   struct guestfs_blockdev_setro_args args;
4283   struct blockdev_setro_ctx ctx;
4284   guestfs_main_loop *ml = guestfs_get_main_loop (g);
4285   int serial;
4286
4287   if (check_state (g, "guestfs_blockdev_setro") == -1) return -1;
4288
4289   memset (&ctx, 0, sizeof ctx);
4290
4291   args.device = (char *) device;
4292   serial = guestfs__send_sync (g, GUESTFS_PROC_BLOCKDEV_SETRO,
4293         (xdrproc_t) xdr_guestfs_blockdev_setro_args, (char *) &args);
4294   if (serial == -1)
4295     return -1;
4296
4297   guestfs__switch_to_receiving (g);
4298   ctx.cb_sequence = 0;
4299   guestfs_set_reply_callback (g, blockdev_setro_reply_cb, &ctx);
4300   (void) ml->main_loop_run (ml, g);
4301   guestfs_set_reply_callback (g, NULL, NULL);
4302   if (ctx.cb_sequence != 1001) {
4303     error (g, "%s reply failed, see earlier error messages", "guestfs_blockdev_setro");
4304     return -1;
4305   }
4306
4307   if (check_reply_header (g, &ctx.hdr, GUESTFS_PROC_BLOCKDEV_SETRO, serial) == -1)
4308     return -1;
4309
4310   if (ctx.hdr.status == GUESTFS_STATUS_ERROR) {
4311     error (g, "%s", ctx.err.error_message);
4312     return -1;
4313   }
4314
4315   return 0;
4316 }
4317
4318 struct blockdev_setrw_ctx {
4319   /* This flag is set by the callbacks, so we know we've done
4320    * the callbacks as expected, and in the right sequence.
4321    * 0 = not called, 1 = send called,
4322    * 1001 = reply called.
4323    */
4324   int cb_sequence;
4325   struct guestfs_message_header hdr;
4326   struct guestfs_message_error err;
4327 };
4328
4329 static void blockdev_setrw_reply_cb (guestfs_h *g, void *data, XDR *xdr)
4330 {
4331   guestfs_main_loop *ml = guestfs_get_main_loop (g);
4332   struct blockdev_setrw_ctx *ctx = (struct blockdev_setrw_ctx *) data;
4333
4334   ml->main_loop_quit (ml, g);
4335
4336   if (!xdr_guestfs_message_header (xdr, &ctx->hdr)) {
4337     error (g, "%s: failed to parse reply header", "guestfs_blockdev_setrw");
4338     return;
4339   }
4340   if (ctx->hdr.status == GUESTFS_STATUS_ERROR) {
4341     if (!xdr_guestfs_message_error (xdr, &ctx->err)) {
4342       error (g, "%s: failed to parse reply error", "guestfs_blockdev_setrw");
4343       return;
4344     }
4345     goto done;
4346   }
4347  done:
4348   ctx->cb_sequence = 1001;
4349 }
4350
4351 int guestfs_blockdev_setrw (guestfs_h *g,
4352                 const char *device)
4353 {
4354   struct guestfs_blockdev_setrw_args args;
4355   struct blockdev_setrw_ctx ctx;
4356   guestfs_main_loop *ml = guestfs_get_main_loop (g);
4357   int serial;
4358
4359   if (check_state (g, "guestfs_blockdev_setrw") == -1) return -1;
4360
4361   memset (&ctx, 0, sizeof ctx);
4362
4363   args.device = (char *) device;
4364   serial = guestfs__send_sync (g, GUESTFS_PROC_BLOCKDEV_SETRW,
4365         (xdrproc_t) xdr_guestfs_blockdev_setrw_args, (char *) &args);
4366   if (serial == -1)
4367     return -1;
4368
4369   guestfs__switch_to_receiving (g);
4370   ctx.cb_sequence = 0;
4371   guestfs_set_reply_callback (g, blockdev_setrw_reply_cb, &ctx);
4372   (void) ml->main_loop_run (ml, g);
4373   guestfs_set_reply_callback (g, NULL, NULL);
4374   if (ctx.cb_sequence != 1001) {
4375     error (g, "%s reply failed, see earlier error messages", "guestfs_blockdev_setrw");
4376     return -1;
4377   }
4378
4379   if (check_reply_header (g, &ctx.hdr, GUESTFS_PROC_BLOCKDEV_SETRW, serial) == -1)
4380     return -1;
4381
4382   if (ctx.hdr.status == GUESTFS_STATUS_ERROR) {
4383     error (g, "%s", ctx.err.error_message);
4384     return -1;
4385   }
4386
4387   return 0;
4388 }
4389
4390 struct blockdev_getro_ctx {
4391   /* This flag is set by the callbacks, so we know we've done
4392    * the callbacks as expected, and in the right sequence.
4393    * 0 = not called, 1 = send called,
4394    * 1001 = reply called.
4395    */
4396   int cb_sequence;
4397   struct guestfs_message_header hdr;
4398   struct guestfs_message_error err;
4399   struct guestfs_blockdev_getro_ret ret;
4400 };
4401
4402 static void blockdev_getro_reply_cb (guestfs_h *g, void *data, XDR *xdr)
4403 {
4404   guestfs_main_loop *ml = guestfs_get_main_loop (g);
4405   struct blockdev_getro_ctx *ctx = (struct blockdev_getro_ctx *) data;
4406
4407   ml->main_loop_quit (ml, g);
4408
4409   if (!xdr_guestfs_message_header (xdr, &ctx->hdr)) {
4410     error (g, "%s: failed to parse reply header", "guestfs_blockdev_getro");
4411     return;
4412   }
4413   if (ctx->hdr.status == GUESTFS_STATUS_ERROR) {
4414     if (!xdr_guestfs_message_error (xdr, &ctx->err)) {
4415       error (g, "%s: failed to parse reply error", "guestfs_blockdev_getro");
4416       return;
4417     }
4418     goto done;
4419   }
4420   if (!xdr_guestfs_blockdev_getro_ret (xdr, &ctx->ret)) {
4421     error (g, "%s: failed to parse reply", "guestfs_blockdev_getro");
4422     return;
4423   }
4424  done:
4425   ctx->cb_sequence = 1001;
4426 }
4427
4428 int guestfs_blockdev_getro (guestfs_h *g,
4429                 const char *device)
4430 {
4431   struct guestfs_blockdev_getro_args args;
4432   struct blockdev_getro_ctx ctx;
4433   guestfs_main_loop *ml = guestfs_get_main_loop (g);
4434   int serial;
4435
4436   if (check_state (g, "guestfs_blockdev_getro") == -1) return -1;
4437
4438   memset (&ctx, 0, sizeof ctx);
4439
4440   args.device = (char *) device;
4441   serial = guestfs__send_sync (g, GUESTFS_PROC_BLOCKDEV_GETRO,
4442         (xdrproc_t) xdr_guestfs_blockdev_getro_args, (char *) &args);
4443   if (serial == -1)
4444     return -1;
4445
4446   guestfs__switch_to_receiving (g);
4447   ctx.cb_sequence = 0;
4448   guestfs_set_reply_callback (g, blockdev_getro_reply_cb, &ctx);
4449   (void) ml->main_loop_run (ml, g);
4450   guestfs_set_reply_callback (g, NULL, NULL);
4451   if (ctx.cb_sequence != 1001) {
4452     error (g, "%s reply failed, see earlier error messages", "guestfs_blockdev_getro");
4453     return -1;
4454   }
4455
4456   if (check_reply_header (g, &ctx.hdr, GUESTFS_PROC_BLOCKDEV_GETRO, serial) == -1)
4457     return -1;
4458
4459   if (ctx.hdr.status == GUESTFS_STATUS_ERROR) {
4460     error (g, "%s", ctx.err.error_message);
4461     return -1;
4462   }
4463
4464   return ctx.ret.ro;
4465 }
4466
4467 struct blockdev_getss_ctx {
4468   /* This flag is set by the callbacks, so we know we've done
4469    * the callbacks as expected, and in the right sequence.
4470    * 0 = not called, 1 = send called,
4471    * 1001 = reply called.
4472    */
4473   int cb_sequence;
4474   struct guestfs_message_header hdr;
4475   struct guestfs_message_error err;
4476   struct guestfs_blockdev_getss_ret ret;
4477 };
4478
4479 static void blockdev_getss_reply_cb (guestfs_h *g, void *data, XDR *xdr)
4480 {
4481   guestfs_main_loop *ml = guestfs_get_main_loop (g);
4482   struct blockdev_getss_ctx *ctx = (struct blockdev_getss_ctx *) data;
4483
4484   ml->main_loop_quit (ml, g);
4485
4486   if (!xdr_guestfs_message_header (xdr, &ctx->hdr)) {
4487     error (g, "%s: failed to parse reply header", "guestfs_blockdev_getss");
4488     return;
4489   }
4490   if (ctx->hdr.status == GUESTFS_STATUS_ERROR) {
4491     if (!xdr_guestfs_message_error (xdr, &ctx->err)) {
4492       error (g, "%s: failed to parse reply error", "guestfs_blockdev_getss");
4493       return;
4494     }
4495     goto done;
4496   }
4497   if (!xdr_guestfs_blockdev_getss_ret (xdr, &ctx->ret)) {
4498     error (g, "%s: failed to parse reply", "guestfs_blockdev_getss");
4499     return;
4500   }
4501  done:
4502   ctx->cb_sequence = 1001;
4503 }
4504
4505 int guestfs_blockdev_getss (guestfs_h *g,
4506                 const char *device)
4507 {
4508   struct guestfs_blockdev_getss_args args;
4509   struct blockdev_getss_ctx ctx;
4510   guestfs_main_loop *ml = guestfs_get_main_loop (g);
4511   int serial;
4512
4513   if (check_state (g, "guestfs_blockdev_getss") == -1) return -1;
4514
4515   memset (&ctx, 0, sizeof ctx);
4516
4517   args.device = (char *) device;
4518   serial = guestfs__send_sync (g, GUESTFS_PROC_BLOCKDEV_GETSS,
4519         (xdrproc_t) xdr_guestfs_blockdev_getss_args, (char *) &args);
4520   if (serial == -1)
4521     return -1;
4522
4523   guestfs__switch_to_receiving (g);
4524   ctx.cb_sequence = 0;
4525   guestfs_set_reply_callback (g, blockdev_getss_reply_cb, &ctx);
4526   (void) ml->main_loop_run (ml, g);
4527   guestfs_set_reply_callback (g, NULL, NULL);
4528   if (ctx.cb_sequence != 1001) {
4529     error (g, "%s reply failed, see earlier error messages", "guestfs_blockdev_getss");
4530     return -1;
4531   }
4532
4533   if (check_reply_header (g, &ctx.hdr, GUESTFS_PROC_BLOCKDEV_GETSS, serial) == -1)
4534     return -1;
4535
4536   if (ctx.hdr.status == GUESTFS_STATUS_ERROR) {
4537     error (g, "%s", ctx.err.error_message);
4538     return -1;
4539   }
4540
4541   return ctx.ret.sectorsize;
4542 }
4543
4544 struct blockdev_getbsz_ctx {
4545   /* This flag is set by the callbacks, so we know we've done
4546    * the callbacks as expected, and in the right sequence.
4547    * 0 = not called, 1 = send called,
4548    * 1001 = reply called.
4549    */
4550   int cb_sequence;
4551   struct guestfs_message_header hdr;
4552   struct guestfs_message_error err;
4553   struct guestfs_blockdev_getbsz_ret ret;
4554 };
4555
4556 static void blockdev_getbsz_reply_cb (guestfs_h *g, void *data, XDR *xdr)
4557 {
4558   guestfs_main_loop *ml = guestfs_get_main_loop (g);
4559   struct blockdev_getbsz_ctx *ctx = (struct blockdev_getbsz_ctx *) data;
4560
4561   ml->main_loop_quit (ml, g);
4562
4563   if (!xdr_guestfs_message_header (xdr, &ctx->hdr)) {
4564     error (g, "%s: failed to parse reply header", "guestfs_blockdev_getbsz");
4565     return;
4566   }
4567   if (ctx->hdr.status == GUESTFS_STATUS_ERROR) {
4568     if (!xdr_guestfs_message_error (xdr, &ctx->err)) {
4569       error (g, "%s: failed to parse reply error", "guestfs_blockdev_getbsz");
4570       return;
4571     }
4572     goto done;
4573   }
4574   if (!xdr_guestfs_blockdev_getbsz_ret (xdr, &ctx->ret)) {
4575     error (g, "%s: failed to parse reply", "guestfs_blockdev_getbsz");
4576     return;
4577   }
4578  done:
4579   ctx->cb_sequence = 1001;
4580 }
4581
4582 int guestfs_blockdev_getbsz (guestfs_h *g,
4583                 const char *device)
4584 {
4585   struct guestfs_blockdev_getbsz_args args;
4586   struct blockdev_getbsz_ctx ctx;
4587   guestfs_main_loop *ml = guestfs_get_main_loop (g);
4588   int serial;
4589
4590   if (check_state (g, "guestfs_blockdev_getbsz") == -1) return -1;
4591
4592   memset (&ctx, 0, sizeof ctx);
4593
4594   args.device = (char *) device;
4595   serial = guestfs__send_sync (g, GUESTFS_PROC_BLOCKDEV_GETBSZ,
4596         (xdrproc_t) xdr_guestfs_blockdev_getbsz_args, (char *) &args);
4597   if (serial == -1)
4598     return -1;
4599
4600   guestfs__switch_to_receiving (g);
4601   ctx.cb_sequence = 0;
4602   guestfs_set_reply_callback (g, blockdev_getbsz_reply_cb, &ctx);
4603   (void) ml->main_loop_run (ml, g);
4604   guestfs_set_reply_callback (g, NULL, NULL);
4605   if (ctx.cb_sequence != 1001) {
4606     error (g, "%s reply failed, see earlier error messages", "guestfs_blockdev_getbsz");
4607     return -1;
4608   }
4609
4610   if (check_reply_header (g, &ctx.hdr, GUESTFS_PROC_BLOCKDEV_GETBSZ, serial) == -1)
4611     return -1;
4612
4613   if (ctx.hdr.status == GUESTFS_STATUS_ERROR) {
4614     error (g, "%s", ctx.err.error_message);
4615     return -1;
4616   }
4617
4618   return ctx.ret.blocksize;
4619 }
4620
4621 struct blockdev_setbsz_ctx {
4622   /* This flag is set by the callbacks, so we know we've done
4623    * the callbacks as expected, and in the right sequence.
4624    * 0 = not called, 1 = send called,
4625    * 1001 = reply called.
4626    */
4627   int cb_sequence;
4628   struct guestfs_message_header hdr;
4629   struct guestfs_message_error err;
4630 };
4631
4632 static void blockdev_setbsz_reply_cb (guestfs_h *g, void *data, XDR *xdr)
4633 {
4634   guestfs_main_loop *ml = guestfs_get_main_loop (g);
4635   struct blockdev_setbsz_ctx *ctx = (struct blockdev_setbsz_ctx *) data;
4636
4637   ml->main_loop_quit (ml, g);
4638
4639   if (!xdr_guestfs_message_header (xdr, &ctx->hdr)) {
4640     error (g, "%s: failed to parse reply header", "guestfs_blockdev_setbsz");
4641     return;
4642   }
4643   if (ctx->hdr.status == GUESTFS_STATUS_ERROR) {
4644     if (!xdr_guestfs_message_error (xdr, &ctx->err)) {
4645       error (g, "%s: failed to parse reply error", "guestfs_blockdev_setbsz");
4646       return;
4647     }
4648     goto done;
4649   }
4650  done:
4651   ctx->cb_sequence = 1001;
4652 }
4653
4654 int guestfs_blockdev_setbsz (guestfs_h *g,
4655                 const char *device,
4656                 int blocksize)
4657 {
4658   struct guestfs_blockdev_setbsz_args args;
4659   struct blockdev_setbsz_ctx ctx;
4660   guestfs_main_loop *ml = guestfs_get_main_loop (g);
4661   int serial;
4662
4663   if (check_state (g, "guestfs_blockdev_setbsz") == -1) return -1;
4664
4665   memset (&ctx, 0, sizeof ctx);
4666
4667   args.device = (char *) device;
4668   args.blocksize = blocksize;
4669   serial = guestfs__send_sync (g, GUESTFS_PROC_BLOCKDEV_SETBSZ,
4670         (xdrproc_t) xdr_guestfs_blockdev_setbsz_args, (char *) &args);
4671   if (serial == -1)
4672     return -1;
4673
4674   guestfs__switch_to_receiving (g);
4675   ctx.cb_sequence = 0;
4676   guestfs_set_reply_callback (g, blockdev_setbsz_reply_cb, &ctx);
4677   (void) ml->main_loop_run (ml, g);
4678   guestfs_set_reply_callback (g, NULL, NULL);
4679   if (ctx.cb_sequence != 1001) {
4680     error (g, "%s reply failed, see earlier error messages", "guestfs_blockdev_setbsz");
4681     return -1;
4682   }
4683
4684   if (check_reply_header (g, &ctx.hdr, GUESTFS_PROC_BLOCKDEV_SETBSZ, serial) == -1)
4685     return -1;
4686
4687   if (ctx.hdr.status == GUESTFS_STATUS_ERROR) {
4688     error (g, "%s", ctx.err.error_message);
4689     return -1;
4690   }
4691
4692   return 0;
4693 }
4694
4695 struct blockdev_getsz_ctx {
4696   /* This flag is set by the callbacks, so we know we've done
4697    * the callbacks as expected, and in the right sequence.
4698    * 0 = not called, 1 = send called,
4699    * 1001 = reply called.
4700    */
4701   int cb_sequence;
4702   struct guestfs_message_header hdr;
4703   struct guestfs_message_error err;
4704   struct guestfs_blockdev_getsz_ret ret;
4705 };
4706
4707 static void blockdev_getsz_reply_cb (guestfs_h *g, void *data, XDR *xdr)
4708 {
4709   guestfs_main_loop *ml = guestfs_get_main_loop (g);
4710   struct blockdev_getsz_ctx *ctx = (struct blockdev_getsz_ctx *) data;
4711
4712   ml->main_loop_quit (ml, g);
4713
4714   if (!xdr_guestfs_message_header (xdr, &ctx->hdr)) {
4715     error (g, "%s: failed to parse reply header", "guestfs_blockdev_getsz");
4716     return;
4717   }
4718   if (ctx->hdr.status == GUESTFS_STATUS_ERROR) {
4719     if (!xdr_guestfs_message_error (xdr, &ctx->err)) {
4720       error (g, "%s: failed to parse reply error", "guestfs_blockdev_getsz");
4721       return;
4722     }
4723     goto done;
4724   }
4725   if (!xdr_guestfs_blockdev_getsz_ret (xdr, &ctx->ret)) {
4726     error (g, "%s: failed to parse reply", "guestfs_blockdev_getsz");
4727     return;
4728   }
4729  done:
4730   ctx->cb_sequence = 1001;
4731 }
4732
4733 int64_t guestfs_blockdev_getsz (guestfs_h *g,
4734                 const char *device)
4735 {
4736   struct guestfs_blockdev_getsz_args args;
4737   struct blockdev_getsz_ctx ctx;
4738   guestfs_main_loop *ml = guestfs_get_main_loop (g);
4739   int serial;
4740
4741   if (check_state (g, "guestfs_blockdev_getsz") == -1) return -1;
4742
4743   memset (&ctx, 0, sizeof ctx);
4744
4745   args.device = (char *) device;
4746   serial = guestfs__send_sync (g, GUESTFS_PROC_BLOCKDEV_GETSZ,