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 static VALUE m_guestfs;                 /* guestfs module */
  32 static VALUE c_guestfs;                 /* guestfs_h handle */
  33 static VALUE e_Error;                   /* used for all errors */
  34
  35 static void ruby_guestfs_free (void *p)
  36 {
  37   if (!p) return;
  38   guestfs_close ((guestfs_h *) p);
  39 }
  40
  41 static VALUE ruby_guestfs_create (VALUE m)
  42 {
  43   guestfs_h *g;
  44
  45   g = guestfs_create ();
  46   if (!g)
  47     rb_raise (e_Error, "failed to create guestfs handle");
  48
  49   /* Don't print error messages to stderr by default. */
  50   guestfs_set_error_handler (g, NULL, NULL);
  51
  52   /* Wrap it, and make sure the close function is called when the
  53    * handle goes away.
  54    */
  55   return Data_Wrap_Struct (c_guestfs, NULL, ruby_guestfs_free, g);
  56 }
  57
  58 static VALUE ruby_guestfs_close (VALUE gv)
  59 {
  60   guestfs_h *g;
  61   Data_Get_Struct (gv, guestfs_h, g);
  62
  63   ruby_guestfs_free (g);
  64   DATA_PTR (gv) = NULL;
  65
  66   return Qnil;
  67 }
  68
  69 static VALUE ruby_guestfs_launch (VALUE gv)
  70 {
  71   guestfs_h *g;
  72   Data_Get_Struct (gv, guestfs_h, g);
  73   if (!g)
  74     rb_raise (rb_eArgError, "%s: used handle after closing it", "launch");
  75
  76
  77   int r;
  78
  79   r = guestfs_launch (g);
  80   if (r == -1)
  81     rb_raise (e_Error, "%s", guestfs_last_error (g));
  82
  83   return Qnil;
  84 }
  85
  86 static VALUE ruby_guestfs_wait_ready (VALUE gv)
  87 {
  88   guestfs_h *g;
  89   Data_Get_Struct (gv, guestfs_h, g);
  90   if (!g)
  91     rb_raise (rb_eArgError, "%s: used handle after closing it", "wait_ready");
  92
  93
  94   int r;
  95
  96   r = guestfs_wait_ready (g);
  97   if (r == -1)
  98     rb_raise (e_Error, "%s", guestfs_last_error (g));
  99
 100   return Qnil;
 101 }
 102
 103 static VALUE ruby_guestfs_kill_subprocess (VALUE gv)
 104 {
 105   guestfs_h *g;
 106   Data_Get_Struct (gv, guestfs_h, g);
 107   if (!g)
 108     rb_raise (rb_eArgError, "%s: used handle after closing it", "kill_subprocess");
 109
 110
 111   int r;
 112
 113   r = guestfs_kill_subprocess (g);
 114   if (r == -1)
 115     rb_raise (e_Error, "%s", guestfs_last_error (g));
 116
 117   return Qnil;
 118 }
 119
 120 static VALUE ruby_guestfs_add_drive (VALUE gv, VALUE filenamev)
 121 {
 122   guestfs_h *g;
 123   Data_Get_Struct (gv, guestfs_h, g);
 124   if (!g)
 125     rb_raise (rb_eArgError, "%s: used handle after closing it", "add_drive");
 126
 127   const char *filename = StringValueCStr (filenamev);
 128   if (!filename)
 129     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
 130               "filename", "add_drive");
 131
 132   int r;
 133
 134   r = guestfs_add_drive (g, filename);
 135   if (r == -1)
 136     rb_raise (e_Error, "%s", guestfs_last_error (g));
 137
 138   return Qnil;
 139 }
 140
 141 static VALUE ruby_guestfs_add_cdrom (VALUE gv, VALUE filenamev)
 142 {
 143   guestfs_h *g;
 144   Data_Get_Struct (gv, guestfs_h, g);
 145   if (!g)
 146     rb_raise (rb_eArgError, "%s: used handle after closing it", "add_cdrom");
 147
 148   const char *filename = StringValueCStr (filenamev);
 149   if (!filename)
 150     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
 151               "filename", "add_cdrom");
 152
 153   int r;
 154
 155   r = guestfs_add_cdrom (g, filename);
 156   if (r == -1)
 157     rb_raise (e_Error, "%s", guestfs_last_error (g));
 158
 159   return Qnil;
 160 }
 161
 162 static VALUE ruby_guestfs_config (VALUE gv, VALUE qemuparamv, VALUE qemuvaluev)
 163 {
 164   guestfs_h *g;
 165   Data_Get_Struct (gv, guestfs_h, g);
 166   if (!g)
 167     rb_raise (rb_eArgError, "%s: used handle after closing it", "config");
 168
 169   const char *qemuparam = StringValueCStr (qemuparamv);
 170   if (!qemuparam)
 171     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
 172               "qemuparam", "config");
 173   const char *qemuvalue = StringValueCStr (qemuvaluev);
 174
 175   int r;
 176
 177   r = guestfs_config (g, qemuparam, qemuvalue);
 178   if (r == -1)
 179     rb_raise (e_Error, "%s", guestfs_last_error (g));
 180
 181   return Qnil;
 182 }
 183
 184 static VALUE ruby_guestfs_set_path (VALUE gv, VALUE pathv)
 185 {
 186   guestfs_h *g;
 187   Data_Get_Struct (gv, guestfs_h, g);
 188   if (!g)
 189     rb_raise (rb_eArgError, "%s: used handle after closing it", "set_path");
 190
 191   const char *path = StringValueCStr (pathv);
 192   if (!path)
 193     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
 194               "path", "set_path");
 195
 196   int r;
 197
 198   r = guestfs_set_path (g, path);
 199   if (r == -1)
 200     rb_raise (e_Error, "%s", guestfs_last_error (g));
 201
 202   return Qnil;
 203 }
 204
 205 static VALUE ruby_guestfs_get_path (VALUE gv)
 206 {
 207   guestfs_h *g;
 208   Data_Get_Struct (gv, guestfs_h, g);
 209   if (!g)
 210     rb_raise (rb_eArgError, "%s: used handle after closing it", "get_path");
 211
 212
 213   const char *r;
 214
 215   r = guestfs_get_path (g);
 216   if (r == NULL)
 217     rb_raise (e_Error, "%s", guestfs_last_error (g));
 218
 219   return rb_str_new2 (r);
 220 }
 221
 222 static VALUE ruby_guestfs_set_autosync (VALUE gv, VALUE autosyncv)
 223 {
 224   guestfs_h *g;
 225   Data_Get_Struct (gv, guestfs_h, g);
 226   if (!g)
 227     rb_raise (rb_eArgError, "%s: used handle after closing it", "set_autosync");
 228
 229   int autosync = NUM2INT (autosyncv);
 230
 231   int r;
 232
 233   r = guestfs_set_autosync (g, autosync);
 234   if (r == -1)
 235     rb_raise (e_Error, "%s", guestfs_last_error (g));
 236
 237   return Qnil;
 238 }
 239
 240 static VALUE ruby_guestfs_get_autosync (VALUE gv)
 241 {
 242   guestfs_h *g;
 243   Data_Get_Struct (gv, guestfs_h, g);
 244   if (!g)
 245     rb_raise (rb_eArgError, "%s: used handle after closing it", "get_autosync");
 246
 247
 248   int r;
 249
 250   r = guestfs_get_autosync (g);
 251   if (r == -1)
 252     rb_raise (e_Error, "%s", guestfs_last_error (g));
 253
 254   return INT2NUM (r);
 255 }
 256
 257 static VALUE ruby_guestfs_set_verbose (VALUE gv, VALUE verbosev)
 258 {
 259   guestfs_h *g;
 260   Data_Get_Struct (gv, guestfs_h, g);
 261   if (!g)
 262     rb_raise (rb_eArgError, "%s: used handle after closing it", "set_verbose");
 263
 264   int verbose = NUM2INT (verbosev);
 265
 266   int r;
 267
 268   r = guestfs_set_verbose (g, verbose);
 269   if (r == -1)
 270     rb_raise (e_Error, "%s", guestfs_last_error (g));
 271
 272   return Qnil;
 273 }
 274
 275 static VALUE ruby_guestfs_get_verbose (VALUE gv)
 276 {
 277   guestfs_h *g;
 278   Data_Get_Struct (gv, guestfs_h, g);
 279   if (!g)
 280     rb_raise (rb_eArgError, "%s: used handle after closing it", "get_verbose");
 281
 282
 283   int r;
 284
 285   r = guestfs_get_verbose (g);
 286   if (r == -1)
 287     rb_raise (e_Error, "%s", guestfs_last_error (g));
 288
 289   return INT2NUM (r);
 290 }
 291
 292 static VALUE ruby_guestfs_is_ready (VALUE gv)
 293 {
 294   guestfs_h *g;
 295   Data_Get_Struct (gv, guestfs_h, g);
 296   if (!g)
 297     rb_raise (rb_eArgError, "%s: used handle after closing it", "is_ready");
 298
 299
 300   int r;
 301
 302   r = guestfs_is_ready (g);
 303   if (r == -1)
 304     rb_raise (e_Error, "%s", guestfs_last_error (g));
 305
 306   return INT2NUM (r);
 307 }
 308
 309 static VALUE ruby_guestfs_is_config (VALUE gv)
 310 {
 311   guestfs_h *g;
 312   Data_Get_Struct (gv, guestfs_h, g);
 313   if (!g)
 314     rb_raise (rb_eArgError, "%s: used handle after closing it", "is_config");
 315
 316
 317   int r;
 318
 319   r = guestfs_is_config (g);
 320   if (r == -1)
 321     rb_raise (e_Error, "%s", guestfs_last_error (g));
 322
 323   return INT2NUM (r);
 324 }
 325
 326 static VALUE ruby_guestfs_is_launching (VALUE gv)
 327 {
 328   guestfs_h *g;
 329   Data_Get_Struct (gv, guestfs_h, g);
 330   if (!g)
 331     rb_raise (rb_eArgError, "%s: used handle after closing it", "is_launching");
 332
 333
 334   int r;
 335
 336   r = guestfs_is_launching (g);
 337   if (r == -1)
 338     rb_raise (e_Error, "%s", guestfs_last_error (g));
 339
 340   return INT2NUM (r);
 341 }
 342
 343 static VALUE ruby_guestfs_is_busy (VALUE gv)
 344 {
 345   guestfs_h *g;
 346   Data_Get_Struct (gv, guestfs_h, g);
 347   if (!g)
 348     rb_raise (rb_eArgError, "%s: used handle after closing it", "is_busy");
 349
 350
 351   int r;
 352
 353   r = guestfs_is_busy (g);
 354   if (r == -1)
 355     rb_raise (e_Error, "%s", guestfs_last_error (g));
 356
 357   return INT2NUM (r);
 358 }
 359
 360 static VALUE ruby_guestfs_get_state (VALUE gv)
 361 {
 362   guestfs_h *g;
 363   Data_Get_Struct (gv, guestfs_h, g);
 364   if (!g)
 365     rb_raise (rb_eArgError, "%s: used handle after closing it", "get_state");
 366
 367
 368   int r;
 369
 370   r = guestfs_get_state (g);
 371   if (r == -1)
 372     rb_raise (e_Error, "%s", guestfs_last_error (g));
 373
 374   return INT2NUM (r);
 375 }
 376
 377 static VALUE ruby_guestfs_set_busy (VALUE gv)
 378 {
 379   guestfs_h *g;
 380   Data_Get_Struct (gv, guestfs_h, g);
 381   if (!g)
 382     rb_raise (rb_eArgError, "%s: used handle after closing it", "set_busy");
 383
 384
 385   int r;
 386
 387   r = guestfs_set_busy (g);
 388   if (r == -1)
 389     rb_raise (e_Error, "%s", guestfs_last_error (g));
 390
 391   return Qnil;
 392 }
 393
 394 static VALUE ruby_guestfs_set_ready (VALUE gv)
 395 {
 396   guestfs_h *g;
 397   Data_Get_Struct (gv, guestfs_h, g);
 398   if (!g)
 399     rb_raise (rb_eArgError, "%s: used handle after closing it", "set_ready");
 400
 401
 402   int r;
 403
 404   r = guestfs_set_ready (g);
 405   if (r == -1)
 406     rb_raise (e_Error, "%s", guestfs_last_error (g));
 407
 408   return Qnil;
 409 }
 410
 411 static VALUE ruby_guestfs_mount (VALUE gv, VALUE devicev, VALUE mountpointv)
 412 {
 413   guestfs_h *g;
 414   Data_Get_Struct (gv, guestfs_h, g);
 415   if (!g)
 416     rb_raise (rb_eArgError, "%s: used handle after closing it", "mount");
 417
 418   const char *device = StringValueCStr (devicev);
 419   if (!device)
 420     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
 421               "device", "mount");
 422   const char *mountpoint = StringValueCStr (mountpointv);
 423   if (!mountpoint)
 424     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
 425               "mountpoint", "mount");
 426
 427   int r;
 428
 429   r = guestfs_mount (g, device, mountpoint);
 430   if (r == -1)
 431     rb_raise (e_Error, "%s", guestfs_last_error (g));
 432
 433   return Qnil;
 434 }
 435
 436 static VALUE ruby_guestfs_sync (VALUE gv)
 437 {
 438   guestfs_h *g;
 439   Data_Get_Struct (gv, guestfs_h, g);
 440   if (!g)
 441     rb_raise (rb_eArgError, "%s: used handle after closing it", "sync");
 442
 443
 444   int r;
 445
 446   r = guestfs_sync (g);
 447   if (r == -1)
 448     rb_raise (e_Error, "%s", guestfs_last_error (g));
 449
 450   return Qnil;
 451 }
 452
 453 static VALUE ruby_guestfs_touch (VALUE gv, VALUE pathv)
 454 {
 455   guestfs_h *g;
 456   Data_Get_Struct (gv, guestfs_h, g);
 457   if (!g)
 458     rb_raise (rb_eArgError, "%s: used handle after closing it", "touch");
 459
 460   const char *path = StringValueCStr (pathv);
 461   if (!path)
 462     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
 463               "path", "touch");
 464
 465   int r;
 466
 467   r = guestfs_touch (g, path);
 468   if (r == -1)
 469     rb_raise (e_Error, "%s", guestfs_last_error (g));
 470
 471   return Qnil;
 472 }
 473
 474 static VALUE ruby_guestfs_cat (VALUE gv, VALUE pathv)
 475 {
 476   guestfs_h *g;
 477   Data_Get_Struct (gv, guestfs_h, g);
 478   if (!g)
 479     rb_raise (rb_eArgError, "%s: used handle after closing it", "cat");
 480
 481   const char *path = StringValueCStr (pathv);
 482   if (!path)
 483     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
 484               "path", "cat");
 485
 486   char *r;
 487
 488   r = guestfs_cat (g, path);
 489   if (r == NULL)
 490     rb_raise (e_Error, "%s", guestfs_last_error (g));
 491
 492   VALUE rv = rb_str_new2 (r);
 493   free (r);
 494   return rv;
 495 }
 496
 497 static VALUE ruby_guestfs_ll (VALUE gv, VALUE directoryv)
 498 {
 499   guestfs_h *g;
 500   Data_Get_Struct (gv, guestfs_h, g);
 501   if (!g)
 502     rb_raise (rb_eArgError, "%s: used handle after closing it", "ll");
 503
 504   const char *directory = StringValueCStr (directoryv);
 505   if (!directory)
 506     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
 507               "directory", "ll");
 508
 509   char *r;
 510
 511   r = guestfs_ll (g, directory);
 512   if (r == NULL)
 513     rb_raise (e_Error, "%s", guestfs_last_error (g));
 514
 515   VALUE rv = rb_str_new2 (r);
 516   free (r);
 517   return rv;
 518 }
 519
 520 static VALUE ruby_guestfs_ls (VALUE gv, VALUE directoryv)
 521 {
 522   guestfs_h *g;
 523   Data_Get_Struct (gv, guestfs_h, g);
 524   if (!g)
 525     rb_raise (rb_eArgError, "%s: used handle after closing it", "ls");
 526
 527   const char *directory = StringValueCStr (directoryv);
 528   if (!directory)
 529     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
 530               "directory", "ls");
 531
 532   char **r;
 533
 534   r = guestfs_ls (g, directory);
 535   if (r == NULL)
 536     rb_raise (e_Error, "%s", guestfs_last_error (g));
 537
 538   int i, len = 0;
 539   for (i = 0; r[i] != NULL; ++i) len++;
 540   VALUE rv = rb_ary_new2 (len);
 541   for (i = 0; r[i] != NULL; ++i) {
 542     rb_ary_push (rv, rb_str_new2 (r[i]));
 543     free (r[i]);
 544   }
 545   free (r);
 546   return rv;
 547 }
 548
 549 static VALUE ruby_guestfs_list_devices (VALUE gv)
 550 {
 551   guestfs_h *g;
 552   Data_Get_Struct (gv, guestfs_h, g);
 553   if (!g)
 554     rb_raise (rb_eArgError, "%s: used handle after closing it", "list_devices");
 555
 556
 557   char **r;
 558
 559   r = guestfs_list_devices (g);
 560   if (r == NULL)
 561     rb_raise (e_Error, "%s", guestfs_last_error (g));
 562
 563   int i, len = 0;
 564   for (i = 0; r[i] != NULL; ++i) len++;
 565   VALUE rv = rb_ary_new2 (len);
 566   for (i = 0; r[i] != NULL; ++i) {
 567     rb_ary_push (rv, rb_str_new2 (r[i]));
 568     free (r[i]);
 569   }
 570   free (r);
 571   return rv;
 572 }
 573
 574 static VALUE ruby_guestfs_list_partitions (VALUE gv)
 575 {
 576   guestfs_h *g;
 577   Data_Get_Struct (gv, guestfs_h, g);
 578   if (!g)
 579     rb_raise (rb_eArgError, "%s: used handle after closing it", "list_partitions");
 580
 581
 582   char **r;
 583
 584   r = guestfs_list_partitions (g);
 585   if (r == NULL)
 586     rb_raise (e_Error, "%s", guestfs_last_error (g));
 587
 588   int i, len = 0;
 589   for (i = 0; r[i] != NULL; ++i) len++;
 590   VALUE rv = rb_ary_new2 (len);
 591   for (i = 0; r[i] != NULL; ++i) {
 592     rb_ary_push (rv, rb_str_new2 (r[i]));
 593     free (r[i]);
 594   }
 595   free (r);
 596   return rv;
 597 }
 598
 599 static VALUE ruby_guestfs_pvs (VALUE gv)
 600 {
 601   guestfs_h *g;
 602   Data_Get_Struct (gv, guestfs_h, g);
 603   if (!g)
 604     rb_raise (rb_eArgError, "%s: used handle after closing it", "pvs");
 605
 606
 607   char **r;
 608
 609   r = guestfs_pvs (g);
 610   if (r == NULL)
 611     rb_raise (e_Error, "%s", guestfs_last_error (g));
 612
 613   int i, len = 0;
 614   for (i = 0; r[i] != NULL; ++i) len++;
 615   VALUE rv = rb_ary_new2 (len);
 616   for (i = 0; r[i] != NULL; ++i) {
 617     rb_ary_push (rv, rb_str_new2 (r[i]));
 618     free (r[i]);
 619   }
 620   free (r);
 621   return rv;
 622 }
 623
 624 static VALUE ruby_guestfs_vgs (VALUE gv)
 625 {
 626   guestfs_h *g;
 627   Data_Get_Struct (gv, guestfs_h, g);
 628   if (!g)
 629     rb_raise (rb_eArgError, "%s: used handle after closing it", "vgs");
 630
 631
 632   char **r;
 633
 634   r = guestfs_vgs (g);
 635   if (r == NULL)
 636     rb_raise (e_Error, "%s", guestfs_last_error (g));
 637
 638   int i, len = 0;
 639   for (i = 0; r[i] != NULL; ++i) len++;
 640   VALUE rv = rb_ary_new2 (len);
 641   for (i = 0; r[i] != NULL; ++i) {
 642     rb_ary_push (rv, rb_str_new2 (r[i]));
 643     free (r[i]);
 644   }
 645   free (r);
 646   return rv;
 647 }
 648
 649 static VALUE ruby_guestfs_lvs (VALUE gv)
 650 {
 651   guestfs_h *g;
 652   Data_Get_Struct (gv, guestfs_h, g);
 653   if (!g)
 654     rb_raise (rb_eArgError, "%s: used handle after closing it", "lvs");
 655
 656
 657   char **r;
 658
 659   r = guestfs_lvs (g);
 660   if (r == NULL)
 661     rb_raise (e_Error, "%s", guestfs_last_error (g));
 662
 663   int i, len = 0;
 664   for (i = 0; r[i] != NULL; ++i) len++;
 665   VALUE rv = rb_ary_new2 (len);
 666   for (i = 0; r[i] != NULL; ++i) {
 667     rb_ary_push (rv, rb_str_new2 (r[i]));
 668     free (r[i]);
 669   }
 670   free (r);
 671   return rv;
 672 }
 673
 674 static VALUE ruby_guestfs_pvs_full (VALUE gv)
 675 {
 676   guestfs_h *g;
 677   Data_Get_Struct (gv, guestfs_h, g);
 678   if (!g)
 679     rb_raise (rb_eArgError, "%s: used handle after closing it", "pvs_full");
 680
 681
 682   struct guestfs_lvm_pv_list *r;
 683
 684   r = guestfs_pvs_full (g);
 685   if (r == NULL)
 686     rb_raise (e_Error, "%s", guestfs_last_error (g));
 687
 688   VALUE rv = rb_ary_new2 (r->len);
 689   int i;
 690   for (i = 0; i < r->len; ++i) {
 691     VALUE hv = rb_hash_new ();
 692     rb_hash_aset (rv, rb_str_new2 ("pv_name"), rb_str_new2 (r->val[i].pv_name));
 693     rb_hash_aset (rv, rb_str_new2 ("pv_uuid"), rb_str_new (r->val[i].pv_uuid, 32));
 694     rb_hash_aset (rv, rb_str_new2 ("pv_fmt"), rb_str_new2 (r->val[i].pv_fmt));
 695     rb_hash_aset (rv, rb_str_new2 ("pv_size"), ULL2NUM (r->val[i].pv_size));
 696     rb_hash_aset (rv, rb_str_new2 ("dev_size"), ULL2NUM (r->val[i].dev_size));
 697     rb_hash_aset (rv, rb_str_new2 ("pv_free"), ULL2NUM (r->val[i].pv_free));
 698     rb_hash_aset (rv, rb_str_new2 ("pv_used"), ULL2NUM (r->val[i].pv_used));
 699     rb_hash_aset (rv, rb_str_new2 ("pv_attr"), rb_str_new2 (r->val[i].pv_attr));
 700     rb_hash_aset (rv, rb_str_new2 ("pv_pe_count"), ULL2NUM (r->val[i].pv_pe_count));
 701     rb_hash_aset (rv, rb_str_new2 ("pv_pe_alloc_count"), ULL2NUM (r->val[i].pv_pe_alloc_count));
 702     rb_hash_aset (rv, rb_str_new2 ("pv_tags"), rb_str_new2 (r->val[i].pv_tags));
 703     rb_hash_aset (rv, rb_str_new2 ("pe_start"), ULL2NUM (r->val[i].pe_start));
 704     rb_hash_aset (rv, rb_str_new2 ("pv_mda_count"), ULL2NUM (r->val[i].pv_mda_count));
 705     rb_hash_aset (rv, rb_str_new2 ("pv_mda_free"), ULL2NUM (r->val[i].pv_mda_free));
 706     rb_ary_push (rv, hv);
 707   }
 708   guestfs_free_lvm_pv_list (r);
 709   return rv;
 710 }
 711
 712 static VALUE ruby_guestfs_vgs_full (VALUE gv)
 713 {
 714   guestfs_h *g;
 715   Data_Get_Struct (gv, guestfs_h, g);
 716   if (!g)
 717     rb_raise (rb_eArgError, "%s: used handle after closing it", "vgs_full");
 718
 719
 720   struct guestfs_lvm_vg_list *r;
 721
 722   r = guestfs_vgs_full (g);
 723   if (r == NULL)
 724     rb_raise (e_Error, "%s", guestfs_last_error (g));
 725
 726   VALUE rv = rb_ary_new2 (r->len);
 727   int i;
 728   for (i = 0; i < r->len; ++i) {
 729     VALUE hv = rb_hash_new ();
 730     rb_hash_aset (rv, rb_str_new2 ("vg_name"), rb_str_new2 (r->val[i].vg_name));
 731     rb_hash_aset (rv, rb_str_new2 ("vg_uuid"), rb_str_new (r->val[i].vg_uuid, 32));
 732     rb_hash_aset (rv, rb_str_new2 ("vg_fmt"), rb_str_new2 (r->val[i].vg_fmt));
 733     rb_hash_aset (rv, rb_str_new2 ("vg_attr"), rb_str_new2 (r->val[i].vg_attr));
 734     rb_hash_aset (rv, rb_str_new2 ("vg_size"), ULL2NUM (r->val[i].vg_size));
 735     rb_hash_aset (rv, rb_str_new2 ("vg_free"), ULL2NUM (r->val[i].vg_free));
 736     rb_hash_aset (rv, rb_str_new2 ("vg_sysid"), rb_str_new2 (r->val[i].vg_sysid));
 737     rb_hash_aset (rv, rb_str_new2 ("vg_extent_size"), ULL2NUM (r->val[i].vg_extent_size));
 738     rb_hash_aset (rv, rb_str_new2 ("vg_extent_count"), ULL2NUM (r->val[i].vg_extent_count));
 739     rb_hash_aset (rv, rb_str_new2 ("vg_free_count"), ULL2NUM (r->val[i].vg_free_count));
 740     rb_hash_aset (rv, rb_str_new2 ("max_lv"), ULL2NUM (r->val[i].max_lv));
 741     rb_hash_aset (rv, rb_str_new2 ("max_pv"), ULL2NUM (r->val[i].max_pv));
 742     rb_hash_aset (rv, rb_str_new2 ("pv_count"), ULL2NUM (r->val[i].pv_count));
 743     rb_hash_aset (rv, rb_str_new2 ("lv_count"), ULL2NUM (r->val[i].lv_count));
 744     rb_hash_aset (rv, rb_str_new2 ("snap_count"), ULL2NUM (r->val[i].snap_count));
 745     rb_hash_aset (rv, rb_str_new2 ("vg_seqno"), ULL2NUM (r->val[i].vg_seqno));
 746     rb_hash_aset (rv, rb_str_new2 ("vg_tags"), rb_str_new2 (r->val[i].vg_tags));
 747     rb_hash_aset (rv, rb_str_new2 ("vg_mda_count"), ULL2NUM (r->val[i].vg_mda_count));
 748     rb_hash_aset (rv, rb_str_new2 ("vg_mda_free"), ULL2NUM (r->val[i].vg_mda_free));
 749     rb_ary_push (rv, hv);
 750   }
 751   guestfs_free_lvm_vg_list (r);
 752   return rv;
 753 }
 754
 755 static VALUE ruby_guestfs_lvs_full (VALUE gv)
 756 {
 757   guestfs_h *g;
 758   Data_Get_Struct (gv, guestfs_h, g);
 759   if (!g)
 760     rb_raise (rb_eArgError, "%s: used handle after closing it", "lvs_full");
 761
 762
 763   struct guestfs_lvm_lv_list *r;
 764
 765   r = guestfs_lvs_full (g);
 766   if (r == NULL)
 767     rb_raise (e_Error, "%s", guestfs_last_error (g));
 768
 769   VALUE rv = rb_ary_new2 (r->len);
 770   int i;
 771   for (i = 0; i < r->len; ++i) {
 772     VALUE hv = rb_hash_new ();
 773     rb_hash_aset (rv, rb_str_new2 ("lv_name"), rb_str_new2 (r->val[i].lv_name));
 774     rb_hash_aset (rv, rb_str_new2 ("lv_uuid"), rb_str_new (r->val[i].lv_uuid, 32));
 775     rb_hash_aset (rv, rb_str_new2 ("lv_attr"), rb_str_new2 (r->val[i].lv_attr));
 776     rb_hash_aset (rv, rb_str_new2 ("lv_major"), ULL2NUM (r->val[i].lv_major));
 777     rb_hash_aset (rv, rb_str_new2 ("lv_minor"), ULL2NUM (r->val[i].lv_minor));
 778     rb_hash_aset (rv, rb_str_new2 ("lv_kernel_major"), ULL2NUM (r->val[i].lv_kernel_major));
 779     rb_hash_aset (rv, rb_str_new2 ("lv_kernel_minor"), ULL2NUM (r->val[i].lv_kernel_minor));
 780     rb_hash_aset (rv, rb_str_new2 ("lv_size"), ULL2NUM (r->val[i].lv_size));
 781     rb_hash_aset (rv, rb_str_new2 ("seg_count"), ULL2NUM (r->val[i].seg_count));
 782     rb_hash_aset (rv, rb_str_new2 ("origin"), rb_str_new2 (r->val[i].origin));
 783     rb_hash_aset (rv, rb_str_new2 ("snap_percent"), rb_dbl2big (r->val[i].snap_percent));
 784     rb_hash_aset (rv, rb_str_new2 ("copy_percent"), rb_dbl2big (r->val[i].copy_percent));
 785     rb_hash_aset (rv, rb_str_new2 ("move_pv"), rb_str_new2 (r->val[i].move_pv));
 786     rb_hash_aset (rv, rb_str_new2 ("lv_tags"), rb_str_new2 (r->val[i].lv_tags));
 787     rb_hash_aset (rv, rb_str_new2 ("mirror_log"), rb_str_new2 (r->val[i].mirror_log));
 788     rb_hash_aset (rv, rb_str_new2 ("modules"), rb_str_new2 (r->val[i].modules));
 789     rb_ary_push (rv, hv);
 790   }
 791   guestfs_free_lvm_lv_list (r);
 792   return rv;
 793 }
 794
 795 static VALUE ruby_guestfs_read_lines (VALUE gv, VALUE pathv)
 796 {
 797   guestfs_h *g;
 798   Data_Get_Struct (gv, guestfs_h, g);
 799   if (!g)
 800     rb_raise (rb_eArgError, "%s: used handle after closing it", "read_lines");
 801
 802   const char *path = StringValueCStr (pathv);
 803   if (!path)
 804     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
 805               "path", "read_lines");
 806
 807   char **r;
 808
 809   r = guestfs_read_lines (g, path);
 810   if (r == NULL)
 811     rb_raise (e_Error, "%s", guestfs_last_error (g));
 812
 813   int i, len = 0;
 814   for (i = 0; r[i] != NULL; ++i) len++;
 815   VALUE rv = rb_ary_new2 (len);
 816   for (i = 0; r[i] != NULL; ++i) {
 817     rb_ary_push (rv, rb_str_new2 (r[i]));
 818     free (r[i]);
 819   }
 820   free (r);
 821   return rv;
 822 }
 823
 824 static VALUE ruby_guestfs_aug_init (VALUE gv, VALUE rootv, VALUE flagsv)
 825 {
 826   guestfs_h *g;
 827   Data_Get_Struct (gv, guestfs_h, g);
 828   if (!g)
 829     rb_raise (rb_eArgError, "%s: used handle after closing it", "aug_init");
 830
 831   const char *root = StringValueCStr (rootv);
 832   if (!root)
 833     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
 834               "root", "aug_init");
 835   int flags = NUM2INT (flagsv);
 836
 837   int r;
 838
 839   r = guestfs_aug_init (g, root, flags);
 840   if (r == -1)
 841     rb_raise (e_Error, "%s", guestfs_last_error (g));
 842
 843   return Qnil;
 844 }
 845
 846 static VALUE ruby_guestfs_aug_close (VALUE gv)
 847 {
 848   guestfs_h *g;
 849   Data_Get_Struct (gv, guestfs_h, g);
 850   if (!g)
 851     rb_raise (rb_eArgError, "%s: used handle after closing it", "aug_close");
 852
 853
 854   int r;
 855
 856   r = guestfs_aug_close (g);
 857   if (r == -1)
 858     rb_raise (e_Error, "%s", guestfs_last_error (g));
 859
 860   return Qnil;
 861 }
 862
 863 static VALUE ruby_guestfs_aug_defvar (VALUE gv, VALUE namev, VALUE exprv)
 864 {
 865   guestfs_h *g;
 866   Data_Get_Struct (gv, guestfs_h, g);
 867   if (!g)
 868     rb_raise (rb_eArgError, "%s: used handle after closing it", "aug_defvar");
 869
 870   const char *name = StringValueCStr (namev);
 871   if (!name)
 872     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
 873               "name", "aug_defvar");
 874   const char *expr = StringValueCStr (exprv);
 875
 876   int r;
 877
 878   r = guestfs_aug_defvar (g, name, expr);
 879   if (r == -1)
 880     rb_raise (e_Error, "%s", guestfs_last_error (g));
 881
 882   return INT2NUM (r);
 883 }
 884
 885 static VALUE ruby_guestfs_aug_defnode (VALUE gv, VALUE namev, VALUE exprv, VALUE valv)
 886 {
 887   guestfs_h *g;
 888   Data_Get_Struct (gv, guestfs_h, g);
 889   if (!g)
 890     rb_raise (rb_eArgError, "%s: used handle after closing it", "aug_defnode");
 891
 892   const char *name = StringValueCStr (namev);
 893   if (!name)
 894     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
 895               "name", "aug_defnode");
 896   const char *expr = StringValueCStr (exprv);
 897   if (!expr)
 898     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
 899               "expr", "aug_defnode");
 900   const char *val = StringValueCStr (valv);
 901   if (!val)
 902     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
 903               "val", "aug_defnode");
 904
 905   struct guestfs_int_bool *r;
 906
 907   r = guestfs_aug_defnode (g, name, expr, val);
 908   if (r == NULL)
 909     rb_raise (e_Error, "%s", guestfs_last_error (g));
 910
 911   VALUE rv = rb_ary_new2 (2);
 912   rb_ary_push (rv, INT2NUM (r->i));
 913   rb_ary_push (rv, INT2NUM (r->b));
 914   guestfs_free_int_bool (r);
 915   return rv;
 916 }
 917
 918 static VALUE ruby_guestfs_aug_get (VALUE gv, VALUE pathv)
 919 {
 920   guestfs_h *g;
 921   Data_Get_Struct (gv, guestfs_h, g);
 922   if (!g)
 923     rb_raise (rb_eArgError, "%s: used handle after closing it", "aug_get");
 924
 925   const char *path = StringValueCStr (pathv);
 926   if (!path)
 927     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
 928               "path", "aug_get");
 929
 930   char *r;
 931
 932   r = guestfs_aug_get (g, path);
 933   if (r == NULL)
 934     rb_raise (e_Error, "%s", guestfs_last_error (g));
 935
 936   VALUE rv = rb_str_new2 (r);
 937   free (r);
 938   return rv;
 939 }
 940
 941 static VALUE ruby_guestfs_aug_set (VALUE gv, VALUE pathv, VALUE valv)
 942 {
 943   guestfs_h *g;
 944   Data_Get_Struct (gv, guestfs_h, g);
 945   if (!g)
 946     rb_raise (rb_eArgError, "%s: used handle after closing it", "aug_set");
 947
 948   const char *path = StringValueCStr (pathv);
 949   if (!path)
 950     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
 951               "path", "aug_set");
 952   const char *val = StringValueCStr (valv);
 953   if (!val)
 954     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
 955               "val", "aug_set");
 956
 957   int r;
 958
 959   r = guestfs_aug_set (g, path, val);
 960   if (r == -1)
 961     rb_raise (e_Error, "%s", guestfs_last_error (g));
 962
 963   return Qnil;
 964 }
 965
 966 static VALUE ruby_guestfs_aug_insert (VALUE gv, VALUE pathv, VALUE labelv, VALUE beforev)
 967 {
 968   guestfs_h *g;
 969   Data_Get_Struct (gv, guestfs_h, g);
 970   if (!g)
 971     rb_raise (rb_eArgError, "%s: used handle after closing it", "aug_insert");
 972
 973   const char *path = StringValueCStr (pathv);
 974   if (!path)
 975     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
 976               "path", "aug_insert");
 977   const char *label = StringValueCStr (labelv);
 978   if (!label)
 979     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
 980               "label", "aug_insert");
 981   int before = NUM2INT (beforev);
 982
 983   int r;
 984
 985   r = guestfs_aug_insert (g, path, label, before);
 986   if (r == -1)
 987     rb_raise (e_Error, "%s", guestfs_last_error (g));
 988
 989   return Qnil;
 990 }
 991
 992 static VALUE ruby_guestfs_aug_rm (VALUE gv, VALUE pathv)
 993 {
 994   guestfs_h *g;
 995   Data_Get_Struct (gv, guestfs_h, g);
 996   if (!g)
 997     rb_raise (rb_eArgError, "%s: used handle after closing it", "aug_rm");
 998
 999   const char *path = StringValueCStr (pathv);
1000   if (!path)
1001     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1002               "path", "aug_rm");
1003
1004   int r;
1005
1006   r = guestfs_aug_rm (g, path);
1007   if (r == -1)
1008     rb_raise (e_Error, "%s", guestfs_last_error (g));
1009
1010   return INT2NUM (r);
1011 }
1012
1013 static VALUE ruby_guestfs_aug_mv (VALUE gv, VALUE srcv, VALUE destv)
1014 {
1015   guestfs_h *g;
1016   Data_Get_Struct (gv, guestfs_h, g);
1017   if (!g)
1018     rb_raise (rb_eArgError, "%s: used handle after closing it", "aug_mv");
1019
1020   const char *src = StringValueCStr (srcv);
1021   if (!src)
1022     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1023               "src", "aug_mv");
1024   const char *dest = StringValueCStr (destv);
1025   if (!dest)
1026     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1027               "dest", "aug_mv");
1028
1029   int r;
1030
1031   r = guestfs_aug_mv (g, src, dest);
1032   if (r == -1)
1033     rb_raise (e_Error, "%s", guestfs_last_error (g));
1034
1035   return Qnil;
1036 }
1037
1038 static VALUE ruby_guestfs_aug_match (VALUE gv, VALUE pathv)
1039 {
1040   guestfs_h *g;
1041   Data_Get_Struct (gv, guestfs_h, g);
1042   if (!g)
1043     rb_raise (rb_eArgError, "%s: used handle after closing it", "aug_match");
1044
1045   const char *path = StringValueCStr (pathv);
1046   if (!path)
1047     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1048               "path", "aug_match");
1049
1050   char **r;
1051
1052   r = guestfs_aug_match (g, path);
1053   if (r == NULL)
1054     rb_raise (e_Error, "%s", guestfs_last_error (g));
1055
1056   int i, len = 0;
1057   for (i = 0; r[i] != NULL; ++i) len++;
1058   VALUE rv = rb_ary_new2 (len);
1059   for (i = 0; r[i] != NULL; ++i) {
1060     rb_ary_push (rv, rb_str_new2 (r[i]));
1061     free (r[i]);
1062   }
1063   free (r);
1064   return rv;
1065 }
1066
1067 static VALUE ruby_guestfs_aug_save (VALUE gv)
1068 {
1069   guestfs_h *g;
1070   Data_Get_Struct (gv, guestfs_h, g);
1071   if (!g)
1072     rb_raise (rb_eArgError, "%s: used handle after closing it", "aug_save");
1073
1074
1075   int r;
1076
1077   r = guestfs_aug_save (g);
1078   if (r == -1)
1079     rb_raise (e_Error, "%s", guestfs_last_error (g));
1080
1081   return Qnil;
1082 }
1083
1084 static VALUE ruby_guestfs_aug_load (VALUE gv)
1085 {
1086   guestfs_h *g;
1087   Data_Get_Struct (gv, guestfs_h, g);
1088   if (!g)
1089     rb_raise (rb_eArgError, "%s: used handle after closing it", "aug_load");
1090
1091
1092   int r;
1093
1094   r = guestfs_aug_load (g);
1095   if (r == -1)
1096     rb_raise (e_Error, "%s", guestfs_last_error (g));
1097
1098   return Qnil;
1099 }
1100
1101 static VALUE ruby_guestfs_aug_ls (VALUE gv, VALUE pathv)
1102 {
1103   guestfs_h *g;
1104   Data_Get_Struct (gv, guestfs_h, g);
1105   if (!g)
1106     rb_raise (rb_eArgError, "%s: used handle after closing it", "aug_ls");
1107
1108   const char *path = StringValueCStr (pathv);
1109   if (!path)
1110     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1111               "path", "aug_ls");
1112
1113   char **r;
1114
1115   r = guestfs_aug_ls (g, path);
1116   if (r == NULL)
1117     rb_raise (e_Error, "%s", guestfs_last_error (g));
1118
1119   int i, len = 0;
1120   for (i = 0; r[i] != NULL; ++i) len++;
1121   VALUE rv = rb_ary_new2 (len);
1122   for (i = 0; r[i] != NULL; ++i) {
1123     rb_ary_push (rv, rb_str_new2 (r[i]));
1124     free (r[i]);
1125   }
1126   free (r);
1127   return rv;
1128 }
1129
1130 static VALUE ruby_guestfs_rm (VALUE gv, VALUE pathv)
1131 {
1132   guestfs_h *g;
1133   Data_Get_Struct (gv, guestfs_h, g);
1134   if (!g)
1135     rb_raise (rb_eArgError, "%s: used handle after closing it", "rm");
1136
1137   const char *path = StringValueCStr (pathv);
1138   if (!path)
1139     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1140               "path", "rm");
1141
1142   int r;
1143
1144   r = guestfs_rm (g, path);
1145   if (r == -1)
1146     rb_raise (e_Error, "%s", guestfs_last_error (g));
1147
1148   return Qnil;
1149 }
1150
1151 static VALUE ruby_guestfs_rmdir (VALUE gv, VALUE pathv)
1152 {
1153   guestfs_h *g;
1154   Data_Get_Struct (gv, guestfs_h, g);
1155   if (!g)
1156     rb_raise (rb_eArgError, "%s: used handle after closing it", "rmdir");
1157
1158   const char *path = StringValueCStr (pathv);
1159   if (!path)
1160     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1161               "path", "rmdir");
1162
1163   int r;
1164
1165   r = guestfs_rmdir (g, path);
1166   if (r == -1)
1167     rb_raise (e_Error, "%s", guestfs_last_error (g));
1168
1169   return Qnil;
1170 }
1171
1172 static VALUE ruby_guestfs_rm_rf (VALUE gv, VALUE pathv)
1173 {
1174   guestfs_h *g;
1175   Data_Get_Struct (gv, guestfs_h, g);
1176   if (!g)
1177     rb_raise (rb_eArgError, "%s: used handle after closing it", "rm_rf");
1178
1179   const char *path = StringValueCStr (pathv);
1180   if (!path)
1181     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1182               "path", "rm_rf");
1183
1184   int r;
1185
1186   r = guestfs_rm_rf (g, path);
1187   if (r == -1)
1188     rb_raise (e_Error, "%s", guestfs_last_error (g));
1189
1190   return Qnil;
1191 }
1192
1193 static VALUE ruby_guestfs_mkdir (VALUE gv, VALUE pathv)
1194 {
1195   guestfs_h *g;
1196   Data_Get_Struct (gv, guestfs_h, g);
1197   if (!g)
1198     rb_raise (rb_eArgError, "%s: used handle after closing it", "mkdir");
1199
1200   const char *path = StringValueCStr (pathv);
1201   if (!path)
1202     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1203               "path", "mkdir");
1204
1205   int r;
1206
1207   r = guestfs_mkdir (g, path);
1208   if (r == -1)
1209     rb_raise (e_Error, "%s", guestfs_last_error (g));
1210
1211   return Qnil;
1212 }
1213
1214 static VALUE ruby_guestfs_mkdir_p (VALUE gv, VALUE pathv)
1215 {
1216   guestfs_h *g;
1217   Data_Get_Struct (gv, guestfs_h, g);
1218   if (!g)
1219     rb_raise (rb_eArgError, "%s: used handle after closing it", "mkdir_p");
1220
1221   const char *path = StringValueCStr (pathv);
1222   if (!path)
1223     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1224               "path", "mkdir_p");
1225
1226   int r;
1227
1228   r = guestfs_mkdir_p (g, path);
1229   if (r == -1)
1230     rb_raise (e_Error, "%s", guestfs_last_error (g));
1231
1232   return Qnil;
1233 }
1234
1235 static VALUE ruby_guestfs_chmod (VALUE gv, VALUE modev, VALUE pathv)
1236 {
1237   guestfs_h *g;
1238   Data_Get_Struct (gv, guestfs_h, g);
1239   if (!g)
1240     rb_raise (rb_eArgError, "%s: used handle after closing it", "chmod");
1241
1242   int mode = NUM2INT (modev);
1243   const char *path = StringValueCStr (pathv);
1244   if (!path)
1245     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1246               "path", "chmod");
1247
1248   int r;
1249
1250   r = guestfs_chmod (g, mode, path);
1251   if (r == -1)
1252     rb_raise (e_Error, "%s", guestfs_last_error (g));
1253
1254   return Qnil;
1255 }
1256
1257 static VALUE ruby_guestfs_chown (VALUE gv, VALUE ownerv, VALUE groupv, VALUE pathv)
1258 {
1259   guestfs_h *g;
1260   Data_Get_Struct (gv, guestfs_h, g);
1261   if (!g)
1262     rb_raise (rb_eArgError, "%s: used handle after closing it", "chown");
1263
1264   int owner = NUM2INT (ownerv);
1265   int group = NUM2INT (groupv);
1266   const char *path = StringValueCStr (pathv);
1267   if (!path)
1268     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1269               "path", "chown");
1270
1271   int r;
1272
1273   r = guestfs_chown (g, owner, group, path);
1274   if (r == -1)
1275     rb_raise (e_Error, "%s", guestfs_last_error (g));
1276
1277   return Qnil;
1278 }
1279
1280 static VALUE ruby_guestfs_exists (VALUE gv, VALUE pathv)
1281 {
1282   guestfs_h *g;
1283   Data_Get_Struct (gv, guestfs_h, g);
1284   if (!g)
1285     rb_raise (rb_eArgError, "%s: used handle after closing it", "exists");
1286
1287   const char *path = StringValueCStr (pathv);
1288   if (!path)
1289     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1290               "path", "exists");
1291
1292   int r;
1293
1294   r = guestfs_exists (g, path);
1295   if (r == -1)
1296     rb_raise (e_Error, "%s", guestfs_last_error (g));
1297
1298   return INT2NUM (r);
1299 }
1300
1301 static VALUE ruby_guestfs_is_file (VALUE gv, VALUE pathv)
1302 {
1303   guestfs_h *g;
1304   Data_Get_Struct (gv, guestfs_h, g);
1305   if (!g)
1306     rb_raise (rb_eArgError, "%s: used handle after closing it", "is_file");
1307
1308   const char *path = StringValueCStr (pathv);
1309   if (!path)
1310     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1311               "path", "is_file");
1312
1313   int r;
1314
1315   r = guestfs_is_file (g, path);
1316   if (r == -1)
1317     rb_raise (e_Error, "%s", guestfs_last_error (g));
1318
1319   return INT2NUM (r);
1320 }
1321
1322 static VALUE ruby_guestfs_is_dir (VALUE gv, VALUE pathv)
1323 {
1324   guestfs_h *g;
1325   Data_Get_Struct (gv, guestfs_h, g);
1326   if (!g)
1327     rb_raise (rb_eArgError, "%s: used handle after closing it", "is_dir");
1328
1329   const char *path = StringValueCStr (pathv);
1330   if (!path)
1331     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1332               "path", "is_dir");
1333
1334   int r;
1335
1336   r = guestfs_is_dir (g, path);
1337   if (r == -1)
1338     rb_raise (e_Error, "%s", guestfs_last_error (g));
1339
1340   return INT2NUM (r);
1341 }
1342
1343 static VALUE ruby_guestfs_pvcreate (VALUE gv, VALUE devicev)
1344 {
1345   guestfs_h *g;
1346   Data_Get_Struct (gv, guestfs_h, g);
1347   if (!g)
1348     rb_raise (rb_eArgError, "%s: used handle after closing it", "pvcreate");
1349
1350   const char *device = StringValueCStr (devicev);
1351   if (!device)
1352     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1353               "device", "pvcreate");
1354
1355   int r;
1356
1357   r = guestfs_pvcreate (g, device);
1358   if (r == -1)
1359     rb_raise (e_Error, "%s", guestfs_last_error (g));
1360
1361   return Qnil;
1362 }
1363
1364 static VALUE ruby_guestfs_vgcreate (VALUE gv, VALUE volgroupv, VALUE physvolsv)
1365 {
1366   guestfs_h *g;
1367   Data_Get_Struct (gv, guestfs_h, g);
1368   if (!g)
1369     rb_raise (rb_eArgError, "%s: used handle after closing it", "vgcreate");
1370
1371   const char *volgroup = StringValueCStr (volgroupv);
1372   if (!volgroup)
1373     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1374               "volgroup", "vgcreate");
1375   char **physvols;  {
1376     int i, len;
1377     len = RARRAY_LEN (physvolsv);
1378     physvols = malloc (sizeof (char *) * (len+1));
1379     for (i = 0; i < len; ++i) {
1380       VALUE v = rb_ary_entry (physvolsv, i);
1381       physvols[i] = StringValueCStr (v);
1382     }
1383   }
1384
1385   int r;
1386
1387   r = guestfs_vgcreate (g, volgroup, physvols);
1388   free (physvols);
1389   if (r == -1)
1390     rb_raise (e_Error, "%s", guestfs_last_error (g));
1391
1392   return Qnil;
1393 }
1394
1395 static VALUE ruby_guestfs_lvcreate (VALUE gv, VALUE logvolv, VALUE volgroupv, VALUE mbytesv)
1396 {
1397   guestfs_h *g;
1398   Data_Get_Struct (gv, guestfs_h, g);
1399   if (!g)
1400     rb_raise (rb_eArgError, "%s: used handle after closing it", "lvcreate");
1401
1402   const char *logvol = StringValueCStr (logvolv);
1403   if (!logvol)
1404     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1405               "logvol", "lvcreate");
1406   const char *volgroup = StringValueCStr (volgroupv);
1407   if (!volgroup)
1408     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1409               "volgroup", "lvcreate");
1410   int mbytes = NUM2INT (mbytesv);
1411
1412   int r;
1413
1414   r = guestfs_lvcreate (g, logvol, volgroup, mbytes);
1415   if (r == -1)
1416     rb_raise (e_Error, "%s", guestfs_last_error (g));
1417
1418   return Qnil;
1419 }
1420
1421 static VALUE ruby_guestfs_mkfs (VALUE gv, VALUE fstypev, VALUE devicev)
1422 {
1423   guestfs_h *g;
1424   Data_Get_Struct (gv, guestfs_h, g);
1425   if (!g)
1426     rb_raise (rb_eArgError, "%s: used handle after closing it", "mkfs");
1427
1428   const char *fstype = StringValueCStr (fstypev);
1429   if (!fstype)
1430     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1431               "fstype", "mkfs");
1432   const char *device = StringValueCStr (devicev);
1433   if (!device)
1434     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1435               "device", "mkfs");
1436
1437   int r;
1438
1439   r = guestfs_mkfs (g, fstype, device);
1440   if (r == -1)
1441     rb_raise (e_Error, "%s", guestfs_last_error (g));
1442
1443   return Qnil;
1444 }
1445
1446 static VALUE ruby_guestfs_sfdisk (VALUE gv, VALUE devicev, VALUE cylsv, VALUE headsv, VALUE sectorsv, VALUE linesv)
1447 {
1448   guestfs_h *g;
1449   Data_Get_Struct (gv, guestfs_h, g);
1450   if (!g)
1451     rb_raise (rb_eArgError, "%s: used handle after closing it", "sfdisk");
1452
1453   const char *device = StringValueCStr (devicev);
1454   if (!device)
1455     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1456               "device", "sfdisk");
1457   int cyls = NUM2INT (cylsv);
1458   int heads = NUM2INT (headsv);
1459   int sectors = NUM2INT (sectorsv);
1460   char **lines;  {
1461     int i, len;
1462     len = RARRAY_LEN (linesv);
1463     lines = malloc (sizeof (char *) * (len+1));
1464     for (i = 0; i < len; ++i) {
1465       VALUE v = rb_ary_entry (linesv, i);
1466       lines[i] = StringValueCStr (v);
1467     }
1468   }
1469
1470   int r;
1471
1472   r = guestfs_sfdisk (g, device, cyls, heads, sectors, lines);
1473   free (lines);
1474   if (r == -1)
1475     rb_raise (e_Error, "%s", guestfs_last_error (g));
1476
1477   return Qnil;
1478 }
1479
1480 static VALUE ruby_guestfs_write_file (VALUE gv, VALUE pathv, VALUE contentv, VALUE sizev)
1481 {
1482   guestfs_h *g;
1483   Data_Get_Struct (gv, guestfs_h, g);
1484   if (!g)
1485     rb_raise (rb_eArgError, "%s: used handle after closing it", "write_file");
1486
1487   const char *path = StringValueCStr (pathv);
1488   if (!path)
1489     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1490               "path", "write_file");
1491   const char *content = StringValueCStr (contentv);
1492   if (!content)
1493     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1494               "content", "write_file");
1495   int size = NUM2INT (sizev);
1496
1497   int r;
1498
1499   r = guestfs_write_file (g, path, content, size);
1500   if (r == -1)
1501     rb_raise (e_Error, "%s", guestfs_last_error (g));
1502
1503   return Qnil;
1504 }
1505
1506 static VALUE ruby_guestfs_umount (VALUE gv, VALUE pathordevicev)
1507 {
1508   guestfs_h *g;
1509   Data_Get_Struct (gv, guestfs_h, g);
1510   if (!g)
1511     rb_raise (rb_eArgError, "%s: used handle after closing it", "umount");
1512
1513   const char *pathordevice = StringValueCStr (pathordevicev);
1514   if (!pathordevice)
1515     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1516               "pathordevice", "umount");
1517
1518   int r;
1519
1520   r = guestfs_umount (g, pathordevice);
1521   if (r == -1)
1522     rb_raise (e_Error, "%s", guestfs_last_error (g));
1523
1524   return Qnil;
1525 }
1526
1527 static VALUE ruby_guestfs_mounts (VALUE gv)
1528 {
1529   guestfs_h *g;
1530   Data_Get_Struct (gv, guestfs_h, g);
1531   if (!g)
1532     rb_raise (rb_eArgError, "%s: used handle after closing it", "mounts");
1533
1534
1535   char **r;
1536
1537   r = guestfs_mounts (g);
1538   if (r == NULL)
1539     rb_raise (e_Error, "%s", guestfs_last_error (g));
1540
1541   int i, len = 0;
1542   for (i = 0; r[i] != NULL; ++i) len++;
1543   VALUE rv = rb_ary_new2 (len);
1544   for (i = 0; r[i] != NULL; ++i) {
1545     rb_ary_push (rv, rb_str_new2 (r[i]));
1546     free (r[i]);
1547   }
1548   free (r);
1549   return rv;
1550 }
1551
1552 static VALUE ruby_guestfs_umount_all (VALUE gv)
1553 {
1554   guestfs_h *g;
1555   Data_Get_Struct (gv, guestfs_h, g);
1556   if (!g)
1557     rb_raise (rb_eArgError, "%s: used handle after closing it", "umount_all");
1558
1559
1560   int r;
1561
1562   r = guestfs_umount_all (g);
1563   if (r == -1)
1564     rb_raise (e_Error, "%s", guestfs_last_error (g));
1565
1566   return Qnil;
1567 }
1568
1569 static VALUE ruby_guestfs_lvm_remove_all (VALUE gv)
1570 {
1571   guestfs_h *g;
1572   Data_Get_Struct (gv, guestfs_h, g);
1573   if (!g)
1574     rb_raise (rb_eArgError, "%s: used handle after closing it", "lvm_remove_all");
1575
1576
1577   int r;
1578
1579   r = guestfs_lvm_remove_all (g);
1580   if (r == -1)
1581     rb_raise (e_Error, "%s", guestfs_last_error (g));
1582
1583   return Qnil;
1584 }
1585
1586 static VALUE ruby_guestfs_file (VALUE gv, VALUE pathv)
1587 {
1588   guestfs_h *g;
1589   Data_Get_Struct (gv, guestfs_h, g);
1590   if (!g)
1591     rb_raise (rb_eArgError, "%s: used handle after closing it", "file");
1592
1593   const char *path = StringValueCStr (pathv);
1594   if (!path)
1595     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1596               "path", "file");
1597
1598   char *r;
1599
1600   r = guestfs_file (g, path);
1601   if (r == NULL)
1602     rb_raise (e_Error, "%s", guestfs_last_error (g));
1603
1604   VALUE rv = rb_str_new2 (r);
1605   free (r);
1606   return rv;
1607 }
1608
1609 static VALUE ruby_guestfs_command (VALUE gv, VALUE argumentsv)
1610 {
1611   guestfs_h *g;
1612   Data_Get_Struct (gv, guestfs_h, g);
1613   if (!g)
1614     rb_raise (rb_eArgError, "%s: used handle after closing it", "command");
1615
1616   char **arguments;  {
1617     int i, len;
1618     len = RARRAY_LEN (argumentsv);
1619     arguments = malloc (sizeof (char *) * (len+1));
1620     for (i = 0; i < len; ++i) {
1621       VALUE v = rb_ary_entry (argumentsv, i);
1622       arguments[i] = StringValueCStr (v);
1623     }
1624   }
1625
1626   char *r;
1627
1628   r = guestfs_command (g, arguments);
1629   free (arguments);
1630   if (r == NULL)
1631     rb_raise (e_Error, "%s", guestfs_last_error (g));
1632
1633   VALUE rv = rb_str_new2 (r);
1634   free (r);
1635   return rv;
1636 }
1637
1638 static VALUE ruby_guestfs_command_lines (VALUE gv, VALUE argumentsv)
1639 {
1640   guestfs_h *g;
1641   Data_Get_Struct (gv, guestfs_h, g);
1642   if (!g)
1643     rb_raise (rb_eArgError, "%s: used handle after closing it", "command_lines");
1644
1645   char **arguments;  {
1646     int i, len;
1647     len = RARRAY_LEN (argumentsv);
1648     arguments = malloc (sizeof (char *) * (len+1));
1649     for (i = 0; i < len; ++i) {
1650       VALUE v = rb_ary_entry (argumentsv, i);
1651       arguments[i] = StringValueCStr (v);
1652     }
1653   }
1654
1655   char **r;
1656
1657   r = guestfs_command_lines (g, arguments);
1658   free (arguments);
1659   if (r == NULL)
1660     rb_raise (e_Error, "%s", guestfs_last_error (g));
1661
1662   int i, len = 0;
1663   for (i = 0; r[i] != NULL; ++i) len++;
1664   VALUE rv = rb_ary_new2 (len);
1665   for (i = 0; r[i] != NULL; ++i) {
1666     rb_ary_push (rv, rb_str_new2 (r[i]));
1667     free (r[i]);
1668   }
1669   free (r);
1670   return rv;
1671 }
1672
1673 static VALUE ruby_guestfs_stat (VALUE gv, VALUE pathv)
1674 {
1675   guestfs_h *g;
1676   Data_Get_Struct (gv, guestfs_h, g);
1677   if (!g)
1678     rb_raise (rb_eArgError, "%s: used handle after closing it", "stat");
1679
1680   const char *path = StringValueCStr (pathv);
1681   if (!path)
1682     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1683               "path", "stat");
1684
1685   struct guestfs_stat *r;
1686
1687   r = guestfs_stat (g, path);
1688   if (r == NULL)
1689     rb_raise (e_Error, "%s", guestfs_last_error (g));
1690
1691   VALUE rv = rb_hash_new ();
1692   rb_hash_aset (rv, rb_str_new2 ("dev"), ULL2NUM (r->dev));
1693   rb_hash_aset (rv, rb_str_new2 ("ino"), ULL2NUM (r->ino));
1694   rb_hash_aset (rv, rb_str_new2 ("mode"), ULL2NUM (r->mode));
1695   rb_hash_aset (rv, rb_str_new2 ("nlink"), ULL2NUM (r->nlink));
1696   rb_hash_aset (rv, rb_str_new2 ("uid"), ULL2NUM (r->uid));
1697   rb_hash_aset (rv, rb_str_new2 ("gid"), ULL2NUM (r->gid));
1698   rb_hash_aset (rv, rb_str_new2 ("rdev"), ULL2NUM (r->rdev));
1699   rb_hash_aset (rv, rb_str_new2 ("size"), ULL2NUM (r->size));
1700   rb_hash_aset (rv, rb_str_new2 ("blksize"), ULL2NUM (r->blksize));
1701   rb_hash_aset (rv, rb_str_new2 ("blocks"), ULL2NUM (r->blocks));
1702   rb_hash_aset (rv, rb_str_new2 ("atime"), ULL2NUM (r->atime));
1703   rb_hash_aset (rv, rb_str_new2 ("mtime"), ULL2NUM (r->mtime));
1704   rb_hash_aset (rv, rb_str_new2 ("ctime"), ULL2NUM (r->ctime));
1705   free (r);
1706   return rv;
1707 }
1708
1709 static VALUE ruby_guestfs_lstat (VALUE gv, VALUE pathv)
1710 {
1711   guestfs_h *g;
1712   Data_Get_Struct (gv, guestfs_h, g);
1713   if (!g)
1714     rb_raise (rb_eArgError, "%s: used handle after closing it", "lstat");
1715
1716   const char *path = StringValueCStr (pathv);
1717   if (!path)
1718     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1719               "path", "lstat");
1720
1721   struct guestfs_stat *r;
1722
1723   r = guestfs_lstat (g, path);
1724   if (r == NULL)
1725     rb_raise (e_Error, "%s", guestfs_last_error (g));
1726
1727   VALUE rv = rb_hash_new ();
1728   rb_hash_aset (rv, rb_str_new2 ("dev"), ULL2NUM (r->dev));
1729   rb_hash_aset (rv, rb_str_new2 ("ino"), ULL2NUM (r->ino));
1730   rb_hash_aset (rv, rb_str_new2 ("mode"), ULL2NUM (r->mode));
1731   rb_hash_aset (rv, rb_str_new2 ("nlink"), ULL2NUM (r->nlink));
1732   rb_hash_aset (rv, rb_str_new2 ("uid"), ULL2NUM (r->uid));
1733   rb_hash_aset (rv, rb_str_new2 ("gid"), ULL2NUM (r->gid));
1734   rb_hash_aset (rv, rb_str_new2 ("rdev"), ULL2NUM (r->rdev));
1735   rb_hash_aset (rv, rb_str_new2 ("size"), ULL2NUM (r->size));
1736   rb_hash_aset (rv, rb_str_new2 ("blksize"), ULL2NUM (r->blksize));
1737   rb_hash_aset (rv, rb_str_new2 ("blocks"), ULL2NUM (r->blocks));
1738   rb_hash_aset (rv, rb_str_new2 ("atime"), ULL2NUM (r->atime));
1739   rb_hash_aset (rv, rb_str_new2 ("mtime"), ULL2NUM (r->mtime));
1740   rb_hash_aset (rv, rb_str_new2 ("ctime"), ULL2NUM (r->ctime));
1741   free (r);
1742   return rv;
1743 }
1744
1745 static VALUE ruby_guestfs_statvfs (VALUE gv, VALUE pathv)
1746 {
1747   guestfs_h *g;
1748   Data_Get_Struct (gv, guestfs_h, g);
1749   if (!g)
1750     rb_raise (rb_eArgError, "%s: used handle after closing it", "statvfs");
1751
1752   const char *path = StringValueCStr (pathv);
1753   if (!path)
1754     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1755               "path", "statvfs");
1756
1757   struct guestfs_statvfs *r;
1758
1759   r = guestfs_statvfs (g, path);
1760   if (r == NULL)
1761     rb_raise (e_Error, "%s", guestfs_last_error (g));
1762
1763   VALUE rv = rb_hash_new ();
1764   rb_hash_aset (rv, rb_str_new2 ("bsize"), ULL2NUM (r->bsize));
1765   rb_hash_aset (rv, rb_str_new2 ("frsize"), ULL2NUM (r->frsize));
1766   rb_hash_aset (rv, rb_str_new2 ("blocks"), ULL2NUM (r->blocks));
1767   rb_hash_aset (rv, rb_str_new2 ("bfree"), ULL2NUM (r->bfree));
1768   rb_hash_aset (rv, rb_str_new2 ("bavail"), ULL2NUM (r->bavail));
1769   rb_hash_aset (rv, rb_str_new2 ("files"), ULL2NUM (r->files));
1770   rb_hash_aset (rv, rb_str_new2 ("ffree"), ULL2NUM (r->ffree));
1771   rb_hash_aset (rv, rb_str_new2 ("favail"), ULL2NUM (r->favail));
1772   rb_hash_aset (rv, rb_str_new2 ("fsid"), ULL2NUM (r->fsid));
1773   rb_hash_aset (rv, rb_str_new2 ("flag"), ULL2NUM (r->flag));
1774   rb_hash_aset (rv, rb_str_new2 ("namemax"), ULL2NUM (r->namemax));
1775   free (r);
1776   return rv;
1777 }
1778
1779 static VALUE ruby_guestfs_tune2fs_l (VALUE gv, VALUE devicev)
1780 {
1781   guestfs_h *g;
1782   Data_Get_Struct (gv, guestfs_h, g);
1783   if (!g)
1784     rb_raise (rb_eArgError, "%s: used handle after closing it", "tune2fs_l");
1785
1786   const char *device = StringValueCStr (devicev);
1787   if (!device)
1788     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1789               "device", "tune2fs_l");
1790
1791   char **r;
1792
1793   r = guestfs_tune2fs_l (g, device);
1794   if (r == NULL)
1795     rb_raise (e_Error, "%s", guestfs_last_error (g));
1796
1797   VALUE rv = rb_hash_new ();
1798   int i;
1799   for (i = 0; r[i] != NULL; i+=2) {
1800     rb_hash_aset (rv, rb_str_new2 (r[i]), rb_str_new2 (r[i+1]));
1801     free (r[i]);
1802     free (r[i+1]);
1803   }
1804   free (r);
1805   return rv;
1806 }
1807
1808 static VALUE ruby_guestfs_blockdev_setro (VALUE gv, VALUE devicev)
1809 {
1810   guestfs_h *g;
1811   Data_Get_Struct (gv, guestfs_h, g);
1812   if (!g)
1813     rb_raise (rb_eArgError, "%s: used handle after closing it", "blockdev_setro");
1814
1815   const char *device = StringValueCStr (devicev);
1816   if (!device)
1817     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1818               "device", "blockdev_setro");
1819
1820   int r;
1821
1822   r = guestfs_blockdev_setro (g, device);
1823   if (r == -1)
1824     rb_raise (e_Error, "%s", guestfs_last_error (g));
1825
1826   return Qnil;
1827 }
1828
1829 static VALUE ruby_guestfs_blockdev_setrw (VALUE gv, VALUE devicev)
1830 {
1831   guestfs_h *g;
1832   Data_Get_Struct (gv, guestfs_h, g);
1833   if (!g)
1834     rb_raise (rb_eArgError, "%s: used handle after closing it", "blockdev_setrw");
1835
1836   const char *device = StringValueCStr (devicev);
1837   if (!device)
1838     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1839               "device", "blockdev_setrw");
1840
1841   int r;
1842
1843   r = guestfs_blockdev_setrw (g, device);
1844   if (r == -1)
1845     rb_raise (e_Error, "%s", guestfs_last_error (g));
1846
1847   return Qnil;
1848 }
1849
1850 static VALUE ruby_guestfs_blockdev_getro (VALUE gv, VALUE devicev)
1851 {
1852   guestfs_h *g;
1853   Data_Get_Struct (gv, guestfs_h, g);
1854   if (!g)
1855     rb_raise (rb_eArgError, "%s: used handle after closing it", "blockdev_getro");
1856
1857   const char *device = StringValueCStr (devicev);
1858   if (!device)
1859     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1860               "device", "blockdev_getro");
1861
1862   int r;
1863
1864   r = guestfs_blockdev_getro (g, device);
1865   if (r == -1)
1866     rb_raise (e_Error, "%s", guestfs_last_error (g));
1867
1868   return INT2NUM (r);
1869 }
1870
1871 static VALUE ruby_guestfs_blockdev_getss (VALUE gv, VALUE devicev)
1872 {
1873   guestfs_h *g;
1874   Data_Get_Struct (gv, guestfs_h, g);
1875   if (!g)
1876     rb_raise (rb_eArgError, "%s: used handle after closing it", "blockdev_getss");
1877
1878   const char *device = StringValueCStr (devicev);
1879   if (!device)
1880     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1881               "device", "blockdev_getss");
1882
1883   int r;
1884
1885   r = guestfs_blockdev_getss (g, device);
1886   if (r == -1)
1887     rb_raise (e_Error, "%s", guestfs_last_error (g));
1888
1889   return INT2NUM (r);
1890 }
1891
1892 static VALUE ruby_guestfs_blockdev_getbsz (VALUE gv, VALUE devicev)
1893 {
1894   guestfs_h *g;
1895   Data_Get_Struct (gv, guestfs_h, g);
1896   if (!g)
1897     rb_raise (rb_eArgError, "%s: used handle after closing it", "blockdev_getbsz");
1898
1899   const char *device = StringValueCStr (devicev);
1900   if (!device)
1901     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1902               "device", "blockdev_getbsz");
1903
1904   int r;
1905
1906   r = guestfs_blockdev_getbsz (g, device);
1907   if (r == -1)
1908     rb_raise (e_Error, "%s", guestfs_last_error (g));
1909
1910   return INT2NUM (r);
1911 }
1912
1913 static VALUE ruby_guestfs_blockdev_setbsz (VALUE gv, VALUE devicev, VALUE blocksizev)
1914 {
1915   guestfs_h *g;
1916   Data_Get_Struct (gv, guestfs_h, g);
1917   if (!g)
1918     rb_raise (rb_eArgError, "%s: used handle after closing it", "blockdev_setbsz");
1919
1920   const char *device = StringValueCStr (devicev);
1921   if (!device)
1922     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1923               "device", "blockdev_setbsz");
1924   int blocksize = NUM2INT (blocksizev);
1925
1926   int r;
1927
1928   r = guestfs_blockdev_setbsz (g, device, blocksize);
1929   if (r == -1)
1930     rb_raise (e_Error, "%s", guestfs_last_error (g));
1931
1932   return Qnil;
1933 }
1934
1935 static VALUE ruby_guestfs_blockdev_getsz (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_getsz");
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_getsz");
1946
1947   int64_t r;
1948
1949   r = guestfs_blockdev_getsz (g, device);
1950   if (r == -1)
1951     rb_raise (e_Error, "%s", guestfs_last_error (g));
1952
1953   return ULL2NUM (r);
1954 }
1955
1956 static VALUE ruby_guestfs_blockdev_getsize64 (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_getsize64");
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_getsize64");
1967
1968   int64_t r;
1969
1970   r = guestfs_blockdev_getsize64 (g, device);
1971   if (r == -1)
1972     rb_raise (e_Error, "%s", guestfs_last_error (g));
1973
1974   return ULL2NUM (r);
1975 }
1976
1977 static VALUE ruby_guestfs_blockdev_flushbufs (VALUE gv, VALUE devicev)
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_flushbufs");
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_flushbufs");
1988
1989   int r;
1990
1991   r = guestfs_blockdev_flushbufs (g, device);
1992   if (r == -1)
1993     rb_raise (e_Error, "%s", guestfs_last_error (g));
1994
1995   return Qnil;
1996 }
1997
1998 static VALUE ruby_guestfs_blockdev_rereadpt (VALUE gv, VALUE devicev)
1999 {
2000   guestfs_h *g;
2001   Data_Get_Struct (gv, guestfs_h, g);
2002   if (!g)
2003     rb_raise (rb_eArgError, "%s: used handle after closing it", "blockdev_rereadpt");
2004
2005   const char *device = StringValueCStr (devicev);
2006   if (!device)
2007     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2008               "device", "blockdev_rereadpt");
2009
2010   int r;
2011
2012   r = guestfs_blockdev_rereadpt (g, device);
2013   if (r == -1)
2014     rb_raise (e_Error, "%s", guestfs_last_error (g));
2015
2016   return Qnil;
2017 }
2018
2019 static VALUE ruby_guestfs_upload (VALUE gv, VALUE filenamev, VALUE remotefilenamev)
2020 {
2021   guestfs_h *g;
2022   Data_Get_Struct (gv, guestfs_h, g);
2023   if (!g)
2024     rb_raise (rb_eArgError, "%s: used handle after closing it", "upload");
2025
2026   const char *filename = StringValueCStr (filenamev);
2027   if (!filename)
2028     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2029               "filename", "upload");
2030   const char *remotefilename = StringValueCStr (remotefilenamev);
2031   if (!remotefilename)
2032     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2033               "remotefilename", "upload");
2034
2035   int r;
2036
2037   r = guestfs_upload (g, filename, remotefilename);
2038   if (r == -1)
2039     rb_raise (e_Error, "%s", guestfs_last_error (g));
2040
2041   return Qnil;
2042 }
2043
2044 static VALUE ruby_guestfs_download (VALUE gv, VALUE remotefilenamev, VALUE filenamev)
2045 {
2046   guestfs_h *g;
2047   Data_Get_Struct (gv, guestfs_h, g);
2048   if (!g)
2049     rb_raise (rb_eArgError, "%s: used handle after closing it", "download");
2050
2051   const char *remotefilename = StringValueCStr (remotefilenamev);
2052   if (!remotefilename)
2053     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2054               "remotefilename", "download");
2055   const char *filename = StringValueCStr (filenamev);
2056   if (!filename)
2057     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2058               "filename", "download");
2059
2060   int r;
2061
2062   r = guestfs_download (g, remotefilename, filename);
2063   if (r == -1)
2064     rb_raise (e_Error, "%s", guestfs_last_error (g));
2065
2066   return Qnil;
2067 }
2068
2069 static VALUE ruby_guestfs_checksum (VALUE gv, VALUE csumtypev, VALUE pathv)
2070 {
2071   guestfs_h *g;
2072   Data_Get_Struct (gv, guestfs_h, g);
2073   if (!g)
2074     rb_raise (rb_eArgError, "%s: used handle after closing it", "checksum");
2075
2076   const char *csumtype = StringValueCStr (csumtypev);
2077   if (!csumtype)
2078     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2079               "csumtype", "checksum");
2080   const char *path = StringValueCStr (pathv);
2081   if (!path)
2082     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2083               "path", "checksum");
2084
2085   char *r;
2086
2087   r = guestfs_checksum (g, csumtype, path);
2088   if (r == NULL)
2089     rb_raise (e_Error, "%s", guestfs_last_error (g));
2090
2091   VALUE rv = rb_str_new2 (r);
2092   free (r);
2093   return rv;
2094 }
2095
2096 /* Initialize the module. */
2097 void Init__guestfs ()
2098 {
2099   m_guestfs = rb_define_module ("Guestfs");
2100   c_guestfs = rb_define_class_under (m_guestfs, "Guestfs", rb_cObject);
2101   e_Error = rb_define_class_under (m_guestfs, "Error", rb_eStandardError);
2102
2103   rb_define_module_function (m_guestfs, "create", ruby_guestfs_create, 0);
2104   rb_define_method (c_guestfs, "close", ruby_guestfs_close, 0);
2105
2106   rb_define_method (c_guestfs, "launch",
2107         ruby_guestfs_launch, 0);
2108   rb_define_method (c_guestfs, "wait_ready",
2109         ruby_guestfs_wait_ready, 0);
2110   rb_define_method (c_guestfs, "kill_subprocess",
2111         ruby_guestfs_kill_subprocess, 0);
2112   rb_define_method (c_guestfs, "add_drive",
2113         ruby_guestfs_add_drive, 1);
2114   rb_define_method (c_guestfs, "add_cdrom",
2115         ruby_guestfs_add_cdrom, 1);
2116   rb_define_method (c_guestfs, "config",
2117         ruby_guestfs_config, 2);
2118   rb_define_method (c_guestfs, "set_path",
2119         ruby_guestfs_set_path, 1);
2120   rb_define_method (c_guestfs, "get_path",
2121         ruby_guestfs_get_path, 0);
2122   rb_define_method (c_guestfs, "set_autosync",
2123         ruby_guestfs_set_autosync, 1);
2124   rb_define_method (c_guestfs, "get_autosync",
2125         ruby_guestfs_get_autosync, 0);
2126   rb_define_method (c_guestfs, "set_verbose",
2127         ruby_guestfs_set_verbose, 1);
2128   rb_define_method (c_guestfs, "get_verbose",
2129         ruby_guestfs_get_verbose, 0);
2130   rb_define_method (c_guestfs, "is_ready",
2131         ruby_guestfs_is_ready, 0);
2132   rb_define_method (c_guestfs, "is_config",
2133         ruby_guestfs_is_config, 0);
2134   rb_define_method (c_guestfs, "is_launching",
2135         ruby_guestfs_is_launching, 0);
2136   rb_define_method (c_guestfs, "is_busy",
2137         ruby_guestfs_is_busy, 0);
2138   rb_define_method (c_guestfs, "get_state",
2139         ruby_guestfs_get_state, 0);
2140   rb_define_method (c_guestfs, "set_busy",
2141         ruby_guestfs_set_busy, 0);
2142   rb_define_method (c_guestfs, "set_ready",
2143         ruby_guestfs_set_ready, 0);
2144   rb_define_method (c_guestfs, "mount",
2145         ruby_guestfs_mount, 2);
2146   rb_define_method (c_guestfs, "sync",
2147         ruby_guestfs_sync, 0);
2148   rb_define_method (c_guestfs, "touch",
2149         ruby_guestfs_touch, 1);
2150   rb_define_method (c_guestfs, "cat",
2151         ruby_guestfs_cat, 1);
2152   rb_define_method (c_guestfs, "ll",
2153         ruby_guestfs_ll, 1);
2154   rb_define_method (c_guestfs, "ls",
2155         ruby_guestfs_ls, 1);
2156   rb_define_method (c_guestfs, "list_devices",
2157         ruby_guestfs_list_devices, 0);
2158   rb_define_method (c_guestfs, "list_partitions",
2159         ruby_guestfs_list_partitions, 0);
2160   rb_define_method (c_guestfs, "pvs",
2161         ruby_guestfs_pvs, 0);
2162   rb_define_method (c_guestfs, "vgs",
2163         ruby_guestfs_vgs, 0);
2164   rb_define_method (c_guestfs, "lvs",
2165         ruby_guestfs_lvs, 0);
2166   rb_define_method (c_guestfs, "pvs_full",
2167         ruby_guestfs_pvs_full, 0);
2168   rb_define_method (c_guestfs, "vgs_full",
2169         ruby_guestfs_vgs_full, 0);
2170   rb_define_method (c_guestfs, "lvs_full",
2171         ruby_guestfs_lvs_full, 0);
2172   rb_define_method (c_guestfs, "read_lines",
2173         ruby_guestfs_read_lines, 1);
2174   rb_define_method (c_guestfs, "aug_init",
2175         ruby_guestfs_aug_init, 2);
2176   rb_define_method (c_guestfs, "aug_close",
2177         ruby_guestfs_aug_close, 0);
2178   rb_define_method (c_guestfs, "aug_defvar",
2179         ruby_guestfs_aug_defvar, 2);
2180   rb_define_method (c_guestfs, "aug_defnode",
2181         ruby_guestfs_aug_defnode, 3);
2182   rb_define_method (c_guestfs, "aug_get",
2183         ruby_guestfs_aug_get, 1);
2184   rb_define_method (c_guestfs, "aug_set",
2185         ruby_guestfs_aug_set, 2);
2186   rb_define_method (c_guestfs, "aug_insert",
2187         ruby_guestfs_aug_insert, 3);
2188   rb_define_method (c_guestfs, "aug_rm",
2189         ruby_guestfs_aug_rm, 1);
2190   rb_define_method (c_guestfs, "aug_mv",
2191         ruby_guestfs_aug_mv, 2);
2192   rb_define_method (c_guestfs, "aug_match",
2193         ruby_guestfs_aug_match, 1);
2194   rb_define_method (c_guestfs, "aug_save",
2195         ruby_guestfs_aug_save, 0);
2196   rb_define_method (c_guestfs, "aug_load",
2197         ruby_guestfs_aug_load, 0);
2198   rb_define_method (c_guestfs, "aug_ls",
2199         ruby_guestfs_aug_ls, 1);
2200   rb_define_method (c_guestfs, "rm",
2201         ruby_guestfs_rm, 1);
2202   rb_define_method (c_guestfs, "rmdir",
2203         ruby_guestfs_rmdir, 1);
2204   rb_define_method (c_guestfs, "rm_rf",
2205         ruby_guestfs_rm_rf, 1);
2206   rb_define_method (c_guestfs, "mkdir",
2207         ruby_guestfs_mkdir, 1);
2208   rb_define_method (c_guestfs, "mkdir_p",
2209         ruby_guestfs_mkdir_p, 1);
2210   rb_define_method (c_guestfs, "chmod",
2211         ruby_guestfs_chmod, 2);
2212   rb_define_method (c_guestfs, "chown",
2213         ruby_guestfs_chown, 3);
2214   rb_define_method (c_guestfs, "exists",
2215         ruby_guestfs_exists, 1);
2216   rb_define_method (c_guestfs, "is_file",
2217         ruby_guestfs_is_file, 1);
2218   rb_define_method (c_guestfs, "is_dir",
2219         ruby_guestfs_is_dir, 1);
2220   rb_define_method (c_guestfs, "pvcreate",
2221         ruby_guestfs_pvcreate, 1);
2222   rb_define_method (c_guestfs, "vgcreate",
2223         ruby_guestfs_vgcreate, 2);
2224   rb_define_method (c_guestfs, "lvcreate",
2225         ruby_guestfs_lvcreate, 3);
2226   rb_define_method (c_guestfs, "mkfs",
2227         ruby_guestfs_mkfs, 2);
2228   rb_define_method (c_guestfs, "sfdisk",
2229         ruby_guestfs_sfdisk, 5);
2230   rb_define_method (c_guestfs, "write_file",
2231         ruby_guestfs_write_file, 3);
2232   rb_define_method (c_guestfs, "umount",
2233         ruby_guestfs_umount, 1);
2234   rb_define_method (c_guestfs, "mounts",
2235         ruby_guestfs_mounts, 0);
2236   rb_define_method (c_guestfs, "umount_all",
2237         ruby_guestfs_umount_all, 0);
2238   rb_define_method (c_guestfs, "lvm_remove_all",
2239         ruby_guestfs_lvm_remove_all, 0);
2240   rb_define_method (c_guestfs, "file",
2241         ruby_guestfs_file, 1);
2242   rb_define_method (c_guestfs, "command",
2243         ruby_guestfs_command, 1);
2244   rb_define_method (c_guestfs, "command_lines",
2245         ruby_guestfs_command_lines, 1);
2246   rb_define_method (c_guestfs, "stat",
2247         ruby_guestfs_stat, 1);
2248   rb_define_method (c_guestfs, "lstat",
2249         ruby_guestfs_lstat, 1);
2250   rb_define_method (c_guestfs, "statvfs",
2251         ruby_guestfs_statvfs, 1);
2252   rb_define_method (c_guestfs, "tune2fs_l",
2253         ruby_guestfs_tune2fs_l, 1);
2254   rb_define_method (c_guestfs, "blockdev_setro",
2255         ruby_guestfs_blockdev_setro, 1);
2256   rb_define_method (c_guestfs, "blockdev_setrw",
2257         ruby_guestfs_blockdev_setrw, 1);
2258   rb_define_method (c_guestfs, "blockdev_getro",
2259         ruby_guestfs_blockdev_getro, 1);
2260   rb_define_method (c_guestfs, "blockdev_getss",
2261         ruby_guestfs_blockdev_getss, 1);
2262   rb_define_method (c_guestfs, "blockdev_getbsz",
2263         ruby_guestfs_blockdev_getbsz, 1);
2264   rb_define_method (c_guestfs, "blockdev_setbsz",
2265         ruby_guestfs_blockdev_setbsz, 2);
2266   rb_define_method (c_guestfs, "blockdev_getsz",
2267         ruby_guestfs_blockdev_getsz, 1);
2268   rb_define_method (c_guestfs, "blockdev_getsize64",
2269         ruby_guestfs_blockdev_getsize64, 1);
2270   rb_define_method (c_guestfs, "blockdev_flushbufs",
2271         ruby_guestfs_blockdev_flushbufs, 1);
2272   rb_define_method (c_guestfs, "blockdev_rereadpt",
2273         ruby_guestfs_blockdev_rereadpt, 1);
2274   rb_define_method (c_guestfs, "upload",
2275         ruby_guestfs_upload, 2);
2276   rb_define_method (c_guestfs, "download",
2277         ruby_guestfs_download, 2);
2278   rb_define_method (c_guestfs, "checksum",
2279         ruby_guestfs_checksum, 2);
2280 }