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 Check_Type (strv, T_STRING);
82 const char *str = StringValueCStr (strv);
84 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
86 const char *optstr = !NIL_P (optstrv) ? StringValueCStr (optstrv) : NULL;
88 Check_Type (strlistv, T_ARRAY);
91 len = RARRAY_LEN (strlistv);
92 strlist = guestfs_safe_malloc (g, sizeof (char *) * (len+1));
93 for (i = 0; i < len; ++i) {
94 VALUE v = rb_ary_entry (strlistv, i);
95 strlist[i] = StringValueCStr (v);
100 int integer = NUM2INT (integerv);
101 Check_Type (fileinv, T_STRING);
102 const char *filein = StringValueCStr (fileinv);
104 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
106 Check_Type (fileoutv, T_STRING);
107 const char *fileout = StringValueCStr (fileoutv);
109 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
114 r = guestfs_test0 (g, str, optstr, strlist, b, integer, filein, fileout);
117 rb_raise (e_Error, "%s", guestfs_last_error (g));
122 static VALUE ruby_guestfs_test0rint (VALUE gv, VALUE valv)
125 Data_Get_Struct (gv, guestfs_h, g);
127 rb_raise (rb_eArgError, "%s: used handle after closing it", "test0rint");
129 Check_Type (valv, T_STRING);
130 const char *val = StringValueCStr (valv);
132 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
137 r = guestfs_test0rint (g, val);
139 rb_raise (e_Error, "%s", guestfs_last_error (g));
144 static VALUE ruby_guestfs_test0rinterr (VALUE gv)
147 Data_Get_Struct (gv, guestfs_h, g);
149 rb_raise (rb_eArgError, "%s: used handle after closing it", "test0rinterr");
154 r = guestfs_test0rinterr (g);
156 rb_raise (e_Error, "%s", guestfs_last_error (g));
161 static VALUE ruby_guestfs_test0rint64 (VALUE gv, VALUE valv)
164 Data_Get_Struct (gv, guestfs_h, g);
166 rb_raise (rb_eArgError, "%s: used handle after closing it", "test0rint64");
168 Check_Type (valv, T_STRING);
169 const char *val = StringValueCStr (valv);
171 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
172 "val", "test0rint64");
176 r = guestfs_test0rint64 (g, val);
178 rb_raise (e_Error, "%s", guestfs_last_error (g));
183 static VALUE ruby_guestfs_test0rint64err (VALUE gv)
186 Data_Get_Struct (gv, guestfs_h, g);
188 rb_raise (rb_eArgError, "%s: used handle after closing it", "test0rint64err");
193 r = guestfs_test0rint64err (g);
195 rb_raise (e_Error, "%s", guestfs_last_error (g));
200 static VALUE ruby_guestfs_test0rbool (VALUE gv, VALUE valv)
203 Data_Get_Struct (gv, guestfs_h, g);
205 rb_raise (rb_eArgError, "%s: used handle after closing it", "test0rbool");
207 Check_Type (valv, T_STRING);
208 const char *val = StringValueCStr (valv);
210 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
211 "val", "test0rbool");
215 r = guestfs_test0rbool (g, val);
217 rb_raise (e_Error, "%s", guestfs_last_error (g));
222 static VALUE ruby_guestfs_test0rboolerr (VALUE gv)
225 Data_Get_Struct (gv, guestfs_h, g);
227 rb_raise (rb_eArgError, "%s: used handle after closing it", "test0rboolerr");
232 r = guestfs_test0rboolerr (g);
234 rb_raise (e_Error, "%s", guestfs_last_error (g));
239 static VALUE ruby_guestfs_test0rconststring (VALUE gv, VALUE valv)
242 Data_Get_Struct (gv, guestfs_h, g);
244 rb_raise (rb_eArgError, "%s: used handle after closing it", "test0rconststring");
246 Check_Type (valv, T_STRING);
247 const char *val = StringValueCStr (valv);
249 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
250 "val", "test0rconststring");
254 r = guestfs_test0rconststring (g, val);
256 rb_raise (e_Error, "%s", guestfs_last_error (g));
258 return rb_str_new2 (r);
261 static VALUE ruby_guestfs_test0rconststringerr (VALUE gv)
264 Data_Get_Struct (gv, guestfs_h, g);
266 rb_raise (rb_eArgError, "%s: used handle after closing it", "test0rconststringerr");
271 r = guestfs_test0rconststringerr (g);
273 rb_raise (e_Error, "%s", guestfs_last_error (g));
275 return rb_str_new2 (r);
278 static VALUE ruby_guestfs_test0rstring (VALUE gv, VALUE valv)
281 Data_Get_Struct (gv, guestfs_h, g);
283 rb_raise (rb_eArgError, "%s: used handle after closing it", "test0rstring");
285 Check_Type (valv, T_STRING);
286 const char *val = StringValueCStr (valv);
288 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
289 "val", "test0rstring");
293 r = guestfs_test0rstring (g, val);
295 rb_raise (e_Error, "%s", guestfs_last_error (g));
297 VALUE rv = rb_str_new2 (r);
302 static VALUE ruby_guestfs_test0rstringerr (VALUE gv)
305 Data_Get_Struct (gv, guestfs_h, g);
307 rb_raise (rb_eArgError, "%s: used handle after closing it", "test0rstringerr");
312 r = guestfs_test0rstringerr (g);
314 rb_raise (e_Error, "%s", guestfs_last_error (g));
316 VALUE rv = rb_str_new2 (r);
321 static VALUE ruby_guestfs_test0rstringlist (VALUE gv, VALUE valv)
324 Data_Get_Struct (gv, guestfs_h, g);
326 rb_raise (rb_eArgError, "%s: used handle after closing it", "test0rstringlist");
328 Check_Type (valv, T_STRING);
329 const char *val = StringValueCStr (valv);
331 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
332 "val", "test0rstringlist");
336 r = guestfs_test0rstringlist (g, val);
338 rb_raise (e_Error, "%s", guestfs_last_error (g));
341 for (i = 0; r[i] != NULL; ++i) len++;
342 VALUE rv = rb_ary_new2 (len);
343 for (i = 0; r[i] != NULL; ++i) {
344 rb_ary_push (rv, rb_str_new2 (r[i]));
351 static VALUE ruby_guestfs_test0rstringlisterr (VALUE gv)
354 Data_Get_Struct (gv, guestfs_h, g);
356 rb_raise (rb_eArgError, "%s: used handle after closing it", "test0rstringlisterr");
361 r = guestfs_test0rstringlisterr (g);
363 rb_raise (e_Error, "%s", guestfs_last_error (g));
366 for (i = 0; r[i] != NULL; ++i) len++;
367 VALUE rv = rb_ary_new2 (len);
368 for (i = 0; r[i] != NULL; ++i) {
369 rb_ary_push (rv, rb_str_new2 (r[i]));
376 static VALUE ruby_guestfs_test0rintbool (VALUE gv, VALUE valv)
379 Data_Get_Struct (gv, guestfs_h, g);
381 rb_raise (rb_eArgError, "%s: used handle after closing it", "test0rintbool");
383 Check_Type (valv, T_STRING);
384 const char *val = StringValueCStr (valv);
386 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
387 "val", "test0rintbool");
389 struct guestfs_int_bool *r;
391 r = guestfs_test0rintbool (g, val);
393 rb_raise (e_Error, "%s", guestfs_last_error (g));
395 VALUE rv = rb_ary_new2 (2);
396 rb_ary_push (rv, INT2NUM (r->i));
397 rb_ary_push (rv, INT2NUM (r->b));
398 guestfs_free_int_bool (r);
402 static VALUE ruby_guestfs_test0rintboolerr (VALUE gv)
405 Data_Get_Struct (gv, guestfs_h, g);
407 rb_raise (rb_eArgError, "%s: used handle after closing it", "test0rintboolerr");
410 struct guestfs_int_bool *r;
412 r = guestfs_test0rintboolerr (g);
414 rb_raise (e_Error, "%s", guestfs_last_error (g));
416 VALUE rv = rb_ary_new2 (2);
417 rb_ary_push (rv, INT2NUM (r->i));
418 rb_ary_push (rv, INT2NUM (r->b));
419 guestfs_free_int_bool (r);
423 static VALUE ruby_guestfs_test0rpvlist (VALUE gv, VALUE valv)
426 Data_Get_Struct (gv, guestfs_h, g);
428 rb_raise (rb_eArgError, "%s: used handle after closing it", "test0rpvlist");
430 Check_Type (valv, T_STRING);
431 const char *val = StringValueCStr (valv);
433 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
434 "val", "test0rpvlist");
436 struct guestfs_lvm_pv_list *r;
438 r = guestfs_test0rpvlist (g, val);
440 rb_raise (e_Error, "%s", guestfs_last_error (g));
442 VALUE rv = rb_ary_new2 (r->len);
444 for (i = 0; i < r->len; ++i) {
445 VALUE hv = rb_hash_new ();
446 rb_hash_aset (rv, rb_str_new2 ("pv_name"), rb_str_new2 (r->val[i].pv_name));
447 rb_hash_aset (rv, rb_str_new2 ("pv_uuid"), rb_str_new (r->val[i].pv_uuid, 32));
448 rb_hash_aset (rv, rb_str_new2 ("pv_fmt"), rb_str_new2 (r->val[i].pv_fmt));
449 rb_hash_aset (rv, rb_str_new2 ("pv_size"), ULL2NUM (r->val[i].pv_size));
450 rb_hash_aset (rv, rb_str_new2 ("dev_size"), ULL2NUM (r->val[i].dev_size));
451 rb_hash_aset (rv, rb_str_new2 ("pv_free"), ULL2NUM (r->val[i].pv_free));
452 rb_hash_aset (rv, rb_str_new2 ("pv_used"), ULL2NUM (r->val[i].pv_used));
453 rb_hash_aset (rv, rb_str_new2 ("pv_attr"), rb_str_new2 (r->val[i].pv_attr));
454 rb_hash_aset (rv, rb_str_new2 ("pv_pe_count"), ULL2NUM (r->val[i].pv_pe_count));
455 rb_hash_aset (rv, rb_str_new2 ("pv_pe_alloc_count"), ULL2NUM (r->val[i].pv_pe_alloc_count));
456 rb_hash_aset (rv, rb_str_new2 ("pv_tags"), rb_str_new2 (r->val[i].pv_tags));
457 rb_hash_aset (rv, rb_str_new2 ("pe_start"), ULL2NUM (r->val[i].pe_start));
458 rb_hash_aset (rv, rb_str_new2 ("pv_mda_count"), ULL2NUM (r->val[i].pv_mda_count));
459 rb_hash_aset (rv, rb_str_new2 ("pv_mda_free"), ULL2NUM (r->val[i].pv_mda_free));
460 rb_ary_push (rv, hv);
462 guestfs_free_lvm_pv_list (r);
466 static VALUE ruby_guestfs_test0rpvlisterr (VALUE gv)
469 Data_Get_Struct (gv, guestfs_h, g);
471 rb_raise (rb_eArgError, "%s: used handle after closing it", "test0rpvlisterr");
474 struct guestfs_lvm_pv_list *r;
476 r = guestfs_test0rpvlisterr (g);
478 rb_raise (e_Error, "%s", guestfs_last_error (g));
480 VALUE rv = rb_ary_new2 (r->len);
482 for (i = 0; i < r->len; ++i) {
483 VALUE hv = rb_hash_new ();
484 rb_hash_aset (rv, rb_str_new2 ("pv_name"), rb_str_new2 (r->val[i].pv_name));
485 rb_hash_aset (rv, rb_str_new2 ("pv_uuid"), rb_str_new (r->val[i].pv_uuid, 32));
486 rb_hash_aset (rv, rb_str_new2 ("pv_fmt"), rb_str_new2 (r->val[i].pv_fmt));
487 rb_hash_aset (rv, rb_str_new2 ("pv_size"), ULL2NUM (r->val[i].pv_size));
488 rb_hash_aset (rv, rb_str_new2 ("dev_size"), ULL2NUM (r->val[i].dev_size));
489 rb_hash_aset (rv, rb_str_new2 ("pv_free"), ULL2NUM (r->val[i].pv_free));
490 rb_hash_aset (rv, rb_str_new2 ("pv_used"), ULL2NUM (r->val[i].pv_used));
491 rb_hash_aset (rv, rb_str_new2 ("pv_attr"), rb_str_new2 (r->val[i].pv_attr));
492 rb_hash_aset (rv, rb_str_new2 ("pv_pe_count"), ULL2NUM (r->val[i].pv_pe_count));
493 rb_hash_aset (rv, rb_str_new2 ("pv_pe_alloc_count"), ULL2NUM (r->val[i].pv_pe_alloc_count));
494 rb_hash_aset (rv, rb_str_new2 ("pv_tags"), rb_str_new2 (r->val[i].pv_tags));
495 rb_hash_aset (rv, rb_str_new2 ("pe_start"), ULL2NUM (r->val[i].pe_start));
496 rb_hash_aset (rv, rb_str_new2 ("pv_mda_count"), ULL2NUM (r->val[i].pv_mda_count));
497 rb_hash_aset (rv, rb_str_new2 ("pv_mda_free"), ULL2NUM (r->val[i].pv_mda_free));
498 rb_ary_push (rv, hv);
500 guestfs_free_lvm_pv_list (r);
504 static VALUE ruby_guestfs_test0rvglist (VALUE gv, VALUE valv)
507 Data_Get_Struct (gv, guestfs_h, g);
509 rb_raise (rb_eArgError, "%s: used handle after closing it", "test0rvglist");
511 Check_Type (valv, T_STRING);
512 const char *val = StringValueCStr (valv);
514 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
515 "val", "test0rvglist");
517 struct guestfs_lvm_vg_list *r;
519 r = guestfs_test0rvglist (g, val);
521 rb_raise (e_Error, "%s", guestfs_last_error (g));
523 VALUE rv = rb_ary_new2 (r->len);
525 for (i = 0; i < r->len; ++i) {
526 VALUE hv = rb_hash_new ();
527 rb_hash_aset (rv, rb_str_new2 ("vg_name"), rb_str_new2 (r->val[i].vg_name));
528 rb_hash_aset (rv, rb_str_new2 ("vg_uuid"), rb_str_new (r->val[i].vg_uuid, 32));
529 rb_hash_aset (rv, rb_str_new2 ("vg_fmt"), rb_str_new2 (r->val[i].vg_fmt));
530 rb_hash_aset (rv, rb_str_new2 ("vg_attr"), rb_str_new2 (r->val[i].vg_attr));
531 rb_hash_aset (rv, rb_str_new2 ("vg_size"), ULL2NUM (r->val[i].vg_size));
532 rb_hash_aset (rv, rb_str_new2 ("vg_free"), ULL2NUM (r->val[i].vg_free));
533 rb_hash_aset (rv, rb_str_new2 ("vg_sysid"), rb_str_new2 (r->val[i].vg_sysid));
534 rb_hash_aset (rv, rb_str_new2 ("vg_extent_size"), ULL2NUM (r->val[i].vg_extent_size));
535 rb_hash_aset (rv, rb_str_new2 ("vg_extent_count"), ULL2NUM (r->val[i].vg_extent_count));
536 rb_hash_aset (rv, rb_str_new2 ("vg_free_count"), ULL2NUM (r->val[i].vg_free_count));
537 rb_hash_aset (rv, rb_str_new2 ("max_lv"), ULL2NUM (r->val[i].max_lv));
538 rb_hash_aset (rv, rb_str_new2 ("max_pv"), ULL2NUM (r->val[i].max_pv));
539 rb_hash_aset (rv, rb_str_new2 ("pv_count"), ULL2NUM (r->val[i].pv_count));
540 rb_hash_aset (rv, rb_str_new2 ("lv_count"), ULL2NUM (r->val[i].lv_count));
541 rb_hash_aset (rv, rb_str_new2 ("snap_count"), ULL2NUM (r->val[i].snap_count));
542 rb_hash_aset (rv, rb_str_new2 ("vg_seqno"), ULL2NUM (r->val[i].vg_seqno));
543 rb_hash_aset (rv, rb_str_new2 ("vg_tags"), rb_str_new2 (r->val[i].vg_tags));
544 rb_hash_aset (rv, rb_str_new2 ("vg_mda_count"), ULL2NUM (r->val[i].vg_mda_count));
545 rb_hash_aset (rv, rb_str_new2 ("vg_mda_free"), ULL2NUM (r->val[i].vg_mda_free));
546 rb_ary_push (rv, hv);
548 guestfs_free_lvm_vg_list (r);
552 static VALUE ruby_guestfs_test0rvglisterr (VALUE gv)
555 Data_Get_Struct (gv, guestfs_h, g);
557 rb_raise (rb_eArgError, "%s: used handle after closing it", "test0rvglisterr");
560 struct guestfs_lvm_vg_list *r;
562 r = guestfs_test0rvglisterr (g);
564 rb_raise (e_Error, "%s", guestfs_last_error (g));
566 VALUE rv = rb_ary_new2 (r->len);
568 for (i = 0; i < r->len; ++i) {
569 VALUE hv = rb_hash_new ();
570 rb_hash_aset (rv, rb_str_new2 ("vg_name"), rb_str_new2 (r->val[i].vg_name));
571 rb_hash_aset (rv, rb_str_new2 ("vg_uuid"), rb_str_new (r->val[i].vg_uuid, 32));
572 rb_hash_aset (rv, rb_str_new2 ("vg_fmt"), rb_str_new2 (r->val[i].vg_fmt));
573 rb_hash_aset (rv, rb_str_new2 ("vg_attr"), rb_str_new2 (r->val[i].vg_attr));
574 rb_hash_aset (rv, rb_str_new2 ("vg_size"), ULL2NUM (r->val[i].vg_size));
575 rb_hash_aset (rv, rb_str_new2 ("vg_free"), ULL2NUM (r->val[i].vg_free));
576 rb_hash_aset (rv, rb_str_new2 ("vg_sysid"), rb_str_new2 (r->val[i].vg_sysid));
577 rb_hash_aset (rv, rb_str_new2 ("vg_extent_size"), ULL2NUM (r->val[i].vg_extent_size));
578 rb_hash_aset (rv, rb_str_new2 ("vg_extent_count"), ULL2NUM (r->val[i].vg_extent_count));
579 rb_hash_aset (rv, rb_str_new2 ("vg_free_count"), ULL2NUM (r->val[i].vg_free_count));
580 rb_hash_aset (rv, rb_str_new2 ("max_lv"), ULL2NUM (r->val[i].max_lv));
581 rb_hash_aset (rv, rb_str_new2 ("max_pv"), ULL2NUM (r->val[i].max_pv));
582 rb_hash_aset (rv, rb_str_new2 ("pv_count"), ULL2NUM (r->val[i].pv_count));
583 rb_hash_aset (rv, rb_str_new2 ("lv_count"), ULL2NUM (r->val[i].lv_count));
584 rb_hash_aset (rv, rb_str_new2 ("snap_count"), ULL2NUM (r->val[i].snap_count));
585 rb_hash_aset (rv, rb_str_new2 ("vg_seqno"), ULL2NUM (r->val[i].vg_seqno));
586 rb_hash_aset (rv, rb_str_new2 ("vg_tags"), rb_str_new2 (r->val[i].vg_tags));
587 rb_hash_aset (rv, rb_str_new2 ("vg_mda_count"), ULL2NUM (r->val[i].vg_mda_count));
588 rb_hash_aset (rv, rb_str_new2 ("vg_mda_free"), ULL2NUM (r->val[i].vg_mda_free));
589 rb_ary_push (rv, hv);
591 guestfs_free_lvm_vg_list (r);
595 static VALUE ruby_guestfs_test0rlvlist (VALUE gv, VALUE valv)
598 Data_Get_Struct (gv, guestfs_h, g);
600 rb_raise (rb_eArgError, "%s: used handle after closing it", "test0rlvlist");
602 Check_Type (valv, T_STRING);
603 const char *val = StringValueCStr (valv);
605 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
606 "val", "test0rlvlist");
608 struct guestfs_lvm_lv_list *r;
610 r = guestfs_test0rlvlist (g, val);
612 rb_raise (e_Error, "%s", guestfs_last_error (g));
614 VALUE rv = rb_ary_new2 (r->len);
616 for (i = 0; i < r->len; ++i) {
617 VALUE hv = rb_hash_new ();
618 rb_hash_aset (rv, rb_str_new2 ("lv_name"), rb_str_new2 (r->val[i].lv_name));
619 rb_hash_aset (rv, rb_str_new2 ("lv_uuid"), rb_str_new (r->val[i].lv_uuid, 32));
620 rb_hash_aset (rv, rb_str_new2 ("lv_attr"), rb_str_new2 (r->val[i].lv_attr));
621 rb_hash_aset (rv, rb_str_new2 ("lv_major"), ULL2NUM (r->val[i].lv_major));
622 rb_hash_aset (rv, rb_str_new2 ("lv_minor"), ULL2NUM (r->val[i].lv_minor));
623 rb_hash_aset (rv, rb_str_new2 ("lv_kernel_major"), ULL2NUM (r->val[i].lv_kernel_major));
624 rb_hash_aset (rv, rb_str_new2 ("lv_kernel_minor"), ULL2NUM (r->val[i].lv_kernel_minor));
625 rb_hash_aset (rv, rb_str_new2 ("lv_size"), ULL2NUM (r->val[i].lv_size));
626 rb_hash_aset (rv, rb_str_new2 ("seg_count"), ULL2NUM (r->val[i].seg_count));
627 rb_hash_aset (rv, rb_str_new2 ("origin"), rb_str_new2 (r->val[i].origin));
628 rb_hash_aset (rv, rb_str_new2 ("snap_percent"), rb_dbl2big (r->val[i].snap_percent));
629 rb_hash_aset (rv, rb_str_new2 ("copy_percent"), rb_dbl2big (r->val[i].copy_percent));
630 rb_hash_aset (rv, rb_str_new2 ("move_pv"), rb_str_new2 (r->val[i].move_pv));
631 rb_hash_aset (rv, rb_str_new2 ("lv_tags"), rb_str_new2 (r->val[i].lv_tags));
632 rb_hash_aset (rv, rb_str_new2 ("mirror_log"), rb_str_new2 (r->val[i].mirror_log));
633 rb_hash_aset (rv, rb_str_new2 ("modules"), rb_str_new2 (r->val[i].modules));
634 rb_ary_push (rv, hv);
636 guestfs_free_lvm_lv_list (r);
640 static VALUE ruby_guestfs_test0rlvlisterr (VALUE gv)
643 Data_Get_Struct (gv, guestfs_h, g);
645 rb_raise (rb_eArgError, "%s: used handle after closing it", "test0rlvlisterr");
648 struct guestfs_lvm_lv_list *r;
650 r = guestfs_test0rlvlisterr (g);
652 rb_raise (e_Error, "%s", guestfs_last_error (g));
654 VALUE rv = rb_ary_new2 (r->len);
656 for (i = 0; i < r->len; ++i) {
657 VALUE hv = rb_hash_new ();
658 rb_hash_aset (rv, rb_str_new2 ("lv_name"), rb_str_new2 (r->val[i].lv_name));
659 rb_hash_aset (rv, rb_str_new2 ("lv_uuid"), rb_str_new (r->val[i].lv_uuid, 32));
660 rb_hash_aset (rv, rb_str_new2 ("lv_attr"), rb_str_new2 (r->val[i].lv_attr));
661 rb_hash_aset (rv, rb_str_new2 ("lv_major"), ULL2NUM (r->val[i].lv_major));
662 rb_hash_aset (rv, rb_str_new2 ("lv_minor"), ULL2NUM (r->val[i].lv_minor));
663 rb_hash_aset (rv, rb_str_new2 ("lv_kernel_major"), ULL2NUM (r->val[i].lv_kernel_major));
664 rb_hash_aset (rv, rb_str_new2 ("lv_kernel_minor"), ULL2NUM (r->val[i].lv_kernel_minor));
665 rb_hash_aset (rv, rb_str_new2 ("lv_size"), ULL2NUM (r->val[i].lv_size));
666 rb_hash_aset (rv, rb_str_new2 ("seg_count"), ULL2NUM (r->val[i].seg_count));
667 rb_hash_aset (rv, rb_str_new2 ("origin"), rb_str_new2 (r->val[i].origin));
668 rb_hash_aset (rv, rb_str_new2 ("snap_percent"), rb_dbl2big (r->val[i].snap_percent));
669 rb_hash_aset (rv, rb_str_new2 ("copy_percent"), rb_dbl2big (r->val[i].copy_percent));
670 rb_hash_aset (rv, rb_str_new2 ("move_pv"), rb_str_new2 (r->val[i].move_pv));
671 rb_hash_aset (rv, rb_str_new2 ("lv_tags"), rb_str_new2 (r->val[i].lv_tags));
672 rb_hash_aset (rv, rb_str_new2 ("mirror_log"), rb_str_new2 (r->val[i].mirror_log));
673 rb_hash_aset (rv, rb_str_new2 ("modules"), rb_str_new2 (r->val[i].modules));
674 rb_ary_push (rv, hv);
676 guestfs_free_lvm_lv_list (r);
680 static VALUE ruby_guestfs_test0rstat (VALUE gv, VALUE valv)
683 Data_Get_Struct (gv, guestfs_h, g);
685 rb_raise (rb_eArgError, "%s: used handle after closing it", "test0rstat");
687 Check_Type (valv, T_STRING);
688 const char *val = StringValueCStr (valv);
690 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
691 "val", "test0rstat");
693 struct guestfs_stat *r;
695 r = guestfs_test0rstat (g, val);
697 rb_raise (e_Error, "%s", guestfs_last_error (g));
699 VALUE rv = rb_hash_new ();
700 rb_hash_aset (rv, rb_str_new2 ("dev"), ULL2NUM (r->dev));
701 rb_hash_aset (rv, rb_str_new2 ("ino"), ULL2NUM (r->ino));
702 rb_hash_aset (rv, rb_str_new2 ("mode"), ULL2NUM (r->mode));
703 rb_hash_aset (rv, rb_str_new2 ("nlink"), ULL2NUM (r->nlink));
704 rb_hash_aset (rv, rb_str_new2 ("uid"), ULL2NUM (r->uid));
705 rb_hash_aset (rv, rb_str_new2 ("gid"), ULL2NUM (r->gid));
706 rb_hash_aset (rv, rb_str_new2 ("rdev"), ULL2NUM (r->rdev));
707 rb_hash_aset (rv, rb_str_new2 ("size"), ULL2NUM (r->size));
708 rb_hash_aset (rv, rb_str_new2 ("blksize"), ULL2NUM (r->blksize));
709 rb_hash_aset (rv, rb_str_new2 ("blocks"), ULL2NUM (r->blocks));
710 rb_hash_aset (rv, rb_str_new2 ("atime"), ULL2NUM (r->atime));
711 rb_hash_aset (rv, rb_str_new2 ("mtime"), ULL2NUM (r->mtime));
712 rb_hash_aset (rv, rb_str_new2 ("ctime"), ULL2NUM (r->ctime));
717 static VALUE ruby_guestfs_test0rstaterr (VALUE gv)
720 Data_Get_Struct (gv, guestfs_h, g);
722 rb_raise (rb_eArgError, "%s: used handle after closing it", "test0rstaterr");
725 struct guestfs_stat *r;
727 r = guestfs_test0rstaterr (g);
729 rb_raise (e_Error, "%s", guestfs_last_error (g));
731 VALUE rv = rb_hash_new ();
732 rb_hash_aset (rv, rb_str_new2 ("dev"), ULL2NUM (r->dev));
733 rb_hash_aset (rv, rb_str_new2 ("ino"), ULL2NUM (r->ino));
734 rb_hash_aset (rv, rb_str_new2 ("mode"), ULL2NUM (r->mode));
735 rb_hash_aset (rv, rb_str_new2 ("nlink"), ULL2NUM (r->nlink));
736 rb_hash_aset (rv, rb_str_new2 ("uid"), ULL2NUM (r->uid));
737 rb_hash_aset (rv, rb_str_new2 ("gid"), ULL2NUM (r->gid));
738 rb_hash_aset (rv, rb_str_new2 ("rdev"), ULL2NUM (r->rdev));
739 rb_hash_aset (rv, rb_str_new2 ("size"), ULL2NUM (r->size));
740 rb_hash_aset (rv, rb_str_new2 ("blksize"), ULL2NUM (r->blksize));
741 rb_hash_aset (rv, rb_str_new2 ("blocks"), ULL2NUM (r->blocks));
742 rb_hash_aset (rv, rb_str_new2 ("atime"), ULL2NUM (r->atime));
743 rb_hash_aset (rv, rb_str_new2 ("mtime"), ULL2NUM (r->mtime));
744 rb_hash_aset (rv, rb_str_new2 ("ctime"), ULL2NUM (r->ctime));
749 static VALUE ruby_guestfs_test0rstatvfs (VALUE gv, VALUE valv)
752 Data_Get_Struct (gv, guestfs_h, g);
754 rb_raise (rb_eArgError, "%s: used handle after closing it", "test0rstatvfs");
756 Check_Type (valv, T_STRING);
757 const char *val = StringValueCStr (valv);
759 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
760 "val", "test0rstatvfs");
762 struct guestfs_statvfs *r;
764 r = guestfs_test0rstatvfs (g, val);
766 rb_raise (e_Error, "%s", guestfs_last_error (g));
768 VALUE rv = rb_hash_new ();
769 rb_hash_aset (rv, rb_str_new2 ("bsize"), ULL2NUM (r->bsize));
770 rb_hash_aset (rv, rb_str_new2 ("frsize"), ULL2NUM (r->frsize));
771 rb_hash_aset (rv, rb_str_new2 ("blocks"), ULL2NUM (r->blocks));
772 rb_hash_aset (rv, rb_str_new2 ("bfree"), ULL2NUM (r->bfree));
773 rb_hash_aset (rv, rb_str_new2 ("bavail"), ULL2NUM (r->bavail));
774 rb_hash_aset (rv, rb_str_new2 ("files"), ULL2NUM (r->files));
775 rb_hash_aset (rv, rb_str_new2 ("ffree"), ULL2NUM (r->ffree));
776 rb_hash_aset (rv, rb_str_new2 ("favail"), ULL2NUM (r->favail));
777 rb_hash_aset (rv, rb_str_new2 ("fsid"), ULL2NUM (r->fsid));
778 rb_hash_aset (rv, rb_str_new2 ("flag"), ULL2NUM (r->flag));
779 rb_hash_aset (rv, rb_str_new2 ("namemax"), ULL2NUM (r->namemax));
784 static VALUE ruby_guestfs_test0rstatvfserr (VALUE gv)
787 Data_Get_Struct (gv, guestfs_h, g);
789 rb_raise (rb_eArgError, "%s: used handle after closing it", "test0rstatvfserr");
792 struct guestfs_statvfs *r;
794 r = guestfs_test0rstatvfserr (g);
796 rb_raise (e_Error, "%s", guestfs_last_error (g));
798 VALUE rv = rb_hash_new ();
799 rb_hash_aset (rv, rb_str_new2 ("bsize"), ULL2NUM (r->bsize));
800 rb_hash_aset (rv, rb_str_new2 ("frsize"), ULL2NUM (r->frsize));
801 rb_hash_aset (rv, rb_str_new2 ("blocks"), ULL2NUM (r->blocks));
802 rb_hash_aset (rv, rb_str_new2 ("bfree"), ULL2NUM (r->bfree));
803 rb_hash_aset (rv, rb_str_new2 ("bavail"), ULL2NUM (r->bavail));
804 rb_hash_aset (rv, rb_str_new2 ("files"), ULL2NUM (r->files));
805 rb_hash_aset (rv, rb_str_new2 ("ffree"), ULL2NUM (r->ffree));
806 rb_hash_aset (rv, rb_str_new2 ("favail"), ULL2NUM (r->favail));
807 rb_hash_aset (rv, rb_str_new2 ("fsid"), ULL2NUM (r->fsid));
808 rb_hash_aset (rv, rb_str_new2 ("flag"), ULL2NUM (r->flag));
809 rb_hash_aset (rv, rb_str_new2 ("namemax"), ULL2NUM (r->namemax));
814 static VALUE ruby_guestfs_test0rhashtable (VALUE gv, VALUE valv)
817 Data_Get_Struct (gv, guestfs_h, g);
819 rb_raise (rb_eArgError, "%s: used handle after closing it", "test0rhashtable");
821 Check_Type (valv, T_STRING);
822 const char *val = StringValueCStr (valv);
824 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
825 "val", "test0rhashtable");
829 r = guestfs_test0rhashtable (g, val);
831 rb_raise (e_Error, "%s", guestfs_last_error (g));
833 VALUE rv = rb_hash_new ();
835 for (i = 0; r[i] != NULL; i+=2) {
836 rb_hash_aset (rv, rb_str_new2 (r[i]), rb_str_new2 (r[i+1]));
844 static VALUE ruby_guestfs_test0rhashtableerr (VALUE gv)
847 Data_Get_Struct (gv, guestfs_h, g);
849 rb_raise (rb_eArgError, "%s: used handle after closing it", "test0rhashtableerr");
854 r = guestfs_test0rhashtableerr (g);
856 rb_raise (e_Error, "%s", guestfs_last_error (g));
858 VALUE rv = rb_hash_new ();
860 for (i = 0; r[i] != NULL; i+=2) {
861 rb_hash_aset (rv, rb_str_new2 (r[i]), rb_str_new2 (r[i+1]));
869 static VALUE ruby_guestfs_launch (VALUE gv)
872 Data_Get_Struct (gv, guestfs_h, g);
874 rb_raise (rb_eArgError, "%s: used handle after closing it", "launch");
879 r = guestfs_launch (g);
881 rb_raise (e_Error, "%s", guestfs_last_error (g));
886 static VALUE ruby_guestfs_wait_ready (VALUE gv)
889 Data_Get_Struct (gv, guestfs_h, g);
891 rb_raise (rb_eArgError, "%s: used handle after closing it", "wait_ready");
896 r = guestfs_wait_ready (g);
898 rb_raise (e_Error, "%s", guestfs_last_error (g));
903 static VALUE ruby_guestfs_kill_subprocess (VALUE gv)
906 Data_Get_Struct (gv, guestfs_h, g);
908 rb_raise (rb_eArgError, "%s: used handle after closing it", "kill_subprocess");
913 r = guestfs_kill_subprocess (g);
915 rb_raise (e_Error, "%s", guestfs_last_error (g));
920 static VALUE ruby_guestfs_add_drive (VALUE gv, VALUE filenamev)
923 Data_Get_Struct (gv, guestfs_h, g);
925 rb_raise (rb_eArgError, "%s: used handle after closing it", "add_drive");
927 Check_Type (filenamev, T_STRING);
928 const char *filename = StringValueCStr (filenamev);
930 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
931 "filename", "add_drive");
935 r = guestfs_add_drive (g, filename);
937 rb_raise (e_Error, "%s", guestfs_last_error (g));
942 static VALUE ruby_guestfs_add_cdrom (VALUE gv, VALUE filenamev)
945 Data_Get_Struct (gv, guestfs_h, g);
947 rb_raise (rb_eArgError, "%s: used handle after closing it", "add_cdrom");
949 Check_Type (filenamev, T_STRING);
950 const char *filename = StringValueCStr (filenamev);
952 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
953 "filename", "add_cdrom");
957 r = guestfs_add_cdrom (g, filename);
959 rb_raise (e_Error, "%s", guestfs_last_error (g));
964 static VALUE ruby_guestfs_add_drive_ro (VALUE gv, VALUE filenamev)
967 Data_Get_Struct (gv, guestfs_h, g);
969 rb_raise (rb_eArgError, "%s: used handle after closing it", "add_drive_ro");
971 Check_Type (filenamev, T_STRING);
972 const char *filename = StringValueCStr (filenamev);
974 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
975 "filename", "add_drive_ro");
979 r = guestfs_add_drive_ro (g, filename);
981 rb_raise (e_Error, "%s", guestfs_last_error (g));
986 static VALUE ruby_guestfs_config (VALUE gv, VALUE qemuparamv, VALUE qemuvaluev)
989 Data_Get_Struct (gv, guestfs_h, g);
991 rb_raise (rb_eArgError, "%s: used handle after closing it", "config");
993 Check_Type (qemuparamv, T_STRING);
994 const char *qemuparam = StringValueCStr (qemuparamv);
996 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
997 "qemuparam", "config");
998 const char *qemuvalue = !NIL_P (qemuvaluev) ? StringValueCStr (qemuvaluev) : NULL;
1002 r = guestfs_config (g, qemuparam, qemuvalue);
1004 rb_raise (e_Error, "%s", guestfs_last_error (g));
1009 static VALUE ruby_guestfs_set_qemu (VALUE gv, VALUE qemuv)
1012 Data_Get_Struct (gv, guestfs_h, g);
1014 rb_raise (rb_eArgError, "%s: used handle after closing it", "set_qemu");
1016 Check_Type (qemuv, T_STRING);
1017 const char *qemu = StringValueCStr (qemuv);
1019 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1020 "qemu", "set_qemu");
1024 r = guestfs_set_qemu (g, qemu);
1026 rb_raise (e_Error, "%s", guestfs_last_error (g));
1031 static VALUE ruby_guestfs_get_qemu (VALUE gv)
1034 Data_Get_Struct (gv, guestfs_h, g);
1036 rb_raise (rb_eArgError, "%s: used handle after closing it", "get_qemu");
1041 r = guestfs_get_qemu (g);
1043 rb_raise (e_Error, "%s", guestfs_last_error (g));
1045 return rb_str_new2 (r);
1048 static VALUE ruby_guestfs_set_path (VALUE gv, VALUE pathv)
1051 Data_Get_Struct (gv, guestfs_h, g);
1053 rb_raise (rb_eArgError, "%s: used handle after closing it", "set_path");
1055 Check_Type (pathv, T_STRING);
1056 const char *path = StringValueCStr (pathv);
1058 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1059 "path", "set_path");
1063 r = guestfs_set_path (g, path);
1065 rb_raise (e_Error, "%s", guestfs_last_error (g));
1070 static VALUE ruby_guestfs_get_path (VALUE gv)
1073 Data_Get_Struct (gv, guestfs_h, g);
1075 rb_raise (rb_eArgError, "%s: used handle after closing it", "get_path");
1080 r = guestfs_get_path (g);
1082 rb_raise (e_Error, "%s", guestfs_last_error (g));
1084 return rb_str_new2 (r);
1087 static VALUE ruby_guestfs_set_append (VALUE gv, VALUE appendv)
1090 Data_Get_Struct (gv, guestfs_h, g);
1092 rb_raise (rb_eArgError, "%s: used handle after closing it", "set_append");
1094 Check_Type (appendv, T_STRING);
1095 const char *append = StringValueCStr (appendv);
1097 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1098 "append", "set_append");
1102 r = guestfs_set_append (g, append);
1104 rb_raise (e_Error, "%s", guestfs_last_error (g));
1109 static VALUE ruby_guestfs_get_append (VALUE gv)
1112 Data_Get_Struct (gv, guestfs_h, g);
1114 rb_raise (rb_eArgError, "%s: used handle after closing it", "get_append");
1119 r = guestfs_get_append (g);
1121 rb_raise (e_Error, "%s", guestfs_last_error (g));
1123 return rb_str_new2 (r);
1126 static VALUE ruby_guestfs_set_autosync (VALUE gv, VALUE autosyncv)
1129 Data_Get_Struct (gv, guestfs_h, g);
1131 rb_raise (rb_eArgError, "%s: used handle after closing it", "set_autosync");
1133 int autosync = RTEST (autosyncv);
1137 r = guestfs_set_autosync (g, autosync);
1139 rb_raise (e_Error, "%s", guestfs_last_error (g));
1144 static VALUE ruby_guestfs_get_autosync (VALUE gv)
1147 Data_Get_Struct (gv, guestfs_h, g);
1149 rb_raise (rb_eArgError, "%s: used handle after closing it", "get_autosync");
1154 r = guestfs_get_autosync (g);
1156 rb_raise (e_Error, "%s", guestfs_last_error (g));
1161 static VALUE ruby_guestfs_set_verbose (VALUE gv, VALUE verbosev)
1164 Data_Get_Struct (gv, guestfs_h, g);
1166 rb_raise (rb_eArgError, "%s: used handle after closing it", "set_verbose");
1168 int verbose = RTEST (verbosev);
1172 r = guestfs_set_verbose (g, verbose);
1174 rb_raise (e_Error, "%s", guestfs_last_error (g));
1179 static VALUE ruby_guestfs_get_verbose (VALUE gv)
1182 Data_Get_Struct (gv, guestfs_h, g);
1184 rb_raise (rb_eArgError, "%s: used handle after closing it", "get_verbose");
1189 r = guestfs_get_verbose (g);
1191 rb_raise (e_Error, "%s", guestfs_last_error (g));
1196 static VALUE ruby_guestfs_is_ready (VALUE gv)
1199 Data_Get_Struct (gv, guestfs_h, g);
1201 rb_raise (rb_eArgError, "%s: used handle after closing it", "is_ready");
1206 r = guestfs_is_ready (g);
1208 rb_raise (e_Error, "%s", guestfs_last_error (g));
1213 static VALUE ruby_guestfs_is_config (VALUE gv)
1216 Data_Get_Struct (gv, guestfs_h, g);
1218 rb_raise (rb_eArgError, "%s: used handle after closing it", "is_config");
1223 r = guestfs_is_config (g);
1225 rb_raise (e_Error, "%s", guestfs_last_error (g));
1230 static VALUE ruby_guestfs_is_launching (VALUE gv)
1233 Data_Get_Struct (gv, guestfs_h, g);
1235 rb_raise (rb_eArgError, "%s: used handle after closing it", "is_launching");
1240 r = guestfs_is_launching (g);
1242 rb_raise (e_Error, "%s", guestfs_last_error (g));
1247 static VALUE ruby_guestfs_is_busy (VALUE gv)
1250 Data_Get_Struct (gv, guestfs_h, g);
1252 rb_raise (rb_eArgError, "%s: used handle after closing it", "is_busy");
1257 r = guestfs_is_busy (g);
1259 rb_raise (e_Error, "%s", guestfs_last_error (g));
1264 static VALUE ruby_guestfs_get_state (VALUE gv)
1267 Data_Get_Struct (gv, guestfs_h, g);
1269 rb_raise (rb_eArgError, "%s: used handle after closing it", "get_state");
1274 r = guestfs_get_state (g);
1276 rb_raise (e_Error, "%s", guestfs_last_error (g));
1281 static VALUE ruby_guestfs_set_busy (VALUE gv)
1284 Data_Get_Struct (gv, guestfs_h, g);
1286 rb_raise (rb_eArgError, "%s: used handle after closing it", "set_busy");
1291 r = guestfs_set_busy (g);
1293 rb_raise (e_Error, "%s", guestfs_last_error (g));
1298 static VALUE ruby_guestfs_set_ready (VALUE gv)
1301 Data_Get_Struct (gv, guestfs_h, g);
1303 rb_raise (rb_eArgError, "%s: used handle after closing it", "set_ready");
1308 r = guestfs_set_ready (g);
1310 rb_raise (e_Error, "%s", guestfs_last_error (g));
1315 static VALUE ruby_guestfs_end_busy (VALUE gv)
1318 Data_Get_Struct (gv, guestfs_h, g);
1320 rb_raise (rb_eArgError, "%s: used handle after closing it", "end_busy");
1325 r = guestfs_end_busy (g);
1327 rb_raise (e_Error, "%s", guestfs_last_error (g));
1332 static VALUE ruby_guestfs_set_memsize (VALUE gv, VALUE memsizev)
1335 Data_Get_Struct (gv, guestfs_h, g);
1337 rb_raise (rb_eArgError, "%s: used handle after closing it", "set_memsize");
1339 int memsize = NUM2INT (memsizev);
1343 r = guestfs_set_memsize (g, memsize);
1345 rb_raise (e_Error, "%s", guestfs_last_error (g));
1350 static VALUE ruby_guestfs_get_memsize (VALUE gv)
1353 Data_Get_Struct (gv, guestfs_h, g);
1355 rb_raise (rb_eArgError, "%s: used handle after closing it", "get_memsize");
1360 r = guestfs_get_memsize (g);
1362 rb_raise (e_Error, "%s", guestfs_last_error (g));
1367 static VALUE ruby_guestfs_mount (VALUE gv, VALUE devicev, VALUE mountpointv)
1370 Data_Get_Struct (gv, guestfs_h, g);
1372 rb_raise (rb_eArgError, "%s: used handle after closing it", "mount");
1374 Check_Type (devicev, T_STRING);
1375 const char *device = StringValueCStr (devicev);
1377 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1379 Check_Type (mountpointv, T_STRING);
1380 const char *mountpoint = StringValueCStr (mountpointv);
1382 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1383 "mountpoint", "mount");
1387 r = guestfs_mount (g, device, mountpoint);
1389 rb_raise (e_Error, "%s", guestfs_last_error (g));
1394 static VALUE ruby_guestfs_sync (VALUE gv)
1397 Data_Get_Struct (gv, guestfs_h, g);
1399 rb_raise (rb_eArgError, "%s: used handle after closing it", "sync");
1404 r = guestfs_sync (g);
1406 rb_raise (e_Error, "%s", guestfs_last_error (g));
1411 static VALUE ruby_guestfs_touch (VALUE gv, VALUE pathv)
1414 Data_Get_Struct (gv, guestfs_h, g);
1416 rb_raise (rb_eArgError, "%s: used handle after closing it", "touch");
1418 Check_Type (pathv, T_STRING);
1419 const char *path = StringValueCStr (pathv);
1421 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1426 r = guestfs_touch (g, path);
1428 rb_raise (e_Error, "%s", guestfs_last_error (g));
1433 static VALUE ruby_guestfs_cat (VALUE gv, VALUE pathv)
1436 Data_Get_Struct (gv, guestfs_h, g);
1438 rb_raise (rb_eArgError, "%s: used handle after closing it", "cat");
1440 Check_Type (pathv, T_STRING);
1441 const char *path = StringValueCStr (pathv);
1443 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1448 r = guestfs_cat (g, path);
1450 rb_raise (e_Error, "%s", guestfs_last_error (g));
1452 VALUE rv = rb_str_new2 (r);
1457 static VALUE ruby_guestfs_ll (VALUE gv, VALUE directoryv)
1460 Data_Get_Struct (gv, guestfs_h, g);
1462 rb_raise (rb_eArgError, "%s: used handle after closing it", "ll");
1464 Check_Type (directoryv, T_STRING);
1465 const char *directory = StringValueCStr (directoryv);
1467 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1472 r = guestfs_ll (g, directory);
1474 rb_raise (e_Error, "%s", guestfs_last_error (g));
1476 VALUE rv = rb_str_new2 (r);
1481 static VALUE ruby_guestfs_ls (VALUE gv, VALUE directoryv)
1484 Data_Get_Struct (gv, guestfs_h, g);
1486 rb_raise (rb_eArgError, "%s: used handle after closing it", "ls");
1488 Check_Type (directoryv, T_STRING);
1489 const char *directory = StringValueCStr (directoryv);
1491 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1496 r = guestfs_ls (g, directory);
1498 rb_raise (e_Error, "%s", guestfs_last_error (g));
1501 for (i = 0; r[i] != NULL; ++i) len++;
1502 VALUE rv = rb_ary_new2 (len);
1503 for (i = 0; r[i] != NULL; ++i) {
1504 rb_ary_push (rv, rb_str_new2 (r[i]));
1511 static VALUE ruby_guestfs_list_devices (VALUE gv)
1514 Data_Get_Struct (gv, guestfs_h, g);
1516 rb_raise (rb_eArgError, "%s: used handle after closing it", "list_devices");
1521 r = guestfs_list_devices (g);
1523 rb_raise (e_Error, "%s", guestfs_last_error (g));
1526 for (i = 0; r[i] != NULL; ++i) len++;
1527 VALUE rv = rb_ary_new2 (len);
1528 for (i = 0; r[i] != NULL; ++i) {
1529 rb_ary_push (rv, rb_str_new2 (r[i]));
1536 static VALUE ruby_guestfs_list_partitions (VALUE gv)
1539 Data_Get_Struct (gv, guestfs_h, g);
1541 rb_raise (rb_eArgError, "%s: used handle after closing it", "list_partitions");
1546 r = guestfs_list_partitions (g);
1548 rb_raise (e_Error, "%s", guestfs_last_error (g));
1551 for (i = 0; r[i] != NULL; ++i) len++;
1552 VALUE rv = rb_ary_new2 (len);
1553 for (i = 0; r[i] != NULL; ++i) {
1554 rb_ary_push (rv, rb_str_new2 (r[i]));
1561 static VALUE ruby_guestfs_pvs (VALUE gv)
1564 Data_Get_Struct (gv, guestfs_h, g);
1566 rb_raise (rb_eArgError, "%s: used handle after closing it", "pvs");
1571 r = guestfs_pvs (g);
1573 rb_raise (e_Error, "%s", guestfs_last_error (g));
1576 for (i = 0; r[i] != NULL; ++i) len++;
1577 VALUE rv = rb_ary_new2 (len);
1578 for (i = 0; r[i] != NULL; ++i) {
1579 rb_ary_push (rv, rb_str_new2 (r[i]));
1586 static VALUE ruby_guestfs_vgs (VALUE gv)
1589 Data_Get_Struct (gv, guestfs_h, g);
1591 rb_raise (rb_eArgError, "%s: used handle after closing it", "vgs");
1596 r = guestfs_vgs (g);
1598 rb_raise (e_Error, "%s", guestfs_last_error (g));
1601 for (i = 0; r[i] != NULL; ++i) len++;
1602 VALUE rv = rb_ary_new2 (len);
1603 for (i = 0; r[i] != NULL; ++i) {
1604 rb_ary_push (rv, rb_str_new2 (r[i]));
1611 static VALUE ruby_guestfs_lvs (VALUE gv)
1614 Data_Get_Struct (gv, guestfs_h, g);
1616 rb_raise (rb_eArgError, "%s: used handle after closing it", "lvs");
1621 r = guestfs_lvs (g);
1623 rb_raise (e_Error, "%s", guestfs_last_error (g));
1626 for (i = 0; r[i] != NULL; ++i) len++;
1627 VALUE rv = rb_ary_new2 (len);
1628 for (i = 0; r[i] != NULL; ++i) {
1629 rb_ary_push (rv, rb_str_new2 (r[i]));
1636 static VALUE ruby_guestfs_pvs_full (VALUE gv)
1639 Data_Get_Struct (gv, guestfs_h, g);
1641 rb_raise (rb_eArgError, "%s: used handle after closing it", "pvs_full");
1644 struct guestfs_lvm_pv_list *r;
1646 r = guestfs_pvs_full (g);
1648 rb_raise (e_Error, "%s", guestfs_last_error (g));
1650 VALUE rv = rb_ary_new2 (r->len);
1652 for (i = 0; i < r->len; ++i) {
1653 VALUE hv = rb_hash_new ();
1654 rb_hash_aset (rv, rb_str_new2 ("pv_name"), rb_str_new2 (r->val[i].pv_name));
1655 rb_hash_aset (rv, rb_str_new2 ("pv_uuid"), rb_str_new (r->val[i].pv_uuid, 32));
1656 rb_hash_aset (rv, rb_str_new2 ("pv_fmt"), rb_str_new2 (r->val[i].pv_fmt));
1657 rb_hash_aset (rv, rb_str_new2 ("pv_size"), ULL2NUM (r->val[i].pv_size));
1658 rb_hash_aset (rv, rb_str_new2 ("dev_size"), ULL2NUM (r->val[i].dev_size));
1659 rb_hash_aset (rv, rb_str_new2 ("pv_free"), ULL2NUM (r->val[i].pv_free));
1660 rb_hash_aset (rv, rb_str_new2 ("pv_used"), ULL2NUM (r->val[i].pv_used));
1661 rb_hash_aset (rv, rb_str_new2 ("pv_attr"), rb_str_new2 (r->val[i].pv_attr));
1662 rb_hash_aset (rv, rb_str_new2 ("pv_pe_count"), ULL2NUM (r->val[i].pv_pe_count));
1663 rb_hash_aset (rv, rb_str_new2 ("pv_pe_alloc_count"), ULL2NUM (r->val[i].pv_pe_alloc_count));
1664 rb_hash_aset (rv, rb_str_new2 ("pv_tags"), rb_str_new2 (r->val[i].pv_tags));
1665 rb_hash_aset (rv, rb_str_new2 ("pe_start"), ULL2NUM (r->val[i].pe_start));
1666 rb_hash_aset (rv, rb_str_new2 ("pv_mda_count"), ULL2NUM (r->val[i].pv_mda_count));
1667 rb_hash_aset (rv, rb_str_new2 ("pv_mda_free"), ULL2NUM (r->val[i].pv_mda_free));
1668 rb_ary_push (rv, hv);
1670 guestfs_free_lvm_pv_list (r);
1674 static VALUE ruby_guestfs_vgs_full (VALUE gv)
1677 Data_Get_Struct (gv, guestfs_h, g);
1679 rb_raise (rb_eArgError, "%s: used handle after closing it", "vgs_full");
1682 struct guestfs_lvm_vg_list *r;
1684 r = guestfs_vgs_full (g);
1686 rb_raise (e_Error, "%s", guestfs_last_error (g));
1688 VALUE rv = rb_ary_new2 (r->len);
1690 for (i = 0; i < r->len; ++i) {
1691 VALUE hv = rb_hash_new ();
1692 rb_hash_aset (rv, rb_str_new2 ("vg_name"), rb_str_new2 (r->val[i].vg_name));
1693 rb_hash_aset (rv, rb_str_new2 ("vg_uuid"), rb_str_new (r->val[i].vg_uuid, 32));
1694 rb_hash_aset (rv, rb_str_new2 ("vg_fmt"), rb_str_new2 (r->val[i].vg_fmt));
1695 rb_hash_aset (rv, rb_str_new2 ("vg_attr"), rb_str_new2 (r->val[i].vg_attr));
1696 rb_hash_aset (rv, rb_str_new2 ("vg_size"), ULL2NUM (r->val[i].vg_size));
1697 rb_hash_aset (rv, rb_str_new2 ("vg_free"), ULL2NUM (r->val[i].vg_free));
1698 rb_hash_aset (rv, rb_str_new2 ("vg_sysid"), rb_str_new2 (r->val[i].vg_sysid));
1699 rb_hash_aset (rv, rb_str_new2 ("vg_extent_size"), ULL2NUM (r->val[i].vg_extent_size));
1700 rb_hash_aset (rv, rb_str_new2 ("vg_extent_count"), ULL2NUM (r->val[i].vg_extent_count));
1701 rb_hash_aset (rv, rb_str_new2 ("vg_free_count"), ULL2NUM (r->val[i].vg_free_count));
1702 rb_hash_aset (rv, rb_str_new2 ("max_lv"), ULL2NUM (r->val[i].max_lv));
1703 rb_hash_aset (rv, rb_str_new2 ("max_pv"), ULL2NUM (r->val[i].max_pv));
1704 rb_hash_aset (rv, rb_str_new2 ("pv_count"), ULL2NUM (r->val[i].pv_count));
1705 rb_hash_aset (rv, rb_str_new2 ("lv_count"), ULL2NUM (r->val[i].lv_count));
1706 rb_hash_aset (rv, rb_str_new2 ("snap_count"), ULL2NUM (r->val[i].snap_count));
1707 rb_hash_aset (rv, rb_str_new2 ("vg_seqno"), ULL2NUM (r->val[i].vg_seqno));
1708 rb_hash_aset (rv, rb_str_new2 ("vg_tags"), rb_str_new2 (r->val[i].vg_tags));
1709 rb_hash_aset (rv, rb_str_new2 ("vg_mda_count"), ULL2NUM (r->val[i].vg_mda_count));
1710 rb_hash_aset (rv, rb_str_new2 ("vg_mda_free"), ULL2NUM (r->val[i].vg_mda_free));
1711 rb_ary_push (rv, hv);
1713 guestfs_free_lvm_vg_list (r);
1717 static VALUE ruby_guestfs_lvs_full (VALUE gv)
1720 Data_Get_Struct (gv, guestfs_h, g);
1722 rb_raise (rb_eArgError, "%s: used handle after closing it", "lvs_full");
1725 struct guestfs_lvm_lv_list *r;
1727 r = guestfs_lvs_full (g);
1729 rb_raise (e_Error, "%s", guestfs_last_error (g));
1731 VALUE rv = rb_ary_new2 (r->len);
1733 for (i = 0; i < r->len; ++i) {
1734 VALUE hv = rb_hash_new ();
1735 rb_hash_aset (rv, rb_str_new2 ("lv_name"), rb_str_new2 (r->val[i].lv_name));
1736 rb_hash_aset (rv, rb_str_new2 ("lv_uuid"), rb_str_new (r->val[i].lv_uuid, 32));
1737 rb_hash_aset (rv, rb_str_new2 ("lv_attr"), rb_str_new2 (r->val[i].lv_attr));
1738 rb_hash_aset (rv, rb_str_new2 ("lv_major"), ULL2NUM (r->val[i].lv_major));
1739 rb_hash_aset (rv, rb_str_new2 ("lv_minor"), ULL2NUM (r->val[i].lv_minor));
1740 rb_hash_aset (rv, rb_str_new2 ("lv_kernel_major"), ULL2NUM (r->val[i].lv_kernel_major));
1741 rb_hash_aset (rv, rb_str_new2 ("lv_kernel_minor"), ULL2NUM (r->val[i].lv_kernel_minor));
1742 rb_hash_aset (rv, rb_str_new2 ("lv_size"), ULL2NUM (r->val[i].lv_size));
1743 rb_hash_aset (rv, rb_str_new2 ("seg_count"), ULL2NUM (r->val[i].seg_count));
1744 rb_hash_aset (rv, rb_str_new2 ("origin"), rb_str_new2 (r->val[i].origin));
1745 rb_hash_aset (rv, rb_str_new2 ("snap_percent"), rb_dbl2big (r->val[i].snap_percent));
1746 rb_hash_aset (rv, rb_str_new2 ("copy_percent"), rb_dbl2big (r->val[i].copy_percent));
1747 rb_hash_aset (rv, rb_str_new2 ("move_pv"), rb_str_new2 (r->val[i].move_pv));
1748 rb_hash_aset (rv, rb_str_new2 ("lv_tags"), rb_str_new2 (r->val[i].lv_tags));
1749 rb_hash_aset (rv, rb_str_new2 ("mirror_log"), rb_str_new2 (r->val[i].mirror_log));
1750 rb_hash_aset (rv, rb_str_new2 ("modules"), rb_str_new2 (r->val[i].modules));
1751 rb_ary_push (rv, hv);
1753 guestfs_free_lvm_lv_list (r);
1757 static VALUE ruby_guestfs_read_lines (VALUE gv, VALUE pathv)
1760 Data_Get_Struct (gv, guestfs_h, g);
1762 rb_raise (rb_eArgError, "%s: used handle after closing it", "read_lines");
1764 Check_Type (pathv, T_STRING);
1765 const char *path = StringValueCStr (pathv);
1767 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1768 "path", "read_lines");
1772 r = guestfs_read_lines (g, path);
1774 rb_raise (e_Error, "%s", guestfs_last_error (g));
1777 for (i = 0; r[i] != NULL; ++i) len++;
1778 VALUE rv = rb_ary_new2 (len);
1779 for (i = 0; r[i] != NULL; ++i) {
1780 rb_ary_push (rv, rb_str_new2 (r[i]));
1787 static VALUE ruby_guestfs_aug_init (VALUE gv, VALUE rootv, VALUE flagsv)
1790 Data_Get_Struct (gv, guestfs_h, g);
1792 rb_raise (rb_eArgError, "%s: used handle after closing it", "aug_init");
1794 Check_Type (rootv, T_STRING);
1795 const char *root = StringValueCStr (rootv);
1797 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1798 "root", "aug_init");
1799 int flags = NUM2INT (flagsv);
1803 r = guestfs_aug_init (g, root, flags);
1805 rb_raise (e_Error, "%s", guestfs_last_error (g));
1810 static VALUE ruby_guestfs_aug_close (VALUE gv)
1813 Data_Get_Struct (gv, guestfs_h, g);
1815 rb_raise (rb_eArgError, "%s: used handle after closing it", "aug_close");
1820 r = guestfs_aug_close (g);
1822 rb_raise (e_Error, "%s", guestfs_last_error (g));
1827 static VALUE ruby_guestfs_aug_defvar (VALUE gv, VALUE namev, VALUE exprv)
1830 Data_Get_Struct (gv, guestfs_h, g);
1832 rb_raise (rb_eArgError, "%s: used handle after closing it", "aug_defvar");
1834 Check_Type (namev, T_STRING);
1835 const char *name = StringValueCStr (namev);
1837 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1838 "name", "aug_defvar");
1839 const char *expr = !NIL_P (exprv) ? StringValueCStr (exprv) : NULL;
1843 r = guestfs_aug_defvar (g, name, expr);
1845 rb_raise (e_Error, "%s", guestfs_last_error (g));
1850 static VALUE ruby_guestfs_aug_defnode (VALUE gv, VALUE namev, VALUE exprv, VALUE valv)
1853 Data_Get_Struct (gv, guestfs_h, g);
1855 rb_raise (rb_eArgError, "%s: used handle after closing it", "aug_defnode");
1857 Check_Type (namev, T_STRING);
1858 const char *name = StringValueCStr (namev);
1860 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1861 "name", "aug_defnode");
1862 Check_Type (exprv, T_STRING);
1863 const char *expr = StringValueCStr (exprv);
1865 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1866 "expr", "aug_defnode");
1867 Check_Type (valv, T_STRING);
1868 const char *val = StringValueCStr (valv);
1870 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1871 "val", "aug_defnode");
1873 struct guestfs_int_bool *r;
1875 r = guestfs_aug_defnode (g, name, expr, val);
1877 rb_raise (e_Error, "%s", guestfs_last_error (g));
1879 VALUE rv = rb_ary_new2 (2);
1880 rb_ary_push (rv, INT2NUM (r->i));
1881 rb_ary_push (rv, INT2NUM (r->b));
1882 guestfs_free_int_bool (r);
1886 static VALUE ruby_guestfs_aug_get (VALUE gv, VALUE pathv)
1889 Data_Get_Struct (gv, guestfs_h, g);
1891 rb_raise (rb_eArgError, "%s: used handle after closing it", "aug_get");
1893 Check_Type (pathv, T_STRING);
1894 const char *path = StringValueCStr (pathv);
1896 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1901 r = guestfs_aug_get (g, path);
1903 rb_raise (e_Error, "%s", guestfs_last_error (g));
1905 VALUE rv = rb_str_new2 (r);
1910 static VALUE ruby_guestfs_aug_set (VALUE gv, VALUE pathv, VALUE valv)
1913 Data_Get_Struct (gv, guestfs_h, g);
1915 rb_raise (rb_eArgError, "%s: used handle after closing it", "aug_set");
1917 Check_Type (pathv, T_STRING);
1918 const char *path = StringValueCStr (pathv);
1920 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1922 Check_Type (valv, T_STRING);
1923 const char *val = StringValueCStr (valv);
1925 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1930 r = guestfs_aug_set (g, path, val);
1932 rb_raise (e_Error, "%s", guestfs_last_error (g));
1937 static VALUE ruby_guestfs_aug_insert (VALUE gv, VALUE pathv, VALUE labelv, VALUE beforev)
1940 Data_Get_Struct (gv, guestfs_h, g);
1942 rb_raise (rb_eArgError, "%s: used handle after closing it", "aug_insert");
1944 Check_Type (pathv, T_STRING);
1945 const char *path = StringValueCStr (pathv);
1947 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1948 "path", "aug_insert");
1949 Check_Type (labelv, T_STRING);
1950 const char *label = StringValueCStr (labelv);
1952 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1953 "label", "aug_insert");
1954 int before = RTEST (beforev);
1958 r = guestfs_aug_insert (g, path, label, before);
1960 rb_raise (e_Error, "%s", guestfs_last_error (g));
1965 static VALUE ruby_guestfs_aug_rm (VALUE gv, VALUE pathv)
1968 Data_Get_Struct (gv, guestfs_h, g);
1970 rb_raise (rb_eArgError, "%s: used handle after closing it", "aug_rm");
1972 Check_Type (pathv, T_STRING);
1973 const char *path = StringValueCStr (pathv);
1975 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1980 r = guestfs_aug_rm (g, path);
1982 rb_raise (e_Error, "%s", guestfs_last_error (g));
1987 static VALUE ruby_guestfs_aug_mv (VALUE gv, VALUE srcv, VALUE destv)
1990 Data_Get_Struct (gv, guestfs_h, g);
1992 rb_raise (rb_eArgError, "%s: used handle after closing it", "aug_mv");
1994 Check_Type (srcv, T_STRING);
1995 const char *src = StringValueCStr (srcv);
1997 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1999 Check_Type (destv, T_STRING);
2000 const char *dest = StringValueCStr (destv);
2002 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2007 r = guestfs_aug_mv (g, src, dest);
2009 rb_raise (e_Error, "%s", guestfs_last_error (g));
2014 static VALUE ruby_guestfs_aug_match (VALUE gv, VALUE pathv)
2017 Data_Get_Struct (gv, guestfs_h, g);
2019 rb_raise (rb_eArgError, "%s: used handle after closing it", "aug_match");
2021 Check_Type (pathv, T_STRING);
2022 const char *path = StringValueCStr (pathv);
2024 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2025 "path", "aug_match");
2029 r = guestfs_aug_match (g, path);
2031 rb_raise (e_Error, "%s", guestfs_last_error (g));
2034 for (i = 0; r[i] != NULL; ++i) len++;
2035 VALUE rv = rb_ary_new2 (len);
2036 for (i = 0; r[i] != NULL; ++i) {
2037 rb_ary_push (rv, rb_str_new2 (r[i]));
2044 static VALUE ruby_guestfs_aug_save (VALUE gv)
2047 Data_Get_Struct (gv, guestfs_h, g);
2049 rb_raise (rb_eArgError, "%s: used handle after closing it", "aug_save");
2054 r = guestfs_aug_save (g);
2056 rb_raise (e_Error, "%s", guestfs_last_error (g));
2061 static VALUE ruby_guestfs_aug_load (VALUE gv)
2064 Data_Get_Struct (gv, guestfs_h, g);
2066 rb_raise (rb_eArgError, "%s: used handle after closing it", "aug_load");
2071 r = guestfs_aug_load (g);
2073 rb_raise (e_Error, "%s", guestfs_last_error (g));
2078 static VALUE ruby_guestfs_aug_ls (VALUE gv, VALUE pathv)
2081 Data_Get_Struct (gv, guestfs_h, g);
2083 rb_raise (rb_eArgError, "%s: used handle after closing it", "aug_ls");
2085 Check_Type (pathv, T_STRING);
2086 const char *path = StringValueCStr (pathv);
2088 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2093 r = guestfs_aug_ls (g, path);
2095 rb_raise (e_Error, "%s", guestfs_last_error (g));
2098 for (i = 0; r[i] != NULL; ++i) len++;
2099 VALUE rv = rb_ary_new2 (len);
2100 for (i = 0; r[i] != NULL; ++i) {
2101 rb_ary_push (rv, rb_str_new2 (r[i]));
2108 static VALUE ruby_guestfs_rm (VALUE gv, VALUE pathv)
2111 Data_Get_Struct (gv, guestfs_h, g);
2113 rb_raise (rb_eArgError, "%s: used handle after closing it", "rm");
2115 Check_Type (pathv, T_STRING);
2116 const char *path = StringValueCStr (pathv);
2118 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2123 r = guestfs_rm (g, path);
2125 rb_raise (e_Error, "%s", guestfs_last_error (g));
2130 static VALUE ruby_guestfs_rmdir (VALUE gv, VALUE pathv)
2133 Data_Get_Struct (gv, guestfs_h, g);
2135 rb_raise (rb_eArgError, "%s: used handle after closing it", "rmdir");
2137 Check_Type (pathv, T_STRING);
2138 const char *path = StringValueCStr (pathv);
2140 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2145 r = guestfs_rmdir (g, path);
2147 rb_raise (e_Error, "%s", guestfs_last_error (g));
2152 static VALUE ruby_guestfs_rm_rf (VALUE gv, VALUE pathv)
2155 Data_Get_Struct (gv, guestfs_h, g);
2157 rb_raise (rb_eArgError, "%s: used handle after closing it", "rm_rf");
2159 Check_Type (pathv, T_STRING);
2160 const char *path = StringValueCStr (pathv);
2162 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2167 r = guestfs_rm_rf (g, path);
2169 rb_raise (e_Error, "%s", guestfs_last_error (g));
2174 static VALUE ruby_guestfs_mkdir (VALUE gv, VALUE pathv)
2177 Data_Get_Struct (gv, guestfs_h, g);
2179 rb_raise (rb_eArgError, "%s: used handle after closing it", "mkdir");
2181 Check_Type (pathv, T_STRING);
2182 const char *path = StringValueCStr (pathv);
2184 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2189 r = guestfs_mkdir (g, path);
2191 rb_raise (e_Error, "%s", guestfs_last_error (g));
2196 static VALUE ruby_guestfs_mkdir_p (VALUE gv, VALUE pathv)
2199 Data_Get_Struct (gv, guestfs_h, g);
2201 rb_raise (rb_eArgError, "%s: used handle after closing it", "mkdir_p");
2203 Check_Type (pathv, T_STRING);
2204 const char *path = StringValueCStr (pathv);
2206 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2211 r = guestfs_mkdir_p (g, path);
2213 rb_raise (e_Error, "%s", guestfs_last_error (g));
2218 static VALUE ruby_guestfs_chmod (VALUE gv, VALUE modev, VALUE pathv)
2221 Data_Get_Struct (gv, guestfs_h, g);
2223 rb_raise (rb_eArgError, "%s: used handle after closing it", "chmod");
2225 int mode = NUM2INT (modev);
2226 Check_Type (pathv, T_STRING);
2227 const char *path = StringValueCStr (pathv);
2229 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2234 r = guestfs_chmod (g, mode, path);
2236 rb_raise (e_Error, "%s", guestfs_last_error (g));
2241 static VALUE ruby_guestfs_chown (VALUE gv, VALUE ownerv, VALUE groupv, VALUE pathv)
2244 Data_Get_Struct (gv, guestfs_h, g);
2246 rb_raise (rb_eArgError, "%s: used handle after closing it", "chown");
2248 int owner = NUM2INT (ownerv);
2249 int group = NUM2INT (groupv);
2250 Check_Type (pathv, T_STRING);
2251 const char *path = StringValueCStr (pathv);
2253 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2258 r = guestfs_chown (g, owner, group, path);
2260 rb_raise (e_Error, "%s", guestfs_last_error (g));
2265 static VALUE ruby_guestfs_exists (VALUE gv, VALUE pathv)
2268 Data_Get_Struct (gv, guestfs_h, g);
2270 rb_raise (rb_eArgError, "%s: used handle after closing it", "exists");
2272 Check_Type (pathv, T_STRING);
2273 const char *path = StringValueCStr (pathv);
2275 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2280 r = guestfs_exists (g, path);
2282 rb_raise (e_Error, "%s", guestfs_last_error (g));
2287 static VALUE ruby_guestfs_is_file (VALUE gv, VALUE pathv)
2290 Data_Get_Struct (gv, guestfs_h, g);
2292 rb_raise (rb_eArgError, "%s: used handle after closing it", "is_file");
2294 Check_Type (pathv, T_STRING);
2295 const char *path = StringValueCStr (pathv);
2297 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2302 r = guestfs_is_file (g, path);
2304 rb_raise (e_Error, "%s", guestfs_last_error (g));
2309 static VALUE ruby_guestfs_is_dir (VALUE gv, VALUE pathv)
2312 Data_Get_Struct (gv, guestfs_h, g);
2314 rb_raise (rb_eArgError, "%s: used handle after closing it", "is_dir");
2316 Check_Type (pathv, T_STRING);
2317 const char *path = StringValueCStr (pathv);
2319 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2324 r = guestfs_is_dir (g, path);
2326 rb_raise (e_Error, "%s", guestfs_last_error (g));
2331 static VALUE ruby_guestfs_pvcreate (VALUE gv, VALUE devicev)
2334 Data_Get_Struct (gv, guestfs_h, g);
2336 rb_raise (rb_eArgError, "%s: used handle after closing it", "pvcreate");
2338 Check_Type (devicev, T_STRING);
2339 const char *device = StringValueCStr (devicev);
2341 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2342 "device", "pvcreate");
2346 r = guestfs_pvcreate (g, device);
2348 rb_raise (e_Error, "%s", guestfs_last_error (g));
2353 static VALUE ruby_guestfs_vgcreate (VALUE gv, VALUE volgroupv, VALUE physvolsv)
2356 Data_Get_Struct (gv, guestfs_h, g);
2358 rb_raise (rb_eArgError, "%s: used handle after closing it", "vgcreate");
2360 Check_Type (volgroupv, T_STRING);
2361 const char *volgroup = StringValueCStr (volgroupv);
2363 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2364 "volgroup", "vgcreate");
2366 Check_Type (physvolsv, T_ARRAY);
2369 len = RARRAY_LEN (physvolsv);
2370 physvols = guestfs_safe_malloc (g, sizeof (char *) * (len+1));
2371 for (i = 0; i < len; ++i) {
2372 VALUE v = rb_ary_entry (physvolsv, i);
2373 physvols[i] = StringValueCStr (v);
2375 physvols[len] = NULL;
2380 r = guestfs_vgcreate (g, volgroup, physvols);
2383 rb_raise (e_Error, "%s", guestfs_last_error (g));
2388 static VALUE ruby_guestfs_lvcreate (VALUE gv, VALUE logvolv, VALUE volgroupv, VALUE mbytesv)
2391 Data_Get_Struct (gv, guestfs_h, g);
2393 rb_raise (rb_eArgError, "%s: used handle after closing it", "lvcreate");
2395 Check_Type (logvolv, T_STRING);
2396 const char *logvol = StringValueCStr (logvolv);
2398 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2399 "logvol", "lvcreate");
2400 Check_Type (volgroupv, T_STRING);
2401 const char *volgroup = StringValueCStr (volgroupv);
2403 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2404 "volgroup", "lvcreate");
2405 int mbytes = NUM2INT (mbytesv);
2409 r = guestfs_lvcreate (g, logvol, volgroup, mbytes);
2411 rb_raise (e_Error, "%s", guestfs_last_error (g));
2416 static VALUE ruby_guestfs_mkfs (VALUE gv, VALUE fstypev, VALUE devicev)
2419 Data_Get_Struct (gv, guestfs_h, g);
2421 rb_raise (rb_eArgError, "%s: used handle after closing it", "mkfs");
2423 Check_Type (fstypev, T_STRING);
2424 const char *fstype = StringValueCStr (fstypev);
2426 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2428 Check_Type (devicev, T_STRING);
2429 const char *device = StringValueCStr (devicev);
2431 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2436 r = guestfs_mkfs (g, fstype, device);
2438 rb_raise (e_Error, "%s", guestfs_last_error (g));
2443 static VALUE ruby_guestfs_sfdisk (VALUE gv, VALUE devicev, VALUE cylsv, VALUE headsv, VALUE sectorsv, VALUE linesv)
2446 Data_Get_Struct (gv, guestfs_h, g);
2448 rb_raise (rb_eArgError, "%s: used handle after closing it", "sfdisk");
2450 Check_Type (devicev, T_STRING);
2451 const char *device = StringValueCStr (devicev);
2453 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2454 "device", "sfdisk");
2455 int cyls = NUM2INT (cylsv);
2456 int heads = NUM2INT (headsv);
2457 int sectors = NUM2INT (sectorsv);
2459 Check_Type (linesv, T_ARRAY);
2462 len = RARRAY_LEN (linesv);
2463 lines = guestfs_safe_malloc (g, sizeof (char *) * (len+1));
2464 for (i = 0; i < len; ++i) {
2465 VALUE v = rb_ary_entry (linesv, i);
2466 lines[i] = StringValueCStr (v);
2473 r = guestfs_sfdisk (g, device, cyls, heads, sectors, lines);
2476 rb_raise (e_Error, "%s", guestfs_last_error (g));
2481 static VALUE ruby_guestfs_write_file (VALUE gv, VALUE pathv, VALUE contentv, VALUE sizev)
2484 Data_Get_Struct (gv, guestfs_h, g);
2486 rb_raise (rb_eArgError, "%s: used handle after closing it", "write_file");
2488 Check_Type (pathv, T_STRING);
2489 const char *path = StringValueCStr (pathv);
2491 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2492 "path", "write_file");
2493 Check_Type (contentv, T_STRING);
2494 const char *content = StringValueCStr (contentv);
2496 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2497 "content", "write_file");
2498 int size = NUM2INT (sizev);
2502 r = guestfs_write_file (g, path, content, size);
2504 rb_raise (e_Error, "%s", guestfs_last_error (g));
2509 static VALUE ruby_guestfs_umount (VALUE gv, VALUE pathordevicev)
2512 Data_Get_Struct (gv, guestfs_h, g);
2514 rb_raise (rb_eArgError, "%s: used handle after closing it", "umount");
2516 Check_Type (pathordevicev, T_STRING);
2517 const char *pathordevice = StringValueCStr (pathordevicev);
2519 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2520 "pathordevice", "umount");
2524 r = guestfs_umount (g, pathordevice);
2526 rb_raise (e_Error, "%s", guestfs_last_error (g));
2531 static VALUE ruby_guestfs_mounts (VALUE gv)
2534 Data_Get_Struct (gv, guestfs_h, g);
2536 rb_raise (rb_eArgError, "%s: used handle after closing it", "mounts");
2541 r = guestfs_mounts (g);
2543 rb_raise (e_Error, "%s", guestfs_last_error (g));
2546 for (i = 0; r[i] != NULL; ++i) len++;
2547 VALUE rv = rb_ary_new2 (len);
2548 for (i = 0; r[i] != NULL; ++i) {
2549 rb_ary_push (rv, rb_str_new2 (r[i]));
2556 static VALUE ruby_guestfs_umount_all (VALUE gv)
2559 Data_Get_Struct (gv, guestfs_h, g);
2561 rb_raise (rb_eArgError, "%s: used handle after closing it", "umount_all");
2566 r = guestfs_umount_all (g);
2568 rb_raise (e_Error, "%s", guestfs_last_error (g));
2573 static VALUE ruby_guestfs_lvm_remove_all (VALUE gv)
2576 Data_Get_Struct (gv, guestfs_h, g);
2578 rb_raise (rb_eArgError, "%s: used handle after closing it", "lvm_remove_all");
2583 r = guestfs_lvm_remove_all (g);
2585 rb_raise (e_Error, "%s", guestfs_last_error (g));
2590 static VALUE ruby_guestfs_file (VALUE gv, VALUE pathv)
2593 Data_Get_Struct (gv, guestfs_h, g);
2595 rb_raise (rb_eArgError, "%s: used handle after closing it", "file");
2597 Check_Type (pathv, T_STRING);
2598 const char *path = StringValueCStr (pathv);
2600 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2605 r = guestfs_file (g, path);
2607 rb_raise (e_Error, "%s", guestfs_last_error (g));
2609 VALUE rv = rb_str_new2 (r);
2614 static VALUE ruby_guestfs_command (VALUE gv, VALUE argumentsv)
2617 Data_Get_Struct (gv, guestfs_h, g);
2619 rb_raise (rb_eArgError, "%s: used handle after closing it", "command");
2622 Check_Type (argumentsv, T_ARRAY);
2625 len = RARRAY_LEN (argumentsv);
2626 arguments = guestfs_safe_malloc (g, sizeof (char *) * (len+1));
2627 for (i = 0; i < len; ++i) {
2628 VALUE v = rb_ary_entry (argumentsv, i);
2629 arguments[i] = StringValueCStr (v);
2631 arguments[len] = NULL;
2636 r = guestfs_command (g, arguments);
2639 rb_raise (e_Error, "%s", guestfs_last_error (g));
2641 VALUE rv = rb_str_new2 (r);
2646 static VALUE ruby_guestfs_command_lines (VALUE gv, VALUE argumentsv)
2649 Data_Get_Struct (gv, guestfs_h, g);
2651 rb_raise (rb_eArgError, "%s: used handle after closing it", "command_lines");
2654 Check_Type (argumentsv, T_ARRAY);
2657 len = RARRAY_LEN (argumentsv);
2658 arguments = guestfs_safe_malloc (g, sizeof (char *) * (len+1));
2659 for (i = 0; i < len; ++i) {
2660 VALUE v = rb_ary_entry (argumentsv, i);
2661 arguments[i] = StringValueCStr (v);
2663 arguments[len] = NULL;
2668 r = guestfs_command_lines (g, arguments);
2671 rb_raise (e_Error, "%s", guestfs_last_error (g));
2674 for (i = 0; r[i] != NULL; ++i) len++;
2675 VALUE rv = rb_ary_new2 (len);
2676 for (i = 0; r[i] != NULL; ++i) {
2677 rb_ary_push (rv, rb_str_new2 (r[i]));
2684 static VALUE ruby_guestfs_stat (VALUE gv, VALUE pathv)
2687 Data_Get_Struct (gv, guestfs_h, g);
2689 rb_raise (rb_eArgError, "%s: used handle after closing it", "stat");
2691 Check_Type (pathv, T_STRING);
2692 const char *path = StringValueCStr (pathv);
2694 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2697 struct guestfs_stat *r;
2699 r = guestfs_stat (g, path);
2701 rb_raise (e_Error, "%s", guestfs_last_error (g));
2703 VALUE rv = rb_hash_new ();
2704 rb_hash_aset (rv, rb_str_new2 ("dev"), ULL2NUM (r->dev));
2705 rb_hash_aset (rv, rb_str_new2 ("ino"), ULL2NUM (r->ino));
2706 rb_hash_aset (rv, rb_str_new2 ("mode"), ULL2NUM (r->mode));
2707 rb_hash_aset (rv, rb_str_new2 ("nlink"), ULL2NUM (r->nlink));
2708 rb_hash_aset (rv, rb_str_new2 ("uid"), ULL2NUM (r->uid));
2709 rb_hash_aset (rv, rb_str_new2 ("gid"), ULL2NUM (r->gid));
2710 rb_hash_aset (rv, rb_str_new2 ("rdev"), ULL2NUM (r->rdev));
2711 rb_hash_aset (rv, rb_str_new2 ("size"), ULL2NUM (r->size));
2712 rb_hash_aset (rv, rb_str_new2 ("blksize"), ULL2NUM (r->blksize));
2713 rb_hash_aset (rv, rb_str_new2 ("blocks"), ULL2NUM (r->blocks));
2714 rb_hash_aset (rv, rb_str_new2 ("atime"), ULL2NUM (r->atime));
2715 rb_hash_aset (rv, rb_str_new2 ("mtime"), ULL2NUM (r->mtime));
2716 rb_hash_aset (rv, rb_str_new2 ("ctime"), ULL2NUM (r->ctime));
2721 static VALUE ruby_guestfs_lstat (VALUE gv, VALUE pathv)
2724 Data_Get_Struct (gv, guestfs_h, g);
2726 rb_raise (rb_eArgError, "%s: used handle after closing it", "lstat");
2728 Check_Type (pathv, T_STRING);
2729 const char *path = StringValueCStr (pathv);
2731 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2734 struct guestfs_stat *r;
2736 r = guestfs_lstat (g, path);
2738 rb_raise (e_Error, "%s", guestfs_last_error (g));
2740 VALUE rv = rb_hash_new ();
2741 rb_hash_aset (rv, rb_str_new2 ("dev"), ULL2NUM (r->dev));
2742 rb_hash_aset (rv, rb_str_new2 ("ino"), ULL2NUM (r->ino));
2743 rb_hash_aset (rv, rb_str_new2 ("mode"), ULL2NUM (r->mode));
2744 rb_hash_aset (rv, rb_str_new2 ("nlink"), ULL2NUM (r->nlink));
2745 rb_hash_aset (rv, rb_str_new2 ("uid"), ULL2NUM (r->uid));
2746 rb_hash_aset (rv, rb_str_new2 ("gid"), ULL2NUM (r->gid));
2747 rb_hash_aset (rv, rb_str_new2 ("rdev"), ULL2NUM (r->rdev));
2748 rb_hash_aset (rv, rb_str_new2 ("size"), ULL2NUM (r->size));
2749 rb_hash_aset (rv, rb_str_new2 ("blksize"), ULL2NUM (r->blksize));
2750 rb_hash_aset (rv, rb_str_new2 ("blocks"), ULL2NUM (r->blocks));
2751 rb_hash_aset (rv, rb_str_new2 ("atime"), ULL2NUM (r->atime));
2752 rb_hash_aset (rv, rb_str_new2 ("mtime"), ULL2NUM (r->mtime));
2753 rb_hash_aset (rv, rb_str_new2 ("ctime"), ULL2NUM (r->ctime));
2758 static VALUE ruby_guestfs_statvfs (VALUE gv, VALUE pathv)
2761 Data_Get_Struct (gv, guestfs_h, g);
2763 rb_raise (rb_eArgError, "%s: used handle after closing it", "statvfs");
2765 Check_Type (pathv, T_STRING);
2766 const char *path = StringValueCStr (pathv);
2768 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2771 struct guestfs_statvfs *r;
2773 r = guestfs_statvfs (g, path);
2775 rb_raise (e_Error, "%s", guestfs_last_error (g));
2777 VALUE rv = rb_hash_new ();
2778 rb_hash_aset (rv, rb_str_new2 ("bsize"), ULL2NUM (r->bsize));
2779 rb_hash_aset (rv, rb_str_new2 ("frsize"), ULL2NUM (r->frsize));
2780 rb_hash_aset (rv, rb_str_new2 ("blocks"), ULL2NUM (r->blocks));
2781 rb_hash_aset (rv, rb_str_new2 ("bfree"), ULL2NUM (r->bfree));
2782 rb_hash_aset (rv, rb_str_new2 ("bavail"), ULL2NUM (r->bavail));
2783 rb_hash_aset (rv, rb_str_new2 ("files"), ULL2NUM (r->files));
2784 rb_hash_aset (rv, rb_str_new2 ("ffree"), ULL2NUM (r->ffree));
2785 rb_hash_aset (rv, rb_str_new2 ("favail"), ULL2NUM (r->favail));
2786 rb_hash_aset (rv, rb_str_new2 ("fsid"), ULL2NUM (r->fsid));
2787 rb_hash_aset (rv, rb_str_new2 ("flag"), ULL2NUM (r->flag));
2788 rb_hash_aset (rv, rb_str_new2 ("namemax"), ULL2NUM (r->namemax));
2793 static VALUE ruby_guestfs_tune2fs_l (VALUE gv, VALUE devicev)
2796 Data_Get_Struct (gv, guestfs_h, g);
2798 rb_raise (rb_eArgError, "%s: used handle after closing it", "tune2fs_l");
2800 Check_Type (devicev, T_STRING);
2801 const char *device = StringValueCStr (devicev);
2803 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2804 "device", "tune2fs_l");
2808 r = guestfs_tune2fs_l (g, device);
2810 rb_raise (e_Error, "%s", guestfs_last_error (g));
2812 VALUE rv = rb_hash_new ();
2814 for (i = 0; r[i] != NULL; i+=2) {
2815 rb_hash_aset (rv, rb_str_new2 (r[i]), rb_str_new2 (r[i+1]));
2823 static VALUE ruby_guestfs_blockdev_setro (VALUE gv, VALUE devicev)
2826 Data_Get_Struct (gv, guestfs_h, g);
2828 rb_raise (rb_eArgError, "%s: used handle after closing it", "blockdev_setro");
2830 Check_Type (devicev, T_STRING);
2831 const char *device = StringValueCStr (devicev);
2833 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2834 "device", "blockdev_setro");
2838 r = guestfs_blockdev_setro (g, device);
2840 rb_raise (e_Error, "%s", guestfs_last_error (g));
2845 static VALUE ruby_guestfs_blockdev_setrw (VALUE gv, VALUE devicev)
2848 Data_Get_Struct (gv, guestfs_h, g);
2850 rb_raise (rb_eArgError, "%s: used handle after closing it", "blockdev_setrw");
2852 Check_Type (devicev, T_STRING);
2853 const char *device = StringValueCStr (devicev);
2855 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2856 "device", "blockdev_setrw");
2860 r = guestfs_blockdev_setrw (g, device);
2862 rb_raise (e_Error, "%s", guestfs_last_error (g));
2867 static VALUE ruby_guestfs_blockdev_getro (VALUE gv, VALUE devicev)
2870 Data_Get_Struct (gv, guestfs_h, g);
2872 rb_raise (rb_eArgError, "%s: used handle after closing it", "blockdev_getro");
2874 Check_Type (devicev, T_STRING);
2875 const char *device = StringValueCStr (devicev);
2877 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2878 "device", "blockdev_getro");
2882 r = guestfs_blockdev_getro (g, device);
2884 rb_raise (e_Error, "%s", guestfs_last_error (g));
2889 static VALUE ruby_guestfs_blockdev_getss (VALUE gv, VALUE devicev)
2892 Data_Get_Struct (gv, guestfs_h, g);
2894 rb_raise (rb_eArgError, "%s: used handle after closing it", "blockdev_getss");
2896 Check_Type (devicev, T_STRING);
2897 const char *device = StringValueCStr (devicev);
2899 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2900 "device", "blockdev_getss");
2904 r = guestfs_blockdev_getss (g, device);
2906 rb_raise (e_Error, "%s", guestfs_last_error (g));
2911 static VALUE ruby_guestfs_blockdev_getbsz (VALUE gv, VALUE devicev)
2914 Data_Get_Struct (gv, guestfs_h, g);
2916 rb_raise (rb_eArgError, "%s: used handle after closing it", "blockdev_getbsz");
2918 Check_Type (devicev, T_STRING);
2919 const char *device = StringValueCStr (devicev);
2921 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2922 "device", "blockdev_getbsz");
2926 r = guestfs_blockdev_getbsz (g, device);
2928 rb_raise (e_Error, "%s", guestfs_last_error (g));
2933 static VALUE ruby_guestfs_blockdev_setbsz (VALUE gv, VALUE devicev, VALUE blocksizev)
2936 Data_Get_Struct (gv, guestfs_h, g);
2938 rb_raise (rb_eArgError, "%s: used handle after closing it", "blockdev_setbsz");
2940 Check_Type (devicev, T_STRING);
2941 const char *device = StringValueCStr (devicev);
2943 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2944 "device", "blockdev_setbsz");
2945 int blocksize = NUM2INT (blocksizev);
2949 r = guestfs_blockdev_setbsz (g, device, blocksize);
2951 rb_raise (e_Error, "%s", guestfs_last_error (g));
2956 static VALUE ruby_guestfs_blockdev_getsz (VALUE gv, VALUE devicev)
2959 Data_Get_Struct (gv, guestfs_h, g);
2961 rb_raise (rb_eArgError, "%s: used handle after closing it", "blockdev_getsz");
2963 Check_Type (devicev, T_STRING);
2964 const char *device = StringValueCStr (devicev);
2966 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2967 "device", "blockdev_getsz");
2971 r = guestfs_blockdev_getsz (g, device);
2973 rb_raise (e_Error, "%s", guestfs_last_error (g));
2978 static VALUE ruby_guestfs_blockdev_getsize64 (VALUE gv, VALUE devicev)
2981 Data_Get_Struct (gv, guestfs_h, g);
2983 rb_raise (rb_eArgError, "%s: used handle after closing it", "blockdev_getsize64");
2985 Check_Type (devicev, T_STRING);
2986 const char *device = StringValueCStr (devicev);
2988 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2989 "device", "blockdev_getsize64");
2993 r = guestfs_blockdev_getsize64 (g, device);
2995 rb_raise (e_Error, "%s", guestfs_last_error (g));
3000 static VALUE ruby_guestfs_blockdev_flushbufs (VALUE gv, VALUE devicev)
3003 Data_Get_Struct (gv, guestfs_h, g);
3005 rb_raise (rb_eArgError, "%s: used handle after closing it", "blockdev_flushbufs");
3007 Check_Type (devicev, T_STRING);
3008 const char *device = StringValueCStr (devicev);
3010 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3011 "device", "blockdev_flushbufs");
3015 r = guestfs_blockdev_flushbufs (g, device);
3017 rb_raise (e_Error, "%s", guestfs_last_error (g));
3022 static VALUE ruby_guestfs_blockdev_rereadpt (VALUE gv, VALUE devicev)
3025 Data_Get_Struct (gv, guestfs_h, g);
3027 rb_raise (rb_eArgError, "%s: used handle after closing it", "blockdev_rereadpt");
3029 Check_Type (devicev, T_STRING);
3030 const char *device = StringValueCStr (devicev);
3032 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3033 "device", "blockdev_rereadpt");
3037 r = guestfs_blockdev_rereadpt (g, device);
3039 rb_raise (e_Error, "%s", guestfs_last_error (g));
3044 static VALUE ruby_guestfs_upload (VALUE gv, VALUE filenamev, VALUE remotefilenamev)
3047 Data_Get_Struct (gv, guestfs_h, g);
3049 rb_raise (rb_eArgError, "%s: used handle after closing it", "upload");
3051 Check_Type (filenamev, T_STRING);
3052 const char *filename = StringValueCStr (filenamev);
3054 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3055 "filename", "upload");
3056 Check_Type (remotefilenamev, T_STRING);
3057 const char *remotefilename = StringValueCStr (remotefilenamev);
3058 if (!remotefilename)
3059 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3060 "remotefilename", "upload");
3064 r = guestfs_upload (g, filename, remotefilename);
3066 rb_raise (e_Error, "%s", guestfs_last_error (g));
3071 static VALUE ruby_guestfs_download (VALUE gv, VALUE remotefilenamev, VALUE filenamev)
3074 Data_Get_Struct (gv, guestfs_h, g);
3076 rb_raise (rb_eArgError, "%s: used handle after closing it", "download");
3078 Check_Type (remotefilenamev, T_STRING);
3079 const char *remotefilename = StringValueCStr (remotefilenamev);
3080 if (!remotefilename)
3081 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3082 "remotefilename", "download");
3083 Check_Type (filenamev, T_STRING);
3084 const char *filename = StringValueCStr (filenamev);
3086 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3087 "filename", "download");
3091 r = guestfs_download (g, remotefilename, filename);
3093 rb_raise (e_Error, "%s", guestfs_last_error (g));
3098 static VALUE ruby_guestfs_checksum (VALUE gv, VALUE csumtypev, VALUE pathv)
3101 Data_Get_Struct (gv, guestfs_h, g);
3103 rb_raise (rb_eArgError, "%s: used handle after closing it", "checksum");
3105 Check_Type (csumtypev, T_STRING);
3106 const char *csumtype = StringValueCStr (csumtypev);
3108 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3109 "csumtype", "checksum");
3110 Check_Type (pathv, T_STRING);
3111 const char *path = StringValueCStr (pathv);
3113 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3114 "path", "checksum");
3118 r = guestfs_checksum (g, csumtype, path);
3120 rb_raise (e_Error, "%s", guestfs_last_error (g));
3122 VALUE rv = rb_str_new2 (r);
3127 static VALUE ruby_guestfs_tar_in (VALUE gv, VALUE tarfilev, VALUE directoryv)
3130 Data_Get_Struct (gv, guestfs_h, g);
3132 rb_raise (rb_eArgError, "%s: used handle after closing it", "tar_in");
3134 Check_Type (tarfilev, T_STRING);
3135 const char *tarfile = StringValueCStr (tarfilev);
3137 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3138 "tarfile", "tar_in");
3139 Check_Type (directoryv, T_STRING);
3140 const char *directory = StringValueCStr (directoryv);
3142 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3143 "directory", "tar_in");
3147 r = guestfs_tar_in (g, tarfile, directory);
3149 rb_raise (e_Error, "%s", guestfs_last_error (g));
3154 static VALUE ruby_guestfs_tar_out (VALUE gv, VALUE directoryv, VALUE tarfilev)
3157 Data_Get_Struct (gv, guestfs_h, g);
3159 rb_raise (rb_eArgError, "%s: used handle after closing it", "tar_out");
3161 Check_Type (directoryv, T_STRING);
3162 const char *directory = StringValueCStr (directoryv);
3164 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3165 "directory", "tar_out");
3166 Check_Type (tarfilev, T_STRING);
3167 const char *tarfile = StringValueCStr (tarfilev);
3169 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3170 "tarfile", "tar_out");
3174 r = guestfs_tar_out (g, directory, tarfile);
3176 rb_raise (e_Error, "%s", guestfs_last_error (g));
3181 static VALUE ruby_guestfs_tgz_in (VALUE gv, VALUE tarballv, VALUE directoryv)
3184 Data_Get_Struct (gv, guestfs_h, g);
3186 rb_raise (rb_eArgError, "%s: used handle after closing it", "tgz_in");
3188 Check_Type (tarballv, T_STRING);
3189 const char *tarball = StringValueCStr (tarballv);
3191 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3192 "tarball", "tgz_in");
3193 Check_Type (directoryv, T_STRING);
3194 const char *directory = StringValueCStr (directoryv);
3196 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3197 "directory", "tgz_in");
3201 r = guestfs_tgz_in (g, tarball, directory);
3203 rb_raise (e_Error, "%s", guestfs_last_error (g));
3208 static VALUE ruby_guestfs_tgz_out (VALUE gv, VALUE directoryv, VALUE tarballv)
3211 Data_Get_Struct (gv, guestfs_h, g);
3213 rb_raise (rb_eArgError, "%s: used handle after closing it", "tgz_out");
3215 Check_Type (directoryv, T_STRING);
3216 const char *directory = StringValueCStr (directoryv);
3218 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3219 "directory", "tgz_out");
3220 Check_Type (tarballv, T_STRING);
3221 const char *tarball = StringValueCStr (tarballv);
3223 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3224 "tarball", "tgz_out");
3228 r = guestfs_tgz_out (g, directory, tarball);
3230 rb_raise (e_Error, "%s", guestfs_last_error (g));
3235 static VALUE ruby_guestfs_mount_ro (VALUE gv, VALUE devicev, VALUE mountpointv)
3238 Data_Get_Struct (gv, guestfs_h, g);
3240 rb_raise (rb_eArgError, "%s: used handle after closing it", "mount_ro");
3242 Check_Type (devicev, T_STRING);
3243 const char *device = StringValueCStr (devicev);
3245 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3246 "device", "mount_ro");
3247 Check_Type (mountpointv, T_STRING);
3248 const char *mountpoint = StringValueCStr (mountpointv);
3250 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3251 "mountpoint", "mount_ro");
3255 r = guestfs_mount_ro (g, device, mountpoint);
3257 rb_raise (e_Error, "%s", guestfs_last_error (g));
3262 static VALUE ruby_guestfs_mount_options (VALUE gv, VALUE optionsv, VALUE devicev, VALUE mountpointv)
3265 Data_Get_Struct (gv, guestfs_h, g);
3267 rb_raise (rb_eArgError, "%s: used handle after closing it", "mount_options");
3269 Check_Type (optionsv, T_STRING);
3270 const char *options = StringValueCStr (optionsv);
3272 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3273 "options", "mount_options");
3274 Check_Type (devicev, T_STRING);
3275 const char *device = StringValueCStr (devicev);
3277 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3278 "device", "mount_options");
3279 Check_Type (mountpointv, T_STRING);
3280 const char *mountpoint = StringValueCStr (mountpointv);
3282 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3283 "mountpoint", "mount_options");
3287 r = guestfs_mount_options (g, options, device, mountpoint);
3289 rb_raise (e_Error, "%s", guestfs_last_error (g));
3294 static VALUE ruby_guestfs_mount_vfs (VALUE gv, VALUE optionsv, VALUE vfstypev, VALUE devicev, VALUE mountpointv)
3297 Data_Get_Struct (gv, guestfs_h, g);
3299 rb_raise (rb_eArgError, "%s: used handle after closing it", "mount_vfs");
3301 Check_Type (optionsv, T_STRING);
3302 const char *options = StringValueCStr (optionsv);
3304 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3305 "options", "mount_vfs");
3306 Check_Type (vfstypev, T_STRING);
3307 const char *vfstype = StringValueCStr (vfstypev);
3309 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3310 "vfstype", "mount_vfs");
3311 Check_Type (devicev, T_STRING);
3312 const char *device = StringValueCStr (devicev);
3314 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3315 "device", "mount_vfs");
3316 Check_Type (mountpointv, T_STRING);
3317 const char *mountpoint = StringValueCStr (mountpointv);
3319 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3320 "mountpoint", "mount_vfs");
3324 r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint);
3326 rb_raise (e_Error, "%s", guestfs_last_error (g));
3331 static VALUE ruby_guestfs_debug (VALUE gv, VALUE subcmdv, VALUE extraargsv)
3334 Data_Get_Struct (gv, guestfs_h, g);
3336 rb_raise (rb_eArgError, "%s: used handle after closing it", "debug");
3338 Check_Type (subcmdv, T_STRING);
3339 const char *subcmd = StringValueCStr (subcmdv);
3341 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3344 Check_Type (extraargsv, T_ARRAY);
3347 len = RARRAY_LEN (extraargsv);
3348 extraargs = guestfs_safe_malloc (g, sizeof (char *) * (len+1));
3349 for (i = 0; i < len; ++i) {
3350 VALUE v = rb_ary_entry (extraargsv, i);
3351 extraargs[i] = StringValueCStr (v);
3353 extraargs[len] = NULL;
3358 r = guestfs_debug (g, subcmd, extraargs);
3361 rb_raise (e_Error, "%s", guestfs_last_error (g));
3363 VALUE rv = rb_str_new2 (r);
3368 static VALUE ruby_guestfs_lvremove (VALUE gv, VALUE devicev)
3371 Data_Get_Struct (gv, guestfs_h, g);
3373 rb_raise (rb_eArgError, "%s: used handle after closing it", "lvremove");
3375 Check_Type (devicev, T_STRING);
3376 const char *device = StringValueCStr (devicev);
3378 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3379 "device", "lvremove");
3383 r = guestfs_lvremove (g, device);
3385 rb_raise (e_Error, "%s", guestfs_last_error (g));
3390 static VALUE ruby_guestfs_vgremove (VALUE gv, VALUE vgnamev)
3393 Data_Get_Struct (gv, guestfs_h, g);
3395 rb_raise (rb_eArgError, "%s: used handle after closing it", "vgremove");
3397 Check_Type (vgnamev, T_STRING);
3398 const char *vgname = StringValueCStr (vgnamev);
3400 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3401 "vgname", "vgremove");
3405 r = guestfs_vgremove (g, vgname);
3407 rb_raise (e_Error, "%s", guestfs_last_error (g));
3412 static VALUE ruby_guestfs_pvremove (VALUE gv, VALUE devicev)
3415 Data_Get_Struct (gv, guestfs_h, g);
3417 rb_raise (rb_eArgError, "%s: used handle after closing it", "pvremove");
3419 Check_Type (devicev, T_STRING);
3420 const char *device = StringValueCStr (devicev);
3422 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3423 "device", "pvremove");
3427 r = guestfs_pvremove (g, device);
3429 rb_raise (e_Error, "%s", guestfs_last_error (g));
3434 static VALUE ruby_guestfs_set_e2label (VALUE gv, VALUE devicev, VALUE labelv)
3437 Data_Get_Struct (gv, guestfs_h, g);
3439 rb_raise (rb_eArgError, "%s: used handle after closing it", "set_e2label");
3441 Check_Type (devicev, T_STRING);
3442 const char *device = StringValueCStr (devicev);
3444 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3445 "device", "set_e2label");
3446 Check_Type (labelv, T_STRING);
3447 const char *label = StringValueCStr (labelv);
3449 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3450 "label", "set_e2label");
3454 r = guestfs_set_e2label (g, device, label);
3456 rb_raise (e_Error, "%s", guestfs_last_error (g));
3461 static VALUE ruby_guestfs_get_e2label (VALUE gv, VALUE devicev)
3464 Data_Get_Struct (gv, guestfs_h, g);
3466 rb_raise (rb_eArgError, "%s: used handle after closing it", "get_e2label");
3468 Check_Type (devicev, T_STRING);
3469 const char *device = StringValueCStr (devicev);
3471 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3472 "device", "get_e2label");
3476 r = guestfs_get_e2label (g, device);
3478 rb_raise (e_Error, "%s", guestfs_last_error (g));
3480 VALUE rv = rb_str_new2 (r);
3485 static VALUE ruby_guestfs_set_e2uuid (VALUE gv, VALUE devicev, VALUE uuidv)
3488 Data_Get_Struct (gv, guestfs_h, g);
3490 rb_raise (rb_eArgError, "%s: used handle after closing it", "set_e2uuid");
3492 Check_Type (devicev, T_STRING);
3493 const char *device = StringValueCStr (devicev);
3495 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3496 "device", "set_e2uuid");
3497 Check_Type (uuidv, T_STRING);
3498 const char *uuid = StringValueCStr (uuidv);
3500 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3501 "uuid", "set_e2uuid");
3505 r = guestfs_set_e2uuid (g, device, uuid);
3507 rb_raise (e_Error, "%s", guestfs_last_error (g));
3512 static VALUE ruby_guestfs_get_e2uuid (VALUE gv, VALUE devicev)
3515 Data_Get_Struct (gv, guestfs_h, g);
3517 rb_raise (rb_eArgError, "%s: used handle after closing it", "get_e2uuid");
3519 Check_Type (devicev, T_STRING);
3520 const char *device = StringValueCStr (devicev);
3522 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3523 "device", "get_e2uuid");
3527 r = guestfs_get_e2uuid (g, device);
3529 rb_raise (e_Error, "%s", guestfs_last_error (g));
3531 VALUE rv = rb_str_new2 (r);
3536 static VALUE ruby_guestfs_fsck (VALUE gv, VALUE fstypev, VALUE devicev)
3539 Data_Get_Struct (gv, guestfs_h, g);
3541 rb_raise (rb_eArgError, "%s: used handle after closing it", "fsck");
3543 Check_Type (fstypev, T_STRING);
3544 const char *fstype = StringValueCStr (fstypev);
3546 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3548 Check_Type (devicev, T_STRING);
3549 const char *device = StringValueCStr (devicev);
3551 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3556 r = guestfs_fsck (g, fstype, device);
3558 rb_raise (e_Error, "%s", guestfs_last_error (g));
3563 static VALUE ruby_guestfs_zero (VALUE gv, VALUE devicev)
3566 Data_Get_Struct (gv, guestfs_h, g);
3568 rb_raise (rb_eArgError, "%s: used handle after closing it", "zero");
3570 Check_Type (devicev, T_STRING);
3571 const char *device = StringValueCStr (devicev);
3573 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3578 r = guestfs_zero (g, device);
3580 rb_raise (e_Error, "%s", guestfs_last_error (g));
3585 static VALUE ruby_guestfs_grub_install (VALUE gv, VALUE rootv, VALUE devicev)
3588 Data_Get_Struct (gv, guestfs_h, g);
3590 rb_raise (rb_eArgError, "%s: used handle after closing it", "grub_install");
3592 Check_Type (rootv, T_STRING);
3593 const char *root = StringValueCStr (rootv);
3595 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3596 "root", "grub_install");
3597 Check_Type (devicev, T_STRING);
3598 const char *device = StringValueCStr (devicev);
3600 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3601 "device", "grub_install");
3605 r = guestfs_grub_install (g, root, device);
3607 rb_raise (e_Error, "%s", guestfs_last_error (g));
3612 static VALUE ruby_guestfs_cp (VALUE gv, VALUE srcv, VALUE destv)
3615 Data_Get_Struct (gv, guestfs_h, g);
3617 rb_raise (rb_eArgError, "%s: used handle after closing it", "cp");
3619 Check_Type (srcv, T_STRING);
3620 const char *src = StringValueCStr (srcv);
3622 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3624 Check_Type (destv, T_STRING);
3625 const char *dest = StringValueCStr (destv);
3627 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3632 r = guestfs_cp (g, src, dest);
3634 rb_raise (e_Error, "%s", guestfs_last_error (g));
3639 static VALUE ruby_guestfs_cp_a (VALUE gv, VALUE srcv, VALUE destv)
3642 Data_Get_Struct (gv, guestfs_h, g);
3644 rb_raise (rb_eArgError, "%s: used handle after closing it", "cp_a");
3646 Check_Type (srcv, T_STRING);
3647 const char *src = StringValueCStr (srcv);
3649 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3651 Check_Type (destv, T_STRING);
3652 const char *dest = StringValueCStr (destv);
3654 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3659 r = guestfs_cp_a (g, src, dest);
3661 rb_raise (e_Error, "%s", guestfs_last_error (g));
3666 static VALUE ruby_guestfs_mv (VALUE gv, VALUE srcv, VALUE destv)
3669 Data_Get_Struct (gv, guestfs_h, g);
3671 rb_raise (rb_eArgError, "%s: used handle after closing it", "mv");
3673 Check_Type (srcv, T_STRING);
3674 const char *src = StringValueCStr (srcv);
3676 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3678 Check_Type (destv, T_STRING);
3679 const char *dest = StringValueCStr (destv);
3681 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3686 r = guestfs_mv (g, src, dest);
3688 rb_raise (e_Error, "%s", guestfs_last_error (g));
3693 static VALUE ruby_guestfs_drop_caches (VALUE gv, VALUE whattodropv)
3696 Data_Get_Struct (gv, guestfs_h, g);
3698 rb_raise (rb_eArgError, "%s: used handle after closing it", "drop_caches");
3700 int whattodrop = NUM2INT (whattodropv);
3704 r = guestfs_drop_caches (g, whattodrop);
3706 rb_raise (e_Error, "%s", guestfs_last_error (g));
3711 static VALUE ruby_guestfs_dmesg (VALUE gv)
3714 Data_Get_Struct (gv, guestfs_h, g);
3716 rb_raise (rb_eArgError, "%s: used handle after closing it", "dmesg");
3721 r = guestfs_dmesg (g);
3723 rb_raise (e_Error, "%s", guestfs_last_error (g));
3725 VALUE rv = rb_str_new2 (r);
3730 static VALUE ruby_guestfs_ping_daemon (VALUE gv)
3733 Data_Get_Struct (gv, guestfs_h, g);
3735 rb_raise (rb_eArgError, "%s: used handle after closing it", "ping_daemon");
3740 r = guestfs_ping_daemon (g);
3742 rb_raise (e_Error, "%s", guestfs_last_error (g));
3747 static VALUE ruby_guestfs_equal (VALUE gv, VALUE file1v, VALUE file2v)
3750 Data_Get_Struct (gv, guestfs_h, g);
3752 rb_raise (rb_eArgError, "%s: used handle after closing it", "equal");
3754 Check_Type (file1v, T_STRING);
3755 const char *file1 = StringValueCStr (file1v);
3757 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3759 Check_Type (file2v, T_STRING);
3760 const char *file2 = StringValueCStr (file2v);
3762 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3767 r = guestfs_equal (g, file1, file2);
3769 rb_raise (e_Error, "%s", guestfs_last_error (g));
3774 static VALUE ruby_guestfs_strings (VALUE gv, VALUE pathv)
3777 Data_Get_Struct (gv, guestfs_h, g);
3779 rb_raise (rb_eArgError, "%s: used handle after closing it", "strings");
3781 Check_Type (pathv, T_STRING);
3782 const char *path = StringValueCStr (pathv);
3784 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3789 r = guestfs_strings (g, path);
3791 rb_raise (e_Error, "%s", guestfs_last_error (g));
3794 for (i = 0; r[i] != NULL; ++i) len++;
3795 VALUE rv = rb_ary_new2 (len);
3796 for (i = 0; r[i] != NULL; ++i) {
3797 rb_ary_push (rv, rb_str_new2 (r[i]));
3804 static VALUE ruby_guestfs_strings_e (VALUE gv, VALUE encodingv, VALUE pathv)
3807 Data_Get_Struct (gv, guestfs_h, g);
3809 rb_raise (rb_eArgError, "%s: used handle after closing it", "strings_e");
3811 Check_Type (encodingv, T_STRING);
3812 const char *encoding = StringValueCStr (encodingv);
3814 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3815 "encoding", "strings_e");
3816 Check_Type (pathv, T_STRING);
3817 const char *path = StringValueCStr (pathv);
3819 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3820 "path", "strings_e");
3824 r = guestfs_strings_e (g, encoding, path);
3826 rb_raise (e_Error, "%s", guestfs_last_error (g));
3829 for (i = 0; r[i] != NULL; ++i) len++;
3830 VALUE rv = rb_ary_new2 (len);
3831 for (i = 0; r[i] != NULL; ++i) {
3832 rb_ary_push (rv, rb_str_new2 (r[i]));
3839 static VALUE ruby_guestfs_hexdump (VALUE gv, VALUE pathv)
3842 Data_Get_Struct (gv, guestfs_h, g);
3844 rb_raise (rb_eArgError, "%s: used handle after closing it", "hexdump");
3846 Check_Type (pathv, T_STRING);
3847 const char *path = StringValueCStr (pathv);
3849 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3854 r = guestfs_hexdump (g, path);
3856 rb_raise (e_Error, "%s", guestfs_last_error (g));
3858 VALUE rv = rb_str_new2 (r);
3863 static VALUE ruby_guestfs_zerofree (VALUE gv, VALUE devicev)
3866 Data_Get_Struct (gv, guestfs_h, g);
3868 rb_raise (rb_eArgError, "%s: used handle after closing it", "zerofree");
3870 Check_Type (devicev, T_STRING);
3871 const char *device = StringValueCStr (devicev);
3873 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3874 "device", "zerofree");
3878 r = guestfs_zerofree (g, device);
3880 rb_raise (e_Error, "%s", guestfs_last_error (g));
3885 static VALUE ruby_guestfs_pvresize (VALUE gv, VALUE devicev)
3888 Data_Get_Struct (gv, guestfs_h, g);
3890 rb_raise (rb_eArgError, "%s: used handle after closing it", "pvresize");
3892 Check_Type (devicev, T_STRING);
3893 const char *device = StringValueCStr (devicev);
3895 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3896 "device", "pvresize");
3900 r = guestfs_pvresize (g, device);
3902 rb_raise (e_Error, "%s", guestfs_last_error (g));
3907 static VALUE ruby_guestfs_sfdisk_N (VALUE gv, VALUE devicev, VALUE partnumv, VALUE cylsv, VALUE headsv, VALUE sectorsv, VALUE linev)
3910 Data_Get_Struct (gv, guestfs_h, g);
3912 rb_raise (rb_eArgError, "%s: used handle after closing it", "sfdisk_N");
3914 Check_Type (devicev, T_STRING);
3915 const char *device = StringValueCStr (devicev);
3917 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3918 "device", "sfdisk_N");
3919 int partnum = NUM2INT (partnumv);
3920 int cyls = NUM2INT (cylsv);
3921 int heads = NUM2INT (headsv);
3922 int sectors = NUM2INT (sectorsv);
3923 Check_Type (linev, T_STRING);
3924 const char *line = StringValueCStr (linev);
3926 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3927 "line", "sfdisk_N");
3931 r = guestfs_sfdisk_N (g, device, partnum, cyls, heads, sectors, line);
3933 rb_raise (e_Error, "%s", guestfs_last_error (g));
3938 static VALUE ruby_guestfs_sfdisk_l (VALUE gv, VALUE devicev)
3941 Data_Get_Struct (gv, guestfs_h, g);
3943 rb_raise (rb_eArgError, "%s: used handle after closing it", "sfdisk_l");
3945 Check_Type (devicev, T_STRING);
3946 const char *device = StringValueCStr (devicev);
3948 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3949 "device", "sfdisk_l");
3953 r = guestfs_sfdisk_l (g, device);
3955 rb_raise (e_Error, "%s", guestfs_last_error (g));
3957 VALUE rv = rb_str_new2 (r);
3962 static VALUE ruby_guestfs_sfdisk_kernel_geometry (VALUE gv, VALUE devicev)
3965 Data_Get_Struct (gv, guestfs_h, g);
3967 rb_raise (rb_eArgError, "%s: used handle after closing it", "sfdisk_kernel_geometry");
3969 Check_Type (devicev, T_STRING);
3970 const char *device = StringValueCStr (devicev);
3972 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3973 "device", "sfdisk_kernel_geometry");
3977 r = guestfs_sfdisk_kernel_geometry (g, device);
3979 rb_raise (e_Error, "%s", guestfs_last_error (g));
3981 VALUE rv = rb_str_new2 (r);
3986 static VALUE ruby_guestfs_sfdisk_disk_geometry (VALUE gv, VALUE devicev)
3989 Data_Get_Struct (gv, guestfs_h, g);
3991 rb_raise (rb_eArgError, "%s: used handle after closing it", "sfdisk_disk_geometry");
3993 Check_Type (devicev, T_STRING);
3994 const char *device = StringValueCStr (devicev);
3996 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3997 "device", "sfdisk_disk_geometry");
4001 r = guestfs_sfdisk_disk_geometry (g, device);
4003 rb_raise (e_Error, "%s", guestfs_last_error (g));
4005 VALUE rv = rb_str_new2 (r);
4010 static VALUE ruby_guestfs_vg_activate_all (VALUE gv, VALUE activatev)
4013 Data_Get_Struct (gv, guestfs_h, g);
4015 rb_raise (rb_eArgError, "%s: used handle after closing it", "vg_activate_all");
4017 int activate = RTEST (activatev);
4021 r = guestfs_vg_activate_all (g, activate);
4023 rb_raise (e_Error, "%s", guestfs_last_error (g));
4028 static VALUE ruby_guestfs_vg_activate (VALUE gv, VALUE activatev, VALUE volgroupsv)
4031 Data_Get_Struct (gv, guestfs_h, g);
4033 rb_raise (rb_eArgError, "%s: used handle after closing it", "vg_activate");
4035 int activate = RTEST (activatev);
4037 Check_Type (volgroupsv, T_ARRAY);
4040 len = RARRAY_LEN (volgroupsv);
4041 volgroups = guestfs_safe_malloc (g, sizeof (char *) * (len+1));
4042 for (i = 0; i < len; ++i) {
4043 VALUE v = rb_ary_entry (volgroupsv, i);
4044 volgroups[i] = StringValueCStr (v);
4046 volgroups[len] = NULL;
4051 r = guestfs_vg_activate (g, activate, volgroups);
4054 rb_raise (e_Error, "%s", guestfs_last_error (g));
4059 static VALUE ruby_guestfs_lvresize (VALUE gv, VALUE devicev, VALUE mbytesv)
4062 Data_Get_Struct (gv, guestfs_h, g);
4064 rb_raise (rb_eArgError, "%s: used handle after closing it", "lvresize");
4066 Check_Type (devicev, T_STRING);
4067 const char *device = StringValueCStr (devicev);
4069 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
4070 "device", "lvresize");
4071 int mbytes = NUM2INT (mbytesv);
4075 r = guestfs_lvresize (g, device, mbytes);
4077 rb_raise (e_Error, "%s", guestfs_last_error (g));
4082 static VALUE ruby_guestfs_resize2fs (VALUE gv, VALUE devicev)
4085 Data_Get_Struct (gv, guestfs_h, g);
4087 rb_raise (rb_eArgError, "%s: used handle after closing it", "resize2fs");
4089 Check_Type (devicev, T_STRING);
4090 const char *device = StringValueCStr (devicev);
4092 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
4093 "device", "resize2fs");
4097 r = guestfs_resize2fs (g, device);
4099 rb_raise (e_Error, "%s", guestfs_last_error (g));
4104 static VALUE ruby_guestfs_find (VALUE gv, VALUE directoryv)
4107 Data_Get_Struct (gv, guestfs_h, g);
4109 rb_raise (rb_eArgError, "%s: used handle after closing it", "find");
4111 Check_Type (directoryv, T_STRING);
4112 const char *directory = StringValueCStr (directoryv);
4114 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
4115 "directory", "find");
4119 r = guestfs_find (g, directory);
4121 rb_raise (e_Error, "%s", guestfs_last_error (g));
4124 for (i = 0; r[i] != NULL; ++i) len++;
4125 VALUE rv = rb_ary_new2 (len);
4126 for (i = 0; r[i] != NULL; ++i) {
4127 rb_ary_push (rv, rb_str_new2 (r[i]));
4134 static VALUE ruby_guestfs_e2fsck_f (VALUE gv, VALUE devicev)
4137 Data_Get_Struct (gv, guestfs_h, g);
4139 rb_raise (rb_eArgError, "%s: used handle after closing it", "e2fsck_f");
4141 Check_Type (devicev, T_STRING);
4142 const char *device = StringValueCStr (devicev);
4144 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
4145 "device", "e2fsck_f");
4149 r = guestfs_e2fsck_f (g, device);
4151 rb_raise (e_Error, "%s", guestfs_last_error (g));
4156 static VALUE ruby_guestfs_sleep (VALUE gv, VALUE secsv)
4159 Data_Get_Struct (gv, guestfs_h, g);
4161 rb_raise (rb_eArgError, "%s: used handle after closing it", "sleep");
4163 int secs = NUM2INT (secsv);
4167 r = guestfs_sleep (g, secs);
4169 rb_raise (e_Error, "%s", guestfs_last_error (g));
4174 static VALUE ruby_guestfs_ntfs_3g_probe (VALUE gv, VALUE rwv, VALUE devicev)
4177 Data_Get_Struct (gv, guestfs_h, g);
4179 rb_raise (rb_eArgError, "%s: used handle after closing it", "ntfs_3g_probe");
4181 int rw = RTEST (rwv);
4182 Check_Type (devicev, T_STRING);
4183 const char *device = StringValueCStr (devicev);
4185 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
4186 "device", "ntfs_3g_probe");
4190 r = guestfs_ntfs_3g_probe (g, rw, device);
4192 rb_raise (e_Error, "%s", guestfs_last_error (g));
4197 static VALUE ruby_guestfs_sh (VALUE gv, VALUE commandv)
4200 Data_Get_Struct (gv, guestfs_h, g);
4202 rb_raise (rb_eArgError, "%s: used handle after closing it", "sh");
4204 Check_Type (commandv, T_STRING);
4205 const char *command = StringValueCStr (commandv);
4207 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
4212 r = guestfs_sh (g, command);
4214 rb_raise (e_Error, "%s", guestfs_last_error (g));
4216 VALUE rv = rb_str_new2 (r);
4221 static VALUE ruby_guestfs_sh_lines (VALUE gv, VALUE commandv)
4224 Data_Get_Struct (gv, guestfs_h, g);
4226 rb_raise (rb_eArgError, "%s: used handle after closing it", "sh_lines");
4228 Check_Type (commandv, T_STRING);
4229 const char *command = StringValueCStr (commandv);
4231 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
4232 "command", "sh_lines");
4236 r = guestfs_sh_lines (g, command);
4238 rb_raise (e_Error, "%s", guestfs_last_error (g));
4241 for (i = 0; r[i] != NULL; ++i) len++;
4242 VALUE rv = rb_ary_new2 (len);
4243 for (i = 0; r[i] != NULL; ++i) {
4244 rb_ary_push (rv, rb_str_new2 (r[i]));
4251 static VALUE ruby_guestfs_glob_expand (VALUE gv, VALUE patternv)
4254 Data_Get_Struct (gv, guestfs_h, g);
4256 rb_raise (rb_eArgError, "%s: used handle after closing it", "glob_expand");
4258 Check_Type (patternv, T_STRING);
4259 const char *pattern = StringValueCStr (patternv);
4261 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
4262 "pattern", "glob_expand");
4266 r = guestfs_glob_expand (g, pattern);
4268 rb_raise (e_Error, "%s", guestfs_last_error (g));
4271 for (i = 0; r[i] != NULL; ++i) len++;
4272 VALUE rv = rb_ary_new2 (len);
4273 for (i = 0; r[i] != NULL; ++i) {
4274 rb_ary_push (rv, rb_str_new2 (r[i]));
4281 static VALUE ruby_guestfs_scrub_device (VALUE gv, VALUE devicev)
4284 Data_Get_Struct (gv, guestfs_h, g);
4286 rb_raise (rb_eArgError, "%s: used handle after closing it", "scrub_device");
4288 Check_Type (devicev, T_STRING);
4289 const char *device = StringValueCStr (devicev);
4291 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
4292 "device", "scrub_device");
4296 r = guestfs_scrub_device (g, device);
4298 rb_raise (e_Error, "%s", guestfs_last_error (g));
4303 static VALUE ruby_guestfs_scrub_file (VALUE gv, VALUE filev)
4306 Data_Get_Struct (gv, guestfs_h, g);
4308 rb_raise (rb_eArgError, "%s: used handle after closing it", "scrub_file");
4310 Check_Type (filev, T_STRING);
4311 const char *file = StringValueCStr (filev);
4313 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
4314 "file", "scrub_file");
4318 r = guestfs_scrub_file (g, file);
4320 rb_raise (e_Error, "%s", guestfs_last_error (g));
4325 static VALUE ruby_guestfs_scrub_freespace (VALUE gv, VALUE dirv)
4328 Data_Get_Struct (gv, guestfs_h, g);
4330 rb_raise (rb_eArgError, "%s: used handle after closing it", "scrub_freespace");
4332 Check_Type (dirv, T_STRING);
4333 const char *dir = StringValueCStr (dirv);
4335 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
4336 "dir", "scrub_freespace");
4340 r = guestfs_scrub_freespace (g, dir);
4342 rb_raise (e_Error, "%s", guestfs_last_error (g));
4347 static VALUE ruby_guestfs_mkdtemp (VALUE gv, VALUE templatev)
4350 Data_Get_Struct (gv, guestfs_h, g);
4352 rb_raise (rb_eArgError, "%s: used handle after closing it", "mkdtemp");
4354 Check_Type (templatev, T_STRING);
4355 const char *template = StringValueCStr (templatev);
4357 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
4358 "template", "mkdtemp");
4362 r = guestfs_mkdtemp (g, template);
4364 rb_raise (e_Error, "%s", guestfs_last_error (g));
4366 VALUE rv = rb_str_new2 (r);
4371 static VALUE ruby_guestfs_wc_l (VALUE gv, VALUE pathv)
4374 Data_Get_Struct (gv, guestfs_h, g);
4376 rb_raise (rb_eArgError, "%s: used handle after closing it", "wc_l");
4378 Check_Type (pathv, T_STRING);
4379 const char *path = StringValueCStr (pathv);
4381 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
4386 r = guestfs_wc_l (g, path);
4388 rb_raise (e_Error, "%s", guestfs_last_error (g));
4393 static VALUE ruby_guestfs_wc_w (VALUE gv, VALUE pathv)
4396 Data_Get_Struct (gv, guestfs_h, g);
4398 rb_raise (rb_eArgError, "%s: used handle after closing it", "wc_w");
4400 Check_Type (pathv, T_STRING);
4401 const char *path = StringValueCStr (pathv);
4403 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
4408 r = guestfs_wc_w (g, path);
4410 rb_raise (e_Error, "%s", guestfs_last_error (g));
4415 static VALUE ruby_guestfs_wc_c (VALUE gv, VALUE pathv)
4418 Data_Get_Struct (gv, guestfs_h, g);
4420 rb_raise (rb_eArgError, "%s: used handle after closing it", "wc_c");
4422 Check_Type (pathv, T_STRING);
4423 const char *path = StringValueCStr (pathv);
4425 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
4430 r = guestfs_wc_c (g, path);
4432 rb_raise (e_Error, "%s", guestfs_last_error (g));
4437 static VALUE ruby_guestfs_head (VALUE gv, VALUE pathv)
4440 Data_Get_Struct (gv, guestfs_h, g);
4442 rb_raise (rb_eArgError, "%s: used handle after closing it", "head");
4444 Check_Type (pathv, T_STRING);
4445 const char *path = StringValueCStr (pathv);
4447 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
4452 r = guestfs_head (g, path);
4454 rb_raise (e_Error, "%s", guestfs_last_error (g));
4457 for (i = 0; r[i] != NULL; ++i) len++;
4458 VALUE rv = rb_ary_new2 (len);
4459 for (i = 0; r[i] != NULL; ++i) {
4460 rb_ary_push (rv, rb_str_new2 (r[i]));
4467 static VALUE ruby_guestfs_head_n (VALUE gv, VALUE nrlinesv, VALUE pathv)
4470 Data_Get_Struct (gv, guestfs_h, g);
4472 rb_raise (rb_eArgError, "%s: used handle after closing it", "head_n");
4474 int nrlines = NUM2INT (nrlinesv);
4475 Check_Type (pathv, T_STRING);
4476 const char *path = StringValueCStr (pathv);
4478 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
4483 r = guestfs_head_n (g, nrlines, path);
4485 rb_raise (e_Error, "%s", guestfs_last_error (g));
4488 for (i = 0; r[i] != NULL; ++i) len++;
4489 VALUE rv = rb_ary_new2 (len);
4490 for (i = 0; r[i] != NULL; ++i) {
4491 rb_ary_push (rv, rb_str_new2 (r[i]));
4498 static VALUE ruby_guestfs_tail (VALUE gv, VALUE pathv)
4501 Data_Get_Struct (gv, guestfs_h, g);
4503 rb_raise (rb_eArgError, "%s: used handle after closing it", "tail");
4505 Check_Type (pathv, T_STRING);
4506 const char *path = StringValueCStr (pathv);
4508 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
4513 r = guestfs_tail (g, path);
4515 rb_raise (e_Error, "%s", guestfs_last_error (g));
4518 for (i = 0; r[i] != NULL; ++i) len++;
4519 VALUE rv = rb_ary_new2 (len);
4520 for (i = 0; r[i] != NULL; ++i) {
4521 rb_ary_push (rv, rb_str_new2 (r[i]));
4528 static VALUE ruby_guestfs_tail_n (VALUE gv, VALUE nrlinesv, VALUE pathv)
4531 Data_Get_Struct (gv, guestfs_h, g);
4533 rb_raise (rb_eArgError, "%s: used handle after closing it", "tail_n");
4535 int nrlines = NUM2INT (nrlinesv);
4536 Check_Type (pathv, T_STRING);
4537 const char *path = StringValueCStr (pathv);
4539 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
4544 r = guestfs_tail_n (g, nrlines, path);
4546 rb_raise (e_Error, "%s", guestfs_last_error (g));
4549 for (i = 0; r[i] != NULL; ++i) len++;
4550 VALUE rv = rb_ary_new2 (len);
4551 for (i = 0; r[i] != NULL; ++i) {
4552 rb_ary_push (rv, rb_str_new2 (r[i]));
4559 static VALUE ruby_guestfs_df (VALUE gv)
4562 Data_Get_Struct (gv, guestfs_h, g);
4564 rb_raise (rb_eArgError, "%s: used handle after closing it", "df");
4571 rb_raise (e_Error, "%s", guestfs_last_error (g));
4573 VALUE rv = rb_str_new2 (r);
4578 static VALUE ruby_guestfs_df_h (VALUE gv)
4581 Data_Get_Struct (gv, guestfs_h, g);
4583 rb_raise (rb_eArgError, "%s: used handle after closing it", "df_h");
4588 r = guestfs_df_h (g);
4590 rb_raise (e_Error, "%s", guestfs_last_error (g));
4592 VALUE rv = rb_str_new2 (r);
4597 static VALUE ruby_guestfs_du (VALUE gv, VALUE pathv)
4600 Data_Get_Struct (gv, guestfs_h, g);
4602 rb_raise (rb_eArgError, "%s: used handle after closing it", "du");
4604 Check_Type (pathv, T_STRING);
4605 const char *path = StringValueCStr (pathv);
4607 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
4612 r = guestfs_du (g, path);
4614 rb_raise (e_Error, "%s", guestfs_last_error (g));
4619 static VALUE ruby_guestfs_initrd_list (VALUE gv, VALUE pathv)
4622 Data_Get_Struct (gv, guestfs_h, g);
4624 rb_raise (rb_eArgError, "%s: used handle after closing it", "initrd_list");
4626 Check_Type (pathv, T_STRING);
4627 const char *path = StringValueCStr (pathv);
4629 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
4630 "path", "initrd_list");
4634 r = guestfs_initrd_list (g, path);
4636 rb_raise (e_Error, "%s", guestfs_last_error (g));
4639 for (i = 0; r[i] != NULL; ++i) len++;
4640 VALUE rv = rb_ary_new2 (len);
4641 for (i = 0; r[i] != NULL; ++i) {
4642 rb_ary_push (rv, rb_str_new2 (r[i]));
4649 static VALUE ruby_guestfs_mount_loop (VALUE gv, VALUE filev, VALUE mountpointv)
4652 Data_Get_Struct (gv, guestfs_h, g);
4654 rb_raise (rb_eArgError, "%s: used handle after closing it", "mount_loop");
4656 Check_Type (filev, T_STRING);
4657 const char *file = StringValueCStr (filev);
4659 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
4660 "file", "mount_loop");
4661 Check_Type (mountpointv, T_STRING);
4662 const char *mountpoint = StringValueCStr (mountpointv);
4664 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
4665 "mountpoint", "mount_loop");
4669 r = guestfs_mount_loop (g, file, mountpoint);
4671 rb_raise (e_Error, "%s", guestfs_last_error (g));
4676 static VALUE ruby_guestfs_mkswap (VALUE gv, VALUE devicev)
4679 Data_Get_Struct (gv, guestfs_h, g);
4681 rb_raise (rb_eArgError, "%s: used handle after closing it", "mkswap");
4683 Check_Type (devicev, T_STRING);
4684 const char *device = StringValueCStr (devicev);
4686 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
4687 "device", "mkswap");
4691 r = guestfs_mkswap (g, device);
4693 rb_raise (e_Error, "%s", guestfs_last_error (g));
4698 static VALUE ruby_guestfs_mkswap_L (VALUE gv, VALUE labelv, VALUE devicev)
4701 Data_Get_Struct (gv, guestfs_h, g);
4703 rb_raise (rb_eArgError, "%s: used handle after closing it", "mkswap_L");
4705 Check_Type (labelv, T_STRING);
4706 const char *label = StringValueCStr (labelv);
4708 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
4709 "label", "mkswap_L");
4710 Check_Type (devicev, T_STRING);
4711 const char *device = StringValueCStr (devicev);
4713 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
4714 "device", "mkswap_L");
4718 r = guestfs_mkswap_L (g, label, device);
4720 rb_raise (e_Error, "%s", guestfs_last_error (g));
4725 static VALUE ruby_guestfs_mkswap_U (VALUE gv, VALUE uuidv, VALUE devicev)
4728 Data_Get_Struct (gv, guestfs_h, g);
4730 rb_raise (rb_eArgError, "%s: used handle after closing it", "mkswap_U");
4732 Check_Type (uuidv, T_STRING);
4733 const char *uuid = StringValueCStr (uuidv);
4735 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
4736 "uuid", "mkswap_U");
4737 Check_Type (devicev, T_STRING);
4738 const char *device = StringValueCStr (devicev);
4740 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
4741 "device", "mkswap_U");
4745 r = guestfs_mkswap_U (g, uuid, device);
4747 rb_raise (e_Error, "%s", guestfs_last_error (g));
4752 /* Initialize the module. */
4753 void Init__guestfs ()
4755 m_guestfs = rb_define_module ("Guestfs");
4756 c_guestfs = rb_define_class_under (m_guestfs, "Guestfs", rb_cObject);
4757 e_Error = rb_define_class_under (m_guestfs, "Error", rb_eStandardError);
4759 rb_define_module_function (m_guestfs, "create", ruby_guestfs_create, 0);
4760 rb_define_method (c_guestfs, "close", ruby_guestfs_close, 0);
4762 rb_define_method (c_guestfs, "test0",
4763 ruby_guestfs_test0, 7);
4764 rb_define_method (c_guestfs, "test0rint",
4765 ruby_guestfs_test0rint, 1);
4766 rb_define_method (c_guestfs, "test0rinterr",
4767 ruby_guestfs_test0rinterr, 0);
4768 rb_define_method (c_guestfs, "test0rint64",
4769 ruby_guestfs_test0rint64, 1);
4770 rb_define_method (c_guestfs, "test0rint64err",
4771 ruby_guestfs_test0rint64err, 0);
4772 rb_define_method (c_guestfs, "test0rbool",
4773 ruby_guestfs_test0rbool, 1);
4774 rb_define_method (c_guestfs, "test0rboolerr",
4775 ruby_guestfs_test0rboolerr, 0);
4776 rb_define_method (c_guestfs, "test0rconststring",
4777 ruby_guestfs_test0rconststring, 1);
4778 rb_define_method (c_guestfs, "test0rconststringerr",
4779 ruby_guestfs_test0rconststringerr, 0);
4780 rb_define_method (c_guestfs, "test0rstring",
4781 ruby_guestfs_test0rstring, 1);
4782 rb_define_method (c_guestfs, "test0rstringerr",
4783 ruby_guestfs_test0rstringerr, 0);
4784 rb_define_method (c_guestfs, "test0rstringlist",
4785 ruby_guestfs_test0rstringlist, 1);
4786 rb_define_method (c_guestfs, "test0rstringlisterr",
4787 ruby_guestfs_test0rstringlisterr, 0);
4788 rb_define_method (c_guestfs, "test0rintbool",
4789 ruby_guestfs_test0rintbool, 1);
4790 rb_define_method (c_guestfs, "test0rintboolerr",
4791 ruby_guestfs_test0rintboolerr, 0);
4792 rb_define_method (c_guestfs, "test0rpvlist",
4793 ruby_guestfs_test0rpvlist, 1);
4794 rb_define_method (c_guestfs, "test0rpvlisterr",
4795 ruby_guestfs_test0rpvlisterr, 0);
4796 rb_define_method (c_guestfs, "test0rvglist",
4797 ruby_guestfs_test0rvglist, 1);
4798 rb_define_method (c_guestfs, "test0rvglisterr",
4799 ruby_guestfs_test0rvglisterr, 0);
4800 rb_define_method (c_guestfs, "test0rlvlist",
4801 ruby_guestfs_test0rlvlist, 1);
4802 rb_define_method (c_guestfs, "test0rlvlisterr",
4803 ruby_guestfs_test0rlvlisterr, 0);
4804 rb_define_method (c_guestfs, "test0rstat",
4805 ruby_guestfs_test0rstat, 1);
4806 rb_define_method (c_guestfs, "test0rstaterr",
4807 ruby_guestfs_test0rstaterr, 0);
4808 rb_define_method (c_guestfs, "test0rstatvfs",
4809 ruby_guestfs_test0rstatvfs, 1);
4810 rb_define_method (c_guestfs, "test0rstatvfserr",
4811 ruby_guestfs_test0rstatvfserr, 0);
4812 rb_define_method (c_guestfs, "test0rhashtable",
4813 ruby_guestfs_test0rhashtable, 1);
4814 rb_define_method (c_guestfs, "test0rhashtableerr",
4815 ruby_guestfs_test0rhashtableerr, 0);
4816 rb_define_method (c_guestfs, "launch",
4817 ruby_guestfs_launch, 0);
4818 rb_define_method (c_guestfs, "wait_ready",
4819 ruby_guestfs_wait_ready, 0);
4820 rb_define_method (c_guestfs, "kill_subprocess",
4821 ruby_guestfs_kill_subprocess, 0);
4822 rb_define_method (c_guestfs, "add_drive",
4823 ruby_guestfs_add_drive, 1);
4824 rb_define_method (c_guestfs, "add_cdrom",
4825 ruby_guestfs_add_cdrom, 1);
4826 rb_define_method (c_guestfs, "add_drive_ro",
4827 ruby_guestfs_add_drive_ro, 1);
4828 rb_define_method (c_guestfs, "config",
4829 ruby_guestfs_config, 2);
4830 rb_define_method (c_guestfs, "set_qemu",
4831 ruby_guestfs_set_qemu, 1);
4832 rb_define_method (c_guestfs, "get_qemu",
4833 ruby_guestfs_get_qemu, 0);
4834 rb_define_method (c_guestfs, "set_path",
4835 ruby_guestfs_set_path, 1);
4836 rb_define_method (c_guestfs, "get_path",
4837 ruby_guestfs_get_path, 0);
4838 rb_define_method (c_guestfs, "set_append",
4839 ruby_guestfs_set_append, 1);
4840 rb_define_method (c_guestfs, "get_append",
4841 ruby_guestfs_get_append, 0);
4842 rb_define_method (c_guestfs, "set_autosync",
4843 ruby_guestfs_set_autosync, 1);
4844 rb_define_method (c_guestfs, "get_autosync",
4845 ruby_guestfs_get_autosync, 0);
4846 rb_define_method (c_guestfs, "set_verbose",
4847 ruby_guestfs_set_verbose, 1);
4848 rb_define_method (c_guestfs, "get_verbose",
4849 ruby_guestfs_get_verbose, 0);
4850 rb_define_method (c_guestfs, "is_ready",
4851 ruby_guestfs_is_ready, 0);
4852 rb_define_method (c_guestfs, "is_config",
4853 ruby_guestfs_is_config, 0);
4854 rb_define_method (c_guestfs, "is_launching",
4855 ruby_guestfs_is_launching, 0);
4856 rb_define_method (c_guestfs, "is_busy",
4857 ruby_guestfs_is_busy, 0);
4858 rb_define_method (c_guestfs, "get_state",
4859 ruby_guestfs_get_state, 0);
4860 rb_define_method (c_guestfs, "set_busy",
4861 ruby_guestfs_set_busy, 0);
4862 rb_define_method (c_guestfs, "set_ready",
4863 ruby_guestfs_set_ready, 0);
4864 rb_define_method (c_guestfs, "end_busy",
4865 ruby_guestfs_end_busy, 0);
4866 rb_define_method (c_guestfs, "set_memsize",
4867 ruby_guestfs_set_memsize, 1);
4868 rb_define_method (c_guestfs, "get_memsize",
4869 ruby_guestfs_get_memsize, 0);
4870 rb_define_method (c_guestfs, "mount",
4871 ruby_guestfs_mount, 2);
4872 rb_define_method (c_guestfs, "sync",
4873 ruby_guestfs_sync, 0);
4874 rb_define_method (c_guestfs, "touch",
4875 ruby_guestfs_touch, 1);
4876 rb_define_method (c_guestfs, "cat",
4877 ruby_guestfs_cat, 1);
4878 rb_define_method (c_guestfs, "ll",
4879 ruby_guestfs_ll, 1);
4880 rb_define_method (c_guestfs, "ls",
4881 ruby_guestfs_ls, 1);
4882 rb_define_method (c_guestfs, "list_devices",
4883 ruby_guestfs_list_devices, 0);
4884 rb_define_method (c_guestfs, "list_partitions",
4885 ruby_guestfs_list_partitions, 0);
4886 rb_define_method (c_guestfs, "pvs",
4887 ruby_guestfs_pvs, 0);
4888 rb_define_method (c_guestfs, "vgs",
4889 ruby_guestfs_vgs, 0);
4890 rb_define_method (c_guestfs, "lvs",
4891 ruby_guestfs_lvs, 0);
4892 rb_define_method (c_guestfs, "pvs_full",
4893 ruby_guestfs_pvs_full, 0);
4894 rb_define_method (c_guestfs, "vgs_full",
4895 ruby_guestfs_vgs_full, 0);
4896 rb_define_method (c_guestfs, "lvs_full",
4897 ruby_guestfs_lvs_full, 0);
4898 rb_define_method (c_guestfs, "read_lines",
4899 ruby_guestfs_read_lines, 1);
4900 rb_define_method (c_guestfs, "aug_init",
4901 ruby_guestfs_aug_init, 2);
4902 rb_define_method (c_guestfs, "aug_close",
4903 ruby_guestfs_aug_close, 0);
4904 rb_define_method (c_guestfs, "aug_defvar",
4905 ruby_guestfs_aug_defvar, 2);
4906 rb_define_method (c_guestfs, "aug_defnode",
4907 ruby_guestfs_aug_defnode, 3);
4908 rb_define_method (c_guestfs, "aug_get",
4909 ruby_guestfs_aug_get, 1);
4910 rb_define_method (c_guestfs, "aug_set",
4911 ruby_guestfs_aug_set, 2);
4912 rb_define_method (c_guestfs, "aug_insert",
4913 ruby_guestfs_aug_insert, 3);
4914 rb_define_method (c_guestfs, "aug_rm",
4915 ruby_guestfs_aug_rm, 1);
4916 rb_define_method (c_guestfs, "aug_mv",
4917 ruby_guestfs_aug_mv, 2);
4918 rb_define_method (c_guestfs, "aug_match",
4919 ruby_guestfs_aug_match, 1);
4920 rb_define_method (c_guestfs, "aug_save",
4921 ruby_guestfs_aug_save, 0);
4922 rb_define_method (c_guestfs, "aug_load",
4923 ruby_guestfs_aug_load, 0);
4924 rb_define_method (c_guestfs, "aug_ls",
4925 ruby_guestfs_aug_ls, 1);
4926 rb_define_method (c_guestfs, "rm",
4927 ruby_guestfs_rm, 1);
4928 rb_define_method (c_guestfs, "rmdir",
4929 ruby_guestfs_rmdir, 1);
4930 rb_define_method (c_guestfs, "rm_rf",
4931 ruby_guestfs_rm_rf, 1);
4932 rb_define_method (c_guestfs, "mkdir",
4933 ruby_guestfs_mkdir, 1);
4934 rb_define_method (c_guestfs, "mkdir_p",
4935 ruby_guestfs_mkdir_p, 1);
4936 rb_define_method (c_guestfs, "chmod",
4937 ruby_guestfs_chmod, 2);
4938 rb_define_method (c_guestfs, "chown",
4939 ruby_guestfs_chown, 3);
4940 rb_define_method (c_guestfs, "exists",
4941 ruby_guestfs_exists, 1);
4942 rb_define_method (c_guestfs, "is_file",
4943 ruby_guestfs_is_file, 1);
4944 rb_define_method (c_guestfs, "is_dir",
4945 ruby_guestfs_is_dir, 1);
4946 rb_define_method (c_guestfs, "pvcreate",
4947 ruby_guestfs_pvcreate, 1);
4948 rb_define_method (c_guestfs, "vgcreate",
4949 ruby_guestfs_vgcreate, 2);
4950 rb_define_method (c_guestfs, "lvcreate",
4951 ruby_guestfs_lvcreate, 3);
4952 rb_define_method (c_guestfs, "mkfs",
4953 ruby_guestfs_mkfs, 2);
4954 rb_define_method (c_guestfs, "sfdisk",
4955 ruby_guestfs_sfdisk, 5);
4956 rb_define_method (c_guestfs, "write_file",
4957 ruby_guestfs_write_file, 3);
4958 rb_define_method (c_guestfs, "umount",
4959 ruby_guestfs_umount, 1);
4960 rb_define_method (c_guestfs, "mounts",
4961 ruby_guestfs_mounts, 0);
4962 rb_define_method (c_guestfs, "umount_all",
4963 ruby_guestfs_umount_all, 0);
4964 rb_define_method (c_guestfs, "lvm_remove_all",
4965 ruby_guestfs_lvm_remove_all, 0);
4966 rb_define_method (c_guestfs, "file",
4967 ruby_guestfs_file, 1);
4968 rb_define_method (c_guestfs, "command",
4969 ruby_guestfs_command, 1);
4970 rb_define_method (c_guestfs, "command_lines",
4971 ruby_guestfs_command_lines, 1);
4972 rb_define_method (c_guestfs, "stat",
4973 ruby_guestfs_stat, 1);
4974 rb_define_method (c_guestfs, "lstat",
4975 ruby_guestfs_lstat, 1);
4976 rb_define_method (c_guestfs, "statvfs",
4977 ruby_guestfs_statvfs, 1);
4978 rb_define_method (c_guestfs, "tune2fs_l",
4979 ruby_guestfs_tune2fs_l, 1);
4980 rb_define_method (c_guestfs, "blockdev_setro",
4981 ruby_guestfs_blockdev_setro, 1);
4982 rb_define_method (c_guestfs, "blockdev_setrw",
4983 ruby_guestfs_blockdev_setrw, 1);
4984 rb_define_method (c_guestfs, "blockdev_getro",
4985 ruby_guestfs_blockdev_getro, 1);
4986 rb_define_method (c_guestfs, "blockdev_getss",
4987 ruby_guestfs_blockdev_getss, 1);
4988 rb_define_method (c_guestfs, "blockdev_getbsz",
4989 ruby_guestfs_blockdev_getbsz, 1);
4990 rb_define_method (c_guestfs, "blockdev_setbsz",
4991 ruby_guestfs_blockdev_setbsz, 2);
4992 rb_define_method (c_guestfs, "blockdev_getsz",
4993 ruby_guestfs_blockdev_getsz, 1);
4994 rb_define_method (c_guestfs, "blockdev_getsize64",
4995 ruby_guestfs_blockdev_getsize64, 1);
4996 rb_define_method (c_guestfs, "blockdev_flushbufs",
4997 ruby_guestfs_blockdev_flushbufs, 1);
4998 rb_define_method (c_guestfs, "blockdev_rereadpt",
4999 ruby_guestfs_blockdev_rereadpt, 1);
5000 rb_define_method (c_guestfs, "upload",
5001 ruby_guestfs_upload, 2);
5002 rb_define_method (c_guestfs, "download",
5003 ruby_guestfs_download, 2);
5004 rb_define_method (c_guestfs, "checksum",
5005 ruby_guestfs_checksum, 2);
5006 rb_define_method (c_guestfs, "tar_in",
5007 ruby_guestfs_tar_in, 2);
5008 rb_define_method (c_guestfs, "tar_out",
5009 ruby_guestfs_tar_out, 2);
5010 rb_define_method (c_guestfs, "tgz_in",
5011 ruby_guestfs_tgz_in, 2);
5012 rb_define_method (c_guestfs, "tgz_out",
5013 ruby_guestfs_tgz_out, 2);
5014 rb_define_method (c_guestfs, "mount_ro",
5015 ruby_guestfs_mount_ro, 2);
5016 rb_define_method (c_guestfs, "mount_options",
5017 ruby_guestfs_mount_options, 3);
5018 rb_define_method (c_guestfs, "mount_vfs",
5019 ruby_guestfs_mount_vfs, 4);
5020 rb_define_method (c_guestfs, "debug",
5021 ruby_guestfs_debug, 2);
5022 rb_define_method (c_guestfs, "lvremove",
5023 ruby_guestfs_lvremove, 1);
5024 rb_define_method (c_guestfs, "vgremove",
5025 ruby_guestfs_vgremove, 1);
5026 rb_define_method (c_guestfs, "pvremove",
5027 ruby_guestfs_pvremove, 1);
5028 rb_define_method (c_guestfs, "set_e2label",
5029 ruby_guestfs_set_e2label, 2);
5030 rb_define_method (c_guestfs, "get_e2label",
5031 ruby_guestfs_get_e2label, 1);
5032 rb_define_method (c_guestfs, "set_e2uuid",
5033 ruby_guestfs_set_e2uuid, 2);
5034 rb_define_method (c_guestfs, "get_e2uuid",
5035 ruby_guestfs_get_e2uuid, 1);
5036 rb_define_method (c_guestfs, "fsck",
5037 ruby_guestfs_fsck, 2);
5038 rb_define_method (c_guestfs, "zero",
5039 ruby_guestfs_zero, 1);
5040 rb_define_method (c_guestfs, "grub_install",
5041 ruby_guestfs_grub_install, 2);
5042 rb_define_method (c_guestfs, "cp",
5043 ruby_guestfs_cp, 2);
5044 rb_define_method (c_guestfs, "cp_a",
5045 ruby_guestfs_cp_a, 2);
5046 rb_define_method (c_guestfs, "mv",
5047 ruby_guestfs_mv, 2);
5048 rb_define_method (c_guestfs, "drop_caches",
5049 ruby_guestfs_drop_caches, 1);
5050 rb_define_method (c_guestfs, "dmesg",
5051 ruby_guestfs_dmesg, 0);
5052 rb_define_method (c_guestfs, "ping_daemon",
5053 ruby_guestfs_ping_daemon, 0);
5054 rb_define_method (c_guestfs, "equal",
5055 ruby_guestfs_equal, 2);
5056 rb_define_method (c_guestfs, "strings",
5057 ruby_guestfs_strings, 1);
5058 rb_define_method (c_guestfs, "strings_e",
5059 ruby_guestfs_strings_e, 2);
5060 rb_define_method (c_guestfs, "hexdump",
5061 ruby_guestfs_hexdump, 1);
5062 rb_define_method (c_guestfs, "zerofree",
5063 ruby_guestfs_zerofree, 1);
5064 rb_define_method (c_guestfs, "pvresize",
5065 ruby_guestfs_pvresize, 1);
5066 rb_define_method (c_guestfs, "sfdisk_N",
5067 ruby_guestfs_sfdisk_N, 6);
5068 rb_define_method (c_guestfs, "sfdisk_l",
5069 ruby_guestfs_sfdisk_l, 1);
5070 rb_define_method (c_guestfs, "sfdisk_kernel_geometry",
5071 ruby_guestfs_sfdisk_kernel_geometry, 1);
5072 rb_define_method (c_guestfs, "sfdisk_disk_geometry",
5073 ruby_guestfs_sfdisk_disk_geometry, 1);
5074 rb_define_method (c_guestfs, "vg_activate_all",
5075 ruby_guestfs_vg_activate_all, 1);
5076 rb_define_method (c_guestfs, "vg_activate",
5077 ruby_guestfs_vg_activate, 2);
5078 rb_define_method (c_guestfs, "lvresize",
5079 ruby_guestfs_lvresize, 2);
5080 rb_define_method (c_guestfs, "resize2fs",
5081 ruby_guestfs_resize2fs, 1);
5082 rb_define_method (c_guestfs, "find",
5083 ruby_guestfs_find, 1);
5084 rb_define_method (c_guestfs, "e2fsck_f",
5085 ruby_guestfs_e2fsck_f, 1);
5086 rb_define_method (c_guestfs, "sleep",
5087 ruby_guestfs_sleep, 1);
5088 rb_define_method (c_guestfs, "ntfs_3g_probe",
5089 ruby_guestfs_ntfs_3g_probe, 2);
5090 rb_define_method (c_guestfs, "sh",
5091 ruby_guestfs_sh, 1);
5092 rb_define_method (c_guestfs, "sh_lines",
5093 ruby_guestfs_sh_lines, 1);
5094 rb_define_method (c_guestfs, "glob_expand",
5095 ruby_guestfs_glob_expand, 1);
5096 rb_define_method (c_guestfs, "scrub_device",
5097 ruby_guestfs_scrub_device, 1);
5098 rb_define_method (c_guestfs, "scrub_file",
5099 ruby_guestfs_scrub_file, 1);
5100 rb_define_method (c_guestfs, "scrub_freespace",
5101 ruby_guestfs_scrub_freespace, 1);
5102 rb_define_method (c_guestfs, "mkdtemp",
5103 ruby_guestfs_mkdtemp, 1);
5104 rb_define_method (c_guestfs, "wc_l",
5105 ruby_guestfs_wc_l, 1);
5106 rb_define_method (c_guestfs, "wc_w",
5107 ruby_guestfs_wc_w, 1);
5108 rb_define_method (c_guestfs, "wc_c",
5109 ruby_guestfs_wc_c, 1);
5110 rb_define_method (c_guestfs, "head",
5111 ruby_guestfs_head, 1);
5112 rb_define_method (c_guestfs, "head_n",
5113 ruby_guestfs_head_n, 2);
5114 rb_define_method (c_guestfs, "tail",
5115 ruby_guestfs_tail, 1);
5116 rb_define_method (c_guestfs, "tail_n",
5117 ruby_guestfs_tail_n, 2);
5118 rb_define_method (c_guestfs, "df",
5119 ruby_guestfs_df, 0);
5120 rb_define_method (c_guestfs, "df_h",
5121 ruby_guestfs_df_h, 0);
5122 rb_define_method (c_guestfs, "du",
5123 ruby_guestfs_du, 1);
5124 rb_define_method (c_guestfs, "initrd_list",
5125 ruby_guestfs_initrd_list, 1);
5126 rb_define_method (c_guestfs, "mount_loop",
5127 ruby_guestfs_mount_loop, 2);
5128 rb_define_method (c_guestfs, "mkswap",
5129 ruby_guestfs_mkswap, 1);
5130 rb_define_method (c_guestfs, "mkswap_L",
5131 ruby_guestfs_mkswap_L, 2);
5132 rb_define_method (c_guestfs, "mkswap_U",
5133 ruby_guestfs_mkswap_U, 2);