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 = malloc (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   }
1422
1423   int r;
1424
1425   r = guestfs_vgcreate (g, volgroup, physvols);
1426   free (physvols);
1427   if (r == -1)
1428     rb_raise (e_Error, "%s", guestfs_last_error (g));
1429
1430   return Qnil;
1431 }
1432
1433 static VALUE ruby_guestfs_lvcreate (VALUE gv, VALUE logvolv, VALUE volgroupv, VALUE mbytesv)
1434 {
1435   guestfs_h *g;
1436   Data_Get_Struct (gv, guestfs_h, g);
1437   if (!g)
1438     rb_raise (rb_eArgError, "%s: used handle after closing it", "lvcreate");
1439
1440   const char *logvol = StringValueCStr (logvolv);
1441   if (!logvol)
1442     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1443               "logvol", "lvcreate");
1444   const char *volgroup = StringValueCStr (volgroupv);
1445   if (!volgroup)
1446     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1447               "volgroup", "lvcreate");
1448   int mbytes = NUM2INT (mbytesv);
1449
1450   int r;
1451
1452   r = guestfs_lvcreate (g, logvol, volgroup, mbytes);
1453   if (r == -1)
1454     rb_raise (e_Error, "%s", guestfs_last_error (g));
1455
1456   return Qnil;
1457 }
1458
1459 static VALUE ruby_guestfs_mkfs (VALUE gv, VALUE fstypev, VALUE devicev)
1460 {
1461   guestfs_h *g;
1462   Data_Get_Struct (gv, guestfs_h, g);
1463   if (!g)
1464     rb_raise (rb_eArgError, "%s: used handle after closing it", "mkfs");
1465
1466   const char *fstype = StringValueCStr (fstypev);
1467   if (!fstype)
1468     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1469               "fstype", "mkfs");
1470   const char *device = StringValueCStr (devicev);
1471   if (!device)
1472     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1473               "device", "mkfs");
1474
1475   int r;
1476
1477   r = guestfs_mkfs (g, fstype, device);
1478   if (r == -1)
1479     rb_raise (e_Error, "%s", guestfs_last_error (g));
1480
1481   return Qnil;
1482 }
1483
1484 static VALUE ruby_guestfs_sfdisk (VALUE gv, VALUE devicev, VALUE cylsv, VALUE headsv, VALUE sectorsv, VALUE linesv)
1485 {
1486   guestfs_h *g;
1487   Data_Get_Struct (gv, guestfs_h, g);
1488   if (!g)
1489     rb_raise (rb_eArgError, "%s: used handle after closing it", "sfdisk");
1490
1491   const char *device = StringValueCStr (devicev);
1492   if (!device)
1493     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1494               "device", "sfdisk");
1495   int cyls = NUM2INT (cylsv);
1496   int heads = NUM2INT (headsv);
1497   int sectors = NUM2INT (sectorsv);
1498   char **lines;  {
1499     int i, len;
1500     len = RARRAY_LEN (linesv);
1501     lines = malloc (sizeof (char *) * (len+1));
1502     for (i = 0; i < len; ++i) {
1503       VALUE v = rb_ary_entry (linesv, i);
1504       lines[i] = StringValueCStr (v);
1505     }
1506   }
1507
1508   int r;
1509
1510   r = guestfs_sfdisk (g, device, cyls, heads, sectors, lines);
1511   free (lines);
1512   if (r == -1)
1513     rb_raise (e_Error, "%s", guestfs_last_error (g));
1514
1515   return Qnil;
1516 }
1517
1518 static VALUE ruby_guestfs_write_file (VALUE gv, VALUE pathv, VALUE contentv, VALUE sizev)
1519 {
1520   guestfs_h *g;
1521   Data_Get_Struct (gv, guestfs_h, g);
1522   if (!g)
1523     rb_raise (rb_eArgError, "%s: used handle after closing it", "write_file");
1524
1525   const char *path = StringValueCStr (pathv);
1526   if (!path)
1527     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1528               "path", "write_file");
1529   const char *content = StringValueCStr (contentv);
1530   if (!content)
1531     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1532               "content", "write_file");
1533   int size = NUM2INT (sizev);
1534
1535   int r;
1536
1537   r = guestfs_write_file (g, path, content, size);
1538   if (r == -1)
1539     rb_raise (e_Error, "%s", guestfs_last_error (g));
1540
1541   return Qnil;
1542 }
1543
1544 static VALUE ruby_guestfs_umount (VALUE gv, VALUE pathordevicev)
1545 {
1546   guestfs_h *g;
1547   Data_Get_Struct (gv, guestfs_h, g);
1548   if (!g)
1549     rb_raise (rb_eArgError, "%s: used handle after closing it", "umount");
1550
1551   const char *pathordevice = StringValueCStr (pathordevicev);
1552   if (!pathordevice)
1553     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1554               "pathordevice", "umount");
1555
1556   int r;
1557
1558   r = guestfs_umount (g, pathordevice);
1559   if (r == -1)
1560     rb_raise (e_Error, "%s", guestfs_last_error (g));
1561
1562   return Qnil;
1563 }
1564
1565 static VALUE ruby_guestfs_mounts (VALUE gv)
1566 {
1567   guestfs_h *g;
1568   Data_Get_Struct (gv, guestfs_h, g);
1569   if (!g)
1570     rb_raise (rb_eArgError, "%s: used handle after closing it", "mounts");
1571
1572
1573   char **r;
1574
1575   r = guestfs_mounts (g);
1576   if (r == NULL)
1577     rb_raise (e_Error, "%s", guestfs_last_error (g));
1578
1579   int i, len = 0;
1580   for (i = 0; r[i] != NULL; ++i) len++;
1581   VALUE rv = rb_ary_new2 (len);
1582   for (i = 0; r[i] != NULL; ++i) {
1583     rb_ary_push (rv, rb_str_new2 (r[i]));
1584     free (r[i]);
1585   }
1586   free (r);
1587   return rv;
1588 }
1589
1590 static VALUE ruby_guestfs_umount_all (VALUE gv)
1591 {
1592   guestfs_h *g;
1593   Data_Get_Struct (gv, guestfs_h, g);
1594   if (!g)
1595     rb_raise (rb_eArgError, "%s: used handle after closing it", "umount_all");
1596
1597
1598   int r;
1599
1600   r = guestfs_umount_all (g);
1601   if (r == -1)
1602     rb_raise (e_Error, "%s", guestfs_last_error (g));
1603
1604   return Qnil;
1605 }
1606
1607 static VALUE ruby_guestfs_lvm_remove_all (VALUE gv)
1608 {
1609   guestfs_h *g;
1610   Data_Get_Struct (gv, guestfs_h, g);
1611   if (!g)
1612     rb_raise (rb_eArgError, "%s: used handle after closing it", "lvm_remove_all");
1613
1614
1615   int r;
1616
1617   r = guestfs_lvm_remove_all (g);
1618   if (r == -1)
1619     rb_raise (e_Error, "%s", guestfs_last_error (g));
1620
1621   return Qnil;
1622 }
1623
1624 static VALUE ruby_guestfs_file (VALUE gv, VALUE pathv)
1625 {
1626   guestfs_h *g;
1627   Data_Get_Struct (gv, guestfs_h, g);
1628   if (!g)
1629     rb_raise (rb_eArgError, "%s: used handle after closing it", "file");
1630
1631   const char *path = StringValueCStr (pathv);
1632   if (!path)
1633     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1634               "path", "file");
1635
1636   char *r;
1637
1638   r = guestfs_file (g, path);
1639   if (r == NULL)
1640     rb_raise (e_Error, "%s", guestfs_last_error (g));
1641
1642   VALUE rv = rb_str_new2 (r);
1643   free (r);
1644   return rv;
1645 }
1646
1647 static VALUE ruby_guestfs_command (VALUE gv, VALUE argumentsv)
1648 {
1649   guestfs_h *g;
1650   Data_Get_Struct (gv, guestfs_h, g);
1651   if (!g)
1652     rb_raise (rb_eArgError, "%s: used handle after closing it", "command");
1653
1654   char **arguments;  {
1655     int i, len;
1656     len = RARRAY_LEN (argumentsv);
1657     arguments = malloc (sizeof (char *) * (len+1));
1658     for (i = 0; i < len; ++i) {
1659       VALUE v = rb_ary_entry (argumentsv, i);
1660       arguments[i] = StringValueCStr (v);
1661     }
1662   }
1663
1664   char *r;
1665
1666   r = guestfs_command (g, arguments);
1667   free (arguments);
1668   if (r == NULL)
1669     rb_raise (e_Error, "%s", guestfs_last_error (g));
1670
1671   VALUE rv = rb_str_new2 (r);
1672   free (r);
1673   return rv;
1674 }
1675
1676 static VALUE ruby_guestfs_command_lines (VALUE gv, VALUE argumentsv)
1677 {
1678   guestfs_h *g;
1679   Data_Get_Struct (gv, guestfs_h, g);
1680   if (!g)
1681     rb_raise (rb_eArgError, "%s: used handle after closing it", "command_lines");
1682
1683   char **arguments;  {
1684     int i, len;
1685     len = RARRAY_LEN (argumentsv);
1686     arguments = malloc (sizeof (char *) * (len+1));
1687     for (i = 0; i < len; ++i) {
1688       VALUE v = rb_ary_entry (argumentsv, i);
1689       arguments[i] = StringValueCStr (v);
1690     }
1691   }
1692
1693   char **r;
1694
1695   r = guestfs_command_lines (g, arguments);
1696   free (arguments);
1697   if (r == NULL)
1698     rb_raise (e_Error, "%s", guestfs_last_error (g));
1699
1700   int i, len = 0;
1701   for (i = 0; r[i] != NULL; ++i) len++;
1702   VALUE rv = rb_ary_new2 (len);
1703   for (i = 0; r[i] != NULL; ++i) {
1704     rb_ary_push (rv, rb_str_new2 (r[i]));
1705     free (r[i]);
1706   }
1707   free (r);
1708   return rv;
1709 }
1710
1711 static VALUE ruby_guestfs_stat (VALUE gv, VALUE pathv)
1712 {
1713   guestfs_h *g;
1714   Data_Get_Struct (gv, guestfs_h, g);
1715   if (!g)
1716     rb_raise (rb_eArgError, "%s: used handle after closing it", "stat");
1717
1718   const char *path = StringValueCStr (pathv);
1719   if (!path)
1720     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1721               "path", "stat");
1722
1723   struct guestfs_stat *r;
1724
1725   r = guestfs_stat (g, path);
1726   if (r == NULL)
1727     rb_raise (e_Error, "%s", guestfs_last_error (g));
1728
1729   VALUE rv = rb_hash_new ();
1730   rb_hash_aset (rv, rb_str_new2 ("dev"), ULL2NUM (r->dev));
1731   rb_hash_aset (rv, rb_str_new2 ("ino"), ULL2NUM (r->ino));
1732   rb_hash_aset (rv, rb_str_new2 ("mode"), ULL2NUM (r->mode));
1733   rb_hash_aset (rv, rb_str_new2 ("nlink"), ULL2NUM (r->nlink));
1734   rb_hash_aset (rv, rb_str_new2 ("uid"), ULL2NUM (r->uid));
1735   rb_hash_aset (rv, rb_str_new2 ("gid"), ULL2NUM (r->gid));
1736   rb_hash_aset (rv, rb_str_new2 ("rdev"), ULL2NUM (r->rdev));
1737   rb_hash_aset (rv, rb_str_new2 ("size"), ULL2NUM (r->size));
1738   rb_hash_aset (rv, rb_str_new2 ("blksize"), ULL2NUM (r->blksize));
1739   rb_hash_aset (rv, rb_str_new2 ("blocks"), ULL2NUM (r->blocks));
1740   rb_hash_aset (rv, rb_str_new2 ("atime"), ULL2NUM (r->atime));
1741   rb_hash_aset (rv, rb_str_new2 ("mtime"), ULL2NUM (r->mtime));
1742   rb_hash_aset (rv, rb_str_new2 ("ctime"), ULL2NUM (r->ctime));
1743   free (r);
1744   return rv;
1745 }
1746
1747 static VALUE ruby_guestfs_lstat (VALUE gv, VALUE pathv)
1748 {
1749   guestfs_h *g;
1750   Data_Get_Struct (gv, guestfs_h, g);
1751   if (!g)
1752     rb_raise (rb_eArgError, "%s: used handle after closing it", "lstat");
1753
1754   const char *path = StringValueCStr (pathv);
1755   if (!path)
1756     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1757               "path", "lstat");
1758
1759   struct guestfs_stat *r;
1760
1761   r = guestfs_lstat (g, path);
1762   if (r == NULL)
1763     rb_raise (e_Error, "%s", guestfs_last_error (g));
1764
1765   VALUE rv = rb_hash_new ();
1766   rb_hash_aset (rv, rb_str_new2 ("dev"), ULL2NUM (r->dev));
1767   rb_hash_aset (rv, rb_str_new2 ("ino"), ULL2NUM (r->ino));
1768   rb_hash_aset (rv, rb_str_new2 ("mode"), ULL2NUM (r->mode));
1769   rb_hash_aset (rv, rb_str_new2 ("nlink"), ULL2NUM (r->nlink));
1770   rb_hash_aset (rv, rb_str_new2 ("uid"), ULL2NUM (r->uid));
1771   rb_hash_aset (rv, rb_str_new2 ("gid"), ULL2NUM (r->gid));
1772   rb_hash_aset (rv, rb_str_new2 ("rdev"), ULL2NUM (r->rdev));
1773   rb_hash_aset (rv, rb_str_new2 ("size"), ULL2NUM (r->size));
1774   rb_hash_aset (rv, rb_str_new2 ("blksize"), ULL2NUM (r->blksize));
1775   rb_hash_aset (rv, rb_str_new2 ("blocks"), ULL2NUM (r->blocks));
1776   rb_hash_aset (rv, rb_str_new2 ("atime"), ULL2NUM (r->atime));
1777   rb_hash_aset (rv, rb_str_new2 ("mtime"), ULL2NUM (r->mtime));
1778   rb_hash_aset (rv, rb_str_new2 ("ctime"), ULL2NUM (r->ctime));
1779   free (r);
1780   return rv;
1781 }
1782
1783 static VALUE ruby_guestfs_statvfs (VALUE gv, VALUE pathv)
1784 {
1785   guestfs_h *g;
1786   Data_Get_Struct (gv, guestfs_h, g);
1787   if (!g)
1788     rb_raise (rb_eArgError, "%s: used handle after closing it", "statvfs");
1789
1790   const char *path = StringValueCStr (pathv);
1791   if (!path)
1792     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1793               "path", "statvfs");
1794
1795   struct guestfs_statvfs *r;
1796
1797   r = guestfs_statvfs (g, path);
1798   if (r == NULL)
1799     rb_raise (e_Error, "%s", guestfs_last_error (g));
1800
1801   VALUE rv = rb_hash_new ();
1802   rb_hash_aset (rv, rb_str_new2 ("bsize"), ULL2NUM (r->bsize));
1803   rb_hash_aset (rv, rb_str_new2 ("frsize"), ULL2NUM (r->frsize));
1804   rb_hash_aset (rv, rb_str_new2 ("blocks"), ULL2NUM (r->blocks));
1805   rb_hash_aset (rv, rb_str_new2 ("bfree"), ULL2NUM (r->bfree));
1806   rb_hash_aset (rv, rb_str_new2 ("bavail"), ULL2NUM (r->bavail));
1807   rb_hash_aset (rv, rb_str_new2 ("files"), ULL2NUM (r->files));
1808   rb_hash_aset (rv, rb_str_new2 ("ffree"), ULL2NUM (r->ffree));
1809   rb_hash_aset (rv, rb_str_new2 ("favail"), ULL2NUM (r->favail));
1810   rb_hash_aset (rv, rb_str_new2 ("fsid"), ULL2NUM (r->fsid));
1811   rb_hash_aset (rv, rb_str_new2 ("flag"), ULL2NUM (r->flag));
1812   rb_hash_aset (rv, rb_str_new2 ("namemax"), ULL2NUM (r->namemax));
1813   free (r);
1814   return rv;
1815 }
1816
1817 static VALUE ruby_guestfs_tune2fs_l (VALUE gv, VALUE devicev)
1818 {
1819   guestfs_h *g;
1820   Data_Get_Struct (gv, guestfs_h, g);
1821   if (!g)
1822     rb_raise (rb_eArgError, "%s: used handle after closing it", "tune2fs_l");
1823
1824   const char *device = StringValueCStr (devicev);
1825   if (!device)
1826     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1827               "device", "tune2fs_l");
1828
1829   char **r;
1830
1831   r = guestfs_tune2fs_l (g, device);
1832   if (r == NULL)
1833     rb_raise (e_Error, "%s", guestfs_last_error (g));
1834
1835   VALUE rv = rb_hash_new ();
1836   int i;
1837   for (i = 0; r[i] != NULL; i+=2) {
1838     rb_hash_aset (rv, rb_str_new2 (r[i]), rb_str_new2 (r[i+1]));
1839     free (r[i]);
1840     free (r[i+1]);
1841   }
1842   free (r);
1843   return rv;
1844 }
1845
1846 static VALUE ruby_guestfs_blockdev_setro (VALUE gv, VALUE devicev)
1847 {
1848   guestfs_h *g;
1849   Data_Get_Struct (gv, guestfs_h, g);
1850   if (!g)
1851     rb_raise (rb_eArgError, "%s: used handle after closing it", "blockdev_setro");
1852
1853   const char *device = StringValueCStr (devicev);
1854   if (!device)
1855     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1856               "device", "blockdev_setro");
1857
1858   int r;
1859
1860   r = guestfs_blockdev_setro (g, device);
1861   if (r == -1)
1862     rb_raise (e_Error, "%s", guestfs_last_error (g));
1863
1864   return Qnil;
1865 }
1866
1867 static VALUE ruby_guestfs_blockdev_setrw (VALUE gv, VALUE devicev)
1868 {
1869   guestfs_h *g;
1870   Data_Get_Struct (gv, guestfs_h, g);
1871   if (!g)
1872     rb_raise (rb_eArgError, "%s: used handle after closing it", "blockdev_setrw");
1873
1874   const char *device = StringValueCStr (devicev);
1875   if (!device)
1876     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1877               "device", "blockdev_setrw");
1878
1879   int r;
1880
1881   r = guestfs_blockdev_setrw (g, device);
1882   if (r == -1)
1883     rb_raise (e_Error, "%s", guestfs_last_error (g));
1884
1885   return Qnil;
1886 }
1887
1888 static VALUE ruby_guestfs_blockdev_getro (VALUE gv, VALUE devicev)
1889 {
1890   guestfs_h *g;
1891   Data_Get_Struct (gv, guestfs_h, g);
1892   if (!g)
1893     rb_raise (rb_eArgError, "%s: used handle after closing it", "blockdev_getro");
1894
1895   const char *device = StringValueCStr (devicev);
1896   if (!device)
1897     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1898               "device", "blockdev_getro");
1899
1900   int r;
1901
1902   r = guestfs_blockdev_getro (g, device);
1903   if (r == -1)
1904     rb_raise (e_Error, "%s", guestfs_last_error (g));
1905
1906   return INT2NUM (r);
1907 }
1908
1909 static VALUE ruby_guestfs_blockdev_getss (VALUE gv, VALUE devicev)
1910 {
1911   guestfs_h *g;
1912   Data_Get_Struct (gv, guestfs_h, g);
1913   if (!g)
1914     rb_raise (rb_eArgError, "%s: used handle after closing it", "blockdev_getss");
1915
1916   const char *device = StringValueCStr (devicev);
1917   if (!device)
1918     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1919               "device", "blockdev_getss");
1920
1921   int r;
1922
1923   r = guestfs_blockdev_getss (g, device);
1924   if (r == -1)
1925     rb_raise (e_Error, "%s", guestfs_last_error (g));
1926
1927   return INT2NUM (r);
1928 }
1929
1930 static VALUE ruby_guestfs_blockdev_getbsz (VALUE gv, VALUE devicev)
1931 {
1932   guestfs_h *g;
1933   Data_Get_Struct (gv, guestfs_h, g);
1934   if (!g)
1935     rb_raise (rb_eArgError, "%s: used handle after closing it", "blockdev_getbsz");
1936
1937   const char *device = StringValueCStr (devicev);
1938   if (!device)
1939     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1940               "device", "blockdev_getbsz");
1941
1942   int r;
1943
1944   r = guestfs_blockdev_getbsz (g, device);
1945   if (r == -1)
1946     rb_raise (e_Error, "%s", guestfs_last_error (g));
1947
1948   return INT2NUM (r);
1949 }
1950
1951 static VALUE ruby_guestfs_blockdev_setbsz (VALUE gv, VALUE devicev, VALUE blocksizev)
1952 {
1953   guestfs_h *g;
1954   Data_Get_Struct (gv, guestfs_h, g);
1955   if (!g)
1956     rb_raise (rb_eArgError, "%s: used handle after closing it", "blockdev_setbsz");
1957
1958   const char *device = StringValueCStr (devicev);
1959   if (!device)
1960     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1961               "device", "blockdev_setbsz");
1962   int blocksize = NUM2INT (blocksizev);
1963
1964   int r;
1965
1966   r = guestfs_blockdev_setbsz (g, device, blocksize);
1967   if (r == -1)
1968     rb_raise (e_Error, "%s", guestfs_last_error (g));
1969
1970   return Qnil;
1971 }
1972
1973 static VALUE ruby_guestfs_blockdev_getsz (VALUE gv, VALUE devicev)
1974 {
1975   guestfs_h *g;
1976   Data_Get_Struct (gv, guestfs_h, g);
1977   if (!g)
1978     rb_raise (rb_eArgError, "%s: used handle after closing it", "blockdev_getsz");
1979
1980   const char *device = StringValueCStr (devicev);
1981   if (!device)
1982     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1983               "device", "blockdev_getsz");
1984
1985   int64_t r;
1986
1987   r = guestfs_blockdev_getsz (g, device);
1988   if (r == -1)
1989     rb_raise (e_Error, "%s", guestfs_last_error (g));
1990
1991   return ULL2NUM (r);
1992 }
1993
1994 static VALUE ruby_guestfs_blockdev_getsize64 (VALUE gv, VALUE devicev)
1995 {
1996   guestfs_h *g;
1997   Data_Get_Struct (gv, guestfs_h, g);
1998   if (!g)
1999     rb_raise (rb_eArgError, "%s: used handle after closing it", "blockdev_getsize64");
2000
2001   const char *device = StringValueCStr (devicev);
2002   if (!device)
2003     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2004               "device", "blockdev_getsize64");
2005
2006   int64_t r;
2007
2008   r = guestfs_blockdev_getsize64 (g, device);
2009   if (r == -1)
2010     rb_raise (e_Error, "%s", guestfs_last_error (g));
2011
2012   return ULL2NUM (r);
2013 }
2014
2015 static VALUE ruby_guestfs_blockdev_flushbufs (VALUE gv, VALUE devicev)
2016 {
2017   guestfs_h *g;
2018   Data_Get_Struct (gv, guestfs_h, g);
2019   if (!g)
2020     rb_raise (rb_eArgError, "%s: used handle after closing it", "blockdev_flushbufs");
2021
2022   const char *device = StringValueCStr (devicev);
2023   if (!device)
2024     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2025               "device", "blockdev_flushbufs");
2026
2027   int r;
2028
2029   r = guestfs_blockdev_flushbufs (g, device);
2030   if (r == -1)
2031     rb_raise (e_Error, "%s", guestfs_last_error (g));
2032
2033   return Qnil;
2034 }
2035
2036 static VALUE ruby_guestfs_blockdev_rereadpt (VALUE gv, VALUE devicev)
2037 {
2038   guestfs_h *g;
2039   Data_Get_Struct (gv, guestfs_h, g);
2040   if (!g)
2041     rb_raise (rb_eArgError, "%s: used handle after closing it", "blockdev_rereadpt");
2042
2043   const char *device = StringValueCStr (devicev);
2044   if (!device)
2045     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2046               "device", "blockdev_rereadpt");
2047
2048   int r;
2049
2050   r = guestfs_blockdev_rereadpt (g, device);
2051   if (r == -1)
2052     rb_raise (e_Error, "%s", guestfs_last_error (g));
2053
2054   return Qnil;
2055 }
2056
2057 static VALUE ruby_guestfs_upload (VALUE gv, VALUE filenamev, VALUE remotefilenamev)
2058 {
2059   guestfs_h *g;
2060   Data_Get_Struct (gv, guestfs_h, g);
2061   if (!g)
2062     rb_raise (rb_eArgError, "%s: used handle after closing it", "upload");
2063
2064   const char *filename = StringValueCStr (filenamev);
2065   if (!filename)
2066     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2067               "filename", "upload");
2068   const char *remotefilename = StringValueCStr (remotefilenamev);
2069   if (!remotefilename)
2070     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2071               "remotefilename", "upload");
2072
2073   int r;
2074
2075   r = guestfs_upload (g, filename, remotefilename);
2076   if (r == -1)
2077     rb_raise (e_Error, "%s", guestfs_last_error (g));
2078
2079   return Qnil;
2080 }
2081
2082 static VALUE ruby_guestfs_download (VALUE gv, VALUE remotefilenamev, VALUE filenamev)
2083 {
2084   guestfs_h *g;
2085   Data_Get_Struct (gv, guestfs_h, g);
2086   if (!g)
2087     rb_raise (rb_eArgError, "%s: used handle after closing it", "download");
2088
2089   const char *remotefilename = StringValueCStr (remotefilenamev);
2090   if (!remotefilename)
2091     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2092               "remotefilename", "download");
2093   const char *filename = StringValueCStr (filenamev);
2094   if (!filename)
2095     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2096               "filename", "download");
2097
2098   int r;
2099
2100   r = guestfs_download (g, remotefilename, filename);
2101   if (r == -1)
2102     rb_raise (e_Error, "%s", guestfs_last_error (g));
2103
2104   return Qnil;
2105 }
2106
2107 static VALUE ruby_guestfs_checksum (VALUE gv, VALUE csumtypev, VALUE pathv)
2108 {
2109   guestfs_h *g;
2110   Data_Get_Struct (gv, guestfs_h, g);
2111   if (!g)
2112     rb_raise (rb_eArgError, "%s: used handle after closing it", "checksum");
2113
2114   const char *csumtype = StringValueCStr (csumtypev);
2115   if (!csumtype)
2116     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2117               "csumtype", "checksum");
2118   const char *path = StringValueCStr (pathv);
2119   if (!path)
2120     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2121               "path", "checksum");
2122
2123   char *r;
2124
2125   r = guestfs_checksum (g, csumtype, path);
2126   if (r == NULL)
2127     rb_raise (e_Error, "%s", guestfs_last_error (g));
2128
2129   VALUE rv = rb_str_new2 (r);
2130   free (r);
2131   return rv;
2132 }
2133
2134 static VALUE ruby_guestfs_tar_in (VALUE gv, VALUE tarfilev, VALUE directoryv)
2135 {
2136   guestfs_h *g;
2137   Data_Get_Struct (gv, guestfs_h, g);
2138   if (!g)
2139     rb_raise (rb_eArgError, "%s: used handle after closing it", "tar_in");
2140
2141   const char *tarfile = StringValueCStr (tarfilev);
2142   if (!tarfile)
2143     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2144               "tarfile", "tar_in");
2145   const char *directory = StringValueCStr (directoryv);
2146   if (!directory)
2147     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2148               "directory", "tar_in");
2149
2150   int r;
2151
2152   r = guestfs_tar_in (g, tarfile, directory);
2153   if (r == -1)
2154     rb_raise (e_Error, "%s", guestfs_last_error (g));
2155
2156   return Qnil;
2157 }
2158
2159 static VALUE ruby_guestfs_tar_out (VALUE gv, VALUE directoryv, VALUE tarfilev)
2160 {
2161   guestfs_h *g;
2162   Data_Get_Struct (gv, guestfs_h, g);
2163   if (!g)
2164     rb_raise (rb_eArgError, "%s: used handle after closing it", "tar_out");
2165
2166   const char *directory = StringValueCStr (directoryv);
2167   if (!directory)
2168     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2169               "directory", "tar_out");
2170   const char *tarfile = StringValueCStr (tarfilev);
2171   if (!tarfile)
2172     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2173               "tarfile", "tar_out");
2174
2175   int r;
2176
2177   r = guestfs_tar_out (g, directory, tarfile);
2178   if (r == -1)
2179     rb_raise (e_Error, "%s", guestfs_last_error (g));
2180
2181   return Qnil;
2182 }
2183
2184 static VALUE ruby_guestfs_tgz_in (VALUE gv, VALUE tarballv, VALUE directoryv)
2185 {
2186   guestfs_h *g;
2187   Data_Get_Struct (gv, guestfs_h, g);
2188   if (!g)
2189     rb_raise (rb_eArgError, "%s: used handle after closing it", "tgz_in");
2190
2191   const char *tarball = StringValueCStr (tarballv);
2192   if (!tarball)
2193     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2194               "tarball", "tgz_in");
2195   const char *directory = StringValueCStr (directoryv);
2196   if (!directory)
2197     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2198               "directory", "tgz_in");
2199
2200   int r;
2201
2202   r = guestfs_tgz_in (g, tarball, directory);
2203   if (r == -1)
2204     rb_raise (e_Error, "%s", guestfs_last_error (g));
2205
2206   return Qnil;
2207 }
2208
2209 static VALUE ruby_guestfs_tgz_out (VALUE gv, VALUE directoryv, VALUE tarballv)
2210 {
2211   guestfs_h *g;
2212   Data_Get_Struct (gv, guestfs_h, g);
2213   if (!g)
2214     rb_raise (rb_eArgError, "%s: used handle after closing it", "tgz_out");
2215
2216   const char *directory = StringValueCStr (directoryv);
2217   if (!directory)
2218     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2219               "directory", "tgz_out");
2220   const char *tarball = StringValueCStr (tarballv);
2221   if (!tarball)
2222     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2223               "tarball", "tgz_out");
2224
2225   int r;
2226
2227   r = guestfs_tgz_out (g, directory, tarball);
2228   if (r == -1)
2229     rb_raise (e_Error, "%s", guestfs_last_error (g));
2230
2231   return Qnil;
2232 }
2233
2234 static VALUE ruby_guestfs_mount_ro (VALUE gv, VALUE devicev, VALUE mountpointv)
2235 {
2236   guestfs_h *g;
2237   Data_Get_Struct (gv, guestfs_h, g);
2238   if (!g)
2239     rb_raise (rb_eArgError, "%s: used handle after closing it", "mount_ro");
2240
2241   const char *device = StringValueCStr (devicev);
2242   if (!device)
2243     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2244               "device", "mount_ro");
2245   const char *mountpoint = StringValueCStr (mountpointv);
2246   if (!mountpoint)
2247     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2248               "mountpoint", "mount_ro");
2249
2250   int r;
2251
2252   r = guestfs_mount_ro (g, device, mountpoint);
2253   if (r == -1)
2254     rb_raise (e_Error, "%s", guestfs_last_error (g));
2255
2256   return Qnil;
2257 }
2258
2259 static VALUE ruby_guestfs_mount_options (VALUE gv, VALUE optionsv, VALUE devicev, VALUE mountpointv)
2260 {
2261   guestfs_h *g;
2262   Data_Get_Struct (gv, guestfs_h, g);
2263   if (!g)
2264     rb_raise (rb_eArgError, "%s: used handle after closing it", "mount_options");
2265
2266   const char *options = StringValueCStr (optionsv);
2267   if (!options)
2268     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2269               "options", "mount_options");
2270   const char *device = StringValueCStr (devicev);
2271   if (!device)
2272     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2273               "device", "mount_options");
2274   const char *mountpoint = StringValueCStr (mountpointv);
2275   if (!mountpoint)
2276     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2277               "mountpoint", "mount_options");
2278
2279   int r;
2280
2281   r = guestfs_mount_options (g, options, device, mountpoint);
2282   if (r == -1)
2283     rb_raise (e_Error, "%s", guestfs_last_error (g));
2284
2285   return Qnil;
2286 }
2287
2288 static VALUE ruby_guestfs_mount_vfs (VALUE gv, VALUE optionsv, VALUE vfstypev, VALUE devicev, VALUE mountpointv)
2289 {
2290   guestfs_h *g;
2291   Data_Get_Struct (gv, guestfs_h, g);
2292   if (!g)
2293     rb_raise (rb_eArgError, "%s: used handle after closing it", "mount_vfs");
2294
2295   const char *options = StringValueCStr (optionsv);
2296   if (!options)
2297     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2298               "options", "mount_vfs");
2299   const char *vfstype = StringValueCStr (vfstypev);
2300   if (!vfstype)
2301     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2302               "vfstype", "mount_vfs");
2303   const char *device = StringValueCStr (devicev);
2304   if (!device)
2305     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2306               "device", "mount_vfs");
2307   const char *mountpoint = StringValueCStr (mountpointv);
2308   if (!mountpoint)
2309     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2310               "mountpoint", "mount_vfs");
2311
2312   int r;
2313
2314   r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint);
2315   if (r == -1)
2316     rb_raise (e_Error, "%s", guestfs_last_error (g));
2317
2318   return Qnil;
2319 }
2320
2321 /* Initialize the module. */
2322 void Init__guestfs ()
2323 {
2324   m_guestfs = rb_define_module ("Guestfs");
2325   c_guestfs = rb_define_class_under (m_guestfs, "Guestfs", rb_cObject);
2326   e_Error = rb_define_class_under (m_guestfs, "Error", rb_eStandardError);
2327
2328   rb_define_module_function (m_guestfs, "create", ruby_guestfs_create, 0);
2329   rb_define_method (c_guestfs, "close", ruby_guestfs_close, 0);
2330
2331   rb_define_method (c_guestfs, "launch",
2332         ruby_guestfs_launch, 0);
2333   rb_define_method (c_guestfs, "wait_ready",
2334         ruby_guestfs_wait_ready, 0);
2335   rb_define_method (c_guestfs, "kill_subprocess",
2336         ruby_guestfs_kill_subprocess, 0);
2337   rb_define_method (c_guestfs, "add_drive",
2338         ruby_guestfs_add_drive, 1);
2339   rb_define_method (c_guestfs, "add_cdrom",
2340         ruby_guestfs_add_cdrom, 1);
2341   rb_define_method (c_guestfs, "config",
2342         ruby_guestfs_config, 2);
2343   rb_define_method (c_guestfs, "set_qemu",
2344         ruby_guestfs_set_qemu, 1);
2345   rb_define_method (c_guestfs, "get_qemu",
2346         ruby_guestfs_get_qemu, 0);
2347   rb_define_method (c_guestfs, "set_path",
2348         ruby_guestfs_set_path, 1);
2349   rb_define_method (c_guestfs, "get_path",
2350         ruby_guestfs_get_path, 0);
2351   rb_define_method (c_guestfs, "set_autosync",
2352         ruby_guestfs_set_autosync, 1);
2353   rb_define_method (c_guestfs, "get_autosync",
2354         ruby_guestfs_get_autosync, 0);
2355   rb_define_method (c_guestfs, "set_verbose",
2356         ruby_guestfs_set_verbose, 1);
2357   rb_define_method (c_guestfs, "get_verbose",
2358         ruby_guestfs_get_verbose, 0);
2359   rb_define_method (c_guestfs, "is_ready",
2360         ruby_guestfs_is_ready, 0);
2361   rb_define_method (c_guestfs, "is_config",
2362         ruby_guestfs_is_config, 0);
2363   rb_define_method (c_guestfs, "is_launching",
2364         ruby_guestfs_is_launching, 0);
2365   rb_define_method (c_guestfs, "is_busy",
2366         ruby_guestfs_is_busy, 0);
2367   rb_define_method (c_guestfs, "get_state",
2368         ruby_guestfs_get_state, 0);
2369   rb_define_method (c_guestfs, "set_busy",
2370         ruby_guestfs_set_busy, 0);
2371   rb_define_method (c_guestfs, "set_ready",
2372         ruby_guestfs_set_ready, 0);
2373   rb_define_method (c_guestfs, "mount",
2374         ruby_guestfs_mount, 2);
2375   rb_define_method (c_guestfs, "sync",
2376         ruby_guestfs_sync, 0);
2377   rb_define_method (c_guestfs, "touch",
2378         ruby_guestfs_touch, 1);
2379   rb_define_method (c_guestfs, "cat",
2380         ruby_guestfs_cat, 1);
2381   rb_define_method (c_guestfs, "ll",
2382         ruby_guestfs_ll, 1);
2383   rb_define_method (c_guestfs, "ls",
2384         ruby_guestfs_ls, 1);
2385   rb_define_method (c_guestfs, "list_devices",
2386         ruby_guestfs_list_devices, 0);
2387   rb_define_method (c_guestfs, "list_partitions",
2388         ruby_guestfs_list_partitions, 0);
2389   rb_define_method (c_guestfs, "pvs",
2390         ruby_guestfs_pvs, 0);
2391   rb_define_method (c_guestfs, "vgs",
2392         ruby_guestfs_vgs, 0);
2393   rb_define_method (c_guestfs, "lvs",
2394         ruby_guestfs_lvs, 0);
2395   rb_define_method (c_guestfs, "pvs_full",
2396         ruby_guestfs_pvs_full, 0);
2397   rb_define_method (c_guestfs, "vgs_full",
2398         ruby_guestfs_vgs_full, 0);
2399   rb_define_method (c_guestfs, "lvs_full",
2400         ruby_guestfs_lvs_full, 0);
2401   rb_define_method (c_guestfs, "read_lines",
2402         ruby_guestfs_read_lines, 1);
2403   rb_define_method (c_guestfs, "aug_init",
2404         ruby_guestfs_aug_init, 2);
2405   rb_define_method (c_guestfs, "aug_close",
2406         ruby_guestfs_aug_close, 0);
2407   rb_define_method (c_guestfs, "aug_defvar",
2408         ruby_guestfs_aug_defvar, 2);
2409   rb_define_method (c_guestfs, "aug_defnode",
2410         ruby_guestfs_aug_defnode, 3);
2411   rb_define_method (c_guestfs, "aug_get",
2412         ruby_guestfs_aug_get, 1);
2413   rb_define_method (c_guestfs, "aug_set",
2414         ruby_guestfs_aug_set, 2);
2415   rb_define_method (c_guestfs, "aug_insert",
2416         ruby_guestfs_aug_insert, 3);
2417   rb_define_method (c_guestfs, "aug_rm",
2418         ruby_guestfs_aug_rm, 1);
2419   rb_define_method (c_guestfs, "aug_mv",
2420         ruby_guestfs_aug_mv, 2);
2421   rb_define_method (c_guestfs, "aug_match",
2422         ruby_guestfs_aug_match, 1);
2423   rb_define_method (c_guestfs, "aug_save",
2424         ruby_guestfs_aug_save, 0);
2425   rb_define_method (c_guestfs, "aug_load",
2426         ruby_guestfs_aug_load, 0);
2427   rb_define_method (c_guestfs, "aug_ls",
2428         ruby_guestfs_aug_ls, 1);
2429   rb_define_method (c_guestfs, "rm",
2430         ruby_guestfs_rm, 1);
2431   rb_define_method (c_guestfs, "rmdir",
2432         ruby_guestfs_rmdir, 1);
2433   rb_define_method (c_guestfs, "rm_rf",
2434         ruby_guestfs_rm_rf, 1);
2435   rb_define_method (c_guestfs, "mkdir",
2436         ruby_guestfs_mkdir, 1);
2437   rb_define_method (c_guestfs, "mkdir_p",
2438         ruby_guestfs_mkdir_p, 1);
2439   rb_define_method (c_guestfs, "chmod",
2440         ruby_guestfs_chmod, 2);
2441   rb_define_method (c_guestfs, "chown",
2442         ruby_guestfs_chown, 3);
2443   rb_define_method (c_guestfs, "exists",
2444         ruby_guestfs_exists, 1);
2445   rb_define_method (c_guestfs, "is_file",
2446         ruby_guestfs_is_file, 1);
2447   rb_define_method (c_guestfs, "is_dir",
2448         ruby_guestfs_is_dir, 1);
2449   rb_define_method (c_guestfs, "pvcreate",
2450         ruby_guestfs_pvcreate, 1);
2451   rb_define_method (c_guestfs, "vgcreate",
2452         ruby_guestfs_vgcreate, 2);
2453   rb_define_method (c_guestfs, "lvcreate",
2454         ruby_guestfs_lvcreate, 3);
2455   rb_define_method (c_guestfs, "mkfs",
2456         ruby_guestfs_mkfs, 2);
2457   rb_define_method (c_guestfs, "sfdisk",
2458         ruby_guestfs_sfdisk, 5);
2459   rb_define_method (c_guestfs, "write_file",
2460         ruby_guestfs_write_file, 3);
2461   rb_define_method (c_guestfs, "umount",
2462         ruby_guestfs_umount, 1);
2463   rb_define_method (c_guestfs, "mounts",
2464         ruby_guestfs_mounts, 0);
2465   rb_define_method (c_guestfs, "umount_all",
2466         ruby_guestfs_umount_all, 0);
2467   rb_define_method (c_guestfs, "lvm_remove_all",
2468         ruby_guestfs_lvm_remove_all, 0);
2469   rb_define_method (c_guestfs, "file",
2470         ruby_guestfs_file, 1);
2471   rb_define_method (c_guestfs, "command",
2472         ruby_guestfs_command, 1);
2473   rb_define_method (c_guestfs, "command_lines",
2474         ruby_guestfs_command_lines, 1);
2475   rb_define_method (c_guestfs, "stat",
2476         ruby_guestfs_stat, 1);
2477   rb_define_method (c_guestfs, "lstat",
2478         ruby_guestfs_lstat, 1);
2479   rb_define_method (c_guestfs, "statvfs",
2480         ruby_guestfs_statvfs, 1);
2481   rb_define_method (c_guestfs, "tune2fs_l",
2482         ruby_guestfs_tune2fs_l, 1);
2483   rb_define_method (c_guestfs, "blockdev_setro",
2484         ruby_guestfs_blockdev_setro, 1);
2485   rb_define_method (c_guestfs, "blockdev_setrw",
2486         ruby_guestfs_blockdev_setrw, 1);
2487   rb_define_method (c_guestfs, "blockdev_getro",
2488         ruby_guestfs_blockdev_getro, 1);
2489   rb_define_method (c_guestfs, "blockdev_getss",
2490         ruby_guestfs_blockdev_getss, 1);
2491   rb_define_method (c_guestfs, "blockdev_getbsz",
2492         ruby_guestfs_blockdev_getbsz, 1);
2493   rb_define_method (c_guestfs, "blockdev_setbsz",
2494         ruby_guestfs_blockdev_setbsz, 2);
2495   rb_define_method (c_guestfs, "blockdev_getsz",
2496         ruby_guestfs_blockdev_getsz, 1);
2497   rb_define_method (c_guestfs, "blockdev_getsize64",
2498         ruby_guestfs_blockdev_getsize64, 1);
2499   rb_define_method (c_guestfs, "blockdev_flushbufs",
2500         ruby_guestfs_blockdev_flushbufs, 1);
2501   rb_define_method (c_guestfs, "blockdev_rereadpt",
2502         ruby_guestfs_blockdev_rereadpt, 1);
2503   rb_define_method (c_guestfs, "upload",
2504         ruby_guestfs_upload, 2);
2505   rb_define_method (c_guestfs, "download",
2506         ruby_guestfs_download, 2);
2507   rb_define_method (c_guestfs, "checksum",
2508         ruby_guestfs_checksum, 2);
2509   rb_define_method (c_guestfs, "tar_in",
2510         ruby_guestfs_tar_in, 2);
2511   rb_define_method (c_guestfs, "tar_out",
2512         ruby_guestfs_tar_out, 2);
2513   rb_define_method (c_guestfs, "tgz_in",
2514         ruby_guestfs_tgz_in, 2);
2515   rb_define_method (c_guestfs, "tgz_out",
2516         ruby_guestfs_tgz_out, 2);
2517   rb_define_method (c_guestfs, "mount_ro",
2518         ruby_guestfs_mount_ro, 2);
2519   rb_define_method (c_guestfs, "mount_options",
2520         ruby_guestfs_mount_options, 3);
2521   rb_define_method (c_guestfs, "mount_vfs",
2522         ruby_guestfs_mount_vfs, 4);
2523 }