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_mount (VALUE gv, VALUE devicev, VALUE mountpointv)
457 Data_Get_Struct (gv, guestfs_h, g);
459 rb_raise (rb_eArgError, "%s: used handle after closing it", "mount");
461 const char *device = StringValueCStr (devicev);
463 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
465 const char *mountpoint = StringValueCStr (mountpointv);
467 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
468 "mountpoint", "mount");
472 r = guestfs_mount (g, device, mountpoint);
474 rb_raise (e_Error, "%s", guestfs_last_error (g));
479 static VALUE ruby_guestfs_sync (VALUE gv)
482 Data_Get_Struct (gv, guestfs_h, g);
484 rb_raise (rb_eArgError, "%s: used handle after closing it", "sync");
489 r = guestfs_sync (g);
491 rb_raise (e_Error, "%s", guestfs_last_error (g));
496 static VALUE ruby_guestfs_touch (VALUE gv, VALUE pathv)
499 Data_Get_Struct (gv, guestfs_h, g);
501 rb_raise (rb_eArgError, "%s: used handle after closing it", "touch");
503 const char *path = StringValueCStr (pathv);
505 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
510 r = guestfs_touch (g, path);
512 rb_raise (e_Error, "%s", guestfs_last_error (g));
517 static VALUE ruby_guestfs_cat (VALUE gv, VALUE pathv)
520 Data_Get_Struct (gv, guestfs_h, g);
522 rb_raise (rb_eArgError, "%s: used handle after closing it", "cat");
524 const char *path = StringValueCStr (pathv);
526 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
531 r = guestfs_cat (g, path);
533 rb_raise (e_Error, "%s", guestfs_last_error (g));
535 VALUE rv = rb_str_new2 (r);
540 static VALUE ruby_guestfs_ll (VALUE gv, VALUE directoryv)
543 Data_Get_Struct (gv, guestfs_h, g);
545 rb_raise (rb_eArgError, "%s: used handle after closing it", "ll");
547 const char *directory = StringValueCStr (directoryv);
549 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
554 r = guestfs_ll (g, directory);
556 rb_raise (e_Error, "%s", guestfs_last_error (g));
558 VALUE rv = rb_str_new2 (r);
563 static VALUE ruby_guestfs_ls (VALUE gv, VALUE directoryv)
566 Data_Get_Struct (gv, guestfs_h, g);
568 rb_raise (rb_eArgError, "%s: used handle after closing it", "ls");
570 const char *directory = StringValueCStr (directoryv);
572 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
577 r = guestfs_ls (g, directory);
579 rb_raise (e_Error, "%s", guestfs_last_error (g));
582 for (i = 0; r[i] != NULL; ++i) len++;
583 VALUE rv = rb_ary_new2 (len);
584 for (i = 0; r[i] != NULL; ++i) {
585 rb_ary_push (rv, rb_str_new2 (r[i]));
592 static VALUE ruby_guestfs_list_devices (VALUE gv)
595 Data_Get_Struct (gv, guestfs_h, g);
597 rb_raise (rb_eArgError, "%s: used handle after closing it", "list_devices");
602 r = guestfs_list_devices (g);
604 rb_raise (e_Error, "%s", guestfs_last_error (g));
607 for (i = 0; r[i] != NULL; ++i) len++;
608 VALUE rv = rb_ary_new2 (len);
609 for (i = 0; r[i] != NULL; ++i) {
610 rb_ary_push (rv, rb_str_new2 (r[i]));
617 static VALUE ruby_guestfs_list_partitions (VALUE gv)
620 Data_Get_Struct (gv, guestfs_h, g);
622 rb_raise (rb_eArgError, "%s: used handle after closing it", "list_partitions");
627 r = guestfs_list_partitions (g);
629 rb_raise (e_Error, "%s", guestfs_last_error (g));
632 for (i = 0; r[i] != NULL; ++i) len++;
633 VALUE rv = rb_ary_new2 (len);
634 for (i = 0; r[i] != NULL; ++i) {
635 rb_ary_push (rv, rb_str_new2 (r[i]));
642 static VALUE ruby_guestfs_pvs (VALUE gv)
645 Data_Get_Struct (gv, guestfs_h, g);
647 rb_raise (rb_eArgError, "%s: used handle after closing it", "pvs");
654 rb_raise (e_Error, "%s", guestfs_last_error (g));
657 for (i = 0; r[i] != NULL; ++i) len++;
658 VALUE rv = rb_ary_new2 (len);
659 for (i = 0; r[i] != NULL; ++i) {
660 rb_ary_push (rv, rb_str_new2 (r[i]));
667 static VALUE ruby_guestfs_vgs (VALUE gv)
670 Data_Get_Struct (gv, guestfs_h, g);
672 rb_raise (rb_eArgError, "%s: used handle after closing it", "vgs");
679 rb_raise (e_Error, "%s", guestfs_last_error (g));
682 for (i = 0; r[i] != NULL; ++i) len++;
683 VALUE rv = rb_ary_new2 (len);
684 for (i = 0; r[i] != NULL; ++i) {
685 rb_ary_push (rv, rb_str_new2 (r[i]));
692 static VALUE ruby_guestfs_lvs (VALUE gv)
695 Data_Get_Struct (gv, guestfs_h, g);
697 rb_raise (rb_eArgError, "%s: used handle after closing it", "lvs");
704 rb_raise (e_Error, "%s", guestfs_last_error (g));
707 for (i = 0; r[i] != NULL; ++i) len++;
708 VALUE rv = rb_ary_new2 (len);
709 for (i = 0; r[i] != NULL; ++i) {
710 rb_ary_push (rv, rb_str_new2 (r[i]));
717 static VALUE ruby_guestfs_pvs_full (VALUE gv)
720 Data_Get_Struct (gv, guestfs_h, g);
722 rb_raise (rb_eArgError, "%s: used handle after closing it", "pvs_full");
725 struct guestfs_lvm_pv_list *r;
727 r = guestfs_pvs_full (g);
729 rb_raise (e_Error, "%s", guestfs_last_error (g));
731 VALUE rv = rb_ary_new2 (r->len);
733 for (i = 0; i < r->len; ++i) {
734 VALUE hv = rb_hash_new ();
735 rb_hash_aset (rv, rb_str_new2 ("pv_name"), rb_str_new2 (r->val[i].pv_name));
736 rb_hash_aset (rv, rb_str_new2 ("pv_uuid"), rb_str_new (r->val[i].pv_uuid, 32));
737 rb_hash_aset (rv, rb_str_new2 ("pv_fmt"), rb_str_new2 (r->val[i].pv_fmt));
738 rb_hash_aset (rv, rb_str_new2 ("pv_size"), ULL2NUM (r->val[i].pv_size));
739 rb_hash_aset (rv, rb_str_new2 ("dev_size"), ULL2NUM (r->val[i].dev_size));
740 rb_hash_aset (rv, rb_str_new2 ("pv_free"), ULL2NUM (r->val[i].pv_free));
741 rb_hash_aset (rv, rb_str_new2 ("pv_used"), ULL2NUM (r->val[i].pv_used));
742 rb_hash_aset (rv, rb_str_new2 ("pv_attr"), rb_str_new2 (r->val[i].pv_attr));
743 rb_hash_aset (rv, rb_str_new2 ("pv_pe_count"), ULL2NUM (r->val[i].pv_pe_count));
744 rb_hash_aset (rv, rb_str_new2 ("pv_pe_alloc_count"), ULL2NUM (r->val[i].pv_pe_alloc_count));
745 rb_hash_aset (rv, rb_str_new2 ("pv_tags"), rb_str_new2 (r->val[i].pv_tags));
746 rb_hash_aset (rv, rb_str_new2 ("pe_start"), ULL2NUM (r->val[i].pe_start));
747 rb_hash_aset (rv, rb_str_new2 ("pv_mda_count"), ULL2NUM (r->val[i].pv_mda_count));
748 rb_hash_aset (rv, rb_str_new2 ("pv_mda_free"), ULL2NUM (r->val[i].pv_mda_free));
749 rb_ary_push (rv, hv);
751 guestfs_free_lvm_pv_list (r);
755 static VALUE ruby_guestfs_vgs_full (VALUE gv)
758 Data_Get_Struct (gv, guestfs_h, g);
760 rb_raise (rb_eArgError, "%s: used handle after closing it", "vgs_full");
763 struct guestfs_lvm_vg_list *r;
765 r = guestfs_vgs_full (g);
767 rb_raise (e_Error, "%s", guestfs_last_error (g));
769 VALUE rv = rb_ary_new2 (r->len);
771 for (i = 0; i < r->len; ++i) {
772 VALUE hv = rb_hash_new ();
773 rb_hash_aset (rv, rb_str_new2 ("vg_name"), rb_str_new2 (r->val[i].vg_name));
774 rb_hash_aset (rv, rb_str_new2 ("vg_uuid"), rb_str_new (r->val[i].vg_uuid, 32));
775 rb_hash_aset (rv, rb_str_new2 ("vg_fmt"), rb_str_new2 (r->val[i].vg_fmt));
776 rb_hash_aset (rv, rb_str_new2 ("vg_attr"), rb_str_new2 (r->val[i].vg_attr));
777 rb_hash_aset (rv, rb_str_new2 ("vg_size"), ULL2NUM (r->val[i].vg_size));
778 rb_hash_aset (rv, rb_str_new2 ("vg_free"), ULL2NUM (r->val[i].vg_free));
779 rb_hash_aset (rv, rb_str_new2 ("vg_sysid"), rb_str_new2 (r->val[i].vg_sysid));
780 rb_hash_aset (rv, rb_str_new2 ("vg_extent_size"), ULL2NUM (r->val[i].vg_extent_size));
781 rb_hash_aset (rv, rb_str_new2 ("vg_extent_count"), ULL2NUM (r->val[i].vg_extent_count));
782 rb_hash_aset (rv, rb_str_new2 ("vg_free_count"), ULL2NUM (r->val[i].vg_free_count));
783 rb_hash_aset (rv, rb_str_new2 ("max_lv"), ULL2NUM (r->val[i].max_lv));
784 rb_hash_aset (rv, rb_str_new2 ("max_pv"), ULL2NUM (r->val[i].max_pv));
785 rb_hash_aset (rv, rb_str_new2 ("pv_count"), ULL2NUM (r->val[i].pv_count));
786 rb_hash_aset (rv, rb_str_new2 ("lv_count"), ULL2NUM (r->val[i].lv_count));
787 rb_hash_aset (rv, rb_str_new2 ("snap_count"), ULL2NUM (r->val[i].snap_count));
788 rb_hash_aset (rv, rb_str_new2 ("vg_seqno"), ULL2NUM (r->val[i].vg_seqno));
789 rb_hash_aset (rv, rb_str_new2 ("vg_tags"), rb_str_new2 (r->val[i].vg_tags));
790 rb_hash_aset (rv, rb_str_new2 ("vg_mda_count"), ULL2NUM (r->val[i].vg_mda_count));
791 rb_hash_aset (rv, rb_str_new2 ("vg_mda_free"), ULL2NUM (r->val[i].vg_mda_free));
792 rb_ary_push (rv, hv);
794 guestfs_free_lvm_vg_list (r);
798 static VALUE ruby_guestfs_lvs_full (VALUE gv)
801 Data_Get_Struct (gv, guestfs_h, g);
803 rb_raise (rb_eArgError, "%s: used handle after closing it", "lvs_full");
806 struct guestfs_lvm_lv_list *r;
808 r = guestfs_lvs_full (g);
810 rb_raise (e_Error, "%s", guestfs_last_error (g));
812 VALUE rv = rb_ary_new2 (r->len);
814 for (i = 0; i < r->len; ++i) {
815 VALUE hv = rb_hash_new ();
816 rb_hash_aset (rv, rb_str_new2 ("lv_name"), rb_str_new2 (r->val[i].lv_name));
817 rb_hash_aset (rv, rb_str_new2 ("lv_uuid"), rb_str_new (r->val[i].lv_uuid, 32));
818 rb_hash_aset (rv, rb_str_new2 ("lv_attr"), rb_str_new2 (r->val[i].lv_attr));
819 rb_hash_aset (rv, rb_str_new2 ("lv_major"), ULL2NUM (r->val[i].lv_major));
820 rb_hash_aset (rv, rb_str_new2 ("lv_minor"), ULL2NUM (r->val[i].lv_minor));
821 rb_hash_aset (rv, rb_str_new2 ("lv_kernel_major"), ULL2NUM (r->val[i].lv_kernel_major));
822 rb_hash_aset (rv, rb_str_new2 ("lv_kernel_minor"), ULL2NUM (r->val[i].lv_kernel_minor));
823 rb_hash_aset (rv, rb_str_new2 ("lv_size"), ULL2NUM (r->val[i].lv_size));
824 rb_hash_aset (rv, rb_str_new2 ("seg_count"), ULL2NUM (r->val[i].seg_count));
825 rb_hash_aset (rv, rb_str_new2 ("origin"), rb_str_new2 (r->val[i].origin));
826 rb_hash_aset (rv, rb_str_new2 ("snap_percent"), rb_dbl2big (r->val[i].snap_percent));
827 rb_hash_aset (rv, rb_str_new2 ("copy_percent"), rb_dbl2big (r->val[i].copy_percent));
828 rb_hash_aset (rv, rb_str_new2 ("move_pv"), rb_str_new2 (r->val[i].move_pv));
829 rb_hash_aset (rv, rb_str_new2 ("lv_tags"), rb_str_new2 (r->val[i].lv_tags));
830 rb_hash_aset (rv, rb_str_new2 ("mirror_log"), rb_str_new2 (r->val[i].mirror_log));
831 rb_hash_aset (rv, rb_str_new2 ("modules"), rb_str_new2 (r->val[i].modules));
832 rb_ary_push (rv, hv);
834 guestfs_free_lvm_lv_list (r);
838 static VALUE ruby_guestfs_read_lines (VALUE gv, VALUE pathv)
841 Data_Get_Struct (gv, guestfs_h, g);
843 rb_raise (rb_eArgError, "%s: used handle after closing it", "read_lines");
845 const char *path = StringValueCStr (pathv);
847 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
848 "path", "read_lines");
852 r = guestfs_read_lines (g, path);
854 rb_raise (e_Error, "%s", guestfs_last_error (g));
857 for (i = 0; r[i] != NULL; ++i) len++;
858 VALUE rv = rb_ary_new2 (len);
859 for (i = 0; r[i] != NULL; ++i) {
860 rb_ary_push (rv, rb_str_new2 (r[i]));
867 static VALUE ruby_guestfs_aug_init (VALUE gv, VALUE rootv, VALUE flagsv)
870 Data_Get_Struct (gv, guestfs_h, g);
872 rb_raise (rb_eArgError, "%s: used handle after closing it", "aug_init");
874 const char *root = StringValueCStr (rootv);
876 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
878 int flags = NUM2INT (flagsv);
882 r = guestfs_aug_init (g, root, flags);
884 rb_raise (e_Error, "%s", guestfs_last_error (g));
889 static VALUE ruby_guestfs_aug_close (VALUE gv)
892 Data_Get_Struct (gv, guestfs_h, g);
894 rb_raise (rb_eArgError, "%s: used handle after closing it", "aug_close");
899 r = guestfs_aug_close (g);
901 rb_raise (e_Error, "%s", guestfs_last_error (g));
906 static VALUE ruby_guestfs_aug_defvar (VALUE gv, VALUE namev, VALUE exprv)
909 Data_Get_Struct (gv, guestfs_h, g);
911 rb_raise (rb_eArgError, "%s: used handle after closing it", "aug_defvar");
913 const char *name = StringValueCStr (namev);
915 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
916 "name", "aug_defvar");
917 const char *expr = StringValueCStr (exprv);
921 r = guestfs_aug_defvar (g, name, expr);
923 rb_raise (e_Error, "%s", guestfs_last_error (g));
928 static VALUE ruby_guestfs_aug_defnode (VALUE gv, VALUE namev, VALUE exprv, VALUE valv)
931 Data_Get_Struct (gv, guestfs_h, g);
933 rb_raise (rb_eArgError, "%s: used handle after closing it", "aug_defnode");
935 const char *name = StringValueCStr (namev);
937 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
938 "name", "aug_defnode");
939 const char *expr = StringValueCStr (exprv);
941 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
942 "expr", "aug_defnode");
943 const char *val = StringValueCStr (valv);
945 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
946 "val", "aug_defnode");
948 struct guestfs_int_bool *r;
950 r = guestfs_aug_defnode (g, name, expr, val);
952 rb_raise (e_Error, "%s", guestfs_last_error (g));
954 VALUE rv = rb_ary_new2 (2);
955 rb_ary_push (rv, INT2NUM (r->i));
956 rb_ary_push (rv, INT2NUM (r->b));
957 guestfs_free_int_bool (r);
961 static VALUE ruby_guestfs_aug_get (VALUE gv, VALUE pathv)
964 Data_Get_Struct (gv, guestfs_h, g);
966 rb_raise (rb_eArgError, "%s: used handle after closing it", "aug_get");
968 const char *path = StringValueCStr (pathv);
970 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
975 r = guestfs_aug_get (g, path);
977 rb_raise (e_Error, "%s", guestfs_last_error (g));
979 VALUE rv = rb_str_new2 (r);
984 static VALUE ruby_guestfs_aug_set (VALUE gv, VALUE pathv, VALUE valv)
987 Data_Get_Struct (gv, guestfs_h, g);
989 rb_raise (rb_eArgError, "%s: used handle after closing it", "aug_set");
991 const char *path = StringValueCStr (pathv);
993 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
995 const char *val = StringValueCStr (valv);
997 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1002 r = guestfs_aug_set (g, path, val);
1004 rb_raise (e_Error, "%s", guestfs_last_error (g));
1009 static VALUE ruby_guestfs_aug_insert (VALUE gv, VALUE pathv, VALUE labelv, VALUE beforev)
1012 Data_Get_Struct (gv, guestfs_h, g);
1014 rb_raise (rb_eArgError, "%s: used handle after closing it", "aug_insert");
1016 const char *path = StringValueCStr (pathv);
1018 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1019 "path", "aug_insert");
1020 const char *label = StringValueCStr (labelv);
1022 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1023 "label", "aug_insert");
1024 int before = NUM2INT (beforev);
1028 r = guestfs_aug_insert (g, path, label, before);
1030 rb_raise (e_Error, "%s", guestfs_last_error (g));
1035 static VALUE ruby_guestfs_aug_rm (VALUE gv, VALUE pathv)
1038 Data_Get_Struct (gv, guestfs_h, g);
1040 rb_raise (rb_eArgError, "%s: used handle after closing it", "aug_rm");
1042 const char *path = StringValueCStr (pathv);
1044 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1049 r = guestfs_aug_rm (g, path);
1051 rb_raise (e_Error, "%s", guestfs_last_error (g));
1056 static VALUE ruby_guestfs_aug_mv (VALUE gv, VALUE srcv, VALUE destv)
1059 Data_Get_Struct (gv, guestfs_h, g);
1061 rb_raise (rb_eArgError, "%s: used handle after closing it", "aug_mv");
1063 const char *src = StringValueCStr (srcv);
1065 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1067 const char *dest = StringValueCStr (destv);
1069 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1074 r = guestfs_aug_mv (g, src, dest);
1076 rb_raise (e_Error, "%s", guestfs_last_error (g));
1081 static VALUE ruby_guestfs_aug_match (VALUE gv, VALUE pathv)
1084 Data_Get_Struct (gv, guestfs_h, g);
1086 rb_raise (rb_eArgError, "%s: used handle after closing it", "aug_match");
1088 const char *path = StringValueCStr (pathv);
1090 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1091 "path", "aug_match");
1095 r = guestfs_aug_match (g, path);
1097 rb_raise (e_Error, "%s", guestfs_last_error (g));
1100 for (i = 0; r[i] != NULL; ++i) len++;
1101 VALUE rv = rb_ary_new2 (len);
1102 for (i = 0; r[i] != NULL; ++i) {
1103 rb_ary_push (rv, rb_str_new2 (r[i]));
1110 static VALUE ruby_guestfs_aug_save (VALUE gv)
1113 Data_Get_Struct (gv, guestfs_h, g);
1115 rb_raise (rb_eArgError, "%s: used handle after closing it", "aug_save");
1120 r = guestfs_aug_save (g);
1122 rb_raise (e_Error, "%s", guestfs_last_error (g));
1127 static VALUE ruby_guestfs_aug_load (VALUE gv)
1130 Data_Get_Struct (gv, guestfs_h, g);
1132 rb_raise (rb_eArgError, "%s: used handle after closing it", "aug_load");
1137 r = guestfs_aug_load (g);
1139 rb_raise (e_Error, "%s", guestfs_last_error (g));
1144 static VALUE ruby_guestfs_aug_ls (VALUE gv, VALUE pathv)
1147 Data_Get_Struct (gv, guestfs_h, g);
1149 rb_raise (rb_eArgError, "%s: used handle after closing it", "aug_ls");
1151 const char *path = StringValueCStr (pathv);
1153 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1158 r = guestfs_aug_ls (g, path);
1160 rb_raise (e_Error, "%s", guestfs_last_error (g));
1163 for (i = 0; r[i] != NULL; ++i) len++;
1164 VALUE rv = rb_ary_new2 (len);
1165 for (i = 0; r[i] != NULL; ++i) {
1166 rb_ary_push (rv, rb_str_new2 (r[i]));
1173 static VALUE ruby_guestfs_rm (VALUE gv, VALUE pathv)
1176 Data_Get_Struct (gv, guestfs_h, g);
1178 rb_raise (rb_eArgError, "%s: used handle after closing it", "rm");
1180 const char *path = StringValueCStr (pathv);
1182 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1187 r = guestfs_rm (g, path);
1189 rb_raise (e_Error, "%s", guestfs_last_error (g));
1194 static VALUE ruby_guestfs_rmdir (VALUE gv, VALUE pathv)
1197 Data_Get_Struct (gv, guestfs_h, g);
1199 rb_raise (rb_eArgError, "%s: used handle after closing it", "rmdir");
1201 const char *path = StringValueCStr (pathv);
1203 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1208 r = guestfs_rmdir (g, path);
1210 rb_raise (e_Error, "%s", guestfs_last_error (g));
1215 static VALUE ruby_guestfs_rm_rf (VALUE gv, VALUE pathv)
1218 Data_Get_Struct (gv, guestfs_h, g);
1220 rb_raise (rb_eArgError, "%s: used handle after closing it", "rm_rf");
1222 const char *path = StringValueCStr (pathv);
1224 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1229 r = guestfs_rm_rf (g, path);
1231 rb_raise (e_Error, "%s", guestfs_last_error (g));
1236 static VALUE ruby_guestfs_mkdir (VALUE gv, VALUE pathv)
1239 Data_Get_Struct (gv, guestfs_h, g);
1241 rb_raise (rb_eArgError, "%s: used handle after closing it", "mkdir");
1243 const char *path = StringValueCStr (pathv);
1245 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1250 r = guestfs_mkdir (g, path);
1252 rb_raise (e_Error, "%s", guestfs_last_error (g));
1257 static VALUE ruby_guestfs_mkdir_p (VALUE gv, VALUE pathv)
1260 Data_Get_Struct (gv, guestfs_h, g);
1262 rb_raise (rb_eArgError, "%s: used handle after closing it", "mkdir_p");
1264 const char *path = StringValueCStr (pathv);
1266 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1271 r = guestfs_mkdir_p (g, path);
1273 rb_raise (e_Error, "%s", guestfs_last_error (g));
1278 static VALUE ruby_guestfs_chmod (VALUE gv, VALUE modev, VALUE pathv)
1281 Data_Get_Struct (gv, guestfs_h, g);
1283 rb_raise (rb_eArgError, "%s: used handle after closing it", "chmod");
1285 int mode = NUM2INT (modev);
1286 const char *path = StringValueCStr (pathv);
1288 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1293 r = guestfs_chmod (g, mode, path);
1295 rb_raise (e_Error, "%s", guestfs_last_error (g));
1300 static VALUE ruby_guestfs_chown (VALUE gv, VALUE ownerv, VALUE groupv, VALUE pathv)
1303 Data_Get_Struct (gv, guestfs_h, g);
1305 rb_raise (rb_eArgError, "%s: used handle after closing it", "chown");
1307 int owner = NUM2INT (ownerv);
1308 int group = NUM2INT (groupv);
1309 const char *path = StringValueCStr (pathv);
1311 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1316 r = guestfs_chown (g, owner, group, path);
1318 rb_raise (e_Error, "%s", guestfs_last_error (g));
1323 static VALUE ruby_guestfs_exists (VALUE gv, VALUE pathv)
1326 Data_Get_Struct (gv, guestfs_h, g);
1328 rb_raise (rb_eArgError, "%s: used handle after closing it", "exists");
1330 const char *path = StringValueCStr (pathv);
1332 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1337 r = guestfs_exists (g, path);
1339 rb_raise (e_Error, "%s", guestfs_last_error (g));
1344 static VALUE ruby_guestfs_is_file (VALUE gv, VALUE pathv)
1347 Data_Get_Struct (gv, guestfs_h, g);
1349 rb_raise (rb_eArgError, "%s: used handle after closing it", "is_file");
1351 const char *path = StringValueCStr (pathv);
1353 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1358 r = guestfs_is_file (g, path);
1360 rb_raise (e_Error, "%s", guestfs_last_error (g));
1365 static VALUE ruby_guestfs_is_dir (VALUE gv, VALUE pathv)
1368 Data_Get_Struct (gv, guestfs_h, g);
1370 rb_raise (rb_eArgError, "%s: used handle after closing it", "is_dir");
1372 const char *path = StringValueCStr (pathv);
1374 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1379 r = guestfs_is_dir (g, path);
1381 rb_raise (e_Error, "%s", guestfs_last_error (g));
1386 static VALUE ruby_guestfs_pvcreate (VALUE gv, VALUE devicev)
1389 Data_Get_Struct (gv, guestfs_h, g);
1391 rb_raise (rb_eArgError, "%s: used handle after closing it", "pvcreate");
1393 const char *device = StringValueCStr (devicev);
1395 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1396 "device", "pvcreate");
1400 r = guestfs_pvcreate (g, device);
1402 rb_raise (e_Error, "%s", guestfs_last_error (g));
1407 static VALUE ruby_guestfs_vgcreate (VALUE gv, VALUE volgroupv, VALUE physvolsv)
1410 Data_Get_Struct (gv, guestfs_h, g);
1412 rb_raise (rb_eArgError, "%s: used handle after closing it", "vgcreate");
1414 const char *volgroup = StringValueCStr (volgroupv);
1416 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1417 "volgroup", "vgcreate");
1420 len = RARRAY_LEN (physvolsv);
1421 physvols = guestfs_safe_malloc (g, sizeof (char *) * (len+1));
1422 for (i = 0; i < len; ++i) {
1423 VALUE v = rb_ary_entry (physvolsv, i);
1424 physvols[i] = StringValueCStr (v);
1426 physvols[len] = NULL;
1431 r = guestfs_vgcreate (g, volgroup, physvols);
1434 rb_raise (e_Error, "%s", guestfs_last_error (g));
1439 static VALUE ruby_guestfs_lvcreate (VALUE gv, VALUE logvolv, VALUE volgroupv, VALUE mbytesv)
1442 Data_Get_Struct (gv, guestfs_h, g);
1444 rb_raise (rb_eArgError, "%s: used handle after closing it", "lvcreate");
1446 const char *logvol = StringValueCStr (logvolv);
1448 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1449 "logvol", "lvcreate");
1450 const char *volgroup = StringValueCStr (volgroupv);
1452 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1453 "volgroup", "lvcreate");
1454 int mbytes = NUM2INT (mbytesv);
1458 r = guestfs_lvcreate (g, logvol, volgroup, mbytes);
1460 rb_raise (e_Error, "%s", guestfs_last_error (g));
1465 static VALUE ruby_guestfs_mkfs (VALUE gv, VALUE fstypev, VALUE devicev)
1468 Data_Get_Struct (gv, guestfs_h, g);
1470 rb_raise (rb_eArgError, "%s: used handle after closing it", "mkfs");
1472 const char *fstype = StringValueCStr (fstypev);
1474 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1476 const char *device = StringValueCStr (devicev);
1478 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1483 r = guestfs_mkfs (g, fstype, device);
1485 rb_raise (e_Error, "%s", guestfs_last_error (g));
1490 static VALUE ruby_guestfs_sfdisk (VALUE gv, VALUE devicev, VALUE cylsv, VALUE headsv, VALUE sectorsv, VALUE linesv)
1493 Data_Get_Struct (gv, guestfs_h, g);
1495 rb_raise (rb_eArgError, "%s: used handle after closing it", "sfdisk");
1497 const char *device = StringValueCStr (devicev);
1499 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1500 "device", "sfdisk");
1501 int cyls = NUM2INT (cylsv);
1502 int heads = NUM2INT (headsv);
1503 int sectors = NUM2INT (sectorsv);
1506 len = RARRAY_LEN (linesv);
1507 lines = guestfs_safe_malloc (g, sizeof (char *) * (len+1));
1508 for (i = 0; i < len; ++i) {
1509 VALUE v = rb_ary_entry (linesv, i);
1510 lines[i] = StringValueCStr (v);
1517 r = guestfs_sfdisk (g, device, cyls, heads, sectors, lines);
1520 rb_raise (e_Error, "%s", guestfs_last_error (g));
1525 static VALUE ruby_guestfs_write_file (VALUE gv, VALUE pathv, VALUE contentv, VALUE sizev)
1528 Data_Get_Struct (gv, guestfs_h, g);
1530 rb_raise (rb_eArgError, "%s: used handle after closing it", "write_file");
1532 const char *path = StringValueCStr (pathv);
1534 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1535 "path", "write_file");
1536 const char *content = StringValueCStr (contentv);
1538 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1539 "content", "write_file");
1540 int size = NUM2INT (sizev);
1544 r = guestfs_write_file (g, path, content, size);
1546 rb_raise (e_Error, "%s", guestfs_last_error (g));
1551 static VALUE ruby_guestfs_umount (VALUE gv, VALUE pathordevicev)
1554 Data_Get_Struct (gv, guestfs_h, g);
1556 rb_raise (rb_eArgError, "%s: used handle after closing it", "umount");
1558 const char *pathordevice = StringValueCStr (pathordevicev);
1560 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1561 "pathordevice", "umount");
1565 r = guestfs_umount (g, pathordevice);
1567 rb_raise (e_Error, "%s", guestfs_last_error (g));
1572 static VALUE ruby_guestfs_mounts (VALUE gv)
1575 Data_Get_Struct (gv, guestfs_h, g);
1577 rb_raise (rb_eArgError, "%s: used handle after closing it", "mounts");
1582 r = guestfs_mounts (g);
1584 rb_raise (e_Error, "%s", guestfs_last_error (g));
1587 for (i = 0; r[i] != NULL; ++i) len++;
1588 VALUE rv = rb_ary_new2 (len);
1589 for (i = 0; r[i] != NULL; ++i) {
1590 rb_ary_push (rv, rb_str_new2 (r[i]));
1597 static VALUE ruby_guestfs_umount_all (VALUE gv)
1600 Data_Get_Struct (gv, guestfs_h, g);
1602 rb_raise (rb_eArgError, "%s: used handle after closing it", "umount_all");
1607 r = guestfs_umount_all (g);
1609 rb_raise (e_Error, "%s", guestfs_last_error (g));
1614 static VALUE ruby_guestfs_lvm_remove_all (VALUE gv)
1617 Data_Get_Struct (gv, guestfs_h, g);
1619 rb_raise (rb_eArgError, "%s: used handle after closing it", "lvm_remove_all");
1624 r = guestfs_lvm_remove_all (g);
1626 rb_raise (e_Error, "%s", guestfs_last_error (g));
1631 static VALUE ruby_guestfs_file (VALUE gv, VALUE pathv)
1634 Data_Get_Struct (gv, guestfs_h, g);
1636 rb_raise (rb_eArgError, "%s: used handle after closing it", "file");
1638 const char *path = StringValueCStr (pathv);
1640 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1645 r = guestfs_file (g, path);
1647 rb_raise (e_Error, "%s", guestfs_last_error (g));
1649 VALUE rv = rb_str_new2 (r);
1654 static VALUE ruby_guestfs_command (VALUE gv, VALUE argumentsv)
1657 Data_Get_Struct (gv, guestfs_h, g);
1659 rb_raise (rb_eArgError, "%s: used handle after closing it", "command");
1663 len = RARRAY_LEN (argumentsv);
1664 arguments = guestfs_safe_malloc (g, sizeof (char *) * (len+1));
1665 for (i = 0; i < len; ++i) {
1666 VALUE v = rb_ary_entry (argumentsv, i);
1667 arguments[i] = StringValueCStr (v);
1669 arguments[len] = NULL;
1674 r = guestfs_command (g, arguments);
1677 rb_raise (e_Error, "%s", guestfs_last_error (g));
1679 VALUE rv = rb_str_new2 (r);
1684 static VALUE ruby_guestfs_command_lines (VALUE gv, VALUE argumentsv)
1687 Data_Get_Struct (gv, guestfs_h, g);
1689 rb_raise (rb_eArgError, "%s: used handle after closing it", "command_lines");
1693 len = RARRAY_LEN (argumentsv);
1694 arguments = guestfs_safe_malloc (g, sizeof (char *) * (len+1));
1695 for (i = 0; i < len; ++i) {
1696 VALUE v = rb_ary_entry (argumentsv, i);
1697 arguments[i] = StringValueCStr (v);
1699 arguments[len] = NULL;
1704 r = guestfs_command_lines (g, arguments);
1707 rb_raise (e_Error, "%s", guestfs_last_error (g));
1710 for (i = 0; r[i] != NULL; ++i) len++;
1711 VALUE rv = rb_ary_new2 (len);
1712 for (i = 0; r[i] != NULL; ++i) {
1713 rb_ary_push (rv, rb_str_new2 (r[i]));
1720 static VALUE ruby_guestfs_stat (VALUE gv, VALUE pathv)
1723 Data_Get_Struct (gv, guestfs_h, g);
1725 rb_raise (rb_eArgError, "%s: used handle after closing it", "stat");
1727 const char *path = StringValueCStr (pathv);
1729 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1732 struct guestfs_stat *r;
1734 r = guestfs_stat (g, path);
1736 rb_raise (e_Error, "%s", guestfs_last_error (g));
1738 VALUE rv = rb_hash_new ();
1739 rb_hash_aset (rv, rb_str_new2 ("dev"), ULL2NUM (r->dev));
1740 rb_hash_aset (rv, rb_str_new2 ("ino"), ULL2NUM (r->ino));
1741 rb_hash_aset (rv, rb_str_new2 ("mode"), ULL2NUM (r->mode));
1742 rb_hash_aset (rv, rb_str_new2 ("nlink"), ULL2NUM (r->nlink));
1743 rb_hash_aset (rv, rb_str_new2 ("uid"), ULL2NUM (r->uid));
1744 rb_hash_aset (rv, rb_str_new2 ("gid"), ULL2NUM (r->gid));
1745 rb_hash_aset (rv, rb_str_new2 ("rdev"), ULL2NUM (r->rdev));
1746 rb_hash_aset (rv, rb_str_new2 ("size"), ULL2NUM (r->size));
1747 rb_hash_aset (rv, rb_str_new2 ("blksize"), ULL2NUM (r->blksize));
1748 rb_hash_aset (rv, rb_str_new2 ("blocks"), ULL2NUM (r->blocks));
1749 rb_hash_aset (rv, rb_str_new2 ("atime"), ULL2NUM (r->atime));
1750 rb_hash_aset (rv, rb_str_new2 ("mtime"), ULL2NUM (r->mtime));
1751 rb_hash_aset (rv, rb_str_new2 ("ctime"), ULL2NUM (r->ctime));
1756 static VALUE ruby_guestfs_lstat (VALUE gv, VALUE pathv)
1759 Data_Get_Struct (gv, guestfs_h, g);
1761 rb_raise (rb_eArgError, "%s: used handle after closing it", "lstat");
1763 const char *path = StringValueCStr (pathv);
1765 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1768 struct guestfs_stat *r;
1770 r = guestfs_lstat (g, path);
1772 rb_raise (e_Error, "%s", guestfs_last_error (g));
1774 VALUE rv = rb_hash_new ();
1775 rb_hash_aset (rv, rb_str_new2 ("dev"), ULL2NUM (r->dev));
1776 rb_hash_aset (rv, rb_str_new2 ("ino"), ULL2NUM (r->ino));
1777 rb_hash_aset (rv, rb_str_new2 ("mode"), ULL2NUM (r->mode));
1778 rb_hash_aset (rv, rb_str_new2 ("nlink"), ULL2NUM (r->nlink));
1779 rb_hash_aset (rv, rb_str_new2 ("uid"), ULL2NUM (r->uid));
1780 rb_hash_aset (rv, rb_str_new2 ("gid"), ULL2NUM (r->gid));
1781 rb_hash_aset (rv, rb_str_new2 ("rdev"), ULL2NUM (r->rdev));
1782 rb_hash_aset (rv, rb_str_new2 ("size"), ULL2NUM (r->size));
1783 rb_hash_aset (rv, rb_str_new2 ("blksize"), ULL2NUM (r->blksize));
1784 rb_hash_aset (rv, rb_str_new2 ("blocks"), ULL2NUM (r->blocks));
1785 rb_hash_aset (rv, rb_str_new2 ("atime"), ULL2NUM (r->atime));
1786 rb_hash_aset (rv, rb_str_new2 ("mtime"), ULL2NUM (r->mtime));
1787 rb_hash_aset (rv, rb_str_new2 ("ctime"), ULL2NUM (r->ctime));
1792 static VALUE ruby_guestfs_statvfs (VALUE gv, VALUE pathv)
1795 Data_Get_Struct (gv, guestfs_h, g);
1797 rb_raise (rb_eArgError, "%s: used handle after closing it", "statvfs");
1799 const char *path = StringValueCStr (pathv);
1801 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1804 struct guestfs_statvfs *r;
1806 r = guestfs_statvfs (g, path);
1808 rb_raise (e_Error, "%s", guestfs_last_error (g));
1810 VALUE rv = rb_hash_new ();
1811 rb_hash_aset (rv, rb_str_new2 ("bsize"), ULL2NUM (r->bsize));
1812 rb_hash_aset (rv, rb_str_new2 ("frsize"), ULL2NUM (r->frsize));
1813 rb_hash_aset (rv, rb_str_new2 ("blocks"), ULL2NUM (r->blocks));
1814 rb_hash_aset (rv, rb_str_new2 ("bfree"), ULL2NUM (r->bfree));
1815 rb_hash_aset (rv, rb_str_new2 ("bavail"), ULL2NUM (r->bavail));
1816 rb_hash_aset (rv, rb_str_new2 ("files"), ULL2NUM (r->files));
1817 rb_hash_aset (rv, rb_str_new2 ("ffree"), ULL2NUM (r->ffree));
1818 rb_hash_aset (rv, rb_str_new2 ("favail"), ULL2NUM (r->favail));
1819 rb_hash_aset (rv, rb_str_new2 ("fsid"), ULL2NUM (r->fsid));
1820 rb_hash_aset (rv, rb_str_new2 ("flag"), ULL2NUM (r->flag));
1821 rb_hash_aset (rv, rb_str_new2 ("namemax"), ULL2NUM (r->namemax));
1826 static VALUE ruby_guestfs_tune2fs_l (VALUE gv, VALUE devicev)
1829 Data_Get_Struct (gv, guestfs_h, g);
1831 rb_raise (rb_eArgError, "%s: used handle after closing it", "tune2fs_l");
1833 const char *device = StringValueCStr (devicev);
1835 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1836 "device", "tune2fs_l");
1840 r = guestfs_tune2fs_l (g, device);
1842 rb_raise (e_Error, "%s", guestfs_last_error (g));
1844 VALUE rv = rb_hash_new ();
1846 for (i = 0; r[i] != NULL; i+=2) {
1847 rb_hash_aset (rv, rb_str_new2 (r[i]), rb_str_new2 (r[i+1]));
1855 static VALUE ruby_guestfs_blockdev_setro (VALUE gv, VALUE devicev)
1858 Data_Get_Struct (gv, guestfs_h, g);
1860 rb_raise (rb_eArgError, "%s: used handle after closing it", "blockdev_setro");
1862 const char *device = StringValueCStr (devicev);
1864 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1865 "device", "blockdev_setro");
1869 r = guestfs_blockdev_setro (g, device);
1871 rb_raise (e_Error, "%s", guestfs_last_error (g));
1876 static VALUE ruby_guestfs_blockdev_setrw (VALUE gv, VALUE devicev)
1879 Data_Get_Struct (gv, guestfs_h, g);
1881 rb_raise (rb_eArgError, "%s: used handle after closing it", "blockdev_setrw");
1883 const char *device = StringValueCStr (devicev);
1885 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1886 "device", "blockdev_setrw");
1890 r = guestfs_blockdev_setrw (g, device);
1892 rb_raise (e_Error, "%s", guestfs_last_error (g));
1897 static VALUE ruby_guestfs_blockdev_getro (VALUE gv, VALUE devicev)
1900 Data_Get_Struct (gv, guestfs_h, g);
1902 rb_raise (rb_eArgError, "%s: used handle after closing it", "blockdev_getro");
1904 const char *device = StringValueCStr (devicev);
1906 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1907 "device", "blockdev_getro");
1911 r = guestfs_blockdev_getro (g, device);
1913 rb_raise (e_Error, "%s", guestfs_last_error (g));
1918 static VALUE ruby_guestfs_blockdev_getss (VALUE gv, VALUE devicev)
1921 Data_Get_Struct (gv, guestfs_h, g);
1923 rb_raise (rb_eArgError, "%s: used handle after closing it", "blockdev_getss");
1925 const char *device = StringValueCStr (devicev);
1927 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1928 "device", "blockdev_getss");
1932 r = guestfs_blockdev_getss (g, device);
1934 rb_raise (e_Error, "%s", guestfs_last_error (g));
1939 static VALUE ruby_guestfs_blockdev_getbsz (VALUE gv, VALUE devicev)
1942 Data_Get_Struct (gv, guestfs_h, g);
1944 rb_raise (rb_eArgError, "%s: used handle after closing it", "blockdev_getbsz");
1946 const char *device = StringValueCStr (devicev);
1948 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1949 "device", "blockdev_getbsz");
1953 r = guestfs_blockdev_getbsz (g, device);
1955 rb_raise (e_Error, "%s", guestfs_last_error (g));
1960 static VALUE ruby_guestfs_blockdev_setbsz (VALUE gv, VALUE devicev, VALUE blocksizev)
1963 Data_Get_Struct (gv, guestfs_h, g);
1965 rb_raise (rb_eArgError, "%s: used handle after closing it", "blockdev_setbsz");
1967 const char *device = StringValueCStr (devicev);
1969 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1970 "device", "blockdev_setbsz");
1971 int blocksize = NUM2INT (blocksizev);
1975 r = guestfs_blockdev_setbsz (g, device, blocksize);
1977 rb_raise (e_Error, "%s", guestfs_last_error (g));
1982 static VALUE ruby_guestfs_blockdev_getsz (VALUE gv, VALUE devicev)
1985 Data_Get_Struct (gv, guestfs_h, g);
1987 rb_raise (rb_eArgError, "%s: used handle after closing it", "blockdev_getsz");
1989 const char *device = StringValueCStr (devicev);
1991 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1992 "device", "blockdev_getsz");
1996 r = guestfs_blockdev_getsz (g, device);
1998 rb_raise (e_Error, "%s", guestfs_last_error (g));
2003 static VALUE ruby_guestfs_blockdev_getsize64 (VALUE gv, VALUE devicev)
2006 Data_Get_Struct (gv, guestfs_h, g);
2008 rb_raise (rb_eArgError, "%s: used handle after closing it", "blockdev_getsize64");
2010 const char *device = StringValueCStr (devicev);
2012 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2013 "device", "blockdev_getsize64");
2017 r = guestfs_blockdev_getsize64 (g, device);
2019 rb_raise (e_Error, "%s", guestfs_last_error (g));
2024 static VALUE ruby_guestfs_blockdev_flushbufs (VALUE gv, VALUE devicev)
2027 Data_Get_Struct (gv, guestfs_h, g);
2029 rb_raise (rb_eArgError, "%s: used handle after closing it", "blockdev_flushbufs");
2031 const char *device = StringValueCStr (devicev);
2033 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2034 "device", "blockdev_flushbufs");
2038 r = guestfs_blockdev_flushbufs (g, device);
2040 rb_raise (e_Error, "%s", guestfs_last_error (g));
2045 static VALUE ruby_guestfs_blockdev_rereadpt (VALUE gv, VALUE devicev)
2048 Data_Get_Struct (gv, guestfs_h, g);
2050 rb_raise (rb_eArgError, "%s: used handle after closing it", "blockdev_rereadpt");
2052 const char *device = StringValueCStr (devicev);
2054 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2055 "device", "blockdev_rereadpt");
2059 r = guestfs_blockdev_rereadpt (g, device);
2061 rb_raise (e_Error, "%s", guestfs_last_error (g));
2066 static VALUE ruby_guestfs_upload (VALUE gv, VALUE filenamev, VALUE remotefilenamev)
2069 Data_Get_Struct (gv, guestfs_h, g);
2071 rb_raise (rb_eArgError, "%s: used handle after closing it", "upload");
2073 const char *filename = StringValueCStr (filenamev);
2075 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2076 "filename", "upload");
2077 const char *remotefilename = StringValueCStr (remotefilenamev);
2078 if (!remotefilename)
2079 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2080 "remotefilename", "upload");
2084 r = guestfs_upload (g, filename, remotefilename);
2086 rb_raise (e_Error, "%s", guestfs_last_error (g));
2091 static VALUE ruby_guestfs_download (VALUE gv, VALUE remotefilenamev, VALUE filenamev)
2094 Data_Get_Struct (gv, guestfs_h, g);
2096 rb_raise (rb_eArgError, "%s: used handle after closing it", "download");
2098 const char *remotefilename = StringValueCStr (remotefilenamev);
2099 if (!remotefilename)
2100 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2101 "remotefilename", "download");
2102 const char *filename = StringValueCStr (filenamev);
2104 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2105 "filename", "download");
2109 r = guestfs_download (g, remotefilename, filename);
2111 rb_raise (e_Error, "%s", guestfs_last_error (g));
2116 static VALUE ruby_guestfs_checksum (VALUE gv, VALUE csumtypev, VALUE pathv)
2119 Data_Get_Struct (gv, guestfs_h, g);
2121 rb_raise (rb_eArgError, "%s: used handle after closing it", "checksum");
2123 const char *csumtype = StringValueCStr (csumtypev);
2125 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2126 "csumtype", "checksum");
2127 const char *path = StringValueCStr (pathv);
2129 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2130 "path", "checksum");
2134 r = guestfs_checksum (g, csumtype, path);
2136 rb_raise (e_Error, "%s", guestfs_last_error (g));
2138 VALUE rv = rb_str_new2 (r);
2143 static VALUE ruby_guestfs_tar_in (VALUE gv, VALUE tarfilev, VALUE directoryv)
2146 Data_Get_Struct (gv, guestfs_h, g);
2148 rb_raise (rb_eArgError, "%s: used handle after closing it", "tar_in");
2150 const char *tarfile = StringValueCStr (tarfilev);
2152 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2153 "tarfile", "tar_in");
2154 const char *directory = StringValueCStr (directoryv);
2156 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2157 "directory", "tar_in");
2161 r = guestfs_tar_in (g, tarfile, directory);
2163 rb_raise (e_Error, "%s", guestfs_last_error (g));
2168 static VALUE ruby_guestfs_tar_out (VALUE gv, VALUE directoryv, VALUE tarfilev)
2171 Data_Get_Struct (gv, guestfs_h, g);
2173 rb_raise (rb_eArgError, "%s: used handle after closing it", "tar_out");
2175 const char *directory = StringValueCStr (directoryv);
2177 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2178 "directory", "tar_out");
2179 const char *tarfile = StringValueCStr (tarfilev);
2181 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2182 "tarfile", "tar_out");
2186 r = guestfs_tar_out (g, directory, tarfile);
2188 rb_raise (e_Error, "%s", guestfs_last_error (g));
2193 static VALUE ruby_guestfs_tgz_in (VALUE gv, VALUE tarballv, VALUE directoryv)
2196 Data_Get_Struct (gv, guestfs_h, g);
2198 rb_raise (rb_eArgError, "%s: used handle after closing it", "tgz_in");
2200 const char *tarball = StringValueCStr (tarballv);
2202 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2203 "tarball", "tgz_in");
2204 const char *directory = StringValueCStr (directoryv);
2206 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2207 "directory", "tgz_in");
2211 r = guestfs_tgz_in (g, tarball, directory);
2213 rb_raise (e_Error, "%s", guestfs_last_error (g));
2218 static VALUE ruby_guestfs_tgz_out (VALUE gv, VALUE directoryv, VALUE tarballv)
2221 Data_Get_Struct (gv, guestfs_h, g);
2223 rb_raise (rb_eArgError, "%s: used handle after closing it", "tgz_out");
2225 const char *directory = StringValueCStr (directoryv);
2227 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2228 "directory", "tgz_out");
2229 const char *tarball = StringValueCStr (tarballv);
2231 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2232 "tarball", "tgz_out");
2236 r = guestfs_tgz_out (g, directory, tarball);
2238 rb_raise (e_Error, "%s", guestfs_last_error (g));
2243 static VALUE ruby_guestfs_mount_ro (VALUE gv, VALUE devicev, VALUE mountpointv)
2246 Data_Get_Struct (gv, guestfs_h, g);
2248 rb_raise (rb_eArgError, "%s: used handle after closing it", "mount_ro");
2250 const char *device = StringValueCStr (devicev);
2252 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2253 "device", "mount_ro");
2254 const char *mountpoint = StringValueCStr (mountpointv);
2256 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2257 "mountpoint", "mount_ro");
2261 r = guestfs_mount_ro (g, device, mountpoint);
2263 rb_raise (e_Error, "%s", guestfs_last_error (g));
2268 static VALUE ruby_guestfs_mount_options (VALUE gv, VALUE optionsv, VALUE devicev, VALUE mountpointv)
2271 Data_Get_Struct (gv, guestfs_h, g);
2273 rb_raise (rb_eArgError, "%s: used handle after closing it", "mount_options");
2275 const char *options = StringValueCStr (optionsv);
2277 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2278 "options", "mount_options");
2279 const char *device = StringValueCStr (devicev);
2281 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2282 "device", "mount_options");
2283 const char *mountpoint = StringValueCStr (mountpointv);
2285 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2286 "mountpoint", "mount_options");
2290 r = guestfs_mount_options (g, options, device, mountpoint);
2292 rb_raise (e_Error, "%s", guestfs_last_error (g));
2297 static VALUE ruby_guestfs_mount_vfs (VALUE gv, VALUE optionsv, VALUE vfstypev, VALUE devicev, VALUE mountpointv)
2300 Data_Get_Struct (gv, guestfs_h, g);
2302 rb_raise (rb_eArgError, "%s: used handle after closing it", "mount_vfs");
2304 const char *options = StringValueCStr (optionsv);
2306 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2307 "options", "mount_vfs");
2308 const char *vfstype = StringValueCStr (vfstypev);
2310 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2311 "vfstype", "mount_vfs");
2312 const char *device = StringValueCStr (devicev);
2314 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2315 "device", "mount_vfs");
2316 const char *mountpoint = StringValueCStr (mountpointv);
2318 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2319 "mountpoint", "mount_vfs");
2323 r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint);
2325 rb_raise (e_Error, "%s", guestfs_last_error (g));
2330 static VALUE ruby_guestfs_debug (VALUE gv, VALUE subcmdv, VALUE extraargsv)
2333 Data_Get_Struct (gv, guestfs_h, g);
2335 rb_raise (rb_eArgError, "%s: used handle after closing it", "debug");
2337 const char *subcmd = StringValueCStr (subcmdv);
2339 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2343 len = RARRAY_LEN (extraargsv);
2344 extraargs = guestfs_safe_malloc (g, sizeof (char *) * (len+1));
2345 for (i = 0; i < len; ++i) {
2346 VALUE v = rb_ary_entry (extraargsv, i);
2347 extraargs[i] = StringValueCStr (v);
2349 extraargs[len] = NULL;
2354 r = guestfs_debug (g, subcmd, extraargs);
2357 rb_raise (e_Error, "%s", guestfs_last_error (g));
2359 VALUE rv = rb_str_new2 (r);
2364 static VALUE ruby_guestfs_lvremove (VALUE gv, VALUE devicev)
2367 Data_Get_Struct (gv, guestfs_h, g);
2369 rb_raise (rb_eArgError, "%s: used handle after closing it", "lvremove");
2371 const char *device = StringValueCStr (devicev);
2373 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2374 "device", "lvremove");
2378 r = guestfs_lvremove (g, device);
2380 rb_raise (e_Error, "%s", guestfs_last_error (g));
2385 static VALUE ruby_guestfs_vgremove (VALUE gv, VALUE vgnamev)
2388 Data_Get_Struct (gv, guestfs_h, g);
2390 rb_raise (rb_eArgError, "%s: used handle after closing it", "vgremove");
2392 const char *vgname = StringValueCStr (vgnamev);
2394 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2395 "vgname", "vgremove");
2399 r = guestfs_vgremove (g, vgname);
2401 rb_raise (e_Error, "%s", guestfs_last_error (g));
2406 static VALUE ruby_guestfs_pvremove (VALUE gv, VALUE devicev)
2409 Data_Get_Struct (gv, guestfs_h, g);
2411 rb_raise (rb_eArgError, "%s: used handle after closing it", "pvremove");
2413 const char *device = StringValueCStr (devicev);
2415 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2416 "device", "pvremove");
2420 r = guestfs_pvremove (g, device);
2422 rb_raise (e_Error, "%s", guestfs_last_error (g));
2427 static VALUE ruby_guestfs_set_e2label (VALUE gv, VALUE devicev, VALUE labelv)
2430 Data_Get_Struct (gv, guestfs_h, g);
2432 rb_raise (rb_eArgError, "%s: used handle after closing it", "set_e2label");
2434 const char *device = StringValueCStr (devicev);
2436 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2437 "device", "set_e2label");
2438 const char *label = StringValueCStr (labelv);
2440 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2441 "label", "set_e2label");
2445 r = guestfs_set_e2label (g, device, label);
2447 rb_raise (e_Error, "%s", guestfs_last_error (g));
2452 static VALUE ruby_guestfs_get_e2label (VALUE gv, VALUE devicev)
2455 Data_Get_Struct (gv, guestfs_h, g);
2457 rb_raise (rb_eArgError, "%s: used handle after closing it", "get_e2label");
2459 const char *device = StringValueCStr (devicev);
2461 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2462 "device", "get_e2label");
2466 r = guestfs_get_e2label (g, device);
2468 rb_raise (e_Error, "%s", guestfs_last_error (g));
2470 VALUE rv = rb_str_new2 (r);
2475 static VALUE ruby_guestfs_set_e2uuid (VALUE gv, VALUE devicev, VALUE uuidv)
2478 Data_Get_Struct (gv, guestfs_h, g);
2480 rb_raise (rb_eArgError, "%s: used handle after closing it", "set_e2uuid");
2482 const char *device = StringValueCStr (devicev);
2484 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2485 "device", "set_e2uuid");
2486 const char *uuid = StringValueCStr (uuidv);
2488 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2489 "uuid", "set_e2uuid");
2493 r = guestfs_set_e2uuid (g, device, uuid);
2495 rb_raise (e_Error, "%s", guestfs_last_error (g));
2500 static VALUE ruby_guestfs_get_e2uuid (VALUE gv, VALUE devicev)
2503 Data_Get_Struct (gv, guestfs_h, g);
2505 rb_raise (rb_eArgError, "%s: used handle after closing it", "get_e2uuid");
2507 const char *device = StringValueCStr (devicev);
2509 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2510 "device", "get_e2uuid");
2514 r = guestfs_get_e2uuid (g, device);
2516 rb_raise (e_Error, "%s", guestfs_last_error (g));
2518 VALUE rv = rb_str_new2 (r);
2523 static VALUE ruby_guestfs_fsck (VALUE gv, VALUE fstypev, VALUE devicev)
2526 Data_Get_Struct (gv, guestfs_h, g);
2528 rb_raise (rb_eArgError, "%s: used handle after closing it", "fsck");
2530 const char *fstype = StringValueCStr (fstypev);
2532 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2534 const char *device = StringValueCStr (devicev);
2536 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2541 r = guestfs_fsck (g, fstype, device);
2543 rb_raise (e_Error, "%s", guestfs_last_error (g));
2548 static VALUE ruby_guestfs_zero (VALUE gv, VALUE devicev)
2551 Data_Get_Struct (gv, guestfs_h, g);
2553 rb_raise (rb_eArgError, "%s: used handle after closing it", "zero");
2555 const char *device = StringValueCStr (devicev);
2557 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2562 r = guestfs_zero (g, device);
2564 rb_raise (e_Error, "%s", guestfs_last_error (g));
2569 static VALUE ruby_guestfs_grub_install (VALUE gv, VALUE rootv, VALUE devicev)
2572 Data_Get_Struct (gv, guestfs_h, g);
2574 rb_raise (rb_eArgError, "%s: used handle after closing it", "grub_install");
2576 const char *root = StringValueCStr (rootv);
2578 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2579 "root", "grub_install");
2580 const char *device = StringValueCStr (devicev);
2582 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2583 "device", "grub_install");
2587 r = guestfs_grub_install (g, root, device);
2589 rb_raise (e_Error, "%s", guestfs_last_error (g));
2594 static VALUE ruby_guestfs_cp (VALUE gv, VALUE srcv, VALUE destv)
2597 Data_Get_Struct (gv, guestfs_h, g);
2599 rb_raise (rb_eArgError, "%s: used handle after closing it", "cp");
2601 const char *src = StringValueCStr (srcv);
2603 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2605 const char *dest = StringValueCStr (destv);
2607 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2612 r = guestfs_cp (g, src, dest);
2614 rb_raise (e_Error, "%s", guestfs_last_error (g));
2619 static VALUE ruby_guestfs_cp_a (VALUE gv, VALUE srcv, VALUE destv)
2622 Data_Get_Struct (gv, guestfs_h, g);
2624 rb_raise (rb_eArgError, "%s: used handle after closing it", "cp_a");
2626 const char *src = StringValueCStr (srcv);
2628 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2630 const char *dest = StringValueCStr (destv);
2632 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2637 r = guestfs_cp_a (g, src, dest);
2639 rb_raise (e_Error, "%s", guestfs_last_error (g));
2644 static VALUE ruby_guestfs_mv (VALUE gv, VALUE srcv, VALUE destv)
2647 Data_Get_Struct (gv, guestfs_h, g);
2649 rb_raise (rb_eArgError, "%s: used handle after closing it", "mv");
2651 const char *src = StringValueCStr (srcv);
2653 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2655 const char *dest = StringValueCStr (destv);
2657 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2662 r = guestfs_mv (g, src, dest);
2664 rb_raise (e_Error, "%s", guestfs_last_error (g));
2669 static VALUE ruby_guestfs_drop_caches (VALUE gv, VALUE whattodropv)
2672 Data_Get_Struct (gv, guestfs_h, g);
2674 rb_raise (rb_eArgError, "%s: used handle after closing it", "drop_caches");
2676 int whattodrop = NUM2INT (whattodropv);
2680 r = guestfs_drop_caches (g, whattodrop);
2682 rb_raise (e_Error, "%s", guestfs_last_error (g));
2687 static VALUE ruby_guestfs_dmesg (VALUE gv)
2690 Data_Get_Struct (gv, guestfs_h, g);
2692 rb_raise (rb_eArgError, "%s: used handle after closing it", "dmesg");
2697 r = guestfs_dmesg (g);
2699 rb_raise (e_Error, "%s", guestfs_last_error (g));
2701 VALUE rv = rb_str_new2 (r);
2706 static VALUE ruby_guestfs_ping_daemon (VALUE gv)
2709 Data_Get_Struct (gv, guestfs_h, g);
2711 rb_raise (rb_eArgError, "%s: used handle after closing it", "ping_daemon");
2716 r = guestfs_ping_daemon (g);
2718 rb_raise (e_Error, "%s", guestfs_last_error (g));
2723 static VALUE ruby_guestfs_equal (VALUE gv, VALUE file1v, VALUE file2v)
2726 Data_Get_Struct (gv, guestfs_h, g);
2728 rb_raise (rb_eArgError, "%s: used handle after closing it", "equal");
2730 const char *file1 = StringValueCStr (file1v);
2732 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2734 const char *file2 = StringValueCStr (file2v);
2736 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2741 r = guestfs_equal (g, file1, file2);
2743 rb_raise (e_Error, "%s", guestfs_last_error (g));
2748 /* Initialize the module. */
2749 void Init__guestfs ()
2751 m_guestfs = rb_define_module ("Guestfs");
2752 c_guestfs = rb_define_class_under (m_guestfs, "Guestfs", rb_cObject);
2753 e_Error = rb_define_class_under (m_guestfs, "Error", rb_eStandardError);
2755 rb_define_module_function (m_guestfs, "create", ruby_guestfs_create, 0);
2756 rb_define_method (c_guestfs, "close", ruby_guestfs_close, 0);
2758 rb_define_method (c_guestfs, "launch",
2759 ruby_guestfs_launch, 0);
2760 rb_define_method (c_guestfs, "wait_ready",
2761 ruby_guestfs_wait_ready, 0);
2762 rb_define_method (c_guestfs, "kill_subprocess",
2763 ruby_guestfs_kill_subprocess, 0);
2764 rb_define_method (c_guestfs, "add_drive",
2765 ruby_guestfs_add_drive, 1);
2766 rb_define_method (c_guestfs, "add_cdrom",
2767 ruby_guestfs_add_cdrom, 1);
2768 rb_define_method (c_guestfs, "config",
2769 ruby_guestfs_config, 2);
2770 rb_define_method (c_guestfs, "set_qemu",
2771 ruby_guestfs_set_qemu, 1);
2772 rb_define_method (c_guestfs, "get_qemu",
2773 ruby_guestfs_get_qemu, 0);
2774 rb_define_method (c_guestfs, "set_path",
2775 ruby_guestfs_set_path, 1);
2776 rb_define_method (c_guestfs, "get_path",
2777 ruby_guestfs_get_path, 0);
2778 rb_define_method (c_guestfs, "set_autosync",
2779 ruby_guestfs_set_autosync, 1);
2780 rb_define_method (c_guestfs, "get_autosync",
2781 ruby_guestfs_get_autosync, 0);
2782 rb_define_method (c_guestfs, "set_verbose",
2783 ruby_guestfs_set_verbose, 1);
2784 rb_define_method (c_guestfs, "get_verbose",
2785 ruby_guestfs_get_verbose, 0);
2786 rb_define_method (c_guestfs, "is_ready",
2787 ruby_guestfs_is_ready, 0);
2788 rb_define_method (c_guestfs, "is_config",
2789 ruby_guestfs_is_config, 0);
2790 rb_define_method (c_guestfs, "is_launching",
2791 ruby_guestfs_is_launching, 0);
2792 rb_define_method (c_guestfs, "is_busy",
2793 ruby_guestfs_is_busy, 0);
2794 rb_define_method (c_guestfs, "get_state",
2795 ruby_guestfs_get_state, 0);
2796 rb_define_method (c_guestfs, "set_busy",
2797 ruby_guestfs_set_busy, 0);
2798 rb_define_method (c_guestfs, "set_ready",
2799 ruby_guestfs_set_ready, 0);
2800 rb_define_method (c_guestfs, "mount",
2801 ruby_guestfs_mount, 2);
2802 rb_define_method (c_guestfs, "sync",
2803 ruby_guestfs_sync, 0);
2804 rb_define_method (c_guestfs, "touch",
2805 ruby_guestfs_touch, 1);
2806 rb_define_method (c_guestfs, "cat",
2807 ruby_guestfs_cat, 1);
2808 rb_define_method (c_guestfs, "ll",
2809 ruby_guestfs_ll, 1);
2810 rb_define_method (c_guestfs, "ls",
2811 ruby_guestfs_ls, 1);
2812 rb_define_method (c_guestfs, "list_devices",
2813 ruby_guestfs_list_devices, 0);
2814 rb_define_method (c_guestfs, "list_partitions",
2815 ruby_guestfs_list_partitions, 0);
2816 rb_define_method (c_guestfs, "pvs",
2817 ruby_guestfs_pvs, 0);
2818 rb_define_method (c_guestfs, "vgs",
2819 ruby_guestfs_vgs, 0);
2820 rb_define_method (c_guestfs, "lvs",
2821 ruby_guestfs_lvs, 0);
2822 rb_define_method (c_guestfs, "pvs_full",
2823 ruby_guestfs_pvs_full, 0);
2824 rb_define_method (c_guestfs, "vgs_full",
2825 ruby_guestfs_vgs_full, 0);
2826 rb_define_method (c_guestfs, "lvs_full",
2827 ruby_guestfs_lvs_full, 0);
2828 rb_define_method (c_guestfs, "read_lines",
2829 ruby_guestfs_read_lines, 1);
2830 rb_define_method (c_guestfs, "aug_init",
2831 ruby_guestfs_aug_init, 2);
2832 rb_define_method (c_guestfs, "aug_close",
2833 ruby_guestfs_aug_close, 0);
2834 rb_define_method (c_guestfs, "aug_defvar",
2835 ruby_guestfs_aug_defvar, 2);
2836 rb_define_method (c_guestfs, "aug_defnode",
2837 ruby_guestfs_aug_defnode, 3);
2838 rb_define_method (c_guestfs, "aug_get",
2839 ruby_guestfs_aug_get, 1);
2840 rb_define_method (c_guestfs, "aug_set",
2841 ruby_guestfs_aug_set, 2);
2842 rb_define_method (c_guestfs, "aug_insert",
2843 ruby_guestfs_aug_insert, 3);
2844 rb_define_method (c_guestfs, "aug_rm",
2845 ruby_guestfs_aug_rm, 1);
2846 rb_define_method (c_guestfs, "aug_mv",
2847 ruby_guestfs_aug_mv, 2);
2848 rb_define_method (c_guestfs, "aug_match",
2849 ruby_guestfs_aug_match, 1);
2850 rb_define_method (c_guestfs, "aug_save",
2851 ruby_guestfs_aug_save, 0);
2852 rb_define_method (c_guestfs, "aug_load",
2853 ruby_guestfs_aug_load, 0);
2854 rb_define_method (c_guestfs, "aug_ls",
2855 ruby_guestfs_aug_ls, 1);
2856 rb_define_method (c_guestfs, "rm",
2857 ruby_guestfs_rm, 1);
2858 rb_define_method (c_guestfs, "rmdir",
2859 ruby_guestfs_rmdir, 1);
2860 rb_define_method (c_guestfs, "rm_rf",
2861 ruby_guestfs_rm_rf, 1);
2862 rb_define_method (c_guestfs, "mkdir",
2863 ruby_guestfs_mkdir, 1);
2864 rb_define_method (c_guestfs, "mkdir_p",
2865 ruby_guestfs_mkdir_p, 1);
2866 rb_define_method (c_guestfs, "chmod",
2867 ruby_guestfs_chmod, 2);
2868 rb_define_method (c_guestfs, "chown",
2869 ruby_guestfs_chown, 3);
2870 rb_define_method (c_guestfs, "exists",
2871 ruby_guestfs_exists, 1);
2872 rb_define_method (c_guestfs, "is_file",
2873 ruby_guestfs_is_file, 1);
2874 rb_define_method (c_guestfs, "is_dir",
2875 ruby_guestfs_is_dir, 1);
2876 rb_define_method (c_guestfs, "pvcreate",
2877 ruby_guestfs_pvcreate, 1);
2878 rb_define_method (c_guestfs, "vgcreate",
2879 ruby_guestfs_vgcreate, 2);
2880 rb_define_method (c_guestfs, "lvcreate",
2881 ruby_guestfs_lvcreate, 3);
2882 rb_define_method (c_guestfs, "mkfs",
2883 ruby_guestfs_mkfs, 2);
2884 rb_define_method (c_guestfs, "sfdisk",
2885 ruby_guestfs_sfdisk, 5);
2886 rb_define_method (c_guestfs, "write_file",
2887 ruby_guestfs_write_file, 3);
2888 rb_define_method (c_guestfs, "umount",
2889 ruby_guestfs_umount, 1);
2890 rb_define_method (c_guestfs, "mounts",
2891 ruby_guestfs_mounts, 0);
2892 rb_define_method (c_guestfs, "umount_all",
2893 ruby_guestfs_umount_all, 0);
2894 rb_define_method (c_guestfs, "lvm_remove_all",
2895 ruby_guestfs_lvm_remove_all, 0);
2896 rb_define_method (c_guestfs, "file",
2897 ruby_guestfs_file, 1);
2898 rb_define_method (c_guestfs, "command",
2899 ruby_guestfs_command, 1);
2900 rb_define_method (c_guestfs, "command_lines",
2901 ruby_guestfs_command_lines, 1);
2902 rb_define_method (c_guestfs, "stat",
2903 ruby_guestfs_stat, 1);
2904 rb_define_method (c_guestfs, "lstat",
2905 ruby_guestfs_lstat, 1);
2906 rb_define_method (c_guestfs, "statvfs",
2907 ruby_guestfs_statvfs, 1);
2908 rb_define_method (c_guestfs, "tune2fs_l",
2909 ruby_guestfs_tune2fs_l, 1);
2910 rb_define_method (c_guestfs, "blockdev_setro",
2911 ruby_guestfs_blockdev_setro, 1);
2912 rb_define_method (c_guestfs, "blockdev_setrw",
2913 ruby_guestfs_blockdev_setrw, 1);
2914 rb_define_method (c_guestfs, "blockdev_getro",
2915 ruby_guestfs_blockdev_getro, 1);
2916 rb_define_method (c_guestfs, "blockdev_getss",
2917 ruby_guestfs_blockdev_getss, 1);
2918 rb_define_method (c_guestfs, "blockdev_getbsz",
2919 ruby_guestfs_blockdev_getbsz, 1);
2920 rb_define_method (c_guestfs, "blockdev_setbsz",
2921 ruby_guestfs_blockdev_setbsz, 2);
2922 rb_define_method (c_guestfs, "blockdev_getsz",
2923 ruby_guestfs_blockdev_getsz, 1);
2924 rb_define_method (c_guestfs, "blockdev_getsize64",
2925 ruby_guestfs_blockdev_getsize64, 1);
2926 rb_define_method (c_guestfs, "blockdev_flushbufs",
2927 ruby_guestfs_blockdev_flushbufs, 1);
2928 rb_define_method (c_guestfs, "blockdev_rereadpt",
2929 ruby_guestfs_blockdev_rereadpt, 1);
2930 rb_define_method (c_guestfs, "upload",
2931 ruby_guestfs_upload, 2);
2932 rb_define_method (c_guestfs, "download",
2933 ruby_guestfs_download, 2);
2934 rb_define_method (c_guestfs, "checksum",
2935 ruby_guestfs_checksum, 2);
2936 rb_define_method (c_guestfs, "tar_in",
2937 ruby_guestfs_tar_in, 2);
2938 rb_define_method (c_guestfs, "tar_out",
2939 ruby_guestfs_tar_out, 2);
2940 rb_define_method (c_guestfs, "tgz_in",
2941 ruby_guestfs_tgz_in, 2);
2942 rb_define_method (c_guestfs, "tgz_out",
2943 ruby_guestfs_tgz_out, 2);
2944 rb_define_method (c_guestfs, "mount_ro",
2945 ruby_guestfs_mount_ro, 2);
2946 rb_define_method (c_guestfs, "mount_options",
2947 ruby_guestfs_mount_options, 3);
2948 rb_define_method (c_guestfs, "mount_vfs",
2949 ruby_guestfs_mount_vfs, 4);
2950 rb_define_method (c_guestfs, "debug",
2951 ruby_guestfs_debug, 2);
2952 rb_define_method (c_guestfs, "lvremove",
2953 ruby_guestfs_lvremove, 1);
2954 rb_define_method (c_guestfs, "vgremove",
2955 ruby_guestfs_vgremove, 1);
2956 rb_define_method (c_guestfs, "pvremove",
2957 ruby_guestfs_pvremove, 1);
2958 rb_define_method (c_guestfs, "set_e2label",
2959 ruby_guestfs_set_e2label, 2);
2960 rb_define_method (c_guestfs, "get_e2label",
2961 ruby_guestfs_get_e2label, 1);
2962 rb_define_method (c_guestfs, "set_e2uuid",
2963 ruby_guestfs_set_e2uuid, 2);
2964 rb_define_method (c_guestfs, "get_e2uuid",
2965 ruby_guestfs_get_e2uuid, 1);
2966 rb_define_method (c_guestfs, "fsck",
2967 ruby_guestfs_fsck, 2);
2968 rb_define_method (c_guestfs, "zero",
2969 ruby_guestfs_zero, 1);
2970 rb_define_method (c_guestfs, "grub_install",
2971 ruby_guestfs_grub_install, 2);
2972 rb_define_method (c_guestfs, "cp",
2973 ruby_guestfs_cp, 2);
2974 rb_define_method (c_guestfs, "cp_a",
2975 ruby_guestfs_cp_a, 2);
2976 rb_define_method (c_guestfs, "mv",
2977 ruby_guestfs_mv, 2);
2978 rb_define_method (c_guestfs, "drop_caches",
2979 ruby_guestfs_drop_caches, 1);
2980 rb_define_method (c_guestfs, "dmesg",
2981 ruby_guestfs_dmesg, 0);
2982 rb_define_method (c_guestfs, "ping_daemon",
2983 ruby_guestfs_ping_daemon, 0);
2984 rb_define_method (c_guestfs, "equal",
2985 ruby_guestfs_equal, 2);