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   const char *device;
  41   const 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   const 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   const 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   const 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   const 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   const 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   const 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   const char *name;
 386   const 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   const char *name;
 414   const char *expr;
 415   const 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   const 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   const char *path;
 470   const 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   const char *path;
 496   const 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   const 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   const char *src;
 550   const 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   const 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   const 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   const 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   const 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   const 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   const 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   const 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   const 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   const 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   const 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   const 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   const 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   const 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   const 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   const char *logvol;
 967   const 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   const char *fstype;
 995   const 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   const 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   const char *path;
1060   const 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   const 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   const 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   const 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   const 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   const 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   const 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   const 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   const 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   const 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   const 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   const 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   const 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   const 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   const 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   const 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   const 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   const 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   const 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   const char *csumtype;
1660   const 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   const 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   const 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   const 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   const 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   const char *device;
1785   const 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   const char *options;
1811   const char *device;
1812   const 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   const char *options;
1839   const char *vfstype;
1840   const char *device;
1841   const 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   const 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   const 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   const 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   const 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   const char *device;
1977   const 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   const 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   const char *device;
2030   const 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   const 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   const char *fstype;
2083   const 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   const 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   const char *root;
2135   const 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   const char *src;
2161   const 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   const char *src;
2187   const 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   const char *src;
2213   const 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   const char *file1;
2292   const 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   const 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   const char *encoding;
2348   const 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   const 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   const 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   const 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   const char *device;
2453   int n;
2454   int cyls;
2455   int heads;
2456   int sectors;
2457   const 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   n = args.n;
2467   cyls = args.cyls;
2468   heads = args.heads;
2469   sectors = args.sectors;
2470   line = args.line;
2471
2472   r = do_sfdisk_N (device, n, 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   const 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   const 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   const 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   const 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   const 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   const 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   const 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   const 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 void dispatch_incoming_message (XDR *xdr_in)
2775 {
2776   switch (proc_nr) {
2777     case GUESTFS_PROC_MOUNT:
2778       mount_stub (xdr_in);
2779       break;
2780     case GUESTFS_PROC_SYNC:
2781       sync_stub (xdr_in);
2782       break;
2783     case GUESTFS_PROC_TOUCH:
2784       touch_stub (xdr_in);
2785       break;
2786     case GUESTFS_PROC_CAT:
2787       cat_stub (xdr_in);
2788       break;
2789     case GUESTFS_PROC_LL:
2790       ll_stub (xdr_in);
2791       break;
2792     case GUESTFS_PROC_LS:
2793       ls_stub (xdr_in);
2794       break;
2795     case GUESTFS_PROC_LIST_DEVICES:
2796       list_devices_stub (xdr_in);
2797       break;
2798     case GUESTFS_PROC_LIST_PARTITIONS:
2799       list_partitions_stub (xdr_in);
2800       break;
2801     case GUESTFS_PROC_PVS:
2802       pvs_stub (xdr_in);
2803       break;
2804     case GUESTFS_PROC_VGS:
2805       vgs_stub (xdr_in);
2806       break;
2807     case GUESTFS_PROC_LVS:
2808       lvs_stub (xdr_in);
2809       break;
2810     case GUESTFS_PROC_PVS_FULL:
2811       pvs_full_stub (xdr_in);
2812       break;
2813     case GUESTFS_PROC_VGS_FULL:
2814       vgs_full_stub (xdr_in);
2815       break;
2816     case GUESTFS_PROC_LVS_FULL:
2817       lvs_full_stub (xdr_in);
2818       break;
2819     case GUESTFS_PROC_READ_LINES:
2820       read_lines_stub (xdr_in);
2821       break;
2822     case GUESTFS_PROC_AUG_INIT:
2823       aug_init_stub (xdr_in);
2824       break;
2825     case GUESTFS_PROC_AUG_CLOSE:
2826       aug_close_stub (xdr_in);
2827       break;
2828     case GUESTFS_PROC_AUG_DEFVAR:
2829       aug_defvar_stub (xdr_in);
2830       break;
2831     case GUESTFS_PROC_AUG_DEFNODE:
2832       aug_defnode_stub (xdr_in);
2833       break;
2834     case GUESTFS_PROC_AUG_GET:
2835       aug_get_stub (xdr_in);
2836       break;
2837     case GUESTFS_PROC_AUG_SET:
2838       aug_set_stub (xdr_in);
2839       break;
2840     case GUESTFS_PROC_AUG_INSERT:
2841       aug_insert_stub (xdr_in);
2842       break;
2843     case GUESTFS_PROC_AUG_RM:
2844       aug_rm_stub (xdr_in);
2845       break;
2846     case GUESTFS_PROC_AUG_MV:
2847       aug_mv_stub (xdr_in);
2848       break;
2849     case GUESTFS_PROC_AUG_MATCH:
2850       aug_match_stub (xdr_in);
2851       break;
2852     case GUESTFS_PROC_AUG_SAVE:
2853       aug_save_stub (xdr_in);
2854       break;
2855     case GUESTFS_PROC_AUG_LOAD:
2856       aug_load_stub (xdr_in);
2857       break;
2858     case GUESTFS_PROC_AUG_LS:
2859       aug_ls_stub (xdr_in);
2860       break;
2861     case GUESTFS_PROC_RM:
2862       rm_stub (xdr_in);
2863       break;
2864     case GUESTFS_PROC_RMDIR:
2865       rmdir_stub (xdr_in);
2866       break;
2867     case GUESTFS_PROC_RM_RF:
2868       rm_rf_stub (xdr_in);
2869       break;
2870     case GUESTFS_PROC_MKDIR:
2871       mkdir_stub (xdr_in);
2872       break;
2873     case GUESTFS_PROC_MKDIR_P:
2874       mkdir_p_stub (xdr_in);
2875       break;
2876     case GUESTFS_PROC_CHMOD:
2877       chmod_stub (xdr_in);
2878       break;
2879     case GUESTFS_PROC_CHOWN:
2880       chown_stub (xdr_in);
2881       break;
2882     case GUESTFS_PROC_EXISTS:
2883       exists_stub (xdr_in);
2884       break;
2885     case GUESTFS_PROC_IS_FILE:
2886       is_file_stub (xdr_in);
2887       break;
2888     case GUESTFS_PROC_IS_DIR:
2889       is_dir_stub (xdr_in);
2890       break;
2891     case GUESTFS_PROC_PVCREATE:
2892       pvcreate_stub (xdr_in);
2893       break;
2894     case GUESTFS_PROC_VGCREATE:
2895       vgcreate_stub (xdr_in);
2896       break;
2897     case GUESTFS_PROC_LVCREATE:
2898       lvcreate_stub (xdr_in);
2899       break;
2900     case GUESTFS_PROC_MKFS:
2901       mkfs_stub (xdr_in);
2902       break;
2903     case GUESTFS_PROC_SFDISK:
2904       sfdisk_stub (xdr_in);
2905       break;
2906     case GUESTFS_PROC_WRITE_FILE:
2907       write_file_stub (xdr_in);
2908       break;
2909     case GUESTFS_PROC_UMOUNT:
2910       umount_stub (xdr_in);
2911       break;
2912     case GUESTFS_PROC_MOUNTS:
2913       mounts_stub (xdr_in);
2914       break;
2915     case GUESTFS_PROC_UMOUNT_ALL:
2916       umount_all_stub (xdr_in);
2917       break;
2918     case GUESTFS_PROC_LVM_REMOVE_ALL:
2919       lvm_remove_all_stub (xdr_in);
2920       break;
2921     case GUESTFS_PROC_FILE:
2922       file_stub (xdr_in);
2923       break;
2924     case GUESTFS_PROC_COMMAND:
2925       command_stub (xdr_in);
2926       break;
2927     case GUESTFS_PROC_COMMAND_LINES:
2928       command_lines_stub (xdr_in);
2929       break;
2930     case GUESTFS_PROC_STAT:
2931       stat_stub (xdr_in);
2932       break;
2933     case GUESTFS_PROC_LSTAT:
2934       lstat_stub (xdr_in);
2935       break;
2936     case GUESTFS_PROC_STATVFS:
2937       statvfs_stub (xdr_in);
2938       break;
2939     case GUESTFS_PROC_TUNE2FS_L:
2940       tune2fs_l_stub (xdr_in);
2941       break;
2942     case GUESTFS_PROC_BLOCKDEV_SETRO:
2943       blockdev_setro_stub (xdr_in);
2944       break;
2945     case GUESTFS_PROC_BLOCKDEV_SETRW:
2946       blockdev_setrw_stub (xdr_in);
2947       break;
2948     case GUESTFS_PROC_BLOCKDEV_GETRO:
2949       blockdev_getro_stub (xdr_in);
2950       break;
2951     case GUESTFS_PROC_BLOCKDEV_GETSS:
2952       blockdev_getss_stub (xdr_in);
2953       break;
2954     case GUESTFS_PROC_BLOCKDEV_GETBSZ:
2955       blockdev_getbsz_stub (xdr_in);
2956       break;
2957     case GUESTFS_PROC_BLOCKDEV_SETBSZ:
2958       blockdev_setbsz_stub (xdr_in);
2959       break;
2960     case GUESTFS_PROC_BLOCKDEV_GETSZ:
2961       blockdev_getsz_stub (xdr_in);
2962       break;
2963     case GUESTFS_PROC_BLOCKDEV_GETSIZE64:
2964       blockdev_getsize64_stub (xdr_in);
2965       break;
2966     case GUESTFS_PROC_BLOCKDEV_FLUSHBUFS:
2967       blockdev_flushbufs_stub (xdr_in);
2968       break;
2969     case GUESTFS_PROC_BLOCKDEV_REREADPT:
2970       blockdev_rereadpt_stub (xdr_in);
2971       break;
2972     case GUESTFS_PROC_UPLOAD:
2973       upload_stub (xdr_in);
2974       break;
2975     case GUESTFS_PROC_DOWNLOAD:
2976       download_stub (xdr_in);
2977       break;
2978     case GUESTFS_PROC_CHECKSUM:
2979       checksum_stub (xdr_in);
2980       break;
2981     case GUESTFS_PROC_TAR_IN:
2982       tar_in_stub (xdr_in);
2983       break;
2984     case GUESTFS_PROC_TAR_OUT:
2985       tar_out_stub (xdr_in);
2986       break;
2987     case GUESTFS_PROC_TGZ_IN:
2988       tgz_in_stub (xdr_in);
2989       break;
2990     case GUESTFS_PROC_TGZ_OUT:
2991       tgz_out_stub (xdr_in);
2992       break;
2993     case GUESTFS_PROC_MOUNT_RO:
2994       mount_ro_stub (xdr_in);
2995       break;
2996     case GUESTFS_PROC_MOUNT_OPTIONS:
2997       mount_options_stub (xdr_in);
2998       break;
2999     case GUESTFS_PROC_MOUNT_VFS:
3000       mount_vfs_stub (xdr_in);
3001       break;
3002     case GUESTFS_PROC_DEBUG:
3003       debug_stub (xdr_in);
3004       break;
3005     case GUESTFS_PROC_LVREMOVE:
3006       lvremove_stub (xdr_in);
3007       break;
3008     case GUESTFS_PROC_VGREMOVE:
3009       vgremove_stub (xdr_in);
3010       break;
3011     case GUESTFS_PROC_PVREMOVE:
3012       pvremove_stub (xdr_in);
3013       break;
3014     case GUESTFS_PROC_SET_E2LABEL:
3015       set_e2label_stub (xdr_in);
3016       break;
3017     case GUESTFS_PROC_GET_E2LABEL:
3018       get_e2label_stub (xdr_in);
3019       break;
3020     case GUESTFS_PROC_SET_E2UUID:
3021       set_e2uuid_stub (xdr_in);
3022       break;
3023     case GUESTFS_PROC_GET_E2UUID:
3024       get_e2uuid_stub (xdr_in);
3025       break;
3026     case GUESTFS_PROC_FSCK:
3027       fsck_stub (xdr_in);
3028       break;
3029     case GUESTFS_PROC_ZERO:
3030       zero_stub (xdr_in);
3031       break;
3032     case GUESTFS_PROC_GRUB_INSTALL:
3033       grub_install_stub (xdr_in);
3034       break;
3035     case GUESTFS_PROC_CP:
3036       cp_stub (xdr_in);
3037       break;
3038     case GUESTFS_PROC_CP_A:
3039       cp_a_stub (xdr_in);
3040       break;
3041     case GUESTFS_PROC_MV:
3042       mv_stub (xdr_in);
3043       break;
3044     case GUESTFS_PROC_DROP_CACHES:
3045       drop_caches_stub (xdr_in);
3046       break;
3047     case GUESTFS_PROC_DMESG:
3048       dmesg_stub (xdr_in);
3049       break;
3050     case GUESTFS_PROC_PING_DAEMON:
3051       ping_daemon_stub (xdr_in);
3052       break;
3053     case GUESTFS_PROC_EQUAL:
3054       equal_stub (xdr_in);
3055       break;
3056     case GUESTFS_PROC_STRINGS:
3057       strings_stub (xdr_in);
3058       break;
3059     case GUESTFS_PROC_STRINGS_E:
3060       strings_e_stub (xdr_in);
3061       break;
3062     case GUESTFS_PROC_HEXDUMP:
3063       hexdump_stub (xdr_in);
3064       break;
3065     case GUESTFS_PROC_ZEROFREE:
3066       zerofree_stub (xdr_in);
3067       break;
3068     case GUESTFS_PROC_PVRESIZE:
3069       pvresize_stub (xdr_in);
3070       break;
3071     case GUESTFS_PROC_SFDISK_N:
3072       sfdisk_N_stub (xdr_in);
3073       break;
3074     case GUESTFS_PROC_SFDISK_L:
3075       sfdisk_l_stub (xdr_in);
3076       break;
3077     case GUESTFS_PROC_SFDISK_KERNEL_GEOMETRY:
3078       sfdisk_kernel_geometry_stub (xdr_in);
3079       break;
3080     case GUESTFS_PROC_SFDISK_DISK_GEOMETRY:
3081       sfdisk_disk_geometry_stub (xdr_in);
3082       break;
3083     case GUESTFS_PROC_VG_ACTIVATE_ALL:
3084       vg_activate_all_stub (xdr_in);
3085       break;
3086     case GUESTFS_PROC_VG_ACTIVATE:
3087       vg_activate_stub (xdr_in);
3088       break;
3089     case GUESTFS_PROC_LVRESIZE:
3090       lvresize_stub (xdr_in);
3091       break;
3092     case GUESTFS_PROC_RESIZE2FS:
3093       resize2fs_stub (xdr_in);
3094       break;
3095     case GUESTFS_PROC_FIND:
3096       find_stub (xdr_in);
3097       break;
3098     case GUESTFS_PROC_E2FSCK_F:
3099       e2fsck_f_stub (xdr_in);
3100       break;
3101     case GUESTFS_PROC_SLEEP:
3102       sleep_stub (xdr_in);
3103       break;
3104     case GUESTFS_PROC_NTFS_3G_PROBE:
3105       ntfs_3g_probe_stub (xdr_in);
3106       break;
3107     default:
3108       reply_with_error ("dispatch_incoming_message: unknown procedure number %d", proc_nr);
3109   }
3110 }
3111
3112 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";
3113
3114 static int lvm_tokenize_pv (char *str, struct guestfs_lvm_int_pv *r)
3115 {
3116   char *tok, *p, *next;
3117   int i, j;
3118
3119   if (!str) {
3120     fprintf (stderr, "%s: failed: passed a NULL string\n", __func__);
3121     return -1;
3122   }
3123   if (!*str || isspace (*str)) {
3124     fprintf (stderr, "%s: failed: passed a empty string or one beginning with whitespace\n", __func__);
3125     return -1;
3126   }
3127   tok = str;
3128   if (!tok) {
3129     fprintf (stderr, "%s: failed: string finished early, around token %s\n", __func__, "pv_name");
3130     return -1;
3131   }
3132   p = strchrnul (tok, ',');
3133   if (*p) next = p+1; else next = NULL;
3134   *p = '\0';
3135   r->pv_name = strdup (tok);
3136   if (r->pv_name == NULL) {
3137     perror ("strdup");
3138     return -1;
3139   }
3140   tok = next;
3141   if (!tok) {
3142     fprintf (stderr, "%s: failed: string finished early, around token %s\n", __func__, "pv_uuid");
3143     return -1;
3144   }
3145   p = strchrnul (tok, ',');
3146   if (*p) next = p+1; else next = NULL;
3147   *p = '\0';
3148   for (i = j = 0; i < 32; ++j) {
3149     if (tok[j] == '\0') {
3150       fprintf (stderr, "%s: failed to parse UUID from '%s'\n", __func__, tok);
3151       return -1;
3152     } else if (tok[j] != '-')
3153       r->pv_uuid[i++] = tok[j];
3154   }
3155   tok = next;
3156   if (!tok) {
3157     fprintf (stderr, "%s: failed: string finished early, around token %s\n", __func__, "pv_fmt");
3158     return -1;
3159   }
3160   p = strchrnul (tok, ',');
3161   if (*p) next = p+1; else next = NULL;
3162   *p = '\0';
3163   r->pv_fmt = strdup (tok);
3164   if (r->pv_fmt == NULL) {
3165     perror ("strdup");
3166     return -1;
3167   }
3168   tok = next;
3169   if (!tok) {
3170     fprintf (stderr, "%s: failed: string finished early, around token %s\n", __func__, "pv_size");
3171     return -1;
3172   }
3173   p = strchrnul (tok, ',');
3174   if (*p) next = p+1; else next = NULL;
3175   *p = '\0';
3176   if (sscanf (tok, "%"SCNu64, &r->pv_size) != 1) {
3177     fprintf (stderr, "%s: failed to parse size '%s' from token %s\n", __func__, tok, "pv_size");
3178     return -1;
3179   }
3180   tok = next;
3181   if (!tok) {
3182     fprintf (stderr, "%s: failed: string finished early, around token %s\n", __func__, "dev_size");
3183     return -1;
3184   }
3185   p = strchrnul (tok, ',');
3186   if (*p) next = p+1; else next = NULL;
3187   *p = '\0';
3188   if (sscanf (tok, "%"SCNu64, &r->dev_size) != 1) {
3189     fprintf (stderr, "%s: failed to parse size '%s' from token %s\n", __func__, tok, "dev_size");
3190     return -1;
3191   }
3192   tok = next;
3193   if (!tok) {
3194     fprintf (stderr, "%s: failed: string finished early, around token %s\n", __func__, "pv_free");
3195     return -1;
3196   }
3197   p = strchrnul (tok, ',');
3198   if (*p) next = p+1; else next = NULL;
3199   *p = '\0';
3200   if (sscanf (tok, "%"SCNu64, &r->pv_free) != 1) {
3201     fprintf (stderr, "%s: failed to parse size '%s' from token %s\n", __func__, tok, "pv_free");
3202     return -1;
3203   }
3204   tok = next;
3205   if (!tok) {
3206     fprintf (stderr, "%s: failed: string finished early, around token %s\n", __func__, "pv_used");
3207     return -1;
3208   }
3209   p = strchrnul (tok, ',');
3210   if (*p) next = p+1; else next = NULL;
3211   *p = '\0';
3212   if (sscanf (tok, "%"SCNu64, &r->pv_used) != 1) {
3213     fprintf (stderr, "%s: failed to parse size '%s' from token %s\n", __func__, tok, "pv_used");
3214     return -1;
3215   }
3216   tok = next;
3217   if (!tok) {
3218     fprintf (stderr, "%s: failed: string finished early, around token %s\n", __func__, "pv_attr");
3219     return -1;
3220   }
3221   p = strchrnul (tok, ',');
3222   if (*p) next = p+1; else next = NULL;
3223   *p = '\0';
3224   r->pv_attr = strdup (tok);
3225   if (r->pv_attr == NULL) {
3226     perror ("strdup");
3227     return -1;
3228   }
3229   tok = next;
3230   if (!tok) {
3231     fprintf (stderr, "%s: failed: string finished early, around token %s\n", __func__, "pv_pe_count");
3232     return -1;
3233   }
3234   p = strchrnul (tok, ',');
3235   if (*p) next = p+1; else next = NULL;
3236   *p = '\0';
3237   if (sscanf (tok, "%"SCNi64, &r->pv_pe_count) != 1) {
3238     fprintf (stderr, "%s: failed to parse int '%s' from token %s\n", __func__, tok, "pv_pe_count");
3239     return -1;
3240   }
3241   tok = next;
3242   if (!tok) {
3243     fprintf (stderr, "%s: failed: string finished early, around token %s\n", __func__, "pv_pe_alloc_count");
3244     return -1;
3245   }
3246   p = strchrnul (tok, ',');
3247   if (*p) next = p+1; else next = NULL;
3248   *p = '\0';
3249   if (sscanf (tok, "%"SCNi64, &r->pv_pe_alloc_count) != 1) {
3250     fprintf (stderr, "%s: failed to parse int '%s' from token %s\n", __func__, tok, "pv_pe_alloc_count");
3251     return -1;
3252   }
3253   tok = next;
3254   if (!tok) {
3255     fprintf (stderr, "%s: failed: string finished early, around token %s\n", __func__, "pv_tags");
3256     return -1;
3257   }
3258   p = strchrnul (tok, ',');
3259   if (*p) next = p+1; else next = NULL;
3260   *p = '\0';
3261   r->pv_tags = strdup (tok);
3262   if (r->pv_tags == NULL) {
3263     perror ("strdup");
3264     return -1;
3265   }
3266   tok = next;
3267   if (!tok) {
3268     fprintf (stderr, "%s: failed: string finished early, around token %s\n", __func__, "pe_start");
3269     return -1;
3270   }
3271   p = strchrnul (tok, ',');
3272   if (*p) next = p+1; else next = NULL;
3273   *p = '\0';
3274   if (sscanf (tok, "%"SCNu64, &r->pe_start) != 1) {
3275     fprintf (stderr, "%s: failed to parse size '%s' from token %s\n", __func__, tok, "pe_start");
3276     return -1;
3277   }
3278   tok = next;
3279   if (!tok) {
3280     fprintf (stderr, "%s: failed: string finished early, around token %s\n", __func__, "pv_mda_count");
3281     return -1;
3282   }
3283   p = strchrnul (tok, ',');
3284   if (*p) next = p+1; else next = NULL;
3285   *p = '\0';
3286   if (sscanf (tok, "%"SCNi64, &r->pv_mda_count) != 1) {
3287     fprintf (stderr, "%s: failed to parse int '%s' from token %s\n", __func__, tok, "pv_mda_count");
3288     return -1;
3289   }
3290   tok = next;
3291   if (!tok) {
3292     fprintf (stderr, "%s: failed: string finished early, around token %s\n", __func__, "pv_mda_free");
3293     return -1;
3294   }
3295   p = strchrnul (tok, ',');
3296   if (*p) next = p+1; else next = NULL;
3297   *p = '\0';
3298   if (sscanf (tok, "%"SCNu64, &r->pv_mda_free) != 1) {
3299     fprintf (stderr, "%s: failed to parse size '%s' from token %s\n", __func__, tok, "pv_mda_free");
3300     return -1;
3301   }
3302   tok = next;
3303   if (tok != NULL) {
3304     fprintf (stderr, "%s: failed: extra tokens at end of string\n", __func__);
3305     return -1;
3306   }
3307   return 0;
3308 }
3309
3310 guestfs_lvm_int_pv_list *
3311 parse_command_line_pvs (void)
3312 {
3313   char *out, *err;
3314   char *p, *pend;
3315   int r, i;
3316   guestfs_lvm_int_pv_list *ret;
3317   void *newp;
3318
3319   ret = malloc (sizeof *ret);
3320   if (!ret) {
3321     reply_with_perror ("malloc");
3322     return NULL;
3323   }
3324
3325   ret->guestfs_lvm_int_pv_list_len = 0;
3326   ret->guestfs_lvm_int_pv_list_val = NULL;
3327
3328   r = command (&out, &err,
3329                "/sbin/lvm", "pvs",
3330                "-o", lvm_pv_cols, "--unbuffered", "--noheadings",
3331                "--nosuffix", "--separator", ",", "--units", "b", NULL);
3332   if (r == -1) {
3333     reply_with_error ("%s", err);
3334     free (out);
3335     free (err);
3336     free (ret);
3337     return NULL;
3338   }
3339
3340   free (err);
3341
3342   /* Tokenize each line of the output. */
3343   p = out;
3344   i = 0;
3345   while (p) {
3346     pend = strchr (p, '\n');    /* Get the next line of output. */
3347     if (pend) {
3348       *pend = '\0';
3349       pend++;
3350     }
3351
3352     while (*p && isspace (*p))  /* Skip any leading whitespace. */
3353       p++;
3354
3355     if (!*p) {                  /* Empty line?  Skip it. */
3356       p = pend;
3357       continue;
3358     }
3359
3360     /* Allocate some space to store this next entry. */
3361     newp = realloc (ret->guestfs_lvm_int_pv_list_val,
3362                     sizeof (guestfs_lvm_int_pv) * (i+1));
3363     if (newp == NULL) {
3364       reply_with_perror ("realloc");
3365       free (ret->guestfs_lvm_int_pv_list_val);
3366       free (ret);
3367       free (out);
3368       return NULL;
3369     }
3370     ret->guestfs_lvm_int_pv_list_val = newp;
3371
3372     /* Tokenize the next entry. */
3373     r = lvm_tokenize_pv (p, &ret->guestfs_lvm_int_pv_list_val[i]);
3374     if (r == -1) {
3375       reply_with_error ("failed to parse output of 'pvs' command");
3376       free (ret->guestfs_lvm_int_pv_list_val);
3377       free (ret);
3378       free (out);
3379       return NULL;
3380     }
3381
3382     ++i;
3383     p = pend;
3384   }
3385
3386   ret->guestfs_lvm_int_pv_list_len = i;
3387
3388   free (out);
3389   return ret;
3390 }
3391 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";
3392
3393 static int lvm_tokenize_vg (char *str, struct guestfs_lvm_int_vg *r)
3394 {
3395   char *tok, *p, *next;
3396   int i, j;
3397
3398   if (!str) {
3399     fprintf (stderr, "%s: failed: passed a NULL string\n", __func__);
3400     return -1;
3401   }
3402   if (!*str || isspace (*str)) {
3403     fprintf (stderr, "%s: failed: passed a empty string or one beginning with whitespace\n", __func__);
3404     return -1;
3405   }
3406   tok = str;
3407   if (!tok) {
3408     fprintf (stderr, "%s: failed: string finished early, around token %s\n", __func__, "vg_name");
3409     return -1;
3410   }
3411   p = strchrnul (tok, ',');
3412   if (*p) next = p+1; else next = NULL;
3413   *p = '\0';
3414   r->vg_name = strdup (tok);
3415   if (r->vg_name == NULL) {
3416     perror ("strdup");
3417     return -1;
3418   }
3419   tok = next;
3420   if (!tok) {
3421     fprintf (stderr, "%s: failed: string finished early, around token %s\n", __func__, "vg_uuid");
3422     return -1;
3423   }
3424   p = strchrnul (tok, ',');
3425   if (*p) next = p+1; else next = NULL;
3426   *p = '\0';
3427   for (i = j = 0; i < 32; ++j) {
3428     if (tok[j] == '\0') {
3429       fprintf (stderr, "%s: failed to parse UUID from '%s'\n", __func__, tok);
3430       return -1;
3431     } else if (tok[j] != '-')
3432       r->vg_uuid[i++] = tok[j];
3433   }
3434   tok = next;
3435   if (!tok) {
3436     fprintf (stderr, "%s: failed: string finished early, around token %s\n", __func__, "vg_fmt");
3437     return -1;
3438   }
3439   p = strchrnul (tok, ',');
3440   if (*p) next = p+1; else next = NULL;
3441   *p = '\0';
3442   r->vg_fmt = strdup (tok);
3443   if (r->vg_fmt == NULL) {
3444     perror ("strdup");
3445     return -1;
3446   }
3447   tok = next;
3448   if (!tok) {
3449     fprintf (stderr, "%s: failed: string finished early, around token %s\n", __func__, "vg_attr");
3450     return -1;
3451   }
3452   p = strchrnul (tok, ',');
3453   if (*p) next = p+1; else next = NULL;
3454   *p = '\0';
3455   r->vg_attr = strdup (tok);
3456   if (r->vg_attr == NULL) {
3457     perror ("strdup");
3458     return -1;
3459   }
3460   tok = next;
3461   if (!tok) {
3462     fprintf (stderr, "%s: failed: string finished early, around token %s\n", __func__, "vg_size");
3463     return -1;
3464   }
3465   p = strchrnul (tok, ',');
3466   if (*p) next = p+1; else next = NULL;
3467   *p = '\0';
3468   if (sscanf (tok, "%"SCNu64, &r->vg_size) != 1) {
3469     fprintf (stderr, "%s: failed to parse size '%s' from token %s\n", __func__, tok, "vg_size");
3470     return -1;
3471   }
3472   tok = next;
3473   if (!tok) {
3474     fprintf (stderr, "%s: failed: string finished early, around token %s\n", __func__, "vg_free");
3475     return -1;
3476   }
3477   p = strchrnul (tok, ',');
3478   if (*p) next = p+1; else next = NULL;
3479   *p = '\0';
3480   if (sscanf (tok, "%"SCNu64, &r->vg_free) != 1) {
3481     fprintf (stderr, "%s: failed to parse size '%s' from token %s\n", __func__, tok, "vg_free");
3482     return -1;
3483   }
3484   tok = next;
3485   if (!tok) {
3486     fprintf (stderr, "%s: failed: string finished early, around token %s\n", __func__, "vg_sysid");
3487     return -1;
3488   }
3489   p = strchrnul (tok, ',');
3490   if (*p) next = p+1; else next = NULL;
3491   *p = '\0';
3492   r->vg_sysid = strdup (tok);
3493   if (r->vg_sysid == NULL) {
3494     perror ("strdup");
3495     return -1;
3496   }
3497   tok = next;
3498   if (!tok) {
3499     fprintf (stderr, "%s: failed: string finished early, around token %s\n", __func__, "vg_extent_size");
3500     return -1;
3501   }
3502   p = strchrnul (tok, ',');
3503   if (*p) next = p+1; else next = NULL;
3504   *p = '\0';
3505   if (sscanf (tok, "%"SCNu64, &r->vg_extent_size) != 1) {
3506     fprintf (stderr, "%s: failed to parse size '%s' from token %s\n", __func__, tok, "vg_extent_size");
3507     return -1;
3508   }
3509   tok = next;
3510   if (!tok) {
3511     fprintf (stderr, "%s: failed: string finished early, around token %s\n", __func__, "vg_extent_count");
3512     return -1;
3513   }
3514   p = strchrnul (tok, ',');
3515   if (*p) next = p+1; else next = NULL;
3516   *p = '\0';
3517   if (sscanf (tok, "%"SCNi64, &r->vg_extent_count) != 1) {
3518     fprintf (stderr, "%s: failed to parse int '%s' from token %s\n", __func__, tok, "vg_extent_count");
3519     return -1;
3520   }
3521   tok = next;
3522   if (!tok) {
3523     fprintf (stderr, "%s: failed: string finished early, around token %s\n", __func__, "vg_free_count");
3524     return -1;
3525   }
3526   p = strchrnul (tok, ',');
3527   if (*p) next = p+1; else next = NULL;
3528   *p = '\0';
3529   if (sscanf (tok, "%"SCNi64, &r->vg_free_count) != 1) {
3530     fprintf (stderr, "%s: failed to parse int '%s' from token %s\n", __func__, tok, "vg_free_count");
3531     return -1;
3532   }
3533   tok = next;
3534   if (!tok) {
3535     fprintf (stderr, "%s: failed: string finished early, around token %s\n", __func__, "max_lv");
3536     return -1;
3537   }
3538   p = strchrnul (tok, ',');
3539   if (*p) next = p+1; else next = NULL;
3540   *p = '\0';
3541   if (sscanf (tok, "%"SCNi64, &r->max_lv) != 1) {
3542     fprintf (stderr, "%s: failed to parse int '%s' from token %s\n", __func__, tok, "max_lv");
3543     return -1;
3544   }
3545   tok = next;
3546   if (!tok) {
3547     fprintf (stderr, "%s: failed: string finished early, around token %s\n", __func__, "max_pv");
3548     return -1;
3549   }
3550   p = strchrnul (tok, ',');
3551   if (*p) next = p+1; else next = NULL;
3552   *p = '\0';
3553   if (sscanf (tok, "%"SCNi64, &r->max_pv) != 1) {
3554     fprintf (stderr, "%s: failed to parse int '%s' from token %s\n", __func__, tok, "max_pv");
3555     return -1;
3556   }
3557   tok = next;
3558   if (!tok) {
3559     fprintf (stderr, "%s: failed: string finished early, around token %s\n", __func__, "pv_count");
3560     return -1;
3561   }
3562   p = strchrnul (tok, ',');
3563   if (*p) next = p+1; else next = NULL;
3564   *p = '\0';
3565   if (sscanf (tok, "%"SCNi64, &r->pv_count) != 1) {
3566     fprintf (stderr, "%s: failed to parse int '%s' from token %s\n", __func__, tok, "pv_count");
3567     return -1;
3568   }
3569   tok = next;
3570   if (!tok) {
3571     fprintf (stderr, "%s: failed: string finished early, around token %s\n", __func__, "lv_count");
3572     return -1;
3573   }
3574   p = strchrnul (tok, ',');
3575   if (*p) next = p+1; else next = NULL;
3576   *p = '\0';
3577   if (sscanf (tok, "%"SCNi64, &r->lv_count) != 1) {
3578     fprintf (stderr, "%s: failed to parse int '%s' from token %s\n", __func__, tok, "lv_count");
3579     return -1;
3580   }
3581   tok = next;
3582   if (!tok) {
3583     fprintf (stderr, "%s: failed: string finished early, around token %s\n", __func__, "snap_count");
3584     return -1;
3585   }
3586   p = strchrnul (tok, ',');
3587   if (*p) next = p+1; else next = NULL;
3588   *p = '\0';
3589   if (sscanf (tok, "%"SCNi64, &r->snap_count) != 1) {
3590     fprintf (stderr, "%s: failed to parse int '%s' from token %s\n", __func__, tok, "snap_count");
3591     return -1;
3592   }
3593   tok = next;
3594   if (!tok) {
3595     fprintf (stderr, "%s: failed: string finished early, around token %s\n", __func__, "vg_seqno");
3596     return -1;
3597   }
3598   p = strchrnul (tok, ',');
3599   if (*p) next = p+1; else next = NULL;
3600   *p = '\0';
3601   if (sscanf (tok, "%"SCNi64, &r->vg_seqno) != 1) {
3602     fprintf (stderr, "%s: failed to parse int '%s' from token %s\n", __func__, tok, "vg_seqno");
3603     return -1;
3604   }
3605   tok = next;
3606   if (!tok) {
3607     fprintf (stderr, "%s: failed: string finished early, around token %s\n", __func__, "vg_tags");
3608     return -1;
3609   }
3610   p = strchrnul (tok, ',');
3611   if (*p) next = p+1; else next = NULL;
3612   *p = '\0';
3613   r->vg_tags = strdup (tok);
3614   if (r->vg_tags == NULL) {
3615     perror ("strdup");
3616     return -1;
3617   }
3618   tok = next;
3619   if (!tok) {
3620     fprintf (stderr, "%s: failed: string finished early, around token %s\n", __func__, "vg_mda_count");
3621     return -1;
3622   }
3623   p = strchrnul (tok, ',');
3624   if (*p) next = p+1; else next = NULL;
3625   *p = '\0';
3626   if (sscanf (tok, "%"SCNi64, &r->vg_mda_count) != 1) {
3627     fprintf (stderr, "%s: failed to parse int '%s' from token %s\n", __func__, tok, "vg_mda_count");
3628     return -1;
3629   }
3630   tok = next;
3631   if (!tok) {
3632     fprintf (stderr, "%s: failed: string finished early, around token %s\n", __func__, "vg_mda_free");
3633     return -1;
3634   }
3635   p = strchrnul (tok, ',');
3636   if (*p) next = p+1; else next = NULL;
3637   *p = '\0';
3638   if (sscanf (tok, "%"SCNu64, &r->vg_mda_free) != 1) {
3639     fprintf (stderr, "%s: failed to parse size '%s' from token %s\n", __func__, tok, "vg_mda_free");
3640     return -1;
3641   }
3642   tok = next;
3643   if (tok != NULL) {
3644     fprintf (stderr, "%s: failed: extra tokens at end of string\n", __func__);
3645     return -1;
3646   }
3647   return 0;
3648 }
3649
3650 guestfs_lvm_int_vg_list *
3651 parse_command_line_vgs (void)
3652 {
3653   char *out, *err;
3654   char *p, *pend;
3655   int r, i;
3656   guestfs_lvm_int_vg_list *ret;
3657   void *newp;
3658
3659   ret = malloc (sizeof *ret);
3660   if (!ret) {
3661     reply_with_perror ("malloc");
3662     return NULL;
3663   }
3664
3665   ret->guestfs_lvm_int_vg_list_len = 0;
3666   ret->guestfs_lvm_int_vg_list_val = NULL;
3667
3668   r = command (&out, &err,
3669                "/sbin/lvm", "vgs",
3670                "-o", lvm_vg_cols, "--unbuffered", "--noheadings",
3671                "--nosuffix", "--separator", ",", "--units", "b", NULL);
3672   if (r == -1) {
3673     reply_with_error ("%s", err);
3674     free (out);
3675     free (err);
3676     free (ret);
3677     return NULL;
3678   }
3679
3680   free (err);
3681
3682   /* Tokenize each line of the output. */
3683   p = out;
3684   i = 0;
3685   while (p) {
3686     pend = strchr (p, '\n');    /* Get the next line of output. */
3687     if (pend) {
3688       *pend = '\0';
3689       pend++;
3690     }
3691
3692     while (*p && isspace (*p))  /* Skip any leading whitespace. */
3693       p++;
3694
3695     if (!*p) {                  /* Empty line?  Skip it. */
3696       p = pend;
3697       continue;
3698     }
3699
3700     /* Allocate some space to store this next entry. */
3701     newp = realloc (ret->guestfs_lvm_int_vg_list_val,
3702                     sizeof (guestfs_lvm_int_vg) * (i+1));
3703     if (newp == NULL) {
3704       reply_with_perror ("realloc");
3705       free (ret->guestfs_lvm_int_vg_list_val);
3706       free (ret);
3707       free (out);
3708       return NULL;
3709     }
3710     ret->guestfs_lvm_int_vg_list_val = newp;
3711
3712     /* Tokenize the next entry. */
3713     r = lvm_tokenize_vg (p, &ret->guestfs_lvm_int_vg_list_val[i]);
3714     if (r == -1) {
3715       reply_with_error ("failed to parse output of 'vgs' command");
3716       free (ret->guestfs_lvm_int_vg_list_val);
3717       free (ret);
3718       free (out);
3719       return NULL;
3720     }
3721
3722     ++i;
3723     p = pend;
3724   }
3725
3726   ret->guestfs_lvm_int_vg_list_len = i;
3727
3728   free (out);
3729   return ret;
3730 }
3731 static const char *lvm_lv_cols = "lv_name,lv_uuid,lv_attr,lv_major,lv_minor,lv_kernel_major,lv_kernel_minor,lv_size,seg_count,origin,snap_percent,copy_percent,move_pv,lv_tags,mirror_log,modules";
3732
3733 static int lvm_tokenize_lv (char *str, struct guestfs_lvm_int_lv *r)
3734 {
3735   char *tok, *p, *next;
3736   int i, j;
3737
3738   if (!str) {
3739     fprintf (stderr, "%s: failed: passed a NULL string\n", __func__);
3740     return -1;
3741   }
3742   if (!*str || isspace (*str)) {
3743     fprintf (stderr, "%s: failed: passed a empty string or one beginning with whitespace\n", __func__);
3744     return -1;
3745   }
3746   tok = str;
3747   if (!tok) {
3748     fprintf (stderr, "%s: failed: string finished early, around token %s\n", __func__, "lv_name");
3749     return -1;
3750   }
3751   p = strchrnul (tok, ',');
3752   if (*p) next = p+1; else next = NULL;
3753   *p = '\0';
3754   r->lv_name = strdup (tok);
3755   if (r->lv_name == NULL) {
3756     perror ("strdup");
3757     return -1;
3758   }
3759   tok = next;
3760   if (!tok) {
3761     fprintf (stderr, "%s: failed: string finished early, around token %s\n", __func__, "lv_uuid");
3762     return -1;
3763   }
3764   p = strchrnul (tok, ',');
3765   if (*p) next = p+1; else next = NULL;
3766   *p = '\0';
3767   for (i = j = 0; i < 32; ++j) {
3768     if (tok[j] == '\0') {
3769       fprintf (stderr, "%s: failed to parse UUID from '%s'\n", __func__, tok);
3770       return -1;
3771     } else if (tok[j] != '-')
3772       r->lv_uuid[i++] = tok[j];
3773   }
3774   tok = next;
3775   if (!tok) {
3776     fprintf (stderr, "%s: failed: string finished early, around token %s\n", __func__, "lv_attr");
3777     return -1;
3778   }
3779   p = strchrnul (tok, ',');
3780   if (*p) next = p+1; else next = NULL;
3781   *p = '\0';
3782   r->lv_attr = strdup (tok);
3783   if (r->lv_attr == NULL) {
3784     perror ("strdup");
3785     return -1;
3786   }
3787   tok = next;
3788   if (!tok) {
3789     fprintf (stderr, "%s: failed: string finished early, around token %s\n", __func__, "lv_major");
3790     return -1;
3791   }
3792   p = strchrnul (tok, ',');
3793   if (*p) next = p+1; else next = NULL;
3794   *p = '\0';
3795   if (sscanf (tok, "%"SCNi64, &r->lv_major) != 1) {
3796     fprintf (stderr, "%s: failed to parse int '%s' from token %s\n", __func__, tok, "lv_major");
3797     return -1;
3798   }
3799   tok = next;
3800   if (!tok) {
3801     fprintf (stderr, "%s: failed: string finished early, around token %s\n", __func__, "lv_minor");
3802     return -1;
3803   }
3804   p = strchrnul (tok, ',');
3805   if (*p) next = p+1; else next = NULL;
3806   *p = '\0';
3807   if (sscanf (tok, "%"SCNi64, &r->lv_minor) != 1) {
3808     fprintf (stderr, "%s: failed to parse int '%s' from token %s\n", __func__, tok, "lv_minor");
3809     return -1;
3810   }
3811   tok = next;
3812   if (!tok) {
3813     fprintf (stderr, "%s: failed: string finished early, around token %s\n", __func__, "lv_kernel_major");
3814     return -1;
3815   }
3816   p = strchrnul (tok, ',');
3817   if (*p) next = p+1; else next = NULL;
3818   *p = '\0';
3819   if (sscanf (tok, "%"SCNi64, &r->lv_kernel_major) != 1) {
3820     fprintf (stderr, "%s: failed to parse int '%s' from token %s\n", __func__, tok, "lv_kernel_major");
3821     return -1;
3822   }
3823   tok = next;
3824   if (!tok) {
3825     fprintf (stderr, "%s: failed: string finished early, around token %s\n", __func__, "lv_kernel_minor");
3826     return -1;
3827   }
3828   p = strchrnul (tok, ',');
3829   if (*p) next = p+1; else next = NULL;
3830   *p = '\0';
3831   if (sscanf (tok, "%"SCNi64, &r->lv_kernel_minor) != 1) {
3832     fprintf (stderr, "%s: failed to parse int '%s' from token %s\n", __func__, tok, "lv_kernel_minor");
3833     return -1;
3834   }
3835   tok = next;
3836   if (!tok) {
3837     fprintf (stderr, "%s: failed: string finished early, around token %s\n", __func__, "lv_size");
3838     return -1;
3839   }
3840   p = strchrnul (tok, ',');
3841   if (*p) next = p+1; else next = NULL;
3842   *p = '\0';
3843   if (sscanf (tok, "%"SCNu64, &r->lv_size) != 1) {
3844     fprintf (stderr, "%s: failed to parse size '%s' from token %s\n", __func__, tok, "lv_size");
3845     return -1;
3846   }
3847   tok = next;
3848   if (!tok) {
3849     fprintf (stderr, "%s: failed: string finished early, around token %s\n", __func__, "seg_count");
3850     return -1;
3851   }
3852   p = strchrnul (tok, ',');
3853   if (*p) next = p+1; else next = NULL;
3854   *p = '\0';
3855   if (sscanf (tok, "%"SCNi64, &r->seg_count) != 1) {
3856     fprintf (stderr, "%s: failed to parse int '%s' from token %s\n", __func__, tok, "seg_count");
3857     return -1;
3858   }
3859   tok = next;
3860   if (!tok) {
3861     fprintf (stderr, "%s: failed: string finished early, around token %s\n", __func__, "origin");
3862     return -1;
3863   }
3864   p = strchrnul (tok, ',');
3865   if (*p) next = p+1; else next = NULL;
3866   *p = '\0';
3867   r->origin = strdup (tok);
3868   if (r->origin == NULL) {
3869     perror ("strdup");
3870     return -1;
3871   }
3872   tok = next;
3873   if (!tok) {
3874     fprintf (stderr, "%s: failed: string finished early, around token %s\n", __func__, "snap_percent");
3875     return -1;
3876   }
3877   p = strchrnul (tok, ',');
3878   if (*p) next = p+1; else next = NULL;
3879   *p = '\0';
3880   if (tok[0] == '\0')
3881     r->snap_percent = -1;
3882   else if (sscanf (tok, "%f", &r->snap_percent) != 1) {
3883     fprintf (stderr, "%s: failed to parse float '%s' from token %s\n", __func__, tok, "snap_percent");
3884     return -1;
3885   }
3886   tok = next;
3887   if (!tok) {
3888     fprintf (stderr, "%s: failed: string finished early, around token %s\n", __func__, "copy_percent");
3889     return -1;
3890   }
3891   p = strchrnul (tok, ',');
3892   if (*p) next = p+1; else next = NULL;
3893   *p = '\0';
3894   if (tok[0] == '\0')
3895     r->copy_percent = -1;
3896   else if (sscanf (tok, "%f", &r->copy_percent) != 1) {
3897     fprintf (stderr, "%s: failed to parse float '%s' from token %s\n", __func__, tok, "copy_percent");
3898     return -1;
3899   }
3900   tok = next;
3901   if (!tok) {
3902     fprintf (stderr, "%s: failed: string finished early, around token %s\n", __func__, "move_pv");
3903     return -1;
3904   }
3905   p = strchrnul (tok, ',');
3906   if (*p) next = p+1; else next = NULL;
3907   *p = '\0';
3908   r->move_pv = strdup (tok);
3909   if (r->move_pv == NULL) {
3910     perror ("strdup");
3911     return -1;
3912   }
3913   tok = next;
3914   if (!tok) {
3915     fprintf (stderr, "%s: failed: string finished early, around token %s\n", __func__, "lv_tags");
3916     return -1;
3917   }
3918   p = strchrnul (tok, ',');
3919   if (*p) next = p+1; else next = NULL;
3920   *p = '\0';
3921   r->lv_tags = strdup (tok);
3922   if (r->lv_tags == NULL) {
3923     perror ("strdup");
3924     return -1;
3925   }
3926   tok = next;
3927   if (!tok) {
3928     fprintf (stderr, "%s: failed: string finished early, around token %s\n", __func__, "mirror_log");
3929     return -1;
3930   }
3931   p = strchrnul (tok, ',');
3932   if (*p) next = p+1; else next = NULL;
3933   *p = '\0';
3934   r->mirror_log = strdup (tok);
3935   if (r->mirror_log == NULL) {
3936     perror ("strdup");
3937     return -1;
3938   }
3939   tok = next;
3940   if (!tok) {
3941     fprintf (stderr, "%s: failed: string finished early, around token %s\n", __func__, "modules");
3942     return -1;
3943   }
3944   p = strchrnul (tok, ',');
3945   if (*p) next = p+1; else next = NULL;
3946   *p = '\0';
3947   r->modules = strdup (tok);
3948   if (r->modules == NULL) {
3949     perror ("strdup");
3950     return -1;
3951   }
3952   tok = next;
3953   if (tok != NULL) {
3954     fprintf (stderr, "%s: failed: extra tokens at end of string\n", __func__);
3955     return -1;
3956   }
3957   return 0;
3958 }
3959
3960 guestfs_lvm_int_lv_list *
3961 parse_command_line_lvs (void)
3962 {
3963   char *out, *err;
3964   char *p, *pend;
3965   int r, i;
3966   guestfs_lvm_int_lv_list *ret;
3967   void *newp;
3968
3969   ret = malloc (sizeof *ret);
3970   if (!ret) {
3971     reply_with_perror ("malloc");
3972     return NULL;
3973   }
3974
3975   ret->guestfs_lvm_int_lv_list_len = 0;
3976   ret->guestfs_lvm_int_lv_list_val = NULL;
3977
3978   r = command (&out, &err,
3979                "/sbin/lvm", "lvs",
3980                "-o", lvm_lv_cols, "--unbuffered", "--noheadings",
3981                "--nosuffix", "--separator", ",", "--units", "b", NULL);
3982   if (r == -1) {
3983     reply_with_error ("%s", err);
3984     free (out);
3985     free (err);
3986     free (ret);
3987     return NULL;
3988   }
3989
3990   free (err);
3991
3992   /* Tokenize each line of the output. */
3993   p = out;
3994   i = 0;
3995   while (p) {
3996     pend = strchr (p, '\n');    /* Get the next line of output. */
3997     if (pend) {
3998       *pend = '\0';
3999       pend++;
4000     }
4001
4002     while (*p && isspace (*p))  /* Skip any leading whitespace. */
4003       p++;
4004
4005     if (!*p) {                  /* Empty line?  Skip it. */
4006       p = pend;
4007       continue;
4008     }
4009
4010     /* Allocate some space to store this next entry. */
4011     newp = realloc (ret->guestfs_lvm_int_lv_list_val,
4012                     sizeof (guestfs_lvm_int_lv) * (i+1));
4013     if (newp == NULL) {
4014       reply_with_perror ("realloc");
4015       free (ret->guestfs_lvm_int_lv_list_val);
4016       free (ret);
4017       free (out);
4018       return NULL;
4019     }
4020     ret->guestfs_lvm_int_lv_list_val = newp;
4021
4022     /* Tokenize the next entry. */
4023     r = lvm_tokenize_lv (p, &ret->guestfs_lvm_int_lv_list_val[i]);
4024     if (r == -1) {
4025       reply_with_error ("failed to parse output of 'lvs' command");
4026       free (ret->guestfs_lvm_int_lv_list_val);
4027       free (ret);
4028       free (out);
4029       return NULL;
4030     }
4031
4032     ++i;
4033     p = pend;
4034   }
4035
4036   ret->guestfs_lvm_int_lv_list_len = i;
4037
4038   free (out);
4039   return ret;
4040 }