ruby/ext/guestfs/_guestfs.c

   1 /* libguestfs generated file
   2  * WARNING: THIS FILE IS GENERATED BY 'src/generator.ml'.
   3  * ANY CHANGES YOU MAKE TO THIS FILE WILL BE LOST.
   4  *
   5  * Copyright (C) 2009 Red Hat Inc.
   6  *
   7  * This library is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2 of the License, or (at your option) any later version.
  11  *
  12  * This library is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with this library; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  20  */
  21
  22 #include <stdio.h>
  23 #include <stdlib.h>
  24
  25 #include <ruby.h>
  26
  27 #include "guestfs.h"
  28
  29 #include "extconf.h"
  30
  31 /* For Ruby < 1.9 */
  32 #ifndef RARRAY_LEN
  33 #define RARRAY_LEN(r) (RARRAY((r))->len)
  34 #endif
  35
  36 static VALUE m_guestfs;                 /* guestfs module */
  37 static VALUE c_guestfs;                 /* guestfs_h handle */
  38 static VALUE e_Error;                   /* used for all errors */
  39
  40 static void ruby_guestfs_free (void *p)
  41 {
  42   if (!p) return;
  43   guestfs_close ((guestfs_h *) p);
  44 }
  45
  46 static VALUE ruby_guestfs_create (VALUE m)
  47 {
  48   guestfs_h *g;
  49
  50   g = guestfs_create ();
  51   if (!g)
  52     rb_raise (e_Error, "failed to create guestfs handle");
  53
  54   /* Don't print error messages to stderr by default. */
  55   guestfs_set_error_handler (g, NULL, NULL);
  56
  57   /* Wrap it, and make sure the close function is called when the
  58    * handle goes away.
  59    */
  60   return Data_Wrap_Struct (c_guestfs, NULL, ruby_guestfs_free, g);
  61 }
  62
  63 static VALUE ruby_guestfs_close (VALUE gv)
  64 {
  65   guestfs_h *g;
  66   Data_Get_Struct (gv, guestfs_h, g);
  67
  68   ruby_guestfs_free (g);
  69   DATA_PTR (gv) = NULL;
  70
  71   return Qnil;
  72 }
  73
  74 static VALUE ruby_guestfs_test0 (VALUE gv, VALUE strv, VALUE optstrv, VALUE strlistv, VALUE bv, VALUE integerv, VALUE fileinv, VALUE fileoutv)
  75 {
  76   guestfs_h *g;
  77   Data_Get_Struct (gv, guestfs_h, g);
  78   if (!g)
  79     rb_raise (rb_eArgError, "%s: used handle after closing it", "test0");
  80
  81   Check_Type (strv, T_STRING);
  82   const char *str = StringValueCStr (strv);
  83   if (!str)
  84     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
  85               "str", "test0");
  86   const char *optstr = !NIL_P (optstrv) ? StringValueCStr (optstrv) : NULL;
  87   char **strlist;
  88   Check_Type (strlistv, T_ARRAY);
  89   {
  90     int i, len;
  91     len = RARRAY_LEN (strlistv);
  92     strlist = guestfs_safe_malloc (g, sizeof (char *) * (len+1));
  93     for (i = 0; i < len; ++i) {
  94       VALUE v = rb_ary_entry (strlistv, i);
  95       strlist[i] = StringValueCStr (v);
  96     }
  97     strlist[len] = NULL;
  98   }
  99   int b = RTEST (bv);
 100   int integer = NUM2INT (integerv);
 101   Check_Type (fileinv, T_STRING);
 102   const char *filein = StringValueCStr (fileinv);
 103   if (!filein)
 104     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
 105               "filein", "test0");
 106   Check_Type (fileoutv, T_STRING);
 107   const char *fileout = StringValueCStr (fileoutv);
 108   if (!fileout)
 109     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
 110               "fileout", "test0");
 111
 112   int r;
 113
 114   r = guestfs_test0 (g, str, optstr, strlist, b, integer, filein, fileout);
 115   free (strlist);
 116   if (r == -1)
 117     rb_raise (e_Error, "%s", guestfs_last_error (g));
 118
 119   return Qnil;
 120 }
 121
 122 static VALUE ruby_guestfs_test0rint (VALUE gv, VALUE valv)
 123 {
 124   guestfs_h *g;
 125   Data_Get_Struct (gv, guestfs_h, g);
 126   if (!g)
 127     rb_raise (rb_eArgError, "%s: used handle after closing it", "test0rint");
 128
 129   Check_Type (valv, T_STRING);
 130   const char *val = StringValueCStr (valv);
 131   if (!val)
 132     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
 133               "val", "test0rint");
 134
 135   int r;
 136
 137   r = guestfs_test0rint (g, val);
 138   if (r == -1)
 139     rb_raise (e_Error, "%s", guestfs_last_error (g));
 140
 141   return INT2NUM (r);
 142 }
 143
 144 static VALUE ruby_guestfs_test0rinterr (VALUE gv)
 145 {
 146   guestfs_h *g;
 147   Data_Get_Struct (gv, guestfs_h, g);
 148   if (!g)
 149     rb_raise (rb_eArgError, "%s: used handle after closing it", "test0rinterr");
 150
 151
 152   int r;
 153
 154   r = guestfs_test0rinterr (g);
 155   if (r == -1)
 156     rb_raise (e_Error, "%s", guestfs_last_error (g));
 157
 158   return INT2NUM (r);
 159 }
 160
 161 static VALUE ruby_guestfs_test0rint64 (VALUE gv, VALUE valv)
 162 {
 163   guestfs_h *g;
 164   Data_Get_Struct (gv, guestfs_h, g);
 165   if (!g)
 166     rb_raise (rb_eArgError, "%s: used handle after closing it", "test0rint64");
 167
 168   Check_Type (valv, T_STRING);
 169   const char *val = StringValueCStr (valv);
 170   if (!val)
 171     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
 172               "val", "test0rint64");
 173
 174   int64_t r;
 175
 176   r = guestfs_test0rint64 (g, val);
 177   if (r == -1)
 178     rb_raise (e_Error, "%s", guestfs_last_error (g));
 179
 180   return ULL2NUM (r);
 181 }
 182
 183 static VALUE ruby_guestfs_test0rint64err (VALUE gv)
 184 {
 185   guestfs_h *g;
 186   Data_Get_Struct (gv, guestfs_h, g);
 187   if (!g)
 188     rb_raise (rb_eArgError, "%s: used handle after closing it", "test0rint64err");
 189
 190
 191   int64_t r;
 192
 193   r = guestfs_test0rint64err (g);
 194   if (r == -1)
 195     rb_raise (e_Error, "%s", guestfs_last_error (g));
 196
 197   return ULL2NUM (r);
 198 }
 199
 200 static VALUE ruby_guestfs_test0rbool (VALUE gv, VALUE valv)
 201 {
 202   guestfs_h *g;
 203   Data_Get_Struct (gv, guestfs_h, g);
 204   if (!g)
 205     rb_raise (rb_eArgError, "%s: used handle after closing it", "test0rbool");
 206
 207   Check_Type (valv, T_STRING);
 208   const char *val = StringValueCStr (valv);
 209   if (!val)
 210     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
 211               "val", "test0rbool");
 212
 213   int r;
 214
 215   r = guestfs_test0rbool (g, val);
 216   if (r == -1)
 217     rb_raise (e_Error, "%s", guestfs_last_error (g));
 218
 219   return INT2NUM (r);
 220 }
 221
 222 static VALUE ruby_guestfs_test0rboolerr (VALUE gv)
 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", "test0rboolerr");
 228
 229
 230   int r;
 231
 232   r = guestfs_test0rboolerr (g);
 233   if (r == -1)
 234     rb_raise (e_Error, "%s", guestfs_last_error (g));
 235
 236   return INT2NUM (r);
 237 }
 238
 239 static VALUE ruby_guestfs_test0rconststring (VALUE gv, VALUE valv)
 240 {
 241   guestfs_h *g;
 242   Data_Get_Struct (gv, guestfs_h, g);
 243   if (!g)
 244     rb_raise (rb_eArgError, "%s: used handle after closing it", "test0rconststring");
 245
 246   Check_Type (valv, T_STRING);
 247   const char *val = StringValueCStr (valv);
 248   if (!val)
 249     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
 250               "val", "test0rconststring");
 251
 252   const char *r;
 253
 254   r = guestfs_test0rconststring (g, val);
 255   if (r == NULL)
 256     rb_raise (e_Error, "%s", guestfs_last_error (g));
 257
 258   return rb_str_new2 (r);
 259 }
 260
 261 static VALUE ruby_guestfs_test0rconststringerr (VALUE gv)
 262 {
 263   guestfs_h *g;
 264   Data_Get_Struct (gv, guestfs_h, g);
 265   if (!g)
 266     rb_raise (rb_eArgError, "%s: used handle after closing it", "test0rconststringerr");
 267
 268
 269   const char *r;
 270
 271   r = guestfs_test0rconststringerr (g);
 272   if (r == NULL)
 273     rb_raise (e_Error, "%s", guestfs_last_error (g));
 274
 275   return rb_str_new2 (r);
 276 }
 277
 278 static VALUE ruby_guestfs_test0rstring (VALUE gv, VALUE valv)
 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", "test0rstring");
 284
 285   Check_Type (valv, T_STRING);
 286   const char *val = StringValueCStr (valv);
 287   if (!val)
 288     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
 289               "val", "test0rstring");
 290
 291   char *r;
 292
 293   r = guestfs_test0rstring (g, val);
 294   if (r == NULL)
 295     rb_raise (e_Error, "%s", guestfs_last_error (g));
 296
 297   VALUE rv = rb_str_new2 (r);
 298   free (r);
 299   return rv;
 300 }
 301
 302 static VALUE ruby_guestfs_test0rstringerr (VALUE gv)
 303 {
 304   guestfs_h *g;
 305   Data_Get_Struct (gv, guestfs_h, g);
 306   if (!g)
 307     rb_raise (rb_eArgError, "%s: used handle after closing it", "test0rstringerr");
 308
 309
 310   char *r;
 311
 312   r = guestfs_test0rstringerr (g);
 313   if (r == NULL)
 314     rb_raise (e_Error, "%s", guestfs_last_error (g));
 315
 316   VALUE rv = rb_str_new2 (r);
 317   free (r);
 318   return rv;
 319 }
 320
 321 static VALUE ruby_guestfs_test0rstringlist (VALUE gv, VALUE valv)
 322 {
 323   guestfs_h *g;
 324   Data_Get_Struct (gv, guestfs_h, g);
 325   if (!g)
 326     rb_raise (rb_eArgError, "%s: used handle after closing it", "test0rstringlist");
 327
 328   Check_Type (valv, T_STRING);
 329   const char *val = StringValueCStr (valv);
 330   if (!val)
 331     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
 332               "val", "test0rstringlist");
 333
 334   char **r;
 335
 336   r = guestfs_test0rstringlist (g, val);
 337   if (r == NULL)
 338     rb_raise (e_Error, "%s", guestfs_last_error (g));
 339
 340   int i, len = 0;
 341   for (i = 0; r[i] != NULL; ++i) len++;
 342   VALUE rv = rb_ary_new2 (len);
 343   for (i = 0; r[i] != NULL; ++i) {
 344     rb_ary_push (rv, rb_str_new2 (r[i]));
 345     free (r[i]);
 346   }
 347   free (r);
 348   return rv;
 349 }
 350
 351 static VALUE ruby_guestfs_test0rstringlisterr (VALUE gv)
 352 {
 353   guestfs_h *g;
 354   Data_Get_Struct (gv, guestfs_h, g);
 355   if (!g)
 356     rb_raise (rb_eArgError, "%s: used handle after closing it", "test0rstringlisterr");
 357
 358
 359   char **r;
 360
 361   r = guestfs_test0rstringlisterr (g);
 362   if (r == NULL)
 363     rb_raise (e_Error, "%s", guestfs_last_error (g));
 364
 365   int i, len = 0;
 366   for (i = 0; r[i] != NULL; ++i) len++;
 367   VALUE rv = rb_ary_new2 (len);
 368   for (i = 0; r[i] != NULL; ++i) {
 369     rb_ary_push (rv, rb_str_new2 (r[i]));
 370     free (r[i]);
 371   }
 372   free (r);
 373   return rv;
 374 }
 375
 376 static VALUE ruby_guestfs_test0rintbool (VALUE gv, VALUE valv)
 377 {
 378   guestfs_h *g;
 379   Data_Get_Struct (gv, guestfs_h, g);
 380   if (!g)
 381     rb_raise (rb_eArgError, "%s: used handle after closing it", "test0rintbool");
 382
 383   Check_Type (valv, T_STRING);
 384   const char *val = StringValueCStr (valv);
 385   if (!val)
 386     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
 387               "val", "test0rintbool");
 388
 389   struct guestfs_int_bool *r;
 390
 391   r = guestfs_test0rintbool (g, val);
 392   if (r == NULL)
 393     rb_raise (e_Error, "%s", guestfs_last_error (g));
 394
 395   VALUE rv = rb_ary_new2 (2);
 396   rb_ary_push (rv, INT2NUM (r->i));
 397   rb_ary_push (rv, INT2NUM (r->b));
 398   guestfs_free_int_bool (r);
 399   return rv;
 400 }
 401
 402 static VALUE ruby_guestfs_test0rintboolerr (VALUE gv)
 403 {
 404   guestfs_h *g;
 405   Data_Get_Struct (gv, guestfs_h, g);
 406   if (!g)
 407     rb_raise (rb_eArgError, "%s: used handle after closing it", "test0rintboolerr");
 408
 409
 410   struct guestfs_int_bool *r;
 411
 412   r = guestfs_test0rintboolerr (g);
 413   if (r == NULL)
 414     rb_raise (e_Error, "%s", guestfs_last_error (g));
 415
 416   VALUE rv = rb_ary_new2 (2);
 417   rb_ary_push (rv, INT2NUM (r->i));
 418   rb_ary_push (rv, INT2NUM (r->b));
 419   guestfs_free_int_bool (r);
 420   return rv;
 421 }
 422
 423 static VALUE ruby_guestfs_test0rpvlist (VALUE gv, VALUE valv)
 424 {
 425   guestfs_h *g;
 426   Data_Get_Struct (gv, guestfs_h, g);
 427   if (!g)
 428     rb_raise (rb_eArgError, "%s: used handle after closing it", "test0rpvlist");
 429
 430   Check_Type (valv, T_STRING);
 431   const char *val = StringValueCStr (valv);
 432   if (!val)
 433     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
 434               "val", "test0rpvlist");
 435
 436   struct guestfs_lvm_pv_list *r;
 437
 438   r = guestfs_test0rpvlist (g, val);
 439   if (r == NULL)
 440     rb_raise (e_Error, "%s", guestfs_last_error (g));
 441
 442   VALUE rv = rb_ary_new2 (r->len);
 443   int i;
 444   for (i = 0; i < r->len; ++i) {
 445     VALUE hv = rb_hash_new ();
 446     rb_hash_aset (rv, rb_str_new2 ("pv_name"), rb_str_new2 (r->val[i].pv_name));
 447     rb_hash_aset (rv, rb_str_new2 ("pv_uuid"), rb_str_new (r->val[i].pv_uuid, 32));
 448     rb_hash_aset (rv, rb_str_new2 ("pv_fmt"), rb_str_new2 (r->val[i].pv_fmt));
 449     rb_hash_aset (rv, rb_str_new2 ("pv_size"), ULL2NUM (r->val[i].pv_size));
 450     rb_hash_aset (rv, rb_str_new2 ("dev_size"), ULL2NUM (r->val[i].dev_size));
 451     rb_hash_aset (rv, rb_str_new2 ("pv_free"), ULL2NUM (r->val[i].pv_free));
 452     rb_hash_aset (rv, rb_str_new2 ("pv_used"), ULL2NUM (r->val[i].pv_used));
 453     rb_hash_aset (rv, rb_str_new2 ("pv_attr"), rb_str_new2 (r->val[i].pv_attr));
 454     rb_hash_aset (rv, rb_str_new2 ("pv_pe_count"), ULL2NUM (r->val[i].pv_pe_count));
 455     rb_hash_aset (rv, rb_str_new2 ("pv_pe_alloc_count"), ULL2NUM (r->val[i].pv_pe_alloc_count));
 456     rb_hash_aset (rv, rb_str_new2 ("pv_tags"), rb_str_new2 (r->val[i].pv_tags));
 457     rb_hash_aset (rv, rb_str_new2 ("pe_start"), ULL2NUM (r->val[i].pe_start));
 458     rb_hash_aset (rv, rb_str_new2 ("pv_mda_count"), ULL2NUM (r->val[i].pv_mda_count));
 459     rb_hash_aset (rv, rb_str_new2 ("pv_mda_free"), ULL2NUM (r->val[i].pv_mda_free));
 460     rb_ary_push (rv, hv);
 461   }
 462   guestfs_free_lvm_pv_list (r);
 463   return rv;
 464 }
 465
 466 static VALUE ruby_guestfs_test0rpvlisterr (VALUE gv)
 467 {
 468   guestfs_h *g;
 469   Data_Get_Struct (gv, guestfs_h, g);
 470   if (!g)
 471     rb_raise (rb_eArgError, "%s: used handle after closing it", "test0rpvlisterr");
 472
 473
 474   struct guestfs_lvm_pv_list *r;
 475
 476   r = guestfs_test0rpvlisterr (g);
 477   if (r == NULL)
 478     rb_raise (e_Error, "%s", guestfs_last_error (g));
 479
 480   VALUE rv = rb_ary_new2 (r->len);
 481   int i;
 482   for (i = 0; i < r->len; ++i) {
 483     VALUE hv = rb_hash_new ();
 484     rb_hash_aset (rv, rb_str_new2 ("pv_name"), rb_str_new2 (r->val[i].pv_name));
 485     rb_hash_aset (rv, rb_str_new2 ("pv_uuid"), rb_str_new (r->val[i].pv_uuid, 32));
 486     rb_hash_aset (rv, rb_str_new2 ("pv_fmt"), rb_str_new2 (r->val[i].pv_fmt));
 487     rb_hash_aset (rv, rb_str_new2 ("pv_size"), ULL2NUM (r->val[i].pv_size));
 488     rb_hash_aset (rv, rb_str_new2 ("dev_size"), ULL2NUM (r->val[i].dev_size));
 489     rb_hash_aset (rv, rb_str_new2 ("pv_free"), ULL2NUM (r->val[i].pv_free));
 490     rb_hash_aset (rv, rb_str_new2 ("pv_used"), ULL2NUM (r->val[i].pv_used));
 491     rb_hash_aset (rv, rb_str_new2 ("pv_attr"), rb_str_new2 (r->val[i].pv_attr));
 492     rb_hash_aset (rv, rb_str_new2 ("pv_pe_count"), ULL2NUM (r->val[i].pv_pe_count));
 493     rb_hash_aset (rv, rb_str_new2 ("pv_pe_alloc_count"), ULL2NUM (r->val[i].pv_pe_alloc_count));
 494     rb_hash_aset (rv, rb_str_new2 ("pv_tags"), rb_str_new2 (r->val[i].pv_tags));
 495     rb_hash_aset (rv, rb_str_new2 ("pe_start"), ULL2NUM (r->val[i].pe_start));
 496     rb_hash_aset (rv, rb_str_new2 ("pv_mda_count"), ULL2NUM (r->val[i].pv_mda_count));
 497     rb_hash_aset (rv, rb_str_new2 ("pv_mda_free"), ULL2NUM (r->val[i].pv_mda_free));
 498     rb_ary_push (rv, hv);
 499   }
 500   guestfs_free_lvm_pv_list (r);
 501   return rv;
 502 }
 503
 504 static VALUE ruby_guestfs_test0rvglist (VALUE gv, VALUE valv)
 505 {
 506   guestfs_h *g;
 507   Data_Get_Struct (gv, guestfs_h, g);
 508   if (!g)
 509     rb_raise (rb_eArgError, "%s: used handle after closing it", "test0rvglist");
 510
 511   Check_Type (valv, T_STRING);
 512   const char *val = StringValueCStr (valv);
 513   if (!val)
 514     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
 515               "val", "test0rvglist");
 516
 517   struct guestfs_lvm_vg_list *r;
 518
 519   r = guestfs_test0rvglist (g, val);
 520   if (r == NULL)
 521     rb_raise (e_Error, "%s", guestfs_last_error (g));
 522
 523   VALUE rv = rb_ary_new2 (r->len);
 524   int i;
 525   for (i = 0; i < r->len; ++i) {
 526     VALUE hv = rb_hash_new ();
 527     rb_hash_aset (rv, rb_str_new2 ("vg_name"), rb_str_new2 (r->val[i].vg_name));
 528     rb_hash_aset (rv, rb_str_new2 ("vg_uuid"), rb_str_new (r->val[i].vg_uuid, 32));
 529     rb_hash_aset (rv, rb_str_new2 ("vg_fmt"), rb_str_new2 (r->val[i].vg_fmt));
 530     rb_hash_aset (rv, rb_str_new2 ("vg_attr"), rb_str_new2 (r->val[i].vg_attr));
 531     rb_hash_aset (rv, rb_str_new2 ("vg_size"), ULL2NUM (r->val[i].vg_size));
 532     rb_hash_aset (rv, rb_str_new2 ("vg_free"), ULL2NUM (r->val[i].vg_free));
 533     rb_hash_aset (rv, rb_str_new2 ("vg_sysid"), rb_str_new2 (r->val[i].vg_sysid));
 534     rb_hash_aset (rv, rb_str_new2 ("vg_extent_size"), ULL2NUM (r->val[i].vg_extent_size));
 535     rb_hash_aset (rv, rb_str_new2 ("vg_extent_count"), ULL2NUM (r->val[i].vg_extent_count));
 536     rb_hash_aset (rv, rb_str_new2 ("vg_free_count"), ULL2NUM (r->val[i].vg_free_count));
 537     rb_hash_aset (rv, rb_str_new2 ("max_lv"), ULL2NUM (r->val[i].max_lv));
 538     rb_hash_aset (rv, rb_str_new2 ("max_pv"), ULL2NUM (r->val[i].max_pv));
 539     rb_hash_aset (rv, rb_str_new2 ("pv_count"), ULL2NUM (r->val[i].pv_count));
 540     rb_hash_aset (rv, rb_str_new2 ("lv_count"), ULL2NUM (r->val[i].lv_count));
 541     rb_hash_aset (rv, rb_str_new2 ("snap_count"), ULL2NUM (r->val[i].snap_count));
 542     rb_hash_aset (rv, rb_str_new2 ("vg_seqno"), ULL2NUM (r->val[i].vg_seqno));
 543     rb_hash_aset (rv, rb_str_new2 ("vg_tags"), rb_str_new2 (r->val[i].vg_tags));
 544     rb_hash_aset (rv, rb_str_new2 ("vg_mda_count"), ULL2NUM (r->val[i].vg_mda_count));
 545     rb_hash_aset (rv, rb_str_new2 ("vg_mda_free"), ULL2NUM (r->val[i].vg_mda_free));
 546     rb_ary_push (rv, hv);
 547   }
 548   guestfs_free_lvm_vg_list (r);
 549   return rv;
 550 }
 551
 552 static VALUE ruby_guestfs_test0rvglisterr (VALUE gv)
 553 {
 554   guestfs_h *g;
 555   Data_Get_Struct (gv, guestfs_h, g);
 556   if (!g)
 557     rb_raise (rb_eArgError, "%s: used handle after closing it", "test0rvglisterr");
 558
 559
 560   struct guestfs_lvm_vg_list *r;
 561
 562   r = guestfs_test0rvglisterr (g);
 563   if (r == NULL)
 564     rb_raise (e_Error, "%s", guestfs_last_error (g));
 565
 566   VALUE rv = rb_ary_new2 (r->len);
 567   int i;
 568   for (i = 0; i < r->len; ++i) {
 569     VALUE hv = rb_hash_new ();
 570     rb_hash_aset (rv, rb_str_new2 ("vg_name"), rb_str_new2 (r->val[i].vg_name));
 571     rb_hash_aset (rv, rb_str_new2 ("vg_uuid"), rb_str_new (r->val[i].vg_uuid, 32));
 572     rb_hash_aset (rv, rb_str_new2 ("vg_fmt"), rb_str_new2 (r->val[i].vg_fmt));
 573     rb_hash_aset (rv, rb_str_new2 ("vg_attr"), rb_str_new2 (r->val[i].vg_attr));
 574     rb_hash_aset (rv, rb_str_new2 ("vg_size"), ULL2NUM (r->val[i].vg_size));
 575     rb_hash_aset (rv, rb_str_new2 ("vg_free"), ULL2NUM (r->val[i].vg_free));
 576     rb_hash_aset (rv, rb_str_new2 ("vg_sysid"), rb_str_new2 (r->val[i].vg_sysid));
 577     rb_hash_aset (rv, rb_str_new2 ("vg_extent_size"), ULL2NUM (r->val[i].vg_extent_size));
 578     rb_hash_aset (rv, rb_str_new2 ("vg_extent_count"), ULL2NUM (r->val[i].vg_extent_count));
 579     rb_hash_aset (rv, rb_str_new2 ("vg_free_count"), ULL2NUM (r->val[i].vg_free_count));
 580     rb_hash_aset (rv, rb_str_new2 ("max_lv"), ULL2NUM (r->val[i].max_lv));
 581     rb_hash_aset (rv, rb_str_new2 ("max_pv"), ULL2NUM (r->val[i].max_pv));
 582     rb_hash_aset (rv, rb_str_new2 ("pv_count"), ULL2NUM (r->val[i].pv_count));
 583     rb_hash_aset (rv, rb_str_new2 ("lv_count"), ULL2NUM (r->val[i].lv_count));
 584     rb_hash_aset (rv, rb_str_new2 ("snap_count"), ULL2NUM (r->val[i].snap_count));
 585     rb_hash_aset (rv, rb_str_new2 ("vg_seqno"), ULL2NUM (r->val[i].vg_seqno));
 586     rb_hash_aset (rv, rb_str_new2 ("vg_tags"), rb_str_new2 (r->val[i].vg_tags));
 587     rb_hash_aset (rv, rb_str_new2 ("vg_mda_count"), ULL2NUM (r->val[i].vg_mda_count));
 588     rb_hash_aset (rv, rb_str_new2 ("vg_mda_free"), ULL2NUM (r->val[i].vg_mda_free));
 589     rb_ary_push (rv, hv);
 590   }
 591   guestfs_free_lvm_vg_list (r);
 592   return rv;
 593 }
 594
 595 static VALUE ruby_guestfs_test0rlvlist (VALUE gv, VALUE valv)
 596 {
 597   guestfs_h *g;
 598   Data_Get_Struct (gv, guestfs_h, g);
 599   if (!g)
 600     rb_raise (rb_eArgError, "%s: used handle after closing it", "test0rlvlist");
 601
 602   Check_Type (valv, T_STRING);
 603   const char *val = StringValueCStr (valv);
 604   if (!val)
 605     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
 606               "val", "test0rlvlist");
 607
 608   struct guestfs_lvm_lv_list *r;
 609
 610   r = guestfs_test0rlvlist (g, val);
 611   if (r == NULL)
 612     rb_raise (e_Error, "%s", guestfs_last_error (g));
 613
 614   VALUE rv = rb_ary_new2 (r->len);
 615   int i;
 616   for (i = 0; i < r->len; ++i) {
 617     VALUE hv = rb_hash_new ();
 618     rb_hash_aset (rv, rb_str_new2 ("lv_name"), rb_str_new2 (r->val[i].lv_name));
 619     rb_hash_aset (rv, rb_str_new2 ("lv_uuid"), rb_str_new (r->val[i].lv_uuid, 32));
 620     rb_hash_aset (rv, rb_str_new2 ("lv_attr"), rb_str_new2 (r->val[i].lv_attr));
 621     rb_hash_aset (rv, rb_str_new2 ("lv_major"), ULL2NUM (r->val[i].lv_major));
 622     rb_hash_aset (rv, rb_str_new2 ("lv_minor"), ULL2NUM (r->val[i].lv_minor));
 623     rb_hash_aset (rv, rb_str_new2 ("lv_kernel_major"), ULL2NUM (r->val[i].lv_kernel_major));
 624     rb_hash_aset (rv, rb_str_new2 ("lv_kernel_minor"), ULL2NUM (r->val[i].lv_kernel_minor));
 625     rb_hash_aset (rv, rb_str_new2 ("lv_size"), ULL2NUM (r->val[i].lv_size));
 626     rb_hash_aset (rv, rb_str_new2 ("seg_count"), ULL2NUM (r->val[i].seg_count));
 627     rb_hash_aset (rv, rb_str_new2 ("origin"), rb_str_new2 (r->val[i].origin));
 628     rb_hash_aset (rv, rb_str_new2 ("snap_percent"), rb_dbl2big (r->val[i].snap_percent));
 629     rb_hash_aset (rv, rb_str_new2 ("copy_percent"), rb_dbl2big (r->val[i].copy_percent));
 630     rb_hash_aset (rv, rb_str_new2 ("move_pv"), rb_str_new2 (r->val[i].move_pv));
 631     rb_hash_aset (rv, rb_str_new2 ("lv_tags"), rb_str_new2 (r->val[i].lv_tags));
 632     rb_hash_aset (rv, rb_str_new2 ("mirror_log"), rb_str_new2 (r->val[i].mirror_log));
 633     rb_hash_aset (rv, rb_str_new2 ("modules"), rb_str_new2 (r->val[i].modules));
 634     rb_ary_push (rv, hv);
 635   }
 636   guestfs_free_lvm_lv_list (r);
 637   return rv;
 638 }
 639
 640 static VALUE ruby_guestfs_test0rlvlisterr (VALUE gv)
 641 {
 642   guestfs_h *g;
 643   Data_Get_Struct (gv, guestfs_h, g);
 644   if (!g)
 645     rb_raise (rb_eArgError, "%s: used handle after closing it", "test0rlvlisterr");
 646
 647
 648   struct guestfs_lvm_lv_list *r;
 649
 650   r = guestfs_test0rlvlisterr (g);
 651   if (r == NULL)
 652     rb_raise (e_Error, "%s", guestfs_last_error (g));
 653
 654   VALUE rv = rb_ary_new2 (r->len);
 655   int i;
 656   for (i = 0; i < r->len; ++i) {
 657     VALUE hv = rb_hash_new ();
 658     rb_hash_aset (rv, rb_str_new2 ("lv_name"), rb_str_new2 (r->val[i].lv_name));
 659     rb_hash_aset (rv, rb_str_new2 ("lv_uuid"), rb_str_new (r->val[i].lv_uuid, 32));
 660     rb_hash_aset (rv, rb_str_new2 ("lv_attr"), rb_str_new2 (r->val[i].lv_attr));
 661     rb_hash_aset (rv, rb_str_new2 ("lv_major"), ULL2NUM (r->val[i].lv_major));
 662     rb_hash_aset (rv, rb_str_new2 ("lv_minor"), ULL2NUM (r->val[i].lv_minor));
 663     rb_hash_aset (rv, rb_str_new2 ("lv_kernel_major"), ULL2NUM (r->val[i].lv_kernel_major));
 664     rb_hash_aset (rv, rb_str_new2 ("lv_kernel_minor"), ULL2NUM (r->val[i].lv_kernel_minor));
 665     rb_hash_aset (rv, rb_str_new2 ("lv_size"), ULL2NUM (r->val[i].lv_size));
 666     rb_hash_aset (rv, rb_str_new2 ("seg_count"), ULL2NUM (r->val[i].seg_count));
 667     rb_hash_aset (rv, rb_str_new2 ("origin"), rb_str_new2 (r->val[i].origin));
 668     rb_hash_aset (rv, rb_str_new2 ("snap_percent"), rb_dbl2big (r->val[i].snap_percent));
 669     rb_hash_aset (rv, rb_str_new2 ("copy_percent"), rb_dbl2big (r->val[i].copy_percent));
 670     rb_hash_aset (rv, rb_str_new2 ("move_pv"), rb_str_new2 (r->val[i].move_pv));
 671     rb_hash_aset (rv, rb_str_new2 ("lv_tags"), rb_str_new2 (r->val[i].lv_tags));
 672     rb_hash_aset (rv, rb_str_new2 ("mirror_log"), rb_str_new2 (r->val[i].mirror_log));
 673     rb_hash_aset (rv, rb_str_new2 ("modules"), rb_str_new2 (r->val[i].modules));
 674     rb_ary_push (rv, hv);
 675   }
 676   guestfs_free_lvm_lv_list (r);
 677   return rv;
 678 }
 679
 680 static VALUE ruby_guestfs_test0rstat (VALUE gv, VALUE valv)
 681 {
 682   guestfs_h *g;
 683   Data_Get_Struct (gv, guestfs_h, g);
 684   if (!g)
 685     rb_raise (rb_eArgError, "%s: used handle after closing it", "test0rstat");
 686
 687   Check_Type (valv, T_STRING);
 688   const char *val = StringValueCStr (valv);
 689   if (!val)
 690     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
 691               "val", "test0rstat");
 692
 693   struct guestfs_stat *r;
 694
 695   r = guestfs_test0rstat (g, val);
 696   if (r == NULL)
 697     rb_raise (e_Error, "%s", guestfs_last_error (g));
 698
 699   VALUE rv = rb_hash_new ();
 700   rb_hash_aset (rv, rb_str_new2 ("dev"), ULL2NUM (r->dev));
 701   rb_hash_aset (rv, rb_str_new2 ("ino"), ULL2NUM (r->ino));
 702   rb_hash_aset (rv, rb_str_new2 ("mode"), ULL2NUM (r->mode));
 703   rb_hash_aset (rv, rb_str_new2 ("nlink"), ULL2NUM (r->nlink));
 704   rb_hash_aset (rv, rb_str_new2 ("uid"), ULL2NUM (r->uid));
 705   rb_hash_aset (rv, rb_str_new2 ("gid"), ULL2NUM (r->gid));
 706   rb_hash_aset (rv, rb_str_new2 ("rdev"), ULL2NUM (r->rdev));
 707   rb_hash_aset (rv, rb_str_new2 ("size"), ULL2NUM (r->size));
 708   rb_hash_aset (rv, rb_str_new2 ("blksize"), ULL2NUM (r->blksize));
 709   rb_hash_aset (rv, rb_str_new2 ("blocks"), ULL2NUM (r->blocks));
 710   rb_hash_aset (rv, rb_str_new2 ("atime"), ULL2NUM (r->atime));
 711   rb_hash_aset (rv, rb_str_new2 ("mtime"), ULL2NUM (r->mtime));
 712   rb_hash_aset (rv, rb_str_new2 ("ctime"), ULL2NUM (r->ctime));
 713   free (r);
 714   return rv;
 715 }
 716
 717 static VALUE ruby_guestfs_test0rstaterr (VALUE gv)
 718 {
 719   guestfs_h *g;
 720   Data_Get_Struct (gv, guestfs_h, g);
 721   if (!g)
 722     rb_raise (rb_eArgError, "%s: used handle after closing it", "test0rstaterr");
 723
 724
 725   struct guestfs_stat *r;
 726
 727   r = guestfs_test0rstaterr (g);
 728   if (r == NULL)
 729     rb_raise (e_Error, "%s", guestfs_last_error (g));
 730
 731   VALUE rv = rb_hash_new ();
 732   rb_hash_aset (rv, rb_str_new2 ("dev"), ULL2NUM (r->dev));
 733   rb_hash_aset (rv, rb_str_new2 ("ino"), ULL2NUM (r->ino));
 734   rb_hash_aset (rv, rb_str_new2 ("mode"), ULL2NUM (r->mode));
 735   rb_hash_aset (rv, rb_str_new2 ("nlink"), ULL2NUM (r->nlink));
 736   rb_hash_aset (rv, rb_str_new2 ("uid"), ULL2NUM (r->uid));
 737   rb_hash_aset (rv, rb_str_new2 ("gid"), ULL2NUM (r->gid));
 738   rb_hash_aset (rv, rb_str_new2 ("rdev"), ULL2NUM (r->rdev));
 739   rb_hash_aset (rv, rb_str_new2 ("size"), ULL2NUM (r->size));
 740   rb_hash_aset (rv, rb_str_new2 ("blksize"), ULL2NUM (r->blksize));
 741   rb_hash_aset (rv, rb_str_new2 ("blocks"), ULL2NUM (r->blocks));
 742   rb_hash_aset (rv, rb_str_new2 ("atime"), ULL2NUM (r->atime));
 743   rb_hash_aset (rv, rb_str_new2 ("mtime"), ULL2NUM (r->mtime));
 744   rb_hash_aset (rv, rb_str_new2 ("ctime"), ULL2NUM (r->ctime));
 745   free (r);
 746   return rv;
 747 }
 748
 749 static VALUE ruby_guestfs_test0rstatvfs (VALUE gv, VALUE valv)
 750 {
 751   guestfs_h *g;
 752   Data_Get_Struct (gv, guestfs_h, g);
 753   if (!g)
 754     rb_raise (rb_eArgError, "%s: used handle after closing it", "test0rstatvfs");
 755
 756   Check_Type (valv, T_STRING);
 757   const char *val = StringValueCStr (valv);
 758   if (!val)
 759     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
 760               "val", "test0rstatvfs");
 761
 762   struct guestfs_statvfs *r;
 763
 764   r = guestfs_test0rstatvfs (g, val);
 765   if (r == NULL)
 766     rb_raise (e_Error, "%s", guestfs_last_error (g));
 767
 768   VALUE rv = rb_hash_new ();
 769   rb_hash_aset (rv, rb_str_new2 ("bsize"), ULL2NUM (r->bsize));
 770   rb_hash_aset (rv, rb_str_new2 ("frsize"), ULL2NUM (r->frsize));
 771   rb_hash_aset (rv, rb_str_new2 ("blocks"), ULL2NUM (r->blocks));
 772   rb_hash_aset (rv, rb_str_new2 ("bfree"), ULL2NUM (r->bfree));
 773   rb_hash_aset (rv, rb_str_new2 ("bavail"), ULL2NUM (r->bavail));
 774   rb_hash_aset (rv, rb_str_new2 ("files"), ULL2NUM (r->files));
 775   rb_hash_aset (rv, rb_str_new2 ("ffree"), ULL2NUM (r->ffree));
 776   rb_hash_aset (rv, rb_str_new2 ("favail"), ULL2NUM (r->favail));
 777   rb_hash_aset (rv, rb_str_new2 ("fsid"), ULL2NUM (r->fsid));
 778   rb_hash_aset (rv, rb_str_new2 ("flag"), ULL2NUM (r->flag));
 779   rb_hash_aset (rv, rb_str_new2 ("namemax"), ULL2NUM (r->namemax));
 780   free (r);
 781   return rv;
 782 }
 783
 784 static VALUE ruby_guestfs_test0rstatvfserr (VALUE gv)
 785 {
 786   guestfs_h *g;
 787   Data_Get_Struct (gv, guestfs_h, g);
 788   if (!g)
 789     rb_raise (rb_eArgError, "%s: used handle after closing it", "test0rstatvfserr");
 790
 791
 792   struct guestfs_statvfs *r;
 793
 794   r = guestfs_test0rstatvfserr (g);
 795   if (r == NULL)
 796     rb_raise (e_Error, "%s", guestfs_last_error (g));
 797
 798   VALUE rv = rb_hash_new ();
 799   rb_hash_aset (rv, rb_str_new2 ("bsize"), ULL2NUM (r->bsize));
 800   rb_hash_aset (rv, rb_str_new2 ("frsize"), ULL2NUM (r->frsize));
 801   rb_hash_aset (rv, rb_str_new2 ("blocks"), ULL2NUM (r->blocks));
 802   rb_hash_aset (rv, rb_str_new2 ("bfree"), ULL2NUM (r->bfree));
 803   rb_hash_aset (rv, rb_str_new2 ("bavail"), ULL2NUM (r->bavail));
 804   rb_hash_aset (rv, rb_str_new2 ("files"), ULL2NUM (r->files));
 805   rb_hash_aset (rv, rb_str_new2 ("ffree"), ULL2NUM (r->ffree));
 806   rb_hash_aset (rv, rb_str_new2 ("favail"), ULL2NUM (r->favail));
 807   rb_hash_aset (rv, rb_str_new2 ("fsid"), ULL2NUM (r->fsid));
 808   rb_hash_aset (rv, rb_str_new2 ("flag"), ULL2NUM (r->flag));
 809   rb_hash_aset (rv, rb_str_new2 ("namemax"), ULL2NUM (r->namemax));
 810   free (r);
 811   return rv;
 812 }
 813
 814 static VALUE ruby_guestfs_test0rhashtable (VALUE gv, VALUE valv)
 815 {
 816   guestfs_h *g;
 817   Data_Get_Struct (gv, guestfs_h, g);
 818   if (!g)
 819     rb_raise (rb_eArgError, "%s: used handle after closing it", "test0rhashtable");
 820
 821   Check_Type (valv, T_STRING);
 822   const char *val = StringValueCStr (valv);
 823   if (!val)
 824     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
 825               "val", "test0rhashtable");
 826
 827   char **r;
 828
 829   r = guestfs_test0rhashtable (g, val);
 830   if (r == NULL)
 831     rb_raise (e_Error, "%s", guestfs_last_error (g));
 832
 833   VALUE rv = rb_hash_new ();
 834   int i;
 835   for (i = 0; r[i] != NULL; i+=2) {
 836     rb_hash_aset (rv, rb_str_new2 (r[i]), rb_str_new2 (r[i+1]));
 837     free (r[i]);
 838     free (r[i+1]);
 839   }
 840   free (r);
 841   return rv;
 842 }
 843
 844 static VALUE ruby_guestfs_test0rhashtableerr (VALUE gv)
 845 {
 846   guestfs_h *g;
 847   Data_Get_Struct (gv, guestfs_h, g);
 848   if (!g)
 849     rb_raise (rb_eArgError, "%s: used handle after closing it", "test0rhashtableerr");
 850
 851
 852   char **r;
 853
 854   r = guestfs_test0rhashtableerr (g);
 855   if (r == NULL)
 856     rb_raise (e_Error, "%s", guestfs_last_error (g));
 857
 858   VALUE rv = rb_hash_new ();
 859   int i;
 860   for (i = 0; r[i] != NULL; i+=2) {
 861     rb_hash_aset (rv, rb_str_new2 (r[i]), rb_str_new2 (r[i+1]));
 862     free (r[i]);
 863     free (r[i+1]);
 864   }
 865   free (r);
 866   return rv;
 867 }
 868
 869 static VALUE ruby_guestfs_launch (VALUE gv)
 870 {
 871   guestfs_h *g;
 872   Data_Get_Struct (gv, guestfs_h, g);
 873   if (!g)
 874     rb_raise (rb_eArgError, "%s: used handle after closing it", "launch");
 875
 876
 877   int r;
 878
 879   r = guestfs_launch (g);
 880   if (r == -1)
 881     rb_raise (e_Error, "%s", guestfs_last_error (g));
 882
 883   return Qnil;
 884 }
 885
 886 static VALUE ruby_guestfs_wait_ready (VALUE gv)
 887 {
 888   guestfs_h *g;
 889   Data_Get_Struct (gv, guestfs_h, g);
 890   if (!g)
 891     rb_raise (rb_eArgError, "%s: used handle after closing it", "wait_ready");
 892
 893
 894   int r;
 895
 896   r = guestfs_wait_ready (g);
 897   if (r == -1)
 898     rb_raise (e_Error, "%s", guestfs_last_error (g));
 899
 900   return Qnil;
 901 }
 902
 903 static VALUE ruby_guestfs_kill_subprocess (VALUE gv)
 904 {
 905   guestfs_h *g;
 906   Data_Get_Struct (gv, guestfs_h, g);
 907   if (!g)
 908     rb_raise (rb_eArgError, "%s: used handle after closing it", "kill_subprocess");
 909
 910
 911   int r;
 912
 913   r = guestfs_kill_subprocess (g);
 914   if (r == -1)
 915     rb_raise (e_Error, "%s", guestfs_last_error (g));
 916
 917   return Qnil;
 918 }
 919
 920 static VALUE ruby_guestfs_add_drive (VALUE gv, VALUE filenamev)
 921 {
 922   guestfs_h *g;
 923   Data_Get_Struct (gv, guestfs_h, g);
 924   if (!g)
 925     rb_raise (rb_eArgError, "%s: used handle after closing it", "add_drive");
 926
 927   Check_Type (filenamev, T_STRING);
 928   const char *filename = StringValueCStr (filenamev);
 929   if (!filename)
 930     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
 931               "filename", "add_drive");
 932
 933   int r;
 934
 935   r = guestfs_add_drive (g, filename);
 936   if (r == -1)
 937     rb_raise (e_Error, "%s", guestfs_last_error (g));
 938
 939   return Qnil;
 940 }
 941
 942 static VALUE ruby_guestfs_add_cdrom (VALUE gv, VALUE filenamev)
 943 {
 944   guestfs_h *g;
 945   Data_Get_Struct (gv, guestfs_h, g);
 946   if (!g)
 947     rb_raise (rb_eArgError, "%s: used handle after closing it", "add_cdrom");
 948
 949   Check_Type (filenamev, T_STRING);
 950   const char *filename = StringValueCStr (filenamev);
 951   if (!filename)
 952     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
 953               "filename", "add_cdrom");
 954
 955   int r;
 956
 957   r = guestfs_add_cdrom (g, filename);
 958   if (r == -1)
 959     rb_raise (e_Error, "%s", guestfs_last_error (g));
 960
 961   return Qnil;
 962 }
 963
 964 static VALUE ruby_guestfs_add_drive_ro (VALUE gv, VALUE filenamev)
 965 {
 966   guestfs_h *g;
 967   Data_Get_Struct (gv, guestfs_h, g);
 968   if (!g)
 969     rb_raise (rb_eArgError, "%s: used handle after closing it", "add_drive_ro");
 970
 971   Check_Type (filenamev, T_STRING);
 972   const char *filename = StringValueCStr (filenamev);
 973   if (!filename)
 974     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
 975               "filename", "add_drive_ro");
 976
 977   int r;
 978
 979   r = guestfs_add_drive_ro (g, filename);
 980   if (r == -1)
 981     rb_raise (e_Error, "%s", guestfs_last_error (g));
 982
 983   return Qnil;
 984 }
 985
 986 static VALUE ruby_guestfs_config (VALUE gv, VALUE qemuparamv, VALUE qemuvaluev)
 987 {
 988   guestfs_h *g;
 989   Data_Get_Struct (gv, guestfs_h, g);
 990   if (!g)
 991     rb_raise (rb_eArgError, "%s: used handle after closing it", "config");
 992
 993   Check_Type (qemuparamv, T_STRING);
 994   const char *qemuparam = StringValueCStr (qemuparamv);
 995   if (!qemuparam)
 996     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
 997               "qemuparam", "config");
 998   const char *qemuvalue = !NIL_P (qemuvaluev) ? StringValueCStr (qemuvaluev) : NULL;
 999
1000   int r;
1001
1002   r = guestfs_config (g, qemuparam, qemuvalue);
1003   if (r == -1)
1004     rb_raise (e_Error, "%s", guestfs_last_error (g));
1005
1006   return Qnil;
1007 }
1008
1009 static VALUE ruby_guestfs_set_qemu (VALUE gv, VALUE qemuv)
1010 {
1011   guestfs_h *g;
1012   Data_Get_Struct (gv, guestfs_h, g);
1013   if (!g)
1014     rb_raise (rb_eArgError, "%s: used handle after closing it", "set_qemu");
1015
1016   Check_Type (qemuv, T_STRING);
1017   const char *qemu = StringValueCStr (qemuv);
1018   if (!qemu)
1019     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1020               "qemu", "set_qemu");
1021
1022   int r;
1023
1024   r = guestfs_set_qemu (g, qemu);
1025   if (r == -1)
1026     rb_raise (e_Error, "%s", guestfs_last_error (g));
1027
1028   return Qnil;
1029 }
1030
1031 static VALUE ruby_guestfs_get_qemu (VALUE gv)
1032 {
1033   guestfs_h *g;
1034   Data_Get_Struct (gv, guestfs_h, g);
1035   if (!g)
1036     rb_raise (rb_eArgError, "%s: used handle after closing it", "get_qemu");
1037
1038
1039   const char *r;
1040
1041   r = guestfs_get_qemu (g);
1042   if (r == NULL)
1043     rb_raise (e_Error, "%s", guestfs_last_error (g));
1044
1045   return rb_str_new2 (r);
1046 }
1047
1048 static VALUE ruby_guestfs_set_path (VALUE gv, VALUE pathv)
1049 {
1050   guestfs_h *g;
1051   Data_Get_Struct (gv, guestfs_h, g);
1052   if (!g)
1053     rb_raise (rb_eArgError, "%s: used handle after closing it", "set_path");
1054
1055   Check_Type (pathv, T_STRING);
1056   const char *path = StringValueCStr (pathv);
1057   if (!path)
1058     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1059               "path", "set_path");
1060
1061   int r;
1062
1063   r = guestfs_set_path (g, path);
1064   if (r == -1)
1065     rb_raise (e_Error, "%s", guestfs_last_error (g));
1066
1067   return Qnil;
1068 }
1069
1070 static VALUE ruby_guestfs_get_path (VALUE gv)
1071 {
1072   guestfs_h *g;
1073   Data_Get_Struct (gv, guestfs_h, g);
1074   if (!g)
1075     rb_raise (rb_eArgError, "%s: used handle after closing it", "get_path");
1076
1077
1078   const char *r;
1079
1080   r = guestfs_get_path (g);
1081   if (r == NULL)
1082     rb_raise (e_Error, "%s", guestfs_last_error (g));
1083
1084   return rb_str_new2 (r);
1085 }
1086
1087 static VALUE ruby_guestfs_set_append (VALUE gv, VALUE appendv)
1088 {
1089   guestfs_h *g;
1090   Data_Get_Struct (gv, guestfs_h, g);
1091   if (!g)
1092     rb_raise (rb_eArgError, "%s: used handle after closing it", "set_append");
1093
1094   Check_Type (appendv, T_STRING);
1095   const char *append = StringValueCStr (appendv);
1096   if (!append)
1097     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1098               "append", "set_append");
1099
1100   int r;
1101
1102   r = guestfs_set_append (g, append);
1103   if (r == -1)
1104     rb_raise (e_Error, "%s", guestfs_last_error (g));
1105
1106   return Qnil;
1107 }
1108
1109 static VALUE ruby_guestfs_get_append (VALUE gv)
1110 {
1111   guestfs_h *g;
1112   Data_Get_Struct (gv, guestfs_h, g);
1113   if (!g)
1114     rb_raise (rb_eArgError, "%s: used handle after closing it", "get_append");
1115
1116
1117   const char *r;
1118
1119   r = guestfs_get_append (g);
1120   if (r == NULL)
1121     rb_raise (e_Error, "%s", guestfs_last_error (g));
1122
1123   return rb_str_new2 (r);
1124 }
1125
1126 static VALUE ruby_guestfs_set_autosync (VALUE gv, VALUE autosyncv)
1127 {
1128   guestfs_h *g;
1129   Data_Get_Struct (gv, guestfs_h, g);
1130   if (!g)
1131     rb_raise (rb_eArgError, "%s: used handle after closing it", "set_autosync");
1132
1133   int autosync = RTEST (autosyncv);
1134
1135   int r;
1136
1137   r = guestfs_set_autosync (g, autosync);
1138   if (r == -1)
1139     rb_raise (e_Error, "%s", guestfs_last_error (g));
1140
1141   return Qnil;
1142 }
1143
1144 static VALUE ruby_guestfs_get_autosync (VALUE gv)
1145 {
1146   guestfs_h *g;
1147   Data_Get_Struct (gv, guestfs_h, g);
1148   if (!g)
1149     rb_raise (rb_eArgError, "%s: used handle after closing it", "get_autosync");
1150
1151
1152   int r;
1153
1154   r = guestfs_get_autosync (g);
1155   if (r == -1)
1156     rb_raise (e_Error, "%s", guestfs_last_error (g));
1157
1158   return INT2NUM (r);
1159 }
1160
1161 static VALUE ruby_guestfs_set_verbose (VALUE gv, VALUE verbosev)
1162 {
1163   guestfs_h *g;
1164   Data_Get_Struct (gv, guestfs_h, g);
1165   if (!g)
1166     rb_raise (rb_eArgError, "%s: used handle after closing it", "set_verbose");
1167
1168   int verbose = RTEST (verbosev);
1169
1170   int r;
1171
1172   r = guestfs_set_verbose (g, verbose);
1173   if (r == -1)
1174     rb_raise (e_Error, "%s", guestfs_last_error (g));
1175
1176   return Qnil;
1177 }
1178
1179 static VALUE ruby_guestfs_get_verbose (VALUE gv)
1180 {
1181   guestfs_h *g;
1182   Data_Get_Struct (gv, guestfs_h, g);
1183   if (!g)
1184     rb_raise (rb_eArgError, "%s: used handle after closing it", "get_verbose");
1185
1186
1187   int r;
1188
1189   r = guestfs_get_verbose (g);
1190   if (r == -1)
1191     rb_raise (e_Error, "%s", guestfs_last_error (g));
1192
1193   return INT2NUM (r);
1194 }
1195
1196 static VALUE ruby_guestfs_is_ready (VALUE gv)
1197 {
1198   guestfs_h *g;
1199   Data_Get_Struct (gv, guestfs_h, g);
1200   if (!g)
1201     rb_raise (rb_eArgError, "%s: used handle after closing it", "is_ready");
1202
1203
1204   int r;
1205
1206   r = guestfs_is_ready (g);
1207   if (r == -1)
1208     rb_raise (e_Error, "%s", guestfs_last_error (g));
1209
1210   return INT2NUM (r);
1211 }
1212
1213 static VALUE ruby_guestfs_is_config (VALUE gv)
1214 {
1215   guestfs_h *g;
1216   Data_Get_Struct (gv, guestfs_h, g);
1217   if (!g)
1218     rb_raise (rb_eArgError, "%s: used handle after closing it", "is_config");
1219
1220
1221   int r;
1222
1223   r = guestfs_is_config (g);
1224   if (r == -1)
1225     rb_raise (e_Error, "%s", guestfs_last_error (g));
1226
1227   return INT2NUM (r);
1228 }
1229
1230 static VALUE ruby_guestfs_is_launching (VALUE gv)
1231 {
1232   guestfs_h *g;
1233   Data_Get_Struct (gv, guestfs_h, g);
1234   if (!g)
1235     rb_raise (rb_eArgError, "%s: used handle after closing it", "is_launching");
1236
1237
1238   int r;
1239
1240   r = guestfs_is_launching (g);
1241   if (r == -1)
1242     rb_raise (e_Error, "%s", guestfs_last_error (g));
1243
1244   return INT2NUM (r);
1245 }
1246
1247 static VALUE ruby_guestfs_is_busy (VALUE gv)
1248 {
1249   guestfs_h *g;
1250   Data_Get_Struct (gv, guestfs_h, g);
1251   if (!g)
1252     rb_raise (rb_eArgError, "%s: used handle after closing it", "is_busy");
1253
1254
1255   int r;
1256
1257   r = guestfs_is_busy (g);
1258   if (r == -1)
1259     rb_raise (e_Error, "%s", guestfs_last_error (g));
1260
1261   return INT2NUM (r);
1262 }
1263
1264 static VALUE ruby_guestfs_get_state (VALUE gv)
1265 {
1266   guestfs_h *g;
1267   Data_Get_Struct (gv, guestfs_h, g);
1268   if (!g)
1269     rb_raise (rb_eArgError, "%s: used handle after closing it", "get_state");
1270
1271
1272   int r;
1273
1274   r = guestfs_get_state (g);
1275   if (r == -1)
1276     rb_raise (e_Error, "%s", guestfs_last_error (g));
1277
1278   return INT2NUM (r);
1279 }
1280
1281 static VALUE ruby_guestfs_set_busy (VALUE gv)
1282 {
1283   guestfs_h *g;
1284   Data_Get_Struct (gv, guestfs_h, g);
1285   if (!g)
1286     rb_raise (rb_eArgError, "%s: used handle after closing it", "set_busy");
1287
1288
1289   int r;
1290
1291   r = guestfs_set_busy (g);
1292   if (r == -1)
1293     rb_raise (e_Error, "%s", guestfs_last_error (g));
1294
1295   return Qnil;
1296 }
1297
1298 static VALUE ruby_guestfs_set_ready (VALUE gv)
1299 {
1300   guestfs_h *g;
1301   Data_Get_Struct (gv, guestfs_h, g);
1302   if (!g)
1303     rb_raise (rb_eArgError, "%s: used handle after closing it", "set_ready");
1304
1305
1306   int r;
1307
1308   r = guestfs_set_ready (g);
1309   if (r == -1)
1310     rb_raise (e_Error, "%s", guestfs_last_error (g));
1311
1312   return Qnil;
1313 }
1314
1315 static VALUE ruby_guestfs_end_busy (VALUE gv)
1316 {
1317   guestfs_h *g;
1318   Data_Get_Struct (gv, guestfs_h, g);
1319   if (!g)
1320     rb_raise (rb_eArgError, "%s: used handle after closing it", "end_busy");
1321
1322
1323   int r;
1324
1325   r = guestfs_end_busy (g);
1326   if (r == -1)
1327     rb_raise (e_Error, "%s", guestfs_last_error (g));
1328
1329   return Qnil;
1330 }
1331
1332 static VALUE ruby_guestfs_mount (VALUE gv, VALUE devicev, VALUE mountpointv)
1333 {
1334   guestfs_h *g;
1335   Data_Get_Struct (gv, guestfs_h, g);
1336   if (!g)
1337     rb_raise (rb_eArgError, "%s: used handle after closing it", "mount");
1338
1339   Check_Type (devicev, T_STRING);
1340   const char *device = StringValueCStr (devicev);
1341   if (!device)
1342     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1343               "device", "mount");
1344   Check_Type (mountpointv, T_STRING);
1345   const char *mountpoint = StringValueCStr (mountpointv);
1346   if (!mountpoint)
1347     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1348               "mountpoint", "mount");
1349
1350   int r;
1351
1352   r = guestfs_mount (g, device, mountpoint);
1353   if (r == -1)
1354     rb_raise (e_Error, "%s", guestfs_last_error (g));
1355
1356   return Qnil;
1357 }
1358
1359 static VALUE ruby_guestfs_sync (VALUE gv)
1360 {
1361   guestfs_h *g;
1362   Data_Get_Struct (gv, guestfs_h, g);
1363   if (!g)
1364     rb_raise (rb_eArgError, "%s: used handle after closing it", "sync");
1365
1366
1367   int r;
1368
1369   r = guestfs_sync (g);
1370   if (r == -1)
1371     rb_raise (e_Error, "%s", guestfs_last_error (g));
1372
1373   return Qnil;
1374 }
1375
1376 static VALUE ruby_guestfs_touch (VALUE gv, VALUE pathv)
1377 {
1378   guestfs_h *g;
1379   Data_Get_Struct (gv, guestfs_h, g);
1380   if (!g)
1381     rb_raise (rb_eArgError, "%s: used handle after closing it", "touch");
1382
1383   Check_Type (pathv, T_STRING);
1384   const char *path = StringValueCStr (pathv);
1385   if (!path)
1386     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1387               "path", "touch");
1388
1389   int r;
1390
1391   r = guestfs_touch (g, path);
1392   if (r == -1)
1393     rb_raise (e_Error, "%s", guestfs_last_error (g));
1394
1395   return Qnil;
1396 }
1397
1398 static VALUE ruby_guestfs_cat (VALUE gv, VALUE pathv)
1399 {
1400   guestfs_h *g;
1401   Data_Get_Struct (gv, guestfs_h, g);
1402   if (!g)
1403     rb_raise (rb_eArgError, "%s: used handle after closing it", "cat");
1404
1405   Check_Type (pathv, T_STRING);
1406   const char *path = StringValueCStr (pathv);
1407   if (!path)
1408     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1409               "path", "cat");
1410
1411   char *r;
1412
1413   r = guestfs_cat (g, path);
1414   if (r == NULL)
1415     rb_raise (e_Error, "%s", guestfs_last_error (g));
1416
1417   VALUE rv = rb_str_new2 (r);
1418   free (r);
1419   return rv;
1420 }
1421
1422 static VALUE ruby_guestfs_ll (VALUE gv, VALUE directoryv)
1423 {
1424   guestfs_h *g;
1425   Data_Get_Struct (gv, guestfs_h, g);
1426   if (!g)
1427     rb_raise (rb_eArgError, "%s: used handle after closing it", "ll");
1428
1429   Check_Type (directoryv, T_STRING);
1430   const char *directory = StringValueCStr (directoryv);
1431   if (!directory)
1432     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1433               "directory", "ll");
1434
1435   char *r;
1436
1437   r = guestfs_ll (g, directory);
1438   if (r == NULL)
1439     rb_raise (e_Error, "%s", guestfs_last_error (g));
1440
1441   VALUE rv = rb_str_new2 (r);
1442   free (r);
1443   return rv;
1444 }
1445
1446 static VALUE ruby_guestfs_ls (VALUE gv, VALUE directoryv)
1447 {
1448   guestfs_h *g;
1449   Data_Get_Struct (gv, guestfs_h, g);
1450   if (!g)
1451     rb_raise (rb_eArgError, "%s: used handle after closing it", "ls");
1452
1453   Check_Type (directoryv, T_STRING);
1454   const char *directory = StringValueCStr (directoryv);
1455   if (!directory)
1456     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1457               "directory", "ls");
1458
1459   char **r;
1460
1461   r = guestfs_ls (g, directory);
1462   if (r == NULL)
1463     rb_raise (e_Error, "%s", guestfs_last_error (g));
1464
1465   int i, len = 0;
1466   for (i = 0; r[i] != NULL; ++i) len++;
1467   VALUE rv = rb_ary_new2 (len);
1468   for (i = 0; r[i] != NULL; ++i) {
1469     rb_ary_push (rv, rb_str_new2 (r[i]));
1470     free (r[i]);
1471   }
1472   free (r);
1473   return rv;
1474 }
1475
1476 static VALUE ruby_guestfs_list_devices (VALUE gv)
1477 {
1478   guestfs_h *g;
1479   Data_Get_Struct (gv, guestfs_h, g);
1480   if (!g)
1481     rb_raise (rb_eArgError, "%s: used handle after closing it", "list_devices");
1482
1483
1484   char **r;
1485
1486   r = guestfs_list_devices (g);
1487   if (r == NULL)
1488     rb_raise (e_Error, "%s", guestfs_last_error (g));
1489
1490   int i, len = 0;
1491   for (i = 0; r[i] != NULL; ++i) len++;
1492   VALUE rv = rb_ary_new2 (len);
1493   for (i = 0; r[i] != NULL; ++i) {
1494     rb_ary_push (rv, rb_str_new2 (r[i]));
1495     free (r[i]);
1496   }
1497   free (r);
1498   return rv;
1499 }
1500
1501 static VALUE ruby_guestfs_list_partitions (VALUE gv)
1502 {
1503   guestfs_h *g;
1504   Data_Get_Struct (gv, guestfs_h, g);
1505   if (!g)
1506     rb_raise (rb_eArgError, "%s: used handle after closing it", "list_partitions");
1507
1508
1509   char **r;
1510
1511   r = guestfs_list_partitions (g);
1512   if (r == NULL)
1513     rb_raise (e_Error, "%s", guestfs_last_error (g));
1514
1515   int i, len = 0;
1516   for (i = 0; r[i] != NULL; ++i) len++;
1517   VALUE rv = rb_ary_new2 (len);
1518   for (i = 0; r[i] != NULL; ++i) {
1519     rb_ary_push (rv, rb_str_new2 (r[i]));
1520     free (r[i]);
1521   }
1522   free (r);
1523   return rv;
1524 }
1525
1526 static VALUE ruby_guestfs_pvs (VALUE gv)
1527 {
1528   guestfs_h *g;
1529   Data_Get_Struct (gv, guestfs_h, g);
1530   if (!g)
1531     rb_raise (rb_eArgError, "%s: used handle after closing it", "pvs");
1532
1533
1534   char **r;
1535
1536   r = guestfs_pvs (g);
1537   if (r == NULL)
1538     rb_raise (e_Error, "%s", guestfs_last_error (g));
1539
1540   int i, len = 0;
1541   for (i = 0; r[i] != NULL; ++i) len++;
1542   VALUE rv = rb_ary_new2 (len);
1543   for (i = 0; r[i] != NULL; ++i) {
1544     rb_ary_push (rv, rb_str_new2 (r[i]));
1545     free (r[i]);
1546   }
1547   free (r);
1548   return rv;
1549 }
1550
1551 static VALUE ruby_guestfs_vgs (VALUE gv)
1552 {
1553   guestfs_h *g;
1554   Data_Get_Struct (gv, guestfs_h, g);
1555   if (!g)
1556     rb_raise (rb_eArgError, "%s: used handle after closing it", "vgs");
1557
1558
1559   char **r;
1560
1561   r = guestfs_vgs (g);
1562   if (r == NULL)
1563     rb_raise (e_Error, "%s", guestfs_last_error (g));
1564
1565   int i, len = 0;
1566   for (i = 0; r[i] != NULL; ++i) len++;
1567   VALUE rv = rb_ary_new2 (len);
1568   for (i = 0; r[i] != NULL; ++i) {
1569     rb_ary_push (rv, rb_str_new2 (r[i]));
1570     free (r[i]);
1571   }
1572   free (r);
1573   return rv;
1574 }
1575
1576 static VALUE ruby_guestfs_lvs (VALUE gv)
1577 {
1578   guestfs_h *g;
1579   Data_Get_Struct (gv, guestfs_h, g);
1580   if (!g)
1581     rb_raise (rb_eArgError, "%s: used handle after closing it", "lvs");
1582
1583
1584   char **r;
1585
1586   r = guestfs_lvs (g);
1587   if (r == NULL)
1588     rb_raise (e_Error, "%s", guestfs_last_error (g));
1589
1590   int i, len = 0;
1591   for (i = 0; r[i] != NULL; ++i) len++;
1592   VALUE rv = rb_ary_new2 (len);
1593   for (i = 0; r[i] != NULL; ++i) {
1594     rb_ary_push (rv, rb_str_new2 (r[i]));
1595     free (r[i]);
1596   }
1597   free (r);
1598   return rv;
1599 }
1600
1601 static VALUE ruby_guestfs_pvs_full (VALUE gv)
1602 {
1603   guestfs_h *g;
1604   Data_Get_Struct (gv, guestfs_h, g);
1605   if (!g)
1606     rb_raise (rb_eArgError, "%s: used handle after closing it", "pvs_full");
1607
1608
1609   struct guestfs_lvm_pv_list *r;
1610
1611   r = guestfs_pvs_full (g);
1612   if (r == NULL)
1613     rb_raise (e_Error, "%s", guestfs_last_error (g));
1614
1615   VALUE rv = rb_ary_new2 (r->len);
1616   int i;
1617   for (i = 0; i < r->len; ++i) {
1618     VALUE hv = rb_hash_new ();
1619     rb_hash_aset (rv, rb_str_new2 ("pv_name"), rb_str_new2 (r->val[i].pv_name));
1620     rb_hash_aset (rv, rb_str_new2 ("pv_uuid"), rb_str_new (r->val[i].pv_uuid, 32));
1621     rb_hash_aset (rv, rb_str_new2 ("pv_fmt"), rb_str_new2 (r->val[i].pv_fmt));
1622     rb_hash_aset (rv, rb_str_new2 ("pv_size"), ULL2NUM (r->val[i].pv_size));
1623     rb_hash_aset (rv, rb_str_new2 ("dev_size"), ULL2NUM (r->val[i].dev_size));
1624     rb_hash_aset (rv, rb_str_new2 ("pv_free"), ULL2NUM (r->val[i].pv_free));
1625     rb_hash_aset (rv, rb_str_new2 ("pv_used"), ULL2NUM (r->val[i].pv_used));
1626     rb_hash_aset (rv, rb_str_new2 ("pv_attr"), rb_str_new2 (r->val[i].pv_attr));
1627     rb_hash_aset (rv, rb_str_new2 ("pv_pe_count"), ULL2NUM (r->val[i].pv_pe_count));
1628     rb_hash_aset (rv, rb_str_new2 ("pv_pe_alloc_count"), ULL2NUM (r->val[i].pv_pe_alloc_count));
1629     rb_hash_aset (rv, rb_str_new2 ("pv_tags"), rb_str_new2 (r->val[i].pv_tags));
1630     rb_hash_aset (rv, rb_str_new2 ("pe_start"), ULL2NUM (r->val[i].pe_start));
1631     rb_hash_aset (rv, rb_str_new2 ("pv_mda_count"), ULL2NUM (r->val[i].pv_mda_count));
1632     rb_hash_aset (rv, rb_str_new2 ("pv_mda_free"), ULL2NUM (r->val[i].pv_mda_free));
1633     rb_ary_push (rv, hv);
1634   }
1635   guestfs_free_lvm_pv_list (r);
1636   return rv;
1637 }
1638
1639 static VALUE ruby_guestfs_vgs_full (VALUE gv)
1640 {
1641   guestfs_h *g;
1642   Data_Get_Struct (gv, guestfs_h, g);
1643   if (!g)
1644     rb_raise (rb_eArgError, "%s: used handle after closing it", "vgs_full");
1645
1646
1647   struct guestfs_lvm_vg_list *r;
1648
1649   r = guestfs_vgs_full (g);
1650   if (r == NULL)
1651     rb_raise (e_Error, "%s", guestfs_last_error (g));
1652
1653   VALUE rv = rb_ary_new2 (r->len);
1654   int i;
1655   for (i = 0; i < r->len; ++i) {
1656     VALUE hv = rb_hash_new ();
1657     rb_hash_aset (rv, rb_str_new2 ("vg_name"), rb_str_new2 (r->val[i].vg_name));
1658     rb_hash_aset (rv, rb_str_new2 ("vg_uuid"), rb_str_new (r->val[i].vg_uuid, 32));
1659     rb_hash_aset (rv, rb_str_new2 ("vg_fmt"), rb_str_new2 (r->val[i].vg_fmt));
1660     rb_hash_aset (rv, rb_str_new2 ("vg_attr"), rb_str_new2 (r->val[i].vg_attr));
1661     rb_hash_aset (rv, rb_str_new2 ("vg_size"), ULL2NUM (r->val[i].vg_size));
1662     rb_hash_aset (rv, rb_str_new2 ("vg_free"), ULL2NUM (r->val[i].vg_free));
1663     rb_hash_aset (rv, rb_str_new2 ("vg_sysid"), rb_str_new2 (r->val[i].vg_sysid));
1664     rb_hash_aset (rv, rb_str_new2 ("vg_extent_size"), ULL2NUM (r->val[i].vg_extent_size));
1665     rb_hash_aset (rv, rb_str_new2 ("vg_extent_count"), ULL2NUM (r->val[i].vg_extent_count));
1666     rb_hash_aset (rv, rb_str_new2 ("vg_free_count"), ULL2NUM (r->val[i].vg_free_count));
1667     rb_hash_aset (rv, rb_str_new2 ("max_lv"), ULL2NUM (r->val[i].max_lv));
1668     rb_hash_aset (rv, rb_str_new2 ("max_pv"), ULL2NUM (r->val[i].max_pv));
1669     rb_hash_aset (rv, rb_str_new2 ("pv_count"), ULL2NUM (r->val[i].pv_count));
1670     rb_hash_aset (rv, rb_str_new2 ("lv_count"), ULL2NUM (r->val[i].lv_count));
1671     rb_hash_aset (rv, rb_str_new2 ("snap_count"), ULL2NUM (r->val[i].snap_count));
1672     rb_hash_aset (rv, rb_str_new2 ("vg_seqno"), ULL2NUM (r->val[i].vg_seqno));
1673     rb_hash_aset (rv, rb_str_new2 ("vg_tags"), rb_str_new2 (r->val[i].vg_tags));
1674     rb_hash_aset (rv, rb_str_new2 ("vg_mda_count"), ULL2NUM (r->val[i].vg_mda_count));
1675     rb_hash_aset (rv, rb_str_new2 ("vg_mda_free"), ULL2NUM (r->val[i].vg_mda_free));
1676     rb_ary_push (rv, hv);
1677   }
1678   guestfs_free_lvm_vg_list (r);
1679   return rv;
1680 }
1681
1682 static VALUE ruby_guestfs_lvs_full (VALUE gv)
1683 {
1684   guestfs_h *g;
1685   Data_Get_Struct (gv, guestfs_h, g);
1686   if (!g)
1687     rb_raise (rb_eArgError, "%s: used handle after closing it", "lvs_full");
1688
1689
1690   struct guestfs_lvm_lv_list *r;
1691
1692   r = guestfs_lvs_full (g);
1693   if (r == NULL)
1694     rb_raise (e_Error, "%s", guestfs_last_error (g));
1695
1696   VALUE rv = rb_ary_new2 (r->len);
1697   int i;
1698   for (i = 0; i < r->len; ++i) {
1699     VALUE hv = rb_hash_new ();
1700     rb_hash_aset (rv, rb_str_new2 ("lv_name"), rb_str_new2 (r->val[i].lv_name));
1701     rb_hash_aset (rv, rb_str_new2 ("lv_uuid"), rb_str_new (r->val[i].lv_uuid, 32));
1702     rb_hash_aset (rv, rb_str_new2 ("lv_attr"), rb_str_new2 (r->val[i].lv_attr));
1703     rb_hash_aset (rv, rb_str_new2 ("lv_major"), ULL2NUM (r->val[i].lv_major));
1704     rb_hash_aset (rv, rb_str_new2 ("lv_minor"), ULL2NUM (r->val[i].lv_minor));
1705     rb_hash_aset (rv, rb_str_new2 ("lv_kernel_major"), ULL2NUM (r->val[i].lv_kernel_major));
1706     rb_hash_aset (rv, rb_str_new2 ("lv_kernel_minor"), ULL2NUM (r->val[i].lv_kernel_minor));
1707     rb_hash_aset (rv, rb_str_new2 ("lv_size"), ULL2NUM (r->val[i].lv_size));
1708     rb_hash_aset (rv, rb_str_new2 ("seg_count"), ULL2NUM (r->val[i].seg_count));
1709     rb_hash_aset (rv, rb_str_new2 ("origin"), rb_str_new2 (r->val[i].origin));
1710     rb_hash_aset (rv, rb_str_new2 ("snap_percent"), rb_dbl2big (r->val[i].snap_percent));
1711     rb_hash_aset (rv, rb_str_new2 ("copy_percent"), rb_dbl2big (r->val[i].copy_percent));
1712     rb_hash_aset (rv, rb_str_new2 ("move_pv"), rb_str_new2 (r->val[i].move_pv));
1713     rb_hash_aset (rv, rb_str_new2 ("lv_tags"), rb_str_new2 (r->val[i].lv_tags));
1714     rb_hash_aset (rv, rb_str_new2 ("mirror_log"), rb_str_new2 (r->val[i].mirror_log));
1715     rb_hash_aset (rv, rb_str_new2 ("modules"), rb_str_new2 (r->val[i].modules));
1716     rb_ary_push (rv, hv);
1717   }
1718   guestfs_free_lvm_lv_list (r);
1719   return rv;
1720 }
1721
1722 static VALUE ruby_guestfs_read_lines (VALUE gv, VALUE pathv)
1723 {
1724   guestfs_h *g;
1725   Data_Get_Struct (gv, guestfs_h, g);
1726   if (!g)
1727     rb_raise (rb_eArgError, "%s: used handle after closing it", "read_lines");
1728
1729   Check_Type (pathv, T_STRING);
1730   const char *path = StringValueCStr (pathv);
1731   if (!path)
1732     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1733               "path", "read_lines");
1734
1735   char **r;
1736
1737   r = guestfs_read_lines (g, path);
1738   if (r == NULL)
1739     rb_raise (e_Error, "%s", guestfs_last_error (g));
1740
1741   int i, len = 0;
1742   for (i = 0; r[i] != NULL; ++i) len++;
1743   VALUE rv = rb_ary_new2 (len);
1744   for (i = 0; r[i] != NULL; ++i) {
1745     rb_ary_push (rv, rb_str_new2 (r[i]));
1746     free (r[i]);
1747   }
1748   free (r);
1749   return rv;
1750 }
1751
1752 static VALUE ruby_guestfs_aug_init (VALUE gv, VALUE rootv, VALUE flagsv)
1753 {
1754   guestfs_h *g;
1755   Data_Get_Struct (gv, guestfs_h, g);
1756   if (!g)
1757     rb_raise (rb_eArgError, "%s: used handle after closing it", "aug_init");
1758
1759   Check_Type (rootv, T_STRING);
1760   const char *root = StringValueCStr (rootv);
1761   if (!root)
1762     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1763               "root", "aug_init");
1764   int flags = NUM2INT (flagsv);
1765
1766   int r;
1767
1768   r = guestfs_aug_init (g, root, flags);
1769   if (r == -1)
1770     rb_raise (e_Error, "%s", guestfs_last_error (g));
1771
1772   return Qnil;
1773 }
1774
1775 static VALUE ruby_guestfs_aug_close (VALUE gv)
1776 {
1777   guestfs_h *g;
1778   Data_Get_Struct (gv, guestfs_h, g);
1779   if (!g)
1780     rb_raise (rb_eArgError, "%s: used handle after closing it", "aug_close");
1781
1782
1783   int r;
1784
1785   r = guestfs_aug_close (g);
1786   if (r == -1)
1787     rb_raise (e_Error, "%s", guestfs_last_error (g));
1788
1789   return Qnil;
1790 }
1791
1792 static VALUE ruby_guestfs_aug_defvar (VALUE gv, VALUE namev, VALUE exprv)
1793 {
1794   guestfs_h *g;
1795   Data_Get_Struct (gv, guestfs_h, g);
1796   if (!g)
1797     rb_raise (rb_eArgError, "%s: used handle after closing it", "aug_defvar");
1798
1799   Check_Type (namev, T_STRING);
1800   const char *name = StringValueCStr (namev);
1801   if (!name)
1802     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1803               "name", "aug_defvar");
1804   const char *expr = !NIL_P (exprv) ? StringValueCStr (exprv) : NULL;
1805
1806   int r;
1807
1808   r = guestfs_aug_defvar (g, name, expr);
1809   if (r == -1)
1810     rb_raise (e_Error, "%s", guestfs_last_error (g));
1811
1812   return INT2NUM (r);
1813 }
1814
1815 static VALUE ruby_guestfs_aug_defnode (VALUE gv, VALUE namev, VALUE exprv, VALUE valv)
1816 {
1817   guestfs_h *g;
1818   Data_Get_Struct (gv, guestfs_h, g);
1819   if (!g)
1820     rb_raise (rb_eArgError, "%s: used handle after closing it", "aug_defnode");
1821
1822   Check_Type (namev, T_STRING);
1823   const char *name = StringValueCStr (namev);
1824   if (!name)
1825     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1826               "name", "aug_defnode");
1827   Check_Type (exprv, T_STRING);
1828   const char *expr = StringValueCStr (exprv);
1829   if (!expr)
1830     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1831               "expr", "aug_defnode");
1832   Check_Type (valv, T_STRING);
1833   const char *val = StringValueCStr (valv);
1834   if (!val)
1835     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1836               "val", "aug_defnode");
1837
1838   struct guestfs_int_bool *r;
1839
1840   r = guestfs_aug_defnode (g, name, expr, val);
1841   if (r == NULL)
1842     rb_raise (e_Error, "%s", guestfs_last_error (g));
1843
1844   VALUE rv = rb_ary_new2 (2);
1845   rb_ary_push (rv, INT2NUM (r->i));
1846   rb_ary_push (rv, INT2NUM (r->b));
1847   guestfs_free_int_bool (r);
1848   return rv;
1849 }
1850
1851 static VALUE ruby_guestfs_aug_get (VALUE gv, VALUE pathv)
1852 {
1853   guestfs_h *g;
1854   Data_Get_Struct (gv, guestfs_h, g);
1855   if (!g)
1856     rb_raise (rb_eArgError, "%s: used handle after closing it", "aug_get");
1857
1858   Check_Type (pathv, T_STRING);
1859   const char *path = StringValueCStr (pathv);
1860   if (!path)
1861     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1862               "path", "aug_get");
1863
1864   char *r;
1865
1866   r = guestfs_aug_get (g, path);
1867   if (r == NULL)
1868     rb_raise (e_Error, "%s", guestfs_last_error (g));
1869
1870   VALUE rv = rb_str_new2 (r);
1871   free (r);
1872   return rv;
1873 }
1874
1875 static VALUE ruby_guestfs_aug_set (VALUE gv, VALUE pathv, VALUE valv)
1876 {
1877   guestfs_h *g;
1878   Data_Get_Struct (gv, guestfs_h, g);
1879   if (!g)
1880     rb_raise (rb_eArgError, "%s: used handle after closing it", "aug_set");
1881
1882   Check_Type (pathv, T_STRING);
1883   const char *path = StringValueCStr (pathv);
1884   if (!path)
1885     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1886               "path", "aug_set");
1887   Check_Type (valv, T_STRING);
1888   const char *val = StringValueCStr (valv);
1889   if (!val)
1890     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1891               "val", "aug_set");
1892
1893   int r;
1894
1895   r = guestfs_aug_set (g, path, val);
1896   if (r == -1)
1897     rb_raise (e_Error, "%s", guestfs_last_error (g));
1898
1899   return Qnil;
1900 }
1901
1902 static VALUE ruby_guestfs_aug_insert (VALUE gv, VALUE pathv, VALUE labelv, VALUE beforev)
1903 {
1904   guestfs_h *g;
1905   Data_Get_Struct (gv, guestfs_h, g);
1906   if (!g)
1907     rb_raise (rb_eArgError, "%s: used handle after closing it", "aug_insert");
1908
1909   Check_Type (pathv, T_STRING);
1910   const char *path = StringValueCStr (pathv);
1911   if (!path)
1912     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1913               "path", "aug_insert");
1914   Check_Type (labelv, T_STRING);
1915   const char *label = StringValueCStr (labelv);
1916   if (!label)
1917     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1918               "label", "aug_insert");
1919   int before = RTEST (beforev);
1920
1921   int r;
1922
1923   r = guestfs_aug_insert (g, path, label, before);
1924   if (r == -1)
1925     rb_raise (e_Error, "%s", guestfs_last_error (g));
1926
1927   return Qnil;
1928 }
1929
1930 static VALUE ruby_guestfs_aug_rm (VALUE gv, VALUE pathv)
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", "aug_rm");
1936
1937   Check_Type (pathv, T_STRING);
1938   const char *path = StringValueCStr (pathv);
1939   if (!path)
1940     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1941               "path", "aug_rm");
1942
1943   int r;
1944
1945   r = guestfs_aug_rm (g, path);
1946   if (r == -1)
1947     rb_raise (e_Error, "%s", guestfs_last_error (g));
1948
1949   return INT2NUM (r);
1950 }
1951
1952 static VALUE ruby_guestfs_aug_mv (VALUE gv, VALUE srcv, VALUE destv)
1953 {
1954   guestfs_h *g;
1955   Data_Get_Struct (gv, guestfs_h, g);
1956   if (!g)
1957     rb_raise (rb_eArgError, "%s: used handle after closing it", "aug_mv");
1958
1959   Check_Type (srcv, T_STRING);
1960   const char *src = StringValueCStr (srcv);
1961   if (!src)
1962     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1963               "src", "aug_mv");
1964   Check_Type (destv, T_STRING);
1965   const char *dest = StringValueCStr (destv);
1966   if (!dest)
1967     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1968               "dest", "aug_mv");
1969
1970   int r;
1971
1972   r = guestfs_aug_mv (g, src, dest);
1973   if (r == -1)
1974     rb_raise (e_Error, "%s", guestfs_last_error (g));
1975
1976   return Qnil;
1977 }
1978
1979 static VALUE ruby_guestfs_aug_match (VALUE gv, VALUE pathv)
1980 {
1981   guestfs_h *g;
1982   Data_Get_Struct (gv, guestfs_h, g);
1983   if (!g)
1984     rb_raise (rb_eArgError, "%s: used handle after closing it", "aug_match");
1985
1986   Check_Type (pathv, T_STRING);
1987   const char *path = StringValueCStr (pathv);
1988   if (!path)
1989     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1990               "path", "aug_match");
1991
1992   char **r;
1993
1994   r = guestfs_aug_match (g, path);
1995   if (r == NULL)
1996     rb_raise (e_Error, "%s", guestfs_last_error (g));
1997
1998   int i, len = 0;
1999   for (i = 0; r[i] != NULL; ++i) len++;
2000   VALUE rv = rb_ary_new2 (len);
2001   for (i = 0; r[i] != NULL; ++i) {
2002     rb_ary_push (rv, rb_str_new2 (r[i]));
2003     free (r[i]);
2004   }
2005   free (r);
2006   return rv;
2007 }
2008
2009 static VALUE ruby_guestfs_aug_save (VALUE gv)
2010 {
2011   guestfs_h *g;
2012   Data_Get_Struct (gv, guestfs_h, g);
2013   if (!g)
2014     rb_raise (rb_eArgError, "%s: used handle after closing it", "aug_save");
2015
2016
2017   int r;
2018
2019   r = guestfs_aug_save (g);
2020   if (r == -1)
2021     rb_raise (e_Error, "%s", guestfs_last_error (g));
2022
2023   return Qnil;
2024 }
2025
2026 static VALUE ruby_guestfs_aug_load (VALUE gv)
2027 {
2028   guestfs_h *g;
2029   Data_Get_Struct (gv, guestfs_h, g);
2030   if (!g)
2031     rb_raise (rb_eArgError, "%s: used handle after closing it", "aug_load");
2032
2033
2034   int r;
2035
2036   r = guestfs_aug_load (g);
2037   if (r == -1)
2038     rb_raise (e_Error, "%s", guestfs_last_error (g));
2039
2040   return Qnil;
2041 }
2042
2043 static VALUE ruby_guestfs_aug_ls (VALUE gv, VALUE pathv)
2044 {
2045   guestfs_h *g;
2046   Data_Get_Struct (gv, guestfs_h, g);
2047   if (!g)
2048     rb_raise (rb_eArgError, "%s: used handle after closing it", "aug_ls");
2049
2050   Check_Type (pathv, T_STRING);
2051   const char *path = StringValueCStr (pathv);
2052   if (!path)
2053     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2054               "path", "aug_ls");
2055
2056   char **r;
2057
2058   r = guestfs_aug_ls (g, path);
2059   if (r == NULL)
2060     rb_raise (e_Error, "%s", guestfs_last_error (g));
2061
2062   int i, len = 0;
2063   for (i = 0; r[i] != NULL; ++i) len++;
2064   VALUE rv = rb_ary_new2 (len);
2065   for (i = 0; r[i] != NULL; ++i) {
2066     rb_ary_push (rv, rb_str_new2 (r[i]));
2067     free (r[i]);
2068   }
2069   free (r);
2070   return rv;
2071 }
2072
2073 static VALUE ruby_guestfs_rm (VALUE gv, VALUE pathv)
2074 {
2075   guestfs_h *g;
2076   Data_Get_Struct (gv, guestfs_h, g);
2077   if (!g)
2078     rb_raise (rb_eArgError, "%s: used handle after closing it", "rm");
2079
2080   Check_Type (pathv, T_STRING);
2081   const char *path = StringValueCStr (pathv);
2082   if (!path)
2083     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2084               "path", "rm");
2085
2086   int r;
2087
2088   r = guestfs_rm (g, path);
2089   if (r == -1)
2090     rb_raise (e_Error, "%s", guestfs_last_error (g));
2091
2092   return Qnil;
2093 }
2094
2095 static VALUE ruby_guestfs_rmdir (VALUE gv, VALUE pathv)
2096 {
2097   guestfs_h *g;
2098   Data_Get_Struct (gv, guestfs_h, g);
2099   if (!g)
2100     rb_raise (rb_eArgError, "%s: used handle after closing it", "rmdir");
2101
2102   Check_Type (pathv, T_STRING);
2103   const char *path = StringValueCStr (pathv);
2104   if (!path)
2105     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2106               "path", "rmdir");
2107
2108   int r;
2109
2110   r = guestfs_rmdir (g, path);
2111   if (r == -1)
2112     rb_raise (e_Error, "%s", guestfs_last_error (g));
2113
2114   return Qnil;
2115 }
2116
2117 static VALUE ruby_guestfs_rm_rf (VALUE gv, VALUE pathv)
2118 {
2119   guestfs_h *g;
2120   Data_Get_Struct (gv, guestfs_h, g);
2121   if (!g)
2122     rb_raise (rb_eArgError, "%s: used handle after closing it", "rm_rf");
2123
2124   Check_Type (pathv, T_STRING);
2125   const char *path = StringValueCStr (pathv);
2126   if (!path)
2127     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2128               "path", "rm_rf");
2129
2130   int r;
2131
2132   r = guestfs_rm_rf (g, path);
2133   if (r == -1)
2134     rb_raise (e_Error, "%s", guestfs_last_error (g));
2135
2136   return Qnil;
2137 }
2138
2139 static VALUE ruby_guestfs_mkdir (VALUE gv, VALUE pathv)
2140 {
2141   guestfs_h *g;
2142   Data_Get_Struct (gv, guestfs_h, g);
2143   if (!g)
2144     rb_raise (rb_eArgError, "%s: used handle after closing it", "mkdir");
2145
2146   Check_Type (pathv, T_STRING);
2147   const char *path = StringValueCStr (pathv);
2148   if (!path)
2149     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2150               "path", "mkdir");
2151
2152   int r;
2153
2154   r = guestfs_mkdir (g, path);
2155   if (r == -1)
2156     rb_raise (e_Error, "%s", guestfs_last_error (g));
2157
2158   return Qnil;
2159 }
2160
2161 static VALUE ruby_guestfs_mkdir_p (VALUE gv, VALUE pathv)
2162 {
2163   guestfs_h *g;
2164   Data_Get_Struct (gv, guestfs_h, g);
2165   if (!g)
2166     rb_raise (rb_eArgError, "%s: used handle after closing it", "mkdir_p");
2167
2168   Check_Type (pathv, T_STRING);
2169   const char *path = StringValueCStr (pathv);
2170   if (!path)
2171     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2172               "path", "mkdir_p");
2173
2174   int r;
2175
2176   r = guestfs_mkdir_p (g, path);
2177   if (r == -1)
2178     rb_raise (e_Error, "%s", guestfs_last_error (g));
2179
2180   return Qnil;
2181 }
2182
2183 static VALUE ruby_guestfs_chmod (VALUE gv, VALUE modev, VALUE pathv)
2184 {
2185   guestfs_h *g;
2186   Data_Get_Struct (gv, guestfs_h, g);
2187   if (!g)
2188     rb_raise (rb_eArgError, "%s: used handle after closing it", "chmod");
2189
2190   int mode = NUM2INT (modev);
2191   Check_Type (pathv, T_STRING);
2192   const char *path = StringValueCStr (pathv);
2193   if (!path)
2194     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2195               "path", "chmod");
2196
2197   int r;
2198
2199   r = guestfs_chmod (g, mode, path);
2200   if (r == -1)
2201     rb_raise (e_Error, "%s", guestfs_last_error (g));
2202
2203   return Qnil;
2204 }
2205
2206 static VALUE ruby_guestfs_chown (VALUE gv, VALUE ownerv, VALUE groupv, VALUE pathv)
2207 {
2208   guestfs_h *g;
2209   Data_Get_Struct (gv, guestfs_h, g);
2210   if (!g)
2211     rb_raise (rb_eArgError, "%s: used handle after closing it", "chown");
2212
2213   int owner = NUM2INT (ownerv);
2214   int group = NUM2INT (groupv);
2215   Check_Type (pathv, T_STRING);
2216   const char *path = StringValueCStr (pathv);
2217   if (!path)
2218     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2219               "path", "chown");
2220
2221   int r;
2222
2223   r = guestfs_chown (g, owner, group, path);
2224   if (r == -1)
2225     rb_raise (e_Error, "%s", guestfs_last_error (g));
2226
2227   return Qnil;
2228 }
2229
2230 static VALUE ruby_guestfs_exists (VALUE gv, VALUE pathv)
2231 {
2232   guestfs_h *g;
2233   Data_Get_Struct (gv, guestfs_h, g);
2234   if (!g)
2235     rb_raise (rb_eArgError, "%s: used handle after closing it", "exists");
2236
2237   Check_Type (pathv, T_STRING);
2238   const char *path = StringValueCStr (pathv);
2239   if (!path)
2240     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2241               "path", "exists");
2242
2243   int r;
2244
2245   r = guestfs_exists (g, path);
2246   if (r == -1)
2247     rb_raise (e_Error, "%s", guestfs_last_error (g));
2248
2249   return INT2NUM (r);
2250 }
2251
2252 static VALUE ruby_guestfs_is_file (VALUE gv, VALUE pathv)
2253 {
2254   guestfs_h *g;
2255   Data_Get_Struct (gv, guestfs_h, g);
2256   if (!g)
2257     rb_raise (rb_eArgError, "%s: used handle after closing it", "is_file");
2258
2259   Check_Type (pathv, T_STRING);
2260   const char *path = StringValueCStr (pathv);
2261   if (!path)
2262     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2263               "path", "is_file");
2264
2265   int r;
2266
2267   r = guestfs_is_file (g, path);
2268   if (r == -1)
2269     rb_raise (e_Error, "%s", guestfs_last_error (g));
2270
2271   return INT2NUM (r);
2272 }
2273
2274 static VALUE ruby_guestfs_is_dir (VALUE gv, VALUE pathv)
2275 {
2276   guestfs_h *g;
2277   Data_Get_Struct (gv, guestfs_h, g);
2278   if (!g)
2279     rb_raise (rb_eArgError, "%s: used handle after closing it", "is_dir");
2280
2281   Check_Type (pathv, T_STRING);
2282   const char *path = StringValueCStr (pathv);
2283   if (!path)
2284     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2285               "path", "is_dir");
2286
2287   int r;
2288
2289   r = guestfs_is_dir (g, path);
2290   if (r == -1)
2291     rb_raise (e_Error, "%s", guestfs_last_error (g));
2292
2293   return INT2NUM (r);
2294 }
2295
2296 static VALUE ruby_guestfs_pvcreate (VALUE gv, VALUE devicev)
2297 {
2298   guestfs_h *g;
2299   Data_Get_Struct (gv, guestfs_h, g);
2300   if (!g)
2301     rb_raise (rb_eArgError, "%s: used handle after closing it", "pvcreate");
2302
2303   Check_Type (devicev, T_STRING);
2304   const char *device = StringValueCStr (devicev);
2305   if (!device)
2306     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2307               "device", "pvcreate");
2308
2309   int r;
2310
2311   r = guestfs_pvcreate (g, device);
2312   if (r == -1)
2313     rb_raise (e_Error, "%s", guestfs_last_error (g));
2314
2315   return Qnil;
2316 }
2317
2318 static VALUE ruby_guestfs_vgcreate (VALUE gv, VALUE volgroupv, VALUE physvolsv)
2319 {
2320   guestfs_h *g;
2321   Data_Get_Struct (gv, guestfs_h, g);
2322   if (!g)
2323     rb_raise (rb_eArgError, "%s: used handle after closing it", "vgcreate");
2324
2325   Check_Type (volgroupv, T_STRING);
2326   const char *volgroup = StringValueCStr (volgroupv);
2327   if (!volgroup)
2328     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2329               "volgroup", "vgcreate");
2330   char **physvols;
2331   Check_Type (physvolsv, T_ARRAY);
2332   {
2333     int i, len;
2334     len = RARRAY_LEN (physvolsv);
2335     physvols = guestfs_safe_malloc (g, sizeof (char *) * (len+1));
2336     for (i = 0; i < len; ++i) {
2337       VALUE v = rb_ary_entry (physvolsv, i);
2338       physvols[i] = StringValueCStr (v);
2339     }
2340     physvols[len] = NULL;
2341   }
2342
2343   int r;
2344
2345   r = guestfs_vgcreate (g, volgroup, physvols);
2346   free (physvols);
2347   if (r == -1)
2348     rb_raise (e_Error, "%s", guestfs_last_error (g));
2349
2350   return Qnil;
2351 }
2352
2353 static VALUE ruby_guestfs_lvcreate (VALUE gv, VALUE logvolv, VALUE volgroupv, VALUE mbytesv)
2354 {
2355   guestfs_h *g;
2356   Data_Get_Struct (gv, guestfs_h, g);
2357   if (!g)
2358     rb_raise (rb_eArgError, "%s: used handle after closing it", "lvcreate");
2359
2360   Check_Type (logvolv, T_STRING);
2361   const char *logvol = StringValueCStr (logvolv);
2362   if (!logvol)
2363     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2364               "logvol", "lvcreate");
2365   Check_Type (volgroupv, T_STRING);
2366   const char *volgroup = StringValueCStr (volgroupv);
2367   if (!volgroup)
2368     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2369               "volgroup", "lvcreate");
2370   int mbytes = NUM2INT (mbytesv);
2371
2372   int r;
2373
2374   r = guestfs_lvcreate (g, logvol, volgroup, mbytes);
2375   if (r == -1)
2376     rb_raise (e_Error, "%s", guestfs_last_error (g));
2377
2378   return Qnil;
2379 }
2380
2381 static VALUE ruby_guestfs_mkfs (VALUE gv, VALUE fstypev, VALUE devicev)
2382 {
2383   guestfs_h *g;
2384   Data_Get_Struct (gv, guestfs_h, g);
2385   if (!g)
2386     rb_raise (rb_eArgError, "%s: used handle after closing it", "mkfs");
2387
2388   Check_Type (fstypev, T_STRING);
2389   const char *fstype = StringValueCStr (fstypev);
2390   if (!fstype)
2391     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2392               "fstype", "mkfs");
2393   Check_Type (devicev, T_STRING);
2394   const char *device = StringValueCStr (devicev);
2395   if (!device)
2396     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2397               "device", "mkfs");
2398
2399   int r;
2400
2401   r = guestfs_mkfs (g, fstype, device);
2402   if (r == -1)
2403     rb_raise (e_Error, "%s", guestfs_last_error (g));
2404
2405   return Qnil;
2406 }
2407
2408 static VALUE ruby_guestfs_sfdisk (VALUE gv, VALUE devicev, VALUE cylsv, VALUE headsv, VALUE sectorsv, VALUE linesv)
2409 {
2410   guestfs_h *g;
2411   Data_Get_Struct (gv, guestfs_h, g);
2412   if (!g)
2413     rb_raise (rb_eArgError, "%s: used handle after closing it", "sfdisk");
2414
2415   Check_Type (devicev, T_STRING);
2416   const char *device = StringValueCStr (devicev);
2417   if (!device)
2418     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2419               "device", "sfdisk");
2420   int cyls = NUM2INT (cylsv);
2421   int heads = NUM2INT (headsv);
2422   int sectors = NUM2INT (sectorsv);
2423   char **lines;
2424   Check_Type (linesv, T_ARRAY);
2425   {
2426     int i, len;
2427     len = RARRAY_LEN (linesv);
2428     lines = guestfs_safe_malloc (g, sizeof (char *) * (len+1));
2429     for (i = 0; i < len; ++i) {
2430       VALUE v = rb_ary_entry (linesv, i);
2431       lines[i] = StringValueCStr (v);
2432     }
2433     lines[len] = NULL;
2434   }
2435
2436   int r;
2437
2438   r = guestfs_sfdisk (g, device, cyls, heads, sectors, lines);
2439   free (lines);
2440   if (r == -1)
2441     rb_raise (e_Error, "%s", guestfs_last_error (g));
2442
2443   return Qnil;
2444 }
2445
2446 static VALUE ruby_guestfs_write_file (VALUE gv, VALUE pathv, VALUE contentv, VALUE sizev)
2447 {
2448   guestfs_h *g;
2449   Data_Get_Struct (gv, guestfs_h, g);
2450   if (!g)
2451     rb_raise (rb_eArgError, "%s: used handle after closing it", "write_file");
2452
2453   Check_Type (pathv, T_STRING);
2454   const char *path = StringValueCStr (pathv);
2455   if (!path)
2456     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2457               "path", "write_file");
2458   Check_Type (contentv, T_STRING);
2459   const char *content = StringValueCStr (contentv);
2460   if (!content)
2461     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2462               "content", "write_file");
2463   int size = NUM2INT (sizev);
2464
2465   int r;
2466
2467   r = guestfs_write_file (g, path, content, size);
2468   if (r == -1)
2469     rb_raise (e_Error, "%s", guestfs_last_error (g));
2470
2471   return Qnil;
2472 }
2473
2474 static VALUE ruby_guestfs_umount (VALUE gv, VALUE pathordevicev)
2475 {
2476   guestfs_h *g;
2477   Data_Get_Struct (gv, guestfs_h, g);
2478   if (!g)
2479     rb_raise (rb_eArgError, "%s: used handle after closing it", "umount");
2480
2481   Check_Type (pathordevicev, T_STRING);
2482   const char *pathordevice = StringValueCStr (pathordevicev);
2483   if (!pathordevice)
2484     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2485               "pathordevice", "umount");
2486
2487   int r;
2488
2489   r = guestfs_umount (g, pathordevice);
2490   if (r == -1)
2491     rb_raise (e_Error, "%s", guestfs_last_error (g));
2492
2493   return Qnil;
2494 }
2495
2496 static VALUE ruby_guestfs_mounts (VALUE gv)
2497 {
2498   guestfs_h *g;
2499   Data_Get_Struct (gv, guestfs_h, g);
2500   if (!g)
2501     rb_raise (rb_eArgError, "%s: used handle after closing it", "mounts");
2502
2503
2504   char **r;
2505
2506   r = guestfs_mounts (g);
2507   if (r == NULL)
2508     rb_raise (e_Error, "%s", guestfs_last_error (g));
2509
2510   int i, len = 0;
2511   for (i = 0; r[i] != NULL; ++i) len++;
2512   VALUE rv = rb_ary_new2 (len);
2513   for (i = 0; r[i] != NULL; ++i) {
2514     rb_ary_push (rv, rb_str_new2 (r[i]));
2515     free (r[i]);
2516   }
2517   free (r);
2518   return rv;
2519 }
2520
2521 static VALUE ruby_guestfs_umount_all (VALUE gv)
2522 {
2523   guestfs_h *g;
2524   Data_Get_Struct (gv, guestfs_h, g);
2525   if (!g)
2526     rb_raise (rb_eArgError, "%s: used handle after closing it", "umount_all");
2527
2528
2529   int r;
2530
2531   r = guestfs_umount_all (g);
2532   if (r == -1)
2533     rb_raise (e_Error, "%s", guestfs_last_error (g));
2534
2535   return Qnil;
2536 }
2537
2538 static VALUE ruby_guestfs_lvm_remove_all (VALUE gv)
2539 {
2540   guestfs_h *g;
2541   Data_Get_Struct (gv, guestfs_h, g);
2542   if (!g)
2543     rb_raise (rb_eArgError, "%s: used handle after closing it", "lvm_remove_all");
2544
2545
2546   int r;
2547
2548   r = guestfs_lvm_remove_all (g);
2549   if (r == -1)
2550     rb_raise (e_Error, "%s", guestfs_last_error (g));
2551
2552   return Qnil;
2553 }
2554
2555 static VALUE ruby_guestfs_file (VALUE gv, VALUE pathv)
2556 {
2557   guestfs_h *g;
2558   Data_Get_Struct (gv, guestfs_h, g);
2559   if (!g)
2560     rb_raise (rb_eArgError, "%s: used handle after closing it", "file");
2561
2562   Check_Type (pathv, T_STRING);
2563   const char *path = StringValueCStr (pathv);
2564   if (!path)
2565     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2566               "path", "file");
2567
2568   char *r;
2569
2570   r = guestfs_file (g, path);
2571   if (r == NULL)
2572     rb_raise (e_Error, "%s", guestfs_last_error (g));
2573
2574   VALUE rv = rb_str_new2 (r);
2575   free (r);
2576   return rv;
2577 }
2578
2579 static VALUE ruby_guestfs_command (VALUE gv, VALUE argumentsv)
2580 {
2581   guestfs_h *g;
2582   Data_Get_Struct (gv, guestfs_h, g);
2583   if (!g)
2584     rb_raise (rb_eArgError, "%s: used handle after closing it", "command");
2585
2586   char **arguments;
2587   Check_Type (argumentsv, T_ARRAY);
2588   {
2589     int i, len;
2590     len = RARRAY_LEN (argumentsv);
2591     arguments = guestfs_safe_malloc (g, sizeof (char *) * (len+1));
2592     for (i = 0; i < len; ++i) {
2593       VALUE v = rb_ary_entry (argumentsv, i);
2594       arguments[i] = StringValueCStr (v);
2595     }
2596     arguments[len] = NULL;
2597   }
2598
2599   char *r;
2600
2601   r = guestfs_command (g, arguments);
2602   free (arguments);
2603   if (r == NULL)
2604     rb_raise (e_Error, "%s", guestfs_last_error (g));
2605
2606   VALUE rv = rb_str_new2 (r);
2607   free (r);
2608   return rv;
2609 }
2610
2611 static VALUE ruby_guestfs_command_lines (VALUE gv, VALUE argumentsv)
2612 {
2613   guestfs_h *g;
2614   Data_Get_Struct (gv, guestfs_h, g);
2615   if (!g)
2616     rb_raise (rb_eArgError, "%s: used handle after closing it", "command_lines");
2617
2618   char **arguments;
2619   Check_Type (argumentsv, T_ARRAY);
2620   {
2621     int i, len;
2622     len = RARRAY_LEN (argumentsv);
2623     arguments = guestfs_safe_malloc (g, sizeof (char *) * (len+1));
2624     for (i = 0; i < len; ++i) {
2625       VALUE v = rb_ary_entry (argumentsv, i);
2626       arguments[i] = StringValueCStr (v);
2627     }
2628     arguments[len] = NULL;
2629   }
2630
2631   char **r;
2632
2633   r = guestfs_command_lines (g, arguments);
2634   free (arguments);
2635   if (r == NULL)
2636     rb_raise (e_Error, "%s", guestfs_last_error (g));
2637
2638   int i, len = 0;
2639   for (i = 0; r[i] != NULL; ++i) len++;
2640   VALUE rv = rb_ary_new2 (len);
2641   for (i = 0; r[i] != NULL; ++i) {
2642     rb_ary_push (rv, rb_str_new2 (r[i]));
2643     free (r[i]);
2644   }
2645   free (r);
2646   return rv;
2647 }
2648
2649 static VALUE ruby_guestfs_stat (VALUE gv, VALUE pathv)
2650 {
2651   guestfs_h *g;
2652   Data_Get_Struct (gv, guestfs_h, g);
2653   if (!g)
2654     rb_raise (rb_eArgError, "%s: used handle after closing it", "stat");
2655
2656   Check_Type (pathv, T_STRING);
2657   const char *path = StringValueCStr (pathv);
2658   if (!path)
2659     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2660               "path", "stat");
2661
2662   struct guestfs_stat *r;
2663
2664   r = guestfs_stat (g, path);
2665   if (r == NULL)
2666     rb_raise (e_Error, "%s", guestfs_last_error (g));
2667
2668   VALUE rv = rb_hash_new ();
2669   rb_hash_aset (rv, rb_str_new2 ("dev"), ULL2NUM (r->dev));
2670   rb_hash_aset (rv, rb_str_new2 ("ino"), ULL2NUM (r->ino));
2671   rb_hash_aset (rv, rb_str_new2 ("mode"), ULL2NUM (r->mode));
2672   rb_hash_aset (rv, rb_str_new2 ("nlink"), ULL2NUM (r->nlink));
2673   rb_hash_aset (rv, rb_str_new2 ("uid"), ULL2NUM (r->uid));
2674   rb_hash_aset (rv, rb_str_new2 ("gid"), ULL2NUM (r->gid));
2675   rb_hash_aset (rv, rb_str_new2 ("rdev"), ULL2NUM (r->rdev));
2676   rb_hash_aset (rv, rb_str_new2 ("size"), ULL2NUM (r->size));
2677   rb_hash_aset (rv, rb_str_new2 ("blksize"), ULL2NUM (r->blksize));
2678   rb_hash_aset (rv, rb_str_new2 ("blocks"), ULL2NUM (r->blocks));
2679   rb_hash_aset (rv, rb_str_new2 ("atime"), ULL2NUM (r->atime));
2680   rb_hash_aset (rv, rb_str_new2 ("mtime"), ULL2NUM (r->mtime));
2681   rb_hash_aset (rv, rb_str_new2 ("ctime"), ULL2NUM (r->ctime));
2682   free (r);
2683   return rv;
2684 }
2685
2686 static VALUE ruby_guestfs_lstat (VALUE gv, VALUE pathv)
2687 {
2688   guestfs_h *g;
2689   Data_Get_Struct (gv, guestfs_h, g);
2690   if (!g)
2691     rb_raise (rb_eArgError, "%s: used handle after closing it", "lstat");
2692
2693   Check_Type (pathv, T_STRING);
2694   const char *path = StringValueCStr (pathv);
2695   if (!path)
2696     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2697               "path", "lstat");
2698
2699   struct guestfs_stat *r;
2700
2701   r = guestfs_lstat (g, path);
2702   if (r == NULL)
2703     rb_raise (e_Error, "%s", guestfs_last_error (g));
2704
2705   VALUE rv = rb_hash_new ();
2706   rb_hash_aset (rv, rb_str_new2 ("dev"), ULL2NUM (r->dev));
2707   rb_hash_aset (rv, rb_str_new2 ("ino"), ULL2NUM (r->ino));
2708   rb_hash_aset (rv, rb_str_new2 ("mode"), ULL2NUM (r->mode));
2709   rb_hash_aset (rv, rb_str_new2 ("nlink"), ULL2NUM (r->nlink));
2710   rb_hash_aset (rv, rb_str_new2 ("uid"), ULL2NUM (r->uid));
2711   rb_hash_aset (rv, rb_str_new2 ("gid"), ULL2NUM (r->gid));
2712   rb_hash_aset (rv, rb_str_new2 ("rdev"), ULL2NUM (r->rdev));
2713   rb_hash_aset (rv, rb_str_new2 ("size"), ULL2NUM (r->size));
2714   rb_hash_aset (rv, rb_str_new2 ("blksize"), ULL2NUM (r->blksize));
2715   rb_hash_aset (rv, rb_str_new2 ("blocks"), ULL2NUM (r->blocks));
2716   rb_hash_aset (rv, rb_str_new2 ("atime"), ULL2NUM (r->atime));
2717   rb_hash_aset (rv, rb_str_new2 ("mtime"), ULL2NUM (r->mtime));
2718   rb_hash_aset (rv, rb_str_new2 ("ctime"), ULL2NUM (r->ctime));
2719   free (r);
2720   return rv;
2721 }
2722
2723 static VALUE ruby_guestfs_statvfs (VALUE gv, VALUE pathv)
2724 {
2725   guestfs_h *g;
2726   Data_Get_Struct (gv, guestfs_h, g);
2727   if (!g)
2728     rb_raise (rb_eArgError, "%s: used handle after closing it", "statvfs");
2729
2730   Check_Type (pathv, T_STRING);
2731   const char *path = StringValueCStr (pathv);
2732   if (!path)
2733     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2734               "path", "statvfs");
2735
2736   struct guestfs_statvfs *r;
2737
2738   r = guestfs_statvfs (g, path);
2739   if (r == NULL)
2740     rb_raise (e_Error, "%s", guestfs_last_error (g));
2741
2742   VALUE rv = rb_hash_new ();
2743   rb_hash_aset (rv, rb_str_new2 ("bsize"), ULL2NUM (r->bsize));
2744   rb_hash_aset (rv, rb_str_new2 ("frsize"), ULL2NUM (r->frsize));
2745   rb_hash_aset (rv, rb_str_new2 ("blocks"), ULL2NUM (r->blocks));
2746   rb_hash_aset (rv, rb_str_new2 ("bfree"), ULL2NUM (r->bfree));
2747   rb_hash_aset (rv, rb_str_new2 ("bavail"), ULL2NUM (r->bavail));
2748   rb_hash_aset (rv, rb_str_new2 ("files"), ULL2NUM (r->files));
2749   rb_hash_aset (rv, rb_str_new2 ("ffree"), ULL2NUM (r->ffree));
2750   rb_hash_aset (rv, rb_str_new2 ("favail"), ULL2NUM (r->favail));
2751   rb_hash_aset (rv, rb_str_new2 ("fsid"), ULL2NUM (r->fsid));
2752   rb_hash_aset (rv, rb_str_new2 ("flag"), ULL2NUM (r->flag));
2753   rb_hash_aset (rv, rb_str_new2 ("namemax"), ULL2NUM (r->namemax));
2754   free (r);
2755   return rv;
2756 }
2757
2758 static VALUE ruby_guestfs_tune2fs_l (VALUE gv, VALUE devicev)
2759 {
2760   guestfs_h *g;
2761   Data_Get_Struct (gv, guestfs_h, g);
2762   if (!g)
2763     rb_raise (rb_eArgError, "%s: used handle after closing it", "tune2fs_l");
2764
2765   Check_Type (devicev, T_STRING);
2766   const char *device = StringValueCStr (devicev);
2767   if (!device)
2768     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2769               "device", "tune2fs_l");
2770
2771   char **r;
2772
2773   r = guestfs_tune2fs_l (g, device);
2774   if (r == NULL)
2775     rb_raise (e_Error, "%s", guestfs_last_error (g));
2776
2777   VALUE rv = rb_hash_new ();
2778   int i;
2779   for (i = 0; r[i] != NULL; i+=2) {
2780     rb_hash_aset (rv, rb_str_new2 (r[i]), rb_str_new2 (r[i+1]));
2781     free (r[i]);
2782     free (r[i+1]);
2783   }
2784   free (r);
2785   return rv;
2786 }
2787
2788 static VALUE ruby_guestfs_blockdev_setro (VALUE gv, VALUE devicev)
2789 {
2790   guestfs_h *g;
2791   Data_Get_Struct (gv, guestfs_h, g);
2792   if (!g)
2793     rb_raise (rb_eArgError, "%s: used handle after closing it", "blockdev_setro");
2794
2795   Check_Type (devicev, T_STRING);
2796   const char *device = StringValueCStr (devicev);
2797   if (!device)
2798     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2799               "device", "blockdev_setro");
2800
2801   int r;
2802
2803   r = guestfs_blockdev_setro (g, device);
2804   if (r == -1)
2805     rb_raise (e_Error, "%s", guestfs_last_error (g));
2806
2807   return Qnil;
2808 }
2809
2810 static VALUE ruby_guestfs_blockdev_setrw (VALUE gv, VALUE devicev)
2811 {
2812   guestfs_h *g;
2813   Data_Get_Struct (gv, guestfs_h, g);
2814   if (!g)
2815     rb_raise (rb_eArgError, "%s: used handle after closing it", "blockdev_setrw");
2816
2817   Check_Type (devicev, T_STRING);
2818   const char *device = StringValueCStr (devicev);
2819   if (!device)
2820     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2821               "device", "blockdev_setrw");
2822
2823   int r;
2824
2825   r = guestfs_blockdev_setrw (g, device);
2826   if (r == -1)
2827     rb_raise (e_Error, "%s", guestfs_last_error (g));
2828
2829   return Qnil;
2830 }
2831
2832 static VALUE ruby_guestfs_blockdev_getro (VALUE gv, VALUE devicev)
2833 {
2834   guestfs_h *g;
2835   Data_Get_Struct (gv, guestfs_h, g);
2836   if (!g)
2837     rb_raise (rb_eArgError, "%s: used handle after closing it", "blockdev_getro");
2838
2839   Check_Type (devicev, T_STRING);
2840   const char *device = StringValueCStr (devicev);
2841   if (!device)
2842     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2843               "device", "blockdev_getro");
2844
2845   int r;
2846
2847   r = guestfs_blockdev_getro (g, device);
2848   if (r == -1)
2849     rb_raise (e_Error, "%s", guestfs_last_error (g));
2850
2851   return INT2NUM (r);
2852 }
2853
2854 static VALUE ruby_guestfs_blockdev_getss (VALUE gv, VALUE devicev)
2855 {
2856   guestfs_h *g;
2857   Data_Get_Struct (gv, guestfs_h, g);
2858   if (!g)
2859     rb_raise (rb_eArgError, "%s: used handle after closing it", "blockdev_getss");
2860
2861   Check_Type (devicev, T_STRING);
2862   const char *device = StringValueCStr (devicev);
2863   if (!device)
2864     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2865               "device", "blockdev_getss");
2866
2867   int r;
2868
2869   r = guestfs_blockdev_getss (g, device);
2870   if (r == -1)
2871     rb_raise (e_Error, "%s", guestfs_last_error (g));
2872
2873   return INT2NUM (r);
2874 }
2875
2876 static VALUE ruby_guestfs_blockdev_getbsz (VALUE gv, VALUE devicev)
2877 {
2878   guestfs_h *g;
2879   Data_Get_Struct (gv, guestfs_h, g);
2880   if (!g)
2881     rb_raise (rb_eArgError, "%s: used handle after closing it", "blockdev_getbsz");
2882
2883   Check_Type (devicev, T_STRING);
2884   const char *device = StringValueCStr (devicev);
2885   if (!device)
2886     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2887               "device", "blockdev_getbsz");
2888
2889   int r;
2890
2891   r = guestfs_blockdev_getbsz (g, device);
2892   if (r == -1)
2893     rb_raise (e_Error, "%s", guestfs_last_error (g));
2894
2895   return INT2NUM (r);
2896 }
2897
2898 static VALUE ruby_guestfs_blockdev_setbsz (VALUE gv, VALUE devicev, VALUE blocksizev)
2899 {
2900   guestfs_h *g;
2901   Data_Get_Struct (gv, guestfs_h, g);
2902   if (!g)
2903     rb_raise (rb_eArgError, "%s: used handle after closing it", "blockdev_setbsz");
2904
2905   Check_Type (devicev, T_STRING);
2906   const char *device = StringValueCStr (devicev);
2907   if (!device)
2908     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2909               "device", "blockdev_setbsz");
2910   int blocksize = NUM2INT (blocksizev);
2911
2912   int r;
2913
2914   r = guestfs_blockdev_setbsz (g, device, blocksize);
2915   if (r == -1)
2916     rb_raise (e_Error, "%s", guestfs_last_error (g));
2917
2918   return Qnil;
2919 }
2920
2921 static VALUE ruby_guestfs_blockdev_getsz (VALUE gv, VALUE devicev)
2922 {
2923   guestfs_h *g;
2924   Data_Get_Struct (gv, guestfs_h, g);
2925   if (!g)
2926     rb_raise (rb_eArgError, "%s: used handle after closing it", "blockdev_getsz");
2927
2928   Check_Type (devicev, T_STRING);
2929   const char *device = StringValueCStr (devicev);
2930   if (!device)
2931     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2932               "device", "blockdev_getsz");
2933
2934   int64_t r;
2935
2936   r = guestfs_blockdev_getsz (g, device);
2937   if (r == -1)
2938     rb_raise (e_Error, "%s", guestfs_last_error (g));
2939
2940   return ULL2NUM (r);
2941 }
2942
2943 static VALUE ruby_guestfs_blockdev_getsize64 (VALUE gv, VALUE devicev)
2944 {
2945   guestfs_h *g;
2946   Data_Get_Struct (gv, guestfs_h, g);
2947   if (!g)
2948     rb_raise (rb_eArgError, "%s: used handle after closing it", "blockdev_getsize64");
2949
2950   Check_Type (devicev, T_STRING);
2951   const char *device = StringValueCStr (devicev);
2952   if (!device)
2953     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2954               "device", "blockdev_getsize64");
2955
2956   int64_t r;
2957
2958   r = guestfs_blockdev_getsize64 (g, device);
2959   if (r == -1)
2960     rb_raise (e_Error, "%s", guestfs_last_error (g));
2961
2962   return ULL2NUM (r);
2963 }
2964
2965 static VALUE ruby_guestfs_blockdev_flushbufs (VALUE gv, VALUE devicev)
2966 {
2967   guestfs_h *g;
2968   Data_Get_Struct (gv, guestfs_h, g);
2969   if (!g)
2970     rb_raise (rb_eArgError, "%s: used handle after closing it", "blockdev_flushbufs");
2971
2972   Check_Type (devicev, T_STRING);
2973   const char *device = StringValueCStr (devicev);
2974   if (!device)
2975     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2976               "device", "blockdev_flushbufs");
2977
2978   int r;
2979
2980   r = guestfs_blockdev_flushbufs (g, device);
2981   if (r == -1)
2982     rb_raise (e_Error, "%s", guestfs_last_error (g));
2983
2984   return Qnil;
2985 }
2986
2987 static VALUE ruby_guestfs_blockdev_rereadpt (VALUE gv, VALUE devicev)
2988 {
2989   guestfs_h *g;
2990   Data_Get_Struct (gv, guestfs_h, g);
2991   if (!g)
2992     rb_raise (rb_eArgError, "%s: used handle after closing it", "blockdev_rereadpt");
2993
2994   Check_Type (devicev, T_STRING);
2995   const char *device = StringValueCStr (devicev);
2996   if (!device)
2997     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2998               "device", "blockdev_rereadpt");
2999
3000   int r;
3001
3002   r = guestfs_blockdev_rereadpt (g, device);
3003   if (r == -1)
3004     rb_raise (e_Error, "%s", guestfs_last_error (g));
3005
3006   return Qnil;
3007 }
3008
3009 static VALUE ruby_guestfs_upload (VALUE gv, VALUE filenamev, VALUE remotefilenamev)
3010 {
3011   guestfs_h *g;
3012   Data_Get_Struct (gv, guestfs_h, g);
3013   if (!g)
3014     rb_raise (rb_eArgError, "%s: used handle after closing it", "upload");
3015
3016   Check_Type (filenamev, T_STRING);
3017   const char *filename = StringValueCStr (filenamev);
3018   if (!filename)
3019     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3020               "filename", "upload");
3021   Check_Type (remotefilenamev, T_STRING);
3022   const char *remotefilename = StringValueCStr (remotefilenamev);
3023   if (!remotefilename)
3024     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3025               "remotefilename", "upload");
3026
3027   int r;
3028
3029   r = guestfs_upload (g, filename, remotefilename);
3030   if (r == -1)
3031     rb_raise (e_Error, "%s", guestfs_last_error (g));
3032
3033   return Qnil;
3034 }
3035
3036 static VALUE ruby_guestfs_download (VALUE gv, VALUE remotefilenamev, VALUE filenamev)
3037 {
3038   guestfs_h *g;
3039   Data_Get_Struct (gv, guestfs_h, g);
3040   if (!g)
3041     rb_raise (rb_eArgError, "%s: used handle after closing it", "download");
3042
3043   Check_Type (remotefilenamev, T_STRING);
3044   const char *remotefilename = StringValueCStr (remotefilenamev);
3045   if (!remotefilename)
3046     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3047               "remotefilename", "download");
3048   Check_Type (filenamev, T_STRING);
3049   const char *filename = StringValueCStr (filenamev);
3050   if (!filename)
3051     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3052               "filename", "download");
3053
3054   int r;
3055
3056   r = guestfs_download (g, remotefilename, filename);
3057   if (r == -1)
3058     rb_raise (e_Error, "%s", guestfs_last_error (g));
3059
3060   return Qnil;
3061 }
3062
3063 static VALUE ruby_guestfs_checksum (VALUE gv, VALUE csumtypev, VALUE pathv)
3064 {
3065   guestfs_h *g;
3066   Data_Get_Struct (gv, guestfs_h, g);
3067   if (!g)
3068     rb_raise (rb_eArgError, "%s: used handle after closing it", "checksum");
3069
3070   Check_Type (csumtypev, T_STRING);
3071   const char *csumtype = StringValueCStr (csumtypev);
3072   if (!csumtype)
3073     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3074               "csumtype", "checksum");
3075   Check_Type (pathv, T_STRING);
3076   const char *path = StringValueCStr (pathv);
3077   if (!path)
3078     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3079               "path", "checksum");
3080
3081   char *r;
3082
3083   r = guestfs_checksum (g, csumtype, path);
3084   if (r == NULL)
3085     rb_raise (e_Error, "%s", guestfs_last_error (g));
3086
3087   VALUE rv = rb_str_new2 (r);
3088   free (r);
3089   return rv;
3090 }
3091
3092 static VALUE ruby_guestfs_tar_in (VALUE gv, VALUE tarfilev, VALUE directoryv)
3093 {
3094   guestfs_h *g;
3095   Data_Get_Struct (gv, guestfs_h, g);
3096   if (!g)
3097     rb_raise (rb_eArgError, "%s: used handle after closing it", "tar_in");
3098
3099   Check_Type (tarfilev, T_STRING);
3100   const char *tarfile = StringValueCStr (tarfilev);
3101   if (!tarfile)
3102     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3103               "tarfile", "tar_in");
3104   Check_Type (directoryv, T_STRING);
3105   const char *directory = StringValueCStr (directoryv);
3106   if (!directory)
3107     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3108               "directory", "tar_in");
3109
3110   int r;
3111
3112   r = guestfs_tar_in (g, tarfile, directory);
3113   if (r == -1)
3114     rb_raise (e_Error, "%s", guestfs_last_error (g));
3115
3116   return Qnil;
3117 }
3118
3119 static VALUE ruby_guestfs_tar_out (VALUE gv, VALUE directoryv, VALUE tarfilev)
3120 {
3121   guestfs_h *g;
3122   Data_Get_Struct (gv, guestfs_h, g);
3123   if (!g)
3124     rb_raise (rb_eArgError, "%s: used handle after closing it", "tar_out");
3125
3126   Check_Type (directoryv, T_STRING);
3127   const char *directory = StringValueCStr (directoryv);
3128   if (!directory)
3129     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3130               "directory", "tar_out");
3131   Check_Type (tarfilev, T_STRING);
3132   const char *tarfile = StringValueCStr (tarfilev);
3133   if (!tarfile)
3134     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3135               "tarfile", "tar_out");
3136
3137   int r;
3138
3139   r = guestfs_tar_out (g, directory, tarfile);
3140   if (r == -1)
3141     rb_raise (e_Error, "%s", guestfs_last_error (g));
3142
3143   return Qnil;
3144 }
3145
3146 static VALUE ruby_guestfs_tgz_in (VALUE gv, VALUE tarballv, VALUE directoryv)
3147 {
3148   guestfs_h *g;
3149   Data_Get_Struct (gv, guestfs_h, g);
3150   if (!g)
3151     rb_raise (rb_eArgError, "%s: used handle after closing it", "tgz_in");
3152
3153   Check_Type (tarballv, T_STRING);
3154   const char *tarball = StringValueCStr (tarballv);
3155   if (!tarball)
3156     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3157               "tarball", "tgz_in");
3158   Check_Type (directoryv, T_STRING);
3159   const char *directory = StringValueCStr (directoryv);
3160   if (!directory)
3161     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3162               "directory", "tgz_in");
3163
3164   int r;
3165
3166   r = guestfs_tgz_in (g, tarball, directory);
3167   if (r == -1)
3168     rb_raise (e_Error, "%s", guestfs_last_error (g));
3169
3170   return Qnil;
3171 }
3172
3173 static VALUE ruby_guestfs_tgz_out (VALUE gv, VALUE directoryv, VALUE tarballv)
3174 {
3175   guestfs_h *g;
3176   Data_Get_Struct (gv, guestfs_h, g);
3177   if (!g)
3178     rb_raise (rb_eArgError, "%s: used handle after closing it", "tgz_out");
3179
3180   Check_Type (directoryv, T_STRING);
3181   const char *directory = StringValueCStr (directoryv);
3182   if (!directory)
3183     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3184               "directory", "tgz_out");
3185   Check_Type (tarballv, T_STRING);
3186   const char *tarball = StringValueCStr (tarballv);
3187   if (!tarball)
3188     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3189               "tarball", "tgz_out");
3190
3191   int r;
3192
3193   r = guestfs_tgz_out (g, directory, tarball);
3194   if (r == -1)
3195     rb_raise (e_Error, "%s", guestfs_last_error (g));
3196
3197   return Qnil;
3198 }
3199
3200 static VALUE ruby_guestfs_mount_ro (VALUE gv, VALUE devicev, VALUE mountpointv)
3201 {
3202   guestfs_h *g;
3203   Data_Get_Struct (gv, guestfs_h, g);
3204   if (!g)
3205     rb_raise (rb_eArgError, "%s: used handle after closing it", "mount_ro");
3206
3207   Check_Type (devicev, T_STRING);
3208   const char *device = StringValueCStr (devicev);
3209   if (!device)
3210     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3211               "device", "mount_ro");
3212   Check_Type (mountpointv, T_STRING);
3213   const char *mountpoint = StringValueCStr (mountpointv);
3214   if (!mountpoint)
3215     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3216               "mountpoint", "mount_ro");
3217
3218   int r;
3219
3220   r = guestfs_mount_ro (g, device, mountpoint);
3221   if (r == -1)
3222     rb_raise (e_Error, "%s", guestfs_last_error (g));
3223
3224   return Qnil;
3225 }
3226
3227 static VALUE ruby_guestfs_mount_options (VALUE gv, VALUE optionsv, VALUE devicev, VALUE mountpointv)
3228 {
3229   guestfs_h *g;
3230   Data_Get_Struct (gv, guestfs_h, g);
3231   if (!g)
3232     rb_raise (rb_eArgError, "%s: used handle after closing it", "mount_options");
3233
3234   Check_Type (optionsv, T_STRING);
3235   const char *options = StringValueCStr (optionsv);
3236   if (!options)
3237     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3238               "options", "mount_options");
3239   Check_Type (devicev, T_STRING);
3240   const char *device = StringValueCStr (devicev);
3241   if (!device)
3242     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3243               "device", "mount_options");
3244   Check_Type (mountpointv, T_STRING);
3245   const char *mountpoint = StringValueCStr (mountpointv);
3246   if (!mountpoint)
3247     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3248               "mountpoint", "mount_options");
3249
3250   int r;
3251
3252   r = guestfs_mount_options (g, options, device, mountpoint);
3253   if (r == -1)
3254     rb_raise (e_Error, "%s", guestfs_last_error (g));
3255
3256   return Qnil;
3257 }
3258
3259 static VALUE ruby_guestfs_mount_vfs (VALUE gv, VALUE optionsv, VALUE vfstypev, VALUE devicev, VALUE mountpointv)
3260 {
3261   guestfs_h *g;
3262   Data_Get_Struct (gv, guestfs_h, g);
3263   if (!g)
3264     rb_raise (rb_eArgError, "%s: used handle after closing it", "mount_vfs");
3265
3266   Check_Type (optionsv, T_STRING);
3267   const char *options = StringValueCStr (optionsv);
3268   if (!options)
3269     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3270               "options", "mount_vfs");
3271   Check_Type (vfstypev, T_STRING);
3272   const char *vfstype = StringValueCStr (vfstypev);
3273   if (!vfstype)
3274     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3275               "vfstype", "mount_vfs");
3276   Check_Type (devicev, T_STRING);
3277   const char *device = StringValueCStr (devicev);
3278   if (!device)
3279     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3280               "device", "mount_vfs");
3281   Check_Type (mountpointv, T_STRING);
3282   const char *mountpoint = StringValueCStr (mountpointv);
3283   if (!mountpoint)
3284     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3285               "mountpoint", "mount_vfs");
3286
3287   int r;
3288
3289   r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint);
3290   if (r == -1)
3291     rb_raise (e_Error, "%s", guestfs_last_error (g));
3292
3293   return Qnil;
3294 }
3295
3296 static VALUE ruby_guestfs_debug (VALUE gv, VALUE subcmdv, VALUE extraargsv)
3297 {
3298   guestfs_h *g;
3299   Data_Get_Struct (gv, guestfs_h, g);
3300   if (!g)
3301     rb_raise (rb_eArgError, "%s: used handle after closing it", "debug");
3302
3303   Check_Type (subcmdv, T_STRING);
3304   const char *subcmd = StringValueCStr (subcmdv);
3305   if (!subcmd)
3306     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3307               "subcmd", "debug");
3308   char **extraargs;
3309   Check_Type (extraargsv, T_ARRAY);
3310   {
3311     int i, len;
3312     len = RARRAY_LEN (extraargsv);
3313     extraargs = guestfs_safe_malloc (g, sizeof (char *) * (len+1));
3314     for (i = 0; i < len; ++i) {
3315       VALUE v = rb_ary_entry (extraargsv, i);
3316       extraargs[i] = StringValueCStr (v);
3317     }
3318     extraargs[len] = NULL;
3319   }
3320
3321   char *r;
3322
3323   r = guestfs_debug (g, subcmd, extraargs);
3324   free (extraargs);
3325   if (r == NULL)
3326     rb_raise (e_Error, "%s", guestfs_last_error (g));
3327
3328   VALUE rv = rb_str_new2 (r);
3329   free (r);
3330   return rv;
3331 }
3332
3333 static VALUE ruby_guestfs_lvremove (VALUE gv, VALUE devicev)
3334 {
3335   guestfs_h *g;
3336   Data_Get_Struct (gv, guestfs_h, g);
3337   if (!g)
3338     rb_raise (rb_eArgError, "%s: used handle after closing it", "lvremove");
3339
3340   Check_Type (devicev, T_STRING);
3341   const char *device = StringValueCStr (devicev);
3342   if (!device)
3343     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3344               "device", "lvremove");
3345
3346   int r;
3347
3348   r = guestfs_lvremove (g, device);
3349   if (r == -1)
3350     rb_raise (e_Error, "%s", guestfs_last_error (g));
3351
3352   return Qnil;
3353 }
3354
3355 static VALUE ruby_guestfs_vgremove (VALUE gv, VALUE vgnamev)
3356 {
3357   guestfs_h *g;
3358   Data_Get_Struct (gv, guestfs_h, g);
3359   if (!g)
3360     rb_raise (rb_eArgError, "%s: used handle after closing it", "vgremove");
3361
3362   Check_Type (vgnamev, T_STRING);
3363   const char *vgname = StringValueCStr (vgnamev);
3364   if (!vgname)
3365     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3366               "vgname", "vgremove");
3367
3368   int r;
3369
3370   r = guestfs_vgremove (g, vgname);
3371   if (r == -1)
3372     rb_raise (e_Error, "%s", guestfs_last_error (g));
3373
3374   return Qnil;
3375 }
3376
3377 static VALUE ruby_guestfs_pvremove (VALUE gv, VALUE devicev)
3378 {
3379   guestfs_h *g;
3380   Data_Get_Struct (gv, guestfs_h, g);
3381   if (!g)
3382     rb_raise (rb_eArgError, "%s: used handle after closing it", "pvremove");
3383
3384   Check_Type (devicev, T_STRING);
3385   const char *device = StringValueCStr (devicev);
3386   if (!device)
3387     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3388               "device", "pvremove");
3389
3390   int r;
3391
3392   r = guestfs_pvremove (g, device);
3393   if (r == -1)
3394     rb_raise (e_Error, "%s", guestfs_last_error (g));
3395
3396   return Qnil;
3397 }
3398
3399 static VALUE ruby_guestfs_set_e2label (VALUE gv, VALUE devicev, VALUE labelv)
3400 {
3401   guestfs_h *g;
3402   Data_Get_Struct (gv, guestfs_h, g);
3403   if (!g)
3404     rb_raise (rb_eArgError, "%s: used handle after closing it", "set_e2label");
3405
3406   Check_Type (devicev, T_STRING);
3407   const char *device = StringValueCStr (devicev);
3408   if (!device)
3409     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3410               "device", "set_e2label");
3411   Check_Type (labelv, T_STRING);
3412   const char *label = StringValueCStr (labelv);
3413   if (!label)
3414     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3415               "label", "set_e2label");
3416
3417   int r;
3418
3419   r = guestfs_set_e2label (g, device, label);
3420   if (r == -1)
3421     rb_raise (e_Error, "%s", guestfs_last_error (g));
3422
3423   return Qnil;
3424 }
3425
3426 static VALUE ruby_guestfs_get_e2label (VALUE gv, VALUE devicev)
3427 {
3428   guestfs_h *g;
3429   Data_Get_Struct (gv, guestfs_h, g);
3430   if (!g)
3431     rb_raise (rb_eArgError, "%s: used handle after closing it", "get_e2label");
3432
3433   Check_Type (devicev, T_STRING);
3434   const char *device = StringValueCStr (devicev);
3435   if (!device)
3436     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3437               "device", "get_e2label");
3438
3439   char *r;
3440
3441   r = guestfs_get_e2label (g, device);
3442   if (r == NULL)
3443     rb_raise (e_Error, "%s", guestfs_last_error (g));
3444
3445   VALUE rv = rb_str_new2 (r);
3446   free (r);
3447   return rv;
3448 }
3449
3450 static VALUE ruby_guestfs_set_e2uuid (VALUE gv, VALUE devicev, VALUE uuidv)
3451 {
3452   guestfs_h *g;
3453   Data_Get_Struct (gv, guestfs_h, g);
3454   if (!g)
3455     rb_raise (rb_eArgError, "%s: used handle after closing it", "set_e2uuid");
3456
3457   Check_Type (devicev, T_STRING);
3458   const char *device = StringValueCStr (devicev);
3459   if (!device)
3460     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3461               "device", "set_e2uuid");
3462   Check_Type (uuidv, T_STRING);
3463   const char *uuid = StringValueCStr (uuidv);
3464   if (!uuid)
3465     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3466               "uuid", "set_e2uuid");
3467
3468   int r;
3469
3470   r = guestfs_set_e2uuid (g, device, uuid);
3471   if (r == -1)
3472     rb_raise (e_Error, "%s", guestfs_last_error (g));
3473
3474   return Qnil;
3475 }
3476
3477 static VALUE ruby_guestfs_get_e2uuid (VALUE gv, VALUE devicev)
3478 {
3479   guestfs_h *g;
3480   Data_Get_Struct (gv, guestfs_h, g);
3481   if (!g)
3482     rb_raise (rb_eArgError, "%s: used handle after closing it", "get_e2uuid");
3483
3484   Check_Type (devicev, T_STRING);
3485   const char *device = StringValueCStr (devicev);
3486   if (!device)
3487     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3488               "device", "get_e2uuid");
3489
3490   char *r;
3491
3492   r = guestfs_get_e2uuid (g, device);
3493   if (r == NULL)
3494     rb_raise (e_Error, "%s", guestfs_last_error (g));
3495
3496   VALUE rv = rb_str_new2 (r);
3497   free (r);
3498   return rv;
3499 }
3500
3501 static VALUE ruby_guestfs_fsck (VALUE gv, VALUE fstypev, VALUE devicev)
3502 {
3503   guestfs_h *g;
3504   Data_Get_Struct (gv, guestfs_h, g);
3505   if (!g)
3506     rb_raise (rb_eArgError, "%s: used handle after closing it", "fsck");
3507
3508   Check_Type (fstypev, T_STRING);
3509   const char *fstype = StringValueCStr (fstypev);
3510   if (!fstype)
3511     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3512               "fstype", "fsck");
3513   Check_Type (devicev, T_STRING);
3514   const char *device = StringValueCStr (devicev);
3515   if (!device)
3516     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3517               "device", "fsck");
3518
3519   int r;
3520
3521   r = guestfs_fsck (g, fstype, device);
3522   if (r == -1)
3523     rb_raise (e_Error, "%s", guestfs_last_error (g));
3524
3525   return INT2NUM (r);
3526 }
3527
3528 static VALUE ruby_guestfs_zero (VALUE gv, VALUE devicev)
3529 {
3530   guestfs_h *g;
3531   Data_Get_Struct (gv, guestfs_h, g);
3532   if (!g)
3533     rb_raise (rb_eArgError, "%s: used handle after closing it", "zero");
3534
3535   Check_Type (devicev, T_STRING);
3536   const char *device = StringValueCStr (devicev);
3537   if (!device)
3538     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3539               "device", "zero");
3540
3541   int r;
3542
3543   r = guestfs_zero (g, device);
3544   if (r == -1)
3545     rb_raise (e_Error, "%s", guestfs_last_error (g));
3546
3547   return Qnil;
3548 }
3549
3550 static VALUE ruby_guestfs_grub_install (VALUE gv, VALUE rootv, VALUE devicev)
3551 {
3552   guestfs_h *g;
3553   Data_Get_Struct (gv, guestfs_h, g);
3554   if (!g)
3555     rb_raise (rb_eArgError, "%s: used handle after closing it", "grub_install");
3556
3557   Check_Type (rootv, T_STRING);
3558   const char *root = StringValueCStr (rootv);
3559   if (!root)
3560     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3561               "root", "grub_install");
3562   Check_Type (devicev, T_STRING);
3563   const char *device = StringValueCStr (devicev);
3564   if (!device)
3565     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3566               "device", "grub_install");
3567
3568   int r;
3569
3570   r = guestfs_grub_install (g, root, device);
3571   if (r == -1)
3572     rb_raise (e_Error, "%s", guestfs_last_error (g));
3573
3574   return Qnil;
3575 }
3576
3577 static VALUE ruby_guestfs_cp (VALUE gv, VALUE srcv, VALUE destv)
3578 {
3579   guestfs_h *g;
3580   Data_Get_Struct (gv, guestfs_h, g);
3581   if (!g)
3582     rb_raise (rb_eArgError, "%s: used handle after closing it", "cp");
3583
3584   Check_Type (srcv, T_STRING);
3585   const char *src = StringValueCStr (srcv);
3586   if (!src)
3587     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3588               "src", "cp");
3589   Check_Type (destv, T_STRING);
3590   const char *dest = StringValueCStr (destv);
3591   if (!dest)
3592     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3593               "dest", "cp");
3594
3595   int r;
3596
3597   r = guestfs_cp (g, src, dest);
3598   if (r == -1)
3599     rb_raise (e_Error, "%s", guestfs_last_error (g));
3600
3601   return Qnil;
3602 }
3603
3604 static VALUE ruby_guestfs_cp_a (VALUE gv, VALUE srcv, VALUE destv)
3605 {
3606   guestfs_h *g;
3607   Data_Get_Struct (gv, guestfs_h, g);
3608   if (!g)
3609     rb_raise (rb_eArgError, "%s: used handle after closing it", "cp_a");
3610
3611   Check_Type (srcv, T_STRING);
3612   const char *src = StringValueCStr (srcv);
3613   if (!src)
3614     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3615               "src", "cp_a");
3616   Check_Type (destv, T_STRING);
3617   const char *dest = StringValueCStr (destv);
3618   if (!dest)
3619     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3620               "dest", "cp_a");
3621
3622   int r;
3623
3624   r = guestfs_cp_a (g, src, dest);
3625   if (r == -1)
3626     rb_raise (e_Error, "%s", guestfs_last_error (g));
3627
3628   return Qnil;
3629 }
3630
3631 static VALUE ruby_guestfs_mv (VALUE gv, VALUE srcv, VALUE destv)
3632 {
3633   guestfs_h *g;
3634   Data_Get_Struct (gv, guestfs_h, g);
3635   if (!g)
3636     rb_raise (rb_eArgError, "%s: used handle after closing it", "mv");
3637
3638   Check_Type (srcv, T_STRING);
3639   const char *src = StringValueCStr (srcv);
3640   if (!src)
3641     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3642               "src", "mv");
3643   Check_Type (destv, T_STRING);
3644   const char *dest = StringValueCStr (destv);
3645   if (!dest)
3646     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3647               "dest", "mv");
3648
3649   int r;
3650
3651   r = guestfs_mv (g, src, dest);
3652   if (r == -1)
3653     rb_raise (e_Error, "%s", guestfs_last_error (g));
3654
3655   return Qnil;
3656 }
3657
3658 static VALUE ruby_guestfs_drop_caches (VALUE gv, VALUE whattodropv)
3659 {
3660   guestfs_h *g;
3661   Data_Get_Struct (gv, guestfs_h, g);
3662   if (!g)
3663     rb_raise (rb_eArgError, "%s: used handle after closing it", "drop_caches");
3664
3665   int whattodrop = NUM2INT (whattodropv);
3666
3667   int r;
3668
3669   r = guestfs_drop_caches (g, whattodrop);
3670   if (r == -1)
3671     rb_raise (e_Error, "%s", guestfs_last_error (g));
3672
3673   return Qnil;
3674 }
3675
3676 static VALUE ruby_guestfs_dmesg (VALUE gv)
3677 {
3678   guestfs_h *g;
3679   Data_Get_Struct (gv, guestfs_h, g);
3680   if (!g)
3681     rb_raise (rb_eArgError, "%s: used handle after closing it", "dmesg");
3682
3683
3684   char *r;
3685
3686   r = guestfs_dmesg (g);
3687   if (r == NULL)
3688     rb_raise (e_Error, "%s", guestfs_last_error (g));
3689
3690   VALUE rv = rb_str_new2 (r);
3691   free (r);
3692   return rv;
3693 }
3694
3695 static VALUE ruby_guestfs_ping_daemon (VALUE gv)
3696 {
3697   guestfs_h *g;
3698   Data_Get_Struct (gv, guestfs_h, g);
3699   if (!g)
3700     rb_raise (rb_eArgError, "%s: used handle after closing it", "ping_daemon");
3701
3702
3703   int r;
3704
3705   r = guestfs_ping_daemon (g);
3706   if (r == -1)
3707     rb_raise (e_Error, "%s", guestfs_last_error (g));
3708
3709   return Qnil;
3710 }
3711
3712 static VALUE ruby_guestfs_equal (VALUE gv, VALUE file1v, VALUE file2v)
3713 {
3714   guestfs_h *g;
3715   Data_Get_Struct (gv, guestfs_h, g);
3716   if (!g)
3717     rb_raise (rb_eArgError, "%s: used handle after closing it", "equal");
3718
3719   Check_Type (file1v, T_STRING);
3720   const char *file1 = StringValueCStr (file1v);
3721   if (!file1)
3722     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3723               "file1", "equal");
3724   Check_Type (file2v, T_STRING);
3725   const char *file2 = StringValueCStr (file2v);
3726   if (!file2)
3727     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3728               "file2", "equal");
3729
3730   int r;
3731
3732   r = guestfs_equal (g, file1, file2);
3733   if (r == -1)
3734     rb_raise (e_Error, "%s", guestfs_last_error (g));
3735
3736   return INT2NUM (r);
3737 }
3738
3739 static VALUE ruby_guestfs_strings (VALUE gv, VALUE pathv)
3740 {
3741   guestfs_h *g;
3742   Data_Get_Struct (gv, guestfs_h, g);
3743   if (!g)
3744     rb_raise (rb_eArgError, "%s: used handle after closing it", "strings");
3745
3746   Check_Type (pathv, T_STRING);
3747   const char *path = StringValueCStr (pathv);
3748   if (!path)
3749     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3750               "path", "strings");
3751
3752   char **r;
3753
3754   r = guestfs_strings (g, path);
3755   if (r == NULL)
3756     rb_raise (e_Error, "%s", guestfs_last_error (g));
3757
3758   int i, len = 0;
3759   for (i = 0; r[i] != NULL; ++i) len++;
3760   VALUE rv = rb_ary_new2 (len);
3761   for (i = 0; r[i] != NULL; ++i) {
3762     rb_ary_push (rv, rb_str_new2 (r[i]));
3763     free (r[i]);
3764   }
3765   free (r);
3766   return rv;
3767 }
3768
3769 static VALUE ruby_guestfs_strings_e (VALUE gv, VALUE encodingv, VALUE pathv)
3770 {
3771   guestfs_h *g;
3772   Data_Get_Struct (gv, guestfs_h, g);
3773   if (!g)
3774     rb_raise (rb_eArgError, "%s: used handle after closing it", "strings_e");
3775
3776   Check_Type (encodingv, T_STRING);
3777   const char *encoding = StringValueCStr (encodingv);
3778   if (!encoding)
3779     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3780               "encoding", "strings_e");
3781   Check_Type (pathv, T_STRING);
3782   const char *path = StringValueCStr (pathv);
3783   if (!path)
3784     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3785               "path", "strings_e");
3786
3787   char **r;
3788
3789   r = guestfs_strings_e (g, encoding, path);
3790   if (r == NULL)
3791     rb_raise (e_Error, "%s", guestfs_last_error (g));
3792
3793   int i, len = 0;
3794   for (i = 0; r[i] != NULL; ++i) len++;
3795   VALUE rv = rb_ary_new2 (len);
3796   for (i = 0; r[i] != NULL; ++i) {
3797     rb_ary_push (rv, rb_str_new2 (r[i]));
3798     free (r[i]);
3799   }
3800   free (r);
3801   return rv;
3802 }
3803
3804 static VALUE ruby_guestfs_hexdump (VALUE gv, VALUE pathv)
3805 {
3806   guestfs_h *g;
3807   Data_Get_Struct (gv, guestfs_h, g);
3808   if (!g)
3809     rb_raise (rb_eArgError, "%s: used handle after closing it", "hexdump");
3810
3811   Check_Type (pathv, T_STRING);
3812   const char *path = StringValueCStr (pathv);
3813   if (!path)
3814     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3815               "path", "hexdump");
3816
3817   char *r;
3818
3819   r = guestfs_hexdump (g, path);
3820   if (r == NULL)
3821     rb_raise (e_Error, "%s", guestfs_last_error (g));
3822
3823   VALUE rv = rb_str_new2 (r);
3824   free (r);
3825   return rv;
3826 }
3827
3828 static VALUE ruby_guestfs_zerofree (VALUE gv, VALUE devicev)
3829 {
3830   guestfs_h *g;
3831   Data_Get_Struct (gv, guestfs_h, g);
3832   if (!g)
3833     rb_raise (rb_eArgError, "%s: used handle after closing it", "zerofree");
3834
3835   Check_Type (devicev, T_STRING);
3836   const char *device = StringValueCStr (devicev);
3837   if (!device)
3838     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3839               "device", "zerofree");
3840
3841   int r;
3842
3843   r = guestfs_zerofree (g, device);
3844   if (r == -1)
3845     rb_raise (e_Error, "%s", guestfs_last_error (g));
3846
3847   return Qnil;
3848 }
3849
3850 static VALUE ruby_guestfs_pvresize (VALUE gv, VALUE devicev)
3851 {
3852   guestfs_h *g;
3853   Data_Get_Struct (gv, guestfs_h, g);
3854   if (!g)
3855     rb_raise (rb_eArgError, "%s: used handle after closing it", "pvresize");
3856
3857   Check_Type (devicev, T_STRING);
3858   const char *device = StringValueCStr (devicev);
3859   if (!device)
3860     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3861               "device", "pvresize");
3862
3863   int r;
3864
3865   r = guestfs_pvresize (g, device);
3866   if (r == -1)
3867     rb_raise (e_Error, "%s", guestfs_last_error (g));
3868
3869   return Qnil;
3870 }
3871
3872 static VALUE ruby_guestfs_sfdisk_N (VALUE gv, VALUE devicev, VALUE partnumv, VALUE cylsv, VALUE headsv, VALUE sectorsv, VALUE linev)
3873 {
3874   guestfs_h *g;
3875   Data_Get_Struct (gv, guestfs_h, g);
3876   if (!g)
3877     rb_raise (rb_eArgError, "%s: used handle after closing it", "sfdisk_N");
3878
3879   Check_Type (devicev, T_STRING);
3880   const char *device = StringValueCStr (devicev);
3881   if (!device)
3882     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3883               "device", "sfdisk_N");
3884   int partnum = NUM2INT (partnumv);
3885   int cyls = NUM2INT (cylsv);
3886   int heads = NUM2INT (headsv);
3887   int sectors = NUM2INT (sectorsv);
3888   Check_Type (linev, T_STRING);
3889   const char *line = StringValueCStr (linev);
3890   if (!line)
3891     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3892               "line", "sfdisk_N");
3893
3894   int r;
3895
3896   r = guestfs_sfdisk_N (g, device, partnum, cyls, heads, sectors, line);
3897   if (r == -1)
3898     rb_raise (e_Error, "%s", guestfs_last_error (g));
3899
3900   return Qnil;
3901 }
3902
3903 static VALUE ruby_guestfs_sfdisk_l (VALUE gv, VALUE devicev)
3904 {
3905   guestfs_h *g;
3906   Data_Get_Struct (gv, guestfs_h, g);
3907   if (!g)
3908     rb_raise (rb_eArgError, "%s: used handle after closing it", "sfdisk_l");
3909
3910   Check_Type (devicev, T_STRING);
3911   const char *device = StringValueCStr (devicev);
3912   if (!device)
3913     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3914               "device", "sfdisk_l");
3915
3916   char *r;
3917
3918   r = guestfs_sfdisk_l (g, device);
3919   if (r == NULL)
3920     rb_raise (e_Error, "%s", guestfs_last_error (g));
3921
3922   VALUE rv = rb_str_new2 (r);
3923   free (r);
3924   return rv;
3925 }
3926
3927 static VALUE ruby_guestfs_sfdisk_kernel_geometry (VALUE gv, VALUE devicev)
3928 {
3929   guestfs_h *g;
3930   Data_Get_Struct (gv, guestfs_h, g);
3931   if (!g)
3932     rb_raise (rb_eArgError, "%s: used handle after closing it", "sfdisk_kernel_geometry");
3933
3934   Check_Type (devicev, T_STRING);
3935   const char *device = StringValueCStr (devicev);
3936   if (!device)
3937     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3938               "device", "sfdisk_kernel_geometry");
3939
3940   char *r;
3941
3942   r = guestfs_sfdisk_kernel_geometry (g, device);
3943   if (r == NULL)
3944     rb_raise (e_Error, "%s", guestfs_last_error (g));
3945
3946   VALUE rv = rb_str_new2 (r);
3947   free (r);
3948   return rv;
3949 }
3950
3951 static VALUE ruby_guestfs_sfdisk_disk_geometry (VALUE gv, VALUE devicev)
3952 {
3953   guestfs_h *g;
3954   Data_Get_Struct (gv, guestfs_h, g);
3955   if (!g)
3956     rb_raise (rb_eArgError, "%s: used handle after closing it", "sfdisk_disk_geometry");
3957
3958   Check_Type (devicev, T_STRING);
3959   const char *device = StringValueCStr (devicev);
3960   if (!device)
3961     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3962               "device", "sfdisk_disk_geometry");
3963
3964   char *r;
3965
3966   r = guestfs_sfdisk_disk_geometry (g, device);
3967   if (r == NULL)
3968     rb_raise (e_Error, "%s", guestfs_last_error (g));
3969
3970   VALUE rv = rb_str_new2 (r);
3971   free (r);
3972   return rv;
3973 }
3974
3975 static VALUE ruby_guestfs_vg_activate_all (VALUE gv, VALUE activatev)
3976 {
3977   guestfs_h *g;
3978   Data_Get_Struct (gv, guestfs_h, g);
3979   if (!g)
3980     rb_raise (rb_eArgError, "%s: used handle after closing it", "vg_activate_all");
3981
3982   int activate = RTEST (activatev);
3983
3984   int r;
3985
3986   r = guestfs_vg_activate_all (g, activate);
3987   if (r == -1)
3988     rb_raise (e_Error, "%s", guestfs_last_error (g));
3989
3990   return Qnil;
3991 }
3992
3993 static VALUE ruby_guestfs_vg_activate (VALUE gv, VALUE activatev, VALUE volgroupsv)
3994 {
3995   guestfs_h *g;
3996   Data_Get_Struct (gv, guestfs_h, g);
3997   if (!g)
3998     rb_raise (rb_eArgError, "%s: used handle after closing it", "vg_activate");
3999
4000   int activate = RTEST (activatev);
4001   char **volgroups;
4002   Check_Type (volgroupsv, T_ARRAY);
4003   {
4004     int i, len;
4005     len = RARRAY_LEN (volgroupsv);
4006     volgroups = guestfs_safe_malloc (g, sizeof (char *) * (len+1));
4007     for (i = 0; i < len; ++i) {
4008       VALUE v = rb_ary_entry (volgroupsv, i);
4009       volgroups[i] = StringValueCStr (v);
4010     }
4011     volgroups[len] = NULL;
4012   }
4013
4014   int r;
4015
4016   r = guestfs_vg_activate (g, activate, volgroups);
4017   free (volgroups);
4018   if (r == -1)
4019     rb_raise (e_Error, "%s", guestfs_last_error (g));
4020
4021   return Qnil;
4022 }
4023
4024 static VALUE ruby_guestfs_lvresize (VALUE gv, VALUE devicev, VALUE mbytesv)
4025 {
4026   guestfs_h *g;
4027   Data_Get_Struct (gv, guestfs_h, g);
4028   if (!g)
4029     rb_raise (rb_eArgError, "%s: used handle after closing it", "lvresize");
4030
4031   Check_Type (devicev, T_STRING);
4032   const char *device = StringValueCStr (devicev);
4033   if (!device)
4034     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
4035               "device", "lvresize");
4036   int mbytes = NUM2INT (mbytesv);
4037
4038   int r;
4039
4040   r = guestfs_lvresize (g, device, mbytes);
4041   if (r == -1)
4042     rb_raise (e_Error, "%s", guestfs_last_error (g));
4043
4044   return Qnil;
4045 }
4046
4047 static VALUE ruby_guestfs_resize2fs (VALUE gv, VALUE devicev)
4048 {
4049   guestfs_h *g;
4050   Data_Get_Struct (gv, guestfs_h, g);
4051   if (!g)
4052     rb_raise (rb_eArgError, "%s: used handle after closing it", "resize2fs");
4053
4054   Check_Type (devicev, T_STRING);
4055   const char *device = StringValueCStr (devicev);
4056   if (!device)
4057     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
4058               "device", "resize2fs");
4059
4060   int r;
4061
4062   r = guestfs_resize2fs (g, device);
4063   if (r == -1)
4064     rb_raise (e_Error, "%s", guestfs_last_error (g));
4065
4066   return Qnil;
4067 }
4068
4069 static VALUE ruby_guestfs_find (VALUE gv, VALUE directoryv)
4070 {
4071   guestfs_h *g;
4072   Data_Get_Struct (gv, guestfs_h, g);
4073   if (!g)
4074     rb_raise (rb_eArgError, "%s: used handle after closing it", "find");
4075
4076   Check_Type (directoryv, T_STRING);
4077   const char *directory = StringValueCStr (directoryv);
4078   if (!directory)
4079     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
4080               "directory", "find");
4081
4082   char **r;
4083
4084   r = guestfs_find (g, directory);
4085   if (r == NULL)
4086     rb_raise (e_Error, "%s", guestfs_last_error (g));
4087
4088   int i, len = 0;
4089   for (i = 0; r[i] != NULL; ++i) len++;
4090   VALUE rv = rb_ary_new2 (len);
4091   for (i = 0; r[i] != NULL; ++i) {
4092     rb_ary_push (rv, rb_str_new2 (r[i]));
4093     free (r[i]);
4094   }
4095   free (r);
4096   return rv;
4097 }
4098
4099 static VALUE ruby_guestfs_e2fsck_f (VALUE gv, VALUE devicev)
4100 {
4101   guestfs_h *g;
4102   Data_Get_Struct (gv, guestfs_h, g);
4103   if (!g)
4104     rb_raise (rb_eArgError, "%s: used handle after closing it", "e2fsck_f");
4105
4106   Check_Type (devicev, T_STRING);
4107   const char *device = StringValueCStr (devicev);
4108   if (!device)
4109     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
4110               "device", "e2fsck_f");
4111
4112   int r;
4113
4114   r = guestfs_e2fsck_f (g, device);
4115   if (r == -1)
4116     rb_raise (e_Error, "%s", guestfs_last_error (g));
4117
4118   return Qnil;
4119 }
4120
4121 static VALUE ruby_guestfs_sleep (VALUE gv, VALUE secsv)
4122 {
4123   guestfs_h *g;
4124   Data_Get_Struct (gv, guestfs_h, g);
4125   if (!g)
4126     rb_raise (rb_eArgError, "%s: used handle after closing it", "sleep");
4127
4128   int secs = NUM2INT (secsv);
4129
4130   int r;
4131
4132   r = guestfs_sleep (g, secs);
4133   if (r == -1)
4134     rb_raise (e_Error, "%s", guestfs_last_error (g));
4135
4136   return Qnil;
4137 }
4138
4139 static VALUE ruby_guestfs_ntfs_3g_probe (VALUE gv, VALUE rwv, VALUE devicev)
4140 {
4141   guestfs_h *g;
4142   Data_Get_Struct (gv, guestfs_h, g);
4143   if (!g)
4144     rb_raise (rb_eArgError, "%s: used handle after closing it", "ntfs_3g_probe");
4145
4146   int rw = RTEST (rwv);
4147   Check_Type (devicev, T_STRING);
4148   const char *device = StringValueCStr (devicev);
4149   if (!device)
4150     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
4151               "device", "ntfs_3g_probe");
4152
4153   int r;
4154
4155   r = guestfs_ntfs_3g_probe (g, rw, device);
4156   if (r == -1)
4157     rb_raise (e_Error, "%s", guestfs_last_error (g));
4158
4159   return INT2NUM (r);
4160 }
4161
4162 static VALUE ruby_guestfs_sh (VALUE gv, VALUE commandv)
4163 {
4164   guestfs_h *g;
4165   Data_Get_Struct (gv, guestfs_h, g);
4166   if (!g)
4167     rb_raise (rb_eArgError, "%s: used handle after closing it", "sh");
4168
4169   Check_Type (commandv, T_STRING);
4170   const char *command = StringValueCStr (commandv);
4171   if (!command)
4172     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
4173               "command", "sh");
4174
4175   char *r;
4176
4177   r = guestfs_sh (g, command);
4178   if (r == NULL)
4179     rb_raise (e_Error, "%s", guestfs_last_error (g));
4180
4181   VALUE rv = rb_str_new2 (r);
4182   free (r);
4183   return rv;
4184 }
4185
4186 static VALUE ruby_guestfs_sh_lines (VALUE gv, VALUE commandv)
4187 {
4188   guestfs_h *g;
4189   Data_Get_Struct (gv, guestfs_h, g);
4190   if (!g)
4191     rb_raise (rb_eArgError, "%s: used handle after closing it", "sh_lines");
4192
4193   Check_Type (commandv, T_STRING);
4194   const char *command = StringValueCStr (commandv);
4195   if (!command)
4196     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
4197               "command", "sh_lines");
4198
4199   char **r;
4200
4201   r = guestfs_sh_lines (g, command);
4202   if (r == NULL)
4203     rb_raise (e_Error, "%s", guestfs_last_error (g));
4204
4205   int i, len = 0;
4206   for (i = 0; r[i] != NULL; ++i) len++;
4207   VALUE rv = rb_ary_new2 (len);
4208   for (i = 0; r[i] != NULL; ++i) {
4209     rb_ary_push (rv, rb_str_new2 (r[i]));
4210     free (r[i]);
4211   }
4212   free (r);
4213   return rv;
4214 }
4215
4216 static VALUE ruby_guestfs_glob_expand (VALUE gv, VALUE patternv)
4217 {
4218   guestfs_h *g;
4219   Data_Get_Struct (gv, guestfs_h, g);
4220   if (!g)
4221     rb_raise (rb_eArgError, "%s: used handle after closing it", "glob_expand");
4222
4223   Check_Type (patternv, T_STRING);
4224   const char *pattern = StringValueCStr (patternv);
4225   if (!pattern)
4226     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
4227               "pattern", "glob_expand");
4228
4229   char **r;
4230
4231   r = guestfs_glob_expand (g, pattern);
4232   if (r == NULL)
4233     rb_raise (e_Error, "%s", guestfs_last_error (g));
4234
4235   int i, len = 0;
4236   for (i = 0; r[i] != NULL; ++i) len++;
4237   VALUE rv = rb_ary_new2 (len);
4238   for (i = 0; r[i] != NULL; ++i) {
4239     rb_ary_push (rv, rb_str_new2 (r[i]));
4240     free (r[i]);
4241   }
4242   free (r);
4243   return rv;
4244 }
4245
4246 static VALUE ruby_guestfs_scrub_device (VALUE gv, VALUE devicev)
4247 {
4248   guestfs_h *g;
4249   Data_Get_Struct (gv, guestfs_h, g);
4250   if (!g)
4251     rb_raise (rb_eArgError, "%s: used handle after closing it", "scrub_device");
4252
4253   Check_Type (devicev, T_STRING);
4254   const char *device = StringValueCStr (devicev);
4255   if (!device)
4256     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
4257               "device", "scrub_device");
4258
4259   int r;
4260
4261   r = guestfs_scrub_device (g, device);
4262   if (r == -1)
4263     rb_raise (e_Error, "%s", guestfs_last_error (g));
4264
4265   return Qnil;
4266 }
4267
4268 static VALUE ruby_guestfs_scrub_file (VALUE gv, VALUE filev)
4269 {
4270   guestfs_h *g;
4271   Data_Get_Struct (gv, guestfs_h, g);
4272   if (!g)
4273     rb_raise (rb_eArgError, "%s: used handle after closing it", "scrub_file");
4274
4275   Check_Type (filev, T_STRING);
4276   const char *file = StringValueCStr (filev);
4277   if (!file)
4278     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
4279               "file", "scrub_file");
4280
4281   int r;
4282
4283   r = guestfs_scrub_file (g, file);
4284   if (r == -1)
4285     rb_raise (e_Error, "%s", guestfs_last_error (g));
4286
4287   return Qnil;
4288 }
4289
4290 static VALUE ruby_guestfs_scrub_freespace (VALUE gv, VALUE dirv)
4291 {
4292   guestfs_h *g;
4293   Data_Get_Struct (gv, guestfs_h, g);
4294   if (!g)
4295     rb_raise (rb_eArgError, "%s: used handle after closing it", "scrub_freespace");
4296
4297   Check_Type (dirv, T_STRING);
4298   const char *dir = StringValueCStr (dirv);
4299   if (!dir)
4300     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
4301               "dir", "scrub_freespace");
4302
4303   int r;
4304
4305   r = guestfs_scrub_freespace (g, dir);
4306   if (r == -1)
4307     rb_raise (e_Error, "%s", guestfs_last_error (g));
4308
4309   return Qnil;
4310 }
4311
4312 static VALUE ruby_guestfs_mkdtemp (VALUE gv, VALUE templatev)
4313 {
4314   guestfs_h *g;
4315   Data_Get_Struct (gv, guestfs_h, g);
4316   if (!g)
4317     rb_raise (rb_eArgError, "%s: used handle after closing it", "mkdtemp");
4318
4319   Check_Type (templatev, T_STRING);
4320   const char *template = StringValueCStr (templatev);
4321   if (!template)
4322     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
4323               "template", "mkdtemp");
4324
4325   char *r;
4326
4327   r = guestfs_mkdtemp (g, template);
4328   if (r == NULL)
4329     rb_raise (e_Error, "%s", guestfs_last_error (g));
4330
4331   VALUE rv = rb_str_new2 (r);
4332   free (r);
4333   return rv;
4334 }
4335
4336 static VALUE ruby_guestfs_wc_l (VALUE gv, VALUE pathv)
4337 {
4338   guestfs_h *g;
4339   Data_Get_Struct (gv, guestfs_h, g);
4340   if (!g)
4341     rb_raise (rb_eArgError, "%s: used handle after closing it", "wc_l");
4342
4343   Check_Type (pathv, T_STRING);
4344   const char *path = StringValueCStr (pathv);
4345   if (!path)
4346     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
4347               "path", "wc_l");
4348
4349   int r;
4350
4351   r = guestfs_wc_l (g, path);
4352   if (r == -1)
4353     rb_raise (e_Error, "%s", guestfs_last_error (g));
4354
4355   return INT2NUM (r);
4356 }
4357
4358 static VALUE ruby_guestfs_wc_w (VALUE gv, VALUE pathv)
4359 {
4360   guestfs_h *g;
4361   Data_Get_Struct (gv, guestfs_h, g);
4362   if (!g)
4363     rb_raise (rb_eArgError, "%s: used handle after closing it", "wc_w");
4364
4365   Check_Type (pathv, T_STRING);
4366   const char *path = StringValueCStr (pathv);
4367   if (!path)
4368     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
4369               "path", "wc_w");
4370
4371   int r;
4372
4373   r = guestfs_wc_w (g, path);
4374   if (r == -1)
4375     rb_raise (e_Error, "%s", guestfs_last_error (g));
4376
4377   return INT2NUM (r);
4378 }
4379
4380 static VALUE ruby_guestfs_wc_c (VALUE gv, VALUE pathv)
4381 {
4382   guestfs_h *g;
4383   Data_Get_Struct (gv, guestfs_h, g);
4384   if (!g)
4385     rb_raise (rb_eArgError, "%s: used handle after closing it", "wc_c");
4386
4387   Check_Type (pathv, T_STRING);
4388   const char *path = StringValueCStr (pathv);
4389   if (!path)
4390     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
4391               "path", "wc_c");
4392
4393   int r;
4394
4395   r = guestfs_wc_c (g, path);
4396   if (r == -1)
4397     rb_raise (e_Error, "%s", guestfs_last_error (g));
4398
4399   return INT2NUM (r);
4400 }
4401
4402 static VALUE ruby_guestfs_head (VALUE gv, VALUE pathv)
4403 {
4404   guestfs_h *g;
4405   Data_Get_Struct (gv, guestfs_h, g);
4406   if (!g)
4407     rb_raise (rb_eArgError, "%s: used handle after closing it", "head");
4408
4409   Check_Type (pathv, T_STRING);
4410   const char *path = StringValueCStr (pathv);
4411   if (!path)
4412     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
4413               "path", "head");
4414
4415   char **r;
4416
4417   r = guestfs_head (g, path);
4418   if (r == NULL)
4419     rb_raise (e_Error, "%s", guestfs_last_error (g));
4420
4421   int i, len = 0;
4422   for (i = 0; r[i] != NULL; ++i) len++;
4423   VALUE rv = rb_ary_new2 (len);
4424   for (i = 0; r[i] != NULL; ++i) {
4425     rb_ary_push (rv, rb_str_new2 (r[i]));
4426     free (r[i]);
4427   }
4428   free (r);
4429   return rv;
4430 }
4431
4432 static VALUE ruby_guestfs_head_n (VALUE gv, VALUE nrlinesv, VALUE pathv)
4433 {
4434   guestfs_h *g;
4435   Data_Get_Struct (gv, guestfs_h, g);
4436   if (!g)
4437     rb_raise (rb_eArgError, "%s: used handle after closing it", "head_n");
4438
4439   int nrlines = NUM2INT (nrlinesv);
4440   Check_Type (pathv, T_STRING);
4441   const char *path = StringValueCStr (pathv);
4442   if (!path)
4443     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
4444               "path", "head_n");
4445
4446   char **r;
4447
4448   r = guestfs_head_n (g, nrlines, path);
4449   if (r == NULL)
4450     rb_raise (e_Error, "%s", guestfs_last_error (g));
4451
4452   int i, len = 0;
4453   for (i = 0; r[i] != NULL; ++i) len++;
4454   VALUE rv = rb_ary_new2 (len);
4455   for (i = 0; r[i] != NULL; ++i) {
4456     rb_ary_push (rv, rb_str_new2 (r[i]));
4457     free (r[i]);
4458   }
4459   free (r);
4460   return rv;
4461 }
4462
4463 static VALUE ruby_guestfs_tail (VALUE gv, VALUE pathv)
4464 {
4465   guestfs_h *g;
4466   Data_Get_Struct (gv, guestfs_h, g);
4467   if (!g)
4468     rb_raise (rb_eArgError, "%s: used handle after closing it", "tail");
4469
4470   Check_Type (pathv, T_STRING);
4471   const char *path = StringValueCStr (pathv);
4472   if (!path)
4473     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
4474               "path", "tail");
4475
4476   char **r;
4477
4478   r = guestfs_tail (g, path);
4479   if (r == NULL)
4480     rb_raise (e_Error, "%s", guestfs_last_error (g));
4481
4482   int i, len = 0;
4483   for (i = 0; r[i] != NULL; ++i) len++;
4484   VALUE rv = rb_ary_new2 (len);
4485   for (i = 0; r[i] != NULL; ++i) {
4486     rb_ary_push (rv, rb_str_new2 (r[i]));
4487     free (r[i]);
4488   }
4489   free (r);
4490   return rv;
4491 }
4492
4493 static VALUE ruby_guestfs_tail_n (VALUE gv, VALUE nrlinesv, VALUE pathv)
4494 {
4495   guestfs_h *g;
4496   Data_Get_Struct (gv, guestfs_h, g);
4497   if (!g)
4498     rb_raise (rb_eArgError, "%s: used handle after closing it", "tail_n");
4499
4500   int nrlines = NUM2INT (nrlinesv);
4501   Check_Type (pathv, T_STRING);
4502   const char *path = StringValueCStr (pathv);
4503   if (!path)
4504     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
4505               "path", "tail_n");
4506
4507   char **r;
4508
4509   r = guestfs_tail_n (g, nrlines, path);
4510   if (r == NULL)
4511     rb_raise (e_Error, "%s", guestfs_last_error (g));
4512
4513   int i, len = 0;
4514   for (i = 0; r[i] != NULL; ++i) len++;
4515   VALUE rv = rb_ary_new2 (len);
4516   for (i = 0; r[i] != NULL; ++i) {
4517     rb_ary_push (rv, rb_str_new2 (r[i]));
4518     free (r[i]);
4519   }
4520   free (r);
4521   return rv;
4522 }
4523
4524 static VALUE ruby_guestfs_df (VALUE gv)
4525 {
4526   guestfs_h *g;
4527   Data_Get_Struct (gv, guestfs_h, g);
4528   if (!g)
4529     rb_raise (rb_eArgError, "%s: used handle after closing it", "df");
4530
4531
4532   char *r;
4533
4534   r = guestfs_df (g);
4535   if (r == NULL)
4536     rb_raise (e_Error, "%s", guestfs_last_error (g));
4537
4538   VALUE rv = rb_str_new2 (r);
4539   free (r);
4540   return rv;
4541 }
4542
4543 static VALUE ruby_guestfs_df_h (VALUE gv)
4544 {
4545   guestfs_h *g;
4546   Data_Get_Struct (gv, guestfs_h, g);
4547   if (!g)
4548     rb_raise (rb_eArgError, "%s: used handle after closing it", "df_h");
4549
4550
4551   char *r;
4552
4553   r = guestfs_df_h (g);
4554   if (r == NULL)
4555     rb_raise (e_Error, "%s", guestfs_last_error (g));
4556
4557   VALUE rv = rb_str_new2 (r);
4558   free (r);
4559   return rv;
4560 }
4561
4562 static VALUE ruby_guestfs_du (VALUE gv, VALUE pathv)
4563 {
4564   guestfs_h *g;
4565   Data_Get_Struct (gv, guestfs_h, g);
4566   if (!g)
4567     rb_raise (rb_eArgError, "%s: used handle after closing it", "du");
4568
4569   Check_Type (pathv, T_STRING);
4570   const char *path = StringValueCStr (pathv);
4571   if (!path)
4572     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
4573               "path", "du");
4574
4575   int64_t r;
4576
4577   r = guestfs_du (g, path);
4578   if (r == -1)
4579     rb_raise (e_Error, "%s", guestfs_last_error (g));
4580
4581   return ULL2NUM (r);
4582 }
4583
4584 static VALUE ruby_guestfs_initrd_list (VALUE gv, VALUE pathv)
4585 {
4586   guestfs_h *g;
4587   Data_Get_Struct (gv, guestfs_h, g);
4588   if (!g)
4589     rb_raise (rb_eArgError, "%s: used handle after closing it", "initrd_list");
4590
4591   Check_Type (pathv, T_STRING);
4592   const char *path = StringValueCStr (pathv);
4593   if (!path)
4594     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
4595               "path", "initrd_list");
4596
4597   char **r;
4598
4599   r = guestfs_initrd_list (g, path);
4600   if (r == NULL)
4601     rb_raise (e_Error, "%s", guestfs_last_error (g));
4602
4603   int i, len = 0;
4604   for (i = 0; r[i] != NULL; ++i) len++;
4605   VALUE rv = rb_ary_new2 (len);
4606   for (i = 0; r[i] != NULL; ++i) {
4607     rb_ary_push (rv, rb_str_new2 (r[i]));
4608     free (r[i]);
4609   }
4610   free (r);
4611   return rv;
4612 }
4613
4614 /* Initialize the module. */
4615 void Init__guestfs ()
4616 {
4617   m_guestfs = rb_define_module ("Guestfs");
4618   c_guestfs = rb_define_class_under (m_guestfs, "Guestfs", rb_cObject);
4619   e_Error = rb_define_class_under (m_guestfs, "Error", rb_eStandardError);
4620
4621   rb_define_module_function (m_guestfs, "create", ruby_guestfs_create, 0);
4622   rb_define_method (c_guestfs, "close", ruby_guestfs_close, 0);
4623
4624   rb_define_method (c_guestfs, "test0",
4625         ruby_guestfs_test0, 7);
4626   rb_define_method (c_guestfs, "test0rint",
4627         ruby_guestfs_test0rint, 1);
4628   rb_define_method (c_guestfs, "test0rinterr",
4629         ruby_guestfs_test0rinterr, 0);
4630   rb_define_method (c_guestfs, "test0rint64",
4631         ruby_guestfs_test0rint64, 1);
4632   rb_define_method (c_guestfs, "test0rint64err",
4633         ruby_guestfs_test0rint64err, 0);
4634   rb_define_method (c_guestfs, "test0rbool",
4635         ruby_guestfs_test0rbool, 1);
4636   rb_define_method (c_guestfs, "test0rboolerr",
4637         ruby_guestfs_test0rboolerr, 0);
4638   rb_define_method (c_guestfs, "test0rconststring",
4639         ruby_guestfs_test0rconststring, 1);
4640   rb_define_method (c_guestfs, "test0rconststringerr",
4641         ruby_guestfs_test0rconststringerr, 0);
4642   rb_define_method (c_guestfs, "test0rstring",
4643         ruby_guestfs_test0rstring, 1);
4644   rb_define_method (c_guestfs, "test0rstringerr",
4645         ruby_guestfs_test0rstringerr, 0);
4646   rb_define_method (c_guestfs, "test0rstringlist",
4647         ruby_guestfs_test0rstringlist, 1);
4648   rb_define_method (c_guestfs, "test0rstringlisterr",
4649         ruby_guestfs_test0rstringlisterr, 0);
4650   rb_define_method (c_guestfs, "test0rintbool",
4651         ruby_guestfs_test0rintbool, 1);
4652   rb_define_method (c_guestfs, "test0rintboolerr",
4653         ruby_guestfs_test0rintboolerr, 0);
4654   rb_define_method (c_guestfs, "test0rpvlist",
4655         ruby_guestfs_test0rpvlist, 1);
4656   rb_define_method (c_guestfs, "test0rpvlisterr",
4657         ruby_guestfs_test0rpvlisterr, 0);
4658   rb_define_method (c_guestfs, "test0rvglist",
4659         ruby_guestfs_test0rvglist, 1);
4660   rb_define_method (c_guestfs, "test0rvglisterr",
4661         ruby_guestfs_test0rvglisterr, 0);
4662   rb_define_method (c_guestfs, "test0rlvlist",
4663         ruby_guestfs_test0rlvlist, 1);
4664   rb_define_method (c_guestfs, "test0rlvlisterr",
4665         ruby_guestfs_test0rlvlisterr, 0);
4666   rb_define_method (c_guestfs, "test0rstat",
4667         ruby_guestfs_test0rstat, 1);
4668   rb_define_method (c_guestfs, "test0rstaterr",
4669         ruby_guestfs_test0rstaterr, 0);
4670   rb_define_method (c_guestfs, "test0rstatvfs",
4671         ruby_guestfs_test0rstatvfs, 1);
4672   rb_define_method (c_guestfs, "test0rstatvfserr",
4673         ruby_guestfs_test0rstatvfserr, 0);
4674   rb_define_method (c_guestfs, "test0rhashtable",
4675         ruby_guestfs_test0rhashtable, 1);
4676   rb_define_method (c_guestfs, "test0rhashtableerr",
4677         ruby_guestfs_test0rhashtableerr, 0);
4678   rb_define_method (c_guestfs, "launch",
4679         ruby_guestfs_launch, 0);
4680   rb_define_method (c_guestfs, "wait_ready",
4681         ruby_guestfs_wait_ready, 0);
4682   rb_define_method (c_guestfs, "kill_subprocess",
4683         ruby_guestfs_kill_subprocess, 0);
4684   rb_define_method (c_guestfs, "add_drive",
4685         ruby_guestfs_add_drive, 1);
4686   rb_define_method (c_guestfs, "add_cdrom",
4687         ruby_guestfs_add_cdrom, 1);
4688   rb_define_method (c_guestfs, "add_drive_ro",
4689         ruby_guestfs_add_drive_ro, 1);
4690   rb_define_method (c_guestfs, "config",
4691         ruby_guestfs_config, 2);
4692   rb_define_method (c_guestfs, "set_qemu",
4693         ruby_guestfs_set_qemu, 1);
4694   rb_define_method (c_guestfs, "get_qemu",
4695         ruby_guestfs_get_qemu, 0);
4696   rb_define_method (c_guestfs, "set_path",
4697         ruby_guestfs_set_path, 1);
4698   rb_define_method (c_guestfs, "get_path",
4699         ruby_guestfs_get_path, 0);
4700   rb_define_method (c_guestfs, "set_append",
4701         ruby_guestfs_set_append, 1);
4702   rb_define_method (c_guestfs, "get_append",
4703         ruby_guestfs_get_append, 0);
4704   rb_define_method (c_guestfs, "set_autosync",
4705         ruby_guestfs_set_autosync, 1);
4706   rb_define_method (c_guestfs, "get_autosync",
4707         ruby_guestfs_get_autosync, 0);
4708   rb_define_method (c_guestfs, "set_verbose",
4709         ruby_guestfs_set_verbose, 1);
4710   rb_define_method (c_guestfs, "get_verbose",
4711         ruby_guestfs_get_verbose, 0);
4712   rb_define_method (c_guestfs, "is_ready",
4713         ruby_guestfs_is_ready, 0);
4714   rb_define_method (c_guestfs, "is_config",
4715         ruby_guestfs_is_config, 0);
4716   rb_define_method (c_guestfs, "is_launching",
4717         ruby_guestfs_is_launching, 0);
4718   rb_define_method (c_guestfs, "is_busy",
4719         ruby_guestfs_is_busy, 0);
4720   rb_define_method (c_guestfs, "get_state",
4721         ruby_guestfs_get_state, 0);
4722   rb_define_method (c_guestfs, "set_busy",
4723         ruby_guestfs_set_busy, 0);
4724   rb_define_method (c_guestfs, "set_ready",
4725         ruby_guestfs_set_ready, 0);
4726   rb_define_method (c_guestfs, "end_busy",
4727         ruby_guestfs_end_busy, 0);
4728   rb_define_method (c_guestfs, "mount",
4729         ruby_guestfs_mount, 2);
4730   rb_define_method (c_guestfs, "sync",
4731         ruby_guestfs_sync, 0);
4732   rb_define_method (c_guestfs, "touch",
4733         ruby_guestfs_touch, 1);
4734   rb_define_method (c_guestfs, "cat",
4735         ruby_guestfs_cat, 1);
4736   rb_define_method (c_guestfs, "ll",
4737         ruby_guestfs_ll, 1);
4738   rb_define_method (c_guestfs, "ls",
4739         ruby_guestfs_ls, 1);
4740   rb_define_method (c_guestfs, "list_devices",
4741         ruby_guestfs_list_devices, 0);
4742   rb_define_method (c_guestfs, "list_partitions",
4743         ruby_guestfs_list_partitions, 0);
4744   rb_define_method (c_guestfs, "pvs",
4745         ruby_guestfs_pvs, 0);
4746   rb_define_method (c_guestfs, "vgs",
4747         ruby_guestfs_vgs, 0);
4748   rb_define_method (c_guestfs, "lvs",
4749         ruby_guestfs_lvs, 0);
4750   rb_define_method (c_guestfs, "pvs_full",
4751         ruby_guestfs_pvs_full, 0);
4752   rb_define_method (c_guestfs, "vgs_full",
4753         ruby_guestfs_vgs_full, 0);
4754   rb_define_method (c_guestfs, "lvs_full",
4755         ruby_guestfs_lvs_full, 0);
4756   rb_define_method (c_guestfs, "read_lines",
4757         ruby_guestfs_read_lines, 1);
4758   rb_define_method (c_guestfs, "aug_init",
4759         ruby_guestfs_aug_init, 2);
4760   rb_define_method (c_guestfs, "aug_close",
4761         ruby_guestfs_aug_close, 0);
4762   rb_define_method (c_guestfs, "aug_defvar",
4763         ruby_guestfs_aug_defvar, 2);
4764   rb_define_method (c_guestfs, "aug_defnode",
4765         ruby_guestfs_aug_defnode, 3);
4766   rb_define_method (c_guestfs, "aug_get",
4767         ruby_guestfs_aug_get, 1);
4768   rb_define_method (c_guestfs, "aug_set",
4769         ruby_guestfs_aug_set, 2);
4770   rb_define_method (c_guestfs, "aug_insert",
4771         ruby_guestfs_aug_insert, 3);
4772   rb_define_method (c_guestfs, "aug_rm",
4773         ruby_guestfs_aug_rm, 1);
4774   rb_define_method (c_guestfs, "aug_mv",
4775         ruby_guestfs_aug_mv, 2);
4776   rb_define_method (c_guestfs, "aug_match",
4777         ruby_guestfs_aug_match, 1);
4778   rb_define_method (c_guestfs, "aug_save",
4779         ruby_guestfs_aug_save, 0);
4780   rb_define_method (c_guestfs, "aug_load",
4781         ruby_guestfs_aug_load, 0);
4782   rb_define_method (c_guestfs, "aug_ls",
4783         ruby_guestfs_aug_ls, 1);
4784   rb_define_method (c_guestfs, "rm",
4785         ruby_guestfs_rm, 1);
4786   rb_define_method (c_guestfs, "rmdir",
4787         ruby_guestfs_rmdir, 1);
4788   rb_define_method (c_guestfs, "rm_rf",
4789         ruby_guestfs_rm_rf, 1);
4790   rb_define_method (c_guestfs, "mkdir",
4791         ruby_guestfs_mkdir, 1);
4792   rb_define_method (c_guestfs, "mkdir_p",
4793         ruby_guestfs_mkdir_p, 1);
4794   rb_define_method (c_guestfs, "chmod",
4795         ruby_guestfs_chmod, 2);
4796   rb_define_method (c_guestfs, "chown",
4797         ruby_guestfs_chown, 3);
4798   rb_define_method (c_guestfs, "exists",
4799         ruby_guestfs_exists, 1);
4800   rb_define_method (c_guestfs, "is_file",
4801         ruby_guestfs_is_file, 1);
4802   rb_define_method (c_guestfs, "is_dir",
4803         ruby_guestfs_is_dir, 1);
4804   rb_define_method (c_guestfs, "pvcreate",
4805         ruby_guestfs_pvcreate, 1);
4806   rb_define_method (c_guestfs, "vgcreate",
4807         ruby_guestfs_vgcreate, 2);
4808   rb_define_method (c_guestfs, "lvcreate",
4809         ruby_guestfs_lvcreate, 3);
4810   rb_define_method (c_guestfs, "mkfs",
4811         ruby_guestfs_mkfs, 2);
4812   rb_define_method (c_guestfs, "sfdisk",
4813         ruby_guestfs_sfdisk, 5);
4814   rb_define_method (c_guestfs, "write_file",
4815         ruby_guestfs_write_file, 3);
4816   rb_define_method (c_guestfs, "umount",
4817         ruby_guestfs_umount, 1);
4818   rb_define_method (c_guestfs, "mounts",
4819         ruby_guestfs_mounts, 0);
4820   rb_define_method (c_guestfs, "umount_all",
4821         ruby_guestfs_umount_all, 0);
4822   rb_define_method (c_guestfs, "lvm_remove_all",
4823         ruby_guestfs_lvm_remove_all, 0);
4824   rb_define_method (c_guestfs, "file",
4825         ruby_guestfs_file, 1);
4826   rb_define_method (c_guestfs, "command",
4827         ruby_guestfs_command, 1);
4828   rb_define_method (c_guestfs, "command_lines",
4829         ruby_guestfs_command_lines, 1);
4830   rb_define_method (c_guestfs, "stat",
4831         ruby_guestfs_stat, 1);
4832   rb_define_method (c_guestfs, "lstat",
4833         ruby_guestfs_lstat, 1);
4834   rb_define_method (c_guestfs, "statvfs",
4835         ruby_guestfs_statvfs, 1);
4836   rb_define_method (c_guestfs, "tune2fs_l",
4837         ruby_guestfs_tune2fs_l, 1);
4838   rb_define_method (c_guestfs, "blockdev_setro",
4839         ruby_guestfs_blockdev_setro, 1);
4840   rb_define_method (c_guestfs, "blockdev_setrw",
4841         ruby_guestfs_blockdev_setrw, 1);
4842   rb_define_method (c_guestfs, "blockdev_getro",
4843         ruby_guestfs_blockdev_getro, 1);
4844   rb_define_method (c_guestfs, "blockdev_getss",
4845         ruby_guestfs_blockdev_getss, 1);
4846   rb_define_method (c_guestfs, "blockdev_getbsz",
4847         ruby_guestfs_blockdev_getbsz, 1);
4848   rb_define_method (c_guestfs, "blockdev_setbsz",
4849         ruby_guestfs_blockdev_setbsz, 2);
4850   rb_define_method (c_guestfs, "blockdev_getsz",
4851         ruby_guestfs_blockdev_getsz, 1);
4852   rb_define_method (c_guestfs, "blockdev_getsize64",
4853         ruby_guestfs_blockdev_getsize64, 1);
4854   rb_define_method (c_guestfs, "blockdev_flushbufs",
4855         ruby_guestfs_blockdev_flushbufs, 1);
4856   rb_define_method (c_guestfs, "blockdev_rereadpt",
4857         ruby_guestfs_blockdev_rereadpt, 1);
4858   rb_define_method (c_guestfs, "upload",
4859         ruby_guestfs_upload, 2);
4860   rb_define_method (c_guestfs, "download",
4861         ruby_guestfs_download, 2);
4862   rb_define_method (c_guestfs, "checksum",
4863         ruby_guestfs_checksum, 2);
4864   rb_define_method (c_guestfs, "tar_in",
4865         ruby_guestfs_tar_in, 2);
4866   rb_define_method (c_guestfs, "tar_out",
4867         ruby_guestfs_tar_out, 2);
4868   rb_define_method (c_guestfs, "tgz_in",
4869         ruby_guestfs_tgz_in, 2);
4870   rb_define_method (c_guestfs, "tgz_out",
4871         ruby_guestfs_tgz_out, 2);
4872   rb_define_method (c_guestfs, "mount_ro",
4873         ruby_guestfs_mount_ro, 2);
4874   rb_define_method (c_guestfs, "mount_options",
4875         ruby_guestfs_mount_options, 3);
4876   rb_define_method (c_guestfs, "mount_vfs",
4877         ruby_guestfs_mount_vfs, 4);
4878   rb_define_method (c_guestfs, "debug",
4879         ruby_guestfs_debug, 2);
4880   rb_define_method (c_guestfs, "lvremove",
4881         ruby_guestfs_lvremove, 1);
4882   rb_define_method (c_guestfs, "vgremove",
4883         ruby_guestfs_vgremove, 1);
4884   rb_define_method (c_guestfs, "pvremove",
4885         ruby_guestfs_pvremove, 1);
4886   rb_define_method (c_guestfs, "set_e2label",
4887         ruby_guestfs_set_e2label, 2);
4888   rb_define_method (c_guestfs, "get_e2label",
4889         ruby_guestfs_get_e2label, 1);
4890   rb_define_method (c_guestfs, "set_e2uuid",
4891         ruby_guestfs_set_e2uuid, 2);
4892   rb_define_method (c_guestfs, "get_e2uuid",
4893         ruby_guestfs_get_e2uuid, 1);
4894   rb_define_method (c_guestfs, "fsck",
4895         ruby_guestfs_fsck, 2);
4896   rb_define_method (c_guestfs, "zero",
4897         ruby_guestfs_zero, 1);
4898   rb_define_method (c_guestfs, "grub_install",
4899         ruby_guestfs_grub_install, 2);
4900   rb_define_method (c_guestfs, "cp",
4901         ruby_guestfs_cp, 2);
4902   rb_define_method (c_guestfs, "cp_a",
4903         ruby_guestfs_cp_a, 2);
4904   rb_define_method (c_guestfs, "mv",
4905         ruby_guestfs_mv, 2);
4906   rb_define_method (c_guestfs, "drop_caches",
4907         ruby_guestfs_drop_caches, 1);
4908   rb_define_method (c_guestfs, "dmesg",
4909         ruby_guestfs_dmesg, 0);
4910   rb_define_method (c_guestfs, "ping_daemon",
4911         ruby_guestfs_ping_daemon, 0);
4912   rb_define_method (c_guestfs, "equal",
4913         ruby_guestfs_equal, 2);
4914   rb_define_method (c_guestfs, "strings",
4915         ruby_guestfs_strings, 1);
4916   rb_define_method (c_guestfs, "strings_e",
4917         ruby_guestfs_strings_e, 2);
4918   rb_define_method (c_guestfs, "hexdump",
4919         ruby_guestfs_hexdump, 1);
4920   rb_define_method (c_guestfs, "zerofree",
4921         ruby_guestfs_zerofree, 1);
4922   rb_define_method (c_guestfs, "pvresize",
4923         ruby_guestfs_pvresize, 1);
4924   rb_define_method (c_guestfs, "sfdisk_N",
4925         ruby_guestfs_sfdisk_N, 6);
4926   rb_define_method (c_guestfs, "sfdisk_l",
4927         ruby_guestfs_sfdisk_l, 1);
4928   rb_define_method (c_guestfs, "sfdisk_kernel_geometry",
4929         ruby_guestfs_sfdisk_kernel_geometry, 1);
4930   rb_define_method (c_guestfs, "sfdisk_disk_geometry",
4931         ruby_guestfs_sfdisk_disk_geometry, 1);
4932   rb_define_method (c_guestfs, "vg_activate_all",
4933         ruby_guestfs_vg_activate_all, 1);
4934   rb_define_method (c_guestfs, "vg_activate",
4935         ruby_guestfs_vg_activate, 2);
4936   rb_define_method (c_guestfs, "lvresize",
4937         ruby_guestfs_lvresize, 2);
4938   rb_define_method (c_guestfs, "resize2fs",
4939         ruby_guestfs_resize2fs, 1);
4940   rb_define_method (c_guestfs, "find",
4941         ruby_guestfs_find, 1);
4942   rb_define_method (c_guestfs, "e2fsck_f",
4943         ruby_guestfs_e2fsck_f, 1);
4944   rb_define_method (c_guestfs, "sleep",
4945         ruby_guestfs_sleep, 1);
4946   rb_define_method (c_guestfs, "ntfs_3g_probe",
4947         ruby_guestfs_ntfs_3g_probe, 2);
4948   rb_define_method (c_guestfs, "sh",
4949         ruby_guestfs_sh, 1);
4950   rb_define_method (c_guestfs, "sh_lines",
4951         ruby_guestfs_sh_lines, 1);
4952   rb_define_method (c_guestfs, "glob_expand",
4953         ruby_guestfs_glob_expand, 1);
4954   rb_define_method (c_guestfs, "scrub_device",
4955         ruby_guestfs_scrub_device, 1);
4956   rb_define_method (c_guestfs, "scrub_file",
4957         ruby_guestfs_scrub_file, 1);
4958   rb_define_method (c_guestfs, "scrub_freespace",
4959         ruby_guestfs_scrub_freespace, 1);
4960   rb_define_method (c_guestfs, "mkdtemp",
4961         ruby_guestfs_mkdtemp, 1);
4962   rb_define_method (c_guestfs, "wc_l",
4963         ruby_guestfs_wc_l, 1);
4964   rb_define_method (c_guestfs, "wc_w",
4965         ruby_guestfs_wc_w, 1);
4966   rb_define_method (c_guestfs, "wc_c",
4967         ruby_guestfs_wc_c, 1);
4968   rb_define_method (c_guestfs, "head",
4969         ruby_guestfs_head, 1);
4970   rb_define_method (c_guestfs, "head_n",
4971         ruby_guestfs_head_n, 2);
4972   rb_define_method (c_guestfs, "tail",
4973         ruby_guestfs_tail, 1);
4974   rb_define_method (c_guestfs, "tail_n",
4975         ruby_guestfs_tail_n, 2);
4976   rb_define_method (c_guestfs, "df",
4977         ruby_guestfs_df, 0);
4978   rb_define_method (c_guestfs, "df_h",
4979         ruby_guestfs_df_h, 0);
4980   rb_define_method (c_guestfs, "du",
4981         ruby_guestfs_du, 1);
4982   rb_define_method (c_guestfs, "initrd_list",
4983         ruby_guestfs_initrd_list, 1);
4984 }