Generated code for mknod, mkfifo, mknod_b, mknod_c, umask.
[libguestfs.git] / daemon / stubs.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 program is free software; you can redistribute it and/or modify
8  * it under the terms of the GNU General Public License as published by
9  * the Free Software Foundation; either version 2 of the License, or
10  * (at your option) any later version.
11  *
12  * This program 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
15  * GNU General Public License for more details.
16  *
17  * You should have received a copy of the GNU General Public License along
18  * with this program; if not, write to the Free Software Foundation, Inc.,
19  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
20  */
21
22 #include <config.h>
23
24 #include <stdio.h>
25 #include <stdlib.h>
26 #include <string.h>
27 #include <inttypes.h>
28 #include <ctype.h>
29 #include <rpc/types.h>
30 #include <rpc/xdr.h>
31
32 #include "daemon.h"
33 #include "../src/guestfs_protocol.h"
34 #include "actions.h"
35
36 static void mount_stub (XDR *xdr_in)
37 {
38   int r;
39   struct guestfs_mount_args args;
40   char *device;
41   char *mountpoint;
42
43   memset (&args, 0, sizeof args);
44
45   if (!xdr_guestfs_mount_args (xdr_in, &args)) {
46     reply_with_error ("%s: daemon failed to decode procedure arguments", "mount");
47     return;
48   }
49   device = args.device;
50   mountpoint = args.mountpoint;
51
52   r = do_mount (device, mountpoint);
53   if (r == -1)
54     /* do_mount has already called reply_with_error */
55     goto done;
56
57   reply (NULL, NULL);
58 done:
59   xdr_free ((xdrproc_t) xdr_guestfs_mount_args, (char *) &args);
60 }
61
62 static void sync_stub (XDR *xdr_in)
63 {
64   int r;
65
66   r = do_sync ();
67   if (r == -1)
68     /* do_sync has already called reply_with_error */
69     goto done;
70
71   reply (NULL, NULL);
72 done: ;
73 }
74
75 static void touch_stub (XDR *xdr_in)
76 {
77   int r;
78   struct guestfs_touch_args args;
79   char *path;
80
81   memset (&args, 0, sizeof args);
82
83   if (!xdr_guestfs_touch_args (xdr_in, &args)) {
84     reply_with_error ("%s: daemon failed to decode procedure arguments", "touch");
85     return;
86   }
87   path = args.path;
88
89   r = do_touch (path);
90   if (r == -1)
91     /* do_touch has already called reply_with_error */
92     goto done;
93
94   reply (NULL, NULL);
95 done:
96   xdr_free ((xdrproc_t) xdr_guestfs_touch_args, (char *) &args);
97 }
98
99 static void cat_stub (XDR *xdr_in)
100 {
101   char *r;
102   struct guestfs_cat_args args;
103   char *path;
104
105   memset (&args, 0, sizeof args);
106
107   if (!xdr_guestfs_cat_args (xdr_in, &args)) {
108     reply_with_error ("%s: daemon failed to decode procedure arguments", "cat");
109     return;
110   }
111   path = args.path;
112
113   r = do_cat (path);
114   if (r == NULL)
115     /* do_cat has already called reply_with_error */
116     goto done;
117
118   struct guestfs_cat_ret ret;
119   ret.content = r;
120   reply ((xdrproc_t) &xdr_guestfs_cat_ret, (char *) &ret);
121   free (r);
122 done:
123   xdr_free ((xdrproc_t) xdr_guestfs_cat_args, (char *) &args);
124 }
125
126 static void ll_stub (XDR *xdr_in)
127 {
128   char *r;
129   struct guestfs_ll_args args;
130   char *directory;
131
132   memset (&args, 0, sizeof args);
133
134   if (!xdr_guestfs_ll_args (xdr_in, &args)) {
135     reply_with_error ("%s: daemon failed to decode procedure arguments", "ll");
136     return;
137   }
138   directory = args.directory;
139
140   r = do_ll (directory);
141   if (r == NULL)
142     /* do_ll has already called reply_with_error */
143     goto done;
144
145   struct guestfs_ll_ret ret;
146   ret.listing = r;
147   reply ((xdrproc_t) &xdr_guestfs_ll_ret, (char *) &ret);
148   free (r);
149 done:
150   xdr_free ((xdrproc_t) xdr_guestfs_ll_args, (char *) &args);
151 }
152
153 static void ls_stub (XDR *xdr_in)
154 {
155   char **r;
156   struct guestfs_ls_args args;
157   char *directory;
158
159   memset (&args, 0, sizeof args);
160
161   if (!xdr_guestfs_ls_args (xdr_in, &args)) {
162     reply_with_error ("%s: daemon failed to decode procedure arguments", "ls");
163     return;
164   }
165   directory = args.directory;
166
167   r = do_ls (directory);
168   if (r == NULL)
169     /* do_ls has already called reply_with_error */
170     goto done;
171
172   struct guestfs_ls_ret ret;
173   ret.listing.listing_len = count_strings (r);
174   ret.listing.listing_val = r;
175   reply ((xdrproc_t) &xdr_guestfs_ls_ret, (char *) &ret);
176   free_strings (r);
177 done:
178   xdr_free ((xdrproc_t) xdr_guestfs_ls_args, (char *) &args);
179 }
180
181 static void list_devices_stub (XDR *xdr_in)
182 {
183   char **r;
184
185   r = do_list_devices ();
186   if (r == NULL)
187     /* do_list_devices has already called reply_with_error */
188     goto done;
189
190   struct guestfs_list_devices_ret ret;
191   ret.devices.devices_len = count_strings (r);
192   ret.devices.devices_val = r;
193   reply ((xdrproc_t) &xdr_guestfs_list_devices_ret, (char *) &ret);
194   free_strings (r);
195 done: ;
196 }
197
198 static void list_partitions_stub (XDR *xdr_in)
199 {
200   char **r;
201
202   r = do_list_partitions ();
203   if (r == NULL)
204     /* do_list_partitions has already called reply_with_error */
205     goto done;
206
207   struct guestfs_list_partitions_ret ret;
208   ret.partitions.partitions_len = count_strings (r);
209   ret.partitions.partitions_val = r;
210   reply ((xdrproc_t) &xdr_guestfs_list_partitions_ret, (char *) &ret);
211   free_strings (r);
212 done: ;
213 }
214
215 static void pvs_stub (XDR *xdr_in)
216 {
217   char **r;
218
219   r = do_pvs ();
220   if (r == NULL)
221     /* do_pvs has already called reply_with_error */
222     goto done;
223
224   struct guestfs_pvs_ret ret;
225   ret.physvols.physvols_len = count_strings (r);
226   ret.physvols.physvols_val = r;
227   reply ((xdrproc_t) &xdr_guestfs_pvs_ret, (char *) &ret);
228   free_strings (r);
229 done: ;
230 }
231
232 static void vgs_stub (XDR *xdr_in)
233 {
234   char **r;
235
236   r = do_vgs ();
237   if (r == NULL)
238     /* do_vgs has already called reply_with_error */
239     goto done;
240
241   struct guestfs_vgs_ret ret;
242   ret.volgroups.volgroups_len = count_strings (r);
243   ret.volgroups.volgroups_val = r;
244   reply ((xdrproc_t) &xdr_guestfs_vgs_ret, (char *) &ret);
245   free_strings (r);
246 done: ;
247 }
248
249 static void lvs_stub (XDR *xdr_in)
250 {
251   char **r;
252
253   r = do_lvs ();
254   if (r == NULL)
255     /* do_lvs has already called reply_with_error */
256     goto done;
257
258   struct guestfs_lvs_ret ret;
259   ret.logvols.logvols_len = count_strings (r);
260   ret.logvols.logvols_val = r;
261   reply ((xdrproc_t) &xdr_guestfs_lvs_ret, (char *) &ret);
262   free_strings (r);
263 done: ;
264 }
265
266 static void pvs_full_stub (XDR *xdr_in)
267 {
268   guestfs_lvm_int_pv_list *r;
269
270   r = do_pvs_full ();
271   if (r == NULL)
272     /* do_pvs_full has already called reply_with_error */
273     goto done;
274
275   struct guestfs_pvs_full_ret ret;
276   ret.physvols = *r;
277   reply ((xdrproc_t) xdr_guestfs_pvs_full_ret, (char *) &ret);
278   xdr_free ((xdrproc_t) xdr_guestfs_pvs_full_ret, (char *) &ret);
279 done: ;
280 }
281
282 static void vgs_full_stub (XDR *xdr_in)
283 {
284   guestfs_lvm_int_vg_list *r;
285
286   r = do_vgs_full ();
287   if (r == NULL)
288     /* do_vgs_full has already called reply_with_error */
289     goto done;
290
291   struct guestfs_vgs_full_ret ret;
292   ret.volgroups = *r;
293   reply ((xdrproc_t) xdr_guestfs_vgs_full_ret, (char *) &ret);
294   xdr_free ((xdrproc_t) xdr_guestfs_vgs_full_ret, (char *) &ret);
295 done: ;
296 }
297
298 static void lvs_full_stub (XDR *xdr_in)
299 {
300   guestfs_lvm_int_lv_list *r;
301
302   r = do_lvs_full ();
303   if (r == NULL)
304     /* do_lvs_full has already called reply_with_error */
305     goto done;
306
307   struct guestfs_lvs_full_ret ret;
308   ret.logvols = *r;
309   reply ((xdrproc_t) xdr_guestfs_lvs_full_ret, (char *) &ret);
310   xdr_free ((xdrproc_t) xdr_guestfs_lvs_full_ret, (char *) &ret);
311 done: ;
312 }
313
314 static void read_lines_stub (XDR *xdr_in)
315 {
316   char **r;
317   struct guestfs_read_lines_args args;
318   char *path;
319
320   memset (&args, 0, sizeof args);
321
322   if (!xdr_guestfs_read_lines_args (xdr_in, &args)) {
323     reply_with_error ("%s: daemon failed to decode procedure arguments", "read_lines");
324     return;
325   }
326   path = args.path;
327
328   r = do_read_lines (path);
329   if (r == NULL)
330     /* do_read_lines has already called reply_with_error */
331     goto done;
332
333   struct guestfs_read_lines_ret ret;
334   ret.lines.lines_len = count_strings (r);
335   ret.lines.lines_val = r;
336   reply ((xdrproc_t) &xdr_guestfs_read_lines_ret, (char *) &ret);
337   free_strings (r);
338 done:
339   xdr_free ((xdrproc_t) xdr_guestfs_read_lines_args, (char *) &args);
340 }
341
342 static void aug_init_stub (XDR *xdr_in)
343 {
344   int r;
345   struct guestfs_aug_init_args args;
346   char *root;
347   int flags;
348
349   memset (&args, 0, sizeof args);
350
351   if (!xdr_guestfs_aug_init_args (xdr_in, &args)) {
352     reply_with_error ("%s: daemon failed to decode procedure arguments", "aug_init");
353     return;
354   }
355   root = args.root;
356   flags = args.flags;
357
358   r = do_aug_init (root, flags);
359   if (r == -1)
360     /* do_aug_init has already called reply_with_error */
361     goto done;
362
363   reply (NULL, NULL);
364 done:
365   xdr_free ((xdrproc_t) xdr_guestfs_aug_init_args, (char *) &args);
366 }
367
368 static void aug_close_stub (XDR *xdr_in)
369 {
370   int r;
371
372   r = do_aug_close ();
373   if (r == -1)
374     /* do_aug_close has already called reply_with_error */
375     goto done;
376
377   reply (NULL, NULL);
378 done: ;
379 }
380
381 static void aug_defvar_stub (XDR *xdr_in)
382 {
383   int r;
384   struct guestfs_aug_defvar_args args;
385   char *name;
386   char *expr;
387
388   memset (&args, 0, sizeof args);
389
390   if (!xdr_guestfs_aug_defvar_args (xdr_in, &args)) {
391     reply_with_error ("%s: daemon failed to decode procedure arguments", "aug_defvar");
392     return;
393   }
394   name = args.name;
395   expr = args.expr ? *args.expr : NULL;
396
397   r = do_aug_defvar (name, expr);
398   if (r == -1)
399     /* do_aug_defvar has already called reply_with_error */
400     goto done;
401
402   struct guestfs_aug_defvar_ret ret;
403   ret.nrnodes = r;
404   reply ((xdrproc_t) &xdr_guestfs_aug_defvar_ret, (char *) &ret);
405 done:
406   xdr_free ((xdrproc_t) xdr_guestfs_aug_defvar_args, (char *) &args);
407 }
408
409 static void aug_defnode_stub (XDR *xdr_in)
410 {
411   guestfs_aug_defnode_ret *r;
412   struct guestfs_aug_defnode_args args;
413   char *name;
414   char *expr;
415   char *val;
416
417   memset (&args, 0, sizeof args);
418
419   if (!xdr_guestfs_aug_defnode_args (xdr_in, &args)) {
420     reply_with_error ("%s: daemon failed to decode procedure arguments", "aug_defnode");
421     return;
422   }
423   name = args.name;
424   expr = args.expr;
425   val = args.val;
426
427   r = do_aug_defnode (name, expr, val);
428   if (r == NULL)
429     /* do_aug_defnode has already called reply_with_error */
430     goto done;
431
432   reply ((xdrproc_t) xdr_guestfs_aug_defnode_ret, (char *) r);
433   xdr_free ((xdrproc_t) xdr_guestfs_aug_defnode_ret, (char *) r);
434 done:
435   xdr_free ((xdrproc_t) xdr_guestfs_aug_defnode_args, (char *) &args);
436 }
437
438 static void aug_get_stub (XDR *xdr_in)
439 {
440   char *r;
441   struct guestfs_aug_get_args args;
442   char *path;
443
444   memset (&args, 0, sizeof args);
445
446   if (!xdr_guestfs_aug_get_args (xdr_in, &args)) {
447     reply_with_error ("%s: daemon failed to decode procedure arguments", "aug_get");
448     return;
449   }
450   path = args.path;
451
452   r = do_aug_get (path);
453   if (r == NULL)
454     /* do_aug_get has already called reply_with_error */
455     goto done;
456
457   struct guestfs_aug_get_ret ret;
458   ret.val = r;
459   reply ((xdrproc_t) &xdr_guestfs_aug_get_ret, (char *) &ret);
460   free (r);
461 done:
462   xdr_free ((xdrproc_t) xdr_guestfs_aug_get_args, (char *) &args);
463 }
464
465 static void aug_set_stub (XDR *xdr_in)
466 {
467   int r;
468   struct guestfs_aug_set_args args;
469   char *path;
470   char *val;
471
472   memset (&args, 0, sizeof args);
473
474   if (!xdr_guestfs_aug_set_args (xdr_in, &args)) {
475     reply_with_error ("%s: daemon failed to decode procedure arguments", "aug_set");
476     return;
477   }
478   path = args.path;
479   val = args.val;
480
481   r = do_aug_set (path, val);
482   if (r == -1)
483     /* do_aug_set has already called reply_with_error */
484     goto done;
485
486   reply (NULL, NULL);
487 done:
488   xdr_free ((xdrproc_t) xdr_guestfs_aug_set_args, (char *) &args);
489 }
490
491 static void aug_insert_stub (XDR *xdr_in)
492 {
493   int r;
494   struct guestfs_aug_insert_args args;
495   char *path;
496   char *label;
497   int before;
498
499   memset (&args, 0, sizeof args);
500
501   if (!xdr_guestfs_aug_insert_args (xdr_in, &args)) {
502     reply_with_error ("%s: daemon failed to decode procedure arguments", "aug_insert");
503     return;
504   }
505   path = args.path;
506   label = args.label;
507   before = args.before;
508
509   r = do_aug_insert (path, label, before);
510   if (r == -1)
511     /* do_aug_insert has already called reply_with_error */
512     goto done;
513
514   reply (NULL, NULL);
515 done:
516   xdr_free ((xdrproc_t) xdr_guestfs_aug_insert_args, (char *) &args);
517 }
518
519 static void aug_rm_stub (XDR *xdr_in)
520 {
521   int r;
522   struct guestfs_aug_rm_args args;
523   char *path;
524
525   memset (&args, 0, sizeof args);
526
527   if (!xdr_guestfs_aug_rm_args (xdr_in, &args)) {
528     reply_with_error ("%s: daemon failed to decode procedure arguments", "aug_rm");
529     return;
530   }
531   path = args.path;
532
533   r = do_aug_rm (path);
534   if (r == -1)
535     /* do_aug_rm has already called reply_with_error */
536     goto done;
537
538   struct guestfs_aug_rm_ret ret;
539   ret.nrnodes = r;
540   reply ((xdrproc_t) &xdr_guestfs_aug_rm_ret, (char *) &ret);
541 done:
542   xdr_free ((xdrproc_t) xdr_guestfs_aug_rm_args, (char *) &args);
543 }
544
545 static void aug_mv_stub (XDR *xdr_in)
546 {
547   int r;
548   struct guestfs_aug_mv_args args;
549   char *src;
550   char *dest;
551
552   memset (&args, 0, sizeof args);
553
554   if (!xdr_guestfs_aug_mv_args (xdr_in, &args)) {
555     reply_with_error ("%s: daemon failed to decode procedure arguments", "aug_mv");
556     return;
557   }
558   src = args.src;
559   dest = args.dest;
560
561   r = do_aug_mv (src, dest);
562   if (r == -1)
563     /* do_aug_mv has already called reply_with_error */
564     goto done;
565
566   reply (NULL, NULL);
567 done:
568   xdr_free ((xdrproc_t) xdr_guestfs_aug_mv_args, (char *) &args);
569 }
570
571 static void aug_match_stub (XDR *xdr_in)
572 {
573   char **r;
574   struct guestfs_aug_match_args args;
575   char *path;
576
577   memset (&args, 0, sizeof args);
578
579   if (!xdr_guestfs_aug_match_args (xdr_in, &args)) {
580     reply_with_error ("%s: daemon failed to decode procedure arguments", "aug_match");
581     return;
582   }
583   path = args.path;
584
585   r = do_aug_match (path);
586   if (r == NULL)
587     /* do_aug_match has already called reply_with_error */
588     goto done;
589
590   struct guestfs_aug_match_ret ret;
591   ret.matches.matches_len = count_strings (r);
592   ret.matches.matches_val = r;
593   reply ((xdrproc_t) &xdr_guestfs_aug_match_ret, (char *) &ret);
594   free_strings (r);
595 done:
596   xdr_free ((xdrproc_t) xdr_guestfs_aug_match_args, (char *) &args);
597 }
598
599 static void aug_save_stub (XDR *xdr_in)
600 {
601   int r;
602
603   r = do_aug_save ();
604   if (r == -1)
605     /* do_aug_save has already called reply_with_error */
606     goto done;
607
608   reply (NULL, NULL);
609 done: ;
610 }
611
612 static void aug_load_stub (XDR *xdr_in)
613 {
614   int r;
615
616   r = do_aug_load ();
617   if (r == -1)
618     /* do_aug_load has already called reply_with_error */
619     goto done;
620
621   reply (NULL, NULL);
622 done: ;
623 }
624
625 static void aug_ls_stub (XDR *xdr_in)
626 {
627   char **r;
628   struct guestfs_aug_ls_args args;
629   char *path;
630
631   memset (&args, 0, sizeof args);
632
633   if (!xdr_guestfs_aug_ls_args (xdr_in, &args)) {
634     reply_with_error ("%s: daemon failed to decode procedure arguments", "aug_ls");
635     return;
636   }
637   path = args.path;
638
639   r = do_aug_ls (path);
640   if (r == NULL)
641     /* do_aug_ls has already called reply_with_error */
642     goto done;
643
644   struct guestfs_aug_ls_ret ret;
645   ret.matches.matches_len = count_strings (r);
646   ret.matches.matches_val = r;
647   reply ((xdrproc_t) &xdr_guestfs_aug_ls_ret, (char *) &ret);
648   free_strings (r);
649 done:
650   xdr_free ((xdrproc_t) xdr_guestfs_aug_ls_args, (char *) &args);
651 }
652
653 static void rm_stub (XDR *xdr_in)
654 {
655   int r;
656   struct guestfs_rm_args args;
657   char *path;
658
659   memset (&args, 0, sizeof args);
660
661   if (!xdr_guestfs_rm_args (xdr_in, &args)) {
662     reply_with_error ("%s: daemon failed to decode procedure arguments", "rm");
663     return;
664   }
665   path = args.path;
666
667   r = do_rm (path);
668   if (r == -1)
669     /* do_rm has already called reply_with_error */
670     goto done;
671
672   reply (NULL, NULL);
673 done:
674   xdr_free ((xdrproc_t) xdr_guestfs_rm_args, (char *) &args);
675 }
676
677 static void rmdir_stub (XDR *xdr_in)
678 {
679   int r;
680   struct guestfs_rmdir_args args;
681   char *path;
682
683   memset (&args, 0, sizeof args);
684
685   if (!xdr_guestfs_rmdir_args (xdr_in, &args)) {
686     reply_with_error ("%s: daemon failed to decode procedure arguments", "rmdir");
687     return;
688   }
689   path = args.path;
690
691   r = do_rmdir (path);
692   if (r == -1)
693     /* do_rmdir has already called reply_with_error */
694     goto done;
695
696   reply (NULL, NULL);
697 done:
698   xdr_free ((xdrproc_t) xdr_guestfs_rmdir_args, (char *) &args);
699 }
700
701 static void rm_rf_stub (XDR *xdr_in)
702 {
703   int r;
704   struct guestfs_rm_rf_args args;
705   char *path;
706
707   memset (&args, 0, sizeof args);
708
709   if (!xdr_guestfs_rm_rf_args (xdr_in, &args)) {
710     reply_with_error ("%s: daemon failed to decode procedure arguments", "rm_rf");
711     return;
712   }
713   path = args.path;
714
715   r = do_rm_rf (path);
716   if (r == -1)
717     /* do_rm_rf has already called reply_with_error */
718     goto done;
719
720   reply (NULL, NULL);
721 done:
722   xdr_free ((xdrproc_t) xdr_guestfs_rm_rf_args, (char *) &args);
723 }
724
725 static void mkdir_stub (XDR *xdr_in)
726 {
727   int r;
728   struct guestfs_mkdir_args args;
729   char *path;
730
731   memset (&args, 0, sizeof args);
732
733   if (!xdr_guestfs_mkdir_args (xdr_in, &args)) {
734     reply_with_error ("%s: daemon failed to decode procedure arguments", "mkdir");
735     return;
736   }
737   path = args.path;
738
739   r = do_mkdir (path);
740   if (r == -1)
741     /* do_mkdir has already called reply_with_error */
742     goto done;
743
744   reply (NULL, NULL);
745 done:
746   xdr_free ((xdrproc_t) xdr_guestfs_mkdir_args, (char *) &args);
747 }
748
749 static void mkdir_p_stub (XDR *xdr_in)
750 {
751   int r;
752   struct guestfs_mkdir_p_args args;
753   char *path;
754
755   memset (&args, 0, sizeof args);
756
757   if (!xdr_guestfs_mkdir_p_args (xdr_in, &args)) {
758     reply_with_error ("%s: daemon failed to decode procedure arguments", "mkdir_p");
759     return;
760   }
761   path = args.path;
762
763   r = do_mkdir_p (path);
764   if (r == -1)
765     /* do_mkdir_p has already called reply_with_error */
766     goto done;
767
768   reply (NULL, NULL);
769 done:
770   xdr_free ((xdrproc_t) xdr_guestfs_mkdir_p_args, (char *) &args);
771 }
772
773 static void chmod_stub (XDR *xdr_in)
774 {
775   int r;
776   struct guestfs_chmod_args args;
777   int mode;
778   char *path;
779
780   memset (&args, 0, sizeof args);
781
782   if (!xdr_guestfs_chmod_args (xdr_in, &args)) {
783     reply_with_error ("%s: daemon failed to decode procedure arguments", "chmod");
784     return;
785   }
786   mode = args.mode;
787   path = args.path;
788
789   r = do_chmod (mode, path);
790   if (r == -1)
791     /* do_chmod has already called reply_with_error */
792     goto done;
793
794   reply (NULL, NULL);
795 done:
796   xdr_free ((xdrproc_t) xdr_guestfs_chmod_args, (char *) &args);
797 }
798
799 static void chown_stub (XDR *xdr_in)
800 {
801   int r;
802   struct guestfs_chown_args args;
803   int owner;
804   int group;
805   char *path;
806
807   memset (&args, 0, sizeof args);
808
809   if (!xdr_guestfs_chown_args (xdr_in, &args)) {
810     reply_with_error ("%s: daemon failed to decode procedure arguments", "chown");
811     return;
812   }
813   owner = args.owner;
814   group = args.group;
815   path = args.path;
816
817   r = do_chown (owner, group, path);
818   if (r == -1)
819     /* do_chown has already called reply_with_error */
820     goto done;
821
822   reply (NULL, NULL);
823 done:
824   xdr_free ((xdrproc_t) xdr_guestfs_chown_args, (char *) &args);
825 }
826
827 static void exists_stub (XDR *xdr_in)
828 {
829   int r;
830   struct guestfs_exists_args args;
831   char *path;
832
833   memset (&args, 0, sizeof args);
834
835   if (!xdr_guestfs_exists_args (xdr_in, &args)) {
836     reply_with_error ("%s: daemon failed to decode procedure arguments", "exists");
837     return;
838   }
839   path = args.path;
840
841   r = do_exists (path);
842   if (r == -1)
843     /* do_exists has already called reply_with_error */
844     goto done;
845
846   struct guestfs_exists_ret ret;
847   ret.existsflag = r;
848   reply ((xdrproc_t) &xdr_guestfs_exists_ret, (char *) &ret);
849 done:
850   xdr_free ((xdrproc_t) xdr_guestfs_exists_args, (char *) &args);
851 }
852
853 static void is_file_stub (XDR *xdr_in)
854 {
855   int r;
856   struct guestfs_is_file_args args;
857   char *path;
858
859   memset (&args, 0, sizeof args);
860
861   if (!xdr_guestfs_is_file_args (xdr_in, &args)) {
862     reply_with_error ("%s: daemon failed to decode procedure arguments", "is_file");
863     return;
864   }
865   path = args.path;
866
867   r = do_is_file (path);
868   if (r == -1)
869     /* do_is_file has already called reply_with_error */
870     goto done;
871
872   struct guestfs_is_file_ret ret;
873   ret.fileflag = r;
874   reply ((xdrproc_t) &xdr_guestfs_is_file_ret, (char *) &ret);
875 done:
876   xdr_free ((xdrproc_t) xdr_guestfs_is_file_args, (char *) &args);
877 }
878
879 static void is_dir_stub (XDR *xdr_in)
880 {
881   int r;
882   struct guestfs_is_dir_args args;
883   char *path;
884
885   memset (&args, 0, sizeof args);
886
887   if (!xdr_guestfs_is_dir_args (xdr_in, &args)) {
888     reply_with_error ("%s: daemon failed to decode procedure arguments", "is_dir");
889     return;
890   }
891   path = args.path;
892
893   r = do_is_dir (path);
894   if (r == -1)
895     /* do_is_dir has already called reply_with_error */
896     goto done;
897
898   struct guestfs_is_dir_ret ret;
899   ret.dirflag = r;
900   reply ((xdrproc_t) &xdr_guestfs_is_dir_ret, (char *) &ret);
901 done:
902   xdr_free ((xdrproc_t) xdr_guestfs_is_dir_args, (char *) &args);
903 }
904
905 static void pvcreate_stub (XDR *xdr_in)
906 {
907   int r;
908   struct guestfs_pvcreate_args args;
909   char *device;
910
911   memset (&args, 0, sizeof args);
912
913   if (!xdr_guestfs_pvcreate_args (xdr_in, &args)) {
914     reply_with_error ("%s: daemon failed to decode procedure arguments", "pvcreate");
915     return;
916   }
917   device = args.device;
918
919   r = do_pvcreate (device);
920   if (r == -1)
921     /* do_pvcreate has already called reply_with_error */
922     goto done;
923
924   reply (NULL, NULL);
925 done:
926   xdr_free ((xdrproc_t) xdr_guestfs_pvcreate_args, (char *) &args);
927 }
928
929 static void vgcreate_stub (XDR *xdr_in)
930 {
931   int r;
932   struct guestfs_vgcreate_args args;
933   char *volgroup;
934   char **physvols;
935
936   memset (&args, 0, sizeof args);
937
938   if (!xdr_guestfs_vgcreate_args (xdr_in, &args)) {
939     reply_with_error ("%s: daemon failed to decode procedure arguments", "vgcreate");
940     return;
941   }
942   volgroup = args.volgroup;
943   physvols = realloc (args.physvols.physvols_val,
944                 sizeof (char *) * (args.physvols.physvols_len+1));
945   if (physvols == NULL) {
946     reply_with_perror ("realloc");
947     goto done;
948   }
949   physvols[args.physvols.physvols_len] = NULL;
950   args.physvols.physvols_val = physvols;
951
952   r = do_vgcreate (volgroup, physvols);
953   if (r == -1)
954     /* do_vgcreate has already called reply_with_error */
955     goto done;
956
957   reply (NULL, NULL);
958 done:
959   xdr_free ((xdrproc_t) xdr_guestfs_vgcreate_args, (char *) &args);
960 }
961
962 static void lvcreate_stub (XDR *xdr_in)
963 {
964   int r;
965   struct guestfs_lvcreate_args args;
966   char *logvol;
967   char *volgroup;
968   int mbytes;
969
970   memset (&args, 0, sizeof args);
971
972   if (!xdr_guestfs_lvcreate_args (xdr_in, &args)) {
973     reply_with_error ("%s: daemon failed to decode procedure arguments", "lvcreate");
974     return;
975   }
976   logvol = args.logvol;
977   volgroup = args.volgroup;
978   mbytes = args.mbytes;
979
980   r = do_lvcreate (logvol, volgroup, mbytes);
981   if (r == -1)
982     /* do_lvcreate has already called reply_with_error */
983     goto done;
984
985   reply (NULL, NULL);
986 done:
987   xdr_free ((xdrproc_t) xdr_guestfs_lvcreate_args, (char *) &args);
988 }
989
990 static void mkfs_stub (XDR *xdr_in)
991 {
992   int r;
993   struct guestfs_mkfs_args args;
994   char *fstype;
995   char *device;
996
997   memset (&args, 0, sizeof args);
998
999   if (!xdr_guestfs_mkfs_args (xdr_in, &args)) {
1000     reply_with_error ("%s: daemon failed to decode procedure arguments", "mkfs");
1001     return;
1002   }
1003   fstype = args.fstype;
1004   device = args.device;
1005
1006   r = do_mkfs (fstype, device);
1007   if (r == -1)
1008     /* do_mkfs has already called reply_with_error */
1009     goto done;
1010
1011   reply (NULL, NULL);
1012 done:
1013   xdr_free ((xdrproc_t) xdr_guestfs_mkfs_args, (char *) &args);
1014 }
1015
1016 static void sfdisk_stub (XDR *xdr_in)
1017 {
1018   int r;
1019   struct guestfs_sfdisk_args args;
1020   char *device;
1021   int cyls;
1022   int heads;
1023   int sectors;
1024   char **lines;
1025
1026   memset (&args, 0, sizeof args);
1027
1028   if (!xdr_guestfs_sfdisk_args (xdr_in, &args)) {
1029     reply_with_error ("%s: daemon failed to decode procedure arguments", "sfdisk");
1030     return;
1031   }
1032   device = args.device;
1033   cyls = args.cyls;
1034   heads = args.heads;
1035   sectors = args.sectors;
1036   lines = realloc (args.lines.lines_val,
1037                 sizeof (char *) * (args.lines.lines_len+1));
1038   if (lines == NULL) {
1039     reply_with_perror ("realloc");
1040     goto done;
1041   }
1042   lines[args.lines.lines_len] = NULL;
1043   args.lines.lines_val = lines;
1044
1045   r = do_sfdisk (device, cyls, heads, sectors, lines);
1046   if (r == -1)
1047     /* do_sfdisk has already called reply_with_error */
1048     goto done;
1049
1050   reply (NULL, NULL);
1051 done:
1052   xdr_free ((xdrproc_t) xdr_guestfs_sfdisk_args, (char *) &args);
1053 }
1054
1055 static void write_file_stub (XDR *xdr_in)
1056 {
1057   int r;
1058   struct guestfs_write_file_args args;
1059   char *path;
1060   char *content;
1061   int size;
1062
1063   memset (&args, 0, sizeof args);
1064
1065   if (!xdr_guestfs_write_file_args (xdr_in, &args)) {
1066     reply_with_error ("%s: daemon failed to decode procedure arguments", "write_file");
1067     return;
1068   }
1069   path = args.path;
1070   content = args.content;
1071   size = args.size;
1072
1073   r = do_write_file (path, content, size);
1074   if (r == -1)
1075     /* do_write_file has already called reply_with_error */
1076     goto done;
1077
1078   reply (NULL, NULL);
1079 done:
1080   xdr_free ((xdrproc_t) xdr_guestfs_write_file_args, (char *) &args);
1081 }
1082
1083 static void umount_stub (XDR *xdr_in)
1084 {
1085   int r;
1086   struct guestfs_umount_args args;
1087   char *pathordevice;
1088
1089   memset (&args, 0, sizeof args);
1090
1091   if (!xdr_guestfs_umount_args (xdr_in, &args)) {
1092     reply_with_error ("%s: daemon failed to decode procedure arguments", "umount");
1093     return;
1094   }
1095   pathordevice = args.pathordevice;
1096
1097   r = do_umount (pathordevice);
1098   if (r == -1)
1099     /* do_umount has already called reply_with_error */
1100     goto done;
1101
1102   reply (NULL, NULL);
1103 done:
1104   xdr_free ((xdrproc_t) xdr_guestfs_umount_args, (char *) &args);
1105 }
1106
1107 static void mounts_stub (XDR *xdr_in)
1108 {
1109   char **r;
1110
1111   r = do_mounts ();
1112   if (r == NULL)
1113     /* do_mounts has already called reply_with_error */
1114     goto done;
1115
1116   struct guestfs_mounts_ret ret;
1117   ret.devices.devices_len = count_strings (r);
1118   ret.devices.devices_val = r;
1119   reply ((xdrproc_t) &xdr_guestfs_mounts_ret, (char *) &ret);
1120   free_strings (r);
1121 done: ;
1122 }
1123
1124 static void umount_all_stub (XDR *xdr_in)
1125 {
1126   int r;
1127
1128   r = do_umount_all ();
1129   if (r == -1)
1130     /* do_umount_all has already called reply_with_error */
1131     goto done;
1132
1133   reply (NULL, NULL);
1134 done: ;
1135 }
1136
1137 static void lvm_remove_all_stub (XDR *xdr_in)
1138 {
1139   int r;
1140
1141   r = do_lvm_remove_all ();
1142   if (r == -1)
1143     /* do_lvm_remove_all has already called reply_with_error */
1144     goto done;
1145
1146   reply (NULL, NULL);
1147 done: ;
1148 }
1149
1150 static void file_stub (XDR *xdr_in)
1151 {
1152   char *r;
1153   struct guestfs_file_args args;
1154   char *path;
1155
1156   memset (&args, 0, sizeof args);
1157
1158   if (!xdr_guestfs_file_args (xdr_in, &args)) {
1159     reply_with_error ("%s: daemon failed to decode procedure arguments", "file");
1160     return;
1161   }
1162   path = args.path;
1163
1164   r = do_file (path);
1165   if (r == NULL)
1166     /* do_file has already called reply_with_error */
1167     goto done;
1168
1169   struct guestfs_file_ret ret;
1170   ret.description = r;
1171   reply ((xdrproc_t) &xdr_guestfs_file_ret, (char *) &ret);
1172   free (r);
1173 done:
1174   xdr_free ((xdrproc_t) xdr_guestfs_file_args, (char *) &args);
1175 }
1176
1177 static void command_stub (XDR *xdr_in)
1178 {
1179   char *r;
1180   struct guestfs_command_args args;
1181   char **arguments;
1182
1183   memset (&args, 0, sizeof args);
1184
1185   if (!xdr_guestfs_command_args (xdr_in, &args)) {
1186     reply_with_error ("%s: daemon failed to decode procedure arguments", "command");
1187     return;
1188   }
1189   arguments = realloc (args.arguments.arguments_val,
1190                 sizeof (char *) * (args.arguments.arguments_len+1));
1191   if (arguments == NULL) {
1192     reply_with_perror ("realloc");
1193     goto done;
1194   }
1195   arguments[args.arguments.arguments_len] = NULL;
1196   args.arguments.arguments_val = arguments;
1197
1198   r = do_command (arguments);
1199   if (r == NULL)
1200     /* do_command has already called reply_with_error */
1201     goto done;
1202
1203   struct guestfs_command_ret ret;
1204   ret.output = r;
1205   reply ((xdrproc_t) &xdr_guestfs_command_ret, (char *) &ret);
1206   free (r);
1207 done:
1208   xdr_free ((xdrproc_t) xdr_guestfs_command_args, (char *) &args);
1209 }
1210
1211 static void command_lines_stub (XDR *xdr_in)
1212 {
1213   char **r;
1214   struct guestfs_command_lines_args args;
1215   char **arguments;
1216
1217   memset (&args, 0, sizeof args);
1218
1219   if (!xdr_guestfs_command_lines_args (xdr_in, &args)) {
1220     reply_with_error ("%s: daemon failed to decode procedure arguments", "command_lines");
1221     return;
1222   }
1223   arguments = realloc (args.arguments.arguments_val,
1224                 sizeof (char *) * (args.arguments.arguments_len+1));
1225   if (arguments == NULL) {
1226     reply_with_perror ("realloc");
1227     goto done;
1228   }
1229   arguments[args.arguments.arguments_len] = NULL;
1230   args.arguments.arguments_val = arguments;
1231
1232   r = do_command_lines (arguments);
1233   if (r == NULL)
1234     /* do_command_lines has already called reply_with_error */
1235     goto done;
1236
1237   struct guestfs_command_lines_ret ret;
1238   ret.lines.lines_len = count_strings (r);
1239   ret.lines.lines_val = r;
1240   reply ((xdrproc_t) &xdr_guestfs_command_lines_ret, (char *) &ret);
1241   free_strings (r);
1242 done:
1243   xdr_free ((xdrproc_t) xdr_guestfs_command_lines_args, (char *) &args);
1244 }
1245
1246 static void stat_stub (XDR *xdr_in)
1247 {
1248   guestfs_int_stat *r;
1249   struct guestfs_stat_args args;
1250   char *path;
1251
1252   memset (&args, 0, sizeof args);
1253
1254   if (!xdr_guestfs_stat_args (xdr_in, &args)) {
1255     reply_with_error ("%s: daemon failed to decode procedure arguments", "stat");
1256     return;
1257   }
1258   path = args.path;
1259
1260   r = do_stat (path);
1261   if (r == NULL)
1262     /* do_stat has already called reply_with_error */
1263     goto done;
1264
1265   struct guestfs_stat_ret ret;
1266   ret.statbuf = *r;
1267   reply ((xdrproc_t) xdr_guestfs_stat_ret, (char *) &ret);
1268   xdr_free ((xdrproc_t) xdr_guestfs_stat_ret, (char *) &ret);
1269 done:
1270   xdr_free ((xdrproc_t) xdr_guestfs_stat_args, (char *) &args);
1271 }
1272
1273 static void lstat_stub (XDR *xdr_in)
1274 {
1275   guestfs_int_stat *r;
1276   struct guestfs_lstat_args args;
1277   char *path;
1278
1279   memset (&args, 0, sizeof args);
1280
1281   if (!xdr_guestfs_lstat_args (xdr_in, &args)) {
1282     reply_with_error ("%s: daemon failed to decode procedure arguments", "lstat");
1283     return;
1284   }
1285   path = args.path;
1286
1287   r = do_lstat (path);
1288   if (r == NULL)
1289     /* do_lstat has already called reply_with_error */
1290     goto done;
1291
1292   struct guestfs_lstat_ret ret;
1293   ret.statbuf = *r;
1294   reply ((xdrproc_t) xdr_guestfs_lstat_ret, (char *) &ret);
1295   xdr_free ((xdrproc_t) xdr_guestfs_lstat_ret, (char *) &ret);
1296 done:
1297   xdr_free ((xdrproc_t) xdr_guestfs_lstat_args, (char *) &args);
1298 }
1299
1300 static void statvfs_stub (XDR *xdr_in)
1301 {
1302   guestfs_int_statvfs *r;
1303   struct guestfs_statvfs_args args;
1304   char *path;
1305
1306   memset (&args, 0, sizeof args);
1307
1308   if (!xdr_guestfs_statvfs_args (xdr_in, &args)) {
1309     reply_with_error ("%s: daemon failed to decode procedure arguments", "statvfs");
1310     return;
1311   }
1312   path = args.path;
1313
1314   r = do_statvfs (path);
1315   if (r == NULL)
1316     /* do_statvfs has already called reply_with_error */
1317     goto done;
1318
1319   struct guestfs_statvfs_ret ret;
1320   ret.statbuf = *r;
1321   reply ((xdrproc_t) xdr_guestfs_statvfs_ret, (char *) &ret);
1322   xdr_free ((xdrproc_t) xdr_guestfs_statvfs_ret, (char *) &ret);
1323 done:
1324   xdr_free ((xdrproc_t) xdr_guestfs_statvfs_args, (char *) &args);
1325 }
1326
1327 static void tune2fs_l_stub (XDR *xdr_in)
1328 {
1329   char **r;
1330   struct guestfs_tune2fs_l_args args;
1331   char *device;
1332
1333   memset (&args, 0, sizeof args);
1334
1335   if (!xdr_guestfs_tune2fs_l_args (xdr_in, &args)) {
1336     reply_with_error ("%s: daemon failed to decode procedure arguments", "tune2fs_l");
1337     return;
1338   }
1339   device = args.device;
1340
1341   r = do_tune2fs_l (device);
1342   if (r == NULL)
1343     /* do_tune2fs_l has already called reply_with_error */
1344     goto done;
1345
1346   struct guestfs_tune2fs_l_ret ret;
1347   ret.superblock.superblock_len = count_strings (r);
1348   ret.superblock.superblock_val = r;
1349   reply ((xdrproc_t) &xdr_guestfs_tune2fs_l_ret, (char *) &ret);
1350   free_strings (r);
1351 done:
1352   xdr_free ((xdrproc_t) xdr_guestfs_tune2fs_l_args, (char *) &args);
1353 }
1354
1355 static void blockdev_setro_stub (XDR *xdr_in)
1356 {
1357   int r;
1358   struct guestfs_blockdev_setro_args args;
1359   char *device;
1360
1361   memset (&args, 0, sizeof args);
1362
1363   if (!xdr_guestfs_blockdev_setro_args (xdr_in, &args)) {
1364     reply_with_error ("%s: daemon failed to decode procedure arguments", "blockdev_setro");
1365     return;
1366   }
1367   device = args.device;
1368
1369   r = do_blockdev_setro (device);
1370   if (r == -1)
1371     /* do_blockdev_setro has already called reply_with_error */
1372     goto done;
1373
1374   reply (NULL, NULL);
1375 done:
1376   xdr_free ((xdrproc_t) xdr_guestfs_blockdev_setro_args, (char *) &args);
1377 }
1378
1379 static void blockdev_setrw_stub (XDR *xdr_in)
1380 {
1381   int r;
1382   struct guestfs_blockdev_setrw_args args;
1383   char *device;
1384
1385   memset (&args, 0, sizeof args);
1386
1387   if (!xdr_guestfs_blockdev_setrw_args (xdr_in, &args)) {
1388     reply_with_error ("%s: daemon failed to decode procedure arguments", "blockdev_setrw");
1389     return;
1390   }
1391   device = args.device;
1392
1393   r = do_blockdev_setrw (device);
1394   if (r == -1)
1395     /* do_blockdev_setrw has already called reply_with_error */
1396     goto done;
1397
1398   reply (NULL, NULL);
1399 done:
1400   xdr_free ((xdrproc_t) xdr_guestfs_blockdev_setrw_args, (char *) &args);
1401 }
1402
1403 static void blockdev_getro_stub (XDR *xdr_in)
1404 {
1405   int r;
1406   struct guestfs_blockdev_getro_args args;
1407   char *device;
1408
1409   memset (&args, 0, sizeof args);
1410
1411   if (!xdr_guestfs_blockdev_getro_args (xdr_in, &args)) {
1412     reply_with_error ("%s: daemon failed to decode procedure arguments", "blockdev_getro");
1413     return;
1414   }
1415   device = args.device;
1416
1417   r = do_blockdev_getro (device);
1418   if (r == -1)
1419     /* do_blockdev_getro has already called reply_with_error */
1420     goto done;
1421
1422   struct guestfs_blockdev_getro_ret ret;
1423   ret.ro = r;
1424   reply ((xdrproc_t) &xdr_guestfs_blockdev_getro_ret, (char *) &ret);
1425 done:
1426   xdr_free ((xdrproc_t) xdr_guestfs_blockdev_getro_args, (char *) &args);
1427 }
1428
1429 static void blockdev_getss_stub (XDR *xdr_in)
1430 {
1431   int r;
1432   struct guestfs_blockdev_getss_args args;
1433   char *device;
1434
1435   memset (&args, 0, sizeof args);
1436
1437   if (!xdr_guestfs_blockdev_getss_args (xdr_in, &args)) {
1438     reply_with_error ("%s: daemon failed to decode procedure arguments", "blockdev_getss");
1439     return;
1440   }
1441   device = args.device;
1442
1443   r = do_blockdev_getss (device);
1444   if (r == -1)
1445     /* do_blockdev_getss has already called reply_with_error */
1446     goto done;
1447
1448   struct guestfs_blockdev_getss_ret ret;
1449   ret.sectorsize = r;
1450   reply ((xdrproc_t) &xdr_guestfs_blockdev_getss_ret, (char *) &ret);
1451 done:
1452   xdr_free ((xdrproc_t) xdr_guestfs_blockdev_getss_args, (char *) &args);
1453 }
1454
1455 static void blockdev_getbsz_stub (XDR *xdr_in)
1456 {
1457   int r;
1458   struct guestfs_blockdev_getbsz_args args;
1459   char *device;
1460
1461   memset (&args, 0, sizeof args);
1462
1463   if (!xdr_guestfs_blockdev_getbsz_args (xdr_in, &args)) {
1464     reply_with_error ("%s: daemon failed to decode procedure arguments", "blockdev_getbsz");
1465     return;
1466   }
1467   device = args.device;
1468
1469   r = do_blockdev_getbsz (device);
1470   if (r == -1)
1471     /* do_blockdev_getbsz has already called reply_with_error */
1472     goto done;
1473
1474   struct guestfs_blockdev_getbsz_ret ret;
1475   ret.blocksize = r;
1476   reply ((xdrproc_t) &xdr_guestfs_blockdev_getbsz_ret, (char *) &ret);
1477 done:
1478   xdr_free ((xdrproc_t) xdr_guestfs_blockdev_getbsz_args, (char *) &args);
1479 }
1480
1481 static void blockdev_setbsz_stub (XDR *xdr_in)
1482 {
1483   int r;
1484   struct guestfs_blockdev_setbsz_args args;
1485   char *device;
1486   int blocksize;
1487
1488   memset (&args, 0, sizeof args);
1489
1490   if (!xdr_guestfs_blockdev_setbsz_args (xdr_in, &args)) {
1491     reply_with_error ("%s: daemon failed to decode procedure arguments", "blockdev_setbsz");
1492     return;
1493   }
1494   device = args.device;
1495   blocksize = args.blocksize;
1496
1497   r = do_blockdev_setbsz (device, blocksize);
1498   if (r == -1)
1499     /* do_blockdev_setbsz has already called reply_with_error */
1500     goto done;
1501
1502   reply (NULL, NULL);
1503 done:
1504   xdr_free ((xdrproc_t) xdr_guestfs_blockdev_setbsz_args, (char *) &args);
1505 }
1506
1507 static void blockdev_getsz_stub (XDR *xdr_in)
1508 {
1509   int64_t r;
1510   struct guestfs_blockdev_getsz_args args;
1511   char *device;
1512
1513   memset (&args, 0, sizeof args);
1514
1515   if (!xdr_guestfs_blockdev_getsz_args (xdr_in, &args)) {
1516     reply_with_error ("%s: daemon failed to decode procedure arguments", "blockdev_getsz");
1517     return;
1518   }
1519   device = args.device;
1520
1521   r = do_blockdev_getsz (device);
1522   if (r == -1)
1523     /* do_blockdev_getsz has already called reply_with_error */
1524     goto done;
1525
1526   struct guestfs_blockdev_getsz_ret ret;
1527   ret.sizeinsectors = r;
1528   reply ((xdrproc_t) &xdr_guestfs_blockdev_getsz_ret, (char *) &ret);
1529 done:
1530   xdr_free ((xdrproc_t) xdr_guestfs_blockdev_getsz_args, (char *) &args);
1531 }
1532
1533 static void blockdev_getsize64_stub (XDR *xdr_in)
1534 {
1535   int64_t r;
1536   struct guestfs_blockdev_getsize64_args args;
1537   char *device;
1538
1539   memset (&args, 0, sizeof args);
1540
1541   if (!xdr_guestfs_blockdev_getsize64_args (xdr_in, &args)) {
1542     reply_with_error ("%s: daemon failed to decode procedure arguments", "blockdev_getsize64");
1543     return;
1544   }
1545   device = args.device;
1546
1547   r = do_blockdev_getsize64 (device);
1548   if (r == -1)
1549     /* do_blockdev_getsize64 has already called reply_with_error */
1550     goto done;
1551
1552   struct guestfs_blockdev_getsize64_ret ret;
1553   ret.sizeinbytes = r;
1554   reply ((xdrproc_t) &xdr_guestfs_blockdev_getsize64_ret, (char *) &ret);
1555 done:
1556   xdr_free ((xdrproc_t) xdr_guestfs_blockdev_getsize64_args, (char *) &args);
1557 }
1558
1559 static void blockdev_flushbufs_stub (XDR *xdr_in)
1560 {
1561   int r;
1562   struct guestfs_blockdev_flushbufs_args args;
1563   char *device;
1564
1565   memset (&args, 0, sizeof args);
1566
1567   if (!xdr_guestfs_blockdev_flushbufs_args (xdr_in, &args)) {
1568     reply_with_error ("%s: daemon failed to decode procedure arguments", "blockdev_flushbufs");
1569     return;
1570   }
1571   device = args.device;
1572
1573   r = do_blockdev_flushbufs (device);
1574   if (r == -1)
1575     /* do_blockdev_flushbufs has already called reply_with_error */
1576     goto done;
1577
1578   reply (NULL, NULL);
1579 done:
1580   xdr_free ((xdrproc_t) xdr_guestfs_blockdev_flushbufs_args, (char *) &args);
1581 }
1582
1583 static void blockdev_rereadpt_stub (XDR *xdr_in)
1584 {
1585   int r;
1586   struct guestfs_blockdev_rereadpt_args args;
1587   char *device;
1588
1589   memset (&args, 0, sizeof args);
1590
1591   if (!xdr_guestfs_blockdev_rereadpt_args (xdr_in, &args)) {
1592     reply_with_error ("%s: daemon failed to decode procedure arguments", "blockdev_rereadpt");
1593     return;
1594   }
1595   device = args.device;
1596
1597   r = do_blockdev_rereadpt (device);
1598   if (r == -1)
1599     /* do_blockdev_rereadpt has already called reply_with_error */
1600     goto done;
1601
1602   reply (NULL, NULL);
1603 done:
1604   xdr_free ((xdrproc_t) xdr_guestfs_blockdev_rereadpt_args, (char *) &args);
1605 }
1606
1607 static void upload_stub (XDR *xdr_in)
1608 {
1609   int r;
1610   struct guestfs_upload_args args;
1611   char *remotefilename;
1612
1613   memset (&args, 0, sizeof args);
1614
1615   if (!xdr_guestfs_upload_args (xdr_in, &args)) {
1616     reply_with_error ("%s: daemon failed to decode procedure arguments", "upload");
1617     return;
1618   }
1619   remotefilename = args.remotefilename;
1620
1621   r = do_upload (remotefilename);
1622   if (r == -1)
1623     /* do_upload has already called reply_with_error */
1624     goto done;
1625
1626   reply (NULL, NULL);
1627 done:
1628   xdr_free ((xdrproc_t) xdr_guestfs_upload_args, (char *) &args);
1629 }
1630
1631 static void download_stub (XDR *xdr_in)
1632 {
1633   int r;
1634   struct guestfs_download_args args;
1635   char *remotefilename;
1636
1637   memset (&args, 0, sizeof args);
1638
1639   if (!xdr_guestfs_download_args (xdr_in, &args)) {
1640     reply_with_error ("%s: daemon failed to decode procedure arguments", "download");
1641     return;
1642   }
1643   remotefilename = args.remotefilename;
1644
1645   r = do_download (remotefilename);
1646   if (r == -1)
1647     /* do_download has already called reply_with_error */
1648     goto done;
1649
1650   /* do_download has already sent a reply */
1651 done:
1652   xdr_free ((xdrproc_t) xdr_guestfs_download_args, (char *) &args);
1653 }
1654
1655 static void checksum_stub (XDR *xdr_in)
1656 {
1657   char *r;
1658   struct guestfs_checksum_args args;
1659   char *csumtype;
1660   char *path;
1661
1662   memset (&args, 0, sizeof args);
1663
1664   if (!xdr_guestfs_checksum_args (xdr_in, &args)) {
1665     reply_with_error ("%s: daemon failed to decode procedure arguments", "checksum");
1666     return;
1667   }
1668   csumtype = args.csumtype;
1669   path = args.path;
1670
1671   r = do_checksum (csumtype, path);
1672   if (r == NULL)
1673     /* do_checksum has already called reply_with_error */
1674     goto done;
1675
1676   struct guestfs_checksum_ret ret;
1677   ret.checksum = r;
1678   reply ((xdrproc_t) &xdr_guestfs_checksum_ret, (char *) &ret);
1679   free (r);
1680 done:
1681   xdr_free ((xdrproc_t) xdr_guestfs_checksum_args, (char *) &args);
1682 }
1683
1684 static void tar_in_stub (XDR *xdr_in)
1685 {
1686   int r;
1687   struct guestfs_tar_in_args args;
1688   char *directory;
1689
1690   memset (&args, 0, sizeof args);
1691
1692   if (!xdr_guestfs_tar_in_args (xdr_in, &args)) {
1693     reply_with_error ("%s: daemon failed to decode procedure arguments", "tar_in");
1694     return;
1695   }
1696   directory = args.directory;
1697
1698   r = do_tar_in (directory);
1699   if (r == -1)
1700     /* do_tar_in has already called reply_with_error */
1701     goto done;
1702
1703   reply (NULL, NULL);
1704 done:
1705   xdr_free ((xdrproc_t) xdr_guestfs_tar_in_args, (char *) &args);
1706 }
1707
1708 static void tar_out_stub (XDR *xdr_in)
1709 {
1710   int r;
1711   struct guestfs_tar_out_args args;
1712   char *directory;
1713
1714   memset (&args, 0, sizeof args);
1715
1716   if (!xdr_guestfs_tar_out_args (xdr_in, &args)) {
1717     reply_with_error ("%s: daemon failed to decode procedure arguments", "tar_out");
1718     return;
1719   }
1720   directory = args.directory;
1721
1722   r = do_tar_out (directory);
1723   if (r == -1)
1724     /* do_tar_out has already called reply_with_error */
1725     goto done;
1726
1727   /* do_tar_out has already sent a reply */
1728 done:
1729   xdr_free ((xdrproc_t) xdr_guestfs_tar_out_args, (char *) &args);
1730 }
1731
1732 static void tgz_in_stub (XDR *xdr_in)
1733 {
1734   int r;
1735   struct guestfs_tgz_in_args args;
1736   char *directory;
1737
1738   memset (&args, 0, sizeof args);
1739
1740   if (!xdr_guestfs_tgz_in_args (xdr_in, &args)) {
1741     reply_with_error ("%s: daemon failed to decode procedure arguments", "tgz_in");
1742     return;
1743   }
1744   directory = args.directory;
1745
1746   r = do_tgz_in (directory);
1747   if (r == -1)
1748     /* do_tgz_in has already called reply_with_error */
1749     goto done;
1750
1751   reply (NULL, NULL);
1752 done:
1753   xdr_free ((xdrproc_t) xdr_guestfs_tgz_in_args, (char *) &args);
1754 }
1755
1756 static void tgz_out_stub (XDR *xdr_in)
1757 {
1758   int r;
1759   struct guestfs_tgz_out_args args;
1760   char *directory;
1761
1762   memset (&args, 0, sizeof args);
1763
1764   if (!xdr_guestfs_tgz_out_args (xdr_in, &args)) {
1765     reply_with_error ("%s: daemon failed to decode procedure arguments", "tgz_out");
1766     return;
1767   }
1768   directory = args.directory;
1769
1770   r = do_tgz_out (directory);
1771   if (r == -1)
1772     /* do_tgz_out has already called reply_with_error */
1773     goto done;
1774
1775   /* do_tgz_out has already sent a reply */
1776 done:
1777   xdr_free ((xdrproc_t) xdr_guestfs_tgz_out_args, (char *) &args);
1778 }
1779
1780 static void mount_ro_stub (XDR *xdr_in)
1781 {
1782   int r;
1783   struct guestfs_mount_ro_args args;
1784   char *device;
1785   char *mountpoint;
1786
1787   memset (&args, 0, sizeof args);
1788
1789   if (!xdr_guestfs_mount_ro_args (xdr_in, &args)) {
1790     reply_with_error ("%s: daemon failed to decode procedure arguments", "mount_ro");
1791     return;
1792   }
1793   device = args.device;
1794   mountpoint = args.mountpoint;
1795
1796   r = do_mount_ro (device, mountpoint);
1797   if (r == -1)
1798     /* do_mount_ro has already called reply_with_error */
1799     goto done;
1800
1801   reply (NULL, NULL);
1802 done:
1803   xdr_free ((xdrproc_t) xdr_guestfs_mount_ro_args, (char *) &args);
1804 }
1805
1806 static void mount_options_stub (XDR *xdr_in)
1807 {
1808   int r;
1809   struct guestfs_mount_options_args args;
1810   char *options;
1811   char *device;
1812   char *mountpoint;
1813
1814   memset (&args, 0, sizeof args);
1815
1816   if (!xdr_guestfs_mount_options_args (xdr_in, &args)) {
1817     reply_with_error ("%s: daemon failed to decode procedure arguments", "mount_options");
1818     return;
1819   }
1820   options = args.options;
1821   device = args.device;
1822   mountpoint = args.mountpoint;
1823
1824   r = do_mount_options (options, device, mountpoint);
1825   if (r == -1)
1826     /* do_mount_options has already called reply_with_error */
1827     goto done;
1828
1829   reply (NULL, NULL);
1830 done:
1831   xdr_free ((xdrproc_t) xdr_guestfs_mount_options_args, (char *) &args);
1832 }
1833
1834 static void mount_vfs_stub (XDR *xdr_in)
1835 {
1836   int r;
1837   struct guestfs_mount_vfs_args args;
1838   char *options;
1839   char *vfstype;
1840   char *device;
1841   char *mountpoint;
1842
1843   memset (&args, 0, sizeof args);
1844
1845   if (!xdr_guestfs_mount_vfs_args (xdr_in, &args)) {
1846     reply_with_error ("%s: daemon failed to decode procedure arguments", "mount_vfs");
1847     return;
1848   }
1849   options = args.options;
1850   vfstype = args.vfstype;
1851   device = args.device;
1852   mountpoint = args.mountpoint;
1853
1854   r = do_mount_vfs (options, vfstype, device, mountpoint);
1855   if (r == -1)
1856     /* do_mount_vfs has already called reply_with_error */
1857     goto done;
1858
1859   reply (NULL, NULL);
1860 done:
1861   xdr_free ((xdrproc_t) xdr_guestfs_mount_vfs_args, (char *) &args);
1862 }
1863
1864 static void debug_stub (XDR *xdr_in)
1865 {
1866   char *r;
1867   struct guestfs_debug_args args;
1868   char *subcmd;
1869   char **extraargs;
1870
1871   memset (&args, 0, sizeof args);
1872
1873   if (!xdr_guestfs_debug_args (xdr_in, &args)) {
1874     reply_with_error ("%s: daemon failed to decode procedure arguments", "debug");
1875     return;
1876   }
1877   subcmd = args.subcmd;
1878   extraargs = realloc (args.extraargs.extraargs_val,
1879                 sizeof (char *) * (args.extraargs.extraargs_len+1));
1880   if (extraargs == NULL) {
1881     reply_with_perror ("realloc");
1882     goto done;
1883   }
1884   extraargs[args.extraargs.extraargs_len] = NULL;
1885   args.extraargs.extraargs_val = extraargs;
1886
1887   r = do_debug (subcmd, extraargs);
1888   if (r == NULL)
1889     /* do_debug has already called reply_with_error */
1890     goto done;
1891
1892   struct guestfs_debug_ret ret;
1893   ret.result = r;
1894   reply ((xdrproc_t) &xdr_guestfs_debug_ret, (char *) &ret);
1895   free (r);
1896 done:
1897   xdr_free ((xdrproc_t) xdr_guestfs_debug_args, (char *) &args);
1898 }
1899
1900 static void lvremove_stub (XDR *xdr_in)
1901 {
1902   int r;
1903   struct guestfs_lvremove_args args;
1904   char *device;
1905
1906   memset (&args, 0, sizeof args);
1907
1908   if (!xdr_guestfs_lvremove_args (xdr_in, &args)) {
1909     reply_with_error ("%s: daemon failed to decode procedure arguments", "lvremove");
1910     return;
1911   }
1912   device = args.device;
1913
1914   r = do_lvremove (device);
1915   if (r == -1)
1916     /* do_lvremove has already called reply_with_error */
1917     goto done;
1918
1919   reply (NULL, NULL);
1920 done:
1921   xdr_free ((xdrproc_t) xdr_guestfs_lvremove_args, (char *) &args);
1922 }
1923
1924 static void vgremove_stub (XDR *xdr_in)
1925 {
1926   int r;
1927   struct guestfs_vgremove_args args;
1928   char *vgname;
1929
1930   memset (&args, 0, sizeof args);
1931
1932   if (!xdr_guestfs_vgremove_args (xdr_in, &args)) {
1933     reply_with_error ("%s: daemon failed to decode procedure arguments", "vgremove");
1934     return;
1935   }
1936   vgname = args.vgname;
1937
1938   r = do_vgremove (vgname);
1939   if (r == -1)
1940     /* do_vgremove has already called reply_with_error */
1941     goto done;
1942
1943   reply (NULL, NULL);
1944 done:
1945   xdr_free ((xdrproc_t) xdr_guestfs_vgremove_args, (char *) &args);
1946 }
1947
1948 static void pvremove_stub (XDR *xdr_in)
1949 {
1950   int r;
1951   struct guestfs_pvremove_args args;
1952   char *device;
1953
1954   memset (&args, 0, sizeof args);
1955
1956   if (!xdr_guestfs_pvremove_args (xdr_in, &args)) {
1957     reply_with_error ("%s: daemon failed to decode procedure arguments", "pvremove");
1958     return;
1959   }
1960   device = args.device;
1961
1962   r = do_pvremove (device);
1963   if (r == -1)
1964     /* do_pvremove has already called reply_with_error */
1965     goto done;
1966
1967   reply (NULL, NULL);
1968 done:
1969   xdr_free ((xdrproc_t) xdr_guestfs_pvremove_args, (char *) &args);
1970 }
1971
1972 static void set_e2label_stub (XDR *xdr_in)
1973 {
1974   int r;
1975   struct guestfs_set_e2label_args args;
1976   char *device;
1977   char *label;
1978
1979   memset (&args, 0, sizeof args);
1980
1981   if (!xdr_guestfs_set_e2label_args (xdr_in, &args)) {
1982     reply_with_error ("%s: daemon failed to decode procedure arguments", "set_e2label");
1983     return;
1984   }
1985   device = args.device;
1986   label = args.label;
1987
1988   r = do_set_e2label (device, label);
1989   if (r == -1)
1990     /* do_set_e2label has already called reply_with_error */
1991     goto done;
1992
1993   reply (NULL, NULL);
1994 done:
1995   xdr_free ((xdrproc_t) xdr_guestfs_set_e2label_args, (char *) &args);
1996 }
1997
1998 static void get_e2label_stub (XDR *xdr_in)
1999 {
2000   char *r;
2001   struct guestfs_get_e2label_args args;
2002   char *device;
2003
2004   memset (&args, 0, sizeof args);
2005
2006   if (!xdr_guestfs_get_e2label_args (xdr_in, &args)) {
2007     reply_with_error ("%s: daemon failed to decode procedure arguments", "get_e2label");
2008     return;
2009   }
2010   device = args.device;
2011
2012   r = do_get_e2label (device);
2013   if (r == NULL)
2014     /* do_get_e2label has already called reply_with_error */
2015     goto done;
2016
2017   struct guestfs_get_e2label_ret ret;
2018   ret.label = r;
2019   reply ((xdrproc_t) &xdr_guestfs_get_e2label_ret, (char *) &ret);
2020   free (r);
2021 done:
2022   xdr_free ((xdrproc_t) xdr_guestfs_get_e2label_args, (char *) &args);
2023 }
2024
2025 static void set_e2uuid_stub (XDR *xdr_in)
2026 {
2027   int r;
2028   struct guestfs_set_e2uuid_args args;
2029   char *device;
2030   char *uuid;
2031
2032   memset (&args, 0, sizeof args);
2033
2034   if (!xdr_guestfs_set_e2uuid_args (xdr_in, &args)) {
2035     reply_with_error ("%s: daemon failed to decode procedure arguments", "set_e2uuid");
2036     return;
2037   }
2038   device = args.device;
2039   uuid = args.uuid;
2040
2041   r = do_set_e2uuid (device, uuid);
2042   if (r == -1)
2043     /* do_set_e2uuid has already called reply_with_error */
2044     goto done;
2045
2046   reply (NULL, NULL);
2047 done:
2048   xdr_free ((xdrproc_t) xdr_guestfs_set_e2uuid_args, (char *) &args);
2049 }
2050
2051 static void get_e2uuid_stub (XDR *xdr_in)
2052 {
2053   char *r;
2054   struct guestfs_get_e2uuid_args args;
2055   char *device;
2056
2057   memset (&args, 0, sizeof args);
2058
2059   if (!xdr_guestfs_get_e2uuid_args (xdr_in, &args)) {
2060     reply_with_error ("%s: daemon failed to decode procedure arguments", "get_e2uuid");
2061     return;
2062   }
2063   device = args.device;
2064
2065   r = do_get_e2uuid (device);
2066   if (r == NULL)
2067     /* do_get_e2uuid has already called reply_with_error */
2068     goto done;
2069
2070   struct guestfs_get_e2uuid_ret ret;
2071   ret.uuid = r;
2072   reply ((xdrproc_t) &xdr_guestfs_get_e2uuid_ret, (char *) &ret);
2073   free (r);
2074 done:
2075   xdr_free ((xdrproc_t) xdr_guestfs_get_e2uuid_args, (char *) &args);
2076 }
2077
2078 static void fsck_stub (XDR *xdr_in)
2079 {
2080   int r;
2081   struct guestfs_fsck_args args;
2082   char *fstype;
2083   char *device;
2084
2085   memset (&args, 0, sizeof args);
2086
2087   if (!xdr_guestfs_fsck_args (xdr_in, &args)) {
2088     reply_with_error ("%s: daemon failed to decode procedure arguments", "fsck");
2089     return;
2090   }
2091   fstype = args.fstype;
2092   device = args.device;
2093
2094   r = do_fsck (fstype, device);
2095   if (r == -1)
2096     /* do_fsck has already called reply_with_error */
2097     goto done;
2098
2099   struct guestfs_fsck_ret ret;
2100   ret.status = r;
2101   reply ((xdrproc_t) &xdr_guestfs_fsck_ret, (char *) &ret);
2102 done:
2103   xdr_free ((xdrproc_t) xdr_guestfs_fsck_args, (char *) &args);
2104 }
2105
2106 static void zero_stub (XDR *xdr_in)
2107 {
2108   int r;
2109   struct guestfs_zero_args args;
2110   char *device;
2111
2112   memset (&args, 0, sizeof args);
2113
2114   if (!xdr_guestfs_zero_args (xdr_in, &args)) {
2115     reply_with_error ("%s: daemon failed to decode procedure arguments", "zero");
2116     return;
2117   }
2118   device = args.device;
2119
2120   r = do_zero (device);
2121   if (r == -1)
2122     /* do_zero has already called reply_with_error */
2123     goto done;
2124
2125   reply (NULL, NULL);
2126 done:
2127   xdr_free ((xdrproc_t) xdr_guestfs_zero_args, (char *) &args);
2128 }
2129
2130 static void grub_install_stub (XDR *xdr_in)
2131 {
2132   int r;
2133   struct guestfs_grub_install_args args;
2134   char *root;
2135   char *device;
2136
2137   memset (&args, 0, sizeof args);
2138
2139   if (!xdr_guestfs_grub_install_args (xdr_in, &args)) {
2140     reply_with_error ("%s: daemon failed to decode procedure arguments", "grub_install");
2141     return;
2142   }
2143   root = args.root;
2144   device = args.device;
2145
2146   r = do_grub_install (root, device);
2147   if (r == -1)
2148     /* do_grub_install has already called reply_with_error */
2149     goto done;
2150
2151   reply (NULL, NULL);
2152 done:
2153   xdr_free ((xdrproc_t) xdr_guestfs_grub_install_args, (char *) &args);
2154 }
2155
2156 static void cp_stub (XDR *xdr_in)
2157 {
2158   int r;
2159   struct guestfs_cp_args args;
2160   char *src;
2161   char *dest;
2162
2163   memset (&args, 0, sizeof args);
2164
2165   if (!xdr_guestfs_cp_args (xdr_in, &args)) {
2166     reply_with_error ("%s: daemon failed to decode procedure arguments", "cp");
2167     return;
2168   }
2169   src = args.src;
2170   dest = args.dest;
2171
2172   r = do_cp (src, dest);
2173   if (r == -1)
2174     /* do_cp has already called reply_with_error */
2175     goto done;
2176
2177   reply (NULL, NULL);
2178 done:
2179   xdr_free ((xdrproc_t) xdr_guestfs_cp_args, (char *) &args);
2180 }
2181
2182 static void cp_a_stub (XDR *xdr_in)
2183 {
2184   int r;
2185   struct guestfs_cp_a_args args;
2186   char *src;
2187   char *dest;
2188
2189   memset (&args, 0, sizeof args);
2190
2191   if (!xdr_guestfs_cp_a_args (xdr_in, &args)) {
2192     reply_with_error ("%s: daemon failed to decode procedure arguments", "cp_a");
2193     return;
2194   }
2195   src = args.src;
2196   dest = args.dest;
2197
2198   r = do_cp_a (src, dest);
2199   if (r == -1)
2200     /* do_cp_a has already called reply_with_error */
2201     goto done;
2202
2203   reply (NULL, NULL);
2204 done:
2205   xdr_free ((xdrproc_t) xdr_guestfs_cp_a_args, (char *) &args);
2206 }
2207
2208 static void mv_stub (XDR *xdr_in)
2209 {
2210   int r;
2211   struct guestfs_mv_args args;
2212   char *src;
2213   char *dest;
2214
2215   memset (&args, 0, sizeof args);
2216
2217   if (!xdr_guestfs_mv_args (xdr_in, &args)) {
2218     reply_with_error ("%s: daemon failed to decode procedure arguments", "mv");
2219     return;
2220   }
2221   src = args.src;
2222   dest = args.dest;
2223
2224   r = do_mv (src, dest);
2225   if (r == -1)
2226     /* do_mv has already called reply_with_error */
2227     goto done;
2228
2229   reply (NULL, NULL);
2230 done:
2231   xdr_free ((xdrproc_t) xdr_guestfs_mv_args, (char *) &args);
2232 }
2233
2234 static void drop_caches_stub (XDR *xdr_in)
2235 {
2236   int r;
2237   struct guestfs_drop_caches_args args;
2238   int whattodrop;
2239
2240   memset (&args, 0, sizeof args);
2241
2242   if (!xdr_guestfs_drop_caches_args (xdr_in, &args)) {
2243     reply_with_error ("%s: daemon failed to decode procedure arguments", "drop_caches");
2244     return;
2245   }
2246   whattodrop = args.whattodrop;
2247
2248   r = do_drop_caches (whattodrop);
2249   if (r == -1)
2250     /* do_drop_caches has already called reply_with_error */
2251     goto done;
2252
2253   reply (NULL, NULL);
2254 done:
2255   xdr_free ((xdrproc_t) xdr_guestfs_drop_caches_args, (char *) &args);
2256 }
2257
2258 static void dmesg_stub (XDR *xdr_in)
2259 {
2260   char *r;
2261
2262   r = do_dmesg ();
2263   if (r == NULL)
2264     /* do_dmesg has already called reply_with_error */
2265     goto done;
2266
2267   struct guestfs_dmesg_ret ret;
2268   ret.kmsgs = r;
2269   reply ((xdrproc_t) &xdr_guestfs_dmesg_ret, (char *) &ret);
2270   free (r);
2271 done: ;
2272 }
2273
2274 static void ping_daemon_stub (XDR *xdr_in)
2275 {
2276   int r;
2277
2278   r = do_ping_daemon ();
2279   if (r == -1)
2280     /* do_ping_daemon has already called reply_with_error */
2281     goto done;
2282
2283   reply (NULL, NULL);
2284 done: ;
2285 }
2286
2287 static void equal_stub (XDR *xdr_in)
2288 {
2289   int r;
2290   struct guestfs_equal_args args;
2291   char *file1;
2292   char *file2;
2293
2294   memset (&args, 0, sizeof args);
2295
2296   if (!xdr_guestfs_equal_args (xdr_in, &args)) {
2297     reply_with_error ("%s: daemon failed to decode procedure arguments", "equal");
2298     return;
2299   }
2300   file1 = args.file1;
2301   file2 = args.file2;
2302
2303   r = do_equal (file1, file2);
2304   if (r == -1)
2305     /* do_equal has already called reply_with_error */
2306     goto done;
2307
2308   struct guestfs_equal_ret ret;
2309   ret.equality = r;
2310   reply ((xdrproc_t) &xdr_guestfs_equal_ret, (char *) &ret);
2311 done:
2312   xdr_free ((xdrproc_t) xdr_guestfs_equal_args, (char *) &args);
2313 }
2314
2315 static void strings_stub (XDR *xdr_in)
2316 {
2317   char **r;
2318   struct guestfs_strings_args args;
2319   char *path;
2320
2321   memset (&args, 0, sizeof args);
2322
2323   if (!xdr_guestfs_strings_args (xdr_in, &args)) {
2324     reply_with_error ("%s: daemon failed to decode procedure arguments", "strings");
2325     return;
2326   }
2327   path = args.path;
2328
2329   r = do_strings (path);
2330   if (r == NULL)
2331     /* do_strings has already called reply_with_error */
2332     goto done;
2333
2334   struct guestfs_strings_ret ret;
2335   ret.stringsout.stringsout_len = count_strings (r);
2336   ret.stringsout.stringsout_val = r;
2337   reply ((xdrproc_t) &xdr_guestfs_strings_ret, (char *) &ret);
2338   free_strings (r);
2339 done:
2340   xdr_free ((xdrproc_t) xdr_guestfs_strings_args, (char *) &args);
2341 }
2342
2343 static void strings_e_stub (XDR *xdr_in)
2344 {
2345   char **r;
2346   struct guestfs_strings_e_args args;
2347   char *encoding;
2348   char *path;
2349
2350   memset (&args, 0, sizeof args);
2351
2352   if (!xdr_guestfs_strings_e_args (xdr_in, &args)) {
2353     reply_with_error ("%s: daemon failed to decode procedure arguments", "strings_e");
2354     return;
2355   }
2356   encoding = args.encoding;
2357   path = args.path;
2358
2359   r = do_strings_e (encoding, path);
2360   if (r == NULL)
2361     /* do_strings_e has already called reply_with_error */
2362     goto done;
2363
2364   struct guestfs_strings_e_ret ret;
2365   ret.stringsout.stringsout_len = count_strings (r);
2366   ret.stringsout.stringsout_val = r;
2367   reply ((xdrproc_t) &xdr_guestfs_strings_e_ret, (char *) &ret);
2368   free_strings (r);
2369 done:
2370   xdr_free ((xdrproc_t) xdr_guestfs_strings_e_args, (char *) &args);
2371 }
2372
2373 static void hexdump_stub (XDR *xdr_in)
2374 {
2375   char *r;
2376   struct guestfs_hexdump_args args;
2377   char *path;
2378
2379   memset (&args, 0, sizeof args);
2380
2381   if (!xdr_guestfs_hexdump_args (xdr_in, &args)) {
2382     reply_with_error ("%s: daemon failed to decode procedure arguments", "hexdump");
2383     return;
2384   }
2385   path = args.path;
2386
2387   r = do_hexdump (path);
2388   if (r == NULL)
2389     /* do_hexdump has already called reply_with_error */
2390     goto done;
2391
2392   struct guestfs_hexdump_ret ret;
2393   ret.dump = r;
2394   reply ((xdrproc_t) &xdr_guestfs_hexdump_ret, (char *) &ret);
2395   free (r);
2396 done:
2397   xdr_free ((xdrproc_t) xdr_guestfs_hexdump_args, (char *) &args);
2398 }
2399
2400 static void zerofree_stub (XDR *xdr_in)
2401 {
2402   int r;
2403   struct guestfs_zerofree_args args;
2404   char *device;
2405
2406   memset (&args, 0, sizeof args);
2407
2408   if (!xdr_guestfs_zerofree_args (xdr_in, &args)) {
2409     reply_with_error ("%s: daemon failed to decode procedure arguments", "zerofree");
2410     return;
2411   }
2412   device = args.device;
2413
2414   r = do_zerofree (device);
2415   if (r == -1)
2416     /* do_zerofree has already called reply_with_error */
2417     goto done;
2418
2419   reply (NULL, NULL);
2420 done:
2421   xdr_free ((xdrproc_t) xdr_guestfs_zerofree_args, (char *) &args);
2422 }
2423
2424 static void pvresize_stub (XDR *xdr_in)
2425 {
2426   int r;
2427   struct guestfs_pvresize_args args;
2428   char *device;
2429
2430   memset (&args, 0, sizeof args);
2431
2432   if (!xdr_guestfs_pvresize_args (xdr_in, &args)) {
2433     reply_with_error ("%s: daemon failed to decode procedure arguments", "pvresize");
2434     return;
2435   }
2436   device = args.device;
2437
2438   r = do_pvresize (device);
2439   if (r == -1)
2440     /* do_pvresize has already called reply_with_error */
2441     goto done;
2442
2443   reply (NULL, NULL);
2444 done:
2445   xdr_free ((xdrproc_t) xdr_guestfs_pvresize_args, (char *) &args);
2446 }
2447
2448 static void sfdisk_N_stub (XDR *xdr_in)
2449 {
2450   int r;
2451   struct guestfs_sfdisk_N_args args;
2452   char *device;
2453   int partnum;
2454   int cyls;
2455   int heads;
2456   int sectors;
2457   char *line;
2458
2459   memset (&args, 0, sizeof args);
2460
2461   if (!xdr_guestfs_sfdisk_N_args (xdr_in, &args)) {
2462     reply_with_error ("%s: daemon failed to decode procedure arguments", "sfdisk_N");
2463     return;
2464   }
2465   device = args.device;
2466   partnum = args.partnum;
2467   cyls = args.cyls;
2468   heads = args.heads;
2469   sectors = args.sectors;
2470   line = args.line;
2471
2472   r = do_sfdisk_N (device, partnum, cyls, heads, sectors, line);
2473   if (r == -1)
2474     /* do_sfdisk_N has already called reply_with_error */
2475     goto done;
2476
2477   reply (NULL, NULL);
2478 done:
2479   xdr_free ((xdrproc_t) xdr_guestfs_sfdisk_N_args, (char *) &args);
2480 }
2481
2482 static void sfdisk_l_stub (XDR *xdr_in)
2483 {
2484   char *r;
2485   struct guestfs_sfdisk_l_args args;
2486   char *device;
2487
2488   memset (&args, 0, sizeof args);
2489
2490   if (!xdr_guestfs_sfdisk_l_args (xdr_in, &args)) {
2491     reply_with_error ("%s: daemon failed to decode procedure arguments", "sfdisk_l");
2492     return;
2493   }
2494   device = args.device;
2495
2496   r = do_sfdisk_l (device);
2497   if (r == NULL)
2498     /* do_sfdisk_l has already called reply_with_error */
2499     goto done;
2500
2501   struct guestfs_sfdisk_l_ret ret;
2502   ret.partitions = r;
2503   reply ((xdrproc_t) &xdr_guestfs_sfdisk_l_ret, (char *) &ret);
2504   free (r);
2505 done:
2506   xdr_free ((xdrproc_t) xdr_guestfs_sfdisk_l_args, (char *) &args);
2507 }
2508
2509 static void sfdisk_kernel_geometry_stub (XDR *xdr_in)
2510 {
2511   char *r;
2512   struct guestfs_sfdisk_kernel_geometry_args args;
2513   char *device;
2514
2515   memset (&args, 0, sizeof args);
2516
2517   if (!xdr_guestfs_sfdisk_kernel_geometry_args (xdr_in, &args)) {
2518     reply_with_error ("%s: daemon failed to decode procedure arguments", "sfdisk_kernel_geometry");
2519     return;
2520   }
2521   device = args.device;
2522
2523   r = do_sfdisk_kernel_geometry (device);
2524   if (r == NULL)
2525     /* do_sfdisk_kernel_geometry has already called reply_with_error */
2526     goto done;
2527
2528   struct guestfs_sfdisk_kernel_geometry_ret ret;
2529   ret.partitions = r;
2530   reply ((xdrproc_t) &xdr_guestfs_sfdisk_kernel_geometry_ret, (char *) &ret);
2531   free (r);
2532 done:
2533   xdr_free ((xdrproc_t) xdr_guestfs_sfdisk_kernel_geometry_args, (char *) &args);
2534 }
2535
2536 static void sfdisk_disk_geometry_stub (XDR *xdr_in)
2537 {
2538   char *r;
2539   struct guestfs_sfdisk_disk_geometry_args args;
2540   char *device;
2541
2542   memset (&args, 0, sizeof args);
2543
2544   if (!xdr_guestfs_sfdisk_disk_geometry_args (xdr_in, &args)) {
2545     reply_with_error ("%s: daemon failed to decode procedure arguments", "sfdisk_disk_geometry");
2546     return;
2547   }
2548   device = args.device;
2549
2550   r = do_sfdisk_disk_geometry (device);
2551   if (r == NULL)
2552     /* do_sfdisk_disk_geometry has already called reply_with_error */
2553     goto done;
2554
2555   struct guestfs_sfdisk_disk_geometry_ret ret;
2556   ret.partitions = r;
2557   reply ((xdrproc_t) &xdr_guestfs_sfdisk_disk_geometry_ret, (char *) &ret);
2558   free (r);
2559 done:
2560   xdr_free ((xdrproc_t) xdr_guestfs_sfdisk_disk_geometry_args, (char *) &args);
2561 }
2562
2563 static void vg_activate_all_stub (XDR *xdr_in)
2564 {
2565   int r;
2566   struct guestfs_vg_activate_all_args args;
2567   int activate;
2568
2569   memset (&args, 0, sizeof args);
2570
2571   if (!xdr_guestfs_vg_activate_all_args (xdr_in, &args)) {
2572     reply_with_error ("%s: daemon failed to decode procedure arguments", "vg_activate_all");
2573     return;
2574   }
2575   activate = args.activate;
2576
2577   r = do_vg_activate_all (activate);
2578   if (r == -1)
2579     /* do_vg_activate_all has already called reply_with_error */
2580     goto done;
2581
2582   reply (NULL, NULL);
2583 done:
2584   xdr_free ((xdrproc_t) xdr_guestfs_vg_activate_all_args, (char *) &args);
2585 }
2586
2587 static void vg_activate_stub (XDR *xdr_in)
2588 {
2589   int r;
2590   struct guestfs_vg_activate_args args;
2591   int activate;
2592   char **volgroups;
2593
2594   memset (&args, 0, sizeof args);
2595
2596   if (!xdr_guestfs_vg_activate_args (xdr_in, &args)) {
2597     reply_with_error ("%s: daemon failed to decode procedure arguments", "vg_activate");
2598     return;
2599   }
2600   activate = args.activate;
2601   volgroups = realloc (args.volgroups.volgroups_val,
2602                 sizeof (char *) * (args.volgroups.volgroups_len+1));
2603   if (volgroups == NULL) {
2604     reply_with_perror ("realloc");
2605     goto done;
2606   }
2607   volgroups[args.volgroups.volgroups_len] = NULL;
2608   args.volgroups.volgroups_val = volgroups;
2609
2610   r = do_vg_activate (activate, volgroups);
2611   if (r == -1)
2612     /* do_vg_activate has already called reply_with_error */
2613     goto done;
2614
2615   reply (NULL, NULL);
2616 done:
2617   xdr_free ((xdrproc_t) xdr_guestfs_vg_activate_args, (char *) &args);
2618 }
2619
2620 static void lvresize_stub (XDR *xdr_in)
2621 {
2622   int r;
2623   struct guestfs_lvresize_args args;
2624   char *device;
2625   int mbytes;
2626
2627   memset (&args, 0, sizeof args);
2628
2629   if (!xdr_guestfs_lvresize_args (xdr_in, &args)) {
2630     reply_with_error ("%s: daemon failed to decode procedure arguments", "lvresize");
2631     return;
2632   }
2633   device = args.device;
2634   mbytes = args.mbytes;
2635
2636   r = do_lvresize (device, mbytes);
2637   if (r == -1)
2638     /* do_lvresize has already called reply_with_error */
2639     goto done;
2640
2641   reply (NULL, NULL);
2642 done:
2643   xdr_free ((xdrproc_t) xdr_guestfs_lvresize_args, (char *) &args);
2644 }
2645
2646 static void resize2fs_stub (XDR *xdr_in)
2647 {
2648   int r;
2649   struct guestfs_resize2fs_args args;
2650   char *device;
2651
2652   memset (&args, 0, sizeof args);
2653
2654   if (!xdr_guestfs_resize2fs_args (xdr_in, &args)) {
2655     reply_with_error ("%s: daemon failed to decode procedure arguments", "resize2fs");
2656     return;
2657   }
2658   device = args.device;
2659
2660   r = do_resize2fs (device);
2661   if (r == -1)
2662     /* do_resize2fs has already called reply_with_error */
2663     goto done;
2664
2665   reply (NULL, NULL);
2666 done:
2667   xdr_free ((xdrproc_t) xdr_guestfs_resize2fs_args, (char *) &args);
2668 }
2669
2670 static void find_stub (XDR *xdr_in)
2671 {
2672   char **r;
2673   struct guestfs_find_args args;
2674   char *directory;
2675
2676   memset (&args, 0, sizeof args);
2677
2678   if (!xdr_guestfs_find_args (xdr_in, &args)) {
2679     reply_with_error ("%s: daemon failed to decode procedure arguments", "find");
2680     return;
2681   }
2682   directory = args.directory;
2683
2684   r = do_find (directory);
2685   if (r == NULL)
2686     /* do_find has already called reply_with_error */
2687     goto done;
2688
2689   struct guestfs_find_ret ret;
2690   ret.names.names_len = count_strings (r);
2691   ret.names.names_val = r;
2692   reply ((xdrproc_t) &xdr_guestfs_find_ret, (char *) &ret);
2693   free_strings (r);
2694 done:
2695   xdr_free ((xdrproc_t) xdr_guestfs_find_args, (char *) &args);
2696 }
2697
2698 static void e2fsck_f_stub (XDR *xdr_in)
2699 {
2700   int r;
2701   struct guestfs_e2fsck_f_args args;
2702   char *device;
2703
2704   memset (&args, 0, sizeof args);
2705
2706   if (!xdr_guestfs_e2fsck_f_args (xdr_in, &args)) {
2707     reply_with_error ("%s: daemon failed to decode procedure arguments", "e2fsck_f");
2708     return;
2709   }
2710   device = args.device;
2711
2712   r = do_e2fsck_f (device);
2713   if (r == -1)
2714     /* do_e2fsck_f has already called reply_with_error */
2715     goto done;
2716
2717   reply (NULL, NULL);
2718 done:
2719   xdr_free ((xdrproc_t) xdr_guestfs_e2fsck_f_args, (char *) &args);
2720 }
2721
2722 static void sleep_stub (XDR *xdr_in)
2723 {
2724   int r;
2725   struct guestfs_sleep_args args;
2726   int secs;
2727
2728   memset (&args, 0, sizeof args);
2729
2730   if (!xdr_guestfs_sleep_args (xdr_in, &args)) {
2731     reply_with_error ("%s: daemon failed to decode procedure arguments", "sleep");
2732     return;
2733   }
2734   secs = args.secs;
2735
2736   r = do_sleep (secs);
2737   if (r == -1)
2738     /* do_sleep has already called reply_with_error */
2739     goto done;
2740
2741   reply (NULL, NULL);
2742 done:
2743   xdr_free ((xdrproc_t) xdr_guestfs_sleep_args, (char *) &args);
2744 }
2745
2746 static void ntfs_3g_probe_stub (XDR *xdr_in)
2747 {
2748   int r;
2749   struct guestfs_ntfs_3g_probe_args args;
2750   int rw;
2751   char *device;
2752
2753   memset (&args, 0, sizeof args);
2754
2755   if (!xdr_guestfs_ntfs_3g_probe_args (xdr_in, &args)) {
2756     reply_with_error ("%s: daemon failed to decode procedure arguments", "ntfs_3g_probe");
2757     return;
2758   }
2759   rw = args.rw;
2760   device = args.device;
2761
2762   r = do_ntfs_3g_probe (rw, device);
2763   if (r == -1)
2764     /* do_ntfs_3g_probe has already called reply_with_error */
2765     goto done;
2766
2767   struct guestfs_ntfs_3g_probe_ret ret;
2768   ret.status = r;
2769   reply ((xdrproc_t) &xdr_guestfs_ntfs_3g_probe_ret, (char *) &ret);
2770 done:
2771   xdr_free ((xdrproc_t) xdr_guestfs_ntfs_3g_probe_args, (char *) &args);
2772 }
2773
2774 static void sh_stub (XDR *xdr_in)
2775 {
2776   char *r;
2777   struct guestfs_sh_args args;
2778   char *command;
2779
2780   memset (&args, 0, sizeof args);
2781
2782   if (!xdr_guestfs_sh_args (xdr_in, &args)) {
2783     reply_with_error ("%s: daemon failed to decode procedure arguments", "sh");
2784     return;
2785   }
2786   command = args.command;
2787
2788   r = do_sh (command);
2789   if (r == NULL)
2790     /* do_sh has already called reply_with_error */
2791     goto done;
2792
2793   struct guestfs_sh_ret ret;
2794   ret.output = r;
2795   reply ((xdrproc_t) &xdr_guestfs_sh_ret, (char *) &ret);
2796   free (r);
2797 done:
2798   xdr_free ((xdrproc_t) xdr_guestfs_sh_args, (char *) &args);
2799 }
2800
2801 static void sh_lines_stub (XDR *xdr_in)
2802 {
2803   char **r;
2804   struct guestfs_sh_lines_args args;
2805   char *command;
2806
2807   memset (&args, 0, sizeof args);
2808
2809   if (!xdr_guestfs_sh_lines_args (xdr_in, &args)) {
2810     reply_with_error ("%s: daemon failed to decode procedure arguments", "sh_lines");
2811     return;
2812   }
2813   command = args.command;
2814
2815   r = do_sh_lines (command);
2816   if (r == NULL)
2817     /* do_sh_lines has already called reply_with_error */
2818     goto done;
2819
2820   struct guestfs_sh_lines_ret ret;
2821   ret.lines.lines_len = count_strings (r);
2822   ret.lines.lines_val = r;
2823   reply ((xdrproc_t) &xdr_guestfs_sh_lines_ret, (char *) &ret);
2824   free_strings (r);
2825 done:
2826   xdr_free ((xdrproc_t) xdr_guestfs_sh_lines_args, (char *) &args);
2827 }
2828
2829 static void glob_expand_stub (XDR *xdr_in)
2830 {
2831   char **r;
2832   struct guestfs_glob_expand_args args;
2833   char *pattern;
2834
2835   memset (&args, 0, sizeof args);
2836
2837   if (!xdr_guestfs_glob_expand_args (xdr_in, &args)) {
2838     reply_with_error ("%s: daemon failed to decode procedure arguments", "glob_expand");
2839     return;
2840   }
2841   pattern = args.pattern;
2842
2843   r = do_glob_expand (pattern);
2844   if (r == NULL)
2845     /* do_glob_expand has already called reply_with_error */
2846     goto done;
2847
2848   struct guestfs_glob_expand_ret ret;
2849   ret.paths.paths_len = count_strings (r);
2850   ret.paths.paths_val = r;
2851   reply ((xdrproc_t) &xdr_guestfs_glob_expand_ret, (char *) &ret);
2852   free_strings (r);
2853 done:
2854   xdr_free ((xdrproc_t) xdr_guestfs_glob_expand_args, (char *) &args);
2855 }
2856
2857 static void scrub_device_stub (XDR *xdr_in)
2858 {
2859   int r;
2860   struct guestfs_scrub_device_args args;
2861   char *device;
2862
2863   memset (&args, 0, sizeof args);
2864
2865   if (!xdr_guestfs_scrub_device_args (xdr_in, &args)) {
2866     reply_with_error ("%s: daemon failed to decode procedure arguments", "scrub_device");
2867     return;
2868   }
2869   device = args.device;
2870
2871   r = do_scrub_device (device);
2872   if (r == -1)
2873     /* do_scrub_device has already called reply_with_error */
2874     goto done;
2875
2876   reply (NULL, NULL);
2877 done:
2878   xdr_free ((xdrproc_t) xdr_guestfs_scrub_device_args, (char *) &args);
2879 }
2880
2881 static void scrub_file_stub (XDR *xdr_in)
2882 {
2883   int r;
2884   struct guestfs_scrub_file_args args;
2885   char *file;
2886
2887   memset (&args, 0, sizeof args);
2888
2889   if (!xdr_guestfs_scrub_file_args (xdr_in, &args)) {
2890     reply_with_error ("%s: daemon failed to decode procedure arguments", "scrub_file");
2891     return;
2892   }
2893   file = args.file;
2894
2895   r = do_scrub_file (file);
2896   if (r == -1)
2897     /* do_scrub_file has already called reply_with_error */
2898     goto done;
2899
2900   reply (NULL, NULL);
2901 done:
2902   xdr_free ((xdrproc_t) xdr_guestfs_scrub_file_args, (char *) &args);
2903 }
2904
2905 static void scrub_freespace_stub (XDR *xdr_in)
2906 {
2907   int r;
2908   struct guestfs_scrub_freespace_args args;
2909   char *dir;
2910
2911   memset (&args, 0, sizeof args);
2912
2913   if (!xdr_guestfs_scrub_freespace_args (xdr_in, &args)) {
2914     reply_with_error ("%s: daemon failed to decode procedure arguments", "scrub_freespace");
2915     return;
2916   }
2917   dir = args.dir;
2918
2919   r = do_scrub_freespace (dir);
2920   if (r == -1)
2921     /* do_scrub_freespace has already called reply_with_error */
2922     goto done;
2923
2924   reply (NULL, NULL);
2925 done:
2926   xdr_free ((xdrproc_t) xdr_guestfs_scrub_freespace_args, (char *) &args);
2927 }
2928
2929 static void mkdtemp_stub (XDR *xdr_in)
2930 {
2931   char *r;
2932   struct guestfs_mkdtemp_args args;
2933   char *template;
2934
2935   memset (&args, 0, sizeof args);
2936
2937   if (!xdr_guestfs_mkdtemp_args (xdr_in, &args)) {
2938     reply_with_error ("%s: daemon failed to decode procedure arguments", "mkdtemp");
2939     return;
2940   }
2941   template = args.template;
2942
2943   r = do_mkdtemp (template);
2944   if (r == NULL)
2945     /* do_mkdtemp has already called reply_with_error */
2946     goto done;
2947
2948   struct guestfs_mkdtemp_ret ret;
2949   ret.dir = r;
2950   reply ((xdrproc_t) &xdr_guestfs_mkdtemp_ret, (char *) &ret);
2951   free (r);
2952 done:
2953   xdr_free ((xdrproc_t) xdr_guestfs_mkdtemp_args, (char *) &args);
2954 }
2955
2956 static void wc_l_stub (XDR *xdr_in)
2957 {
2958   int r;
2959   struct guestfs_wc_l_args args;
2960   char *path;
2961
2962   memset (&args, 0, sizeof args);
2963
2964   if (!xdr_guestfs_wc_l_args (xdr_in, &args)) {
2965     reply_with_error ("%s: daemon failed to decode procedure arguments", "wc_l");
2966     return;
2967   }
2968   path = args.path;
2969
2970   r = do_wc_l (path);
2971   if (r == -1)
2972     /* do_wc_l has already called reply_with_error */
2973     goto done;
2974
2975   struct guestfs_wc_l_ret ret;
2976   ret.lines = r;
2977   reply ((xdrproc_t) &xdr_guestfs_wc_l_ret, (char *) &ret);
2978 done:
2979   xdr_free ((xdrproc_t) xdr_guestfs_wc_l_args, (char *) &args);
2980 }
2981
2982 static void wc_w_stub (XDR *xdr_in)
2983 {
2984   int r;
2985   struct guestfs_wc_w_args args;
2986   char *path;
2987
2988   memset (&args, 0, sizeof args);
2989
2990   if (!xdr_guestfs_wc_w_args (xdr_in, &args)) {
2991     reply_with_error ("%s: daemon failed to decode procedure arguments", "wc_w");
2992     return;
2993   }
2994   path = args.path;
2995
2996   r = do_wc_w (path);
2997   if (r == -1)
2998     /* do_wc_w has already called reply_with_error */
2999     goto done;
3000
3001   struct guestfs_wc_w_ret ret;
3002   ret.words = r;
3003   reply ((xdrproc_t) &xdr_guestfs_wc_w_ret, (char *) &ret);
3004 done:
3005   xdr_free ((xdrproc_t) xdr_guestfs_wc_w_args, (char *) &args);
3006 }
3007
3008 static void wc_c_stub (XDR *xdr_in)
3009 {
3010   int r;
3011   struct guestfs_wc_c_args args;
3012   char *path;
3013
3014   memset (&args, 0, sizeof args);
3015
3016   if (!xdr_guestfs_wc_c_args (xdr_in, &args)) {
3017     reply_with_error ("%s: daemon failed to decode procedure arguments", "wc_c");
3018     return;
3019   }
3020   path = args.path;
3021
3022   r = do_wc_c (path);
3023   if (r == -1)
3024     /* do_wc_c has already called reply_with_error */
3025     goto done;
3026
3027   struct guestfs_wc_c_ret ret;
3028   ret.chars = r;
3029   reply ((xdrproc_t) &xdr_guestfs_wc_c_ret, (char *) &ret);
3030 done:
3031   xdr_free ((xdrproc_t) xdr_guestfs_wc_c_args, (char *) &args);
3032 }
3033
3034 static void head_stub (XDR *xdr_in)
3035 {
3036   char **r;
3037   struct guestfs_head_args args;
3038   char *path;
3039
3040   memset (&args, 0, sizeof args);
3041
3042   if (!xdr_guestfs_head_args (xdr_in, &args)) {
3043     reply_with_error ("%s: daemon failed to decode procedure arguments", "head");
3044     return;
3045   }
3046   path = args.path;
3047
3048   r = do_head (path);
3049   if (r == NULL)
3050     /* do_head has already called reply_with_error */
3051     goto done;
3052
3053   struct guestfs_head_ret ret;
3054   ret.lines.lines_len = count_strings (r);
3055   ret.lines.lines_val = r;
3056   reply ((xdrproc_t) &xdr_guestfs_head_ret, (char *) &ret);
3057   free_strings (r);
3058 done:
3059   xdr_free ((xdrproc_t) xdr_guestfs_head_args, (char *) &args);
3060 }
3061
3062 static void head_n_stub (XDR *xdr_in)
3063 {
3064   char **r;
3065   struct guestfs_head_n_args args;
3066   int nrlines;
3067   char *path;
3068
3069   memset (&args, 0, sizeof args);
3070
3071   if (!xdr_guestfs_head_n_args (xdr_in, &args)) {
3072     reply_with_error ("%s: daemon failed to decode procedure arguments", "head_n");
3073     return;
3074   }
3075   nrlines = args.nrlines;
3076   path = args.path;
3077
3078   r = do_head_n (nrlines, path);
3079   if (r == NULL)
3080     /* do_head_n has already called reply_with_error */
3081     goto done;
3082
3083   struct guestfs_head_n_ret ret;
3084   ret.lines.lines_len = count_strings (r);
3085   ret.lines.lines_val = r;
3086   reply ((xdrproc_t) &xdr_guestfs_head_n_ret, (char *) &ret);
3087   free_strings (r);
3088 done:
3089   xdr_free ((xdrproc_t) xdr_guestfs_head_n_args, (char *) &args);
3090 }
3091
3092 static void tail_stub (XDR *xdr_in)
3093 {
3094   char **r;
3095   struct guestfs_tail_args args;
3096   char *path;
3097
3098   memset (&args, 0, sizeof args);
3099
3100   if (!xdr_guestfs_tail_args (xdr_in, &args)) {
3101     reply_with_error ("%s: daemon failed to decode procedure arguments", "tail");
3102     return;
3103   }
3104   path = args.path;
3105
3106   r = do_tail (path);
3107   if (r == NULL)
3108     /* do_tail has already called reply_with_error */
3109     goto done;
3110
3111   struct guestfs_tail_ret ret;
3112   ret.lines.lines_len = count_strings (r);
3113   ret.lines.lines_val = r;
3114   reply ((xdrproc_t) &xdr_guestfs_tail_ret, (char *) &ret);
3115   free_strings (r);
3116 done:
3117   xdr_free ((xdrproc_t) xdr_guestfs_tail_args, (char *) &args);
3118 }
3119
3120 static void tail_n_stub (XDR *xdr_in)
3121 {
3122   char **r;
3123   struct guestfs_tail_n_args args;
3124   int nrlines;
3125   char *path;
3126
3127   memset (&args, 0, sizeof args);
3128
3129   if (!xdr_guestfs_tail_n_args (xdr_in, &args)) {
3130     reply_with_error ("%s: daemon failed to decode procedure arguments", "tail_n");
3131     return;
3132   }
3133   nrlines = args.nrlines;
3134   path = args.path;
3135
3136   r = do_tail_n (nrlines, path);
3137   if (r == NULL)
3138     /* do_tail_n has already called reply_with_error */
3139     goto done;
3140
3141   struct guestfs_tail_n_ret ret;
3142   ret.lines.lines_len = count_strings (r);
3143   ret.lines.lines_val = r;
3144   reply ((xdrproc_t) &xdr_guestfs_tail_n_ret, (char *) &ret);
3145   free_strings (r);
3146 done:
3147   xdr_free ((xdrproc_t) xdr_guestfs_tail_n_args, (char *) &args);
3148 }
3149
3150 static void df_stub (XDR *xdr_in)
3151 {
3152   char *r;
3153
3154   r = do_df ();
3155   if (r == NULL)
3156     /* do_df has already called reply_with_error */
3157     goto done;
3158
3159   struct guestfs_df_ret ret;
3160   ret.output = r;
3161   reply ((xdrproc_t) &xdr_guestfs_df_ret, (char *) &ret);
3162   free (r);
3163 done: ;
3164 }
3165
3166 static void df_h_stub (XDR *xdr_in)
3167 {
3168   char *r;
3169
3170   r = do_df_h ();
3171   if (r == NULL)
3172     /* do_df_h has already called reply_with_error */
3173     goto done;
3174
3175   struct guestfs_df_h_ret ret;
3176   ret.output = r;
3177   reply ((xdrproc_t) &xdr_guestfs_df_h_ret, (char *) &ret);
3178   free (r);
3179 done: ;
3180 }
3181
3182 static void du_stub (XDR *xdr_in)
3183 {
3184   int64_t r;
3185   struct guestfs_du_args args;
3186   char *path;
3187
3188   memset (&args, 0, sizeof args);
3189
3190   if (!xdr_guestfs_du_args (xdr_in, &args)) {
3191     reply_with_error ("%s: daemon failed to decode procedure arguments", "du");
3192     return;
3193   }
3194   path = args.path;
3195
3196   r = do_du (path);
3197   if (r == -1)
3198     /* do_du has already called reply_with_error */
3199     goto done;
3200
3201   struct guestfs_du_ret ret;
3202   ret.sizekb = r;
3203   reply ((xdrproc_t) &xdr_guestfs_du_ret, (char *) &ret);
3204 done:
3205   xdr_free ((xdrproc_t) xdr_guestfs_du_args, (char *) &args);
3206 }
3207
3208 static void initrd_list_stub (XDR *xdr_in)
3209 {
3210   char **r;
3211   struct guestfs_initrd_list_args args;
3212   char *path;
3213
3214   memset (&args, 0, sizeof args);
3215
3216   if (!xdr_guestfs_initrd_list_args (xdr_in, &args)) {
3217     reply_with_error ("%s: daemon failed to decode procedure arguments", "initrd_list");
3218     return;
3219   }
3220   path = args.path;
3221
3222   r = do_initrd_list (path);
3223   if (r == NULL)
3224     /* do_initrd_list has already called reply_with_error */
3225     goto done;
3226
3227   struct guestfs_initrd_list_ret ret;
3228   ret.filenames.filenames_len = count_strings (r);
3229   ret.filenames.filenames_val = r;
3230   reply ((xdrproc_t) &xdr_guestfs_initrd_list_ret, (char *) &ret);
3231   free_strings (r);
3232 done:
3233   xdr_free ((xdrproc_t) xdr_guestfs_initrd_list_args, (char *) &args);
3234 }
3235
3236 static void mount_loop_stub (XDR *xdr_in)
3237 {
3238   int r;
3239   struct guestfs_mount_loop_args args;
3240   char *file;
3241   char *mountpoint;
3242
3243   memset (&args, 0, sizeof args);
3244
3245   if (!xdr_guestfs_mount_loop_args (xdr_in, &args)) {
3246     reply_with_error ("%s: daemon failed to decode procedure arguments", "mount_loop");
3247     return;
3248   }
3249   file = args.file;
3250   mountpoint = args.mountpoint;
3251
3252   r = do_mount_loop (file, mountpoint);
3253   if (r == -1)
3254     /* do_mount_loop has already called reply_with_error */
3255     goto done;
3256
3257   reply (NULL, NULL);
3258 done:
3259   xdr_free ((xdrproc_t) xdr_guestfs_mount_loop_args, (char *) &args);
3260 }
3261
3262 static void mkswap_stub (XDR *xdr_in)
3263 {
3264   int r;
3265   struct guestfs_mkswap_args args;
3266   char *device;
3267
3268   memset (&args, 0, sizeof args);
3269
3270   if (!xdr_guestfs_mkswap_args (xdr_in, &args)) {
3271     reply_with_error ("%s: daemon failed to decode procedure arguments", "mkswap");
3272     return;
3273   }
3274   device = args.device;
3275
3276   r = do_mkswap (device);
3277   if (r == -1)
3278     /* do_mkswap has already called reply_with_error */
3279     goto done;
3280
3281   reply (NULL, NULL);
3282 done:
3283   xdr_free ((xdrproc_t) xdr_guestfs_mkswap_args, (char *) &args);
3284 }
3285
3286 static void mkswap_L_stub (XDR *xdr_in)
3287 {
3288   int r;
3289   struct guestfs_mkswap_L_args args;
3290   char *label;
3291   char *device;
3292
3293   memset (&args, 0, sizeof args);
3294
3295   if (!xdr_guestfs_mkswap_L_args (xdr_in, &args)) {
3296     reply_with_error ("%s: daemon failed to decode procedure arguments", "mkswap_L");
3297     return;
3298   }
3299   label = args.label;
3300   device = args.device;
3301
3302   r = do_mkswap_L (label, device);
3303   if (r == -1)
3304     /* do_mkswap_L has already called reply_with_error */
3305     goto done;
3306
3307   reply (NULL, NULL);
3308 done:
3309   xdr_free ((xdrproc_t) xdr_guestfs_mkswap_L_args, (char *) &args);
3310 }
3311
3312 static void mkswap_U_stub (XDR *xdr_in)
3313 {
3314   int r;
3315   struct guestfs_mkswap_U_args args;
3316   char *uuid;
3317   char *device;
3318
3319   memset (&args, 0, sizeof args);
3320
3321   if (!xdr_guestfs_mkswap_U_args (xdr_in, &args)) {
3322     reply_with_error ("%s: daemon failed to decode procedure arguments", "mkswap_U");
3323     return;
3324   }
3325   uuid = args.uuid;
3326   device = args.device;
3327
3328   r = do_mkswap_U (uuid, device);
3329   if (r == -1)
3330     /* do_mkswap_U has already called reply_with_error */
3331     goto done;
3332
3333   reply (NULL, NULL);
3334 done:
3335   xdr_free ((xdrproc_t) xdr_guestfs_mkswap_U_args, (char *) &args);
3336 }
3337
3338 static void mknod_stub (XDR *xdr_in)
3339 {
3340   int r;
3341   struct guestfs_mknod_args args;
3342   int mode;
3343   int devmajor;
3344   int devminor;
3345   char *path;
3346
3347   memset (&args, 0, sizeof args);
3348
3349   if (!xdr_guestfs_mknod_args (xdr_in, &args)) {
3350     reply_with_error ("%s: daemon failed to decode procedure arguments", "mknod");
3351     return;
3352   }
3353   mode = args.mode;
3354   devmajor = args.devmajor;
3355   devminor = args.devminor;
3356   path = args.path;
3357
3358   r = do_mknod (mode, devmajor, devminor, path);
3359   if (r == -1)
3360     /* do_mknod has already called reply_with_error */
3361     goto done;
3362
3363   reply (NULL, NULL);
3364 done:
3365   xdr_free ((xdrproc_t) xdr_guestfs_mknod_args, (char *) &args);
3366 }
3367
3368 static void mkfifo_stub (XDR *xdr_in)
3369 {
3370   int r;
3371   struct guestfs_mkfifo_args args;
3372   int mode;
3373   char *path;
3374
3375   memset (&args, 0, sizeof args);
3376
3377   if (!xdr_guestfs_mkfifo_args (xdr_in, &args)) {
3378     reply_with_error ("%s: daemon failed to decode procedure arguments", "mkfifo");
3379     return;
3380   }
3381   mode = args.mode;
3382   path = args.path;
3383
3384   r = do_mkfifo (mode, path);
3385   if (r == -1)
3386     /* do_mkfifo has already called reply_with_error */
3387     goto done;
3388
3389   reply (NULL, NULL);
3390 done:
3391   xdr_free ((xdrproc_t) xdr_guestfs_mkfifo_args, (char *) &args);
3392 }
3393
3394 static void mknod_b_stub (XDR *xdr_in)
3395 {
3396   int r;
3397   struct guestfs_mknod_b_args args;
3398   int mode;
3399   int devmajor;
3400   int devminor;
3401   char *path;
3402
3403   memset (&args, 0, sizeof args);
3404
3405   if (!xdr_guestfs_mknod_b_args (xdr_in, &args)) {
3406     reply_with_error ("%s: daemon failed to decode procedure arguments", "mknod_b");
3407     return;
3408   }
3409   mode = args.mode;
3410   devmajor = args.devmajor;
3411   devminor = args.devminor;
3412   path = args.path;
3413
3414   r = do_mknod_b (mode, devmajor, devminor, path);
3415   if (r == -1)
3416     /* do_mknod_b has already called reply_with_error */
3417     goto done;
3418
3419   reply (NULL, NULL);
3420 done:
3421   xdr_free ((xdrproc_t) xdr_guestfs_mknod_b_args, (char *) &args);
3422 }
3423
3424 static void mknod_c_stub (XDR *xdr_in)
3425 {
3426   int r;
3427   struct guestfs_mknod_c_args args;
3428   int mode;
3429   int devmajor;
3430   int devminor;
3431   char *path;
3432
3433   memset (&args, 0, sizeof args);
3434
3435   if (!xdr_guestfs_mknod_c_args (xdr_in, &args)) {
3436     reply_with_error ("%s: daemon failed to decode procedure arguments", "mknod_c");
3437     return;
3438   }
3439   mode = args.mode;
3440   devmajor = args.devmajor;
3441   devminor = args.devminor;
3442   path = args.path;
3443
3444   r = do_mknod_c (mode, devmajor, devminor, path);
3445   if (r == -1)
3446     /* do_mknod_c has already called reply_with_error */
3447     goto done;
3448
3449   reply (NULL, NULL);
3450 done:
3451   xdr_free ((xdrproc_t) xdr_guestfs_mknod_c_args, (char *) &args);
3452 }
3453
3454 static void umask_stub (XDR *xdr_in)
3455 {
3456   int r;
3457   struct guestfs_umask_args args;
3458   int mask;
3459
3460   memset (&args, 0, sizeof args);
3461
3462   if (!xdr_guestfs_umask_args (xdr_in, &args)) {
3463     reply_with_error ("%s: daemon failed to decode procedure arguments", "umask");
3464     return;
3465   }
3466   mask = args.mask;
3467
3468   r = do_umask (mask);
3469   if (r == -1)
3470     /* do_umask has already called reply_with_error */
3471     goto done;
3472
3473   struct guestfs_umask_ret ret;
3474   ret.oldmask = r;
3475   reply ((xdrproc_t) &xdr_guestfs_umask_ret, (char *) &ret);
3476 done:
3477   xdr_free ((xdrproc_t) xdr_guestfs_umask_args, (char *) &args);
3478 }
3479
3480 void dispatch_incoming_message (XDR *xdr_in)
3481 {
3482   switch (proc_nr) {
3483     case GUESTFS_PROC_MOUNT:
3484       mount_stub (xdr_in);
3485       break;
3486     case GUESTFS_PROC_SYNC:
3487       sync_stub (xdr_in);
3488       break;
3489     case GUESTFS_PROC_TOUCH:
3490       touch_stub (xdr_in);
3491       break;
3492     case GUESTFS_PROC_CAT:
3493       cat_stub (xdr_in);
3494       break;
3495     case GUESTFS_PROC_LL:
3496       ll_stub (xdr_in);
3497       break;
3498     case GUESTFS_PROC_LS:
3499       ls_stub (xdr_in);
3500       break;
3501     case GUESTFS_PROC_LIST_DEVICES:
3502       list_devices_stub (xdr_in);
3503       break;
3504     case GUESTFS_PROC_LIST_PARTITIONS:
3505       list_partitions_stub (xdr_in);
3506       break;
3507     case GUESTFS_PROC_PVS:
3508       pvs_stub (xdr_in);
3509       break;
3510     case GUESTFS_PROC_VGS:
3511       vgs_stub (xdr_in);
3512       break;
3513     case GUESTFS_PROC_LVS:
3514       lvs_stub (xdr_in);
3515       break;
3516     case GUESTFS_PROC_PVS_FULL:
3517       pvs_full_stub (xdr_in);
3518       break;
3519     case GUESTFS_PROC_VGS_FULL:
3520       vgs_full_stub (xdr_in);
3521       break;
3522     case GUESTFS_PROC_LVS_FULL:
3523       lvs_full_stub (xdr_in);
3524       break;
3525     case GUESTFS_PROC_READ_LINES:
3526       read_lines_stub (xdr_in);
3527       break;
3528     case GUESTFS_PROC_AUG_INIT:
3529       aug_init_stub (xdr_in);
3530       break;
3531     case GUESTFS_PROC_AUG_CLOSE:
3532       aug_close_stub (xdr_in);
3533       break;
3534     case GUESTFS_PROC_AUG_DEFVAR:
3535       aug_defvar_stub (xdr_in);
3536       break;
3537     case GUESTFS_PROC_AUG_DEFNODE:
3538       aug_defnode_stub (xdr_in);
3539       break;
3540     case GUESTFS_PROC_AUG_GET:
3541       aug_get_stub (xdr_in);
3542       break;
3543     case GUESTFS_PROC_AUG_SET:
3544       aug_set_stub (xdr_in);
3545       break;
3546     case GUESTFS_PROC_AUG_INSERT:
3547       aug_insert_stub (xdr_in);
3548       break;
3549     case GUESTFS_PROC_AUG_RM:
3550       aug_rm_stub (xdr_in);
3551       break;
3552     case GUESTFS_PROC_AUG_MV:
3553       aug_mv_stub (xdr_in);
3554       break;
3555     case GUESTFS_PROC_AUG_MATCH:
3556       aug_match_stub (xdr_in);
3557       break;
3558     case GUESTFS_PROC_AUG_SAVE:
3559       aug_save_stub (xdr_in);
3560       break;
3561     case GUESTFS_PROC_AUG_LOAD:
3562       aug_load_stub (xdr_in);
3563       break;
3564     case GUESTFS_PROC_AUG_LS:
3565       aug_ls_stub (xdr_in);
3566       break;
3567     case GUESTFS_PROC_RM:
3568       rm_stub (xdr_in);
3569       break;
3570     case GUESTFS_PROC_RMDIR:
3571       rmdir_stub (xdr_in);
3572       break;
3573     case GUESTFS_PROC_RM_RF:
3574       rm_rf_stub (xdr_in);
3575       break;
3576     case GUESTFS_PROC_MKDIR:
3577       mkdir_stub (xdr_in);
3578       break;
3579     case GUESTFS_PROC_MKDIR_P:
3580       mkdir_p_stub (xdr_in);
3581       break;
3582     case GUESTFS_PROC_CHMOD:
3583       chmod_stub (xdr_in);
3584       break;
3585     case GUESTFS_PROC_CHOWN:
3586       chown_stub (xdr_in);
3587       break;
3588     case GUESTFS_PROC_EXISTS:
3589       exists_stub (xdr_in);
3590       break;
3591     case GUESTFS_PROC_IS_FILE:
3592       is_file_stub (xdr_in);
3593       break;
3594     case GUESTFS_PROC_IS_DIR:
3595       is_dir_stub (xdr_in);
3596       break;
3597     case GUESTFS_PROC_PVCREATE:
3598       pvcreate_stub (xdr_in);
3599       break;
3600     case GUESTFS_PROC_VGCREATE:
3601       vgcreate_stub (xdr_in);
3602       break;
3603     case GUESTFS_PROC_LVCREATE:
3604       lvcreate_stub (xdr_in);
3605       break;
3606     case GUESTFS_PROC_MKFS:
3607       mkfs_stub (xdr_in);
3608       break;
3609     case GUESTFS_PROC_SFDISK:
3610       sfdisk_stub (xdr_in);
3611       break;
3612     case GUESTFS_PROC_WRITE_FILE:
3613       write_file_stub (xdr_in);
3614       break;
3615     case GUESTFS_PROC_UMOUNT:
3616       umount_stub (xdr_in);
3617       break;
3618     case GUESTFS_PROC_MOUNTS:
3619       mounts_stub (xdr_in);
3620       break;
3621     case GUESTFS_PROC_UMOUNT_ALL:
3622       umount_all_stub (xdr_in);
3623       break;
3624     case GUESTFS_PROC_LVM_REMOVE_ALL:
3625       lvm_remove_all_stub (xdr_in);
3626       break;
3627     case GUESTFS_PROC_FILE:
3628       file_stub (xdr_in);
3629       break;
3630     case GUESTFS_PROC_COMMAND:
3631       command_stub (xdr_in);
3632       break;
3633     case GUESTFS_PROC_COMMAND_LINES:
3634       command_lines_stub (xdr_in);
3635       break;
3636     case GUESTFS_PROC_STAT:
3637       stat_stub (xdr_in);
3638       break;
3639     case GUESTFS_PROC_LSTAT:
3640       lstat_stub (xdr_in);
3641       break;
3642     case GUESTFS_PROC_STATVFS:
3643       statvfs_stub (xdr_in);
3644       break;
3645     case GUESTFS_PROC_TUNE2FS_L:
3646       tune2fs_l_stub (xdr_in);
3647       break;
3648     case GUESTFS_PROC_BLOCKDEV_SETRO:
3649       blockdev_setro_stub (xdr_in);
3650       break;
3651     case GUESTFS_PROC_BLOCKDEV_SETRW:
3652       blockdev_setrw_stub (xdr_in);
3653       break;
3654     case GUESTFS_PROC_BLOCKDEV_GETRO:
3655       blockdev_getro_stub (xdr_in);
3656       break;
3657     case GUESTFS_PROC_BLOCKDEV_GETSS:
3658       blockdev_getss_stub (xdr_in);
3659       break;
3660     case GUESTFS_PROC_BLOCKDEV_GETBSZ:
3661       blockdev_getbsz_stub (xdr_in);
3662       break;
3663     case GUESTFS_PROC_BLOCKDEV_SETBSZ:
3664       blockdev_setbsz_stub (xdr_in);
3665       break;
3666     case GUESTFS_PROC_BLOCKDEV_GETSZ:
3667       blockdev_getsz_stub (xdr_in);
3668       break;
3669     case GUESTFS_PROC_BLOCKDEV_GETSIZE64:
3670       blockdev_getsize64_stub (xdr_in);
3671       break;
3672     case GUESTFS_PROC_BLOCKDEV_FLUSHBUFS:
3673       blockdev_flushbufs_stub (xdr_in);
3674       break;
3675     case GUESTFS_PROC_BLOCKDEV_REREADPT:
3676       blockdev_rereadpt_stub (xdr_in);
3677       break;
3678     case GUESTFS_PROC_UPLOAD:
3679       upload_stub (xdr_in);
3680       break;
3681     case GUESTFS_PROC_DOWNLOAD:
3682       download_stub (xdr_in);
3683       break;
3684     case GUESTFS_PROC_CHECKSUM:
3685       checksum_stub (xdr_in);
3686       break;
3687     case GUESTFS_PROC_TAR_IN:
3688       tar_in_stub (xdr_in);
3689       break;
3690     case GUESTFS_PROC_TAR_OUT:
3691       tar_out_stub (xdr_in);
3692       break;
3693     case GUESTFS_PROC_TGZ_IN:
3694       tgz_in_stub (xdr_in);
3695       break;
3696     case GUESTFS_PROC_TGZ_OUT:
3697       tgz_out_stub (xdr_in);
3698       break;
3699     case GUESTFS_PROC_MOUNT_RO:
3700       mount_ro_stub (xdr_in);
3701       break;
3702     case GUESTFS_PROC_MOUNT_OPTIONS:
3703       mount_options_stub (xdr_in);
3704       break;
3705     case GUESTFS_PROC_MOUNT_VFS:
3706       mount_vfs_stub (xdr_in);
3707       break;
3708     case GUESTFS_PROC_DEBUG:
3709       debug_stub (xdr_in);
3710       break;
3711     case GUESTFS_PROC_LVREMOVE:
3712       lvremove_stub (xdr_in);
3713       break;
3714     case GUESTFS_PROC_VGREMOVE:
3715       vgremove_stub (xdr_in);
3716       break;
3717     case GUESTFS_PROC_PVREMOVE:
3718       pvremove_stub (xdr_in);
3719       break;
3720     case GUESTFS_PROC_SET_E2LABEL:
3721       set_e2label_stub (xdr_in);
3722       break;
3723     case GUESTFS_PROC_GET_E2LABEL:
3724       get_e2label_stub (xdr_in);
3725       break;
3726     case GUESTFS_PROC_SET_E2UUID:
3727       set_e2uuid_stub (xdr_in);
3728       break;
3729     case GUESTFS_PROC_GET_E2UUID:
3730       get_e2uuid_stub (xdr_in);
3731       break;
3732     case GUESTFS_PROC_FSCK:
3733       fsck_stub (xdr_in);
3734       break;
3735     case GUESTFS_PROC_ZERO:
3736       zero_stub (xdr_in);
3737       break;
3738     case GUESTFS_PROC_GRUB_INSTALL:
3739       grub_install_stub (xdr_in);
3740       break;
3741     case GUESTFS_PROC_CP:
3742       cp_stub (xdr_in);
3743       break;
3744     case GUESTFS_PROC_CP_A:
3745       cp_a_stub (xdr_in);
3746       break;
3747     case GUESTFS_PROC_MV:
3748       mv_stub (xdr_in);
3749       break;
3750     case GUESTFS_PROC_DROP_CACHES:
3751       drop_caches_stub (xdr_in);
3752       break;
3753     case GUESTFS_PROC_DMESG:
3754       dmesg_stub (xdr_in);
3755       break;
3756     case GUESTFS_PROC_PING_DAEMON:
3757       ping_daemon_stub (xdr_in);
3758       break;
3759     case GUESTFS_PROC_EQUAL:
3760       equal_stub (xdr_in);
3761       break;
3762     case GUESTFS_PROC_STRINGS:
3763       strings_stub (xdr_in);
3764       break;
3765     case GUESTFS_PROC_STRINGS_E:
3766       strings_e_stub (xdr_in);
3767       break;
3768     case GUESTFS_PROC_HEXDUMP:
3769       hexdump_stub (xdr_in);
3770       break;
3771     case GUESTFS_PROC_ZEROFREE:
3772       zerofree_stub (xdr_in);
3773       break;
3774     case GUESTFS_PROC_PVRESIZE:
3775       pvresize_stub (xdr_in);
3776       break;
3777     case GUESTFS_PROC_SFDISK_N:
3778       sfdisk_N_stub (xdr_in);
3779       break;
3780     case GUESTFS_PROC_SFDISK_L:
3781       sfdisk_l_stub (xdr_in);
3782       break;
3783     case GUESTFS_PROC_SFDISK_KERNEL_GEOMETRY:
3784       sfdisk_kernel_geometry_stub (xdr_in);
3785       break;
3786     case GUESTFS_PROC_SFDISK_DISK_GEOMETRY:
3787       sfdisk_disk_geometry_stub (xdr_in);
3788       break;
3789     case GUESTFS_PROC_VG_ACTIVATE_ALL:
3790       vg_activate_all_stub (xdr_in);
3791       break;
3792     case GUESTFS_PROC_VG_ACTIVATE:
3793       vg_activate_stub (xdr_in);
3794       break;
3795     case GUESTFS_PROC_LVRESIZE:
3796       lvresize_stub (xdr_in);
3797       break;
3798     case GUESTFS_PROC_RESIZE2FS:
3799       resize2fs_stub (xdr_in);
3800       break;
3801     case GUESTFS_PROC_FIND:
3802       find_stub (xdr_in);
3803       break;
3804     case GUESTFS_PROC_E2FSCK_F:
3805       e2fsck_f_stub (xdr_in);
3806       break;
3807     case GUESTFS_PROC_SLEEP:
3808       sleep_stub (xdr_in);
3809       break;
3810     case GUESTFS_PROC_NTFS_3G_PROBE:
3811       ntfs_3g_probe_stub (xdr_in);
3812       break;
3813     case GUESTFS_PROC_SH:
3814       sh_stub (xdr_in);
3815       break;
3816     case GUESTFS_PROC_SH_LINES:
3817       sh_lines_stub (xdr_in);
3818       break;
3819     case GUESTFS_PROC_GLOB_EXPAND:
3820       glob_expand_stub (xdr_in);
3821       break;
3822     case GUESTFS_PROC_SCRUB_DEVICE:
3823       scrub_device_stub (xdr_in);
3824       break;
3825     case GUESTFS_PROC_SCRUB_FILE:
3826       scrub_file_stub (xdr_in);
3827       break;
3828     case GUESTFS_PROC_SCRUB_FREESPACE:
3829       scrub_freespace_stub (xdr_in);
3830       break;
3831     case GUESTFS_PROC_MKDTEMP:
3832       mkdtemp_stub (xdr_in);
3833       break;
3834     case GUESTFS_PROC_WC_L:
3835       wc_l_stub (xdr_in);
3836       break;
3837     case GUESTFS_PROC_WC_W:
3838       wc_w_stub (xdr_in);
3839       break;
3840     case GUESTFS_PROC_WC_C:
3841       wc_c_stub (xdr_in);
3842       break;
3843     case GUESTFS_PROC_HEAD:
3844       head_stub (xdr_in);
3845       break;
3846     case GUESTFS_PROC_HEAD_N:
3847       head_n_stub (xdr_in);
3848       break;
3849     case GUESTFS_PROC_TAIL:
3850       tail_stub (xdr_in);
3851       break;
3852     case GUESTFS_PROC_TAIL_N:
3853       tail_n_stub (xdr_in);
3854       break;
3855     case GUESTFS_PROC_DF:
3856       df_stub (xdr_in);
3857       break;
3858     case GUESTFS_PROC_DF_H:
3859       df_h_stub (xdr_in);
3860       break;
3861     case GUESTFS_PROC_DU:
3862       du_stub (xdr_in);
3863       break;
3864     case GUESTFS_PROC_INITRD_LIST:
3865       initrd_list_stub (xdr_in);
3866       break;
3867     case GUESTFS_PROC_MOUNT_LOOP:
3868       mount_loop_stub (xdr_in);
3869       break;
3870     case GUESTFS_PROC_MKSWAP:
3871       mkswap_stub (xdr_in);
3872       break;
3873     case GUESTFS_PROC_MKSWAP_L:
3874       mkswap_L_stub (xdr_in);
3875       break;
3876     case GUESTFS_PROC_MKSWAP_U:
3877       mkswap_U_stub (xdr_in);
3878       break;
3879     case GUESTFS_PROC_MKNOD:
3880       mknod_stub (xdr_in);
3881       break;
3882     case GUESTFS_PROC_MKFIFO:
3883       mkfifo_stub (xdr_in);
3884       break;
3885     case GUESTFS_PROC_MKNOD_B:
3886       mknod_b_stub (xdr_in);
3887       break;
3888     case GUESTFS_PROC_MKNOD_C:
3889       mknod_c_stub (xdr_in);
3890       break;
3891     case GUESTFS_PROC_UMASK:
3892       umask_stub (xdr_in);
3893       break;
3894     default:
3895       reply_with_error ("dispatch_incoming_message: unknown procedure number %d, set LIBGUESTFS_PATH to point to the matching libguestfs appliance directory", proc_nr);
3896   }
3897 }
3898
3899 static const char *lvm_pv_cols = "pv_name,pv_uuid,pv_fmt,pv_size,dev_size,pv_free,pv_used,pv_attr,pv_pe_count,pv_pe_alloc_count,pv_tags,pe_start,pv_mda_count,pv_mda_free";
3900
3901 static int lvm_tokenize_pv (char *str, struct guestfs_lvm_int_pv *r)
3902 {
3903   char *tok, *p, *next;
3904   int i, j;
3905
3906   if (!str) {
3907     fprintf (stderr, "%s: failed: passed a NULL string\n", __func__);
3908     return -1;
3909   }
3910   if (!*str || isspace (*str)) {
3911     fprintf (stderr, "%s: failed: passed a empty string or one beginning with whitespace\n", __func__);
3912     return -1;
3913   }
3914   tok = str;
3915   if (!tok) {
3916     fprintf (stderr, "%s: failed: string finished early, around token %s\n", __func__, "pv_name");
3917     return -1;
3918   }
3919   p = strchrnul (tok, ',');
3920   if (*p) next = p+1; else next = NULL;
3921   *p = '\0';
3922   r->pv_name = strdup (tok);
3923   if (r->pv_name == NULL) {
3924     perror ("strdup");
3925     return -1;
3926   }
3927   tok = next;
3928   if (!tok) {
3929     fprintf (stderr, "%s: failed: string finished early, around token %s\n", __func__, "pv_uuid");
3930     return -1;
3931   }
3932   p = strchrnul (tok, ',');
3933   if (*p) next = p+1; else next = NULL;
3934   *p = '\0';
3935   for (i = j = 0; i < 32; ++j) {
3936     if (tok[j] == '\0') {
3937       fprintf (stderr, "%s: failed to parse UUID from '%s'\n", __func__, tok);
3938       return -1;
3939     } else if (tok[j] != '-')
3940       r->pv_uuid[i++] = tok[j];
3941   }
3942   tok = next;
3943   if (!tok) {
3944     fprintf (stderr, "%s: failed: string finished early, around token %s\n", __func__, "pv_fmt");
3945     return -1;
3946   }
3947   p = strchrnul (tok, ',');
3948   if (*p) next = p+1; else next = NULL;
3949   *p = '\0';
3950   r->pv_fmt = strdup (tok);
3951   if (r->pv_fmt == NULL) {
3952     perror ("strdup");
3953     return -1;
3954   }
3955   tok = next;
3956   if (!tok) {
3957     fprintf (stderr, "%s: failed: string finished early, around token %s\n", __func__, "pv_size");
3958     return -1;
3959   }
3960   p = strchrnul (tok, ',');
3961   if (*p) next = p+1; else next = NULL;
3962   *p = '\0';
3963   if (sscanf (tok, "%"SCNu64, &r->pv_size) != 1) {
3964     fprintf (stderr, "%s: failed to parse size '%s' from token %s\n", __func__, tok, "pv_size");
3965     return -1;
3966   }
3967   tok = next;
3968   if (!tok) {
3969     fprintf (stderr, "%s: failed: string finished early, around token %s\n", __func__, "dev_size");
3970     return -1;
3971   }
3972   p = strchrnul (tok, ',');
3973   if (*p) next = p+1; else next = NULL;
3974   *p = '\0';
3975   if (sscanf (tok, "%"SCNu64, &r->dev_size) != 1) {
3976     fprintf (stderr, "%s: failed to parse size '%s' from token %s\n", __func__, tok, "dev_size");
3977     return -1;
3978   }
3979   tok = next;
3980   if (!tok) {
3981     fprintf (stderr, "%s: failed: string finished early, around token %s\n", __func__, "pv_free");
3982     return -1;
3983   }
3984   p = strchrnul (tok, ',');
3985   if (*p) next = p+1; else next = NULL;
3986   *p = '\0';
3987   if (sscanf (tok, "%"SCNu64, &r->pv_free) != 1) {
3988     fprintf (stderr, "%s: failed to parse size '%s' from token %s\n", __func__, tok, "pv_free");
3989     return -1;
3990   }
3991   tok = next;
3992   if (!tok) {
3993     fprintf (stderr, "%s: failed: string finished early, around token %s\n", __func__, "pv_used");
3994     return -1;
3995   }
3996   p = strchrnul (tok, ',');
3997   if (*p) next = p+1; else next = NULL;
3998   *p = '\0';
3999   if (sscanf (tok, "%"SCNu64, &r->pv_used) != 1) {
4000     fprintf (stderr, "%s: failed to parse size '%s' from token %s\n", __func__, tok, "pv_used");
4001     return -1;
4002   }
4003   tok = next;
4004   if (!tok) {
4005     fprintf (stderr, "%s: failed: string finished early, around token %s\n", __func__, "pv_attr");
4006     return -1;
4007   }
4008   p = strchrnul (tok, ',');
4009   if (*p) next = p+1; else next = NULL;
4010   *p = '\0';
4011   r->pv_attr = strdup (tok);
4012   if (r->pv_attr == NULL) {
4013     perror ("strdup");
4014     return -1;
4015   }
4016   tok = next;
4017   if (!tok) {
4018     fprintf (stderr, "%s: failed: string finished early, around token %s\n", __func__, "pv_pe_count");
4019     return -1;
4020   }
4021   p = strchrnul (tok, ',');
4022   if (*p) next = p+1; else next = NULL;
4023   *p = '\0';
4024   if (sscanf (tok, "%"SCNi64, &r->pv_pe_count) != 1) {
4025     fprintf (stderr, "%s: failed to parse int '%s' from token %s\n", __func__, tok, "pv_pe_count");
4026     return -1;
4027   }
4028   tok = next;
4029   if (!tok) {
4030     fprintf (stderr, "%s: failed: string finished early, around token %s\n", __func__, "pv_pe_alloc_count");
4031     return -1;
4032   }
4033   p = strchrnul (tok, ',');
4034   if (*p) next = p+1; else next = NULL;
4035   *p = '\0';
4036   if (sscanf (tok, "%"SCNi64, &r->pv_pe_alloc_count) != 1) {
4037     fprintf (stderr, "%s: failed to parse int '%s' from token %s\n", __func__, tok, "pv_pe_alloc_count");
4038     return -1;
4039   }
4040   tok = next;
4041   if (!tok) {
4042     fprintf (stderr, "%s: failed: string finished early, around token %s\n", __func__, "pv_tags");
4043     return -1;
4044   }
4045   p = strchrnul (tok, ',');
4046   if (*p) next = p+1; else next = NULL;
4047   *p = '\0';
4048   r->pv_tags = strdup (tok);
4049   if (r->pv_tags == NULL) {
4050     perror ("strdup");
4051     return -1;
4052   }
4053   tok = next;
4054   if (!tok) {
4055     fprintf (stderr, "%s: failed: string finished early, around token %s\n", __func__, "pe_start");
4056     return -1;
4057   }
4058   p = strchrnul (tok, ',');
4059   if (*p) next = p+1; else next = NULL;
4060   *p = '\0';
4061   if (sscanf (tok, "%"SCNu64, &r->pe_start) != 1) {
4062     fprintf (stderr, "%s: failed to parse size '%s' from token %s\n", __func__, tok, "pe_start");
4063     return -1;
4064   }
4065   tok = next;
4066   if (!tok) {
4067     fprintf (stderr, "%s: failed: string finished early, around token %s\n", __func__, "pv_mda_count");
4068     return -1;
4069   }
4070   p = strchrnul (tok, ',');
4071   if (*p) next = p+1; else next = NULL;
4072   *p = '\0';
4073   if (sscanf (tok, "%"SCNi64, &r->pv_mda_count) != 1) {
4074     fprintf (stderr, "%s: failed to parse int '%s' from token %s\n", __func__, tok, "pv_mda_count");
4075     return -1;
4076   }
4077   tok = next;
4078   if (!tok) {
4079     fprintf (stderr, "%s: failed: string finished early, around token %s\n", __func__, "pv_mda_free");
4080     return -1;
4081   }
4082   p = strchrnul (tok, ',');
4083   if (*p) next = p+1; else next = NULL;
4084   *p = '\0';
4085   if (sscanf (tok, "%"SCNu64, &r->pv_mda_free) != 1) {
4086     fprintf (stderr, "%s: failed to parse size '%s' from token %s\n", __func__, tok, "pv_mda_free");
4087     return -1;
4088   }
4089   tok = next;
4090   if (tok != NULL) {
4091     fprintf (stderr, "%s: failed: extra tokens at end of string\n", __func__);
4092     return -1;
4093   }
4094   return 0;
4095 }
4096
4097 guestfs_lvm_int_pv_list *
4098 parse_command_line_pvs (void)
4099 {
4100   char *out, *err;
4101   char *p, *pend;
4102   int r, i;
4103   guestfs_lvm_int_pv_list *ret;
4104   void *newp;
4105
4106   ret = malloc (sizeof *ret);
4107   if (!ret) {
4108     reply_with_perror ("malloc");
4109     return NULL;
4110   }
4111
4112   ret->guestfs_lvm_int_pv_list_len = 0;
4113   ret->guestfs_lvm_int_pv_list_val = NULL;
4114
4115   r = command (&out, &err,
4116                "/sbin/lvm", "pvs",
4117                "-o", lvm_pv_cols, "--unbuffered", "--noheadings",
4118                "--nosuffix", "--separator", ",", "--units", "b", NULL);
4119   if (r == -1) {
4120     reply_with_error ("%s", err);
4121     free (out);
4122     free (err);
4123     free (ret);
4124     return NULL;
4125   }
4126
4127   free (err);
4128
4129   /* Tokenize each line of the output. */
4130   p = out;
4131   i = 0;
4132   while (p) {
4133     pend = strchr (p, '\n');    /* Get the next line of output. */
4134     if (pend) {
4135       *pend = '\0';
4136       pend++;
4137     }
4138
4139     while (*p && isspace (*p))  /* Skip any leading whitespace. */
4140       p++;
4141
4142     if (!*p) {                  /* Empty line?  Skip it. */
4143       p = pend;
4144       continue;
4145     }
4146
4147     /* Allocate some space to store this next entry. */
4148     newp = realloc (ret->guestfs_lvm_int_pv_list_val,
4149                     sizeof (guestfs_lvm_int_pv) * (i+1));
4150     if (newp == NULL) {
4151       reply_with_perror ("realloc");
4152       free (ret->guestfs_lvm_int_pv_list_val);
4153       free (ret);
4154       free (out);
4155       return NULL;
4156     }
4157     ret->guestfs_lvm_int_pv_list_val = newp;
4158
4159     /* Tokenize the next entry. */
4160     r = lvm_tokenize_pv (p, &ret->guestfs_lvm_int_pv_list_val[i]);
4161     if (r == -1) {
4162       reply_with_error ("failed to parse output of 'pvs' command");
4163       free (ret->guestfs_lvm_int_pv_list_val);
4164       free (ret);
4165       free (out);
4166       return NULL;
4167     }
4168
4169     ++i;
4170     p = pend;
4171   }
4172
4173   ret->guestfs_lvm_int_pv_list_len = i;
4174
4175   free (out);
4176   return ret;
4177 }
4178 static const char *lvm_vg_cols = "vg_name,vg_uuid,vg_fmt,vg_attr,vg_size,vg_free,vg_sysid,vg_extent_size,vg_extent_count,vg_free_count,max_lv,max_pv,pv_count,lv_count,snap_count,vg_seqno,vg_tags,vg_mda_count,vg_mda_free";
4179
4180 static int lvm_tokenize_vg (char *str, struct guestfs_lvm_int_vg *r)
4181 {
4182   char *tok, *p, *next;
4183   int i, j;
4184
4185   if (!str) {
4186     fprintf (stderr, "%s: failed: passed a NULL string\n", __func__);
4187     return -1;
4188   }
4189   if (!*str || isspace (*str)) {
4190     fprintf (stderr, "%s: failed: passed a empty string or one beginning with whitespace\n", __func__);
4191     return -1;
4192   }
4193   tok = str;
4194   if (!tok) {
4195     fprintf (stderr, "%s: failed: string finished early, around token %s\n", __func__, "vg_name");
4196     return -1;
4197   }