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.
5 * Copyright (C) 2009 Red Hat Inc.
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.
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.
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
31 static VALUE m_guestfs; /* guestfs module */
32 static VALUE c_guestfs; /* guestfs_h handle */
33 static VALUE e_Error; /* used for all errors */
35 static void ruby_guestfs_free (void *p)
38 guestfs_close ((guestfs_h *) p);
41 static VALUE ruby_guestfs_create (VALUE m)
45 g = guestfs_create ();
47 rb_raise (e_Error, "failed to create guestfs handle");
49 /* Don't print error messages to stderr by default. */
50 guestfs_set_error_handler (g, NULL, NULL);
52 /* Wrap it, and make sure the close function is called when the
55 return Data_Wrap_Struct (c_guestfs, NULL, ruby_guestfs_free, g);
58 static VALUE ruby_guestfs_close (VALUE gv)
61 Data_Get_Struct (gv, guestfs_h, g);
63 ruby_guestfs_free (g);
69 static VALUE ruby_guestfs_launch (VALUE gv)
72 Data_Get_Struct (gv, guestfs_h, g);
74 rb_raise (rb_eArgError, "%s: used handle after closing it", "launch");
79 r = guestfs_launch (g);
81 rb_raise (e_Error, "%s", guestfs_last_error (g));
86 static VALUE ruby_guestfs_wait_ready (VALUE gv)
89 Data_Get_Struct (gv, guestfs_h, g);
91 rb_raise (rb_eArgError, "%s: used handle after closing it", "wait_ready");
96 r = guestfs_wait_ready (g);
98 rb_raise (e_Error, "%s", guestfs_last_error (g));
103 static VALUE ruby_guestfs_kill_subprocess (VALUE gv)
106 Data_Get_Struct (gv, guestfs_h, g);
108 rb_raise (rb_eArgError, "%s: used handle after closing it", "kill_subprocess");
113 r = guestfs_kill_subprocess (g);
115 rb_raise (e_Error, "%s", guestfs_last_error (g));
120 static VALUE ruby_guestfs_add_drive (VALUE gv, VALUE filenamev)
123 Data_Get_Struct (gv, guestfs_h, g);
125 rb_raise (rb_eArgError, "%s: used handle after closing it", "add_drive");
127 const char *filename = StringValueCStr (filenamev);
129 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
130 "filename", "add_drive");
134 r = guestfs_add_drive (g, filename);
136 rb_raise (e_Error, "%s", guestfs_last_error (g));
141 static VALUE ruby_guestfs_add_cdrom (VALUE gv, VALUE filenamev)
144 Data_Get_Struct (gv, guestfs_h, g);
146 rb_raise (rb_eArgError, "%s: used handle after closing it", "add_cdrom");
148 const char *filename = StringValueCStr (filenamev);
150 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
151 "filename", "add_cdrom");
155 r = guestfs_add_cdrom (g, filename);
157 rb_raise (e_Error, "%s", guestfs_last_error (g));
162 static VALUE ruby_guestfs_config (VALUE gv, VALUE qemuparamv, VALUE qemuvaluev)
165 Data_Get_Struct (gv, guestfs_h, g);
167 rb_raise (rb_eArgError, "%s: used handle after closing it", "config");
169 const char *qemuparam = StringValueCStr (qemuparamv);
171 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
172 "qemuparam", "config");
173 const char *qemuvalue = StringValueCStr (qemuvaluev);
177 r = guestfs_config (g, qemuparam, qemuvalue);
179 rb_raise (e_Error, "%s", guestfs_last_error (g));
184 static VALUE ruby_guestfs_set_qemu (VALUE gv, VALUE qemuv)
187 Data_Get_Struct (gv, guestfs_h, g);
189 rb_raise (rb_eArgError, "%s: used handle after closing it", "set_qemu");
191 const char *qemu = StringValueCStr (qemuv);
193 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
198 r = guestfs_set_qemu (g, qemu);
200 rb_raise (e_Error, "%s", guestfs_last_error (g));
205 static VALUE ruby_guestfs_get_qemu (VALUE gv)
208 Data_Get_Struct (gv, guestfs_h, g);
210 rb_raise (rb_eArgError, "%s: used handle after closing it", "get_qemu");
215 r = guestfs_get_qemu (g);
217 rb_raise (e_Error, "%s", guestfs_last_error (g));
219 return rb_str_new2 (r);
222 static VALUE ruby_guestfs_set_path (VALUE gv, VALUE pathv)
225 Data_Get_Struct (gv, guestfs_h, g);
227 rb_raise (rb_eArgError, "%s: used handle after closing it", "set_path");
229 const char *path = StringValueCStr (pathv);
231 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
236 r = guestfs_set_path (g, path);
238 rb_raise (e_Error, "%s", guestfs_last_error (g));
243 static VALUE ruby_guestfs_get_path (VALUE gv)
246 Data_Get_Struct (gv, guestfs_h, g);
248 rb_raise (rb_eArgError, "%s: used handle after closing it", "get_path");
253 r = guestfs_get_path (g);
255 rb_raise (e_Error, "%s", guestfs_last_error (g));
257 return rb_str_new2 (r);
260 static VALUE ruby_guestfs_set_autosync (VALUE gv, VALUE autosyncv)
263 Data_Get_Struct (gv, guestfs_h, g);
265 rb_raise (rb_eArgError, "%s: used handle after closing it", "set_autosync");
267 int autosync = NUM2INT (autosyncv);
271 r = guestfs_set_autosync (g, autosync);
273 rb_raise (e_Error, "%s", guestfs_last_error (g));
278 static VALUE ruby_guestfs_get_autosync (VALUE gv)
281 Data_Get_Struct (gv, guestfs_h, g);
283 rb_raise (rb_eArgError, "%s: used handle after closing it", "get_autosync");
288 r = guestfs_get_autosync (g);
290 rb_raise (e_Error, "%s", guestfs_last_error (g));
295 static VALUE ruby_guestfs_set_verbose (VALUE gv, VALUE verbosev)
298 Data_Get_Struct (gv, guestfs_h, g);
300 rb_raise (rb_eArgError, "%s: used handle after closing it", "set_verbose");
302 int verbose = NUM2INT (verbosev);
306 r = guestfs_set_verbose (g, verbose);
308 rb_raise (e_Error, "%s", guestfs_last_error (g));
313 static VALUE ruby_guestfs_get_verbose (VALUE gv)
316 Data_Get_Struct (gv, guestfs_h, g);
318 rb_raise (rb_eArgError, "%s: used handle after closing it", "get_verbose");
323 r = guestfs_get_verbose (g);
325 rb_raise (e_Error, "%s", guestfs_last_error (g));
330 static VALUE ruby_guestfs_is_ready (VALUE gv)
333 Data_Get_Struct (gv, guestfs_h, g);
335 rb_raise (rb_eArgError, "%s: used handle after closing it", "is_ready");
340 r = guestfs_is_ready (g);
342 rb_raise (e_Error, "%s", guestfs_last_error (g));
347 static VALUE ruby_guestfs_is_config (VALUE gv)
350 Data_Get_Struct (gv, guestfs_h, g);
352 rb_raise (rb_eArgError, "%s: used handle after closing it", "is_config");
357 r = guestfs_is_config (g);
359 rb_raise (e_Error, "%s", guestfs_last_error (g));
364 static VALUE ruby_guestfs_is_launching (VALUE gv)
367 Data_Get_Struct (gv, guestfs_h, g);
369 rb_raise (rb_eArgError, "%s: used handle after closing it", "is_launching");
374 r = guestfs_is_launching (g);
376 rb_raise (e_Error, "%s", guestfs_last_error (g));
381 static VALUE ruby_guestfs_is_busy (VALUE gv)
384 Data_Get_Struct (gv, guestfs_h, g);
386 rb_raise (rb_eArgError, "%s: used handle after closing it", "is_busy");
391 r = guestfs_is_busy (g);
393 rb_raise (e_Error, "%s", guestfs_last_error (g));
398 static VALUE ruby_guestfs_get_state (VALUE gv)
401 Data_Get_Struct (gv, guestfs_h, g);
403 rb_raise (rb_eArgError, "%s: used handle after closing it", "get_state");
408 r = guestfs_get_state (g);
410 rb_raise (e_Error, "%s", guestfs_last_error (g));
415 static VALUE ruby_guestfs_set_busy (VALUE gv)
418 Data_Get_Struct (gv, guestfs_h, g);
420 rb_raise (rb_eArgError, "%s: used handle after closing it", "set_busy");
425 r = guestfs_set_busy (g);
427 rb_raise (e_Error, "%s", guestfs_last_error (g));
432 static VALUE ruby_guestfs_set_ready (VALUE gv)
435 Data_Get_Struct (gv, guestfs_h, g);
437 rb_raise (rb_eArgError, "%s: used handle after closing it", "set_ready");
442 r = guestfs_set_ready (g);
444 rb_raise (e_Error, "%s", guestfs_last_error (g));
449 static VALUE ruby_guestfs_mount (VALUE gv, VALUE devicev, VALUE mountpointv)
452 Data_Get_Struct (gv, guestfs_h, g);
454 rb_raise (rb_eArgError, "%s: used handle after closing it", "mount");
456 const char *device = StringValueCStr (devicev);
458 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
460 const char *mountpoint = StringValueCStr (mountpointv);
462 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
463 "mountpoint", "mount");
467 r = guestfs_mount (g, device, mountpoint);
469 rb_raise (e_Error, "%s", guestfs_last_error (g));
474 static VALUE ruby_guestfs_sync (VALUE gv)
477 Data_Get_Struct (gv, guestfs_h, g);
479 rb_raise (rb_eArgError, "%s: used handle after closing it", "sync");
484 r = guestfs_sync (g);
486 rb_raise (e_Error, "%s", guestfs_last_error (g));
491 static VALUE ruby_guestfs_touch (VALUE gv, VALUE pathv)
494 Data_Get_Struct (gv, guestfs_h, g);
496 rb_raise (rb_eArgError, "%s: used handle after closing it", "touch");
498 const char *path = StringValueCStr (pathv);
500 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
505 r = guestfs_touch (g, path);
507 rb_raise (e_Error, "%s", guestfs_last_error (g));
512 static VALUE ruby_guestfs_cat (VALUE gv, VALUE pathv)
515 Data_Get_Struct (gv, guestfs_h, g);
517 rb_raise (rb_eArgError, "%s: used handle after closing it", "cat");
519 const char *path = StringValueCStr (pathv);
521 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
526 r = guestfs_cat (g, path);
528 rb_raise (e_Error, "%s", guestfs_last_error (g));
530 VALUE rv = rb_str_new2 (r);
535 static VALUE ruby_guestfs_ll (VALUE gv, VALUE directoryv)
538 Data_Get_Struct (gv, guestfs_h, g);
540 rb_raise (rb_eArgError, "%s: used handle after closing it", "ll");
542 const char *directory = StringValueCStr (directoryv);
544 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
549 r = guestfs_ll (g, directory);
551 rb_raise (e_Error, "%s", guestfs_last_error (g));
553 VALUE rv = rb_str_new2 (r);
558 static VALUE ruby_guestfs_ls (VALUE gv, VALUE directoryv)
561 Data_Get_Struct (gv, guestfs_h, g);
563 rb_raise (rb_eArgError, "%s: used handle after closing it", "ls");
565 const char *directory = StringValueCStr (directoryv);
567 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
572 r = guestfs_ls (g, directory);
574 rb_raise (e_Error, "%s", guestfs_last_error (g));
577 for (i = 0; r[i] != NULL; ++i) len++;
578 VALUE rv = rb_ary_new2 (len);
579 for (i = 0; r[i] != NULL; ++i) {
580 rb_ary_push (rv, rb_str_new2 (r[i]));
587 static VALUE ruby_guestfs_list_devices (VALUE gv)
590 Data_Get_Struct (gv, guestfs_h, g);
592 rb_raise (rb_eArgError, "%s: used handle after closing it", "list_devices");
597 r = guestfs_list_devices (g);
599 rb_raise (e_Error, "%s", guestfs_last_error (g));
602 for (i = 0; r[i] != NULL; ++i) len++;
603 VALUE rv = rb_ary_new2 (len);
604 for (i = 0; r[i] != NULL; ++i) {
605 rb_ary_push (rv, rb_str_new2 (r[i]));
612 static VALUE ruby_guestfs_list_partitions (VALUE gv)
615 Data_Get_Struct (gv, guestfs_h, g);
617 rb_raise (rb_eArgError, "%s: used handle after closing it", "list_partitions");
622 r = guestfs_list_partitions (g);
624 rb_raise (e_Error, "%s", guestfs_last_error (g));
627 for (i = 0; r[i] != NULL; ++i) len++;
628 VALUE rv = rb_ary_new2 (len);
629 for (i = 0; r[i] != NULL; ++i) {
630 rb_ary_push (rv, rb_str_new2 (r[i]));
637 static VALUE ruby_guestfs_pvs (VALUE gv)
640 Data_Get_Struct (gv, guestfs_h, g);
642 rb_raise (rb_eArgError, "%s: used handle after closing it", "pvs");
649 rb_raise (e_Error, "%s", guestfs_last_error (g));
652 for (i = 0; r[i] != NULL; ++i) len++;
653 VALUE rv = rb_ary_new2 (len);
654 for (i = 0; r[i] != NULL; ++i) {
655 rb_ary_push (rv, rb_str_new2 (r[i]));
662 static VALUE ruby_guestfs_vgs (VALUE gv)
665 Data_Get_Struct (gv, guestfs_h, g);
667 rb_raise (rb_eArgError, "%s: used handle after closing it", "vgs");
674 rb_raise (e_Error, "%s", guestfs_last_error (g));
677 for (i = 0; r[i] != NULL; ++i) len++;
678 VALUE rv = rb_ary_new2 (len);
679 for (i = 0; r[i] != NULL; ++i) {
680 rb_ary_push (rv, rb_str_new2 (r[i]));
687 static VALUE ruby_guestfs_lvs (VALUE gv)
690 Data_Get_Struct (gv, guestfs_h, g);
692 rb_raise (rb_eArgError, "%s: used handle after closing it", "lvs");
699 rb_raise (e_Error, "%s", guestfs_last_error (g));
702 for (i = 0; r[i] != NULL; ++i) len++;
703 VALUE rv = rb_ary_new2 (len);
704 for (i = 0; r[i] != NULL; ++i) {
705 rb_ary_push (rv, rb_str_new2 (r[i]));
712 static VALUE ruby_guestfs_pvs_full (VALUE gv)
715 Data_Get_Struct (gv, guestfs_h, g);
717 rb_raise (rb_eArgError, "%s: used handle after closing it", "pvs_full");
720 struct guestfs_lvm_pv_list *r;
722 r = guestfs_pvs_full (g);
724 rb_raise (e_Error, "%s", guestfs_last_error (g));
726 VALUE rv = rb_ary_new2 (r->len);
728 for (i = 0; i < r->len; ++i) {
729 VALUE hv = rb_hash_new ();
730 rb_hash_aset (rv, rb_str_new2 ("pv_name"), rb_str_new2 (r->val[i].pv_name));
731 rb_hash_aset (rv, rb_str_new2 ("pv_uuid"), rb_str_new (r->val[i].pv_uuid, 32));
732 rb_hash_aset (rv, rb_str_new2 ("pv_fmt"), rb_str_new2 (r->val[i].pv_fmt));
733 rb_hash_aset (rv, rb_str_new2 ("pv_size"), ULL2NUM (r->val[i].pv_size));
734 rb_hash_aset (rv, rb_str_new2 ("dev_size"), ULL2NUM (r->val[i].dev_size));
735 rb_hash_aset (rv, rb_str_new2 ("pv_free"), ULL2NUM (r->val[i].pv_free));
736 rb_hash_aset (rv, rb_str_new2 ("pv_used"), ULL2NUM (r->val[i].pv_used));
737 rb_hash_aset (rv, rb_str_new2 ("pv_attr"), rb_str_new2 (r->val[i].pv_attr));
738 rb_hash_aset (rv, rb_str_new2 ("pv_pe_count"), ULL2NUM (r->val[i].pv_pe_count));
739 rb_hash_aset (rv, rb_str_new2 ("pv_pe_alloc_count"), ULL2NUM (r->val[i].pv_pe_alloc_count));
740 rb_hash_aset (rv, rb_str_new2 ("pv_tags"), rb_str_new2 (r->val[i].pv_tags));
741 rb_hash_aset (rv, rb_str_new2 ("pe_start"), ULL2NUM (r->val[i].pe_start));
742 rb_hash_aset (rv, rb_str_new2 ("pv_mda_count"), ULL2NUM (r->val[i].pv_mda_count));
743 rb_hash_aset (rv, rb_str_new2 ("pv_mda_free"), ULL2NUM (r->val[i].pv_mda_free));
744 rb_ary_push (rv, hv);
746 guestfs_free_lvm_pv_list (r);
750 static VALUE ruby_guestfs_vgs_full (VALUE gv)
753 Data_Get_Struct (gv, guestfs_h, g);
755 rb_raise (rb_eArgError, "%s: used handle after closing it", "vgs_full");
758 struct guestfs_lvm_vg_list *r;
760 r = guestfs_vgs_full (g);
762 rb_raise (e_Error, "%s", guestfs_last_error (g));
764 VALUE rv = rb_ary_new2 (r->len);
766 for (i = 0; i < r->len; ++i) {
767 VALUE hv = rb_hash_new ();
768 rb_hash_aset (rv, rb_str_new2 ("vg_name"), rb_str_new2 (r->val[i].vg_name));
769 rb_hash_aset (rv, rb_str_new2 ("vg_uuid"), rb_str_new (r->val[i].vg_uuid, 32));
770 rb_hash_aset (rv, rb_str_new2 ("vg_fmt"), rb_str_new2 (r->val[i].vg_fmt));
771 rb_hash_aset (rv, rb_str_new2 ("vg_attr"), rb_str_new2 (r->val[i].vg_attr));
772 rb_hash_aset (rv, rb_str_new2 ("vg_size"), ULL2NUM (r->val[i].vg_size));
773 rb_hash_aset (rv, rb_str_new2 ("vg_free"), ULL2NUM (r->val[i].vg_free));
774 rb_hash_aset (rv, rb_str_new2 ("vg_sysid"), rb_str_new2 (r->val[i].vg_sysid));
775 rb_hash_aset (rv, rb_str_new2 ("vg_extent_size"), ULL2NUM (r->val[i].vg_extent_size));
776 rb_hash_aset (rv, rb_str_new2 ("vg_extent_count"), ULL2NUM (r->val[i].vg_extent_count));
777 rb_hash_aset (rv, rb_str_new2 ("vg_free_count"), ULL2NUM (r->val[i].vg_free_count));
778 rb_hash_aset (rv, rb_str_new2 ("max_lv"), ULL2NUM (r->val[i].max_lv));
779 rb_hash_aset (rv, rb_str_new2 ("max_pv"), ULL2NUM (r->val[i].max_pv));
780 rb_hash_aset (rv, rb_str_new2 ("pv_count"), ULL2NUM (r->val[i].pv_count));
781 rb_hash_aset (rv, rb_str_new2 ("lv_count"), ULL2NUM (r->val[i].lv_count));
782 rb_hash_aset (rv, rb_str_new2 ("snap_count"), ULL2NUM (r->val[i].snap_count));
783 rb_hash_aset (rv, rb_str_new2 ("vg_seqno"), ULL2NUM (r->val[i].vg_seqno));
784 rb_hash_aset (rv, rb_str_new2 ("vg_tags"), rb_str_new2 (r->val[i].vg_tags));
785 rb_hash_aset (rv, rb_str_new2 ("vg_mda_count"), ULL2NUM (r->val[i].vg_mda_count));
786 rb_hash_aset (rv, rb_str_new2 ("vg_mda_free"), ULL2NUM (r->val[i].vg_mda_free));
787 rb_ary_push (rv, hv);
789 guestfs_free_lvm_vg_list (r);
793 static VALUE ruby_guestfs_lvs_full (VALUE gv)
796 Data_Get_Struct (gv, guestfs_h, g);
798 rb_raise (rb_eArgError, "%s: used handle after closing it", "lvs_full");
801 struct guestfs_lvm_lv_list *r;
803 r = guestfs_lvs_full (g);
805 rb_raise (e_Error, "%s", guestfs_last_error (g));
807 VALUE rv = rb_ary_new2 (r->len);
809 for (i = 0; i < r->len; ++i) {
810 VALUE hv = rb_hash_new ();
811 rb_hash_aset (rv, rb_str_new2 ("lv_name"), rb_str_new2 (r->val[i].lv_name));
812 rb_hash_aset (rv, rb_str_new2 ("lv_uuid"), rb_str_new (r->val[i].lv_uuid, 32));
813 rb_hash_aset (rv, rb_str_new2 ("lv_attr"), rb_str_new2 (r->val[i].lv_attr));
814 rb_hash_aset (rv, rb_str_new2 ("lv_major"), ULL2NUM (r->val[i].lv_major));
815 rb_hash_aset (rv, rb_str_new2 ("lv_minor"), ULL2NUM (r->val[i].lv_minor));
816 rb_hash_aset (rv, rb_str_new2 ("lv_kernel_major"), ULL2NUM (r->val[i].lv_kernel_major));
817 rb_hash_aset (rv, rb_str_new2 ("lv_kernel_minor"), ULL2NUM (r->val[i].lv_kernel_minor));
818 rb_hash_aset (rv, rb_str_new2 ("lv_size"), ULL2NUM (r->val[i].lv_size));
819 rb_hash_aset (rv, rb_str_new2 ("seg_count"), ULL2NUM (r->val[i].seg_count));
820 rb_hash_aset (rv, rb_str_new2 ("origin"), rb_str_new2 (r->val[i].origin));
821 rb_hash_aset (rv, rb_str_new2 ("snap_percent"), rb_dbl2big (r->val[i].snap_percent));
822 rb_hash_aset (rv, rb_str_new2 ("copy_percent"), rb_dbl2big (r->val[i].copy_percent));
823 rb_hash_aset (rv, rb_str_new2 ("move_pv"), rb_str_new2 (r->val[i].move_pv));
824 rb_hash_aset (rv, rb_str_new2 ("lv_tags"), rb_str_new2 (r->val[i].lv_tags));
825 rb_hash_aset (rv, rb_str_new2 ("mirror_log"), rb_str_new2 (r->val[i].mirror_log));
826 rb_hash_aset (rv, rb_str_new2 ("modules"), rb_str_new2 (r->val[i].modules));
827 rb_ary_push (rv, hv);
829 guestfs_free_lvm_lv_list (r);
833 static VALUE ruby_guestfs_read_lines (VALUE gv, VALUE pathv)
836 Data_Get_Struct (gv, guestfs_h, g);
838 rb_raise (rb_eArgError, "%s: used handle after closing it", "read_lines");
840 const char *path = StringValueCStr (pathv);
842 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
843 "path", "read_lines");
847 r = guestfs_read_lines (g, path);
849 rb_raise (e_Error, "%s", guestfs_last_error (g));
852 for (i = 0; r[i] != NULL; ++i) len++;
853 VALUE rv = rb_ary_new2 (len);
854 for (i = 0; r[i] != NULL; ++i) {
855 rb_ary_push (rv, rb_str_new2 (r[i]));
862 static VALUE ruby_guestfs_aug_init (VALUE gv, VALUE rootv, VALUE flagsv)
865 Data_Get_Struct (gv, guestfs_h, g);
867 rb_raise (rb_eArgError, "%s: used handle after closing it", "aug_init");
869 const char *root = StringValueCStr (rootv);
871 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
873 int flags = NUM2INT (flagsv);
877 r = guestfs_aug_init (g, root, flags);
879 rb_raise (e_Error, "%s", guestfs_last_error (g));
884 static VALUE ruby_guestfs_aug_close (VALUE gv)
887 Data_Get_Struct (gv, guestfs_h, g);
889 rb_raise (rb_eArgError, "%s: used handle after closing it", "aug_close");
894 r = guestfs_aug_close (g);
896 rb_raise (e_Error, "%s", guestfs_last_error (g));
901 static VALUE ruby_guestfs_aug_defvar (VALUE gv, VALUE namev, VALUE exprv)
904 Data_Get_Struct (gv, guestfs_h, g);
906 rb_raise (rb_eArgError, "%s: used handle after closing it", "aug_defvar");
908 const char *name = StringValueCStr (namev);
910 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
911 "name", "aug_defvar");
912 const char *expr = StringValueCStr (exprv);
916 r = guestfs_aug_defvar (g, name, expr);
918 rb_raise (e_Error, "%s", guestfs_last_error (g));
923 static VALUE ruby_guestfs_aug_defnode (VALUE gv, VALUE namev, VALUE exprv, VALUE valv)
926 Data_Get_Struct (gv, guestfs_h, g);
928 rb_raise (rb_eArgError, "%s: used handle after closing it", "aug_defnode");
930 const char *name = StringValueCStr (namev);
932 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
933 "name", "aug_defnode");
934 const char *expr = StringValueCStr (exprv);
936 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
937 "expr", "aug_defnode");
938 const char *val = StringValueCStr (valv);
940 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
941 "val", "aug_defnode");
943 struct guestfs_int_bool *r;
945 r = guestfs_aug_defnode (g, name, expr, val);
947 rb_raise (e_Error, "%s", guestfs_last_error (g));
949 VALUE rv = rb_ary_new2 (2);
950 rb_ary_push (rv, INT2NUM (r->i));
951 rb_ary_push (rv, INT2NUM (r->b));
952 guestfs_free_int_bool (r);
956 static VALUE ruby_guestfs_aug_get (VALUE gv, VALUE pathv)
959 Data_Get_Struct (gv, guestfs_h, g);
961 rb_raise (rb_eArgError, "%s: used handle after closing it", "aug_get");
963 const char *path = StringValueCStr (pathv);
965 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
970 r = guestfs_aug_get (g, path);
972 rb_raise (e_Error, "%s", guestfs_last_error (g));
974 VALUE rv = rb_str_new2 (r);
979 static VALUE ruby_guestfs_aug_set (VALUE gv, VALUE pathv, VALUE valv)
982 Data_Get_Struct (gv, guestfs_h, g);
984 rb_raise (rb_eArgError, "%s: used handle after closing it", "aug_set");
986 const char *path = StringValueCStr (pathv);
988 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
990 const char *val = StringValueCStr (valv);
992 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
997 r = guestfs_aug_set (g, path, val);
999 rb_raise (e_Error, "%s", guestfs_last_error (g));
1004 static VALUE ruby_guestfs_aug_insert (VALUE gv, VALUE pathv, VALUE labelv, VALUE beforev)
1007 Data_Get_Struct (gv, guestfs_h, g);
1009 rb_raise (rb_eArgError, "%s: used handle after closing it", "aug_insert");
1011 const char *path = StringValueCStr (pathv);
1013 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1014 "path", "aug_insert");
1015 const char *label = StringValueCStr (labelv);
1017 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1018 "label", "aug_insert");
1019 int before = NUM2INT (beforev);
1023 r = guestfs_aug_insert (g, path, label, before);
1025 rb_raise (e_Error, "%s", guestfs_last_error (g));
1030 static VALUE ruby_guestfs_aug_rm (VALUE gv, VALUE pathv)
1033 Data_Get_Struct (gv, guestfs_h, g);
1035 rb_raise (rb_eArgError, "%s: used handle after closing it", "aug_rm");
1037 const char *path = StringValueCStr (pathv);
1039 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1044 r = guestfs_aug_rm (g, path);
1046 rb_raise (e_Error, "%s", guestfs_last_error (g));
1051 static VALUE ruby_guestfs_aug_mv (VALUE gv, VALUE srcv, VALUE destv)
1054 Data_Get_Struct (gv, guestfs_h, g);
1056 rb_raise (rb_eArgError, "%s: used handle after closing it", "aug_mv");
1058 const char *src = StringValueCStr (srcv);
1060 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1062 const char *dest = StringValueCStr (destv);
1064 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1069 r = guestfs_aug_mv (g, src, dest);
1071 rb_raise (e_Error, "%s", guestfs_last_error (g));
1076 static VALUE ruby_guestfs_aug_match (VALUE gv, VALUE pathv)
1079 Data_Get_Struct (gv, guestfs_h, g);
1081 rb_raise (rb_eArgError, "%s: used handle after closing it", "aug_match");
1083 const char *path = StringValueCStr (pathv);
1085 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1086 "path", "aug_match");
1090 r = guestfs_aug_match (g, path);
1092 rb_raise (e_Error, "%s", guestfs_last_error (g));
1095 for (i = 0; r[i] != NULL; ++i) len++;
1096 VALUE rv = rb_ary_new2 (len);
1097 for (i = 0; r[i] != NULL; ++i) {
1098 rb_ary_push (rv, rb_str_new2 (r[i]));
1105 static VALUE ruby_guestfs_aug_save (VALUE gv)
1108 Data_Get_Struct (gv, guestfs_h, g);
1110 rb_raise (rb_eArgError, "%s: used handle after closing it", "aug_save");
1115 r = guestfs_aug_save (g);
1117 rb_raise (e_Error, "%s", guestfs_last_error (g));
1122 static VALUE ruby_guestfs_aug_load (VALUE gv)
1125 Data_Get_Struct (gv, guestfs_h, g);
1127 rb_raise (rb_eArgError, "%s: used handle after closing it", "aug_load");
1132 r = guestfs_aug_load (g);
1134 rb_raise (e_Error, "%s", guestfs_last_error (g));
1139 static VALUE ruby_guestfs_aug_ls (VALUE gv, VALUE pathv)
1142 Data_Get_Struct (gv, guestfs_h, g);
1144 rb_raise (rb_eArgError, "%s: used handle after closing it", "aug_ls");
1146 const char *path = StringValueCStr (pathv);
1148 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1153 r = guestfs_aug_ls (g, path);
1155 rb_raise (e_Error, "%s", guestfs_last_error (g));
1158 for (i = 0; r[i] != NULL; ++i) len++;
1159 VALUE rv = rb_ary_new2 (len);
1160 for (i = 0; r[i] != NULL; ++i) {
1161 rb_ary_push (rv, rb_str_new2 (r[i]));
1168 static VALUE ruby_guestfs_rm (VALUE gv, VALUE pathv)
1171 Data_Get_Struct (gv, guestfs_h, g);
1173 rb_raise (rb_eArgError, "%s: used handle after closing it", "rm");
1175 const char *path = StringValueCStr (pathv);
1177 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1182 r = guestfs_rm (g, path);
1184 rb_raise (e_Error, "%s", guestfs_last_error (g));
1189 static VALUE ruby_guestfs_rmdir (VALUE gv, VALUE pathv)
1192 Data_Get_Struct (gv, guestfs_h, g);
1194 rb_raise (rb_eArgError, "%s: used handle after closing it", "rmdir");
1196 const char *path = StringValueCStr (pathv);
1198 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1203 r = guestfs_rmdir (g, path);
1205 rb_raise (e_Error, "%s", guestfs_last_error (g));
1210 static VALUE ruby_guestfs_rm_rf (VALUE gv, VALUE pathv)
1213 Data_Get_Struct (gv, guestfs_h, g);
1215 rb_raise (rb_eArgError, "%s: used handle after closing it", "rm_rf");
1217 const char *path = StringValueCStr (pathv);
1219 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1224 r = guestfs_rm_rf (g, path);
1226 rb_raise (e_Error, "%s", guestfs_last_error (g));
1231 static VALUE ruby_guestfs_mkdir (VALUE gv, VALUE pathv)
1234 Data_Get_Struct (gv, guestfs_h, g);
1236 rb_raise (rb_eArgError, "%s: used handle after closing it", "mkdir");
1238 const char *path = StringValueCStr (pathv);
1240 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1245 r = guestfs_mkdir (g, path);
1247 rb_raise (e_Error, "%s", guestfs_last_error (g));
1252 static VALUE ruby_guestfs_mkdir_p (VALUE gv, VALUE pathv)
1255 Data_Get_Struct (gv, guestfs_h, g);
1257 rb_raise (rb_eArgError, "%s: used handle after closing it", "mkdir_p");
1259 const char *path = StringValueCStr (pathv);
1261 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1266 r = guestfs_mkdir_p (g, path);
1268 rb_raise (e_Error, "%s", guestfs_last_error (g));
1273 static VALUE ruby_guestfs_chmod (VALUE gv, VALUE modev, VALUE pathv)
1276 Data_Get_Struct (gv, guestfs_h, g);
1278 rb_raise (rb_eArgError, "%s: used handle after closing it", "chmod");
1280 int mode = NUM2INT (modev);
1281 const char *path = StringValueCStr (pathv);
1283 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1288 r = guestfs_chmod (g, mode, path);
1290 rb_raise (e_Error, "%s", guestfs_last_error (g));
1295 static VALUE ruby_guestfs_chown (VALUE gv, VALUE ownerv, VALUE groupv, VALUE pathv)
1298 Data_Get_Struct (gv, guestfs_h, g);
1300 rb_raise (rb_eArgError, "%s: used handle after closing it", "chown");
1302 int owner = NUM2INT (ownerv);
1303 int group = NUM2INT (groupv);
1304 const char *path = StringValueCStr (pathv);
1306 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1311 r = guestfs_chown (g, owner, group, path);
1313 rb_raise (e_Error, "%s", guestfs_last_error (g));
1318 static VALUE ruby_guestfs_exists (VALUE gv, VALUE pathv)
1321 Data_Get_Struct (gv, guestfs_h, g);
1323 rb_raise (rb_eArgError, "%s: used handle after closing it", "exists");
1325 const char *path = StringValueCStr (pathv);
1327 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1332 r = guestfs_exists (g, path);
1334 rb_raise (e_Error, "%s", guestfs_last_error (g));
1339 static VALUE ruby_guestfs_is_file (VALUE gv, VALUE pathv)
1342 Data_Get_Struct (gv, guestfs_h, g);
1344 rb_raise (rb_eArgError, "%s: used handle after closing it", "is_file");
1346 const char *path = StringValueCStr (pathv);
1348 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1353 r = guestfs_is_file (g, path);
1355 rb_raise (e_Error, "%s", guestfs_last_error (g));
1360 static VALUE ruby_guestfs_is_dir (VALUE gv, VALUE pathv)
1363 Data_Get_Struct (gv, guestfs_h, g);
1365 rb_raise (rb_eArgError, "%s: used handle after closing it", "is_dir");
1367 const char *path = StringValueCStr (pathv);
1369 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1374 r = guestfs_is_dir (g, path);
1376 rb_raise (e_Error, "%s", guestfs_last_error (g));
1381 static VALUE ruby_guestfs_pvcreate (VALUE gv, VALUE devicev)
1384 Data_Get_Struct (gv, guestfs_h, g);
1386 rb_raise (rb_eArgError, "%s: used handle after closing it", "pvcreate");
1388 const char *device = StringValueCStr (devicev);
1390 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1391 "device", "pvcreate");
1395 r = guestfs_pvcreate (g, device);
1397 rb_raise (e_Error, "%s", guestfs_last_error (g));
1402 static VALUE ruby_guestfs_vgcreate (VALUE gv, VALUE volgroupv, VALUE physvolsv)
1405 Data_Get_Struct (gv, guestfs_h, g);
1407 rb_raise (rb_eArgError, "%s: used handle after closing it", "vgcreate");
1409 const char *volgroup = StringValueCStr (volgroupv);
1411 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1412 "volgroup", "vgcreate");
1415 len = RARRAY_LEN (physvolsv);
1416 physvols = guestfs_safe_malloc (g, sizeof (char *) * (len+1));
1417 for (i = 0; i < len; ++i) {
1418 VALUE v = rb_ary_entry (physvolsv, i);
1419 physvols[i] = StringValueCStr (v);
1421 physvols[len] = NULL;
1426 r = guestfs_vgcreate (g, volgroup, physvols);
1429 rb_raise (e_Error, "%s", guestfs_last_error (g));
1434 static VALUE ruby_guestfs_lvcreate (VALUE gv, VALUE logvolv, VALUE volgroupv, VALUE mbytesv)
1437 Data_Get_Struct (gv, guestfs_h, g);
1439 rb_raise (rb_eArgError, "%s: used handle after closing it", "lvcreate");
1441 const char *logvol = StringValueCStr (logvolv);
1443 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1444 "logvol", "lvcreate");
1445 const char *volgroup = StringValueCStr (volgroupv);
1447 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1448 "volgroup", "lvcreate");
1449 int mbytes = NUM2INT (mbytesv);
1453 r = guestfs_lvcreate (g, logvol, volgroup, mbytes);
1455 rb_raise (e_Error, "%s", guestfs_last_error (g));
1460 static VALUE ruby_guestfs_mkfs (VALUE gv, VALUE fstypev, VALUE devicev)
1463 Data_Get_Struct (gv, guestfs_h, g);
1465 rb_raise (rb_eArgError, "%s: used handle after closing it", "mkfs");
1467 const char *fstype = StringValueCStr (fstypev);
1469 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1471 const char *device = StringValueCStr (devicev);
1473 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1478 r = guestfs_mkfs (g, fstype, device);
1480 rb_raise (e_Error, "%s", guestfs_last_error (g));
1485 static VALUE ruby_guestfs_sfdisk (VALUE gv, VALUE devicev, VALUE cylsv, VALUE headsv, VALUE sectorsv, VALUE linesv)
1488 Data_Get_Struct (gv, guestfs_h, g);
1490 rb_raise (rb_eArgError, "%s: used handle after closing it", "sfdisk");
1492 const char *device = StringValueCStr (devicev);
1494 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1495 "device", "sfdisk");
1496 int cyls = NUM2INT (cylsv);
1497 int heads = NUM2INT (headsv);
1498 int sectors = NUM2INT (sectorsv);
1501 len = RARRAY_LEN (linesv);
1502 lines = guestfs_safe_malloc (g, sizeof (char *) * (len+1));
1503 for (i = 0; i < len; ++i) {
1504 VALUE v = rb_ary_entry (linesv, i);
1505 lines[i] = StringValueCStr (v);
1512 r = guestfs_sfdisk (g, device, cyls, heads, sectors, lines);
1515 rb_raise (e_Error, "%s", guestfs_last_error (g));
1520 static VALUE ruby_guestfs_write_file (VALUE gv, VALUE pathv, VALUE contentv, VALUE sizev)
1523 Data_Get_Struct (gv, guestfs_h, g);
1525 rb_raise (rb_eArgError, "%s: used handle after closing it", "write_file");
1527 const char *path = StringValueCStr (pathv);
1529 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1530 "path", "write_file");
1531 const char *content = StringValueCStr (contentv);
1533 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1534 "content", "write_file");
1535 int size = NUM2INT (sizev);
1539 r = guestfs_write_file (g, path, content, size);
1541 rb_raise (e_Error, "%s", guestfs_last_error (g));
1546 static VALUE ruby_guestfs_umount (VALUE gv, VALUE pathordevicev)
1549 Data_Get_Struct (gv, guestfs_h, g);
1551 rb_raise (rb_eArgError, "%s: used handle after closing it", "umount");
1553 const char *pathordevice = StringValueCStr (pathordevicev);
1555 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1556 "pathordevice", "umount");
1560 r = guestfs_umount (g, pathordevice);
1562 rb_raise (e_Error, "%s", guestfs_last_error (g));
1567 static VALUE ruby_guestfs_mounts (VALUE gv)
1570 Data_Get_Struct (gv, guestfs_h, g);
1572 rb_raise (rb_eArgError, "%s: used handle after closing it", "mounts");
1577 r = guestfs_mounts (g);
1579 rb_raise (e_Error, "%s", guestfs_last_error (g));
1582 for (i = 0; r[i] != NULL; ++i) len++;
1583 VALUE rv = rb_ary_new2 (len);
1584 for (i = 0; r[i] != NULL; ++i) {
1585 rb_ary_push (rv, rb_str_new2 (r[i]));
1592 static VALUE ruby_guestfs_umount_all (VALUE gv)
1595 Data_Get_Struct (gv, guestfs_h, g);
1597 rb_raise (rb_eArgError, "%s: used handle after closing it", "umount_all");
1602 r = guestfs_umount_all (g);
1604 rb_raise (e_Error, "%s", guestfs_last_error (g));
1609 static VALUE ruby_guestfs_lvm_remove_all (VALUE gv)
1612 Data_Get_Struct (gv, guestfs_h, g);
1614 rb_raise (rb_eArgError, "%s: used handle after closing it", "lvm_remove_all");
1619 r = guestfs_lvm_remove_all (g);
1621 rb_raise (e_Error, "%s", guestfs_last_error (g));
1626 static VALUE ruby_guestfs_file (VALUE gv, VALUE pathv)
1629 Data_Get_Struct (gv, guestfs_h, g);
1631 rb_raise (rb_eArgError, "%s: used handle after closing it", "file");
1633 const char *path = StringValueCStr (pathv);
1635 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1640 r = guestfs_file (g, path);
1642 rb_raise (e_Error, "%s", guestfs_last_error (g));
1644 VALUE rv = rb_str_new2 (r);
1649 static VALUE ruby_guestfs_command (VALUE gv, VALUE argumentsv)
1652 Data_Get_Struct (gv, guestfs_h, g);
1654 rb_raise (rb_eArgError, "%s: used handle after closing it", "command");
1658 len = RARRAY_LEN (argumentsv);
1659 arguments = guestfs_safe_malloc (g, sizeof (char *) * (len+1));
1660 for (i = 0; i < len; ++i) {
1661 VALUE v = rb_ary_entry (argumentsv, i);
1662 arguments[i] = StringValueCStr (v);
1664 arguments[len] = NULL;
1669 r = guestfs_command (g, arguments);
1672 rb_raise (e_Error, "%s", guestfs_last_error (g));
1674 VALUE rv = rb_str_new2 (r);
1679 static VALUE ruby_guestfs_command_lines (VALUE gv, VALUE argumentsv)
1682 Data_Get_Struct (gv, guestfs_h, g);
1684 rb_raise (rb_eArgError, "%s: used handle after closing it", "command_lines");
1688 len = RARRAY_LEN (argumentsv);
1689 arguments = guestfs_safe_malloc (g, sizeof (char *) * (len+1));
1690 for (i = 0; i < len; ++i) {
1691 VALUE v = rb_ary_entry (argumentsv, i);
1692 arguments[i] = StringValueCStr (v);
1694 arguments[len] = NULL;
1699 r = guestfs_command_lines (g, arguments);
1702 rb_raise (e_Error, "%s", guestfs_last_error (g));
1705 for (i = 0; r[i] != NULL; ++i) len++;
1706 VALUE rv = rb_ary_new2 (len);
1707 for (i = 0; r[i] != NULL; ++i) {
1708 rb_ary_push (rv, rb_str_new2 (r[i]));
1715 static VALUE ruby_guestfs_stat (VALUE gv, VALUE pathv)
1718 Data_Get_Struct (gv, guestfs_h, g);
1720 rb_raise (rb_eArgError, "%s: used handle after closing it", "stat");
1722 const char *path = StringValueCStr (pathv);
1724 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1727 struct guestfs_stat *r;
1729 r = guestfs_stat (g, path);
1731 rb_raise (e_Error, "%s", guestfs_last_error (g));
1733 VALUE rv = rb_hash_new ();
1734 rb_hash_aset (rv, rb_str_new2 ("dev"), ULL2NUM (r->dev));
1735 rb_hash_aset (rv, rb_str_new2 ("ino"), ULL2NUM (r->ino));
1736 rb_hash_aset (rv, rb_str_new2 ("mode"), ULL2NUM (r->mode));
1737 rb_hash_aset (rv, rb_str_new2 ("nlink"), ULL2NUM (r->nlink));
1738 rb_hash_aset (rv, rb_str_new2 ("uid"), ULL2NUM (r->uid));
1739 rb_hash_aset (rv, rb_str_new2 ("gid"), ULL2NUM (r->gid));
1740 rb_hash_aset (rv, rb_str_new2 ("rdev"), ULL2NUM (r->rdev));
1741 rb_hash_aset (rv, rb_str_new2 ("size"), ULL2NUM (r->size));
1742 rb_hash_aset (rv, rb_str_new2 ("blksize"), ULL2NUM (r->blksize));
1743 rb_hash_aset (rv, rb_str_new2 ("blocks"), ULL2NUM (r->blocks));
1744 rb_hash_aset (rv, rb_str_new2 ("atime"), ULL2NUM (r->atime));
1745 rb_hash_aset (rv, rb_str_new2 ("mtime"), ULL2NUM (r->mtime));
1746 rb_hash_aset (rv, rb_str_new2 ("ctime"), ULL2NUM (r->ctime));
1751 static VALUE ruby_guestfs_lstat (VALUE gv, VALUE pathv)
1754 Data_Get_Struct (gv, guestfs_h, g);
1756 rb_raise (rb_eArgError, "%s: used handle after closing it", "lstat");
1758 const char *path = StringValueCStr (pathv);
1760 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1763 struct guestfs_stat *r;
1765 r = guestfs_lstat (g, path);
1767 rb_raise (e_Error, "%s", guestfs_last_error (g));
1769 VALUE rv = rb_hash_new ();
1770 rb_hash_aset (rv, rb_str_new2 ("dev"), ULL2NUM (r->dev));
1771 rb_hash_aset (rv, rb_str_new2 ("ino"), ULL2NUM (r->ino));
1772 rb_hash_aset (rv, rb_str_new2 ("mode"), ULL2NUM (r->mode));
1773 rb_hash_aset (rv, rb_str_new2 ("nlink"), ULL2NUM (r->nlink));
1774 rb_hash_aset (rv, rb_str_new2 ("uid"), ULL2NUM (r->uid));
1775 rb_hash_aset (rv, rb_str_new2 ("gid"), ULL2NUM (r->gid));
1776 rb_hash_aset (rv, rb_str_new2 ("rdev"), ULL2NUM (r->rdev));
1777 rb_hash_aset (rv, rb_str_new2 ("size"), ULL2NUM (r->size));
1778 rb_hash_aset (rv, rb_str_new2 ("blksize"), ULL2NUM (r->blksize));
1779 rb_hash_aset (rv, rb_str_new2 ("blocks"), ULL2NUM (r->blocks));
1780 rb_hash_aset (rv, rb_str_new2 ("atime"), ULL2NUM (r->atime));
1781 rb_hash_aset (rv, rb_str_new2 ("mtime"), ULL2NUM (r->mtime));
1782 rb_hash_aset (rv, rb_str_new2 ("ctime"), ULL2NUM (r->ctime));
1787 static VALUE ruby_guestfs_statvfs (VALUE gv, VALUE pathv)
1790 Data_Get_Struct (gv, guestfs_h, g);
1792 rb_raise (rb_eArgError, "%s: used handle after closing it", "statvfs");
1794 const char *path = StringValueCStr (pathv);
1796 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1799 struct guestfs_statvfs *r;
1801 r = guestfs_statvfs (g, path);
1803 rb_raise (e_Error, "%s", guestfs_last_error (g));
1805 VALUE rv = rb_hash_new ();
1806 rb_hash_aset (rv, rb_str_new2 ("bsize"), ULL2NUM (r->bsize));
1807 rb_hash_aset (rv, rb_str_new2 ("frsize"), ULL2NUM (r->frsize));
1808 rb_hash_aset (rv, rb_str_new2 ("blocks"), ULL2NUM (r->blocks));
1809 rb_hash_aset (rv, rb_str_new2 ("bfree"), ULL2NUM (r->bfree));
1810 rb_hash_aset (rv, rb_str_new2 ("bavail"), ULL2NUM (r->bavail));
1811 rb_hash_aset (rv, rb_str_new2 ("files"), ULL2NUM (r->files));
1812 rb_hash_aset (rv, rb_str_new2 ("ffree"), ULL2NUM (r->ffree));
1813 rb_hash_aset (rv, rb_str_new2 ("favail"), ULL2NUM (r->favail));
1814 rb_hash_aset (rv, rb_str_new2 ("fsid"), ULL2NUM (r->fsid));
1815 rb_hash_aset (rv, rb_str_new2 ("flag"), ULL2NUM (r->flag));
1816 rb_hash_aset (rv, rb_str_new2 ("namemax"), ULL2NUM (r->namemax));
1821 static VALUE ruby_guestfs_tune2fs_l (VALUE gv, VALUE devicev)
1824 Data_Get_Struct (gv, guestfs_h, g);
1826 rb_raise (rb_eArgError, "%s: used handle after closing it", "tune2fs_l");
1828 const char *device = StringValueCStr (devicev);
1830 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1831 "device", "tune2fs_l");
1835 r = guestfs_tune2fs_l (g, device);
1837 rb_raise (e_Error, "%s", guestfs_last_error (g));
1839 VALUE rv = rb_hash_new ();
1841 for (i = 0; r[i] != NULL; i+=2) {
1842 rb_hash_aset (rv, rb_str_new2 (r[i]), rb_str_new2 (r[i+1]));
1850 static VALUE ruby_guestfs_blockdev_setro (VALUE gv, VALUE devicev)
1853 Data_Get_Struct (gv, guestfs_h, g);
1855 rb_raise (rb_eArgError, "%s: used handle after closing it", "blockdev_setro");
1857 const char *device = StringValueCStr (devicev);
1859 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1860 "device", "blockdev_setro");
1864 r = guestfs_blockdev_setro (g, device);
1866 rb_raise (e_Error, "%s", guestfs_last_error (g));
1871 static VALUE ruby_guestfs_blockdev_setrw (VALUE gv, VALUE devicev)
1874 Data_Get_Struct (gv, guestfs_h, g);
1876 rb_raise (rb_eArgError, "%s: used handle after closing it", "blockdev_setrw");
1878 const char *device = StringValueCStr (devicev);
1880 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1881 "device", "blockdev_setrw");
1885 r = guestfs_blockdev_setrw (g, device);
1887 rb_raise (e_Error, "%s", guestfs_last_error (g));
1892 static VALUE ruby_guestfs_blockdev_getro (VALUE gv, VALUE devicev)
1895 Data_Get_Struct (gv, guestfs_h, g);
1897 rb_raise (rb_eArgError, "%s: used handle after closing it", "blockdev_getro");
1899 const char *device = StringValueCStr (devicev);
1901 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1902 "device", "blockdev_getro");
1906 r = guestfs_blockdev_getro (g, device);
1908 rb_raise (e_Error, "%s", guestfs_last_error (g));
1913 static VALUE ruby_guestfs_blockdev_getss (VALUE gv, VALUE devicev)
1916 Data_Get_Struct (gv, guestfs_h, g);
1918 rb_raise (rb_eArgError, "%s: used handle after closing it", "blockdev_getss");
1920 const char *device = StringValueCStr (devicev);
1922 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1923 "device", "blockdev_getss");
1927 r = guestfs_blockdev_getss (g, device);
1929 rb_raise (e_Error, "%s", guestfs_last_error (g));
1934 static VALUE ruby_guestfs_blockdev_getbsz (VALUE gv, VALUE devicev)
1937 Data_Get_Struct (gv, guestfs_h, g);
1939 rb_raise (rb_eArgError, "%s: used handle after closing it", "blockdev_getbsz");
1941 const char *device = StringValueCStr (devicev);
1943 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1944 "device", "blockdev_getbsz");
1948 r = guestfs_blockdev_getbsz (g, device);
1950 rb_raise (e_Error, "%s", guestfs_last_error (g));
1955 static VALUE ruby_guestfs_blockdev_setbsz (VALUE gv, VALUE devicev, VALUE blocksizev)
1958 Data_Get_Struct (gv, guestfs_h, g);
1960 rb_raise (rb_eArgError, "%s: used handle after closing it", "blockdev_setbsz");
1962 const char *device = StringValueCStr (devicev);
1964 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1965 "device", "blockdev_setbsz");
1966 int blocksize = NUM2INT (blocksizev);
1970 r = guestfs_blockdev_setbsz (g, device, blocksize);
1972 rb_raise (e_Error, "%s", guestfs_last_error (g));
1977 static VALUE ruby_guestfs_blockdev_getsz (VALUE gv, VALUE devicev)
1980 Data_Get_Struct (gv, guestfs_h, g);
1982 rb_raise (rb_eArgError, "%s: used handle after closing it", "blockdev_getsz");
1984 const char *device = StringValueCStr (devicev);
1986 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1987 "device", "blockdev_getsz");
1991 r = guestfs_blockdev_getsz (g, device);
1993 rb_raise (e_Error, "%s", guestfs_last_error (g));
1998 static VALUE ruby_guestfs_blockdev_getsize64 (VALUE gv, VALUE devicev)
2001 Data_Get_Struct (gv, guestfs_h, g);
2003 rb_raise (rb_eArgError, "%s: used handle after closing it", "blockdev_getsize64");
2005 const char *device = StringValueCStr (devicev);
2007 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2008 "device", "blockdev_getsize64");
2012 r = guestfs_blockdev_getsize64 (g, device);
2014 rb_raise (e_Error, "%s", guestfs_last_error (g));
2019 static VALUE ruby_guestfs_blockdev_flushbufs (VALUE gv, VALUE devicev)
2022 Data_Get_Struct (gv, guestfs_h, g);
2024 rb_raise (rb_eArgError, "%s: used handle after closing it", "blockdev_flushbufs");
2026 const char *device = StringValueCStr (devicev);
2028 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2029 "device", "blockdev_flushbufs");
2033 r = guestfs_blockdev_flushbufs (g, device);
2035 rb_raise (e_Error, "%s", guestfs_last_error (g));
2040 static VALUE ruby_guestfs_blockdev_rereadpt (VALUE gv, VALUE devicev)
2043 Data_Get_Struct (gv, guestfs_h, g);
2045 rb_raise (rb_eArgError, "%s: used handle after closing it", "blockdev_rereadpt");
2047 const char *device = StringValueCStr (devicev);
2049 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2050 "device", "blockdev_rereadpt");
2054 r = guestfs_blockdev_rereadpt (g, device);
2056 rb_raise (e_Error, "%s", guestfs_last_error (g));
2061 static VALUE ruby_guestfs_upload (VALUE gv, VALUE filenamev, VALUE remotefilenamev)
2064 Data_Get_Struct (gv, guestfs_h, g);
2066 rb_raise (rb_eArgError, "%s: used handle after closing it", "upload");
2068 const char *filename = StringValueCStr (filenamev);
2070 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2071 "filename", "upload");
2072 const char *remotefilename = StringValueCStr (remotefilenamev);
2073 if (!remotefilename)
2074 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2075 "remotefilename", "upload");
2079 r = guestfs_upload (g, filename, remotefilename);
2081 rb_raise (e_Error, "%s", guestfs_last_error (g));
2086 static VALUE ruby_guestfs_download (VALUE gv, VALUE remotefilenamev, VALUE filenamev)
2089 Data_Get_Struct (gv, guestfs_h, g);
2091 rb_raise (rb_eArgError, "%s: used handle after closing it", "download");
2093 const char *remotefilename = StringValueCStr (remotefilenamev);
2094 if (!remotefilename)
2095 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2096 "remotefilename", "download");
2097 const char *filename = StringValueCStr (filenamev);
2099 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2100 "filename", "download");
2104 r = guestfs_download (g, remotefilename, filename);
2106 rb_raise (e_Error, "%s", guestfs_last_error (g));
2111 static VALUE ruby_guestfs_checksum (VALUE gv, VALUE csumtypev, VALUE pathv)
2114 Data_Get_Struct (gv, guestfs_h, g);
2116 rb_raise (rb_eArgError, "%s: used handle after closing it", "checksum");
2118 const char *csumtype = StringValueCStr (csumtypev);
2120 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2121 "csumtype", "checksum");
2122 const char *path = StringValueCStr (pathv);
2124 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2125 "path", "checksum");
2129 r = guestfs_checksum (g, csumtype, path);
2131 rb_raise (e_Error, "%s", guestfs_last_error (g));
2133 VALUE rv = rb_str_new2 (r);
2138 static VALUE ruby_guestfs_tar_in (VALUE gv, VALUE tarfilev, VALUE directoryv)
2141 Data_Get_Struct (gv, guestfs_h, g);
2143 rb_raise (rb_eArgError, "%s: used handle after closing it", "tar_in");
2145 const char *tarfile = StringValueCStr (tarfilev);
2147 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2148 "tarfile", "tar_in");
2149 const char *directory = StringValueCStr (directoryv);
2151 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2152 "directory", "tar_in");
2156 r = guestfs_tar_in (g, tarfile, directory);
2158 rb_raise (e_Error, "%s", guestfs_last_error (g));
2163 static VALUE ruby_guestfs_tar_out (VALUE gv, VALUE directoryv, VALUE tarfilev)
2166 Data_Get_Struct (gv, guestfs_h, g);
2168 rb_raise (rb_eArgError, "%s: used handle after closing it", "tar_out");
2170 const char *directory = StringValueCStr (directoryv);
2172 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2173 "directory", "tar_out");
2174 const char *tarfile = StringValueCStr (tarfilev);
2176 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2177 "tarfile", "tar_out");
2181 r = guestfs_tar_out (g, directory, tarfile);
2183 rb_raise (e_Error, "%s", guestfs_last_error (g));
2188 static VALUE ruby_guestfs_tgz_in (VALUE gv, VALUE tarballv, VALUE directoryv)
2191 Data_Get_Struct (gv, guestfs_h, g);
2193 rb_raise (rb_eArgError, "%s: used handle after closing it", "tgz_in");
2195 const char *tarball = StringValueCStr (tarballv);
2197 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2198 "tarball", "tgz_in");
2199 const char *directory = StringValueCStr (directoryv);
2201 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2202 "directory", "tgz_in");
2206 r = guestfs_tgz_in (g, tarball, directory);
2208 rb_raise (e_Error, "%s", guestfs_last_error (g));
2213 static VALUE ruby_guestfs_tgz_out (VALUE gv, VALUE directoryv, VALUE tarballv)
2216 Data_Get_Struct (gv, guestfs_h, g);
2218 rb_raise (rb_eArgError, "%s: used handle after closing it", "tgz_out");
2220 const char *directory = StringValueCStr (directoryv);
2222 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2223 "directory", "tgz_out");
2224 const char *tarball = StringValueCStr (tarballv);
2226 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2227 "tarball", "tgz_out");
2231 r = guestfs_tgz_out (g, directory, tarball);
2233 rb_raise (e_Error, "%s", guestfs_last_error (g));
2238 static VALUE ruby_guestfs_mount_ro (VALUE gv, VALUE devicev, VALUE mountpointv)
2241 Data_Get_Struct (gv, guestfs_h, g);
2243 rb_raise (rb_eArgError, "%s: used handle after closing it", "mount_ro");
2245 const char *device = StringValueCStr (devicev);
2247 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2248 "device", "mount_ro");
2249 const char *mountpoint = StringValueCStr (mountpointv);
2251 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2252 "mountpoint", "mount_ro");
2256 r = guestfs_mount_ro (g, device, mountpoint);
2258 rb_raise (e_Error, "%s", guestfs_last_error (g));
2263 static VALUE ruby_guestfs_mount_options (VALUE gv, VALUE optionsv, VALUE devicev, VALUE mountpointv)
2266 Data_Get_Struct (gv, guestfs_h, g);
2268 rb_raise (rb_eArgError, "%s: used handle after closing it", "mount_options");
2270 const char *options = StringValueCStr (optionsv);
2272 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2273 "options", "mount_options");
2274 const char *device = StringValueCStr (devicev);
2276 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2277 "device", "mount_options");
2278 const char *mountpoint = StringValueCStr (mountpointv);
2280 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2281 "mountpoint", "mount_options");
2285 r = guestfs_mount_options (g, options, device, mountpoint);
2287 rb_raise (e_Error, "%s", guestfs_last_error (g));
2292 static VALUE ruby_guestfs_mount_vfs (VALUE gv, VALUE optionsv, VALUE vfstypev, VALUE devicev, VALUE mountpointv)
2295 Data_Get_Struct (gv, guestfs_h, g);
2297 rb_raise (rb_eArgError, "%s: used handle after closing it", "mount_vfs");
2299 const char *options = StringValueCStr (optionsv);
2301 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2302 "options", "mount_vfs");
2303 const char *vfstype = StringValueCStr (vfstypev);
2305 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2306 "vfstype", "mount_vfs");
2307 const char *device = StringValueCStr (devicev);
2309 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2310 "device", "mount_vfs");
2311 const char *mountpoint = StringValueCStr (mountpointv);
2313 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2314 "mountpoint", "mount_vfs");
2318 r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint);
2320 rb_raise (e_Error, "%s", guestfs_last_error (g));
2325 static VALUE ruby_guestfs_debug (VALUE gv, VALUE subcmdv, VALUE extraargsv)
2328 Data_Get_Struct (gv, guestfs_h, g);
2330 rb_raise (rb_eArgError, "%s: used handle after closing it", "debug");
2332 const char *subcmd = StringValueCStr (subcmdv);
2334 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2338 len = RARRAY_LEN (extraargsv);
2339 extraargs = guestfs_safe_malloc (g, sizeof (char *) * (len+1));
2340 for (i = 0; i < len; ++i) {
2341 VALUE v = rb_ary_entry (extraargsv, i);
2342 extraargs[i] = StringValueCStr (v);
2344 extraargs[len] = NULL;
2349 r = guestfs_debug (g, subcmd, extraargs);
2352 rb_raise (e_Error, "%s", guestfs_last_error (g));
2354 VALUE rv = rb_str_new2 (r);
2359 static VALUE ruby_guestfs_lvremove (VALUE gv, VALUE devicev)
2362 Data_Get_Struct (gv, guestfs_h, g);
2364 rb_raise (rb_eArgError, "%s: used handle after closing it", "lvremove");
2366 const char *device = StringValueCStr (devicev);
2368 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2369 "device", "lvremove");
2373 r = guestfs_lvremove (g, device);
2375 rb_raise (e_Error, "%s", guestfs_last_error (g));
2380 static VALUE ruby_guestfs_vgremove (VALUE gv, VALUE vgnamev)
2383 Data_Get_Struct (gv, guestfs_h, g);
2385 rb_raise (rb_eArgError, "%s: used handle after closing it", "vgremove");
2387 const char *vgname = StringValueCStr (vgnamev);
2389 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2390 "vgname", "vgremove");
2394 r = guestfs_vgremove (g, vgname);
2396 rb_raise (e_Error, "%s", guestfs_last_error (g));
2401 static VALUE ruby_guestfs_pvremove (VALUE gv, VALUE devicev)
2404 Data_Get_Struct (gv, guestfs_h, g);
2406 rb_raise (rb_eArgError, "%s: used handle after closing it", "pvremove");
2408 const char *device = StringValueCStr (devicev);
2410 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2411 "device", "pvremove");
2415 r = guestfs_pvremove (g, device);
2417 rb_raise (e_Error, "%s", guestfs_last_error (g));
2422 static VALUE ruby_guestfs_set_e2label (VALUE gv, VALUE devicev, VALUE labelv)
2425 Data_Get_Struct (gv, guestfs_h, g);
2427 rb_raise (rb_eArgError, "%s: used handle after closing it", "set_e2label");
2429 const char *device = StringValueCStr (devicev);
2431 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2432 "device", "set_e2label");
2433 const char *label = StringValueCStr (labelv);
2435 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2436 "label", "set_e2label");
2440 r = guestfs_set_e2label (g, device, label);
2442 rb_raise (e_Error, "%s", guestfs_last_error (g));
2447 static VALUE ruby_guestfs_get_e2label (VALUE gv, VALUE devicev)
2450 Data_Get_Struct (gv, guestfs_h, g);
2452 rb_raise (rb_eArgError, "%s: used handle after closing it", "get_e2label");
2454 const char *device = StringValueCStr (devicev);
2456 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2457 "device", "get_e2label");
2461 r = guestfs_get_e2label (g, device);
2463 rb_raise (e_Error, "%s", guestfs_last_error (g));
2465 VALUE rv = rb_str_new2 (r);
2470 static VALUE ruby_guestfs_set_e2uuid (VALUE gv, VALUE devicev, VALUE uuidv)
2473 Data_Get_Struct (gv, guestfs_h, g);
2475 rb_raise (rb_eArgError, "%s: used handle after closing it", "set_e2uuid");
2477 const char *device = StringValueCStr (devicev);
2479 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2480 "device", "set_e2uuid");
2481 const char *uuid = StringValueCStr (uuidv);
2483 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2484 "uuid", "set_e2uuid");
2488 r = guestfs_set_e2uuid (g, device, uuid);
2490 rb_raise (e_Error, "%s", guestfs_last_error (g));
2495 static VALUE ruby_guestfs_get_e2uuid (VALUE gv, VALUE devicev)
2498 Data_Get_Struct (gv, guestfs_h, g);
2500 rb_raise (rb_eArgError, "%s: used handle after closing it", "get_e2uuid");
2502 const char *device = StringValueCStr (devicev);
2504 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2505 "device", "get_e2uuid");
2509 r = guestfs_get_e2uuid (g, device);
2511 rb_raise (e_Error, "%s", guestfs_last_error (g));
2513 VALUE rv = rb_str_new2 (r);
2518 /* Initialize the module. */
2519 void Init__guestfs ()
2521 m_guestfs = rb_define_module ("Guestfs");
2522 c_guestfs = rb_define_class_under (m_guestfs, "Guestfs", rb_cObject);
2523 e_Error = rb_define_class_under (m_guestfs, "Error", rb_eStandardError);
2525 rb_define_module_function (m_guestfs, "create", ruby_guestfs_create, 0);
2526 rb_define_method (c_guestfs, "close", ruby_guestfs_close, 0);
2528 rb_define_method (c_guestfs, "launch",
2529 ruby_guestfs_launch, 0);
2530 rb_define_method (c_guestfs, "wait_ready",
2531 ruby_guestfs_wait_ready, 0);
2532 rb_define_method (c_guestfs, "kill_subprocess",
2533 ruby_guestfs_kill_subprocess, 0);
2534 rb_define_method (c_guestfs, "add_drive",
2535 ruby_guestfs_add_drive, 1);
2536 rb_define_method (c_guestfs, "add_cdrom",
2537 ruby_guestfs_add_cdrom, 1);
2538 rb_define_method (c_guestfs, "config",
2539 ruby_guestfs_config, 2);
2540 rb_define_method (c_guestfs, "set_qemu",
2541 ruby_guestfs_set_qemu, 1);
2542 rb_define_method (c_guestfs, "get_qemu",
2543 ruby_guestfs_get_qemu, 0);
2544 rb_define_method (c_guestfs, "set_path",
2545 ruby_guestfs_set_path, 1);
2546 rb_define_method (c_guestfs, "get_path",
2547 ruby_guestfs_get_path, 0);
2548 rb_define_method (c_guestfs, "set_autosync",
2549 ruby_guestfs_set_autosync, 1);
2550 rb_define_method (c_guestfs, "get_autosync",
2551 ruby_guestfs_get_autosync, 0);
2552 rb_define_method (c_guestfs, "set_verbose",
2553 ruby_guestfs_set_verbose, 1);
2554 rb_define_method (c_guestfs, "get_verbose",
2555 ruby_guestfs_get_verbose, 0);
2556 rb_define_method (c_guestfs, "is_ready",
2557 ruby_guestfs_is_ready, 0);
2558 rb_define_method (c_guestfs, "is_config",
2559 ruby_guestfs_is_config, 0);
2560 rb_define_method (c_guestfs, "is_launching",
2561 ruby_guestfs_is_launching, 0);
2562 rb_define_method (c_guestfs, "is_busy",
2563 ruby_guestfs_is_busy, 0);
2564 rb_define_method (c_guestfs, "get_state",
2565 ruby_guestfs_get_state, 0);
2566 rb_define_method (c_guestfs, "set_busy",
2567 ruby_guestfs_set_busy, 0);
2568 rb_define_method (c_guestfs, "set_ready",
2569 ruby_guestfs_set_ready, 0);
2570 rb_define_method (c_guestfs, "mount",
2571 ruby_guestfs_mount, 2);
2572 rb_define_method (c_guestfs, "sync",
2573 ruby_guestfs_sync, 0);
2574 rb_define_method (c_guestfs, "touch",
2575 ruby_guestfs_touch, 1);
2576 rb_define_method (c_guestfs, "cat",
2577 ruby_guestfs_cat, 1);
2578 rb_define_method (c_guestfs, "ll",
2579 ruby_guestfs_ll, 1);
2580 rb_define_method (c_guestfs, "ls",
2581 ruby_guestfs_ls, 1);
2582 rb_define_method (c_guestfs, "list_devices",
2583 ruby_guestfs_list_devices, 0);
2584 rb_define_method (c_guestfs, "list_partitions",
2585 ruby_guestfs_list_partitions, 0);
2586 rb_define_method (c_guestfs, "pvs",
2587 ruby_guestfs_pvs, 0);
2588 rb_define_method (c_guestfs, "vgs",
2589 ruby_guestfs_vgs, 0);
2590 rb_define_method (c_guestfs, "lvs",
2591 ruby_guestfs_lvs, 0);
2592 rb_define_method (c_guestfs, "pvs_full",
2593 ruby_guestfs_pvs_full, 0);
2594 rb_define_method (c_guestfs, "vgs_full",
2595 ruby_guestfs_vgs_full, 0);
2596 rb_define_method (c_guestfs, "lvs_full",
2597 ruby_guestfs_lvs_full, 0);
2598 rb_define_method (c_guestfs, "read_lines",
2599 ruby_guestfs_read_lines, 1);
2600 rb_define_method (c_guestfs, "aug_init",
2601 ruby_guestfs_aug_init, 2);
2602 rb_define_method (c_guestfs, "aug_close",
2603 ruby_guestfs_aug_close, 0);
2604 rb_define_method (c_guestfs, "aug_defvar",
2605 ruby_guestfs_aug_defvar, 2);
2606 rb_define_method (c_guestfs, "aug_defnode",
2607 ruby_guestfs_aug_defnode, 3);
2608 rb_define_method (c_guestfs, "aug_get",
2609 ruby_guestfs_aug_get, 1);
2610 rb_define_method (c_guestfs, "aug_set",
2611 ruby_guestfs_aug_set, 2);
2612 rb_define_method (c_guestfs, "aug_insert",
2613 ruby_guestfs_aug_insert, 3);
2614 rb_define_method (c_guestfs, "aug_rm",
2615 ruby_guestfs_aug_rm, 1);
2616 rb_define_method (c_guestfs, "aug_mv",
2617 ruby_guestfs_aug_mv, 2);
2618 rb_define_method (c_guestfs, "aug_match",
2619 ruby_guestfs_aug_match, 1);
2620 rb_define_method (c_guestfs, "aug_save",
2621 ruby_guestfs_aug_save, 0);
2622 rb_define_method (c_guestfs, "aug_load",
2623 ruby_guestfs_aug_load, 0);
2624 rb_define_method (c_guestfs, "aug_ls",
2625 ruby_guestfs_aug_ls, 1);
2626 rb_define_method (c_guestfs, "rm",
2627 ruby_guestfs_rm, 1);
2628 rb_define_method (c_guestfs, "rmdir",
2629 ruby_guestfs_rmdir, 1);
2630 rb_define_method (c_guestfs, "rm_rf",
2631 ruby_guestfs_rm_rf, 1);
2632 rb_define_method (c_guestfs, "mkdir",
2633 ruby_guestfs_mkdir, 1);
2634 rb_define_method (c_guestfs, "mkdir_p",
2635 ruby_guestfs_mkdir_p, 1);
2636 rb_define_method (c_guestfs, "chmod",
2637 ruby_guestfs_chmod, 2);
2638 rb_define_method (c_guestfs, "chown",
2639 ruby_guestfs_chown, 3);
2640 rb_define_method (c_guestfs, "exists",
2641 ruby_guestfs_exists, 1);
2642 rb_define_method (c_guestfs, "is_file",
2643 ruby_guestfs_is_file, 1);
2644 rb_define_method (c_guestfs, "is_dir",
2645 ruby_guestfs_is_dir, 1);
2646 rb_define_method (c_guestfs, "pvcreate",
2647 ruby_guestfs_pvcreate, 1);
2648 rb_define_method (c_guestfs, "vgcreate",
2649 ruby_guestfs_vgcreate, 2);
2650 rb_define_method (c_guestfs, "lvcreate",
2651 ruby_guestfs_lvcreate, 3);
2652 rb_define_method (c_guestfs, "mkfs",
2653 ruby_guestfs_mkfs, 2);
2654 rb_define_method (c_guestfs, "sfdisk",
2655 ruby_guestfs_sfdisk, 5);
2656 rb_define_method (c_guestfs, "write_file",
2657 ruby_guestfs_write_file, 3);
2658 rb_define_method (c_guestfs, "umount",
2659 ruby_guestfs_umount, 1);
2660 rb_define_method (c_guestfs, "mounts",
2661 ruby_guestfs_mounts, 0);
2662 rb_define_method (c_guestfs, "umount_all",
2663 ruby_guestfs_umount_all, 0);
2664 rb_define_method (c_guestfs, "lvm_remove_all",
2665 ruby_guestfs_lvm_remove_all, 0);
2666 rb_define_method (c_guestfs, "file",
2667 ruby_guestfs_file, 1);
2668 rb_define_method (c_guestfs, "command",
2669 ruby_guestfs_command, 1);
2670 rb_define_method (c_guestfs, "command_lines",
2671 ruby_guestfs_command_lines, 1);
2672 rb_define_method (c_guestfs, "stat",
2673 ruby_guestfs_stat, 1);
2674 rb_define_method (c_guestfs, "lstat",
2675 ruby_guestfs_lstat, 1);
2676 rb_define_method (c_guestfs, "statvfs",
2677 ruby_guestfs_statvfs, 1);
2678 rb_define_method (c_guestfs, "tune2fs_l",
2679 ruby_guestfs_tune2fs_l, 1);
2680 rb_define_method (c_guestfs, "blockdev_setro",
2681 ruby_guestfs_blockdev_setro, 1);
2682 rb_define_method (c_guestfs, "blockdev_setrw",
2683 ruby_guestfs_blockdev_setrw, 1);
2684 rb_define_method (c_guestfs, "blockdev_getro",
2685 ruby_guestfs_blockdev_getro, 1);
2686 rb_define_method (c_guestfs, "blockdev_getss",
2687 ruby_guestfs_blockdev_getss, 1);
2688 rb_define_method (c_guestfs, "blockdev_getbsz",
2689 ruby_guestfs_blockdev_getbsz, 1);
2690 rb_define_method (c_guestfs, "blockdev_setbsz",
2691 ruby_guestfs_blockdev_setbsz, 2);
2692 rb_define_method (c_guestfs, "blockdev_getsz",
2693 ruby_guestfs_blockdev_getsz, 1);
2694 rb_define_method (c_guestfs, "blockdev_getsize64",
2695 ruby_guestfs_blockdev_getsize64, 1);
2696 rb_define_method (c_guestfs, "blockdev_flushbufs",
2697 ruby_guestfs_blockdev_flushbufs, 1);
2698 rb_define_method (c_guestfs, "blockdev_rereadpt",
2699 ruby_guestfs_blockdev_rereadpt, 1);
2700 rb_define_method (c_guestfs, "upload",
2701 ruby_guestfs_upload, 2);
2702 rb_define_method (c_guestfs, "download",
2703 ruby_guestfs_download, 2);
2704 rb_define_method (c_guestfs, "checksum",
2705 ruby_guestfs_checksum, 2);
2706 rb_define_method (c_guestfs, "tar_in",
2707 ruby_guestfs_tar_in, 2);
2708 rb_define_method (c_guestfs, "tar_out",
2709 ruby_guestfs_tar_out, 2);
2710 rb_define_method (c_guestfs, "tgz_in",
2711 ruby_guestfs_tgz_in, 2);
2712 rb_define_method (c_guestfs, "tgz_out",
2713 ruby_guestfs_tgz_out, 2);
2714 rb_define_method (c_guestfs, "mount_ro",
2715 ruby_guestfs_mount_ro, 2);
2716 rb_define_method (c_guestfs, "mount_options",
2717 ruby_guestfs_mount_options, 3);
2718 rb_define_method (c_guestfs, "mount_vfs",
2719 ruby_guestfs_mount_vfs, 4);
2720 rb_define_method (c_guestfs, "debug",
2721 ruby_guestfs_debug, 2);
2722 rb_define_method (c_guestfs, "lvremove",
2723 ruby_guestfs_lvremove, 1);
2724 rb_define_method (c_guestfs, "vgremove",
2725 ruby_guestfs_vgremove, 1);
2726 rb_define_method (c_guestfs, "pvremove",
2727 ruby_guestfs_pvremove, 1);
2728 rb_define_method (c_guestfs, "set_e2label",
2729 ruby_guestfs_set_e2label, 2);
2730 rb_define_method (c_guestfs, "get_e2label",
2731 ruby_guestfs_get_e2label, 1);
2732 rb_define_method (c_guestfs, "set_e2uuid",
2733 ruby_guestfs_set_e2uuid, 2);
2734 rb_define_method (c_guestfs, "get_e2uuid",
2735 ruby_guestfs_get_e2uuid, 1);