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   args.physvols.physvols_val = realloc (args.physvols.physvols_val, sizeof (char *) * (args.physvols.physvols_len+1));
 944   args.physvols.physvols_val[args.physvols.physvols_len] = NULL;
 945   physvols = args.physvols.physvols_val;
 946
 947   r = do_vgcreate (volgroup, physvols);
 948   if (r == -1)
 949     /* do_vgcreate has already called reply_with_error */
 950     goto done;
 951
 952   reply (NULL, NULL);
 953 done:
 954   xdr_free ((xdrproc_t) xdr_guestfs_vgcreate_args, (char *) &args);
 955 }
 956
 957 static void lvcreate_stub (XDR *xdr_in)
 958 {
 959   int r;
 960   struct guestfs_lvcreate_args args;
 961   const char *logvol;
 962   const char *volgroup;
 963   int mbytes;
 964
 965   memset (&args, 0, sizeof args);
 966
 967   if (!xdr_guestfs_lvcreate_args (xdr_in, &args)) {
 968     reply_with_error ("%s: daemon failed to decode procedure arguments", "lvcreate");
 969     return;
 970   }
 971   logvol = args.logvol;
 972   volgroup = args.volgroup;
 973   mbytes = args.mbytes;
 974
 975   r = do_lvcreate (logvol, volgroup, mbytes);
 976   if (r == -1)
 977     /* do_lvcreate has already called reply_with_error */
 978     goto done;
 979
 980   reply (NULL, NULL);
 981 done:
 982   xdr_free ((xdrproc_t) xdr_guestfs_lvcreate_args, (char *) &args);
 983 }
 984
 985 static void mkfs_stub (XDR *xdr_in)
 986 {
 987   int r;
 988   struct guestfs_mkfs_args args;
 989   const char *fstype;
 990   const char *device;
 991
 992   memset (&args, 0, sizeof args);
 993
 994   if (!xdr_guestfs_mkfs_args (xdr_in, &args)) {
 995     reply_with_error ("%s: daemon failed to decode procedure arguments", "mkfs");
 996     return;
 997   }
 998   fstype = args.fstype;
 999   device = args.device;
1000
1001   r = do_mkfs (fstype, device);
1002   if (r == -1)
1003     /* do_mkfs has already called reply_with_error */
1004     goto done;
1005
1006   reply (NULL, NULL);
1007 done:
1008   xdr_free ((xdrproc_t) xdr_guestfs_mkfs_args, (char *) &args);
1009 }
1010
1011 static void sfdisk_stub (XDR *xdr_in)
1012 {
1013   int r;
1014   struct guestfs_sfdisk_args args;
1015   const char *device;
1016   int cyls;
1017   int heads;
1018   int sectors;
1019   char **lines;
1020
1021   memset (&args, 0, sizeof args);
1022
1023   if (!xdr_guestfs_sfdisk_args (xdr_in, &args)) {
1024     reply_with_error ("%s: daemon failed to decode procedure arguments", "sfdisk");
1025     return;
1026   }
1027   device = args.device;
1028   cyls = args.cyls;
1029   heads = args.heads;
1030   sectors = args.sectors;
1031   args.lines.lines_val = realloc (args.lines.lines_val, sizeof (char *) * (args.lines.lines_len+1));
1032   args.lines.lines_val[args.lines.lines_len] = NULL;
1033   lines = args.lines.lines_val;
1034
1035   r = do_sfdisk (device, cyls, heads, sectors, lines);
1036   if (r == -1)
1037     /* do_sfdisk has already called reply_with_error */
1038     goto done;
1039
1040   reply (NULL, NULL);
1041 done:
1042   xdr_free ((xdrproc_t) xdr_guestfs_sfdisk_args, (char *) &args);
1043 }
1044
1045 static void write_file_stub (XDR *xdr_in)
1046 {
1047   int r;
1048   struct guestfs_write_file_args args;
1049   const char *path;
1050   const char *content;
1051   int size;
1052
1053   memset (&args, 0, sizeof args);
1054
1055   if (!xdr_guestfs_write_file_args (xdr_in, &args)) {
1056     reply_with_error ("%s: daemon failed to decode procedure arguments", "write_file");
1057     return;
1058   }
1059   path = args.path;
1060   content = args.content;
1061   size = args.size;
1062
1063   r = do_write_file (path, content, size);
1064   if (r == -1)
1065     /* do_write_file has already called reply_with_error */
1066     goto done;
1067
1068   reply (NULL, NULL);
1069 done:
1070   xdr_free ((xdrproc_t) xdr_guestfs_write_file_args, (char *) &args);
1071 }
1072
1073 static void umount_stub (XDR *xdr_in)
1074 {
1075   int r;
1076   struct guestfs_umount_args args;
1077   const char *pathordevice;
1078
1079   memset (&args, 0, sizeof args);
1080
1081   if (!xdr_guestfs_umount_args (xdr_in, &args)) {
1082     reply_with_error ("%s: daemon failed to decode procedure arguments", "umount");
1083     return;
1084   }
1085   pathordevice = args.pathordevice;
1086
1087   r = do_umount (pathordevice);
1088   if (r == -1)
1089     /* do_umount has already called reply_with_error */
1090     goto done;
1091
1092   reply (NULL, NULL);
1093 done:
1094   xdr_free ((xdrproc_t) xdr_guestfs_umount_args, (char *) &args);
1095 }
1096
1097 static void mounts_stub (XDR *xdr_in)
1098 {
1099   char **r;
1100
1101   r = do_mounts ();
1102   if (r == NULL)
1103     /* do_mounts has already called reply_with_error */
1104     goto done;
1105
1106   struct guestfs_mounts_ret ret;
1107   ret.devices.devices_len = count_strings (r);
1108   ret.devices.devices_val = r;
1109   reply ((xdrproc_t) &xdr_guestfs_mounts_ret, (char *) &ret);
1110   free_strings (r);
1111 done: ;
1112 }
1113
1114 static void umount_all_stub (XDR *xdr_in)
1115 {
1116   int r;
1117
1118   r = do_umount_all ();
1119   if (r == -1)
1120     /* do_umount_all has already called reply_with_error */
1121     goto done;
1122
1123   reply (NULL, NULL);
1124 done: ;
1125 }
1126
1127 static void lvm_remove_all_stub (XDR *xdr_in)
1128 {
1129   int r;
1130
1131   r = do_lvm_remove_all ();
1132   if (r == -1)
1133     /* do_lvm_remove_all has already called reply_with_error */
1134     goto done;
1135
1136   reply (NULL, NULL);
1137 done: ;
1138 }
1139
1140 static void file_stub (XDR *xdr_in)
1141 {
1142   char *r;
1143   struct guestfs_file_args args;
1144   const char *path;
1145
1146   memset (&args, 0, sizeof args);
1147
1148   if (!xdr_guestfs_file_args (xdr_in, &args)) {
1149     reply_with_error ("%s: daemon failed to decode procedure arguments", "file");
1150     return;
1151   }
1152   path = args.path;
1153
1154   r = do_file (path);
1155   if (r == NULL)
1156     /* do_file has already called reply_with_error */
1157     goto done;
1158
1159   struct guestfs_file_ret ret;
1160   ret.description = r;
1161   reply ((xdrproc_t) &xdr_guestfs_file_ret, (char *) &ret);
1162   free (r);
1163 done:
1164   xdr_free ((xdrproc_t) xdr_guestfs_file_args, (char *) &args);
1165 }
1166
1167 static void command_stub (XDR *xdr_in)
1168 {
1169   char *r;
1170   struct guestfs_command_args args;
1171   char **arguments;
1172
1173   memset (&args, 0, sizeof args);
1174
1175   if (!xdr_guestfs_command_args (xdr_in, &args)) {
1176     reply_with_error ("%s: daemon failed to decode procedure arguments", "command");
1177     return;
1178   }
1179   args.arguments.arguments_val = realloc (args.arguments.arguments_val, sizeof (char *) * (args.arguments.arguments_len+1));
1180   args.arguments.arguments_val[args.arguments.arguments_len] = NULL;
1181   arguments = args.arguments.arguments_val;
1182
1183   r = do_command (arguments);
1184   if (r == NULL)
1185     /* do_command has already called reply_with_error */
1186     goto done;
1187
1188   struct guestfs_command_ret ret;
1189   ret.output = r;
1190   reply ((xdrproc_t) &xdr_guestfs_command_ret, (char *) &ret);
1191   free (r);
1192 done:
1193   xdr_free ((xdrproc_t) xdr_guestfs_command_args, (char *) &args);
1194 }
1195
1196 static void command_lines_stub (XDR *xdr_in)
1197 {
1198   char **r;
1199   struct guestfs_command_lines_args args;
1200   char **arguments;
1201
1202   memset (&args, 0, sizeof args);
1203
1204   if (!xdr_guestfs_command_lines_args (xdr_in, &args)) {
1205     reply_with_error ("%s: daemon failed to decode procedure arguments", "command_lines");
1206     return;
1207   }
1208   args.arguments.arguments_val = realloc (args.arguments.arguments_val, sizeof (char *) * (args.arguments.arguments_len+1));
1209   args.arguments.arguments_val[args.arguments.arguments_len] = NULL;
1210   arguments = args.arguments.arguments_val;
1211
1212   r = do_command_lines (arguments);
1213   if (r == NULL)
1214     /* do_command_lines has already called reply_with_error */
1215     goto done;
1216
1217   struct guestfs_command_lines_ret ret;
1218   ret.lines.lines_len = count_strings (r);
1219   ret.lines.lines_val = r;
1220   reply ((xdrproc_t) &xdr_guestfs_command_lines_ret, (char *) &ret);
1221   free_strings (r);
1222 done:
1223   xdr_free ((xdrproc_t) xdr_guestfs_command_lines_args, (char *) &args);
1224 }
1225
1226 static void stat_stub (XDR *xdr_in)
1227 {
1228   guestfs_int_stat *r;
1229   struct guestfs_stat_args args;
1230   const char *path;
1231
1232   memset (&args, 0, sizeof args);
1233
1234   if (!xdr_guestfs_stat_args (xdr_in, &args)) {
1235     reply_with_error ("%s: daemon failed to decode procedure arguments", "stat");
1236     return;
1237   }
1238   path = args.path;
1239
1240   r = do_stat (path);
1241   if (r == NULL)
1242     /* do_stat has already called reply_with_error */
1243     goto done;
1244
1245   struct guestfs_stat_ret ret;
1246   ret.statbuf = *r;
1247   reply ((xdrproc_t) xdr_guestfs_stat_ret, (char *) &ret);
1248   xdr_free ((xdrproc_t) xdr_guestfs_stat_ret, (char *) &ret);
1249 done:
1250   xdr_free ((xdrproc_t) xdr_guestfs_stat_args, (char *) &args);
1251 }
1252
1253 static void lstat_stub (XDR *xdr_in)
1254 {
1255   guestfs_int_stat *r;
1256   struct guestfs_lstat_args args;
1257   const char *path;
1258
1259   memset (&args, 0, sizeof args);
1260
1261   if (!xdr_guestfs_lstat_args (xdr_in, &args)) {
1262     reply_with_error ("%s: daemon failed to decode procedure arguments", "lstat");
1263     return;
1264   }
1265   path = args.path;
1266
1267   r = do_lstat (path);
1268   if (r == NULL)
1269     /* do_lstat has already called reply_with_error */
1270     goto done;
1271
1272   struct guestfs_lstat_ret ret;
1273   ret.statbuf = *r;
1274   reply ((xdrproc_t) xdr_guestfs_lstat_ret, (char *) &ret);
1275   xdr_free ((xdrproc_t) xdr_guestfs_lstat_ret, (char *) &ret);
1276 done:
1277   xdr_free ((xdrproc_t) xdr_guestfs_lstat_args, (char *) &args);
1278 }
1279
1280 static void statvfs_stub (XDR *xdr_in)
1281 {
1282   guestfs_int_statvfs *r;
1283   struct guestfs_statvfs_args args;
1284   const char *path;
1285
1286   memset (&args, 0, sizeof args);
1287
1288   if (!xdr_guestfs_statvfs_args (xdr_in, &args)) {
1289     reply_with_error ("%s: daemon failed to decode procedure arguments", "statvfs");
1290     return;
1291   }
1292   path = args.path;
1293
1294   r = do_statvfs (path);
1295   if (r == NULL)
1296     /* do_statvfs has already called reply_with_error */
1297     goto done;
1298
1299   struct guestfs_statvfs_ret ret;
1300   ret.statbuf = *r;
1301   reply ((xdrproc_t) xdr_guestfs_statvfs_ret, (char *) &ret);
1302   xdr_free ((xdrproc_t) xdr_guestfs_statvfs_ret, (char *) &ret);
1303 done:
1304   xdr_free ((xdrproc_t) xdr_guestfs_statvfs_args, (char *) &args);
1305 }
1306
1307 static void tune2fs_l_stub (XDR *xdr_in)
1308 {
1309   char **r;
1310   struct guestfs_tune2fs_l_args args;
1311   const char *device;
1312
1313   memset (&args, 0, sizeof args);
1314
1315   if (!xdr_guestfs_tune2fs_l_args (xdr_in, &args)) {
1316     reply_with_error ("%s: daemon failed to decode procedure arguments", "tune2fs_l");
1317     return;
1318   }
1319   device = args.device;
1320
1321   r = do_tune2fs_l (device);
1322   if (r == NULL)
1323     /* do_tune2fs_l has already called reply_with_error */
1324     goto done;
1325
1326   struct guestfs_tune2fs_l_ret ret;
1327   ret.superblock.superblock_len = count_strings (r);
1328   ret.superblock.superblock_val = r;
1329   reply ((xdrproc_t) &xdr_guestfs_tune2fs_l_ret, (char *) &ret);
1330   free_strings (r);
1331 done:
1332   xdr_free ((xdrproc_t) xdr_guestfs_tune2fs_l_args, (char *) &args);
1333 }
1334
1335 static void blockdev_setro_stub (XDR *xdr_in)
1336 {
1337   int r;
1338   struct guestfs_blockdev_setro_args args;
1339   const char *device;
1340
1341   memset (&args, 0, sizeof args);
1342
1343   if (!xdr_guestfs_blockdev_setro_args (xdr_in, &args)) {
1344     reply_with_error ("%s: daemon failed to decode procedure arguments", "blockdev_setro");
1345     return;
1346   }
1347   device = args.device;
1348
1349   r = do_blockdev_setro (device);
1350   if (r == -1)
1351     /* do_blockdev_setro has already called reply_with_error */
1352     goto done;
1353
1354   reply (NULL, NULL);
1355 done:
1356   xdr_free ((xdrproc_t) xdr_guestfs_blockdev_setro_args, (char *) &args);
1357 }
1358
1359 static void blockdev_setrw_stub (XDR *xdr_in)
1360 {
1361   int r;
1362   struct guestfs_blockdev_setrw_args args;
1363   const char *device;
1364
1365   memset (&args, 0, sizeof args);
1366
1367   if (!xdr_guestfs_blockdev_setrw_args (xdr_in, &args)) {
1368     reply_with_error ("%s: daemon failed to decode procedure arguments", "blockdev_setrw");
1369     return;
1370   }
1371   device = args.device;
1372
1373   r = do_blockdev_setrw (device);
1374   if (r == -1)
1375     /* do_blockdev_setrw has already called reply_with_error */
1376     goto done;
1377
1378   reply (NULL, NULL);
1379 done:
1380   xdr_free ((xdrproc_t) xdr_guestfs_blockdev_setrw_args, (char *) &args);
1381 }
1382
1383 static void blockdev_getro_stub (XDR *xdr_in)
1384 {
1385   int r;
1386   struct guestfs_blockdev_getro_args args;
1387   const char *device;
1388
1389   memset (&args, 0, sizeof args);
1390
1391   if (!xdr_guestfs_blockdev_getro_args (xdr_in, &args)) {
1392     reply_with_error ("%s: daemon failed to decode procedure arguments", "blockdev_getro");
1393     return;
1394   }
1395   device = args.device;
1396
1397   r = do_blockdev_getro (device);
1398   if (r == -1)
1399     /* do_blockdev_getro has already called reply_with_error */
1400     goto done;
1401
1402   struct guestfs_blockdev_getro_ret ret;
1403   ret.ro = r;
1404   reply ((xdrproc_t) &xdr_guestfs_blockdev_getro_ret, (char *) &ret);
1405 done:
1406   xdr_free ((xdrproc_t) xdr_guestfs_blockdev_getro_args, (char *) &args);
1407 }
1408
1409 static void blockdev_getss_stub (XDR *xdr_in)
1410 {
1411   int r;
1412   struct guestfs_blockdev_getss_args args;
1413   const char *device;
1414
1415   memset (&args, 0, sizeof args);
1416
1417   if (!xdr_guestfs_blockdev_getss_args (xdr_in, &args)) {
1418     reply_with_error ("%s: daemon failed to decode procedure arguments", "blockdev_getss");
1419     return;
1420   }
1421   device = args.device;
1422
1423   r = do_blockdev_getss (device);
1424   if (r == -1)
1425     /* do_blockdev_getss has already called reply_with_error */
1426     goto done;
1427
1428   struct guestfs_blockdev_getss_ret ret;
1429   ret.sectorsize = r;
1430   reply ((xdrproc_t) &xdr_guestfs_blockdev_getss_ret, (char *) &ret);
1431 done:
1432   xdr_free ((xdrproc_t) xdr_guestfs_blockdev_getss_args, (char *) &args);
1433 }
1434
1435 static void blockdev_getbsz_stub (XDR *xdr_in)
1436 {
1437   int r;
1438   struct guestfs_blockdev_getbsz_args args;
1439   const char *device;
1440
1441   memset (&args, 0, sizeof args);
1442
1443   if (!xdr_guestfs_blockdev_getbsz_args (xdr_in, &args)) {
1444     reply_with_error ("%s: daemon failed to decode procedure arguments", "blockdev_getbsz");
1445     return;
1446   }
1447   device = args.device;
1448
1449   r = do_blockdev_getbsz (device);
1450   if (r == -1)
1451     /* do_blockdev_getbsz has already called reply_with_error */
1452     goto done;
1453
1454   struct guestfs_blockdev_getbsz_ret ret;
1455   ret.blocksize = r;
1456   reply ((xdrproc_t) &xdr_guestfs_blockdev_getbsz_ret, (char *) &ret);
1457 done:
1458   xdr_free ((xdrproc_t) xdr_guestfs_blockdev_getbsz_args, (char *) &args);
1459 }
1460
1461 static void blockdev_setbsz_stub (XDR *xdr_in)
1462 {
1463   int r;
1464   struct guestfs_blockdev_setbsz_args args;
1465   const char *device;
1466   int blocksize;
1467
1468   memset (&args, 0, sizeof args);
1469
1470   if (!xdr_guestfs_blockdev_setbsz_args (xdr_in, &args)) {
1471     reply_with_error ("%s: daemon failed to decode procedure arguments", "blockdev_setbsz");
1472     return;
1473   }
1474   device = args.device;
1475   blocksize = args.blocksize;
1476
1477   r = do_blockdev_setbsz (device, blocksize);
1478   if (r == -1)
1479     /* do_blockdev_setbsz has already called reply_with_error */
1480     goto done;
1481
1482   reply (NULL, NULL);
1483 done:
1484   xdr_free ((xdrproc_t) xdr_guestfs_blockdev_setbsz_args, (char *) &args);
1485 }
1486
1487 static void blockdev_getsz_stub (XDR *xdr_in)
1488 {
1489   int64_t r;
1490   struct guestfs_blockdev_getsz_args args;
1491   const char *device;
1492
1493   memset (&args, 0, sizeof args);
1494
1495   if (!xdr_guestfs_blockdev_getsz_args (xdr_in, &args)) {
1496     reply_with_error ("%s: daemon failed to decode procedure arguments", "blockdev_getsz");
1497     return;
1498   }
1499   device = args.device;
1500
1501   r = do_blockdev_getsz (device);
1502   if (r == -1)
1503     /* do_blockdev_getsz has already called reply_with_error */
1504     goto done;
1505
1506   struct guestfs_blockdev_getsz_ret ret;
1507   ret.sizeinsectors = r;
1508   reply ((xdrproc_t) &xdr_guestfs_blockdev_getsz_ret, (char *) &ret);
1509 done:
1510   xdr_free ((xdrproc_t) xdr_guestfs_blockdev_getsz_args, (char *) &args);
1511 }
1512
1513 static void blockdev_getsize64_stub (XDR *xdr_in)
1514 {
1515   int64_t r;
1516   struct guestfs_blockdev_getsize64_args args;
1517   const char *device;
1518
1519   memset (&args, 0, sizeof args);
1520
1521   if (!xdr_guestfs_blockdev_getsize64_args (xdr_in, &args)) {
1522     reply_with_error ("%s: daemon failed to decode procedure arguments", "blockdev_getsize64");
1523     return;
1524   }
1525   device = args.device;
1526
1527   r = do_blockdev_getsize64 (device);
1528   if (r == -1)
1529     /* do_blockdev_getsize64 has already called reply_with_error */
1530     goto done;
1531
1532   struct guestfs_blockdev_getsize64_ret ret;
1533   ret.sizeinbytes = r;
1534   reply ((xdrproc_t) &xdr_guestfs_blockdev_getsize64_ret, (char *) &ret);
1535 done:
1536   xdr_free ((xdrproc_t) xdr_guestfs_blockdev_getsize64_args, (char *) &args);
1537 }
1538
1539 static void blockdev_flushbufs_stub (XDR *xdr_in)
1540 {
1541   int r;
1542   struct guestfs_blockdev_flushbufs_args args;
1543   const char *device;
1544
1545   memset (&args, 0, sizeof args);
1546
1547   if (!xdr_guestfs_blockdev_flushbufs_args (xdr_in, &args)) {
1548     reply_with_error ("%s: daemon failed to decode procedure arguments", "blockdev_flushbufs");
1549     return;
1550   }
1551   device = args.device;
1552
1553   r = do_blockdev_flushbufs (device);
1554   if (r == -1)
1555     /* do_blockdev_flushbufs has already called reply_with_error */
1556     goto done;
1557
1558   reply (NULL, NULL);
1559 done:
1560   xdr_free ((xdrproc_t) xdr_guestfs_blockdev_flushbufs_args, (char *) &args);
1561 }
1562
1563 static void blockdev_rereadpt_stub (XDR *xdr_in)
1564 {
1565   int r;
1566   struct guestfs_blockdev_rereadpt_args args;
1567   const char *device;
1568
1569   memset (&args, 0, sizeof args);
1570
1571   if (!xdr_guestfs_blockdev_rereadpt_args (xdr_in, &args)) {
1572     reply_with_error ("%s: daemon failed to decode procedure arguments", "blockdev_rereadpt");
1573     return;
1574   }
1575   device = args.device;
1576
1577   r = do_blockdev_rereadpt (device);
1578   if (r == -1)
1579     /* do_blockdev_rereadpt has already called reply_with_error */
1580     goto done;
1581
1582   reply (NULL, NULL);
1583 done:
1584   xdr_free ((xdrproc_t) xdr_guestfs_blockdev_rereadpt_args, (char *) &args);
1585 }
1586
1587 static void upload_stub (XDR *xdr_in)
1588 {
1589   int r;
1590   struct guestfs_upload_args args;
1591   const char *remotefilename;
1592
1593   memset (&args, 0, sizeof args);
1594
1595   if (!xdr_guestfs_upload_args (xdr_in, &args)) {
1596     reply_with_error ("%s: daemon failed to decode procedure arguments", "upload");
1597     return;
1598   }
1599   remotefilename = args.remotefilename;
1600
1601   r = do_upload (remotefilename);
1602   if (r == -1)
1603     /* do_upload has already called reply_with_error */
1604     goto done;
1605
1606   reply (NULL, NULL);
1607 done:
1608   xdr_free ((xdrproc_t) xdr_guestfs_upload_args, (char *) &args);
1609 }
1610
1611 static void download_stub (XDR *xdr_in)
1612 {
1613   int r;
1614   struct guestfs_download_args args;
1615   const char *remotefilename;
1616
1617   memset (&args, 0, sizeof args);
1618
1619   if (!xdr_guestfs_download_args (xdr_in, &args)) {
1620     reply_with_error ("%s: daemon failed to decode procedure arguments", "download");
1621     return;
1622   }
1623   remotefilename = args.remotefilename;
1624
1625   r = do_download (remotefilename);
1626   if (r == -1)
1627     /* do_download has already called reply_with_error */
1628     goto done;
1629
1630   /* do_download has already sent a reply */
1631 done:
1632   xdr_free ((xdrproc_t) xdr_guestfs_download_args, (char *) &args);
1633 }
1634
1635 static void checksum_stub (XDR *xdr_in)
1636 {
1637   char *r;
1638   struct guestfs_checksum_args args;
1639   const char *csumtype;
1640   const char *path;
1641
1642   memset (&args, 0, sizeof args);
1643
1644   if (!xdr_guestfs_checksum_args (xdr_in, &args)) {
1645     reply_with_error ("%s: daemon failed to decode procedure arguments", "checksum");
1646     return;
1647   }
1648   csumtype = args.csumtype;
1649   path = args.path;
1650
1651   r = do_checksum (csumtype, path);
1652   if (r == NULL)
1653     /* do_checksum has already called reply_with_error */
1654     goto done;
1655
1656   struct guestfs_checksum_ret ret;
1657   ret.checksum = r;
1658   reply ((xdrproc_t) &xdr_guestfs_checksum_ret, (char *) &ret);
1659   free (r);
1660 done:
1661   xdr_free ((xdrproc_t) xdr_guestfs_checksum_args, (char *) &args);
1662 }
1663
1664 static void tar_in_stub (XDR *xdr_in)
1665 {
1666   int r;
1667   struct guestfs_tar_in_args args;
1668   const char *directory;
1669
1670   memset (&args, 0, sizeof args);
1671
1672   if (!xdr_guestfs_tar_in_args (xdr_in, &args)) {
1673     reply_with_error ("%s: daemon failed to decode procedure arguments", "tar_in");
1674     return;
1675   }
1676   directory = args.directory;
1677
1678   r = do_tar_in (directory);
1679   if (r == -1)
1680     /* do_tar_in has already called reply_with_error */
1681     goto done;
1682
1683   reply (NULL, NULL);
1684 done:
1685   xdr_free ((xdrproc_t) xdr_guestfs_tar_in_args, (char *) &args);
1686 }
1687
1688 static void tar_out_stub (XDR *xdr_in)
1689 {
1690   int r;
1691   struct guestfs_tar_out_args args;
1692   const char *directory;
1693
1694   memset (&args, 0, sizeof args);
1695
1696   if (!xdr_guestfs_tar_out_args (xdr_in, &args)) {
1697     reply_with_error ("%s: daemon failed to decode procedure arguments", "tar_out");
1698     return;
1699   }
1700   directory = args.directory;
1701
1702   r = do_tar_out (directory);
1703   if (r == -1)
1704     /* do_tar_out has already called reply_with_error */
1705     goto done;
1706
1707   /* do_tar_out has already sent a reply */
1708 done:
1709   xdr_free ((xdrproc_t) xdr_guestfs_tar_out_args, (char *) &args);
1710 }
1711
1712 static void tgz_in_stub (XDR *xdr_in)
1713 {
1714   int r;
1715   struct guestfs_tgz_in_args args;
1716   const char *directory;
1717
1718   memset (&args, 0, sizeof args);
1719
1720   if (!xdr_guestfs_tgz_in_args (xdr_in, &args)) {
1721     reply_with_error ("%s: daemon failed to decode procedure arguments", "tgz_in");
1722     return;
1723   }
1724   directory = args.directory;
1725
1726   r = do_tgz_in (directory);
1727   if (r == -1)
1728     /* do_tgz_in has already called reply_with_error */
1729     goto done;
1730
1731   reply (NULL, NULL);
1732 done:
1733   xdr_free ((xdrproc_t) xdr_guestfs_tgz_in_args, (char *) &args);
1734 }
1735
1736 static void tgz_out_stub (XDR *xdr_in)
1737 {
1738   int r;
1739   struct guestfs_tgz_out_args args;
1740   const char *directory;
1741
1742   memset (&args, 0, sizeof args);
1743
1744   if (!xdr_guestfs_tgz_out_args (xdr_in, &args)) {
1745     reply_with_error ("%s: daemon failed to decode procedure arguments", "tgz_out");
1746     return;
1747   }
1748   directory = args.directory;
1749
1750   r = do_tgz_out (directory);
1751   if (r == -1)
1752     /* do_tgz_out has already called reply_with_error */
1753     goto done;
1754
1755   /* do_tgz_out has already sent a reply */
1756 done:
1757   xdr_free ((xdrproc_t) xdr_guestfs_tgz_out_args, (char *) &args);
1758 }
1759
1760 static void mount_ro_stub (XDR *xdr_in)
1761 {
1762   int r;
1763   struct guestfs_mount_ro_args args;
1764   const char *device;
1765   const char *mountpoint;
1766
1767   memset (&args, 0, sizeof args);
1768
1769   if (!xdr_guestfs_mount_ro_args (xdr_in, &args)) {
1770     reply_with_error ("%s: daemon failed to decode procedure arguments", "mount_ro");
1771     return;
1772   }
1773   device = args.device;
1774   mountpoint = args.mountpoint;
1775
1776   r = do_mount_ro (device, mountpoint);
1777   if (r == -1)
1778     /* do_mount_ro has already called reply_with_error */
1779     goto done;
1780
1781   reply (NULL, NULL);
1782 done:
1783   xdr_free ((xdrproc_t) xdr_guestfs_mount_ro_args, (char *) &args);
1784 }
1785
1786 static void mount_options_stub (XDR *xdr_in)
1787 {
1788   int r;
1789   struct guestfs_mount_options_args args;
1790   const char *options;
1791   const char *device;
1792   const char *mountpoint;
1793
1794   memset (&args, 0, sizeof args);
1795
1796   if (!xdr_guestfs_mount_options_args (xdr_in, &args)) {
1797     reply_with_error ("%s: daemon failed to decode procedure arguments", "mount_options");
1798     return;
1799   }
1800   options = args.options;
1801   device = args.device;
1802   mountpoint = args.mountpoint;
1803
1804   r = do_mount_options (options, device, mountpoint);
1805   if (r == -1)
1806     /* do_mount_options has already called reply_with_error */
1807     goto done;
1808
1809   reply (NULL, NULL);
1810 done:
1811   xdr_free ((xdrproc_t) xdr_guestfs_mount_options_args, (char *) &args);
1812 }
1813
1814 static void mount_vfs_stub (XDR *xdr_in)
1815 {
1816   int r;
1817   struct guestfs_mount_vfs_args args;
1818   const char *options;
1819   const char *vfstype;
1820   const char *device;
1821   const char *mountpoint;
1822
1823   memset (&args, 0, sizeof args);
1824
1825   if (!xdr_guestfs_mount_vfs_args (xdr_in, &args)) {
1826     reply_with_error ("%s: daemon failed to decode procedure arguments", "mount_vfs");
1827     return;
1828   }
1829   options = args.options;
1830   vfstype = args.vfstype;
1831   device = args.device;
1832   mountpoint = args.mountpoint;
1833
1834   r = do_mount_vfs (options, vfstype, device, mountpoint);
1835   if (r == -1)
1836     /* do_mount_vfs has already called reply_with_error */
1837     goto done;
1838
1839   reply (NULL, NULL);
1840 done:
1841   xdr_free ((xdrproc_t) xdr_guestfs_mount_vfs_args, (char *) &args);
1842 }
1843
1844 static void debug_stub (XDR *xdr_in)
1845 {
1846   char *r;
1847   struct guestfs_debug_args args;
1848   const char *subcmd;
1849   char **extraargs;
1850
1851   memset (&args, 0, sizeof args);
1852
1853   if (!xdr_guestfs_debug_args (xdr_in, &args)) {
1854     reply_with_error ("%s: daemon failed to decode procedure arguments", "debug");
1855     return;
1856   }
1857   subcmd = args.subcmd;
1858   args.extraargs.extraargs_val = realloc (args.extraargs.extraargs_val, sizeof (char *) * (args.extraargs.extraargs_len+1));
1859   args.extraargs.extraargs_val[args.extraargs.extraargs_len] = NULL;
1860   extraargs = args.extraargs.extraargs_val;
1861
1862   r = do_debug (subcmd, extraargs);
1863   if (r == NULL)
1864     /* do_debug has already called reply_with_error */
1865     goto done;
1866
1867   struct guestfs_debug_ret ret;
1868   ret.result = r;
1869   reply ((xdrproc_t) &xdr_guestfs_debug_ret, (char *) &ret);
1870   free (r);
1871 done:
1872   xdr_free ((xdrproc_t) xdr_guestfs_debug_args, (char *) &args);
1873 }
1874
1875 static void lvremove_stub (XDR *xdr_in)
1876 {
1877   int r;
1878   struct guestfs_lvremove_args args;
1879   const char *device;
1880
1881   memset (&args, 0, sizeof args);
1882
1883   if (!xdr_guestfs_lvremove_args (xdr_in, &args)) {
1884     reply_with_error ("%s: daemon failed to decode procedure arguments", "lvremove");
1885     return;
1886   }
1887   device = args.device;
1888
1889   r = do_lvremove (device);
1890   if (r == -1)
1891     /* do_lvremove has already called reply_with_error */
1892     goto done;
1893
1894   reply (NULL, NULL);
1895 done:
1896   xdr_free ((xdrproc_t) xdr_guestfs_lvremove_args, (char *) &args);
1897 }
1898
1899 static void vgremove_stub (XDR *xdr_in)
1900 {
1901   int r;
1902   struct guestfs_vgremove_args args;
1903   const char *vgname;
1904
1905   memset (&args, 0, sizeof args);
1906
1907   if (!xdr_guestfs_vgremove_args (xdr_in, &args)) {
1908     reply_with_error ("%s: daemon failed to decode procedure arguments", "vgremove");
1909     return;
1910   }
1911   vgname = args.vgname;
1912
1913   r = do_vgremove (vgname);
1914   if (r == -1)
1915     /* do_vgremove has already called reply_with_error */
1916     goto done;
1917
1918   reply (NULL, NULL);
1919 done:
1920   xdr_free ((xdrproc_t) xdr_guestfs_vgremove_args, (char *) &args);
1921 }
1922
1923 static void pvremove_stub (XDR *xdr_in)
1924 {
1925   int r;
1926   struct guestfs_pvremove_args args;
1927   const char *device;
1928
1929   memset (&args, 0, sizeof args);
1930
1931   if (!xdr_guestfs_pvremove_args (xdr_in, &args)) {
1932     reply_with_error ("%s: daemon failed to decode procedure arguments", "pvremove");
1933     return;
1934   }
1935   device = args.device;
1936
1937   r = do_pvremove (device);
1938   if (r == -1)
1939     /* do_pvremove has already called reply_with_error */
1940     goto done;
1941
1942   reply (NULL, NULL);
1943 done:
1944   xdr_free ((xdrproc_t) xdr_guestfs_pvremove_args, (char *) &args);
1945 }
1946
1947 void dispatch_incoming_message (XDR *xdr_in)
1948 {
1949   switch (proc_nr) {
1950     case GUESTFS_PROC_MOUNT:
1951       mount_stub (xdr_in);
1952       break;
1953     case GUESTFS_PROC_SYNC:
1954       sync_stub (xdr_in);
1955       break;
1956     case GUESTFS_PROC_TOUCH:
1957       touch_stub (xdr_in);
1958       break;
1959     case GUESTFS_PROC_CAT:
1960       cat_stub (xdr_in);
1961       break;
1962     case GUESTFS_PROC_LL:
1963       ll_stub (xdr_in);
1964       break;
1965     case GUESTFS_PROC_LS:
1966       ls_stub (xdr_in);
1967       break;
1968     case GUESTFS_PROC_LIST_DEVICES:
1969       list_devices_stub (xdr_in);
1970       break;
1971     case GUESTFS_PROC_LIST_PARTITIONS:
1972       list_partitions_stub (xdr_in);
1973       break;
1974     case GUESTFS_PROC_PVS:
1975       pvs_stub (xdr_in);
1976       break;
1977     case GUESTFS_PROC_VGS:
1978       vgs_stub (xdr_in);
1979       break;
1980     case GUESTFS_PROC_LVS:
1981       lvs_stub (xdr_in);
1982       break;
1983     case GUESTFS_PROC_PVS_FULL:
1984       pvs_full_stub (xdr_in);
1985       break;
1986     case GUESTFS_PROC_VGS_FULL:
1987       vgs_full_stub (xdr_in);
1988       break;
1989     case GUESTFS_PROC_LVS_FULL:
1990       lvs_full_stub (xdr_in);
1991       break;
1992     case GUESTFS_PROC_READ_LINES:
1993       read_lines_stub (xdr_in);
1994       break;
1995     case GUESTFS_PROC_AUG_INIT:
1996       aug_init_stub (xdr_in);
1997       break;
1998     case GUESTFS_PROC_AUG_CLOSE:
1999       aug_close_stub (xdr_in);
2000       break;
2001     case GUESTFS_PROC_AUG_DEFVAR:
2002       aug_defvar_stub (xdr_in);
2003       break;
2004     case GUESTFS_PROC_AUG_DEFNODE:
2005       aug_defnode_stub (xdr_in);
2006       break;
2007     case GUESTFS_PROC_AUG_GET:
2008       aug_get_stub (xdr_in);
2009       break;
2010     case GUESTFS_PROC_AUG_SET:
2011       aug_set_stub (xdr_in);
2012       break;
2013     case GUESTFS_PROC_AUG_INSERT:
2014       aug_insert_stub (xdr_in);
2015       break;
2016     case GUESTFS_PROC_AUG_RM:
2017       aug_rm_stub (xdr_in);
2018       break;
2019     case GUESTFS_PROC_AUG_MV:
2020       aug_mv_stub (xdr_in);
2021       break;
2022     case GUESTFS_PROC_AUG_MATCH:
2023       aug_match_stub (xdr_in);
2024       break;
2025     case GUESTFS_PROC_AUG_SAVE:
2026       aug_save_stub (xdr_in);
2027       break;
2028     case GUESTFS_PROC_AUG_LOAD:
2029       aug_load_stub (xdr_in);
2030       break;
2031     case GUESTFS_PROC_AUG_LS:
2032       aug_ls_stub (xdr_in);
2033       break;
2034     case GUESTFS_PROC_RM:
2035       rm_stub (xdr_in);
2036       break;
2037     case GUESTFS_PROC_RMDIR:
2038       rmdir_stub (xdr_in);
2039       break;
2040     case GUESTFS_PROC_RM_RF:
2041       rm_rf_stub (xdr_in);
2042       break;
2043     case GUESTFS_PROC_MKDIR:
2044       mkdir_stub (xdr_in);
2045       break;
2046     case GUESTFS_PROC_MKDIR_P:
2047       mkdir_p_stub (xdr_in);
2048       break;
2049     case GUESTFS_PROC_CHMOD:
2050       chmod_stub (xdr_in);
2051       break;
2052     case GUESTFS_PROC_CHOWN:
2053       chown_stub (xdr_in);
2054       break;
2055     case GUESTFS_PROC_EXISTS:
2056       exists_stub (xdr_in);
2057       break;
2058     case GUESTFS_PROC_IS_FILE:
2059       is_file_stub (xdr_in);
2060       break;
2061     case GUESTFS_PROC_IS_DIR:
2062       is_dir_stub (xdr_in);
2063       break;
2064     case GUESTFS_PROC_PVCREATE:
2065       pvcreate_stub (xdr_in);
2066       break;
2067     case GUESTFS_PROC_VGCREATE:
2068       vgcreate_stub (xdr_in);
2069       break;
2070     case GUESTFS_PROC_LVCREATE:
2071       lvcreate_stub (xdr_in);
2072       break;
2073     case GUESTFS_PROC_MKFS:
2074       mkfs_stub (xdr_in);
2075       break;
2076     case GUESTFS_PROC_SFDISK:
2077       sfdisk_stub (xdr_in);
2078       break;
2079     case GUESTFS_PROC_WRITE_FILE:
2080       write_file_stub (xdr_in);
2081       break;
2082     case GUESTFS_PROC_UMOUNT:
2083       umount_stub (xdr_in);
2084       break;
2085     case GUESTFS_PROC_MOUNTS:
2086       mounts_stub (xdr_in);
2087       break;
2088     case GUESTFS_PROC_UMOUNT_ALL:
2089       umount_all_stub (xdr_in);
2090       break;
2091     case GUESTFS_PROC_LVM_REMOVE_ALL:
2092       lvm_remove_all_stub (xdr_in);
2093       break;
2094     case GUESTFS_PROC_FILE:
2095       file_stub (xdr_in);
2096       break;
2097     case GUESTFS_PROC_COMMAND:
2098       command_stub (xdr_in);
2099       break;
2100     case GUESTFS_PROC_COMMAND_LINES:
2101       command_lines_stub (xdr_in);
2102       break;
2103     case GUESTFS_PROC_STAT:
2104       stat_stub (xdr_in);
2105       break;
2106     case GUESTFS_PROC_LSTAT:
2107       lstat_stub (xdr_in);
2108       break;
2109     case GUESTFS_PROC_STATVFS:
2110       statvfs_stub (xdr_in);
2111       break;
2112     case GUESTFS_PROC_TUNE2FS_L:
2113       tune2fs_l_stub (xdr_in);
2114       break;
2115     case GUESTFS_PROC_BLOCKDEV_SETRO:
2116       blockdev_setro_stub (xdr_in);
2117       break;
2118     case GUESTFS_PROC_BLOCKDEV_SETRW:
2119       blockdev_setrw_stub (xdr_in);
2120       break;
2121     case GUESTFS_PROC_BLOCKDEV_GETRO:
2122       blockdev_getro_stub (xdr_in);
2123       break;
2124     case GUESTFS_PROC_BLOCKDEV_GETSS:
2125       blockdev_getss_stub (xdr_in);
2126       break;
2127     case GUESTFS_PROC_BLOCKDEV_GETBSZ:
2128       blockdev_getbsz_stub (xdr_in);
2129       break;
2130     case GUESTFS_PROC_BLOCKDEV_SETBSZ:
2131       blockdev_setbsz_stub (xdr_in);
2132       break;
2133     case GUESTFS_PROC_BLOCKDEV_GETSZ:
2134       blockdev_getsz_stub (xdr_in);
2135       break;
2136     case GUESTFS_PROC_BLOCKDEV_GETSIZE64:
2137       blockdev_getsize64_stub (xdr_in);
2138       break;
2139     case GUESTFS_PROC_BLOCKDEV_FLUSHBUFS:
2140       blockdev_flushbufs_stub (xdr_in);
2141       break;
2142     case GUESTFS_PROC_BLOCKDEV_REREADPT:
2143       blockdev_rereadpt_stub (xdr_in);
2144       break;
2145     case GUESTFS_PROC_UPLOAD:
2146       upload_stub (xdr_in);
2147       break;
2148     case GUESTFS_PROC_DOWNLOAD:
2149       download_stub (xdr_in);
2150       break;
2151     case GUESTFS_PROC_CHECKSUM:
2152       checksum_stub (xdr_in);
2153       break;
2154     case GUESTFS_PROC_TAR_IN:
2155       tar_in_stub (xdr_in);
2156       break;
2157     case GUESTFS_PROC_TAR_OUT:
2158       tar_out_stub (xdr_in);
2159       break;
2160     case GUESTFS_PROC_TGZ_IN:
2161       tgz_in_stub (xdr_in);
2162       break;
2163     case GUESTFS_PROC_TGZ_OUT:
2164       tgz_out_stub (xdr_in);
2165       break;
2166     case GUESTFS_PROC_MOUNT_RO:
2167       mount_ro_stub (xdr_in);
2168       break;
2169     case GUESTFS_PROC_MOUNT_OPTIONS:
2170       mount_options_stub (xdr_in);
2171       break;
2172     case GUESTFS_PROC_MOUNT_VFS:
2173       mount_vfs_stub (xdr_in);
2174       break;
2175     case GUESTFS_PROC_DEBUG:
2176       debug_stub (xdr_in);
2177       break;
2178     case GUESTFS_PROC_LVREMOVE:
2179       lvremove_stub (xdr_in);
2180       break;
2181     case GUESTFS_PROC_VGREMOVE:
2182       vgremove_stub (xdr_in);
2183       break;
2184     case GUESTFS_PROC_PVREMOVE:
2185       pvremove_stub (xdr_in);
2186       break;
2187     default:
2188       reply_with_error ("dispatch_incoming_message: unknown procedure number %d", proc_nr);
2189   }
2190 }
2191
2192 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";
2193
2194 static int lvm_tokenize_pv (char *str, struct guestfs_lvm_int_pv *r)
2195 {
2196   char *tok, *p, *next;
2197   int i, j;
2198
2199   if (!str) {
2200     fprintf (stderr, "%s: failed: passed a NULL string\n", __func__);
2201     return -1;
2202   }
2203   if (!*str || isspace (*str)) {
2204     fprintf (stderr, "%s: failed: passed a empty string or one beginning with whitespace\n", __func__);
2205     return -1;
2206   }
2207   tok = str;
2208   if (!tok) {
2209     fprintf (stderr, "%s: failed: string finished early, around token %s\n", __func__, "pv_name");
2210     return -1;
2211   }
2212   p = strchrnul (tok, ',');
2213   if (*p) next = p+1; else next = NULL;
2214   *p = '\0';
2215   r->pv_name = strdup (tok);
2216   if (r->pv_name == NULL) {
2217     perror ("strdup");
2218     return -1;
2219   }
2220   tok = next;
2221   if (!tok) {
2222     fprintf (stderr, "%s: failed: string finished early, around token %s\n", __func__, "pv_uuid");
2223     return -1;
2224   }
2225   p = strchrnul (tok, ',');
2226   if (*p) next = p+1; else next = NULL;
2227   *p = '\0';
2228   for (i = j = 0; i < 32; ++j) {
2229     if (tok[j] == '\0') {
2230       fprintf (stderr, "%s: failed to parse UUID from '%s'\n", __func__, tok);
2231       return -1;
2232     } else if (tok[j] != '-')
2233       r->pv_uuid[i++] = tok[j];
2234   }
2235   tok = next;
2236   if (!tok) {
2237     fprintf (stderr, "%s: failed: string finished early, around token %s\n", __func__, "pv_fmt");
2238     return -1;
2239   }
2240   p = strchrnul (tok, ',');
2241   if (*p) next = p+1; else next = NULL;
2242   *p = '\0';
2243   r->pv_fmt = strdup (tok);
2244   if (r->pv_fmt == NULL) {
2245     perror ("strdup");
2246     return -1;
2247   }
2248   tok = next;
2249   if (!tok) {
2250     fprintf (stderr, "%s: failed: string finished early, around token %s\n", __func__, "pv_size");
2251     return -1;
2252   }
2253   p = strchrnul (tok, ',');
2254   if (*p) next = p+1; else next = NULL;
2255   *p = '\0';
2256   if (sscanf (tok, "%"SCNu64, &r->pv_size) != 1) {
2257     fprintf (stderr, "%s: failed to parse size '%s' from token %s\n", __func__, tok, "pv_size");
2258     return -1;
2259   }
2260   tok = next;
2261   if (!tok) {
2262     fprintf (stderr, "%s: failed: string finished early, around token %s\n", __func__, "dev_size");
2263     return -1;
2264   }
2265   p = strchrnul (tok, ',');
2266   if (*p) next = p+1; else next = NULL;
2267   *p = '\0';
2268   if (sscanf (tok, "%"SCNu64, &r->dev_size) != 1) {
2269     fprintf (stderr, "%s: failed to parse size '%s' from token %s\n", __func__, tok, "dev_size");
2270     return -1;
2271   }
2272   tok = next;
2273   if (!tok) {
2274     fprintf (stderr, "%s: failed: string finished early, around token %s\n", __func__, "pv_free");
2275     return -1;
2276   }
2277   p = strchrnul (tok, ',');
2278   if (*p) next = p+1; else next = NULL;
2279   *p = '\0';
2280   if (sscanf (tok, "%"SCNu64, &r->pv_free) != 1) {
2281     fprintf (stderr, "%s: failed to parse size '%s' from token %s\n", __func__, tok, "pv_free");
2282     return -1;
2283   }
2284   tok = next;
2285   if (!tok) {
2286     fprintf (stderr, "%s: failed: string finished early, around token %s\n", __func__, "pv_used");
2287     return -1;
2288   }
2289   p = strchrnul (tok, ',');
2290   if (*p) next = p+1; else next = NULL;
2291   *p = '\0';
2292   if (sscanf (tok, "%"SCNu64, &r->pv_used) != 1) {
2293     fprintf (stderr, "%s: failed to parse size '%s' from token %s\n", __func__, tok, "pv_used");
2294     return -1;
2295   }
2296   tok = next;
2297   if (!tok) {
2298     fprintf (stderr, "%s: failed: string finished early, around token %s\n", __func__, "pv_attr");
2299     return -1;
2300   }
2301   p = strchrnul (tok, ',');
2302   if (*p) next = p+1; else next = NULL;
2303   *p = '\0';
2304   r->pv_attr = strdup (tok);
2305   if (r->pv_attr == NULL) {
2306     perror ("strdup");
2307     return -1;
2308   }
2309   tok = next;
2310   if (!tok) {
2311     fprintf (stderr, "%s: failed: string finished early, around token %s\n", __func__, "pv_pe_count");
2312     return -1;
2313   }
2314   p = strchrnul (tok, ',');
2315   if (*p) next = p+1; else next = NULL;
2316   *p = '\0';
2317   if (sscanf (tok, "%"SCNi64, &r->pv_pe_count) != 1) {
2318     fprintf (stderr, "%s: failed to parse int '%s' from token %s\n", __func__, tok, "pv_pe_count");
2319     return -1;
2320   }
2321   tok = next;
2322   if (!tok) {
2323     fprintf (stderr, "%s: failed: string finished early, around token %s\n", __func__, "pv_pe_alloc_count");
2324     return -1;
2325   }
2326   p = strchrnul (tok, ',');
2327   if (*p) next = p+1; else next = NULL;
2328   *p = '\0';
2329   if (sscanf (tok, "%"SCNi64, &r->pv_pe_alloc_count) != 1) {
2330     fprintf (stderr, "%s: failed to parse int '%s' from token %s\n", __func__, tok, "pv_pe_alloc_count");
2331     return -1;
2332   }
2333   tok = next;
2334   if (!tok) {
2335     fprintf (stderr, "%s: failed: string finished early, around token %s\n", __func__, "pv_tags");
2336     return -1;
2337   }
2338   p = strchrnul (tok, ',');
2339   if (*p) next = p+1; else next = NULL;
2340   *p = '\0';
2341   r->pv_tags = strdup (tok);
2342   if (r->pv_tags == NULL) {
2343     perror ("strdup");
2344     return -1;
2345   }
2346   tok = next;
2347   if (!tok) {
2348     fprintf (stderr, "%s: failed: string finished early, around token %s\n", __func__, "pe_start");
2349     return -1;
2350   }
2351   p = strchrnul (tok, ',');
2352   if (*p) next = p+1; else next = NULL;
2353   *p = '\0';
2354   if (sscanf (tok, "%"SCNu64, &r->pe_start) != 1) {
2355     fprintf (stderr, "%s: failed to parse size '%s' from token %s\n", __func__, tok, "pe_start");
2356     return -1;
2357   }
2358   tok = next;
2359   if (!tok) {
2360     fprintf (stderr, "%s: failed: string finished early, around token %s\n", __func__, "pv_mda_count");
2361     return -1;
2362   }
2363   p = strchrnul (tok, ',');
2364   if (*p) next = p+1; else next = NULL;
2365   *p = '\0';
2366   if (sscanf (tok, "%"SCNi64, &r->pv_mda_count) != 1) {
2367     fprintf (stderr, "%s: failed to parse int '%s' from token %s\n", __func__, tok, "pv_mda_count");
2368     return -1;
2369   }
2370   tok = next;
2371   if (!tok) {
2372     fprintf (stderr, "%s: failed: string finished early, around token %s\n", __func__, "pv_mda_free");
2373     return -1;
2374   }
2375   p = strchrnul (tok, ',');
2376   if (*p) next = p+1; else next = NULL;
2377   *p = '\0';
2378   if (sscanf (tok, "%"SCNu64, &r->pv_mda_free) != 1) {
2379     fprintf (stderr, "%s: failed to parse size '%s' from token %s\n", __func__, tok, "pv_mda_free");
2380     return -1;
2381   }
2382   tok = next;
2383   if (tok != NULL) {
2384     fprintf (stderr, "%s: failed: extra tokens at end of string\n", __func__);
2385     return -1;
2386   }
2387   return 0;
2388 }
2389
2390 guestfs_lvm_int_pv_list *
2391 parse_command_line_pvs (void)
2392 {
2393   char *out, *err;
2394   char *p, *pend;
2395   int r, i;
2396   guestfs_lvm_int_pv_list *ret;
2397   void *newp;
2398
2399   ret = malloc (sizeof *ret);
2400   if (!ret) {
2401     reply_with_perror ("malloc");
2402     return NULL;
2403   }
2404
2405   ret->guestfs_lvm_int_pv_list_len = 0;
2406   ret->guestfs_lvm_int_pv_list_val = NULL;
2407
2408   r = command (&out, &err,
2409                "/sbin/lvm", "pvs",
2410                "-o", lvm_pv_cols, "--unbuffered", "--noheadings",
2411                "--nosuffix", "--separator", ",", "--units", "b", NULL);
2412   if (r == -1) {
2413     reply_with_error ("%s", err);
2414     free (out);
2415     free (err);
2416     free (ret);
2417     return NULL;
2418   }
2419
2420   free (err);
2421
2422   /* Tokenize each line of the output. */
2423   p = out;
2424   i = 0;
2425   while (p) {
2426     pend = strchr (p, '\n');    /* Get the next line of output. */
2427     if (pend) {
2428       *pend = '\0';
2429       pend++;
2430     }
2431
2432     while (*p && isspace (*p))  /* Skip any leading whitespace. */
2433       p++;
2434
2435     if (!*p) {                  /* Empty line?  Skip it. */
2436       p = pend;
2437       continue;
2438     }
2439
2440     /* Allocate some space to store this next entry. */
2441     newp = realloc (ret->guestfs_lvm_int_pv_list_val,
2442                     sizeof (guestfs_lvm_int_pv) * (i+1));
2443     if (newp == NULL) {
2444       reply_with_perror ("realloc");
2445       free (ret->guestfs_lvm_int_pv_list_val);
2446       free (ret);
2447       free (out);
2448       return NULL;
2449     }
2450     ret->guestfs_lvm_int_pv_list_val = newp;
2451
2452     /* Tokenize the next entry. */
2453     r = lvm_tokenize_pv (p, &ret->guestfs_lvm_int_pv_list_val[i]);
2454     if (r == -1) {
2455       reply_with_error ("failed to parse output of 'pvs' command");
2456       free (ret->guestfs_lvm_int_pv_list_val);
2457       free (ret);
2458       free (out);
2459       return NULL;
2460     }
2461
2462     ++i;
2463     p = pend;
2464   }
2465
2466   ret->guestfs_lvm_int_pv_list_len = i;
2467
2468   free (out);
2469   return ret;
2470 }
2471 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";
2472
2473 static int lvm_tokenize_vg (char *str, struct guestfs_lvm_int_vg *r)
2474 {
2475   char *tok, *p, *next;
2476   int i, j;
2477
2478   if (!str) {
2479     fprintf (stderr, "%s: failed: passed a NULL string\n", __func__);
2480     return -1;
2481   }
2482   if (!*str || isspace (*str)) {
2483     fprintf (stderr, "%s: failed: passed a empty string or one beginning with whitespace\n", __func__);
2484     return -1;
2485   }
2486   tok = str;
2487   if (!tok) {
2488     fprintf (stderr, "%s: failed: string finished early, around token %s\n", __func__, "vg_name");
2489     return -1;
2490   }
2491   p = strchrnul (tok, ',');
2492   if (*p) next = p+1; else next = NULL;
2493   *p = '\0';
2494   r->vg_name = strdup (tok);
2495   if (r->vg_name == NULL) {
2496     perror ("strdup");
2497     return -1;
2498   }
2499   tok = next;
2500   if (!tok) {
2501     fprintf (stderr, "%s: failed: string finished early, around token %s\n", __func__, "vg_uuid");
2502     return -1;
2503   }
2504   p = strchrnul (tok, ',');
2505   if (*p) next = p+1; else next = NULL;
2506   *p = '\0';
2507   for (i = j = 0; i < 32; ++j) {
2508     if (tok[j] == '\0') {
2509       fprintf (stderr, "%s: failed to parse UUID from '%s'\n", __func__, tok);
2510       return -1;
2511     } else if (tok[j] != '-')
2512       r->vg_uuid[i++] = tok[j];
2513   }
2514   tok = next;
2515   if (!tok) {
2516     fprintf (stderr, "%s: failed: string finished early, around token %s\n", __func__, "vg_fmt");
2517     return -1;
2518   }
2519   p = strchrnul (tok, ',');
2520   if (*p) next = p+1; else next = NULL;
2521   *p = '\0';
2522   r->vg_fmt = strdup (tok);
2523   if (r->vg_fmt == NULL) {
2524     perror ("strdup");
2525     return -1;
2526   }
2527   tok = next;
2528   if (!tok) {
2529     fprintf (stderr, "%s: failed: string finished early, around token %s\n", __func__, "vg_attr");
2530     return -1;
2531   }
2532   p = strchrnul (tok, ',');
2533   if (*p) next = p+1; else next = NULL;
2534   *p = '\0';
2535   r->vg_attr = strdup (tok);
2536   if (r->vg_attr == NULL) {
2537     perror ("strdup");
2538     return -1;
2539   }
2540   tok = next;
2541   if (!tok) {
2542     fprintf (stderr, "%s: failed: string finished early, around token %s\n", __func__, "vg_size");
2543     return -1;
2544   }
2545   p = strchrnul (tok, ',');
2546   if (*p) next = p+1; else next = NULL;
2547   *p = '\0';
2548   if (sscanf (tok, "%"SCNu64, &r->vg_size) != 1) {
2549     fprintf (stderr, "%s: failed to parse size '%s' from token %s\n", __func__, tok, "vg_size");
2550     return -1;
2551   }
2552   tok = next;
2553   if (!tok) {
2554     fprintf (stderr, "%s: failed: string finished early, around token %s\n", __func__, "vg_free");
2555     return -1;
2556   }
2557   p = strchrnul (tok, ',');
2558   if (*p) next = p+1; else next = NULL;
2559   *p = '\0';
2560   if (sscanf (tok, "%"SCNu64, &r->vg_free) != 1) {
2561     fprintf (stderr, "%s: failed to parse size '%s' from token %s\n", __func__, tok, "vg_free");
2562     return -1;
2563   }
2564   tok = next;
2565   if (!tok) {
2566     fprintf (stderr, "%s: failed: string finished early, around token %s\n", __func__, "vg_sysid");
2567     return -1;
2568   }
2569   p = strchrnul (tok, ',');
2570   if (*p) next = p+1; else next = NULL;
2571   *p = '\0';
2572   r->vg_sysid = strdup (tok);
2573   if (r->vg_sysid == NULL) {
2574     perror ("strdup");
2575     return -1;
2576   }
2577   tok = next;
2578   if (!tok) {
2579     fprintf (stderr, "%s: failed: string finished early, around token %s\n", __func__, "vg_extent_size");
2580     return -1;
2581   }
2582   p = strchrnul (tok, ',');
2583   if (*p) next = p+1; else next = NULL;
2584   *p = '\0';
2585   if (sscanf (tok, "%"SCNu64, &r->vg_extent_size) != 1) {
2586     fprintf (stderr, "%s: failed to parse size '%s' from token %s\n", __func__, tok, "vg_extent_size");
2587     return -1;
2588   }
2589   tok = next;
2590   if (!tok) {
2591     fprintf (stderr, "%s: failed: string finished early, around token %s\n", __func__, "vg_extent_count");
2592     return -1;
2593   }
2594   p = strchrnul (tok, ',');
2595   if (*p) next = p+1; else next = NULL;
2596   *p = '\0';
2597   if (sscanf (tok, "%"SCNi64, &r->vg_extent_count) != 1) {
2598     fprintf (stderr, "%s: failed to parse int '%s' from token %s\n", __func__, tok, "vg_extent_count");
2599     return -1;
2600   }
2601   tok = next;
2602   if (!tok) {
2603     fprintf (stderr, "%s: failed: string finished early, around token %s\n", __func__, "vg_free_count");
2604     return -1;
2605   }
2606   p = strchrnul (tok, ',');
2607   if (*p) next = p+1; else next = NULL;
2608   *p = '\0';
2609   if (sscanf (tok, "%"SCNi64, &r->vg_free_count) != 1) {
2610     fprintf (stderr, "%s: failed to parse int '%s' from token %s\n", __func__, tok, "vg_free_count");
2611     return -1;
2612   }
2613   tok = next;
2614   if (!tok) {
2615     fprintf (stderr, "%s: failed: string finished early, around token %s\n", __func__, "max_lv");
2616     return -1;
2617   }
2618   p = strchrnul (tok, ',');
2619   if (*p) next = p+1; else next = NULL;
2620   *p = '\0';
2621   if (sscanf (tok, "%"SCNi64, &r->max_lv) != 1) {
2622     fprintf (stderr, "%s: failed to parse int '%s' from token %s\n", __func__, tok, "max_lv");
2623     return -1;
2624   }
2625   tok = next;
2626   if (!tok) {
2627     fprintf (stderr, "%s: failed: string finished early, around token %s\n", __func__, "max_pv");
2628     return -1;
2629   }
2630   p = strchrnul (tok, ',');
2631   if (*p) next = p+1; else next = NULL;
2632   *p = '\0';
2633   if (sscanf (tok, "%"SCNi64, &r->max_pv) != 1) {
2634     fprintf (stderr, "%s: failed to parse int '%s' from token %s\n", __func__, tok, "max_pv");
2635     return -1;
2636   }
2637   tok = next;
2638   if (!tok) {
2639     fprintf (stderr, "%s: failed: string finished early, around token %s\n", __func__, "pv_count");
2640     return -1;
2641   }
2642   p = strchrnul (tok, ',');
2643   if (*p) next = p+1; else next = NULL;
2644   *p = '\0';
2645   if (sscanf (tok, "%"SCNi64, &r->pv_count) != 1) {
2646     fprintf (stderr, "%s: failed to parse int '%s' from token %s\n", __func__, tok, "pv_count");
2647     return -1;
2648   }
2649   tok = next;
2650   if (!tok) {
2651     fprintf (stderr, "%s: failed: string finished early, around token %s\n", __func__, "lv_count");
2652     return -1;
2653   }
2654   p = strchrnul (tok, ',');
2655   if (*p) next = p+1; else next = NULL;
2656   *p = '\0';
2657   if (sscanf (tok, "%"SCNi64, &r->lv_count) != 1) {
2658     fprintf (stderr, "%s: failed to parse int '%s' from token %s\n", __func__, tok, "lv_count");
2659     return -1;
2660   }
2661   tok = next;
2662   if (!tok) {
2663     fprintf (stderr, "%s: failed: string finished early, around token %s\n", __func__, "snap_count");
2664     return -1;
2665   }
2666   p = strchrnul (tok, ',');
2667   if (*p) next = p+1; else next = NULL;
2668   *p = '\0';
2669   if (sscanf (tok, "%"SCNi64, &r->snap_count) != 1) {
2670     fprintf (stderr, "%s: failed to parse int '%s' from token %s\n", __func__, tok, "snap_count");
2671     return -1;
2672   }
2673   tok = next;
2674   if (!tok) {
2675     fprintf (stderr, "%s: failed: string finished early, around token %s\n", __func__, "vg_seqno");
2676     return -1;
2677   }
2678   p = strchrnul (tok, ',');
2679   if (*p) next = p+1; else next = NULL;
2680   *p = '\0';
2681   if (sscanf (tok, "%"SCNi64, &r->vg_seqno) != 1) {
2682     fprintf (stderr, "%s: failed to parse int '%s' from token %s\n", __func__, tok, "vg_seqno");
2683     return -1;
2684   }
2685   tok = next;
2686   if (!tok) {
2687     fprintf (stderr, "%s: failed: string finished early, around token %s\n", __func__, "vg_tags");
2688     return -1;
2689   }
2690   p = strchrnul (tok, ',');
2691   if (*p) next = p+1; else next = NULL;
2692   *p = '\0';
2693   r->vg_tags = strdup (tok);
2694   if (r->vg_tags == NULL) {
2695     perror ("strdup");
2696     return -1;
2697   }
2698   tok = next;
2699   if (!tok) {
2700     fprintf (stderr, "%s: failed: string finished early, around token %s\n", __func__, "vg_mda_count");
2701     return -1;
2702   }
2703   p = strchrnul (tok, ',');
2704   if (*p) next = p+1; else next = NULL;
2705   *p = '\0';
2706   if (sscanf (tok, "%"SCNi64, &r->vg_mda_count) != 1) {
2707     fprintf (stderr, "%s: failed to parse int '%s' from token %s\n", __func__, tok, "vg_mda_count");
2708     return -1;
2709   }
2710   tok = next;
2711   if (!tok) {
2712     fprintf (stderr, "%s: failed: string finished early, around token %s\n", __func__, "vg_mda_free");
2713     return -1;
2714   }
2715   p = strchrnul (tok, ',');
2716   if (*p) next = p+1; else next = NULL;
2717   *p = '\0';
2718   if (sscanf (tok, "%"SCNu64, &r->vg_mda_free) != 1) {
2719     fprintf (stderr, "%s: failed to parse size '%s' from token %s\n", __func__, tok, "vg_mda_free");
2720     return -1;
2721   }
2722   tok = next;
2723   if (tok != NULL) {
2724     fprintf (stderr, "%s: failed: extra tokens at end of string\n", __func__);
2725     return -1;
2726   }
2727   return 0;
2728 }
2729
2730 guestfs_lvm_int_vg_list *
2731 parse_command_line_vgs (void)
2732 {
2733   char *out, *err;
2734   char *p, *pend;
2735   int r, i;
2736   guestfs_lvm_int_vg_list *ret;
2737   void *newp;
2738
2739   ret = malloc (sizeof *ret);
2740   if (!ret) {
2741     reply_with_perror ("malloc");
2742     return NULL;
2743   }
2744
2745   ret->guestfs_lvm_int_vg_list_len = 0;
2746   ret->guestfs_lvm_int_vg_list_val = NULL;
2747
2748   r = command (&out, &err,
2749                "/sbin/lvm", "vgs",
2750                "-o", lvm_vg_cols, "--unbuffered", "--noheadings",
2751                "--nosuffix", "--separator", ",", "--units", "b", NULL);
2752   if (r == -1) {
2753     reply_with_error ("%s", err);
2754     free (out);
2755     free (err);
2756     free (ret);
2757     return NULL;
2758   }
2759
2760   free (err);
2761
2762   /* Tokenize each line of the output. */
2763   p = out;
2764   i = 0;
2765   while (p) {
2766     pend = strchr (p, '\n');    /* Get the next line of output. */
2767     if (pend) {
2768       *pend = '\0';
2769       pend++;
2770     }
2771
2772     while (*p && isspace (*p))  /* Skip any leading whitespace. */
2773       p++;
2774
2775     if (!*p) {                  /* Empty line?  Skip it. */
2776       p = pend;
2777       continue;
2778     }
2779
2780     /* Allocate some space to store this next entry. */
2781     newp = realloc (ret->guestfs_lvm_int_vg_list_val,
2782                     sizeof (guestfs_lvm_int_vg) * (i+1));
2783     if (newp == NULL) {
2784       reply_with_perror ("realloc");
2785       free (ret->guestfs_lvm_int_vg_list_val);
2786       free (ret);
2787       free (out);
2788       return NULL;
2789     }
2790     ret->guestfs_lvm_int_vg_list_val = newp;
2791
2792     /* Tokenize the next entry. */
2793     r = lvm_tokenize_vg (p, &ret->guestfs_lvm_int_vg_list_val[i]);
2794     if (r == -1) {
2795       reply_with_error ("failed to parse output of 'vgs' command");
2796       free (ret->guestfs_lvm_int_vg_list_val);
2797       free (ret);
2798       free (out);
2799       return NULL;
2800     }
2801
2802     ++i;
2803     p = pend;
2804   }
2805
2806   ret->guestfs_lvm_int_vg_list_len = i;
2807
2808   free (out);
2809   return ret;
2810 }
2811 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";
2812
2813 static int lvm_tokenize_lv (char *str, struct guestfs_lvm_int_lv *r)
2814 {
2815   char *tok, *p, *next;
2816   int i, j;
2817
2818   if (!str) {
2819     fprintf (stderr, "%s: failed: passed a NULL string\n", __func__);
2820     return -1;
2821   }
2822   if (!*str || isspace (*str)) {
2823     fprintf (stderr, "%s: failed: passed a empty string or one beginning with whitespace\n", __func__);
2824     return -1;
2825   }
2826   tok = str;
2827   if (!tok) {
2828     fprintf (stderr, "%s: failed: string finished early, around token %s\n", __func__, "lv_name");
2829     return -1;
2830   }
2831   p = strchrnul (tok, ',');
2832   if (*p) next = p+1; else next = NULL;
2833   *p = '\0';
2834   r->lv_name = strdup (tok);
2835   if (r->lv_name == NULL) {
2836     perror ("strdup");
2837     return -1;
2838   }
2839   tok = next;
2840   if (!tok) {
2841     fprintf (stderr, "%s: failed: string finished early, around token %s\n", __func__, "lv_uuid");
2842     return -1;
2843   }
2844   p = strchrnul (tok, ',');
2845   if (*p) next = p+1; else next = NULL;
2846   *p = '\0';
2847   for (i = j = 0; i < 32; ++j) {
2848     if (tok[j] == '\0') {
2849       fprintf (stderr, "%s: failed to parse UUID from '%s'\n", __func__, tok);
2850       return -1;
2851     } else if (tok[j] != '-')
2852       r->lv_uuid[i++] = tok[j];
2853   }
2854   tok = next;
2855   if (!tok) {
2856     fprintf (stderr, "%s: failed: string finished early, around token %s\n", __func__, "lv_attr");
2857     return -1;
2858   }
2859   p = strchrnul (tok, ',');
2860   if (*p) next = p+1; else next = NULL;
2861   *p = '\0';
2862   r->lv_attr = strdup (tok);
2863   if (r->lv_attr == NULL) {
2864     perror ("strdup");
2865     return -1;
2866   }
2867   tok = next;
2868   if (!tok) {
2869     fprintf (stderr, "%s: failed: string finished early, around token %s\n", __func__, "lv_major");
2870     return -1;
2871   }
2872   p = strchrnul (tok, ',');
2873   if (*p) next = p+1; else next = NULL;
2874   *p = '\0';
2875   if (sscanf (tok, "%"SCNi64, &r->lv_major) != 1) {
2876     fprintf (stderr, "%s: failed to parse int '%s' from token %s\n", __func__, tok, "lv_major");
2877     return -1;
2878   }
2879   tok = next;
2880   if (!tok) {
2881     fprintf (stderr, "%s: failed: string finished early, around token %s\n", __func__, "lv_minor");
2882     return -1;
2883   }
2884   p = strchrnul (tok, ',');
2885   if (*p) next = p+1; else next = NULL;
2886   *p = '\0';
2887   if (sscanf (tok, "%"SCNi64, &r->lv_minor) != 1) {
2888     fprintf (stderr, "%s: failed to parse int '%s' from token %s\n", __func__, tok, "lv_minor");
2889     return -1;
2890   }
2891   tok = next;
2892   if (!tok) {
2893     fprintf (stderr, "%s: failed: string finished early, around token %s\n", __func__, "lv_kernel_major");
2894     return -1;
2895   }
2896   p = strchrnul (tok, ',');
2897   if (*p) next = p+1; else next = NULL;
2898   *p = '\0';
2899   if (sscanf (tok, "%"SCNi64, &r->lv_kernel_major) != 1) {
2900     fprintf (stderr, "%s: failed to parse int '%s' from token %s\n", __func__, tok, "lv_kernel_major");
2901     return -1;
2902   }
2903   tok = next;
2904   if (!tok) {
2905     fprintf (stderr, "%s: failed: string finished early, around token %s\n", __func__, "lv_kernel_minor");
2906     return -1;
2907   }
2908   p = strchrnul (tok, ',');
2909   if (*p) next = p+1; else next = NULL;
2910   *p = '\0';
2911   if (sscanf (tok, "%"SCNi64, &r->lv_kernel_minor) != 1) {
2912     fprintf (stderr, "%s: failed to parse int '%s' from token %s\n", __func__, tok, "lv_kernel_minor");
2913     return -1;
2914   }
2915   tok = next;
2916   if (!tok) {
2917     fprintf (stderr, "%s: failed: string finished early, around token %s\n", __func__, "lv_size");
2918     return -1;
2919   }
2920   p = strchrnul (tok, ',');
2921   if (*p) next = p+1; else next = NULL;
2922   *p = '\0';
2923   if (sscanf (tok, "%"SCNu64, &r->lv_size) != 1) {
2924     fprintf (stderr, "%s: failed to parse size '%s' from token %s\n", __func__, tok, "lv_size");
2925     return -1;
2926   }
2927   tok = next;
2928   if (!tok) {
2929     fprintf (stderr, "%s: failed: string finished early, around token %s\n", __func__, "seg_count");
2930     return -1;
2931   }
2932   p = strchrnul (tok, ',');
2933   if (*p) next = p+1; else next = NULL;
2934   *p = '\0';
2935   if (sscanf (tok, "%"SCNi64, &r->seg_count) != 1) {
2936     fprintf (stderr, "%s: failed to parse int '%s' from token %s\n", __func__, tok, "seg_count");
2937     return -1;
2938   }
2939   tok = next;
2940   if (!tok) {
2941     fprintf (stderr, "%s: failed: string finished early, around token %s\n", __func__, "origin");
2942     return -1;
2943   }
2944   p = strchrnul (tok, ',');
2945   if (*p) next = p+1; else next = NULL;
2946   *p = '\0';
2947   r->origin = strdup (tok);
2948   if (r->origin == NULL) {
2949     perror ("strdup");
2950     return -1;
2951   }
2952   tok = next;
2953   if (!tok) {
2954     fprintf (stderr, "%s: failed: string finished early, around token %s\n", __func__, "snap_percent");
2955     return -1;
2956   }
2957   p = strchrnul (tok, ',');
2958   if (*p) next = p+1; else next = NULL;
2959   *p = '\0';
2960   if (tok[0] == '\0')
2961     r->snap_percent = -1;
2962   else if (sscanf (tok, "%f", &r->snap_percent) != 1) {
2963     fprintf (stderr, "%s: failed to parse float '%s' from token %s\n", __func__, tok, "snap_percent");
2964     return -1;
2965   }
2966   tok = next;
2967   if (!tok) {
2968     fprintf (stderr, "%s: failed: string finished early, around token %s\n", __func__, "copy_percent");
2969     return -1;
2970   }
2971   p = strchrnul (tok, ',');
2972   if (*p) next = p+1; else next = NULL;
2973   *p = '\0';
2974   if (tok[0] == '\0')
2975     r->copy_percent = -1;
2976   else if (sscanf (tok, "%f", &r->copy_percent) != 1) {
2977     fprintf (stderr, "%s: failed to parse float '%s' from token %s\n", __func__, tok, "copy_percent");
2978     return -1;
2979   }
2980   tok = next;
2981   if (!tok) {
2982     fprintf (stderr, "%s: failed: string finished early, around token %s\n", __func__, "move_pv");
2983     return -1;
2984   }
2985   p = strchrnul (tok, ',');
2986   if (*p) next = p+1; else next = NULL;
2987   *p = '\0';
2988   r->move_pv = strdup (tok);
2989   if (r->move_pv == NULL) {
2990     perror ("strdup");
2991     return -1;
2992   }
2993   tok = next;
2994   if (!tok) {
2995     fprintf (stderr, "%s: failed: string finished early, around token %s\n", __func__, "lv_tags");
2996     return -1;
2997   }
2998   p = strchrnul (tok, ',');
2999   if (*p) next = p+1; else next = NULL;
3000   *p = '\0';
3001   r->lv_tags = strdup (tok);
3002   if (r->lv_tags == NULL) {
3003     perror ("strdup");
3004     return -1;
3005   }
3006   tok = next;
3007   if (!tok) {
3008     fprintf (stderr, "%s: failed: string finished early, around token %s\n", __func__, "mirror_log");
3009     return -1;
3010   }
3011   p = strchrnul (tok, ',');
3012   if (*p) next = p+1; else next = NULL;
3013   *p = '\0';
3014   r->mirror_log = strdup (tok);
3015   if (r->mirror_log == NULL) {
3016     perror ("strdup");
3017     return -1;
3018   }
3019   tok = next;
3020   if (!tok) {
3021     fprintf (stderr, "%s: failed: string finished early, around token %s\n", __func__, "modules");
3022     return -1;
3023   }
3024   p = strchrnul (tok, ',');
3025   if (*p) next = p+1; else next = NULL;
3026   *p = '\0';
3027   r->modules = strdup (tok);
3028   if (r->modules == NULL) {
3029     perror ("strdup");
3030     return -1;
3031   }
3032   tok = next;
3033   if (tok != NULL) {
3034     fprintf (stderr, "%s: failed: extra tokens at end of string\n", __func__);
3035     return -1;
3036   }
3037   return 0;
3038 }
3039
3040 guestfs_lvm_int_lv_list *
3041 parse_command_line_lvs (void)
3042 {
3043   char *out, *err;
3044   char *p, *pend;
3045   int r, i;
3046   guestfs_lvm_int_lv_list *ret;
3047   void *newp;
3048
3049   ret = malloc (sizeof *ret);
3050   if (!ret) {
3051     reply_with_perror ("malloc");
3052     return NULL;
3053   }
3054
3055   ret->guestfs_lvm_int_lv_list_len = 0;
3056   ret->guestfs_lvm_int_lv_list_val = NULL;
3057
3058   r = command (&out, &err,
3059                "/sbin/lvm", "lvs",
3060                "-o", lvm_lv_cols, "--unbuffered", "--noheadings",
3061                "--nosuffix", "--separator", ",", "--units", "b", NULL);
3062   if (r == -1) {
3063     reply_with_error ("%s", err);
3064     free (out);
3065     free (err);
3066     free (ret);
3067     return NULL;
3068   }
3069
3070   free (err);
3071
3072   /* Tokenize each line of the output. */
3073   p = out;
3074   i = 0;
3075   while (p) {
3076     pend = strchr (p, '\n');    /* Get the next line of output. */
3077     if (pend) {
3078       *pend = '\0';
3079       pend++;
3080     }
3081
3082     while (*p && isspace (*p))  /* Skip any leading whitespace. */
3083       p++;
3084
3085     if (!*p) {                  /* Empty line?  Skip it. */
3086       p = pend;
3087       continue;
3088     }
3089
3090     /* Allocate some space to store this next entry. */
3091     newp = realloc (ret->guestfs_lvm_int_lv_list_val,
3092                     sizeof (guestfs_lvm_int_lv) * (i+1));
3093     if (newp == NULL) {
3094       reply_with_perror ("realloc");
3095       free (ret->guestfs_lvm_int_lv_list_val);
3096       free (ret);
3097       free (out);
3098       return NULL;
3099     }
3100     ret->guestfs_lvm_int_lv_list_val = newp;
3101
3102     /* Tokenize the next entry. */
3103     r = lvm_tokenize_lv (p, &ret->guestfs_lvm_int_lv_list_val[i]);
3104     if (r == -1) {
3105       reply_with_error ("failed to parse output of 'lvs' command");
3106       free (ret->guestfs_lvm_int_lv_list_val);
3107       free (ret);
3108       free (out);
3109       return NULL;
3110     }
3111
3112     ++i;
3113     p = pend;
3114   }
3115
3116   ret->guestfs_lvm_int_lv_list_len = i;
3117
3118   free (out);
3119   return ret;
3120 }