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