1 /* libguestfs generated file
2 * WARNING: THIS FILE IS GENERATED BY 'src/generator.ml'.
3 * ANY CHANGES YOU MAKE TO THIS FILE WILL BE LOST.
5 * Copyright (C) 2009 Red Hat Inc.
7 * This library is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2 of the License, or (at your option) any later version.
12 * This library is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with this library; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
33 #define RARRAY_LEN(r) (RARRAY((r))->len)
36 static VALUE m_guestfs; /* guestfs module */
37 static VALUE c_guestfs; /* guestfs_h handle */
38 static VALUE e_Error; /* used for all errors */
40 static void ruby_guestfs_free (void *p)
43 guestfs_close ((guestfs_h *) p);
46 static VALUE ruby_guestfs_create (VALUE m)
50 g = guestfs_create ();
52 rb_raise (e_Error, "failed to create guestfs handle");
54 /* Don't print error messages to stderr by default. */
55 guestfs_set_error_handler (g, NULL, NULL);
57 /* Wrap it, and make sure the close function is called when the
60 return Data_Wrap_Struct (c_guestfs, NULL, ruby_guestfs_free, g);
63 static VALUE ruby_guestfs_close (VALUE gv)
66 Data_Get_Struct (gv, guestfs_h, g);
68 ruby_guestfs_free (g);
74 static VALUE ruby_guestfs_test0 (VALUE gv, VALUE strv, VALUE optstrv, VALUE strlistv, VALUE bv, VALUE integerv, VALUE fileinv, VALUE fileoutv)
77 Data_Get_Struct (gv, guestfs_h, g);
79 rb_raise (rb_eArgError, "%s: used handle after closing it", "test0");
81 const char *str = StringValueCStr (strv);
83 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
85 const char *optstr = StringValueCStr (optstrv);
88 len = RARRAY_LEN (strlistv);
89 strlist = guestfs_safe_malloc (g, sizeof (char *) * (len+1));
90 for (i = 0; i < len; ++i) {
91 VALUE v = rb_ary_entry (strlistv, i);
92 strlist[i] = StringValueCStr (v);
97 int integer = NUM2INT (integerv);
98 const char *filein = StringValueCStr (fileinv);
100 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
102 const char *fileout = StringValueCStr (fileoutv);
104 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
109 r = guestfs_test0 (g, str, optstr, strlist, b, integer, filein, fileout);
112 rb_raise (e_Error, "%s", guestfs_last_error (g));
117 static VALUE ruby_guestfs_test0rint (VALUE gv, VALUE valv)
120 Data_Get_Struct (gv, guestfs_h, g);
122 rb_raise (rb_eArgError, "%s: used handle after closing it", "test0rint");
124 const char *val = StringValueCStr (valv);
126 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
131 r = guestfs_test0rint (g, val);
133 rb_raise (e_Error, "%s", guestfs_last_error (g));
138 static VALUE ruby_guestfs_test0rinterr (VALUE gv)
141 Data_Get_Struct (gv, guestfs_h, g);
143 rb_raise (rb_eArgError, "%s: used handle after closing it", "test0rinterr");
148 r = guestfs_test0rinterr (g);
150 rb_raise (e_Error, "%s", guestfs_last_error (g));
155 static VALUE ruby_guestfs_test0rint64 (VALUE gv, VALUE valv)
158 Data_Get_Struct (gv, guestfs_h, g);
160 rb_raise (rb_eArgError, "%s: used handle after closing it", "test0rint64");
162 const char *val = StringValueCStr (valv);
164 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
165 "val", "test0rint64");
169 r = guestfs_test0rint64 (g, val);
171 rb_raise (e_Error, "%s", guestfs_last_error (g));
176 static VALUE ruby_guestfs_test0rint64err (VALUE gv)
179 Data_Get_Struct (gv, guestfs_h, g);
181 rb_raise (rb_eArgError, "%s: used handle after closing it", "test0rint64err");
186 r = guestfs_test0rint64err (g);
188 rb_raise (e_Error, "%s", guestfs_last_error (g));
193 static VALUE ruby_guestfs_test0rbool (VALUE gv, VALUE valv)
196 Data_Get_Struct (gv, guestfs_h, g);
198 rb_raise (rb_eArgError, "%s: used handle after closing it", "test0rbool");
200 const char *val = StringValueCStr (valv);
202 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
203 "val", "test0rbool");
207 r = guestfs_test0rbool (g, val);
209 rb_raise (e_Error, "%s", guestfs_last_error (g));
214 static VALUE ruby_guestfs_test0rboolerr (VALUE gv)
217 Data_Get_Struct (gv, guestfs_h, g);
219 rb_raise (rb_eArgError, "%s: used handle after closing it", "test0rboolerr");
224 r = guestfs_test0rboolerr (g);
226 rb_raise (e_Error, "%s", guestfs_last_error (g));
231 static VALUE ruby_guestfs_test0rconststring (VALUE gv, VALUE valv)
234 Data_Get_Struct (gv, guestfs_h, g);
236 rb_raise (rb_eArgError, "%s: used handle after closing it", "test0rconststring");
238 const char *val = StringValueCStr (valv);
240 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
241 "val", "test0rconststring");
245 r = guestfs_test0rconststring (g, val);
247 rb_raise (e_Error, "%s", guestfs_last_error (g));
249 return rb_str_new2 (r);
252 static VALUE ruby_guestfs_test0rconststringerr (VALUE gv)
255 Data_Get_Struct (gv, guestfs_h, g);
257 rb_raise (rb_eArgError, "%s: used handle after closing it", "test0rconststringerr");
262 r = guestfs_test0rconststringerr (g);
264 rb_raise (e_Error, "%s", guestfs_last_error (g));
266 return rb_str_new2 (r);
269 static VALUE ruby_guestfs_test0rstring (VALUE gv, VALUE valv)
272 Data_Get_Struct (gv, guestfs_h, g);
274 rb_raise (rb_eArgError, "%s: used handle after closing it", "test0rstring");
276 const char *val = StringValueCStr (valv);
278 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
279 "val", "test0rstring");
283 r = guestfs_test0rstring (g, val);
285 rb_raise (e_Error, "%s", guestfs_last_error (g));
287 VALUE rv = rb_str_new2 (r);
292 static VALUE ruby_guestfs_test0rstringerr (VALUE gv)
295 Data_Get_Struct (gv, guestfs_h, g);
297 rb_raise (rb_eArgError, "%s: used handle after closing it", "test0rstringerr");
302 r = guestfs_test0rstringerr (g);
304 rb_raise (e_Error, "%s", guestfs_last_error (g));
306 VALUE rv = rb_str_new2 (r);
311 static VALUE ruby_guestfs_test0rstringlist (VALUE gv, VALUE valv)
314 Data_Get_Struct (gv, guestfs_h, g);
316 rb_raise (rb_eArgError, "%s: used handle after closing it", "test0rstringlist");
318 const char *val = StringValueCStr (valv);
320 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
321 "val", "test0rstringlist");
325 r = guestfs_test0rstringlist (g, val);
327 rb_raise (e_Error, "%s", guestfs_last_error (g));
330 for (i = 0; r[i] != NULL; ++i) len++;
331 VALUE rv = rb_ary_new2 (len);
332 for (i = 0; r[i] != NULL; ++i) {
333 rb_ary_push (rv, rb_str_new2 (r[i]));
340 static VALUE ruby_guestfs_test0rstringlisterr (VALUE gv)
343 Data_Get_Struct (gv, guestfs_h, g);
345 rb_raise (rb_eArgError, "%s: used handle after closing it", "test0rstringlisterr");
350 r = guestfs_test0rstringlisterr (g);
352 rb_raise (e_Error, "%s", guestfs_last_error (g));
355 for (i = 0; r[i] != NULL; ++i) len++;
356 VALUE rv = rb_ary_new2 (len);
357 for (i = 0; r[i] != NULL; ++i) {
358 rb_ary_push (rv, rb_str_new2 (r[i]));
365 static VALUE ruby_guestfs_test0rintbool (VALUE gv, VALUE valv)
368 Data_Get_Struct (gv, guestfs_h, g);
370 rb_raise (rb_eArgError, "%s: used handle after closing it", "test0rintbool");
372 const char *val = StringValueCStr (valv);
374 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
375 "val", "test0rintbool");
377 struct guestfs_int_bool *r;
379 r = guestfs_test0rintbool (g, val);
381 rb_raise (e_Error, "%s", guestfs_last_error (g));
383 VALUE rv = rb_ary_new2 (2);
384 rb_ary_push (rv, INT2NUM (r->i));
385 rb_ary_push (rv, INT2NUM (r->b));
386 guestfs_free_int_bool (r);
390 static VALUE ruby_guestfs_test0rintboolerr (VALUE gv)
393 Data_Get_Struct (gv, guestfs_h, g);
395 rb_raise (rb_eArgError, "%s: used handle after closing it", "test0rintboolerr");
398 struct guestfs_int_bool *r;
400 r = guestfs_test0rintboolerr (g);
402 rb_raise (e_Error, "%s", guestfs_last_error (g));
404 VALUE rv = rb_ary_new2 (2);
405 rb_ary_push (rv, INT2NUM (r->i));
406 rb_ary_push (rv, INT2NUM (r->b));
407 guestfs_free_int_bool (r);
411 static VALUE ruby_guestfs_test0rpvlist (VALUE gv, VALUE valv)
414 Data_Get_Struct (gv, guestfs_h, g);
416 rb_raise (rb_eArgError, "%s: used handle after closing it", "test0rpvlist");
418 const char *val = StringValueCStr (valv);
420 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
421 "val", "test0rpvlist");
423 struct guestfs_lvm_pv_list *r;
425 r = guestfs_test0rpvlist (g, val);
427 rb_raise (e_Error, "%s", guestfs_last_error (g));
429 VALUE rv = rb_ary_new2 (r->len);
431 for (i = 0; i < r->len; ++i) {
432 VALUE hv = rb_hash_new ();
433 rb_hash_aset (rv, rb_str_new2 ("pv_name"), rb_str_new2 (r->val[i].pv_name));
434 rb_hash_aset (rv, rb_str_new2 ("pv_uuid"), rb_str_new (r->val[i].pv_uuid, 32));
435 rb_hash_aset (rv, rb_str_new2 ("pv_fmt"), rb_str_new2 (r->val[i].pv_fmt));
436 rb_hash_aset (rv, rb_str_new2 ("pv_size"), ULL2NUM (r->val[i].pv_size));
437 rb_hash_aset (rv, rb_str_new2 ("dev_size"), ULL2NUM (r->val[i].dev_size));
438 rb_hash_aset (rv, rb_str_new2 ("pv_free"), ULL2NUM (r->val[i].pv_free));
439 rb_hash_aset (rv, rb_str_new2 ("pv_used"), ULL2NUM (r->val[i].pv_used));
440 rb_hash_aset (rv, rb_str_new2 ("pv_attr"), rb_str_new2 (r->val[i].pv_attr));
441 rb_hash_aset (rv, rb_str_new2 ("pv_pe_count"), ULL2NUM (r->val[i].pv_pe_count));
442 rb_hash_aset (rv, rb_str_new2 ("pv_pe_alloc_count"), ULL2NUM (r->val[i].pv_pe_alloc_count));
443 rb_hash_aset (rv, rb_str_new2 ("pv_tags"), rb_str_new2 (r->val[i].pv_tags));
444 rb_hash_aset (rv, rb_str_new2 ("pe_start"), ULL2NUM (r->val[i].pe_start));
445 rb_hash_aset (rv, rb_str_new2 ("pv_mda_count"), ULL2NUM (r->val[i].pv_mda_count));
446 rb_hash_aset (rv, rb_str_new2 ("pv_mda_free"), ULL2NUM (r->val[i].pv_mda_free));
447 rb_ary_push (rv, hv);
449 guestfs_free_lvm_pv_list (r);
453 static VALUE ruby_guestfs_test0rpvlisterr (VALUE gv)
456 Data_Get_Struct (gv, guestfs_h, g);
458 rb_raise (rb_eArgError, "%s: used handle after closing it", "test0rpvlisterr");
461 struct guestfs_lvm_pv_list *r;
463 r = guestfs_test0rpvlisterr (g);
465 rb_raise (e_Error, "%s", guestfs_last_error (g));
467 VALUE rv = rb_ary_new2 (r->len);
469 for (i = 0; i < r->len; ++i) {
470 VALUE hv = rb_hash_new ();
471 rb_hash_aset (rv, rb_str_new2 ("pv_name"), rb_str_new2 (r->val[i].pv_name));
472 rb_hash_aset (rv, rb_str_new2 ("pv_uuid"), rb_str_new (r->val[i].pv_uuid, 32));
473 rb_hash_aset (rv, rb_str_new2 ("pv_fmt"), rb_str_new2 (r->val[i].pv_fmt));
474 rb_hash_aset (rv, rb_str_new2 ("pv_size"), ULL2NUM (r->val[i].pv_size));
475 rb_hash_aset (rv, rb_str_new2 ("dev_size"), ULL2NUM (r->val[i].dev_size));
476 rb_hash_aset (rv, rb_str_new2 ("pv_free"), ULL2NUM (r->val[i].pv_free));
477 rb_hash_aset (rv, rb_str_new2 ("pv_used"), ULL2NUM (r->val[i].pv_used));
478 rb_hash_aset (rv, rb_str_new2 ("pv_attr"), rb_str_new2 (r->val[i].pv_attr));
479 rb_hash_aset (rv, rb_str_new2 ("pv_pe_count"), ULL2NUM (r->val[i].pv_pe_count));
480 rb_hash_aset (rv, rb_str_new2 ("pv_pe_alloc_count"), ULL2NUM (r->val[i].pv_pe_alloc_count));
481 rb_hash_aset (rv, rb_str_new2 ("pv_tags"), rb_str_new2 (r->val[i].pv_tags));
482 rb_hash_aset (rv, rb_str_new2 ("pe_start"), ULL2NUM (r->val[i].pe_start));
483 rb_hash_aset (rv, rb_str_new2 ("pv_mda_count"), ULL2NUM (r->val[i].pv_mda_count));
484 rb_hash_aset (rv, rb_str_new2 ("pv_mda_free"), ULL2NUM (r->val[i].pv_mda_free));
485 rb_ary_push (rv, hv);
487 guestfs_free_lvm_pv_list (r);
491 static VALUE ruby_guestfs_test0rvglist (VALUE gv, VALUE valv)
494 Data_Get_Struct (gv, guestfs_h, g);
496 rb_raise (rb_eArgError, "%s: used handle after closing it", "test0rvglist");
498 const char *val = StringValueCStr (valv);
500 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
501 "val", "test0rvglist");
503 struct guestfs_lvm_vg_list *r;
505 r = guestfs_test0rvglist (g, val);
507 rb_raise (e_Error, "%s", guestfs_last_error (g));
509 VALUE rv = rb_ary_new2 (r->len);
511 for (i = 0; i < r->len; ++i) {
512 VALUE hv = rb_hash_new ();
513 rb_hash_aset (rv, rb_str_new2 ("vg_name"), rb_str_new2 (r->val[i].vg_name));
514 rb_hash_aset (rv, rb_str_new2 ("vg_uuid"), rb_str_new (r->val[i].vg_uuid, 32));
515 rb_hash_aset (rv, rb_str_new2 ("vg_fmt"), rb_str_new2 (r->val[i].vg_fmt));
516 rb_hash_aset (rv, rb_str_new2 ("vg_attr"), rb_str_new2 (r->val[i].vg_attr));
517 rb_hash_aset (rv, rb_str_new2 ("vg_size"), ULL2NUM (r->val[i].vg_size));
518 rb_hash_aset (rv, rb_str_new2 ("vg_free"), ULL2NUM (r->val[i].vg_free));
519 rb_hash_aset (rv, rb_str_new2 ("vg_sysid"), rb_str_new2 (r->val[i].vg_sysid));
520 rb_hash_aset (rv, rb_str_new2 ("vg_extent_size"), ULL2NUM (r->val[i].vg_extent_size));
521 rb_hash_aset (rv, rb_str_new2 ("vg_extent_count"), ULL2NUM (r->val[i].vg_extent_count));
522 rb_hash_aset (rv, rb_str_new2 ("vg_free_count"), ULL2NUM (r->val[i].vg_free_count));
523 rb_hash_aset (rv, rb_str_new2 ("max_lv"), ULL2NUM (r->val[i].max_lv));
524 rb_hash_aset (rv, rb_str_new2 ("max_pv"), ULL2NUM (r->val[i].max_pv));
525 rb_hash_aset (rv, rb_str_new2 ("pv_count"), ULL2NUM (r->val[i].pv_count));
526 rb_hash_aset (rv, rb_str_new2 ("lv_count"), ULL2NUM (r->val[i].lv_count));
527 rb_hash_aset (rv, rb_str_new2 ("snap_count"), ULL2NUM (r->val[i].snap_count));
528 rb_hash_aset (rv, rb_str_new2 ("vg_seqno"), ULL2NUM (r->val[i].vg_seqno));
529 rb_hash_aset (rv, rb_str_new2 ("vg_tags"), rb_str_new2 (r->val[i].vg_tags));
530 rb_hash_aset (rv, rb_str_new2 ("vg_mda_count"), ULL2NUM (r->val[i].vg_mda_count));
531 rb_hash_aset (rv, rb_str_new2 ("vg_mda_free"), ULL2NUM (r->val[i].vg_mda_free));
532 rb_ary_push (rv, hv);
534 guestfs_free_lvm_vg_list (r);
538 static VALUE ruby_guestfs_test0rvglisterr (VALUE gv)
541 Data_Get_Struct (gv, guestfs_h, g);
543 rb_raise (rb_eArgError, "%s: used handle after closing it", "test0rvglisterr");
546 struct guestfs_lvm_vg_list *r;
548 r = guestfs_test0rvglisterr (g);
550 rb_raise (e_Error, "%s", guestfs_last_error (g));
552 VALUE rv = rb_ary_new2 (r->len);
554 for (i = 0; i < r->len; ++i) {
555 VALUE hv = rb_hash_new ();
556 rb_hash_aset (rv, rb_str_new2 ("vg_name"), rb_str_new2 (r->val[i].vg_name));
557 rb_hash_aset (rv, rb_str_new2 ("vg_uuid"), rb_str_new (r->val[i].vg_uuid, 32));
558 rb_hash_aset (rv, rb_str_new2 ("vg_fmt"), rb_str_new2 (r->val[i].vg_fmt));
559 rb_hash_aset (rv, rb_str_new2 ("vg_attr"), rb_str_new2 (r->val[i].vg_attr));
560 rb_hash_aset (rv, rb_str_new2 ("vg_size"), ULL2NUM (r->val[i].vg_size));
561 rb_hash_aset (rv, rb_str_new2 ("vg_free"), ULL2NUM (r->val[i].vg_free));
562 rb_hash_aset (rv, rb_str_new2 ("vg_sysid"), rb_str_new2 (r->val[i].vg_sysid));
563 rb_hash_aset (rv, rb_str_new2 ("vg_extent_size"), ULL2NUM (r->val[i].vg_extent_size));
564 rb_hash_aset (rv, rb_str_new2 ("vg_extent_count"), ULL2NUM (r->val[i].vg_extent_count));
565 rb_hash_aset (rv, rb_str_new2 ("vg_free_count"), ULL2NUM (r->val[i].vg_free_count));
566 rb_hash_aset (rv, rb_str_new2 ("max_lv"), ULL2NUM (r->val[i].max_lv));
567 rb_hash_aset (rv, rb_str_new2 ("max_pv"), ULL2NUM (r->val[i].max_pv));
568 rb_hash_aset (rv, rb_str_new2 ("pv_count"), ULL2NUM (r->val[i].pv_count));
569 rb_hash_aset (rv, rb_str_new2 ("lv_count"), ULL2NUM (r->val[i].lv_count));
570 rb_hash_aset (rv, rb_str_new2 ("snap_count"), ULL2NUM (r->val[i].snap_count));
571 rb_hash_aset (rv, rb_str_new2 ("vg_seqno"), ULL2NUM (r->val[i].vg_seqno));
572 rb_hash_aset (rv, rb_str_new2 ("vg_tags"), rb_str_new2 (r->val[i].vg_tags));
573 rb_hash_aset (rv, rb_str_new2 ("vg_mda_count"), ULL2NUM (r->val[i].vg_mda_count));
574 rb_hash_aset (rv, rb_str_new2 ("vg_mda_free"), ULL2NUM (r->val[i].vg_mda_free));
575 rb_ary_push (rv, hv);
577 guestfs_free_lvm_vg_list (r);
581 static VALUE ruby_guestfs_test0rlvlist (VALUE gv, VALUE valv)
584 Data_Get_Struct (gv, guestfs_h, g);
586 rb_raise (rb_eArgError, "%s: used handle after closing it", "test0rlvlist");
588 const char *val = StringValueCStr (valv);
590 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
591 "val", "test0rlvlist");
593 struct guestfs_lvm_lv_list *r;
595 r = guestfs_test0rlvlist (g, val);
597 rb_raise (e_Error, "%s", guestfs_last_error (g));
599 VALUE rv = rb_ary_new2 (r->len);
601 for (i = 0; i < r->len; ++i) {
602 VALUE hv = rb_hash_new ();
603 rb_hash_aset (rv, rb_str_new2 ("lv_name"), rb_str_new2 (r->val[i].lv_name));
604 rb_hash_aset (rv, rb_str_new2 ("lv_uuid"), rb_str_new (r->val[i].lv_uuid, 32));
605 rb_hash_aset (rv, rb_str_new2 ("lv_attr"), rb_str_new2 (r->val[i].lv_attr));
606 rb_hash_aset (rv, rb_str_new2 ("lv_major"), ULL2NUM (r->val[i].lv_major));
607 rb_hash_aset (rv, rb_str_new2 ("lv_minor"), ULL2NUM (r->val[i].lv_minor));
608 rb_hash_aset (rv, rb_str_new2 ("lv_kernel_major"), ULL2NUM (r->val[i].lv_kernel_major));
609 rb_hash_aset (rv, rb_str_new2 ("lv_kernel_minor"), ULL2NUM (r->val[i].lv_kernel_minor));
610 rb_hash_aset (rv, rb_str_new2 ("lv_size"), ULL2NUM (r->val[i].lv_size));
611 rb_hash_aset (rv, rb_str_new2 ("seg_count"), ULL2NUM (r->val[i].seg_count));
612 rb_hash_aset (rv, rb_str_new2 ("origin"), rb_str_new2 (r->val[i].origin));
613 rb_hash_aset (rv, rb_str_new2 ("snap_percent"), rb_dbl2big (r->val[i].snap_percent));
614 rb_hash_aset (rv, rb_str_new2 ("copy_percent"), rb_dbl2big (r->val[i].copy_percent));
615 rb_hash_aset (rv, rb_str_new2 ("move_pv"), rb_str_new2 (r->val[i].move_pv));
616 rb_hash_aset (rv, rb_str_new2 ("lv_tags"), rb_str_new2 (r->val[i].lv_tags));
617 rb_hash_aset (rv, rb_str_new2 ("mirror_log"), rb_str_new2 (r->val[i].mirror_log));
618 rb_hash_aset (rv, rb_str_new2 ("modules"), rb_str_new2 (r->val[i].modules));
619 rb_ary_push (rv, hv);
621 guestfs_free_lvm_lv_list (r);
625 static VALUE ruby_guestfs_test0rlvlisterr (VALUE gv)
628 Data_Get_Struct (gv, guestfs_h, g);
630 rb_raise (rb_eArgError, "%s: used handle after closing it", "test0rlvlisterr");
633 struct guestfs_lvm_lv_list *r;
635 r = guestfs_test0rlvlisterr (g);
637 rb_raise (e_Error, "%s", guestfs_last_error (g));
639 VALUE rv = rb_ary_new2 (r->len);
641 for (i = 0; i < r->len; ++i) {
642 VALUE hv = rb_hash_new ();
643 rb_hash_aset (rv, rb_str_new2 ("lv_name"), rb_str_new2 (r->val[i].lv_name));
644 rb_hash_aset (rv, rb_str_new2 ("lv_uuid"), rb_str_new (r->val[i].lv_uuid, 32));
645 rb_hash_aset (rv, rb_str_new2 ("lv_attr"), rb_str_new2 (r->val[i].lv_attr));
646 rb_hash_aset (rv, rb_str_new2 ("lv_major"), ULL2NUM (r->val[i].lv_major));
647 rb_hash_aset (rv, rb_str_new2 ("lv_minor"), ULL2NUM (r->val[i].lv_minor));
648 rb_hash_aset (rv, rb_str_new2 ("lv_kernel_major"), ULL2NUM (r->val[i].lv_kernel_major));
649 rb_hash_aset (rv, rb_str_new2 ("lv_kernel_minor"), ULL2NUM (r->val[i].lv_kernel_minor));
650 rb_hash_aset (rv, rb_str_new2 ("lv_size"), ULL2NUM (r->val[i].lv_size));
651 rb_hash_aset (rv, rb_str_new2 ("seg_count"), ULL2NUM (r->val[i].seg_count));
652 rb_hash_aset (rv, rb_str_new2 ("origin"), rb_str_new2 (r->val[i].origin));
653 rb_hash_aset (rv, rb_str_new2 ("snap_percent"), rb_dbl2big (r->val[i].snap_percent));
654 rb_hash_aset (rv, rb_str_new2 ("copy_percent"), rb_dbl2big (r->val[i].copy_percent));
655 rb_hash_aset (rv, rb_str_new2 ("move_pv"), rb_str_new2 (r->val[i].move_pv));
656 rb_hash_aset (rv, rb_str_new2 ("lv_tags"), rb_str_new2 (r->val[i].lv_tags));
657 rb_hash_aset (rv, rb_str_new2 ("mirror_log"), rb_str_new2 (r->val[i].mirror_log));
658 rb_hash_aset (rv, rb_str_new2 ("modules"), rb_str_new2 (r->val[i].modules));
659 rb_ary_push (rv, hv);
661 guestfs_free_lvm_lv_list (r);
665 static VALUE ruby_guestfs_test0rstat (VALUE gv, VALUE valv)
668 Data_Get_Struct (gv, guestfs_h, g);
670 rb_raise (rb_eArgError, "%s: used handle after closing it", "test0rstat");
672 const char *val = StringValueCStr (valv);
674 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
675 "val", "test0rstat");
677 struct guestfs_stat *r;
679 r = guestfs_test0rstat (g, val);
681 rb_raise (e_Error, "%s", guestfs_last_error (g));
683 VALUE rv = rb_hash_new ();
684 rb_hash_aset (rv, rb_str_new2 ("dev"), ULL2NUM (r->dev));
685 rb_hash_aset (rv, rb_str_new2 ("ino"), ULL2NUM (r->ino));
686 rb_hash_aset (rv, rb_str_new2 ("mode"), ULL2NUM (r->mode));
687 rb_hash_aset (rv, rb_str_new2 ("nlink"), ULL2NUM (r->nlink));
688 rb_hash_aset (rv, rb_str_new2 ("uid"), ULL2NUM (r->uid));
689 rb_hash_aset (rv, rb_str_new2 ("gid"), ULL2NUM (r->gid));
690 rb_hash_aset (rv, rb_str_new2 ("rdev"), ULL2NUM (r->rdev));
691 rb_hash_aset (rv, rb_str_new2 ("size"), ULL2NUM (r->size));
692 rb_hash_aset (rv, rb_str_new2 ("blksize"), ULL2NUM (r->blksize));
693 rb_hash_aset (rv, rb_str_new2 ("blocks"), ULL2NUM (r->blocks));
694 rb_hash_aset (rv, rb_str_new2 ("atime"), ULL2NUM (r->atime));
695 rb_hash_aset (rv, rb_str_new2 ("mtime"), ULL2NUM (r->mtime));
696 rb_hash_aset (rv, rb_str_new2 ("ctime"), ULL2NUM (r->ctime));
701 static VALUE ruby_guestfs_test0rstaterr (VALUE gv)
704 Data_Get_Struct (gv, guestfs_h, g);
706 rb_raise (rb_eArgError, "%s: used handle after closing it", "test0rstaterr");
709 struct guestfs_stat *r;
711 r = guestfs_test0rstaterr (g);
713 rb_raise (e_Error, "%s", guestfs_last_error (g));
715 VALUE rv = rb_hash_new ();
716 rb_hash_aset (rv, rb_str_new2 ("dev"), ULL2NUM (r->dev));
717 rb_hash_aset (rv, rb_str_new2 ("ino"), ULL2NUM (r->ino));
718 rb_hash_aset (rv, rb_str_new2 ("mode"), ULL2NUM (r->mode));
719 rb_hash_aset (rv, rb_str_new2 ("nlink"), ULL2NUM (r->nlink));
720 rb_hash_aset (rv, rb_str_new2 ("uid"), ULL2NUM (r->uid));
721 rb_hash_aset (rv, rb_str_new2 ("gid"), ULL2NUM (r->gid));
722 rb_hash_aset (rv, rb_str_new2 ("rdev"), ULL2NUM (r->rdev));
723 rb_hash_aset (rv, rb_str_new2 ("size"), ULL2NUM (r->size));
724 rb_hash_aset (rv, rb_str_new2 ("blksize"), ULL2NUM (r->blksize));
725 rb_hash_aset (rv, rb_str_new2 ("blocks"), ULL2NUM (r->blocks));
726 rb_hash_aset (rv, rb_str_new2 ("atime"), ULL2NUM (r->atime));
727 rb_hash_aset (rv, rb_str_new2 ("mtime"), ULL2NUM (r->mtime));
728 rb_hash_aset (rv, rb_str_new2 ("ctime"), ULL2NUM (r->ctime));
733 static VALUE ruby_guestfs_test0rstatvfs (VALUE gv, VALUE valv)
736 Data_Get_Struct (gv, guestfs_h, g);
738 rb_raise (rb_eArgError, "%s: used handle after closing it", "test0rstatvfs");
740 const char *val = StringValueCStr (valv);
742 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
743 "val", "test0rstatvfs");
745 struct guestfs_statvfs *r;
747 r = guestfs_test0rstatvfs (g, val);
749 rb_raise (e_Error, "%s", guestfs_last_error (g));
751 VALUE rv = rb_hash_new ();
752 rb_hash_aset (rv, rb_str_new2 ("bsize"), ULL2NUM (r->bsize));
753 rb_hash_aset (rv, rb_str_new2 ("frsize"), ULL2NUM (r->frsize));
754 rb_hash_aset (rv, rb_str_new2 ("blocks"), ULL2NUM (r->blocks));
755 rb_hash_aset (rv, rb_str_new2 ("bfree"), ULL2NUM (r->bfree));
756 rb_hash_aset (rv, rb_str_new2 ("bavail"), ULL2NUM (r->bavail));
757 rb_hash_aset (rv, rb_str_new2 ("files"), ULL2NUM (r->files));
758 rb_hash_aset (rv, rb_str_new2 ("ffree"), ULL2NUM (r->ffree));
759 rb_hash_aset (rv, rb_str_new2 ("favail"), ULL2NUM (r->favail));
760 rb_hash_aset (rv, rb_str_new2 ("fsid"), ULL2NUM (r->fsid));
761 rb_hash_aset (rv, rb_str_new2 ("flag"), ULL2NUM (r->flag));
762 rb_hash_aset (rv, rb_str_new2 ("namemax"), ULL2NUM (r->namemax));
767 static VALUE ruby_guestfs_test0rstatvfserr (VALUE gv)
770 Data_Get_Struct (gv, guestfs_h, g);
772 rb_raise (rb_eArgError, "%s: used handle after closing it", "test0rstatvfserr");
775 struct guestfs_statvfs *r;
777 r = guestfs_test0rstatvfserr (g);
779 rb_raise (e_Error, "%s", guestfs_last_error (g));
781 VALUE rv = rb_hash_new ();
782 rb_hash_aset (rv, rb_str_new2 ("bsize"), ULL2NUM (r->bsize));
783 rb_hash_aset (rv, rb_str_new2 ("frsize"), ULL2NUM (r->frsize));
784 rb_hash_aset (rv, rb_str_new2 ("blocks"), ULL2NUM (r->blocks));
785 rb_hash_aset (rv, rb_str_new2 ("bfree"), ULL2NUM (r->bfree));
786 rb_hash_aset (rv, rb_str_new2 ("bavail"), ULL2NUM (r->bavail));
787 rb_hash_aset (rv, rb_str_new2 ("files"), ULL2NUM (r->files));
788 rb_hash_aset (rv, rb_str_new2 ("ffree"), ULL2NUM (r->ffree));
789 rb_hash_aset (rv, rb_str_new2 ("favail"), ULL2NUM (r->favail));
790 rb_hash_aset (rv, rb_str_new2 ("fsid"), ULL2NUM (r->fsid));
791 rb_hash_aset (rv, rb_str_new2 ("flag"), ULL2NUM (r->flag));
792 rb_hash_aset (rv, rb_str_new2 ("namemax"), ULL2NUM (r->namemax));
797 static VALUE ruby_guestfs_test0rhashtable (VALUE gv, VALUE valv)
800 Data_Get_Struct (gv, guestfs_h, g);
802 rb_raise (rb_eArgError, "%s: used handle after closing it", "test0rhashtable");
804 const char *val = StringValueCStr (valv);
806 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
807 "val", "test0rhashtable");
811 r = guestfs_test0rhashtable (g, val);
813 rb_raise (e_Error, "%s", guestfs_last_error (g));
815 VALUE rv = rb_hash_new ();
817 for (i = 0; r[i] != NULL; i+=2) {
818 rb_hash_aset (rv, rb_str_new2 (r[i]), rb_str_new2 (r[i+1]));
826 static VALUE ruby_guestfs_test0rhashtableerr (VALUE gv)
829 Data_Get_Struct (gv, guestfs_h, g);
831 rb_raise (rb_eArgError, "%s: used handle after closing it", "test0rhashtableerr");
836 r = guestfs_test0rhashtableerr (g);
838 rb_raise (e_Error, "%s", guestfs_last_error (g));
840 VALUE rv = rb_hash_new ();
842 for (i = 0; r[i] != NULL; i+=2) {
843 rb_hash_aset (rv, rb_str_new2 (r[i]), rb_str_new2 (r[i+1]));
851 static VALUE ruby_guestfs_launch (VALUE gv)
854 Data_Get_Struct (gv, guestfs_h, g);
856 rb_raise (rb_eArgError, "%s: used handle after closing it", "launch");
861 r = guestfs_launch (g);
863 rb_raise (e_Error, "%s", guestfs_last_error (g));
868 static VALUE ruby_guestfs_wait_ready (VALUE gv)
871 Data_Get_Struct (gv, guestfs_h, g);
873 rb_raise (rb_eArgError, "%s: used handle after closing it", "wait_ready");
878 r = guestfs_wait_ready (g);
880 rb_raise (e_Error, "%s", guestfs_last_error (g));
885 static VALUE ruby_guestfs_kill_subprocess (VALUE gv)
888 Data_Get_Struct (gv, guestfs_h, g);
890 rb_raise (rb_eArgError, "%s: used handle after closing it", "kill_subprocess");
895 r = guestfs_kill_subprocess (g);
897 rb_raise (e_Error, "%s", guestfs_last_error (g));
902 static VALUE ruby_guestfs_add_drive (VALUE gv, VALUE filenamev)
905 Data_Get_Struct (gv, guestfs_h, g);
907 rb_raise (rb_eArgError, "%s: used handle after closing it", "add_drive");
909 const char *filename = StringValueCStr (filenamev);
911 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
912 "filename", "add_drive");
916 r = guestfs_add_drive (g, filename);
918 rb_raise (e_Error, "%s", guestfs_last_error (g));
923 static VALUE ruby_guestfs_add_cdrom (VALUE gv, VALUE filenamev)
926 Data_Get_Struct (gv, guestfs_h, g);
928 rb_raise (rb_eArgError, "%s: used handle after closing it", "add_cdrom");
930 const char *filename = StringValueCStr (filenamev);
932 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
933 "filename", "add_cdrom");
937 r = guestfs_add_cdrom (g, filename);
939 rb_raise (e_Error, "%s", guestfs_last_error (g));
944 static VALUE ruby_guestfs_config (VALUE gv, VALUE qemuparamv, VALUE qemuvaluev)
947 Data_Get_Struct (gv, guestfs_h, g);
949 rb_raise (rb_eArgError, "%s: used handle after closing it", "config");
951 const char *qemuparam = StringValueCStr (qemuparamv);
953 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
954 "qemuparam", "config");
955 const char *qemuvalue = StringValueCStr (qemuvaluev);
959 r = guestfs_config (g, qemuparam, qemuvalue);
961 rb_raise (e_Error, "%s", guestfs_last_error (g));
966 static VALUE ruby_guestfs_set_qemu (VALUE gv, VALUE qemuv)
969 Data_Get_Struct (gv, guestfs_h, g);
971 rb_raise (rb_eArgError, "%s: used handle after closing it", "set_qemu");
973 const char *qemu = StringValueCStr (qemuv);
975 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
980 r = guestfs_set_qemu (g, qemu);
982 rb_raise (e_Error, "%s", guestfs_last_error (g));
987 static VALUE ruby_guestfs_get_qemu (VALUE gv)
990 Data_Get_Struct (gv, guestfs_h, g);
992 rb_raise (rb_eArgError, "%s: used handle after closing it", "get_qemu");
997 r = guestfs_get_qemu (g);
999 rb_raise (e_Error, "%s", guestfs_last_error (g));
1001 return rb_str_new2 (r);
1004 static VALUE ruby_guestfs_set_path (VALUE gv, VALUE pathv)
1007 Data_Get_Struct (gv, guestfs_h, g);
1009 rb_raise (rb_eArgError, "%s: used handle after closing it", "set_path");
1011 const char *path = StringValueCStr (pathv);
1013 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1014 "path", "set_path");
1018 r = guestfs_set_path (g, path);
1020 rb_raise (e_Error, "%s", guestfs_last_error (g));
1025 static VALUE ruby_guestfs_get_path (VALUE gv)
1028 Data_Get_Struct (gv, guestfs_h, g);
1030 rb_raise (rb_eArgError, "%s: used handle after closing it", "get_path");
1035 r = guestfs_get_path (g);
1037 rb_raise (e_Error, "%s", guestfs_last_error (g));
1039 return rb_str_new2 (r);
1042 static VALUE ruby_guestfs_set_append (VALUE gv, VALUE appendv)
1045 Data_Get_Struct (gv, guestfs_h, g);
1047 rb_raise (rb_eArgError, "%s: used handle after closing it", "set_append");
1049 const char *append = StringValueCStr (appendv);
1051 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1052 "append", "set_append");
1056 r = guestfs_set_append (g, append);
1058 rb_raise (e_Error, "%s", guestfs_last_error (g));
1063 static VALUE ruby_guestfs_get_append (VALUE gv)
1066 Data_Get_Struct (gv, guestfs_h, g);
1068 rb_raise (rb_eArgError, "%s: used handle after closing it", "get_append");
1073 r = guestfs_get_append (g);
1075 rb_raise (e_Error, "%s", guestfs_last_error (g));
1077 return rb_str_new2 (r);
1080 static VALUE ruby_guestfs_set_autosync (VALUE gv, VALUE autosyncv)
1083 Data_Get_Struct (gv, guestfs_h, g);
1085 rb_raise (rb_eArgError, "%s: used handle after closing it", "set_autosync");
1087 int autosync = NUM2INT (autosyncv);
1091 r = guestfs_set_autosync (g, autosync);
1093 rb_raise (e_Error, "%s", guestfs_last_error (g));
1098 static VALUE ruby_guestfs_get_autosync (VALUE gv)
1101 Data_Get_Struct (gv, guestfs_h, g);
1103 rb_raise (rb_eArgError, "%s: used handle after closing it", "get_autosync");
1108 r = guestfs_get_autosync (g);
1110 rb_raise (e_Error, "%s", guestfs_last_error (g));
1115 static VALUE ruby_guestfs_set_verbose (VALUE gv, VALUE verbosev)
1118 Data_Get_Struct (gv, guestfs_h, g);
1120 rb_raise (rb_eArgError, "%s: used handle after closing it", "set_verbose");
1122 int verbose = NUM2INT (verbosev);
1126 r = guestfs_set_verbose (g, verbose);
1128 rb_raise (e_Error, "%s", guestfs_last_error (g));
1133 static VALUE ruby_guestfs_get_verbose (VALUE gv)
1136 Data_Get_Struct (gv, guestfs_h, g);
1138 rb_raise (rb_eArgError, "%s: used handle after closing it", "get_verbose");
1143 r = guestfs_get_verbose (g);
1145 rb_raise (e_Error, "%s", guestfs_last_error (g));
1150 static VALUE ruby_guestfs_is_ready (VALUE gv)
1153 Data_Get_Struct (gv, guestfs_h, g);
1155 rb_raise (rb_eArgError, "%s: used handle after closing it", "is_ready");
1160 r = guestfs_is_ready (g);
1162 rb_raise (e_Error, "%s", guestfs_last_error (g));
1167 static VALUE ruby_guestfs_is_config (VALUE gv)
1170 Data_Get_Struct (gv, guestfs_h, g);
1172 rb_raise (rb_eArgError, "%s: used handle after closing it", "is_config");
1177 r = guestfs_is_config (g);
1179 rb_raise (e_Error, "%s", guestfs_last_error (g));
1184 static VALUE ruby_guestfs_is_launching (VALUE gv)
1187 Data_Get_Struct (gv, guestfs_h, g);
1189 rb_raise (rb_eArgError, "%s: used handle after closing it", "is_launching");
1194 r = guestfs_is_launching (g);
1196 rb_raise (e_Error, "%s", guestfs_last_error (g));
1201 static VALUE ruby_guestfs_is_busy (VALUE gv)
1204 Data_Get_Struct (gv, guestfs_h, g);
1206 rb_raise (rb_eArgError, "%s: used handle after closing it", "is_busy");
1211 r = guestfs_is_busy (g);
1213 rb_raise (e_Error, "%s", guestfs_last_error (g));
1218 static VALUE ruby_guestfs_get_state (VALUE gv)
1221 Data_Get_Struct (gv, guestfs_h, g);
1223 rb_raise (rb_eArgError, "%s: used handle after closing it", "get_state");
1228 r = guestfs_get_state (g);
1230 rb_raise (e_Error, "%s", guestfs_last_error (g));
1235 static VALUE ruby_guestfs_set_busy (VALUE gv)
1238 Data_Get_Struct (gv, guestfs_h, g);
1240 rb_raise (rb_eArgError, "%s: used handle after closing it", "set_busy");
1245 r = guestfs_set_busy (g);
1247 rb_raise (e_Error, "%s", guestfs_last_error (g));
1252 static VALUE ruby_guestfs_set_ready (VALUE gv)
1255 Data_Get_Struct (gv, guestfs_h, g);
1257 rb_raise (rb_eArgError, "%s: used handle after closing it", "set_ready");
1262 r = guestfs_set_ready (g);
1264 rb_raise (e_Error, "%s", guestfs_last_error (g));
1269 static VALUE ruby_guestfs_end_busy (VALUE gv)
1272 Data_Get_Struct (gv, guestfs_h, g);
1274 rb_raise (rb_eArgError, "%s: used handle after closing it", "end_busy");
1279 r = guestfs_end_busy (g);
1281 rb_raise (e_Error, "%s", guestfs_last_error (g));
1286 static VALUE ruby_guestfs_mount (VALUE gv, VALUE devicev, VALUE mountpointv)
1289 Data_Get_Struct (gv, guestfs_h, g);
1291 rb_raise (rb_eArgError, "%s: used handle after closing it", "mount");
1293 const char *device = StringValueCStr (devicev);
1295 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1297 const char *mountpoint = StringValueCStr (mountpointv);
1299 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1300 "mountpoint", "mount");
1304 r = guestfs_mount (g, device, mountpoint);
1306 rb_raise (e_Error, "%s", guestfs_last_error (g));
1311 static VALUE ruby_guestfs_sync (VALUE gv)
1314 Data_Get_Struct (gv, guestfs_h, g);
1316 rb_raise (rb_eArgError, "%s: used handle after closing it", "sync");
1321 r = guestfs_sync (g);
1323 rb_raise (e_Error, "%s", guestfs_last_error (g));
1328 static VALUE ruby_guestfs_touch (VALUE gv, VALUE pathv)
1331 Data_Get_Struct (gv, guestfs_h, g);
1333 rb_raise (rb_eArgError, "%s: used handle after closing it", "touch");
1335 const char *path = StringValueCStr (pathv);
1337 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1342 r = guestfs_touch (g, path);
1344 rb_raise (e_Error, "%s", guestfs_last_error (g));
1349 static VALUE ruby_guestfs_cat (VALUE gv, VALUE pathv)
1352 Data_Get_Struct (gv, guestfs_h, g);
1354 rb_raise (rb_eArgError, "%s: used handle after closing it", "cat");
1356 const char *path = StringValueCStr (pathv);
1358 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1363 r = guestfs_cat (g, path);
1365 rb_raise (e_Error, "%s", guestfs_last_error (g));
1367 VALUE rv = rb_str_new2 (r);
1372 static VALUE ruby_guestfs_ll (VALUE gv, VALUE directoryv)
1375 Data_Get_Struct (gv, guestfs_h, g);
1377 rb_raise (rb_eArgError, "%s: used handle after closing it", "ll");
1379 const char *directory = StringValueCStr (directoryv);
1381 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1386 r = guestfs_ll (g, directory);
1388 rb_raise (e_Error, "%s", guestfs_last_error (g));
1390 VALUE rv = rb_str_new2 (r);
1395 static VALUE ruby_guestfs_ls (VALUE gv, VALUE directoryv)
1398 Data_Get_Struct (gv, guestfs_h, g);
1400 rb_raise (rb_eArgError, "%s: used handle after closing it", "ls");
1402 const char *directory = StringValueCStr (directoryv);
1404 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1409 r = guestfs_ls (g, directory);
1411 rb_raise (e_Error, "%s", guestfs_last_error (g));
1414 for (i = 0; r[i] != NULL; ++i) len++;
1415 VALUE rv = rb_ary_new2 (len);
1416 for (i = 0; r[i] != NULL; ++i) {
1417 rb_ary_push (rv, rb_str_new2 (r[i]));
1424 static VALUE ruby_guestfs_list_devices (VALUE gv)
1427 Data_Get_Struct (gv, guestfs_h, g);
1429 rb_raise (rb_eArgError, "%s: used handle after closing it", "list_devices");
1434 r = guestfs_list_devices (g);
1436 rb_raise (e_Error, "%s", guestfs_last_error (g));
1439 for (i = 0; r[i] != NULL; ++i) len++;
1440 VALUE rv = rb_ary_new2 (len);
1441 for (i = 0; r[i] != NULL; ++i) {
1442 rb_ary_push (rv, rb_str_new2 (r[i]));
1449 static VALUE ruby_guestfs_list_partitions (VALUE gv)
1452 Data_Get_Struct (gv, guestfs_h, g);
1454 rb_raise (rb_eArgError, "%s: used handle after closing it", "list_partitions");
1459 r = guestfs_list_partitions (g);
1461 rb_raise (e_Error, "%s", guestfs_last_error (g));
1464 for (i = 0; r[i] != NULL; ++i) len++;
1465 VALUE rv = rb_ary_new2 (len);
1466 for (i = 0; r[i] != NULL; ++i) {
1467 rb_ary_push (rv, rb_str_new2 (r[i]));
1474 static VALUE ruby_guestfs_pvs (VALUE gv)
1477 Data_Get_Struct (gv, guestfs_h, g);
1479 rb_raise (rb_eArgError, "%s: used handle after closing it", "pvs");
1484 r = guestfs_pvs (g);
1486 rb_raise (e_Error, "%s", guestfs_last_error (g));
1489 for (i = 0; r[i] != NULL; ++i) len++;
1490 VALUE rv = rb_ary_new2 (len);
1491 for (i = 0; r[i] != NULL; ++i) {
1492 rb_ary_push (rv, rb_str_new2 (r[i]));
1499 static VALUE ruby_guestfs_vgs (VALUE gv)
1502 Data_Get_Struct (gv, guestfs_h, g);
1504 rb_raise (rb_eArgError, "%s: used handle after closing it", "vgs");
1509 r = guestfs_vgs (g);
1511 rb_raise (e_Error, "%s", guestfs_last_error (g));
1514 for (i = 0; r[i] != NULL; ++i) len++;
1515 VALUE rv = rb_ary_new2 (len);
1516 for (i = 0; r[i] != NULL; ++i) {
1517 rb_ary_push (rv, rb_str_new2 (r[i]));
1524 static VALUE ruby_guestfs_lvs (VALUE gv)
1527 Data_Get_Struct (gv, guestfs_h, g);
1529 rb_raise (rb_eArgError, "%s: used handle after closing it", "lvs");
1534 r = guestfs_lvs (g);
1536 rb_raise (e_Error, "%s", guestfs_last_error (g));
1539 for (i = 0; r[i] != NULL; ++i) len++;
1540 VALUE rv = rb_ary_new2 (len);
1541 for (i = 0; r[i] != NULL; ++i) {
1542 rb_ary_push (rv, rb_str_new2 (r[i]));
1549 static VALUE ruby_guestfs_pvs_full (VALUE gv)
1552 Data_Get_Struct (gv, guestfs_h, g);
1554 rb_raise (rb_eArgError, "%s: used handle after closing it", "pvs_full");
1557 struct guestfs_lvm_pv_list *r;
1559 r = guestfs_pvs_full (g);
1561 rb_raise (e_Error, "%s", guestfs_last_error (g));
1563 VALUE rv = rb_ary_new2 (r->len);
1565 for (i = 0; i < r->len; ++i) {
1566 VALUE hv = rb_hash_new ();
1567 rb_hash_aset (rv, rb_str_new2 ("pv_name"), rb_str_new2 (r->val[i].pv_name));
1568 rb_hash_aset (rv, rb_str_new2 ("pv_uuid"), rb_str_new (r->val[i].pv_uuid, 32));
1569 rb_hash_aset (rv, rb_str_new2 ("pv_fmt"), rb_str_new2 (r->val[i].pv_fmt));
1570 rb_hash_aset (rv, rb_str_new2 ("pv_size"), ULL2NUM (r->val[i].pv_size));
1571 rb_hash_aset (rv, rb_str_new2 ("dev_size"), ULL2NUM (r->val[i].dev_size));
1572 rb_hash_aset (rv, rb_str_new2 ("pv_free"), ULL2NUM (r->val[i].pv_free));
1573 rb_hash_aset (rv, rb_str_new2 ("pv_used"), ULL2NUM (r->val[i].pv_used));
1574 rb_hash_aset (rv, rb_str_new2 ("pv_attr"), rb_str_new2 (r->val[i].pv_attr));
1575 rb_hash_aset (rv, rb_str_new2 ("pv_pe_count"), ULL2NUM (r->val[i].pv_pe_count));
1576 rb_hash_aset (rv, rb_str_new2 ("pv_pe_alloc_count"), ULL2NUM (r->val[i].pv_pe_alloc_count));
1577 rb_hash_aset (rv, rb_str_new2 ("pv_tags"), rb_str_new2 (r->val[i].pv_tags));
1578 rb_hash_aset (rv, rb_str_new2 ("pe_start"), ULL2NUM (r->val[i].pe_start));
1579 rb_hash_aset (rv, rb_str_new2 ("pv_mda_count"), ULL2NUM (r->val[i].pv_mda_count));
1580 rb_hash_aset (rv, rb_str_new2 ("pv_mda_free"), ULL2NUM (r->val[i].pv_mda_free));
1581 rb_ary_push (rv, hv);
1583 guestfs_free_lvm_pv_list (r);
1587 static VALUE ruby_guestfs_vgs_full (VALUE gv)
1590 Data_Get_Struct (gv, guestfs_h, g);
1592 rb_raise (rb_eArgError, "%s: used handle after closing it", "vgs_full");
1595 struct guestfs_lvm_vg_list *r;
1597 r = guestfs_vgs_full (g);
1599 rb_raise (e_Error, "%s", guestfs_last_error (g));
1601 VALUE rv = rb_ary_new2 (r->len);
1603 for (i = 0; i < r->len; ++i) {
1604 VALUE hv = rb_hash_new ();
1605 rb_hash_aset (rv, rb_str_new2 ("vg_name"), rb_str_new2 (r->val[i].vg_name));
1606 rb_hash_aset (rv, rb_str_new2 ("vg_uuid"), rb_str_new (r->val[i].vg_uuid, 32));
1607 rb_hash_aset (rv, rb_str_new2 ("vg_fmt"), rb_str_new2 (r->val[i].vg_fmt));
1608 rb_hash_aset (rv, rb_str_new2 ("vg_attr"), rb_str_new2 (r->val[i].vg_attr));
1609 rb_hash_aset (rv, rb_str_new2 ("vg_size"), ULL2NUM (r->val[i].vg_size));
1610 rb_hash_aset (rv, rb_str_new2 ("vg_free"), ULL2NUM (r->val[i].vg_free));
1611 rb_hash_aset (rv, rb_str_new2 ("vg_sysid"), rb_str_new2 (r->val[i].vg_sysid));
1612 rb_hash_aset (rv, rb_str_new2 ("vg_extent_size"), ULL2NUM (r->val[i].vg_extent_size));
1613 rb_hash_aset (rv, rb_str_new2 ("vg_extent_count"), ULL2NUM (r->val[i].vg_extent_count));
1614 rb_hash_aset (rv, rb_str_new2 ("vg_free_count"), ULL2NUM (r->val[i].vg_free_count));
1615 rb_hash_aset (rv, rb_str_new2 ("max_lv"), ULL2NUM (r->val[i].max_lv));
1616 rb_hash_aset (rv, rb_str_new2 ("max_pv"), ULL2NUM (r->val[i].max_pv));
1617 rb_hash_aset (rv, rb_str_new2 ("pv_count"), ULL2NUM (r->val[i].pv_count));
1618 rb_hash_aset (rv, rb_str_new2 ("lv_count"), ULL2NUM (r->val[i].lv_count));
1619 rb_hash_aset (rv, rb_str_new2 ("snap_count"), ULL2NUM (r->val[i].snap_count));
1620 rb_hash_aset (rv, rb_str_new2 ("vg_seqno"), ULL2NUM (r->val[i].vg_seqno));
1621 rb_hash_aset (rv, rb_str_new2 ("vg_tags"), rb_str_new2 (r->val[i].vg_tags));
1622 rb_hash_aset (rv, rb_str_new2 ("vg_mda_count"), ULL2NUM (r->val[i].vg_mda_count));
1623 rb_hash_aset (rv, rb_str_new2 ("vg_mda_free"), ULL2NUM (r->val[i].vg_mda_free));
1624 rb_ary_push (rv, hv);
1626 guestfs_free_lvm_vg_list (r);
1630 static VALUE ruby_guestfs_lvs_full (VALUE gv)
1633 Data_Get_Struct (gv, guestfs_h, g);
1635 rb_raise (rb_eArgError, "%s: used handle after closing it", "lvs_full");
1638 struct guestfs_lvm_lv_list *r;
1640 r = guestfs_lvs_full (g);
1642 rb_raise (e_Error, "%s", guestfs_last_error (g));
1644 VALUE rv = rb_ary_new2 (r->len);
1646 for (i = 0; i < r->len; ++i) {
1647 VALUE hv = rb_hash_new ();
1648 rb_hash_aset (rv, rb_str_new2 ("lv_name"), rb_str_new2 (r->val[i].lv_name));
1649 rb_hash_aset (rv, rb_str_new2 ("lv_uuid"), rb_str_new (r->val[i].lv_uuid, 32));
1650 rb_hash_aset (rv, rb_str_new2 ("lv_attr"), rb_str_new2 (r->val[i].lv_attr));
1651 rb_hash_aset (rv, rb_str_new2 ("lv_major"), ULL2NUM (r->val[i].lv_major));
1652 rb_hash_aset (rv, rb_str_new2 ("lv_minor"), ULL2NUM (r->val[i].lv_minor));
1653 rb_hash_aset (rv, rb_str_new2 ("lv_kernel_major"), ULL2NUM (r->val[i].lv_kernel_major));
1654 rb_hash_aset (rv, rb_str_new2 ("lv_kernel_minor"), ULL2NUM (r->val[i].lv_kernel_minor));
1655 rb_hash_aset (rv, rb_str_new2 ("lv_size"), ULL2NUM (r->val[i].lv_size));
1656 rb_hash_aset (rv, rb_str_new2 ("seg_count"), ULL2NUM (r->val[i].seg_count));
1657 rb_hash_aset (rv, rb_str_new2 ("origin"), rb_str_new2 (r->val[i].origin));
1658 rb_hash_aset (rv, rb_str_new2 ("snap_percent"), rb_dbl2big (r->val[i].snap_percent));
1659 rb_hash_aset (rv, rb_str_new2 ("copy_percent"), rb_dbl2big (r->val[i].copy_percent));
1660 rb_hash_aset (rv, rb_str_new2 ("move_pv"), rb_str_new2 (r->val[i].move_pv));
1661 rb_hash_aset (rv, rb_str_new2 ("lv_tags"), rb_str_new2 (r->val[i].lv_tags));
1662 rb_hash_aset (rv, rb_str_new2 ("mirror_log"), rb_str_new2 (r->val[i].mirror_log));
1663 rb_hash_aset (rv, rb_str_new2 ("modules"), rb_str_new2 (r->val[i].modules));
1664 rb_ary_push (rv, hv);
1666 guestfs_free_lvm_lv_list (r);
1670 static VALUE ruby_guestfs_read_lines (VALUE gv, VALUE pathv)
1673 Data_Get_Struct (gv, guestfs_h, g);
1675 rb_raise (rb_eArgError, "%s: used handle after closing it", "read_lines");
1677 const char *path = StringValueCStr (pathv);
1679 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1680 "path", "read_lines");
1684 r = guestfs_read_lines (g, path);
1686 rb_raise (e_Error, "%s", guestfs_last_error (g));
1689 for (i = 0; r[i] != NULL; ++i) len++;
1690 VALUE rv = rb_ary_new2 (len);
1691 for (i = 0; r[i] != NULL; ++i) {
1692 rb_ary_push (rv, rb_str_new2 (r[i]));
1699 static VALUE ruby_guestfs_aug_init (VALUE gv, VALUE rootv, VALUE flagsv)
1702 Data_Get_Struct (gv, guestfs_h, g);
1704 rb_raise (rb_eArgError, "%s: used handle after closing it", "aug_init");
1706 const char *root = StringValueCStr (rootv);
1708 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1709 "root", "aug_init");
1710 int flags = NUM2INT (flagsv);
1714 r = guestfs_aug_init (g, root, flags);
1716 rb_raise (e_Error, "%s", guestfs_last_error (g));
1721 static VALUE ruby_guestfs_aug_close (VALUE gv)
1724 Data_Get_Struct (gv, guestfs_h, g);
1726 rb_raise (rb_eArgError, "%s: used handle after closing it", "aug_close");
1731 r = guestfs_aug_close (g);
1733 rb_raise (e_Error, "%s", guestfs_last_error (g));
1738 static VALUE ruby_guestfs_aug_defvar (VALUE gv, VALUE namev, VALUE exprv)
1741 Data_Get_Struct (gv, guestfs_h, g);
1743 rb_raise (rb_eArgError, "%s: used handle after closing it", "aug_defvar");
1745 const char *name = StringValueCStr (namev);
1747 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1748 "name", "aug_defvar");
1749 const char *expr = StringValueCStr (exprv);
1753 r = guestfs_aug_defvar (g, name, expr);
1755 rb_raise (e_Error, "%s", guestfs_last_error (g));
1760 static VALUE ruby_guestfs_aug_defnode (VALUE gv, VALUE namev, VALUE exprv, VALUE valv)
1763 Data_Get_Struct (gv, guestfs_h, g);
1765 rb_raise (rb_eArgError, "%s: used handle after closing it", "aug_defnode");
1767 const char *name = StringValueCStr (namev);
1769 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1770 "name", "aug_defnode");
1771 const char *expr = StringValueCStr (exprv);
1773 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1774 "expr", "aug_defnode");
1775 const char *val = StringValueCStr (valv);
1777 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1778 "val", "aug_defnode");
1780 struct guestfs_int_bool *r;
1782 r = guestfs_aug_defnode (g, name, expr, val);
1784 rb_raise (e_Error, "%s", guestfs_last_error (g));
1786 VALUE rv = rb_ary_new2 (2);
1787 rb_ary_push (rv, INT2NUM (r->i));
1788 rb_ary_push (rv, INT2NUM (r->b));
1789 guestfs_free_int_bool (r);
1793 static VALUE ruby_guestfs_aug_get (VALUE gv, VALUE pathv)
1796 Data_Get_Struct (gv, guestfs_h, g);
1798 rb_raise (rb_eArgError, "%s: used handle after closing it", "aug_get");
1800 const char *path = StringValueCStr (pathv);
1802 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1807 r = guestfs_aug_get (g, path);
1809 rb_raise (e_Error, "%s", guestfs_last_error (g));
1811 VALUE rv = rb_str_new2 (r);
1816 static VALUE ruby_guestfs_aug_set (VALUE gv, VALUE pathv, VALUE valv)
1819 Data_Get_Struct (gv, guestfs_h, g);
1821 rb_raise (rb_eArgError, "%s: used handle after closing it", "aug_set");
1823 const char *path = StringValueCStr (pathv);
1825 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1827 const char *val = StringValueCStr (valv);
1829 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1834 r = guestfs_aug_set (g, path, val);
1836 rb_raise (e_Error, "%s", guestfs_last_error (g));
1841 static VALUE ruby_guestfs_aug_insert (VALUE gv, VALUE pathv, VALUE labelv, VALUE beforev)
1844 Data_Get_Struct (gv, guestfs_h, g);
1846 rb_raise (rb_eArgError, "%s: used handle after closing it", "aug_insert");
1848 const char *path = StringValueCStr (pathv);
1850 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1851 "path", "aug_insert");
1852 const char *label = StringValueCStr (labelv);
1854 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1855 "label", "aug_insert");
1856 int before = NUM2INT (beforev);
1860 r = guestfs_aug_insert (g, path, label, before);
1862 rb_raise (e_Error, "%s", guestfs_last_error (g));
1867 static VALUE ruby_guestfs_aug_rm (VALUE gv, VALUE pathv)
1870 Data_Get_Struct (gv, guestfs_h, g);
1872 rb_raise (rb_eArgError, "%s: used handle after closing it", "aug_rm");
1874 const char *path = StringValueCStr (pathv);
1876 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1881 r = guestfs_aug_rm (g, path);
1883 rb_raise (e_Error, "%s", guestfs_last_error (g));
1888 static VALUE ruby_guestfs_aug_mv (VALUE gv, VALUE srcv, VALUE destv)
1891 Data_Get_Struct (gv, guestfs_h, g);
1893 rb_raise (rb_eArgError, "%s: used handle after closing it", "aug_mv");
1895 const char *src = StringValueCStr (srcv);
1897 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1899 const char *dest = StringValueCStr (destv);
1901 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1906 r = guestfs_aug_mv (g, src, dest);
1908 rb_raise (e_Error, "%s", guestfs_last_error (g));
1913 static VALUE ruby_guestfs_aug_match (VALUE gv, VALUE pathv)
1916 Data_Get_Struct (gv, guestfs_h, g);
1918 rb_raise (rb_eArgError, "%s: used handle after closing it", "aug_match");
1920 const char *path = StringValueCStr (pathv);
1922 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1923 "path", "aug_match");
1927 r = guestfs_aug_match (g, path);
1929 rb_raise (e_Error, "%s", guestfs_last_error (g));
1932 for (i = 0; r[i] != NULL; ++i) len++;
1933 VALUE rv = rb_ary_new2 (len);
1934 for (i = 0; r[i] != NULL; ++i) {
1935 rb_ary_push (rv, rb_str_new2 (r[i]));
1942 static VALUE ruby_guestfs_aug_save (VALUE gv)
1945 Data_Get_Struct (gv, guestfs_h, g);
1947 rb_raise (rb_eArgError, "%s: used handle after closing it", "aug_save");
1952 r = guestfs_aug_save (g);
1954 rb_raise (e_Error, "%s", guestfs_last_error (g));
1959 static VALUE ruby_guestfs_aug_load (VALUE gv)
1962 Data_Get_Struct (gv, guestfs_h, g);
1964 rb_raise (rb_eArgError, "%s: used handle after closing it", "aug_load");
1969 r = guestfs_aug_load (g);
1971 rb_raise (e_Error, "%s", guestfs_last_error (g));
1976 static VALUE ruby_guestfs_aug_ls (VALUE gv, VALUE pathv)
1979 Data_Get_Struct (gv, guestfs_h, g);
1981 rb_raise (rb_eArgError, "%s: used handle after closing it", "aug_ls");
1983 const char *path = StringValueCStr (pathv);
1985 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1990 r = guestfs_aug_ls (g, path);
1992 rb_raise (e_Error, "%s", guestfs_last_error (g));
1995 for (i = 0; r[i] != NULL; ++i) len++;
1996 VALUE rv = rb_ary_new2 (len);
1997 for (i = 0; r[i] != NULL; ++i) {
1998 rb_ary_push (rv, rb_str_new2 (r[i]));
2005 static VALUE ruby_guestfs_rm (VALUE gv, VALUE pathv)
2008 Data_Get_Struct (gv, guestfs_h, g);
2010 rb_raise (rb_eArgError, "%s: used handle after closing it", "rm");
2012 const char *path = StringValueCStr (pathv);
2014 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2019 r = guestfs_rm (g, path);
2021 rb_raise (e_Error, "%s", guestfs_last_error (g));
2026 static VALUE ruby_guestfs_rmdir (VALUE gv, VALUE pathv)
2029 Data_Get_Struct (gv, guestfs_h, g);
2031 rb_raise (rb_eArgError, "%s: used handle after closing it", "rmdir");
2033 const char *path = StringValueCStr (pathv);
2035 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2040 r = guestfs_rmdir (g, path);
2042 rb_raise (e_Error, "%s", guestfs_last_error (g));
2047 static VALUE ruby_guestfs_rm_rf (VALUE gv, VALUE pathv)
2050 Data_Get_Struct (gv, guestfs_h, g);
2052 rb_raise (rb_eArgError, "%s: used handle after closing it", "rm_rf");
2054 const char *path = StringValueCStr (pathv);
2056 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2061 r = guestfs_rm_rf (g, path);
2063 rb_raise (e_Error, "%s", guestfs_last_error (g));
2068 static VALUE ruby_guestfs_mkdir (VALUE gv, VALUE pathv)
2071 Data_Get_Struct (gv, guestfs_h, g);
2073 rb_raise (rb_eArgError, "%s: used handle after closing it", "mkdir");
2075 const char *path = StringValueCStr (pathv);
2077 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2082 r = guestfs_mkdir (g, path);
2084 rb_raise (e_Error, "%s", guestfs_last_error (g));
2089 static VALUE ruby_guestfs_mkdir_p (VALUE gv, VALUE pathv)
2092 Data_Get_Struct (gv, guestfs_h, g);
2094 rb_raise (rb_eArgError, "%s: used handle after closing it", "mkdir_p");
2096 const char *path = StringValueCStr (pathv);
2098 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2103 r = guestfs_mkdir_p (g, path);
2105 rb_raise (e_Error, "%s", guestfs_last_error (g));
2110 static VALUE ruby_guestfs_chmod (VALUE gv, VALUE modev, VALUE pathv)
2113 Data_Get_Struct (gv, guestfs_h, g);
2115 rb_raise (rb_eArgError, "%s: used handle after closing it", "chmod");
2117 int mode = NUM2INT (modev);
2118 const char *path = StringValueCStr (pathv);
2120 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2125 r = guestfs_chmod (g, mode, path);
2127 rb_raise (e_Error, "%s", guestfs_last_error (g));
2132 static VALUE ruby_guestfs_chown (VALUE gv, VALUE ownerv, VALUE groupv, VALUE pathv)
2135 Data_Get_Struct (gv, guestfs_h, g);
2137 rb_raise (rb_eArgError, "%s: used handle after closing it", "chown");
2139 int owner = NUM2INT (ownerv);
2140 int group = NUM2INT (groupv);
2141 const char *path = StringValueCStr (pathv);
2143 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2148 r = guestfs_chown (g, owner, group, path);
2150 rb_raise (e_Error, "%s", guestfs_last_error (g));
2155 static VALUE ruby_guestfs_exists (VALUE gv, VALUE pathv)
2158 Data_Get_Struct (gv, guestfs_h, g);
2160 rb_raise (rb_eArgError, "%s: used handle after closing it", "exists");
2162 const char *path = StringValueCStr (pathv);
2164 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2169 r = guestfs_exists (g, path);
2171 rb_raise (e_Error, "%s", guestfs_last_error (g));
2176 static VALUE ruby_guestfs_is_file (VALUE gv, VALUE pathv)
2179 Data_Get_Struct (gv, guestfs_h, g);
2181 rb_raise (rb_eArgError, "%s: used handle after closing it", "is_file");
2183 const char *path = StringValueCStr (pathv);
2185 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2190 r = guestfs_is_file (g, path);
2192 rb_raise (e_Error, "%s", guestfs_last_error (g));
2197 static VALUE ruby_guestfs_is_dir (VALUE gv, VALUE pathv)
2200 Data_Get_Struct (gv, guestfs_h, g);
2202 rb_raise (rb_eArgError, "%s: used handle after closing it", "is_dir");
2204 const char *path = StringValueCStr (pathv);
2206 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2211 r = guestfs_is_dir (g, path);
2213 rb_raise (e_Error, "%s", guestfs_last_error (g));
2218 static VALUE ruby_guestfs_pvcreate (VALUE gv, VALUE devicev)
2221 Data_Get_Struct (gv, guestfs_h, g);
2223 rb_raise (rb_eArgError, "%s: used handle after closing it", "pvcreate");
2225 const char *device = StringValueCStr (devicev);
2227 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2228 "device", "pvcreate");
2232 r = guestfs_pvcreate (g, device);
2234 rb_raise (e_Error, "%s", guestfs_last_error (g));
2239 static VALUE ruby_guestfs_vgcreate (VALUE gv, VALUE volgroupv, VALUE physvolsv)
2242 Data_Get_Struct (gv, guestfs_h, g);
2244 rb_raise (rb_eArgError, "%s: used handle after closing it", "vgcreate");
2246 const char *volgroup = StringValueCStr (volgroupv);
2248 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2249 "volgroup", "vgcreate");
2252 len = RARRAY_LEN (physvolsv);
2253 physvols = guestfs_safe_malloc (g, sizeof (char *) * (len+1));
2254 for (i = 0; i < len; ++i) {
2255 VALUE v = rb_ary_entry (physvolsv, i);
2256 physvols[i] = StringValueCStr (v);
2258 physvols[len] = NULL;
2263 r = guestfs_vgcreate (g, volgroup, physvols);
2266 rb_raise (e_Error, "%s", guestfs_last_error (g));
2271 static VALUE ruby_guestfs_lvcreate (VALUE gv, VALUE logvolv, VALUE volgroupv, VALUE mbytesv)
2274 Data_Get_Struct (gv, guestfs_h, g);
2276 rb_raise (rb_eArgError, "%s: used handle after closing it", "lvcreate");
2278 const char *logvol = StringValueCStr (logvolv);
2280 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2281 "logvol", "lvcreate");
2282 const char *volgroup = StringValueCStr (volgroupv);
2284 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2285 "volgroup", "lvcreate");
2286 int mbytes = NUM2INT (mbytesv);
2290 r = guestfs_lvcreate (g, logvol, volgroup, mbytes);
2292 rb_raise (e_Error, "%s", guestfs_last_error (g));
2297 static VALUE ruby_guestfs_mkfs (VALUE gv, VALUE fstypev, VALUE devicev)
2300 Data_Get_Struct (gv, guestfs_h, g);
2302 rb_raise (rb_eArgError, "%s: used handle after closing it", "mkfs");
2304 const char *fstype = StringValueCStr (fstypev);
2306 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2308 const char *device = StringValueCStr (devicev);
2310 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2315 r = guestfs_mkfs (g, fstype, device);
2317 rb_raise (e_Error, "%s", guestfs_last_error (g));
2322 static VALUE ruby_guestfs_sfdisk (VALUE gv, VALUE devicev, VALUE cylsv, VALUE headsv, VALUE sectorsv, VALUE linesv)
2325 Data_Get_Struct (gv, guestfs_h, g);
2327 rb_raise (rb_eArgError, "%s: used handle after closing it", "sfdisk");
2329 const char *device = StringValueCStr (devicev);
2331 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2332 "device", "sfdisk");
2333 int cyls = NUM2INT (cylsv);
2334 int heads = NUM2INT (headsv);
2335 int sectors = NUM2INT (sectorsv);
2338 len = RARRAY_LEN (linesv);
2339 lines = guestfs_safe_malloc (g, sizeof (char *) * (len+1));
2340 for (i = 0; i < len; ++i) {
2341 VALUE v = rb_ary_entry (linesv, i);
2342 lines[i] = StringValueCStr (v);
2349 r = guestfs_sfdisk (g, device, cyls, heads, sectors, lines);
2352 rb_raise (e_Error, "%s", guestfs_last_error (g));
2357 static VALUE ruby_guestfs_write_file (VALUE gv, VALUE pathv, VALUE contentv, VALUE sizev)
2360 Data_Get_Struct (gv, guestfs_h, g);
2362 rb_raise (rb_eArgError, "%s: used handle after closing it", "write_file");
2364 const char *path = StringValueCStr (pathv);
2366 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2367 "path", "write_file");
2368 const char *content = StringValueCStr (contentv);
2370 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2371 "content", "write_file");
2372 int size = NUM2INT (sizev);
2376 r = guestfs_write_file (g, path, content, size);
2378 rb_raise (e_Error, "%s", guestfs_last_error (g));
2383 static VALUE ruby_guestfs_umount (VALUE gv, VALUE pathordevicev)
2386 Data_Get_Struct (gv, guestfs_h, g);
2388 rb_raise (rb_eArgError, "%s: used handle after closing it", "umount");
2390 const char *pathordevice = StringValueCStr (pathordevicev);
2392 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2393 "pathordevice", "umount");
2397 r = guestfs_umount (g, pathordevice);
2399 rb_raise (e_Error, "%s", guestfs_last_error (g));
2404 static VALUE ruby_guestfs_mounts (VALUE gv)
2407 Data_Get_Struct (gv, guestfs_h, g);
2409 rb_raise (rb_eArgError, "%s: used handle after closing it", "mounts");
2414 r = guestfs_mounts (g);
2416 rb_raise (e_Error, "%s", guestfs_last_error (g));
2419 for (i = 0; r[i] != NULL; ++i) len++;
2420 VALUE rv = rb_ary_new2 (len);
2421 for (i = 0; r[i] != NULL; ++i) {
2422 rb_ary_push (rv, rb_str_new2 (r[i]));
2429 static VALUE ruby_guestfs_umount_all (VALUE gv)
2432 Data_Get_Struct (gv, guestfs_h, g);
2434 rb_raise (rb_eArgError, "%s: used handle after closing it", "umount_all");
2439 r = guestfs_umount_all (g);
2441 rb_raise (e_Error, "%s", guestfs_last_error (g));
2446 static VALUE ruby_guestfs_lvm_remove_all (VALUE gv)
2449 Data_Get_Struct (gv, guestfs_h, g);
2451 rb_raise (rb_eArgError, "%s: used handle after closing it", "lvm_remove_all");
2456 r = guestfs_lvm_remove_all (g);
2458 rb_raise (e_Error, "%s", guestfs_last_error (g));
2463 static VALUE ruby_guestfs_file (VALUE gv, VALUE pathv)
2466 Data_Get_Struct (gv, guestfs_h, g);
2468 rb_raise (rb_eArgError, "%s: used handle after closing it", "file");
2470 const char *path = StringValueCStr (pathv);
2472 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2477 r = guestfs_file (g, path);
2479 rb_raise (e_Error, "%s", guestfs_last_error (g));
2481 VALUE rv = rb_str_new2 (r);
2486 static VALUE ruby_guestfs_command (VALUE gv, VALUE argumentsv)
2489 Data_Get_Struct (gv, guestfs_h, g);
2491 rb_raise (rb_eArgError, "%s: used handle after closing it", "command");
2495 len = RARRAY_LEN (argumentsv);
2496 arguments = guestfs_safe_malloc (g, sizeof (char *) * (len+1));
2497 for (i = 0; i < len; ++i) {
2498 VALUE v = rb_ary_entry (argumentsv, i);
2499 arguments[i] = StringValueCStr (v);
2501 arguments[len] = NULL;
2506 r = guestfs_command (g, arguments);
2509 rb_raise (e_Error, "%s", guestfs_last_error (g));
2511 VALUE rv = rb_str_new2 (r);
2516 static VALUE ruby_guestfs_command_lines (VALUE gv, VALUE argumentsv)
2519 Data_Get_Struct (gv, guestfs_h, g);
2521 rb_raise (rb_eArgError, "%s: used handle after closing it", "command_lines");
2525 len = RARRAY_LEN (argumentsv);
2526 arguments = guestfs_safe_malloc (g, sizeof (char *) * (len+1));
2527 for (i = 0; i < len; ++i) {
2528 VALUE v = rb_ary_entry (argumentsv, i);
2529 arguments[i] = StringValueCStr (v);
2531 arguments[len] = NULL;
2536 r = guestfs_command_lines (g, arguments);
2539 rb_raise (e_Error, "%s", guestfs_last_error (g));
2542 for (i = 0; r[i] != NULL; ++i) len++;
2543 VALUE rv = rb_ary_new2 (len);
2544 for (i = 0; r[i] != NULL; ++i) {
2545 rb_ary_push (rv, rb_str_new2 (r[i]));
2552 static VALUE ruby_guestfs_stat (VALUE gv, VALUE pathv)
2555 Data_Get_Struct (gv, guestfs_h, g);
2557 rb_raise (rb_eArgError, "%s: used handle after closing it", "stat");
2559 const char *path = StringValueCStr (pathv);
2561 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2564 struct guestfs_stat *r;
2566 r = guestfs_stat (g, path);
2568 rb_raise (e_Error, "%s", guestfs_last_error (g));
2570 VALUE rv = rb_hash_new ();
2571 rb_hash_aset (rv, rb_str_new2 ("dev"), ULL2NUM (r->dev));
2572 rb_hash_aset (rv, rb_str_new2 ("ino"), ULL2NUM (r->ino));
2573 rb_hash_aset (rv, rb_str_new2 ("mode"), ULL2NUM (r->mode));
2574 rb_hash_aset (rv, rb_str_new2 ("nlink"), ULL2NUM (r->nlink));
2575 rb_hash_aset (rv, rb_str_new2 ("uid"), ULL2NUM (r->uid));
2576 rb_hash_aset (rv, rb_str_new2 ("gid"), ULL2NUM (r->gid));
2577 rb_hash_aset (rv, rb_str_new2 ("rdev"), ULL2NUM (r->rdev));
2578 rb_hash_aset (rv, rb_str_new2 ("size"), ULL2NUM (r->size));
2579 rb_hash_aset (rv, rb_str_new2 ("blksize"), ULL2NUM (r->blksize));
2580 rb_hash_aset (rv, rb_str_new2 ("blocks"), ULL2NUM (r->blocks));
2581 rb_hash_aset (rv, rb_str_new2 ("atime"), ULL2NUM (r->atime));
2582 rb_hash_aset (rv, rb_str_new2 ("mtime"), ULL2NUM (r->mtime));
2583 rb_hash_aset (rv, rb_str_new2 ("ctime"), ULL2NUM (r->ctime));
2588 static VALUE ruby_guestfs_lstat (VALUE gv, VALUE pathv)
2591 Data_Get_Struct (gv, guestfs_h, g);
2593 rb_raise (rb_eArgError, "%s: used handle after closing it", "lstat");
2595 const char *path = StringValueCStr (pathv);
2597 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2600 struct guestfs_stat *r;
2602 r = guestfs_lstat (g, path);
2604 rb_raise (e_Error, "%s", guestfs_last_error (g));
2606 VALUE rv = rb_hash_new ();
2607 rb_hash_aset (rv, rb_str_new2 ("dev"), ULL2NUM (r->dev));
2608 rb_hash_aset (rv, rb_str_new2 ("ino"), ULL2NUM (r->ino));
2609 rb_hash_aset (rv, rb_str_new2 ("mode"), ULL2NUM (r->mode));
2610 rb_hash_aset (rv, rb_str_new2 ("nlink"), ULL2NUM (r->nlink));
2611 rb_hash_aset (rv, rb_str_new2 ("uid"), ULL2NUM (r->uid));
2612 rb_hash_aset (rv, rb_str_new2 ("gid"), ULL2NUM (r->gid));
2613 rb_hash_aset (rv, rb_str_new2 ("rdev"), ULL2NUM (r->rdev));
2614 rb_hash_aset (rv, rb_str_new2 ("size"), ULL2NUM (r->size));
2615 rb_hash_aset (rv, rb_str_new2 ("blksize"), ULL2NUM (r->blksize));
2616 rb_hash_aset (rv, rb_str_new2 ("blocks"), ULL2NUM (r->blocks));
2617 rb_hash_aset (rv, rb_str_new2 ("atime"), ULL2NUM (r->atime));
2618 rb_hash_aset (rv, rb_str_new2 ("mtime"), ULL2NUM (r->mtime));
2619 rb_hash_aset (rv, rb_str_new2 ("ctime"), ULL2NUM (r->ctime));
2624 static VALUE ruby_guestfs_statvfs (VALUE gv, VALUE pathv)
2627 Data_Get_Struct (gv, guestfs_h, g);
2629 rb_raise (rb_eArgError, "%s: used handle after closing it", "statvfs");
2631 const char *path = StringValueCStr (pathv);
2633 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2636 struct guestfs_statvfs *r;
2638 r = guestfs_statvfs (g, path);
2640 rb_raise (e_Error, "%s", guestfs_last_error (g));
2642 VALUE rv = rb_hash_new ();
2643 rb_hash_aset (rv, rb_str_new2 ("bsize"), ULL2NUM (r->bsize));
2644 rb_hash_aset (rv, rb_str_new2 ("frsize"), ULL2NUM (r->frsize));
2645 rb_hash_aset (rv, rb_str_new2 ("blocks"), ULL2NUM (r->blocks));
2646 rb_hash_aset (rv, rb_str_new2 ("bfree"), ULL2NUM (r->bfree));
2647 rb_hash_aset (rv, rb_str_new2 ("bavail"), ULL2NUM (r->bavail));
2648 rb_hash_aset (rv, rb_str_new2 ("files"), ULL2NUM (r->files));
2649 rb_hash_aset (rv, rb_str_new2 ("ffree"), ULL2NUM (r->ffree));
2650 rb_hash_aset (rv, rb_str_new2 ("favail"), ULL2NUM (r->favail));
2651 rb_hash_aset (rv, rb_str_new2 ("fsid"), ULL2NUM (r->fsid));
2652 rb_hash_aset (rv, rb_str_new2 ("flag"), ULL2NUM (r->flag));
2653 rb_hash_aset (rv, rb_str_new2 ("namemax"), ULL2NUM (r->namemax));
2658 static VALUE ruby_guestfs_tune2fs_l (VALUE gv, VALUE devicev)
2661 Data_Get_Struct (gv, guestfs_h, g);
2663 rb_raise (rb_eArgError, "%s: used handle after closing it", "tune2fs_l");
2665 const char *device = StringValueCStr (devicev);
2667 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2668 "device", "tune2fs_l");
2672 r = guestfs_tune2fs_l (g, device);
2674 rb_raise (e_Error, "%s", guestfs_last_error (g));
2676 VALUE rv = rb_hash_new ();
2678 for (i = 0; r[i] != NULL; i+=2) {
2679 rb_hash_aset (rv, rb_str_new2 (r[i]), rb_str_new2 (r[i+1]));
2687 static VALUE ruby_guestfs_blockdev_setro (VALUE gv, VALUE devicev)
2690 Data_Get_Struct (gv, guestfs_h, g);
2692 rb_raise (rb_eArgError, "%s: used handle after closing it", "blockdev_setro");
2694 const char *device = StringValueCStr (devicev);
2696 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2697 "device", "blockdev_setro");
2701 r = guestfs_blockdev_setro (g, device);
2703 rb_raise (e_Error, "%s", guestfs_last_error (g));
2708 static VALUE ruby_guestfs_blockdev_setrw (VALUE gv, VALUE devicev)
2711 Data_Get_Struct (gv, guestfs_h, g);
2713 rb_raise (rb_eArgError, "%s: used handle after closing it", "blockdev_setrw");
2715 const char *device = StringValueCStr (devicev);
2717 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2718 "device", "blockdev_setrw");
2722 r = guestfs_blockdev_setrw (g, device);
2724 rb_raise (e_Error, "%s", guestfs_last_error (g));
2729 static VALUE ruby_guestfs_blockdev_getro (VALUE gv, VALUE devicev)
2732 Data_Get_Struct (gv, guestfs_h, g);
2734 rb_raise (rb_eArgError, "%s: used handle after closing it", "blockdev_getro");
2736 const char *device = StringValueCStr (devicev);
2738 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2739 "device", "blockdev_getro");
2743 r = guestfs_blockdev_getro (g, device);
2745 rb_raise (e_Error, "%s", guestfs_last_error (g));
2750 static VALUE ruby_guestfs_blockdev_getss (VALUE gv, VALUE devicev)
2753 Data_Get_Struct (gv, guestfs_h, g);
2755 rb_raise (rb_eArgError, "%s: used handle after closing it", "blockdev_getss");
2757 const char *device = StringValueCStr (devicev);
2759 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2760 "device", "blockdev_getss");
2764 r = guestfs_blockdev_getss (g, device);
2766 rb_raise (e_Error, "%s", guestfs_last_error (g));
2771 static VALUE ruby_guestfs_blockdev_getbsz (VALUE gv, VALUE devicev)
2774 Data_Get_Struct (gv, guestfs_h, g);
2776 rb_raise (rb_eArgError, "%s: used handle after closing it", "blockdev_getbsz");
2778 const char *device = StringValueCStr (devicev);
2780 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2781 "device", "blockdev_getbsz");
2785 r = guestfs_blockdev_getbsz (g, device);
2787 rb_raise (e_Error, "%s", guestfs_last_error (g));
2792 static VALUE ruby_guestfs_blockdev_setbsz (VALUE gv, VALUE devicev, VALUE blocksizev)
2795 Data_Get_Struct (gv, guestfs_h, g);
2797 rb_raise (rb_eArgError, "%s: used handle after closing it", "blockdev_setbsz");
2799 const char *device = StringValueCStr (devicev);
2801 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2802 "device", "blockdev_setbsz");
2803 int blocksize = NUM2INT (blocksizev);
2807 r = guestfs_blockdev_setbsz (g, device, blocksize);
2809 rb_raise (e_Error, "%s", guestfs_last_error (g));
2814 static VALUE ruby_guestfs_blockdev_getsz (VALUE gv, VALUE devicev)
2817 Data_Get_Struct (gv, guestfs_h, g);
2819 rb_raise (rb_eArgError, "%s: used handle after closing it", "blockdev_getsz");
2821 const char *device = StringValueCStr (devicev);
2823 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2824 "device", "blockdev_getsz");
2828 r = guestfs_blockdev_getsz (g, device);
2830 rb_raise (e_Error, "%s", guestfs_last_error (g));
2835 static VALUE ruby_guestfs_blockdev_getsize64 (VALUE gv, VALUE devicev)
2838 Data_Get_Struct (gv, guestfs_h, g);
2840 rb_raise (rb_eArgError, "%s: used handle after closing it", "blockdev_getsize64");
2842 const char *device = StringValueCStr (devicev);
2844 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2845 "device", "blockdev_getsize64");
2849 r = guestfs_blockdev_getsize64 (g, device);
2851 rb_raise (e_Error, "%s", guestfs_last_error (g));
2856 static VALUE ruby_guestfs_blockdev_flushbufs (VALUE gv, VALUE devicev)
2859 Data_Get_Struct (gv, guestfs_h, g);
2861 rb_raise (rb_eArgError, "%s: used handle after closing it", "blockdev_flushbufs");
2863 const char *device = StringValueCStr (devicev);
2865 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2866 "device", "blockdev_flushbufs");
2870 r = guestfs_blockdev_flushbufs (g, device);
2872 rb_raise (e_Error, "%s", guestfs_last_error (g));
2877 static VALUE ruby_guestfs_blockdev_rereadpt (VALUE gv, VALUE devicev)
2880 Data_Get_Struct (gv, guestfs_h, g);
2882 rb_raise (rb_eArgError, "%s: used handle after closing it", "blockdev_rereadpt");
2884 const char *device = StringValueCStr (devicev);
2886 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2887 "device", "blockdev_rereadpt");
2891 r = guestfs_blockdev_rereadpt (g, device);
2893 rb_raise (e_Error, "%s", guestfs_last_error (g));
2898 static VALUE ruby_guestfs_upload (VALUE gv, VALUE filenamev, VALUE remotefilenamev)
2901 Data_Get_Struct (gv, guestfs_h, g);
2903 rb_raise (rb_eArgError, "%s: used handle after closing it", "upload");
2905 const char *filename = StringValueCStr (filenamev);
2907 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2908 "filename", "upload");
2909 const char *remotefilename = StringValueCStr (remotefilenamev);
2910 if (!remotefilename)
2911 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2912 "remotefilename", "upload");
2916 r = guestfs_upload (g, filename, remotefilename);
2918 rb_raise (e_Error, "%s", guestfs_last_error (g));
2923 static VALUE ruby_guestfs_download (VALUE gv, VALUE remotefilenamev, VALUE filenamev)
2926 Data_Get_Struct (gv, guestfs_h, g);
2928 rb_raise (rb_eArgError, "%s: used handle after closing it", "download");
2930 const char *remotefilename = StringValueCStr (remotefilenamev);
2931 if (!remotefilename)
2932 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2933 "remotefilename", "download");
2934 const char *filename = StringValueCStr (filenamev);
2936 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2937 "filename", "download");
2941 r = guestfs_download (g, remotefilename, filename);
2943 rb_raise (e_Error, "%s", guestfs_last_error (g));
2948 static VALUE ruby_guestfs_checksum (VALUE gv, VALUE csumtypev, VALUE pathv)
2951 Data_Get_Struct (gv, guestfs_h, g);
2953 rb_raise (rb_eArgError, "%s: used handle after closing it", "checksum");
2955 const char *csumtype = StringValueCStr (csumtypev);
2957 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2958 "csumtype", "checksum");
2959 const char *path = StringValueCStr (pathv);
2961 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2962 "path", "checksum");
2966 r = guestfs_checksum (g, csumtype, path);
2968 rb_raise (e_Error, "%s", guestfs_last_error (g));
2970 VALUE rv = rb_str_new2 (r);
2975 static VALUE ruby_guestfs_tar_in (VALUE gv, VALUE tarfilev, VALUE directoryv)
2978 Data_Get_Struct (gv, guestfs_h, g);
2980 rb_raise (rb_eArgError, "%s: used handle after closing it", "tar_in");
2982 const char *tarfile = StringValueCStr (tarfilev);
2984 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2985 "tarfile", "tar_in");
2986 const char *directory = StringValueCStr (directoryv);
2988 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2989 "directory", "tar_in");
2993 r = guestfs_tar_in (g, tarfile, directory);
2995 rb_raise (e_Error, "%s", guestfs_last_error (g));
3000 static VALUE ruby_guestfs_tar_out (VALUE gv, VALUE directoryv, VALUE tarfilev)
3003 Data_Get_Struct (gv, guestfs_h, g);
3005 rb_raise (rb_eArgError, "%s: used handle after closing it", "tar_out");
3007 const char *directory = StringValueCStr (directoryv);
3009 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3010 "directory", "tar_out");
3011 const char *tarfile = StringValueCStr (tarfilev);
3013 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3014 "tarfile", "tar_out");
3018 r = guestfs_tar_out (g, directory, tarfile);
3020 rb_raise (e_Error, "%s", guestfs_last_error (g));
3025 static VALUE ruby_guestfs_tgz_in (VALUE gv, VALUE tarballv, VALUE directoryv)
3028 Data_Get_Struct (gv, guestfs_h, g);
3030 rb_raise (rb_eArgError, "%s: used handle after closing it", "tgz_in");
3032 const char *tarball = StringValueCStr (tarballv);
3034 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3035 "tarball", "tgz_in");
3036 const char *directory = StringValueCStr (directoryv);
3038 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3039 "directory", "tgz_in");
3043 r = guestfs_tgz_in (g, tarball, directory);
3045 rb_raise (e_Error, "%s", guestfs_last_error (g));
3050 static VALUE ruby_guestfs_tgz_out (VALUE gv, VALUE directoryv, VALUE tarballv)
3053 Data_Get_Struct (gv, guestfs_h, g);
3055 rb_raise (rb_eArgError, "%s: used handle after closing it", "tgz_out");
3057 const char *directory = StringValueCStr (directoryv);
3059 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3060 "directory", "tgz_out");
3061 const char *tarball = StringValueCStr (tarballv);
3063 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3064 "tarball", "tgz_out");
3068 r = guestfs_tgz_out (g, directory, tarball);
3070 rb_raise (e_Error, "%s", guestfs_last_error (g));
3075 static VALUE ruby_guestfs_mount_ro (VALUE gv, VALUE devicev, VALUE mountpointv)
3078 Data_Get_Struct (gv, guestfs_h, g);
3080 rb_raise (rb_eArgError, "%s: used handle after closing it", "mount_ro");
3082 const char *device = StringValueCStr (devicev);
3084 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3085 "device", "mount_ro");
3086 const char *mountpoint = StringValueCStr (mountpointv);
3088 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3089 "mountpoint", "mount_ro");
3093 r = guestfs_mount_ro (g, device, mountpoint);
3095 rb_raise (e_Error, "%s", guestfs_last_error (g));
3100 static VALUE ruby_guestfs_mount_options (VALUE gv, VALUE optionsv, VALUE devicev, VALUE mountpointv)
3103 Data_Get_Struct (gv, guestfs_h, g);
3105 rb_raise (rb_eArgError, "%s: used handle after closing it", "mount_options");
3107 const char *options = StringValueCStr (optionsv);
3109 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3110 "options", "mount_options");
3111 const char *device = StringValueCStr (devicev);
3113 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3114 "device", "mount_options");
3115 const char *mountpoint = StringValueCStr (mountpointv);
3117 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3118 "mountpoint", "mount_options");
3122 r = guestfs_mount_options (g, options, device, mountpoint);
3124 rb_raise (e_Error, "%s", guestfs_last_error (g));
3129 static VALUE ruby_guestfs_mount_vfs (VALUE gv, VALUE optionsv, VALUE vfstypev, VALUE devicev, VALUE mountpointv)
3132 Data_Get_Struct (gv, guestfs_h, g);
3134 rb_raise (rb_eArgError, "%s: used handle after closing it", "mount_vfs");
3136 const char *options = StringValueCStr (optionsv);
3138 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3139 "options", "mount_vfs");
3140 const char *vfstype = StringValueCStr (vfstypev);
3142 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3143 "vfstype", "mount_vfs");
3144 const char *device = StringValueCStr (devicev);
3146 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3147 "device", "mount_vfs");
3148 const char *mountpoint = StringValueCStr (mountpointv);
3150 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3151 "mountpoint", "mount_vfs");
3155 r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint);
3157 rb_raise (e_Error, "%s", guestfs_last_error (g));
3162 static VALUE ruby_guestfs_debug (VALUE gv, VALUE subcmdv, VALUE extraargsv)
3165 Data_Get_Struct (gv, guestfs_h, g);
3167 rb_raise (rb_eArgError, "%s: used handle after closing it", "debug");
3169 const char *subcmd = StringValueCStr (subcmdv);
3171 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3175 len = RARRAY_LEN (extraargsv);
3176 extraargs = guestfs_safe_malloc (g, sizeof (char *) * (len+1));
3177 for (i = 0; i < len; ++i) {
3178 VALUE v = rb_ary_entry (extraargsv, i);
3179 extraargs[i] = StringValueCStr (v);
3181 extraargs[len] = NULL;
3186 r = guestfs_debug (g, subcmd, extraargs);
3189 rb_raise (e_Error, "%s", guestfs_last_error (g));
3191 VALUE rv = rb_str_new2 (r);
3196 static VALUE ruby_guestfs_lvremove (VALUE gv, VALUE devicev)
3199 Data_Get_Struct (gv, guestfs_h, g);
3201 rb_raise (rb_eArgError, "%s: used handle after closing it", "lvremove");
3203 const char *device = StringValueCStr (devicev);
3205 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3206 "device", "lvremove");
3210 r = guestfs_lvremove (g, device);
3212 rb_raise (e_Error, "%s", guestfs_last_error (g));
3217 static VALUE ruby_guestfs_vgremove (VALUE gv, VALUE vgnamev)
3220 Data_Get_Struct (gv, guestfs_h, g);
3222 rb_raise (rb_eArgError, "%s: used handle after closing it", "vgremove");
3224 const char *vgname = StringValueCStr (vgnamev);
3226 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3227 "vgname", "vgremove");
3231 r = guestfs_vgremove (g, vgname);
3233 rb_raise (e_Error, "%s", guestfs_last_error (g));
3238 static VALUE ruby_guestfs_pvremove (VALUE gv, VALUE devicev)
3241 Data_Get_Struct (gv, guestfs_h, g);
3243 rb_raise (rb_eArgError, "%s: used handle after closing it", "pvremove");
3245 const char *device = StringValueCStr (devicev);
3247 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3248 "device", "pvremove");
3252 r = guestfs_pvremove (g, device);
3254 rb_raise (e_Error, "%s", guestfs_last_error (g));
3259 static VALUE ruby_guestfs_set_e2label (VALUE gv, VALUE devicev, VALUE labelv)
3262 Data_Get_Struct (gv, guestfs_h, g);
3264 rb_raise (rb_eArgError, "%s: used handle after closing it", "set_e2label");
3266 const char *device = StringValueCStr (devicev);
3268 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3269 "device", "set_e2label");
3270 const char *label = StringValueCStr (labelv);
3272 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3273 "label", "set_e2label");
3277 r = guestfs_set_e2label (g, device, label);
3279 rb_raise (e_Error, "%s", guestfs_last_error (g));
3284 static VALUE ruby_guestfs_get_e2label (VALUE gv, VALUE devicev)
3287 Data_Get_Struct (gv, guestfs_h, g);
3289 rb_raise (rb_eArgError, "%s: used handle after closing it", "get_e2label");
3291 const char *device = StringValueCStr (devicev);
3293 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3294 "device", "get_e2label");
3298 r = guestfs_get_e2label (g, device);
3300 rb_raise (e_Error, "%s", guestfs_last_error (g));
3302 VALUE rv = rb_str_new2 (r);
3307 static VALUE ruby_guestfs_set_e2uuid (VALUE gv, VALUE devicev, VALUE uuidv)
3310 Data_Get_Struct (gv, guestfs_h, g);
3312 rb_raise (rb_eArgError, "%s: used handle after closing it", "set_e2uuid");
3314 const char *device = StringValueCStr (devicev);
3316 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3317 "device", "set_e2uuid");
3318 const char *uuid = StringValueCStr (uuidv);
3320 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3321 "uuid", "set_e2uuid");
3325 r = guestfs_set_e2uuid (g, device, uuid);
3327 rb_raise (e_Error, "%s", guestfs_last_error (g));
3332 static VALUE ruby_guestfs_get_e2uuid (VALUE gv, VALUE devicev)
3335 Data_Get_Struct (gv, guestfs_h, g);
3337 rb_raise (rb_eArgError, "%s: used handle after closing it", "get_e2uuid");
3339 const char *device = StringValueCStr (devicev);
3341 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3342 "device", "get_e2uuid");
3346 r = guestfs_get_e2uuid (g, device);
3348 rb_raise (e_Error, "%s", guestfs_last_error (g));
3350 VALUE rv = rb_str_new2 (r);
3355 static VALUE ruby_guestfs_fsck (VALUE gv, VALUE fstypev, VALUE devicev)
3358 Data_Get_Struct (gv, guestfs_h, g);
3360 rb_raise (rb_eArgError, "%s: used handle after closing it", "fsck");
3362 const char *fstype = StringValueCStr (fstypev);
3364 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3366 const char *device = StringValueCStr (devicev);
3368 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3373 r = guestfs_fsck (g, fstype, device);
3375 rb_raise (e_Error, "%s", guestfs_last_error (g));
3380 static VALUE ruby_guestfs_zero (VALUE gv, VALUE devicev)
3383 Data_Get_Struct (gv, guestfs_h, g);
3385 rb_raise (rb_eArgError, "%s: used handle after closing it", "zero");
3387 const char *device = StringValueCStr (devicev);
3389 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3394 r = guestfs_zero (g, device);
3396 rb_raise (e_Error, "%s", guestfs_last_error (g));
3401 static VALUE ruby_guestfs_grub_install (VALUE gv, VALUE rootv, VALUE devicev)
3404 Data_Get_Struct (gv, guestfs_h, g);
3406 rb_raise (rb_eArgError, "%s: used handle after closing it", "grub_install");
3408 const char *root = StringValueCStr (rootv);
3410 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3411 "root", "grub_install");
3412 const char *device = StringValueCStr (devicev);
3414 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3415 "device", "grub_install");
3419 r = guestfs_grub_install (g, root, device);
3421 rb_raise (e_Error, "%s", guestfs_last_error (g));
3426 static VALUE ruby_guestfs_cp (VALUE gv, VALUE srcv, VALUE destv)
3429 Data_Get_Struct (gv, guestfs_h, g);
3431 rb_raise (rb_eArgError, "%s: used handle after closing it", "cp");
3433 const char *src = StringValueCStr (srcv);
3435 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3437 const char *dest = StringValueCStr (destv);
3439 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3444 r = guestfs_cp (g, src, dest);
3446 rb_raise (e_Error, "%s", guestfs_last_error (g));
3451 static VALUE ruby_guestfs_cp_a (VALUE gv, VALUE srcv, VALUE destv)
3454 Data_Get_Struct (gv, guestfs_h, g);
3456 rb_raise (rb_eArgError, "%s: used handle after closing it", "cp_a");
3458 const char *src = StringValueCStr (srcv);
3460 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3462 const char *dest = StringValueCStr (destv);
3464 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3469 r = guestfs_cp_a (g, src, dest);
3471 rb_raise (e_Error, "%s", guestfs_last_error (g));
3476 static VALUE ruby_guestfs_mv (VALUE gv, VALUE srcv, VALUE destv)
3479 Data_Get_Struct (gv, guestfs_h, g);
3481 rb_raise (rb_eArgError, "%s: used handle after closing it", "mv");
3483 const char *src = StringValueCStr (srcv);
3485 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3487 const char *dest = StringValueCStr (destv);
3489 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3494 r = guestfs_mv (g, src, dest);
3496 rb_raise (e_Error, "%s", guestfs_last_error (g));
3501 static VALUE ruby_guestfs_drop_caches (VALUE gv, VALUE whattodropv)
3504 Data_Get_Struct (gv, guestfs_h, g);
3506 rb_raise (rb_eArgError, "%s: used handle after closing it", "drop_caches");
3508 int whattodrop = NUM2INT (whattodropv);
3512 r = guestfs_drop_caches (g, whattodrop);
3514 rb_raise (e_Error, "%s", guestfs_last_error (g));
3519 static VALUE ruby_guestfs_dmesg (VALUE gv)
3522 Data_Get_Struct (gv, guestfs_h, g);
3524 rb_raise (rb_eArgError, "%s: used handle after closing it", "dmesg");
3529 r = guestfs_dmesg (g);
3531 rb_raise (e_Error, "%s", guestfs_last_error (g));
3533 VALUE rv = rb_str_new2 (r);
3538 static VALUE ruby_guestfs_ping_daemon (VALUE gv)
3541 Data_Get_Struct (gv, guestfs_h, g);
3543 rb_raise (rb_eArgError, "%s: used handle after closing it", "ping_daemon");
3548 r = guestfs_ping_daemon (g);
3550 rb_raise (e_Error, "%s", guestfs_last_error (g));
3555 static VALUE ruby_guestfs_equal (VALUE gv, VALUE file1v, VALUE file2v)
3558 Data_Get_Struct (gv, guestfs_h, g);
3560 rb_raise (rb_eArgError, "%s: used handle after closing it", "equal");
3562 const char *file1 = StringValueCStr (file1v);
3564 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3566 const char *file2 = StringValueCStr (file2v);
3568 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3573 r = guestfs_equal (g, file1, file2);
3575 rb_raise (e_Error, "%s", guestfs_last_error (g));
3580 static VALUE ruby_guestfs_strings (VALUE gv, VALUE pathv)
3583 Data_Get_Struct (gv, guestfs_h, g);
3585 rb_raise (rb_eArgError, "%s: used handle after closing it", "strings");
3587 const char *path = StringValueCStr (pathv);
3589 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3594 r = guestfs_strings (g, path);
3596 rb_raise (e_Error, "%s", guestfs_last_error (g));
3599 for (i = 0; r[i] != NULL; ++i) len++;
3600 VALUE rv = rb_ary_new2 (len);
3601 for (i = 0; r[i] != NULL; ++i) {
3602 rb_ary_push (rv, rb_str_new2 (r[i]));
3609 static VALUE ruby_guestfs_strings_e (VALUE gv, VALUE encodingv, VALUE pathv)
3612 Data_Get_Struct (gv, guestfs_h, g);
3614 rb_raise (rb_eArgError, "%s: used handle after closing it", "strings_e");
3616 const char *encoding = StringValueCStr (encodingv);
3618 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3619 "encoding", "strings_e");
3620 const char *path = StringValueCStr (pathv);
3622 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3623 "path", "strings_e");
3627 r = guestfs_strings_e (g, encoding, path);
3629 rb_raise (e_Error, "%s", guestfs_last_error (g));
3632 for (i = 0; r[i] != NULL; ++i) len++;
3633 VALUE rv = rb_ary_new2 (len);
3634 for (i = 0; r[i] != NULL; ++i) {
3635 rb_ary_push (rv, rb_str_new2 (r[i]));
3642 static VALUE ruby_guestfs_hexdump (VALUE gv, VALUE pathv)
3645 Data_Get_Struct (gv, guestfs_h, g);
3647 rb_raise (rb_eArgError, "%s: used handle after closing it", "hexdump");
3649 const char *path = StringValueCStr (pathv);
3651 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3656 r = guestfs_hexdump (g, path);
3658 rb_raise (e_Error, "%s", guestfs_last_error (g));
3660 VALUE rv = rb_str_new2 (r);
3665 static VALUE ruby_guestfs_zerofree (VALUE gv, VALUE devicev)
3668 Data_Get_Struct (gv, guestfs_h, g);
3670 rb_raise (rb_eArgError, "%s: used handle after closing it", "zerofree");
3672 const char *device = StringValueCStr (devicev);
3674 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3675 "device", "zerofree");
3679 r = guestfs_zerofree (g, device);
3681 rb_raise (e_Error, "%s", guestfs_last_error (g));
3686 static VALUE ruby_guestfs_pvresize (VALUE gv, VALUE devicev)
3689 Data_Get_Struct (gv, guestfs_h, g);
3691 rb_raise (rb_eArgError, "%s: used handle after closing it", "pvresize");
3693 const char *device = StringValueCStr (devicev);
3695 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3696 "device", "pvresize");
3700 r = guestfs_pvresize (g, device);
3702 rb_raise (e_Error, "%s", guestfs_last_error (g));
3707 static VALUE ruby_guestfs_sfdisk_N (VALUE gv, VALUE devicev, VALUE nv, VALUE cylsv, VALUE headsv, VALUE sectorsv, VALUE linev)
3710 Data_Get_Struct (gv, guestfs_h, g);
3712 rb_raise (rb_eArgError, "%s: used handle after closing it", "sfdisk_N");
3714 const char *device = StringValueCStr (devicev);
3716 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3717 "device", "sfdisk_N");
3718 int n = NUM2INT (nv);
3719 int cyls = NUM2INT (cylsv);
3720 int heads = NUM2INT (headsv);
3721 int sectors = NUM2INT (sectorsv);
3722 const char *line = StringValueCStr (linev);
3724 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3725 "line", "sfdisk_N");
3729 r = guestfs_sfdisk_N (g, device, n, cyls, heads, sectors, line);
3731 rb_raise (e_Error, "%s", guestfs_last_error (g));
3736 static VALUE ruby_guestfs_sfdisk_l (VALUE gv, VALUE devicev)
3739 Data_Get_Struct (gv, guestfs_h, g);
3741 rb_raise (rb_eArgError, "%s: used handle after closing it", "sfdisk_l");
3743 const char *device = StringValueCStr (devicev);
3745 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3746 "device", "sfdisk_l");
3750 r = guestfs_sfdisk_l (g, device);
3752 rb_raise (e_Error, "%s", guestfs_last_error (g));
3754 VALUE rv = rb_str_new2 (r);
3759 static VALUE ruby_guestfs_sfdisk_kernel_geometry (VALUE gv, VALUE devicev)
3762 Data_Get_Struct (gv, guestfs_h, g);
3764 rb_raise (rb_eArgError, "%s: used handle after closing it", "sfdisk_kernel_geometry");
3766 const char *device = StringValueCStr (devicev);
3768 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3769 "device", "sfdisk_kernel_geometry");
3773 r = guestfs_sfdisk_kernel_geometry (g, device);
3775 rb_raise (e_Error, "%s", guestfs_last_error (g));
3777 VALUE rv = rb_str_new2 (r);
3782 static VALUE ruby_guestfs_sfdisk_disk_geometry (VALUE gv, VALUE devicev)
3785 Data_Get_Struct (gv, guestfs_h, g);
3787 rb_raise (rb_eArgError, "%s: used handle after closing it", "sfdisk_disk_geometry");
3789 const char *device = StringValueCStr (devicev);
3791 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3792 "device", "sfdisk_disk_geometry");
3796 r = guestfs_sfdisk_disk_geometry (g, device);
3798 rb_raise (e_Error, "%s", guestfs_last_error (g));
3800 VALUE rv = rb_str_new2 (r);
3805 static VALUE ruby_guestfs_vg_activate_all (VALUE gv, VALUE activatev)
3808 Data_Get_Struct (gv, guestfs_h, g);
3810 rb_raise (rb_eArgError, "%s: used handle after closing it", "vg_activate_all");
3812 int activate = NUM2INT (activatev);
3816 r = guestfs_vg_activate_all (g, activate);
3818 rb_raise (e_Error, "%s", guestfs_last_error (g));
3823 static VALUE ruby_guestfs_vg_activate (VALUE gv, VALUE activatev, VALUE volgroupsv)
3826 Data_Get_Struct (gv, guestfs_h, g);
3828 rb_raise (rb_eArgError, "%s: used handle after closing it", "vg_activate");
3830 int activate = NUM2INT (activatev);
3833 len = RARRAY_LEN (volgroupsv);
3834 volgroups = guestfs_safe_malloc (g, sizeof (char *) * (len+1));
3835 for (i = 0; i < len; ++i) {
3836 VALUE v = rb_ary_entry (volgroupsv, i);
3837 volgroups[i] = StringValueCStr (v);
3839 volgroups[len] = NULL;
3844 r = guestfs_vg_activate (g, activate, volgroups);
3847 rb_raise (e_Error, "%s", guestfs_last_error (g));
3852 static VALUE ruby_guestfs_lvresize (VALUE gv, VALUE devicev, VALUE mbytesv)
3855 Data_Get_Struct (gv, guestfs_h, g);
3857 rb_raise (rb_eArgError, "%s: used handle after closing it", "lvresize");
3859 const char *device = StringValueCStr (devicev);
3861 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3862 "device", "lvresize");
3863 int mbytes = NUM2INT (mbytesv);
3867 r = guestfs_lvresize (g, device, mbytes);
3869 rb_raise (e_Error, "%s", guestfs_last_error (g));
3874 static VALUE ruby_guestfs_resize2fs (VALUE gv, VALUE devicev)
3877 Data_Get_Struct (gv, guestfs_h, g);
3879 rb_raise (rb_eArgError, "%s: used handle after closing it", "resize2fs");
3881 const char *device = StringValueCStr (devicev);
3883 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3884 "device", "resize2fs");
3888 r = guestfs_resize2fs (g, device);
3890 rb_raise (e_Error, "%s", guestfs_last_error (g));
3895 static VALUE ruby_guestfs_find (VALUE gv, VALUE directoryv)
3898 Data_Get_Struct (gv, guestfs_h, g);
3900 rb_raise (rb_eArgError, "%s: used handle after closing it", "find");
3902 const char *directory = StringValueCStr (directoryv);
3904 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3905 "directory", "find");
3909 r = guestfs_find (g, directory);
3911 rb_raise (e_Error, "%s", guestfs_last_error (g));
3914 for (i = 0; r[i] != NULL; ++i) len++;
3915 VALUE rv = rb_ary_new2 (len);
3916 for (i = 0; r[i] != NULL; ++i) {
3917 rb_ary_push (rv, rb_str_new2 (r[i]));
3924 static VALUE ruby_guestfs_e2fsck_f (VALUE gv, VALUE devicev)
3927 Data_Get_Struct (gv, guestfs_h, g);
3929 rb_raise (rb_eArgError, "%s: used handle after closing it", "e2fsck_f");
3931 const char *device = StringValueCStr (devicev);
3933 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3934 "device", "e2fsck_f");
3938 r = guestfs_e2fsck_f (g, device);
3940 rb_raise (e_Error, "%s", guestfs_last_error (g));
3945 /* Initialize the module. */
3946 void Init__guestfs ()
3948 m_guestfs = rb_define_module ("Guestfs");
3949 c_guestfs = rb_define_class_under (m_guestfs, "Guestfs", rb_cObject);
3950 e_Error = rb_define_class_under (m_guestfs, "Error", rb_eStandardError);
3952 rb_define_module_function (m_guestfs, "create", ruby_guestfs_create, 0);
3953 rb_define_method (c_guestfs, "close", ruby_guestfs_close, 0);
3955 rb_define_method (c_guestfs, "test0",
3956 ruby_guestfs_test0, 7);
3957 rb_define_method (c_guestfs, "test0rint",
3958 ruby_guestfs_test0rint, 1);
3959 rb_define_method (c_guestfs, "test0rinterr",
3960 ruby_guestfs_test0rinterr, 0);
3961 rb_define_method (c_guestfs, "test0rint64",
3962 ruby_guestfs_test0rint64, 1);
3963 rb_define_method (c_guestfs, "test0rint64err",
3964 ruby_guestfs_test0rint64err, 0);
3965 rb_define_method (c_guestfs, "test0rbool",
3966 ruby_guestfs_test0rbool, 1);
3967 rb_define_method (c_guestfs, "test0rboolerr",
3968 ruby_guestfs_test0rboolerr, 0);
3969 rb_define_method (c_guestfs, "test0rconststring",
3970 ruby_guestfs_test0rconststring, 1);
3971 rb_define_method (c_guestfs, "test0rconststringerr",
3972 ruby_guestfs_test0rconststringerr, 0);
3973 rb_define_method (c_guestfs, "test0rstring",
3974 ruby_guestfs_test0rstring, 1);
3975 rb_define_method (c_guestfs, "test0rstringerr",
3976 ruby_guestfs_test0rstringerr, 0);
3977 rb_define_method (c_guestfs, "test0rstringlist",
3978 ruby_guestfs_test0rstringlist, 1);
3979 rb_define_method (c_guestfs, "test0rstringlisterr",
3980 ruby_guestfs_test0rstringlisterr, 0);
3981 rb_define_method (c_guestfs, "test0rintbool",
3982 ruby_guestfs_test0rintbool, 1);
3983 rb_define_method (c_guestfs, "test0rintboolerr",
3984 ruby_guestfs_test0rintboolerr, 0);
3985 rb_define_method (c_guestfs, "test0rpvlist",
3986 ruby_guestfs_test0rpvlist, 1);
3987 rb_define_method (c_guestfs, "test0rpvlisterr",
3988 ruby_guestfs_test0rpvlisterr, 0);
3989 rb_define_method (c_guestfs, "test0rvglist",
3990 ruby_guestfs_test0rvglist, 1);
3991 rb_define_method (c_guestfs, "test0rvglisterr",
3992 ruby_guestfs_test0rvglisterr, 0);
3993 rb_define_method (c_guestfs, "test0rlvlist",
3994 ruby_guestfs_test0rlvlist, 1);
3995 rb_define_method (c_guestfs, "test0rlvlisterr",
3996 ruby_guestfs_test0rlvlisterr, 0);
3997 rb_define_method (c_guestfs, "test0rstat",
3998 ruby_guestfs_test0rstat, 1);
3999 rb_define_method (c_guestfs, "test0rstaterr",
4000 ruby_guestfs_test0rstaterr, 0);
4001 rb_define_method (c_guestfs, "test0rstatvfs",
4002 ruby_guestfs_test0rstatvfs, 1);
4003 rb_define_method (c_guestfs, "test0rstatvfserr",
4004 ruby_guestfs_test0rstatvfserr, 0);
4005 rb_define_method (c_guestfs, "test0rhashtable",
4006 ruby_guestfs_test0rhashtable, 1);
4007 rb_define_method (c_guestfs, "test0rhashtableerr",
4008 ruby_guestfs_test0rhashtableerr, 0);
4009 rb_define_method (c_guestfs, "launch",
4010 ruby_guestfs_launch, 0);
4011 rb_define_method (c_guestfs, "wait_ready",
4012 ruby_guestfs_wait_ready, 0);
4013 rb_define_method (c_guestfs, "kill_subprocess",
4014 ruby_guestfs_kill_subprocess, 0);
4015 rb_define_method (c_guestfs, "add_drive",
4016 ruby_guestfs_add_drive, 1);
4017 rb_define_method (c_guestfs, "add_cdrom",
4018 ruby_guestfs_add_cdrom, 1);
4019 rb_define_method (c_guestfs, "config",
4020 ruby_guestfs_config, 2);
4021 rb_define_method (c_guestfs, "set_qemu",
4022 ruby_guestfs_set_qemu, 1);
4023 rb_define_method (c_guestfs, "get_qemu",
4024 ruby_guestfs_get_qemu, 0);
4025 rb_define_method (c_guestfs, "set_path",
4026 ruby_guestfs_set_path, 1);
4027 rb_define_method (c_guestfs, "get_path",
4028 ruby_guestfs_get_path, 0);
4029 rb_define_method (c_guestfs, "set_append",
4030 ruby_guestfs_set_append, 1);
4031 rb_define_method (c_guestfs, "get_append",
4032 ruby_guestfs_get_append, 0);
4033 rb_define_method (c_guestfs, "set_autosync",
4034 ruby_guestfs_set_autosync, 1);
4035 rb_define_method (c_guestfs, "get_autosync",
4036 ruby_guestfs_get_autosync, 0);
4037 rb_define_method (c_guestfs, "set_verbose",
4038 ruby_guestfs_set_verbose, 1);
4039 rb_define_method (c_guestfs, "get_verbose",
4040 ruby_guestfs_get_verbose, 0);
4041 rb_define_method (c_guestfs, "is_ready",
4042 ruby_guestfs_is_ready, 0);
4043 rb_define_method (c_guestfs, "is_config",
4044 ruby_guestfs_is_config, 0);
4045 rb_define_method (c_guestfs, "is_launching",
4046 ruby_guestfs_is_launching, 0);
4047 rb_define_method (c_guestfs, "is_busy",
4048 ruby_guestfs_is_busy, 0);
4049 rb_define_method (c_guestfs, "get_state",
4050 ruby_guestfs_get_state, 0);
4051 rb_define_method (c_guestfs, "set_busy",
4052 ruby_guestfs_set_busy, 0);
4053 rb_define_method (c_guestfs, "set_ready",
4054 ruby_guestfs_set_ready, 0);
4055 rb_define_method (c_guestfs, "end_busy",
4056 ruby_guestfs_end_busy, 0);
4057 rb_define_method (c_guestfs, "mount",
4058 ruby_guestfs_mount, 2);
4059 rb_define_method (c_guestfs, "sync",
4060 ruby_guestfs_sync, 0);
4061 rb_define_method (c_guestfs, "touch",
4062 ruby_guestfs_touch, 1);
4063 rb_define_method (c_guestfs, "cat",
4064 ruby_guestfs_cat, 1);
4065 rb_define_method (c_guestfs, "ll",
4066 ruby_guestfs_ll, 1);
4067 rb_define_method (c_guestfs, "ls",
4068 ruby_guestfs_ls, 1);
4069 rb_define_method (c_guestfs, "list_devices",
4070 ruby_guestfs_list_devices, 0);
4071 rb_define_method (c_guestfs, "list_partitions",
4072 ruby_guestfs_list_partitions, 0);
4073 rb_define_method (c_guestfs, "pvs",
4074 ruby_guestfs_pvs, 0);
4075 rb_define_method (c_guestfs, "vgs",
4076 ruby_guestfs_vgs, 0);
4077 rb_define_method (c_guestfs, "lvs",
4078 ruby_guestfs_lvs, 0);
4079 rb_define_method (c_guestfs, "pvs_full",
4080 ruby_guestfs_pvs_full, 0);
4081 rb_define_method (c_guestfs, "vgs_full",
4082 ruby_guestfs_vgs_full, 0);
4083 rb_define_method (c_guestfs, "lvs_full",
4084 ruby_guestfs_lvs_full, 0);
4085 rb_define_method (c_guestfs, "read_lines",
4086 ruby_guestfs_read_lines, 1);
4087 rb_define_method (c_guestfs, "aug_init",
4088 ruby_guestfs_aug_init, 2);
4089 rb_define_method (c_guestfs, "aug_close",
4090 ruby_guestfs_aug_close, 0);
4091 rb_define_method (c_guestfs, "aug_defvar",
4092 ruby_guestfs_aug_defvar, 2);
4093 rb_define_method (c_guestfs, "aug_defnode",
4094 ruby_guestfs_aug_defnode, 3);
4095 rb_define_method (c_guestfs, "aug_get",
4096 ruby_guestfs_aug_get, 1);
4097 rb_define_method (c_guestfs, "aug_set",
4098 ruby_guestfs_aug_set, 2);
4099 rb_define_method (c_guestfs, "aug_insert",
4100 ruby_guestfs_aug_insert, 3);
4101 rb_define_method (c_guestfs, "aug_rm",
4102 ruby_guestfs_aug_rm, 1);
4103 rb_define_method (c_guestfs, "aug_mv",
4104 ruby_guestfs_aug_mv, 2);
4105 rb_define_method (c_guestfs, "aug_match",
4106 ruby_guestfs_aug_match, 1);
4107 rb_define_method (c_guestfs, "aug_save",
4108 ruby_guestfs_aug_save, 0);
4109 rb_define_method (c_guestfs, "aug_load",
4110 ruby_guestfs_aug_load, 0);
4111 rb_define_method (c_guestfs, "aug_ls",
4112 ruby_guestfs_aug_ls, 1);
4113 rb_define_method (c_guestfs, "rm",
4114 ruby_guestfs_rm, 1);
4115 rb_define_method (c_guestfs, "rmdir",
4116 ruby_guestfs_rmdir, 1);
4117 rb_define_method (c_guestfs, "rm_rf",
4118 ruby_guestfs_rm_rf, 1);
4119 rb_define_method (c_guestfs, "mkdir",
4120 ruby_guestfs_mkdir, 1);
4121 rb_define_method (c_guestfs, "mkdir_p",
4122 ruby_guestfs_mkdir_p, 1);
4123 rb_define_method (c_guestfs, "chmod",
4124 ruby_guestfs_chmod, 2);
4125 rb_define_method (c_guestfs, "chown",
4126 ruby_guestfs_chown, 3);
4127 rb_define_method (c_guestfs, "exists",
4128 ruby_guestfs_exists, 1);
4129 rb_define_method (c_guestfs, "is_file",
4130 ruby_guestfs_is_file, 1);
4131 rb_define_method (c_guestfs, "is_dir",
4132 ruby_guestfs_is_dir, 1);
4133 rb_define_method (c_guestfs, "pvcreate",
4134 ruby_guestfs_pvcreate, 1);
4135 rb_define_method (c_guestfs, "vgcreate",
4136 ruby_guestfs_vgcreate, 2);
4137 rb_define_method (c_guestfs, "lvcreate",
4138 ruby_guestfs_lvcreate, 3);
4139 rb_define_method (c_guestfs, "mkfs",
4140 ruby_guestfs_mkfs, 2);
4141 rb_define_method (c_guestfs, "sfdisk",
4142 ruby_guestfs_sfdisk, 5);
4143 rb_define_method (c_guestfs, "write_file",
4144 ruby_guestfs_write_file, 3);
4145 rb_define_method (c_guestfs, "umount",
4146 ruby_guestfs_umount, 1);
4147 rb_define_method (c_guestfs, "mounts",
4148 ruby_guestfs_mounts, 0);
4149 rb_define_method (c_guestfs, "umount_all",
4150 ruby_guestfs_umount_all, 0);
4151 rb_define_method (c_guestfs, "lvm_remove_all",
4152 ruby_guestfs_lvm_remove_all, 0);
4153 rb_define_method (c_guestfs, "file",
4154 ruby_guestfs_file, 1);
4155 rb_define_method (c_guestfs, "command",
4156 ruby_guestfs_command, 1);
4157 rb_define_method (c_guestfs, "command_lines",
4158 ruby_guestfs_command_lines, 1);
4159 rb_define_method (c_guestfs, "stat",
4160 ruby_guestfs_stat, 1);
4161 rb_define_method (c_guestfs, "lstat",
4162 ruby_guestfs_lstat, 1);
4163 rb_define_method (c_guestfs, "statvfs",
4164 ruby_guestfs_statvfs, 1);
4165 rb_define_method (c_guestfs, "tune2fs_l",
4166 ruby_guestfs_tune2fs_l, 1);
4167 rb_define_method (c_guestfs, "blockdev_setro",
4168 ruby_guestfs_blockdev_setro, 1);
4169 rb_define_method (c_guestfs, "blockdev_setrw",
4170 ruby_guestfs_blockdev_setrw, 1);
4171 rb_define_method (c_guestfs, "blockdev_getro",
4172 ruby_guestfs_blockdev_getro, 1);
4173 rb_define_method (c_guestfs, "blockdev_getss",
4174 ruby_guestfs_blockdev_getss, 1);
4175 rb_define_method (c_guestfs, "blockdev_getbsz",
4176 ruby_guestfs_blockdev_getbsz, 1);
4177 rb_define_method (c_guestfs, "blockdev_setbsz",
4178 ruby_guestfs_blockdev_setbsz, 2);
4179 rb_define_method (c_guestfs, "blockdev_getsz",
4180 ruby_guestfs_blockdev_getsz, 1);
4181 rb_define_method (c_guestfs, "blockdev_getsize64",
4182 ruby_guestfs_blockdev_getsize64, 1);
4183 rb_define_method (c_guestfs, "blockdev_flushbufs",
4184 ruby_guestfs_blockdev_flushbufs, 1);
4185 rb_define_method (c_guestfs, "blockdev_rereadpt",
4186 ruby_guestfs_blockdev_rereadpt, 1);
4187 rb_define_method (c_guestfs, "upload",
4188 ruby_guestfs_upload, 2);
4189 rb_define_method (c_guestfs, "download",
4190 ruby_guestfs_download, 2);
4191 rb_define_method (c_guestfs, "checksum",
4192 ruby_guestfs_checksum, 2);
4193 rb_define_method (c_guestfs, "tar_in",
4194 ruby_guestfs_tar_in, 2);
4195 rb_define_method (c_guestfs, "tar_out",
4196 ruby_guestfs_tar_out, 2);
4197 rb_define_method (c_guestfs, "tgz_in",
4198 ruby_guestfs_tgz_in, 2);
4199 rb_define_method (c_guestfs, "tgz_out",
4200 ruby_guestfs_tgz_out, 2);
4201 rb_define_method (c_guestfs, "mount_ro",
4202 ruby_guestfs_mount_ro, 2);
4203 rb_define_method (c_guestfs, "mount_options",
4204 ruby_guestfs_mount_options, 3);
4205 rb_define_method (c_guestfs, "mount_vfs",
4206 ruby_guestfs_mount_vfs, 4);
4207 rb_define_method (c_guestfs, "debug",
4208 ruby_guestfs_debug, 2);
4209 rb_define_method (c_guestfs, "lvremove",
4210 ruby_guestfs_lvremove, 1);
4211 rb_define_method (c_guestfs, "vgremove",
4212 ruby_guestfs_vgremove, 1);
4213 rb_define_method (c_guestfs, "pvremove",
4214 ruby_guestfs_pvremove, 1);
4215 rb_define_method (c_guestfs, "set_e2label",
4216 ruby_guestfs_set_e2label, 2);
4217 rb_define_method (c_guestfs, "get_e2label",
4218 ruby_guestfs_get_e2label, 1);
4219 rb_define_method (c_guestfs, "set_e2uuid",
4220 ruby_guestfs_set_e2uuid, 2);
4221 rb_define_method (c_guestfs, "get_e2uuid",
4222 ruby_guestfs_get_e2uuid, 1);
4223 rb_define_method (c_guestfs, "fsck",
4224 ruby_guestfs_fsck, 2);
4225 rb_define_method (c_guestfs, "zero",
4226 ruby_guestfs_zero, 1);
4227 rb_define_method (c_guestfs, "grub_install",
4228 ruby_guestfs_grub_install, 2);
4229 rb_define_method (c_guestfs, "cp",
4230 ruby_guestfs_cp, 2);
4231 rb_define_method (c_guestfs, "cp_a",
4232 ruby_guestfs_cp_a, 2);
4233 rb_define_method (c_guestfs, "mv",
4234 ruby_guestfs_mv, 2);
4235 rb_define_method (c_guestfs, "drop_caches",
4236 ruby_guestfs_drop_caches, 1);
4237 rb_define_method (c_guestfs, "dmesg",
4238 ruby_guestfs_dmesg, 0);
4239 rb_define_method (c_guestfs, "ping_daemon",
4240 ruby_guestfs_ping_daemon, 0);
4241 rb_define_method (c_guestfs, "equal",
4242 ruby_guestfs_equal, 2);
4243 rb_define_method (c_guestfs, "strings",
4244 ruby_guestfs_strings, 1);
4245 rb_define_method (c_guestfs, "strings_e",
4246 ruby_guestfs_strings_e, 2);
4247 rb_define_method (c_guestfs, "hexdump",
4248 ruby_guestfs_hexdump, 1);
4249 rb_define_method (c_guestfs, "zerofree",
4250 ruby_guestfs_zerofree, 1);
4251 rb_define_method (c_guestfs, "pvresize",
4252 ruby_guestfs_pvresize, 1);
4253 rb_define_method (c_guestfs, "sfdisk_N",
4254 ruby_guestfs_sfdisk_N, 6);
4255 rb_define_method (c_guestfs, "sfdisk_l",
4256 ruby_guestfs_sfdisk_l, 1);
4257 rb_define_method (c_guestfs, "sfdisk_kernel_geometry",
4258 ruby_guestfs_sfdisk_kernel_geometry, 1);
4259 rb_define_method (c_guestfs, "sfdisk_disk_geometry",
4260 ruby_guestfs_sfdisk_disk_geometry, 1);
4261 rb_define_method (c_guestfs, "vg_activate_all",
4262 ruby_guestfs_vg_activate_all, 1);
4263 rb_define_method (c_guestfs, "vg_activate",
4264 ruby_guestfs_vg_activate, 2);
4265 rb_define_method (c_guestfs, "lvresize",
4266 ruby_guestfs_lvresize, 2);
4267 rb_define_method (c_guestfs, "resize2fs",
4268 ruby_guestfs_resize2fs, 1);
4269 rb_define_method (c_guestfs, "find",
4270 ruby_guestfs_find, 1);
4271 rb_define_method (c_guestfs, "e2fsck_f",
4272 ruby_guestfs_e2fsck_f, 1);