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