ruby/ext/guestfs/_guestfs.c

   1 /* libguestfs generated file
   2  * WARNING: THIS FILE IS GENERATED BY 'src/generator.ml'.
   3  * ANY CHANGES YOU MAKE TO THIS FILE WILL BE LOST.
   4  *
   5  * Copyright (C) 2009 Red Hat Inc.
   6  *
   7  * This library is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2 of the License, or (at your option) any later version.
  11  *
  12  * This library is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with this library; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  20  */
  21
  22 #include <stdio.h>
  23 #include <stdlib.h>
  24
  25 #include <ruby.h>
  26
  27 #include "guestfs.h"
  28
  29 #include "extconf.h"
  30
  31 /* For Ruby < 1.9 */
  32 #ifndef RARRAY_LEN
  33 #define RARRAY_LEN(r) (RARRAY((r))->len)
  34 #endif
  35
  36 static VALUE m_guestfs;                 /* guestfs module */
  37 static VALUE c_guestfs;                 /* guestfs_h handle */
  38 static VALUE e_Error;                   /* used for all errors */
  39
  40 static void ruby_guestfs_free (void *p)
  41 {
  42   if (!p) return;
  43   guestfs_close ((guestfs_h *) p);
  44 }
  45
  46 static VALUE ruby_guestfs_create (VALUE m)
  47 {
  48   guestfs_h *g;
  49
  50   g = guestfs_create ();
  51   if (!g)
  52     rb_raise (e_Error, "failed to create guestfs handle");
  53
  54   /* Don't print error messages to stderr by default. */
  55   guestfs_set_error_handler (g, NULL, NULL);
  56
  57   /* Wrap it, and make sure the close function is called when the
  58    * handle goes away.
  59    */
  60   return Data_Wrap_Struct (c_guestfs, NULL, ruby_guestfs_free, g);
  61 }
  62
  63 static VALUE ruby_guestfs_close (VALUE gv)
  64 {
  65   guestfs_h *g;
  66   Data_Get_Struct (gv, guestfs_h, g);
  67
  68   ruby_guestfs_free (g);
  69   DATA_PTR (gv) = NULL;
  70
  71   return Qnil;
  72 }
  73
  74 static VALUE ruby_guestfs_launch (VALUE gv)
  75 {
  76   guestfs_h *g;
  77   Data_Get_Struct (gv, guestfs_h, g);
  78   if (!g)
  79     rb_raise (rb_eArgError, "%s: used handle after closing it", "launch");
  80
  81
  82   int r;
  83
  84   r = guestfs_launch (g);
  85   if (r == -1)
  86     rb_raise (e_Error, "%s", guestfs_last_error (g));
  87
  88   return Qnil;
  89 }
  90
  91 static VALUE ruby_guestfs_wait_ready (VALUE gv)
  92 {
  93   guestfs_h *g;
  94   Data_Get_Struct (gv, guestfs_h, g);
  95   if (!g)
  96     rb_raise (rb_eArgError, "%s: used handle after closing it", "wait_ready");
  97
  98
  99   int r;
 100
 101   r = guestfs_wait_ready (g);
 102   if (r == -1)
 103     rb_raise (e_Error, "%s", guestfs_last_error (g));
 104
 105   return Qnil;
 106 }
 107
 108 static VALUE ruby_guestfs_kill_subprocess (VALUE gv)
 109 {
 110   guestfs_h *g;
 111   Data_Get_Struct (gv, guestfs_h, g);
 112   if (!g)
 113     rb_raise (rb_eArgError, "%s: used handle after closing it", "kill_subprocess");
 114
 115
 116   int r;
 117
 118   r = guestfs_kill_subprocess (g);
 119   if (r == -1)
 120     rb_raise (e_Error, "%s", guestfs_last_error (g));
 121
 122   return Qnil;
 123 }
 124
 125 static VALUE ruby_guestfs_add_drive (VALUE gv, VALUE filenamev)
 126 {
 127   guestfs_h *g;
 128   Data_Get_Struct (gv, guestfs_h, g);
 129   if (!g)
 130     rb_raise (rb_eArgError, "%s: used handle after closing it", "add_drive");
 131
 132   const char *filename = StringValueCStr (filenamev);
 133   if (!filename)
 134     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
 135               "filename", "add_drive");
 136
 137   int r;
 138
 139   r = guestfs_add_drive (g, filename);
 140   if (r == -1)
 141     rb_raise (e_Error, "%s", guestfs_last_error (g));
 142
 143   return Qnil;
 144 }
 145
 146 static VALUE ruby_guestfs_add_cdrom (VALUE gv, VALUE filenamev)
 147 {
 148   guestfs_h *g;
 149   Data_Get_Struct (gv, guestfs_h, g);
 150   if (!g)
 151     rb_raise (rb_eArgError, "%s: used handle after closing it", "add_cdrom");
 152
 153   const char *filename = StringValueCStr (filenamev);
 154   if (!filename)
 155     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
 156               "filename", "add_cdrom");
 157
 158   int r;
 159
 160   r = guestfs_add_cdrom (g, filename);
 161   if (r == -1)
 162     rb_raise (e_Error, "%s", guestfs_last_error (g));
 163
 164   return Qnil;
 165 }
 166
 167 static VALUE ruby_guestfs_config (VALUE gv, VALUE qemuparamv, VALUE qemuvaluev)
 168 {
 169   guestfs_h *g;
 170   Data_Get_Struct (gv, guestfs_h, g);
 171   if (!g)
 172     rb_raise (rb_eArgError, "%s: used handle after closing it", "config");
 173
 174   const char *qemuparam = StringValueCStr (qemuparamv);
 175   if (!qemuparam)
 176     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
 177               "qemuparam", "config");
 178   const char *qemuvalue = StringValueCStr (qemuvaluev);
 179
 180   int r;
 181
 182   r = guestfs_config (g, qemuparam, qemuvalue);
 183   if (r == -1)
 184     rb_raise (e_Error, "%s", guestfs_last_error (g));
 185
 186   return Qnil;
 187 }
 188
 189 static VALUE ruby_guestfs_set_qemu (VALUE gv, VALUE qemuv)
 190 {
 191   guestfs_h *g;
 192   Data_Get_Struct (gv, guestfs_h, g);
 193   if (!g)
 194     rb_raise (rb_eArgError, "%s: used handle after closing it", "set_qemu");
 195
 196   const char *qemu = StringValueCStr (qemuv);
 197   if (!qemu)
 198     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
 199               "qemu", "set_qemu");
 200
 201   int r;
 202
 203   r = guestfs_set_qemu (g, qemu);
 204   if (r == -1)
 205     rb_raise (e_Error, "%s", guestfs_last_error (g));
 206
 207   return Qnil;
 208 }
 209
 210 static VALUE ruby_guestfs_get_qemu (VALUE gv)
 211 {
 212   guestfs_h *g;
 213   Data_Get_Struct (gv, guestfs_h, g);
 214   if (!g)
 215     rb_raise (rb_eArgError, "%s: used handle after closing it", "get_qemu");
 216
 217
 218   const char *r;
 219
 220   r = guestfs_get_qemu (g);
 221   if (r == NULL)
 222     rb_raise (e_Error, "%s", guestfs_last_error (g));
 223
 224   return rb_str_new2 (r);
 225 }
 226
 227 static VALUE ruby_guestfs_set_path (VALUE gv, VALUE pathv)
 228 {
 229   guestfs_h *g;
 230   Data_Get_Struct (gv, guestfs_h, g);
 231   if (!g)
 232     rb_raise (rb_eArgError, "%s: used handle after closing it", "set_path");
 233
 234   const char *path = StringValueCStr (pathv);
 235   if (!path)
 236     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
 237               "path", "set_path");
 238
 239   int r;
 240
 241   r = guestfs_set_path (g, path);
 242   if (r == -1)
 243     rb_raise (e_Error, "%s", guestfs_last_error (g));
 244
 245   return Qnil;
 246 }
 247
 248 static VALUE ruby_guestfs_get_path (VALUE gv)
 249 {
 250   guestfs_h *g;
 251   Data_Get_Struct (gv, guestfs_h, g);
 252   if (!g)
 253     rb_raise (rb_eArgError, "%s: used handle after closing it", "get_path");
 254
 255
 256   const char *r;
 257
 258   r = guestfs_get_path (g);
 259   if (r == NULL)
 260     rb_raise (e_Error, "%s", guestfs_last_error (g));
 261
 262   return rb_str_new2 (r);
 263 }
 264
 265 static VALUE ruby_guestfs_set_autosync (VALUE gv, VALUE autosyncv)
 266 {
 267   guestfs_h *g;
 268   Data_Get_Struct (gv, guestfs_h, g);
 269   if (!g)
 270     rb_raise (rb_eArgError, "%s: used handle after closing it", "set_autosync");
 271
 272   int autosync = NUM2INT (autosyncv);
 273
 274   int r;
 275
 276   r = guestfs_set_autosync (g, autosync);
 277   if (r == -1)
 278     rb_raise (e_Error, "%s", guestfs_last_error (g));
 279
 280   return Qnil;
 281 }
 282
 283 static VALUE ruby_guestfs_get_autosync (VALUE gv)
 284 {
 285   guestfs_h *g;
 286   Data_Get_Struct (gv, guestfs_h, g);
 287   if (!g)
 288     rb_raise (rb_eArgError, "%s: used handle after closing it", "get_autosync");
 289
 290
 291   int r;
 292
 293   r = guestfs_get_autosync (g);
 294   if (r == -1)
 295     rb_raise (e_Error, "%s", guestfs_last_error (g));
 296
 297   return INT2NUM (r);
 298 }
 299
 300 static VALUE ruby_guestfs_set_verbose (VALUE gv, VALUE verbosev)
 301 {
 302   guestfs_h *g;
 303   Data_Get_Struct (gv, guestfs_h, g);
 304   if (!g)
 305     rb_raise (rb_eArgError, "%s: used handle after closing it", "set_verbose");
 306
 307   int verbose = NUM2INT (verbosev);
 308
 309   int r;
 310
 311   r = guestfs_set_verbose (g, verbose);
 312   if (r == -1)
 313     rb_raise (e_Error, "%s", guestfs_last_error (g));
 314
 315   return Qnil;
 316 }
 317
 318 static VALUE ruby_guestfs_get_verbose (VALUE gv)
 319 {
 320   guestfs_h *g;
 321   Data_Get_Struct (gv, guestfs_h, g);
 322   if (!g)
 323     rb_raise (rb_eArgError, "%s: used handle after closing it", "get_verbose");
 324
 325
 326   int r;
 327
 328   r = guestfs_get_verbose (g);
 329   if (r == -1)
 330     rb_raise (e_Error, "%s", guestfs_last_error (g));
 331
 332   return INT2NUM (r);
 333 }
 334
 335 static VALUE ruby_guestfs_is_ready (VALUE gv)
 336 {
 337   guestfs_h *g;
 338   Data_Get_Struct (gv, guestfs_h, g);
 339   if (!g)
 340     rb_raise (rb_eArgError, "%s: used handle after closing it", "is_ready");
 341
 342
 343   int r;
 344
 345   r = guestfs_is_ready (g);
 346   if (r == -1)
 347     rb_raise (e_Error, "%s", guestfs_last_error (g));
 348
 349   return INT2NUM (r);
 350 }
 351
 352 static VALUE ruby_guestfs_is_config (VALUE gv)
 353 {
 354   guestfs_h *g;
 355   Data_Get_Struct (gv, guestfs_h, g);
 356   if (!g)
 357     rb_raise (rb_eArgError, "%s: used handle after closing it", "is_config");
 358
 359
 360   int r;
 361
 362   r = guestfs_is_config (g);
 363   if (r == -1)
 364     rb_raise (e_Error, "%s", guestfs_last_error (g));
 365
 366   return INT2NUM (r);
 367 }
 368
 369 static VALUE ruby_guestfs_is_launching (VALUE gv)
 370 {
 371   guestfs_h *g;
 372   Data_Get_Struct (gv, guestfs_h, g);
 373   if (!g)
 374     rb_raise (rb_eArgError, "%s: used handle after closing it", "is_launching");
 375
 376
 377   int r;
 378
 379   r = guestfs_is_launching (g);
 380   if (r == -1)
 381     rb_raise (e_Error, "%s", guestfs_last_error (g));
 382
 383   return INT2NUM (r);
 384 }
 385
 386 static VALUE ruby_guestfs_is_busy (VALUE gv)
 387 {
 388   guestfs_h *g;
 389   Data_Get_Struct (gv, guestfs_h, g);
 390   if (!g)
 391     rb_raise (rb_eArgError, "%s: used handle after closing it", "is_busy");
 392
 393
 394   int r;
 395
 396   r = guestfs_is_busy (g);
 397   if (r == -1)
 398     rb_raise (e_Error, "%s", guestfs_last_error (g));
 399
 400   return INT2NUM (r);
 401 }
 402
 403 static VALUE ruby_guestfs_get_state (VALUE gv)
 404 {
 405   guestfs_h *g;
 406   Data_Get_Struct (gv, guestfs_h, g);
 407   if (!g)
 408     rb_raise (rb_eArgError, "%s: used handle after closing it", "get_state");
 409
 410
 411   int r;
 412
 413   r = guestfs_get_state (g);
 414   if (r == -1)
 415     rb_raise (e_Error, "%s", guestfs_last_error (g));
 416
 417   return INT2NUM (r);
 418 }
 419
 420 static VALUE ruby_guestfs_set_busy (VALUE gv)
 421 {
 422   guestfs_h *g;
 423   Data_Get_Struct (gv, guestfs_h, g);
 424   if (!g)
 425     rb_raise (rb_eArgError, "%s: used handle after closing it", "set_busy");
 426
 427
 428   int r;
 429
 430   r = guestfs_set_busy (g);
 431   if (r == -1)
 432     rb_raise (e_Error, "%s", guestfs_last_error (g));
 433
 434   return Qnil;
 435 }
 436
 437 static VALUE ruby_guestfs_set_ready (VALUE gv)
 438 {
 439   guestfs_h *g;
 440   Data_Get_Struct (gv, guestfs_h, g);
 441   if (!g)
 442     rb_raise (rb_eArgError, "%s: used handle after closing it", "set_ready");
 443
 444
 445   int r;
 446
 447   r = guestfs_set_ready (g);
 448   if (r == -1)
 449     rb_raise (e_Error, "%s", guestfs_last_error (g));
 450
 451   return Qnil;
 452 }
 453
 454 static VALUE ruby_guestfs_end_busy (VALUE gv)
 455 {
 456   guestfs_h *g;
 457   Data_Get_Struct (gv, guestfs_h, g);
 458   if (!g)
 459     rb_raise (rb_eArgError, "%s: used handle after closing it", "end_busy");
 460
 461
 462   int r;
 463
 464   r = guestfs_end_busy (g);
 465   if (r == -1)
 466     rb_raise (e_Error, "%s", guestfs_last_error (g));
 467
 468   return Qnil;
 469 }
 470
 471 static VALUE ruby_guestfs_mount (VALUE gv, VALUE devicev, VALUE mountpointv)
 472 {
 473   guestfs_h *g;
 474   Data_Get_Struct (gv, guestfs_h, g);
 475   if (!g)
 476     rb_raise (rb_eArgError, "%s: used handle after closing it", "mount");
 477
 478   const char *device = StringValueCStr (devicev);
 479   if (!device)
 480     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
 481               "device", "mount");
 482   const char *mountpoint = StringValueCStr (mountpointv);
 483   if (!mountpoint)
 484     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
 485               "mountpoint", "mount");
 486
 487   int r;
 488
 489   r = guestfs_mount (g, device, mountpoint);
 490   if (r == -1)
 491     rb_raise (e_Error, "%s", guestfs_last_error (g));
 492
 493   return Qnil;
 494 }
 495
 496 static VALUE ruby_guestfs_sync (VALUE gv)
 497 {
 498   guestfs_h *g;
 499   Data_Get_Struct (gv, guestfs_h, g);
 500   if (!g)
 501     rb_raise (rb_eArgError, "%s: used handle after closing it", "sync");
 502
 503
 504   int r;
 505
 506   r = guestfs_sync (g);
 507   if (r == -1)
 508     rb_raise (e_Error, "%s", guestfs_last_error (g));
 509
 510   return Qnil;
 511 }
 512
 513 static VALUE ruby_guestfs_touch (VALUE gv, VALUE pathv)
 514 {
 515   guestfs_h *g;
 516   Data_Get_Struct (gv, guestfs_h, g);
 517   if (!g)
 518     rb_raise (rb_eArgError, "%s: used handle after closing it", "touch");
 519
 520   const char *path = StringValueCStr (pathv);
 521   if (!path)
 522     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
 523               "path", "touch");
 524
 525   int r;
 526
 527   r = guestfs_touch (g, path);
 528   if (r == -1)
 529     rb_raise (e_Error, "%s", guestfs_last_error (g));
 530
 531   return Qnil;
 532 }
 533
 534 static VALUE ruby_guestfs_cat (VALUE gv, VALUE pathv)
 535 {
 536   guestfs_h *g;
 537   Data_Get_Struct (gv, guestfs_h, g);
 538   if (!g)
 539     rb_raise (rb_eArgError, "%s: used handle after closing it", "cat");
 540
 541   const char *path = StringValueCStr (pathv);
 542   if (!path)
 543     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
 544               "path", "cat");
 545
 546   char *r;
 547
 548   r = guestfs_cat (g, path);
 549   if (r == NULL)
 550     rb_raise (e_Error, "%s", guestfs_last_error (g));
 551
 552   VALUE rv = rb_str_new2 (r);
 553   free (r);
 554   return rv;
 555 }
 556
 557 static VALUE ruby_guestfs_ll (VALUE gv, VALUE directoryv)
 558 {
 559   guestfs_h *g;
 560   Data_Get_Struct (gv, guestfs_h, g);
 561   if (!g)
 562     rb_raise (rb_eArgError, "%s: used handle after closing it", "ll");
 563
 564   const char *directory = StringValueCStr (directoryv);
 565   if (!directory)
 566     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
 567               "directory", "ll");
 568
 569   char *r;
 570
 571   r = guestfs_ll (g, directory);
 572   if (r == NULL)
 573     rb_raise (e_Error, "%s", guestfs_last_error (g));
 574
 575   VALUE rv = rb_str_new2 (r);
 576   free (r);
 577   return rv;
 578 }
 579
 580 static VALUE ruby_guestfs_ls (VALUE gv, VALUE directoryv)
 581 {
 582   guestfs_h *g;
 583   Data_Get_Struct (gv, guestfs_h, g);
 584   if (!g)
 585     rb_raise (rb_eArgError, "%s: used handle after closing it", "ls");
 586
 587   const char *directory = StringValueCStr (directoryv);
 588   if (!directory)
 589     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
 590               "directory", "ls");
 591
 592   char **r;
 593
 594   r = guestfs_ls (g, directory);
 595   if (r == NULL)
 596     rb_raise (e_Error, "%s", guestfs_last_error (g));
 597
 598   int i, len = 0;
 599   for (i = 0; r[i] != NULL; ++i) len++;
 600   VALUE rv = rb_ary_new2 (len);
 601   for (i = 0; r[i] != NULL; ++i) {
 602     rb_ary_push (rv, rb_str_new2 (r[i]));
 603     free (r[i]);
 604   }
 605   free (r);
 606   return rv;
 607 }
 608
 609 static VALUE ruby_guestfs_list_devices (VALUE gv)
 610 {
 611   guestfs_h *g;
 612   Data_Get_Struct (gv, guestfs_h, g);
 613   if (!g)
 614     rb_raise (rb_eArgError, "%s: used handle after closing it", "list_devices");
 615
 616
 617   char **r;
 618
 619   r = guestfs_list_devices (g);
 620   if (r == NULL)
 621     rb_raise (e_Error, "%s", guestfs_last_error (g));
 622
 623   int i, len = 0;
 624   for (i = 0; r[i] != NULL; ++i) len++;
 625   VALUE rv = rb_ary_new2 (len);
 626   for (i = 0; r[i] != NULL; ++i) {
 627     rb_ary_push (rv, rb_str_new2 (r[i]));
 628     free (r[i]);
 629   }
 630   free (r);
 631   return rv;
 632 }
 633
 634 static VALUE ruby_guestfs_list_partitions (VALUE gv)
 635 {
 636   guestfs_h *g;
 637   Data_Get_Struct (gv, guestfs_h, g);
 638   if (!g)
 639     rb_raise (rb_eArgError, "%s: used handle after closing it", "list_partitions");
 640
 641
 642   char **r;
 643
 644   r = guestfs_list_partitions (g);
 645   if (r == NULL)
 646     rb_raise (e_Error, "%s", guestfs_last_error (g));
 647
 648   int i, len = 0;
 649   for (i = 0; r[i] != NULL; ++i) len++;
 650   VALUE rv = rb_ary_new2 (len);
 651   for (i = 0; r[i] != NULL; ++i) {
 652     rb_ary_push (rv, rb_str_new2 (r[i]));
 653     free (r[i]);
 654   }
 655   free (r);
 656   return rv;
 657 }
 658
 659 static VALUE ruby_guestfs_pvs (VALUE gv)
 660 {
 661   guestfs_h *g;
 662   Data_Get_Struct (gv, guestfs_h, g);
 663   if (!g)
 664     rb_raise (rb_eArgError, "%s: used handle after closing it", "pvs");
 665
 666
 667   char **r;
 668
 669   r = guestfs_pvs (g);
 670   if (r == NULL)
 671     rb_raise (e_Error, "%s", guestfs_last_error (g));
 672
 673   int i, len = 0;
 674   for (i = 0; r[i] != NULL; ++i) len++;
 675   VALUE rv = rb_ary_new2 (len);
 676   for (i = 0; r[i] != NULL; ++i) {
 677     rb_ary_push (rv, rb_str_new2 (r[i]));
 678     free (r[i]);
 679   }
 680   free (r);
 681   return rv;
 682 }
 683
 684 static VALUE ruby_guestfs_vgs (VALUE gv)
 685 {
 686   guestfs_h *g;
 687   Data_Get_Struct (gv, guestfs_h, g);
 688   if (!g)
 689     rb_raise (rb_eArgError, "%s: used handle after closing it", "vgs");
 690
 691
 692   char **r;
 693
 694   r = guestfs_vgs (g);
 695   if (r == NULL)
 696     rb_raise (e_Error, "%s", guestfs_last_error (g));
 697
 698   int i, len = 0;
 699   for (i = 0; r[i] != NULL; ++i) len++;
 700   VALUE rv = rb_ary_new2 (len);
 701   for (i = 0; r[i] != NULL; ++i) {
 702     rb_ary_push (rv, rb_str_new2 (r[i]));
 703     free (r[i]);
 704   }
 705   free (r);
 706   return rv;
 707 }
 708
 709 static VALUE ruby_guestfs_lvs (VALUE gv)
 710 {
 711   guestfs_h *g;
 712   Data_Get_Struct (gv, guestfs_h, g);
 713   if (!g)
 714     rb_raise (rb_eArgError, "%s: used handle after closing it", "lvs");
 715
 716
 717   char **r;
 718
 719   r = guestfs_lvs (g);
 720   if (r == NULL)
 721     rb_raise (e_Error, "%s", guestfs_last_error (g));
 722
 723   int i, len = 0;
 724   for (i = 0; r[i] != NULL; ++i) len++;
 725   VALUE rv = rb_ary_new2 (len);
 726   for (i = 0; r[i] != NULL; ++i) {
 727     rb_ary_push (rv, rb_str_new2 (r[i]));
 728     free (r[i]);
 729   }
 730   free (r);
 731   return rv;
 732 }
 733
 734 static VALUE ruby_guestfs_pvs_full (VALUE gv)
 735 {
 736   guestfs_h *g;
 737   Data_Get_Struct (gv, guestfs_h, g);
 738   if (!g)
 739     rb_raise (rb_eArgError, "%s: used handle after closing it", "pvs_full");
 740
 741
 742   struct guestfs_lvm_pv_list *r;
 743
 744   r = guestfs_pvs_full (g);
 745   if (r == NULL)
 746     rb_raise (e_Error, "%s", guestfs_last_error (g));
 747
 748   VALUE rv = rb_ary_new2 (r->len);
 749   int i;
 750   for (i = 0; i < r->len; ++i) {
 751     VALUE hv = rb_hash_new ();
 752     rb_hash_aset (rv, rb_str_new2 ("pv_name"), rb_str_new2 (r->val[i].pv_name));
 753     rb_hash_aset (rv, rb_str_new2 ("pv_uuid"), rb_str_new (r->val[i].pv_uuid, 32));
 754     rb_hash_aset (rv, rb_str_new2 ("pv_fmt"), rb_str_new2 (r->val[i].pv_fmt));
 755     rb_hash_aset (rv, rb_str_new2 ("pv_size"), ULL2NUM (r->val[i].pv_size));
 756     rb_hash_aset (rv, rb_str_new2 ("dev_size"), ULL2NUM (r->val[i].dev_size));
 757     rb_hash_aset (rv, rb_str_new2 ("pv_free"), ULL2NUM (r->val[i].pv_free));
 758     rb_hash_aset (rv, rb_str_new2 ("pv_used"), ULL2NUM (r->val[i].pv_used));
 759     rb_hash_aset (rv, rb_str_new2 ("pv_attr"), rb_str_new2 (r->val[i].pv_attr));
 760     rb_hash_aset (rv, rb_str_new2 ("pv_pe_count"), ULL2NUM (r->val[i].pv_pe_count));
 761     rb_hash_aset (rv, rb_str_new2 ("pv_pe_alloc_count"), ULL2NUM (r->val[i].pv_pe_alloc_count));
 762     rb_hash_aset (rv, rb_str_new2 ("pv_tags"), rb_str_new2 (r->val[i].pv_tags));
 763     rb_hash_aset (rv, rb_str_new2 ("pe_start"), ULL2NUM (r->val[i].pe_start));
 764     rb_hash_aset (rv, rb_str_new2 ("pv_mda_count"), ULL2NUM (r->val[i].pv_mda_count));
 765     rb_hash_aset (rv, rb_str_new2 ("pv_mda_free"), ULL2NUM (r->val[i].pv_mda_free));
 766     rb_ary_push (rv, hv);
 767   }
 768   guestfs_free_lvm_pv_list (r);
 769   return rv;
 770 }
 771
 772 static VALUE ruby_guestfs_vgs_full (VALUE gv)
 773 {
 774   guestfs_h *g;
 775   Data_Get_Struct (gv, guestfs_h, g);
 776   if (!g)
 777     rb_raise (rb_eArgError, "%s: used handle after closing it", "vgs_full");
 778
 779
 780   struct guestfs_lvm_vg_list *r;
 781
 782   r = guestfs_vgs_full (g);
 783   if (r == NULL)
 784     rb_raise (e_Error, "%s", guestfs_last_error (g));
 785
 786   VALUE rv = rb_ary_new2 (r->len);
 787   int i;
 788   for (i = 0; i < r->len; ++i) {
 789     VALUE hv = rb_hash_new ();
 790     rb_hash_aset (rv, rb_str_new2 ("vg_name"), rb_str_new2 (r->val[i].vg_name));
 791     rb_hash_aset (rv, rb_str_new2 ("vg_uuid"), rb_str_new (r->val[i].vg_uuid, 32));
 792     rb_hash_aset (rv, rb_str_new2 ("vg_fmt"), rb_str_new2 (r->val[i].vg_fmt));
 793     rb_hash_aset (rv, rb_str_new2 ("vg_attr"), rb_str_new2 (r->val[i].vg_attr));
 794     rb_hash_aset (rv, rb_str_new2 ("vg_size"), ULL2NUM (r->val[i].vg_size));
 795     rb_hash_aset (rv, rb_str_new2 ("vg_free"), ULL2NUM (r->val[i].vg_free));
 796     rb_hash_aset (rv, rb_str_new2 ("vg_sysid"), rb_str_new2 (r->val[i].vg_sysid));
 797     rb_hash_aset (rv, rb_str_new2 ("vg_extent_size"), ULL2NUM (r->val[i].vg_extent_size));
 798     rb_hash_aset (rv, rb_str_new2 ("vg_extent_count"), ULL2NUM (r->val[i].vg_extent_count));
 799     rb_hash_aset (rv, rb_str_new2 ("vg_free_count"), ULL2NUM (r->val[i].vg_free_count));
 800     rb_hash_aset (rv, rb_str_new2 ("max_lv"), ULL2NUM (r->val[i].max_lv));
 801     rb_hash_aset (rv, rb_str_new2 ("max_pv"), ULL2NUM (r->val[i].max_pv));
 802     rb_hash_aset (rv, rb_str_new2 ("pv_count"), ULL2NUM (r->val[i].pv_count));
 803     rb_hash_aset (rv, rb_str_new2 ("lv_count"), ULL2NUM (r->val[i].lv_count));
 804     rb_hash_aset (rv, rb_str_new2 ("snap_count"), ULL2NUM (r->val[i].snap_count));
 805     rb_hash_aset (rv, rb_str_new2 ("vg_seqno"), ULL2NUM (r->val[i].vg_seqno));
 806     rb_hash_aset (rv, rb_str_new2 ("vg_tags"), rb_str_new2 (r->val[i].vg_tags));
 807     rb_hash_aset (rv, rb_str_new2 ("vg_mda_count"), ULL2NUM (r->val[i].vg_mda_count));
 808     rb_hash_aset (rv, rb_str_new2 ("vg_mda_free"), ULL2NUM (r->val[i].vg_mda_free));
 809     rb_ary_push (rv, hv);
 810   }
 811   guestfs_free_lvm_vg_list (r);
 812   return rv;
 813 }
 814
 815 static VALUE ruby_guestfs_lvs_full (VALUE gv)
 816 {
 817   guestfs_h *g;
 818   Data_Get_Struct (gv, guestfs_h, g);
 819   if (!g)
 820     rb_raise (rb_eArgError, "%s: used handle after closing it", "lvs_full");
 821
 822
 823   struct guestfs_lvm_lv_list *r;
 824
 825   r = guestfs_lvs_full (g);
 826   if (r == NULL)
 827     rb_raise (e_Error, "%s", guestfs_last_error (g));
 828
 829   VALUE rv = rb_ary_new2 (r->len);
 830   int i;
 831   for (i = 0; i < r->len; ++i) {
 832     VALUE hv = rb_hash_new ();
 833     rb_hash_aset (rv, rb_str_new2 ("lv_name"), rb_str_new2 (r->val[i].lv_name));
 834     rb_hash_aset (rv, rb_str_new2 ("lv_uuid"), rb_str_new (r->val[i].lv_uuid, 32));
 835     rb_hash_aset (rv, rb_str_new2 ("lv_attr"), rb_str_new2 (r->val[i].lv_attr));
 836     rb_hash_aset (rv, rb_str_new2 ("lv_major"), ULL2NUM (r->val[i].lv_major));
 837     rb_hash_aset (rv, rb_str_new2 ("lv_minor"), ULL2NUM (r->val[i].lv_minor));
 838     rb_hash_aset (rv, rb_str_new2 ("lv_kernel_major"), ULL2NUM (r->val[i].lv_kernel_major));
 839     rb_hash_aset (rv, rb_str_new2 ("lv_kernel_minor"), ULL2NUM (r->val[i].lv_kernel_minor));
 840     rb_hash_aset (rv, rb_str_new2 ("lv_size"), ULL2NUM (r->val[i].lv_size));
 841     rb_hash_aset (rv, rb_str_new2 ("seg_count"), ULL2NUM (r->val[i].seg_count));
 842     rb_hash_aset (rv, rb_str_new2 ("origin"), rb_str_new2 (r->val[i].origin));
 843     rb_hash_aset (rv, rb_str_new2 ("snap_percent"), rb_dbl2big (r->val[i].snap_percent));
 844     rb_hash_aset (rv, rb_str_new2 ("copy_percent"), rb_dbl2big (r->val[i].copy_percent));
 845     rb_hash_aset (rv, rb_str_new2 ("move_pv"), rb_str_new2 (r->val[i].move_pv));
 846     rb_hash_aset (rv, rb_str_new2 ("lv_tags"), rb_str_new2 (r->val[i].lv_tags));
 847     rb_hash_aset (rv, rb_str_new2 ("mirror_log"), rb_str_new2 (r->val[i].mirror_log));
 848     rb_hash_aset (rv, rb_str_new2 ("modules"), rb_str_new2 (r->val[i].modules));
 849     rb_ary_push (rv, hv);
 850   }
 851   guestfs_free_lvm_lv_list (r);
 852   return rv;
 853 }
 854
 855 static VALUE ruby_guestfs_read_lines (VALUE gv, VALUE pathv)
 856 {
 857   guestfs_h *g;
 858   Data_Get_Struct (gv, guestfs_h, g);
 859   if (!g)
 860     rb_raise (rb_eArgError, "%s: used handle after closing it", "read_lines");
 861
 862   const char *path = StringValueCStr (pathv);
 863   if (!path)
 864     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
 865               "path", "read_lines");
 866
 867   char **r;
 868
 869   r = guestfs_read_lines (g, path);
 870   if (r == NULL)
 871     rb_raise (e_Error, "%s", guestfs_last_error (g));
 872
 873   int i, len = 0;
 874   for (i = 0; r[i] != NULL; ++i) len++;
 875   VALUE rv = rb_ary_new2 (len);
 876   for (i = 0; r[i] != NULL; ++i) {
 877     rb_ary_push (rv, rb_str_new2 (r[i]));
 878     free (r[i]);
 879   }
 880   free (r);
 881   return rv;
 882 }
 883
 884 static VALUE ruby_guestfs_aug_init (VALUE gv, VALUE rootv, VALUE flagsv)
 885 {
 886   guestfs_h *g;
 887   Data_Get_Struct (gv, guestfs_h, g);
 888   if (!g)
 889     rb_raise (rb_eArgError, "%s: used handle after closing it", "aug_init");
 890
 891   const char *root = StringValueCStr (rootv);
 892   if (!root)
 893     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
 894               "root", "aug_init");
 895   int flags = NUM2INT (flagsv);
 896
 897   int r;
 898
 899   r = guestfs_aug_init (g, root, flags);
 900   if (r == -1)
 901     rb_raise (e_Error, "%s", guestfs_last_error (g));
 902
 903   return Qnil;
 904 }
 905
 906 static VALUE ruby_guestfs_aug_close (VALUE gv)
 907 {
 908   guestfs_h *g;
 909   Data_Get_Struct (gv, guestfs_h, g);
 910   if (!g)
 911     rb_raise (rb_eArgError, "%s: used handle after closing it", "aug_close");
 912
 913
 914   int r;
 915
 916   r = guestfs_aug_close (g);
 917   if (r == -1)
 918     rb_raise (e_Error, "%s", guestfs_last_error (g));
 919
 920   return Qnil;
 921 }
 922
 923 static VALUE ruby_guestfs_aug_defvar (VALUE gv, VALUE namev, VALUE exprv)
 924 {
 925   guestfs_h *g;
 926   Data_Get_Struct (gv, guestfs_h, g);
 927   if (!g)
 928     rb_raise (rb_eArgError, "%s: used handle after closing it", "aug_defvar");
 929
 930   const char *name = StringValueCStr (namev);
 931   if (!name)
 932     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
 933               "name", "aug_defvar");
 934   const char *expr = StringValueCStr (exprv);
 935
 936   int r;
 937
 938   r = guestfs_aug_defvar (g, name, expr);
 939   if (r == -1)
 940     rb_raise (e_Error, "%s", guestfs_last_error (g));
 941
 942   return INT2NUM (r);
 943 }
 944
 945 static VALUE ruby_guestfs_aug_defnode (VALUE gv, VALUE namev, VALUE exprv, VALUE valv)
 946 {
 947   guestfs_h *g;
 948   Data_Get_Struct (gv, guestfs_h, g);
 949   if (!g)
 950     rb_raise (rb_eArgError, "%s: used handle after closing it", "aug_defnode");
 951
 952   const char *name = StringValueCStr (namev);
 953   if (!name)
 954     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
 955               "name", "aug_defnode");
 956   const char *expr = StringValueCStr (exprv);
 957   if (!expr)
 958     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
 959               "expr", "aug_defnode");
 960   const char *val = StringValueCStr (valv);
 961   if (!val)
 962     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
 963               "val", "aug_defnode");
 964
 965   struct guestfs_int_bool *r;
 966
 967   r = guestfs_aug_defnode (g, name, expr, val);
 968   if (r == NULL)
 969     rb_raise (e_Error, "%s", guestfs_last_error (g));
 970
 971   VALUE rv = rb_ary_new2 (2);
 972   rb_ary_push (rv, INT2NUM (r->i));
 973   rb_ary_push (rv, INT2NUM (r->b));
 974   guestfs_free_int_bool (r);
 975   return rv;
 976 }
 977
 978 static VALUE ruby_guestfs_aug_get (VALUE gv, VALUE pathv)
 979 {
 980   guestfs_h *g;
 981   Data_Get_Struct (gv, guestfs_h, g);
 982   if (!g)
 983     rb_raise (rb_eArgError, "%s: used handle after closing it", "aug_get");
 984
 985   const char *path = StringValueCStr (pathv);
 986   if (!path)
 987     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
 988               "path", "aug_get");
 989
 990   char *r;
 991
 992   r = guestfs_aug_get (g, path);
 993   if (r == NULL)
 994     rb_raise (e_Error, "%s", guestfs_last_error (g));
 995
 996   VALUE rv = rb_str_new2 (r);
 997   free (r);
 998   return rv;
 999 }
1000
1001 static VALUE ruby_guestfs_aug_set (VALUE gv, VALUE pathv, VALUE valv)
1002 {
1003   guestfs_h *g;
1004   Data_Get_Struct (gv, guestfs_h, g);
1005   if (!g)
1006     rb_raise (rb_eArgError, "%s: used handle after closing it", "aug_set");
1007
1008   const char *path = StringValueCStr (pathv);
1009   if (!path)
1010     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1011               "path", "aug_set");
1012   const char *val = StringValueCStr (valv);
1013   if (!val)
1014     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1015               "val", "aug_set");
1016
1017   int r;
1018
1019   r = guestfs_aug_set (g, path, val);
1020   if (r == -1)
1021     rb_raise (e_Error, "%s", guestfs_last_error (g));
1022
1023   return Qnil;
1024 }
1025
1026 static VALUE ruby_guestfs_aug_insert (VALUE gv, VALUE pathv, VALUE labelv, VALUE beforev)
1027 {
1028   guestfs_h *g;
1029   Data_Get_Struct (gv, guestfs_h, g);
1030   if (!g)
1031     rb_raise (rb_eArgError, "%s: used handle after closing it", "aug_insert");
1032
1033   const char *path = StringValueCStr (pathv);
1034   if (!path)
1035     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1036               "path", "aug_insert");
1037   const char *label = StringValueCStr (labelv);
1038   if (!label)
1039     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1040               "label", "aug_insert");
1041   int before = NUM2INT (beforev);
1042
1043   int r;
1044
1045   r = guestfs_aug_insert (g, path, label, before);
1046   if (r == -1)
1047     rb_raise (e_Error, "%s", guestfs_last_error (g));
1048
1049   return Qnil;
1050 }
1051
1052 static VALUE ruby_guestfs_aug_rm (VALUE gv, VALUE pathv)
1053 {
1054   guestfs_h *g;
1055   Data_Get_Struct (gv, guestfs_h, g);
1056   if (!g)
1057     rb_raise (rb_eArgError, "%s: used handle after closing it", "aug_rm");
1058
1059   const char *path = StringValueCStr (pathv);
1060   if (!path)
1061     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1062               "path", "aug_rm");
1063
1064   int r;
1065
1066   r = guestfs_aug_rm (g, path);
1067   if (r == -1)
1068     rb_raise (e_Error, "%s", guestfs_last_error (g));
1069
1070   return INT2NUM (r);
1071 }
1072
1073 static VALUE ruby_guestfs_aug_mv (VALUE gv, VALUE srcv, VALUE destv)
1074 {
1075   guestfs_h *g;
1076   Data_Get_Struct (gv, guestfs_h, g);
1077   if (!g)
1078     rb_raise (rb_eArgError, "%s: used handle after closing it", "aug_mv");
1079
1080   const char *src = StringValueCStr (srcv);
1081   if (!src)
1082     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1083               "src", "aug_mv");
1084   const char *dest = StringValueCStr (destv);
1085   if (!dest)
1086     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1087               "dest", "aug_mv");
1088
1089   int r;
1090
1091   r = guestfs_aug_mv (g, src, dest);
1092   if (r == -1)
1093     rb_raise (e_Error, "%s", guestfs_last_error (g));
1094
1095   return Qnil;
1096 }
1097
1098 static VALUE ruby_guestfs_aug_match (VALUE gv, VALUE pathv)
1099 {
1100   guestfs_h *g;
1101   Data_Get_Struct (gv, guestfs_h, g);
1102   if (!g)
1103     rb_raise (rb_eArgError, "%s: used handle after closing it", "aug_match");
1104
1105   const char *path = StringValueCStr (pathv);
1106   if (!path)
1107     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1108               "path", "aug_match");
1109
1110   char **r;
1111
1112   r = guestfs_aug_match (g, path);
1113   if (r == NULL)
1114     rb_raise (e_Error, "%s", guestfs_last_error (g));
1115
1116   int i, len = 0;
1117   for (i = 0; r[i] != NULL; ++i) len++;
1118   VALUE rv = rb_ary_new2 (len);
1119   for (i = 0; r[i] != NULL; ++i) {
1120     rb_ary_push (rv, rb_str_new2 (r[i]));
1121     free (r[i]);
1122   }
1123   free (r);
1124   return rv;
1125 }
1126
1127 static VALUE ruby_guestfs_aug_save (VALUE gv)
1128 {
1129   guestfs_h *g;
1130   Data_Get_Struct (gv, guestfs_h, g);
1131   if (!g)
1132     rb_raise (rb_eArgError, "%s: used handle after closing it", "aug_save");
1133
1134
1135   int r;
1136
1137   r = guestfs_aug_save (g);
1138   if (r == -1)
1139     rb_raise (e_Error, "%s", guestfs_last_error (g));
1140
1141   return Qnil;
1142 }
1143
1144 static VALUE ruby_guestfs_aug_load (VALUE gv)
1145 {
1146   guestfs_h *g;
1147   Data_Get_Struct (gv, guestfs_h, g);
1148   if (!g)
1149     rb_raise (rb_eArgError, "%s: used handle after closing it", "aug_load");
1150
1151
1152   int r;
1153
1154   r = guestfs_aug_load (g);
1155   if (r == -1)
1156     rb_raise (e_Error, "%s", guestfs_last_error (g));
1157
1158   return Qnil;
1159 }
1160
1161 static VALUE ruby_guestfs_aug_ls (VALUE gv, VALUE pathv)
1162 {
1163   guestfs_h *g;
1164   Data_Get_Struct (gv, guestfs_h, g);
1165   if (!g)
1166     rb_raise (rb_eArgError, "%s: used handle after closing it", "aug_ls");
1167
1168   const char *path = StringValueCStr (pathv);
1169   if (!path)
1170     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1171               "path", "aug_ls");
1172
1173   char **r;
1174
1175   r = guestfs_aug_ls (g, path);
1176   if (r == NULL)
1177     rb_raise (e_Error, "%s", guestfs_last_error (g));
1178
1179   int i, len = 0;
1180   for (i = 0; r[i] != NULL; ++i) len++;
1181   VALUE rv = rb_ary_new2 (len);
1182   for (i = 0; r[i] != NULL; ++i) {
1183     rb_ary_push (rv, rb_str_new2 (r[i]));
1184     free (r[i]);
1185   }
1186   free (r);
1187   return rv;
1188 }
1189
1190 static VALUE ruby_guestfs_rm (VALUE gv, VALUE pathv)
1191 {
1192   guestfs_h *g;
1193   Data_Get_Struct (gv, guestfs_h, g);
1194   if (!g)
1195     rb_raise (rb_eArgError, "%s: used handle after closing it", "rm");
1196
1197   const char *path = StringValueCStr (pathv);
1198   if (!path)
1199     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1200               "path", "rm");
1201
1202   int r;
1203
1204   r = guestfs_rm (g, path);
1205   if (r == -1)
1206     rb_raise (e_Error, "%s", guestfs_last_error (g));
1207
1208   return Qnil;
1209 }
1210
1211 static VALUE ruby_guestfs_rmdir (VALUE gv, VALUE pathv)
1212 {
1213   guestfs_h *g;
1214   Data_Get_Struct (gv, guestfs_h, g);
1215   if (!g)
1216     rb_raise (rb_eArgError, "%s: used handle after closing it", "rmdir");
1217
1218   const char *path = StringValueCStr (pathv);
1219   if (!path)
1220     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1221               "path", "rmdir");
1222
1223   int r;
1224
1225   r = guestfs_rmdir (g, path);
1226   if (r == -1)
1227     rb_raise (e_Error, "%s", guestfs_last_error (g));
1228
1229   return Qnil;
1230 }
1231
1232 static VALUE ruby_guestfs_rm_rf (VALUE gv, VALUE pathv)
1233 {
1234   guestfs_h *g;
1235   Data_Get_Struct (gv, guestfs_h, g);
1236   if (!g)
1237     rb_raise (rb_eArgError, "%s: used handle after closing it", "rm_rf");
1238
1239   const char *path = StringValueCStr (pathv);
1240   if (!path)
1241     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1242               "path", "rm_rf");
1243
1244   int r;
1245
1246   r = guestfs_rm_rf (g, path);
1247   if (r == -1)
1248     rb_raise (e_Error, "%s", guestfs_last_error (g));
1249
1250   return Qnil;
1251 }
1252
1253 static VALUE ruby_guestfs_mkdir (VALUE gv, VALUE pathv)
1254 {
1255   guestfs_h *g;
1256   Data_Get_Struct (gv, guestfs_h, g);
1257   if (!g)
1258     rb_raise (rb_eArgError, "%s: used handle after closing it", "mkdir");
1259
1260   const char *path = StringValueCStr (pathv);
1261   if (!path)
1262     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1263               "path", "mkdir");
1264
1265   int r;
1266
1267   r = guestfs_mkdir (g, path);
1268   if (r == -1)
1269     rb_raise (e_Error, "%s", guestfs_last_error (g));
1270
1271   return Qnil;
1272 }
1273
1274 static VALUE ruby_guestfs_mkdir_p (VALUE gv, VALUE pathv)
1275 {
1276   guestfs_h *g;
1277   Data_Get_Struct (gv, guestfs_h, g);
1278   if (!g)
1279     rb_raise (rb_eArgError, "%s: used handle after closing it", "mkdir_p");
1280
1281   const char *path = StringValueCStr (pathv);
1282   if (!path)
1283     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1284               "path", "mkdir_p");
1285
1286   int r;
1287
1288   r = guestfs_mkdir_p (g, path);
1289   if (r == -1)
1290     rb_raise (e_Error, "%s", guestfs_last_error (g));
1291
1292   return Qnil;
1293 }
1294
1295 static VALUE ruby_guestfs_chmod (VALUE gv, VALUE modev, VALUE pathv)
1296 {
1297   guestfs_h *g;
1298   Data_Get_Struct (gv, guestfs_h, g);
1299   if (!g)
1300     rb_raise (rb_eArgError, "%s: used handle after closing it", "chmod");
1301
1302   int mode = NUM2INT (modev);
1303   const char *path = StringValueCStr (pathv);
1304   if (!path)
1305     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1306               "path", "chmod");
1307
1308   int r;
1309
1310   r = guestfs_chmod (g, mode, path);
1311   if (r == -1)
1312     rb_raise (e_Error, "%s", guestfs_last_error (g));
1313
1314   return Qnil;
1315 }
1316
1317 static VALUE ruby_guestfs_chown (VALUE gv, VALUE ownerv, VALUE groupv, VALUE pathv)
1318 {
1319   guestfs_h *g;
1320   Data_Get_Struct (gv, guestfs_h, g);
1321   if (!g)
1322     rb_raise (rb_eArgError, "%s: used handle after closing it", "chown");
1323
1324   int owner = NUM2INT (ownerv);
1325   int group = NUM2INT (groupv);
1326   const char *path = StringValueCStr (pathv);
1327   if (!path)
1328     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1329               "path", "chown");
1330
1331   int r;
1332
1333   r = guestfs_chown (g, owner, group, path);
1334   if (r == -1)
1335     rb_raise (e_Error, "%s", guestfs_last_error (g));
1336
1337   return Qnil;
1338 }
1339
1340 static VALUE ruby_guestfs_exists (VALUE gv, VALUE pathv)
1341 {
1342   guestfs_h *g;
1343   Data_Get_Struct (gv, guestfs_h, g);
1344   if (!g)
1345     rb_raise (rb_eArgError, "%s: used handle after closing it", "exists");
1346
1347   const char *path = StringValueCStr (pathv);
1348   if (!path)
1349     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1350               "path", "exists");
1351
1352   int r;
1353
1354   r = guestfs_exists (g, path);
1355   if (r == -1)
1356     rb_raise (e_Error, "%s", guestfs_last_error (g));
1357
1358   return INT2NUM (r);
1359 }
1360
1361 static VALUE ruby_guestfs_is_file (VALUE gv, VALUE pathv)
1362 {
1363   guestfs_h *g;
1364   Data_Get_Struct (gv, guestfs_h, g);
1365   if (!g)
1366     rb_raise (rb_eArgError, "%s: used handle after closing it", "is_file");
1367
1368   const char *path = StringValueCStr (pathv);
1369   if (!path)
1370     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1371               "path", "is_file");
1372
1373   int r;
1374
1375   r = guestfs_is_file (g, path);
1376   if (r == -1)
1377     rb_raise (e_Error, "%s", guestfs_last_error (g));
1378
1379   return INT2NUM (r);
1380 }
1381
1382 static VALUE ruby_guestfs_is_dir (VALUE gv, VALUE pathv)
1383 {
1384   guestfs_h *g;
1385   Data_Get_Struct (gv, guestfs_h, g);
1386   if (!g)
1387     rb_raise (rb_eArgError, "%s: used handle after closing it", "is_dir");
1388
1389   const char *path = StringValueCStr (pathv);
1390   if (!path)
1391     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1392               "path", "is_dir");
1393
1394   int r;
1395
1396   r = guestfs_is_dir (g, path);
1397   if (r == -1)
1398     rb_raise (e_Error, "%s", guestfs_last_error (g));
1399
1400   return INT2NUM (r);
1401 }
1402
1403 static VALUE ruby_guestfs_pvcreate (VALUE gv, VALUE devicev)
1404 {
1405   guestfs_h *g;
1406   Data_Get_Struct (gv, guestfs_h, g);
1407   if (!g)
1408     rb_raise (rb_eArgError, "%s: used handle after closing it", "pvcreate");
1409
1410   const char *device = StringValueCStr (devicev);
1411   if (!device)
1412     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1413               "device", "pvcreate");
1414
1415   int r;
1416
1417   r = guestfs_pvcreate (g, device);
1418   if (r == -1)
1419     rb_raise (e_Error, "%s", guestfs_last_error (g));
1420
1421   return Qnil;
1422 }
1423
1424 static VALUE ruby_guestfs_vgcreate (VALUE gv, VALUE volgroupv, VALUE physvolsv)
1425 {
1426   guestfs_h *g;
1427   Data_Get_Struct (gv, guestfs_h, g);
1428   if (!g)
1429     rb_raise (rb_eArgError, "%s: used handle after closing it", "vgcreate");
1430
1431   const char *volgroup = StringValueCStr (volgroupv);
1432   if (!volgroup)
1433     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1434               "volgroup", "vgcreate");
1435   char **physvols;  {
1436     int i, len;
1437     len = RARRAY_LEN (physvolsv);
1438     physvols = guestfs_safe_malloc (g, sizeof (char *) * (len+1));
1439     for (i = 0; i < len; ++i) {
1440       VALUE v = rb_ary_entry (physvolsv, i);
1441       physvols[i] = StringValueCStr (v);
1442     }
1443     physvols[len] = NULL;
1444   }
1445
1446   int r;
1447
1448   r = guestfs_vgcreate (g, volgroup, physvols);
1449   free (physvols);
1450   if (r == -1)
1451     rb_raise (e_Error, "%s", guestfs_last_error (g));
1452
1453   return Qnil;
1454 }
1455
1456 static VALUE ruby_guestfs_lvcreate (VALUE gv, VALUE logvolv, VALUE volgroupv, VALUE mbytesv)
1457 {
1458   guestfs_h *g;
1459   Data_Get_Struct (gv, guestfs_h, g);
1460   if (!g)
1461     rb_raise (rb_eArgError, "%s: used handle after closing it", "lvcreate");
1462
1463   const char *logvol = StringValueCStr (logvolv);
1464   if (!logvol)
1465     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1466               "logvol", "lvcreate");
1467   const char *volgroup = StringValueCStr (volgroupv);
1468   if (!volgroup)
1469     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1470               "volgroup", "lvcreate");
1471   int mbytes = NUM2INT (mbytesv);
1472
1473   int r;
1474
1475   r = guestfs_lvcreate (g, logvol, volgroup, mbytes);
1476   if (r == -1)
1477     rb_raise (e_Error, "%s", guestfs_last_error (g));
1478
1479   return Qnil;
1480 }
1481
1482 static VALUE ruby_guestfs_mkfs (VALUE gv, VALUE fstypev, VALUE devicev)
1483 {
1484   guestfs_h *g;
1485   Data_Get_Struct (gv, guestfs_h, g);
1486   if (!g)
1487     rb_raise (rb_eArgError, "%s: used handle after closing it", "mkfs");
1488
1489   const char *fstype = StringValueCStr (fstypev);
1490   if (!fstype)
1491     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1492               "fstype", "mkfs");
1493   const char *device = StringValueCStr (devicev);
1494   if (!device)
1495     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1496               "device", "mkfs");
1497
1498   int r;
1499
1500   r = guestfs_mkfs (g, fstype, device);
1501   if (r == -1)
1502     rb_raise (e_Error, "%s", guestfs_last_error (g));
1503
1504   return Qnil;
1505 }
1506
1507 static VALUE ruby_guestfs_sfdisk (VALUE gv, VALUE devicev, VALUE cylsv, VALUE headsv, VALUE sectorsv, VALUE linesv)
1508 {
1509   guestfs_h *g;
1510   Data_Get_Struct (gv, guestfs_h, g);
1511   if (!g)
1512     rb_raise (rb_eArgError, "%s: used handle after closing it", "sfdisk");
1513
1514   const char *device = StringValueCStr (devicev);
1515   if (!device)
1516     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1517               "device", "sfdisk");
1518   int cyls = NUM2INT (cylsv);
1519   int heads = NUM2INT (headsv);
1520   int sectors = NUM2INT (sectorsv);
1521   char **lines;  {
1522     int i, len;
1523     len = RARRAY_LEN (linesv);
1524     lines = guestfs_safe_malloc (g, sizeof (char *) * (len+1));
1525     for (i = 0; i < len; ++i) {
1526       VALUE v = rb_ary_entry (linesv, i);
1527       lines[i] = StringValueCStr (v);
1528     }
1529     lines[len] = NULL;
1530   }
1531
1532   int r;
1533
1534   r = guestfs_sfdisk (g, device, cyls, heads, sectors, lines);
1535   free (lines);
1536   if (r == -1)
1537     rb_raise (e_Error, "%s", guestfs_last_error (g));
1538
1539   return Qnil;
1540 }
1541
1542 static VALUE ruby_guestfs_write_file (VALUE gv, VALUE pathv, VALUE contentv, VALUE sizev)
1543 {
1544   guestfs_h *g;
1545   Data_Get_Struct (gv, guestfs_h, g);
1546   if (!g)
1547     rb_raise (rb_eArgError, "%s: used handle after closing it", "write_file");
1548
1549   const char *path = StringValueCStr (pathv);
1550   if (!path)
1551     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1552               "path", "write_file");
1553   const char *content = StringValueCStr (contentv);
1554   if (!content)
1555     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1556               "content", "write_file");
1557   int size = NUM2INT (sizev);
1558
1559   int r;
1560
1561   r = guestfs_write_file (g, path, content, size);
1562   if (r == -1)
1563     rb_raise (e_Error, "%s", guestfs_last_error (g));
1564
1565   return Qnil;
1566 }
1567
1568 static VALUE ruby_guestfs_umount (VALUE gv, VALUE pathordevicev)
1569 {
1570   guestfs_h *g;
1571   Data_Get_Struct (gv, guestfs_h, g);
1572   if (!g)
1573     rb_raise (rb_eArgError, "%s: used handle after closing it", "umount");
1574
1575   const char *pathordevice = StringValueCStr (pathordevicev);
1576   if (!pathordevice)
1577     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1578               "pathordevice", "umount");
1579
1580   int r;
1581
1582   r = guestfs_umount (g, pathordevice);
1583   if (r == -1)
1584     rb_raise (e_Error, "%s", guestfs_last_error (g));
1585
1586   return Qnil;
1587 }
1588
1589 static VALUE ruby_guestfs_mounts (VALUE gv)
1590 {
1591   guestfs_h *g;
1592   Data_Get_Struct (gv, guestfs_h, g);
1593   if (!g)
1594     rb_raise (rb_eArgError, "%s: used handle after closing it", "mounts");
1595
1596
1597   char **r;
1598
1599   r = guestfs_mounts (g);
1600   if (r == NULL)
1601     rb_raise (e_Error, "%s", guestfs_last_error (g));
1602
1603   int i, len = 0;
1604   for (i = 0; r[i] != NULL; ++i) len++;
1605   VALUE rv = rb_ary_new2 (len);
1606   for (i = 0; r[i] != NULL; ++i) {
1607     rb_ary_push (rv, rb_str_new2 (r[i]));
1608     free (r[i]);
1609   }
1610   free (r);
1611   return rv;
1612 }
1613
1614 static VALUE ruby_guestfs_umount_all (VALUE gv)
1615 {
1616   guestfs_h *g;
1617   Data_Get_Struct (gv, guestfs_h, g);
1618   if (!g)
1619     rb_raise (rb_eArgError, "%s: used handle after closing it", "umount_all");
1620
1621
1622   int r;
1623
1624   r = guestfs_umount_all (g);
1625   if (r == -1)
1626     rb_raise (e_Error, "%s", guestfs_last_error (g));
1627
1628   return Qnil;
1629 }
1630
1631 static VALUE ruby_guestfs_lvm_remove_all (VALUE gv)
1632 {
1633   guestfs_h *g;
1634   Data_Get_Struct (gv, guestfs_h, g);
1635   if (!g)
1636     rb_raise (rb_eArgError, "%s: used handle after closing it", "lvm_remove_all");
1637
1638
1639   int r;
1640
1641   r = guestfs_lvm_remove_all (g);
1642   if (r == -1)
1643     rb_raise (e_Error, "%s", guestfs_last_error (g));
1644
1645   return Qnil;
1646 }
1647
1648 static VALUE ruby_guestfs_file (VALUE gv, VALUE pathv)
1649 {
1650   guestfs_h *g;
1651   Data_Get_Struct (gv, guestfs_h, g);
1652   if (!g)
1653     rb_raise (rb_eArgError, "%s: used handle after closing it", "file");
1654
1655   const char *path = StringValueCStr (pathv);
1656   if (!path)
1657     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1658               "path", "file");
1659
1660   char *r;
1661
1662   r = guestfs_file (g, path);
1663   if (r == NULL)
1664     rb_raise (e_Error, "%s", guestfs_last_error (g));
1665
1666   VALUE rv = rb_str_new2 (r);
1667   free (r);
1668   return rv;
1669 }
1670
1671 static VALUE ruby_guestfs_command (VALUE gv, VALUE argumentsv)
1672 {
1673   guestfs_h *g;
1674   Data_Get_Struct (gv, guestfs_h, g);
1675   if (!g)
1676     rb_raise (rb_eArgError, "%s: used handle after closing it", "command");
1677
1678   char **arguments;  {
1679     int i, len;
1680     len = RARRAY_LEN (argumentsv);
1681     arguments = guestfs_safe_malloc (g, sizeof (char *) * (len+1));
1682     for (i = 0; i < len; ++i) {
1683       VALUE v = rb_ary_entry (argumentsv, i);
1684       arguments[i] = StringValueCStr (v);
1685     }
1686     arguments[len] = NULL;
1687   }
1688
1689   char *r;
1690
1691   r = guestfs_command (g, arguments);
1692   free (arguments);
1693   if (r == NULL)
1694     rb_raise (e_Error, "%s", guestfs_last_error (g));
1695
1696   VALUE rv = rb_str_new2 (r);
1697   free (r);
1698   return rv;
1699 }
1700
1701 static VALUE ruby_guestfs_command_lines (VALUE gv, VALUE argumentsv)
1702 {
1703   guestfs_h *g;
1704   Data_Get_Struct (gv, guestfs_h, g);
1705   if (!g)
1706     rb_raise (rb_eArgError, "%s: used handle after closing it", "command_lines");
1707
1708   char **arguments;  {
1709     int i, len;
1710     len = RARRAY_LEN (argumentsv);
1711     arguments = guestfs_safe_malloc (g, sizeof (char *) * (len+1));
1712     for (i = 0; i < len; ++i) {
1713       VALUE v = rb_ary_entry (argumentsv, i);
1714       arguments[i] = StringValueCStr (v);
1715     }
1716     arguments[len] = NULL;
1717   }
1718
1719   char **r;
1720
1721   r = guestfs_command_lines (g, arguments);
1722   free (arguments);
1723   if (r == NULL)
1724     rb_raise (e_Error, "%s", guestfs_last_error (g));
1725
1726   int i, len = 0;
1727   for (i = 0; r[i] != NULL; ++i) len++;
1728   VALUE rv = rb_ary_new2 (len);
1729   for (i = 0; r[i] != NULL; ++i) {
1730     rb_ary_push (rv, rb_str_new2 (r[i]));
1731     free (r[i]);
1732   }
1733   free (r);
1734   return rv;
1735 }
1736
1737 static VALUE ruby_guestfs_stat (VALUE gv, VALUE pathv)
1738 {
1739   guestfs_h *g;
1740   Data_Get_Struct (gv, guestfs_h, g);
1741   if (!g)
1742     rb_raise (rb_eArgError, "%s: used handle after closing it", "stat");
1743
1744   const char *path = StringValueCStr (pathv);
1745   if (!path)
1746     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1747               "path", "stat");
1748
1749   struct guestfs_stat *r;
1750
1751   r = guestfs_stat (g, path);
1752   if (r == NULL)
1753     rb_raise (e_Error, "%s", guestfs_last_error (g));
1754
1755   VALUE rv = rb_hash_new ();
1756   rb_hash_aset (rv, rb_str_new2 ("dev"), ULL2NUM (r->dev));
1757   rb_hash_aset (rv, rb_str_new2 ("ino"), ULL2NUM (r->ino));
1758   rb_hash_aset (rv, rb_str_new2 ("mode"), ULL2NUM (r->mode));
1759   rb_hash_aset (rv, rb_str_new2 ("nlink"), ULL2NUM (r->nlink));
1760   rb_hash_aset (rv, rb_str_new2 ("uid"), ULL2NUM (r->uid));
1761   rb_hash_aset (rv, rb_str_new2 ("gid"), ULL2NUM (r->gid));
1762   rb_hash_aset (rv, rb_str_new2 ("rdev"), ULL2NUM (r->rdev));
1763   rb_hash_aset (rv, rb_str_new2 ("size"), ULL2NUM (r->size));
1764   rb_hash_aset (rv, rb_str_new2 ("blksize"), ULL2NUM (r->blksize));
1765   rb_hash_aset (rv, rb_str_new2 ("blocks"), ULL2NUM (r->blocks));
1766   rb_hash_aset (rv, rb_str_new2 ("atime"), ULL2NUM (r->atime));
1767   rb_hash_aset (rv, rb_str_new2 ("mtime"), ULL2NUM (r->mtime));
1768   rb_hash_aset (rv, rb_str_new2 ("ctime"), ULL2NUM (r->ctime));
1769   free (r);
1770   return rv;
1771 }
1772
1773 static VALUE ruby_guestfs_lstat (VALUE gv, VALUE pathv)
1774 {
1775   guestfs_h *g;
1776   Data_Get_Struct (gv, guestfs_h, g);
1777   if (!g)
1778     rb_raise (rb_eArgError, "%s: used handle after closing it", "lstat");
1779
1780   const char *path = StringValueCStr (pathv);
1781   if (!path)
1782     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1783               "path", "lstat");
1784
1785   struct guestfs_stat *r;
1786
1787   r = guestfs_lstat (g, path);
1788   if (r == NULL)
1789     rb_raise (e_Error, "%s", guestfs_last_error (g));
1790
1791   VALUE rv = rb_hash_new ();
1792   rb_hash_aset (rv, rb_str_new2 ("dev"), ULL2NUM (r->dev));
1793   rb_hash_aset (rv, rb_str_new2 ("ino"), ULL2NUM (r->ino));
1794   rb_hash_aset (rv, rb_str_new2 ("mode"), ULL2NUM (r->mode));
1795   rb_hash_aset (rv, rb_str_new2 ("nlink"), ULL2NUM (r->nlink));
1796   rb_hash_aset (rv, rb_str_new2 ("uid"), ULL2NUM (r->uid));
1797   rb_hash_aset (rv, rb_str_new2 ("gid"), ULL2NUM (r->gid));
1798   rb_hash_aset (rv, rb_str_new2 ("rdev"), ULL2NUM (r->rdev));
1799   rb_hash_aset (rv, rb_str_new2 ("size"), ULL2NUM (r->size));
1800   rb_hash_aset (rv, rb_str_new2 ("blksize"), ULL2NUM (r->blksize));
1801   rb_hash_aset (rv, rb_str_new2 ("blocks"), ULL2NUM (r->blocks));
1802   rb_hash_aset (rv, rb_str_new2 ("atime"), ULL2NUM (r->atime));
1803   rb_hash_aset (rv, rb_str_new2 ("mtime"), ULL2NUM (r->mtime));
1804   rb_hash_aset (rv, rb_str_new2 ("ctime"), ULL2NUM (r->ctime));
1805   free (r);
1806   return rv;
1807 }
1808
1809 static VALUE ruby_guestfs_statvfs (VALUE gv, VALUE pathv)
1810 {
1811   guestfs_h *g;
1812   Data_Get_Struct (gv, guestfs_h, g);
1813   if (!g)
1814     rb_raise (rb_eArgError, "%s: used handle after closing it", "statvfs");
1815
1816   const char *path = StringValueCStr (pathv);
1817   if (!path)
1818     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1819               "path", "statvfs");
1820
1821   struct guestfs_statvfs *r;
1822
1823   r = guestfs_statvfs (g, path);
1824   if (r == NULL)
1825     rb_raise (e_Error, "%s", guestfs_last_error (g));
1826
1827   VALUE rv = rb_hash_new ();
1828   rb_hash_aset (rv, rb_str_new2 ("bsize"), ULL2NUM (r->bsize));
1829   rb_hash_aset (rv, rb_str_new2 ("frsize"), ULL2NUM (r->frsize));
1830   rb_hash_aset (rv, rb_str_new2 ("blocks"), ULL2NUM (r->blocks));
1831   rb_hash_aset (rv, rb_str_new2 ("bfree"), ULL2NUM (r->bfree));
1832   rb_hash_aset (rv, rb_str_new2 ("bavail"), ULL2NUM (r->bavail));
1833   rb_hash_aset (rv, rb_str_new2 ("files"), ULL2NUM (r->files));
1834   rb_hash_aset (rv, rb_str_new2 ("ffree"), ULL2NUM (r->ffree));
1835   rb_hash_aset (rv, rb_str_new2 ("favail"), ULL2NUM (r->favail));
1836   rb_hash_aset (rv, rb_str_new2 ("fsid"), ULL2NUM (r->fsid));
1837   rb_hash_aset (rv, rb_str_new2 ("flag"), ULL2NUM (r->flag));
1838   rb_hash_aset (rv, rb_str_new2 ("namemax"), ULL2NUM (r->namemax));
1839   free (r);
1840   return rv;
1841 }
1842
1843 static VALUE ruby_guestfs_tune2fs_l (VALUE gv, VALUE devicev)
1844 {
1845   guestfs_h *g;
1846   Data_Get_Struct (gv, guestfs_h, g);
1847   if (!g)
1848     rb_raise (rb_eArgError, "%s: used handle after closing it", "tune2fs_l");
1849
1850   const char *device = StringValueCStr (devicev);
1851   if (!device)
1852     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1853               "device", "tune2fs_l");
1854
1855   char **r;
1856
1857   r = guestfs_tune2fs_l (g, device);
1858   if (r == NULL)
1859     rb_raise (e_Error, "%s", guestfs_last_error (g));
1860
1861   VALUE rv = rb_hash_new ();
1862   int i;
1863   for (i = 0; r[i] != NULL; i+=2) {
1864     rb_hash_aset (rv, rb_str_new2 (r[i]), rb_str_new2 (r[i+1]));
1865     free (r[i]);
1866     free (r[i+1]);
1867   }
1868   free (r);
1869   return rv;
1870 }
1871
1872 static VALUE ruby_guestfs_blockdev_setro (VALUE gv, VALUE devicev)
1873 {
1874   guestfs_h *g;
1875   Data_Get_Struct (gv, guestfs_h, g);
1876   if (!g)
1877     rb_raise (rb_eArgError, "%s: used handle after closing it", "blockdev_setro");
1878
1879   const char *device = StringValueCStr (devicev);
1880   if (!device)
1881     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1882               "device", "blockdev_setro");
1883
1884   int r;
1885
1886   r = guestfs_blockdev_setro (g, device);
1887   if (r == -1)
1888     rb_raise (e_Error, "%s", guestfs_last_error (g));
1889
1890   return Qnil;
1891 }
1892
1893 static VALUE ruby_guestfs_blockdev_setrw (VALUE gv, VALUE devicev)
1894 {
1895   guestfs_h *g;
1896   Data_Get_Struct (gv, guestfs_h, g);
1897   if (!g)
1898     rb_raise (rb_eArgError, "%s: used handle after closing it", "blockdev_setrw");
1899
1900   const char *device = StringValueCStr (devicev);
1901   if (!device)
1902     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1903               "device", "blockdev_setrw");
1904
1905   int r;
1906
1907   r = guestfs_blockdev_setrw (g, device);
1908   if (r == -1)
1909     rb_raise (e_Error, "%s", guestfs_last_error (g));
1910
1911   return Qnil;
1912 }
1913
1914 static VALUE ruby_guestfs_blockdev_getro (VALUE gv, VALUE devicev)
1915 {
1916   guestfs_h *g;
1917   Data_Get_Struct (gv, guestfs_h, g);
1918   if (!g)
1919     rb_raise (rb_eArgError, "%s: used handle after closing it", "blockdev_getro");
1920
1921   const char *device = StringValueCStr (devicev);
1922   if (!device)
1923     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1924               "device", "blockdev_getro");
1925
1926   int r;
1927
1928   r = guestfs_blockdev_getro (g, device);
1929   if (r == -1)
1930     rb_raise (e_Error, "%s", guestfs_last_error (g));
1931
1932   return INT2NUM (r);
1933 }
1934
1935 static VALUE ruby_guestfs_blockdev_getss (VALUE gv, VALUE devicev)
1936 {
1937   guestfs_h *g;
1938   Data_Get_Struct (gv, guestfs_h, g);
1939   if (!g)
1940     rb_raise (rb_eArgError, "%s: used handle after closing it", "blockdev_getss");
1941
1942   const char *device = StringValueCStr (devicev);
1943   if (!device)
1944     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1945               "device", "blockdev_getss");
1946
1947   int r;
1948
1949   r = guestfs_blockdev_getss (g, device);
1950   if (r == -1)
1951     rb_raise (e_Error, "%s", guestfs_last_error (g));
1952
1953   return INT2NUM (r);
1954 }
1955
1956 static VALUE ruby_guestfs_blockdev_getbsz (VALUE gv, VALUE devicev)
1957 {
1958   guestfs_h *g;
1959   Data_Get_Struct (gv, guestfs_h, g);
1960   if (!g)
1961     rb_raise (rb_eArgError, "%s: used handle after closing it", "blockdev_getbsz");
1962
1963   const char *device = StringValueCStr (devicev);
1964   if (!device)
1965     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1966               "device", "blockdev_getbsz");
1967
1968   int r;
1969
1970   r = guestfs_blockdev_getbsz (g, device);
1971   if (r == -1)
1972     rb_raise (e_Error, "%s", guestfs_last_error (g));
1973
1974   return INT2NUM (r);
1975 }
1976
1977 static VALUE ruby_guestfs_blockdev_setbsz (VALUE gv, VALUE devicev, VALUE blocksizev)
1978 {
1979   guestfs_h *g;
1980   Data_Get_Struct (gv, guestfs_h, g);
1981   if (!g)
1982     rb_raise (rb_eArgError, "%s: used handle after closing it", "blockdev_setbsz");
1983
1984   const char *device = StringValueCStr (devicev);
1985   if (!device)
1986     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1987               "device", "blockdev_setbsz");
1988   int blocksize = NUM2INT (blocksizev);
1989
1990   int r;
1991
1992   r = guestfs_blockdev_setbsz (g, device, blocksize);
1993   if (r == -1)
1994     rb_raise (e_Error, "%s", guestfs_last_error (g));
1995
1996   return Qnil;
1997 }
1998
1999 static VALUE ruby_guestfs_blockdev_getsz (VALUE gv, VALUE devicev)
2000 {
2001   guestfs_h *g;
2002   Data_Get_Struct (gv, guestfs_h, g);
2003   if (!g)
2004     rb_raise (rb_eArgError, "%s: used handle after closing it", "blockdev_getsz");
2005
2006   const char *device = StringValueCStr (devicev);
2007   if (!device)
2008     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2009               "device", "blockdev_getsz");
2010
2011   int64_t r;
2012
2013   r = guestfs_blockdev_getsz (g, device);
2014   if (r == -1)
2015     rb_raise (e_Error, "%s", guestfs_last_error (g));
2016
2017   return ULL2NUM (r);
2018 }
2019
2020 static VALUE ruby_guestfs_blockdev_getsize64 (VALUE gv, VALUE devicev)
2021 {
2022   guestfs_h *g;
2023   Data_Get_Struct (gv, guestfs_h, g);
2024   if (!g)
2025     rb_raise (rb_eArgError, "%s: used handle after closing it", "blockdev_getsize64");
2026
2027   const char *device = StringValueCStr (devicev);
2028   if (!device)
2029     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2030               "device", "blockdev_getsize64");
2031
2032   int64_t r;
2033
2034   r = guestfs_blockdev_getsize64 (g, device);
2035   if (r == -1)
2036     rb_raise (e_Error, "%s", guestfs_last_error (g));
2037
2038   return ULL2NUM (r);
2039 }
2040
2041 static VALUE ruby_guestfs_blockdev_flushbufs (VALUE gv, VALUE devicev)
2042 {
2043   guestfs_h *g;
2044   Data_Get_Struct (gv, guestfs_h, g);
2045   if (!g)
2046     rb_raise (rb_eArgError, "%s: used handle after closing it", "blockdev_flushbufs");
2047
2048   const char *device = StringValueCStr (devicev);
2049   if (!device)
2050     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2051               "device", "blockdev_flushbufs");
2052
2053   int r;
2054
2055   r = guestfs_blockdev_flushbufs (g, device);
2056   if (r == -1)
2057     rb_raise (e_Error, "%s", guestfs_last_error (g));
2058
2059   return Qnil;
2060 }
2061
2062 static VALUE ruby_guestfs_blockdev_rereadpt (VALUE gv, VALUE devicev)
2063 {
2064   guestfs_h *g;
2065   Data_Get_Struct (gv, guestfs_h, g);
2066   if (!g)
2067     rb_raise (rb_eArgError, "%s: used handle after closing it", "blockdev_rereadpt");
2068
2069   const char *device = StringValueCStr (devicev);
2070   if (!device)
2071     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2072               "device", "blockdev_rereadpt");
2073
2074   int r;
2075
2076   r = guestfs_blockdev_rereadpt (g, device);
2077   if (r == -1)
2078     rb_raise (e_Error, "%s", guestfs_last_error (g));
2079
2080   return Qnil;
2081 }
2082
2083 static VALUE ruby_guestfs_upload (VALUE gv, VALUE filenamev, VALUE remotefilenamev)
2084 {
2085   guestfs_h *g;
2086   Data_Get_Struct (gv, guestfs_h, g);
2087   if (!g)
2088     rb_raise (rb_eArgError, "%s: used handle after closing it", "upload");
2089
2090   const char *filename = StringValueCStr (filenamev);
2091   if (!filename)
2092     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2093               "filename", "upload");
2094   const char *remotefilename = StringValueCStr (remotefilenamev);
2095   if (!remotefilename)
2096     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2097               "remotefilename", "upload");
2098
2099   int r;
2100
2101   r = guestfs_upload (g, filename, remotefilename);
2102   if (r == -1)
2103     rb_raise (e_Error, "%s", guestfs_last_error (g));
2104
2105   return Qnil;
2106 }
2107
2108 static VALUE ruby_guestfs_download (VALUE gv, VALUE remotefilenamev, VALUE filenamev)
2109 {
2110   guestfs_h *g;
2111   Data_Get_Struct (gv, guestfs_h, g);
2112   if (!g)
2113     rb_raise (rb_eArgError, "%s: used handle after closing it", "download");
2114
2115   const char *remotefilename = StringValueCStr (remotefilenamev);
2116   if (!remotefilename)
2117     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2118               "remotefilename", "download");
2119   const char *filename = StringValueCStr (filenamev);
2120   if (!filename)
2121     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2122               "filename", "download");
2123
2124   int r;
2125
2126   r = guestfs_download (g, remotefilename, filename);
2127   if (r == -1)
2128     rb_raise (e_Error, "%s", guestfs_last_error (g));
2129
2130   return Qnil;
2131 }
2132
2133 static VALUE ruby_guestfs_checksum (VALUE gv, VALUE csumtypev, VALUE pathv)
2134 {
2135   guestfs_h *g;
2136   Data_Get_Struct (gv, guestfs_h, g);
2137   if (!g)
2138     rb_raise (rb_eArgError, "%s: used handle after closing it", "checksum");
2139
2140   const char *csumtype = StringValueCStr (csumtypev);
2141   if (!csumtype)
2142     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2143               "csumtype", "checksum");
2144   const char *path = StringValueCStr (pathv);
2145   if (!path)
2146     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2147               "path", "checksum");
2148
2149   char *r;
2150
2151   r = guestfs_checksum (g, csumtype, path);
2152   if (r == NULL)
2153     rb_raise (e_Error, "%s", guestfs_last_error (g));
2154
2155   VALUE rv = rb_str_new2 (r);
2156   free (r);
2157   return rv;
2158 }
2159
2160 static VALUE ruby_guestfs_tar_in (VALUE gv, VALUE tarfilev, VALUE directoryv)
2161 {
2162   guestfs_h *g;
2163   Data_Get_Struct (gv, guestfs_h, g);
2164   if (!g)
2165     rb_raise (rb_eArgError, "%s: used handle after closing it", "tar_in");
2166
2167   const char *tarfile = StringValueCStr (tarfilev);
2168   if (!tarfile)
2169     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2170               "tarfile", "tar_in");
2171   const char *directory = StringValueCStr (directoryv);
2172   if (!directory)
2173     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2174               "directory", "tar_in");
2175
2176   int r;
2177
2178   r = guestfs_tar_in (g, tarfile, directory);
2179   if (r == -1)
2180     rb_raise (e_Error, "%s", guestfs_last_error (g));
2181
2182   return Qnil;
2183 }
2184
2185 static VALUE ruby_guestfs_tar_out (VALUE gv, VALUE directoryv, VALUE tarfilev)
2186 {
2187   guestfs_h *g;
2188   Data_Get_Struct (gv, guestfs_h, g);
2189   if (!g)
2190     rb_raise (rb_eArgError, "%s: used handle after closing it", "tar_out");
2191
2192   const char *directory = StringValueCStr (directoryv);
2193   if (!directory)
2194     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2195               "directory", "tar_out");
2196   const char *tarfile = StringValueCStr (tarfilev);
2197   if (!tarfile)
2198     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2199               "tarfile", "tar_out");
2200
2201   int r;
2202
2203   r = guestfs_tar_out (g, directory, tarfile);
2204   if (r == -1)
2205     rb_raise (e_Error, "%s", guestfs_last_error (g));
2206
2207   return Qnil;
2208 }
2209
2210 static VALUE ruby_guestfs_tgz_in (VALUE gv, VALUE tarballv, VALUE directoryv)
2211 {
2212   guestfs_h *g;
2213   Data_Get_Struct (gv, guestfs_h, g);
2214   if (!g)
2215     rb_raise (rb_eArgError, "%s: used handle after closing it", "tgz_in");
2216
2217   const char *tarball = StringValueCStr (tarballv);
2218   if (!tarball)
2219     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2220               "tarball", "tgz_in");
2221   const char *directory = StringValueCStr (directoryv);
2222   if (!directory)
2223     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2224               "directory", "tgz_in");
2225
2226   int r;
2227
2228   r = guestfs_tgz_in (g, tarball, directory);
2229   if (r == -1)
2230     rb_raise (e_Error, "%s", guestfs_last_error (g));
2231
2232   return Qnil;
2233 }
2234
2235 static VALUE ruby_guestfs_tgz_out (VALUE gv, VALUE directoryv, VALUE tarballv)
2236 {
2237   guestfs_h *g;
2238   Data_Get_Struct (gv, guestfs_h, g);
2239   if (!g)
2240     rb_raise (rb_eArgError, "%s: used handle after closing it", "tgz_out");
2241
2242   const char *directory = StringValueCStr (directoryv);
2243   if (!directory)
2244     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2245               "directory", "tgz_out");
2246   const char *tarball = StringValueCStr (tarballv);
2247   if (!tarball)
2248     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2249               "tarball", "tgz_out");
2250
2251   int r;
2252
2253   r = guestfs_tgz_out (g, directory, tarball);
2254   if (r == -1)
2255     rb_raise (e_Error, "%s", guestfs_last_error (g));
2256
2257   return Qnil;
2258 }
2259
2260 static VALUE ruby_guestfs_mount_ro (VALUE gv, VALUE devicev, VALUE mountpointv)
2261 {
2262   guestfs_h *g;
2263   Data_Get_Struct (gv, guestfs_h, g);
2264   if (!g)
2265     rb_raise (rb_eArgError, "%s: used handle after closing it", "mount_ro");
2266
2267   const char *device = StringValueCStr (devicev);
2268   if (!device)
2269     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2270               "device", "mount_ro");
2271   const char *mountpoint = StringValueCStr (mountpointv);
2272   if (!mountpoint)
2273     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2274               "mountpoint", "mount_ro");
2275
2276   int r;
2277
2278   r = guestfs_mount_ro (g, device, mountpoint);
2279   if (r == -1)
2280     rb_raise (e_Error, "%s", guestfs_last_error (g));
2281
2282   return Qnil;
2283 }
2284
2285 static VALUE ruby_guestfs_mount_options (VALUE gv, VALUE optionsv, VALUE devicev, VALUE mountpointv)
2286 {
2287   guestfs_h *g;
2288   Data_Get_Struct (gv, guestfs_h, g);
2289   if (!g)
2290     rb_raise (rb_eArgError, "%s: used handle after closing it", "mount_options");
2291
2292   const char *options = StringValueCStr (optionsv);
2293   if (!options)
2294     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2295               "options", "mount_options");
2296   const char *device = StringValueCStr (devicev);
2297   if (!device)
2298     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2299               "device", "mount_options");
2300   const char *mountpoint = StringValueCStr (mountpointv);
2301   if (!mountpoint)
2302     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2303               "mountpoint", "mount_options");
2304
2305   int r;
2306
2307   r = guestfs_mount_options (g, options, device, mountpoint);
2308   if (r == -1)
2309     rb_raise (e_Error, "%s", guestfs_last_error (g));
2310
2311   return Qnil;
2312 }
2313
2314 static VALUE ruby_guestfs_mount_vfs (VALUE gv, VALUE optionsv, VALUE vfstypev, VALUE devicev, VALUE mountpointv)
2315 {
2316   guestfs_h *g;
2317   Data_Get_Struct (gv, guestfs_h, g);
2318   if (!g)
2319     rb_raise (rb_eArgError, "%s: used handle after closing it", "mount_vfs");
2320
2321   const char *options = StringValueCStr (optionsv);
2322   if (!options)
2323     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2324               "options", "mount_vfs");
2325   const char *vfstype = StringValueCStr (vfstypev);
2326   if (!vfstype)
2327     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2328               "vfstype", "mount_vfs");
2329   const char *device = StringValueCStr (devicev);
2330   if (!device)
2331     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2332               "device", "mount_vfs");
2333   const char *mountpoint = StringValueCStr (mountpointv);
2334   if (!mountpoint)
2335     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2336               "mountpoint", "mount_vfs");
2337
2338   int r;
2339
2340   r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint);
2341   if (r == -1)
2342     rb_raise (e_Error, "%s", guestfs_last_error (g));
2343
2344   return Qnil;
2345 }
2346
2347 static VALUE ruby_guestfs_debug (VALUE gv, VALUE subcmdv, VALUE extraargsv)
2348 {
2349   guestfs_h *g;
2350   Data_Get_Struct (gv, guestfs_h, g);
2351   if (!g)
2352     rb_raise (rb_eArgError, "%s: used handle after closing it", "debug");
2353
2354   const char *subcmd = StringValueCStr (subcmdv);
2355   if (!subcmd)
2356     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2357               "subcmd", "debug");
2358   char **extraargs;  {
2359     int i, len;
2360     len = RARRAY_LEN (extraargsv);
2361     extraargs = guestfs_safe_malloc (g, sizeof (char *) * (len+1));
2362     for (i = 0; i < len; ++i) {
2363       VALUE v = rb_ary_entry (extraargsv, i);
2364       extraargs[i] = StringValueCStr (v);
2365     }
2366     extraargs[len] = NULL;
2367   }
2368
2369   char *r;
2370
2371   r = guestfs_debug (g, subcmd, extraargs);
2372   free (extraargs);
2373   if (r == NULL)
2374     rb_raise (e_Error, "%s", guestfs_last_error (g));
2375
2376   VALUE rv = rb_str_new2 (r);
2377   free (r);
2378   return rv;
2379 }
2380
2381 static VALUE ruby_guestfs_lvremove (VALUE gv, VALUE devicev)
2382 {
2383   guestfs_h *g;
2384   Data_Get_Struct (gv, guestfs_h, g);
2385   if (!g)
2386     rb_raise (rb_eArgError, "%s: used handle after closing it", "lvremove");
2387
2388   const char *device = StringValueCStr (devicev);
2389   if (!device)
2390     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2391               "device", "lvremove");
2392
2393   int r;
2394
2395   r = guestfs_lvremove (g, device);
2396   if (r == -1)
2397     rb_raise (e_Error, "%s", guestfs_last_error (g));
2398
2399   return Qnil;
2400 }
2401
2402 static VALUE ruby_guestfs_vgremove (VALUE gv, VALUE vgnamev)
2403 {
2404   guestfs_h *g;
2405   Data_Get_Struct (gv, guestfs_h, g);
2406   if (!g)
2407     rb_raise (rb_eArgError, "%s: used handle after closing it", "vgremove");
2408
2409   const char *vgname = StringValueCStr (vgnamev);
2410   if (!vgname)
2411     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2412               "vgname", "vgremove");
2413
2414   int r;
2415
2416   r = guestfs_vgremove (g, vgname);
2417   if (r == -1)
2418     rb_raise (e_Error, "%s", guestfs_last_error (g));
2419
2420   return Qnil;
2421 }
2422
2423 static VALUE ruby_guestfs_pvremove (VALUE gv, VALUE devicev)
2424 {
2425   guestfs_h *g;
2426   Data_Get_Struct (gv, guestfs_h, g);
2427   if (!g)
2428     rb_raise (rb_eArgError, "%s: used handle after closing it", "pvremove");
2429
2430   const char *device = StringValueCStr (devicev);
2431   if (!device)
2432     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2433               "device", "pvremove");
2434
2435   int r;
2436
2437   r = guestfs_pvremove (g, device);
2438   if (r == -1)
2439     rb_raise (e_Error, "%s", guestfs_last_error (g));
2440
2441   return Qnil;
2442 }
2443
2444 static VALUE ruby_guestfs_set_e2label (VALUE gv, VALUE devicev, VALUE labelv)
2445 {
2446   guestfs_h *g;
2447   Data_Get_Struct (gv, guestfs_h, g);
2448   if (!g)
2449     rb_raise (rb_eArgError, "%s: used handle after closing it", "set_e2label");
2450
2451   const char *device = StringValueCStr (devicev);
2452   if (!device)
2453     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2454               "device", "set_e2label");
2455   const char *label = StringValueCStr (labelv);
2456   if (!label)
2457     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2458               "label", "set_e2label");
2459
2460   int r;
2461
2462   r = guestfs_set_e2label (g, device, label);
2463   if (r == -1)
2464     rb_raise (e_Error, "%s", guestfs_last_error (g));
2465
2466   return Qnil;
2467 }
2468
2469 static VALUE ruby_guestfs_get_e2label (VALUE gv, VALUE devicev)
2470 {
2471   guestfs_h *g;
2472   Data_Get_Struct (gv, guestfs_h, g);
2473   if (!g)
2474     rb_raise (rb_eArgError, "%s: used handle after closing it", "get_e2label");
2475
2476   const char *device = StringValueCStr (devicev);
2477   if (!device)
2478     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2479               "device", "get_e2label");
2480
2481   char *r;
2482
2483   r = guestfs_get_e2label (g, device);
2484   if (r == NULL)
2485     rb_raise (e_Error, "%s", guestfs_last_error (g));
2486
2487   VALUE rv = rb_str_new2 (r);
2488   free (r);
2489   return rv;
2490 }
2491
2492 static VALUE ruby_guestfs_set_e2uuid (VALUE gv, VALUE devicev, VALUE uuidv)
2493 {
2494   guestfs_h *g;
2495   Data_Get_Struct (gv, guestfs_h, g);
2496   if (!g)
2497     rb_raise (rb_eArgError, "%s: used handle after closing it", "set_e2uuid");
2498
2499   const char *device = StringValueCStr (devicev);
2500   if (!device)
2501     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2502               "device", "set_e2uuid");
2503   const char *uuid = StringValueCStr (uuidv);
2504   if (!uuid)
2505     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2506               "uuid", "set_e2uuid");
2507
2508   int r;
2509
2510   r = guestfs_set_e2uuid (g, device, uuid);
2511   if (r == -1)
2512     rb_raise (e_Error, "%s", guestfs_last_error (g));
2513
2514   return Qnil;
2515 }
2516
2517 static VALUE ruby_guestfs_get_e2uuid (VALUE gv, VALUE devicev)
2518 {
2519   guestfs_h *g;
2520   Data_Get_Struct (gv, guestfs_h, g);
2521   if (!g)
2522     rb_raise (rb_eArgError, "%s: used handle after closing it", "get_e2uuid");
2523
2524   const char *device = StringValueCStr (devicev);
2525   if (!device)
2526     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2527               "device", "get_e2uuid");
2528
2529   char *r;
2530
2531   r = guestfs_get_e2uuid (g, device);
2532   if (r == NULL)
2533     rb_raise (e_Error, "%s", guestfs_last_error (g));
2534
2535   VALUE rv = rb_str_new2 (r);
2536   free (r);
2537   return rv;
2538 }
2539
2540 static VALUE ruby_guestfs_fsck (VALUE gv, VALUE fstypev, VALUE devicev)
2541 {
2542   guestfs_h *g;
2543   Data_Get_Struct (gv, guestfs_h, g);
2544   if (!g)
2545     rb_raise (rb_eArgError, "%s: used handle after closing it", "fsck");
2546
2547   const char *fstype = StringValueCStr (fstypev);
2548   if (!fstype)
2549     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2550               "fstype", "fsck");
2551   const char *device = StringValueCStr (devicev);
2552   if (!device)
2553     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2554               "device", "fsck");
2555
2556   int r;
2557
2558   r = guestfs_fsck (g, fstype, device);
2559   if (r == -1)
2560     rb_raise (e_Error, "%s", guestfs_last_error (g));
2561
2562   return INT2NUM (r);
2563 }
2564
2565 static VALUE ruby_guestfs_zero (VALUE gv, VALUE devicev)
2566 {
2567   guestfs_h *g;
2568   Data_Get_Struct (gv, guestfs_h, g);
2569   if (!g)
2570     rb_raise (rb_eArgError, "%s: used handle after closing it", "zero");
2571
2572   const char *device = StringValueCStr (devicev);
2573   if (!device)
2574     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2575               "device", "zero");
2576
2577   int r;
2578
2579   r = guestfs_zero (g, device);
2580   if (r == -1)
2581     rb_raise (e_Error, "%s", guestfs_last_error (g));
2582
2583   return Qnil;
2584 }
2585
2586 static VALUE ruby_guestfs_grub_install (VALUE gv, VALUE rootv, VALUE devicev)
2587 {
2588   guestfs_h *g;
2589   Data_Get_Struct (gv, guestfs_h, g);
2590   if (!g)
2591     rb_raise (rb_eArgError, "%s: used handle after closing it", "grub_install");
2592
2593   const char *root = StringValueCStr (rootv);
2594   if (!root)
2595     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2596               "root", "grub_install");
2597   const char *device = StringValueCStr (devicev);
2598   if (!device)
2599     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2600               "device", "grub_install");
2601
2602   int r;
2603
2604   r = guestfs_grub_install (g, root, device);
2605   if (r == -1)
2606     rb_raise (e_Error, "%s", guestfs_last_error (g));
2607
2608   return Qnil;
2609 }
2610
2611 static VALUE ruby_guestfs_cp (VALUE gv, VALUE srcv, VALUE destv)
2612 {
2613   guestfs_h *g;
2614   Data_Get_Struct (gv, guestfs_h, g);
2615   if (!g)
2616     rb_raise (rb_eArgError, "%s: used handle after closing it", "cp");
2617
2618   const char *src = StringValueCStr (srcv);
2619   if (!src)
2620     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2621               "src", "cp");
2622   const char *dest = StringValueCStr (destv);
2623   if (!dest)
2624     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2625               "dest", "cp");
2626
2627   int r;
2628
2629   r = guestfs_cp (g, src, dest);
2630   if (r == -1)
2631     rb_raise (e_Error, "%s", guestfs_last_error (g));
2632
2633   return Qnil;
2634 }
2635
2636 static VALUE ruby_guestfs_cp_a (VALUE gv, VALUE srcv, VALUE destv)
2637 {
2638   guestfs_h *g;
2639   Data_Get_Struct (gv, guestfs_h, g);
2640   if (!g)
2641     rb_raise (rb_eArgError, "%s: used handle after closing it", "cp_a");
2642
2643   const char *src = StringValueCStr (srcv);
2644   if (!src)
2645     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2646               "src", "cp_a");
2647   const char *dest = StringValueCStr (destv);
2648   if (!dest)
2649     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2650               "dest", "cp_a");
2651
2652   int r;
2653
2654   r = guestfs_cp_a (g, src, dest);
2655   if (r == -1)
2656     rb_raise (e_Error, "%s", guestfs_last_error (g));
2657
2658   return Qnil;
2659 }
2660
2661 static VALUE ruby_guestfs_mv (VALUE gv, VALUE srcv, VALUE destv)
2662 {
2663   guestfs_h *g;
2664   Data_Get_Struct (gv, guestfs_h, g);
2665   if (!g)
2666     rb_raise (rb_eArgError, "%s: used handle after closing it", "mv");
2667
2668   const char *src = StringValueCStr (srcv);
2669   if (!src)
2670     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2671               "src", "mv");
2672   const char *dest = StringValueCStr (destv);
2673   if (!dest)
2674     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2675               "dest", "mv");
2676
2677   int r;
2678
2679   r = guestfs_mv (g, src, dest);
2680   if (r == -1)
2681     rb_raise (e_Error, "%s", guestfs_last_error (g));
2682
2683   return Qnil;
2684 }
2685
2686 static VALUE ruby_guestfs_drop_caches (VALUE gv, VALUE whattodropv)
2687 {
2688   guestfs_h *g;
2689   Data_Get_Struct (gv, guestfs_h, g);
2690   if (!g)
2691     rb_raise (rb_eArgError, "%s: used handle after closing it", "drop_caches");
2692
2693   int whattodrop = NUM2INT (whattodropv);
2694
2695   int r;
2696
2697   r = guestfs_drop_caches (g, whattodrop);
2698   if (r == -1)
2699     rb_raise (e_Error, "%s", guestfs_last_error (g));
2700
2701   return Qnil;
2702 }
2703
2704 static VALUE ruby_guestfs_dmesg (VALUE gv)
2705 {
2706   guestfs_h *g;
2707   Data_Get_Struct (gv, guestfs_h, g);
2708   if (!g)
2709     rb_raise (rb_eArgError, "%s: used handle after closing it", "dmesg");
2710
2711
2712   char *r;
2713
2714   r = guestfs_dmesg (g);
2715   if (r == NULL)
2716     rb_raise (e_Error, "%s", guestfs_last_error (g));
2717
2718   VALUE rv = rb_str_new2 (r);
2719   free (r);
2720   return rv;
2721 }
2722
2723 static VALUE ruby_guestfs_ping_daemon (VALUE gv)
2724 {
2725   guestfs_h *g;
2726   Data_Get_Struct (gv, guestfs_h, g);
2727   if (!g)
2728     rb_raise (rb_eArgError, "%s: used handle after closing it", "ping_daemon");
2729
2730
2731   int r;
2732
2733   r = guestfs_ping_daemon (g);
2734   if (r == -1)
2735     rb_raise (e_Error, "%s", guestfs_last_error (g));
2736
2737   return Qnil;
2738 }
2739
2740 static VALUE ruby_guestfs_equal (VALUE gv, VALUE file1v, VALUE file2v)
2741 {
2742   guestfs_h *g;
2743   Data_Get_Struct (gv, guestfs_h, g);
2744   if (!g)
2745     rb_raise (rb_eArgError, "%s: used handle after closing it", "equal");
2746
2747   const char *file1 = StringValueCStr (file1v);
2748   if (!file1)
2749     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2750               "file1", "equal");
2751   const char *file2 = StringValueCStr (file2v);
2752   if (!file2)
2753     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2754               "file2", "equal");
2755
2756   int r;
2757
2758   r = guestfs_equal (g, file1, file2);
2759   if (r == -1)
2760     rb_raise (e_Error, "%s", guestfs_last_error (g));
2761
2762   return INT2NUM (r);
2763 }
2764
2765 static VALUE ruby_guestfs_strings (VALUE gv, VALUE pathv)
2766 {
2767   guestfs_h *g;
2768   Data_Get_Struct (gv, guestfs_h, g);
2769   if (!g)
2770     rb_raise (rb_eArgError, "%s: used handle after closing it", "strings");
2771
2772   const char *path = StringValueCStr (pathv);
2773   if (!path)
2774     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2775               "path", "strings");
2776
2777   char **r;
2778
2779   r = guestfs_strings (g, path);
2780   if (r == NULL)
2781     rb_raise (e_Error, "%s", guestfs_last_error (g));
2782
2783   int i, len = 0;
2784   for (i = 0; r[i] != NULL; ++i) len++;
2785   VALUE rv = rb_ary_new2 (len);
2786   for (i = 0; r[i] != NULL; ++i) {
2787     rb_ary_push (rv, rb_str_new2 (r[i]));
2788     free (r[i]);
2789   }
2790   free (r);
2791   return rv;
2792 }
2793
2794 static VALUE ruby_guestfs_strings_e (VALUE gv, VALUE encodingv, VALUE pathv)
2795 {
2796   guestfs_h *g;
2797   Data_Get_Struct (gv, guestfs_h, g);
2798   if (!g)
2799     rb_raise (rb_eArgError, "%s: used handle after closing it", "strings_e");
2800
2801   const char *encoding = StringValueCStr (encodingv);
2802   if (!encoding)
2803     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2804               "encoding", "strings_e");
2805   const char *path = StringValueCStr (pathv);
2806   if (!path)
2807     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2808               "path", "strings_e");
2809
2810   char **r;
2811
2812   r = guestfs_strings_e (g, encoding, path);
2813   if (r == NULL)
2814     rb_raise (e_Error, "%s", guestfs_last_error (g));
2815
2816   int i, len = 0;
2817   for (i = 0; r[i] != NULL; ++i) len++;
2818   VALUE rv = rb_ary_new2 (len);
2819   for (i = 0; r[i] != NULL; ++i) {
2820     rb_ary_push (rv, rb_str_new2 (r[i]));
2821     free (r[i]);
2822   }
2823   free (r);
2824   return rv;
2825 }
2826
2827 static VALUE ruby_guestfs_hexdump (VALUE gv, VALUE pathv)
2828 {
2829   guestfs_h *g;
2830   Data_Get_Struct (gv, guestfs_h, g);
2831   if (!g)
2832     rb_raise (rb_eArgError, "%s: used handle after closing it", "hexdump");
2833
2834   const char *path = StringValueCStr (pathv);
2835   if (!path)
2836     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2837               "path", "hexdump");
2838
2839   char *r;
2840
2841   r = guestfs_hexdump (g, path);
2842   if (r == NULL)
2843     rb_raise (e_Error, "%s", guestfs_last_error (g));
2844
2845   VALUE rv = rb_str_new2 (r);
2846   free (r);
2847   return rv;
2848 }
2849
2850 /* Initialize the module. */
2851 void Init__guestfs ()
2852 {
2853   m_guestfs = rb_define_module ("Guestfs");
2854   c_guestfs = rb_define_class_under (m_guestfs, "Guestfs", rb_cObject);
2855   e_Error = rb_define_class_under (m_guestfs, "Error", rb_eStandardError);
2856
2857   rb_define_module_function (m_guestfs, "create", ruby_guestfs_create, 0);
2858   rb_define_method (c_guestfs, "close", ruby_guestfs_close, 0);
2859
2860   rb_define_method (c_guestfs, "launch",
2861         ruby_guestfs_launch, 0);
2862   rb_define_method (c_guestfs, "wait_ready",
2863         ruby_guestfs_wait_ready, 0);
2864   rb_define_method (c_guestfs, "kill_subprocess",
2865         ruby_guestfs_kill_subprocess, 0);
2866   rb_define_method (c_guestfs, "add_drive",
2867         ruby_guestfs_add_drive, 1);
2868   rb_define_method (c_guestfs, "add_cdrom",
2869         ruby_guestfs_add_cdrom, 1);
2870   rb_define_method (c_guestfs, "config",
2871         ruby_guestfs_config, 2);
2872   rb_define_method (c_guestfs, "set_qemu",
2873         ruby_guestfs_set_qemu, 1);
2874   rb_define_method (c_guestfs, "get_qemu",
2875         ruby_guestfs_get_qemu, 0);
2876   rb_define_method (c_guestfs, "set_path",
2877         ruby_guestfs_set_path, 1);
2878   rb_define_method (c_guestfs, "get_path",
2879         ruby_guestfs_get_path, 0);
2880   rb_define_method (c_guestfs, "set_autosync",
2881         ruby_guestfs_set_autosync, 1);
2882   rb_define_method (c_guestfs, "get_autosync",
2883         ruby_guestfs_get_autosync, 0);
2884   rb_define_method (c_guestfs, "set_verbose",
2885         ruby_guestfs_set_verbose, 1);
2886   rb_define_method (c_guestfs, "get_verbose",
2887         ruby_guestfs_get_verbose, 0);
2888   rb_define_method (c_guestfs, "is_ready",
2889         ruby_guestfs_is_ready, 0);
2890   rb_define_method (c_guestfs, "is_config",
2891         ruby_guestfs_is_config, 0);
2892   rb_define_method (c_guestfs, "is_launching",
2893         ruby_guestfs_is_launching, 0);
2894   rb_define_method (c_guestfs, "is_busy",
2895         ruby_guestfs_is_busy, 0);
2896   rb_define_method (c_guestfs, "get_state",
2897         ruby_guestfs_get_state, 0);
2898   rb_define_method (c_guestfs, "set_busy",
2899         ruby_guestfs_set_busy, 0);
2900   rb_define_method (c_guestfs, "set_ready",
2901         ruby_guestfs_set_ready, 0);
2902   rb_define_method (c_guestfs, "end_busy",
2903         ruby_guestfs_end_busy, 0);
2904   rb_define_method (c_guestfs, "mount",
2905         ruby_guestfs_mount, 2);
2906   rb_define_method (c_guestfs, "sync",
2907         ruby_guestfs_sync, 0);
2908   rb_define_method (c_guestfs, "touch",
2909         ruby_guestfs_touch, 1);
2910   rb_define_method (c_guestfs, "cat",
2911         ruby_guestfs_cat, 1);
2912   rb_define_method (c_guestfs, "ll",
2913         ruby_guestfs_ll, 1);
2914   rb_define_method (c_guestfs, "ls",
2915         ruby_guestfs_ls, 1);
2916   rb_define_method (c_guestfs, "list_devices",
2917         ruby_guestfs_list_devices, 0);
2918   rb_define_method (c_guestfs, "list_partitions",
2919         ruby_guestfs_list_partitions, 0);
2920   rb_define_method (c_guestfs, "pvs",
2921         ruby_guestfs_pvs, 0);
2922   rb_define_method (c_guestfs, "vgs",
2923         ruby_guestfs_vgs, 0);
2924   rb_define_method (c_guestfs, "lvs",
2925         ruby_guestfs_lvs, 0);
2926   rb_define_method (c_guestfs, "pvs_full",
2927         ruby_guestfs_pvs_full, 0);
2928   rb_define_method (c_guestfs, "vgs_full",
2929         ruby_guestfs_vgs_full, 0);
2930   rb_define_method (c_guestfs, "lvs_full",
2931         ruby_guestfs_lvs_full, 0);
2932   rb_define_method (c_guestfs, "read_lines",
2933         ruby_guestfs_read_lines, 1);
2934   rb_define_method (c_guestfs, "aug_init",
2935         ruby_guestfs_aug_init, 2);
2936   rb_define_method (c_guestfs, "aug_close",
2937         ruby_guestfs_aug_close, 0);
2938   rb_define_method (c_guestfs, "aug_defvar",
2939         ruby_guestfs_aug_defvar, 2);
2940   rb_define_method (c_guestfs, "aug_defnode",
2941         ruby_guestfs_aug_defnode, 3);
2942   rb_define_method (c_guestfs, "aug_get",
2943         ruby_guestfs_aug_get, 1);
2944   rb_define_method (c_guestfs, "aug_set",
2945         ruby_guestfs_aug_set, 2);
2946   rb_define_method (c_guestfs, "aug_insert",
2947         ruby_guestfs_aug_insert, 3);
2948   rb_define_method (c_guestfs, "aug_rm",
2949         ruby_guestfs_aug_rm, 1);
2950   rb_define_method (c_guestfs, "aug_mv",
2951         ruby_guestfs_aug_mv, 2);
2952   rb_define_method (c_guestfs, "aug_match",
2953         ruby_guestfs_aug_match, 1);
2954   rb_define_method (c_guestfs, "aug_save",
2955         ruby_guestfs_aug_save, 0);
2956   rb_define_method (c_guestfs, "aug_load",
2957         ruby_guestfs_aug_load, 0);
2958   rb_define_method (c_guestfs, "aug_ls",
2959         ruby_guestfs_aug_ls, 1);
2960   rb_define_method (c_guestfs, "rm",
2961         ruby_guestfs_rm, 1);
2962   rb_define_method (c_guestfs, "rmdir",
2963         ruby_guestfs_rmdir, 1);
2964   rb_define_method (c_guestfs, "rm_rf",
2965         ruby_guestfs_rm_rf, 1);
2966   rb_define_method (c_guestfs, "mkdir",
2967         ruby_guestfs_mkdir, 1);
2968   rb_define_method (c_guestfs, "mkdir_p",
2969         ruby_guestfs_mkdir_p, 1);
2970   rb_define_method (c_guestfs, "chmod",
2971         ruby_guestfs_chmod, 2);
2972   rb_define_method (c_guestfs, "chown",
2973         ruby_guestfs_chown, 3);
2974   rb_define_method (c_guestfs, "exists",
2975         ruby_guestfs_exists, 1);
2976   rb_define_method (c_guestfs, "is_file",
2977         ruby_guestfs_is_file, 1);
2978   rb_define_method (c_guestfs, "is_dir",
2979         ruby_guestfs_is_dir, 1);
2980   rb_define_method (c_guestfs, "pvcreate",
2981         ruby_guestfs_pvcreate, 1);
2982   rb_define_method (c_guestfs, "vgcreate",
2983         ruby_guestfs_vgcreate, 2);
2984   rb_define_method (c_guestfs, "lvcreate",
2985         ruby_guestfs_lvcreate, 3);
2986   rb_define_method (c_guestfs, "mkfs",
2987         ruby_guestfs_mkfs, 2);
2988   rb_define_method (c_guestfs, "sfdisk",
2989         ruby_guestfs_sfdisk, 5);
2990   rb_define_method (c_guestfs, "write_file",
2991         ruby_guestfs_write_file, 3);
2992   rb_define_method (c_guestfs, "umount",
2993         ruby_guestfs_umount, 1);
2994   rb_define_method (c_guestfs, "mounts",
2995         ruby_guestfs_mounts, 0);
2996   rb_define_method (c_guestfs, "umount_all",
2997         ruby_guestfs_umount_all, 0);
2998   rb_define_method (c_guestfs, "lvm_remove_all",
2999         ruby_guestfs_lvm_remove_all, 0);
3000   rb_define_method (c_guestfs, "file",
3001         ruby_guestfs_file, 1);
3002   rb_define_method (c_guestfs, "command",
3003         ruby_guestfs_command, 1);
3004   rb_define_method (c_guestfs, "command_lines",
3005         ruby_guestfs_command_lines, 1);
3006   rb_define_method (c_guestfs, "stat",
3007         ruby_guestfs_stat, 1);
3008   rb_define_method (c_guestfs, "lstat",
3009         ruby_guestfs_lstat, 1);
3010   rb_define_method (c_guestfs, "statvfs",
3011         ruby_guestfs_statvfs, 1);
3012   rb_define_method (c_guestfs, "tune2fs_l",
3013         ruby_guestfs_tune2fs_l, 1);
3014   rb_define_method (c_guestfs, "blockdev_setro",
3015         ruby_guestfs_blockdev_setro, 1);
3016   rb_define_method (c_guestfs, "blockdev_setrw",
3017         ruby_guestfs_blockdev_setrw, 1);
3018   rb_define_method (c_guestfs, "blockdev_getro",
3019         ruby_guestfs_blockdev_getro, 1);
3020   rb_define_method (c_guestfs, "blockdev_getss",
3021         ruby_guestfs_blockdev_getss, 1);
3022   rb_define_method (c_guestfs, "blockdev_getbsz",
3023         ruby_guestfs_blockdev_getbsz, 1);
3024   rb_define_method (c_guestfs, "blockdev_setbsz",
3025         ruby_guestfs_blockdev_setbsz, 2);
3026   rb_define_method (c_guestfs, "blockdev_getsz",
3027         ruby_guestfs_blockdev_getsz, 1);
3028   rb_define_method (c_guestfs, "blockdev_getsize64",
3029         ruby_guestfs_blockdev_getsize64, 1);
3030   rb_define_method (c_guestfs, "blockdev_flushbufs",
3031         ruby_guestfs_blockdev_flushbufs, 1);
3032   rb_define_method (c_guestfs, "blockdev_rereadpt",
3033         ruby_guestfs_blockdev_rereadpt, 1);
3034   rb_define_method (c_guestfs, "upload",
3035         ruby_guestfs_upload, 2);
3036   rb_define_method (c_guestfs, "download",
3037         ruby_guestfs_download, 2);
3038   rb_define_method (c_guestfs, "checksum",
3039         ruby_guestfs_checksum, 2);
3040   rb_define_method (c_guestfs, "tar_in",
3041         ruby_guestfs_tar_in, 2);
3042   rb_define_method (c_guestfs, "tar_out",
3043         ruby_guestfs_tar_out, 2);
3044   rb_define_method (c_guestfs, "tgz_in",
3045         ruby_guestfs_tgz_in, 2);
3046   rb_define_method (c_guestfs, "tgz_out",
3047         ruby_guestfs_tgz_out, 2);
3048   rb_define_method (c_guestfs, "mount_ro",
3049         ruby_guestfs_mount_ro, 2);
3050   rb_define_method (c_guestfs, "mount_options",
3051         ruby_guestfs_mount_options, 3);
3052   rb_define_method (c_guestfs, "mount_vfs",
3053         ruby_guestfs_mount_vfs, 4);
3054   rb_define_method (c_guestfs, "debug",
3055         ruby_guestfs_debug, 2);
3056   rb_define_method (c_guestfs, "lvremove",
3057         ruby_guestfs_lvremove, 1);
3058   rb_define_method (c_guestfs, "vgremove",
3059         ruby_guestfs_vgremove, 1);
3060   rb_define_method (c_guestfs, "pvremove",
3061         ruby_guestfs_pvremove, 1);
3062   rb_define_method (c_guestfs, "set_e2label",
3063         ruby_guestfs_set_e2label, 2);
3064   rb_define_method (c_guestfs, "get_e2label",
3065         ruby_guestfs_get_e2label, 1);
3066   rb_define_method (c_guestfs, "set_e2uuid",
3067         ruby_guestfs_set_e2uuid, 2);
3068   rb_define_method (c_guestfs, "get_e2uuid",
3069         ruby_guestfs_get_e2uuid, 1);
3070   rb_define_method (c_guestfs, "fsck",
3071         ruby_guestfs_fsck, 2);
3072   rb_define_method (c_guestfs, "zero",
3073         ruby_guestfs_zero, 1);
3074   rb_define_method (c_guestfs, "grub_install",
3075         ruby_guestfs_grub_install, 2);
3076   rb_define_method (c_guestfs, "cp",
3077         ruby_guestfs_cp, 2);
3078   rb_define_method (c_guestfs, "cp_a",
3079         ruby_guestfs_cp_a, 2);
3080   rb_define_method (c_guestfs, "mv",
3081         ruby_guestfs_mv, 2);
3082   rb_define_method (c_guestfs, "drop_caches",
3083         ruby_guestfs_drop_caches, 1);
3084   rb_define_method (c_guestfs, "dmesg",
3085         ruby_guestfs_dmesg, 0);
3086   rb_define_method (c_guestfs, "ping_daemon",
3087         ruby_guestfs_ping_daemon, 0);
3088   rb_define_method (c_guestfs, "equal",
3089         ruby_guestfs_equal, 2);
3090   rb_define_method (c_guestfs, "strings",
3091         ruby_guestfs_strings, 1);
3092   rb_define_method (c_guestfs, "strings_e",
3093         ruby_guestfs_strings_e, 2);
3094   rb_define_method (c_guestfs, "hexdump",
3095         ruby_guestfs_hexdump, 1);
3096 }