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