X-Git-Url: http://git.annexia.org/?p=libguestfs.git;a=blobdiff_plain;f=ruby%2Fext%2Fguestfs%2F_guestfs.c;h=606e9a2afa3cb24c439d0339a790890bea60cedd;hp=cd4c27181368c8e6f57866ab0d535c214031b5d1;hb=0884d8bbae6d76a603ec1385ada2938f88981c5c;hpb=ef499de8946cf4b8120ef7917b2e5d7f9115041f diff --git a/ruby/ext/guestfs/_guestfs.c b/ruby/ext/guestfs/_guestfs.c index cd4c271..606e9a2 100644 --- a/ruby/ext/guestfs/_guestfs.c +++ b/ruby/ext/guestfs/_guestfs.c @@ -28,6 +28,11 @@ #include "extconf.h" +/* For Ruby < 1.9 */ +#ifndef RARRAY_LEN +#define RARRAY_LEN(r) (RARRAY((r))->len) +#endif + static VALUE m_guestfs; /* guestfs module */ static VALUE c_guestfs; /* guestfs_h handle */ static VALUE e_Error; /* used for all errors */ @@ -66,836 +71,3654 @@ static VALUE ruby_guestfs_close (VALUE gv) return Qnil; } -static VALUE ruby_guestfs_launch (VALUE gv) +static VALUE ruby_guestfs_test0 (VALUE gv, VALUE strv, VALUE optstrv, VALUE strlistv, VALUE bv, VALUE integerv, VALUE fileinv, VALUE fileoutv) { guestfs_h *g; Data_Get_Struct (gv, guestfs_h, g); if (!g) - rb_raise (rb_eArgError, "%s: used handle after closing it", "launch"); + rb_raise (rb_eArgError, "%s: used handle after closing it", "test0"); + Check_Type (strv, T_STRING); + const char *str = StringValueCStr (strv); + if (!str) + rb_raise (rb_eTypeError, "expected string for parameter %s of %s", + "str", "test0"); + const char *optstr = !NIL_P (optstrv) ? StringValueCStr (optstrv) : NULL; + char **strlist; + Check_Type (strlistv, T_ARRAY); + { + int i, len; + len = RARRAY_LEN (strlistv); + strlist = guestfs_safe_malloc (g, sizeof (char *) * (len+1)); + for (i = 0; i < len; ++i) { + VALUE v = rb_ary_entry (strlistv, i); + strlist[i] = StringValueCStr (v); + } + strlist[len] = NULL; + } + int b = RTEST (bv); + int integer = NUM2INT (integerv); + Check_Type (fileinv, T_STRING); + const char *filein = StringValueCStr (fileinv); + if (!filein) + rb_raise (rb_eTypeError, "expected string for parameter %s of %s", + "filein", "test0"); + Check_Type (fileoutv, T_STRING); + const char *fileout = StringValueCStr (fileoutv); + if (!fileout) + rb_raise (rb_eTypeError, "expected string for parameter %s of %s", + "fileout", "test0"); int r; - r = guestfs_launch (g); + r = guestfs_test0 (g, str, optstr, strlist, b, integer, filein, fileout); + free (strlist); if (r == -1) rb_raise (e_Error, "%s", guestfs_last_error (g)); return Qnil; } -static VALUE ruby_guestfs_wait_ready (VALUE gv) +static VALUE ruby_guestfs_test0rint (VALUE gv, VALUE valv) { guestfs_h *g; Data_Get_Struct (gv, guestfs_h, g); if (!g) - rb_raise (rb_eArgError, "%s: used handle after closing it", "wait_ready"); + rb_raise (rb_eArgError, "%s: used handle after closing it", "test0rint"); + Check_Type (valv, T_STRING); + const char *val = StringValueCStr (valv); + if (!val) + rb_raise (rb_eTypeError, "expected string for parameter %s of %s", + "val", "test0rint"); int r; - r = guestfs_wait_ready (g); + r = guestfs_test0rint (g, val); if (r == -1) rb_raise (e_Error, "%s", guestfs_last_error (g)); - return Qnil; + return INT2NUM (r); } -static VALUE ruby_guestfs_kill_subprocess (VALUE gv) +static VALUE ruby_guestfs_test0rinterr (VALUE gv) { guestfs_h *g; Data_Get_Struct (gv, guestfs_h, g); if (!g) - rb_raise (rb_eArgError, "%s: used handle after closing it", "kill_subprocess"); + rb_raise (rb_eArgError, "%s: used handle after closing it", "test0rinterr"); int r; - r = guestfs_kill_subprocess (g); + r = guestfs_test0rinterr (g); if (r == -1) rb_raise (e_Error, "%s", guestfs_last_error (g)); - return Qnil; + return INT2NUM (r); } -static VALUE ruby_guestfs_add_drive (VALUE gv, VALUE filenamev) +static VALUE ruby_guestfs_test0rint64 (VALUE gv, VALUE valv) { guestfs_h *g; Data_Get_Struct (gv, guestfs_h, g); if (!g) - rb_raise (rb_eArgError, "%s: used handle after closing it", "add_drive"); + rb_raise (rb_eArgError, "%s: used handle after closing it", "test0rint64"); - const char *filename = StringValueCStr (filenamev); - if (!filename) + Check_Type (valv, T_STRING); + const char *val = StringValueCStr (valv); + if (!val) rb_raise (rb_eTypeError, "expected string for parameter %s of %s", - "filename", "add_drive"); + "val", "test0rint64"); - int r; + int64_t r; - r = guestfs_add_drive (g, filename); + r = guestfs_test0rint64 (g, val); if (r == -1) rb_raise (e_Error, "%s", guestfs_last_error (g)); - return Qnil; + return ULL2NUM (r); } -static VALUE ruby_guestfs_add_cdrom (VALUE gv, VALUE filenamev) +static VALUE ruby_guestfs_test0rint64err (VALUE gv) { guestfs_h *g; Data_Get_Struct (gv, guestfs_h, g); if (!g) - rb_raise (rb_eArgError, "%s: used handle after closing it", "add_cdrom"); + rb_raise (rb_eArgError, "%s: used handle after closing it", "test0rint64err"); - const char *filename = StringValueCStr (filenamev); - if (!filename) - rb_raise (rb_eTypeError, "expected string for parameter %s of %s", - "filename", "add_cdrom"); - int r; + int64_t r; - r = guestfs_add_cdrom (g, filename); + r = guestfs_test0rint64err (g); if (r == -1) rb_raise (e_Error, "%s", guestfs_last_error (g)); - return Qnil; + return ULL2NUM (r); } -static VALUE ruby_guestfs_config (VALUE gv, VALUE qemuparamv, VALUE qemuvaluev) +static VALUE ruby_guestfs_test0rbool (VALUE gv, VALUE valv) { guestfs_h *g; Data_Get_Struct (gv, guestfs_h, g); if (!g) - rb_raise (rb_eArgError, "%s: used handle after closing it", "config"); + rb_raise (rb_eArgError, "%s: used handle after closing it", "test0rbool"); - const char *qemuparam = StringValueCStr (qemuparamv); - if (!qemuparam) + Check_Type (valv, T_STRING); + const char *val = StringValueCStr (valv); + if (!val) rb_raise (rb_eTypeError, "expected string for parameter %s of %s", - "qemuparam", "config"); - const char *qemuvalue = StringValueCStr (qemuvaluev); + "val", "test0rbool"); int r; - r = guestfs_config (g, qemuparam, qemuvalue); + r = guestfs_test0rbool (g, val); if (r == -1) rb_raise (e_Error, "%s", guestfs_last_error (g)); - return Qnil; + return INT2NUM (r); } -static VALUE ruby_guestfs_set_path (VALUE gv, VALUE pathv) +static VALUE ruby_guestfs_test0rboolerr (VALUE gv) { guestfs_h *g; Data_Get_Struct (gv, guestfs_h, g); if (!g) - rb_raise (rb_eArgError, "%s: used handle after closing it", "set_path"); + rb_raise (rb_eArgError, "%s: used handle after closing it", "test0rboolerr"); - const char *path = StringValueCStr (pathv); - if (!path) - rb_raise (rb_eTypeError, "expected string for parameter %s of %s", - "path", "set_path"); int r; - r = guestfs_set_path (g, path); + r = guestfs_test0rboolerr (g); if (r == -1) rb_raise (e_Error, "%s", guestfs_last_error (g)); - return Qnil; + return INT2NUM (r); } -static VALUE ruby_guestfs_get_path (VALUE gv) +static VALUE ruby_guestfs_test0rconststring (VALUE gv, VALUE valv) { guestfs_h *g; Data_Get_Struct (gv, guestfs_h, g); if (!g) - rb_raise (rb_eArgError, "%s: used handle after closing it", "get_path"); + rb_raise (rb_eArgError, "%s: used handle after closing it", "test0rconststring"); + Check_Type (valv, T_STRING); + const char *val = StringValueCStr (valv); + if (!val) + rb_raise (rb_eTypeError, "expected string for parameter %s of %s", + "val", "test0rconststring"); const char *r; - r = guestfs_get_path (g); + r = guestfs_test0rconststring (g, val); if (r == NULL) rb_raise (e_Error, "%s", guestfs_last_error (g)); return rb_str_new2 (r); } -static VALUE ruby_guestfs_set_autosync (VALUE gv, VALUE autosyncv) +static VALUE ruby_guestfs_test0rconststringerr (VALUE gv) { guestfs_h *g; Data_Get_Struct (gv, guestfs_h, g); if (!g) - rb_raise (rb_eArgError, "%s: used handle after closing it", "set_autosync"); + rb_raise (rb_eArgError, "%s: used handle after closing it", "test0rconststringerr"); - int autosync = NUM2INT (autosyncv); - int r; + const char *r; - r = guestfs_set_autosync (g, autosync); - if (r == -1) + r = guestfs_test0rconststringerr (g); + if (r == NULL) rb_raise (e_Error, "%s", guestfs_last_error (g)); - return Qnil; + return rb_str_new2 (r); } -static VALUE ruby_guestfs_get_autosync (VALUE gv) +static VALUE ruby_guestfs_test0rstring (VALUE gv, VALUE valv) { guestfs_h *g; Data_Get_Struct (gv, guestfs_h, g); if (!g) - rb_raise (rb_eArgError, "%s: used handle after closing it", "get_autosync"); + rb_raise (rb_eArgError, "%s: used handle after closing it", "test0rstring"); + Check_Type (valv, T_STRING); + const char *val = StringValueCStr (valv); + if (!val) + rb_raise (rb_eTypeError, "expected string for parameter %s of %s", + "val", "test0rstring"); - int r; + char *r; - r = guestfs_get_autosync (g); - if (r == -1) + r = guestfs_test0rstring (g, val); + if (r == NULL) rb_raise (e_Error, "%s", guestfs_last_error (g)); - return INT2NUM (r); + VALUE rv = rb_str_new2 (r); + free (r); + return rv; } -static VALUE ruby_guestfs_set_verbose (VALUE gv, VALUE verbosev) +static VALUE ruby_guestfs_test0rstringerr (VALUE gv) { guestfs_h *g; Data_Get_Struct (gv, guestfs_h, g); if (!g) - rb_raise (rb_eArgError, "%s: used handle after closing it", "set_verbose"); + rb_raise (rb_eArgError, "%s: used handle after closing it", "test0rstringerr"); - int verbose = NUM2INT (verbosev); - int r; + char *r; - r = guestfs_set_verbose (g, verbose); - if (r == -1) + r = guestfs_test0rstringerr (g); + if (r == NULL) rb_raise (e_Error, "%s", guestfs_last_error (g)); - return Qnil; + VALUE rv = rb_str_new2 (r); + free (r); + return rv; } -static VALUE ruby_guestfs_get_verbose (VALUE gv) +static VALUE ruby_guestfs_test0rstringlist (VALUE gv, VALUE valv) { guestfs_h *g; Data_Get_Struct (gv, guestfs_h, g); if (!g) - rb_raise (rb_eArgError, "%s: used handle after closing it", "get_verbose"); + rb_raise (rb_eArgError, "%s: used handle after closing it", "test0rstringlist"); + Check_Type (valv, T_STRING); + const char *val = StringValueCStr (valv); + if (!val) + rb_raise (rb_eTypeError, "expected string for parameter %s of %s", + "val", "test0rstringlist"); - int r; + char **r; - r = guestfs_get_verbose (g); - if (r == -1) + r = guestfs_test0rstringlist (g, val); + if (r == NULL) rb_raise (e_Error, "%s", guestfs_last_error (g)); - return INT2NUM (r); + int i, len = 0; + for (i = 0; r[i] != NULL; ++i) len++; + VALUE rv = rb_ary_new2 (len); + for (i = 0; r[i] != NULL; ++i) { + rb_ary_push (rv, rb_str_new2 (r[i])); + free (r[i]); + } + free (r); + return rv; } -static VALUE ruby_guestfs_is_ready (VALUE gv) +static VALUE ruby_guestfs_test0rstringlisterr (VALUE gv) { guestfs_h *g; Data_Get_Struct (gv, guestfs_h, g); if (!g) - rb_raise (rb_eArgError, "%s: used handle after closing it", "is_ready"); + rb_raise (rb_eArgError, "%s: used handle after closing it", "test0rstringlisterr"); - int r; + char **r; - r = guestfs_is_ready (g); - if (r == -1) + r = guestfs_test0rstringlisterr (g); + if (r == NULL) rb_raise (e_Error, "%s", guestfs_last_error (g)); - return INT2NUM (r); + int i, len = 0; + for (i = 0; r[i] != NULL; ++i) len++; + VALUE rv = rb_ary_new2 (len); + for (i = 0; r[i] != NULL; ++i) { + rb_ary_push (rv, rb_str_new2 (r[i])); + free (r[i]); + } + free (r); + return rv; } -static VALUE ruby_guestfs_is_config (VALUE gv) +static VALUE ruby_guestfs_test0rintbool (VALUE gv, VALUE valv) { guestfs_h *g; Data_Get_Struct (gv, guestfs_h, g); if (!g) - rb_raise (rb_eArgError, "%s: used handle after closing it", "is_config"); + rb_raise (rb_eArgError, "%s: used handle after closing it", "test0rintbool"); + Check_Type (valv, T_STRING); + const char *val = StringValueCStr (valv); + if (!val) + rb_raise (rb_eTypeError, "expected string for parameter %s of %s", + "val", "test0rintbool"); - int r; + struct guestfs_int_bool *r; - r = guestfs_is_config (g); - if (r == -1) + r = guestfs_test0rintbool (g, val); + if (r == NULL) rb_raise (e_Error, "%s", guestfs_last_error (g)); - return INT2NUM (r); + VALUE rv = rb_ary_new2 (2); + rb_ary_push (rv, INT2NUM (r->i)); + rb_ary_push (rv, INT2NUM (r->b)); + guestfs_free_int_bool (r); + return rv; } -static VALUE ruby_guestfs_is_launching (VALUE gv) +static VALUE ruby_guestfs_test0rintboolerr (VALUE gv) { guestfs_h *g; Data_Get_Struct (gv, guestfs_h, g); if (!g) - rb_raise (rb_eArgError, "%s: used handle after closing it", "is_launching"); + rb_raise (rb_eArgError, "%s: used handle after closing it", "test0rintboolerr"); - int r; + struct guestfs_int_bool *r; - r = guestfs_is_launching (g); - if (r == -1) + r = guestfs_test0rintboolerr (g); + if (r == NULL) rb_raise (e_Error, "%s", guestfs_last_error (g)); - return INT2NUM (r); + VALUE rv = rb_ary_new2 (2); + rb_ary_push (rv, INT2NUM (r->i)); + rb_ary_push (rv, INT2NUM (r->b)); + guestfs_free_int_bool (r); + return rv; } -static VALUE ruby_guestfs_is_busy (VALUE gv) +static VALUE ruby_guestfs_test0rpvlist (VALUE gv, VALUE valv) { guestfs_h *g; Data_Get_Struct (gv, guestfs_h, g); if (!g) - rb_raise (rb_eArgError, "%s: used handle after closing it", "is_busy"); + rb_raise (rb_eArgError, "%s: used handle after closing it", "test0rpvlist"); + Check_Type (valv, T_STRING); + const char *val = StringValueCStr (valv); + if (!val) + rb_raise (rb_eTypeError, "expected string for parameter %s of %s", + "val", "test0rpvlist"); - int r; + struct guestfs_lvm_pv_list *r; - r = guestfs_is_busy (g); - if (r == -1) + r = guestfs_test0rpvlist (g, val); + if (r == NULL) rb_raise (e_Error, "%s", guestfs_last_error (g)); - return INT2NUM (r); + VALUE rv = rb_ary_new2 (r->len); + int i; + for (i = 0; i < r->len; ++i) { + VALUE hv = rb_hash_new (); + rb_hash_aset (rv, rb_str_new2 ("pv_name"), rb_str_new2 (r->val[i].pv_name)); + rb_hash_aset (rv, rb_str_new2 ("pv_uuid"), rb_str_new (r->val[i].pv_uuid, 32)); + rb_hash_aset (rv, rb_str_new2 ("pv_fmt"), rb_str_new2 (r->val[i].pv_fmt)); + rb_hash_aset (rv, rb_str_new2 ("pv_size"), ULL2NUM (r->val[i].pv_size)); + rb_hash_aset (rv, rb_str_new2 ("dev_size"), ULL2NUM (r->val[i].dev_size)); + rb_hash_aset (rv, rb_str_new2 ("pv_free"), ULL2NUM (r->val[i].pv_free)); + rb_hash_aset (rv, rb_str_new2 ("pv_used"), ULL2NUM (r->val[i].pv_used)); + rb_hash_aset (rv, rb_str_new2 ("pv_attr"), rb_str_new2 (r->val[i].pv_attr)); + rb_hash_aset (rv, rb_str_new2 ("pv_pe_count"), ULL2NUM (r->val[i].pv_pe_count)); + rb_hash_aset (rv, rb_str_new2 ("pv_pe_alloc_count"), ULL2NUM (r->val[i].pv_pe_alloc_count)); + rb_hash_aset (rv, rb_str_new2 ("pv_tags"), rb_str_new2 (r->val[i].pv_tags)); + rb_hash_aset (rv, rb_str_new2 ("pe_start"), ULL2NUM (r->val[i].pe_start)); + rb_hash_aset (rv, rb_str_new2 ("pv_mda_count"), ULL2NUM (r->val[i].pv_mda_count)); + rb_hash_aset (rv, rb_str_new2 ("pv_mda_free"), ULL2NUM (r->val[i].pv_mda_free)); + rb_ary_push (rv, hv); + } + guestfs_free_lvm_pv_list (r); + return rv; } -static VALUE ruby_guestfs_get_state (VALUE gv) +static VALUE ruby_guestfs_test0rpvlisterr (VALUE gv) { guestfs_h *g; Data_Get_Struct (gv, guestfs_h, g); if (!g) - rb_raise (rb_eArgError, "%s: used handle after closing it", "get_state"); + rb_raise (rb_eArgError, "%s: used handle after closing it", "test0rpvlisterr"); - int r; + struct guestfs_lvm_pv_list *r; - r = guestfs_get_state (g); - if (r == -1) + r = guestfs_test0rpvlisterr (g); + if (r == NULL) rb_raise (e_Error, "%s", guestfs_last_error (g)); - return INT2NUM (r); + VALUE rv = rb_ary_new2 (r->len); + int i; + for (i = 0; i < r->len; ++i) { + VALUE hv = rb_hash_new (); + rb_hash_aset (rv, rb_str_new2 ("pv_name"), rb_str_new2 (r->val[i].pv_name)); + rb_hash_aset (rv, rb_str_new2 ("pv_uuid"), rb_str_new (r->val[i].pv_uuid, 32)); + rb_hash_aset (rv, rb_str_new2 ("pv_fmt"), rb_str_new2 (r->val[i].pv_fmt)); + rb_hash_aset (rv, rb_str_new2 ("pv_size"), ULL2NUM (r->val[i].pv_size)); + rb_hash_aset (rv, rb_str_new2 ("dev_size"), ULL2NUM (r->val[i].dev_size)); + rb_hash_aset (rv, rb_str_new2 ("pv_free"), ULL2NUM (r->val[i].pv_free)); + rb_hash_aset (rv, rb_str_new2 ("pv_used"), ULL2NUM (r->val[i].pv_used)); + rb_hash_aset (rv, rb_str_new2 ("pv_attr"), rb_str_new2 (r->val[i].pv_attr)); + rb_hash_aset (rv, rb_str_new2 ("pv_pe_count"), ULL2NUM (r->val[i].pv_pe_count)); + rb_hash_aset (rv, rb_str_new2 ("pv_pe_alloc_count"), ULL2NUM (r->val[i].pv_pe_alloc_count)); + rb_hash_aset (rv, rb_str_new2 ("pv_tags"), rb_str_new2 (r->val[i].pv_tags)); + rb_hash_aset (rv, rb_str_new2 ("pe_start"), ULL2NUM (r->val[i].pe_start)); + rb_hash_aset (rv, rb_str_new2 ("pv_mda_count"), ULL2NUM (r->val[i].pv_mda_count)); + rb_hash_aset (rv, rb_str_new2 ("pv_mda_free"), ULL2NUM (r->val[i].pv_mda_free)); + rb_ary_push (rv, hv); + } + guestfs_free_lvm_pv_list (r); + return rv; } -static VALUE ruby_guestfs_mount (VALUE gv, VALUE devicev, VALUE mountpointv) +static VALUE ruby_guestfs_test0rvglist (VALUE gv, VALUE valv) { guestfs_h *g; Data_Get_Struct (gv, guestfs_h, g); if (!g) - rb_raise (rb_eArgError, "%s: used handle after closing it", "mount"); + rb_raise (rb_eArgError, "%s: used handle after closing it", "test0rvglist"); - const char *device = StringValueCStr (devicev); - if (!device) - rb_raise (rb_eTypeError, "expected string for parameter %s of %s", - "device", "mount"); - const char *mountpoint = StringValueCStr (mountpointv); - if (!mountpoint) + Check_Type (valv, T_STRING); + const char *val = StringValueCStr (valv); + if (!val) rb_raise (rb_eTypeError, "expected string for parameter %s of %s", - "mountpoint", "mount"); + "val", "test0rvglist"); - int r; + struct guestfs_lvm_vg_list *r; - r = guestfs_mount (g, device, mountpoint); - if (r == -1) + r = guestfs_test0rvglist (g, val); + if (r == NULL) rb_raise (e_Error, "%s", guestfs_last_error (g)); - return Qnil; -} - -static VALUE ruby_guestfs_sync (VALUE gv) -{ + VALUE rv = rb_ary_new2 (r->len); + int i; + for (i = 0; i < r->len; ++i) { + VALUE hv = rb_hash_new (); + rb_hash_aset (rv, rb_str_new2 ("vg_name"), rb_str_new2 (r->val[i].vg_name)); + rb_hash_aset (rv, rb_str_new2 ("vg_uuid"), rb_str_new (r->val[i].vg_uuid, 32)); + rb_hash_aset (rv, rb_str_new2 ("vg_fmt"), rb_str_new2 (r->val[i].vg_fmt)); + rb_hash_aset (rv, rb_str_new2 ("vg_attr"), rb_str_new2 (r->val[i].vg_attr)); + rb_hash_aset (rv, rb_str_new2 ("vg_size"), ULL2NUM (r->val[i].vg_size)); + rb_hash_aset (rv, rb_str_new2 ("vg_free"), ULL2NUM (r->val[i].vg_free)); + rb_hash_aset (rv, rb_str_new2 ("vg_sysid"), rb_str_new2 (r->val[i].vg_sysid)); + rb_hash_aset (rv, rb_str_new2 ("vg_extent_size"), ULL2NUM (r->val[i].vg_extent_size)); + rb_hash_aset (rv, rb_str_new2 ("vg_extent_count"), ULL2NUM (r->val[i].vg_extent_count)); + rb_hash_aset (rv, rb_str_new2 ("vg_free_count"), ULL2NUM (r->val[i].vg_free_count)); + rb_hash_aset (rv, rb_str_new2 ("max_lv"), ULL2NUM (r->val[i].max_lv)); + rb_hash_aset (rv, rb_str_new2 ("max_pv"), ULL2NUM (r->val[i].max_pv)); + rb_hash_aset (rv, rb_str_new2 ("pv_count"), ULL2NUM (r->val[i].pv_count)); + rb_hash_aset (rv, rb_str_new2 ("lv_count"), ULL2NUM (r->val[i].lv_count)); + rb_hash_aset (rv, rb_str_new2 ("snap_count"), ULL2NUM (r->val[i].snap_count)); + rb_hash_aset (rv, rb_str_new2 ("vg_seqno"), ULL2NUM (r->val[i].vg_seqno)); + rb_hash_aset (rv, rb_str_new2 ("vg_tags"), rb_str_new2 (r->val[i].vg_tags)); + rb_hash_aset (rv, rb_str_new2 ("vg_mda_count"), ULL2NUM (r->val[i].vg_mda_count)); + rb_hash_aset (rv, rb_str_new2 ("vg_mda_free"), ULL2NUM (r->val[i].vg_mda_free)); + rb_ary_push (rv, hv); + } + guestfs_free_lvm_vg_list (r); + return rv; +} + +static VALUE ruby_guestfs_test0rvglisterr (VALUE gv) +{ + guestfs_h *g; + Data_Get_Struct (gv, guestfs_h, g); + if (!g) + rb_raise (rb_eArgError, "%s: used handle after closing it", "test0rvglisterr"); + + + struct guestfs_lvm_vg_list *r; + + r = guestfs_test0rvglisterr (g); + if (r == NULL) + rb_raise (e_Error, "%s", guestfs_last_error (g)); + + VALUE rv = rb_ary_new2 (r->len); + int i; + for (i = 0; i < r->len; ++i) { + VALUE hv = rb_hash_new (); + rb_hash_aset (rv, rb_str_new2 ("vg_name"), rb_str_new2 (r->val[i].vg_name)); + rb_hash_aset (rv, rb_str_new2 ("vg_uuid"), rb_str_new (r->val[i].vg_uuid, 32)); + rb_hash_aset (rv, rb_str_new2 ("vg_fmt"), rb_str_new2 (r->val[i].vg_fmt)); + rb_hash_aset (rv, rb_str_new2 ("vg_attr"), rb_str_new2 (r->val[i].vg_attr)); + rb_hash_aset (rv, rb_str_new2 ("vg_size"), ULL2NUM (r->val[i].vg_size)); + rb_hash_aset (rv, rb_str_new2 ("vg_free"), ULL2NUM (r->val[i].vg_free)); + rb_hash_aset (rv, rb_str_new2 ("vg_sysid"), rb_str_new2 (r->val[i].vg_sysid)); + rb_hash_aset (rv, rb_str_new2 ("vg_extent_size"), ULL2NUM (r->val[i].vg_extent_size)); + rb_hash_aset (rv, rb_str_new2 ("vg_extent_count"), ULL2NUM (r->val[i].vg_extent_count)); + rb_hash_aset (rv, rb_str_new2 ("vg_free_count"), ULL2NUM (r->val[i].vg_free_count)); + rb_hash_aset (rv, rb_str_new2 ("max_lv"), ULL2NUM (r->val[i].max_lv)); + rb_hash_aset (rv, rb_str_new2 ("max_pv"), ULL2NUM (r->val[i].max_pv)); + rb_hash_aset (rv, rb_str_new2 ("pv_count"), ULL2NUM (r->val[i].pv_count)); + rb_hash_aset (rv, rb_str_new2 ("lv_count"), ULL2NUM (r->val[i].lv_count)); + rb_hash_aset (rv, rb_str_new2 ("snap_count"), ULL2NUM (r->val[i].snap_count)); + rb_hash_aset (rv, rb_str_new2 ("vg_seqno"), ULL2NUM (r->val[i].vg_seqno)); + rb_hash_aset (rv, rb_str_new2 ("vg_tags"), rb_str_new2 (r->val[i].vg_tags)); + rb_hash_aset (rv, rb_str_new2 ("vg_mda_count"), ULL2NUM (r->val[i].vg_mda_count)); + rb_hash_aset (rv, rb_str_new2 ("vg_mda_free"), ULL2NUM (r->val[i].vg_mda_free)); + rb_ary_push (rv, hv); + } + guestfs_free_lvm_vg_list (r); + return rv; +} + +static VALUE ruby_guestfs_test0rlvlist (VALUE gv, VALUE valv) +{ + guestfs_h *g; + Data_Get_Struct (gv, guestfs_h, g); + if (!g) + rb_raise (rb_eArgError, "%s: used handle after closing it", "test0rlvlist"); + + Check_Type (valv, T_STRING); + const char *val = StringValueCStr (valv); + if (!val) + rb_raise (rb_eTypeError, "expected string for parameter %s of %s", + "val", "test0rlvlist"); + + struct guestfs_lvm_lv_list *r; + + r = guestfs_test0rlvlist (g, val); + if (r == NULL) + rb_raise (e_Error, "%s", guestfs_last_error (g)); + + VALUE rv = rb_ary_new2 (r->len); + int i; + for (i = 0; i < r->len; ++i) { + VALUE hv = rb_hash_new (); + rb_hash_aset (rv, rb_str_new2 ("lv_name"), rb_str_new2 (r->val[i].lv_name)); + rb_hash_aset (rv, rb_str_new2 ("lv_uuid"), rb_str_new (r->val[i].lv_uuid, 32)); + rb_hash_aset (rv, rb_str_new2 ("lv_attr"), rb_str_new2 (r->val[i].lv_attr)); + rb_hash_aset (rv, rb_str_new2 ("lv_major"), ULL2NUM (r->val[i].lv_major)); + rb_hash_aset (rv, rb_str_new2 ("lv_minor"), ULL2NUM (r->val[i].lv_minor)); + rb_hash_aset (rv, rb_str_new2 ("lv_kernel_major"), ULL2NUM (r->val[i].lv_kernel_major)); + rb_hash_aset (rv, rb_str_new2 ("lv_kernel_minor"), ULL2NUM (r->val[i].lv_kernel_minor)); + rb_hash_aset (rv, rb_str_new2 ("lv_size"), ULL2NUM (r->val[i].lv_size)); + rb_hash_aset (rv, rb_str_new2 ("seg_count"), ULL2NUM (r->val[i].seg_count)); + rb_hash_aset (rv, rb_str_new2 ("origin"), rb_str_new2 (r->val[i].origin)); + rb_hash_aset (rv, rb_str_new2 ("snap_percent"), rb_dbl2big (r->val[i].snap_percent)); + rb_hash_aset (rv, rb_str_new2 ("copy_percent"), rb_dbl2big (r->val[i].copy_percent)); + rb_hash_aset (rv, rb_str_new2 ("move_pv"), rb_str_new2 (r->val[i].move_pv)); + rb_hash_aset (rv, rb_str_new2 ("lv_tags"), rb_str_new2 (r->val[i].lv_tags)); + rb_hash_aset (rv, rb_str_new2 ("mirror_log"), rb_str_new2 (r->val[i].mirror_log)); + rb_hash_aset (rv, rb_str_new2 ("modules"), rb_str_new2 (r->val[i].modules)); + rb_ary_push (rv, hv); + } + guestfs_free_lvm_lv_list (r); + return rv; +} + +static VALUE ruby_guestfs_test0rlvlisterr (VALUE gv) +{ + guestfs_h *g; + Data_Get_Struct (gv, guestfs_h, g); + if (!g) + rb_raise (rb_eArgError, "%s: used handle after closing it", "test0rlvlisterr"); + + + struct guestfs_lvm_lv_list *r; + + r = guestfs_test0rlvlisterr (g); + if (r == NULL) + rb_raise (e_Error, "%s", guestfs_last_error (g)); + + VALUE rv = rb_ary_new2 (r->len); + int i; + for (i = 0; i < r->len; ++i) { + VALUE hv = rb_hash_new (); + rb_hash_aset (rv, rb_str_new2 ("lv_name"), rb_str_new2 (r->val[i].lv_name)); + rb_hash_aset (rv, rb_str_new2 ("lv_uuid"), rb_str_new (r->val[i].lv_uuid, 32)); + rb_hash_aset (rv, rb_str_new2 ("lv_attr"), rb_str_new2 (r->val[i].lv_attr)); + rb_hash_aset (rv, rb_str_new2 ("lv_major"), ULL2NUM (r->val[i].lv_major)); + rb_hash_aset (rv, rb_str_new2 ("lv_minor"), ULL2NUM (r->val[i].lv_minor)); + rb_hash_aset (rv, rb_str_new2 ("lv_kernel_major"), ULL2NUM (r->val[i].lv_kernel_major)); + rb_hash_aset (rv, rb_str_new2 ("lv_kernel_minor"), ULL2NUM (r->val[i].lv_kernel_minor)); + rb_hash_aset (rv, rb_str_new2 ("lv_size"), ULL2NUM (r->val[i].lv_size)); + rb_hash_aset (rv, rb_str_new2 ("seg_count"), ULL2NUM (r->val[i].seg_count)); + rb_hash_aset (rv, rb_str_new2 ("origin"), rb_str_new2 (r->val[i].origin)); + rb_hash_aset (rv, rb_str_new2 ("snap_percent"), rb_dbl2big (r->val[i].snap_percent)); + rb_hash_aset (rv, rb_str_new2 ("copy_percent"), rb_dbl2big (r->val[i].copy_percent)); + rb_hash_aset (rv, rb_str_new2 ("move_pv"), rb_str_new2 (r->val[i].move_pv)); + rb_hash_aset (rv, rb_str_new2 ("lv_tags"), rb_str_new2 (r->val[i].lv_tags)); + rb_hash_aset (rv, rb_str_new2 ("mirror_log"), rb_str_new2 (r->val[i].mirror_log)); + rb_hash_aset (rv, rb_str_new2 ("modules"), rb_str_new2 (r->val[i].modules)); + rb_ary_push (rv, hv); + } + guestfs_free_lvm_lv_list (r); + return rv; +} + +static VALUE ruby_guestfs_test0rstat (VALUE gv, VALUE valv) +{ + guestfs_h *g; + Data_Get_Struct (gv, guestfs_h, g); + if (!g) + rb_raise (rb_eArgError, "%s: used handle after closing it", "test0rstat"); + + Check_Type (valv, T_STRING); + const char *val = StringValueCStr (valv); + if (!val) + rb_raise (rb_eTypeError, "expected string for parameter %s of %s", + "val", "test0rstat"); + + struct guestfs_stat *r; + + r = guestfs_test0rstat (g, val); + if (r == NULL) + rb_raise (e_Error, "%s", guestfs_last_error (g)); + + VALUE rv = rb_hash_new (); + rb_hash_aset (rv, rb_str_new2 ("dev"), ULL2NUM (r->dev)); + rb_hash_aset (rv, rb_str_new2 ("ino"), ULL2NUM (r->ino)); + rb_hash_aset (rv, rb_str_new2 ("mode"), ULL2NUM (r->mode)); + rb_hash_aset (rv, rb_str_new2 ("nlink"), ULL2NUM (r->nlink)); + rb_hash_aset (rv, rb_str_new2 ("uid"), ULL2NUM (r->uid)); + rb_hash_aset (rv, rb_str_new2 ("gid"), ULL2NUM (r->gid)); + rb_hash_aset (rv, rb_str_new2 ("rdev"), ULL2NUM (r->rdev)); + rb_hash_aset (rv, rb_str_new2 ("size"), ULL2NUM (r->size)); + rb_hash_aset (rv, rb_str_new2 ("blksize"), ULL2NUM (r->blksize)); + rb_hash_aset (rv, rb_str_new2 ("blocks"), ULL2NUM (r->blocks)); + rb_hash_aset (rv, rb_str_new2 ("atime"), ULL2NUM (r->atime)); + rb_hash_aset (rv, rb_str_new2 ("mtime"), ULL2NUM (r->mtime)); + rb_hash_aset (rv, rb_str_new2 ("ctime"), ULL2NUM (r->ctime)); + free (r); + return rv; +} + +static VALUE ruby_guestfs_test0rstaterr (VALUE gv) +{ + guestfs_h *g; + Data_Get_Struct (gv, guestfs_h, g); + if (!g) + rb_raise (rb_eArgError, "%s: used handle after closing it", "test0rstaterr"); + + + struct guestfs_stat *r; + + r = guestfs_test0rstaterr (g); + if (r == NULL) + rb_raise (e_Error, "%s", guestfs_last_error (g)); + + VALUE rv = rb_hash_new (); + rb_hash_aset (rv, rb_str_new2 ("dev"), ULL2NUM (r->dev)); + rb_hash_aset (rv, rb_str_new2 ("ino"), ULL2NUM (r->ino)); + rb_hash_aset (rv, rb_str_new2 ("mode"), ULL2NUM (r->mode)); + rb_hash_aset (rv, rb_str_new2 ("nlink"), ULL2NUM (r->nlink)); + rb_hash_aset (rv, rb_str_new2 ("uid"), ULL2NUM (r->uid)); + rb_hash_aset (rv, rb_str_new2 ("gid"), ULL2NUM (r->gid)); + rb_hash_aset (rv, rb_str_new2 ("rdev"), ULL2NUM (r->rdev)); + rb_hash_aset (rv, rb_str_new2 ("size"), ULL2NUM (r->size)); + rb_hash_aset (rv, rb_str_new2 ("blksize"), ULL2NUM (r->blksize)); + rb_hash_aset (rv, rb_str_new2 ("blocks"), ULL2NUM (r->blocks)); + rb_hash_aset (rv, rb_str_new2 ("atime"), ULL2NUM (r->atime)); + rb_hash_aset (rv, rb_str_new2 ("mtime"), ULL2NUM (r->mtime)); + rb_hash_aset (rv, rb_str_new2 ("ctime"), ULL2NUM (r->ctime)); + free (r); + return rv; +} + +static VALUE ruby_guestfs_test0rstatvfs (VALUE gv, VALUE valv) +{ + guestfs_h *g; + Data_Get_Struct (gv, guestfs_h, g); + if (!g) + rb_raise (rb_eArgError, "%s: used handle after closing it", "test0rstatvfs"); + + Check_Type (valv, T_STRING); + const char *val = StringValueCStr (valv); + if (!val) + rb_raise (rb_eTypeError, "expected string for parameter %s of %s", + "val", "test0rstatvfs"); + + struct guestfs_statvfs *r; + + r = guestfs_test0rstatvfs (g, val); + if (r == NULL) + rb_raise (e_Error, "%s", guestfs_last_error (g)); + + VALUE rv = rb_hash_new (); + rb_hash_aset (rv, rb_str_new2 ("bsize"), ULL2NUM (r->bsize)); + rb_hash_aset (rv, rb_str_new2 ("frsize"), ULL2NUM (r->frsize)); + rb_hash_aset (rv, rb_str_new2 ("blocks"), ULL2NUM (r->blocks)); + rb_hash_aset (rv, rb_str_new2 ("bfree"), ULL2NUM (r->bfree)); + rb_hash_aset (rv, rb_str_new2 ("bavail"), ULL2NUM (r->bavail)); + rb_hash_aset (rv, rb_str_new2 ("files"), ULL2NUM (r->files)); + rb_hash_aset (rv, rb_str_new2 ("ffree"), ULL2NUM (r->ffree)); + rb_hash_aset (rv, rb_str_new2 ("favail"), ULL2NUM (r->favail)); + rb_hash_aset (rv, rb_str_new2 ("fsid"), ULL2NUM (r->fsid)); + rb_hash_aset (rv, rb_str_new2 ("flag"), ULL2NUM (r->flag)); + rb_hash_aset (rv, rb_str_new2 ("namemax"), ULL2NUM (r->namemax)); + free (r); + return rv; +} + +static VALUE ruby_guestfs_test0rstatvfserr (VALUE gv) +{ + guestfs_h *g; + Data_Get_Struct (gv, guestfs_h, g); + if (!g) + rb_raise (rb_eArgError, "%s: used handle after closing it", "test0rstatvfserr"); + + + struct guestfs_statvfs *r; + + r = guestfs_test0rstatvfserr (g); + if (r == NULL) + rb_raise (e_Error, "%s", guestfs_last_error (g)); + + VALUE rv = rb_hash_new (); + rb_hash_aset (rv, rb_str_new2 ("bsize"), ULL2NUM (r->bsize)); + rb_hash_aset (rv, rb_str_new2 ("frsize"), ULL2NUM (r->frsize)); + rb_hash_aset (rv, rb_str_new2 ("blocks"), ULL2NUM (r->blocks)); + rb_hash_aset (rv, rb_str_new2 ("bfree"), ULL2NUM (r->bfree)); + rb_hash_aset (rv, rb_str_new2 ("bavail"), ULL2NUM (r->bavail)); + rb_hash_aset (rv, rb_str_new2 ("files"), ULL2NUM (r->files)); + rb_hash_aset (rv, rb_str_new2 ("ffree"), ULL2NUM (r->ffree)); + rb_hash_aset (rv, rb_str_new2 ("favail"), ULL2NUM (r->favail)); + rb_hash_aset (rv, rb_str_new2 ("fsid"), ULL2NUM (r->fsid)); + rb_hash_aset (rv, rb_str_new2 ("flag"), ULL2NUM (r->flag)); + rb_hash_aset (rv, rb_str_new2 ("namemax"), ULL2NUM (r->namemax)); + free (r); + return rv; +} + +static VALUE ruby_guestfs_test0rhashtable (VALUE gv, VALUE valv) +{ + guestfs_h *g; + Data_Get_Struct (gv, guestfs_h, g); + if (!g) + rb_raise (rb_eArgError, "%s: used handle after closing it", "test0rhashtable"); + + Check_Type (valv, T_STRING); + const char *val = StringValueCStr (valv); + if (!val) + rb_raise (rb_eTypeError, "expected string for parameter %s of %s", + "val", "test0rhashtable"); + + char **r; + + r = guestfs_test0rhashtable (g, val); + if (r == NULL) + rb_raise (e_Error, "%s", guestfs_last_error (g)); + + VALUE rv = rb_hash_new (); + int i; + for (i = 0; r[i] != NULL; i+=2) { + rb_hash_aset (rv, rb_str_new2 (r[i]), rb_str_new2 (r[i+1])); + free (r[i]); + free (r[i+1]); + } + free (r); + return rv; +} + +static VALUE ruby_guestfs_test0rhashtableerr (VALUE gv) +{ + guestfs_h *g; + Data_Get_Struct (gv, guestfs_h, g); + if (!g) + rb_raise (rb_eArgError, "%s: used handle after closing it", "test0rhashtableerr"); + + + char **r; + + r = guestfs_test0rhashtableerr (g); + if (r == NULL) + rb_raise (e_Error, "%s", guestfs_last_error (g)); + + VALUE rv = rb_hash_new (); + int i; + for (i = 0; r[i] != NULL; i+=2) { + rb_hash_aset (rv, rb_str_new2 (r[i]), rb_str_new2 (r[i+1])); + free (r[i]); + free (r[i+1]); + } + free (r); + return rv; +} + +static VALUE ruby_guestfs_launch (VALUE gv) +{ + guestfs_h *g; + Data_Get_Struct (gv, guestfs_h, g); + if (!g) + rb_raise (rb_eArgError, "%s: used handle after closing it", "launch"); + + + int r; + + r = guestfs_launch (g); + if (r == -1) + rb_raise (e_Error, "%s", guestfs_last_error (g)); + + return Qnil; +} + +static VALUE ruby_guestfs_wait_ready (VALUE gv) +{ + guestfs_h *g; + Data_Get_Struct (gv, guestfs_h, g); + if (!g) + rb_raise (rb_eArgError, "%s: used handle after closing it", "wait_ready"); + + + int r; + + r = guestfs_wait_ready (g); + if (r == -1) + rb_raise (e_Error, "%s", guestfs_last_error (g)); + + return Qnil; +} + +static VALUE ruby_guestfs_kill_subprocess (VALUE gv) +{ + guestfs_h *g; + Data_Get_Struct (gv, guestfs_h, g); + if (!g) + rb_raise (rb_eArgError, "%s: used handle after closing it", "kill_subprocess"); + + + int r; + + r = guestfs_kill_subprocess (g); + if (r == -1) + rb_raise (e_Error, "%s", guestfs_last_error (g)); + + return Qnil; +} + +static VALUE ruby_guestfs_add_drive (VALUE gv, VALUE filenamev) +{ + guestfs_h *g; + Data_Get_Struct (gv, guestfs_h, g); + if (!g) + rb_raise (rb_eArgError, "%s: used handle after closing it", "add_drive"); + + Check_Type (filenamev, T_STRING); + const char *filename = StringValueCStr (filenamev); + if (!filename) + rb_raise (rb_eTypeError, "expected string for parameter %s of %s", + "filename", "add_drive"); + + int r; + + r = guestfs_add_drive (g, filename); + if (r == -1) + rb_raise (e_Error, "%s", guestfs_last_error (g)); + + return Qnil; +} + +static VALUE ruby_guestfs_add_cdrom (VALUE gv, VALUE filenamev) +{ + guestfs_h *g; + Data_Get_Struct (gv, guestfs_h, g); + if (!g) + rb_raise (rb_eArgError, "%s: used handle after closing it", "add_cdrom"); + + Check_Type (filenamev, T_STRING); + const char *filename = StringValueCStr (filenamev); + if (!filename) + rb_raise (rb_eTypeError, "expected string for parameter %s of %s", + "filename", "add_cdrom"); + + int r; + + r = guestfs_add_cdrom (g, filename); + if (r == -1) + rb_raise (e_Error, "%s", guestfs_last_error (g)); + + return Qnil; +} + +static VALUE ruby_guestfs_add_drive_ro (VALUE gv, VALUE filenamev) +{ + guestfs_h *g; + Data_Get_Struct (gv, guestfs_h, g); + if (!g) + rb_raise (rb_eArgError, "%s: used handle after closing it", "add_drive_ro"); + + Check_Type (filenamev, T_STRING); + const char *filename = StringValueCStr (filenamev); + if (!filename) + rb_raise (rb_eTypeError, "expected string for parameter %s of %s", + "filename", "add_drive_ro"); + + int r; + + r = guestfs_add_drive_ro (g, filename); + if (r == -1) + rb_raise (e_Error, "%s", guestfs_last_error (g)); + + return Qnil; +} + +static VALUE ruby_guestfs_config (VALUE gv, VALUE qemuparamv, VALUE qemuvaluev) +{ + guestfs_h *g; + Data_Get_Struct (gv, guestfs_h, g); + if (!g) + rb_raise (rb_eArgError, "%s: used handle after closing it", "config"); + + Check_Type (qemuparamv, T_STRING); + const char *qemuparam = StringValueCStr (qemuparamv); + if (!qemuparam) + rb_raise (rb_eTypeError, "expected string for parameter %s of %s", + "qemuparam", "config"); + const char *qemuvalue = !NIL_P (qemuvaluev) ? StringValueCStr (qemuvaluev) : NULL; + + int r; + + r = guestfs_config (g, qemuparam, qemuvalue); + if (r == -1) + rb_raise (e_Error, "%s", guestfs_last_error (g)); + + return Qnil; +} + +static VALUE ruby_guestfs_set_qemu (VALUE gv, VALUE qemuv) +{ + guestfs_h *g; + Data_Get_Struct (gv, guestfs_h, g); + if (!g) + rb_raise (rb_eArgError, "%s: used handle after closing it", "set_qemu"); + + Check_Type (qemuv, T_STRING); + const char *qemu = StringValueCStr (qemuv); + if (!qemu) + rb_raise (rb_eTypeError, "expected string for parameter %s of %s", + "qemu", "set_qemu"); + + int r; + + r = guestfs_set_qemu (g, qemu); + if (r == -1) + rb_raise (e_Error, "%s", guestfs_last_error (g)); + + return Qnil; +} + +static VALUE ruby_guestfs_get_qemu (VALUE gv) +{ + guestfs_h *g; + Data_Get_Struct (gv, guestfs_h, g); + if (!g) + rb_raise (rb_eArgError, "%s: used handle after closing it", "get_qemu"); + + + const char *r; + + r = guestfs_get_qemu (g); + if (r == NULL) + rb_raise (e_Error, "%s", guestfs_last_error (g)); + + return rb_str_new2 (r); +} + +static VALUE ruby_guestfs_set_path (VALUE gv, VALUE pathv) +{ + guestfs_h *g; + Data_Get_Struct (gv, guestfs_h, g); + if (!g) + rb_raise (rb_eArgError, "%s: used handle after closing it", "set_path"); + + Check_Type (pathv, T_STRING); + const char *path = StringValueCStr (pathv); + if (!path) + rb_raise (rb_eTypeError, "expected string for parameter %s of %s", + "path", "set_path"); + + int r; + + r = guestfs_set_path (g, path); + if (r == -1) + rb_raise (e_Error, "%s", guestfs_last_error (g)); + + return Qnil; +} + +static VALUE ruby_guestfs_get_path (VALUE gv) +{ + guestfs_h *g; + Data_Get_Struct (gv, guestfs_h, g); + if (!g) + rb_raise (rb_eArgError, "%s: used handle after closing it", "get_path"); + + + const char *r; + + r = guestfs_get_path (g); + if (r == NULL) + rb_raise (e_Error, "%s", guestfs_last_error (g)); + + return rb_str_new2 (r); +} + +static VALUE ruby_guestfs_set_append (VALUE gv, VALUE appendv) +{ + guestfs_h *g; + Data_Get_Struct (gv, guestfs_h, g); + if (!g) + rb_raise (rb_eArgError, "%s: used handle after closing it", "set_append"); + + Check_Type (appendv, T_STRING); + const char *append = StringValueCStr (appendv); + if (!append) + rb_raise (rb_eTypeError, "expected string for parameter %s of %s", + "append", "set_append"); + + int r; + + r = guestfs_set_append (g, append); + if (r == -1) + rb_raise (e_Error, "%s", guestfs_last_error (g)); + + return Qnil; +} + +static VALUE ruby_guestfs_get_append (VALUE gv) +{ + guestfs_h *g; + Data_Get_Struct (gv, guestfs_h, g); + if (!g) + rb_raise (rb_eArgError, "%s: used handle after closing it", "get_append"); + + + const char *r; + + r = guestfs_get_append (g); + if (r == NULL) + rb_raise (e_Error, "%s", guestfs_last_error (g)); + + return rb_str_new2 (r); +} + +static VALUE ruby_guestfs_set_autosync (VALUE gv, VALUE autosyncv) +{ + guestfs_h *g; + Data_Get_Struct (gv, guestfs_h, g); + if (!g) + rb_raise (rb_eArgError, "%s: used handle after closing it", "set_autosync"); + + int autosync = RTEST (autosyncv); + + int r; + + r = guestfs_set_autosync (g, autosync); + if (r == -1) + rb_raise (e_Error, "%s", guestfs_last_error (g)); + + return Qnil; +} + +static VALUE ruby_guestfs_get_autosync (VALUE gv) +{ + guestfs_h *g; + Data_Get_Struct (gv, guestfs_h, g); + if (!g) + rb_raise (rb_eArgError, "%s: used handle after closing it", "get_autosync"); + + + int r; + + r = guestfs_get_autosync (g); + if (r == -1) + rb_raise (e_Error, "%s", guestfs_last_error (g)); + + return INT2NUM (r); +} + +static VALUE ruby_guestfs_set_verbose (VALUE gv, VALUE verbosev) +{ + guestfs_h *g; + Data_Get_Struct (gv, guestfs_h, g); + if (!g) + rb_raise (rb_eArgError, "%s: used handle after closing it", "set_verbose"); + + int verbose = RTEST (verbosev); + + int r; + + r = guestfs_set_verbose (g, verbose); + if (r == -1) + rb_raise (e_Error, "%s", guestfs_last_error (g)); + + return Qnil; +} + +static VALUE ruby_guestfs_get_verbose (VALUE gv) +{ + guestfs_h *g; + Data_Get_Struct (gv, guestfs_h, g); + if (!g) + rb_raise (rb_eArgError, "%s: used handle after closing it", "get_verbose"); + + + int r; + + r = guestfs_get_verbose (g); + if (r == -1) + rb_raise (e_Error, "%s", guestfs_last_error (g)); + + return INT2NUM (r); +} + +static VALUE ruby_guestfs_is_ready (VALUE gv) +{ + guestfs_h *g; + Data_Get_Struct (gv, guestfs_h, g); + if (!g) + rb_raise (rb_eArgError, "%s: used handle after closing it", "is_ready"); + + + int r; + + r = guestfs_is_ready (g); + if (r == -1) + rb_raise (e_Error, "%s", guestfs_last_error (g)); + + return INT2NUM (r); +} + +static VALUE ruby_guestfs_is_config (VALUE gv) +{ + guestfs_h *g; + Data_Get_Struct (gv, guestfs_h, g); + if (!g) + rb_raise (rb_eArgError, "%s: used handle after closing it", "is_config"); + + + int r; + + r = guestfs_is_config (g); + if (r == -1) + rb_raise (e_Error, "%s", guestfs_last_error (g)); + + return INT2NUM (r); +} + +static VALUE ruby_guestfs_is_launching (VALUE gv) +{ + guestfs_h *g; + Data_Get_Struct (gv, guestfs_h, g); + if (!g) + rb_raise (rb_eArgError, "%s: used handle after closing it", "is_launching"); + + + int r; + + r = guestfs_is_launching (g); + if (r == -1) + rb_raise (e_Error, "%s", guestfs_last_error (g)); + + return INT2NUM (r); +} + +static VALUE ruby_guestfs_is_busy (VALUE gv) +{ + guestfs_h *g; + Data_Get_Struct (gv, guestfs_h, g); + if (!g) + rb_raise (rb_eArgError, "%s: used handle after closing it", "is_busy"); + + + int r; + + r = guestfs_is_busy (g); + if (r == -1) + rb_raise (e_Error, "%s", guestfs_last_error (g)); + + return INT2NUM (r); +} + +static VALUE ruby_guestfs_get_state (VALUE gv) +{ + guestfs_h *g; + Data_Get_Struct (gv, guestfs_h, g); + if (!g) + rb_raise (rb_eArgError, "%s: used handle after closing it", "get_state"); + + + int r; + + r = guestfs_get_state (g); + if (r == -1) + rb_raise (e_Error, "%s", guestfs_last_error (g)); + + return INT2NUM (r); +} + +static VALUE ruby_guestfs_set_busy (VALUE gv) +{ + guestfs_h *g; + Data_Get_Struct (gv, guestfs_h, g); + if (!g) + rb_raise (rb_eArgError, "%s: used handle after closing it", "set_busy"); + + + int r; + + r = guestfs_set_busy (g); + if (r == -1) + rb_raise (e_Error, "%s", guestfs_last_error (g)); + + return Qnil; +} + +static VALUE ruby_guestfs_set_ready (VALUE gv) +{ + guestfs_h *g; + Data_Get_Struct (gv, guestfs_h, g); + if (!g) + rb_raise (rb_eArgError, "%s: used handle after closing it", "set_ready"); + + + int r; + + r = guestfs_set_ready (g); + if (r == -1) + rb_raise (e_Error, "%s", guestfs_last_error (g)); + + return Qnil; +} + +static VALUE ruby_guestfs_end_busy (VALUE gv) +{ + guestfs_h *g; + Data_Get_Struct (gv, guestfs_h, g); + if (!g) + rb_raise (rb_eArgError, "%s: used handle after closing it", "end_busy"); + + + int r; + + r = guestfs_end_busy (g); + if (r == -1) + rb_raise (e_Error, "%s", guestfs_last_error (g)); + + return Qnil; +} + +static VALUE ruby_guestfs_set_memsize (VALUE gv, VALUE memsizev) +{ + guestfs_h *g; + Data_Get_Struct (gv, guestfs_h, g); + if (!g) + rb_raise (rb_eArgError, "%s: used handle after closing it", "set_memsize"); + + int memsize = NUM2INT (memsizev); + + int r; + + r = guestfs_set_memsize (g, memsize); + if (r == -1) + rb_raise (e_Error, "%s", guestfs_last_error (g)); + + return Qnil; +} + +static VALUE ruby_guestfs_get_memsize (VALUE gv) +{ + guestfs_h *g; + Data_Get_Struct (gv, guestfs_h, g); + if (!g) + rb_raise (rb_eArgError, "%s: used handle after closing it", "get_memsize"); + + + int r; + + r = guestfs_get_memsize (g); + if (r == -1) + rb_raise (e_Error, "%s", guestfs_last_error (g)); + + return INT2NUM (r); +} + +static VALUE ruby_guestfs_mount (VALUE gv, VALUE devicev, VALUE mountpointv) +{ + guestfs_h *g; + Data_Get_Struct (gv, guestfs_h, g); + if (!g) + rb_raise (rb_eArgError, "%s: used handle after closing it", "mount"); + + Check_Type (devicev, T_STRING); + const char *device = StringValueCStr (devicev); + if (!device) + rb_raise (rb_eTypeError, "expected string for parameter %s of %s", + "device", "mount"); + Check_Type (mountpointv, T_STRING); + const char *mountpoint = StringValueCStr (mountpointv); + if (!mountpoint) + rb_raise (rb_eTypeError, "expected string for parameter %s of %s", + "mountpoint", "mount"); + + int r; + + r = guestfs_mount (g, device, mountpoint); + if (r == -1) + rb_raise (e_Error, "%s", guestfs_last_error (g)); + + return Qnil; +} + +static VALUE ruby_guestfs_sync (VALUE gv) +{ + guestfs_h *g; + Data_Get_Struct (gv, guestfs_h, g); + if (!g) + rb_raise (rb_eArgError, "%s: used handle after closing it", "sync"); + + + int r; + + r = guestfs_sync (g); + if (r == -1) + rb_raise (e_Error, "%s", guestfs_last_error (g)); + + return Qnil; +} + +static VALUE ruby_guestfs_touch (VALUE gv, VALUE pathv) +{ + guestfs_h *g; + Data_Get_Struct (gv, guestfs_h, g); + if (!g) + rb_raise (rb_eArgError, "%s: used handle after closing it", "touch"); + + Check_Type (pathv, T_STRING); + const char *path = StringValueCStr (pathv); + if (!path) + rb_raise (rb_eTypeError, "expected string for parameter %s of %s", + "path", "touch"); + + int r; + + r = guestfs_touch (g, path); + if (r == -1) + rb_raise (e_Error, "%s", guestfs_last_error (g)); + + return Qnil; +} + +static VALUE ruby_guestfs_cat (VALUE gv, VALUE pathv) +{ + guestfs_h *g; + Data_Get_Struct (gv, guestfs_h, g); + if (!g) + rb_raise (rb_eArgError, "%s: used handle after closing it", "cat"); + + Check_Type (pathv, T_STRING); + const char *path = StringValueCStr (pathv); + if (!path) + rb_raise (rb_eTypeError, "expected string for parameter %s of %s", + "path", "cat"); + + char *r; + + r = guestfs_cat (g, path); + if (r == NULL) + rb_raise (e_Error, "%s", guestfs_last_error (g)); + + VALUE rv = rb_str_new2 (r); + free (r); + return rv; +} + +static VALUE ruby_guestfs_ll (VALUE gv, VALUE directoryv) +{ + guestfs_h *g; + Data_Get_Struct (gv, guestfs_h, g); + if (!g) + rb_raise (rb_eArgError, "%s: used handle after closing it", "ll"); + + Check_Type (directoryv, T_STRING); + const char *directory = StringValueCStr (directoryv); + if (!directory) + rb_raise (rb_eTypeError, "expected string for parameter %s of %s", + "directory", "ll"); + + char *r; + + r = guestfs_ll (g, directory); + if (r == NULL) + rb_raise (e_Error, "%s", guestfs_last_error (g)); + + VALUE rv = rb_str_new2 (r); + free (r); + return rv; +} + +static VALUE ruby_guestfs_ls (VALUE gv, VALUE directoryv) +{ + guestfs_h *g; + Data_Get_Struct (gv, guestfs_h, g); + if (!g) + rb_raise (rb_eArgError, "%s: used handle after closing it", "ls"); + + Check_Type (directoryv, T_STRING); + const char *directory = StringValueCStr (directoryv); + if (!directory) + rb_raise (rb_eTypeError, "expected string for parameter %s of %s", + "directory", "ls"); + + char **r; + + r = guestfs_ls (g, directory); + if (r == NULL) + rb_raise (e_Error, "%s", guestfs_last_error (g)); + + int i, len = 0; + for (i = 0; r[i] != NULL; ++i) len++; + VALUE rv = rb_ary_new2 (len); + for (i = 0; r[i] != NULL; ++i) { + rb_ary_push (rv, rb_str_new2 (r[i])); + free (r[i]); + } + free (r); + return rv; +} + +static VALUE ruby_guestfs_list_devices (VALUE gv) +{ + guestfs_h *g; + Data_Get_Struct (gv, guestfs_h, g); + if (!g) + rb_raise (rb_eArgError, "%s: used handle after closing it", "list_devices"); + + + char **r; + + r = guestfs_list_devices (g); + if (r == NULL) + rb_raise (e_Error, "%s", guestfs_last_error (g)); + + int i, len = 0; + for (i = 0; r[i] != NULL; ++i) len++; + VALUE rv = rb_ary_new2 (len); + for (i = 0; r[i] != NULL; ++i) { + rb_ary_push (rv, rb_str_new2 (r[i])); + free (r[i]); + } + free (r); + return rv; +} + +static VALUE ruby_guestfs_list_partitions (VALUE gv) +{ + guestfs_h *g; + Data_Get_Struct (gv, guestfs_h, g); + if (!g) + rb_raise (rb_eArgError, "%s: used handle after closing it", "list_partitions"); + + + char **r; + + r = guestfs_list_partitions (g); + if (r == NULL) + rb_raise (e_Error, "%s", guestfs_last_error (g)); + + int i, len = 0; + for (i = 0; r[i] != NULL; ++i) len++; + VALUE rv = rb_ary_new2 (len); + for (i = 0; r[i] != NULL; ++i) { + rb_ary_push (rv, rb_str_new2 (r[i])); + free (r[i]); + } + free (r); + return rv; +} + +static VALUE ruby_guestfs_pvs (VALUE gv) +{ + guestfs_h *g; + Data_Get_Struct (gv, guestfs_h, g); + if (!g) + rb_raise (rb_eArgError, "%s: used handle after closing it", "pvs"); + + + char **r; + + r = guestfs_pvs (g); + if (r == NULL) + rb_raise (e_Error, "%s", guestfs_last_error (g)); + + int i, len = 0; + for (i = 0; r[i] != NULL; ++i) len++; + VALUE rv = rb_ary_new2 (len); + for (i = 0; r[i] != NULL; ++i) { + rb_ary_push (rv, rb_str_new2 (r[i])); + free (r[i]); + } + free (r); + return rv; +} + +static VALUE ruby_guestfs_vgs (VALUE gv) +{ + guestfs_h *g; + Data_Get_Struct (gv, guestfs_h, g); + if (!g) + rb_raise (rb_eArgError, "%s: used handle after closing it", "vgs"); + + + char **r; + + r = guestfs_vgs (g); + if (r == NULL) + rb_raise (e_Error, "%s", guestfs_last_error (g)); + + int i, len = 0; + for (i = 0; r[i] != NULL; ++i) len++; + VALUE rv = rb_ary_new2 (len); + for (i = 0; r[i] != NULL; ++i) { + rb_ary_push (rv, rb_str_new2 (r[i])); + free (r[i]); + } + free (r); + return rv; +} + +static VALUE ruby_guestfs_lvs (VALUE gv) +{ + guestfs_h *g; + Data_Get_Struct (gv, guestfs_h, g); + if (!g) + rb_raise (rb_eArgError, "%s: used handle after closing it", "lvs"); + + + char **r; + + r = guestfs_lvs (g); + if (r == NULL) + rb_raise (e_Error, "%s", guestfs_last_error (g)); + + int i, len = 0; + for (i = 0; r[i] != NULL; ++i) len++; + VALUE rv = rb_ary_new2 (len); + for (i = 0; r[i] != NULL; ++i) { + rb_ary_push (rv, rb_str_new2 (r[i])); + free (r[i]); + } + free (r); + return rv; +} + +static VALUE ruby_guestfs_pvs_full (VALUE gv) +{ + guestfs_h *g; + Data_Get_Struct (gv, guestfs_h, g); + if (!g) + rb_raise (rb_eArgError, "%s: used handle after closing it", "pvs_full"); + + + struct guestfs_lvm_pv_list *r; + + r = guestfs_pvs_full (g); + if (r == NULL) + rb_raise (e_Error, "%s", guestfs_last_error (g)); + + VALUE rv = rb_ary_new2 (r->len); + int i; + for (i = 0; i < r->len; ++i) { + VALUE hv = rb_hash_new (); + rb_hash_aset (rv, rb_str_new2 ("pv_name"), rb_str_new2 (r->val[i].pv_name)); + rb_hash_aset (rv, rb_str_new2 ("pv_uuid"), rb_str_new (r->val[i].pv_uuid, 32)); + rb_hash_aset (rv, rb_str_new2 ("pv_fmt"), rb_str_new2 (r->val[i].pv_fmt)); + rb_hash_aset (rv, rb_str_new2 ("pv_size"), ULL2NUM (r->val[i].pv_size)); + rb_hash_aset (rv, rb_str_new2 ("dev_size"), ULL2NUM (r->val[i].dev_size)); + rb_hash_aset (rv, rb_str_new2 ("pv_free"), ULL2NUM (r->val[i].pv_free)); + rb_hash_aset (rv, rb_str_new2 ("pv_used"), ULL2NUM (r->val[i].pv_used)); + rb_hash_aset (rv, rb_str_new2 ("pv_attr"), rb_str_new2 (r->val[i].pv_attr)); + rb_hash_aset (rv, rb_str_new2 ("pv_pe_count"), ULL2NUM (r->val[i].pv_pe_count)); + rb_hash_aset (rv, rb_str_new2 ("pv_pe_alloc_count"), ULL2NUM (r->val[i].pv_pe_alloc_count)); + rb_hash_aset (rv, rb_str_new2 ("pv_tags"), rb_str_new2 (r->val[i].pv_tags)); + rb_hash_aset (rv, rb_str_new2 ("pe_start"), ULL2NUM (r->val[i].pe_start)); + rb_hash_aset (rv, rb_str_new2 ("pv_mda_count"), ULL2NUM (r->val[i].pv_mda_count)); + rb_hash_aset (rv, rb_str_new2 ("pv_mda_free"), ULL2NUM (r->val[i].pv_mda_free)); + rb_ary_push (rv, hv); + } + guestfs_free_lvm_pv_list (r); + return rv; +} + +static VALUE ruby_guestfs_vgs_full (VALUE gv) +{ + guestfs_h *g; + Data_Get_Struct (gv, guestfs_h, g); + if (!g) + rb_raise (rb_eArgError, "%s: used handle after closing it", "vgs_full"); + + + struct guestfs_lvm_vg_list *r; + + r = guestfs_vgs_full (g); + if (r == NULL) + rb_raise (e_Error, "%s", guestfs_last_error (g)); + + VALUE rv = rb_ary_new2 (r->len); + int i; + for (i = 0; i < r->len; ++i) { + VALUE hv = rb_hash_new (); + rb_hash_aset (rv, rb_str_new2 ("vg_name"), rb_str_new2 (r->val[i].vg_name)); + rb_hash_aset (rv, rb_str_new2 ("vg_uuid"), rb_str_new (r->val[i].vg_uuid, 32)); + rb_hash_aset (rv, rb_str_new2 ("vg_fmt"), rb_str_new2 (r->val[i].vg_fmt)); + rb_hash_aset (rv, rb_str_new2 ("vg_attr"), rb_str_new2 (r->val[i].vg_attr)); + rb_hash_aset (rv, rb_str_new2 ("vg_size"), ULL2NUM (r->val[i].vg_size)); + rb_hash_aset (rv, rb_str_new2 ("vg_free"), ULL2NUM (r->val[i].vg_free)); + rb_hash_aset (rv, rb_str_new2 ("vg_sysid"), rb_str_new2 (r->val[i].vg_sysid)); + rb_hash_aset (rv, rb_str_new2 ("vg_extent_size"), ULL2NUM (r->val[i].vg_extent_size)); + rb_hash_aset (rv, rb_str_new2 ("vg_extent_count"), ULL2NUM (r->val[i].vg_extent_count)); + rb_hash_aset (rv, rb_str_new2 ("vg_free_count"), ULL2NUM (r->val[i].vg_free_count)); + rb_hash_aset (rv, rb_str_new2 ("max_lv"), ULL2NUM (r->val[i].max_lv)); + rb_hash_aset (rv, rb_str_new2 ("max_pv"), ULL2NUM (r->val[i].max_pv)); + rb_hash_aset (rv, rb_str_new2 ("pv_count"), ULL2NUM (r->val[i].pv_count)); + rb_hash_aset (rv, rb_str_new2 ("lv_count"), ULL2NUM (r->val[i].lv_count)); + rb_hash_aset (rv, rb_str_new2 ("snap_count"), ULL2NUM (r->val[i].snap_count)); + rb_hash_aset (rv, rb_str_new2 ("vg_seqno"), ULL2NUM (r->val[i].vg_seqno)); + rb_hash_aset (rv, rb_str_new2 ("vg_tags"), rb_str_new2 (r->val[i].vg_tags)); + rb_hash_aset (rv, rb_str_new2 ("vg_mda_count"), ULL2NUM (r->val[i].vg_mda_count)); + rb_hash_aset (rv, rb_str_new2 ("vg_mda_free"), ULL2NUM (r->val[i].vg_mda_free)); + rb_ary_push (rv, hv); + } + guestfs_free_lvm_vg_list (r); + return rv; +} + +static VALUE ruby_guestfs_lvs_full (VALUE gv) +{ + guestfs_h *g; + Data_Get_Struct (gv, guestfs_h, g); + if (!g) + rb_raise (rb_eArgError, "%s: used handle after closing it", "lvs_full"); + + + struct guestfs_lvm_lv_list *r; + + r = guestfs_lvs_full (g); + if (r == NULL) + rb_raise (e_Error, "%s", guestfs_last_error (g)); + + VALUE rv = rb_ary_new2 (r->len); + int i; + for (i = 0; i < r->len; ++i) { + VALUE hv = rb_hash_new (); + rb_hash_aset (rv, rb_str_new2 ("lv_name"), rb_str_new2 (r->val[i].lv_name)); + rb_hash_aset (rv, rb_str_new2 ("lv_uuid"), rb_str_new (r->val[i].lv_uuid, 32)); + rb_hash_aset (rv, rb_str_new2 ("lv_attr"), rb_str_new2 (r->val[i].lv_attr)); + rb_hash_aset (rv, rb_str_new2 ("lv_major"), ULL2NUM (r->val[i].lv_major)); + rb_hash_aset (rv, rb_str_new2 ("lv_minor"), ULL2NUM (r->val[i].lv_minor)); + rb_hash_aset (rv, rb_str_new2 ("lv_kernel_major"), ULL2NUM (r->val[i].lv_kernel_major)); + rb_hash_aset (rv, rb_str_new2 ("lv_kernel_minor"), ULL2NUM (r->val[i].lv_kernel_minor)); + rb_hash_aset (rv, rb_str_new2 ("lv_size"), ULL2NUM (r->val[i].lv_size)); + rb_hash_aset (rv, rb_str_new2 ("seg_count"), ULL2NUM (r->val[i].seg_count)); + rb_hash_aset (rv, rb_str_new2 ("origin"), rb_str_new2 (r->val[i].origin)); + rb_hash_aset (rv, rb_str_new2 ("snap_percent"), rb_dbl2big (r->val[i].snap_percent)); + rb_hash_aset (rv, rb_str_new2 ("copy_percent"), rb_dbl2big (r->val[i].copy_percent)); + rb_hash_aset (rv, rb_str_new2 ("move_pv"), rb_str_new2 (r->val[i].move_pv)); + rb_hash_aset (rv, rb_str_new2 ("lv_tags"), rb_str_new2 (r->val[i].lv_tags)); + rb_hash_aset (rv, rb_str_new2 ("mirror_log"), rb_str_new2 (r->val[i].mirror_log)); + rb_hash_aset (rv, rb_str_new2 ("modules"), rb_str_new2 (r->val[i].modules)); + rb_ary_push (rv, hv); + } + guestfs_free_lvm_lv_list (r); + return rv; +} + +static VALUE ruby_guestfs_read_lines (VALUE gv, VALUE pathv) +{ + guestfs_h *g; + Data_Get_Struct (gv, guestfs_h, g); + if (!g) + rb_raise (rb_eArgError, "%s: used handle after closing it", "read_lines"); + + Check_Type (pathv, T_STRING); + const char *path = StringValueCStr (pathv); + if (!path) + rb_raise (rb_eTypeError, "expected string for parameter %s of %s", + "path", "read_lines"); + + char **r; + + r = guestfs_read_lines (g, path); + if (r == NULL) + rb_raise (e_Error, "%s", guestfs_last_error (g)); + + int i, len = 0; + for (i = 0; r[i] != NULL; ++i) len++; + VALUE rv = rb_ary_new2 (len); + for (i = 0; r[i] != NULL; ++i) { + rb_ary_push (rv, rb_str_new2 (r[i])); + free (r[i]); + } + free (r); + return rv; +} + +static VALUE ruby_guestfs_aug_init (VALUE gv, VALUE rootv, VALUE flagsv) +{ + guestfs_h *g; + Data_Get_Struct (gv, guestfs_h, g); + if (!g) + rb_raise (rb_eArgError, "%s: used handle after closing it", "aug_init"); + + Check_Type (rootv, T_STRING); + const char *root = StringValueCStr (rootv); + if (!root) + rb_raise (rb_eTypeError, "expected string for parameter %s of %s", + "root", "aug_init"); + int flags = NUM2INT (flagsv); + + int r; + + r = guestfs_aug_init (g, root, flags); + if (r == -1) + rb_raise (e_Error, "%s", guestfs_last_error (g)); + + return Qnil; +} + +static VALUE ruby_guestfs_aug_close (VALUE gv) +{ + guestfs_h *g; + Data_Get_Struct (gv, guestfs_h, g); + if (!g) + rb_raise (rb_eArgError, "%s: used handle after closing it", "aug_close"); + + + int r; + + r = guestfs_aug_close (g); + if (r == -1) + rb_raise (e_Error, "%s", guestfs_last_error (g)); + + return Qnil; +} + +static VALUE ruby_guestfs_aug_defvar (VALUE gv, VALUE namev, VALUE exprv) +{ + guestfs_h *g; + Data_Get_Struct (gv, guestfs_h, g); + if (!g) + rb_raise (rb_eArgError, "%s: used handle after closing it", "aug_defvar"); + + Check_Type (namev, T_STRING); + const char *name = StringValueCStr (namev); + if (!name) + rb_raise (rb_eTypeError, "expected string for parameter %s of %s", + "name", "aug_defvar"); + const char *expr = !NIL_P (exprv) ? StringValueCStr (exprv) : NULL; + + int r; + + r = guestfs_aug_defvar (g, name, expr); + if (r == -1) + rb_raise (e_Error, "%s", guestfs_last_error (g)); + + return INT2NUM (r); +} + +static VALUE ruby_guestfs_aug_defnode (VALUE gv, VALUE namev, VALUE exprv, VALUE valv) +{ + guestfs_h *g; + Data_Get_Struct (gv, guestfs_h, g); + if (!g) + rb_raise (rb_eArgError, "%s: used handle after closing it", "aug_defnode"); + + Check_Type (namev, T_STRING); + const char *name = StringValueCStr (namev); + if (!name) + rb_raise (rb_eTypeError, "expected string for parameter %s of %s", + "name", "aug_defnode"); + Check_Type (exprv, T_STRING); + const char *expr = StringValueCStr (exprv); + if (!expr) + rb_raise (rb_eTypeError, "expected string for parameter %s of %s", + "expr", "aug_defnode"); + Check_Type (valv, T_STRING); + const char *val = StringValueCStr (valv); + if (!val) + rb_raise (rb_eTypeError, "expected string for parameter %s of %s", + "val", "aug_defnode"); + + struct guestfs_int_bool *r; + + r = guestfs_aug_defnode (g, name, expr, val); + if (r == NULL) + rb_raise (e_Error, "%s", guestfs_last_error (g)); + + VALUE rv = rb_ary_new2 (2); + rb_ary_push (rv, INT2NUM (r->i)); + rb_ary_push (rv, INT2NUM (r->b)); + guestfs_free_int_bool (r); + return rv; +} + +static VALUE ruby_guestfs_aug_get (VALUE gv, VALUE pathv) +{ + guestfs_h *g; + Data_Get_Struct (gv, guestfs_h, g); + if (!g) + rb_raise (rb_eArgError, "%s: used handle after closing it", "aug_get"); + + Check_Type (pathv, T_STRING); + const char *path = StringValueCStr (pathv); + if (!path) + rb_raise (rb_eTypeError, "expected string for parameter %s of %s", + "path", "aug_get"); + + char *r; + + r = guestfs_aug_get (g, path); + if (r == NULL) + rb_raise (e_Error, "%s", guestfs_last_error (g)); + + VALUE rv = rb_str_new2 (r); + free (r); + return rv; +} + +static VALUE ruby_guestfs_aug_set (VALUE gv, VALUE pathv, VALUE valv) +{ + guestfs_h *g; + Data_Get_Struct (gv, guestfs_h, g); + if (!g) + rb_raise (rb_eArgError, "%s: used handle after closing it", "aug_set"); + + Check_Type (pathv, T_STRING); + const char *path = StringValueCStr (pathv); + if (!path) + rb_raise (rb_eTypeError, "expected string for parameter %s of %s", + "path", "aug_set"); + Check_Type (valv, T_STRING); + const char *val = StringValueCStr (valv); + if (!val) + rb_raise (rb_eTypeError, "expected string for parameter %s of %s", + "val", "aug_set"); + + int r; + + r = guestfs_aug_set (g, path, val); + if (r == -1) + rb_raise (e_Error, "%s", guestfs_last_error (g)); + + return Qnil; +} + +static VALUE ruby_guestfs_aug_insert (VALUE gv, VALUE pathv, VALUE labelv, VALUE beforev) +{ + guestfs_h *g; + Data_Get_Struct (gv, guestfs_h, g); + if (!g) + rb_raise (rb_eArgError, "%s: used handle after closing it", "aug_insert"); + + Check_Type (pathv, T_STRING); + const char *path = StringValueCStr (pathv); + if (!path) + rb_raise (rb_eTypeError, "expected string for parameter %s of %s", + "path", "aug_insert"); + Check_Type (labelv, T_STRING); + const char *label = StringValueCStr (labelv); + if (!label) + rb_raise (rb_eTypeError, "expected string for parameter %s of %s", + "label", "aug_insert"); + int before = RTEST (beforev); + + int r; + + r = guestfs_aug_insert (g, path, label, before); + if (r == -1) + rb_raise (e_Error, "%s", guestfs_last_error (g)); + + return Qnil; +} + +static VALUE ruby_guestfs_aug_rm (VALUE gv, VALUE pathv) +{ + guestfs_h *g; + Data_Get_Struct (gv, guestfs_h, g); + if (!g) + rb_raise (rb_eArgError, "%s: used handle after closing it", "aug_rm"); + + Check_Type (pathv, T_STRING); + const char *path = StringValueCStr (pathv); + if (!path) + rb_raise (rb_eTypeError, "expected string for parameter %s of %s", + "path", "aug_rm"); + + int r; + + r = guestfs_aug_rm (g, path); + if (r == -1) + rb_raise (e_Error, "%s", guestfs_last_error (g)); + + return INT2NUM (r); +} + +static VALUE ruby_guestfs_aug_mv (VALUE gv, VALUE srcv, VALUE destv) +{ + guestfs_h *g; + Data_Get_Struct (gv, guestfs_h, g); + if (!g) + rb_raise (rb_eArgError, "%s: used handle after closing it", "aug_mv"); + + Check_Type (srcv, T_STRING); + const char *src = StringValueCStr (srcv); + if (!src) + rb_raise (rb_eTypeError, "expected string for parameter %s of %s", + "src", "aug_mv"); + Check_Type (destv, T_STRING); + const char *dest = StringValueCStr (destv); + if (!dest) + rb_raise (rb_eTypeError, "expected string for parameter %s of %s", + "dest", "aug_mv"); + + int r; + + r = guestfs_aug_mv (g, src, dest); + if (r == -1) + rb_raise (e_Error, "%s", guestfs_last_error (g)); + + return Qnil; +} + +static VALUE ruby_guestfs_aug_match (VALUE gv, VALUE pathv) +{ + guestfs_h *g; + Data_Get_Struct (gv, guestfs_h, g); + if (!g) + rb_raise (rb_eArgError, "%s: used handle after closing it", "aug_match"); + + Check_Type (pathv, T_STRING); + const char *path = StringValueCStr (pathv); + if (!path) + rb_raise (rb_eTypeError, "expected string for parameter %s of %s", + "path", "aug_match"); + + char **r; + + r = guestfs_aug_match (g, path); + if (r == NULL) + rb_raise (e_Error, "%s", guestfs_last_error (g)); + + int i, len = 0; + for (i = 0; r[i] != NULL; ++i) len++; + VALUE rv = rb_ary_new2 (len); + for (i = 0; r[i] != NULL; ++i) { + rb_ary_push (rv, rb_str_new2 (r[i])); + free (r[i]); + } + free (r); + return rv; +} + +static VALUE ruby_guestfs_aug_save (VALUE gv) +{ + guestfs_h *g; + Data_Get_Struct (gv, guestfs_h, g); + if (!g) + rb_raise (rb_eArgError, "%s: used handle after closing it", "aug_save"); + + + int r; + + r = guestfs_aug_save (g); + if (r == -1) + rb_raise (e_Error, "%s", guestfs_last_error (g)); + + return Qnil; +} + +static VALUE ruby_guestfs_aug_load (VALUE gv) +{ + guestfs_h *g; + Data_Get_Struct (gv, guestfs_h, g); + if (!g) + rb_raise (rb_eArgError, "%s: used handle after closing it", "aug_load"); + + + int r; + + r = guestfs_aug_load (g); + if (r == -1) + rb_raise (e_Error, "%s", guestfs_last_error (g)); + + return Qnil; +} + +static VALUE ruby_guestfs_aug_ls (VALUE gv, VALUE pathv) +{ + guestfs_h *g; + Data_Get_Struct (gv, guestfs_h, g); + if (!g) + rb_raise (rb_eArgError, "%s: used handle after closing it", "aug_ls"); + + Check_Type (pathv, T_STRING); + const char *path = StringValueCStr (pathv); + if (!path) + rb_raise (rb_eTypeError, "expected string for parameter %s of %s", + "path", "aug_ls"); + + char **r; + + r = guestfs_aug_ls (g, path); + if (r == NULL) + rb_raise (e_Error, "%s", guestfs_last_error (g)); + + int i, len = 0; + for (i = 0; r[i] != NULL; ++i) len++; + VALUE rv = rb_ary_new2 (len); + for (i = 0; r[i] != NULL; ++i) { + rb_ary_push (rv, rb_str_new2 (r[i])); + free (r[i]); + } + free (r); + return rv; +} + +static VALUE ruby_guestfs_rm (VALUE gv, VALUE pathv) +{ + guestfs_h *g; + Data_Get_Struct (gv, guestfs_h, g); + if (!g) + rb_raise (rb_eArgError, "%s: used handle after closing it", "rm"); + + Check_Type (pathv, T_STRING); + const char *path = StringValueCStr (pathv); + if (!path) + rb_raise (rb_eTypeError, "expected string for parameter %s of %s", + "path", "rm"); + + int r; + + r = guestfs_rm (g, path); + if (r == -1) + rb_raise (e_Error, "%s", guestfs_last_error (g)); + + return Qnil; +} + +static VALUE ruby_guestfs_rmdir (VALUE gv, VALUE pathv) +{ + guestfs_h *g; + Data_Get_Struct (gv, guestfs_h, g); + if (!g) + rb_raise (rb_eArgError, "%s: used handle after closing it", "rmdir"); + + Check_Type (pathv, T_STRING); + const char *path = StringValueCStr (pathv); + if (!path) + rb_raise (rb_eTypeError, "expected string for parameter %s of %s", + "path", "rmdir"); + + int r; + + r = guestfs_rmdir (g, path); + if (r == -1) + rb_raise (e_Error, "%s", guestfs_last_error (g)); + + return Qnil; +} + +static VALUE ruby_guestfs_rm_rf (VALUE gv, VALUE pathv) +{ + guestfs_h *g; + Data_Get_Struct (gv, guestfs_h, g); + if (!g) + rb_raise (rb_eArgError, "%s: used handle after closing it", "rm_rf"); + + Check_Type (pathv, T_STRING); + const char *path = StringValueCStr (pathv); + if (!path) + rb_raise (rb_eTypeError, "expected string for parameter %s of %s", + "path", "rm_rf"); + + int r; + + r = guestfs_rm_rf (g, path); + if (r == -1) + rb_raise (e_Error, "%s", guestfs_last_error (g)); + + return Qnil; +} + +static VALUE ruby_guestfs_mkdir (VALUE gv, VALUE pathv) +{ + guestfs_h *g; + Data_Get_Struct (gv, guestfs_h, g); + if (!g) + rb_raise (rb_eArgError, "%s: used handle after closing it", "mkdir"); + + Check_Type (pathv, T_STRING); + const char *path = StringValueCStr (pathv); + if (!path) + rb_raise (rb_eTypeError, "expected string for parameter %s of %s", + "path", "mkdir"); + + int r; + + r = guestfs_mkdir (g, path); + if (r == -1) + rb_raise (e_Error, "%s", guestfs_last_error (g)); + + return Qnil; +} + +static VALUE ruby_guestfs_mkdir_p (VALUE gv, VALUE pathv) +{ + guestfs_h *g; + Data_Get_Struct (gv, guestfs_h, g); + if (!g) + rb_raise (rb_eArgError, "%s: used handle after closing it", "mkdir_p"); + + Check_Type (pathv, T_STRING); + const char *path = StringValueCStr (pathv); + if (!path) + rb_raise (rb_eTypeError, "expected string for parameter %s of %s", + "path", "mkdir_p"); + + int r; + + r = guestfs_mkdir_p (g, path); + if (r == -1) + rb_raise (e_Error, "%s", guestfs_last_error (g)); + + return Qnil; +} + +static VALUE ruby_guestfs_chmod (VALUE gv, VALUE modev, VALUE pathv) +{ + guestfs_h *g; + Data_Get_Struct (gv, guestfs_h, g); + if (!g) + rb_raise (rb_eArgError, "%s: used handle after closing it", "chmod"); + + int mode = NUM2INT (modev); + Check_Type (pathv, T_STRING); + const char *path = StringValueCStr (pathv); + if (!path) + rb_raise (rb_eTypeError, "expected string for parameter %s of %s", + "path", "chmod"); + + int r; + + r = guestfs_chmod (g, mode, path); + if (r == -1) + rb_raise (e_Error, "%s", guestfs_last_error (g)); + + return Qnil; +} + +static VALUE ruby_guestfs_chown (VALUE gv, VALUE ownerv, VALUE groupv, VALUE pathv) +{ + guestfs_h *g; + Data_Get_Struct (gv, guestfs_h, g); + if (!g) + rb_raise (rb_eArgError, "%s: used handle after closing it", "chown"); + + int owner = NUM2INT (ownerv); + int group = NUM2INT (groupv); + Check_Type (pathv, T_STRING); + const char *path = StringValueCStr (pathv); + if (!path) + rb_raise (rb_eTypeError, "expected string for parameter %s of %s", + "path", "chown"); + + int r; + + r = guestfs_chown (g, owner, group, path); + if (r == -1) + rb_raise (e_Error, "%s", guestfs_last_error (g)); + + return Qnil; +} + +static VALUE ruby_guestfs_exists (VALUE gv, VALUE pathv) +{ + guestfs_h *g; + Data_Get_Struct (gv, guestfs_h, g); + if (!g) + rb_raise (rb_eArgError, "%s: used handle after closing it", "exists"); + + Check_Type (pathv, T_STRING); + const char *path = StringValueCStr (pathv); + if (!path) + rb_raise (rb_eTypeError, "expected string for parameter %s of %s", + "path", "exists"); + + int r; + + r = guestfs_exists (g, path); + if (r == -1) + rb_raise (e_Error, "%s", guestfs_last_error (g)); + + return INT2NUM (r); +} + +static VALUE ruby_guestfs_is_file (VALUE gv, VALUE pathv) +{ + guestfs_h *g; + Data_Get_Struct (gv, guestfs_h, g); + if (!g) + rb_raise (rb_eArgError, "%s: used handle after closing it", "is_file"); + + Check_Type (pathv, T_STRING); + const char *path = StringValueCStr (pathv); + if (!path) + rb_raise (rb_eTypeError, "expected string for parameter %s of %s", + "path", "is_file"); + + int r; + + r = guestfs_is_file (g, path); + if (r == -1) + rb_raise (e_Error, "%s", guestfs_last_error (g)); + + return INT2NUM (r); +} + +static VALUE ruby_guestfs_is_dir (VALUE gv, VALUE pathv) +{ + guestfs_h *g; + Data_Get_Struct (gv, guestfs_h, g); + if (!g) + rb_raise (rb_eArgError, "%s: used handle after closing it", "is_dir"); + + Check_Type (pathv, T_STRING); + const char *path = StringValueCStr (pathv); + if (!path) + rb_raise (rb_eTypeError, "expected string for parameter %s of %s", + "path", "is_dir"); + + int r; + + r = guestfs_is_dir (g, path); + if (r == -1) + rb_raise (e_Error, "%s", guestfs_last_error (g)); + + return INT2NUM (r); +} + +static VALUE ruby_guestfs_pvcreate (VALUE gv, VALUE devicev) +{ + guestfs_h *g; + Data_Get_Struct (gv, guestfs_h, g); + if (!g) + rb_raise (rb_eArgError, "%s: used handle after closing it", "pvcreate"); + + Check_Type (devicev, T_STRING); + const char *device = StringValueCStr (devicev); + if (!device) + rb_raise (rb_eTypeError, "expected string for parameter %s of %s", + "device", "pvcreate"); + + int r; + + r = guestfs_pvcreate (g, device); + if (r == -1) + rb_raise (e_Error, "%s", guestfs_last_error (g)); + + return Qnil; +} + +static VALUE ruby_guestfs_vgcreate (VALUE gv, VALUE volgroupv, VALUE physvolsv) +{ + guestfs_h *g; + Data_Get_Struct (gv, guestfs_h, g); + if (!g) + rb_raise (rb_eArgError, "%s: used handle after closing it", "vgcreate"); + + Check_Type (volgroupv, T_STRING); + const char *volgroup = StringValueCStr (volgroupv); + if (!volgroup) + rb_raise (rb_eTypeError, "expected string for parameter %s of %s", + "volgroup", "vgcreate"); + char **physvols; + Check_Type (physvolsv, T_ARRAY); + { + int i, len; + len = RARRAY_LEN (physvolsv); + physvols = guestfs_safe_malloc (g, sizeof (char *) * (len+1)); + for (i = 0; i < len; ++i) { + VALUE v = rb_ary_entry (physvolsv, i); + physvols[i] = StringValueCStr (v); + } + physvols[len] = NULL; + } + + int r; + + r = guestfs_vgcreate (g, volgroup, physvols); + free (physvols); + if (r == -1) + rb_raise (e_Error, "%s", guestfs_last_error (g)); + + return Qnil; +} + +static VALUE ruby_guestfs_lvcreate (VALUE gv, VALUE logvolv, VALUE volgroupv, VALUE mbytesv) +{ + guestfs_h *g; + Data_Get_Struct (gv, guestfs_h, g); + if (!g) + rb_raise (rb_eArgError, "%s: used handle after closing it", "lvcreate"); + + Check_Type (logvolv, T_STRING); + const char *logvol = StringValueCStr (logvolv); + if (!logvol) + rb_raise (rb_eTypeError, "expected string for parameter %s of %s", + "logvol", "lvcreate"); + Check_Type (volgroupv, T_STRING); + const char *volgroup = StringValueCStr (volgroupv); + if (!volgroup) + rb_raise (rb_eTypeError, "expected string for parameter %s of %s", + "volgroup", "lvcreate"); + int mbytes = NUM2INT (mbytesv); + + int r; + + r = guestfs_lvcreate (g, logvol, volgroup, mbytes); + if (r == -1) + rb_raise (e_Error, "%s", guestfs_last_error (g)); + + return Qnil; +} + +static VALUE ruby_guestfs_mkfs (VALUE gv, VALUE fstypev, VALUE devicev) +{ + guestfs_h *g; + Data_Get_Struct (gv, guestfs_h, g); + if (!g) + rb_raise (rb_eArgError, "%s: used handle after closing it", "mkfs"); + + Check_Type (fstypev, T_STRING); + const char *fstype = StringValueCStr (fstypev); + if (!fstype) + rb_raise (rb_eTypeError, "expected string for parameter %s of %s", + "fstype", "mkfs"); + Check_Type (devicev, T_STRING); + const char *device = StringValueCStr (devicev); + if (!device) + rb_raise (rb_eTypeError, "expected string for parameter %s of %s", + "device", "mkfs"); + + int r; + + r = guestfs_mkfs (g, fstype, device); + if (r == -1) + rb_raise (e_Error, "%s", guestfs_last_error (g)); + + return Qnil; +} + +static VALUE ruby_guestfs_sfdisk (VALUE gv, VALUE devicev, VALUE cylsv, VALUE headsv, VALUE sectorsv, VALUE linesv) +{ + guestfs_h *g; + Data_Get_Struct (gv, guestfs_h, g); + if (!g) + rb_raise (rb_eArgError, "%s: used handle after closing it", "sfdisk"); + + Check_Type (devicev, T_STRING); + const char *device = StringValueCStr (devicev); + if (!device) + rb_raise (rb_eTypeError, "expected string for parameter %s of %s", + "device", "sfdisk"); + int cyls = NUM2INT (cylsv); + int heads = NUM2INT (headsv); + int sectors = NUM2INT (sectorsv); + char **lines; + Check_Type (linesv, T_ARRAY); + { + int i, len; + len = RARRAY_LEN (linesv); + lines = guestfs_safe_malloc (g, sizeof (char *) * (len+1)); + for (i = 0; i < len; ++i) { + VALUE v = rb_ary_entry (linesv, i); + lines[i] = StringValueCStr (v); + } + lines[len] = NULL; + } + + int r; + + r = guestfs_sfdisk (g, device, cyls, heads, sectors, lines); + free (lines); + if (r == -1) + rb_raise (e_Error, "%s", guestfs_last_error (g)); + + return Qnil; +} + +static VALUE ruby_guestfs_write_file (VALUE gv, VALUE pathv, VALUE contentv, VALUE sizev) +{ + guestfs_h *g; + Data_Get_Struct (gv, guestfs_h, g); + if (!g) + rb_raise (rb_eArgError, "%s: used handle after closing it", "write_file"); + + Check_Type (pathv, T_STRING); + const char *path = StringValueCStr (pathv); + if (!path) + rb_raise (rb_eTypeError, "expected string for parameter %s of %s", + "path", "write_file"); + Check_Type (contentv, T_STRING); + const char *content = StringValueCStr (contentv); + if (!content) + rb_raise (rb_eTypeError, "expected string for parameter %s of %s", + "content", "write_file"); + int size = NUM2INT (sizev); + + int r; + + r = guestfs_write_file (g, path, content, size); + if (r == -1) + rb_raise (e_Error, "%s", guestfs_last_error (g)); + + return Qnil; +} + +static VALUE ruby_guestfs_umount (VALUE gv, VALUE pathordevicev) +{ + guestfs_h *g; + Data_Get_Struct (gv, guestfs_h, g); + if (!g) + rb_raise (rb_eArgError, "%s: used handle after closing it", "umount"); + + Check_Type (pathordevicev, T_STRING); + const char *pathordevice = StringValueCStr (pathordevicev); + if (!pathordevice) + rb_raise (rb_eTypeError, "expected string for parameter %s of %s", + "pathordevice", "umount"); + + int r; + + r = guestfs_umount (g, pathordevice); + if (r == -1) + rb_raise (e_Error, "%s", guestfs_last_error (g)); + + return Qnil; +} + +static VALUE ruby_guestfs_mounts (VALUE gv) +{ + guestfs_h *g; + Data_Get_Struct (gv, guestfs_h, g); + if (!g) + rb_raise (rb_eArgError, "%s: used handle after closing it", "mounts"); + + + char **r; + + r = guestfs_mounts (g); + if (r == NULL) + rb_raise (e_Error, "%s", guestfs_last_error (g)); + + int i, len = 0; + for (i = 0; r[i] != NULL; ++i) len++; + VALUE rv = rb_ary_new2 (len); + for (i = 0; r[i] != NULL; ++i) { + rb_ary_push (rv, rb_str_new2 (r[i])); + free (r[i]); + } + free (r); + return rv; +} + +static VALUE ruby_guestfs_umount_all (VALUE gv) +{ + guestfs_h *g; + Data_Get_Struct (gv, guestfs_h, g); + if (!g) + rb_raise (rb_eArgError, "%s: used handle after closing it", "umount_all"); + + + int r; + + r = guestfs_umount_all (g); + if (r == -1) + rb_raise (e_Error, "%s", guestfs_last_error (g)); + + return Qnil; +} + +static VALUE ruby_guestfs_lvm_remove_all (VALUE gv) +{ + guestfs_h *g; + Data_Get_Struct (gv, guestfs_h, g); + if (!g) + rb_raise (rb_eArgError, "%s: used handle after closing it", "lvm_remove_all"); + + + int r; + + r = guestfs_lvm_remove_all (g); + if (r == -1) + rb_raise (e_Error, "%s", guestfs_last_error (g)); + + return Qnil; +} + +static VALUE ruby_guestfs_file (VALUE gv, VALUE pathv) +{ + guestfs_h *g; + Data_Get_Struct (gv, guestfs_h, g); + if (!g) + rb_raise (rb_eArgError, "%s: used handle after closing it", "file"); + + Check_Type (pathv, T_STRING); + const char *path = StringValueCStr (pathv); + if (!path) + rb_raise (rb_eTypeError, "expected string for parameter %s of %s", + "path", "file"); + + char *r; + + r = guestfs_file (g, path); + if (r == NULL) + rb_raise (e_Error, "%s", guestfs_last_error (g)); + + VALUE rv = rb_str_new2 (r); + free (r); + return rv; +} + +static VALUE ruby_guestfs_command (VALUE gv, VALUE argumentsv) +{ + guestfs_h *g; + Data_Get_Struct (gv, guestfs_h, g); + if (!g) + rb_raise (rb_eArgError, "%s: used handle after closing it", "command"); + + char **arguments; + Check_Type (argumentsv, T_ARRAY); + { + int i, len; + len = RARRAY_LEN (argumentsv); + arguments = guestfs_safe_malloc (g, sizeof (char *) * (len+1)); + for (i = 0; i < len; ++i) { + VALUE v = rb_ary_entry (argumentsv, i); + arguments[i] = StringValueCStr (v); + } + arguments[len] = NULL; + } + + char *r; + + r = guestfs_command (g, arguments); + free (arguments); + if (r == NULL) + rb_raise (e_Error, "%s", guestfs_last_error (g)); + + VALUE rv = rb_str_new2 (r); + free (r); + return rv; +} + +static VALUE ruby_guestfs_command_lines (VALUE gv, VALUE argumentsv) +{ + guestfs_h *g; + Data_Get_Struct (gv, guestfs_h, g); + if (!g) + rb_raise (rb_eArgError, "%s: used handle after closing it", "command_lines"); + + char **arguments; + Check_Type (argumentsv, T_ARRAY); + { + int i, len; + len = RARRAY_LEN (argumentsv); + arguments = guestfs_safe_malloc (g, sizeof (char *) * (len+1)); + for (i = 0; i < len; ++i) { + VALUE v = rb_ary_entry (argumentsv, i); + arguments[i] = StringValueCStr (v); + } + arguments[len] = NULL; + } + + char **r; + + r = guestfs_command_lines (g, arguments); + free (arguments); + if (r == NULL) + rb_raise (e_Error, "%s", guestfs_last_error (g)); + + int i, len = 0; + for (i = 0; r[i] != NULL; ++i) len++; + VALUE rv = rb_ary_new2 (len); + for (i = 0; r[i] != NULL; ++i) { + rb_ary_push (rv, rb_str_new2 (r[i])); + free (r[i]); + } + free (r); + return rv; +} + +static VALUE ruby_guestfs_stat (VALUE gv, VALUE pathv) +{ + guestfs_h *g; + Data_Get_Struct (gv, guestfs_h, g); + if (!g) + rb_raise (rb_eArgError, "%s: used handle after closing it", "stat"); + + Check_Type (pathv, T_STRING); + const char *path = StringValueCStr (pathv); + if (!path) + rb_raise (rb_eTypeError, "expected string for parameter %s of %s", + "path", "stat"); + + struct guestfs_stat *r; + + r = guestfs_stat (g, path); + if (r == NULL) + rb_raise (e_Error, "%s", guestfs_last_error (g)); + + VALUE rv = rb_hash_new (); + rb_hash_aset (rv, rb_str_new2 ("dev"), ULL2NUM (r->dev)); + rb_hash_aset (rv, rb_str_new2 ("ino"), ULL2NUM (r->ino)); + rb_hash_aset (rv, rb_str_new2 ("mode"), ULL2NUM (r->mode)); + rb_hash_aset (rv, rb_str_new2 ("nlink"), ULL2NUM (r->nlink)); + rb_hash_aset (rv, rb_str_new2 ("uid"), ULL2NUM (r->uid)); + rb_hash_aset (rv, rb_str_new2 ("gid"), ULL2NUM (r->gid)); + rb_hash_aset (rv, rb_str_new2 ("rdev"), ULL2NUM (r->rdev)); + rb_hash_aset (rv, rb_str_new2 ("size"), ULL2NUM (r->size)); + rb_hash_aset (rv, rb_str_new2 ("blksize"), ULL2NUM (r->blksize)); + rb_hash_aset (rv, rb_str_new2 ("blocks"), ULL2NUM (r->blocks)); + rb_hash_aset (rv, rb_str_new2 ("atime"), ULL2NUM (r->atime)); + rb_hash_aset (rv, rb_str_new2 ("mtime"), ULL2NUM (r->mtime)); + rb_hash_aset (rv, rb_str_new2 ("ctime"), ULL2NUM (r->ctime)); + free (r); + return rv; +} + +static VALUE ruby_guestfs_lstat (VALUE gv, VALUE pathv) +{ + guestfs_h *g; + Data_Get_Struct (gv, guestfs_h, g); + if (!g) + rb_raise (rb_eArgError, "%s: used handle after closing it", "lstat"); + + Check_Type (pathv, T_STRING); + const char *path = StringValueCStr (pathv); + if (!path) + rb_raise (rb_eTypeError, "expected string for parameter %s of %s", + "path", "lstat"); + + struct guestfs_stat *r; + + r = guestfs_lstat (g, path); + if (r == NULL) + rb_raise (e_Error, "%s", guestfs_last_error (g)); + + VALUE rv = rb_hash_new (); + rb_hash_aset (rv, rb_str_new2 ("dev"), ULL2NUM (r->dev)); + rb_hash_aset (rv, rb_str_new2 ("ino"), ULL2NUM (r->ino)); + rb_hash_aset (rv, rb_str_new2 ("mode"), ULL2NUM (r->mode)); + rb_hash_aset (rv, rb_str_new2 ("nlink"), ULL2NUM (r->nlink)); + rb_hash_aset (rv, rb_str_new2 ("uid"), ULL2NUM (r->uid)); + rb_hash_aset (rv, rb_str_new2 ("gid"), ULL2NUM (r->gid)); + rb_hash_aset (rv, rb_str_new2 ("rdev"), ULL2NUM (r->rdev)); + rb_hash_aset (rv, rb_str_new2 ("size"), ULL2NUM (r->size)); + rb_hash_aset (rv, rb_str_new2 ("blksize"), ULL2NUM (r->blksize)); + rb_hash_aset (rv, rb_str_new2 ("blocks"), ULL2NUM (r->blocks)); + rb_hash_aset (rv, rb_str_new2 ("atime"), ULL2NUM (r->atime)); + rb_hash_aset (rv, rb_str_new2 ("mtime"), ULL2NUM (r->mtime)); + rb_hash_aset (rv, rb_str_new2 ("ctime"), ULL2NUM (r->ctime)); + free (r); + return rv; +} + +static VALUE ruby_guestfs_statvfs (VALUE gv, VALUE pathv) +{ + guestfs_h *g; + Data_Get_Struct (gv, guestfs_h, g); + if (!g) + rb_raise (rb_eArgError, "%s: used handle after closing it", "statvfs"); + + Check_Type (pathv, T_STRING); + const char *path = StringValueCStr (pathv); + if (!path) + rb_raise (rb_eTypeError, "expected string for parameter %s of %s", + "path", "statvfs"); + + struct guestfs_statvfs *r; + + r = guestfs_statvfs (g, path); + if (r == NULL) + rb_raise (e_Error, "%s", guestfs_last_error (g)); + + VALUE rv = rb_hash_new (); + rb_hash_aset (rv, rb_str_new2 ("bsize"), ULL2NUM (r->bsize)); + rb_hash_aset (rv, rb_str_new2 ("frsize"), ULL2NUM (r->frsize)); + rb_hash_aset (rv, rb_str_new2 ("blocks"), ULL2NUM (r->blocks)); + rb_hash_aset (rv, rb_str_new2 ("bfree"), ULL2NUM (r->bfree)); + rb_hash_aset (rv, rb_str_new2 ("bavail"), ULL2NUM (r->bavail)); + rb_hash_aset (rv, rb_str_new2 ("files"), ULL2NUM (r->files)); + rb_hash_aset (rv, rb_str_new2 ("ffree"), ULL2NUM (r->ffree)); + rb_hash_aset (rv, rb_str_new2 ("favail"), ULL2NUM (r->favail)); + rb_hash_aset (rv, rb_str_new2 ("fsid"), ULL2NUM (r->fsid)); + rb_hash_aset (rv, rb_str_new2 ("flag"), ULL2NUM (r->flag)); + rb_hash_aset (rv, rb_str_new2 ("namemax"), ULL2NUM (r->namemax)); + free (r); + return rv; +} + +static VALUE ruby_guestfs_tune2fs_l (VALUE gv, VALUE devicev) +{ + guestfs_h *g; + Data_Get_Struct (gv, guestfs_h, g); + if (!g) + rb_raise (rb_eArgError, "%s: used handle after closing it", "tune2fs_l"); + + Check_Type (devicev, T_STRING); + const char *device = StringValueCStr (devicev); + if (!device) + rb_raise (rb_eTypeError, "expected string for parameter %s of %s", + "device", "tune2fs_l"); + + char **r; + + r = guestfs_tune2fs_l (g, device); + if (r == NULL) + rb_raise (e_Error, "%s", guestfs_last_error (g)); + + VALUE rv = rb_hash_new (); + int i; + for (i = 0; r[i] != NULL; i+=2) { + rb_hash_aset (rv, rb_str_new2 (r[i]), rb_str_new2 (r[i+1])); + free (r[i]); + free (r[i+1]); + } + free (r); + return rv; +} + +static VALUE ruby_guestfs_blockdev_setro (VALUE gv, VALUE devicev) +{ + guestfs_h *g; + Data_Get_Struct (gv, guestfs_h, g); + if (!g) + rb_raise (rb_eArgError, "%s: used handle after closing it", "blockdev_setro"); + + Check_Type (devicev, T_STRING); + const char *device = StringValueCStr (devicev); + if (!device) + rb_raise (rb_eTypeError, "expected string for parameter %s of %s", + "device", "blockdev_setro"); + + int r; + + r = guestfs_blockdev_setro (g, device); + if (r == -1) + rb_raise (e_Error, "%s", guestfs_last_error (g)); + + return Qnil; +} + +static VALUE ruby_guestfs_blockdev_setrw (VALUE gv, VALUE devicev) +{ + guestfs_h *g; + Data_Get_Struct (gv, guestfs_h, g); + if (!g) + rb_raise (rb_eArgError, "%s: used handle after closing it", "blockdev_setrw"); + + Check_Type (devicev, T_STRING); + const char *device = StringValueCStr (devicev); + if (!device) + rb_raise (rb_eTypeError, "expected string for parameter %s of %s", + "device", "blockdev_setrw"); + + int r; + + r = guestfs_blockdev_setrw (g, device); + if (r == -1) + rb_raise (e_Error, "%s", guestfs_last_error (g)); + + return Qnil; +} + +static VALUE ruby_guestfs_blockdev_getro (VALUE gv, VALUE devicev) +{ + guestfs_h *g; + Data_Get_Struct (gv, guestfs_h, g); + if (!g) + rb_raise (rb_eArgError, "%s: used handle after closing it", "blockdev_getro"); + + Check_Type (devicev, T_STRING); + const char *device = StringValueCStr (devicev); + if (!device) + rb_raise (rb_eTypeError, "expected string for parameter %s of %s", + "device", "blockdev_getro"); + + int r; + + r = guestfs_blockdev_getro (g, device); + if (r == -1) + rb_raise (e_Error, "%s", guestfs_last_error (g)); + + return INT2NUM (r); +} + +static VALUE ruby_guestfs_blockdev_getss (VALUE gv, VALUE devicev) +{ + guestfs_h *g; + Data_Get_Struct (gv, guestfs_h, g); + if (!g) + rb_raise (rb_eArgError, "%s: used handle after closing it", "blockdev_getss"); + + Check_Type (devicev, T_STRING); + const char *device = StringValueCStr (devicev); + if (!device) + rb_raise (rb_eTypeError, "expected string for parameter %s of %s", + "device", "blockdev_getss"); + + int r; + + r = guestfs_blockdev_getss (g, device); + if (r == -1) + rb_raise (e_Error, "%s", guestfs_last_error (g)); + + return INT2NUM (r); +} + +static VALUE ruby_guestfs_blockdev_getbsz (VALUE gv, VALUE devicev) +{ guestfs_h *g; Data_Get_Struct (gv, guestfs_h, g); if (!g) - rb_raise (rb_eArgError, "%s: used handle after closing it", "sync"); + rb_raise (rb_eArgError, "%s: used handle after closing it", "blockdev_getbsz"); + Check_Type (devicev, T_STRING); + const char *device = StringValueCStr (devicev); + if (!device) + rb_raise (rb_eTypeError, "expected string for parameter %s of %s", + "device", "blockdev_getbsz"); int r; - r = guestfs_sync (g); + r = guestfs_blockdev_getbsz (g, device); + if (r == -1) + rb_raise (e_Error, "%s", guestfs_last_error (g)); + + return INT2NUM (r); +} + +static VALUE ruby_guestfs_blockdev_setbsz (VALUE gv, VALUE devicev, VALUE blocksizev) +{ + guestfs_h *g; + Data_Get_Struct (gv, guestfs_h, g); + if (!g) + rb_raise (rb_eArgError, "%s: used handle after closing it", "blockdev_setbsz"); + + Check_Type (devicev, T_STRING); + const char *device = StringValueCStr (devicev); + if (!device) + rb_raise (rb_eTypeError, "expected string for parameter %s of %s", + "device", "blockdev_setbsz"); + int blocksize = NUM2INT (blocksizev); + + int r; + + r = guestfs_blockdev_setbsz (g, device, blocksize); if (r == -1) rb_raise (e_Error, "%s", guestfs_last_error (g)); return Qnil; } -static VALUE ruby_guestfs_touch (VALUE gv, VALUE pathv) +static VALUE ruby_guestfs_blockdev_getsz (VALUE gv, VALUE devicev) { guestfs_h *g; Data_Get_Struct (gv, guestfs_h, g); if (!g) - rb_raise (rb_eArgError, "%s: used handle after closing it", "touch"); + rb_raise (rb_eArgError, "%s: used handle after closing it", "blockdev_getsz"); - const char *path = StringValueCStr (pathv); - if (!path) + Check_Type (devicev, T_STRING); + const char *device = StringValueCStr (devicev); + if (!device) rb_raise (rb_eTypeError, "expected string for parameter %s of %s", - "path", "touch"); + "device", "blockdev_getsz"); + + int64_t r; + + r = guestfs_blockdev_getsz (g, device); + if (r == -1) + rb_raise (e_Error, "%s", guestfs_last_error (g)); + + return ULL2NUM (r); +} + +static VALUE ruby_guestfs_blockdev_getsize64 (VALUE gv, VALUE devicev) +{ + guestfs_h *g; + Data_Get_Struct (gv, guestfs_h, g); + if (!g) + rb_raise (rb_eArgError, "%s: used handle after closing it", "blockdev_getsize64"); + + Check_Type (devicev, T_STRING); + const char *device = StringValueCStr (devicev); + if (!device) + rb_raise (rb_eTypeError, "expected string for parameter %s of %s", + "device", "blockdev_getsize64"); + + int64_t r; + + r = guestfs_blockdev_getsize64 (g, device); + if (r == -1) + rb_raise (e_Error, "%s", guestfs_last_error (g)); + + return ULL2NUM (r); +} + +static VALUE ruby_guestfs_blockdev_flushbufs (VALUE gv, VALUE devicev) +{ + guestfs_h *g; + Data_Get_Struct (gv, guestfs_h, g); + if (!g) + rb_raise (rb_eArgError, "%s: used handle after closing it", "blockdev_flushbufs"); + + Check_Type (devicev, T_STRING); + const char *device = StringValueCStr (devicev); + if (!device) + rb_raise (rb_eTypeError, "expected string for parameter %s of %s", + "device", "blockdev_flushbufs"); int r; - r = guestfs_touch (g, path); + r = guestfs_blockdev_flushbufs (g, device); if (r == -1) rb_raise (e_Error, "%s", guestfs_last_error (g)); return Qnil; } -static VALUE ruby_guestfs_cat (VALUE gv, VALUE pathv) +static VALUE ruby_guestfs_blockdev_rereadpt (VALUE gv, VALUE devicev) { guestfs_h *g; Data_Get_Struct (gv, guestfs_h, g); if (!g) - rb_raise (rb_eArgError, "%s: used handle after closing it", "cat"); + rb_raise (rb_eArgError, "%s: used handle after closing it", "blockdev_rereadpt"); + + Check_Type (devicev, T_STRING); + const char *device = StringValueCStr (devicev); + if (!device) + rb_raise (rb_eTypeError, "expected string for parameter %s of %s", + "device", "blockdev_rereadpt"); + + int r; + + r = guestfs_blockdev_rereadpt (g, device); + if (r == -1) + rb_raise (e_Error, "%s", guestfs_last_error (g)); + + return Qnil; +} + +static VALUE ruby_guestfs_upload (VALUE gv, VALUE filenamev, VALUE remotefilenamev) +{ + guestfs_h *g; + Data_Get_Struct (gv, guestfs_h, g); + if (!g) + rb_raise (rb_eArgError, "%s: used handle after closing it", "upload"); + + Check_Type (filenamev, T_STRING); + const char *filename = StringValueCStr (filenamev); + if (!filename) + rb_raise (rb_eTypeError, "expected string for parameter %s of %s", + "filename", "upload"); + Check_Type (remotefilenamev, T_STRING); + const char *remotefilename = StringValueCStr (remotefilenamev); + if (!remotefilename) + rb_raise (rb_eTypeError, "expected string for parameter %s of %s", + "remotefilename", "upload"); + + int r; + + r = guestfs_upload (g, filename, remotefilename); + if (r == -1) + rb_raise (e_Error, "%s", guestfs_last_error (g)); + + return Qnil; +} + +static VALUE ruby_guestfs_download (VALUE gv, VALUE remotefilenamev, VALUE filenamev) +{ + guestfs_h *g; + Data_Get_Struct (gv, guestfs_h, g); + if (!g) + rb_raise (rb_eArgError, "%s: used handle after closing it", "download"); + + Check_Type (remotefilenamev, T_STRING); + const char *remotefilename = StringValueCStr (remotefilenamev); + if (!remotefilename) + rb_raise (rb_eTypeError, "expected string for parameter %s of %s", + "remotefilename", "download"); + Check_Type (filenamev, T_STRING); + const char *filename = StringValueCStr (filenamev); + if (!filename) + rb_raise (rb_eTypeError, "expected string for parameter %s of %s", + "filename", "download"); + + int r; + + r = guestfs_download (g, remotefilename, filename); + if (r == -1) + rb_raise (e_Error, "%s", guestfs_last_error (g)); + + return Qnil; +} + +static VALUE ruby_guestfs_checksum (VALUE gv, VALUE csumtypev, VALUE pathv) +{ + guestfs_h *g; + Data_Get_Struct (gv, guestfs_h, g); + if (!g) + rb_raise (rb_eArgError, "%s: used handle after closing it", "checksum"); + Check_Type (csumtypev, T_STRING); + const char *csumtype = StringValueCStr (csumtypev); + if (!csumtype) + rb_raise (rb_eTypeError, "expected string for parameter %s of %s", + "csumtype", "checksum"); + Check_Type (pathv, T_STRING); const char *path = StringValueCStr (pathv); if (!path) rb_raise (rb_eTypeError, "expected string for parameter %s of %s", - "path", "cat"); + "path", "checksum"); + + char *r; + + r = guestfs_checksum (g, csumtype, path); + if (r == NULL) + rb_raise (e_Error, "%s", guestfs_last_error (g)); + + VALUE rv = rb_str_new2 (r); + free (r); + return rv; +} + +static VALUE ruby_guestfs_tar_in (VALUE gv, VALUE tarfilev, VALUE directoryv) +{ + guestfs_h *g; + Data_Get_Struct (gv, guestfs_h, g); + if (!g) + rb_raise (rb_eArgError, "%s: used handle after closing it", "tar_in"); + + Check_Type (tarfilev, T_STRING); + const char *tarfile = StringValueCStr (tarfilev); + if (!tarfile) + rb_raise (rb_eTypeError, "expected string for parameter %s of %s", + "tarfile", "tar_in"); + Check_Type (directoryv, T_STRING); + const char *directory = StringValueCStr (directoryv); + if (!directory) + rb_raise (rb_eTypeError, "expected string for parameter %s of %s", + "directory", "tar_in"); + + int r; + + r = guestfs_tar_in (g, tarfile, directory); + if (r == -1) + rb_raise (e_Error, "%s", guestfs_last_error (g)); + + return Qnil; +} + +static VALUE ruby_guestfs_tar_out (VALUE gv, VALUE directoryv, VALUE tarfilev) +{ + guestfs_h *g; + Data_Get_Struct (gv, guestfs_h, g); + if (!g) + rb_raise (rb_eArgError, "%s: used handle after closing it", "tar_out"); + + Check_Type (directoryv, T_STRING); + const char *directory = StringValueCStr (directoryv); + if (!directory) + rb_raise (rb_eTypeError, "expected string for parameter %s of %s", + "directory", "tar_out"); + Check_Type (tarfilev, T_STRING); + const char *tarfile = StringValueCStr (tarfilev); + if (!tarfile) + rb_raise (rb_eTypeError, "expected string for parameter %s of %s", + "tarfile", "tar_out"); + + int r; + + r = guestfs_tar_out (g, directory, tarfile); + if (r == -1) + rb_raise (e_Error, "%s", guestfs_last_error (g)); + + return Qnil; +} + +static VALUE ruby_guestfs_tgz_in (VALUE gv, VALUE tarballv, VALUE directoryv) +{ + guestfs_h *g; + Data_Get_Struct (gv, guestfs_h, g); + if (!g) + rb_raise (rb_eArgError, "%s: used handle after closing it", "tgz_in"); + + Check_Type (tarballv, T_STRING); + const char *tarball = StringValueCStr (tarballv); + if (!tarball) + rb_raise (rb_eTypeError, "expected string for parameter %s of %s", + "tarball", "tgz_in"); + Check_Type (directoryv, T_STRING); + const char *directory = StringValueCStr (directoryv); + if (!directory) + rb_raise (rb_eTypeError, "expected string for parameter %s of %s", + "directory", "tgz_in"); + + int r; + + r = guestfs_tgz_in (g, tarball, directory); + if (r == -1) + rb_raise (e_Error, "%s", guestfs_last_error (g)); + + return Qnil; +} + +static VALUE ruby_guestfs_tgz_out (VALUE gv, VALUE directoryv, VALUE tarballv) +{ + guestfs_h *g; + Data_Get_Struct (gv, guestfs_h, g); + if (!g) + rb_raise (rb_eArgError, "%s: used handle after closing it", "tgz_out"); + + Check_Type (directoryv, T_STRING); + const char *directory = StringValueCStr (directoryv); + if (!directory) + rb_raise (rb_eTypeError, "expected string for parameter %s of %s", + "directory", "tgz_out"); + Check_Type (tarballv, T_STRING); + const char *tarball = StringValueCStr (tarballv); + if (!tarball) + rb_raise (rb_eTypeError, "expected string for parameter %s of %s", + "tarball", "tgz_out"); + + int r; + + r = guestfs_tgz_out (g, directory, tarball); + if (r == -1) + rb_raise (e_Error, "%s", guestfs_last_error (g)); + + return Qnil; +} + +static VALUE ruby_guestfs_mount_ro (VALUE gv, VALUE devicev, VALUE mountpointv) +{ + guestfs_h *g; + Data_Get_Struct (gv, guestfs_h, g); + if (!g) + rb_raise (rb_eArgError, "%s: used handle after closing it", "mount_ro"); + + Check_Type (devicev, T_STRING); + const char *device = StringValueCStr (devicev); + if (!device) + rb_raise (rb_eTypeError, "expected string for parameter %s of %s", + "device", "mount_ro"); + Check_Type (mountpointv, T_STRING); + const char *mountpoint = StringValueCStr (mountpointv); + if (!mountpoint) + rb_raise (rb_eTypeError, "expected string for parameter %s of %s", + "mountpoint", "mount_ro"); + + int r; + + r = guestfs_mount_ro (g, device, mountpoint); + if (r == -1) + rb_raise (e_Error, "%s", guestfs_last_error (g)); + + return Qnil; +} + +static VALUE ruby_guestfs_mount_options (VALUE gv, VALUE optionsv, VALUE devicev, VALUE mountpointv) +{ + guestfs_h *g; + Data_Get_Struct (gv, guestfs_h, g); + if (!g) + rb_raise (rb_eArgError, "%s: used handle after closing it", "mount_options"); + + Check_Type (optionsv, T_STRING); + const char *options = StringValueCStr (optionsv); + if (!options) + rb_raise (rb_eTypeError, "expected string for parameter %s of %s", + "options", "mount_options"); + Check_Type (devicev, T_STRING); + const char *device = StringValueCStr (devicev); + if (!device) + rb_raise (rb_eTypeError, "expected string for parameter %s of %s", + "device", "mount_options"); + Check_Type (mountpointv, T_STRING); + const char *mountpoint = StringValueCStr (mountpointv); + if (!mountpoint) + rb_raise (rb_eTypeError, "expected string for parameter %s of %s", + "mountpoint", "mount_options"); - char *r; + int r; - r = guestfs_cat (g, path); - if (r == NULL) + r = guestfs_mount_options (g, options, device, mountpoint); + if (r == -1) rb_raise (e_Error, "%s", guestfs_last_error (g)); - VALUE rv = rb_str_new2 (r); - free (r); - return rv; + return Qnil; } -static VALUE ruby_guestfs_ll (VALUE gv, VALUE directoryv) +static VALUE ruby_guestfs_mount_vfs (VALUE gv, VALUE optionsv, VALUE vfstypev, VALUE devicev, VALUE mountpointv) { guestfs_h *g; Data_Get_Struct (gv, guestfs_h, g); if (!g) - rb_raise (rb_eArgError, "%s: used handle after closing it", "ll"); + rb_raise (rb_eArgError, "%s: used handle after closing it", "mount_vfs"); - const char *directory = StringValueCStr (directoryv); - if (!directory) + Check_Type (optionsv, T_STRING); + const char *options = StringValueCStr (optionsv); + if (!options) rb_raise (rb_eTypeError, "expected string for parameter %s of %s", - "directory", "ll"); + "options", "mount_vfs"); + Check_Type (vfstypev, T_STRING); + const char *vfstype = StringValueCStr (vfstypev); + if (!vfstype) + rb_raise (rb_eTypeError, "expected string for parameter %s of %s", + "vfstype", "mount_vfs"); + Check_Type (devicev, T_STRING); + const char *device = StringValueCStr (devicev); + if (!device) + rb_raise (rb_eTypeError, "expected string for parameter %s of %s", + "device", "mount_vfs"); + Check_Type (mountpointv, T_STRING); + const char *mountpoint = StringValueCStr (mountpointv); + if (!mountpoint) + rb_raise (rb_eTypeError, "expected string for parameter %s of %s", + "mountpoint", "mount_vfs"); - char *r; + int r; - r = guestfs_ll (g, directory); - if (r == NULL) + r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint); + if (r == -1) rb_raise (e_Error, "%s", guestfs_last_error (g)); - VALUE rv = rb_str_new2 (r); - free (r); - return rv; + return Qnil; } -static VALUE ruby_guestfs_ls (VALUE gv, VALUE directoryv) +static VALUE ruby_guestfs_debug (VALUE gv, VALUE subcmdv, VALUE extraargsv) { guestfs_h *g; Data_Get_Struct (gv, guestfs_h, g); if (!g) - rb_raise (rb_eArgError, "%s: used handle after closing it", "ls"); + rb_raise (rb_eArgError, "%s: used handle after closing it", "debug"); - const char *directory = StringValueCStr (directoryv); - if (!directory) + Check_Type (subcmdv, T_STRING); + const char *subcmd = StringValueCStr (subcmdv); + if (!subcmd) rb_raise (rb_eTypeError, "expected string for parameter %s of %s", - "directory", "ls"); + "subcmd", "debug"); + char **extraargs; + Check_Type (extraargsv, T_ARRAY); + { + int i, len; + len = RARRAY_LEN (extraargsv); + extraargs = guestfs_safe_malloc (g, sizeof (char *) * (len+1)); + for (i = 0; i < len; ++i) { + VALUE v = rb_ary_entry (extraargsv, i); + extraargs[i] = StringValueCStr (v); + } + extraargs[len] = NULL; + } - char **r; + char *r; - r = guestfs_ls (g, directory); + r = guestfs_debug (g, subcmd, extraargs); + free (extraargs); if (r == NULL) rb_raise (e_Error, "%s", guestfs_last_error (g)); - int i, len = 0; - for (i = 0; r[i] != NULL; ++i) len++; - VALUE rv = rb_ary_new2 (len); - for (i = 0; r[i] != NULL; ++i) { - rb_ary_push (rv, rb_str_new2 (r[i])); - free (r[i]); - } + VALUE rv = rb_str_new2 (r); free (r); return rv; } -static VALUE ruby_guestfs_list_devices (VALUE gv) +static VALUE ruby_guestfs_lvremove (VALUE gv, VALUE devicev) { guestfs_h *g; Data_Get_Struct (gv, guestfs_h, g); if (!g) - rb_raise (rb_eArgError, "%s: used handle after closing it", "list_devices"); + rb_raise (rb_eArgError, "%s: used handle after closing it", "lvremove"); + Check_Type (devicev, T_STRING); + const char *device = StringValueCStr (devicev); + if (!device) + rb_raise (rb_eTypeError, "expected string for parameter %s of %s", + "device", "lvremove"); - char **r; + int r; - r = guestfs_list_devices (g); - if (r == NULL) + r = guestfs_lvremove (g, device); + if (r == -1) rb_raise (e_Error, "%s", guestfs_last_error (g)); - int i, len = 0; - for (i = 0; r[i] != NULL; ++i) len++; - VALUE rv = rb_ary_new2 (len); - for (i = 0; r[i] != NULL; ++i) { - rb_ary_push (rv, rb_str_new2 (r[i])); - free (r[i]); - } - free (r); - return rv; + return Qnil; } -static VALUE ruby_guestfs_list_partitions (VALUE gv) +static VALUE ruby_guestfs_vgremove (VALUE gv, VALUE vgnamev) { guestfs_h *g; Data_Get_Struct (gv, guestfs_h, g); if (!g) - rb_raise (rb_eArgError, "%s: used handle after closing it", "list_partitions"); + rb_raise (rb_eArgError, "%s: used handle after closing it", "vgremove"); + Check_Type (vgnamev, T_STRING); + const char *vgname = StringValueCStr (vgnamev); + if (!vgname) + rb_raise (rb_eTypeError, "expected string for parameter %s of %s", + "vgname", "vgremove"); - char **r; + int r; - r = guestfs_list_partitions (g); - if (r == NULL) + r = guestfs_vgremove (g, vgname); + if (r == -1) rb_raise (e_Error, "%s", guestfs_last_error (g)); - int i, len = 0; - for (i = 0; r[i] != NULL; ++i) len++; - VALUE rv = rb_ary_new2 (len); - for (i = 0; r[i] != NULL; ++i) { - rb_ary_push (rv, rb_str_new2 (r[i])); - free (r[i]); - } - free (r); - return rv; + return Qnil; } -static VALUE ruby_guestfs_pvs (VALUE gv) +static VALUE ruby_guestfs_pvremove (VALUE gv, VALUE devicev) { guestfs_h *g; Data_Get_Struct (gv, guestfs_h, g); if (!g) - rb_raise (rb_eArgError, "%s: used handle after closing it", "pvs"); + rb_raise (rb_eArgError, "%s: used handle after closing it", "pvremove"); + Check_Type (devicev, T_STRING); + const char *device = StringValueCStr (devicev); + if (!device) + rb_raise (rb_eTypeError, "expected string for parameter %s of %s", + "device", "pvremove"); - char **r; + int r; - r = guestfs_pvs (g); - if (r == NULL) + r = guestfs_pvremove (g, device); + if (r == -1) rb_raise (e_Error, "%s", guestfs_last_error (g)); - int i, len = 0; - for (i = 0; r[i] != NULL; ++i) len++; - VALUE rv = rb_ary_new2 (len); - for (i = 0; r[i] != NULL; ++i) { - rb_ary_push (rv, rb_str_new2 (r[i])); - free (r[i]); - } - free (r); - return rv; + return Qnil; } -static VALUE ruby_guestfs_vgs (VALUE gv) +static VALUE ruby_guestfs_set_e2label (VALUE gv, VALUE devicev, VALUE labelv) { guestfs_h *g; Data_Get_Struct (gv, guestfs_h, g); if (!g) - rb_raise (rb_eArgError, "%s: used handle after closing it", "vgs"); + rb_raise (rb_eArgError, "%s: used handle after closing it", "set_e2label"); + Check_Type (devicev, T_STRING); + const char *device = StringValueCStr (devicev); + if (!device) + rb_raise (rb_eTypeError, "expected string for parameter %s of %s", + "device", "set_e2label"); + Check_Type (labelv, T_STRING); + const char *label = StringValueCStr (labelv); + if (!label) + rb_raise (rb_eTypeError, "expected string for parameter %s of %s", + "label", "set_e2label"); - char **r; + int r; - r = guestfs_vgs (g); - if (r == NULL) + r = guestfs_set_e2label (g, device, label); + if (r == -1) rb_raise (e_Error, "%s", guestfs_last_error (g)); - int i, len = 0; - for (i = 0; r[i] != NULL; ++i) len++; - VALUE rv = rb_ary_new2 (len); - for (i = 0; r[i] != NULL; ++i) { - rb_ary_push (rv, rb_str_new2 (r[i])); - free (r[i]); - } - free (r); - return rv; + return Qnil; } -static VALUE ruby_guestfs_lvs (VALUE gv) +static VALUE ruby_guestfs_get_e2label (VALUE gv, VALUE devicev) { guestfs_h *g; Data_Get_Struct (gv, guestfs_h, g); if (!g) - rb_raise (rb_eArgError, "%s: used handle after closing it", "lvs"); + rb_raise (rb_eArgError, "%s: used handle after closing it", "get_e2label"); + Check_Type (devicev, T_STRING); + const char *device = StringValueCStr (devicev); + if (!device) + rb_raise (rb_eTypeError, "expected string for parameter %s of %s", + "device", "get_e2label"); - char **r; + char *r; - r = guestfs_lvs (g); + r = guestfs_get_e2label (g, device); if (r == NULL) rb_raise (e_Error, "%s", guestfs_last_error (g)); - int i, len = 0; - for (i = 0; r[i] != NULL; ++i) len++; - VALUE rv = rb_ary_new2 (len); - for (i = 0; r[i] != NULL; ++i) { - rb_ary_push (rv, rb_str_new2 (r[i])); - free (r[i]); - } + VALUE rv = rb_str_new2 (r); free (r); return rv; } -static VALUE ruby_guestfs_pvs_full (VALUE gv) +static VALUE ruby_guestfs_set_e2uuid (VALUE gv, VALUE devicev, VALUE uuidv) { guestfs_h *g; Data_Get_Struct (gv, guestfs_h, g); if (!g) - rb_raise (rb_eArgError, "%s: used handle after closing it", "pvs_full"); + rb_raise (rb_eArgError, "%s: used handle after closing it", "set_e2uuid"); + Check_Type (devicev, T_STRING); + const char *device = StringValueCStr (devicev); + if (!device) + rb_raise (rb_eTypeError, "expected string for parameter %s of %s", + "device", "set_e2uuid"); + Check_Type (uuidv, T_STRING); + const char *uuid = StringValueCStr (uuidv); + if (!uuid) + rb_raise (rb_eTypeError, "expected string for parameter %s of %s", + "uuid", "set_e2uuid"); - struct guestfs_lvm_pv_list *r; + int r; - r = guestfs_pvs_full (g); - if (r == NULL) + r = guestfs_set_e2uuid (g, device, uuid); + if (r == -1) rb_raise (e_Error, "%s", guestfs_last_error (g)); - VALUE rv = rb_ary_new2 (r->len); - int i; - for (i = 0; i < r->len; ++i) { - VALUE hv = rb_hash_new (); - rb_hash_aset (rv, rb_str_new2 ("pv_name"), rb_str_new2 (r->val[i].pv_name)); - rb_hash_aset (rv, rb_str_new2 ("pv_uuid"), rb_str_new (r->val[i].pv_uuid, 32)); - rb_hash_aset (rv, rb_str_new2 ("pv_fmt"), rb_str_new2 (r->val[i].pv_fmt)); - rb_hash_aset (rv, rb_str_new2 ("pv_size"), ULL2NUM (r->val[i].pv_size)); - rb_hash_aset (rv, rb_str_new2 ("dev_size"), ULL2NUM (r->val[i].dev_size)); - rb_hash_aset (rv, rb_str_new2 ("pv_free"), ULL2NUM (r->val[i].pv_free)); - rb_hash_aset (rv, rb_str_new2 ("pv_used"), ULL2NUM (r->val[i].pv_used)); - rb_hash_aset (rv, rb_str_new2 ("pv_attr"), rb_str_new2 (r->val[i].pv_attr)); - rb_hash_aset (rv, rb_str_new2 ("pv_pe_count"), ULL2NUM (r->val[i].pv_pe_count)); - rb_hash_aset (rv, rb_str_new2 ("pv_pe_alloc_count"), ULL2NUM (r->val[i].pv_pe_alloc_count)); - rb_hash_aset (rv, rb_str_new2 ("pv_tags"), rb_str_new2 (r->val[i].pv_tags)); - rb_hash_aset (rv, rb_str_new2 ("pe_start"), ULL2NUM (r->val[i].pe_start)); - rb_hash_aset (rv, rb_str_new2 ("pv_mda_count"), ULL2NUM (r->val[i].pv_mda_count)); - rb_hash_aset (rv, rb_str_new2 ("pv_mda_free"), ULL2NUM (r->val[i].pv_mda_free)); - rb_ary_push (rv, hv); - } - guestfs_free_lvm_pv_list (r); - return rv; + return Qnil; } -static VALUE ruby_guestfs_vgs_full (VALUE gv) +static VALUE ruby_guestfs_get_e2uuid (VALUE gv, VALUE devicev) { guestfs_h *g; Data_Get_Struct (gv, guestfs_h, g); if (!g) - rb_raise (rb_eArgError, "%s: used handle after closing it", "vgs_full"); + rb_raise (rb_eArgError, "%s: used handle after closing it", "get_e2uuid"); + Check_Type (devicev, T_STRING); + const char *device = StringValueCStr (devicev); + if (!device) + rb_raise (rb_eTypeError, "expected string for parameter %s of %s", + "device", "get_e2uuid"); - struct guestfs_lvm_vg_list *r; + char *r; - r = guestfs_vgs_full (g); + r = guestfs_get_e2uuid (g, device); if (r == NULL) rb_raise (e_Error, "%s", guestfs_last_error (g)); - VALUE rv = rb_ary_new2 (r->len); - int i; - for (i = 0; i < r->len; ++i) { - VALUE hv = rb_hash_new (); - rb_hash_aset (rv, rb_str_new2 ("vg_name"), rb_str_new2 (r->val[i].vg_name)); - rb_hash_aset (rv, rb_str_new2 ("vg_uuid"), rb_str_new (r->val[i].vg_uuid, 32)); - rb_hash_aset (rv, rb_str_new2 ("vg_fmt"), rb_str_new2 (r->val[i].vg_fmt)); - rb_hash_aset (rv, rb_str_new2 ("vg_attr"), rb_str_new2 (r->val[i].vg_attr)); - rb_hash_aset (rv, rb_str_new2 ("vg_size"), ULL2NUM (r->val[i].vg_size)); - rb_hash_aset (rv, rb_str_new2 ("vg_free"), ULL2NUM (r->val[i].vg_free)); - rb_hash_aset (rv, rb_str_new2 ("vg_sysid"), rb_str_new2 (r->val[i].vg_sysid)); - rb_hash_aset (rv, rb_str_new2 ("vg_extent_size"), ULL2NUM (r->val[i].vg_extent_size)); - rb_hash_aset (rv, rb_str_new2 ("vg_extent_count"), ULL2NUM (r->val[i].vg_extent_count)); - rb_hash_aset (rv, rb_str_new2 ("vg_free_count"), ULL2NUM (r->val[i].vg_free_count)); - rb_hash_aset (rv, rb_str_new2 ("max_lv"), ULL2NUM (r->val[i].max_lv)); - rb_hash_aset (rv, rb_str_new2 ("max_pv"), ULL2NUM (r->val[i].max_pv)); - rb_hash_aset (rv, rb_str_new2 ("pv_count"), ULL2NUM (r->val[i].pv_count)); - rb_hash_aset (rv, rb_str_new2 ("lv_count"), ULL2NUM (r->val[i].lv_count)); - rb_hash_aset (rv, rb_str_new2 ("snap_count"), ULL2NUM (r->val[i].snap_count)); - rb_hash_aset (rv, rb_str_new2 ("vg_seqno"), ULL2NUM (r->val[i].vg_seqno)); - rb_hash_aset (rv, rb_str_new2 ("vg_tags"), rb_str_new2 (r->val[i].vg_tags)); - rb_hash_aset (rv, rb_str_new2 ("vg_mda_count"), ULL2NUM (r->val[i].vg_mda_count)); - rb_hash_aset (rv, rb_str_new2 ("vg_mda_free"), ULL2NUM (r->val[i].vg_mda_free)); - rb_ary_push (rv, hv); - } - guestfs_free_lvm_vg_list (r); + VALUE rv = rb_str_new2 (r); + free (r); return rv; } -static VALUE ruby_guestfs_lvs_full (VALUE gv) +static VALUE ruby_guestfs_fsck (VALUE gv, VALUE fstypev, VALUE devicev) { guestfs_h *g; Data_Get_Struct (gv, guestfs_h, g); if (!g) - rb_raise (rb_eArgError, "%s: used handle after closing it", "lvs_full"); - + rb_raise (rb_eArgError, "%s: used handle after closing it", "fsck"); - struct guestfs_lvm_lv_list *r; - - r = guestfs_lvs_full (g); - if (r == NULL) - rb_raise (e_Error, "%s", guestfs_last_error (g)); - - VALUE rv = rb_ary_new2 (r->len); - int i; - for (i = 0; i < r->len; ++i) { - VALUE hv = rb_hash_new (); - rb_hash_aset (rv, rb_str_new2 ("lv_name"), rb_str_new2 (r->val[i].lv_name)); - rb_hash_aset (rv, rb_str_new2 ("lv_uuid"), rb_str_new (r->val[i].lv_uuid, 32)); - rb_hash_aset (rv, rb_str_new2 ("lv_attr"), rb_str_new2 (r->val[i].lv_attr)); - rb_hash_aset (rv, rb_str_new2 ("lv_major"), ULL2NUM (r->val[i].lv_major)); - rb_hash_aset (rv, rb_str_new2 ("lv_minor"), ULL2NUM (r->val[i].lv_minor)); - rb_hash_aset (rv, rb_str_new2 ("lv_kernel_major"), ULL2NUM (r->val[i].lv_kernel_major)); - rb_hash_aset (rv, rb_str_new2 ("lv_kernel_minor"), ULL2NUM (r->val[i].lv_kernel_minor)); - rb_hash_aset (rv, rb_str_new2 ("lv_size"), ULL2NUM (r->val[i].lv_size)); - rb_hash_aset (rv, rb_str_new2 ("seg_count"), ULL2NUM (r->val[i].seg_count)); - rb_hash_aset (rv, rb_str_new2 ("origin"), rb_str_new2 (r->val[i].origin)); - rb_hash_aset (rv, rb_str_new2 ("snap_percent"), rb_dbl2big (r->val[i].snap_percent)); - rb_hash_aset (rv, rb_str_new2 ("copy_percent"), rb_dbl2big (r->val[i].copy_percent)); - rb_hash_aset (rv, rb_str_new2 ("move_pv"), rb_str_new2 (r->val[i].move_pv)); - rb_hash_aset (rv, rb_str_new2 ("lv_tags"), rb_str_new2 (r->val[i].lv_tags)); - rb_hash_aset (rv, rb_str_new2 ("mirror_log"), rb_str_new2 (r->val[i].mirror_log)); - rb_hash_aset (rv, rb_str_new2 ("modules"), rb_str_new2 (r->val[i].modules)); - rb_ary_push (rv, hv); - } - guestfs_free_lvm_lv_list (r); - return rv; + Check_Type (fstypev, T_STRING); + const char *fstype = StringValueCStr (fstypev); + if (!fstype) + rb_raise (rb_eTypeError, "expected string for parameter %s of %s", + "fstype", "fsck"); + Check_Type (devicev, T_STRING); + const char *device = StringValueCStr (devicev); + if (!device) + rb_raise (rb_eTypeError, "expected string for parameter %s of %s", + "device", "fsck"); + + int r; + + r = guestfs_fsck (g, fstype, device); + if (r == -1) + rb_raise (e_Error, "%s", guestfs_last_error (g)); + + return INT2NUM (r); } -static VALUE ruby_guestfs_read_lines (VALUE gv, VALUE pathv) +static VALUE ruby_guestfs_zero (VALUE gv, VALUE devicev) { guestfs_h *g; Data_Get_Struct (gv, guestfs_h, g); if (!g) - rb_raise (rb_eArgError, "%s: used handle after closing it", "read_lines"); + rb_raise (rb_eArgError, "%s: used handle after closing it", "zero"); - const char *path = StringValueCStr (pathv); - if (!path) + Check_Type (devicev, T_STRING); + const char *device = StringValueCStr (devicev); + if (!device) rb_raise (rb_eTypeError, "expected string for parameter %s of %s", - "path", "read_lines"); + "device", "zero"); - char **r; + int r; - r = guestfs_read_lines (g, path); - if (r == NULL) + r = guestfs_zero (g, device); + if (r == -1) rb_raise (e_Error, "%s", guestfs_last_error (g)); - int i, len = 0; - for (i = 0; r[i] != NULL; ++i) len++; - VALUE rv = rb_ary_new2 (len); - for (i = 0; r[i] != NULL; ++i) { - rb_ary_push (rv, rb_str_new2 (r[i])); - free (r[i]); - } - free (r); - return rv; + return Qnil; } -static VALUE ruby_guestfs_aug_init (VALUE gv, VALUE rootv, VALUE flagsv) +static VALUE ruby_guestfs_grub_install (VALUE gv, VALUE rootv, VALUE devicev) { guestfs_h *g; Data_Get_Struct (gv, guestfs_h, g); if (!g) - rb_raise (rb_eArgError, "%s: used handle after closing it", "aug_init"); + rb_raise (rb_eArgError, "%s: used handle after closing it", "grub_install"); + Check_Type (rootv, T_STRING); const char *root = StringValueCStr (rootv); if (!root) rb_raise (rb_eTypeError, "expected string for parameter %s of %s", - "root", "aug_init"); - int flags = NUM2INT (flagsv); + "root", "grub_install"); + Check_Type (devicev, T_STRING); + const char *device = StringValueCStr (devicev); + if (!device) + rb_raise (rb_eTypeError, "expected string for parameter %s of %s", + "device", "grub_install"); int r; - r = guestfs_aug_init (g, root, flags); + r = guestfs_grub_install (g, root, device); if (r == -1) rb_raise (e_Error, "%s", guestfs_last_error (g)); return Qnil; } -static VALUE ruby_guestfs_aug_close (VALUE gv) +static VALUE ruby_guestfs_cp (VALUE gv, VALUE srcv, VALUE destv) { guestfs_h *g; Data_Get_Struct (gv, guestfs_h, g); if (!g) - rb_raise (rb_eArgError, "%s: used handle after closing it", "aug_close"); + rb_raise (rb_eArgError, "%s: used handle after closing it", "cp"); + Check_Type (srcv, T_STRING); + const char *src = StringValueCStr (srcv); + if (!src) + rb_raise (rb_eTypeError, "expected string for parameter %s of %s", + "src", "cp"); + Check_Type (destv, T_STRING); + const char *dest = StringValueCStr (destv); + if (!dest) + rb_raise (rb_eTypeError, "expected string for parameter %s of %s", + "dest", "cp"); int r; - r = guestfs_aug_close (g); + r = guestfs_cp (g, src, dest); if (r == -1) rb_raise (e_Error, "%s", guestfs_last_error (g)); return Qnil; } -static VALUE ruby_guestfs_aug_defvar (VALUE gv, VALUE namev, VALUE exprv) +static VALUE ruby_guestfs_cp_a (VALUE gv, VALUE srcv, VALUE destv) { guestfs_h *g; Data_Get_Struct (gv, guestfs_h, g); if (!g) - rb_raise (rb_eArgError, "%s: used handle after closing it", "aug_defvar"); + rb_raise (rb_eArgError, "%s: used handle after closing it", "cp_a"); - const char *name = StringValueCStr (namev); - if (!name) + Check_Type (srcv, T_STRING); + const char *src = StringValueCStr (srcv); + if (!src) rb_raise (rb_eTypeError, "expected string for parameter %s of %s", - "name", "aug_defvar"); - const char *expr = StringValueCStr (exprv); + "src", "cp_a"); + Check_Type (destv, T_STRING); + const char *dest = StringValueCStr (destv); + if (!dest) + rb_raise (rb_eTypeError, "expected string for parameter %s of %s", + "dest", "cp_a"); int r; - r = guestfs_aug_defvar (g, name, expr); + r = guestfs_cp_a (g, src, dest); if (r == -1) rb_raise (e_Error, "%s", guestfs_last_error (g)); - return INT2NUM (r); + return Qnil; } -static VALUE ruby_guestfs_aug_defnode (VALUE gv, VALUE namev, VALUE exprv, VALUE valv) +static VALUE ruby_guestfs_mv (VALUE gv, VALUE srcv, VALUE destv) { guestfs_h *g; Data_Get_Struct (gv, guestfs_h, g); if (!g) - rb_raise (rb_eArgError, "%s: used handle after closing it", "aug_defnode"); + rb_raise (rb_eArgError, "%s: used handle after closing it", "mv"); - const char *name = StringValueCStr (namev); - if (!name) - rb_raise (rb_eTypeError, "expected string for parameter %s of %s", - "name", "aug_defnode"); - const char *expr = StringValueCStr (exprv); - if (!expr) + Check_Type (srcv, T_STRING); + const char *src = StringValueCStr (srcv); + if (!src) rb_raise (rb_eTypeError, "expected string for parameter %s of %s", - "expr", "aug_defnode"); - const char *val = StringValueCStr (valv); - if (!val) + "src", "mv"); + Check_Type (destv, T_STRING); + const char *dest = StringValueCStr (destv); + if (!dest) rb_raise (rb_eTypeError, "expected string for parameter %s of %s", - "val", "aug_defnode"); + "dest", "mv"); - struct guestfs_int_bool *r; + int r; - r = guestfs_aug_defnode (g, name, expr, val); - if (r == NULL) + r = guestfs_mv (g, src, dest); + if (r == -1) rb_raise (e_Error, "%s", guestfs_last_error (g)); - VALUE rv = rb_ary_new2 (2); - rb_ary_push (rv, INT2NUM (r->i)); - rb_ary_push (rv, INT2NUM (r->b)); - guestfs_free_int_bool (r); - return rv; + return Qnil; } -static VALUE ruby_guestfs_aug_get (VALUE gv, VALUE pathv) +static VALUE ruby_guestfs_drop_caches (VALUE gv, VALUE whattodropv) { guestfs_h *g; Data_Get_Struct (gv, guestfs_h, g); if (!g) - rb_raise (rb_eArgError, "%s: used handle after closing it", "aug_get"); + rb_raise (rb_eArgError, "%s: used handle after closing it", "drop_caches"); + + int whattodrop = NUM2INT (whattodropv); + + int r; + + r = guestfs_drop_caches (g, whattodrop); + if (r == -1) + rb_raise (e_Error, "%s", guestfs_last_error (g)); + + return Qnil; +} + +static VALUE ruby_guestfs_dmesg (VALUE gv) +{ + guestfs_h *g; + Data_Get_Struct (gv, guestfs_h, g); + if (!g) + rb_raise (rb_eArgError, "%s: used handle after closing it", "dmesg"); - const char *path = StringValueCStr (pathv); - if (!path) - rb_raise (rb_eTypeError, "expected string for parameter %s of %s", - "path", "aug_get"); char *r; - r = guestfs_aug_get (g, path); + r = guestfs_dmesg (g); if (r == NULL) rb_raise (e_Error, "%s", guestfs_last_error (g)); @@ -904,724 +3727,790 @@ static VALUE ruby_guestfs_aug_get (VALUE gv, VALUE pathv) return rv; } -static VALUE ruby_guestfs_aug_set (VALUE gv, VALUE pathv, VALUE valv) +static VALUE ruby_guestfs_ping_daemon (VALUE gv) { guestfs_h *g; Data_Get_Struct (gv, guestfs_h, g); if (!g) - rb_raise (rb_eArgError, "%s: used handle after closing it", "aug_set"); + rb_raise (rb_eArgError, "%s: used handle after closing it", "ping_daemon"); - const char *path = StringValueCStr (pathv); - if (!path) - rb_raise (rb_eTypeError, "expected string for parameter %s of %s", - "path", "aug_set"); - const char *val = StringValueCStr (valv); - if (!val) - rb_raise (rb_eTypeError, "expected string for parameter %s of %s", - "val", "aug_set"); int r; - r = guestfs_aug_set (g, path, val); + r = guestfs_ping_daemon (g); if (r == -1) rb_raise (e_Error, "%s", guestfs_last_error (g)); return Qnil; } -static VALUE ruby_guestfs_aug_insert (VALUE gv, VALUE pathv, VALUE labelv, VALUE beforev) +static VALUE ruby_guestfs_equal (VALUE gv, VALUE file1v, VALUE file2v) { guestfs_h *g; Data_Get_Struct (gv, guestfs_h, g); if (!g) - rb_raise (rb_eArgError, "%s: used handle after closing it", "aug_insert"); + rb_raise (rb_eArgError, "%s: used handle after closing it", "equal"); - const char *path = StringValueCStr (pathv); - if (!path) + Check_Type (file1v, T_STRING); + const char *file1 = StringValueCStr (file1v); + if (!file1) rb_raise (rb_eTypeError, "expected string for parameter %s of %s", - "path", "aug_insert"); - const char *label = StringValueCStr (labelv); - if (!label) + "file1", "equal"); + Check_Type (file2v, T_STRING); + const char *file2 = StringValueCStr (file2v); + if (!file2) rb_raise (rb_eTypeError, "expected string for parameter %s of %s", - "label", "aug_insert"); - int before = NUM2INT (beforev); + "file2", "equal"); int r; - r = guestfs_aug_insert (g, path, label, before); + r = guestfs_equal (g, file1, file2); if (r == -1) rb_raise (e_Error, "%s", guestfs_last_error (g)); - return Qnil; + return INT2NUM (r); } -static VALUE ruby_guestfs_aug_rm (VALUE gv, VALUE pathv) +static VALUE ruby_guestfs_strings (VALUE gv, VALUE pathv) { guestfs_h *g; Data_Get_Struct (gv, guestfs_h, g); if (!g) - rb_raise (rb_eArgError, "%s: used handle after closing it", "aug_rm"); + rb_raise (rb_eArgError, "%s: used handle after closing it", "strings"); + Check_Type (pathv, T_STRING); const char *path = StringValueCStr (pathv); if (!path) rb_raise (rb_eTypeError, "expected string for parameter %s of %s", - "path", "aug_rm"); + "path", "strings"); - int r; + char **r; - r = guestfs_aug_rm (g, path); - if (r == -1) + r = guestfs_strings (g, path); + if (r == NULL) rb_raise (e_Error, "%s", guestfs_last_error (g)); - return INT2NUM (r); + int i, len = 0; + for (i = 0; r[i] != NULL; ++i) len++; + VALUE rv = rb_ary_new2 (len); + for (i = 0; r[i] != NULL; ++i) { + rb_ary_push (rv, rb_str_new2 (r[i])); + free (r[i]); + } + free (r); + return rv; } -static VALUE ruby_guestfs_aug_mv (VALUE gv, VALUE srcv, VALUE destv) +static VALUE ruby_guestfs_strings_e (VALUE gv, VALUE encodingv, VALUE pathv) { guestfs_h *g; Data_Get_Struct (gv, guestfs_h, g); if (!g) - rb_raise (rb_eArgError, "%s: used handle after closing it", "aug_mv"); + rb_raise (rb_eArgError, "%s: used handle after closing it", "strings_e"); - const char *src = StringValueCStr (srcv); - if (!src) + Check_Type (encodingv, T_STRING); + const char *encoding = StringValueCStr (encodingv); + if (!encoding) rb_raise (rb_eTypeError, "expected string for parameter %s of %s", - "src", "aug_mv"); - const char *dest = StringValueCStr (destv); - if (!dest) + "encoding", "strings_e"); + Check_Type (pathv, T_STRING); + const char *path = StringValueCStr (pathv); + if (!path) rb_raise (rb_eTypeError, "expected string for parameter %s of %s", - "dest", "aug_mv"); + "path", "strings_e"); - int r; + char **r; - r = guestfs_aug_mv (g, src, dest); - if (r == -1) + r = guestfs_strings_e (g, encoding, path); + if (r == NULL) rb_raise (e_Error, "%s", guestfs_last_error (g)); - return Qnil; + int i, len = 0; + for (i = 0; r[i] != NULL; ++i) len++; + VALUE rv = rb_ary_new2 (len); + for (i = 0; r[i] != NULL; ++i) { + rb_ary_push (rv, rb_str_new2 (r[i])); + free (r[i]); + } + free (r); + return rv; } -static VALUE ruby_guestfs_aug_match (VALUE gv, VALUE pathv) +static VALUE ruby_guestfs_hexdump (VALUE gv, VALUE pathv) { guestfs_h *g; Data_Get_Struct (gv, guestfs_h, g); if (!g) - rb_raise (rb_eArgError, "%s: used handle after closing it", "aug_match"); + rb_raise (rb_eArgError, "%s: used handle after closing it", "hexdump"); + Check_Type (pathv, T_STRING); const char *path = StringValueCStr (pathv); if (!path) rb_raise (rb_eTypeError, "expected string for parameter %s of %s", - "path", "aug_match"); + "path", "hexdump"); - char **r; + char *r; - r = guestfs_aug_match (g, path); + r = guestfs_hexdump (g, path); if (r == NULL) rb_raise (e_Error, "%s", guestfs_last_error (g)); - int i, len = 0; - for (i = 0; r[i] != NULL; ++i) len++; - VALUE rv = rb_ary_new2 (len); - for (i = 0; r[i] != NULL; ++i) { - rb_ary_push (rv, rb_str_new2 (r[i])); - free (r[i]); - } + VALUE rv = rb_str_new2 (r); free (r); return rv; } -static VALUE ruby_guestfs_aug_save (VALUE gv) +static VALUE ruby_guestfs_zerofree (VALUE gv, VALUE devicev) { guestfs_h *g; Data_Get_Struct (gv, guestfs_h, g); if (!g) - rb_raise (rb_eArgError, "%s: used handle after closing it", "aug_save"); + rb_raise (rb_eArgError, "%s: used handle after closing it", "zerofree"); + Check_Type (devicev, T_STRING); + const char *device = StringValueCStr (devicev); + if (!device) + rb_raise (rb_eTypeError, "expected string for parameter %s of %s", + "device", "zerofree"); int r; - r = guestfs_aug_save (g); + r = guestfs_zerofree (g, device); if (r == -1) rb_raise (e_Error, "%s", guestfs_last_error (g)); return Qnil; } -static VALUE ruby_guestfs_aug_load (VALUE gv) +static VALUE ruby_guestfs_pvresize (VALUE gv, VALUE devicev) { guestfs_h *g; Data_Get_Struct (gv, guestfs_h, g); if (!g) - rb_raise (rb_eArgError, "%s: used handle after closing it", "aug_load"); + rb_raise (rb_eArgError, "%s: used handle after closing it", "pvresize"); + Check_Type (devicev, T_STRING); + const char *device = StringValueCStr (devicev); + if (!device) + rb_raise (rb_eTypeError, "expected string for parameter %s of %s", + "device", "pvresize"); int r; - r = guestfs_aug_load (g); + r = guestfs_pvresize (g, device); if (r == -1) rb_raise (e_Error, "%s", guestfs_last_error (g)); return Qnil; } -static VALUE ruby_guestfs_aug_ls (VALUE gv, VALUE pathv) +static VALUE ruby_guestfs_sfdisk_N (VALUE gv, VALUE devicev, VALUE partnumv, VALUE cylsv, VALUE headsv, VALUE sectorsv, VALUE linev) { guestfs_h *g; Data_Get_Struct (gv, guestfs_h, g); if (!g) - rb_raise (rb_eArgError, "%s: used handle after closing it", "aug_ls"); + rb_raise (rb_eArgError, "%s: used handle after closing it", "sfdisk_N"); - const char *path = StringValueCStr (pathv); - if (!path) + Check_Type (devicev, T_STRING); + const char *device = StringValueCStr (devicev); + if (!device) rb_raise (rb_eTypeError, "expected string for parameter %s of %s", - "path", "aug_ls"); + "device", "sfdisk_N"); + int partnum = NUM2INT (partnumv); + int cyls = NUM2INT (cylsv); + int heads = NUM2INT (headsv); + int sectors = NUM2INT (sectorsv); + Check_Type (linev, T_STRING); + const char *line = StringValueCStr (linev); + if (!line) + rb_raise (rb_eTypeError, "expected string for parameter %s of %s", + "line", "sfdisk_N"); - char **r; + int r; - r = guestfs_aug_ls (g, path); + r = guestfs_sfdisk_N (g, device, partnum, cyls, heads, sectors, line); + if (r == -1) + rb_raise (e_Error, "%s", guestfs_last_error (g)); + + return Qnil; +} + +static VALUE ruby_guestfs_sfdisk_l (VALUE gv, VALUE devicev) +{ + guestfs_h *g; + Data_Get_Struct (gv, guestfs_h, g); + if (!g) + rb_raise (rb_eArgError, "%s: used handle after closing it", "sfdisk_l"); + + Check_Type (devicev, T_STRING); + const char *device = StringValueCStr (devicev); + if (!device) + rb_raise (rb_eTypeError, "expected string for parameter %s of %s", + "device", "sfdisk_l"); + + char *r; + + r = guestfs_sfdisk_l (g, device); if (r == NULL) rb_raise (e_Error, "%s", guestfs_last_error (g)); - int i, len = 0; - for (i = 0; r[i] != NULL; ++i) len++; - VALUE rv = rb_ary_new2 (len); - for (i = 0; r[i] != NULL; ++i) { - rb_ary_push (rv, rb_str_new2 (r[i])); - free (r[i]); - } + VALUE rv = rb_str_new2 (r); free (r); return rv; } -static VALUE ruby_guestfs_rm (VALUE gv, VALUE pathv) +static VALUE ruby_guestfs_sfdisk_kernel_geometry (VALUE gv, VALUE devicev) { guestfs_h *g; Data_Get_Struct (gv, guestfs_h, g); if (!g) - rb_raise (rb_eArgError, "%s: used handle after closing it", "rm"); + rb_raise (rb_eArgError, "%s: used handle after closing it", "sfdisk_kernel_geometry"); - const char *path = StringValueCStr (pathv); - if (!path) + Check_Type (devicev, T_STRING); + const char *device = StringValueCStr (devicev); + if (!device) rb_raise (rb_eTypeError, "expected string for parameter %s of %s", - "path", "rm"); + "device", "sfdisk_kernel_geometry"); - int r; + char *r; - r = guestfs_rm (g, path); - if (r == -1) + r = guestfs_sfdisk_kernel_geometry (g, device); + if (r == NULL) rb_raise (e_Error, "%s", guestfs_last_error (g)); - return Qnil; + VALUE rv = rb_str_new2 (r); + free (r); + return rv; } -static VALUE ruby_guestfs_rmdir (VALUE gv, VALUE pathv) +static VALUE ruby_guestfs_sfdisk_disk_geometry (VALUE gv, VALUE devicev) { guestfs_h *g; Data_Get_Struct (gv, guestfs_h, g); if (!g) - rb_raise (rb_eArgError, "%s: used handle after closing it", "rmdir"); + rb_raise (rb_eArgError, "%s: used handle after closing it", "sfdisk_disk_geometry"); - const char *path = StringValueCStr (pathv); - if (!path) + Check_Type (devicev, T_STRING); + const char *device = StringValueCStr (devicev); + if (!device) rb_raise (rb_eTypeError, "expected string for parameter %s of %s", - "path", "rmdir"); + "device", "sfdisk_disk_geometry"); - int r; + char *r; - r = guestfs_rmdir (g, path); - if (r == -1) + r = guestfs_sfdisk_disk_geometry (g, device); + if (r == NULL) rb_raise (e_Error, "%s", guestfs_last_error (g)); - return Qnil; + VALUE rv = rb_str_new2 (r); + free (r); + return rv; } -static VALUE ruby_guestfs_rm_rf (VALUE gv, VALUE pathv) +static VALUE ruby_guestfs_vg_activate_all (VALUE gv, VALUE activatev) { guestfs_h *g; Data_Get_Struct (gv, guestfs_h, g); if (!g) - rb_raise (rb_eArgError, "%s: used handle after closing it", "rm_rf"); + rb_raise (rb_eArgError, "%s: used handle after closing it", "vg_activate_all"); - const char *path = StringValueCStr (pathv); - if (!path) - rb_raise (rb_eTypeError, "expected string for parameter %s of %s", - "path", "rm_rf"); + int activate = RTEST (activatev); int r; - r = guestfs_rm_rf (g, path); + r = guestfs_vg_activate_all (g, activate); if (r == -1) rb_raise (e_Error, "%s", guestfs_last_error (g)); return Qnil; } -static VALUE ruby_guestfs_mkdir (VALUE gv, VALUE pathv) +static VALUE ruby_guestfs_vg_activate (VALUE gv, VALUE activatev, VALUE volgroupsv) { guestfs_h *g; Data_Get_Struct (gv, guestfs_h, g); if (!g) - rb_raise (rb_eArgError, "%s: used handle after closing it", "mkdir"); + rb_raise (rb_eArgError, "%s: used handle after closing it", "vg_activate"); - const char *path = StringValueCStr (pathv); - if (!path) - rb_raise (rb_eTypeError, "expected string for parameter %s of %s", - "path", "mkdir"); + int activate = RTEST (activatev); + char **volgroups; + Check_Type (volgroupsv, T_ARRAY); + { + int i, len; + len = RARRAY_LEN (volgroupsv); + volgroups = guestfs_safe_malloc (g, sizeof (char *) * (len+1)); + for (i = 0; i < len; ++i) { + VALUE v = rb_ary_entry (volgroupsv, i); + volgroups[i] = StringValueCStr (v); + } + volgroups[len] = NULL; + } int r; - r = guestfs_mkdir (g, path); + r = guestfs_vg_activate (g, activate, volgroups); + free (volgroups); if (r == -1) rb_raise (e_Error, "%s", guestfs_last_error (g)); return Qnil; } -static VALUE ruby_guestfs_mkdir_p (VALUE gv, VALUE pathv) +static VALUE ruby_guestfs_lvresize (VALUE gv, VALUE devicev, VALUE mbytesv) { guestfs_h *g; Data_Get_Struct (gv, guestfs_h, g); if (!g) - rb_raise (rb_eArgError, "%s: used handle after closing it", "mkdir_p"); + rb_raise (rb_eArgError, "%s: used handle after closing it", "lvresize"); - const char *path = StringValueCStr (pathv); - if (!path) + Check_Type (devicev, T_STRING); + const char *device = StringValueCStr (devicev); + if (!device) rb_raise (rb_eTypeError, "expected string for parameter %s of %s", - "path", "mkdir_p"); + "device", "lvresize"); + int mbytes = NUM2INT (mbytesv); int r; - r = guestfs_mkdir_p (g, path); + r = guestfs_lvresize (g, device, mbytes); if (r == -1) rb_raise (e_Error, "%s", guestfs_last_error (g)); return Qnil; } -static VALUE ruby_guestfs_chmod (VALUE gv, VALUE modev, VALUE pathv) +static VALUE ruby_guestfs_resize2fs (VALUE gv, VALUE devicev) { guestfs_h *g; Data_Get_Struct (gv, guestfs_h, g); if (!g) - rb_raise (rb_eArgError, "%s: used handle after closing it", "chmod"); + rb_raise (rb_eArgError, "%s: used handle after closing it", "resize2fs"); - int mode = NUM2INT (modev); - const char *path = StringValueCStr (pathv); - if (!path) + Check_Type (devicev, T_STRING); + const char *device = StringValueCStr (devicev); + if (!device) rb_raise (rb_eTypeError, "expected string for parameter %s of %s", - "path", "chmod"); + "device", "resize2fs"); int r; - r = guestfs_chmod (g, mode, path); + r = guestfs_resize2fs (g, device); if (r == -1) rb_raise (e_Error, "%s", guestfs_last_error (g)); return Qnil; } -static VALUE ruby_guestfs_chown (VALUE gv, VALUE ownerv, VALUE groupv, VALUE pathv) +static VALUE ruby_guestfs_find (VALUE gv, VALUE directoryv) { guestfs_h *g; Data_Get_Struct (gv, guestfs_h, g); if (!g) - rb_raise (rb_eArgError, "%s: used handle after closing it", "chown"); + rb_raise (rb_eArgError, "%s: used handle after closing it", "find"); - int owner = NUM2INT (ownerv); - int group = NUM2INT (groupv); - const char *path = StringValueCStr (pathv); - if (!path) + Check_Type (directoryv, T_STRING); + const char *directory = StringValueCStr (directoryv); + if (!directory) rb_raise (rb_eTypeError, "expected string for parameter %s of %s", - "path", "chown"); + "directory", "find"); - int r; + char **r; - r = guestfs_chown (g, owner, group, path); - if (r == -1) + r = guestfs_find (g, directory); + if (r == NULL) rb_raise (e_Error, "%s", guestfs_last_error (g)); - return Qnil; + int i, len = 0; + for (i = 0; r[i] != NULL; ++i) len++; + VALUE rv = rb_ary_new2 (len); + for (i = 0; r[i] != NULL; ++i) { + rb_ary_push (rv, rb_str_new2 (r[i])); + free (r[i]); + } + free (r); + return rv; } -static VALUE ruby_guestfs_exists (VALUE gv, VALUE pathv) +static VALUE ruby_guestfs_e2fsck_f (VALUE gv, VALUE devicev) { guestfs_h *g; Data_Get_Struct (gv, guestfs_h, g); if (!g) - rb_raise (rb_eArgError, "%s: used handle after closing it", "exists"); + rb_raise (rb_eArgError, "%s: used handle after closing it", "e2fsck_f"); - const char *path = StringValueCStr (pathv); - if (!path) + Check_Type (devicev, T_STRING); + const char *device = StringValueCStr (devicev); + if (!device) rb_raise (rb_eTypeError, "expected string for parameter %s of %s", - "path", "exists"); + "device", "e2fsck_f"); int r; - r = guestfs_exists (g, path); + r = guestfs_e2fsck_f (g, device); if (r == -1) rb_raise (e_Error, "%s", guestfs_last_error (g)); - return INT2NUM (r); + return Qnil; } -static VALUE ruby_guestfs_is_file (VALUE gv, VALUE pathv) +static VALUE ruby_guestfs_sleep (VALUE gv, VALUE secsv) { guestfs_h *g; Data_Get_Struct (gv, guestfs_h, g); if (!g) - rb_raise (rb_eArgError, "%s: used handle after closing it", "is_file"); + rb_raise (rb_eArgError, "%s: used handle after closing it", "sleep"); - const char *path = StringValueCStr (pathv); - if (!path) - rb_raise (rb_eTypeError, "expected string for parameter %s of %s", - "path", "is_file"); + int secs = NUM2INT (secsv); int r; - r = guestfs_is_file (g, path); + r = guestfs_sleep (g, secs); if (r == -1) rb_raise (e_Error, "%s", guestfs_last_error (g)); - return INT2NUM (r); + return Qnil; } -static VALUE ruby_guestfs_is_dir (VALUE gv, VALUE pathv) +static VALUE ruby_guestfs_ntfs_3g_probe (VALUE gv, VALUE rwv, VALUE devicev) { guestfs_h *g; Data_Get_Struct (gv, guestfs_h, g); if (!g) - rb_raise (rb_eArgError, "%s: used handle after closing it", "is_dir"); + rb_raise (rb_eArgError, "%s: used handle after closing it", "ntfs_3g_probe"); - const char *path = StringValueCStr (pathv); - if (!path) + int rw = RTEST (rwv); + Check_Type (devicev, T_STRING); + const char *device = StringValueCStr (devicev); + if (!device) rb_raise (rb_eTypeError, "expected string for parameter %s of %s", - "path", "is_dir"); + "device", "ntfs_3g_probe"); int r; - r = guestfs_is_dir (g, path); + r = guestfs_ntfs_3g_probe (g, rw, device); if (r == -1) rb_raise (e_Error, "%s", guestfs_last_error (g)); return INT2NUM (r); } -static VALUE ruby_guestfs_pvcreate (VALUE gv, VALUE devicev) +static VALUE ruby_guestfs_sh (VALUE gv, VALUE commandv) { guestfs_h *g; Data_Get_Struct (gv, guestfs_h, g); if (!g) - rb_raise (rb_eArgError, "%s: used handle after closing it", "pvcreate"); + rb_raise (rb_eArgError, "%s: used handle after closing it", "sh"); - const char *device = StringValueCStr (devicev); - if (!device) + Check_Type (commandv, T_STRING); + const char *command = StringValueCStr (commandv); + if (!command) rb_raise (rb_eTypeError, "expected string for parameter %s of %s", - "device", "pvcreate"); + "command", "sh"); - int r; + char *r; - r = guestfs_pvcreate (g, device); - if (r == -1) + r = guestfs_sh (g, command); + if (r == NULL) rb_raise (e_Error, "%s", guestfs_last_error (g)); - return Qnil; + VALUE rv = rb_str_new2 (r); + free (r); + return rv; } -static VALUE ruby_guestfs_vgcreate (VALUE gv, VALUE volgroupv, VALUE physvolsv) +static VALUE ruby_guestfs_sh_lines (VALUE gv, VALUE commandv) { guestfs_h *g; Data_Get_Struct (gv, guestfs_h, g); if (!g) - rb_raise (rb_eArgError, "%s: used handle after closing it", "vgcreate"); + rb_raise (rb_eArgError, "%s: used handle after closing it", "sh_lines"); - const char *volgroup = StringValueCStr (volgroupv); - if (!volgroup) + Check_Type (commandv, T_STRING); + const char *command = StringValueCStr (commandv); + if (!command) rb_raise (rb_eTypeError, "expected string for parameter %s of %s", - "volgroup", "vgcreate"); - char **physvols; { - int i, len; - len = RARRAY_LEN (physvolsv); - physvols = malloc (sizeof (char *) * (len+1)); - for (i = 0; i < len; ++i) { - VALUE v = rb_ary_entry (physvolsv, i); - physvols[i] = StringValueCStr (v); - } - } + "command", "sh_lines"); - int r; + char **r; - r = guestfs_vgcreate (g, volgroup, physvols); - free (physvols); - if (r == -1) + r = guestfs_sh_lines (g, command); + if (r == NULL) rb_raise (e_Error, "%s", guestfs_last_error (g)); - return Qnil; + int i, len = 0; + for (i = 0; r[i] != NULL; ++i) len++; + VALUE rv = rb_ary_new2 (len); + for (i = 0; r[i] != NULL; ++i) { + rb_ary_push (rv, rb_str_new2 (r[i])); + free (r[i]); + } + free (r); + return rv; } -static VALUE ruby_guestfs_lvcreate (VALUE gv, VALUE logvolv, VALUE volgroupv, VALUE mbytesv) +static VALUE ruby_guestfs_glob_expand (VALUE gv, VALUE patternv) { guestfs_h *g; Data_Get_Struct (gv, guestfs_h, g); if (!g) - rb_raise (rb_eArgError, "%s: used handle after closing it", "lvcreate"); + rb_raise (rb_eArgError, "%s: used handle after closing it", "glob_expand"); - const char *logvol = StringValueCStr (logvolv); - if (!logvol) - rb_raise (rb_eTypeError, "expected string for parameter %s of %s", - "logvol", "lvcreate"); - const char *volgroup = StringValueCStr (volgroupv); - if (!volgroup) + Check_Type (patternv, T_STRING); + const char *pattern = StringValueCStr (patternv); + if (!pattern) rb_raise (rb_eTypeError, "expected string for parameter %s of %s", - "volgroup", "lvcreate"); - int mbytes = NUM2INT (mbytesv); + "pattern", "glob_expand"); - int r; + char **r; - r = guestfs_lvcreate (g, logvol, volgroup, mbytes); - if (r == -1) + r = guestfs_glob_expand (g, pattern); + if (r == NULL) rb_raise (e_Error, "%s", guestfs_last_error (g)); - return Qnil; + int i, len = 0; + for (i = 0; r[i] != NULL; ++i) len++; + VALUE rv = rb_ary_new2 (len); + for (i = 0; r[i] != NULL; ++i) { + rb_ary_push (rv, rb_str_new2 (r[i])); + free (r[i]); + } + free (r); + return rv; } -static VALUE ruby_guestfs_mkfs (VALUE gv, VALUE fstypev, VALUE devicev) +static VALUE ruby_guestfs_scrub_device (VALUE gv, VALUE devicev) { guestfs_h *g; Data_Get_Struct (gv, guestfs_h, g); if (!g) - rb_raise (rb_eArgError, "%s: used handle after closing it", "mkfs"); + rb_raise (rb_eArgError, "%s: used handle after closing it", "scrub_device"); - const char *fstype = StringValueCStr (fstypev); - if (!fstype) - rb_raise (rb_eTypeError, "expected string for parameter %s of %s", - "fstype", "mkfs"); + Check_Type (devicev, T_STRING); const char *device = StringValueCStr (devicev); if (!device) rb_raise (rb_eTypeError, "expected string for parameter %s of %s", - "device", "mkfs"); + "device", "scrub_device"); int r; - r = guestfs_mkfs (g, fstype, device); + r = guestfs_scrub_device (g, device); if (r == -1) rb_raise (e_Error, "%s", guestfs_last_error (g)); return Qnil; } -static VALUE ruby_guestfs_sfdisk (VALUE gv, VALUE devicev, VALUE cylsv, VALUE headsv, VALUE sectorsv, VALUE linesv) +static VALUE ruby_guestfs_scrub_file (VALUE gv, VALUE filev) { guestfs_h *g; Data_Get_Struct (gv, guestfs_h, g); if (!g) - rb_raise (rb_eArgError, "%s: used handle after closing it", "sfdisk"); + rb_raise (rb_eArgError, "%s: used handle after closing it", "scrub_file"); - const char *device = StringValueCStr (devicev); - if (!device) + Check_Type (filev, T_STRING); + const char *file = StringValueCStr (filev); + if (!file) rb_raise (rb_eTypeError, "expected string for parameter %s of %s", - "device", "sfdisk"); - int cyls = NUM2INT (cylsv); - int heads = NUM2INT (headsv); - int sectors = NUM2INT (sectorsv); - char **lines; { - int i, len; - len = RARRAY_LEN (linesv); - lines = malloc (sizeof (char *) * (len+1)); - for (i = 0; i < len; ++i) { - VALUE v = rb_ary_entry (linesv, i); - lines[i] = StringValueCStr (v); - } - } + "file", "scrub_file"); int r; - r = guestfs_sfdisk (g, device, cyls, heads, sectors, lines); - free (lines); + r = guestfs_scrub_file (g, file); if (r == -1) rb_raise (e_Error, "%s", guestfs_last_error (g)); return Qnil; } -static VALUE ruby_guestfs_write_file (VALUE gv, VALUE pathv, VALUE contentv, VALUE sizev) +static VALUE ruby_guestfs_scrub_freespace (VALUE gv, VALUE dirv) { guestfs_h *g; Data_Get_Struct (gv, guestfs_h, g); if (!g) - rb_raise (rb_eArgError, "%s: used handle after closing it", "write_file"); + rb_raise (rb_eArgError, "%s: used handle after closing it", "scrub_freespace"); - const char *path = StringValueCStr (pathv); - if (!path) - rb_raise (rb_eTypeError, "expected string for parameter %s of %s", - "path", "write_file"); - const char *content = StringValueCStr (contentv); - if (!content) + Check_Type (dirv, T_STRING); + const char *dir = StringValueCStr (dirv); + if (!dir) rb_raise (rb_eTypeError, "expected string for parameter %s of %s", - "content", "write_file"); - int size = NUM2INT (sizev); + "dir", "scrub_freespace"); int r; - r = guestfs_write_file (g, path, content, size); + r = guestfs_scrub_freespace (g, dir); if (r == -1) rb_raise (e_Error, "%s", guestfs_last_error (g)); return Qnil; } -static VALUE ruby_guestfs_umount (VALUE gv, VALUE pathordevicev) +static VALUE ruby_guestfs_mkdtemp (VALUE gv, VALUE templatev) { guestfs_h *g; Data_Get_Struct (gv, guestfs_h, g); if (!g) - rb_raise (rb_eArgError, "%s: used handle after closing it", "umount"); + rb_raise (rb_eArgError, "%s: used handle after closing it", "mkdtemp"); - const char *pathordevice = StringValueCStr (pathordevicev); - if (!pathordevice) + Check_Type (templatev, T_STRING); + const char *template = StringValueCStr (templatev); + if (!template) rb_raise (rb_eTypeError, "expected string for parameter %s of %s", - "pathordevice", "umount"); + "template", "mkdtemp"); - int r; + char *r; - r = guestfs_umount (g, pathordevice); - if (r == -1) + r = guestfs_mkdtemp (g, template); + if (r == NULL) rb_raise (e_Error, "%s", guestfs_last_error (g)); - return Qnil; + VALUE rv = rb_str_new2 (r); + free (r); + return rv; } -static VALUE ruby_guestfs_mounts (VALUE gv) +static VALUE ruby_guestfs_wc_l (VALUE gv, VALUE pathv) { guestfs_h *g; Data_Get_Struct (gv, guestfs_h, g); if (!g) - rb_raise (rb_eArgError, "%s: used handle after closing it", "mounts"); + rb_raise (rb_eArgError, "%s: used handle after closing it", "wc_l"); + Check_Type (pathv, T_STRING); + const char *path = StringValueCStr (pathv); + if (!path) + rb_raise (rb_eTypeError, "expected string for parameter %s of %s", + "path", "wc_l"); - char **r; + int r; - r = guestfs_mounts (g); - if (r == NULL) + r = guestfs_wc_l (g, path); + if (r == -1) rb_raise (e_Error, "%s", guestfs_last_error (g)); - int i, len = 0; - for (i = 0; r[i] != NULL; ++i) len++; - VALUE rv = rb_ary_new2 (len); - for (i = 0; r[i] != NULL; ++i) { - rb_ary_push (rv, rb_str_new2 (r[i])); - free (r[i]); - } - free (r); - return rv; + return INT2NUM (r); } -static VALUE ruby_guestfs_umount_all (VALUE gv) +static VALUE ruby_guestfs_wc_w (VALUE gv, VALUE pathv) { guestfs_h *g; Data_Get_Struct (gv, guestfs_h, g); if (!g) - rb_raise (rb_eArgError, "%s: used handle after closing it", "umount_all"); + rb_raise (rb_eArgError, "%s: used handle after closing it", "wc_w"); + Check_Type (pathv, T_STRING); + const char *path = StringValueCStr (pathv); + if (!path) + rb_raise (rb_eTypeError, "expected string for parameter %s of %s", + "path", "wc_w"); int r; - r = guestfs_umount_all (g); + r = guestfs_wc_w (g, path); if (r == -1) rb_raise (e_Error, "%s", guestfs_last_error (g)); - return Qnil; + return INT2NUM (r); } -static VALUE ruby_guestfs_lvm_remove_all (VALUE gv) +static VALUE ruby_guestfs_wc_c (VALUE gv, VALUE pathv) { guestfs_h *g; Data_Get_Struct (gv, guestfs_h, g); if (!g) - rb_raise (rb_eArgError, "%s: used handle after closing it", "lvm_remove_all"); + rb_raise (rb_eArgError, "%s: used handle after closing it", "wc_c"); + Check_Type (pathv, T_STRING); + const char *path = StringValueCStr (pathv); + if (!path) + rb_raise (rb_eTypeError, "expected string for parameter %s of %s", + "path", "wc_c"); int r; - r = guestfs_lvm_remove_all (g); + r = guestfs_wc_c (g, path); if (r == -1) rb_raise (e_Error, "%s", guestfs_last_error (g)); - return Qnil; + return INT2NUM (r); } -static VALUE ruby_guestfs_file (VALUE gv, VALUE pathv) +static VALUE ruby_guestfs_head (VALUE gv, VALUE pathv) { guestfs_h *g; Data_Get_Struct (gv, guestfs_h, g); if (!g) - rb_raise (rb_eArgError, "%s: used handle after closing it", "file"); + rb_raise (rb_eArgError, "%s: used handle after closing it", "head"); + Check_Type (pathv, T_STRING); const char *path = StringValueCStr (pathv); if (!path) rb_raise (rb_eTypeError, "expected string for parameter %s of %s", - "path", "file"); + "path", "head"); - char *r; + char **r; - r = guestfs_file (g, path); + r = guestfs_head (g, path); if (r == NULL) rb_raise (e_Error, "%s", guestfs_last_error (g)); - VALUE rv = rb_str_new2 (r); + int i, len = 0; + for (i = 0; r[i] != NULL; ++i) len++; + VALUE rv = rb_ary_new2 (len); + for (i = 0; r[i] != NULL; ++i) { + rb_ary_push (rv, rb_str_new2 (r[i])); + free (r[i]); + } free (r); return rv; } -static VALUE ruby_guestfs_command (VALUE gv, VALUE argumentsv) +static VALUE ruby_guestfs_head_n (VALUE gv, VALUE nrlinesv, VALUE pathv) { guestfs_h *g; Data_Get_Struct (gv, guestfs_h, g); if (!g) - rb_raise (rb_eArgError, "%s: used handle after closing it", "command"); + rb_raise (rb_eArgError, "%s: used handle after closing it", "head_n"); - char **arguments; { - int i, len; - len = RARRAY_LEN (argumentsv); - arguments = malloc (sizeof (char *) * (len+1)); - for (i = 0; i < len; ++i) { - VALUE v = rb_ary_entry (argumentsv, i); - arguments[i] = StringValueCStr (v); - } - } + int nrlines = NUM2INT (nrlinesv); + Check_Type (pathv, T_STRING); + const char *path = StringValueCStr (pathv); + if (!path) + rb_raise (rb_eTypeError, "expected string for parameter %s of %s", + "path", "head_n"); - char *r; + char **r; - r = guestfs_command (g, arguments); - free (arguments); + r = guestfs_head_n (g, nrlines, path); if (r == NULL) rb_raise (e_Error, "%s", guestfs_last_error (g)); - VALUE rv = rb_str_new2 (r); + int i, len = 0; + for (i = 0; r[i] != NULL; ++i) len++; + VALUE rv = rb_ary_new2 (len); + for (i = 0; r[i] != NULL; ++i) { + rb_ary_push (rv, rb_str_new2 (r[i])); + free (r[i]); + } free (r); return rv; } -static VALUE ruby_guestfs_command_lines (VALUE gv, VALUE argumentsv) +static VALUE ruby_guestfs_tail (VALUE gv, VALUE pathv) { guestfs_h *g; Data_Get_Struct (gv, guestfs_h, g); if (!g) - rb_raise (rb_eArgError, "%s: used handle after closing it", "command_lines"); + rb_raise (rb_eArgError, "%s: used handle after closing it", "tail"); - char **arguments; { - int i, len; - len = RARRAY_LEN (argumentsv); - arguments = malloc (sizeof (char *) * (len+1)); - for (i = 0; i < len; ++i) { - VALUE v = rb_ary_entry (argumentsv, i); - arguments[i] = StringValueCStr (v); - } - } + Check_Type (pathv, T_STRING); + const char *path = StringValueCStr (pathv); + if (!path) + rb_raise (rb_eTypeError, "expected string for parameter %s of %s", + "path", "tail"); char **r; - r = guestfs_command_lines (g, arguments); - free (arguments); + r = guestfs_tail (g, path); if (r == NULL) rb_raise (e_Error, "%s", guestfs_last_error (g)); @@ -1636,350 +4525,344 @@ static VALUE ruby_guestfs_command_lines (VALUE gv, VALUE argumentsv) return rv; } -static VALUE ruby_guestfs_stat (VALUE gv, VALUE pathv) +static VALUE ruby_guestfs_tail_n (VALUE gv, VALUE nrlinesv, VALUE pathv) { guestfs_h *g; Data_Get_Struct (gv, guestfs_h, g); if (!g) - rb_raise (rb_eArgError, "%s: used handle after closing it", "stat"); + rb_raise (rb_eArgError, "%s: used handle after closing it", "tail_n"); + int nrlines = NUM2INT (nrlinesv); + Check_Type (pathv, T_STRING); const char *path = StringValueCStr (pathv); if (!path) rb_raise (rb_eTypeError, "expected string for parameter %s of %s", - "path", "stat"); + "path", "tail_n"); - struct guestfs_stat *r; + char **r; - r = guestfs_stat (g, path); + r = guestfs_tail_n (g, nrlines, path); if (r == NULL) rb_raise (e_Error, "%s", guestfs_last_error (g)); - VALUE rv = rb_hash_new (); - rb_hash_aset (rv, rb_str_new2 ("dev"), ULL2NUM (r->dev)); - rb_hash_aset (rv, rb_str_new2 ("ino"), ULL2NUM (r->ino)); - rb_hash_aset (rv, rb_str_new2 ("mode"), ULL2NUM (r->mode)); - rb_hash_aset (rv, rb_str_new2 ("nlink"), ULL2NUM (r->nlink)); - rb_hash_aset (rv, rb_str_new2 ("uid"), ULL2NUM (r->uid)); - rb_hash_aset (rv, rb_str_new2 ("gid"), ULL2NUM (r->gid)); - rb_hash_aset (rv, rb_str_new2 ("rdev"), ULL2NUM (r->rdev)); - rb_hash_aset (rv, rb_str_new2 ("size"), ULL2NUM (r->size)); - rb_hash_aset (rv, rb_str_new2 ("blksize"), ULL2NUM (r->blksize)); - rb_hash_aset (rv, rb_str_new2 ("blocks"), ULL2NUM (r->blocks)); - rb_hash_aset (rv, rb_str_new2 ("atime"), ULL2NUM (r->atime)); - rb_hash_aset (rv, rb_str_new2 ("mtime"), ULL2NUM (r->mtime)); - rb_hash_aset (rv, rb_str_new2 ("ctime"), ULL2NUM (r->ctime)); + int i, len = 0; + for (i = 0; r[i] != NULL; ++i) len++; + VALUE rv = rb_ary_new2 (len); + for (i = 0; r[i] != NULL; ++i) { + rb_ary_push (rv, rb_str_new2 (r[i])); + free (r[i]); + } free (r); return rv; } -static VALUE ruby_guestfs_lstat (VALUE gv, VALUE pathv) +static VALUE ruby_guestfs_df (VALUE gv) { guestfs_h *g; Data_Get_Struct (gv, guestfs_h, g); if (!g) - rb_raise (rb_eArgError, "%s: used handle after closing it", "lstat"); + rb_raise (rb_eArgError, "%s: used handle after closing it", "df"); - const char *path = StringValueCStr (pathv); - if (!path) - rb_raise (rb_eTypeError, "expected string for parameter %s of %s", - "path", "lstat"); - struct guestfs_stat *r; + char *r; - r = guestfs_lstat (g, path); + r = guestfs_df (g); if (r == NULL) rb_raise (e_Error, "%s", guestfs_last_error (g)); - VALUE rv = rb_hash_new (); - rb_hash_aset (rv, rb_str_new2 ("dev"), ULL2NUM (r->dev)); - rb_hash_aset (rv, rb_str_new2 ("ino"), ULL2NUM (r->ino)); - rb_hash_aset (rv, rb_str_new2 ("mode"), ULL2NUM (r->mode)); - rb_hash_aset (rv, rb_str_new2 ("nlink"), ULL2NUM (r->nlink)); - rb_hash_aset (rv, rb_str_new2 ("uid"), ULL2NUM (r->uid)); - rb_hash_aset (rv, rb_str_new2 ("gid"), ULL2NUM (r->gid)); - rb_hash_aset (rv, rb_str_new2 ("rdev"), ULL2NUM (r->rdev)); - rb_hash_aset (rv, rb_str_new2 ("size"), ULL2NUM (r->size)); - rb_hash_aset (rv, rb_str_new2 ("blksize"), ULL2NUM (r->blksize)); - rb_hash_aset (rv, rb_str_new2 ("blocks"), ULL2NUM (r->blocks)); - rb_hash_aset (rv, rb_str_new2 ("atime"), ULL2NUM (r->atime)); - rb_hash_aset (rv, rb_str_new2 ("mtime"), ULL2NUM (r->mtime)); - rb_hash_aset (rv, rb_str_new2 ("ctime"), ULL2NUM (r->ctime)); + VALUE rv = rb_str_new2 (r); free (r); return rv; } -static VALUE ruby_guestfs_statvfs (VALUE gv, VALUE pathv) +static VALUE ruby_guestfs_df_h (VALUE gv) { guestfs_h *g; Data_Get_Struct (gv, guestfs_h, g); if (!g) - rb_raise (rb_eArgError, "%s: used handle after closing it", "statvfs"); + rb_raise (rb_eArgError, "%s: used handle after closing it", "df_h"); - const char *path = StringValueCStr (pathv); - if (!path) - rb_raise (rb_eTypeError, "expected string for parameter %s of %s", - "path", "statvfs"); - struct guestfs_statvfs *r; + char *r; - r = guestfs_statvfs (g, path); + r = guestfs_df_h (g); if (r == NULL) rb_raise (e_Error, "%s", guestfs_last_error (g)); - VALUE rv = rb_hash_new (); - rb_hash_aset (rv, rb_str_new2 ("bsize"), ULL2NUM (r->bsize)); - rb_hash_aset (rv, rb_str_new2 ("frsize"), ULL2NUM (r->frsize)); - rb_hash_aset (rv, rb_str_new2 ("blocks"), ULL2NUM (r->blocks)); - rb_hash_aset (rv, rb_str_new2 ("bfree"), ULL2NUM (r->bfree)); - rb_hash_aset (rv, rb_str_new2 ("bavail"), ULL2NUM (r->bavail)); - rb_hash_aset (rv, rb_str_new2 ("files"), ULL2NUM (r->files)); - rb_hash_aset (rv, rb_str_new2 ("ffree"), ULL2NUM (r->ffree)); - rb_hash_aset (rv, rb_str_new2 ("favail"), ULL2NUM (r->favail)); - rb_hash_aset (rv, rb_str_new2 ("fsid"), ULL2NUM (r->fsid)); - rb_hash_aset (rv, rb_str_new2 ("flag"), ULL2NUM (r->flag)); - rb_hash_aset (rv, rb_str_new2 ("namemax"), ULL2NUM (r->namemax)); + VALUE rv = rb_str_new2 (r); free (r); return rv; } -static VALUE ruby_guestfs_tune2fs_l (VALUE gv, VALUE devicev) +static VALUE ruby_guestfs_du (VALUE gv, VALUE pathv) { guestfs_h *g; Data_Get_Struct (gv, guestfs_h, g); if (!g) - rb_raise (rb_eArgError, "%s: used handle after closing it", "tune2fs_l"); + rb_raise (rb_eArgError, "%s: used handle after closing it", "du"); - const char *device = StringValueCStr (devicev); - if (!device) + Check_Type (pathv, T_STRING); + const char *path = StringValueCStr (pathv); + if (!path) rb_raise (rb_eTypeError, "expected string for parameter %s of %s", - "device", "tune2fs_l"); + "path", "du"); - char **r; + int64_t r; - r = guestfs_tune2fs_l (g, device); - if (r == NULL) + r = guestfs_du (g, path); + if (r == -1) rb_raise (e_Error, "%s", guestfs_last_error (g)); - VALUE rv = rb_hash_new (); - int i; - for (i = 0; r[i] != NULL; i+=2) { - rb_hash_aset (rv, rb_str_new2 (r[i]), rb_str_new2 (r[i+1])); - free (r[i]); - free (r[i+1]); - } - free (r); - return rv; + return ULL2NUM (r); } -static VALUE ruby_guestfs_blockdev_setro (VALUE gv, VALUE devicev) +static VALUE ruby_guestfs_initrd_list (VALUE gv, VALUE pathv) { guestfs_h *g; Data_Get_Struct (gv, guestfs_h, g); if (!g) - rb_raise (rb_eArgError, "%s: used handle after closing it", "blockdev_setro"); + rb_raise (rb_eArgError, "%s: used handle after closing it", "initrd_list"); - const char *device = StringValueCStr (devicev); - if (!device) + Check_Type (pathv, T_STRING); + const char *path = StringValueCStr (pathv); + if (!path) rb_raise (rb_eTypeError, "expected string for parameter %s of %s", - "device", "blockdev_setro"); + "path", "initrd_list"); - int r; + char **r; - r = guestfs_blockdev_setro (g, device); - if (r == -1) + r = guestfs_initrd_list (g, path); + if (r == NULL) rb_raise (e_Error, "%s", guestfs_last_error (g)); - return Qnil; + int i, len = 0; + for (i = 0; r[i] != NULL; ++i) len++; + VALUE rv = rb_ary_new2 (len); + for (i = 0; r[i] != NULL; ++i) { + rb_ary_push (rv, rb_str_new2 (r[i])); + free (r[i]); + } + free (r); + return rv; } -static VALUE ruby_guestfs_blockdev_setrw (VALUE gv, VALUE devicev) +static VALUE ruby_guestfs_mount_loop (VALUE gv, VALUE filev, VALUE mountpointv) { guestfs_h *g; Data_Get_Struct (gv, guestfs_h, g); if (!g) - rb_raise (rb_eArgError, "%s: used handle after closing it", "blockdev_setrw"); + rb_raise (rb_eArgError, "%s: used handle after closing it", "mount_loop"); - const char *device = StringValueCStr (devicev); - if (!device) + Check_Type (filev, T_STRING); + const char *file = StringValueCStr (filev); + if (!file) rb_raise (rb_eTypeError, "expected string for parameter %s of %s", - "device", "blockdev_setrw"); + "file", "mount_loop"); + Check_Type (mountpointv, T_STRING); + const char *mountpoint = StringValueCStr (mountpointv); + if (!mountpoint) + rb_raise (rb_eTypeError, "expected string for parameter %s of %s", + "mountpoint", "mount_loop"); int r; - r = guestfs_blockdev_setrw (g, device); + r = guestfs_mount_loop (g, file, mountpoint); if (r == -1) rb_raise (e_Error, "%s", guestfs_last_error (g)); return Qnil; } -static VALUE ruby_guestfs_blockdev_getro (VALUE gv, VALUE devicev) +static VALUE ruby_guestfs_mkswap (VALUE gv, VALUE devicev) { guestfs_h *g; Data_Get_Struct (gv, guestfs_h, g); if (!g) - rb_raise (rb_eArgError, "%s: used handle after closing it", "blockdev_getro"); + rb_raise (rb_eArgError, "%s: used handle after closing it", "mkswap"); + Check_Type (devicev, T_STRING); const char *device = StringValueCStr (devicev); if (!device) rb_raise (rb_eTypeError, "expected string for parameter %s of %s", - "device", "blockdev_getro"); + "device", "mkswap"); int r; - r = guestfs_blockdev_getro (g, device); + r = guestfs_mkswap (g, device); if (r == -1) rb_raise (e_Error, "%s", guestfs_last_error (g)); - return INT2NUM (r); + return Qnil; } -static VALUE ruby_guestfs_blockdev_getss (VALUE gv, VALUE devicev) +static VALUE ruby_guestfs_mkswap_L (VALUE gv, VALUE labelv, VALUE devicev) { guestfs_h *g; Data_Get_Struct (gv, guestfs_h, g); if (!g) - rb_raise (rb_eArgError, "%s: used handle after closing it", "blockdev_getss"); + rb_raise (rb_eArgError, "%s: used handle after closing it", "mkswap_L"); + Check_Type (labelv, T_STRING); + const char *label = StringValueCStr (labelv); + if (!label) + rb_raise (rb_eTypeError, "expected string for parameter %s of %s", + "label", "mkswap_L"); + Check_Type (devicev, T_STRING); const char *device = StringValueCStr (devicev); if (!device) rb_raise (rb_eTypeError, "expected string for parameter %s of %s", - "device", "blockdev_getss"); + "device", "mkswap_L"); int r; - r = guestfs_blockdev_getss (g, device); + r = guestfs_mkswap_L (g, label, device); if (r == -1) rb_raise (e_Error, "%s", guestfs_last_error (g)); - return INT2NUM (r); + return Qnil; } -static VALUE ruby_guestfs_blockdev_getbsz (VALUE gv, VALUE devicev) +static VALUE ruby_guestfs_mkswap_U (VALUE gv, VALUE uuidv, VALUE devicev) { guestfs_h *g; Data_Get_Struct (gv, guestfs_h, g); if (!g) - rb_raise (rb_eArgError, "%s: used handle after closing it", "blockdev_getbsz"); + rb_raise (rb_eArgError, "%s: used handle after closing it", "mkswap_U"); + Check_Type (uuidv, T_STRING); + const char *uuid = StringValueCStr (uuidv); + if (!uuid) + rb_raise (rb_eTypeError, "expected string for parameter %s of %s", + "uuid", "mkswap_U"); + Check_Type (devicev, T_STRING); const char *device = StringValueCStr (devicev); if (!device) rb_raise (rb_eTypeError, "expected string for parameter %s of %s", - "device", "blockdev_getbsz"); + "device", "mkswap_U"); int r; - r = guestfs_blockdev_getbsz (g, device); + r = guestfs_mkswap_U (g, uuid, device); if (r == -1) rb_raise (e_Error, "%s", guestfs_last_error (g)); - return INT2NUM (r); + return Qnil; } -static VALUE ruby_guestfs_blockdev_setbsz (VALUE gv, VALUE devicev, VALUE blocksizev) +static VALUE ruby_guestfs_mknod (VALUE gv, VALUE modev, VALUE devmajorv, VALUE devminorv, VALUE pathv) { guestfs_h *g; Data_Get_Struct (gv, guestfs_h, g); if (!g) - rb_raise (rb_eArgError, "%s: used handle after closing it", "blockdev_setbsz"); + rb_raise (rb_eArgError, "%s: used handle after closing it", "mknod"); - const char *device = StringValueCStr (devicev); - if (!device) + int mode = NUM2INT (modev); + int devmajor = NUM2INT (devmajorv); + int devminor = NUM2INT (devminorv); + Check_Type (pathv, T_STRING); + const char *path = StringValueCStr (pathv); + if (!path) rb_raise (rb_eTypeError, "expected string for parameter %s of %s", - "device", "blockdev_setbsz"); - int blocksize = NUM2INT (blocksizev); + "path", "mknod"); int r; - r = guestfs_blockdev_setbsz (g, device, blocksize); + r = guestfs_mknod (g, mode, devmajor, devminor, path); if (r == -1) rb_raise (e_Error, "%s", guestfs_last_error (g)); return Qnil; } -static VALUE ruby_guestfs_blockdev_getsz (VALUE gv, VALUE devicev) +static VALUE ruby_guestfs_mkfifo (VALUE gv, VALUE modev, VALUE pathv) { guestfs_h *g; Data_Get_Struct (gv, guestfs_h, g); if (!g) - rb_raise (rb_eArgError, "%s: used handle after closing it", "blockdev_getsz"); + rb_raise (rb_eArgError, "%s: used handle after closing it", "mkfifo"); - const char *device = StringValueCStr (devicev); - if (!device) + int mode = NUM2INT (modev); + Check_Type (pathv, T_STRING); + const char *path = StringValueCStr (pathv); + if (!path) rb_raise (rb_eTypeError, "expected string for parameter %s of %s", - "device", "blockdev_getsz"); + "path", "mkfifo"); - int64_t r; + int r; - r = guestfs_blockdev_getsz (g, device); + r = guestfs_mkfifo (g, mode, path); if (r == -1) rb_raise (e_Error, "%s", guestfs_last_error (g)); - return ULL2NUM (r); + return Qnil; } -static VALUE ruby_guestfs_blockdev_getsize64 (VALUE gv, VALUE devicev) +static VALUE ruby_guestfs_mknod_b (VALUE gv, VALUE modev, VALUE devmajorv, VALUE devminorv, VALUE pathv) { guestfs_h *g; Data_Get_Struct (gv, guestfs_h, g); if (!g) - rb_raise (rb_eArgError, "%s: used handle after closing it", "blockdev_getsize64"); + rb_raise (rb_eArgError, "%s: used handle after closing it", "mknod_b"); - const char *device = StringValueCStr (devicev); - if (!device) + int mode = NUM2INT (modev); + int devmajor = NUM2INT (devmajorv); + int devminor = NUM2INT (devminorv); + Check_Type (pathv, T_STRING); + const char *path = StringValueCStr (pathv); + if (!path) rb_raise (rb_eTypeError, "expected string for parameter %s of %s", - "device", "blockdev_getsize64"); + "path", "mknod_b"); - int64_t r; + int r; - r = guestfs_blockdev_getsize64 (g, device); + r = guestfs_mknod_b (g, mode, devmajor, devminor, path); if (r == -1) rb_raise (e_Error, "%s", guestfs_last_error (g)); - return ULL2NUM (r); + return Qnil; } -static VALUE ruby_guestfs_blockdev_flushbufs (VALUE gv, VALUE devicev) +static VALUE ruby_guestfs_mknod_c (VALUE gv, VALUE modev, VALUE devmajorv, VALUE devminorv, VALUE pathv) { guestfs_h *g; Data_Get_Struct (gv, guestfs_h, g); if (!g) - rb_raise (rb_eArgError, "%s: used handle after closing it", "blockdev_flushbufs"); + rb_raise (rb_eArgError, "%s: used handle after closing it", "mknod_c"); - const char *device = StringValueCStr (devicev); - if (!device) + int mode = NUM2INT (modev); + int devmajor = NUM2INT (devmajorv); + int devminor = NUM2INT (devminorv); + Check_Type (pathv, T_STRING); + const char *path = StringValueCStr (pathv); + if (!path) rb_raise (rb_eTypeError, "expected string for parameter %s of %s", - "device", "blockdev_flushbufs"); + "path", "mknod_c"); int r; - r = guestfs_blockdev_flushbufs (g, device); + r = guestfs_mknod_c (g, mode, devmajor, devminor, path); if (r == -1) rb_raise (e_Error, "%s", guestfs_last_error (g)); return Qnil; } -static VALUE ruby_guestfs_blockdev_rereadpt (VALUE gv, VALUE devicev) +static VALUE ruby_guestfs_umask (VALUE gv, VALUE maskv) { guestfs_h *g; Data_Get_Struct (gv, guestfs_h, g); if (!g) - rb_raise (rb_eArgError, "%s: used handle after closing it", "blockdev_rereadpt"); + rb_raise (rb_eArgError, "%s: used handle after closing it", "umask"); - const char *device = StringValueCStr (devicev); - if (!device) - rb_raise (rb_eTypeError, "expected string for parameter %s of %s", - "device", "blockdev_rereadpt"); + int mask = NUM2INT (maskv); int r; - r = guestfs_blockdev_rereadpt (g, device); + r = guestfs_umask (g, mask); if (r == -1) rb_raise (e_Error, "%s", guestfs_last_error (g)); - return Qnil; + return INT2NUM (r); } /* Initialize the module. */ @@ -1992,6 +4875,60 @@ void Init__guestfs () rb_define_module_function (m_guestfs, "create", ruby_guestfs_create, 0); rb_define_method (c_guestfs, "close", ruby_guestfs_close, 0); + rb_define_method (c_guestfs, "test0", + ruby_guestfs_test0, 7); + rb_define_method (c_guestfs, "test0rint", + ruby_guestfs_test0rint, 1); + rb_define_method (c_guestfs, "test0rinterr", + ruby_guestfs_test0rinterr, 0); + rb_define_method (c_guestfs, "test0rint64", + ruby_guestfs_test0rint64, 1); + rb_define_method (c_guestfs, "test0rint64err", + ruby_guestfs_test0rint64err, 0); + rb_define_method (c_guestfs, "test0rbool", + ruby_guestfs_test0rbool, 1); + rb_define_method (c_guestfs, "test0rboolerr", + ruby_guestfs_test0rboolerr, 0); + rb_define_method (c_guestfs, "test0rconststring", + ruby_guestfs_test0rconststring, 1); + rb_define_method (c_guestfs, "test0rconststringerr", + ruby_guestfs_test0rconststringerr, 0); + rb_define_method (c_guestfs, "test0rstring", + ruby_guestfs_test0rstring, 1); + rb_define_method (c_guestfs, "test0rstringerr", + ruby_guestfs_test0rstringerr, 0); + rb_define_method (c_guestfs, "test0rstringlist", + ruby_guestfs_test0rstringlist, 1); + rb_define_method (c_guestfs, "test0rstringlisterr", + ruby_guestfs_test0rstringlisterr, 0); + rb_define_method (c_guestfs, "test0rintbool", + ruby_guestfs_test0rintbool, 1); + rb_define_method (c_guestfs, "test0rintboolerr", + ruby_guestfs_test0rintboolerr, 0); + rb_define_method (c_guestfs, "test0rpvlist", + ruby_guestfs_test0rpvlist, 1); + rb_define_method (c_guestfs, "test0rpvlisterr", + ruby_guestfs_test0rpvlisterr, 0); + rb_define_method (c_guestfs, "test0rvglist", + ruby_guestfs_test0rvglist, 1); + rb_define_method (c_guestfs, "test0rvglisterr", + ruby_guestfs_test0rvglisterr, 0); + rb_define_method (c_guestfs, "test0rlvlist", + ruby_guestfs_test0rlvlist, 1); + rb_define_method (c_guestfs, "test0rlvlisterr", + ruby_guestfs_test0rlvlisterr, 0); + rb_define_method (c_guestfs, "test0rstat", + ruby_guestfs_test0rstat, 1); + rb_define_method (c_guestfs, "test0rstaterr", + ruby_guestfs_test0rstaterr, 0); + rb_define_method (c_guestfs, "test0rstatvfs", + ruby_guestfs_test0rstatvfs, 1); + rb_define_method (c_guestfs, "test0rstatvfserr", + ruby_guestfs_test0rstatvfserr, 0); + rb_define_method (c_guestfs, "test0rhashtable", + ruby_guestfs_test0rhashtable, 1); + rb_define_method (c_guestfs, "test0rhashtableerr", + ruby_guestfs_test0rhashtableerr, 0); rb_define_method (c_guestfs, "launch", ruby_guestfs_launch, 0); rb_define_method (c_guestfs, "wait_ready", @@ -2002,12 +4939,22 @@ void Init__guestfs () ruby_guestfs_add_drive, 1); rb_define_method (c_guestfs, "add_cdrom", ruby_guestfs_add_cdrom, 1); + rb_define_method (c_guestfs, "add_drive_ro", + ruby_guestfs_add_drive_ro, 1); rb_define_method (c_guestfs, "config", ruby_guestfs_config, 2); + rb_define_method (c_guestfs, "set_qemu", + ruby_guestfs_set_qemu, 1); + rb_define_method (c_guestfs, "get_qemu", + ruby_guestfs_get_qemu, 0); rb_define_method (c_guestfs, "set_path", ruby_guestfs_set_path, 1); rb_define_method (c_guestfs, "get_path", ruby_guestfs_get_path, 0); + rb_define_method (c_guestfs, "set_append", + ruby_guestfs_set_append, 1); + rb_define_method (c_guestfs, "get_append", + ruby_guestfs_get_append, 0); rb_define_method (c_guestfs, "set_autosync", ruby_guestfs_set_autosync, 1); rb_define_method (c_guestfs, "get_autosync", @@ -2026,6 +4973,16 @@ void Init__guestfs () ruby_guestfs_is_busy, 0); rb_define_method (c_guestfs, "get_state", ruby_guestfs_get_state, 0); + rb_define_method (c_guestfs, "set_busy", + ruby_guestfs_set_busy, 0); + rb_define_method (c_guestfs, "set_ready", + ruby_guestfs_set_ready, 0); + rb_define_method (c_guestfs, "end_busy", + ruby_guestfs_end_busy, 0); + rb_define_method (c_guestfs, "set_memsize", + ruby_guestfs_set_memsize, 1); + rb_define_method (c_guestfs, "get_memsize", + ruby_guestfs_get_memsize, 0); rb_define_method (c_guestfs, "mount", ruby_guestfs_mount, 2); rb_define_method (c_guestfs, "sync", @@ -2156,4 +5113,148 @@ void Init__guestfs () ruby_guestfs_blockdev_flushbufs, 1); rb_define_method (c_guestfs, "blockdev_rereadpt", ruby_guestfs_blockdev_rereadpt, 1); + rb_define_method (c_guestfs, "upload", + ruby_guestfs_upload, 2); + rb_define_method (c_guestfs, "download", + ruby_guestfs_download, 2); + rb_define_method (c_guestfs, "checksum", + ruby_guestfs_checksum, 2); + rb_define_method (c_guestfs, "tar_in", + ruby_guestfs_tar_in, 2); + rb_define_method (c_guestfs, "tar_out", + ruby_guestfs_tar_out, 2); + rb_define_method (c_guestfs, "tgz_in", + ruby_guestfs_tgz_in, 2); + rb_define_method (c_guestfs, "tgz_out", + ruby_guestfs_tgz_out, 2); + rb_define_method (c_guestfs, "mount_ro", + ruby_guestfs_mount_ro, 2); + rb_define_method (c_guestfs, "mount_options", + ruby_guestfs_mount_options, 3); + rb_define_method (c_guestfs, "mount_vfs", + ruby_guestfs_mount_vfs, 4); + rb_define_method (c_guestfs, "debug", + ruby_guestfs_debug, 2); + rb_define_method (c_guestfs, "lvremove", + ruby_guestfs_lvremove, 1); + rb_define_method (c_guestfs, "vgremove", + ruby_guestfs_vgremove, 1); + rb_define_method (c_guestfs, "pvremove", + ruby_guestfs_pvremove, 1); + rb_define_method (c_guestfs, "set_e2label", + ruby_guestfs_set_e2label, 2); + rb_define_method (c_guestfs, "get_e2label", + ruby_guestfs_get_e2label, 1); + rb_define_method (c_guestfs, "set_e2uuid", + ruby_guestfs_set_e2uuid, 2); + rb_define_method (c_guestfs, "get_e2uuid", + ruby_guestfs_get_e2uuid, 1); + rb_define_method (c_guestfs, "fsck", + ruby_guestfs_fsck, 2); + rb_define_method (c_guestfs, "zero", + ruby_guestfs_zero, 1); + rb_define_method (c_guestfs, "grub_install", + ruby_guestfs_grub_install, 2); + rb_define_method (c_guestfs, "cp", + ruby_guestfs_cp, 2); + rb_define_method (c_guestfs, "cp_a", + ruby_guestfs_cp_a, 2); + rb_define_method (c_guestfs, "mv", + ruby_guestfs_mv, 2); + rb_define_method (c_guestfs, "drop_caches", + ruby_guestfs_drop_caches, 1); + rb_define_method (c_guestfs, "dmesg", + ruby_guestfs_dmesg, 0); + rb_define_method (c_guestfs, "ping_daemon", + ruby_guestfs_ping_daemon, 0); + rb_define_method (c_guestfs, "equal", + ruby_guestfs_equal, 2); + rb_define_method (c_guestfs, "strings", + ruby_guestfs_strings, 1); + rb_define_method (c_guestfs, "strings_e", + ruby_guestfs_strings_e, 2); + rb_define_method (c_guestfs, "hexdump", + ruby_guestfs_hexdump, 1); + rb_define_method (c_guestfs, "zerofree", + ruby_guestfs_zerofree, 1); + rb_define_method (c_guestfs, "pvresize", + ruby_guestfs_pvresize, 1); + rb_define_method (c_guestfs, "sfdisk_N", + ruby_guestfs_sfdisk_N, 6); + rb_define_method (c_guestfs, "sfdisk_l", + ruby_guestfs_sfdisk_l, 1); + rb_define_method (c_guestfs, "sfdisk_kernel_geometry", + ruby_guestfs_sfdisk_kernel_geometry, 1); + rb_define_method (c_guestfs, "sfdisk_disk_geometry", + ruby_guestfs_sfdisk_disk_geometry, 1); + rb_define_method (c_guestfs, "vg_activate_all", + ruby_guestfs_vg_activate_all, 1); + rb_define_method (c_guestfs, "vg_activate", + ruby_guestfs_vg_activate, 2); + rb_define_method (c_guestfs, "lvresize", + ruby_guestfs_lvresize, 2); + rb_define_method (c_guestfs, "resize2fs", + ruby_guestfs_resize2fs, 1); + rb_define_method (c_guestfs, "find", + ruby_guestfs_find, 1); + rb_define_method (c_guestfs, "e2fsck_f", + ruby_guestfs_e2fsck_f, 1); + rb_define_method (c_guestfs, "sleep", + ruby_guestfs_sleep, 1); + rb_define_method (c_guestfs, "ntfs_3g_probe", + ruby_guestfs_ntfs_3g_probe, 2); + rb_define_method (c_guestfs, "sh", + ruby_guestfs_sh, 1); + rb_define_method (c_guestfs, "sh_lines", + ruby_guestfs_sh_lines, 1); + rb_define_method (c_guestfs, "glob_expand", + ruby_guestfs_glob_expand, 1); + rb_define_method (c_guestfs, "scrub_device", + ruby_guestfs_scrub_device, 1); + rb_define_method (c_guestfs, "scrub_file", + ruby_guestfs_scrub_file, 1); + rb_define_method (c_guestfs, "scrub_freespace", + ruby_guestfs_scrub_freespace, 1); + rb_define_method (c_guestfs, "mkdtemp", + ruby_guestfs_mkdtemp, 1); + rb_define_method (c_guestfs, "wc_l", + ruby_guestfs_wc_l, 1); + rb_define_method (c_guestfs, "wc_w", + ruby_guestfs_wc_w, 1); + rb_define_method (c_guestfs, "wc_c", + ruby_guestfs_wc_c, 1); + rb_define_method (c_guestfs, "head", + ruby_guestfs_head, 1); + rb_define_method (c_guestfs, "head_n", + ruby_guestfs_head_n, 2); + rb_define_method (c_guestfs, "tail", + ruby_guestfs_tail, 1); + rb_define_method (c_guestfs, "tail_n", + ruby_guestfs_tail_n, 2); + rb_define_method (c_guestfs, "df", + ruby_guestfs_df, 0); + rb_define_method (c_guestfs, "df_h", + ruby_guestfs_df_h, 0); + rb_define_method (c_guestfs, "du", + ruby_guestfs_du, 1); + rb_define_method (c_guestfs, "initrd_list", + ruby_guestfs_initrd_list, 1); + rb_define_method (c_guestfs, "mount_loop", + ruby_guestfs_mount_loop, 2); + rb_define_method (c_guestfs, "mkswap", + ruby_guestfs_mkswap, 1); + rb_define_method (c_guestfs, "mkswap_L", + ruby_guestfs_mkswap_L, 2); + rb_define_method (c_guestfs, "mkswap_U", + ruby_guestfs_mkswap_U, 2); + rb_define_method (c_guestfs, "mknod", + ruby_guestfs_mknod, 4); + rb_define_method (c_guestfs, "mkfifo", + ruby_guestfs_mkfifo, 2); + rb_define_method (c_guestfs, "mknod_b", + ruby_guestfs_mknod_b, 4); + rb_define_method (c_guestfs, "mknod_c", + ruby_guestfs_mknod_c, 4); + rb_define_method (c_guestfs, "umask", + ruby_guestfs_umask, 1); }