1 /* libguestfs generated file
2 * WARNING: THIS FILE IS GENERATED BY 'src/generator.ml'.
3 * ANY CHANGES YOU MAKE TO THIS FILE WILL BE LOST.
5 * Copyright (C) 2009 Red Hat Inc.
7 * This library is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2 of the License, or (at your option) any later version.
12 * This library is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with this library; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
31 static VALUE m_guestfs; /* guestfs module */
32 static VALUE c_guestfs; /* guestfs_h handle */
33 static VALUE e_Error; /* used for all errors */
35 static void ruby_guestfs_free (void *p)
38 guestfs_close ((guestfs_h *) p);
41 static VALUE ruby_guestfs_create (VALUE m)
45 g = guestfs_create ();
47 rb_raise (e_Error, "failed to create guestfs handle");
49 /* Don't print error messages to stderr by default. */
50 guestfs_set_error_handler (g, NULL, NULL);
52 /* Wrap it, and make sure the close function is called when the
55 return Data_Wrap_Struct (c_guestfs, NULL, ruby_guestfs_free, g);
58 static VALUE ruby_guestfs_close (VALUE gv)
61 Data_Get_Struct (gv, guestfs_h, g);
63 ruby_guestfs_free (g);
69 static VALUE ruby_guestfs_launch (VALUE gv)
72 Data_Get_Struct (gv, guestfs_h, g);
74 rb_raise (rb_eArgError, "%s: used handle after closing it", "launch");
79 r = guestfs_launch (g);
81 rb_raise (e_Error, "%s", guestfs_last_error (g));
86 static VALUE ruby_guestfs_wait_ready (VALUE gv)
89 Data_Get_Struct (gv, guestfs_h, g);
91 rb_raise (rb_eArgError, "%s: used handle after closing it", "wait_ready");
96 r = guestfs_wait_ready (g);
98 rb_raise (e_Error, "%s", guestfs_last_error (g));
103 static VALUE ruby_guestfs_kill_subprocess (VALUE gv)
106 Data_Get_Struct (gv, guestfs_h, g);
108 rb_raise (rb_eArgError, "%s: used handle after closing it", "kill_subprocess");
113 r = guestfs_kill_subprocess (g);
115 rb_raise (e_Error, "%s", guestfs_last_error (g));
120 static VALUE ruby_guestfs_add_drive (VALUE gv, VALUE filenamev)
123 Data_Get_Struct (gv, guestfs_h, g);
125 rb_raise (rb_eArgError, "%s: used handle after closing it", "add_drive");
127 const char *filename = StringValueCStr (filenamev);
129 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
130 "filename", "add_drive");
134 r = guestfs_add_drive (g, filename);
136 rb_raise (e_Error, "%s", guestfs_last_error (g));
141 static VALUE ruby_guestfs_add_cdrom (VALUE gv, VALUE filenamev)
144 Data_Get_Struct (gv, guestfs_h, g);
146 rb_raise (rb_eArgError, "%s: used handle after closing it", "add_cdrom");
148 const char *filename = StringValueCStr (filenamev);
150 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
151 "filename", "add_cdrom");
155 r = guestfs_add_cdrom (g, filename);
157 rb_raise (e_Error, "%s", guestfs_last_error (g));
162 static VALUE ruby_guestfs_config (VALUE gv, VALUE qemuparamv, VALUE qemuvaluev)
165 Data_Get_Struct (gv, guestfs_h, g);
167 rb_raise (rb_eArgError, "%s: used handle after closing it", "config");
169 const char *qemuparam = StringValueCStr (qemuparamv);
171 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
172 "qemuparam", "config");
173 const char *qemuvalue = StringValueCStr (qemuvaluev);
177 r = guestfs_config (g, qemuparam, qemuvalue);
179 rb_raise (e_Error, "%s", guestfs_last_error (g));
184 static VALUE ruby_guestfs_set_path (VALUE gv, VALUE pathv)
187 Data_Get_Struct (gv, guestfs_h, g);
189 rb_raise (rb_eArgError, "%s: used handle after closing it", "set_path");
191 const char *path = StringValueCStr (pathv);
193 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
198 r = guestfs_set_path (g, path);
200 rb_raise (e_Error, "%s", guestfs_last_error (g));
205 static VALUE ruby_guestfs_get_path (VALUE gv)
208 Data_Get_Struct (gv, guestfs_h, g);
210 rb_raise (rb_eArgError, "%s: used handle after closing it", "get_path");
215 r = guestfs_get_path (g);
217 rb_raise (e_Error, "%s", guestfs_last_error (g));
219 return rb_str_new2 (r);
222 static VALUE ruby_guestfs_set_autosync (VALUE gv, VALUE autosyncv)
225 Data_Get_Struct (gv, guestfs_h, g);
227 rb_raise (rb_eArgError, "%s: used handle after closing it", "set_autosync");
229 int autosync = NUM2INT (autosyncv);
233 r = guestfs_set_autosync (g, autosync);
235 rb_raise (e_Error, "%s", guestfs_last_error (g));
240 static VALUE ruby_guestfs_get_autosync (VALUE gv)
243 Data_Get_Struct (gv, guestfs_h, g);
245 rb_raise (rb_eArgError, "%s: used handle after closing it", "get_autosync");
250 r = guestfs_get_autosync (g);
252 rb_raise (e_Error, "%s", guestfs_last_error (g));
257 static VALUE ruby_guestfs_set_verbose (VALUE gv, VALUE verbosev)
260 Data_Get_Struct (gv, guestfs_h, g);
262 rb_raise (rb_eArgError, "%s: used handle after closing it", "set_verbose");
264 int verbose = NUM2INT (verbosev);
268 r = guestfs_set_verbose (g, verbose);
270 rb_raise (e_Error, "%s", guestfs_last_error (g));
275 static VALUE ruby_guestfs_get_verbose (VALUE gv)
278 Data_Get_Struct (gv, guestfs_h, g);
280 rb_raise (rb_eArgError, "%s: used handle after closing it", "get_verbose");
285 r = guestfs_get_verbose (g);
287 rb_raise (e_Error, "%s", guestfs_last_error (g));
292 static VALUE ruby_guestfs_is_ready (VALUE gv)
295 Data_Get_Struct (gv, guestfs_h, g);
297 rb_raise (rb_eArgError, "%s: used handle after closing it", "is_ready");
302 r = guestfs_is_ready (g);
304 rb_raise (e_Error, "%s", guestfs_last_error (g));
309 static VALUE ruby_guestfs_is_config (VALUE gv)
312 Data_Get_Struct (gv, guestfs_h, g);
314 rb_raise (rb_eArgError, "%s: used handle after closing it", "is_config");
319 r = guestfs_is_config (g);
321 rb_raise (e_Error, "%s", guestfs_last_error (g));
326 static VALUE ruby_guestfs_is_launching (VALUE gv)
329 Data_Get_Struct (gv, guestfs_h, g);
331 rb_raise (rb_eArgError, "%s: used handle after closing it", "is_launching");
336 r = guestfs_is_launching (g);
338 rb_raise (e_Error, "%s", guestfs_last_error (g));
343 static VALUE ruby_guestfs_is_busy (VALUE gv)
346 Data_Get_Struct (gv, guestfs_h, g);
348 rb_raise (rb_eArgError, "%s: used handle after closing it", "is_busy");
353 r = guestfs_is_busy (g);
355 rb_raise (e_Error, "%s", guestfs_last_error (g));
360 static VALUE ruby_guestfs_get_state (VALUE gv)
363 Data_Get_Struct (gv, guestfs_h, g);
365 rb_raise (rb_eArgError, "%s: used handle after closing it", "get_state");
370 r = guestfs_get_state (g);
372 rb_raise (e_Error, "%s", guestfs_last_error (g));
377 static VALUE ruby_guestfs_set_busy (VALUE gv)
380 Data_Get_Struct (gv, guestfs_h, g);
382 rb_raise (rb_eArgError, "%s: used handle after closing it", "set_busy");
387 r = guestfs_set_busy (g);
389 rb_raise (e_Error, "%s", guestfs_last_error (g));
394 static VALUE ruby_guestfs_set_ready (VALUE gv)
397 Data_Get_Struct (gv, guestfs_h, g);
399 rb_raise (rb_eArgError, "%s: used handle after closing it", "set_ready");
404 r = guestfs_set_ready (g);
406 rb_raise (e_Error, "%s", guestfs_last_error (g));
411 static VALUE ruby_guestfs_mount (VALUE gv, VALUE devicev, VALUE mountpointv)
414 Data_Get_Struct (gv, guestfs_h, g);
416 rb_raise (rb_eArgError, "%s: used handle after closing it", "mount");
418 const char *device = StringValueCStr (devicev);
420 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
422 const char *mountpoint = StringValueCStr (mountpointv);
424 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
425 "mountpoint", "mount");
429 r = guestfs_mount (g, device, mountpoint);
431 rb_raise (e_Error, "%s", guestfs_last_error (g));
436 static VALUE ruby_guestfs_sync (VALUE gv)
439 Data_Get_Struct (gv, guestfs_h, g);
441 rb_raise (rb_eArgError, "%s: used handle after closing it", "sync");
446 r = guestfs_sync (g);
448 rb_raise (e_Error, "%s", guestfs_last_error (g));
453 static VALUE ruby_guestfs_touch (VALUE gv, VALUE pathv)
456 Data_Get_Struct (gv, guestfs_h, g);
458 rb_raise (rb_eArgError, "%s: used handle after closing it", "touch");
460 const char *path = StringValueCStr (pathv);
462 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
467 r = guestfs_touch (g, path);
469 rb_raise (e_Error, "%s", guestfs_last_error (g));
474 static VALUE ruby_guestfs_cat (VALUE gv, VALUE pathv)
477 Data_Get_Struct (gv, guestfs_h, g);
479 rb_raise (rb_eArgError, "%s: used handle after closing it", "cat");
481 const char *path = StringValueCStr (pathv);
483 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
488 r = guestfs_cat (g, path);
490 rb_raise (e_Error, "%s", guestfs_last_error (g));
492 VALUE rv = rb_str_new2 (r);
497 static VALUE ruby_guestfs_ll (VALUE gv, VALUE directoryv)
500 Data_Get_Struct (gv, guestfs_h, g);
502 rb_raise (rb_eArgError, "%s: used handle after closing it", "ll");
504 const char *directory = StringValueCStr (directoryv);
506 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
511 r = guestfs_ll (g, directory);
513 rb_raise (e_Error, "%s", guestfs_last_error (g));
515 VALUE rv = rb_str_new2 (r);
520 static VALUE ruby_guestfs_ls (VALUE gv, VALUE directoryv)
523 Data_Get_Struct (gv, guestfs_h, g);
525 rb_raise (rb_eArgError, "%s: used handle after closing it", "ls");
527 const char *directory = StringValueCStr (directoryv);
529 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
534 r = guestfs_ls (g, directory);
536 rb_raise (e_Error, "%s", guestfs_last_error (g));
539 for (i = 0; r[i] != NULL; ++i) len++;
540 VALUE rv = rb_ary_new2 (len);
541 for (i = 0; r[i] != NULL; ++i) {
542 rb_ary_push (rv, rb_str_new2 (r[i]));
549 static VALUE ruby_guestfs_list_devices (VALUE gv)
552 Data_Get_Struct (gv, guestfs_h, g);
554 rb_raise (rb_eArgError, "%s: used handle after closing it", "list_devices");
559 r = guestfs_list_devices (g);
561 rb_raise (e_Error, "%s", guestfs_last_error (g));
564 for (i = 0; r[i] != NULL; ++i) len++;
565 VALUE rv = rb_ary_new2 (len);
566 for (i = 0; r[i] != NULL; ++i) {
567 rb_ary_push (rv, rb_str_new2 (r[i]));
574 static VALUE ruby_guestfs_list_partitions (VALUE gv)
577 Data_Get_Struct (gv, guestfs_h, g);
579 rb_raise (rb_eArgError, "%s: used handle after closing it", "list_partitions");
584 r = guestfs_list_partitions (g);
586 rb_raise (e_Error, "%s", guestfs_last_error (g));
589 for (i = 0; r[i] != NULL; ++i) len++;
590 VALUE rv = rb_ary_new2 (len);
591 for (i = 0; r[i] != NULL; ++i) {
592 rb_ary_push (rv, rb_str_new2 (r[i]));
599 static VALUE ruby_guestfs_pvs (VALUE gv)
602 Data_Get_Struct (gv, guestfs_h, g);
604 rb_raise (rb_eArgError, "%s: used handle after closing it", "pvs");
611 rb_raise (e_Error, "%s", guestfs_last_error (g));
614 for (i = 0; r[i] != NULL; ++i) len++;
615 VALUE rv = rb_ary_new2 (len);
616 for (i = 0; r[i] != NULL; ++i) {
617 rb_ary_push (rv, rb_str_new2 (r[i]));
624 static VALUE ruby_guestfs_vgs (VALUE gv)
627 Data_Get_Struct (gv, guestfs_h, g);
629 rb_raise (rb_eArgError, "%s: used handle after closing it", "vgs");
636 rb_raise (e_Error, "%s", guestfs_last_error (g));
639 for (i = 0; r[i] != NULL; ++i) len++;
640 VALUE rv = rb_ary_new2 (len);
641 for (i = 0; r[i] != NULL; ++i) {
642 rb_ary_push (rv, rb_str_new2 (r[i]));
649 static VALUE ruby_guestfs_lvs (VALUE gv)
652 Data_Get_Struct (gv, guestfs_h, g);
654 rb_raise (rb_eArgError, "%s: used handle after closing it", "lvs");
661 rb_raise (e_Error, "%s", guestfs_last_error (g));
664 for (i = 0; r[i] != NULL; ++i) len++;
665 VALUE rv = rb_ary_new2 (len);
666 for (i = 0; r[i] != NULL; ++i) {
667 rb_ary_push (rv, rb_str_new2 (r[i]));
674 static VALUE ruby_guestfs_pvs_full (VALUE gv)
677 Data_Get_Struct (gv, guestfs_h, g);
679 rb_raise (rb_eArgError, "%s: used handle after closing it", "pvs_full");
682 struct guestfs_lvm_pv_list *r;
684 r = guestfs_pvs_full (g);
686 rb_raise (e_Error, "%s", guestfs_last_error (g));
688 VALUE rv = rb_ary_new2 (r->len);
690 for (i = 0; i < r->len; ++i) {
691 VALUE hv = rb_hash_new ();
692 rb_hash_aset (rv, rb_str_new2 ("pv_name"), rb_str_new2 (r->val[i].pv_name));
693 rb_hash_aset (rv, rb_str_new2 ("pv_uuid"), rb_str_new (r->val[i].pv_uuid, 32));
694 rb_hash_aset (rv, rb_str_new2 ("pv_fmt"), rb_str_new2 (r->val[i].pv_fmt));
695 rb_hash_aset (rv, rb_str_new2 ("pv_size"), ULL2NUM (r->val[i].pv_size));
696 rb_hash_aset (rv, rb_str_new2 ("dev_size"), ULL2NUM (r->val[i].dev_size));
697 rb_hash_aset (rv, rb_str_new2 ("pv_free"), ULL2NUM (r->val[i].pv_free));
698 rb_hash_aset (rv, rb_str_new2 ("pv_used"), ULL2NUM (r->val[i].pv_used));
699 rb_hash_aset (rv, rb_str_new2 ("pv_attr"), rb_str_new2 (r->val[i].pv_attr));
700 rb_hash_aset (rv, rb_str_new2 ("pv_pe_count"), ULL2NUM (r->val[i].pv_pe_count));
701 rb_hash_aset (rv, rb_str_new2 ("pv_pe_alloc_count"), ULL2NUM (r->val[i].pv_pe_alloc_count));
702 rb_hash_aset (rv, rb_str_new2 ("pv_tags"), rb_str_new2 (r->val[i].pv_tags));
703 rb_hash_aset (rv, rb_str_new2 ("pe_start"), ULL2NUM (r->val[i].pe_start));
704 rb_hash_aset (rv, rb_str_new2 ("pv_mda_count"), ULL2NUM (r->val[i].pv_mda_count));
705 rb_hash_aset (rv, rb_str_new2 ("pv_mda_free"), ULL2NUM (r->val[i].pv_mda_free));
706 rb_ary_push (rv, hv);
708 guestfs_free_lvm_pv_list (r);
712 static VALUE ruby_guestfs_vgs_full (VALUE gv)
715 Data_Get_Struct (gv, guestfs_h, g);
717 rb_raise (rb_eArgError, "%s: used handle after closing it", "vgs_full");
720 struct guestfs_lvm_vg_list *r;
722 r = guestfs_vgs_full (g);
724 rb_raise (e_Error, "%s", guestfs_last_error (g));
726 VALUE rv = rb_ary_new2 (r->len);
728 for (i = 0; i < r->len; ++i) {
729 VALUE hv = rb_hash_new ();
730 rb_hash_aset (rv, rb_str_new2 ("vg_name"), rb_str_new2 (r->val[i].vg_name));
731 rb_hash_aset (rv, rb_str_new2 ("vg_uuid"), rb_str_new (r->val[i].vg_uuid, 32));
732 rb_hash_aset (rv, rb_str_new2 ("vg_fmt"), rb_str_new2 (r->val[i].vg_fmt));
733 rb_hash_aset (rv, rb_str_new2 ("vg_attr"), rb_str_new2 (r->val[i].vg_attr));
734 rb_hash_aset (rv, rb_str_new2 ("vg_size"), ULL2NUM (r->val[i].vg_size));
735 rb_hash_aset (rv, rb_str_new2 ("vg_free"), ULL2NUM (r->val[i].vg_free));
736 rb_hash_aset (rv, rb_str_new2 ("vg_sysid"), rb_str_new2 (r->val[i].vg_sysid));
737 rb_hash_aset (rv, rb_str_new2 ("vg_extent_size"), ULL2NUM (r->val[i].vg_extent_size));
738 rb_hash_aset (rv, rb_str_new2 ("vg_extent_count"), ULL2NUM (r->val[i].vg_extent_count));
739 rb_hash_aset (rv, rb_str_new2 ("vg_free_count"), ULL2NUM (r->val[i].vg_free_count));
740 rb_hash_aset (rv, rb_str_new2 ("max_lv"), ULL2NUM (r->val[i].max_lv));
741 rb_hash_aset (rv, rb_str_new2 ("max_pv"), ULL2NUM (r->val[i].max_pv));
742 rb_hash_aset (rv, rb_str_new2 ("pv_count"), ULL2NUM (r->val[i].pv_count));
743 rb_hash_aset (rv, rb_str_new2 ("lv_count"), ULL2NUM (r->val[i].lv_count));
744 rb_hash_aset (rv, rb_str_new2 ("snap_count"), ULL2NUM (r->val[i].snap_count));
745 rb_hash_aset (rv, rb_str_new2 ("vg_seqno"), ULL2NUM (r->val[i].vg_seqno));
746 rb_hash_aset (rv, rb_str_new2 ("vg_tags"), rb_str_new2 (r->val[i].vg_tags));
747 rb_hash_aset (rv, rb_str_new2 ("vg_mda_count"), ULL2NUM (r->val[i].vg_mda_count));
748 rb_hash_aset (rv, rb_str_new2 ("vg_mda_free"), ULL2NUM (r->val[i].vg_mda_free));
749 rb_ary_push (rv, hv);
751 guestfs_free_lvm_vg_list (r);
755 static VALUE ruby_guestfs_lvs_full (VALUE gv)
758 Data_Get_Struct (gv, guestfs_h, g);
760 rb_raise (rb_eArgError, "%s: used handle after closing it", "lvs_full");
763 struct guestfs_lvm_lv_list *r;
765 r = guestfs_lvs_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 ("lv_name"), rb_str_new2 (r->val[i].lv_name));
774 rb_hash_aset (rv, rb_str_new2 ("lv_uuid"), rb_str_new (r->val[i].lv_uuid, 32));
775 rb_hash_aset (rv, rb_str_new2 ("lv_attr"), rb_str_new2 (r->val[i].lv_attr));
776 rb_hash_aset (rv, rb_str_new2 ("lv_major"), ULL2NUM (r->val[i].lv_major));
777 rb_hash_aset (rv, rb_str_new2 ("lv_minor"), ULL2NUM (r->val[i].lv_minor));
778 rb_hash_aset (rv, rb_str_new2 ("lv_kernel_major"), ULL2NUM (r->val[i].lv_kernel_major));
779 rb_hash_aset (rv, rb_str_new2 ("lv_kernel_minor"), ULL2NUM (r->val[i].lv_kernel_minor));
780 rb_hash_aset (rv, rb_str_new2 ("lv_size"), ULL2NUM (r->val[i].lv_size));
781 rb_hash_aset (rv, rb_str_new2 ("seg_count"), ULL2NUM (r->val[i].seg_count));
782 rb_hash_aset (rv, rb_str_new2 ("origin"), rb_str_new2 (r->val[i].origin));
783 rb_hash_aset (rv, rb_str_new2 ("snap_percent"), rb_dbl2big (r->val[i].snap_percent));
784 rb_hash_aset (rv, rb_str_new2 ("copy_percent"), rb_dbl2big (r->val[i].copy_percent));
785 rb_hash_aset (rv, rb_str_new2 ("move_pv"), rb_str_new2 (r->val[i].move_pv));
786 rb_hash_aset (rv, rb_str_new2 ("lv_tags"), rb_str_new2 (r->val[i].lv_tags));
787 rb_hash_aset (rv, rb_str_new2 ("mirror_log"), rb_str_new2 (r->val[i].mirror_log));
788 rb_hash_aset (rv, rb_str_new2 ("modules"), rb_str_new2 (r->val[i].modules));
789 rb_ary_push (rv, hv);
791 guestfs_free_lvm_lv_list (r);
795 static VALUE ruby_guestfs_read_lines (VALUE gv, VALUE pathv)
798 Data_Get_Struct (gv, guestfs_h, g);
800 rb_raise (rb_eArgError, "%s: used handle after closing it", "read_lines");
802 const char *path = StringValueCStr (pathv);
804 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
805 "path", "read_lines");
809 r = guestfs_read_lines (g, path);
811 rb_raise (e_Error, "%s", guestfs_last_error (g));
814 for (i = 0; r[i] != NULL; ++i) len++;
815 VALUE rv = rb_ary_new2 (len);
816 for (i = 0; r[i] != NULL; ++i) {
817 rb_ary_push (rv, rb_str_new2 (r[i]));
824 static VALUE ruby_guestfs_aug_init (VALUE gv, VALUE rootv, VALUE flagsv)
827 Data_Get_Struct (gv, guestfs_h, g);
829 rb_raise (rb_eArgError, "%s: used handle after closing it", "aug_init");
831 const char *root = StringValueCStr (rootv);
833 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
835 int flags = NUM2INT (flagsv);
839 r = guestfs_aug_init (g, root, flags);
841 rb_raise (e_Error, "%s", guestfs_last_error (g));
846 static VALUE ruby_guestfs_aug_close (VALUE gv)
849 Data_Get_Struct (gv, guestfs_h, g);
851 rb_raise (rb_eArgError, "%s: used handle after closing it", "aug_close");
856 r = guestfs_aug_close (g);
858 rb_raise (e_Error, "%s", guestfs_last_error (g));
863 static VALUE ruby_guestfs_aug_defvar (VALUE gv, VALUE namev, VALUE exprv)
866 Data_Get_Struct (gv, guestfs_h, g);
868 rb_raise (rb_eArgError, "%s: used handle after closing it", "aug_defvar");
870 const char *name = StringValueCStr (namev);
872 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
873 "name", "aug_defvar");
874 const char *expr = StringValueCStr (exprv);
878 r = guestfs_aug_defvar (g, name, expr);
880 rb_raise (e_Error, "%s", guestfs_last_error (g));
885 static VALUE ruby_guestfs_aug_defnode (VALUE gv, VALUE namev, VALUE exprv, VALUE valv)
888 Data_Get_Struct (gv, guestfs_h, g);
890 rb_raise (rb_eArgError, "%s: used handle after closing it", "aug_defnode");
892 const char *name = StringValueCStr (namev);
894 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
895 "name", "aug_defnode");
896 const char *expr = StringValueCStr (exprv);
898 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
899 "expr", "aug_defnode");
900 const char *val = StringValueCStr (valv);
902 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
903 "val", "aug_defnode");
905 struct guestfs_int_bool *r;
907 r = guestfs_aug_defnode (g, name, expr, val);
909 rb_raise (e_Error, "%s", guestfs_last_error (g));
911 VALUE rv = rb_ary_new2 (2);
912 rb_ary_push (rv, INT2NUM (r->i));
913 rb_ary_push (rv, INT2NUM (r->b));
914 guestfs_free_int_bool (r);
918 static VALUE ruby_guestfs_aug_get (VALUE gv, VALUE pathv)
921 Data_Get_Struct (gv, guestfs_h, g);
923 rb_raise (rb_eArgError, "%s: used handle after closing it", "aug_get");
925 const char *path = StringValueCStr (pathv);
927 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
932 r = guestfs_aug_get (g, path);
934 rb_raise (e_Error, "%s", guestfs_last_error (g));
936 VALUE rv = rb_str_new2 (r);
941 static VALUE ruby_guestfs_aug_set (VALUE gv, VALUE pathv, VALUE valv)
944 Data_Get_Struct (gv, guestfs_h, g);
946 rb_raise (rb_eArgError, "%s: used handle after closing it", "aug_set");
948 const char *path = StringValueCStr (pathv);
950 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
952 const char *val = StringValueCStr (valv);
954 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
959 r = guestfs_aug_set (g, path, val);
961 rb_raise (e_Error, "%s", guestfs_last_error (g));
966 static VALUE ruby_guestfs_aug_insert (VALUE gv, VALUE pathv, VALUE labelv, VALUE beforev)
969 Data_Get_Struct (gv, guestfs_h, g);
971 rb_raise (rb_eArgError, "%s: used handle after closing it", "aug_insert");
973 const char *path = StringValueCStr (pathv);
975 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
976 "path", "aug_insert");
977 const char *label = StringValueCStr (labelv);
979 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
980 "label", "aug_insert");
981 int before = NUM2INT (beforev);
985 r = guestfs_aug_insert (g, path, label, before);
987 rb_raise (e_Error, "%s", guestfs_last_error (g));
992 static VALUE ruby_guestfs_aug_rm (VALUE gv, VALUE pathv)
995 Data_Get_Struct (gv, guestfs_h, g);
997 rb_raise (rb_eArgError, "%s: used handle after closing it", "aug_rm");
999 const char *path = StringValueCStr (pathv);
1001 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1006 r = guestfs_aug_rm (g, path);
1008 rb_raise (e_Error, "%s", guestfs_last_error (g));
1013 static VALUE ruby_guestfs_aug_mv (VALUE gv, VALUE srcv, VALUE destv)
1016 Data_Get_Struct (gv, guestfs_h, g);
1018 rb_raise (rb_eArgError, "%s: used handle after closing it", "aug_mv");
1020 const char *src = StringValueCStr (srcv);
1022 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1024 const char *dest = StringValueCStr (destv);
1026 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1031 r = guestfs_aug_mv (g, src, dest);
1033 rb_raise (e_Error, "%s", guestfs_last_error (g));
1038 static VALUE ruby_guestfs_aug_match (VALUE gv, VALUE pathv)
1041 Data_Get_Struct (gv, guestfs_h, g);
1043 rb_raise (rb_eArgError, "%s: used handle after closing it", "aug_match");
1045 const char *path = StringValueCStr (pathv);
1047 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1048 "path", "aug_match");
1052 r = guestfs_aug_match (g, path);
1054 rb_raise (e_Error, "%s", guestfs_last_error (g));
1057 for (i = 0; r[i] != NULL; ++i) len++;
1058 VALUE rv = rb_ary_new2 (len);
1059 for (i = 0; r[i] != NULL; ++i) {
1060 rb_ary_push (rv, rb_str_new2 (r[i]));
1067 static VALUE ruby_guestfs_aug_save (VALUE gv)
1070 Data_Get_Struct (gv, guestfs_h, g);
1072 rb_raise (rb_eArgError, "%s: used handle after closing it", "aug_save");
1077 r = guestfs_aug_save (g);
1079 rb_raise (e_Error, "%s", guestfs_last_error (g));
1084 static VALUE ruby_guestfs_aug_load (VALUE gv)
1087 Data_Get_Struct (gv, guestfs_h, g);
1089 rb_raise (rb_eArgError, "%s: used handle after closing it", "aug_load");
1094 r = guestfs_aug_load (g);
1096 rb_raise (e_Error, "%s", guestfs_last_error (g));
1101 static VALUE ruby_guestfs_aug_ls (VALUE gv, VALUE pathv)
1104 Data_Get_Struct (gv, guestfs_h, g);
1106 rb_raise (rb_eArgError, "%s: used handle after closing it", "aug_ls");
1108 const char *path = StringValueCStr (pathv);
1110 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1115 r = guestfs_aug_ls (g, path);
1117 rb_raise (e_Error, "%s", guestfs_last_error (g));
1120 for (i = 0; r[i] != NULL; ++i) len++;
1121 VALUE rv = rb_ary_new2 (len);
1122 for (i = 0; r[i] != NULL; ++i) {
1123 rb_ary_push (rv, rb_str_new2 (r[i]));
1130 static VALUE ruby_guestfs_rm (VALUE gv, VALUE pathv)
1133 Data_Get_Struct (gv, guestfs_h, g);
1135 rb_raise (rb_eArgError, "%s: used handle after closing it", "rm");
1137 const char *path = StringValueCStr (pathv);
1139 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1144 r = guestfs_rm (g, path);
1146 rb_raise (e_Error, "%s", guestfs_last_error (g));
1151 static VALUE ruby_guestfs_rmdir (VALUE gv, VALUE pathv)
1154 Data_Get_Struct (gv, guestfs_h, g);
1156 rb_raise (rb_eArgError, "%s: used handle after closing it", "rmdir");
1158 const char *path = StringValueCStr (pathv);
1160 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1165 r = guestfs_rmdir (g, path);
1167 rb_raise (e_Error, "%s", guestfs_last_error (g));
1172 static VALUE ruby_guestfs_rm_rf (VALUE gv, VALUE pathv)
1175 Data_Get_Struct (gv, guestfs_h, g);
1177 rb_raise (rb_eArgError, "%s: used handle after closing it", "rm_rf");
1179 const char *path = StringValueCStr (pathv);
1181 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1186 r = guestfs_rm_rf (g, path);
1188 rb_raise (e_Error, "%s", guestfs_last_error (g));
1193 static VALUE ruby_guestfs_mkdir (VALUE gv, VALUE pathv)
1196 Data_Get_Struct (gv, guestfs_h, g);
1198 rb_raise (rb_eArgError, "%s: used handle after closing it", "mkdir");
1200 const char *path = StringValueCStr (pathv);
1202 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1207 r = guestfs_mkdir (g, path);
1209 rb_raise (e_Error, "%s", guestfs_last_error (g));
1214 static VALUE ruby_guestfs_mkdir_p (VALUE gv, VALUE pathv)
1217 Data_Get_Struct (gv, guestfs_h, g);
1219 rb_raise (rb_eArgError, "%s: used handle after closing it", "mkdir_p");
1221 const char *path = StringValueCStr (pathv);
1223 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1228 r = guestfs_mkdir_p (g, path);
1230 rb_raise (e_Error, "%s", guestfs_last_error (g));
1235 static VALUE ruby_guestfs_chmod (VALUE gv, VALUE modev, VALUE pathv)
1238 Data_Get_Struct (gv, guestfs_h, g);
1240 rb_raise (rb_eArgError, "%s: used handle after closing it", "chmod");
1242 int mode = NUM2INT (modev);
1243 const char *path = StringValueCStr (pathv);
1245 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1250 r = guestfs_chmod (g, mode, path);
1252 rb_raise (e_Error, "%s", guestfs_last_error (g));
1257 static VALUE ruby_guestfs_chown (VALUE gv, VALUE ownerv, VALUE groupv, VALUE pathv)
1260 Data_Get_Struct (gv, guestfs_h, g);
1262 rb_raise (rb_eArgError, "%s: used handle after closing it", "chown");
1264 int owner = NUM2INT (ownerv);
1265 int group = NUM2INT (groupv);
1266 const char *path = StringValueCStr (pathv);
1268 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1273 r = guestfs_chown (g, owner, group, path);
1275 rb_raise (e_Error, "%s", guestfs_last_error (g));
1280 static VALUE ruby_guestfs_exists (VALUE gv, VALUE pathv)
1283 Data_Get_Struct (gv, guestfs_h, g);
1285 rb_raise (rb_eArgError, "%s: used handle after closing it", "exists");
1287 const char *path = StringValueCStr (pathv);
1289 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1294 r = guestfs_exists (g, path);
1296 rb_raise (e_Error, "%s", guestfs_last_error (g));
1301 static VALUE ruby_guestfs_is_file (VALUE gv, VALUE pathv)
1304 Data_Get_Struct (gv, guestfs_h, g);
1306 rb_raise (rb_eArgError, "%s: used handle after closing it", "is_file");
1308 const char *path = StringValueCStr (pathv);
1310 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1315 r = guestfs_is_file (g, path);
1317 rb_raise (e_Error, "%s", guestfs_last_error (g));
1322 static VALUE ruby_guestfs_is_dir (VALUE gv, VALUE pathv)
1325 Data_Get_Struct (gv, guestfs_h, g);
1327 rb_raise (rb_eArgError, "%s: used handle after closing it", "is_dir");
1329 const char *path = StringValueCStr (pathv);
1331 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1336 r = guestfs_is_dir (g, path);
1338 rb_raise (e_Error, "%s", guestfs_last_error (g));
1343 static VALUE ruby_guestfs_pvcreate (VALUE gv, VALUE devicev)
1346 Data_Get_Struct (gv, guestfs_h, g);
1348 rb_raise (rb_eArgError, "%s: used handle after closing it", "pvcreate");
1350 const char *device = StringValueCStr (devicev);
1352 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1353 "device", "pvcreate");
1357 r = guestfs_pvcreate (g, device);
1359 rb_raise (e_Error, "%s", guestfs_last_error (g));
1364 static VALUE ruby_guestfs_vgcreate (VALUE gv, VALUE volgroupv, VALUE physvolsv)
1367 Data_Get_Struct (gv, guestfs_h, g);
1369 rb_raise (rb_eArgError, "%s: used handle after closing it", "vgcreate");
1371 const char *volgroup = StringValueCStr (volgroupv);
1373 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1374 "volgroup", "vgcreate");
1377 len = RARRAY_LEN (physvolsv);
1378 physvols = malloc (sizeof (char *) * (len+1));
1379 for (i = 0; i < len; ++i) {
1380 VALUE v = rb_ary_entry (physvolsv, i);
1381 physvols[i] = StringValueCStr (v);
1387 r = guestfs_vgcreate (g, volgroup, physvols);
1390 rb_raise (e_Error, "%s", guestfs_last_error (g));
1395 static VALUE ruby_guestfs_lvcreate (VALUE gv, VALUE logvolv, VALUE volgroupv, VALUE mbytesv)
1398 Data_Get_Struct (gv, guestfs_h, g);
1400 rb_raise (rb_eArgError, "%s: used handle after closing it", "lvcreate");
1402 const char *logvol = StringValueCStr (logvolv);
1404 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1405 "logvol", "lvcreate");
1406 const char *volgroup = StringValueCStr (volgroupv);
1408 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1409 "volgroup", "lvcreate");
1410 int mbytes = NUM2INT (mbytesv);
1414 r = guestfs_lvcreate (g, logvol, volgroup, mbytes);
1416 rb_raise (e_Error, "%s", guestfs_last_error (g));
1421 static VALUE ruby_guestfs_mkfs (VALUE gv, VALUE fstypev, VALUE devicev)
1424 Data_Get_Struct (gv, guestfs_h, g);
1426 rb_raise (rb_eArgError, "%s: used handle after closing it", "mkfs");
1428 const char *fstype = StringValueCStr (fstypev);
1430 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1432 const char *device = StringValueCStr (devicev);
1434 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1439 r = guestfs_mkfs (g, fstype, device);
1441 rb_raise (e_Error, "%s", guestfs_last_error (g));
1446 static VALUE ruby_guestfs_sfdisk (VALUE gv, VALUE devicev, VALUE cylsv, VALUE headsv, VALUE sectorsv, VALUE linesv)
1449 Data_Get_Struct (gv, guestfs_h, g);
1451 rb_raise (rb_eArgError, "%s: used handle after closing it", "sfdisk");
1453 const char *device = StringValueCStr (devicev);
1455 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1456 "device", "sfdisk");
1457 int cyls = NUM2INT (cylsv);
1458 int heads = NUM2INT (headsv);
1459 int sectors = NUM2INT (sectorsv);
1462 len = RARRAY_LEN (linesv);
1463 lines = malloc (sizeof (char *) * (len+1));
1464 for (i = 0; i < len; ++i) {
1465 VALUE v = rb_ary_entry (linesv, i);
1466 lines[i] = StringValueCStr (v);
1472 r = guestfs_sfdisk (g, device, cyls, heads, sectors, lines);
1475 rb_raise (e_Error, "%s", guestfs_last_error (g));
1480 static VALUE ruby_guestfs_write_file (VALUE gv, VALUE pathv, VALUE contentv, VALUE sizev)
1483 Data_Get_Struct (gv, guestfs_h, g);
1485 rb_raise (rb_eArgError, "%s: used handle after closing it", "write_file");
1487 const char *path = StringValueCStr (pathv);
1489 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1490 "path", "write_file");
1491 const char *content = StringValueCStr (contentv);
1493 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1494 "content", "write_file");
1495 int size = NUM2INT (sizev);
1499 r = guestfs_write_file (g, path, content, size);
1501 rb_raise (e_Error, "%s", guestfs_last_error (g));
1506 static VALUE ruby_guestfs_umount (VALUE gv, VALUE pathordevicev)
1509 Data_Get_Struct (gv, guestfs_h, g);
1511 rb_raise (rb_eArgError, "%s: used handle after closing it", "umount");
1513 const char *pathordevice = StringValueCStr (pathordevicev);
1515 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1516 "pathordevice", "umount");
1520 r = guestfs_umount (g, pathordevice);
1522 rb_raise (e_Error, "%s", guestfs_last_error (g));
1527 static VALUE ruby_guestfs_mounts (VALUE gv)
1530 Data_Get_Struct (gv, guestfs_h, g);
1532 rb_raise (rb_eArgError, "%s: used handle after closing it", "mounts");
1537 r = guestfs_mounts (g);
1539 rb_raise (e_Error, "%s", guestfs_last_error (g));
1542 for (i = 0; r[i] != NULL; ++i) len++;
1543 VALUE rv = rb_ary_new2 (len);
1544 for (i = 0; r[i] != NULL; ++i) {
1545 rb_ary_push (rv, rb_str_new2 (r[i]));
1552 static VALUE ruby_guestfs_umount_all (VALUE gv)
1555 Data_Get_Struct (gv, guestfs_h, g);
1557 rb_raise (rb_eArgError, "%s: used handle after closing it", "umount_all");
1562 r = guestfs_umount_all (g);
1564 rb_raise (e_Error, "%s", guestfs_last_error (g));
1569 static VALUE ruby_guestfs_lvm_remove_all (VALUE gv)
1572 Data_Get_Struct (gv, guestfs_h, g);
1574 rb_raise (rb_eArgError, "%s: used handle after closing it", "lvm_remove_all");
1579 r = guestfs_lvm_remove_all (g);
1581 rb_raise (e_Error, "%s", guestfs_last_error (g));
1586 static VALUE ruby_guestfs_file (VALUE gv, VALUE pathv)
1589 Data_Get_Struct (gv, guestfs_h, g);
1591 rb_raise (rb_eArgError, "%s: used handle after closing it", "file");
1593 const char *path = StringValueCStr (pathv);
1595 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1600 r = guestfs_file (g, path);
1602 rb_raise (e_Error, "%s", guestfs_last_error (g));
1604 VALUE rv = rb_str_new2 (r);
1609 static VALUE ruby_guestfs_command (VALUE gv, VALUE argumentsv)
1612 Data_Get_Struct (gv, guestfs_h, g);
1614 rb_raise (rb_eArgError, "%s: used handle after closing it", "command");
1618 len = RARRAY_LEN (argumentsv);
1619 arguments = malloc (sizeof (char *) * (len+1));
1620 for (i = 0; i < len; ++i) {
1621 VALUE v = rb_ary_entry (argumentsv, i);
1622 arguments[i] = StringValueCStr (v);
1628 r = guestfs_command (g, arguments);
1631 rb_raise (e_Error, "%s", guestfs_last_error (g));
1633 VALUE rv = rb_str_new2 (r);
1638 static VALUE ruby_guestfs_command_lines (VALUE gv, VALUE argumentsv)
1641 Data_Get_Struct (gv, guestfs_h, g);
1643 rb_raise (rb_eArgError, "%s: used handle after closing it", "command_lines");
1647 len = RARRAY_LEN (argumentsv);
1648 arguments = malloc (sizeof (char *) * (len+1));
1649 for (i = 0; i < len; ++i) {
1650 VALUE v = rb_ary_entry (argumentsv, i);
1651 arguments[i] = StringValueCStr (v);
1657 r = guestfs_command_lines (g, arguments);
1660 rb_raise (e_Error, "%s", guestfs_last_error (g));
1663 for (i = 0; r[i] != NULL; ++i) len++;
1664 VALUE rv = rb_ary_new2 (len);
1665 for (i = 0; r[i] != NULL; ++i) {
1666 rb_ary_push (rv, rb_str_new2 (r[i]));
1673 static VALUE ruby_guestfs_stat (VALUE gv, VALUE pathv)
1676 Data_Get_Struct (gv, guestfs_h, g);
1678 rb_raise (rb_eArgError, "%s: used handle after closing it", "stat");
1680 const char *path = StringValueCStr (pathv);
1682 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1685 struct guestfs_stat *r;
1687 r = guestfs_stat (g, path);
1689 rb_raise (e_Error, "%s", guestfs_last_error (g));
1691 VALUE rv = rb_hash_new ();
1692 rb_hash_aset (rv, rb_str_new2 ("dev"), ULL2NUM (r->dev));
1693 rb_hash_aset (rv, rb_str_new2 ("ino"), ULL2NUM (r->ino));
1694 rb_hash_aset (rv, rb_str_new2 ("mode"), ULL2NUM (r->mode));
1695 rb_hash_aset (rv, rb_str_new2 ("nlink"), ULL2NUM (r->nlink));
1696 rb_hash_aset (rv, rb_str_new2 ("uid"), ULL2NUM (r->uid));
1697 rb_hash_aset (rv, rb_str_new2 ("gid"), ULL2NUM (r->gid));
1698 rb_hash_aset (rv, rb_str_new2 ("rdev"), ULL2NUM (r->rdev));
1699 rb_hash_aset (rv, rb_str_new2 ("size"), ULL2NUM (r->size));
1700 rb_hash_aset (rv, rb_str_new2 ("blksize"), ULL2NUM (r->blksize));
1701 rb_hash_aset (rv, rb_str_new2 ("blocks"), ULL2NUM (r->blocks));
1702 rb_hash_aset (rv, rb_str_new2 ("atime"), ULL2NUM (r->atime));
1703 rb_hash_aset (rv, rb_str_new2 ("mtime"), ULL2NUM (r->mtime));
1704 rb_hash_aset (rv, rb_str_new2 ("ctime"), ULL2NUM (r->ctime));
1709 static VALUE ruby_guestfs_lstat (VALUE gv, VALUE pathv)
1712 Data_Get_Struct (gv, guestfs_h, g);
1714 rb_raise (rb_eArgError, "%s: used handle after closing it", "lstat");
1716 const char *path = StringValueCStr (pathv);
1718 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1721 struct guestfs_stat *r;
1723 r = guestfs_lstat (g, path);
1725 rb_raise (e_Error, "%s", guestfs_last_error (g));
1727 VALUE rv = rb_hash_new ();
1728 rb_hash_aset (rv, rb_str_new2 ("dev"), ULL2NUM (r->dev));
1729 rb_hash_aset (rv, rb_str_new2 ("ino"), ULL2NUM (r->ino));
1730 rb_hash_aset (rv, rb_str_new2 ("mode"), ULL2NUM (r->mode));
1731 rb_hash_aset (rv, rb_str_new2 ("nlink"), ULL2NUM (r->nlink));
1732 rb_hash_aset (rv, rb_str_new2 ("uid"), ULL2NUM (r->uid));
1733 rb_hash_aset (rv, rb_str_new2 ("gid"), ULL2NUM (r->gid));
1734 rb_hash_aset (rv, rb_str_new2 ("rdev"), ULL2NUM (r->rdev));
1735 rb_hash_aset (rv, rb_str_new2 ("size"), ULL2NUM (r->size));
1736 rb_hash_aset (rv, rb_str_new2 ("blksize"), ULL2NUM (r->blksize));
1737 rb_hash_aset (rv, rb_str_new2 ("blocks"), ULL2NUM (r->blocks));
1738 rb_hash_aset (rv, rb_str_new2 ("atime"), ULL2NUM (r->atime));
1739 rb_hash_aset (rv, rb_str_new2 ("mtime"), ULL2NUM (r->mtime));
1740 rb_hash_aset (rv, rb_str_new2 ("ctime"), ULL2NUM (r->ctime));
1745 static VALUE ruby_guestfs_statvfs (VALUE gv, VALUE pathv)
1748 Data_Get_Struct (gv, guestfs_h, g);
1750 rb_raise (rb_eArgError, "%s: used handle after closing it", "statvfs");
1752 const char *path = StringValueCStr (pathv);
1754 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1757 struct guestfs_statvfs *r;
1759 r = guestfs_statvfs (g, path);
1761 rb_raise (e_Error, "%s", guestfs_last_error (g));
1763 VALUE rv = rb_hash_new ();
1764 rb_hash_aset (rv, rb_str_new2 ("bsize"), ULL2NUM (r->bsize));
1765 rb_hash_aset (rv, rb_str_new2 ("frsize"), ULL2NUM (r->frsize));
1766 rb_hash_aset (rv, rb_str_new2 ("blocks"), ULL2NUM (r->blocks));
1767 rb_hash_aset (rv, rb_str_new2 ("bfree"), ULL2NUM (r->bfree));
1768 rb_hash_aset (rv, rb_str_new2 ("bavail"), ULL2NUM (r->bavail));
1769 rb_hash_aset (rv, rb_str_new2 ("files"), ULL2NUM (r->files));
1770 rb_hash_aset (rv, rb_str_new2 ("ffree"), ULL2NUM (r->ffree));
1771 rb_hash_aset (rv, rb_str_new2 ("favail"), ULL2NUM (r->favail));
1772 rb_hash_aset (rv, rb_str_new2 ("fsid"), ULL2NUM (r->fsid));
1773 rb_hash_aset (rv, rb_str_new2 ("flag"), ULL2NUM (r->flag));
1774 rb_hash_aset (rv, rb_str_new2 ("namemax"), ULL2NUM (r->namemax));
1779 static VALUE ruby_guestfs_tune2fs_l (VALUE gv, VALUE devicev)
1782 Data_Get_Struct (gv, guestfs_h, g);
1784 rb_raise (rb_eArgError, "%s: used handle after closing it", "tune2fs_l");
1786 const char *device = StringValueCStr (devicev);
1788 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1789 "device", "tune2fs_l");
1793 r = guestfs_tune2fs_l (g, device);
1795 rb_raise (e_Error, "%s", guestfs_last_error (g));
1797 VALUE rv = rb_hash_new ();
1799 for (i = 0; r[i] != NULL; i+=2) {
1800 rb_hash_aset (rv, rb_str_new2 (r[i]), rb_str_new2 (r[i+1]));
1808 static VALUE ruby_guestfs_blockdev_setro (VALUE gv, VALUE devicev)
1811 Data_Get_Struct (gv, guestfs_h, g);
1813 rb_raise (rb_eArgError, "%s: used handle after closing it", "blockdev_setro");
1815 const char *device = StringValueCStr (devicev);
1817 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1818 "device", "blockdev_setro");
1822 r = guestfs_blockdev_setro (g, device);
1824 rb_raise (e_Error, "%s", guestfs_last_error (g));
1829 static VALUE ruby_guestfs_blockdev_setrw (VALUE gv, VALUE devicev)
1832 Data_Get_Struct (gv, guestfs_h, g);
1834 rb_raise (rb_eArgError, "%s: used handle after closing it", "blockdev_setrw");
1836 const char *device = StringValueCStr (devicev);
1838 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1839 "device", "blockdev_setrw");
1843 r = guestfs_blockdev_setrw (g, device);
1845 rb_raise (e_Error, "%s", guestfs_last_error (g));
1850 static VALUE ruby_guestfs_blockdev_getro (VALUE gv, VALUE devicev)
1853 Data_Get_Struct (gv, guestfs_h, g);
1855 rb_raise (rb_eArgError, "%s: used handle after closing it", "blockdev_getro");
1857 const char *device = StringValueCStr (devicev);
1859 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1860 "device", "blockdev_getro");
1864 r = guestfs_blockdev_getro (g, device);
1866 rb_raise (e_Error, "%s", guestfs_last_error (g));
1871 static VALUE ruby_guestfs_blockdev_getss (VALUE gv, VALUE devicev)
1874 Data_Get_Struct (gv, guestfs_h, g);
1876 rb_raise (rb_eArgError, "%s: used handle after closing it", "blockdev_getss");
1878 const char *device = StringValueCStr (devicev);
1880 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1881 "device", "blockdev_getss");
1885 r = guestfs_blockdev_getss (g, device);
1887 rb_raise (e_Error, "%s", guestfs_last_error (g));
1892 static VALUE ruby_guestfs_blockdev_getbsz (VALUE gv, VALUE devicev)
1895 Data_Get_Struct (gv, guestfs_h, g);
1897 rb_raise (rb_eArgError, "%s: used handle after closing it", "blockdev_getbsz");
1899 const char *device = StringValueCStr (devicev);
1901 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1902 "device", "blockdev_getbsz");
1906 r = guestfs_blockdev_getbsz (g, device);
1908 rb_raise (e_Error, "%s", guestfs_last_error (g));
1913 static VALUE ruby_guestfs_blockdev_setbsz (VALUE gv, VALUE devicev, VALUE blocksizev)
1916 Data_Get_Struct (gv, guestfs_h, g);
1918 rb_raise (rb_eArgError, "%s: used handle after closing it", "blockdev_setbsz");
1920 const char *device = StringValueCStr (devicev);
1922 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1923 "device", "blockdev_setbsz");
1924 int blocksize = NUM2INT (blocksizev);
1928 r = guestfs_blockdev_setbsz (g, device, blocksize);
1930 rb_raise (e_Error, "%s", guestfs_last_error (g));
1935 static VALUE ruby_guestfs_blockdev_getsz (VALUE gv, VALUE devicev)
1938 Data_Get_Struct (gv, guestfs_h, g);
1940 rb_raise (rb_eArgError, "%s: used handle after closing it", "blockdev_getsz");
1942 const char *device = StringValueCStr (devicev);
1944 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1945 "device", "blockdev_getsz");
1949 r = guestfs_blockdev_getsz (g, device);
1951 rb_raise (e_Error, "%s", guestfs_last_error (g));
1956 static VALUE ruby_guestfs_blockdev_getsize64 (VALUE gv, VALUE devicev)
1959 Data_Get_Struct (gv, guestfs_h, g);
1961 rb_raise (rb_eArgError, "%s: used handle after closing it", "blockdev_getsize64");
1963 const char *device = StringValueCStr (devicev);
1965 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1966 "device", "blockdev_getsize64");
1970 r = guestfs_blockdev_getsize64 (g, device);
1972 rb_raise (e_Error, "%s", guestfs_last_error (g));
1977 static VALUE ruby_guestfs_blockdev_flushbufs (VALUE gv, VALUE devicev)
1980 Data_Get_Struct (gv, guestfs_h, g);
1982 rb_raise (rb_eArgError, "%s: used handle after closing it", "blockdev_flushbufs");
1984 const char *device = StringValueCStr (devicev);
1986 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1987 "device", "blockdev_flushbufs");
1991 r = guestfs_blockdev_flushbufs (g, device);
1993 rb_raise (e_Error, "%s", guestfs_last_error (g));
1998 static VALUE ruby_guestfs_blockdev_rereadpt (VALUE gv, VALUE devicev)
2001 Data_Get_Struct (gv, guestfs_h, g);
2003 rb_raise (rb_eArgError, "%s: used handle after closing it", "blockdev_rereadpt");
2005 const char *device = StringValueCStr (devicev);
2007 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2008 "device", "blockdev_rereadpt");
2012 r = guestfs_blockdev_rereadpt (g, device);
2014 rb_raise (e_Error, "%s", guestfs_last_error (g));
2019 static VALUE ruby_guestfs_upload (VALUE gv, VALUE filenamev, VALUE remotefilenamev)
2022 Data_Get_Struct (gv, guestfs_h, g);
2024 rb_raise (rb_eArgError, "%s: used handle after closing it", "upload");
2026 const char *filename = StringValueCStr (filenamev);
2028 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2029 "filename", "upload");
2030 const char *remotefilename = StringValueCStr (remotefilenamev);
2031 if (!remotefilename)
2032 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2033 "remotefilename", "upload");
2037 r = guestfs_upload (g, filename, remotefilename);
2039 rb_raise (e_Error, "%s", guestfs_last_error (g));
2044 static VALUE ruby_guestfs_download (VALUE gv, VALUE remotefilenamev, VALUE filenamev)
2047 Data_Get_Struct (gv, guestfs_h, g);
2049 rb_raise (rb_eArgError, "%s: used handle after closing it", "download");
2051 const char *remotefilename = StringValueCStr (remotefilenamev);
2052 if (!remotefilename)
2053 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2054 "remotefilename", "download");
2055 const char *filename = StringValueCStr (filenamev);
2057 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2058 "filename", "download");
2062 r = guestfs_download (g, remotefilename, filename);
2064 rb_raise (e_Error, "%s", guestfs_last_error (g));
2069 /* Initialize the module. */
2070 void Init__guestfs ()
2072 m_guestfs = rb_define_module ("Guestfs");
2073 c_guestfs = rb_define_class_under (m_guestfs, "Guestfs", rb_cObject);
2074 e_Error = rb_define_class_under (m_guestfs, "Error", rb_eStandardError);
2076 rb_define_module_function (m_guestfs, "create", ruby_guestfs_create, 0);
2077 rb_define_method (c_guestfs, "close", ruby_guestfs_close, 0);
2079 rb_define_method (c_guestfs, "launch",
2080 ruby_guestfs_launch, 0);
2081 rb_define_method (c_guestfs, "wait_ready",
2082 ruby_guestfs_wait_ready, 0);
2083 rb_define_method (c_guestfs, "kill_subprocess",
2084 ruby_guestfs_kill_subprocess, 0);
2085 rb_define_method (c_guestfs, "add_drive",
2086 ruby_guestfs_add_drive, 1);
2087 rb_define_method (c_guestfs, "add_cdrom",
2088 ruby_guestfs_add_cdrom, 1);
2089 rb_define_method (c_guestfs, "config",
2090 ruby_guestfs_config, 2);
2091 rb_define_method (c_guestfs, "set_path",
2092 ruby_guestfs_set_path, 1);
2093 rb_define_method (c_guestfs, "get_path",
2094 ruby_guestfs_get_path, 0);
2095 rb_define_method (c_guestfs, "set_autosync",
2096 ruby_guestfs_set_autosync, 1);
2097 rb_define_method (c_guestfs, "get_autosync",
2098 ruby_guestfs_get_autosync, 0);
2099 rb_define_method (c_guestfs, "set_verbose",
2100 ruby_guestfs_set_verbose, 1);
2101 rb_define_method (c_guestfs, "get_verbose",
2102 ruby_guestfs_get_verbose, 0);
2103 rb_define_method (c_guestfs, "is_ready",
2104 ruby_guestfs_is_ready, 0);
2105 rb_define_method (c_guestfs, "is_config",
2106 ruby_guestfs_is_config, 0);
2107 rb_define_method (c_guestfs, "is_launching",
2108 ruby_guestfs_is_launching, 0);
2109 rb_define_method (c_guestfs, "is_busy",
2110 ruby_guestfs_is_busy, 0);
2111 rb_define_method (c_guestfs, "get_state",
2112 ruby_guestfs_get_state, 0);
2113 rb_define_method (c_guestfs, "set_busy",
2114 ruby_guestfs_set_busy, 0);
2115 rb_define_method (c_guestfs, "set_ready",
2116 ruby_guestfs_set_ready, 0);
2117 rb_define_method (c_guestfs, "mount",
2118 ruby_guestfs_mount, 2);
2119 rb_define_method (c_guestfs, "sync",
2120 ruby_guestfs_sync, 0);
2121 rb_define_method (c_guestfs, "touch",
2122 ruby_guestfs_touch, 1);
2123 rb_define_method (c_guestfs, "cat",
2124 ruby_guestfs_cat, 1);
2125 rb_define_method (c_guestfs, "ll",
2126 ruby_guestfs_ll, 1);
2127 rb_define_method (c_guestfs, "ls",
2128 ruby_guestfs_ls, 1);
2129 rb_define_method (c_guestfs, "list_devices",
2130 ruby_guestfs_list_devices, 0);
2131 rb_define_method (c_guestfs, "list_partitions",
2132 ruby_guestfs_list_partitions, 0);
2133 rb_define_method (c_guestfs, "pvs",
2134 ruby_guestfs_pvs, 0);
2135 rb_define_method (c_guestfs, "vgs",
2136 ruby_guestfs_vgs, 0);
2137 rb_define_method (c_guestfs, "lvs",
2138 ruby_guestfs_lvs, 0);
2139 rb_define_method (c_guestfs, "pvs_full",
2140 ruby_guestfs_pvs_full, 0);
2141 rb_define_method (c_guestfs, "vgs_full",
2142 ruby_guestfs_vgs_full, 0);
2143 rb_define_method (c_guestfs, "lvs_full",
2144 ruby_guestfs_lvs_full, 0);
2145 rb_define_method (c_guestfs, "read_lines",
2146 ruby_guestfs_read_lines, 1);
2147 rb_define_method (c_guestfs, "aug_init",
2148 ruby_guestfs_aug_init, 2);
2149 rb_define_method (c_guestfs, "aug_close",
2150 ruby_guestfs_aug_close, 0);
2151 rb_define_method (c_guestfs, "aug_defvar",
2152 ruby_guestfs_aug_defvar, 2);
2153 rb_define_method (c_guestfs, "aug_defnode",
2154 ruby_guestfs_aug_defnode, 3);
2155 rb_define_method (c_guestfs, "aug_get",
2156 ruby_guestfs_aug_get, 1);
2157 rb_define_method (c_guestfs, "aug_set",
2158 ruby_guestfs_aug_set, 2);
2159 rb_define_method (c_guestfs, "aug_insert",
2160 ruby_guestfs_aug_insert, 3);
2161 rb_define_method (c_guestfs, "aug_rm",
2162 ruby_guestfs_aug_rm, 1);
2163 rb_define_method (c_guestfs, "aug_mv",
2164 ruby_guestfs_aug_mv, 2);
2165 rb_define_method (c_guestfs, "aug_match",
2166 ruby_guestfs_aug_match, 1);
2167 rb_define_method (c_guestfs, "aug_save",
2168 ruby_guestfs_aug_save, 0);
2169 rb_define_method (c_guestfs, "aug_load",
2170 ruby_guestfs_aug_load, 0);
2171 rb_define_method (c_guestfs, "aug_ls",
2172 ruby_guestfs_aug_ls, 1);
2173 rb_define_method (c_guestfs, "rm",
2174 ruby_guestfs_rm, 1);
2175 rb_define_method (c_guestfs, "rmdir",
2176 ruby_guestfs_rmdir, 1);
2177 rb_define_method (c_guestfs, "rm_rf",
2178 ruby_guestfs_rm_rf, 1);
2179 rb_define_method (c_guestfs, "mkdir",
2180 ruby_guestfs_mkdir, 1);
2181 rb_define_method (c_guestfs, "mkdir_p",
2182 ruby_guestfs_mkdir_p, 1);
2183 rb_define_method (c_guestfs, "chmod",
2184 ruby_guestfs_chmod, 2);
2185 rb_define_method (c_guestfs, "chown",
2186 ruby_guestfs_chown, 3);
2187 rb_define_method (c_guestfs, "exists",
2188 ruby_guestfs_exists, 1);
2189 rb_define_method (c_guestfs, "is_file",
2190 ruby_guestfs_is_file, 1);
2191 rb_define_method (c_guestfs, "is_dir",
2192 ruby_guestfs_is_dir, 1);
2193 rb_define_method (c_guestfs, "pvcreate",
2194 ruby_guestfs_pvcreate, 1);
2195 rb_define_method (c_guestfs, "vgcreate",
2196 ruby_guestfs_vgcreate, 2);
2197 rb_define_method (c_guestfs, "lvcreate",
2198 ruby_guestfs_lvcreate, 3);
2199 rb_define_method (c_guestfs, "mkfs",
2200 ruby_guestfs_mkfs, 2);
2201 rb_define_method (c_guestfs, "sfdisk",
2202 ruby_guestfs_sfdisk, 5);
2203 rb_define_method (c_guestfs, "write_file",
2204 ruby_guestfs_write_file, 3);
2205 rb_define_method (c_guestfs, "umount",
2206 ruby_guestfs_umount, 1);
2207 rb_define_method (c_guestfs, "mounts",
2208 ruby_guestfs_mounts, 0);
2209 rb_define_method (c_guestfs, "umount_all",
2210 ruby_guestfs_umount_all, 0);
2211 rb_define_method (c_guestfs, "lvm_remove_all",
2212 ruby_guestfs_lvm_remove_all, 0);
2213 rb_define_method (c_guestfs, "file",
2214 ruby_guestfs_file, 1);
2215 rb_define_method (c_guestfs, "command",
2216 ruby_guestfs_command, 1);
2217 rb_define_method (c_guestfs, "command_lines",
2218 ruby_guestfs_command_lines, 1);
2219 rb_define_method (c_guestfs, "stat",
2220 ruby_guestfs_stat, 1);
2221 rb_define_method (c_guestfs, "lstat",
2222 ruby_guestfs_lstat, 1);
2223 rb_define_method (c_guestfs, "statvfs",
2224 ruby_guestfs_statvfs, 1);
2225 rb_define_method (c_guestfs, "tune2fs_l",
2226 ruby_guestfs_tune2fs_l, 1);
2227 rb_define_method (c_guestfs, "blockdev_setro",
2228 ruby_guestfs_blockdev_setro, 1);
2229 rb_define_method (c_guestfs, "blockdev_setrw",
2230 ruby_guestfs_blockdev_setrw, 1);
2231 rb_define_method (c_guestfs, "blockdev_getro",
2232 ruby_guestfs_blockdev_getro, 1);
2233 rb_define_method (c_guestfs, "blockdev_getss",
2234 ruby_guestfs_blockdev_getss, 1);
2235 rb_define_method (c_guestfs, "blockdev_getbsz",
2236 ruby_guestfs_blockdev_getbsz, 1);
2237 rb_define_method (c_guestfs, "blockdev_setbsz",
2238 ruby_guestfs_blockdev_setbsz, 2);
2239 rb_define_method (c_guestfs, "blockdev_getsz",
2240 ruby_guestfs_blockdev_getsz, 1);
2241 rb_define_method (c_guestfs, "blockdev_getsize64",
2242 ruby_guestfs_blockdev_getsize64, 1);
2243 rb_define_method (c_guestfs, "blockdev_flushbufs",
2244 ruby_guestfs_blockdev_flushbufs, 1);
2245 rb_define_method (c_guestfs, "blockdev_rereadpt",
2246 ruby_guestfs_blockdev_rereadpt, 1);
2247 rb_define_method (c_guestfs, "upload",
2248 ruby_guestfs_upload, 2);
2249 rb_define_method (c_guestfs, "download",
2250 ruby_guestfs_download, 2);