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
33 #define RARRAY_LEN(r) (RARRAY((r))->len)
36 static VALUE m_guestfs; /* guestfs module */
37 static VALUE c_guestfs; /* guestfs_h handle */
38 static VALUE e_Error; /* used for all errors */
40 static void ruby_guestfs_free (void *p)
43 guestfs_close ((guestfs_h *) p);
46 static VALUE ruby_guestfs_create (VALUE m)
50 g = guestfs_create ();
52 rb_raise (e_Error, "failed to create guestfs handle");
54 /* Don't print error messages to stderr by default. */
55 guestfs_set_error_handler (g, NULL, NULL);
57 /* Wrap it, and make sure the close function is called when the
60 return Data_Wrap_Struct (c_guestfs, NULL, ruby_guestfs_free, g);
63 static VALUE ruby_guestfs_close (VALUE gv)
66 Data_Get_Struct (gv, guestfs_h, g);
68 ruby_guestfs_free (g);
74 static VALUE ruby_guestfs_launch (VALUE gv)
77 Data_Get_Struct (gv, guestfs_h, g);
79 rb_raise (rb_eArgError, "%s: used handle after closing it", "launch");
84 r = guestfs_launch (g);
86 rb_raise (e_Error, "%s", guestfs_last_error (g));
91 static VALUE ruby_guestfs_wait_ready (VALUE gv)
94 Data_Get_Struct (gv, guestfs_h, g);
96 rb_raise (rb_eArgError, "%s: used handle after closing it", "wait_ready");
101 r = guestfs_wait_ready (g);
103 rb_raise (e_Error, "%s", guestfs_last_error (g));
108 static VALUE ruby_guestfs_kill_subprocess (VALUE gv)
111 Data_Get_Struct (gv, guestfs_h, g);
113 rb_raise (rb_eArgError, "%s: used handle after closing it", "kill_subprocess");
118 r = guestfs_kill_subprocess (g);
120 rb_raise (e_Error, "%s", guestfs_last_error (g));
125 static VALUE ruby_guestfs_add_drive (VALUE gv, VALUE filenamev)
128 Data_Get_Struct (gv, guestfs_h, g);
130 rb_raise (rb_eArgError, "%s: used handle after closing it", "add_drive");
132 const char *filename = StringValueCStr (filenamev);
134 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
135 "filename", "add_drive");
139 r = guestfs_add_drive (g, filename);
141 rb_raise (e_Error, "%s", guestfs_last_error (g));
146 static VALUE ruby_guestfs_add_cdrom (VALUE gv, VALUE filenamev)
149 Data_Get_Struct (gv, guestfs_h, g);
151 rb_raise (rb_eArgError, "%s: used handle after closing it", "add_cdrom");
153 const char *filename = StringValueCStr (filenamev);
155 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
156 "filename", "add_cdrom");
160 r = guestfs_add_cdrom (g, filename);
162 rb_raise (e_Error, "%s", guestfs_last_error (g));
167 static VALUE ruby_guestfs_config (VALUE gv, VALUE qemuparamv, VALUE qemuvaluev)
170 Data_Get_Struct (gv, guestfs_h, g);
172 rb_raise (rb_eArgError, "%s: used handle after closing it", "config");
174 const char *qemuparam = StringValueCStr (qemuparamv);
176 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
177 "qemuparam", "config");
178 const char *qemuvalue = StringValueCStr (qemuvaluev);
182 r = guestfs_config (g, qemuparam, qemuvalue);
184 rb_raise (e_Error, "%s", guestfs_last_error (g));
189 static VALUE ruby_guestfs_set_qemu (VALUE gv, VALUE qemuv)
192 Data_Get_Struct (gv, guestfs_h, g);
194 rb_raise (rb_eArgError, "%s: used handle after closing it", "set_qemu");
196 const char *qemu = StringValueCStr (qemuv);
198 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
203 r = guestfs_set_qemu (g, qemu);
205 rb_raise (e_Error, "%s", guestfs_last_error (g));
210 static VALUE ruby_guestfs_get_qemu (VALUE gv)
213 Data_Get_Struct (gv, guestfs_h, g);
215 rb_raise (rb_eArgError, "%s: used handle after closing it", "get_qemu");
220 r = guestfs_get_qemu (g);
222 rb_raise (e_Error, "%s", guestfs_last_error (g));
224 return rb_str_new2 (r);
227 static VALUE ruby_guestfs_set_path (VALUE gv, VALUE pathv)
230 Data_Get_Struct (gv, guestfs_h, g);
232 rb_raise (rb_eArgError, "%s: used handle after closing it", "set_path");
234 const char *path = StringValueCStr (pathv);
236 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
241 r = guestfs_set_path (g, path);
243 rb_raise (e_Error, "%s", guestfs_last_error (g));
248 static VALUE ruby_guestfs_get_path (VALUE gv)
251 Data_Get_Struct (gv, guestfs_h, g);
253 rb_raise (rb_eArgError, "%s: used handle after closing it", "get_path");
258 r = guestfs_get_path (g);
260 rb_raise (e_Error, "%s", guestfs_last_error (g));
262 return rb_str_new2 (r);
265 static VALUE ruby_guestfs_set_autosync (VALUE gv, VALUE autosyncv)
268 Data_Get_Struct (gv, guestfs_h, g);
270 rb_raise (rb_eArgError, "%s: used handle after closing it", "set_autosync");
272 int autosync = NUM2INT (autosyncv);
276 r = guestfs_set_autosync (g, autosync);
278 rb_raise (e_Error, "%s", guestfs_last_error (g));
283 static VALUE ruby_guestfs_get_autosync (VALUE gv)
286 Data_Get_Struct (gv, guestfs_h, g);
288 rb_raise (rb_eArgError, "%s: used handle after closing it", "get_autosync");
293 r = guestfs_get_autosync (g);
295 rb_raise (e_Error, "%s", guestfs_last_error (g));
300 static VALUE ruby_guestfs_set_verbose (VALUE gv, VALUE verbosev)
303 Data_Get_Struct (gv, guestfs_h, g);
305 rb_raise (rb_eArgError, "%s: used handle after closing it", "set_verbose");
307 int verbose = NUM2INT (verbosev);
311 r = guestfs_set_verbose (g, verbose);
313 rb_raise (e_Error, "%s", guestfs_last_error (g));
318 static VALUE ruby_guestfs_get_verbose (VALUE gv)
321 Data_Get_Struct (gv, guestfs_h, g);
323 rb_raise (rb_eArgError, "%s: used handle after closing it", "get_verbose");
328 r = guestfs_get_verbose (g);
330 rb_raise (e_Error, "%s", guestfs_last_error (g));
335 static VALUE ruby_guestfs_is_ready (VALUE gv)
338 Data_Get_Struct (gv, guestfs_h, g);
340 rb_raise (rb_eArgError, "%s: used handle after closing it", "is_ready");
345 r = guestfs_is_ready (g);
347 rb_raise (e_Error, "%s", guestfs_last_error (g));
352 static VALUE ruby_guestfs_is_config (VALUE gv)
355 Data_Get_Struct (gv, guestfs_h, g);
357 rb_raise (rb_eArgError, "%s: used handle after closing it", "is_config");
362 r = guestfs_is_config (g);
364 rb_raise (e_Error, "%s", guestfs_last_error (g));
369 static VALUE ruby_guestfs_is_launching (VALUE gv)
372 Data_Get_Struct (gv, guestfs_h, g);
374 rb_raise (rb_eArgError, "%s: used handle after closing it", "is_launching");
379 r = guestfs_is_launching (g);
381 rb_raise (e_Error, "%s", guestfs_last_error (g));
386 static VALUE ruby_guestfs_is_busy (VALUE gv)
389 Data_Get_Struct (gv, guestfs_h, g);
391 rb_raise (rb_eArgError, "%s: used handle after closing it", "is_busy");
396 r = guestfs_is_busy (g);
398 rb_raise (e_Error, "%s", guestfs_last_error (g));
403 static VALUE ruby_guestfs_get_state (VALUE gv)
406 Data_Get_Struct (gv, guestfs_h, g);
408 rb_raise (rb_eArgError, "%s: used handle after closing it", "get_state");
413 r = guestfs_get_state (g);
415 rb_raise (e_Error, "%s", guestfs_last_error (g));
420 static VALUE ruby_guestfs_set_busy (VALUE gv)
423 Data_Get_Struct (gv, guestfs_h, g);
425 rb_raise (rb_eArgError, "%s: used handle after closing it", "set_busy");
430 r = guestfs_set_busy (g);
432 rb_raise (e_Error, "%s", guestfs_last_error (g));
437 static VALUE ruby_guestfs_set_ready (VALUE gv)
440 Data_Get_Struct (gv, guestfs_h, g);
442 rb_raise (rb_eArgError, "%s: used handle after closing it", "set_ready");
447 r = guestfs_set_ready (g);
449 rb_raise (e_Error, "%s", guestfs_last_error (g));
454 static VALUE ruby_guestfs_end_busy (VALUE gv)
457 Data_Get_Struct (gv, guestfs_h, g);
459 rb_raise (rb_eArgError, "%s: used handle after closing it", "end_busy");
464 r = guestfs_end_busy (g);
466 rb_raise (e_Error, "%s", guestfs_last_error (g));
471 static VALUE ruby_guestfs_mount (VALUE gv, VALUE devicev, VALUE mountpointv)
474 Data_Get_Struct (gv, guestfs_h, g);
476 rb_raise (rb_eArgError, "%s: used handle after closing it", "mount");
478 const char *device = StringValueCStr (devicev);
480 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
482 const char *mountpoint = StringValueCStr (mountpointv);
484 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
485 "mountpoint", "mount");
489 r = guestfs_mount (g, device, mountpoint);
491 rb_raise (e_Error, "%s", guestfs_last_error (g));
496 static VALUE ruby_guestfs_sync (VALUE gv)
499 Data_Get_Struct (gv, guestfs_h, g);
501 rb_raise (rb_eArgError, "%s: used handle after closing it", "sync");
506 r = guestfs_sync (g);
508 rb_raise (e_Error, "%s", guestfs_last_error (g));
513 static VALUE ruby_guestfs_touch (VALUE gv, VALUE pathv)
516 Data_Get_Struct (gv, guestfs_h, g);
518 rb_raise (rb_eArgError, "%s: used handle after closing it", "touch");
520 const char *path = StringValueCStr (pathv);
522 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
527 r = guestfs_touch (g, path);
529 rb_raise (e_Error, "%s", guestfs_last_error (g));
534 static VALUE ruby_guestfs_cat (VALUE gv, VALUE pathv)
537 Data_Get_Struct (gv, guestfs_h, g);
539 rb_raise (rb_eArgError, "%s: used handle after closing it", "cat");
541 const char *path = StringValueCStr (pathv);
543 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
548 r = guestfs_cat (g, path);
550 rb_raise (e_Error, "%s", guestfs_last_error (g));
552 VALUE rv = rb_str_new2 (r);
557 static VALUE ruby_guestfs_ll (VALUE gv, VALUE directoryv)
560 Data_Get_Struct (gv, guestfs_h, g);
562 rb_raise (rb_eArgError, "%s: used handle after closing it", "ll");
564 const char *directory = StringValueCStr (directoryv);
566 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
571 r = guestfs_ll (g, directory);
573 rb_raise (e_Error, "%s", guestfs_last_error (g));
575 VALUE rv = rb_str_new2 (r);
580 static VALUE ruby_guestfs_ls (VALUE gv, VALUE directoryv)
583 Data_Get_Struct (gv, guestfs_h, g);
585 rb_raise (rb_eArgError, "%s: used handle after closing it", "ls");
587 const char *directory = StringValueCStr (directoryv);
589 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
594 r = guestfs_ls (g, directory);
596 rb_raise (e_Error, "%s", guestfs_last_error (g));
599 for (i = 0; r[i] != NULL; ++i) len++;
600 VALUE rv = rb_ary_new2 (len);
601 for (i = 0; r[i] != NULL; ++i) {
602 rb_ary_push (rv, rb_str_new2 (r[i]));
609 static VALUE ruby_guestfs_list_devices (VALUE gv)
612 Data_Get_Struct (gv, guestfs_h, g);
614 rb_raise (rb_eArgError, "%s: used handle after closing it", "list_devices");
619 r = guestfs_list_devices (g);
621 rb_raise (e_Error, "%s", guestfs_last_error (g));
624 for (i = 0; r[i] != NULL; ++i) len++;
625 VALUE rv = rb_ary_new2 (len);
626 for (i = 0; r[i] != NULL; ++i) {
627 rb_ary_push (rv, rb_str_new2 (r[i]));
634 static VALUE ruby_guestfs_list_partitions (VALUE gv)
637 Data_Get_Struct (gv, guestfs_h, g);
639 rb_raise (rb_eArgError, "%s: used handle after closing it", "list_partitions");
644 r = guestfs_list_partitions (g);
646 rb_raise (e_Error, "%s", guestfs_last_error (g));
649 for (i = 0; r[i] != NULL; ++i) len++;
650 VALUE rv = rb_ary_new2 (len);
651 for (i = 0; r[i] != NULL; ++i) {
652 rb_ary_push (rv, rb_str_new2 (r[i]));
659 static VALUE ruby_guestfs_pvs (VALUE gv)
662 Data_Get_Struct (gv, guestfs_h, g);
664 rb_raise (rb_eArgError, "%s: used handle after closing it", "pvs");
671 rb_raise (e_Error, "%s", guestfs_last_error (g));
674 for (i = 0; r[i] != NULL; ++i) len++;
675 VALUE rv = rb_ary_new2 (len);
676 for (i = 0; r[i] != NULL; ++i) {
677 rb_ary_push (rv, rb_str_new2 (r[i]));
684 static VALUE ruby_guestfs_vgs (VALUE gv)
687 Data_Get_Struct (gv, guestfs_h, g);
689 rb_raise (rb_eArgError, "%s: used handle after closing it", "vgs");
696 rb_raise (e_Error, "%s", guestfs_last_error (g));
699 for (i = 0; r[i] != NULL; ++i) len++;
700 VALUE rv = rb_ary_new2 (len);
701 for (i = 0; r[i] != NULL; ++i) {
702 rb_ary_push (rv, rb_str_new2 (r[i]));
709 static VALUE ruby_guestfs_lvs (VALUE gv)
712 Data_Get_Struct (gv, guestfs_h, g);
714 rb_raise (rb_eArgError, "%s: used handle after closing it", "lvs");
721 rb_raise (e_Error, "%s", guestfs_last_error (g));
724 for (i = 0; r[i] != NULL; ++i) len++;
725 VALUE rv = rb_ary_new2 (len);
726 for (i = 0; r[i] != NULL; ++i) {
727 rb_ary_push (rv, rb_str_new2 (r[i]));
734 static VALUE ruby_guestfs_pvs_full (VALUE gv)
737 Data_Get_Struct (gv, guestfs_h, g);
739 rb_raise (rb_eArgError, "%s: used handle after closing it", "pvs_full");
742 struct guestfs_lvm_pv_list *r;
744 r = guestfs_pvs_full (g);
746 rb_raise (e_Error, "%s", guestfs_last_error (g));
748 VALUE rv = rb_ary_new2 (r->len);
750 for (i = 0; i < r->len; ++i) {
751 VALUE hv = rb_hash_new ();
752 rb_hash_aset (rv, rb_str_new2 ("pv_name"), rb_str_new2 (r->val[i].pv_name));
753 rb_hash_aset (rv, rb_str_new2 ("pv_uuid"), rb_str_new (r->val[i].pv_uuid, 32));
754 rb_hash_aset (rv, rb_str_new2 ("pv_fmt"), rb_str_new2 (r->val[i].pv_fmt));
755 rb_hash_aset (rv, rb_str_new2 ("pv_size"), ULL2NUM (r->val[i].pv_size));
756 rb_hash_aset (rv, rb_str_new2 ("dev_size"), ULL2NUM (r->val[i].dev_size));
757 rb_hash_aset (rv, rb_str_new2 ("pv_free"), ULL2NUM (r->val[i].pv_free));
758 rb_hash_aset (rv, rb_str_new2 ("pv_used"), ULL2NUM (r->val[i].pv_used));
759 rb_hash_aset (rv, rb_str_new2 ("pv_attr"), rb_str_new2 (r->val[i].pv_attr));
760 rb_hash_aset (rv, rb_str_new2 ("pv_pe_count"), ULL2NUM (r->val[i].pv_pe_count));
761 rb_hash_aset (rv, rb_str_new2 ("pv_pe_alloc_count"), ULL2NUM (r->val[i].pv_pe_alloc_count));
762 rb_hash_aset (rv, rb_str_new2 ("pv_tags"), rb_str_new2 (r->val[i].pv_tags));
763 rb_hash_aset (rv, rb_str_new2 ("pe_start"), ULL2NUM (r->val[i].pe_start));
764 rb_hash_aset (rv, rb_str_new2 ("pv_mda_count"), ULL2NUM (r->val[i].pv_mda_count));
765 rb_hash_aset (rv, rb_str_new2 ("pv_mda_free"), ULL2NUM (r->val[i].pv_mda_free));
766 rb_ary_push (rv, hv);
768 guestfs_free_lvm_pv_list (r);
772 static VALUE ruby_guestfs_vgs_full (VALUE gv)
775 Data_Get_Struct (gv, guestfs_h, g);
777 rb_raise (rb_eArgError, "%s: used handle after closing it", "vgs_full");
780 struct guestfs_lvm_vg_list *r;
782 r = guestfs_vgs_full (g);
784 rb_raise (e_Error, "%s", guestfs_last_error (g));
786 VALUE rv = rb_ary_new2 (r->len);
788 for (i = 0; i < r->len; ++i) {
789 VALUE hv = rb_hash_new ();
790 rb_hash_aset (rv, rb_str_new2 ("vg_name"), rb_str_new2 (r->val[i].vg_name));
791 rb_hash_aset (rv, rb_str_new2 ("vg_uuid"), rb_str_new (r->val[i].vg_uuid, 32));
792 rb_hash_aset (rv, rb_str_new2 ("vg_fmt"), rb_str_new2 (r->val[i].vg_fmt));
793 rb_hash_aset (rv, rb_str_new2 ("vg_attr"), rb_str_new2 (r->val[i].vg_attr));
794 rb_hash_aset (rv, rb_str_new2 ("vg_size"), ULL2NUM (r->val[i].vg_size));
795 rb_hash_aset (rv, rb_str_new2 ("vg_free"), ULL2NUM (r->val[i].vg_free));
796 rb_hash_aset (rv, rb_str_new2 ("vg_sysid"), rb_str_new2 (r->val[i].vg_sysid));
797 rb_hash_aset (rv, rb_str_new2 ("vg_extent_size"), ULL2NUM (r->val[i].vg_extent_size));
798 rb_hash_aset (rv, rb_str_new2 ("vg_extent_count"), ULL2NUM (r->val[i].vg_extent_count));
799 rb_hash_aset (rv, rb_str_new2 ("vg_free_count"), ULL2NUM (r->val[i].vg_free_count));
800 rb_hash_aset (rv, rb_str_new2 ("max_lv"), ULL2NUM (r->val[i].max_lv));
801 rb_hash_aset (rv, rb_str_new2 ("max_pv"), ULL2NUM (r->val[i].max_pv));
802 rb_hash_aset (rv, rb_str_new2 ("pv_count"), ULL2NUM (r->val[i].pv_count));
803 rb_hash_aset (rv, rb_str_new2 ("lv_count"), ULL2NUM (r->val[i].lv_count));
804 rb_hash_aset (rv, rb_str_new2 ("snap_count"), ULL2NUM (r->val[i].snap_count));
805 rb_hash_aset (rv, rb_str_new2 ("vg_seqno"), ULL2NUM (r->val[i].vg_seqno));
806 rb_hash_aset (rv, rb_str_new2 ("vg_tags"), rb_str_new2 (r->val[i].vg_tags));
807 rb_hash_aset (rv, rb_str_new2 ("vg_mda_count"), ULL2NUM (r->val[i].vg_mda_count));
808 rb_hash_aset (rv, rb_str_new2 ("vg_mda_free"), ULL2NUM (r->val[i].vg_mda_free));
809 rb_ary_push (rv, hv);
811 guestfs_free_lvm_vg_list (r);
815 static VALUE ruby_guestfs_lvs_full (VALUE gv)
818 Data_Get_Struct (gv, guestfs_h, g);
820 rb_raise (rb_eArgError, "%s: used handle after closing it", "lvs_full");
823 struct guestfs_lvm_lv_list *r;
825 r = guestfs_lvs_full (g);
827 rb_raise (e_Error, "%s", guestfs_last_error (g));
829 VALUE rv = rb_ary_new2 (r->len);
831 for (i = 0; i < r->len; ++i) {
832 VALUE hv = rb_hash_new ();
833 rb_hash_aset (rv, rb_str_new2 ("lv_name"), rb_str_new2 (r->val[i].lv_name));
834 rb_hash_aset (rv, rb_str_new2 ("lv_uuid"), rb_str_new (r->val[i].lv_uuid, 32));
835 rb_hash_aset (rv, rb_str_new2 ("lv_attr"), rb_str_new2 (r->val[i].lv_attr));
836 rb_hash_aset (rv, rb_str_new2 ("lv_major"), ULL2NUM (r->val[i].lv_major));
837 rb_hash_aset (rv, rb_str_new2 ("lv_minor"), ULL2NUM (r->val[i].lv_minor));
838 rb_hash_aset (rv, rb_str_new2 ("lv_kernel_major"), ULL2NUM (r->val[i].lv_kernel_major));
839 rb_hash_aset (rv, rb_str_new2 ("lv_kernel_minor"), ULL2NUM (r->val[i].lv_kernel_minor));
840 rb_hash_aset (rv, rb_str_new2 ("lv_size"), ULL2NUM (r->val[i].lv_size));
841 rb_hash_aset (rv, rb_str_new2 ("seg_count"), ULL2NUM (r->val[i].seg_count));
842 rb_hash_aset (rv, rb_str_new2 ("origin"), rb_str_new2 (r->val[i].origin));
843 rb_hash_aset (rv, rb_str_new2 ("snap_percent"), rb_dbl2big (r->val[i].snap_percent));
844 rb_hash_aset (rv, rb_str_new2 ("copy_percent"), rb_dbl2big (r->val[i].copy_percent));
845 rb_hash_aset (rv, rb_str_new2 ("move_pv"), rb_str_new2 (r->val[i].move_pv));
846 rb_hash_aset (rv, rb_str_new2 ("lv_tags"), rb_str_new2 (r->val[i].lv_tags));
847 rb_hash_aset (rv, rb_str_new2 ("mirror_log"), rb_str_new2 (r->val[i].mirror_log));
848 rb_hash_aset (rv, rb_str_new2 ("modules"), rb_str_new2 (r->val[i].modules));
849 rb_ary_push (rv, hv);
851 guestfs_free_lvm_lv_list (r);
855 static VALUE ruby_guestfs_read_lines (VALUE gv, VALUE pathv)
858 Data_Get_Struct (gv, guestfs_h, g);
860 rb_raise (rb_eArgError, "%s: used handle after closing it", "read_lines");
862 const char *path = StringValueCStr (pathv);
864 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
865 "path", "read_lines");
869 r = guestfs_read_lines (g, path);
871 rb_raise (e_Error, "%s", guestfs_last_error (g));
874 for (i = 0; r[i] != NULL; ++i) len++;
875 VALUE rv = rb_ary_new2 (len);
876 for (i = 0; r[i] != NULL; ++i) {
877 rb_ary_push (rv, rb_str_new2 (r[i]));
884 static VALUE ruby_guestfs_aug_init (VALUE gv, VALUE rootv, VALUE flagsv)
887 Data_Get_Struct (gv, guestfs_h, g);
889 rb_raise (rb_eArgError, "%s: used handle after closing it", "aug_init");
891 const char *root = StringValueCStr (rootv);
893 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
895 int flags = NUM2INT (flagsv);
899 r = guestfs_aug_init (g, root, flags);
901 rb_raise (e_Error, "%s", guestfs_last_error (g));
906 static VALUE ruby_guestfs_aug_close (VALUE gv)
909 Data_Get_Struct (gv, guestfs_h, g);
911 rb_raise (rb_eArgError, "%s: used handle after closing it", "aug_close");
916 r = guestfs_aug_close (g);
918 rb_raise (e_Error, "%s", guestfs_last_error (g));
923 static VALUE ruby_guestfs_aug_defvar (VALUE gv, VALUE namev, VALUE exprv)
926 Data_Get_Struct (gv, guestfs_h, g);
928 rb_raise (rb_eArgError, "%s: used handle after closing it", "aug_defvar");
930 const char *name = StringValueCStr (namev);
932 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
933 "name", "aug_defvar");
934 const char *expr = StringValueCStr (exprv);
938 r = guestfs_aug_defvar (g, name, expr);
940 rb_raise (e_Error, "%s", guestfs_last_error (g));
945 static VALUE ruby_guestfs_aug_defnode (VALUE gv, VALUE namev, VALUE exprv, VALUE valv)
948 Data_Get_Struct (gv, guestfs_h, g);
950 rb_raise (rb_eArgError, "%s: used handle after closing it", "aug_defnode");
952 const char *name = StringValueCStr (namev);
954 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
955 "name", "aug_defnode");
956 const char *expr = StringValueCStr (exprv);
958 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
959 "expr", "aug_defnode");
960 const char *val = StringValueCStr (valv);
962 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
963 "val", "aug_defnode");
965 struct guestfs_int_bool *r;
967 r = guestfs_aug_defnode (g, name, expr, val);
969 rb_raise (e_Error, "%s", guestfs_last_error (g));
971 VALUE rv = rb_ary_new2 (2);
972 rb_ary_push (rv, INT2NUM (r->i));
973 rb_ary_push (rv, INT2NUM (r->b));
974 guestfs_free_int_bool (r);
978 static VALUE ruby_guestfs_aug_get (VALUE gv, VALUE pathv)
981 Data_Get_Struct (gv, guestfs_h, g);
983 rb_raise (rb_eArgError, "%s: used handle after closing it", "aug_get");
985 const char *path = StringValueCStr (pathv);
987 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
992 r = guestfs_aug_get (g, path);
994 rb_raise (e_Error, "%s", guestfs_last_error (g));
996 VALUE rv = rb_str_new2 (r);
1001 static VALUE ruby_guestfs_aug_set (VALUE gv, VALUE pathv, VALUE valv)
1004 Data_Get_Struct (gv, guestfs_h, g);
1006 rb_raise (rb_eArgError, "%s: used handle after closing it", "aug_set");
1008 const char *path = StringValueCStr (pathv);
1010 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1012 const char *val = StringValueCStr (valv);
1014 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1019 r = guestfs_aug_set (g, path, val);
1021 rb_raise (e_Error, "%s", guestfs_last_error (g));
1026 static VALUE ruby_guestfs_aug_insert (VALUE gv, VALUE pathv, VALUE labelv, VALUE beforev)
1029 Data_Get_Struct (gv, guestfs_h, g);
1031 rb_raise (rb_eArgError, "%s: used handle after closing it", "aug_insert");
1033 const char *path = StringValueCStr (pathv);
1035 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1036 "path", "aug_insert");
1037 const char *label = StringValueCStr (labelv);
1039 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1040 "label", "aug_insert");
1041 int before = NUM2INT (beforev);
1045 r = guestfs_aug_insert (g, path, label, before);
1047 rb_raise (e_Error, "%s", guestfs_last_error (g));
1052 static VALUE ruby_guestfs_aug_rm (VALUE gv, VALUE pathv)
1055 Data_Get_Struct (gv, guestfs_h, g);
1057 rb_raise (rb_eArgError, "%s: used handle after closing it", "aug_rm");
1059 const char *path = StringValueCStr (pathv);
1061 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1066 r = guestfs_aug_rm (g, path);
1068 rb_raise (e_Error, "%s", guestfs_last_error (g));
1073 static VALUE ruby_guestfs_aug_mv (VALUE gv, VALUE srcv, VALUE destv)
1076 Data_Get_Struct (gv, guestfs_h, g);
1078 rb_raise (rb_eArgError, "%s: used handle after closing it", "aug_mv");
1080 const char *src = StringValueCStr (srcv);
1082 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1084 const char *dest = StringValueCStr (destv);
1086 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1091 r = guestfs_aug_mv (g, src, dest);
1093 rb_raise (e_Error, "%s", guestfs_last_error (g));
1098 static VALUE ruby_guestfs_aug_match (VALUE gv, VALUE pathv)
1101 Data_Get_Struct (gv, guestfs_h, g);
1103 rb_raise (rb_eArgError, "%s: used handle after closing it", "aug_match");
1105 const char *path = StringValueCStr (pathv);
1107 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1108 "path", "aug_match");
1112 r = guestfs_aug_match (g, path);
1114 rb_raise (e_Error, "%s", guestfs_last_error (g));
1117 for (i = 0; r[i] != NULL; ++i) len++;
1118 VALUE rv = rb_ary_new2 (len);
1119 for (i = 0; r[i] != NULL; ++i) {
1120 rb_ary_push (rv, rb_str_new2 (r[i]));
1127 static VALUE ruby_guestfs_aug_save (VALUE gv)
1130 Data_Get_Struct (gv, guestfs_h, g);
1132 rb_raise (rb_eArgError, "%s: used handle after closing it", "aug_save");
1137 r = guestfs_aug_save (g);
1139 rb_raise (e_Error, "%s", guestfs_last_error (g));
1144 static VALUE ruby_guestfs_aug_load (VALUE gv)
1147 Data_Get_Struct (gv, guestfs_h, g);
1149 rb_raise (rb_eArgError, "%s: used handle after closing it", "aug_load");
1154 r = guestfs_aug_load (g);
1156 rb_raise (e_Error, "%s", guestfs_last_error (g));
1161 static VALUE ruby_guestfs_aug_ls (VALUE gv, VALUE pathv)
1164 Data_Get_Struct (gv, guestfs_h, g);
1166 rb_raise (rb_eArgError, "%s: used handle after closing it", "aug_ls");
1168 const char *path = StringValueCStr (pathv);
1170 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1175 r = guestfs_aug_ls (g, path);
1177 rb_raise (e_Error, "%s", guestfs_last_error (g));
1180 for (i = 0; r[i] != NULL; ++i) len++;
1181 VALUE rv = rb_ary_new2 (len);
1182 for (i = 0; r[i] != NULL; ++i) {
1183 rb_ary_push (rv, rb_str_new2 (r[i]));
1190 static VALUE ruby_guestfs_rm (VALUE gv, VALUE pathv)
1193 Data_Get_Struct (gv, guestfs_h, g);
1195 rb_raise (rb_eArgError, "%s: used handle after closing it", "rm");
1197 const char *path = StringValueCStr (pathv);
1199 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1204 r = guestfs_rm (g, path);
1206 rb_raise (e_Error, "%s", guestfs_last_error (g));
1211 static VALUE ruby_guestfs_rmdir (VALUE gv, VALUE pathv)
1214 Data_Get_Struct (gv, guestfs_h, g);
1216 rb_raise (rb_eArgError, "%s: used handle after closing it", "rmdir");
1218 const char *path = StringValueCStr (pathv);
1220 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1225 r = guestfs_rmdir (g, path);
1227 rb_raise (e_Error, "%s", guestfs_last_error (g));
1232 static VALUE ruby_guestfs_rm_rf (VALUE gv, VALUE pathv)
1235 Data_Get_Struct (gv, guestfs_h, g);
1237 rb_raise (rb_eArgError, "%s: used handle after closing it", "rm_rf");
1239 const char *path = StringValueCStr (pathv);
1241 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1246 r = guestfs_rm_rf (g, path);
1248 rb_raise (e_Error, "%s", guestfs_last_error (g));
1253 static VALUE ruby_guestfs_mkdir (VALUE gv, VALUE pathv)
1256 Data_Get_Struct (gv, guestfs_h, g);
1258 rb_raise (rb_eArgError, "%s: used handle after closing it", "mkdir");
1260 const char *path = StringValueCStr (pathv);
1262 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1267 r = guestfs_mkdir (g, path);
1269 rb_raise (e_Error, "%s", guestfs_last_error (g));
1274 static VALUE ruby_guestfs_mkdir_p (VALUE gv, VALUE pathv)
1277 Data_Get_Struct (gv, guestfs_h, g);
1279 rb_raise (rb_eArgError, "%s: used handle after closing it", "mkdir_p");
1281 const char *path = StringValueCStr (pathv);
1283 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1288 r = guestfs_mkdir_p (g, path);
1290 rb_raise (e_Error, "%s", guestfs_last_error (g));
1295 static VALUE ruby_guestfs_chmod (VALUE gv, VALUE modev, VALUE pathv)
1298 Data_Get_Struct (gv, guestfs_h, g);
1300 rb_raise (rb_eArgError, "%s: used handle after closing it", "chmod");
1302 int mode = NUM2INT (modev);
1303 const char *path = StringValueCStr (pathv);
1305 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1310 r = guestfs_chmod (g, mode, path);
1312 rb_raise (e_Error, "%s", guestfs_last_error (g));
1317 static VALUE ruby_guestfs_chown (VALUE gv, VALUE ownerv, VALUE groupv, VALUE pathv)
1320 Data_Get_Struct (gv, guestfs_h, g);
1322 rb_raise (rb_eArgError, "%s: used handle after closing it", "chown");
1324 int owner = NUM2INT (ownerv);
1325 int group = NUM2INT (groupv);
1326 const char *path = StringValueCStr (pathv);
1328 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1333 r = guestfs_chown (g, owner, group, path);
1335 rb_raise (e_Error, "%s", guestfs_last_error (g));
1340 static VALUE ruby_guestfs_exists (VALUE gv, VALUE pathv)
1343 Data_Get_Struct (gv, guestfs_h, g);
1345 rb_raise (rb_eArgError, "%s: used handle after closing it", "exists");
1347 const char *path = StringValueCStr (pathv);
1349 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1354 r = guestfs_exists (g, path);
1356 rb_raise (e_Error, "%s", guestfs_last_error (g));
1361 static VALUE ruby_guestfs_is_file (VALUE gv, VALUE pathv)
1364 Data_Get_Struct (gv, guestfs_h, g);
1366 rb_raise (rb_eArgError, "%s: used handle after closing it", "is_file");
1368 const char *path = StringValueCStr (pathv);
1370 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1375 r = guestfs_is_file (g, path);
1377 rb_raise (e_Error, "%s", guestfs_last_error (g));
1382 static VALUE ruby_guestfs_is_dir (VALUE gv, VALUE pathv)
1385 Data_Get_Struct (gv, guestfs_h, g);
1387 rb_raise (rb_eArgError, "%s: used handle after closing it", "is_dir");
1389 const char *path = StringValueCStr (pathv);
1391 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1396 r = guestfs_is_dir (g, path);
1398 rb_raise (e_Error, "%s", guestfs_last_error (g));
1403 static VALUE ruby_guestfs_pvcreate (VALUE gv, VALUE devicev)
1406 Data_Get_Struct (gv, guestfs_h, g);
1408 rb_raise (rb_eArgError, "%s: used handle after closing it", "pvcreate");
1410 const char *device = StringValueCStr (devicev);
1412 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1413 "device", "pvcreate");
1417 r = guestfs_pvcreate (g, device);
1419 rb_raise (e_Error, "%s", guestfs_last_error (g));
1424 static VALUE ruby_guestfs_vgcreate (VALUE gv, VALUE volgroupv, VALUE physvolsv)
1427 Data_Get_Struct (gv, guestfs_h, g);
1429 rb_raise (rb_eArgError, "%s: used handle after closing it", "vgcreate");
1431 const char *volgroup = StringValueCStr (volgroupv);
1433 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1434 "volgroup", "vgcreate");
1437 len = RARRAY_LEN (physvolsv);
1438 physvols = guestfs_safe_malloc (g, sizeof (char *) * (len+1));
1439 for (i = 0; i < len; ++i) {
1440 VALUE v = rb_ary_entry (physvolsv, i);
1441 physvols[i] = StringValueCStr (v);
1443 physvols[len] = NULL;
1448 r = guestfs_vgcreate (g, volgroup, physvols);
1451 rb_raise (e_Error, "%s", guestfs_last_error (g));
1456 static VALUE ruby_guestfs_lvcreate (VALUE gv, VALUE logvolv, VALUE volgroupv, VALUE mbytesv)
1459 Data_Get_Struct (gv, guestfs_h, g);
1461 rb_raise (rb_eArgError, "%s: used handle after closing it", "lvcreate");
1463 const char *logvol = StringValueCStr (logvolv);
1465 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1466 "logvol", "lvcreate");
1467 const char *volgroup = StringValueCStr (volgroupv);
1469 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1470 "volgroup", "lvcreate");
1471 int mbytes = NUM2INT (mbytesv);
1475 r = guestfs_lvcreate (g, logvol, volgroup, mbytes);
1477 rb_raise (e_Error, "%s", guestfs_last_error (g));
1482 static VALUE ruby_guestfs_mkfs (VALUE gv, VALUE fstypev, VALUE devicev)
1485 Data_Get_Struct (gv, guestfs_h, g);
1487 rb_raise (rb_eArgError, "%s: used handle after closing it", "mkfs");
1489 const char *fstype = StringValueCStr (fstypev);
1491 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1493 const char *device = StringValueCStr (devicev);
1495 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1500 r = guestfs_mkfs (g, fstype, device);
1502 rb_raise (e_Error, "%s", guestfs_last_error (g));
1507 static VALUE ruby_guestfs_sfdisk (VALUE gv, VALUE devicev, VALUE cylsv, VALUE headsv, VALUE sectorsv, VALUE linesv)
1510 Data_Get_Struct (gv, guestfs_h, g);
1512 rb_raise (rb_eArgError, "%s: used handle after closing it", "sfdisk");
1514 const char *device = StringValueCStr (devicev);
1516 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1517 "device", "sfdisk");
1518 int cyls = NUM2INT (cylsv);
1519 int heads = NUM2INT (headsv);
1520 int sectors = NUM2INT (sectorsv);
1523 len = RARRAY_LEN (linesv);
1524 lines = guestfs_safe_malloc (g, sizeof (char *) * (len+1));
1525 for (i = 0; i < len; ++i) {
1526 VALUE v = rb_ary_entry (linesv, i);
1527 lines[i] = StringValueCStr (v);
1534 r = guestfs_sfdisk (g, device, cyls, heads, sectors, lines);
1537 rb_raise (e_Error, "%s", guestfs_last_error (g));
1542 static VALUE ruby_guestfs_write_file (VALUE gv, VALUE pathv, VALUE contentv, VALUE sizev)
1545 Data_Get_Struct (gv, guestfs_h, g);
1547 rb_raise (rb_eArgError, "%s: used handle after closing it", "write_file");
1549 const char *path = StringValueCStr (pathv);
1551 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1552 "path", "write_file");
1553 const char *content = StringValueCStr (contentv);
1555 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1556 "content", "write_file");
1557 int size = NUM2INT (sizev);
1561 r = guestfs_write_file (g, path, content, size);
1563 rb_raise (e_Error, "%s", guestfs_last_error (g));
1568 static VALUE ruby_guestfs_umount (VALUE gv, VALUE pathordevicev)
1571 Data_Get_Struct (gv, guestfs_h, g);
1573 rb_raise (rb_eArgError, "%s: used handle after closing it", "umount");
1575 const char *pathordevice = StringValueCStr (pathordevicev);
1577 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1578 "pathordevice", "umount");
1582 r = guestfs_umount (g, pathordevice);
1584 rb_raise (e_Error, "%s", guestfs_last_error (g));
1589 static VALUE ruby_guestfs_mounts (VALUE gv)
1592 Data_Get_Struct (gv, guestfs_h, g);
1594 rb_raise (rb_eArgError, "%s: used handle after closing it", "mounts");
1599 r = guestfs_mounts (g);
1601 rb_raise (e_Error, "%s", guestfs_last_error (g));
1604 for (i = 0; r[i] != NULL; ++i) len++;
1605 VALUE rv = rb_ary_new2 (len);
1606 for (i = 0; r[i] != NULL; ++i) {
1607 rb_ary_push (rv, rb_str_new2 (r[i]));
1614 static VALUE ruby_guestfs_umount_all (VALUE gv)
1617 Data_Get_Struct (gv, guestfs_h, g);
1619 rb_raise (rb_eArgError, "%s: used handle after closing it", "umount_all");
1624 r = guestfs_umount_all (g);
1626 rb_raise (e_Error, "%s", guestfs_last_error (g));
1631 static VALUE ruby_guestfs_lvm_remove_all (VALUE gv)
1634 Data_Get_Struct (gv, guestfs_h, g);
1636 rb_raise (rb_eArgError, "%s: used handle after closing it", "lvm_remove_all");
1641 r = guestfs_lvm_remove_all (g);
1643 rb_raise (e_Error, "%s", guestfs_last_error (g));
1648 static VALUE ruby_guestfs_file (VALUE gv, VALUE pathv)
1651 Data_Get_Struct (gv, guestfs_h, g);
1653 rb_raise (rb_eArgError, "%s: used handle after closing it", "file");
1655 const char *path = StringValueCStr (pathv);
1657 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1662 r = guestfs_file (g, path);
1664 rb_raise (e_Error, "%s", guestfs_last_error (g));
1666 VALUE rv = rb_str_new2 (r);
1671 static VALUE ruby_guestfs_command (VALUE gv, VALUE argumentsv)
1674 Data_Get_Struct (gv, guestfs_h, g);
1676 rb_raise (rb_eArgError, "%s: used handle after closing it", "command");
1680 len = RARRAY_LEN (argumentsv);
1681 arguments = guestfs_safe_malloc (g, sizeof (char *) * (len+1));
1682 for (i = 0; i < len; ++i) {
1683 VALUE v = rb_ary_entry (argumentsv, i);
1684 arguments[i] = StringValueCStr (v);
1686 arguments[len] = NULL;
1691 r = guestfs_command (g, arguments);
1694 rb_raise (e_Error, "%s", guestfs_last_error (g));
1696 VALUE rv = rb_str_new2 (r);
1701 static VALUE ruby_guestfs_command_lines (VALUE gv, VALUE argumentsv)
1704 Data_Get_Struct (gv, guestfs_h, g);
1706 rb_raise (rb_eArgError, "%s: used handle after closing it", "command_lines");
1710 len = RARRAY_LEN (argumentsv);
1711 arguments = guestfs_safe_malloc (g, sizeof (char *) * (len+1));
1712 for (i = 0; i < len; ++i) {
1713 VALUE v = rb_ary_entry (argumentsv, i);
1714 arguments[i] = StringValueCStr (v);
1716 arguments[len] = NULL;
1721 r = guestfs_command_lines (g, arguments);
1724 rb_raise (e_Error, "%s", guestfs_last_error (g));
1727 for (i = 0; r[i] != NULL; ++i) len++;
1728 VALUE rv = rb_ary_new2 (len);
1729 for (i = 0; r[i] != NULL; ++i) {
1730 rb_ary_push (rv, rb_str_new2 (r[i]));
1737 static VALUE ruby_guestfs_stat (VALUE gv, VALUE pathv)
1740 Data_Get_Struct (gv, guestfs_h, g);
1742 rb_raise (rb_eArgError, "%s: used handle after closing it", "stat");
1744 const char *path = StringValueCStr (pathv);
1746 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1749 struct guestfs_stat *r;
1751 r = guestfs_stat (g, path);
1753 rb_raise (e_Error, "%s", guestfs_last_error (g));
1755 VALUE rv = rb_hash_new ();
1756 rb_hash_aset (rv, rb_str_new2 ("dev"), ULL2NUM (r->dev));
1757 rb_hash_aset (rv, rb_str_new2 ("ino"), ULL2NUM (r->ino));
1758 rb_hash_aset (rv, rb_str_new2 ("mode"), ULL2NUM (r->mode));
1759 rb_hash_aset (rv, rb_str_new2 ("nlink"), ULL2NUM (r->nlink));
1760 rb_hash_aset (rv, rb_str_new2 ("uid"), ULL2NUM (r->uid));
1761 rb_hash_aset (rv, rb_str_new2 ("gid"), ULL2NUM (r->gid));
1762 rb_hash_aset (rv, rb_str_new2 ("rdev"), ULL2NUM (r->rdev));
1763 rb_hash_aset (rv, rb_str_new2 ("size"), ULL2NUM (r->size));
1764 rb_hash_aset (rv, rb_str_new2 ("blksize"), ULL2NUM (r->blksize));
1765 rb_hash_aset (rv, rb_str_new2 ("blocks"), ULL2NUM (r->blocks));
1766 rb_hash_aset (rv, rb_str_new2 ("atime"), ULL2NUM (r->atime));
1767 rb_hash_aset (rv, rb_str_new2 ("mtime"), ULL2NUM (r->mtime));
1768 rb_hash_aset (rv, rb_str_new2 ("ctime"), ULL2NUM (r->ctime));
1773 static VALUE ruby_guestfs_lstat (VALUE gv, VALUE pathv)
1776 Data_Get_Struct (gv, guestfs_h, g);
1778 rb_raise (rb_eArgError, "%s: used handle after closing it", "lstat");
1780 const char *path = StringValueCStr (pathv);
1782 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1785 struct guestfs_stat *r;
1787 r = guestfs_lstat (g, path);
1789 rb_raise (e_Error, "%s", guestfs_last_error (g));
1791 VALUE rv = rb_hash_new ();
1792 rb_hash_aset (rv, rb_str_new2 ("dev"), ULL2NUM (r->dev));
1793 rb_hash_aset (rv, rb_str_new2 ("ino"), ULL2NUM (r->ino));
1794 rb_hash_aset (rv, rb_str_new2 ("mode"), ULL2NUM (r->mode));
1795 rb_hash_aset (rv, rb_str_new2 ("nlink"), ULL2NUM (r->nlink));
1796 rb_hash_aset (rv, rb_str_new2 ("uid"), ULL2NUM (r->uid));
1797 rb_hash_aset (rv, rb_str_new2 ("gid"), ULL2NUM (r->gid));
1798 rb_hash_aset (rv, rb_str_new2 ("rdev"), ULL2NUM (r->rdev));
1799 rb_hash_aset (rv, rb_str_new2 ("size"), ULL2NUM (r->size));
1800 rb_hash_aset (rv, rb_str_new2 ("blksize"), ULL2NUM (r->blksize));
1801 rb_hash_aset (rv, rb_str_new2 ("blocks"), ULL2NUM (r->blocks));
1802 rb_hash_aset (rv, rb_str_new2 ("atime"), ULL2NUM (r->atime));
1803 rb_hash_aset (rv, rb_str_new2 ("mtime"), ULL2NUM (r->mtime));
1804 rb_hash_aset (rv, rb_str_new2 ("ctime"), ULL2NUM (r->ctime));
1809 static VALUE ruby_guestfs_statvfs (VALUE gv, VALUE pathv)
1812 Data_Get_Struct (gv, guestfs_h, g);
1814 rb_raise (rb_eArgError, "%s: used handle after closing it", "statvfs");
1816 const char *path = StringValueCStr (pathv);
1818 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1821 struct guestfs_statvfs *r;
1823 r = guestfs_statvfs (g, path);
1825 rb_raise (e_Error, "%s", guestfs_last_error (g));
1827 VALUE rv = rb_hash_new ();
1828 rb_hash_aset (rv, rb_str_new2 ("bsize"), ULL2NUM (r->bsize));
1829 rb_hash_aset (rv, rb_str_new2 ("frsize"), ULL2NUM (r->frsize));
1830 rb_hash_aset (rv, rb_str_new2 ("blocks"), ULL2NUM (r->blocks));
1831 rb_hash_aset (rv, rb_str_new2 ("bfree"), ULL2NUM (r->bfree));
1832 rb_hash_aset (rv, rb_str_new2 ("bavail"), ULL2NUM (r->bavail));
1833 rb_hash_aset (rv, rb_str_new2 ("files"), ULL2NUM (r->files));
1834 rb_hash_aset (rv, rb_str_new2 ("ffree"), ULL2NUM (r->ffree));
1835 rb_hash_aset (rv, rb_str_new2 ("favail"), ULL2NUM (r->favail));
1836 rb_hash_aset (rv, rb_str_new2 ("fsid"), ULL2NUM (r->fsid));
1837 rb_hash_aset (rv, rb_str_new2 ("flag"), ULL2NUM (r->flag));
1838 rb_hash_aset (rv, rb_str_new2 ("namemax"), ULL2NUM (r->namemax));
1843 static VALUE ruby_guestfs_tune2fs_l (VALUE gv, VALUE devicev)
1846 Data_Get_Struct (gv, guestfs_h, g);
1848 rb_raise (rb_eArgError, "%s: used handle after closing it", "tune2fs_l");
1850 const char *device = StringValueCStr (devicev);
1852 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1853 "device", "tune2fs_l");
1857 r = guestfs_tune2fs_l (g, device);
1859 rb_raise (e_Error, "%s", guestfs_last_error (g));
1861 VALUE rv = rb_hash_new ();
1863 for (i = 0; r[i] != NULL; i+=2) {
1864 rb_hash_aset (rv, rb_str_new2 (r[i]), rb_str_new2 (r[i+1]));
1872 static VALUE ruby_guestfs_blockdev_setro (VALUE gv, VALUE devicev)
1875 Data_Get_Struct (gv, guestfs_h, g);
1877 rb_raise (rb_eArgError, "%s: used handle after closing it", "blockdev_setro");
1879 const char *device = StringValueCStr (devicev);
1881 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1882 "device", "blockdev_setro");
1886 r = guestfs_blockdev_setro (g, device);
1888 rb_raise (e_Error, "%s", guestfs_last_error (g));
1893 static VALUE ruby_guestfs_blockdev_setrw (VALUE gv, VALUE devicev)
1896 Data_Get_Struct (gv, guestfs_h, g);
1898 rb_raise (rb_eArgError, "%s: used handle after closing it", "blockdev_setrw");
1900 const char *device = StringValueCStr (devicev);
1902 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1903 "device", "blockdev_setrw");
1907 r = guestfs_blockdev_setrw (g, device);
1909 rb_raise (e_Error, "%s", guestfs_last_error (g));
1914 static VALUE ruby_guestfs_blockdev_getro (VALUE gv, VALUE devicev)
1917 Data_Get_Struct (gv, guestfs_h, g);
1919 rb_raise (rb_eArgError, "%s: used handle after closing it", "blockdev_getro");
1921 const char *device = StringValueCStr (devicev);
1923 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1924 "device", "blockdev_getro");
1928 r = guestfs_blockdev_getro (g, device);
1930 rb_raise (e_Error, "%s", guestfs_last_error (g));
1935 static VALUE ruby_guestfs_blockdev_getss (VALUE gv, VALUE devicev)
1938 Data_Get_Struct (gv, guestfs_h, g);
1940 rb_raise (rb_eArgError, "%s: used handle after closing it", "blockdev_getss");
1942 const char *device = StringValueCStr (devicev);
1944 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1945 "device", "blockdev_getss");
1949 r = guestfs_blockdev_getss (g, device);
1951 rb_raise (e_Error, "%s", guestfs_last_error (g));
1956 static VALUE ruby_guestfs_blockdev_getbsz (VALUE gv, VALUE devicev)
1959 Data_Get_Struct (gv, guestfs_h, g);
1961 rb_raise (rb_eArgError, "%s: used handle after closing it", "blockdev_getbsz");
1963 const char *device = StringValueCStr (devicev);
1965 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1966 "device", "blockdev_getbsz");
1970 r = guestfs_blockdev_getbsz (g, device);
1972 rb_raise (e_Error, "%s", guestfs_last_error (g));
1977 static VALUE ruby_guestfs_blockdev_setbsz (VALUE gv, VALUE devicev, VALUE blocksizev)
1980 Data_Get_Struct (gv, guestfs_h, g);
1982 rb_raise (rb_eArgError, "%s: used handle after closing it", "blockdev_setbsz");
1984 const char *device = StringValueCStr (devicev);
1986 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1987 "device", "blockdev_setbsz");
1988 int blocksize = NUM2INT (blocksizev);
1992 r = guestfs_blockdev_setbsz (g, device, blocksize);
1994 rb_raise (e_Error, "%s", guestfs_last_error (g));
1999 static VALUE ruby_guestfs_blockdev_getsz (VALUE gv, VALUE devicev)
2002 Data_Get_Struct (gv, guestfs_h, g);
2004 rb_raise (rb_eArgError, "%s: used handle after closing it", "blockdev_getsz");
2006 const char *device = StringValueCStr (devicev);
2008 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2009 "device", "blockdev_getsz");
2013 r = guestfs_blockdev_getsz (g, device);
2015 rb_raise (e_Error, "%s", guestfs_last_error (g));
2020 static VALUE ruby_guestfs_blockdev_getsize64 (VALUE gv, VALUE devicev)
2023 Data_Get_Struct (gv, guestfs_h, g);
2025 rb_raise (rb_eArgError, "%s: used handle after closing it", "blockdev_getsize64");
2027 const char *device = StringValueCStr (devicev);
2029 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2030 "device", "blockdev_getsize64");
2034 r = guestfs_blockdev_getsize64 (g, device);
2036 rb_raise (e_Error, "%s", guestfs_last_error (g));
2041 static VALUE ruby_guestfs_blockdev_flushbufs (VALUE gv, VALUE devicev)
2044 Data_Get_Struct (gv, guestfs_h, g);
2046 rb_raise (rb_eArgError, "%s: used handle after closing it", "blockdev_flushbufs");
2048 const char *device = StringValueCStr (devicev);
2050 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2051 "device", "blockdev_flushbufs");
2055 r = guestfs_blockdev_flushbufs (g, device);
2057 rb_raise (e_Error, "%s", guestfs_last_error (g));
2062 static VALUE ruby_guestfs_blockdev_rereadpt (VALUE gv, VALUE devicev)
2065 Data_Get_Struct (gv, guestfs_h, g);
2067 rb_raise (rb_eArgError, "%s: used handle after closing it", "blockdev_rereadpt");
2069 const char *device = StringValueCStr (devicev);
2071 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2072 "device", "blockdev_rereadpt");
2076 r = guestfs_blockdev_rereadpt (g, device);
2078 rb_raise (e_Error, "%s", guestfs_last_error (g));
2083 static VALUE ruby_guestfs_upload (VALUE gv, VALUE filenamev, VALUE remotefilenamev)
2086 Data_Get_Struct (gv, guestfs_h, g);
2088 rb_raise (rb_eArgError, "%s: used handle after closing it", "upload");
2090 const char *filename = StringValueCStr (filenamev);
2092 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2093 "filename", "upload");
2094 const char *remotefilename = StringValueCStr (remotefilenamev);
2095 if (!remotefilename)
2096 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2097 "remotefilename", "upload");
2101 r = guestfs_upload (g, filename, remotefilename);
2103 rb_raise (e_Error, "%s", guestfs_last_error (g));
2108 static VALUE ruby_guestfs_download (VALUE gv, VALUE remotefilenamev, VALUE filenamev)
2111 Data_Get_Struct (gv, guestfs_h, g);
2113 rb_raise (rb_eArgError, "%s: used handle after closing it", "download");
2115 const char *remotefilename = StringValueCStr (remotefilenamev);
2116 if (!remotefilename)
2117 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2118 "remotefilename", "download");
2119 const char *filename = StringValueCStr (filenamev);
2121 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2122 "filename", "download");
2126 r = guestfs_download (g, remotefilename, filename);
2128 rb_raise (e_Error, "%s", guestfs_last_error (g));
2133 static VALUE ruby_guestfs_checksum (VALUE gv, VALUE csumtypev, VALUE pathv)
2136 Data_Get_Struct (gv, guestfs_h, g);
2138 rb_raise (rb_eArgError, "%s: used handle after closing it", "checksum");
2140 const char *csumtype = StringValueCStr (csumtypev);
2142 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2143 "csumtype", "checksum");
2144 const char *path = StringValueCStr (pathv);
2146 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2147 "path", "checksum");
2151 r = guestfs_checksum (g, csumtype, path);
2153 rb_raise (e_Error, "%s", guestfs_last_error (g));
2155 VALUE rv = rb_str_new2 (r);
2160 static VALUE ruby_guestfs_tar_in (VALUE gv, VALUE tarfilev, VALUE directoryv)
2163 Data_Get_Struct (gv, guestfs_h, g);
2165 rb_raise (rb_eArgError, "%s: used handle after closing it", "tar_in");
2167 const char *tarfile = StringValueCStr (tarfilev);
2169 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2170 "tarfile", "tar_in");
2171 const char *directory = StringValueCStr (directoryv);
2173 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2174 "directory", "tar_in");
2178 r = guestfs_tar_in (g, tarfile, directory);
2180 rb_raise (e_Error, "%s", guestfs_last_error (g));
2185 static VALUE ruby_guestfs_tar_out (VALUE gv, VALUE directoryv, VALUE tarfilev)
2188 Data_Get_Struct (gv, guestfs_h, g);
2190 rb_raise (rb_eArgError, "%s: used handle after closing it", "tar_out");
2192 const char *directory = StringValueCStr (directoryv);
2194 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2195 "directory", "tar_out");
2196 const char *tarfile = StringValueCStr (tarfilev);
2198 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2199 "tarfile", "tar_out");
2203 r = guestfs_tar_out (g, directory, tarfile);
2205 rb_raise (e_Error, "%s", guestfs_last_error (g));
2210 static VALUE ruby_guestfs_tgz_in (VALUE gv, VALUE tarballv, VALUE directoryv)
2213 Data_Get_Struct (gv, guestfs_h, g);
2215 rb_raise (rb_eArgError, "%s: used handle after closing it", "tgz_in");
2217 const char *tarball = StringValueCStr (tarballv);
2219 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2220 "tarball", "tgz_in");
2221 const char *directory = StringValueCStr (directoryv);
2223 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2224 "directory", "tgz_in");
2228 r = guestfs_tgz_in (g, tarball, directory);
2230 rb_raise (e_Error, "%s", guestfs_last_error (g));
2235 static VALUE ruby_guestfs_tgz_out (VALUE gv, VALUE directoryv, VALUE tarballv)
2238 Data_Get_Struct (gv, guestfs_h, g);
2240 rb_raise (rb_eArgError, "%s: used handle after closing it", "tgz_out");
2242 const char *directory = StringValueCStr (directoryv);
2244 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2245 "directory", "tgz_out");
2246 const char *tarball = StringValueCStr (tarballv);
2248 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2249 "tarball", "tgz_out");
2253 r = guestfs_tgz_out (g, directory, tarball);
2255 rb_raise (e_Error, "%s", guestfs_last_error (g));
2260 static VALUE ruby_guestfs_mount_ro (VALUE gv, VALUE devicev, VALUE mountpointv)
2263 Data_Get_Struct (gv, guestfs_h, g);
2265 rb_raise (rb_eArgError, "%s: used handle after closing it", "mount_ro");
2267 const char *device = StringValueCStr (devicev);
2269 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2270 "device", "mount_ro");
2271 const char *mountpoint = StringValueCStr (mountpointv);
2273 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2274 "mountpoint", "mount_ro");
2278 r = guestfs_mount_ro (g, device, mountpoint);
2280 rb_raise (e_Error, "%s", guestfs_last_error (g));
2285 static VALUE ruby_guestfs_mount_options (VALUE gv, VALUE optionsv, VALUE devicev, VALUE mountpointv)
2288 Data_Get_Struct (gv, guestfs_h, g);
2290 rb_raise (rb_eArgError, "%s: used handle after closing it", "mount_options");
2292 const char *options = StringValueCStr (optionsv);
2294 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2295 "options", "mount_options");
2296 const char *device = StringValueCStr (devicev);
2298 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2299 "device", "mount_options");
2300 const char *mountpoint = StringValueCStr (mountpointv);
2302 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2303 "mountpoint", "mount_options");
2307 r = guestfs_mount_options (g, options, device, mountpoint);
2309 rb_raise (e_Error, "%s", guestfs_last_error (g));
2314 static VALUE ruby_guestfs_mount_vfs (VALUE gv, VALUE optionsv, VALUE vfstypev, VALUE devicev, VALUE mountpointv)
2317 Data_Get_Struct (gv, guestfs_h, g);
2319 rb_raise (rb_eArgError, "%s: used handle after closing it", "mount_vfs");
2321 const char *options = StringValueCStr (optionsv);
2323 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2324 "options", "mount_vfs");
2325 const char *vfstype = StringValueCStr (vfstypev);
2327 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2328 "vfstype", "mount_vfs");
2329 const char *device = StringValueCStr (devicev);
2331 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2332 "device", "mount_vfs");
2333 const char *mountpoint = StringValueCStr (mountpointv);
2335 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2336 "mountpoint", "mount_vfs");
2340 r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint);
2342 rb_raise (e_Error, "%s", guestfs_last_error (g));
2347 static VALUE ruby_guestfs_debug (VALUE gv, VALUE subcmdv, VALUE extraargsv)
2350 Data_Get_Struct (gv, guestfs_h, g);
2352 rb_raise (rb_eArgError, "%s: used handle after closing it", "debug");
2354 const char *subcmd = StringValueCStr (subcmdv);
2356 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2360 len = RARRAY_LEN (extraargsv);
2361 extraargs = guestfs_safe_malloc (g, sizeof (char *) * (len+1));
2362 for (i = 0; i < len; ++i) {
2363 VALUE v = rb_ary_entry (extraargsv, i);
2364 extraargs[i] = StringValueCStr (v);
2366 extraargs[len] = NULL;
2371 r = guestfs_debug (g, subcmd, extraargs);
2374 rb_raise (e_Error, "%s", guestfs_last_error (g));
2376 VALUE rv = rb_str_new2 (r);
2381 static VALUE ruby_guestfs_lvremove (VALUE gv, VALUE devicev)
2384 Data_Get_Struct (gv, guestfs_h, g);
2386 rb_raise (rb_eArgError, "%s: used handle after closing it", "lvremove");
2388 const char *device = StringValueCStr (devicev);
2390 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2391 "device", "lvremove");
2395 r = guestfs_lvremove (g, device);
2397 rb_raise (e_Error, "%s", guestfs_last_error (g));
2402 static VALUE ruby_guestfs_vgremove (VALUE gv, VALUE vgnamev)
2405 Data_Get_Struct (gv, guestfs_h, g);
2407 rb_raise (rb_eArgError, "%s: used handle after closing it", "vgremove");
2409 const char *vgname = StringValueCStr (vgnamev);
2411 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2412 "vgname", "vgremove");
2416 r = guestfs_vgremove (g, vgname);
2418 rb_raise (e_Error, "%s", guestfs_last_error (g));
2423 static VALUE ruby_guestfs_pvremove (VALUE gv, VALUE devicev)
2426 Data_Get_Struct (gv, guestfs_h, g);
2428 rb_raise (rb_eArgError, "%s: used handle after closing it", "pvremove");
2430 const char *device = StringValueCStr (devicev);
2432 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2433 "device", "pvremove");
2437 r = guestfs_pvremove (g, device);
2439 rb_raise (e_Error, "%s", guestfs_last_error (g));
2444 static VALUE ruby_guestfs_set_e2label (VALUE gv, VALUE devicev, VALUE labelv)
2447 Data_Get_Struct (gv, guestfs_h, g);
2449 rb_raise (rb_eArgError, "%s: used handle after closing it", "set_e2label");
2451 const char *device = StringValueCStr (devicev);
2453 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2454 "device", "set_e2label");
2455 const char *label = StringValueCStr (labelv);
2457 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2458 "label", "set_e2label");
2462 r = guestfs_set_e2label (g, device, label);
2464 rb_raise (e_Error, "%s", guestfs_last_error (g));
2469 static VALUE ruby_guestfs_get_e2label (VALUE gv, VALUE devicev)
2472 Data_Get_Struct (gv, guestfs_h, g);
2474 rb_raise (rb_eArgError, "%s: used handle after closing it", "get_e2label");
2476 const char *device = StringValueCStr (devicev);
2478 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2479 "device", "get_e2label");
2483 r = guestfs_get_e2label (g, device);
2485 rb_raise (e_Error, "%s", guestfs_last_error (g));
2487 VALUE rv = rb_str_new2 (r);
2492 static VALUE ruby_guestfs_set_e2uuid (VALUE gv, VALUE devicev, VALUE uuidv)
2495 Data_Get_Struct (gv, guestfs_h, g);
2497 rb_raise (rb_eArgError, "%s: used handle after closing it", "set_e2uuid");
2499 const char *device = StringValueCStr (devicev);
2501 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2502 "device", "set_e2uuid");
2503 const char *uuid = StringValueCStr (uuidv);
2505 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2506 "uuid", "set_e2uuid");
2510 r = guestfs_set_e2uuid (g, device, uuid);
2512 rb_raise (e_Error, "%s", guestfs_last_error (g));
2517 static VALUE ruby_guestfs_get_e2uuid (VALUE gv, VALUE devicev)
2520 Data_Get_Struct (gv, guestfs_h, g);
2522 rb_raise (rb_eArgError, "%s: used handle after closing it", "get_e2uuid");
2524 const char *device = StringValueCStr (devicev);
2526 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2527 "device", "get_e2uuid");
2531 r = guestfs_get_e2uuid (g, device);
2533 rb_raise (e_Error, "%s", guestfs_last_error (g));
2535 VALUE rv = rb_str_new2 (r);
2540 static VALUE ruby_guestfs_fsck (VALUE gv, VALUE fstypev, VALUE devicev)
2543 Data_Get_Struct (gv, guestfs_h, g);
2545 rb_raise (rb_eArgError, "%s: used handle after closing it", "fsck");
2547 const char *fstype = StringValueCStr (fstypev);
2549 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2551 const char *device = StringValueCStr (devicev);
2553 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2558 r = guestfs_fsck (g, fstype, device);
2560 rb_raise (e_Error, "%s", guestfs_last_error (g));
2565 static VALUE ruby_guestfs_zero (VALUE gv, VALUE devicev)
2568 Data_Get_Struct (gv, guestfs_h, g);
2570 rb_raise (rb_eArgError, "%s: used handle after closing it", "zero");
2572 const char *device = StringValueCStr (devicev);
2574 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2579 r = guestfs_zero (g, device);
2581 rb_raise (e_Error, "%s", guestfs_last_error (g));
2586 static VALUE ruby_guestfs_grub_install (VALUE gv, VALUE rootv, VALUE devicev)
2589 Data_Get_Struct (gv, guestfs_h, g);
2591 rb_raise (rb_eArgError, "%s: used handle after closing it", "grub_install");
2593 const char *root = StringValueCStr (rootv);
2595 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2596 "root", "grub_install");
2597 const char *device = StringValueCStr (devicev);
2599 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2600 "device", "grub_install");
2604 r = guestfs_grub_install (g, root, device);
2606 rb_raise (e_Error, "%s", guestfs_last_error (g));
2611 static VALUE ruby_guestfs_cp (VALUE gv, VALUE srcv, VALUE destv)
2614 Data_Get_Struct (gv, guestfs_h, g);
2616 rb_raise (rb_eArgError, "%s: used handle after closing it", "cp");
2618 const char *src = StringValueCStr (srcv);
2620 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2622 const char *dest = StringValueCStr (destv);
2624 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2629 r = guestfs_cp (g, src, dest);
2631 rb_raise (e_Error, "%s", guestfs_last_error (g));
2636 static VALUE ruby_guestfs_cp_a (VALUE gv, VALUE srcv, VALUE destv)
2639 Data_Get_Struct (gv, guestfs_h, g);
2641 rb_raise (rb_eArgError, "%s: used handle after closing it", "cp_a");
2643 const char *src = StringValueCStr (srcv);
2645 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2647 const char *dest = StringValueCStr (destv);
2649 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2654 r = guestfs_cp_a (g, src, dest);
2656 rb_raise (e_Error, "%s", guestfs_last_error (g));
2661 static VALUE ruby_guestfs_mv (VALUE gv, VALUE srcv, VALUE destv)
2664 Data_Get_Struct (gv, guestfs_h, g);
2666 rb_raise (rb_eArgError, "%s: used handle after closing it", "mv");
2668 const char *src = StringValueCStr (srcv);
2670 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2672 const char *dest = StringValueCStr (destv);
2674 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2679 r = guestfs_mv (g, src, dest);
2681 rb_raise (e_Error, "%s", guestfs_last_error (g));
2686 static VALUE ruby_guestfs_drop_caches (VALUE gv, VALUE whattodropv)
2689 Data_Get_Struct (gv, guestfs_h, g);
2691 rb_raise (rb_eArgError, "%s: used handle after closing it", "drop_caches");
2693 int whattodrop = NUM2INT (whattodropv);
2697 r = guestfs_drop_caches (g, whattodrop);
2699 rb_raise (e_Error, "%s", guestfs_last_error (g));
2704 static VALUE ruby_guestfs_dmesg (VALUE gv)
2707 Data_Get_Struct (gv, guestfs_h, g);
2709 rb_raise (rb_eArgError, "%s: used handle after closing it", "dmesg");
2714 r = guestfs_dmesg (g);
2716 rb_raise (e_Error, "%s", guestfs_last_error (g));
2718 VALUE rv = rb_str_new2 (r);
2723 static VALUE ruby_guestfs_ping_daemon (VALUE gv)
2726 Data_Get_Struct (gv, guestfs_h, g);
2728 rb_raise (rb_eArgError, "%s: used handle after closing it", "ping_daemon");
2733 r = guestfs_ping_daemon (g);
2735 rb_raise (e_Error, "%s", guestfs_last_error (g));
2740 static VALUE ruby_guestfs_equal (VALUE gv, VALUE file1v, VALUE file2v)
2743 Data_Get_Struct (gv, guestfs_h, g);
2745 rb_raise (rb_eArgError, "%s: used handle after closing it", "equal");
2747 const char *file1 = StringValueCStr (file1v);
2749 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2751 const char *file2 = StringValueCStr (file2v);
2753 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2758 r = guestfs_equal (g, file1, file2);
2760 rb_raise (e_Error, "%s", guestfs_last_error (g));
2765 static VALUE ruby_guestfs_strings (VALUE gv, VALUE pathv)
2768 Data_Get_Struct (gv, guestfs_h, g);
2770 rb_raise (rb_eArgError, "%s: used handle after closing it", "strings");
2772 const char *path = StringValueCStr (pathv);
2774 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2779 r = guestfs_strings (g, path);
2781 rb_raise (e_Error, "%s", guestfs_last_error (g));
2784 for (i = 0; r[i] != NULL; ++i) len++;
2785 VALUE rv = rb_ary_new2 (len);
2786 for (i = 0; r[i] != NULL; ++i) {
2787 rb_ary_push (rv, rb_str_new2 (r[i]));
2794 static VALUE ruby_guestfs_strings_e (VALUE gv, VALUE encodingv, VALUE pathv)
2797 Data_Get_Struct (gv, guestfs_h, g);
2799 rb_raise (rb_eArgError, "%s: used handle after closing it", "strings_e");
2801 const char *encoding = StringValueCStr (encodingv);
2803 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2804 "encoding", "strings_e");
2805 const char *path = StringValueCStr (pathv);
2807 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2808 "path", "strings_e");
2812 r = guestfs_strings_e (g, encoding, path);
2814 rb_raise (e_Error, "%s", guestfs_last_error (g));
2817 for (i = 0; r[i] != NULL; ++i) len++;
2818 VALUE rv = rb_ary_new2 (len);
2819 for (i = 0; r[i] != NULL; ++i) {
2820 rb_ary_push (rv, rb_str_new2 (r[i]));
2827 static VALUE ruby_guestfs_hexdump (VALUE gv, VALUE pathv)
2830 Data_Get_Struct (gv, guestfs_h, g);
2832 rb_raise (rb_eArgError, "%s: used handle after closing it", "hexdump");
2834 const char *path = StringValueCStr (pathv);
2836 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2841 r = guestfs_hexdump (g, path);
2843 rb_raise (e_Error, "%s", guestfs_last_error (g));
2845 VALUE rv = rb_str_new2 (r);
2850 /* Initialize the module. */
2851 void Init__guestfs ()
2853 m_guestfs = rb_define_module ("Guestfs");
2854 c_guestfs = rb_define_class_under (m_guestfs, "Guestfs", rb_cObject);
2855 e_Error = rb_define_class_under (m_guestfs, "Error", rb_eStandardError);
2857 rb_define_module_function (m_guestfs, "create", ruby_guestfs_create, 0);
2858 rb_define_method (c_guestfs, "close", ruby_guestfs_close, 0);
2860 rb_define_method (c_guestfs, "launch",
2861 ruby_guestfs_launch, 0);
2862 rb_define_method (c_guestfs, "wait_ready",
2863 ruby_guestfs_wait_ready, 0);
2864 rb_define_method (c_guestfs, "kill_subprocess",
2865 ruby_guestfs_kill_subprocess, 0);
2866 rb_define_method (c_guestfs, "add_drive",
2867 ruby_guestfs_add_drive, 1);
2868 rb_define_method (c_guestfs, "add_cdrom",
2869 ruby_guestfs_add_cdrom, 1);
2870 rb_define_method (c_guestfs, "config",
2871 ruby_guestfs_config, 2);
2872 rb_define_method (c_guestfs, "set_qemu",
2873 ruby_guestfs_set_qemu, 1);
2874 rb_define_method (c_guestfs, "get_qemu",
2875 ruby_guestfs_get_qemu, 0);
2876 rb_define_method (c_guestfs, "set_path",
2877 ruby_guestfs_set_path, 1);
2878 rb_define_method (c_guestfs, "get_path",
2879 ruby_guestfs_get_path, 0);
2880 rb_define_method (c_guestfs, "set_autosync",
2881 ruby_guestfs_set_autosync, 1);
2882 rb_define_method (c_guestfs, "get_autosync",
2883 ruby_guestfs_get_autosync, 0);
2884 rb_define_method (c_guestfs, "set_verbose",
2885 ruby_guestfs_set_verbose, 1);
2886 rb_define_method (c_guestfs, "get_verbose",
2887 ruby_guestfs_get_verbose, 0);
2888 rb_define_method (c_guestfs, "is_ready",
2889 ruby_guestfs_is_ready, 0);
2890 rb_define_method (c_guestfs, "is_config",
2891 ruby_guestfs_is_config, 0);
2892 rb_define_method (c_guestfs, "is_launching",
2893 ruby_guestfs_is_launching, 0);
2894 rb_define_method (c_guestfs, "is_busy",
2895 ruby_guestfs_is_busy, 0);
2896 rb_define_method (c_guestfs, "get_state",
2897 ruby_guestfs_get_state, 0);
2898 rb_define_method (c_guestfs, "set_busy",
2899 ruby_guestfs_set_busy, 0);
2900 rb_define_method (c_guestfs, "set_ready",
2901 ruby_guestfs_set_ready, 0);
2902 rb_define_method (c_guestfs, "end_busy",
2903 ruby_guestfs_end_busy, 0);
2904 rb_define_method (c_guestfs, "mount",
2905 ruby_guestfs_mount, 2);
2906 rb_define_method (c_guestfs, "sync",
2907 ruby_guestfs_sync, 0);
2908 rb_define_method (c_guestfs, "touch",
2909 ruby_guestfs_touch, 1);
2910 rb_define_method (c_guestfs, "cat",
2911 ruby_guestfs_cat, 1);
2912 rb_define_method (c_guestfs, "ll",
2913 ruby_guestfs_ll, 1);
2914 rb_define_method (c_guestfs, "ls",
2915 ruby_guestfs_ls, 1);
2916 rb_define_method (c_guestfs, "list_devices",
2917 ruby_guestfs_list_devices, 0);
2918 rb_define_method (c_guestfs, "list_partitions",
2919 ruby_guestfs_list_partitions, 0);
2920 rb_define_method (c_guestfs, "pvs",
2921 ruby_guestfs_pvs, 0);
2922 rb_define_method (c_guestfs, "vgs",
2923 ruby_guestfs_vgs, 0);
2924 rb_define_method (c_guestfs, "lvs",
2925 ruby_guestfs_lvs, 0);
2926 rb_define_method (c_guestfs, "pvs_full",
2927 ruby_guestfs_pvs_full, 0);
2928 rb_define_method (c_guestfs, "vgs_full",
2929 ruby_guestfs_vgs_full, 0);
2930 rb_define_method (c_guestfs, "lvs_full",
2931 ruby_guestfs_lvs_full, 0);
2932 rb_define_method (c_guestfs, "read_lines",
2933 ruby_guestfs_read_lines, 1);
2934 rb_define_method (c_guestfs, "aug_init",
2935 ruby_guestfs_aug_init, 2);
2936 rb_define_method (c_guestfs, "aug_close",
2937 ruby_guestfs_aug_close, 0);
2938 rb_define_method (c_guestfs, "aug_defvar",
2939 ruby_guestfs_aug_defvar, 2);
2940 rb_define_method (c_guestfs, "aug_defnode",
2941 ruby_guestfs_aug_defnode, 3);
2942 rb_define_method (c_guestfs, "aug_get",
2943 ruby_guestfs_aug_get, 1);
2944 rb_define_method (c_guestfs, "aug_set",
2945 ruby_guestfs_aug_set, 2);
2946 rb_define_method (c_guestfs, "aug_insert",
2947 ruby_guestfs_aug_insert, 3);
2948 rb_define_method (c_guestfs, "aug_rm",
2949 ruby_guestfs_aug_rm, 1);
2950 rb_define_method (c_guestfs, "aug_mv",
2951 ruby_guestfs_aug_mv, 2);
2952 rb_define_method (c_guestfs, "aug_match",
2953 ruby_guestfs_aug_match, 1);
2954 rb_define_method (c_guestfs, "aug_save",
2955 ruby_guestfs_aug_save, 0);
2956 rb_define_method (c_guestfs, "aug_load",
2957 ruby_guestfs_aug_load, 0);
2958 rb_define_method (c_guestfs, "aug_ls",
2959 ruby_guestfs_aug_ls, 1);
2960 rb_define_method (c_guestfs, "rm",
2961 ruby_guestfs_rm, 1);
2962 rb_define_method (c_guestfs, "rmdir",
2963 ruby_guestfs_rmdir, 1);
2964 rb_define_method (c_guestfs, "rm_rf",
2965 ruby_guestfs_rm_rf, 1);
2966 rb_define_method (c_guestfs, "mkdir",
2967 ruby_guestfs_mkdir, 1);
2968 rb_define_method (c_guestfs, "mkdir_p",
2969 ruby_guestfs_mkdir_p, 1);
2970 rb_define_method (c_guestfs, "chmod",
2971 ruby_guestfs_chmod, 2);
2972 rb_define_method (c_guestfs, "chown",
2973 ruby_guestfs_chown, 3);
2974 rb_define_method (c_guestfs, "exists",
2975 ruby_guestfs_exists, 1);
2976 rb_define_method (c_guestfs, "is_file",
2977 ruby_guestfs_is_file, 1);
2978 rb_define_method (c_guestfs, "is_dir",
2979 ruby_guestfs_is_dir, 1);
2980 rb_define_method (c_guestfs, "pvcreate",
2981 ruby_guestfs_pvcreate, 1);
2982 rb_define_method (c_guestfs, "vgcreate",
2983 ruby_guestfs_vgcreate, 2);
2984 rb_define_method (c_guestfs, "lvcreate",
2985 ruby_guestfs_lvcreate, 3);
2986 rb_define_method (c_guestfs, "mkfs",
2987 ruby_guestfs_mkfs, 2);
2988 rb_define_method (c_guestfs, "sfdisk",
2989 ruby_guestfs_sfdisk, 5);
2990 rb_define_method (c_guestfs, "write_file",
2991 ruby_guestfs_write_file, 3);
2992 rb_define_method (c_guestfs, "umount",
2993 ruby_guestfs_umount, 1);
2994 rb_define_method (c_guestfs, "mounts",
2995 ruby_guestfs_mounts, 0);
2996 rb_define_method (c_guestfs, "umount_all",
2997 ruby_guestfs_umount_all, 0);
2998 rb_define_method (c_guestfs, "lvm_remove_all",
2999 ruby_guestfs_lvm_remove_all, 0);
3000 rb_define_method (c_guestfs, "file",
3001 ruby_guestfs_file, 1);
3002 rb_define_method (c_guestfs, "command",
3003 ruby_guestfs_command, 1);
3004 rb_define_method (c_guestfs, "command_lines",
3005 ruby_guestfs_command_lines, 1);
3006 rb_define_method (c_guestfs, "stat",
3007 ruby_guestfs_stat, 1);
3008 rb_define_method (c_guestfs, "lstat",
3009 ruby_guestfs_lstat, 1);
3010 rb_define_method (c_guestfs, "statvfs",
3011 ruby_guestfs_statvfs, 1);
3012 rb_define_method (c_guestfs, "tune2fs_l",
3013 ruby_guestfs_tune2fs_l, 1);
3014 rb_define_method (c_guestfs, "blockdev_setro",
3015 ruby_guestfs_blockdev_setro, 1);
3016 rb_define_method (c_guestfs, "blockdev_setrw",
3017 ruby_guestfs_blockdev_setrw, 1);
3018 rb_define_method (c_guestfs, "blockdev_getro",
3019 ruby_guestfs_blockdev_getro, 1);
3020 rb_define_method (c_guestfs, "blockdev_getss",
3021 ruby_guestfs_blockdev_getss, 1);
3022 rb_define_method (c_guestfs, "blockdev_getbsz",
3023 ruby_guestfs_blockdev_getbsz, 1);
3024 rb_define_method (c_guestfs, "blockdev_setbsz",
3025 ruby_guestfs_blockdev_setbsz, 2);
3026 rb_define_method (c_guestfs, "blockdev_getsz",
3027 ruby_guestfs_blockdev_getsz, 1);
3028 rb_define_method (c_guestfs, "blockdev_getsize64",
3029 ruby_guestfs_blockdev_getsize64, 1);
3030 rb_define_method (c_guestfs, "blockdev_flushbufs",
3031 ruby_guestfs_blockdev_flushbufs, 1);
3032 rb_define_method (c_guestfs, "blockdev_rereadpt",
3033 ruby_guestfs_blockdev_rereadpt, 1);
3034 rb_define_method (c_guestfs, "upload",
3035 ruby_guestfs_upload, 2);
3036 rb_define_method (c_guestfs, "download",
3037 ruby_guestfs_download, 2);
3038 rb_define_method (c_guestfs, "checksum",
3039 ruby_guestfs_checksum, 2);
3040 rb_define_method (c_guestfs, "tar_in",
3041 ruby_guestfs_tar_in, 2);
3042 rb_define_method (c_guestfs, "tar_out",
3043 ruby_guestfs_tar_out, 2);
3044 rb_define_method (c_guestfs, "tgz_in",
3045 ruby_guestfs_tgz_in, 2);
3046 rb_define_method (c_guestfs, "tgz_out",
3047 ruby_guestfs_tgz_out, 2);
3048 rb_define_method (c_guestfs, "mount_ro",
3049 ruby_guestfs_mount_ro, 2);
3050 rb_define_method (c_guestfs, "mount_options",
3051 ruby_guestfs_mount_options, 3);
3052 rb_define_method (c_guestfs, "mount_vfs",
3053 ruby_guestfs_mount_vfs, 4);
3054 rb_define_method (c_guestfs, "debug",
3055 ruby_guestfs_debug, 2);
3056 rb_define_method (c_guestfs, "lvremove",
3057 ruby_guestfs_lvremove, 1);
3058 rb_define_method (c_guestfs, "vgremove",
3059 ruby_guestfs_vgremove, 1);
3060 rb_define_method (c_guestfs, "pvremove",
3061 ruby_guestfs_pvremove, 1);
3062 rb_define_method (c_guestfs, "set_e2label",
3063 ruby_guestfs_set_e2label, 2);
3064 rb_define_method (c_guestfs, "get_e2label",
3065 ruby_guestfs_get_e2label, 1);
3066 rb_define_method (c_guestfs, "set_e2uuid",
3067 ruby_guestfs_set_e2uuid, 2);
3068 rb_define_method (c_guestfs, "get_e2uuid",
3069 ruby_guestfs_get_e2uuid, 1);
3070 rb_define_method (c_guestfs, "fsck",
3071 ruby_guestfs_fsck, 2);
3072 rb_define_method (c_guestfs, "zero",
3073 ruby_guestfs_zero, 1);
3074 rb_define_method (c_guestfs, "grub_install",
3075 ruby_guestfs_grub_install, 2);
3076 rb_define_method (c_guestfs, "cp",
3077 ruby_guestfs_cp, 2);
3078 rb_define_method (c_guestfs, "cp_a",
3079 ruby_guestfs_cp_a, 2);
3080 rb_define_method (c_guestfs, "mv",
3081 ruby_guestfs_mv, 2);
3082 rb_define_method (c_guestfs, "drop_caches",
3083 ruby_guestfs_drop_caches, 1);
3084 rb_define_method (c_guestfs, "dmesg",
3085 ruby_guestfs_dmesg, 0);
3086 rb_define_method (c_guestfs, "ping_daemon",
3087 ruby_guestfs_ping_daemon, 0);
3088 rb_define_method (c_guestfs, "equal",
3089 ruby_guestfs_equal, 2);
3090 rb_define_method (c_guestfs, "strings",
3091 ruby_guestfs_strings, 1);
3092 rb_define_method (c_guestfs, "strings_e",
3093 ruby_guestfs_strings_e, 2);
3094 rb_define_method (c_guestfs, "hexdump",
3095 ruby_guestfs_hexdump, 1);