src/guestfs-actions.c

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