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_set_memsize (VALUE gv, VALUE memsizev)
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", "set_memsize");
1338
1339   int memsize = NUM2INT (memsizev);
1340
1341   int r;
1342
1343   r = guestfs_set_memsize (g, memsize);
1344   if (r == -1)
1345     rb_raise (e_Error, "%s", guestfs_last_error (g));
1346
1347   return Qnil;
1348 }
1349
1350 static VALUE ruby_guestfs_get_memsize (VALUE gv)
1351 {
1352   guestfs_h *g;
1353   Data_Get_Struct (gv, guestfs_h, g);
1354   if (!g)
1355     rb_raise (rb_eArgError, "%s: used handle after closing it", "get_memsize");
1356
1357
1358   int r;
1359
1360   r = guestfs_get_memsize (g);
1361   if (r == -1)
1362     rb_raise (e_Error, "%s", guestfs_last_error (g));
1363
1364   return INT2NUM (r);
1365 }
1366
1367 static VALUE ruby_guestfs_mount (VALUE gv, VALUE devicev, VALUE mountpointv)
1368 {
1369   guestfs_h *g;
1370   Data_Get_Struct (gv, guestfs_h, g);
1371   if (!g)
1372     rb_raise (rb_eArgError, "%s: used handle after closing it", "mount");
1373
1374   Check_Type (devicev, T_STRING);
1375   const char *device = StringValueCStr (devicev);
1376   if (!device)
1377     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1378               "device", "mount");
1379   Check_Type (mountpointv, T_STRING);
1380   const char *mountpoint = StringValueCStr (mountpointv);
1381   if (!mountpoint)
1382     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1383               "mountpoint", "mount");
1384
1385   int r;
1386
1387   r = guestfs_mount (g, device, mountpoint);
1388   if (r == -1)
1389     rb_raise (e_Error, "%s", guestfs_last_error (g));
1390
1391   return Qnil;
1392 }
1393
1394 static VALUE ruby_guestfs_sync (VALUE gv)
1395 {
1396   guestfs_h *g;
1397   Data_Get_Struct (gv, guestfs_h, g);
1398   if (!g)
1399     rb_raise (rb_eArgError, "%s: used handle after closing it", "sync");
1400
1401
1402   int r;
1403
1404   r = guestfs_sync (g);
1405   if (r == -1)
1406     rb_raise (e_Error, "%s", guestfs_last_error (g));
1407
1408   return Qnil;
1409 }
1410
1411 static VALUE ruby_guestfs_touch (VALUE gv, VALUE pathv)
1412 {
1413   guestfs_h *g;
1414   Data_Get_Struct (gv, guestfs_h, g);
1415   if (!g)
1416     rb_raise (rb_eArgError, "%s: used handle after closing it", "touch");
1417
1418   Check_Type (pathv, T_STRING);
1419   const char *path = StringValueCStr (pathv);
1420   if (!path)
1421     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1422               "path", "touch");
1423
1424   int r;
1425
1426   r = guestfs_touch (g, path);
1427   if (r == -1)
1428     rb_raise (e_Error, "%s", guestfs_last_error (g));
1429
1430   return Qnil;
1431 }
1432
1433 static VALUE ruby_guestfs_cat (VALUE gv, VALUE pathv)
1434 {
1435   guestfs_h *g;
1436   Data_Get_Struct (gv, guestfs_h, g);
1437   if (!g)
1438     rb_raise (rb_eArgError, "%s: used handle after closing it", "cat");
1439
1440   Check_Type (pathv, T_STRING);
1441   const char *path = StringValueCStr (pathv);
1442   if (!path)
1443     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1444               "path", "cat");
1445
1446   char *r;
1447
1448   r = guestfs_cat (g, path);
1449   if (r == NULL)
1450     rb_raise (e_Error, "%s", guestfs_last_error (g));
1451
1452   VALUE rv = rb_str_new2 (r);
1453   free (r);
1454   return rv;
1455 }
1456
1457 static VALUE ruby_guestfs_ll (VALUE gv, VALUE directoryv)
1458 {
1459   guestfs_h *g;
1460   Data_Get_Struct (gv, guestfs_h, g);
1461   if (!g)
1462     rb_raise (rb_eArgError, "%s: used handle after closing it", "ll");
1463
1464   Check_Type (directoryv, T_STRING);
1465   const char *directory = StringValueCStr (directoryv);
1466   if (!directory)
1467     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1468               "directory", "ll");
1469
1470   char *r;
1471
1472   r = guestfs_ll (g, directory);
1473   if (r == NULL)
1474     rb_raise (e_Error, "%s", guestfs_last_error (g));
1475
1476   VALUE rv = rb_str_new2 (r);
1477   free (r);
1478   return rv;
1479 }
1480
1481 static VALUE ruby_guestfs_ls (VALUE gv, VALUE directoryv)
1482 {
1483   guestfs_h *g;
1484   Data_Get_Struct (gv, guestfs_h, g);
1485   if (!g)
1486     rb_raise (rb_eArgError, "%s: used handle after closing it", "ls");
1487
1488   Check_Type (directoryv, T_STRING);
1489   const char *directory = StringValueCStr (directoryv);
1490   if (!directory)
1491     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1492               "directory", "ls");
1493
1494   char **r;
1495
1496   r = guestfs_ls (g, directory);
1497   if (r == NULL)
1498     rb_raise (e_Error, "%s", guestfs_last_error (g));
1499
1500   int i, len = 0;
1501   for (i = 0; r[i] != NULL; ++i) len++;
1502   VALUE rv = rb_ary_new2 (len);
1503   for (i = 0; r[i] != NULL; ++i) {
1504     rb_ary_push (rv, rb_str_new2 (r[i]));
1505     free (r[i]);
1506   }
1507   free (r);
1508   return rv;
1509 }
1510
1511 static VALUE ruby_guestfs_list_devices (VALUE gv)
1512 {
1513   guestfs_h *g;
1514   Data_Get_Struct (gv, guestfs_h, g);
1515   if (!g)
1516     rb_raise (rb_eArgError, "%s: used handle after closing it", "list_devices");
1517
1518
1519   char **r;
1520
1521   r = guestfs_list_devices (g);
1522   if (r == NULL)
1523     rb_raise (e_Error, "%s", guestfs_last_error (g));
1524
1525   int i, len = 0;
1526   for (i = 0; r[i] != NULL; ++i) len++;
1527   VALUE rv = rb_ary_new2 (len);
1528   for (i = 0; r[i] != NULL; ++i) {
1529     rb_ary_push (rv, rb_str_new2 (r[i]));
1530     free (r[i]);
1531   }
1532   free (r);
1533   return rv;
1534 }
1535
1536 static VALUE ruby_guestfs_list_partitions (VALUE gv)
1537 {
1538   guestfs_h *g;
1539   Data_Get_Struct (gv, guestfs_h, g);
1540   if (!g)
1541     rb_raise (rb_eArgError, "%s: used handle after closing it", "list_partitions");
1542
1543
1544   char **r;
1545
1546   r = guestfs_list_partitions (g);
1547   if (r == NULL)
1548     rb_raise (e_Error, "%s", guestfs_last_error (g));
1549
1550   int i, len = 0;
1551   for (i = 0; r[i] != NULL; ++i) len++;
1552   VALUE rv = rb_ary_new2 (len);
1553   for (i = 0; r[i] != NULL; ++i) {
1554     rb_ary_push (rv, rb_str_new2 (r[i]));
1555     free (r[i]);
1556   }
1557   free (r);
1558   return rv;
1559 }
1560
1561 static VALUE ruby_guestfs_pvs (VALUE gv)
1562 {
1563   guestfs_h *g;
1564   Data_Get_Struct (gv, guestfs_h, g);
1565   if (!g)
1566     rb_raise (rb_eArgError, "%s: used handle after closing it", "pvs");
1567
1568
1569   char **r;
1570
1571   r = guestfs_pvs (g);
1572   if (r == NULL)
1573     rb_raise (e_Error, "%s", guestfs_last_error (g));
1574
1575   int i, len = 0;
1576   for (i = 0; r[i] != NULL; ++i) len++;
1577   VALUE rv = rb_ary_new2 (len);
1578   for (i = 0; r[i] != NULL; ++i) {
1579     rb_ary_push (rv, rb_str_new2 (r[i]));
1580     free (r[i]);
1581   }
1582   free (r);
1583   return rv;
1584 }
1585
1586 static VALUE ruby_guestfs_vgs (VALUE gv)
1587 {
1588   guestfs_h *g;
1589   Data_Get_Struct (gv, guestfs_h, g);
1590   if (!g)
1591     rb_raise (rb_eArgError, "%s: used handle after closing it", "vgs");
1592
1593
1594   char **r;
1595
1596   r = guestfs_vgs (g);
1597   if (r == NULL)
1598     rb_raise (e_Error, "%s", guestfs_last_error (g));
1599
1600   int i, len = 0;
1601   for (i = 0; r[i] != NULL; ++i) len++;
1602   VALUE rv = rb_ary_new2 (len);
1603   for (i = 0; r[i] != NULL; ++i) {
1604     rb_ary_push (rv, rb_str_new2 (r[i]));
1605     free (r[i]);
1606   }
1607   free (r);
1608   return rv;
1609 }
1610
1611 static VALUE ruby_guestfs_lvs (VALUE gv)
1612 {
1613   guestfs_h *g;
1614   Data_Get_Struct (gv, guestfs_h, g);
1615   if (!g)
1616     rb_raise (rb_eArgError, "%s: used handle after closing it", "lvs");
1617
1618
1619   char **r;
1620
1621   r = guestfs_lvs (g);
1622   if (r == NULL)
1623     rb_raise (e_Error, "%s", guestfs_last_error (g));
1624
1625   int i, len = 0;
1626   for (i = 0; r[i] != NULL; ++i) len++;
1627   VALUE rv = rb_ary_new2 (len);
1628   for (i = 0; r[i] != NULL; ++i) {
1629     rb_ary_push (rv, rb_str_new2 (r[i]));
1630     free (r[i]);
1631   }
1632   free (r);
1633   return rv;
1634 }
1635
1636 static VALUE ruby_guestfs_pvs_full (VALUE gv)
1637 {
1638   guestfs_h *g;
1639   Data_Get_Struct (gv, guestfs_h, g);
1640   if (!g)
1641     rb_raise (rb_eArgError, "%s: used handle after closing it", "pvs_full");
1642
1643
1644   struct guestfs_lvm_pv_list *r;
1645
1646   r = guestfs_pvs_full (g);
1647   if (r == NULL)
1648     rb_raise (e_Error, "%s", guestfs_last_error (g));
1649
1650   VALUE rv = rb_ary_new2 (r->len);
1651   int i;
1652   for (i = 0; i < r->len; ++i) {
1653     VALUE hv = rb_hash_new ();
1654     rb_hash_aset (rv, rb_str_new2 ("pv_name"), rb_str_new2 (r->val[i].pv_name));
1655     rb_hash_aset (rv, rb_str_new2 ("pv_uuid"), rb_str_new (r->val[i].pv_uuid, 32));
1656     rb_hash_aset (rv, rb_str_new2 ("pv_fmt"), rb_str_new2 (r->val[i].pv_fmt));
1657     rb_hash_aset (rv, rb_str_new2 ("pv_size"), ULL2NUM (r->val[i].pv_size));
1658     rb_hash_aset (rv, rb_str_new2 ("dev_size"), ULL2NUM (r->val[i].dev_size));
1659     rb_hash_aset (rv, rb_str_new2 ("pv_free"), ULL2NUM (r->val[i].pv_free));
1660     rb_hash_aset (rv, rb_str_new2 ("pv_used"), ULL2NUM (r->val[i].pv_used));
1661     rb_hash_aset (rv, rb_str_new2 ("pv_attr"), rb_str_new2 (r->val[i].pv_attr));
1662     rb_hash_aset (rv, rb_str_new2 ("pv_pe_count"), ULL2NUM (r->val[i].pv_pe_count));
1663     rb_hash_aset (rv, rb_str_new2 ("pv_pe_alloc_count"), ULL2NUM (r->val[i].pv_pe_alloc_count));
1664     rb_hash_aset (rv, rb_str_new2 ("pv_tags"), rb_str_new2 (r->val[i].pv_tags));
1665     rb_hash_aset (rv, rb_str_new2 ("pe_start"), ULL2NUM (r->val[i].pe_start));
1666     rb_hash_aset (rv, rb_str_new2 ("pv_mda_count"), ULL2NUM (r->val[i].pv_mda_count));
1667     rb_hash_aset (rv, rb_str_new2 ("pv_mda_free"), ULL2NUM (r->val[i].pv_mda_free));
1668     rb_ary_push (rv, hv);
1669   }
1670   guestfs_free_lvm_pv_list (r);
1671   return rv;
1672 }
1673
1674 static VALUE ruby_guestfs_vgs_full (VALUE gv)
1675 {
1676   guestfs_h *g;
1677   Data_Get_Struct (gv, guestfs_h, g);
1678   if (!g)
1679     rb_raise (rb_eArgError, "%s: used handle after closing it", "vgs_full");
1680
1681
1682   struct guestfs_lvm_vg_list *r;
1683
1684   r = guestfs_vgs_full (g);
1685   if (r == NULL)
1686     rb_raise (e_Error, "%s", guestfs_last_error (g));
1687
1688   VALUE rv = rb_ary_new2 (r->len);
1689   int i;
1690   for (i = 0; i < r->len; ++i) {
1691     VALUE hv = rb_hash_new ();
1692     rb_hash_aset (rv, rb_str_new2 ("vg_name"), rb_str_new2 (r->val[i].vg_name));
1693     rb_hash_aset (rv, rb_str_new2 ("vg_uuid"), rb_str_new (r->val[i].vg_uuid, 32));
1694     rb_hash_aset (rv, rb_str_new2 ("vg_fmt"), rb_str_new2 (r->val[i].vg_fmt));
1695     rb_hash_aset (rv, rb_str_new2 ("vg_attr"), rb_str_new2 (r->val[i].vg_attr));
1696     rb_hash_aset (rv, rb_str_new2 ("vg_size"), ULL2NUM (r->val[i].vg_size));
1697     rb_hash_aset (rv, rb_str_new2 ("vg_free"), ULL2NUM (r->val[i].vg_free));
1698     rb_hash_aset (rv, rb_str_new2 ("vg_sysid"), rb_str_new2 (r->val[i].vg_sysid));
1699     rb_hash_aset (rv, rb_str_new2 ("vg_extent_size"), ULL2NUM (r->val[i].vg_extent_size));
1700     rb_hash_aset (rv, rb_str_new2 ("vg_extent_count"), ULL2NUM (r->val[i].vg_extent_count));
1701     rb_hash_aset (rv, rb_str_new2 ("vg_free_count"), ULL2NUM (r->val[i].vg_free_count));
1702     rb_hash_aset (rv, rb_str_new2 ("max_lv"), ULL2NUM (r->val[i].max_lv));
1703     rb_hash_aset (rv, rb_str_new2 ("max_pv"), ULL2NUM (r->val[i].max_pv));
1704     rb_hash_aset (rv, rb_str_new2 ("pv_count"), ULL2NUM (r->val[i].pv_count));
1705     rb_hash_aset (rv, rb_str_new2 ("lv_count"), ULL2NUM (r->val[i].lv_count));
1706     rb_hash_aset (rv, rb_str_new2 ("snap_count"), ULL2NUM (r->val[i].snap_count));
1707     rb_hash_aset (rv, rb_str_new2 ("vg_seqno"), ULL2NUM (r->val[i].vg_seqno));
1708     rb_hash_aset (rv, rb_str_new2 ("vg_tags"), rb_str_new2 (r->val[i].vg_tags));
1709     rb_hash_aset (rv, rb_str_new2 ("vg_mda_count"), ULL2NUM (r->val[i].vg_mda_count));
1710     rb_hash_aset (rv, rb_str_new2 ("vg_mda_free"), ULL2NUM (r->val[i].vg_mda_free));
1711     rb_ary_push (rv, hv);
1712   }
1713   guestfs_free_lvm_vg_list (r);
1714   return rv;
1715 }
1716
1717 static VALUE ruby_guestfs_lvs_full (VALUE gv)
1718 {
1719   guestfs_h *g;
1720   Data_Get_Struct (gv, guestfs_h, g);
1721   if (!g)
1722     rb_raise (rb_eArgError, "%s: used handle after closing it", "lvs_full");
1723
1724
1725   struct guestfs_lvm_lv_list *r;
1726
1727   r = guestfs_lvs_full (g);
1728   if (r == NULL)
1729     rb_raise (e_Error, "%s", guestfs_last_error (g));
1730
1731   VALUE rv = rb_ary_new2 (r->len);
1732   int i;
1733   for (i = 0; i < r->len; ++i) {
1734     VALUE hv = rb_hash_new ();
1735     rb_hash_aset (rv, rb_str_new2 ("lv_name"), rb_str_new2 (r->val[i].lv_name));
1736     rb_hash_aset (rv, rb_str_new2 ("lv_uuid"), rb_str_new (r->val[i].lv_uuid, 32));
1737     rb_hash_aset (rv, rb_str_new2 ("lv_attr"), rb_str_new2 (r->val[i].lv_attr));
1738     rb_hash_aset (rv, rb_str_new2 ("lv_major"), ULL2NUM (r->val[i].lv_major));
1739     rb_hash_aset (rv, rb_str_new2 ("lv_minor"), ULL2NUM (r->val[i].lv_minor));
1740     rb_hash_aset (rv, rb_str_new2 ("lv_kernel_major"), ULL2NUM (r->val[i].lv_kernel_major));
1741     rb_hash_aset (rv, rb_str_new2 ("lv_kernel_minor"), ULL2NUM (r->val[i].lv_kernel_minor));
1742     rb_hash_aset (rv, rb_str_new2 ("lv_size"), ULL2NUM (r->val[i].lv_size));
1743     rb_hash_aset (rv, rb_str_new2 ("seg_count"), ULL2NUM (r->val[i].seg_count));
1744     rb_hash_aset (rv, rb_str_new2 ("origin"), rb_str_new2 (r->val[i].origin));
1745     rb_hash_aset (rv, rb_str_new2 ("snap_percent"), rb_dbl2big (r->val[i].snap_percent));
1746     rb_hash_aset (rv, rb_str_new2 ("copy_percent"), rb_dbl2big (r->val[i].copy_percent));
1747     rb_hash_aset (rv, rb_str_new2 ("move_pv"), rb_str_new2 (r->val[i].move_pv));
1748     rb_hash_aset (rv, rb_str_new2 ("lv_tags"), rb_str_new2 (r->val[i].lv_tags));
1749     rb_hash_aset (rv, rb_str_new2 ("mirror_log"), rb_str_new2 (r->val[i].mirror_log));
1750     rb_hash_aset (rv, rb_str_new2 ("modules"), rb_str_new2 (r->val[i].modules));
1751     rb_ary_push (rv, hv);
1752   }
1753   guestfs_free_lvm_lv_list (r);
1754   return rv;
1755 }
1756
1757 static VALUE ruby_guestfs_read_lines (VALUE gv, VALUE pathv)
1758 {
1759   guestfs_h *g;
1760   Data_Get_Struct (gv, guestfs_h, g);
1761   if (!g)
1762     rb_raise (rb_eArgError, "%s: used handle after closing it", "read_lines");
1763
1764   Check_Type (pathv, T_STRING);
1765   const char *path = StringValueCStr (pathv);
1766   if (!path)
1767     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1768               "path", "read_lines");
1769
1770   char **r;
1771
1772   r = guestfs_read_lines (g, path);
1773   if (r == NULL)
1774     rb_raise (e_Error, "%s", guestfs_last_error (g));
1775
1776   int i, len = 0;
1777   for (i = 0; r[i] != NULL; ++i) len++;
1778   VALUE rv = rb_ary_new2 (len);
1779   for (i = 0; r[i] != NULL; ++i) {
1780     rb_ary_push (rv, rb_str_new2 (r[i]));
1781     free (r[i]);
1782   }
1783   free (r);
1784   return rv;
1785 }
1786
1787 static VALUE ruby_guestfs_aug_init (VALUE gv, VALUE rootv, VALUE flagsv)
1788 {
1789   guestfs_h *g;
1790   Data_Get_Struct (gv, guestfs_h, g);
1791   if (!g)
1792     rb_raise (rb_eArgError, "%s: used handle after closing it", "aug_init");
1793
1794   Check_Type (rootv, T_STRING);
1795   const char *root = StringValueCStr (rootv);
1796   if (!root)
1797     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1798               "root", "aug_init");
1799   int flags = NUM2INT (flagsv);
1800
1801   int r;
1802
1803   r = guestfs_aug_init (g, root, flags);
1804   if (r == -1)
1805     rb_raise (e_Error, "%s", guestfs_last_error (g));
1806
1807   return Qnil;
1808 }
1809
1810 static VALUE ruby_guestfs_aug_close (VALUE gv)
1811 {
1812   guestfs_h *g;
1813   Data_Get_Struct (gv, guestfs_h, g);
1814   if (!g)
1815     rb_raise (rb_eArgError, "%s: used handle after closing it", "aug_close");
1816
1817
1818   int r;
1819
1820   r = guestfs_aug_close (g);
1821   if (r == -1)
1822     rb_raise (e_Error, "%s", guestfs_last_error (g));
1823
1824   return Qnil;
1825 }
1826
1827 static VALUE ruby_guestfs_aug_defvar (VALUE gv, VALUE namev, VALUE exprv)
1828 {
1829   guestfs_h *g;
1830   Data_Get_Struct (gv, guestfs_h, g);
1831   if (!g)
1832     rb_raise (rb_eArgError, "%s: used handle after closing it", "aug_defvar");
1833
1834   Check_Type (namev, T_STRING);
1835   const char *name = StringValueCStr (namev);
1836   if (!name)
1837     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1838               "name", "aug_defvar");
1839   const char *expr = !NIL_P (exprv) ? StringValueCStr (exprv) : NULL;
1840
1841   int r;
1842
1843   r = guestfs_aug_defvar (g, name, expr);
1844   if (r == -1)
1845     rb_raise (e_Error, "%s", guestfs_last_error (g));
1846
1847   return INT2NUM (r);
1848 }
1849
1850 static VALUE ruby_guestfs_aug_defnode (VALUE gv, VALUE namev, VALUE exprv, VALUE valv)
1851 {
1852   guestfs_h *g;
1853   Data_Get_Struct (gv, guestfs_h, g);
1854   if (!g)
1855     rb_raise (rb_eArgError, "%s: used handle after closing it", "aug_defnode");
1856
1857   Check_Type (namev, T_STRING);
1858   const char *name = StringValueCStr (namev);
1859   if (!name)
1860     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1861               "name", "aug_defnode");
1862   Check_Type (exprv, T_STRING);
1863   const char *expr = StringValueCStr (exprv);
1864   if (!expr)
1865     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1866               "expr", "aug_defnode");
1867   Check_Type (valv, T_STRING);
1868   const char *val = StringValueCStr (valv);
1869   if (!val)
1870     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1871               "val", "aug_defnode");
1872
1873   struct guestfs_int_bool *r;
1874
1875   r = guestfs_aug_defnode (g, name, expr, val);
1876   if (r == NULL)
1877     rb_raise (e_Error, "%s", guestfs_last_error (g));
1878
1879   VALUE rv = rb_ary_new2 (2);
1880   rb_ary_push (rv, INT2NUM (r->i));
1881   rb_ary_push (rv, INT2NUM (r->b));
1882   guestfs_free_int_bool (r);
1883   return rv;
1884 }
1885
1886 static VALUE ruby_guestfs_aug_get (VALUE gv, VALUE pathv)
1887 {
1888   guestfs_h *g;
1889   Data_Get_Struct (gv, guestfs_h, g);
1890   if (!g)
1891     rb_raise (rb_eArgError, "%s: used handle after closing it", "aug_get");
1892
1893   Check_Type (pathv, T_STRING);
1894   const char *path = StringValueCStr (pathv);
1895   if (!path)
1896     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1897               "path", "aug_get");
1898
1899   char *r;
1900
1901   r = guestfs_aug_get (g, path);
1902   if (r == NULL)
1903     rb_raise (e_Error, "%s", guestfs_last_error (g));
1904
1905   VALUE rv = rb_str_new2 (r);
1906   free (r);
1907   return rv;
1908 }
1909
1910 static VALUE ruby_guestfs_aug_set (VALUE gv, VALUE pathv, VALUE valv)
1911 {
1912   guestfs_h *g;
1913   Data_Get_Struct (gv, guestfs_h, g);
1914   if (!g)
1915     rb_raise (rb_eArgError, "%s: used handle after closing it", "aug_set");
1916
1917   Check_Type (pathv, T_STRING);
1918   const char *path = StringValueCStr (pathv);
1919   if (!path)
1920     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1921               "path", "aug_set");
1922   Check_Type (valv, T_STRING);
1923   const char *val = StringValueCStr (valv);
1924   if (!val)
1925     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1926               "val", "aug_set");
1927
1928   int r;
1929
1930   r = guestfs_aug_set (g, path, val);
1931   if (r == -1)
1932     rb_raise (e_Error, "%s", guestfs_last_error (g));
1933
1934   return Qnil;
1935 }
1936
1937 static VALUE ruby_guestfs_aug_insert (VALUE gv, VALUE pathv, VALUE labelv, VALUE beforev)
1938 {
1939   guestfs_h *g;
1940   Data_Get_Struct (gv, guestfs_h, g);
1941   if (!g)
1942     rb_raise (rb_eArgError, "%s: used handle after closing it", "aug_insert");
1943
1944   Check_Type (pathv, T_STRING);
1945   const char *path = StringValueCStr (pathv);
1946   if (!path)
1947     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1948               "path", "aug_insert");
1949   Check_Type (labelv, T_STRING);
1950   const char *label = StringValueCStr (labelv);
1951   if (!label)
1952     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1953               "label", "aug_insert");
1954   int before = RTEST (beforev);
1955
1956   int r;
1957
1958   r = guestfs_aug_insert (g, path, label, before);
1959   if (r == -1)
1960     rb_raise (e_Error, "%s", guestfs_last_error (g));
1961
1962   return Qnil;
1963 }
1964
1965 static VALUE ruby_guestfs_aug_rm (VALUE gv, VALUE pathv)
1966 {
1967   guestfs_h *g;
1968   Data_Get_Struct (gv, guestfs_h, g);
1969   if (!g)
1970     rb_raise (rb_eArgError, "%s: used handle after closing it", "aug_rm");
1971
1972   Check_Type (pathv, T_STRING);
1973   const char *path = StringValueCStr (pathv);
1974   if (!path)
1975     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1976               "path", "aug_rm");
1977
1978   int r;
1979
1980   r = guestfs_aug_rm (g, path);
1981   if (r == -1)
1982     rb_raise (e_Error, "%s", guestfs_last_error (g));
1983
1984   return INT2NUM (r);
1985 }
1986
1987 static VALUE ruby_guestfs_aug_mv (VALUE gv, VALUE srcv, VALUE destv)
1988 {
1989   guestfs_h *g;
1990   Data_Get_Struct (gv, guestfs_h, g);
1991   if (!g)
1992     rb_raise (rb_eArgError, "%s: used handle after closing it", "aug_mv");
1993
1994   Check_Type (srcv, T_STRING);
1995   const char *src = StringValueCStr (srcv);
1996   if (!src)
1997     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1998               "src", "aug_mv");
1999   Check_Type (destv, T_STRING);
2000   const char *dest = StringValueCStr (destv);
2001   if (!dest)
2002     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2003               "dest", "aug_mv");
2004
2005   int r;
2006
2007   r = guestfs_aug_mv (g, src, dest);
2008   if (r == -1)
2009     rb_raise (e_Error, "%s", guestfs_last_error (g));
2010
2011   return Qnil;
2012 }
2013
2014 static VALUE ruby_guestfs_aug_match (VALUE gv, VALUE pathv)
2015 {
2016   guestfs_h *g;
2017   Data_Get_Struct (gv, guestfs_h, g);
2018   if (!g)
2019     rb_raise (rb_eArgError, "%s: used handle after closing it", "aug_match");
2020
2021   Check_Type (pathv, T_STRING);
2022   const char *path = StringValueCStr (pathv);
2023   if (!path)
2024     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2025               "path", "aug_match");
2026
2027   char **r;
2028
2029   r = guestfs_aug_match (g, path);
2030   if (r == NULL)
2031     rb_raise (e_Error, "%s", guestfs_last_error (g));
2032
2033   int i, len = 0;
2034   for (i = 0; r[i] != NULL; ++i) len++;
2035   VALUE rv = rb_ary_new2 (len);
2036   for (i = 0; r[i] != NULL; ++i) {
2037     rb_ary_push (rv, rb_str_new2 (r[i]));
2038     free (r[i]);
2039   }
2040   free (r);
2041   return rv;
2042 }
2043
2044 static VALUE ruby_guestfs_aug_save (VALUE gv)
2045 {
2046   guestfs_h *g;
2047   Data_Get_Struct (gv, guestfs_h, g);
2048   if (!g)
2049     rb_raise (rb_eArgError, "%s: used handle after closing it", "aug_save");
2050
2051
2052   int r;
2053
2054   r = guestfs_aug_save (g);
2055   if (r == -1)
2056     rb_raise (e_Error, "%s", guestfs_last_error (g));
2057
2058   return Qnil;
2059 }
2060
2061 static VALUE ruby_guestfs_aug_load (VALUE gv)
2062 {
2063   guestfs_h *g;
2064   Data_Get_Struct (gv, guestfs_h, g);
2065   if (!g)
2066     rb_raise (rb_eArgError, "%s: used handle after closing it", "aug_load");
2067
2068
2069   int r;
2070
2071   r = guestfs_aug_load (g);
2072   if (r == -1)
2073     rb_raise (e_Error, "%s", guestfs_last_error (g));
2074
2075   return Qnil;
2076 }
2077
2078 static VALUE ruby_guestfs_aug_ls (VALUE gv, VALUE pathv)
2079 {
2080   guestfs_h *g;
2081   Data_Get_Struct (gv, guestfs_h, g);
2082   if (!g)
2083     rb_raise (rb_eArgError, "%s: used handle after closing it", "aug_ls");
2084
2085   Check_Type (pathv, T_STRING);
2086   const char *path = StringValueCStr (pathv);
2087   if (!path)
2088     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2089               "path", "aug_ls");
2090
2091   char **r;
2092
2093   r = guestfs_aug_ls (g, path);
2094   if (r == NULL)
2095     rb_raise (e_Error, "%s", guestfs_last_error (g));
2096
2097   int i, len = 0;
2098   for (i = 0; r[i] != NULL; ++i) len++;
2099   VALUE rv = rb_ary_new2 (len);
2100   for (i = 0; r[i] != NULL; ++i) {
2101     rb_ary_push (rv, rb_str_new2 (r[i]));
2102     free (r[i]);
2103   }
2104   free (r);
2105   return rv;
2106 }
2107
2108 static VALUE ruby_guestfs_rm (VALUE gv, VALUE pathv)
2109 {
2110   guestfs_h *g;
2111   Data_Get_Struct (gv, guestfs_h, g);
2112   if (!g)
2113     rb_raise (rb_eArgError, "%s: used handle after closing it", "rm");
2114
2115   Check_Type (pathv, T_STRING);
2116   const char *path = StringValueCStr (pathv);
2117   if (!path)
2118     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2119               "path", "rm");
2120
2121   int r;
2122
2123   r = guestfs_rm (g, path);
2124   if (r == -1)
2125     rb_raise (e_Error, "%s", guestfs_last_error (g));
2126
2127   return Qnil;
2128 }
2129
2130 static VALUE ruby_guestfs_rmdir (VALUE gv, VALUE pathv)
2131 {
2132   guestfs_h *g;
2133   Data_Get_Struct (gv, guestfs_h, g);
2134   if (!g)
2135     rb_raise (rb_eArgError, "%s: used handle after closing it", "rmdir");
2136
2137   Check_Type (pathv, T_STRING);
2138   const char *path = StringValueCStr (pathv);
2139   if (!path)
2140     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2141               "path", "rmdir");
2142
2143   int r;
2144
2145   r = guestfs_rmdir (g, path);
2146   if (r == -1)
2147     rb_raise (e_Error, "%s", guestfs_last_error (g));
2148
2149   return Qnil;
2150 }
2151
2152 static VALUE ruby_guestfs_rm_rf (VALUE gv, VALUE pathv)
2153 {
2154   guestfs_h *g;
2155   Data_Get_Struct (gv, guestfs_h, g);
2156   if (!g)
2157     rb_raise (rb_eArgError, "%s: used handle after closing it", "rm_rf");
2158
2159   Check_Type (pathv, T_STRING);
2160   const char *path = StringValueCStr (pathv);
2161   if (!path)
2162     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2163               "path", "rm_rf");
2164
2165   int r;
2166
2167   r = guestfs_rm_rf (g, path);
2168   if (r == -1)
2169     rb_raise (e_Error, "%s", guestfs_last_error (g));
2170
2171   return Qnil;
2172 }
2173
2174 static VALUE ruby_guestfs_mkdir (VALUE gv, VALUE pathv)
2175 {
2176   guestfs_h *g;
2177   Data_Get_Struct (gv, guestfs_h, g);
2178   if (!g)
2179     rb_raise (rb_eArgError, "%s: used handle after closing it", "mkdir");
2180
2181   Check_Type (pathv, T_STRING);
2182   const char *path = StringValueCStr (pathv);
2183   if (!path)
2184     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2185               "path", "mkdir");
2186
2187   int r;
2188
2189   r = guestfs_mkdir (g, path);
2190   if (r == -1)
2191     rb_raise (e_Error, "%s", guestfs_last_error (g));
2192
2193   return Qnil;
2194 }
2195
2196 static VALUE ruby_guestfs_mkdir_p (VALUE gv, VALUE pathv)
2197 {
2198   guestfs_h *g;
2199   Data_Get_Struct (gv, guestfs_h, g);
2200   if (!g)
2201     rb_raise (rb_eArgError, "%s: used handle after closing it", "mkdir_p");
2202
2203   Check_Type (pathv, T_STRING);
2204   const char *path = StringValueCStr (pathv);
2205   if (!path)
2206     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2207               "path", "mkdir_p");
2208
2209   int r;
2210
2211   r = guestfs_mkdir_p (g, path);
2212   if (r == -1)
2213     rb_raise (e_Error, "%s", guestfs_last_error (g));
2214
2215   return Qnil;
2216 }
2217
2218 static VALUE ruby_guestfs_chmod (VALUE gv, VALUE modev, VALUE pathv)
2219 {
2220   guestfs_h *g;
2221   Data_Get_Struct (gv, guestfs_h, g);
2222   if (!g)
2223     rb_raise (rb_eArgError, "%s: used handle after closing it", "chmod");
2224
2225   int mode = NUM2INT (modev);
2226   Check_Type (pathv, T_STRING);
2227   const char *path = StringValueCStr (pathv);
2228   if (!path)
2229     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2230               "path", "chmod");
2231
2232   int r;
2233
2234   r = guestfs_chmod (g, mode, path);
2235   if (r == -1)
2236     rb_raise (e_Error, "%s", guestfs_last_error (g));
2237
2238   return Qnil;
2239 }
2240
2241 static VALUE ruby_guestfs_chown (VALUE gv, VALUE ownerv, VALUE groupv, VALUE pathv)
2242 {
2243   guestfs_h *g;
2244   Data_Get_Struct (gv, guestfs_h, g);
2245   if (!g)
2246     rb_raise (rb_eArgError, "%s: used handle after closing it", "chown");
2247
2248   int owner = NUM2INT (ownerv);
2249   int group = NUM2INT (groupv);
2250   Check_Type (pathv, T_STRING);
2251   const char *path = StringValueCStr (pathv);
2252   if (!path)
2253     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2254               "path", "chown");
2255
2256   int r;
2257
2258   r = guestfs_chown (g, owner, group, path);
2259   if (r == -1)
2260     rb_raise (e_Error, "%s", guestfs_last_error (g));
2261
2262   return Qnil;
2263 }
2264
2265 static VALUE ruby_guestfs_exists (VALUE gv, VALUE pathv)
2266 {
2267   guestfs_h *g;
2268   Data_Get_Struct (gv, guestfs_h, g);
2269   if (!g)
2270     rb_raise (rb_eArgError, "%s: used handle after closing it", "exists");
2271
2272   Check_Type (pathv, T_STRING);
2273   const char *path = StringValueCStr (pathv);
2274   if (!path)
2275     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2276               "path", "exists");
2277
2278   int r;
2279
2280   r = guestfs_exists (g, path);
2281   if (r == -1)
2282     rb_raise (e_Error, "%s", guestfs_last_error (g));
2283
2284   return INT2NUM (r);
2285 }
2286
2287 static VALUE ruby_guestfs_is_file (VALUE gv, VALUE pathv)
2288 {
2289   guestfs_h *g;
2290   Data_Get_Struct (gv, guestfs_h, g);
2291   if (!g)
2292     rb_raise (rb_eArgError, "%s: used handle after closing it", "is_file");
2293
2294   Check_Type (pathv, T_STRING);
2295   const char *path = StringValueCStr (pathv);
2296   if (!path)
2297     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2298               "path", "is_file");
2299
2300   int r;
2301
2302   r = guestfs_is_file (g, path);
2303   if (r == -1)
2304     rb_raise (e_Error, "%s", guestfs_last_error (g));
2305
2306   return INT2NUM (r);
2307 }
2308
2309 static VALUE ruby_guestfs_is_dir (VALUE gv, VALUE pathv)
2310 {
2311   guestfs_h *g;
2312   Data_Get_Struct (gv, guestfs_h, g);
2313   if (!g)
2314     rb_raise (rb_eArgError, "%s: used handle after closing it", "is_dir");
2315
2316   Check_Type (pathv, T_STRING);
2317   const char *path = StringValueCStr (pathv);
2318   if (!path)
2319     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2320               "path", "is_dir");
2321
2322   int r;
2323
2324   r = guestfs_is_dir (g, path);
2325   if (r == -1)
2326     rb_raise (e_Error, "%s", guestfs_last_error (g));
2327
2328   return INT2NUM (r);
2329 }
2330
2331 static VALUE ruby_guestfs_pvcreate (VALUE gv, VALUE devicev)
2332 {
2333   guestfs_h *g;
2334   Data_Get_Struct (gv, guestfs_h, g);
2335   if (!g)
2336     rb_raise (rb_eArgError, "%s: used handle after closing it", "pvcreate");
2337
2338   Check_Type (devicev, T_STRING);
2339   const char *device = StringValueCStr (devicev);
2340   if (!device)
2341     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2342               "device", "pvcreate");
2343
2344   int r;
2345
2346   r = guestfs_pvcreate (g, device);
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_vgcreate (VALUE gv, VALUE volgroupv, VALUE physvolsv)
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", "vgcreate");
2359
2360   Check_Type (volgroupv, T_STRING);
2361   const char *volgroup = StringValueCStr (volgroupv);
2362   if (!volgroup)
2363     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2364               "volgroup", "vgcreate");
2365   char **physvols;
2366   Check_Type (physvolsv, T_ARRAY);
2367   {
2368     int i, len;
2369     len = RARRAY_LEN (physvolsv);
2370     physvols = guestfs_safe_malloc (g, sizeof (char *) * (len+1));
2371     for (i = 0; i < len; ++i) {
2372       VALUE v = rb_ary_entry (physvolsv, i);
2373       physvols[i] = StringValueCStr (v);
2374     }
2375     physvols[len] = NULL;
2376   }
2377
2378   int r;
2379
2380   r = guestfs_vgcreate (g, volgroup, physvols);
2381   free (physvols);
2382   if (r == -1)
2383     rb_raise (e_Error, "%s", guestfs_last_error (g));
2384
2385   return Qnil;
2386 }
2387
2388 static VALUE ruby_guestfs_lvcreate (VALUE gv, VALUE logvolv, VALUE volgroupv, VALUE mbytesv)
2389 {
2390   guestfs_h *g;
2391   Data_Get_Struct (gv, guestfs_h, g);
2392   if (!g)
2393     rb_raise (rb_eArgError, "%s: used handle after closing it", "lvcreate");
2394
2395   Check_Type (logvolv, T_STRING);
2396   const char *logvol = StringValueCStr (logvolv);
2397   if (!logvol)
2398     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2399               "logvol", "lvcreate");
2400   Check_Type (volgroupv, T_STRING);
2401   const char *volgroup = StringValueCStr (volgroupv);
2402   if (!volgroup)
2403     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2404               "volgroup", "lvcreate");
2405   int mbytes = NUM2INT (mbytesv);
2406
2407   int r;
2408
2409   r = guestfs_lvcreate (g, logvol, volgroup, mbytes);
2410   if (r == -1)
2411     rb_raise (e_Error, "%s", guestfs_last_error (g));
2412
2413   return Qnil;
2414 }
2415
2416 static VALUE ruby_guestfs_mkfs (VALUE gv, VALUE fstypev, VALUE devicev)
2417 {
2418   guestfs_h *g;
2419   Data_Get_Struct (gv, guestfs_h, g);
2420   if (!g)
2421     rb_raise (rb_eArgError, "%s: used handle after closing it", "mkfs");
2422
2423   Check_Type (fstypev, T_STRING);
2424   const char *fstype = StringValueCStr (fstypev);
2425   if (!fstype)
2426     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2427               "fstype", "mkfs");
2428   Check_Type (devicev, T_STRING);
2429   const char *device = StringValueCStr (devicev);
2430   if (!device)
2431     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2432               "device", "mkfs");
2433
2434   int r;
2435
2436   r = guestfs_mkfs (g, fstype, device);
2437   if (r == -1)
2438     rb_raise (e_Error, "%s", guestfs_last_error (g));
2439
2440   return Qnil;
2441 }
2442
2443 static VALUE ruby_guestfs_sfdisk (VALUE gv, VALUE devicev, VALUE cylsv, VALUE headsv, VALUE sectorsv, VALUE linesv)
2444 {
2445   guestfs_h *g;
2446   Data_Get_Struct (gv, guestfs_h, g);
2447   if (!g)
2448     rb_raise (rb_eArgError, "%s: used handle after closing it", "sfdisk");
2449
2450   Check_Type (devicev, T_STRING);
2451   const char *device = StringValueCStr (devicev);
2452   if (!device)
2453     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2454               "device", "sfdisk");
2455   int cyls = NUM2INT (cylsv);
2456   int heads = NUM2INT (headsv);
2457   int sectors = NUM2INT (sectorsv);
2458   char **lines;
2459   Check_Type (linesv, T_ARRAY);
2460   {
2461     int i, len;
2462     len = RARRAY_LEN (linesv);
2463     lines = guestfs_safe_malloc (g, sizeof (char *) * (len+1));
2464     for (i = 0; i < len; ++i) {
2465       VALUE v = rb_ary_entry (linesv, i);
2466       lines[i] = StringValueCStr (v);
2467     }
2468     lines[len] = NULL;
2469   }
2470
2471   int r;
2472
2473   r = guestfs_sfdisk (g, device, cyls, heads, sectors, lines);
2474   free (lines);
2475   if (r == -1)
2476     rb_raise (e_Error, "%s", guestfs_last_error (g));
2477
2478   return Qnil;
2479 }
2480
2481 static VALUE ruby_guestfs_write_file (VALUE gv, VALUE pathv, VALUE contentv, VALUE sizev)
2482 {
2483   guestfs_h *g;
2484   Data_Get_Struct (gv, guestfs_h, g);
2485   if (!g)
2486     rb_raise (rb_eArgError, "%s: used handle after closing it", "write_file");
2487
2488   Check_Type (pathv, T_STRING);
2489   const char *path = StringValueCStr (pathv);
2490   if (!path)
2491     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2492               "path", "write_file");
2493   Check_Type (contentv, T_STRING);
2494   const char *content = StringValueCStr (contentv);
2495   if (!content)
2496     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2497               "content", "write_file");
2498   int size = NUM2INT (sizev);
2499
2500   int r;
2501
2502   r = guestfs_write_file (g, path, content, size);
2503   if (r == -1)
2504     rb_raise (e_Error, "%s", guestfs_last_error (g));
2505
2506   return Qnil;
2507 }
2508
2509 static VALUE ruby_guestfs_umount (VALUE gv, VALUE pathordevicev)
2510 {
2511   guestfs_h *g;
2512   Data_Get_Struct (gv, guestfs_h, g);
2513   if (!g)
2514     rb_raise (rb_eArgError, "%s: used handle after closing it", "umount");
2515
2516   Check_Type (pathordevicev, T_STRING);
2517   const char *pathordevice = StringValueCStr (pathordevicev);
2518   if (!pathordevice)
2519     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2520               "pathordevice", "umount");
2521
2522   int r;
2523
2524   r = guestfs_umount (g, pathordevice);
2525   if (r == -1)
2526     rb_raise (e_Error, "%s", guestfs_last_error (g));
2527
2528   return Qnil;
2529 }
2530
2531 static VALUE ruby_guestfs_mounts (VALUE gv)
2532 {
2533   guestfs_h *g;
2534   Data_Get_Struct (gv, guestfs_h, g);
2535   if (!g)
2536     rb_raise (rb_eArgError, "%s: used handle after closing it", "mounts");
2537
2538
2539   char **r;
2540
2541   r = guestfs_mounts (g);
2542   if (r == NULL)
2543     rb_raise (e_Error, "%s", guestfs_last_error (g));
2544
2545   int i, len = 0;
2546   for (i = 0; r[i] != NULL; ++i) len++;
2547   VALUE rv = rb_ary_new2 (len);
2548   for (i = 0; r[i] != NULL; ++i) {
2549     rb_ary_push (rv, rb_str_new2 (r[i]));
2550     free (r[i]);
2551   }
2552   free (r);
2553   return rv;
2554 }
2555
2556 static VALUE ruby_guestfs_umount_all (VALUE gv)
2557 {
2558   guestfs_h *g;
2559   Data_Get_Struct (gv, guestfs_h, g);
2560   if (!g)
2561     rb_raise (rb_eArgError, "%s: used handle after closing it", "umount_all");
2562
2563
2564   int r;
2565
2566   r = guestfs_umount_all (g);
2567   if (r == -1)
2568     rb_raise (e_Error, "%s", guestfs_last_error (g));
2569
2570   return Qnil;
2571 }
2572
2573 static VALUE ruby_guestfs_lvm_remove_all (VALUE gv)
2574 {
2575   guestfs_h *g;
2576   Data_Get_Struct (gv, guestfs_h, g);
2577   if (!g)
2578     rb_raise (rb_eArgError, "%s: used handle after closing it", "lvm_remove_all");
2579
2580
2581   int r;
2582
2583   r = guestfs_lvm_remove_all (g);
2584   if (r == -1)
2585     rb_raise (e_Error, "%s", guestfs_last_error (g));
2586
2587   return Qnil;
2588 }
2589
2590 static VALUE ruby_guestfs_file (VALUE gv, VALUE pathv)
2591 {
2592   guestfs_h *g;
2593   Data_Get_Struct (gv, guestfs_h, g);
2594   if (!g)
2595     rb_raise (rb_eArgError, "%s: used handle after closing it", "file");
2596
2597   Check_Type (pathv, T_STRING);
2598   const char *path = StringValueCStr (pathv);
2599   if (!path)
2600     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2601               "path", "file");
2602
2603   char *r;
2604
2605   r = guestfs_file (g, path);
2606   if (r == NULL)
2607     rb_raise (e_Error, "%s", guestfs_last_error (g));
2608
2609   VALUE rv = rb_str_new2 (r);
2610   free (r);
2611   return rv;
2612 }
2613
2614 static VALUE ruby_guestfs_command (VALUE gv, VALUE argumentsv)
2615 {
2616   guestfs_h *g;
2617   Data_Get_Struct (gv, guestfs_h, g);
2618   if (!g)
2619     rb_raise (rb_eArgError, "%s: used handle after closing it", "command");
2620
2621   char **arguments;
2622   Check_Type (argumentsv, T_ARRAY);
2623   {
2624     int i, len;
2625     len = RARRAY_LEN (argumentsv);
2626     arguments = guestfs_safe_malloc (g, sizeof (char *) * (len+1));
2627     for (i = 0; i < len; ++i) {
2628       VALUE v = rb_ary_entry (argumentsv, i);
2629       arguments[i] = StringValueCStr (v);
2630     }
2631     arguments[len] = NULL;
2632   }
2633
2634   char *r;
2635
2636   r = guestfs_command (g, arguments);
2637   free (arguments);
2638   if (r == NULL)
2639     rb_raise (e_Error, "%s", guestfs_last_error (g));
2640
2641   VALUE rv = rb_str_new2 (r);
2642   free (r);
2643   return rv;
2644 }
2645
2646 static VALUE ruby_guestfs_command_lines (VALUE gv, VALUE argumentsv)
2647 {
2648   guestfs_h *g;
2649   Data_Get_Struct (gv, guestfs_h, g);
2650   if (!g)
2651     rb_raise (rb_eArgError, "%s: used handle after closing it", "command_lines");
2652
2653   char **arguments;
2654   Check_Type (argumentsv, T_ARRAY);
2655   {
2656     int i, len;
2657     len = RARRAY_LEN (argumentsv);
2658     arguments = guestfs_safe_malloc (g, sizeof (char *) * (len+1));
2659     for (i = 0; i < len; ++i) {
2660       VALUE v = rb_ary_entry (argumentsv, i);
2661       arguments[i] = StringValueCStr (v);
2662     }
2663     arguments[len] = NULL;
2664   }
2665
2666   char **r;
2667
2668   r = guestfs_command_lines (g, arguments);
2669   free (arguments);
2670   if (r == NULL)
2671     rb_raise (e_Error, "%s", guestfs_last_error (g));
2672
2673   int i, len = 0;
2674   for (i = 0; r[i] != NULL; ++i) len++;
2675   VALUE rv = rb_ary_new2 (len);
2676   for (i = 0; r[i] != NULL; ++i) {
2677     rb_ary_push (rv, rb_str_new2 (r[i]));
2678     free (r[i]);
2679   }
2680   free (r);
2681   return rv;
2682 }
2683
2684 static VALUE ruby_guestfs_stat (VALUE gv, VALUE pathv)
2685 {
2686   guestfs_h *g;
2687   Data_Get_Struct (gv, guestfs_h, g);
2688   if (!g)
2689     rb_raise (rb_eArgError, "%s: used handle after closing it", "stat");
2690
2691   Check_Type (pathv, T_STRING);
2692   const char *path = StringValueCStr (pathv);
2693   if (!path)
2694     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2695               "path", "stat");
2696
2697   struct guestfs_stat *r;
2698
2699   r = guestfs_stat (g, path);
2700   if (r == NULL)
2701     rb_raise (e_Error, "%s", guestfs_last_error (g));
2702
2703   VALUE rv = rb_hash_new ();
2704   rb_hash_aset (rv, rb_str_new2 ("dev"), ULL2NUM (r->dev));
2705   rb_hash_aset (rv, rb_str_new2 ("ino"), ULL2NUM (r->ino));
2706   rb_hash_aset (rv, rb_str_new2 ("mode"), ULL2NUM (r->mode));
2707   rb_hash_aset (rv, rb_str_new2 ("nlink"), ULL2NUM (r->nlink));
2708   rb_hash_aset (rv, rb_str_new2 ("uid"), ULL2NUM (r->uid));
2709   rb_hash_aset (rv, rb_str_new2 ("gid"), ULL2NUM (r->gid));
2710   rb_hash_aset (rv, rb_str_new2 ("rdev"), ULL2NUM (r->rdev));
2711   rb_hash_aset (rv, rb_str_new2 ("size"), ULL2NUM (r->size));
2712   rb_hash_aset (rv, rb_str_new2 ("blksize"), ULL2NUM (r->blksize));
2713   rb_hash_aset (rv, rb_str_new2 ("blocks"), ULL2NUM (r->blocks));
2714   rb_hash_aset (rv, rb_str_new2 ("atime"), ULL2NUM (r->atime));
2715   rb_hash_aset (rv, rb_str_new2 ("mtime"), ULL2NUM (r->mtime));
2716   rb_hash_aset (rv, rb_str_new2 ("ctime"), ULL2NUM (r->ctime));
2717   free (r);
2718   return rv;
2719 }
2720
2721 static VALUE ruby_guestfs_lstat (VALUE gv, VALUE pathv)
2722 {
2723   guestfs_h *g;
2724   Data_Get_Struct (gv, guestfs_h, g);
2725   if (!g)
2726     rb_raise (rb_eArgError, "%s: used handle after closing it", "lstat");
2727
2728   Check_Type (pathv, T_STRING);
2729   const char *path = StringValueCStr (pathv);
2730   if (!path)
2731     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2732               "path", "lstat");
2733
2734   struct guestfs_stat *r;
2735
2736   r = guestfs_lstat (g, path);
2737   if (r == NULL)
2738     rb_raise (e_Error, "%s", guestfs_last_error (g));
2739
2740   VALUE rv = rb_hash_new ();
2741   rb_hash_aset (rv, rb_str_new2 ("dev"), ULL2NUM (r->dev));
2742   rb_hash_aset (rv, rb_str_new2 ("ino"), ULL2NUM (r->ino));
2743   rb_hash_aset (rv, rb_str_new2 ("mode"), ULL2NUM (r->mode));
2744   rb_hash_aset (rv, rb_str_new2 ("nlink"), ULL2NUM (r->nlink));
2745   rb_hash_aset (rv, rb_str_new2 ("uid"), ULL2NUM (r->uid));
2746   rb_hash_aset (rv, rb_str_new2 ("gid"), ULL2NUM (r->gid));
2747   rb_hash_aset (rv, rb_str_new2 ("rdev"), ULL2NUM (r->rdev));
2748   rb_hash_aset (rv, rb_str_new2 ("size"), ULL2NUM (r->size));
2749   rb_hash_aset (rv, rb_str_new2 ("blksize"), ULL2NUM (r->blksize));
2750   rb_hash_aset (rv, rb_str_new2 ("blocks"), ULL2NUM (r->blocks));
2751   rb_hash_aset (rv, rb_str_new2 ("atime"), ULL2NUM (r->atime));
2752   rb_hash_aset (rv, rb_str_new2 ("mtime"), ULL2NUM (r->mtime));
2753   rb_hash_aset (rv, rb_str_new2 ("ctime"), ULL2NUM (r->ctime));
2754   free (r);
2755   return rv;
2756 }
2757
2758 static VALUE ruby_guestfs_statvfs (VALUE gv, VALUE pathv)
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", "statvfs");
2764
2765   Check_Type (pathv, T_STRING);
2766   const char *path = StringValueCStr (pathv);
2767   if (!path)
2768     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2769               "path", "statvfs");
2770
2771   struct guestfs_statvfs *r;
2772
2773   r = guestfs_statvfs (g, path);
2774   if (r == NULL)
2775     rb_raise (e_Error, "%s", guestfs_last_error (g));
2776
2777   VALUE rv = rb_hash_new ();
2778   rb_hash_aset (rv, rb_str_new2 ("bsize"), ULL2NUM (r->bsize));
2779   rb_hash_aset (rv, rb_str_new2 ("frsize"), ULL2NUM (r->frsize));
2780   rb_hash_aset (rv, rb_str_new2 ("blocks"), ULL2NUM (r->blocks));
2781   rb_hash_aset (rv, rb_str_new2 ("bfree"), ULL2NUM (r->bfree));
2782   rb_hash_aset (rv, rb_str_new2 ("bavail"), ULL2NUM (r->bavail));
2783   rb_hash_aset (rv, rb_str_new2 ("files"), ULL2NUM (r->files));
2784   rb_hash_aset (rv, rb_str_new2 ("ffree"), ULL2NUM (r->ffree));
2785   rb_hash_aset (rv, rb_str_new2 ("favail"), ULL2NUM (r->favail));
2786   rb_hash_aset (rv, rb_str_new2 ("fsid"), ULL2NUM (r->fsid));
2787   rb_hash_aset (rv, rb_str_new2 ("flag"), ULL2NUM (r->flag));
2788   rb_hash_aset (rv, rb_str_new2 ("namemax"), ULL2NUM (r->namemax));
2789   free (r);
2790   return rv;
2791 }
2792
2793 static VALUE ruby_guestfs_tune2fs_l (VALUE gv, VALUE devicev)
2794 {
2795   guestfs_h *g;
2796   Data_Get_Struct (gv, guestfs_h, g);
2797   if (!g)
2798     rb_raise (rb_eArgError, "%s: used handle after closing it", "tune2fs_l");
2799
2800   Check_Type (devicev, T_STRING);
2801   const char *device = StringValueCStr (devicev);
2802   if (!device)
2803     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2804               "device", "tune2fs_l");
2805
2806   char **r;
2807
2808   r = guestfs_tune2fs_l (g, device);
2809   if (r == NULL)
2810     rb_raise (e_Error, "%s", guestfs_last_error (g));
2811
2812   VALUE rv = rb_hash_new ();
2813   int i;
2814   for (i = 0; r[i] != NULL; i+=2) {
2815     rb_hash_aset (rv, rb_str_new2 (r[i]), rb_str_new2 (r[i+1]));
2816     free (r[i]);
2817     free (r[i+1]);
2818   }
2819   free (r);
2820   return rv;
2821 }
2822
2823 static VALUE ruby_guestfs_blockdev_setro (VALUE gv, VALUE devicev)
2824 {
2825   guestfs_h *g;
2826   Data_Get_Struct (gv, guestfs_h, g);
2827   if (!g)
2828     rb_raise (rb_eArgError, "%s: used handle after closing it", "blockdev_setro");
2829
2830   Check_Type (devicev, T_STRING);
2831   const char *device = StringValueCStr (devicev);
2832   if (!device)
2833     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2834               "device", "blockdev_setro");
2835
2836   int r;
2837
2838   r = guestfs_blockdev_setro (g, device);
2839   if (r == -1)
2840     rb_raise (e_Error, "%s", guestfs_last_error (g));
2841
2842   return Qnil;
2843 }
2844
2845 static VALUE ruby_guestfs_blockdev_setrw (VALUE gv, VALUE devicev)
2846 {
2847   guestfs_h *g;
2848   Data_Get_Struct (gv, guestfs_h, g);
2849   if (!g)
2850     rb_raise (rb_eArgError, "%s: used handle after closing it", "blockdev_setrw");
2851
2852   Check_Type (devicev, T_STRING);
2853   const char *device = StringValueCStr (devicev);
2854   if (!device)
2855     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2856               "device", "blockdev_setrw");
2857
2858   int r;
2859
2860   r = guestfs_blockdev_setrw (g, device);
2861   if (r == -1)
2862     rb_raise (e_Error, "%s", guestfs_last_error (g));
2863
2864   return Qnil;
2865 }
2866
2867 static VALUE ruby_guestfs_blockdev_getro (VALUE gv, VALUE devicev)
2868 {
2869   guestfs_h *g;
2870   Data_Get_Struct (gv, guestfs_h, g);
2871   if (!g)
2872     rb_raise (rb_eArgError, "%s: used handle after closing it", "blockdev_getro");
2873
2874   Check_Type (devicev, T_STRING);
2875   const char *device = StringValueCStr (devicev);
2876   if (!device)
2877     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2878               "device", "blockdev_getro");
2879
2880   int r;
2881
2882   r = guestfs_blockdev_getro (g, device);
2883   if (r == -1)
2884     rb_raise (e_Error, "%s", guestfs_last_error (g));
2885
2886   return INT2NUM (r);
2887 }
2888
2889 static VALUE ruby_guestfs_blockdev_getss (VALUE gv, VALUE devicev)
2890 {
2891   guestfs_h *g;
2892   Data_Get_Struct (gv, guestfs_h, g);
2893   if (!g)
2894     rb_raise (rb_eArgError, "%s: used handle after closing it", "blockdev_getss");
2895
2896   Check_Type (devicev, T_STRING);
2897   const char *device = StringValueCStr (devicev);
2898   if (!device)
2899     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2900               "device", "blockdev_getss");
2901
2902   int r;
2903
2904   r = guestfs_blockdev_getss (g, device);
2905   if (r == -1)
2906     rb_raise (e_Error, "%s", guestfs_last_error (g));
2907
2908   return INT2NUM (r);
2909 }
2910
2911 static VALUE ruby_guestfs_blockdev_getbsz (VALUE gv, VALUE devicev)
2912 {
2913   guestfs_h *g;
2914   Data_Get_Struct (gv, guestfs_h, g);
2915   if (!g)
2916     rb_raise (rb_eArgError, "%s: used handle after closing it", "blockdev_getbsz");
2917
2918   Check_Type (devicev, T_STRING);
2919   const char *device = StringValueCStr (devicev);
2920   if (!device)
2921     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2922               "device", "blockdev_getbsz");
2923
2924   int r;
2925
2926   r = guestfs_blockdev_getbsz (g, device);
2927   if (r == -1)
2928     rb_raise (e_Error, "%s", guestfs_last_error (g));
2929
2930   return INT2NUM (r);
2931 }
2932
2933 static VALUE ruby_guestfs_blockdev_setbsz (VALUE gv, VALUE devicev, VALUE blocksizev)
2934 {
2935   guestfs_h *g;
2936   Data_Get_Struct (gv, guestfs_h, g);
2937   if (!g)
2938     rb_raise (rb_eArgError, "%s: used handle after closing it", "blockdev_setbsz");
2939
2940   Check_Type (devicev, T_STRING);
2941   const char *device = StringValueCStr (devicev);
2942   if (!device)
2943     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2944               "device", "blockdev_setbsz");
2945   int blocksize = NUM2INT (blocksizev);
2946
2947   int r;
2948
2949   r = guestfs_blockdev_setbsz (g, device, blocksize);
2950   if (r == -1)
2951     rb_raise (e_Error, "%s", guestfs_last_error (g));
2952
2953   return Qnil;
2954 }
2955
2956 static VALUE ruby_guestfs_blockdev_getsz (VALUE gv, VALUE devicev)
2957 {
2958   guestfs_h *g;
2959   Data_Get_Struct (gv, guestfs_h, g);
2960   if (!g)
2961     rb_raise (rb_eArgError, "%s: used handle after closing it", "blockdev_getsz");
2962
2963   Check_Type (devicev, T_STRING);
2964   const char *device = StringValueCStr (devicev);
2965   if (!device)
2966     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2967               "device", "blockdev_getsz");
2968
2969   int64_t r;
2970
2971   r = guestfs_blockdev_getsz (g, device);
2972   if (r == -1)
2973     rb_raise (e_Error, "%s", guestfs_last_error (g));
2974
2975   return ULL2NUM (r);
2976 }
2977
2978 static VALUE ruby_guestfs_blockdev_getsize64 (VALUE gv, VALUE devicev)
2979 {
2980   guestfs_h *g;
2981   Data_Get_Struct (gv, guestfs_h, g);
2982   if (!g)
2983     rb_raise (rb_eArgError, "%s: used handle after closing it", "blockdev_getsize64");
2984
2985   Check_Type (devicev, T_STRING);
2986   const char *device = StringValueCStr (devicev);
2987   if (!device)
2988     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2989               "device", "blockdev_getsize64");
2990
2991   int64_t r;
2992
2993   r = guestfs_blockdev_getsize64 (g, device);
2994   if (r == -1)
2995     rb_raise (e_Error, "%s", guestfs_last_error (g));
2996
2997   return ULL2NUM (r);
2998 }
2999
3000 static VALUE ruby_guestfs_blockdev_flushbufs (VALUE gv, VALUE devicev)
3001 {
3002   guestfs_h *g;
3003   Data_Get_Struct (gv, guestfs_h, g);
3004   if (!g)
3005     rb_raise (rb_eArgError, "%s: used handle after closing it", "blockdev_flushbufs");
3006
3007   Check_Type (devicev, T_STRING);
3008   const char *device = StringValueCStr (devicev);
3009   if (!device)
3010     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3011               "device", "blockdev_flushbufs");
3012
3013   int r;
3014
3015   r = guestfs_blockdev_flushbufs (g, device);
3016   if (r == -1)
3017     rb_raise (e_Error, "%s", guestfs_last_error (g));
3018
3019   return Qnil;
3020 }
3021
3022 static VALUE ruby_guestfs_blockdev_rereadpt (VALUE gv, VALUE devicev)
3023 {
3024   guestfs_h *g;
3025   Data_Get_Struct (gv, guestfs_h, g);
3026   if (!g)
3027     rb_raise (rb_eArgError, "%s: used handle after closing it", "blockdev_rereadpt");
3028
3029   Check_Type (devicev, T_STRING);
3030   const char *device = StringValueCStr (devicev);
3031   if (!device)
3032     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3033               "device", "blockdev_rereadpt");
3034
3035   int r;
3036
3037   r = guestfs_blockdev_rereadpt (g, device);
3038   if (r == -1)
3039     rb_raise (e_Error, "%s", guestfs_last_error (g));
3040
3041   return Qnil;
3042 }
3043
3044 static VALUE ruby_guestfs_upload (VALUE gv, VALUE filenamev, VALUE remotefilenamev)
3045 {
3046   guestfs_h *g;
3047   Data_Get_Struct (gv, guestfs_h, g);
3048   if (!g)
3049     rb_raise (rb_eArgError, "%s: used handle after closing it", "upload");
3050
3051   Check_Type (filenamev, T_STRING);
3052   const char *filename = StringValueCStr (filenamev);
3053   if (!filename)
3054     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3055               "filename", "upload");
3056   Check_Type (remotefilenamev, T_STRING);
3057   const char *remotefilename = StringValueCStr (remotefilenamev);
3058   if (!remotefilename)
3059     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3060               "remotefilename", "upload");
3061
3062   int r;
3063
3064   r = guestfs_upload (g, filename, remotefilename);
3065   if (r == -1)
3066     rb_raise (e_Error, "%s", guestfs_last_error (g));
3067
3068   return Qnil;
3069 }
3070
3071 static VALUE ruby_guestfs_download (VALUE gv, VALUE remotefilenamev, VALUE filenamev)
3072 {
3073   guestfs_h *g;
3074   Data_Get_Struct (gv, guestfs_h, g);
3075   if (!g)
3076     rb_raise (rb_eArgError, "%s: used handle after closing it", "download");
3077
3078   Check_Type (remotefilenamev, T_STRING);
3079   const char *remotefilename = StringValueCStr (remotefilenamev);
3080   if (!remotefilename)
3081     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3082               "remotefilename", "download");
3083   Check_Type (filenamev, T_STRING);
3084   const char *filename = StringValueCStr (filenamev);
3085   if (!filename)
3086     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3087               "filename", "download");
3088
3089   int r;
3090
3091   r = guestfs_download (g, remotefilename, filename);
3092   if (r == -1)
3093     rb_raise (e_Error, "%s", guestfs_last_error (g));
3094
3095   return Qnil;
3096 }
3097
3098 static VALUE ruby_guestfs_checksum (VALUE gv, VALUE csumtypev, VALUE pathv)
3099 {
3100   guestfs_h *g;
3101   Data_Get_Struct (gv, guestfs_h, g);
3102   if (!g)
3103     rb_raise (rb_eArgError, "%s: used handle after closing it", "checksum");
3104
3105   Check_Type (csumtypev, T_STRING);
3106   const char *csumtype = StringValueCStr (csumtypev);
3107   if (!csumtype)
3108     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3109               "csumtype", "checksum");
3110   Check_Type (pathv, T_STRING);
3111   const char *path = StringValueCStr (pathv);
3112   if (!path)
3113     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3114               "path", "checksum");
3115
3116   char *r;
3117
3118   r = guestfs_checksum (g, csumtype, path);
3119   if (r == NULL)
3120     rb_raise (e_Error, "%s", guestfs_last_error (g));
3121
3122   VALUE rv = rb_str_new2 (r);
3123   free (r);
3124   return rv;
3125 }
3126
3127 static VALUE ruby_guestfs_tar_in (VALUE gv, VALUE tarfilev, VALUE directoryv)
3128 {
3129   guestfs_h *g;
3130   Data_Get_Struct (gv, guestfs_h, g);
3131   if (!g)
3132     rb_raise (rb_eArgError, "%s: used handle after closing it", "tar_in");
3133
3134   Check_Type (tarfilev, T_STRING);
3135   const char *tarfile = StringValueCStr (tarfilev);
3136   if (!tarfile)
3137     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3138               "tarfile", "tar_in");
3139   Check_Type (directoryv, T_STRING);
3140   const char *directory = StringValueCStr (directoryv);
3141   if (!directory)
3142     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3143               "directory", "tar_in");
3144
3145   int r;
3146
3147   r = guestfs_tar_in (g, tarfile, directory);
3148   if (r == -1)
3149     rb_raise (e_Error, "%s", guestfs_last_error (g));
3150
3151   return Qnil;
3152 }
3153
3154 static VALUE ruby_guestfs_tar_out (VALUE gv, VALUE directoryv, VALUE tarfilev)
3155 {
3156   guestfs_h *g;
3157   Data_Get_Struct (gv, guestfs_h, g);
3158   if (!g)
3159     rb_raise (rb_eArgError, "%s: used handle after closing it", "tar_out");
3160
3161   Check_Type (directoryv, T_STRING);
3162   const char *directory = StringValueCStr (directoryv);
3163   if (!directory)
3164     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3165               "directory", "tar_out");
3166   Check_Type (tarfilev, T_STRING);
3167   const char *tarfile = StringValueCStr (tarfilev);
3168   if (!tarfile)
3169     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3170               "tarfile", "tar_out");
3171
3172   int r;
3173
3174   r = guestfs_tar_out (g, directory, tarfile);
3175   if (r == -1)
3176     rb_raise (e_Error, "%s", guestfs_last_error (g));
3177
3178   return Qnil;
3179 }
3180
3181 static VALUE ruby_guestfs_tgz_in (VALUE gv, VALUE tarballv, VALUE directoryv)
3182 {
3183   guestfs_h *g;
3184   Data_Get_Struct (gv, guestfs_h, g);
3185   if (!g)
3186     rb_raise (rb_eArgError, "%s: used handle after closing it", "tgz_in");
3187
3188   Check_Type (tarballv, T_STRING);
3189   const char *tarball = StringValueCStr (tarballv);
3190   if (!tarball)
3191     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3192               "tarball", "tgz_in");
3193   Check_Type (directoryv, T_STRING);
3194   const char *directory = StringValueCStr (directoryv);
3195   if (!directory)
3196     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3197               "directory", "tgz_in");
3198
3199   int r;
3200
3201   r = guestfs_tgz_in (g, tarball, directory);
3202   if (r == -1)
3203     rb_raise (e_Error, "%s", guestfs_last_error (g));
3204
3205   return Qnil;
3206 }
3207
3208 static VALUE ruby_guestfs_tgz_out (VALUE gv, VALUE directoryv, VALUE tarballv)
3209 {
3210   guestfs_h *g;
3211   Data_Get_Struct (gv, guestfs_h, g);
3212   if (!g)
3213     rb_raise (rb_eArgError, "%s: used handle after closing it", "tgz_out");
3214
3215   Check_Type (directoryv, T_STRING);
3216   const char *directory = StringValueCStr (directoryv);
3217   if (!directory)
3218     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3219               "directory", "tgz_out");
3220   Check_Type (tarballv, T_STRING);
3221   const char *tarball = StringValueCStr (tarballv);
3222   if (!tarball)
3223     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3224               "tarball", "tgz_out");
3225
3226   int r;
3227
3228   r = guestfs_tgz_out (g, directory, tarball);
3229   if (r == -1)
3230     rb_raise (e_Error, "%s", guestfs_last_error (g));
3231
3232   return Qnil;
3233 }
3234
3235 static VALUE ruby_guestfs_mount_ro (VALUE gv, VALUE devicev, VALUE mountpointv)
3236 {
3237   guestfs_h *g;
3238   Data_Get_Struct (gv, guestfs_h, g);
3239   if (!g)
3240     rb_raise (rb_eArgError, "%s: used handle after closing it", "mount_ro");
3241
3242   Check_Type (devicev, T_STRING);
3243   const char *device = StringValueCStr (devicev);
3244   if (!device)
3245     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3246               "device", "mount_ro");
3247   Check_Type (mountpointv, T_STRING);
3248   const char *mountpoint = StringValueCStr (mountpointv);
3249   if (!mountpoint)
3250     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3251               "mountpoint", "mount_ro");
3252
3253   int r;
3254
3255   r = guestfs_mount_ro (g, device, mountpoint);
3256   if (r == -1)
3257     rb_raise (e_Error, "%s", guestfs_last_error (g));
3258
3259   return Qnil;
3260 }
3261
3262 static VALUE ruby_guestfs_mount_options (VALUE gv, VALUE optionsv, VALUE devicev, VALUE mountpointv)
3263 {
3264   guestfs_h *g;
3265   Data_Get_Struct (gv, guestfs_h, g);
3266   if (!g)
3267     rb_raise (rb_eArgError, "%s: used handle after closing it", "mount_options");
3268
3269   Check_Type (optionsv, T_STRING);
3270   const char *options = StringValueCStr (optionsv);
3271   if (!options)
3272     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3273               "options", "mount_options");
3274   Check_Type (devicev, T_STRING);
3275   const char *device = StringValueCStr (devicev);
3276   if (!device)
3277     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3278               "device", "mount_options");
3279   Check_Type (mountpointv, T_STRING);
3280   const char *mountpoint = StringValueCStr (mountpointv);
3281   if (!mountpoint)
3282     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3283               "mountpoint", "mount_options");
3284
3285   int r;
3286
3287   r = guestfs_mount_options (g, options, device, mountpoint);
3288   if (r == -1)
3289     rb_raise (e_Error, "%s", guestfs_last_error (g));
3290
3291   return Qnil;
3292 }
3293
3294 static VALUE ruby_guestfs_mount_vfs (VALUE gv, VALUE optionsv, VALUE vfstypev, VALUE devicev, VALUE mountpointv)
3295 {
3296   guestfs_h *g;
3297   Data_Get_Struct (gv, guestfs_h, g);
3298   if (!g)
3299     rb_raise (rb_eArgError, "%s: used handle after closing it", "mount_vfs");
3300
3301   Check_Type (optionsv, T_STRING);
3302   const char *options = StringValueCStr (optionsv);
3303   if (!options)
3304     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3305               "options", "mount_vfs");
3306   Check_Type (vfstypev, T_STRING);
3307   const char *vfstype = StringValueCStr (vfstypev);
3308   if (!vfstype)
3309     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3310               "vfstype", "mount_vfs");
3311   Check_Type (devicev, T_STRING);
3312   const char *device = StringValueCStr (devicev);
3313   if (!device)
3314     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3315               "device", "mount_vfs");
3316   Check_Type (mountpointv, T_STRING);
3317   const char *mountpoint = StringValueCStr (mountpointv);
3318   if (!mountpoint)
3319     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3320               "mountpoint", "mount_vfs");
3321
3322   int r;
3323
3324   r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint);
3325   if (r == -1)
3326     rb_raise (e_Error, "%s", guestfs_last_error (g));
3327
3328   return Qnil;
3329 }
3330
3331 static VALUE ruby_guestfs_debug (VALUE gv, VALUE subcmdv, VALUE extraargsv)
3332 {
3333   guestfs_h *g;
3334   Data_Get_Struct (gv, guestfs_h, g);
3335   if (!g)
3336     rb_raise (rb_eArgError, "%s: used handle after closing it", "debug");
3337
3338   Check_Type (subcmdv, T_STRING);
3339   const char *subcmd = StringValueCStr (subcmdv);
3340   if (!subcmd)
3341     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3342               "subcmd", "debug");
3343   char **extraargs;
3344   Check_Type (extraargsv, T_ARRAY);
3345   {
3346     int i, len;
3347     len = RARRAY_LEN (extraargsv);
3348     extraargs = guestfs_safe_malloc (g, sizeof (char *) * (len+1));
3349     for (i = 0; i < len; ++i) {
3350       VALUE v = rb_ary_entry (extraargsv, i);
3351       extraargs[i] = StringValueCStr (v);
3352     }
3353     extraargs[len] = NULL;
3354   }
3355
3356   char *r;
3357
3358   r = guestfs_debug (g, subcmd, extraargs);
3359   free (extraargs);
3360   if (r == NULL)
3361     rb_raise (e_Error, "%s", guestfs_last_error (g));
3362
3363   VALUE rv = rb_str_new2 (r);
3364   free (r);
3365   return rv;
3366 }
3367
3368 static VALUE ruby_guestfs_lvremove (VALUE gv, VALUE devicev)
3369 {
3370   guestfs_h *g;
3371   Data_Get_Struct (gv, guestfs_h, g);
3372   if (!g)
3373     rb_raise (rb_eArgError, "%s: used handle after closing it", "lvremove");
3374
3375   Check_Type (devicev, T_STRING);
3376   const char *device = StringValueCStr (devicev);
3377   if (!device)
3378     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3379               "device", "lvremove");
3380
3381   int r;
3382
3383   r = guestfs_lvremove (g, device);
3384   if (r == -1)
3385     rb_raise (e_Error, "%s", guestfs_last_error (g));
3386
3387   return Qnil;
3388 }
3389
3390 static VALUE ruby_guestfs_vgremove (VALUE gv, VALUE vgnamev)
3391 {
3392   guestfs_h *g;
3393   Data_Get_Struct (gv, guestfs_h, g);
3394   if (!g)
3395     rb_raise (rb_eArgError, "%s: used handle after closing it", "vgremove");
3396
3397   Check_Type (vgnamev, T_STRING);
3398   const char *vgname = StringValueCStr (vgnamev);
3399   if (!vgname)
3400     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3401               "vgname", "vgremove");
3402
3403   int r;
3404
3405   r = guestfs_vgremove (g, vgname);
3406   if (r == -1)
3407     rb_raise (e_Error, "%s", guestfs_last_error (g));
3408
3409   return Qnil;
3410 }
3411
3412 static VALUE ruby_guestfs_pvremove (VALUE gv, VALUE devicev)
3413 {
3414   guestfs_h *g;
3415   Data_Get_Struct (gv, guestfs_h, g);
3416   if (!g)
3417     rb_raise (rb_eArgError, "%s: used handle after closing it", "pvremove");
3418
3419   Check_Type (devicev, T_STRING);
3420   const char *device = StringValueCStr (devicev);
3421   if (!device)
3422     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3423               "device", "pvremove");
3424
3425   int r;
3426
3427   r = guestfs_pvremove (g, device);
3428   if (r == -1)
3429     rb_raise (e_Error, "%s", guestfs_last_error (g));
3430
3431   return Qnil;
3432 }
3433
3434 static VALUE ruby_guestfs_set_e2label (VALUE gv, VALUE devicev, VALUE labelv)
3435 {
3436   guestfs_h *g;
3437   Data_Get_Struct (gv, guestfs_h, g);
3438   if (!g)
3439     rb_raise (rb_eArgError, "%s: used handle after closing it", "set_e2label");
3440
3441   Check_Type (devicev, T_STRING);
3442   const char *device = StringValueCStr (devicev);
3443   if (!device)
3444     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3445               "device", "set_e2label");
3446   Check_Type (labelv, T_STRING);
3447   const char *label = StringValueCStr (labelv);
3448   if (!label)
3449     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3450               "label", "set_e2label");
3451
3452   int r;
3453
3454   r = guestfs_set_e2label (g, device, label);
3455   if (r == -1)
3456     rb_raise (e_Error, "%s", guestfs_last_error (g));
3457
3458   return Qnil;
3459 }
3460
3461 static VALUE ruby_guestfs_get_e2label (VALUE gv, VALUE devicev)
3462 {
3463   guestfs_h *g;
3464   Data_Get_Struct (gv, guestfs_h, g);
3465   if (!g)
3466     rb_raise (rb_eArgError, "%s: used handle after closing it", "get_e2label");
3467
3468   Check_Type (devicev, T_STRING);
3469   const char *device = StringValueCStr (devicev);
3470   if (!device)
3471     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3472               "device", "get_e2label");
3473
3474   char *r;
3475
3476   r = guestfs_get_e2label (g, device);
3477   if (r == NULL)
3478     rb_raise (e_Error, "%s", guestfs_last_error (g));
3479
3480   VALUE rv = rb_str_new2 (r);
3481   free (r);
3482   return rv;
3483 }
3484
3485 static VALUE ruby_guestfs_set_e2uuid (VALUE gv, VALUE devicev, VALUE uuidv)
3486 {
3487   guestfs_h *g;
3488   Data_Get_Struct (gv, guestfs_h, g);
3489   if (!g)
3490     rb_raise (rb_eArgError, "%s: used handle after closing it", "set_e2uuid");
3491
3492   Check_Type (devicev, T_STRING);
3493   const char *device = StringValueCStr (devicev);
3494   if (!device)
3495     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3496               "device", "set_e2uuid");
3497   Check_Type (uuidv, T_STRING);
3498   const char *uuid = StringValueCStr (uuidv);
3499   if (!uuid)
3500     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3501               "uuid", "set_e2uuid");
3502
3503   int r;
3504
3505   r = guestfs_set_e2uuid (g, device, uuid);
3506   if (r == -1)
3507     rb_raise (e_Error, "%s", guestfs_last_error (g));
3508
3509   return Qnil;
3510 }
3511
3512 static VALUE ruby_guestfs_get_e2uuid (VALUE gv, VALUE devicev)
3513 {
3514   guestfs_h *g;
3515   Data_Get_Struct (gv, guestfs_h, g);
3516   if (!g)
3517     rb_raise (rb_eArgError, "%s: used handle after closing it", "get_e2uuid");
3518
3519   Check_Type (devicev, T_STRING);
3520   const char *device = StringValueCStr (devicev);
3521   if (!device)
3522     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3523               "device", "get_e2uuid");
3524
3525   char *r;
3526
3527   r = guestfs_get_e2uuid (g, device);
3528   if (r == NULL)
3529     rb_raise (e_Error, "%s", guestfs_last_error (g));
3530
3531   VALUE rv = rb_str_new2 (r);
3532   free (r);
3533   return rv;
3534 }
3535
3536 static VALUE ruby_guestfs_fsck (VALUE gv, VALUE fstypev, VALUE devicev)
3537 {
3538   guestfs_h *g;
3539   Data_Get_Struct (gv, guestfs_h, g);
3540   if (!g)
3541     rb_raise (rb_eArgError, "%s: used handle after closing it", "fsck");
3542
3543   Check_Type (fstypev, T_STRING);
3544   const char *fstype = StringValueCStr (fstypev);
3545   if (!fstype)
3546     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3547               "fstype", "fsck");
3548   Check_Type (devicev, T_STRING);
3549   const char *device = StringValueCStr (devicev);
3550   if (!device)
3551     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3552               "device", "fsck");
3553
3554   int r;
3555
3556   r = guestfs_fsck (g, fstype, device);
3557   if (r == -1)
3558     rb_raise (e_Error, "%s", guestfs_last_error (g));
3559
3560   return INT2NUM (r);
3561 }
3562
3563 static VALUE ruby_guestfs_zero (VALUE gv, VALUE devicev)
3564 {
3565   guestfs_h *g;
3566   Data_Get_Struct (gv, guestfs_h, g);
3567   if (!g)
3568     rb_raise (rb_eArgError, "%s: used handle after closing it", "zero");
3569
3570   Check_Type (devicev, T_STRING);
3571   const char *device = StringValueCStr (devicev);
3572   if (!device)
3573     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3574               "device", "zero");
3575
3576   int r;
3577
3578   r = guestfs_zero (g, device);
3579   if (r == -1)
3580     rb_raise (e_Error, "%s", guestfs_last_error (g));
3581
3582   return Qnil;
3583 }
3584
3585 static VALUE ruby_guestfs_grub_install (VALUE gv, VALUE rootv, VALUE devicev)
3586 {
3587   guestfs_h *g;
3588   Data_Get_Struct (gv, guestfs_h, g);
3589   if (!g)
3590     rb_raise (rb_eArgError, "%s: used handle after closing it", "grub_install");
3591
3592   Check_Type (rootv, T_STRING);
3593   const char *root = StringValueCStr (rootv);
3594   if (!root)
3595     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3596               "root", "grub_install");
3597   Check_Type (devicev, T_STRING);
3598   const char *device = StringValueCStr (devicev);
3599   if (!device)
3600     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3601               "device", "grub_install");
3602
3603   int r;
3604
3605   r = guestfs_grub_install (g, root, device);
3606   if (r == -1)
3607     rb_raise (e_Error, "%s", guestfs_last_error (g));
3608
3609   return Qnil;
3610 }
3611
3612 static VALUE ruby_guestfs_cp (VALUE gv, VALUE srcv, VALUE destv)
3613 {
3614   guestfs_h *g;
3615   Data_Get_Struct (gv, guestfs_h, g);
3616   if (!g)
3617     rb_raise (rb_eArgError, "%s: used handle after closing it", "cp");
3618
3619   Check_Type (srcv, T_STRING);
3620   const char *src = StringValueCStr (srcv);
3621   if (!src)
3622     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3623               "src", "cp");
3624   Check_Type (destv, T_STRING);
3625   const char *dest = StringValueCStr (destv);
3626   if (!dest)
3627     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3628               "dest", "cp");
3629
3630   int r;
3631
3632   r = guestfs_cp (g, src, dest);
3633   if (r == -1)
3634     rb_raise (e_Error, "%s", guestfs_last_error (g));
3635
3636   return Qnil;
3637 }
3638
3639 static VALUE ruby_guestfs_cp_a (VALUE gv, VALUE srcv, VALUE destv)
3640 {
3641   guestfs_h *g;
3642   Data_Get_Struct (gv, guestfs_h, g);
3643   if (!g)
3644     rb_raise (rb_eArgError, "%s: used handle after closing it", "cp_a");
3645
3646   Check_Type (srcv, T_STRING);
3647   const char *src = StringValueCStr (srcv);
3648   if (!src)
3649     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3650               "src", "cp_a");
3651   Check_Type (destv, T_STRING);
3652   const char *dest = StringValueCStr (destv);
3653   if (!dest)
3654     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3655               "dest", "cp_a");
3656
3657   int r;
3658
3659   r = guestfs_cp_a (g, src, dest);
3660   if (r == -1)
3661     rb_raise (e_Error, "%s", guestfs_last_error (g));
3662
3663   return Qnil;
3664 }
3665
3666 static VALUE ruby_guestfs_mv (VALUE gv, VALUE srcv, VALUE destv)
3667 {
3668   guestfs_h *g;
3669   Data_Get_Struct (gv, guestfs_h, g);
3670   if (!g)
3671     rb_raise (rb_eArgError, "%s: used handle after closing it", "mv");
3672
3673   Check_Type (srcv, T_STRING);
3674   const char *src = StringValueCStr (srcv);
3675   if (!src)
3676     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3677               "src", "mv");
3678   Check_Type (destv, T_STRING);
3679   const char *dest = StringValueCStr (destv);
3680   if (!dest)
3681     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3682               "dest", "mv");
3683
3684   int r;
3685
3686   r = guestfs_mv (g, src, dest);
3687   if (r == -1)
3688     rb_raise (e_Error, "%s", guestfs_last_error (g));
3689
3690   return Qnil;
3691 }
3692
3693 static VALUE ruby_guestfs_drop_caches (VALUE gv, VALUE whattodropv)
3694 {
3695   guestfs_h *g;
3696   Data_Get_Struct (gv, guestfs_h, g);
3697   if (!g)
3698     rb_raise (rb_eArgError, "%s: used handle after closing it", "drop_caches");
3699
3700   int whattodrop = NUM2INT (whattodropv);
3701
3702   int r;
3703
3704   r = guestfs_drop_caches (g, whattodrop);
3705   if (r == -1)
3706     rb_raise (e_Error, "%s", guestfs_last_error (g));
3707
3708   return Qnil;
3709 }
3710
3711 static VALUE ruby_guestfs_dmesg (VALUE gv)
3712 {
3713   guestfs_h *g;
3714   Data_Get_Struct (gv, guestfs_h, g);
3715   if (!g)
3716     rb_raise (rb_eArgError, "%s: used handle after closing it", "dmesg");
3717
3718
3719   char *r;
3720
3721   r = guestfs_dmesg (g);
3722   if (r == NULL)
3723     rb_raise (e_Error, "%s", guestfs_last_error (g));
3724
3725   VALUE rv = rb_str_new2 (r);
3726   free (r);
3727   return rv;
3728 }
3729
3730 static VALUE ruby_guestfs_ping_daemon (VALUE gv)
3731 {
3732   guestfs_h *g;
3733   Data_Get_Struct (gv, guestfs_h, g);
3734   if (!g)
3735     rb_raise (rb_eArgError, "%s: used handle after closing it", "ping_daemon");
3736
3737
3738   int r;
3739
3740   r = guestfs_ping_daemon (g);
3741   if (r == -1)
3742     rb_raise (e_Error, "%s", guestfs_last_error (g));
3743
3744   return Qnil;
3745 }
3746
3747 static VALUE ruby_guestfs_equal (VALUE gv, VALUE file1v, VALUE file2v)
3748 {
3749   guestfs_h *g;
3750   Data_Get_Struct (gv, guestfs_h, g);
3751   if (!g)
3752     rb_raise (rb_eArgError, "%s: used handle after closing it", "equal");
3753
3754   Check_Type (file1v, T_STRING);
3755   const char *file1 = StringValueCStr (file1v);
3756   if (!file1)
3757     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3758               "file1", "equal");
3759   Check_Type (file2v, T_STRING);
3760   const char *file2 = StringValueCStr (file2v);
3761   if (!file2)
3762     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3763               "file2", "equal");
3764
3765   int r;
3766
3767   r = guestfs_equal (g, file1, file2);
3768   if (r == -1)
3769     rb_raise (e_Error, "%s", guestfs_last_error (g));
3770
3771   return INT2NUM (r);
3772 }
3773
3774 static VALUE ruby_guestfs_strings (VALUE gv, VALUE pathv)
3775 {
3776   guestfs_h *g;
3777   Data_Get_Struct (gv, guestfs_h, g);
3778   if (!g)
3779     rb_raise (rb_eArgError, "%s: used handle after closing it", "strings");
3780
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");
3786
3787   char **r;
3788
3789   r = guestfs_strings (g, 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_strings_e (VALUE gv, VALUE encodingv, 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", "strings_e");
3810
3811   Check_Type (encodingv, T_STRING);
3812   const char *encoding = StringValueCStr (encodingv);
3813   if (!encoding)
3814     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3815               "encoding", "strings_e");
3816   Check_Type (pathv, T_STRING);
3817   const char *path = StringValueCStr (pathv);
3818   if (!path)
3819     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3820               "path", "strings_e");
3821
3822   char **r;
3823
3824   r = guestfs_strings_e (g, encoding, path);
3825   if (r == NULL)
3826     rb_raise (e_Error, "%s", guestfs_last_error (g));
3827
3828   int i, len = 0;
3829   for (i = 0; r[i] != NULL; ++i) len++;
3830   VALUE rv = rb_ary_new2 (len);
3831   for (i = 0; r[i] != NULL; ++i) {
3832     rb_ary_push (rv, rb_str_new2 (r[i]));
3833     free (r[i]);
3834   }
3835   free (r);
3836   return rv;
3837 }
3838
3839 static VALUE ruby_guestfs_hexdump (VALUE gv, VALUE pathv)
3840 {
3841   guestfs_h *g;
3842   Data_Get_Struct (gv, guestfs_h, g);
3843   if (!g)
3844     rb_raise (rb_eArgError, "%s: used handle after closing it", "hexdump");
3845
3846   Check_Type (pathv, T_STRING);
3847   const char *path = StringValueCStr (pathv);
3848   if (!path)
3849     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3850               "path", "hexdump");
3851
3852   char *r;
3853
3854   r = guestfs_hexdump (g, path);
3855   if (r == NULL)
3856     rb_raise (e_Error, "%s", guestfs_last_error (g));
3857
3858   VALUE rv = rb_str_new2 (r);
3859   free (r);
3860   return rv;
3861 }
3862
3863 static VALUE ruby_guestfs_zerofree (VALUE gv, VALUE devicev)
3864 {
3865   guestfs_h *g;
3866   Data_Get_Struct (gv, guestfs_h, g);
3867   if (!g)
3868     rb_raise (rb_eArgError, "%s: used handle after closing it", "zerofree");
3869
3870   Check_Type (devicev, T_STRING);
3871   const char *device = StringValueCStr (devicev);
3872   if (!device)
3873     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3874               "device", "zerofree");
3875
3876   int r;
3877
3878   r = guestfs_zerofree (g, device);
3879   if (r == -1)
3880     rb_raise (e_Error, "%s", guestfs_last_error (g));
3881
3882   return Qnil;
3883 }
3884
3885 static VALUE ruby_guestfs_pvresize (VALUE gv, VALUE devicev)
3886 {
3887   guestfs_h *g;
3888   Data_Get_Struct (gv, guestfs_h, g);
3889   if (!g)
3890     rb_raise (rb_eArgError, "%s: used handle after closing it", "pvresize");
3891
3892   Check_Type (devicev, T_STRING);
3893   const char *device = StringValueCStr (devicev);
3894   if (!device)
3895     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3896               "device", "pvresize");
3897
3898   int r;
3899
3900   r = guestfs_pvresize (g, device);
3901   if (r == -1)
3902     rb_raise (e_Error, "%s", guestfs_last_error (g));
3903
3904   return Qnil;
3905 }
3906
3907 static VALUE ruby_guestfs_sfdisk_N (VALUE gv, VALUE devicev, VALUE partnumv, VALUE cylsv, VALUE headsv, VALUE sectorsv, VALUE linev)
3908 {
3909   guestfs_h *g;
3910   Data_Get_Struct (gv, guestfs_h, g);
3911   if (!g)
3912     rb_raise (rb_eArgError, "%s: used handle after closing it", "sfdisk_N");
3913
3914   Check_Type (devicev, T_STRING);
3915   const char *device = StringValueCStr (devicev);
3916   if (!device)
3917     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3918               "device", "sfdisk_N");
3919   int partnum = NUM2INT (partnumv);
3920   int cyls = NUM2INT (cylsv);
3921   int heads = NUM2INT (headsv);
3922   int sectors = NUM2INT (sectorsv);
3923   Check_Type (linev, T_STRING);
3924   const char *line = StringValueCStr (linev);
3925   if (!line)
3926     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3927               "line", "sfdisk_N");
3928
3929   int r;
3930
3931   r = guestfs_sfdisk_N (g, device, partnum, cyls, heads, sectors, line);
3932   if (r == -1)
3933     rb_raise (e_Error, "%s", guestfs_last_error (g));
3934
3935   return Qnil;
3936 }
3937
3938 static VALUE ruby_guestfs_sfdisk_l (VALUE gv, VALUE devicev)
3939 {
3940   guestfs_h *g;
3941   Data_Get_Struct (gv, guestfs_h, g);
3942   if (!g)
3943     rb_raise (rb_eArgError, "%s: used handle after closing it", "sfdisk_l");
3944
3945   Check_Type (devicev, T_STRING);
3946   const char *device = StringValueCStr (devicev);
3947   if (!device)
3948     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3949               "device", "sfdisk_l");
3950
3951   char *r;
3952
3953   r = guestfs_sfdisk_l (g, device);
3954   if (r == NULL)
3955     rb_raise (e_Error, "%s", guestfs_last_error (g));
3956
3957   VALUE rv = rb_str_new2 (r);
3958   free (r);
3959   return rv;
3960 }
3961
3962 static VALUE ruby_guestfs_sfdisk_kernel_geometry (VALUE gv, VALUE devicev)
3963 {
3964   guestfs_h *g;
3965   Data_Get_Struct (gv, guestfs_h, g);
3966   if (!g)
3967     rb_raise (rb_eArgError, "%s: used handle after closing it", "sfdisk_kernel_geometry");
3968
3969   Check_Type (devicev, T_STRING);
3970   const char *device = StringValueCStr (devicev);
3971   if (!device)
3972     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3973               "device", "sfdisk_kernel_geometry");
3974
3975   char *r;
3976
3977   r = guestfs_sfdisk_kernel_geometry (g, device);
3978   if (r == NULL)
3979     rb_raise (e_Error, "%s", guestfs_last_error (g));
3980
3981   VALUE rv = rb_str_new2 (r);
3982   free (r);
3983   return rv;
3984 }
3985
3986 static VALUE ruby_guestfs_sfdisk_disk_geometry (VALUE gv, VALUE devicev)
3987 {
3988   guestfs_h *g;
3989   Data_Get_Struct (gv, guestfs_h, g);
3990   if (!g)
3991     rb_raise (rb_eArgError, "%s: used handle after closing it", "sfdisk_disk_geometry");
3992
3993   Check_Type (devicev, T_STRING);
3994   const char *device = StringValueCStr (devicev);
3995   if (!device)
3996     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3997               "device", "sfdisk_disk_geometry");
3998
3999   char *r;
4000
4001   r = guestfs_sfdisk_disk_geometry (g, device);
4002   if (r == NULL)
4003     rb_raise (e_Error, "%s", guestfs_last_error (g));
4004
4005   VALUE rv = rb_str_new2 (r);
4006   free (r);
4007   return rv;
4008 }
4009
4010 static VALUE ruby_guestfs_vg_activate_all (VALUE gv, VALUE activatev)
4011 {
4012   guestfs_h *g;
4013   Data_Get_Struct (gv, guestfs_h, g);
4014   if (!g)
4015     rb_raise (rb_eArgError, "%s: used handle after closing it", "vg_activate_all");
4016
4017   int activate = RTEST (activatev);
4018
4019   int r;
4020
4021   r = guestfs_vg_activate_all (g, activate);
4022   if (r == -1)
4023     rb_raise (e_Error, "%s", guestfs_last_error (g));
4024
4025   return Qnil;
4026 }
4027
4028 static VALUE ruby_guestfs_vg_activate (VALUE gv, VALUE activatev, VALUE volgroupsv)
4029 {
4030   guestfs_h *g;
4031   Data_Get_Struct (gv, guestfs_h, g);
4032   if (!g)
4033     rb_raise (rb_eArgError, "%s: used handle after closing it", "vg_activate");
4034
4035   int activate = RTEST (activatev);
4036   char **volgroups;
4037   Check_Type (volgroupsv, T_ARRAY);
4038   {
4039     int i, len;
4040     len = RARRAY_LEN (volgroupsv);
4041     volgroups = guestfs_safe_malloc (g, sizeof (char *) * (len+1));
4042     for (i = 0; i < len; ++i) {
4043       VALUE v = rb_ary_entry (volgroupsv, i);
4044       volgroups[i] = StringValueCStr (v);
4045     }
4046     volgroups[len] = NULL;
4047   }
4048
4049   int r;
4050
4051   r = guestfs_vg_activate (g, activate, volgroups);
4052   free (volgroups);
4053   if (r == -1)
4054     rb_raise (e_Error, "%s", guestfs_last_error (g));
4055
4056   return Qnil;
4057 }
4058
4059 static VALUE ruby_guestfs_lvresize (VALUE gv, VALUE devicev, VALUE mbytesv)
4060 {
4061   guestfs_h *g;
4062   Data_Get_Struct (gv, guestfs_h, g);
4063   if (!g)
4064     rb_raise (rb_eArgError, "%s: used handle after closing it", "lvresize");
4065
4066   Check_Type (devicev, T_STRING);
4067   const char *device = StringValueCStr (devicev);
4068   if (!device)
4069     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
4070               "device", "lvresize");
4071   int mbytes = NUM2INT (mbytesv);
4072
4073   int r;
4074
4075   r = guestfs_lvresize (g, device, mbytes);
4076   if (r == -1)
4077     rb_raise (e_Error, "%s", guestfs_last_error (g));
4078
4079   return Qnil;
4080 }
4081
4082 static VALUE ruby_guestfs_resize2fs (VALUE gv, VALUE devicev)
4083 {
4084   guestfs_h *g;
4085   Data_Get_Struct (gv, guestfs_h, g);
4086   if (!g)
4087     rb_raise (rb_eArgError, "%s: used handle after closing it", "resize2fs");
4088
4089   Check_Type (devicev, T_STRING);
4090   const char *device = StringValueCStr (devicev);
4091   if (!device)
4092     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
4093               "device", "resize2fs");
4094
4095   int r;
4096
4097   r = guestfs_resize2fs (g, device);
4098   if (r == -1)
4099     rb_raise (e_Error, "%s", guestfs_last_error (g));
4100
4101   return Qnil;
4102 }
4103
4104 static VALUE ruby_guestfs_find (VALUE gv, VALUE directoryv)
4105 {
4106   guestfs_h *g;
4107   Data_Get_Struct (gv, guestfs_h, g);
4108   if (!g)
4109     rb_raise (rb_eArgError, "%s: used handle after closing it", "find");
4110
4111   Check_Type (directoryv, T_STRING);
4112   const char *directory = StringValueCStr (directoryv);
4113   if (!directory)
4114     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
4115               "directory", "find");
4116
4117   char **r;
4118
4119   r = guestfs_find (g, directory);
4120   if (r == NULL)
4121     rb_raise (e_Error, "%s", guestfs_last_error (g));
4122
4123   int i, len = 0;
4124   for (i = 0; r[i] != NULL; ++i) len++;
4125   VALUE rv = rb_ary_new2 (len);
4126   for (i = 0; r[i] != NULL; ++i) {
4127     rb_ary_push (rv, rb_str_new2 (r[i]));
4128     free (r[i]);
4129   }
4130   free (r);
4131   return rv;
4132 }
4133
4134 static VALUE ruby_guestfs_e2fsck_f (VALUE gv, VALUE devicev)
4135 {
4136   guestfs_h *g;
4137   Data_Get_Struct (gv, guestfs_h, g);
4138   if (!g)
4139     rb_raise (rb_eArgError, "%s: used handle after closing it", "e2fsck_f");
4140
4141   Check_Type (devicev, T_STRING);
4142   const char *device = StringValueCStr (devicev);
4143   if (!device)
4144     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
4145               "device", "e2fsck_f");
4146
4147   int r;
4148
4149   r = guestfs_e2fsck_f (g, device);
4150   if (r == -1)
4151     rb_raise (e_Error, "%s", guestfs_last_error (g));
4152
4153   return Qnil;
4154 }
4155
4156 static VALUE ruby_guestfs_sleep (VALUE gv, VALUE secsv)
4157 {
4158   guestfs_h *g;
4159   Data_Get_Struct (gv, guestfs_h, g);
4160   if (!g)
4161     rb_raise (rb_eArgError, "%s: used handle after closing it", "sleep");
4162
4163   int secs = NUM2INT (secsv);
4164
4165   int r;
4166
4167   r = guestfs_sleep (g, secs);
4168   if (r == -1)
4169     rb_raise (e_Error, "%s", guestfs_last_error (g));
4170
4171   return Qnil;
4172 }
4173
4174 static VALUE ruby_guestfs_ntfs_3g_probe (VALUE gv, VALUE rwv, VALUE devicev)
4175 {
4176   guestfs_h *g;
4177   Data_Get_Struct (gv, guestfs_h, g);
4178   if (!g)
4179     rb_raise (rb_eArgError, "%s: used handle after closing it", "ntfs_3g_probe");
4180
4181   int rw = RTEST (rwv);
4182   Check_Type (devicev, T_STRING);
4183   const char *device = StringValueCStr (devicev);
4184   if (!device)
4185     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
4186               "device", "ntfs_3g_probe");
4187
4188   int r;
4189
4190   r = guestfs_ntfs_3g_probe (g, rw, device);
4191   if (r == -1)
4192     rb_raise (e_Error, "%s", guestfs_last_error (g));
4193
4194   return INT2NUM (r);
4195 }
4196
4197 static VALUE ruby_guestfs_sh (VALUE gv, VALUE commandv)
4198 {
4199   guestfs_h *g;
4200   Data_Get_Struct (gv, guestfs_h, g);
4201   if (!g)
4202     rb_raise (rb_eArgError, "%s: used handle after closing it", "sh");
4203
4204   Check_Type (commandv, T_STRING);
4205   const char *command = StringValueCStr (commandv);
4206   if (!command)
4207     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
4208               "command", "sh");
4209
4210   char *r;
4211
4212   r = guestfs_sh (g, command);
4213   if (r == NULL)
4214     rb_raise (e_Error, "%s", guestfs_last_error (g));
4215
4216   VALUE rv = rb_str_new2 (r);
4217   free (r);
4218   return rv;
4219 }
4220
4221 static VALUE ruby_guestfs_sh_lines (VALUE gv, VALUE commandv)
4222 {
4223   guestfs_h *g;
4224   Data_Get_Struct (gv, guestfs_h, g);
4225   if (!g)
4226     rb_raise (rb_eArgError, "%s: used handle after closing it", "sh_lines");
4227
4228   Check_Type (commandv, T_STRING);
4229   const char *command = StringValueCStr (commandv);
4230   if (!command)
4231     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
4232               "command", "sh_lines");
4233
4234   char **r;
4235
4236   r = guestfs_sh_lines (g, command);
4237   if (r == NULL)
4238     rb_raise (e_Error, "%s", guestfs_last_error (g));
4239
4240   int i, len = 0;
4241   for (i = 0; r[i] != NULL; ++i) len++;
4242   VALUE rv = rb_ary_new2 (len);
4243   for (i = 0; r[i] != NULL; ++i) {
4244     rb_ary_push (rv, rb_str_new2 (r[i]));
4245     free (r[i]);
4246   }
4247   free (r);
4248   return rv;
4249 }
4250
4251 static VALUE ruby_guestfs_glob_expand (VALUE gv, VALUE patternv)
4252 {
4253   guestfs_h *g;
4254   Data_Get_Struct (gv, guestfs_h, g);
4255   if (!g)
4256     rb_raise (rb_eArgError, "%s: used handle after closing it", "glob_expand");
4257
4258   Check_Type (patternv, T_STRING);
4259   const char *pattern = StringValueCStr (patternv);
4260   if (!pattern)
4261     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
4262               "pattern", "glob_expand");
4263
4264   char **r;
4265
4266   r = guestfs_glob_expand (g, pattern);
4267   if (r == NULL)
4268     rb_raise (e_Error, "%s", guestfs_last_error (g));
4269
4270   int i, len = 0;
4271   for (i = 0; r[i] != NULL; ++i) len++;
4272   VALUE rv = rb_ary_new2 (len);
4273   for (i = 0; r[i] != NULL; ++i) {
4274     rb_ary_push (rv, rb_str_new2 (r[i]));
4275     free (r[i]);
4276   }
4277   free (r);
4278   return rv;
4279 }
4280
4281 static VALUE ruby_guestfs_scrub_device (VALUE gv, VALUE devicev)
4282 {
4283   guestfs_h *g;
4284   Data_Get_Struct (gv, guestfs_h, g);
4285   if (!g)
4286     rb_raise (rb_eArgError, "%s: used handle after closing it", "scrub_device");
4287
4288   Check_Type (devicev, T_STRING);
4289   const char *device = StringValueCStr (devicev);
4290   if (!device)
4291     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
4292               "device", "scrub_device");
4293
4294   int r;
4295
4296   r = guestfs_scrub_device (g, device);
4297   if (r == -1)
4298     rb_raise (e_Error, "%s", guestfs_last_error (g));
4299
4300   return Qnil;
4301 }
4302
4303 static VALUE ruby_guestfs_scrub_file (VALUE gv, VALUE filev)
4304 {
4305   guestfs_h *g;
4306   Data_Get_Struct (gv, guestfs_h, g);
4307   if (!g)
4308     rb_raise (rb_eArgError, "%s: used handle after closing it", "scrub_file");
4309
4310   Check_Type (filev, T_STRING);
4311   const char *file = StringValueCStr (filev);
4312   if (!file)
4313     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
4314               "file", "scrub_file");
4315
4316   int r;
4317
4318   r = guestfs_scrub_file (g, file);
4319   if (r == -1)
4320     rb_raise (e_Error, "%s", guestfs_last_error (g));
4321
4322   return Qnil;
4323 }
4324
4325 static VALUE ruby_guestfs_scrub_freespace (VALUE gv, VALUE dirv)
4326 {
4327   guestfs_h *g;
4328   Data_Get_Struct (gv, guestfs_h, g);
4329   if (!g)
4330     rb_raise (rb_eArgError, "%s: used handle after closing it", "scrub_freespace");
4331
4332   Check_Type (dirv, T_STRING);
4333   const char *dir = StringValueCStr (dirv);
4334   if (!dir)
4335     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
4336               "dir", "scrub_freespace");
4337
4338   int r;
4339
4340   r = guestfs_scrub_freespace (g, dir);
4341   if (r == -1)
4342     rb_raise (e_Error, "%s", guestfs_last_error (g));
4343
4344   return Qnil;
4345 }
4346
4347 static VALUE ruby_guestfs_mkdtemp (VALUE gv, VALUE templatev)
4348 {
4349   guestfs_h *g;
4350   Data_Get_Struct (gv, guestfs_h, g);
4351   if (!g)
4352     rb_raise (rb_eArgError, "%s: used handle after closing it", "mkdtemp");
4353
4354   Check_Type (templatev, T_STRING);
4355   const char *template = StringValueCStr (templatev);
4356   if (!template)
4357     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
4358               "template", "mkdtemp");
4359
4360   char *r;
4361
4362   r = guestfs_mkdtemp (g, template);
4363   if (r == NULL)
4364     rb_raise (e_Error, "%s", guestfs_last_error (g));
4365
4366   VALUE rv = rb_str_new2 (r);
4367   free (r);
4368   return rv;
4369 }
4370
4371 static VALUE ruby_guestfs_wc_l (VALUE gv, VALUE pathv)
4372 {
4373   guestfs_h *g;
4374   Data_Get_Struct (gv, guestfs_h, g);
4375   if (!g)
4376     rb_raise (rb_eArgError, "%s: used handle after closing it", "wc_l");
4377
4378   Check_Type (pathv, T_STRING);
4379   const char *path = StringValueCStr (pathv);
4380   if (!path)
4381     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
4382               "path", "wc_l");
4383
4384   int r;
4385
4386   r = guestfs_wc_l (g, path);
4387   if (r == -1)
4388     rb_raise (e_Error, "%s", guestfs_last_error (g));
4389
4390   return INT2NUM (r);
4391 }
4392
4393 static VALUE ruby_guestfs_wc_w (VALUE gv, VALUE pathv)
4394 {
4395   guestfs_h *g;
4396   Data_Get_Struct (gv, guestfs_h, g);
4397   if (!g)
4398     rb_raise (rb_eArgError, "%s: used handle after closing it", "wc_w");
4399
4400   Check_Type (pathv, T_STRING);
4401   const char *path = StringValueCStr (pathv);
4402   if (!path)
4403     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
4404               "path", "wc_w");
4405
4406   int r;
4407
4408   r = guestfs_wc_w (g, path);
4409   if (r == -1)
4410     rb_raise (e_Error, "%s", guestfs_last_error (g));
4411
4412   return INT2NUM (r);
4413 }
4414
4415 static VALUE ruby_guestfs_wc_c (VALUE gv, VALUE pathv)
4416 {
4417   guestfs_h *g;
4418   Data_Get_Struct (gv, guestfs_h, g);
4419   if (!g)
4420     rb_raise (rb_eArgError, "%s: used handle after closing it", "wc_c");
4421
4422   Check_Type (pathv, T_STRING);
4423   const char *path = StringValueCStr (pathv);
4424   if (!path)
4425     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
4426               "path", "wc_c");
4427
4428   int r;
4429
4430   r = guestfs_wc_c (g, path);
4431   if (r == -1)
4432     rb_raise (e_Error, "%s", guestfs_last_error (g));
4433
4434   return INT2NUM (r);
4435 }
4436
4437 static VALUE ruby_guestfs_head (VALUE gv, VALUE pathv)
4438 {
4439   guestfs_h *g;
4440   Data_Get_Struct (gv, guestfs_h, g);
4441   if (!g)
4442     rb_raise (rb_eArgError, "%s: used handle after closing it", "head");
4443
4444   Check_Type (pathv, T_STRING);
4445   const char *path = StringValueCStr (pathv);
4446   if (!path)
4447     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
4448               "path", "head");
4449
4450   char **r;
4451
4452   r = guestfs_head (g, path);
4453   if (r == NULL)
4454     rb_raise (e_Error, "%s", guestfs_last_error (g));
4455
4456   int i, len = 0;
4457   for (i = 0; r[i] != NULL; ++i) len++;
4458   VALUE rv = rb_ary_new2 (len);
4459   for (i = 0; r[i] != NULL; ++i) {
4460     rb_ary_push (rv, rb_str_new2 (r[i]));
4461     free (r[i]);
4462   }
4463   free (r);
4464   return rv;
4465 }
4466
4467 static VALUE ruby_guestfs_head_n (VALUE gv, VALUE nrlinesv, VALUE pathv)
4468 {
4469   guestfs_h *g;
4470   Data_Get_Struct (gv, guestfs_h, g);
4471   if (!g)
4472     rb_raise (rb_eArgError, "%s: used handle after closing it", "head_n");
4473
4474   int nrlines = NUM2INT (nrlinesv);
4475   Check_Type (pathv, T_STRING);
4476   const char *path = StringValueCStr (pathv);
4477   if (!path)
4478     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
4479               "path", "head_n");
4480
4481   char **r;
4482
4483   r = guestfs_head_n (g, nrlines, path);
4484   if (r == NULL)
4485     rb_raise (e_Error, "%s", guestfs_last_error (g));
4486
4487   int i, len = 0;
4488   for (i = 0; r[i] != NULL; ++i) len++;
4489   VALUE rv = rb_ary_new2 (len);
4490   for (i = 0; r[i] != NULL; ++i) {
4491     rb_ary_push (rv, rb_str_new2 (r[i]));
4492     free (r[i]);
4493   }
4494   free (r);
4495   return rv;
4496 }
4497
4498 static VALUE ruby_guestfs_tail (VALUE gv, VALUE pathv)
4499 {
4500   guestfs_h *g;
4501   Data_Get_Struct (gv, guestfs_h, g);
4502   if (!g)
4503     rb_raise (rb_eArgError, "%s: used handle after closing it", "tail");
4504
4505   Check_Type (pathv, T_STRING);
4506   const char *path = StringValueCStr (pathv);
4507   if (!path)
4508     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
4509               "path", "tail");
4510
4511   char **r;
4512
4513   r = guestfs_tail (g, path);
4514   if (r == NULL)
4515     rb_raise (e_Error, "%s", guestfs_last_error (g));
4516
4517   int i, len = 0;
4518   for (i = 0; r[i] != NULL; ++i) len++;
4519   VALUE rv = rb_ary_new2 (len);
4520   for (i = 0; r[i] != NULL; ++i) {
4521     rb_ary_push (rv, rb_str_new2 (r[i]));
4522     free (r[i]);
4523   }
4524   free (r);
4525   return rv;
4526 }
4527
4528 static VALUE ruby_guestfs_tail_n (VALUE gv, VALUE nrlinesv, VALUE pathv)
4529 {
4530   guestfs_h *g;
4531   Data_Get_Struct (gv, guestfs_h, g);
4532   if (!g)
4533     rb_raise (rb_eArgError, "%s: used handle after closing it", "tail_n");
4534
4535   int nrlines = NUM2INT (nrlinesv);
4536   Check_Type (pathv, T_STRING);
4537   const char *path = StringValueCStr (pathv);
4538   if (!path)
4539     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
4540               "path", "tail_n");
4541
4542   char **r;
4543
4544   r = guestfs_tail_n (g, nrlines, path);
4545   if (r == NULL)
4546     rb_raise (e_Error, "%s", guestfs_last_error (g));
4547
4548   int i, len = 0;
4549   for (i = 0; r[i] != NULL; ++i) len++;
4550   VALUE rv = rb_ary_new2 (len);
4551   for (i = 0; r[i] != NULL; ++i) {
4552     rb_ary_push (rv, rb_str_new2 (r[i]));
4553     free (r[i]);
4554   }
4555   free (r);
4556   return rv;
4557 }
4558
4559 static VALUE ruby_guestfs_df (VALUE gv)
4560 {
4561   guestfs_h *g;
4562   Data_Get_Struct (gv, guestfs_h, g);
4563   if (!g)
4564     rb_raise (rb_eArgError, "%s: used handle after closing it", "df");
4565
4566
4567   char *r;
4568
4569   r = guestfs_df (g);
4570   if (r == NULL)
4571     rb_raise (e_Error, "%s", guestfs_last_error (g));
4572
4573   VALUE rv = rb_str_new2 (r);
4574   free (r);
4575   return rv;
4576 }
4577
4578 static VALUE ruby_guestfs_df_h (VALUE gv)
4579 {
4580   guestfs_h *g;
4581   Data_Get_Struct (gv, guestfs_h, g);
4582   if (!g)
4583     rb_raise (rb_eArgError, "%s: used handle after closing it", "df_h");
4584
4585
4586   char *r;
4587
4588   r = guestfs_df_h (g);
4589   if (r == NULL)
4590     rb_raise (e_Error, "%s", guestfs_last_error (g));
4591
4592   VALUE rv = rb_str_new2 (r);
4593   free (r);
4594   return rv;
4595 }
4596
4597 static VALUE ruby_guestfs_du (VALUE gv, VALUE pathv)
4598 {
4599   guestfs_h *g;
4600   Data_Get_Struct (gv, guestfs_h, g);
4601   if (!g)
4602     rb_raise (rb_eArgError, "%s: used handle after closing it", "du");
4603
4604   Check_Type (pathv, T_STRING);
4605   const char *path = StringValueCStr (pathv);
4606   if (!path)
4607     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
4608               "path", "du");
4609
4610   int64_t r;
4611
4612   r = guestfs_du (g, path);
4613   if (r == -1)
4614     rb_raise (e_Error, "%s", guestfs_last_error (g));
4615
4616   return ULL2NUM (r);
4617 }
4618
4619 static VALUE ruby_guestfs_initrd_list (VALUE gv, VALUE pathv)
4620 {
4621   guestfs_h *g;
4622   Data_Get_Struct (gv, guestfs_h, g);
4623   if (!g)
4624     rb_raise (rb_eArgError, "%s: used handle after closing it", "initrd_list");
4625
4626   Check_Type (pathv, T_STRING);
4627   const char *path = StringValueCStr (pathv);
4628   if (!path)
4629     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
4630               "path", "initrd_list");
4631
4632   char **r;
4633
4634   r = guestfs_initrd_list (g, path);
4635   if (r == NULL)
4636     rb_raise (e_Error, "%s", guestfs_last_error (g));
4637
4638   int i, len = 0;
4639   for (i = 0; r[i] != NULL; ++i) len++;
4640   VALUE rv = rb_ary_new2 (len);
4641   for (i = 0; r[i] != NULL; ++i) {
4642     rb_ary_push (rv, rb_str_new2 (r[i]));
4643     free (r[i]);
4644   }
4645   free (r);
4646   return rv;
4647 }
4648
4649 static VALUE ruby_guestfs_mount_loop (VALUE gv, VALUE filev, VALUE mountpointv)
4650 {
4651   guestfs_h *g;
4652   Data_Get_Struct (gv, guestfs_h, g);
4653   if (!g)
4654     rb_raise (rb_eArgError, "%s: used handle after closing it", "mount_loop");
4655
4656   Check_Type (filev, T_STRING);
4657   const char *file = StringValueCStr (filev);
4658   if (!file)
4659     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
4660               "file", "mount_loop");
4661   Check_Type (mountpointv, T_STRING);
4662   const char *mountpoint = StringValueCStr (mountpointv);
4663   if (!mountpoint)
4664     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
4665               "mountpoint", "mount_loop");
4666
4667   int r;
4668
4669   r = guestfs_mount_loop (g, file, mountpoint);
4670   if (r == -1)
4671     rb_raise (e_Error, "%s", guestfs_last_error (g));
4672
4673   return Qnil;
4674 }
4675
4676 static VALUE ruby_guestfs_mkswap (VALUE gv, VALUE devicev)
4677 {
4678   guestfs_h *g;
4679   Data_Get_Struct (gv, guestfs_h, g);
4680   if (!g)
4681     rb_raise (rb_eArgError, "%s: used handle after closing it", "mkswap");
4682
4683   Check_Type (devicev, T_STRING);
4684   const char *device = StringValueCStr (devicev);
4685   if (!device)
4686     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
4687               "device", "mkswap");
4688
4689   int r;
4690
4691   r = guestfs_mkswap (g, device);
4692   if (r == -1)
4693     rb_raise (e_Error, "%s", guestfs_last_error (g));
4694
4695   return Qnil;
4696 }
4697
4698 static VALUE ruby_guestfs_mkswap_L (VALUE gv, VALUE labelv, VALUE devicev)
4699 {
4700   guestfs_h *g;
4701   Data_Get_Struct (gv, guestfs_h, g);
4702   if (!g)
4703     rb_raise (rb_eArgError, "%s: used handle after closing it", "mkswap_L");
4704
4705   Check_Type (labelv, T_STRING);
4706   const char *label = StringValueCStr (labelv);
4707   if (!label)
4708     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
4709               "label", "mkswap_L");
4710   Check_Type (devicev, T_STRING);
4711   const char *device = StringValueCStr (devicev);
4712   if (!device)
4713     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
4714               "device", "mkswap_L");
4715
4716   int r;
4717
4718   r = guestfs_mkswap_L (g, label, device);
4719   if (r == -1)
4720     rb_raise (e_Error, "%s", guestfs_last_error (g));
4721
4722   return Qnil;
4723 }
4724
4725 static VALUE ruby_guestfs_mkswap_U (VALUE gv, VALUE uuidv, VALUE devicev)
4726 {
4727   guestfs_h *g;
4728   Data_Get_Struct (gv, guestfs_h, g);
4729   if (!g)
4730     rb_raise (rb_eArgError, "%s: used handle after closing it", "mkswap_U");
4731
4732   Check_Type (uuidv, T_STRING);
4733   const char *uuid = StringValueCStr (uuidv);
4734   if (!uuid)
4735     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
4736               "uuid", "mkswap_U");
4737   Check_Type (devicev, T_STRING);
4738   const char *device = StringValueCStr (devicev);
4739   if (!device)
4740     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
4741               "device", "mkswap_U");
4742
4743   int r;
4744
4745   r = guestfs_mkswap_U (g, uuid, device);
4746   if (r == -1)
4747     rb_raise (e_Error, "%s", guestfs_last_error (g));
4748
4749   return Qnil;
4750 }
4751
4752 static VALUE ruby_guestfs_mknod (VALUE gv, VALUE modev, VALUE devmajorv, VALUE devminorv, VALUE pathv)
4753 {
4754   guestfs_h *g;
4755   Data_Get_Struct (gv, guestfs_h, g);
4756   if (!g)
4757     rb_raise (rb_eArgError, "%s: used handle after closing it", "mknod");
4758
4759   int mode = NUM2INT (modev);
4760   int devmajor = NUM2INT (devmajorv);
4761   int devminor = NUM2INT (devminorv);
4762   Check_Type (pathv, T_STRING);
4763   const char *path = StringValueCStr (pathv);
4764   if (!path)
4765     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
4766               "path", "mknod");
4767
4768   int r;
4769
4770   r = guestfs_mknod (g, mode, devmajor, devminor, path);
4771   if (r == -1)
4772     rb_raise (e_Error, "%s", guestfs_last_error (g));
4773
4774   return Qnil;
4775 }
4776
4777 static VALUE ruby_guestfs_mkfifo (VALUE gv, VALUE modev, VALUE pathv)
4778 {
4779   guestfs_h *g;
4780   Data_Get_Struct (gv, guestfs_h, g);
4781   if (!g)
4782     rb_raise (rb_eArgError, "%s: used handle after closing it", "mkfifo");
4783
4784   int mode = NUM2INT (modev);
4785   Check_Type (pathv, T_STRING);
4786   const char *path = StringValueCStr (pathv);
4787   if (!path)
4788     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
4789               "path", "mkfifo");
4790
4791   int r;
4792
4793   r = guestfs_mkfifo (g, mode, path);
4794   if (r == -1)
4795     rb_raise (e_Error, "%s", guestfs_last_error (g));
4796
4797   return Qnil;
4798 }
4799
4800 static VALUE ruby_guestfs_mknod_b (VALUE gv, VALUE modev, VALUE devmajorv, VALUE devminorv, VALUE pathv)
4801 {
4802   guestfs_h *g;
4803   Data_Get_Struct (gv, guestfs_h, g);
4804   if (!g)
4805     rb_raise (rb_eArgError, "%s: used handle after closing it", "mknod_b");
4806
4807   int mode = NUM2INT (modev);
4808   int devmajor = NUM2INT (devmajorv);
4809   int devminor = NUM2INT (devminorv);
4810   Check_Type (pathv, T_STRING);
4811   const char *path = StringValueCStr (pathv);
4812   if (!path)
4813     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
4814               "path", "mknod_b");
4815
4816   int r;
4817
4818   r = guestfs_mknod_b (g, mode, devmajor, devminor, path);
4819   if (r == -1)
4820     rb_raise (e_Error, "%s", guestfs_last_error (g));
4821
4822   return Qnil;
4823 }
4824
4825 static VALUE ruby_guestfs_mknod_c (VALUE gv, VALUE modev, VALUE devmajorv, VALUE devminorv, VALUE pathv)
4826 {
4827   guestfs_h *g;
4828   Data_Get_Struct (gv, guestfs_h, g);
4829   if (!g)
4830     rb_raise (rb_eArgError, "%s: used handle after closing it", "mknod_c");
4831
4832   int mode = NUM2INT (modev);
4833   int devmajor = NUM2INT (devmajorv);
4834   int devminor = NUM2INT (devminorv);
4835   Check_Type (pathv, T_STRING);
4836   const char *path = StringValueCStr (pathv);
4837   if (!path)
4838     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
4839               "path", "mknod_c");
4840
4841   int r;
4842
4843   r = guestfs_mknod_c (g, mode, devmajor, devminor, path);
4844   if (r == -1)
4845     rb_raise (e_Error, "%s", guestfs_last_error (g));
4846
4847   return Qnil;
4848 }
4849
4850 static VALUE ruby_guestfs_umask (VALUE gv, VALUE maskv)
4851 {
4852   guestfs_h *g;
4853   Data_Get_Struct (gv, guestfs_h, g);
4854   if (!g)
4855     rb_raise (rb_eArgError, "%s: used handle after closing it", "umask");
4856
4857   int mask = NUM2INT (maskv);
4858
4859   int r;
4860
4861   r = guestfs_umask (g, mask);
4862   if (r == -1)
4863     rb_raise (e_Error, "%s", guestfs_last_error (g));
4864
4865   return INT2NUM (r);
4866 }
4867
4868 /* Initialize the module. */
4869 void Init__guestfs ()
4870 {
4871   m_guestfs = rb_define_module ("Guestfs");
4872   c_guestfs = rb_define_class_under (m_guestfs, "Guestfs", rb_cObject);
4873   e_Error = rb_define_class_under (m_guestfs, "Error", rb_eStandardError);
4874
4875   rb_define_module_function (m_guestfs, "create", ruby_guestfs_create, 0);
4876   rb_define_method (c_guestfs, "close", ruby_guestfs_close, 0);
4877
4878   rb_define_method (c_guestfs, "test0",
4879         ruby_guestfs_test0, 7);
4880   rb_define_method (c_guestfs, "test0rint",
4881         ruby_guestfs_test0rint, 1);
4882   rb_define_method (c_guestfs, "test0rinterr",
4883         ruby_guestfs_test0rinterr, 0);
4884   rb_define_method (c_guestfs, "test0rint64",
4885         ruby_guestfs_test0rint64, 1);
4886   rb_define_method (c_guestfs, "test0rint64err",
4887         ruby_guestfs_test0rint64err, 0);
4888   rb_define_method (c_guestfs, "test0rbool",
4889         ruby_guestfs_test0rbool, 1);
4890   rb_define_method (c_guestfs, "test0rboolerr",
4891         ruby_guestfs_test0rboolerr, 0);
4892   rb_define_method (c_guestfs, "test0rconststring",
4893         ruby_guestfs_test0rconststring, 1);
4894   rb_define_method (c_guestfs, "test0rconststringerr",
4895         ruby_guestfs_test0rconststringerr, 0);
4896   rb_define_method (c_guestfs, "test0rstring",
4897         ruby_guestfs_test0rstring, 1);
4898   rb_define_method (c_guestfs, "test0rstringerr",
4899         ruby_guestfs_test0rstringerr, 0);
4900   rb_define_method (c_guestfs, "test0rstringlist",
4901         ruby_guestfs_test0rstringlist, 1);
4902   rb_define_method (c_guestfs, "test0rstringlisterr",
4903         ruby_guestfs_test0rstringlisterr, 0);
4904   rb_define_method (c_guestfs, "test0rintbool",
4905         ruby_guestfs_test0rintbool, 1);
4906   rb_define_method (c_guestfs, "test0rintboolerr",
4907         ruby_guestfs_test0rintboolerr, 0);
4908   rb_define_method (c_guestfs, "test0rpvlist",
4909         ruby_guestfs_test0rpvlist, 1);
4910   rb_define_method (c_guestfs, "test0rpvlisterr",
4911         ruby_guestfs_test0rpvlisterr, 0);
4912   rb_define_method (c_guestfs, "test0rvglist",
4913         ruby_guestfs_test0rvglist, 1);
4914   rb_define_method (c_guestfs, "test0rvglisterr",
4915         ruby_guestfs_test0rvglisterr, 0);
4916   rb_define_method (c_guestfs, "test0rlvlist",
4917         ruby_guestfs_test0rlvlist, 1);
4918   rb_define_method (c_guestfs, "test0rlvlisterr",
4919         ruby_guestfs_test0rlvlisterr, 0);
4920   rb_define_method (c_guestfs, "test0rstat",
4921         ruby_guestfs_test0rstat, 1);
4922   rb_define_method (c_guestfs, "test0rstaterr",
4923         ruby_guestfs_test0rstaterr, 0);
4924   rb_define_method (c_guestfs, "test0rstatvfs",
4925         ruby_guestfs_test0rstatvfs, 1);
4926   rb_define_method (c_guestfs, "test0rstatvfserr",
4927         ruby_guestfs_test0rstatvfserr, 0);
4928   rb_define_method (c_guestfs, "test0rhashtable",
4929         ruby_guestfs_test0rhashtable, 1);
4930   rb_define_method (c_guestfs, "test0rhashtableerr",
4931         ruby_guestfs_test0rhashtableerr, 0);
4932   rb_define_method (c_guestfs, "launch",
4933         ruby_guestfs_launch, 0);
4934   rb_define_method (c_guestfs, "wait_ready",
4935         ruby_guestfs_wait_ready, 0);
4936   rb_define_method (c_guestfs, "kill_subprocess",
4937         ruby_guestfs_kill_subprocess, 0);
4938   rb_define_method (c_guestfs, "add_drive",
4939         ruby_guestfs_add_drive, 1);
4940   rb_define_method (c_guestfs, "add_cdrom",
4941         ruby_guestfs_add_cdrom, 1);
4942   rb_define_method (c_guestfs, "add_drive_ro",
4943         ruby_guestfs_add_drive_ro, 1);
4944   rb_define_method (c_guestfs, "config",
4945         ruby_guestfs_config, 2);
4946   rb_define_method (c_guestfs, "set_qemu",
4947         ruby_guestfs_set_qemu, 1);
4948   rb_define_method (c_guestfs, "get_qemu",
4949         ruby_guestfs_get_qemu, 0);
4950   rb_define_method (c_guestfs, "set_path",
4951         ruby_guestfs_set_path, 1);
4952   rb_define_method (c_guestfs, "get_path",
4953         ruby_guestfs_get_path, 0);
4954   rb_define_method (c_guestfs, "set_append",
4955         ruby_guestfs_set_append, 1);
4956   rb_define_method (c_guestfs, "get_append",
4957         ruby_guestfs_get_append, 0);
4958   rb_define_method (c_guestfs, "set_autosync",
4959         ruby_guestfs_set_autosync, 1);
4960   rb_define_method (c_guestfs, "get_autosync",
4961         ruby_guestfs_get_autosync, 0);
4962   rb_define_method (c_guestfs, "set_verbose",
4963         ruby_guestfs_set_verbose, 1);
4964   rb_define_method (c_guestfs, "get_verbose",
4965         ruby_guestfs_get_verbose, 0);
4966   rb_define_method (c_guestfs, "is_ready",
4967         ruby_guestfs_is_ready, 0);
4968   rb_define_method (c_guestfs, "is_config",
4969         ruby_guestfs_is_config, 0);
4970   rb_define_method (c_guestfs, "is_launching",
4971         ruby_guestfs_is_launching, 0);
4972   rb_define_method (c_guestfs, "is_busy",
4973         ruby_guestfs_is_busy, 0);
4974   rb_define_method (c_guestfs, "get_state",
4975         ruby_guestfs_get_state, 0);
4976   rb_define_method (c_guestfs, "set_busy",
4977         ruby_guestfs_set_busy, 0);
4978   rb_define_method (c_guestfs, "set_ready",
4979         ruby_guestfs_set_ready, 0);
4980   rb_define_method (c_guestfs, "end_busy",
4981         ruby_guestfs_end_busy, 0);
4982   rb_define_method (c_guestfs, "set_memsize",
4983         ruby_guestfs_set_memsize, 1);
4984   rb_define_method (c_guestfs, "get_memsize",
4985         ruby_guestfs_get_memsize, 0);
4986   rb_define_method (c_guestfs, "mount",
4987         ruby_guestfs_mount, 2);
4988   rb_define_method (c_guestfs, "sync",
4989         ruby_guestfs_sync, 0);
4990   rb_define_method (c_guestfs, "touch",
4991         ruby_guestfs_touch, 1);
4992   rb_define_method (c_guestfs, "cat",
4993         ruby_guestfs_cat, 1);
4994   rb_define_method (c_guestfs, "ll",
4995         ruby_guestfs_ll, 1);
4996   rb_define_method (c_guestfs, "ls",
4997         ruby_guestfs_ls, 1);
4998   rb_define_method (c_guestfs, "list_devices",
4999         ruby_guestfs_list_devices, 0);
5000   rb_define_method (c_guestfs, "list_partitions",
5001         ruby_guestfs_list_partitions, 0);
5002   rb_define_method (c_guestfs, "pvs",
5003         ruby_guestfs_pvs, 0);
5004   rb_define_method (c_guestfs, "vgs",
5005         ruby_guestfs_vgs, 0);
5006   rb_define_method (c_guestfs, "lvs",
5007         ruby_guestfs_lvs, 0);
5008   rb_define_method (c_guestfs, "pvs_full",
5009         ruby_guestfs_pvs_full, 0);
5010   rb_define_method (c_guestfs, "vgs_full",
5011         ruby_guestfs_vgs_full, 0);
5012   rb_define_method (c_guestfs, "lvs_full",
5013         ruby_guestfs_lvs_full, 0);
5014   rb_define_method (c_guestfs, "read_lines",
5015         ruby_guestfs_read_lines, 1);
5016   rb_define_method (c_guestfs, "aug_init",
5017         ruby_guestfs_aug_init, 2);
5018   rb_define_method (c_guestfs, "aug_close",
5019         ruby_guestfs_aug_close, 0);
5020   rb_define_method (c_guestfs, "aug_defvar",
5021         ruby_guestfs_aug_defvar, 2);
5022   rb_define_method (c_guestfs, "aug_defnode",
5023         ruby_guestfs_aug_defnode, 3);
5024   rb_define_method (c_guestfs, "aug_get",
5025         ruby_guestfs_aug_get, 1);
5026   rb_define_method (c_guestfs, "aug_set",
5027         ruby_guestfs_aug_set, 2);
5028   rb_define_method (c_guestfs, "aug_insert",
5029         ruby_guestfs_aug_insert, 3);
5030   rb_define_method (c_guestfs, "aug_rm",
5031         ruby_guestfs_aug_rm, 1);
5032   rb_define_method (c_guestfs, "aug_mv",
5033         ruby_guestfs_aug_mv, 2);
5034   rb_define_method (c_guestfs, "aug_match",
5035         ruby_guestfs_aug_match, 1);
5036   rb_define_method (c_guestfs, "aug_save",
5037         ruby_guestfs_aug_save, 0);
5038   rb_define_method (c_guestfs, "aug_load",
5039         ruby_guestfs_aug_load, 0);
5040   rb_define_method (c_guestfs, "aug_ls",
5041         ruby_guestfs_aug_ls, 1);
5042   rb_define_method (c_guestfs, "rm",
5043         ruby_guestfs_rm, 1);
5044   rb_define_method (c_guestfs, "rmdir",
5045         ruby_guestfs_rmdir, 1);
5046   rb_define_method (c_guestfs, "rm_rf",
5047         ruby_guestfs_rm_rf, 1);
5048   rb_define_method (c_guestfs, "mkdir",
5049         ruby_guestfs_mkdir, 1);
5050   rb_define_method (c_guestfs, "mkdir_p",
5051         ruby_guestfs_mkdir_p, 1);
5052   rb_define_method (c_guestfs, "chmod",
5053         ruby_guestfs_chmod, 2);
5054   rb_define_method (c_guestfs, "chown",
5055         ruby_guestfs_chown, 3);
5056   rb_define_method (c_guestfs, "exists",
5057         ruby_guestfs_exists, 1);
5058   rb_define_method (c_guestfs, "is_file",
5059         ruby_guestfs_is_file, 1);
5060   rb_define_method (c_guestfs, "is_dir",
5061         ruby_guestfs_is_dir, 1);
5062   rb_define_method (c_guestfs, "pvcreate",
5063         ruby_guestfs_pvcreate, 1);
5064   rb_define_method (c_guestfs, "vgcreate",
5065         ruby_guestfs_vgcreate, 2);
5066   rb_define_method (c_guestfs, "lvcreate",
5067         ruby_guestfs_lvcreate, 3);
5068   rb_define_method (c_guestfs, "mkfs",
5069         ruby_guestfs_mkfs, 2);
5070   rb_define_method (c_guestfs, "sfdisk",
5071         ruby_guestfs_sfdisk, 5);
5072   rb_define_method (c_guestfs, "write_file",
5073         ruby_guestfs_write_file, 3);
5074   rb_define_method (c_guestfs, "umount",
5075         ruby_guestfs_umount, 1);
5076   rb_define_method (c_guestfs, "mounts",
5077         ruby_guestfs_mounts, 0);
5078   rb_define_method (c_guestfs, "umount_all",
5079         ruby_guestfs_umount_all, 0);
5080   rb_define_method (c_guestfs, "lvm_remove_all",
5081         ruby_guestfs_lvm_remove_all, 0);
5082   rb_define_method (c_guestfs, "file",
5083         ruby_guestfs_file, 1);
5084   rb_define_method (c_guestfs, "command",
5085         ruby_guestfs_command, 1);
5086   rb_define_method (c_guestfs, "command_lines",
5087         ruby_guestfs_command_lines, 1);
5088   rb_define_method (c_guestfs, "stat",
5089         ruby_guestfs_stat, 1);
5090   rb_define_method (c_guestfs, "lstat",
5091         ruby_guestfs_lstat, 1);
5092   rb_define_method (c_guestfs, "statvfs",
5093         ruby_guestfs_statvfs, 1);
5094   rb_define_method (c_guestfs, "tune2fs_l",
5095         ruby_guestfs_tune2fs_l, 1);
5096   rb_define_method (c_guestfs, "blockdev_setro",
5097         ruby_guestfs_blockdev_setro, 1);
5098   rb_define_method (c_guestfs, "blockdev_setrw",
5099         ruby_guestfs_blockdev_setrw, 1);
5100   rb_define_method (c_guestfs, "blockdev_getro",
5101         ruby_guestfs_blockdev_getro, 1);
5102   rb_define_method (c_guestfs, "blockdev_getss",
5103         ruby_guestfs_blockdev_getss, 1);
5104   rb_define_method (c_guestfs, "blockdev_getbsz",
5105         ruby_guestfs_blockdev_getbsz, 1);
5106   rb_define_method (c_guestfs, "blockdev_setbsz",
5107         ruby_guestfs_blockdev_setbsz, 2);
5108   rb_define_method (c_guestfs, "blockdev_getsz",
5109         ruby_guestfs_blockdev_getsz, 1);
5110   rb_define_method (c_guestfs, "blockdev_getsize64",
5111         ruby_guestfs_blockdev_getsize64, 1);
5112   rb_define_method (c_guestfs, "blockdev_flushbufs",
5113         ruby_guestfs_blockdev_flushbufs, 1);
5114   rb_define_method (c_guestfs, "blockdev_rereadpt",
5115         ruby_guestfs_blockdev_rereadpt, 1);
5116   rb_define_method (c_guestfs, "upload",
5117         ruby_guestfs_upload, 2);
5118   rb_define_method (c_guestfs, "download",
5119         ruby_guestfs_download, 2);
5120   rb_define_method (c_guestfs, "checksum",
5121         ruby_guestfs_checksum, 2);
5122   rb_define_method (c_guestfs, "tar_in",
5123         ruby_guestfs_tar_in, 2);
5124   rb_define_method (c_guestfs, "tar_out",
5125         ruby_guestfs_tar_out, 2);
5126   rb_define_method (c_guestfs, "tgz_in",
5127         ruby_guestfs_tgz_in, 2);
5128   rb_define_method (c_guestfs, "tgz_out",
5129         ruby_guestfs_tgz_out, 2);
5130   rb_define_method (c_guestfs, "mount_ro",
5131         ruby_guestfs_mount_ro, 2);
5132   rb_define_method (c_guestfs, "mount_options",
5133         ruby_guestfs_mount_options, 3);
5134   rb_define_method (c_guestfs, "mount_vfs",
5135         ruby_guestfs_mount_vfs, 4);
5136   rb_define_method (c_guestfs, "debug",
5137         ruby_guestfs_debug, 2);
5138   rb_define_method (c_guestfs, "lvremove",
5139         ruby_guestfs_lvremove, 1);
5140   rb_define_method (c_guestfs, "vgremove",
5141         ruby_guestfs_vgremove, 1);
5142   rb_define_method (c_guestfs, "pvremove",
5143         ruby_guestfs_pvremove, 1);
5144   rb_define_method (c_guestfs, "set_e2label",
5145         ruby_guestfs_set_e2label, 2);
5146   rb_define_method (c_guestfs, "get_e2label",
5147         ruby_guestfs_get_e2label, 1);
5148   rb_define_method (c_guestfs, "set_e2uuid",
5149         ruby_guestfs_set_e2uuid, 2);
5150   rb_define_method (c_guestfs, "get_e2uuid",
5151         ruby_guestfs_get_e2uuid, 1);
5152   rb_define_method (c_guestfs, "fsck",
5153         ruby_guestfs_fsck, 2);
5154   rb_define_method (c_guestfs, "zero",
5155         ruby_guestfs_zero, 1);
5156   rb_define_method (c_guestfs, "grub_install",
5157         ruby_guestfs_grub_install, 2);
5158   rb_define_method (c_guestfs, "cp",
5159         ruby_guestfs_cp, 2);
5160   rb_define_method (c_guestfs, "cp_a",
5161         ruby_guestfs_cp_a, 2);
5162   rb_define_method (c_guestfs, "mv",
5163         ruby_guestfs_mv, 2);
5164   rb_define_method (c_guestfs, "drop_caches",
5165         ruby_guestfs_drop_caches, 1);
5166   rb_define_method (c_guestfs, "dmesg",
5167         ruby_guestfs_dmesg, 0);
5168   rb_define_method (c_guestfs, "ping_daemon",
5169         ruby_guestfs_ping_daemon, 0);
5170   rb_define_method (c_guestfs, "equal",
5171         ruby_guestfs_equal, 2);
5172   rb_define_method (c_guestfs, "strings",
5173         ruby_guestfs_strings, 1);
5174   rb_define_method (c_guestfs, "strings_e",
5175         ruby_guestfs_strings_e, 2);
5176   rb_define_method (c_guestfs, "hexdump",
5177         ruby_guestfs_hexdump, 1);
5178   rb_define_method (c_guestfs, "zerofree",
5179         ruby_guestfs_zerofree, 1);
5180   rb_define_method (c_guestfs, "pvresize",
5181         ruby_guestfs_pvresize, 1);
5182   rb_define_method (c_guestfs, "sfdisk_N",
5183         ruby_guestfs_sfdisk_N, 6);
5184   rb_define_method (c_guestfs, "sfdisk_l",
5185         ruby_guestfs_sfdisk_l, 1);
5186   rb_define_method (c_guestfs, "sfdisk_kernel_geometry",
5187         ruby_guestfs_sfdisk_kernel_geometry, 1);
5188   rb_define_method (c_guestfs, "sfdisk_disk_geometry",
5189         ruby_guestfs_sfdisk_disk_geometry, 1);
5190   rb_define_method (c_guestfs, "vg_activate_all",
5191         ruby_guestfs_vg_activate_all, 1);
5192   rb_define_method (c_guestfs, "vg_activate",
5193         ruby_guestfs_vg_activate, 2);
5194   rb_define_method (c_guestfs, "lvresize",
5195         ruby_guestfs_lvresize, 2);
5196   rb_define_method (c_guestfs, "resize2fs",
5197         ruby_guestfs_resize2fs, 1);
5198   rb_define_method (c_guestfs, "find",
5199         ruby_guestfs_find, 1);
5200   rb_define_method (c_guestfs, "e2fsck_f",
5201         ruby_guestfs_e2fsck_f, 1);
5202   rb_define_method (c_guestfs, "sleep",
5203         ruby_guestfs_sleep, 1);
5204   rb_define_method (c_guestfs, "ntfs_3g_probe",
5205         ruby_guestfs_ntfs_3g_probe, 2);
5206   rb_define_method (c_guestfs, "sh",
5207         ruby_guestfs_sh, 1);
5208   rb_define_method (c_guestfs, "sh_lines",
5209         ruby_guestfs_sh_lines, 1);
5210   rb_define_method (c_guestfs, "glob_expand",
5211         ruby_guestfs_glob_expand, 1);
5212   rb_define_method (c_guestfs, "scrub_device",
5213         ruby_guestfs_scrub_device, 1);
5214   rb_define_method (c_guestfs, "scrub_file",
5215         ruby_guestfs_scrub_file, 1);
5216   rb_define_method (c_guestfs, "scrub_freespace",
5217         ruby_guestfs_scrub_freespace, 1);
5218   rb_define_method (c_guestfs, "mkdtemp",
5219         ruby_guestfs_mkdtemp, 1);
5220   rb_define_method (c_guestfs, "wc_l",
5221         ruby_guestfs_wc_l, 1);
5222   rb_define_method (c_guestfs, "wc_w",
5223         ruby_guestfs_wc_w, 1);
5224   rb_define_method (c_guestfs, "wc_c",
5225         ruby_guestfs_wc_c, 1);
5226   rb_define_method (c_guestfs, "head",
5227         ruby_guestfs_head, 1);
5228   rb_define_method (c_guestfs, "head_n",
5229         ruby_guestfs_head_n, 2);
5230   rb_define_method (c_guestfs, "tail",
5231         ruby_guestfs_tail, 1);
5232   rb_define_method (c_guestfs, "tail_n",
5233         ruby_guestfs_tail_n, 2);
5234   rb_define_method (c_guestfs, "df",
5235         ruby_guestfs_df, 0);
5236   rb_define_method (c_guestfs, "df_h",
5237         ruby_guestfs_df_h, 0);
5238   rb_define_method (c_guestfs, "du",
5239         ruby_guestfs_du, 1);
5240   rb_define_method (c_guestfs, "initrd_list",
5241         ruby_guestfs_initrd_list, 1);
5242   rb_define_method (c_guestfs, "mount_loop",
5243         ruby_guestfs_mount_loop, 2);
5244   rb_define_method (c_guestfs, "mkswap",
5245         ruby_guestfs_mkswap, 1);
5246   rb_define_method (c_guestfs, "mkswap_L",
5247         ruby_guestfs_mkswap_L, 2);
5248   rb_define_method (c_guestfs, "mkswap_U",
5249         ruby_guestfs_mkswap_U, 2);
5250   rb_define_method (c_guestfs, "mknod",
5251         ruby_guestfs_mknod, 4);
5252   rb_define_method (c_guestfs, "mkfifo",
5253         ruby_guestfs_mkfifo, 2);
5254   rb_define_method (c_guestfs, "mknod_b",
5255         ruby_guestfs_mknod_b, 4);
5256   rb_define_method (c_guestfs, "mknod_c",
5257         ruby_guestfs_mknod_c, 4);
5258   rb_define_method (c_guestfs, "umask",
5259         ruby_guestfs_umask, 1);
5260 }