#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 */
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");
+ 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; {
+ 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);
+ const char *filein = StringValueCStr (fileinv);
+ if (!filein)
+ rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
+ "filein", "test0");
+ 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");
+ 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)
+ 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)
+ 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_qemu (VALUE gv, VALUE qemuv)
+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_qemu");
+ rb_raise (rb_eArgError, "%s: used handle after closing it", "test0rboolerr");
- 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);
+ 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_qemu (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_qemu");
+ rb_raise (rb_eArgError, "%s: used handle after closing it", "test0rconststring");
+ 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_qemu (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_path (VALUE gv, VALUE pathv)
+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_path");
+ rb_raise (rb_eArgError, "%s: used handle after closing it", "test0rconststringerr");
- const char *path = StringValueCStr (pathv);
- if (!path)
- rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
- "path", "set_path");
- int r;
+ const char *r;
- r = guestfs_set_path (g, path);
- 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_path (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_path");
+ rb_raise (rb_eArgError, "%s: used handle after closing it", "test0rstring");
+ const char *val = StringValueCStr (valv);
+ if (!val)
+ rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
+ "val", "test0rstring");
- const char *r;
+ char *r;
- r = guestfs_get_path (g);
+ r = guestfs_test0rstring (g, val);
if (r == NULL)
rb_raise (e_Error, "%s", guestfs_last_error (g));
- return rb_str_new2 (r);
+ VALUE rv = rb_str_new2 (r);
+ free (r);
+ return rv;
}
-static VALUE ruby_guestfs_set_autosync (VALUE gv, VALUE autosyncv)
+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_autosync");
+ rb_raise (rb_eArgError, "%s: used handle after closing it", "test0rstringerr");
- int autosync = NUM2INT (autosyncv);
- int r;
+ char *r;
- r = guestfs_set_autosync (g, autosync);
- 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_autosync (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_autosync");
+ rb_raise (rb_eArgError, "%s: used handle after closing it", "test0rstringlist");
+ 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_autosync (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_set_verbose (VALUE gv, VALUE verbosev)
+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", "set_verbose");
+ rb_raise (rb_eArgError, "%s: used handle after closing it", "test0rstringlisterr");
- int verbose = NUM2INT (verbosev);
- int r;
+ char **r;
- r = guestfs_set_verbose (g, verbose);
- if (r == -1)
+ r = guestfs_test0rstringlisterr (g);
+ 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_get_verbose (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", "get_verbose");
+ rb_raise (rb_eArgError, "%s: used handle after closing it", "test0rintbool");
+ 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_get_verbose (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_ready (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_ready");
+ rb_raise (rb_eArgError, "%s: used handle after closing it", "test0rintboolerr");
- int r;
+ struct guestfs_int_bool *r;
- r = guestfs_is_ready (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_config (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_config");
+ rb_raise (rb_eArgError, "%s: used handle after closing it", "test0rpvlist");
+ 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_config (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_is_launching (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", "is_launching");
+ rb_raise (rb_eArgError, "%s: used handle after closing it", "test0rpvlisterr");
- int r;
+ struct guestfs_lvm_pv_list *r;
- r = guestfs_is_launching (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_is_busy (VALUE gv)
+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", "is_busy");
+ rb_raise (rb_eArgError, "%s: used handle after closing it", "test0rvglist");
+ const char *val = StringValueCStr (valv);
+ if (!val)
+ rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
+ "val", "test0rvglist");
- int r;
+ struct guestfs_lvm_vg_list *r;
- r = guestfs_is_busy (g);
- if (r == -1)
+ r = guestfs_test0rvglist (g, val);
+ if (r == NULL)
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");
+ 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");
+
+ 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");
+
+ 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");
+
+ 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");
+
+ 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");
+
+ 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");
+
+ 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");
+
+ 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");
+
+ 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");
+
+ 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");
+
+ 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");
+
+ 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_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");
+
+ 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)
+ 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");
+
+ 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");
+
+ 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");
+
+ 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");
+
+ 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");
+
+ 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");
+ 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_get_state (g);
+ r = guestfs_aug_init (g, root, flags);
if (r == -1)
rb_raise (e_Error, "%s", guestfs_last_error (g));
- return INT2NUM (r);
+ return Qnil;
}
-static VALUE ruby_guestfs_set_busy (VALUE gv)
+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", "set_busy");
+ rb_raise (rb_eArgError, "%s: used handle after closing it", "aug_close");
int r;
- r = guestfs_set_busy (g);
+ r = guestfs_aug_close (g);
if (r == -1)
rb_raise (e_Error, "%s", guestfs_last_error (g));
return Qnil;
}
-static VALUE ruby_guestfs_set_ready (VALUE gv)
+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", "set_ready");
+ rb_raise (rb_eArgError, "%s: used handle after closing it", "aug_defvar");
+ 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_set_ready (g);
+ r = guestfs_aug_defvar (g, name, expr);
if (r == -1)
rb_raise (e_Error, "%s", guestfs_last_error (g));
- return Qnil;
+ return INT2NUM (r);
}
-static VALUE ruby_guestfs_mount (VALUE gv, VALUE devicev, VALUE mountpointv)
+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", "mount");
+ rb_raise (rb_eArgError, "%s: used handle after closing it", "aug_defnode");
- const char *device = StringValueCStr (devicev);
- if (!device)
+ const char *name = StringValueCStr (namev);
+ if (!name)
rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
- "device", "mount");
- const char *mountpoint = StringValueCStr (mountpointv);
- if (!mountpoint)
+ "name", "aug_defnode");
+ const char *expr = StringValueCStr (exprv);
+ if (!expr)
rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
- "mountpoint", "mount");
+ "expr", "aug_defnode");
+ const char *val = StringValueCStr (valv);
+ if (!val)
+ rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
+ "val", "aug_defnode");
- int r;
+ struct guestfs_int_bool *r;
- r = guestfs_mount (g, device, mountpoint);
- if (r == -1)
+ r = guestfs_aug_defnode (g, name, expr, val);
+ if (r == NULL)
rb_raise (e_Error, "%s", guestfs_last_error (g));
- return Qnil;
+ 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_sync (VALUE gv)
+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", "sync");
+ rb_raise (rb_eArgError, "%s: used handle after closing it", "aug_get");
+
+ 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");
+ 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_sync (g);
+ 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_touch (VALUE gv, VALUE pathv)
+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", "touch");
+ rb_raise (rb_eArgError, "%s: used handle after closing it", "aug_insert");
const char *path = StringValueCStr (pathv);
if (!path)
rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
- "path", "touch");
+ "path", "aug_insert");
+ 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_touch (g, path);
+ 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_cat (VALUE gv, VALUE pathv)
+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", "cat");
+ rb_raise (rb_eArgError, "%s: used handle after closing it", "aug_rm");
const char *path = StringValueCStr (pathv);
if (!path)
rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
- "path", "cat");
+ "path", "aug_rm");
- char *r;
+ int r;
- r = guestfs_cat (g, path);
- if (r == NULL)
+ r = guestfs_aug_rm (g, path);
+ if (r == -1)
rb_raise (e_Error, "%s", guestfs_last_error (g));
- VALUE rv = rb_str_new2 (r);
- free (r);
- return rv;
+ return INT2NUM (r);
}
-static VALUE ruby_guestfs_ll (VALUE gv, VALUE directoryv)
+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", "ll");
+ rb_raise (rb_eArgError, "%s: used handle after closing it", "aug_mv");
- const char *directory = StringValueCStr (directoryv);
- if (!directory)
+ const char *src = StringValueCStr (srcv);
+ if (!src)
rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
- "directory", "ll");
+ "src", "aug_mv");
+ const char *dest = StringValueCStr (destv);
+ if (!dest)
+ rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
+ "dest", "aug_mv");
- char *r;
+ int r;
- r = guestfs_ll (g, directory);
- if (r == NULL)
+ r = guestfs_aug_mv (g, src, dest);
+ 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_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", "ls");
+ rb_raise (rb_eArgError, "%s: used handle after closing it", "aug_match");
- const char *directory = StringValueCStr (directoryv);
- if (!directory)
+ const char *path = StringValueCStr (pathv);
+ if (!path)
rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
- "directory", "ls");
+ "path", "aug_match");
char **r;
- r = guestfs_ls (g, directory);
+ r = guestfs_aug_match (g, path);
if (r == NULL)
rb_raise (e_Error, "%s", guestfs_last_error (g));
return rv;
}
-static VALUE ruby_guestfs_list_devices (VALUE gv)
+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", "list_devices");
+ rb_raise (rb_eArgError, "%s: used handle after closing it", "aug_save");
- char **r;
+ int r;
- r = guestfs_list_devices (g);
- if (r == NULL)
+ r = guestfs_aug_save (g);
+ 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_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", "list_partitions");
+ rb_raise (rb_eArgError, "%s: used handle after closing it", "aug_load");
- char **r;
+ int r;
- r = guestfs_list_partitions (g);
- if (r == NULL)
+ r = guestfs_aug_load (g);
+ 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_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", "pvs");
+ rb_raise (rb_eArgError, "%s: used handle after closing it", "aug_ls");
+ 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_pvs (g);
+ r = guestfs_aug_ls (g, path);
if (r == NULL)
rb_raise (e_Error, "%s", guestfs_last_error (g));
return rv;
}
-static VALUE ruby_guestfs_vgs (VALUE gv)
+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");
+
+ 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");
+
+ 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", "vgs");
+ rb_raise (rb_eArgError, "%s: used handle after closing it", "rm_rf");
+ const char *path = StringValueCStr (pathv);
+ if (!path)
+ rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
+ "path", "rm_rf");
- char **r;
+ int r;
- r = guestfs_vgs (g);
- if (r == NULL)
+ r = guestfs_rm_rf (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 Qnil;
}
-static VALUE ruby_guestfs_lvs (VALUE gv)
+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", "lvs");
+ rb_raise (rb_eArgError, "%s: used handle after closing it", "mkdir");
+ const char *path = StringValueCStr (pathv);
+ if (!path)
+ rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
+ "path", "mkdir");
- char **r;
+ int r;
- r = guestfs_lvs (g);
- if (r == NULL)
+ r = guestfs_mkdir (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 Qnil;
}
-static VALUE ruby_guestfs_pvs_full (VALUE gv)
+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", "pvs_full");
+ rb_raise (rb_eArgError, "%s: used handle after closing it", "mkdir_p");
+ const char *path = StringValueCStr (pathv);
+ if (!path)
+ rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
+ "path", "mkdir_p");
- struct guestfs_lvm_pv_list *r;
+ int r;
- r = guestfs_pvs_full (g);
- if (r == NULL)
+ r = guestfs_mkdir_p (g, path);
+ 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_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", "vgs_full");
+ rb_raise (rb_eArgError, "%s: used handle after closing it", "chmod");
+ int mode = NUM2INT (modev);
+ const char *path = StringValueCStr (pathv);
+ if (!path)
+ rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
+ "path", "chmod");
- struct guestfs_lvm_vg_list *r;
+ int r;
- r = guestfs_vgs_full (g);
- if (r == NULL)
+ r = guestfs_chmod (g, mode, path);
+ 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 ("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;
+ return Qnil;
}
-static VALUE ruby_guestfs_lvs_full (VALUE gv)
+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", "lvs_full");
+ rb_raise (rb_eArgError, "%s: used handle after closing it", "chown");
+ int owner = NUM2INT (ownerv);
+ int group = NUM2INT (groupv);
+ const char *path = StringValueCStr (pathv);
+ if (!path)
+ rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
+ "path", "chown");
- struct guestfs_lvm_lv_list *r;
+ int r;
- r = guestfs_lvs_full (g);
- if (r == NULL)
+ r = guestfs_chown (g, owner, group, path);
+ 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 ("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;
+ return Qnil;
}
-static VALUE ruby_guestfs_read_lines (VALUE gv, VALUE pathv)
+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", "read_lines");
+ rb_raise (rb_eArgError, "%s: used handle after closing it", "exists");
const char *path = StringValueCStr (pathv);
if (!path)
rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
- "path", "read_lines");
+ "path", "exists");
- char **r;
+ int r;
- r = guestfs_read_lines (g, path);
- if (r == NULL)
+ r = guestfs_exists (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_aug_init (VALUE gv, VALUE rootv, VALUE flagsv)
+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", "aug_init");
+ rb_raise (rb_eArgError, "%s: used handle after closing it", "is_file");
- const char *root = StringValueCStr (rootv);
- if (!root)
+ const char *path = StringValueCStr (pathv);
+ if (!path)
rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
- "root", "aug_init");
- int flags = NUM2INT (flagsv);
+ "path", "is_file");
int r;
- r = guestfs_aug_init (g, root, flags);
+ r = guestfs_is_file (g, path);
if (r == -1)
rb_raise (e_Error, "%s", guestfs_last_error (g));
- return Qnil;
+ return INT2NUM (r);
}
-static VALUE ruby_guestfs_aug_close (VALUE gv)
+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", "aug_close");
+ rb_raise (rb_eArgError, "%s: used handle after closing it", "is_dir");
+ 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_aug_close (g);
+ r = guestfs_is_dir (g, path);
if (r == -1)
rb_raise (e_Error, "%s", guestfs_last_error (g));
- return Qnil;
+ return INT2NUM (r);
}
-static VALUE ruby_guestfs_aug_defvar (VALUE gv, VALUE namev, VALUE exprv)
+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", "aug_defvar");
+ rb_raise (rb_eArgError, "%s: used handle after closing it", "pvcreate");
- const char *name = StringValueCStr (namev);
- if (!name)
+ const char *device = StringValueCStr (devicev);
+ if (!device)
rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
- "name", "aug_defvar");
- const char *expr = StringValueCStr (exprv);
+ "device", "pvcreate");
int r;
- r = guestfs_aug_defvar (g, name, expr);
+ r = guestfs_pvcreate (g, device);
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_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", "aug_defnode");
+ rb_raise (rb_eArgError, "%s: used handle after closing it", "vgcreate");
- 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)
- rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
- "expr", "aug_defnode");
- const char *val = StringValueCStr (valv);
- if (!val)
+ const char *volgroup = StringValueCStr (volgroupv);
+ if (!volgroup)
rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
- "val", "aug_defnode");
+ "volgroup", "vgcreate");
+ char **physvols; {
+ 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;
+ }
- struct guestfs_int_bool *r;
+ int r;
- r = guestfs_aug_defnode (g, name, expr, val);
- if (r == NULL)
+ r = guestfs_vgcreate (g, volgroup, physvols);
+ free (physvols);
+ 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_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", "aug_get");
+ rb_raise (rb_eArgError, "%s: used handle after closing it", "lvcreate");
- const char *path = StringValueCStr (pathv);
- if (!path)
+ const char *logvol = StringValueCStr (logvolv);
+ if (!logvol)
rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
- "path", "aug_get");
+ "logvol", "lvcreate");
+ const char *volgroup = StringValueCStr (volgroupv);
+ if (!volgroup)
+ rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
+ "volgroup", "lvcreate");
+ int mbytes = NUM2INT (mbytesv);
- char *r;
+ int r;
- r = guestfs_aug_get (g, path);
- if (r == NULL)
+ r = guestfs_lvcreate (g, logvol, volgroup, mbytes);
+ 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_aug_set (VALUE gv, VALUE pathv, VALUE valv)
+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", "aug_set");
+ rb_raise (rb_eArgError, "%s: used handle after closing it", "mkfs");
- const char *path = StringValueCStr (pathv);
- if (!path)
+ const char *fstype = StringValueCStr (fstypev);
+ if (!fstype)
rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
- "path", "aug_set");
- const char *val = StringValueCStr (valv);
- if (!val)
+ "fstype", "mkfs");
+ const char *device = StringValueCStr (devicev);
+ if (!device)
rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
- "val", "aug_set");
+ "device", "mkfs");
int r;
- r = guestfs_aug_set (g, path, val);
+ r = guestfs_mkfs (g, fstype, device);
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_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", "aug_insert");
+ rb_raise (rb_eArgError, "%s: used handle after closing it", "sfdisk");
- const char *path = StringValueCStr (pathv);
- if (!path)
- rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
- "path", "aug_insert");
- const char *label = StringValueCStr (labelv);
- if (!label)
+ const char *device = StringValueCStr (devicev);
+ if (!device)
rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
- "label", "aug_insert");
- int before = NUM2INT (beforev);
+ "device", "sfdisk");
+ int cyls = NUM2INT (cylsv);
+ int heads = NUM2INT (headsv);
+ int sectors = NUM2INT (sectorsv);
+ char **lines; {
+ 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_aug_insert (g, path, label, before);
+ 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_aug_rm (VALUE gv, VALUE pathv)
+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", "aug_rm");
+ rb_raise (rb_eArgError, "%s: used handle after closing it", "write_file");
const char *path = StringValueCStr (pathv);
if (!path)
rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
- "path", "aug_rm");
+ "path", "write_file");
+ 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_aug_rm (g, path);
+ r = guestfs_write_file (g, path, content, size);
if (r == -1)
rb_raise (e_Error, "%s", guestfs_last_error (g));
- return INT2NUM (r);
+ return Qnil;
}
-static VALUE ruby_guestfs_aug_mv (VALUE gv, VALUE srcv, VALUE destv)
+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", "aug_mv");
+ rb_raise (rb_eArgError, "%s: used handle after closing it", "umount");
- const char *src = StringValueCStr (srcv);
- if (!src)
- rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
- "src", "aug_mv");
- const char *dest = StringValueCStr (destv);
- if (!dest)
+ const char *pathordevice = StringValueCStr (pathordevicev);
+ if (!pathordevice)
rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
- "dest", "aug_mv");
+ "pathordevice", "umount");
int r;
- r = guestfs_aug_mv (g, src, dest);
+ r = guestfs_umount (g, pathordevice);
if (r == -1)
rb_raise (e_Error, "%s", guestfs_last_error (g));
return Qnil;
}
-static VALUE ruby_guestfs_aug_match (VALUE gv, VALUE pathv)
+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", "aug_match");
+ rb_raise (rb_eArgError, "%s: used handle after closing it", "mounts");
- 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);
+ r = guestfs_mounts (g);
if (r == NULL)
rb_raise (e_Error, "%s", guestfs_last_error (g));
return rv;
}
-static VALUE ruby_guestfs_aug_save (VALUE gv)
+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", "aug_save");
+ rb_raise (rb_eArgError, "%s: used handle after closing it", "umount_all");
int r;
- r = guestfs_aug_save (g);
+ r = guestfs_umount_all (g);
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_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", "aug_load");
+ rb_raise (rb_eArgError, "%s: used handle after closing it", "lvm_remove_all");
int r;
- r = guestfs_aug_load (g);
+ r = guestfs_lvm_remove_all (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)
+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", "aug_ls");
+ rb_raise (rb_eArgError, "%s: used handle after closing it", "file");
const char *path = StringValueCStr (pathv);
if (!path)
rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
- "path", "aug_ls");
+ "path", "file");
- char **r;
+ char *r;
- r = guestfs_aug_ls (g, path);
+ r = guestfs_file (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_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; {
+ 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_rm (VALUE gv, VALUE pathv)
+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", "rm");
+ rb_raise (rb_eArgError, "%s: used handle after closing it", "command_lines");
- const char *path = StringValueCStr (pathv);
- if (!path)
- rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
- "path", "rm");
+ char **arguments; {
+ 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;
+ }
- int r;
+ char **r;
- r = guestfs_rm (g, path);
- if (r == -1)
+ r = guestfs_command_lines (g, arguments);
+ free (arguments);
+ 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_rmdir (VALUE gv, VALUE pathv)
+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", "rmdir");
+ rb_raise (rb_eArgError, "%s: used handle after closing it", "stat");
const char *path = StringValueCStr (pathv);
if (!path)
rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
- "path", "rmdir");
+ "path", "stat");
- int r;
+ struct guestfs_stat *r;
- r = guestfs_rmdir (g, path);
- if (r == -1)
+ r = guestfs_stat (g, path);
+ if (r == NULL)
rb_raise (e_Error, "%s", guestfs_last_error (g));
- return Qnil;
+ 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_rm_rf (VALUE gv, VALUE pathv)
+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", "rm_rf");
+ rb_raise (rb_eArgError, "%s: used handle after closing it", "lstat");
const char *path = StringValueCStr (pathv);
if (!path)
rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
- "path", "rm_rf");
+ "path", "lstat");
- int r;
+ struct guestfs_stat *r;
- r = guestfs_rm_rf (g, path);
- if (r == -1)
+ r = guestfs_lstat (g, path);
+ if (r == NULL)
rb_raise (e_Error, "%s", guestfs_last_error (g));
- return Qnil;
+ 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_mkdir (VALUE gv, VALUE pathv)
+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", "mkdir");
+ rb_raise (rb_eArgError, "%s: used handle after closing it", "statvfs");
const char *path = StringValueCStr (pathv);
if (!path)
rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
- "path", "mkdir");
+ "path", "statvfs");
- int r;
+ struct guestfs_statvfs *r;
- r = guestfs_mkdir (g, path);
- if (r == -1)
+ r = guestfs_statvfs (g, path);
+ if (r == NULL)
rb_raise (e_Error, "%s", guestfs_last_error (g));
- return Qnil;
+ 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_mkdir_p (VALUE gv, VALUE pathv)
+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", "mkdir_p");
+ rb_raise (rb_eArgError, "%s: used handle after closing it", "tune2fs_l");
- const char *path = StringValueCStr (pathv);
- if (!path)
+ const char *device = StringValueCStr (devicev);
+ if (!device)
rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
- "path", "mkdir_p");
+ "device", "tune2fs_l");
- int r;
+ char **r;
- r = guestfs_mkdir_p (g, path);
- if (r == -1)
+ r = guestfs_tune2fs_l (g, device);
+ if (r == NULL)
rb_raise (e_Error, "%s", guestfs_last_error (g));
- return Qnil;
+ 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_chmod (VALUE gv, VALUE modev, VALUE pathv)
+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", "chmod");
+ rb_raise (rb_eArgError, "%s: used handle after closing it", "blockdev_setro");
- int mode = NUM2INT (modev);
- const char *path = StringValueCStr (pathv);
- if (!path)
+ const char *device = StringValueCStr (devicev);
+ if (!device)
rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
- "path", "chmod");
+ "device", "blockdev_setro");
int r;
- r = guestfs_chmod (g, mode, path);
+ r = guestfs_blockdev_setro (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_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", "chown");
+ rb_raise (rb_eArgError, "%s: used handle after closing it", "blockdev_setrw");
- int owner = NUM2INT (ownerv);
- int group = NUM2INT (groupv);
- const char *path = StringValueCStr (pathv);
- if (!path)
+ const char *device = StringValueCStr (devicev);
+ if (!device)
rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
- "path", "chown");
+ "device", "blockdev_setrw");
int r;
- r = guestfs_chown (g, owner, group, path);
+ r = guestfs_blockdev_setrw (g, device);
if (r == -1)
rb_raise (e_Error, "%s", guestfs_last_error (g));
return Qnil;
}
-static VALUE ruby_guestfs_exists (VALUE gv, VALUE pathv)
+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", "exists");
+ rb_raise (rb_eArgError, "%s: used handle after closing it", "blockdev_getro");
- const char *path = StringValueCStr (pathv);
- if (!path)
+ const char *device = StringValueCStr (devicev);
+ if (!device)
rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
- "path", "exists");
+ "device", "blockdev_getro");
int r;
- r = guestfs_exists (g, path);
+ 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_is_file (VALUE gv, VALUE pathv)
+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", "is_file");
+ rb_raise (rb_eArgError, "%s: used handle after closing it", "blockdev_getss");
- const char *path = StringValueCStr (pathv);
- if (!path)
+ const char *device = StringValueCStr (devicev);
+ if (!device)
rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
- "path", "is_file");
+ "device", "blockdev_getss");
int r;
- r = guestfs_is_file (g, path);
+ 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_is_dir (VALUE gv, VALUE pathv)
+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", "is_dir");
+ rb_raise (rb_eArgError, "%s: used handle after closing it", "blockdev_getbsz");
- const char *path = StringValueCStr (pathv);
- if (!path)
+ const char *device = StringValueCStr (devicev);
+ if (!device)
rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
- "path", "is_dir");
+ "device", "blockdev_getbsz");
int r;
- r = guestfs_is_dir (g, path);
+ 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_pvcreate (VALUE gv, VALUE devicev)
+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", "pvcreate");
+ rb_raise (rb_eArgError, "%s: used handle after closing it", "blockdev_setbsz");
const char *device = StringValueCStr (devicev);
if (!device)
rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
- "device", "pvcreate");
+ "device", "blockdev_setbsz");
+ int blocksize = NUM2INT (blocksizev);
int r;
- r = guestfs_pvcreate (g, device);
+ 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_vgcreate (VALUE gv, VALUE volgroupv, VALUE physvolsv)
+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", "vgcreate");
+ rb_raise (rb_eArgError, "%s: used handle after closing it", "blockdev_getsz");
- const char *volgroup = StringValueCStr (volgroupv);
- if (!volgroup)
+ const char *device = StringValueCStr (devicev);
+ if (!device)
rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
- "volgroup", "vgcreate");
- char **physvols; {
- 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;
- }
+ "device", "blockdev_getsz");
- int r;
+ int64_t r;
- r = guestfs_vgcreate (g, volgroup, physvols);
- free (physvols);
+ r = guestfs_blockdev_getsz (g, device);
if (r == -1)
rb_raise (e_Error, "%s", guestfs_last_error (g));
- return Qnil;
+ return ULL2NUM (r);
}
-static VALUE ruby_guestfs_lvcreate (VALUE gv, VALUE logvolv, VALUE volgroupv, VALUE mbytesv)
+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", "lvcreate");
+ rb_raise (rb_eArgError, "%s: used handle after closing it", "blockdev_getsize64");
- 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)
+ const char *device = StringValueCStr (devicev);
+ if (!device)
rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
- "volgroup", "lvcreate");
- int mbytes = NUM2INT (mbytesv);
+ "device", "blockdev_getsize64");
- int r;
+ int64_t r;
- r = guestfs_lvcreate (g, logvol, volgroup, mbytes);
+ r = guestfs_blockdev_getsize64 (g, device);
if (r == -1)
rb_raise (e_Error, "%s", guestfs_last_error (g));
- return Qnil;
+ return ULL2NUM (r);
}
-static VALUE ruby_guestfs_mkfs (VALUE gv, VALUE fstypev, VALUE devicev)
+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", "mkfs");
+ rb_raise (rb_eArgError, "%s: used handle after closing it", "blockdev_flushbufs");
- const char *fstype = StringValueCStr (fstypev);
- if (!fstype)
- rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
- "fstype", "mkfs");
const char *device = StringValueCStr (devicev);
if (!device)
rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
- "device", "mkfs");
+ "device", "blockdev_flushbufs");
int r;
- r = guestfs_mkfs (g, fstype, device);
+ r = guestfs_blockdev_flushbufs (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_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", "sfdisk");
+ rb_raise (rb_eArgError, "%s: used handle after closing it", "blockdev_rereadpt");
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; {
- 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;
- }
+ "device", "blockdev_rereadpt");
int r;
- r = guestfs_sfdisk (g, device, cyls, heads, sectors, lines);
- free (lines);
+ r = guestfs_blockdev_rereadpt (g, device);
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_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", "write_file");
+ rb_raise (rb_eArgError, "%s: used handle after closing it", "upload");
- const char *path = StringValueCStr (pathv);
- if (!path)
+ const char *filename = StringValueCStr (filenamev);
+ if (!filename)
rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
- "path", "write_file");
- const char *content = StringValueCStr (contentv);
- if (!content)
+ "filename", "upload");
+ const char *remotefilename = StringValueCStr (remotefilenamev);
+ if (!remotefilename)
rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
- "content", "write_file");
- int size = NUM2INT (sizev);
+ "remotefilename", "upload");
int r;
- r = guestfs_write_file (g, path, content, size);
+ r = guestfs_upload (g, filename, remotefilename);
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_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", "umount");
+ rb_raise (rb_eArgError, "%s: used handle after closing it", "download");
- const char *pathordevice = StringValueCStr (pathordevicev);
- if (!pathordevice)
+ const char *remotefilename = StringValueCStr (remotefilenamev);
+ if (!remotefilename)
rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
- "pathordevice", "umount");
+ "remotefilename", "download");
+ const char *filename = StringValueCStr (filenamev);
+ if (!filename)
+ rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
+ "filename", "download");
int r;
- r = guestfs_umount (g, pathordevice);
+ r = guestfs_download (g, remotefilename, filename);
if (r == -1)
rb_raise (e_Error, "%s", guestfs_last_error (g));
return Qnil;
}
-static VALUE ruby_guestfs_mounts (VALUE gv)
+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", "mounts");
+ rb_raise (rb_eArgError, "%s: used handle after closing it", "checksum");
+ const char *csumtype = StringValueCStr (csumtypev);
+ if (!csumtype)
+ rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
+ "csumtype", "checksum");
+ const char *path = StringValueCStr (pathv);
+ if (!path)
+ rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
+ "path", "checksum");
- char **r;
+ char *r;
- r = guestfs_mounts (g);
+ r = guestfs_checksum (g, csumtype, 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_umount_all (VALUE gv)
+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", "umount_all");
+ rb_raise (rb_eArgError, "%s: used handle after closing it", "tar_in");
+ const char *tarfile = StringValueCStr (tarfilev);
+ if (!tarfile)
+ rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
+ "tarfile", "tar_in");
+ 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_umount_all (g);
+ 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_lvm_remove_all (VALUE gv)
+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", "lvm_remove_all");
+ rb_raise (rb_eArgError, "%s: used handle after closing it", "tar_out");
+ const char *directory = StringValueCStr (directoryv);
+ if (!directory)
+ rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
+ "directory", "tar_out");
+ 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_lvm_remove_all (g);
+ 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_file (VALUE gv, VALUE pathv)
+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", "file");
+ rb_raise (rb_eArgError, "%s: used handle after closing it", "tgz_in");
- const char *path = StringValueCStr (pathv);
- if (!path)
+ const char *tarball = StringValueCStr (tarballv);
+ if (!tarball)
rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
- "path", "file");
+ "tarball", "tgz_in");
+ const char *directory = StringValueCStr (directoryv);
+ if (!directory)
+ rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
+ "directory", "tgz_in");
- char *r;
+ int r;
- r = guestfs_file (g, path);
- if (r == NULL)
+ r = guestfs_tgz_in (g, tarball, directory);
+ 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_command (VALUE gv, VALUE argumentsv)
+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", "command");
+ rb_raise (rb_eArgError, "%s: used handle after closing it", "tgz_out");
- char **arguments; {
- 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;
- }
+ const char *directory = StringValueCStr (directoryv);
+ if (!directory)
+ rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
+ "directory", "tgz_out");
+ const char *tarball = StringValueCStr (tarballv);
+ if (!tarball)
+ rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
+ "tarball", "tgz_out");
- char *r;
+ int r;
- r = guestfs_command (g, arguments);
- free (arguments);
- if (r == NULL)
+ r = guestfs_tgz_out (g, directory, tarball);
+ 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_command_lines (VALUE gv, VALUE argumentsv)
+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", "command_lines");
+ rb_raise (rb_eArgError, "%s: used handle after closing it", "mount_ro");
- char **arguments; {
- 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;
- }
+ const char *device = StringValueCStr (devicev);
+ if (!device)
+ rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
+ "device", "mount_ro");
+ const char *mountpoint = StringValueCStr (mountpointv);
+ if (!mountpoint)
+ rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
+ "mountpoint", "mount_ro");
- char **r;
+ int r;
- r = guestfs_command_lines (g, arguments);
- free (arguments);
- if (r == NULL)
+ r = guestfs_mount_ro (g, device, mountpoint);
+ 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_stat (VALUE gv, VALUE pathv)
+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", "stat");
+ rb_raise (rb_eArgError, "%s: used handle after closing it", "mount_options");
- const char *path = StringValueCStr (pathv);
- if (!path)
+ const char *options = StringValueCStr (optionsv);
+ if (!options)
rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
- "path", "stat");
+ "options", "mount_options");
+ const char *device = StringValueCStr (devicev);
+ if (!device)
+ rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
+ "device", "mount_options");
+ const char *mountpoint = StringValueCStr (mountpointv);
+ if (!mountpoint)
+ rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
+ "mountpoint", "mount_options");
- struct guestfs_stat *r;
+ int r;
- r = guestfs_stat (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_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;
+ return Qnil;
}
-static VALUE ruby_guestfs_lstat (VALUE gv, VALUE pathv)
+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", "lstat");
+ rb_raise (rb_eArgError, "%s: used handle after closing it", "mount_vfs");
- const char *path = StringValueCStr (pathv);
- if (!path)
+ const char *options = StringValueCStr (optionsv);
+ if (!options)
rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
- "path", "lstat");
-
- struct guestfs_stat *r;
+ "options", "mount_vfs");
+ const char *vfstype = StringValueCStr (vfstypev);
+ if (!vfstype)
+ rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
+ "vfstype", "mount_vfs");
+ const char *device = StringValueCStr (devicev);
+ if (!device)
+ rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
+ "device", "mount_vfs");
+ const char *mountpoint = StringValueCStr (mountpointv);
+ if (!mountpoint)
+ rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
+ "mountpoint", "mount_vfs");
- r = guestfs_lstat (g, path);
- if (r == NULL)
- rb_raise (e_Error, "%s", guestfs_last_error (g));
+ int r;
- 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;
+ r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint);
+ if (r == -1)
+ rb_raise (e_Error, "%s", guestfs_last_error (g));
+
+ return Qnil;
}
-static VALUE ruby_guestfs_statvfs (VALUE gv, VALUE pathv)
+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", "statvfs");
+ rb_raise (rb_eArgError, "%s: used handle after closing it", "debug");
- const char *path = StringValueCStr (pathv);
- if (!path)
+ const char *subcmd = StringValueCStr (subcmdv);
+ if (!subcmd)
rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
- "path", "statvfs");
+ "subcmd", "debug");
+ char **extraargs; {
+ 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;
+ }
- struct guestfs_statvfs *r;
+ char *r;
- r = guestfs_statvfs (g, path);
+ r = guestfs_debug (g, subcmd, extraargs);
+ free (extraargs);
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_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", "tune2fs_l");
+ rb_raise (rb_eArgError, "%s: used handle after closing it", "lvremove");
const char *device = StringValueCStr (devicev);
if (!device)
rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
- "device", "tune2fs_l");
+ "device", "lvremove");
- char **r;
+ int r;
- r = guestfs_tune2fs_l (g, device);
- if (r == NULL)
+ r = guestfs_lvremove (g, device);
+ 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 Qnil;
}
-static VALUE ruby_guestfs_blockdev_setro (VALUE gv, VALUE devicev)
+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", "blockdev_setro");
+ rb_raise (rb_eArgError, "%s: used handle after closing it", "vgremove");
- const char *device = StringValueCStr (devicev);
- if (!device)
+ const char *vgname = StringValueCStr (vgnamev);
+ if (!vgname)
rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
- "device", "blockdev_setro");
+ "vgname", "vgremove");
int r;
- r = guestfs_blockdev_setro (g, device);
+ r = guestfs_vgremove (g, vgname);
if (r == -1)
rb_raise (e_Error, "%s", guestfs_last_error (g));
return Qnil;
}
-static VALUE ruby_guestfs_blockdev_setrw (VALUE gv, VALUE devicev)
+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", "blockdev_setrw");
+ rb_raise (rb_eArgError, "%s: used handle after closing it", "pvremove");
const char *device = StringValueCStr (devicev);
if (!device)
rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
- "device", "blockdev_setrw");
+ "device", "pvremove");
int r;
- r = guestfs_blockdev_setrw (g, device);
+ r = guestfs_pvremove (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)
+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", "blockdev_getro");
+ rb_raise (rb_eArgError, "%s: used handle after closing it", "set_e2label");
const char *device = StringValueCStr (devicev);
if (!device)
rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
- "device", "blockdev_getro");
+ "device", "set_e2label");
+ const char *label = StringValueCStr (labelv);
+ if (!label)
+ rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
+ "label", "set_e2label");
int r;
- r = guestfs_blockdev_getro (g, device);
+ r = guestfs_set_e2label (g, device, label);
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_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", "blockdev_getss");
+ rb_raise (rb_eArgError, "%s: used handle after closing it", "get_e2label");
const char *device = StringValueCStr (devicev);
if (!device)
rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
- "device", "blockdev_getss");
+ "device", "get_e2label");
- int r;
+ char *r;
- r = guestfs_blockdev_getss (g, device);
- if (r == -1)
+ r = guestfs_get_e2label (g, device);
+ 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_blockdev_getbsz (VALUE gv, VALUE devicev)
+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", "blockdev_getbsz");
+ rb_raise (rb_eArgError, "%s: used handle after closing it", "set_e2uuid");
const char *device = StringValueCStr (devicev);
if (!device)
rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
- "device", "blockdev_getbsz");
+ "device", "set_e2uuid");
+ const char *uuid = StringValueCStr (uuidv);
+ if (!uuid)
+ rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
+ "uuid", "set_e2uuid");
int r;
- r = guestfs_blockdev_getbsz (g, device);
+ r = guestfs_set_e2uuid (g, device, uuid);
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_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", "blockdev_setbsz");
+ rb_raise (rb_eArgError, "%s: used handle after closing it", "get_e2uuid");
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);
+ "device", "get_e2uuid");
- int r;
+ char *r;
- r = guestfs_blockdev_setbsz (g, device, blocksize);
- if (r == -1)
+ r = guestfs_get_e2uuid (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_blockdev_getsz (VALUE gv, VALUE devicev)
+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", "blockdev_getsz");
+ rb_raise (rb_eArgError, "%s: used handle after closing it", "fsck");
+ const char *fstype = StringValueCStr (fstypev);
+ if (!fstype)
+ rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
+ "fstype", "fsck");
const char *device = StringValueCStr (devicev);
if (!device)
rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
- "device", "blockdev_getsz");
+ "device", "fsck");
- int64_t r;
+ int r;
- r = guestfs_blockdev_getsz (g, device);
+ r = guestfs_fsck (g, fstype, device);
if (r == -1)
rb_raise (e_Error, "%s", guestfs_last_error (g));
- return ULL2NUM (r);
+ return INT2NUM (r);
}
-static VALUE ruby_guestfs_blockdev_getsize64 (VALUE gv, VALUE devicev)
+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", "blockdev_getsize64");
+ rb_raise (rb_eArgError, "%s: used handle after closing it", "zero");
const char *device = StringValueCStr (devicev);
if (!device)
rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
- "device", "blockdev_getsize64");
+ "device", "zero");
- int64_t r;
+ int r;
- r = guestfs_blockdev_getsize64 (g, device);
+ r = guestfs_zero (g, device);
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_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", "blockdev_flushbufs");
+ rb_raise (rb_eArgError, "%s: used handle after closing it", "grub_install");
+ const char *root = StringValueCStr (rootv);
+ if (!root)
+ rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
+ "root", "grub_install");
const char *device = StringValueCStr (devicev);
if (!device)
rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
- "device", "blockdev_flushbufs");
+ "device", "grub_install");
int r;
- r = guestfs_blockdev_flushbufs (g, device);
+ 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_blockdev_rereadpt (VALUE gv, VALUE devicev)
+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", "blockdev_rereadpt");
+ rb_raise (rb_eArgError, "%s: used handle after closing it", "cp");
- const char *device = StringValueCStr (devicev);
- if (!device)
+ const char *src = StringValueCStr (srcv);
+ if (!src)
rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
- "device", "blockdev_rereadpt");
+ "src", "cp");
+ const char *dest = StringValueCStr (destv);
+ if (!dest)
+ rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
+ "dest", "cp");
int r;
- r = guestfs_blockdev_rereadpt (g, device);
+ r = guestfs_cp (g, src, dest);
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)
+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", "upload");
+ rb_raise (rb_eArgError, "%s: used handle after closing it", "cp_a");
- const char *filename = StringValueCStr (filenamev);
- if (!filename)
+ const char *src = StringValueCStr (srcv);
+ if (!src)
rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
- "filename", "upload");
- const char *remotefilename = StringValueCStr (remotefilenamev);
- if (!remotefilename)
+ "src", "cp_a");
+ const char *dest = StringValueCStr (destv);
+ if (!dest)
rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
- "remotefilename", "upload");
+ "dest", "cp_a");
int r;
- r = guestfs_upload (g, filename, remotefilename);
+ r = guestfs_cp_a (g, src, dest);
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)
+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", "download");
+ rb_raise (rb_eArgError, "%s: used handle after closing it", "mv");
- const char *remotefilename = StringValueCStr (remotefilenamev);
- if (!remotefilename)
+ const char *src = StringValueCStr (srcv);
+ if (!src)
rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
- "remotefilename", "download");
- const char *filename = StringValueCStr (filenamev);
- if (!filename)
+ "src", "mv");
+ const char *dest = StringValueCStr (destv);
+ if (!dest)
rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
- "filename", "download");
+ "dest", "mv");
int r;
- r = guestfs_download (g, remotefilename, filename);
+ r = guestfs_mv (g, src, dest);
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)
+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", "checksum");
+ 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 *csumtype = StringValueCStr (csumtypev);
- if (!csumtype)
- rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
- "csumtype", "checksum");
- const char *path = StringValueCStr (pathv);
- if (!path)
- rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
- "path", "checksum");
char *r;
- r = guestfs_checksum (g, csumtype, path);
+ r = guestfs_dmesg (g);
if (r == NULL)
rb_raise (e_Error, "%s", guestfs_last_error (g));
return rv;
}
-static VALUE ruby_guestfs_tar_in (VALUE gv, VALUE tarfilev, VALUE directoryv)
+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", "ping_daemon");
+
+
+ int r;
+
+ r = guestfs_ping_daemon (g);
+ if (r == -1)
+ rb_raise (e_Error, "%s", guestfs_last_error (g));
+
+ return Qnil;
+}
+
+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", "tar_in");
+ rb_raise (rb_eArgError, "%s: used handle after closing it", "equal");
- const char *tarfile = StringValueCStr (tarfilev);
- if (!tarfile)
+ const char *file1 = StringValueCStr (file1v);
+ if (!file1)
rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
- "tarfile", "tar_in");
- const char *directory = StringValueCStr (directoryv);
- if (!directory)
+ "file1", "equal");
+ const char *file2 = StringValueCStr (file2v);
+ if (!file2)
rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
- "directory", "tar_in");
+ "file2", "equal");
int r;
- r = guestfs_tar_in (g, tarfile, directory);
+ 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_tar_out (VALUE gv, VALUE directoryv, VALUE tarfilev)
+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", "tar_out");
+ rb_raise (rb_eArgError, "%s: used handle after closing it", "strings");
- const char *directory = StringValueCStr (directoryv);
- if (!directory)
- rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
- "directory", "tar_out");
- const char *tarfile = StringValueCStr (tarfilev);
- if (!tarfile)
+ const char *path = StringValueCStr (pathv);
+ if (!path)
rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
- "tarfile", "tar_out");
+ "path", "strings");
- int r;
+ char **r;
- r = guestfs_tar_out (g, directory, tarfile);
- if (r == -1)
+ r = guestfs_strings (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_tgz_in (VALUE gv, VALUE tarballv, VALUE directoryv)
+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", "tgz_in");
+ rb_raise (rb_eArgError, "%s: used handle after closing it", "strings_e");
- const char *tarball = StringValueCStr (tarballv);
- if (!tarball)
+ const char *encoding = StringValueCStr (encodingv);
+ if (!encoding)
rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
- "tarball", "tgz_in");
- const char *directory = StringValueCStr (directoryv);
- if (!directory)
+ "encoding", "strings_e");
+ const char *path = StringValueCStr (pathv);
+ if (!path)
rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
- "directory", "tgz_in");
+ "path", "strings_e");
- int r;
+ char **r;
- r = guestfs_tgz_in (g, tarball, directory);
- 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_tgz_out (VALUE gv, VALUE directoryv, VALUE tarballv)
+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", "tgz_out");
+ rb_raise (rb_eArgError, "%s: used handle after closing it", "hexdump");
- const char *directory = StringValueCStr (directoryv);
- if (!directory)
- rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
- "directory", "tgz_out");
- const char *tarball = StringValueCStr (tarballv);
- if (!tarball)
+ const char *path = StringValueCStr (pathv);
+ if (!path)
rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
- "tarball", "tgz_out");
+ "path", "hexdump");
- int r;
+ char *r;
- r = guestfs_tgz_out (g, directory, tarball);
- if (r == -1)
+ r = guestfs_hexdump (g, path);
+ 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_mount_ro (VALUE gv, VALUE devicev, VALUE mountpointv)
+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", "mount_ro");
+ rb_raise (rb_eArgError, "%s: used handle after closing it", "zerofree");
const char *device = StringValueCStr (devicev);
if (!device)
rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
- "device", "mount_ro");
- const char *mountpoint = StringValueCStr (mountpointv);
- if (!mountpoint)
- rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
- "mountpoint", "mount_ro");
+ "device", "zerofree");
int r;
- r = guestfs_mount_ro (g, device, mountpoint);
+ r = guestfs_zerofree (g, device);
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)
+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", "mount_options");
+ rb_raise (rb_eArgError, "%s: used handle after closing it", "pvresize");
- const char *options = StringValueCStr (optionsv);
- if (!options)
- rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
- "options", "mount_options");
const char *device = StringValueCStr (devicev);
if (!device)
rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
- "device", "mount_options");
- const char *mountpoint = StringValueCStr (mountpointv);
- if (!mountpoint)
- rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
- "mountpoint", "mount_options");
+ "device", "pvresize");
int r;
- r = guestfs_mount_options (g, options, device, mountpoint);
+ r = guestfs_pvresize (g, device);
if (r == -1)
rb_raise (e_Error, "%s", guestfs_last_error (g));
return Qnil;
}
-static VALUE ruby_guestfs_mount_vfs (VALUE gv, VALUE optionsv, VALUE vfstypev, VALUE devicev, VALUE mountpointv)
+static VALUE ruby_guestfs_sfdisk_N (VALUE gv, VALUE devicev, VALUE nv, 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", "mount_vfs");
+ rb_raise (rb_eArgError, "%s: used handle after closing it", "sfdisk_N");
- const char *options = StringValueCStr (optionsv);
- if (!options)
- rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
- "options", "mount_vfs");
- const char *vfstype = StringValueCStr (vfstypev);
- if (!vfstype)
- rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
- "vfstype", "mount_vfs");
const char *device = StringValueCStr (devicev);
if (!device)
rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
- "device", "mount_vfs");
- const char *mountpoint = StringValueCStr (mountpointv);
- if (!mountpoint)
+ "device", "sfdisk_N");
+ int n = NUM2INT (nv);
+ int cyls = NUM2INT (cylsv);
+ int heads = NUM2INT (headsv);
+ int sectors = NUM2INT (sectorsv);
+ const char *line = StringValueCStr (linev);
+ if (!line)
rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
- "mountpoint", "mount_vfs");
+ "line", "sfdisk_N");
int r;
- r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint);
+ r = guestfs_sfdisk_N (g, device, n, cyls, heads, sectors, line);
if (r == -1)
rb_raise (e_Error, "%s", guestfs_last_error (g));
return Qnil;
}
-static VALUE ruby_guestfs_debug (VALUE gv, VALUE subcmdv, VALUE extraargsv)
+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", "debug");
+ rb_raise (rb_eArgError, "%s: used handle after closing it", "sfdisk_l");
- const char *subcmd = StringValueCStr (subcmdv);
- if (!subcmd)
+ const char *device = StringValueCStr (devicev);
+ if (!device)
rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
- "subcmd", "debug");
- char **extraargs; {
- 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;
- }
+ "device", "sfdisk_l");
char *r;
- r = guestfs_debug (g, subcmd, extraargs);
- free (extraargs);
+ r = guestfs_sfdisk_l (g, device);
if (r == NULL)
rb_raise (e_Error, "%s", guestfs_last_error (g));
return rv;
}
-static VALUE ruby_guestfs_lvremove (VALUE gv, VALUE devicev)
+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", "lvremove");
+ rb_raise (rb_eArgError, "%s: used handle after closing it", "sfdisk_kernel_geometry");
const char *device = StringValueCStr (devicev);
if (!device)
rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
- "device", "lvremove");
+ "device", "sfdisk_kernel_geometry");
- int r;
+ char *r;
- r = guestfs_lvremove (g, device);
- 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_vgremove (VALUE gv, VALUE vgnamev)
+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", "vgremove");
+ rb_raise (rb_eArgError, "%s: used handle after closing it", "sfdisk_disk_geometry");
- const char *vgname = StringValueCStr (vgnamev);
- if (!vgname)
+ const char *device = StringValueCStr (devicev);
+ if (!device)
rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
- "vgname", "vgremove");
+ "device", "sfdisk_disk_geometry");
- int r;
+ char *r;
- r = guestfs_vgremove (g, vgname);
- 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_pvremove (VALUE gv, VALUE devicev)
+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", "pvremove");
+ rb_raise (rb_eArgError, "%s: used handle after closing it", "vg_activate_all");
- const char *device = StringValueCStr (devicev);
- if (!device)
- rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
- "device", "pvremove");
+ int activate = RTEST (activatev);
int r;
- r = guestfs_pvremove (g, device);
+ 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_set_e2label (VALUE gv, VALUE devicev, VALUE labelv)
+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", "set_e2label");
+ rb_raise (rb_eArgError, "%s: used handle after closing it", "vg_activate");
- const char *device = StringValueCStr (devicev);
- if (!device)
- rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
- "device", "set_e2label");
- const char *label = StringValueCStr (labelv);
- if (!label)
- rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
- "label", "set_e2label");
+ int activate = RTEST (activatev);
+ char **volgroups; {
+ 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_set_e2label (g, device, label);
+ 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_get_e2label (VALUE gv, VALUE devicev)
+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", "get_e2label");
+ rb_raise (rb_eArgError, "%s: used handle after closing it", "lvresize");
const char *device = StringValueCStr (devicev);
if (!device)
rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
- "device", "get_e2label");
+ "device", "lvresize");
+ int mbytes = NUM2INT (mbytesv);
- char *r;
+ int r;
- r = guestfs_get_e2label (g, device);
- if (r == NULL)
+ r = guestfs_lvresize (g, device, mbytes);
+ 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_set_e2uuid (VALUE gv, VALUE devicev, VALUE uuidv)
+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", "set_e2uuid");
+ rb_raise (rb_eArgError, "%s: used handle after closing it", "resize2fs");
const char *device = StringValueCStr (devicev);
if (!device)
rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
- "device", "set_e2uuid");
- const char *uuid = StringValueCStr (uuidv);
- if (!uuid)
- rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
- "uuid", "set_e2uuid");
+ "device", "resize2fs");
int r;
- r = guestfs_set_e2uuid (g, device, uuid);
+ r = guestfs_resize2fs (g, device);
if (r == -1)
rb_raise (e_Error, "%s", guestfs_last_error (g));
return Qnil;
}
-static VALUE ruby_guestfs_get_e2uuid (VALUE gv, VALUE devicev)
+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", "get_e2uuid");
+ rb_raise (rb_eArgError, "%s: used handle after closing it", "find");
- const char *device = StringValueCStr (devicev);
- if (!device)
+ const char *directory = StringValueCStr (directoryv);
+ if (!directory)
rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
- "device", "get_e2uuid");
+ "directory", "find");
- char *r;
+ char **r;
- r = guestfs_get_e2uuid (g, device);
+ r = guestfs_find (g, directory);
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_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", "fsck");
-
- const char *fstype = StringValueCStr (fstypev);
- if (!fstype)
- rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
- "fstype", "fsck");
- 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_zero (VALUE gv, VALUE devicev)
+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", "zero");
+ rb_raise (rb_eArgError, "%s: used handle after closing it", "e2fsck_f");
const char *device = StringValueCStr (devicev);
if (!device)
rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
- "device", "zero");
+ "device", "e2fsck_f");
int r;
- r = guestfs_zero (g, device);
+ r = guestfs_e2fsck_f (g, device);
if (r == -1)
rb_raise (e_Error, "%s", guestfs_last_error (g));
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",
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_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",
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, "mount",
ruby_guestfs_mount, 2);
rb_define_method (c_guestfs, "sync",
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);
}
git.annexia.org / libguestfs.git / blobdiff