1 /* libguestfs generated file
2 * WARNING: THIS FILE IS GENERATED BY 'src/generator.ml'.
3 * ANY CHANGES YOU MAKE TO THIS FILE WILL BE LOST.
5 * Copyright (C) 2009 Red Hat Inc.
7 * This library is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2 of the License, or (at your option) any later version.
12 * This library is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with this library; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
33 #define RARRAY_LEN(r) (RARRAY((r))->len)
36 static VALUE m_guestfs; /* guestfs module */
37 static VALUE c_guestfs; /* guestfs_h handle */
38 static VALUE e_Error; /* used for all errors */
40 static void ruby_guestfs_free (void *p)
43 guestfs_close ((guestfs_h *) p);
46 static VALUE ruby_guestfs_create (VALUE m)
50 g = guestfs_create ();
52 rb_raise (e_Error, "failed to create guestfs handle");
54 /* Don't print error messages to stderr by default. */
55 guestfs_set_error_handler (g, NULL, NULL);
57 /* Wrap it, and make sure the close function is called when the
60 return Data_Wrap_Struct (c_guestfs, NULL, ruby_guestfs_free, g);
63 static VALUE ruby_guestfs_close (VALUE gv)
66 Data_Get_Struct (gv, guestfs_h, g);
68 ruby_guestfs_free (g);
74 static VALUE ruby_guestfs_test0 (VALUE gv, VALUE strv, VALUE optstrv, VALUE strlistv, VALUE bv, VALUE integerv, VALUE fileinv, VALUE fileoutv)
77 Data_Get_Struct (gv, guestfs_h, g);
79 rb_raise (rb_eArgError, "%s: used handle after closing it", "test0");
81 const char *str = StringValueCStr (strv);
83 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
85 const char *optstr = !NIL_P (optstrv) ? StringValueCStr (optstrv) : NULL;
89 len = RARRAY_LEN (strlistv);
90 strlist = guestfs_safe_malloc (g, sizeof (char *) * (len+1));
91 for (i = 0; i < len; ++i) {
92 VALUE v = rb_ary_entry (strlistv, i);
93 strlist[i] = StringValueCStr (v);
98 int integer = NUM2INT (integerv);
99 const char *filein = StringValueCStr (fileinv);
101 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
103 const char *fileout = StringValueCStr (fileoutv);
105 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
110 r = guestfs_test0 (g, str, optstr, strlist, b, integer, filein, fileout);
113 rb_raise (e_Error, "%s", guestfs_last_error (g));
118 static VALUE ruby_guestfs_test0rint (VALUE gv, VALUE valv)
121 Data_Get_Struct (gv, guestfs_h, g);
123 rb_raise (rb_eArgError, "%s: used handle after closing it", "test0rint");
125 const char *val = StringValueCStr (valv);
127 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
132 r = guestfs_test0rint (g, val);
134 rb_raise (e_Error, "%s", guestfs_last_error (g));
139 static VALUE ruby_guestfs_test0rinterr (VALUE gv)
142 Data_Get_Struct (gv, guestfs_h, g);
144 rb_raise (rb_eArgError, "%s: used handle after closing it", "test0rinterr");
149 r = guestfs_test0rinterr (g);
151 rb_raise (e_Error, "%s", guestfs_last_error (g));
156 static VALUE ruby_guestfs_test0rint64 (VALUE gv, VALUE valv)
159 Data_Get_Struct (gv, guestfs_h, g);
161 rb_raise (rb_eArgError, "%s: used handle after closing it", "test0rint64");
163 const char *val = StringValueCStr (valv);
165 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
166 "val", "test0rint64");
170 r = guestfs_test0rint64 (g, val);
172 rb_raise (e_Error, "%s", guestfs_last_error (g));
177 static VALUE ruby_guestfs_test0rint64err (VALUE gv)
180 Data_Get_Struct (gv, guestfs_h, g);
182 rb_raise (rb_eArgError, "%s: used handle after closing it", "test0rint64err");
187 r = guestfs_test0rint64err (g);
189 rb_raise (e_Error, "%s", guestfs_last_error (g));
194 static VALUE ruby_guestfs_test0rbool (VALUE gv, VALUE valv)
197 Data_Get_Struct (gv, guestfs_h, g);
199 rb_raise (rb_eArgError, "%s: used handle after closing it", "test0rbool");
201 const char *val = StringValueCStr (valv);
203 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
204 "val", "test0rbool");
208 r = guestfs_test0rbool (g, val);
210 rb_raise (e_Error, "%s", guestfs_last_error (g));
215 static VALUE ruby_guestfs_test0rboolerr (VALUE gv)
218 Data_Get_Struct (gv, guestfs_h, g);
220 rb_raise (rb_eArgError, "%s: used handle after closing it", "test0rboolerr");
225 r = guestfs_test0rboolerr (g);
227 rb_raise (e_Error, "%s", guestfs_last_error (g));
232 static VALUE ruby_guestfs_test0rconststring (VALUE gv, VALUE valv)
235 Data_Get_Struct (gv, guestfs_h, g);
237 rb_raise (rb_eArgError, "%s: used handle after closing it", "test0rconststring");
239 const char *val = StringValueCStr (valv);
241 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
242 "val", "test0rconststring");
246 r = guestfs_test0rconststring (g, val);
248 rb_raise (e_Error, "%s", guestfs_last_error (g));
250 return rb_str_new2 (r);
253 static VALUE ruby_guestfs_test0rconststringerr (VALUE gv)
256 Data_Get_Struct (gv, guestfs_h, g);
258 rb_raise (rb_eArgError, "%s: used handle after closing it", "test0rconststringerr");
263 r = guestfs_test0rconststringerr (g);
265 rb_raise (e_Error, "%s", guestfs_last_error (g));
267 return rb_str_new2 (r);
270 static VALUE ruby_guestfs_test0rstring (VALUE gv, VALUE valv)
273 Data_Get_Struct (gv, guestfs_h, g);
275 rb_raise (rb_eArgError, "%s: used handle after closing it", "test0rstring");
277 const char *val = StringValueCStr (valv);
279 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
280 "val", "test0rstring");
284 r = guestfs_test0rstring (g, val);
286 rb_raise (e_Error, "%s", guestfs_last_error (g));
288 VALUE rv = rb_str_new2 (r);
293 static VALUE ruby_guestfs_test0rstringerr (VALUE gv)
296 Data_Get_Struct (gv, guestfs_h, g);
298 rb_raise (rb_eArgError, "%s: used handle after closing it", "test0rstringerr");
303 r = guestfs_test0rstringerr (g);
305 rb_raise (e_Error, "%s", guestfs_last_error (g));
307 VALUE rv = rb_str_new2 (r);
312 static VALUE ruby_guestfs_test0rstringlist (VALUE gv, VALUE valv)
315 Data_Get_Struct (gv, guestfs_h, g);
317 rb_raise (rb_eArgError, "%s: used handle after closing it", "test0rstringlist");
319 const char *val = StringValueCStr (valv);
321 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
322 "val", "test0rstringlist");
326 r = guestfs_test0rstringlist (g, val);
328 rb_raise (e_Error, "%s", guestfs_last_error (g));
331 for (i = 0; r[i] != NULL; ++i) len++;
332 VALUE rv = rb_ary_new2 (len);
333 for (i = 0; r[i] != NULL; ++i) {
334 rb_ary_push (rv, rb_str_new2 (r[i]));
341 static VALUE ruby_guestfs_test0rstringlisterr (VALUE gv)
344 Data_Get_Struct (gv, guestfs_h, g);
346 rb_raise (rb_eArgError, "%s: used handle after closing it", "test0rstringlisterr");
351 r = guestfs_test0rstringlisterr (g);
353 rb_raise (e_Error, "%s", guestfs_last_error (g));
356 for (i = 0; r[i] != NULL; ++i) len++;
357 VALUE rv = rb_ary_new2 (len);
358 for (i = 0; r[i] != NULL; ++i) {
359 rb_ary_push (rv, rb_str_new2 (r[i]));
366 static VALUE ruby_guestfs_test0rintbool (VALUE gv, VALUE valv)
369 Data_Get_Struct (gv, guestfs_h, g);
371 rb_raise (rb_eArgError, "%s: used handle after closing it", "test0rintbool");
373 const char *val = StringValueCStr (valv);
375 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
376 "val", "test0rintbool");
378 struct guestfs_int_bool *r;
380 r = guestfs_test0rintbool (g, val);
382 rb_raise (e_Error, "%s", guestfs_last_error (g));
384 VALUE rv = rb_ary_new2 (2);
385 rb_ary_push (rv, INT2NUM (r->i));
386 rb_ary_push (rv, INT2NUM (r->b));
387 guestfs_free_int_bool (r);
391 static VALUE ruby_guestfs_test0rintboolerr (VALUE gv)
394 Data_Get_Struct (gv, guestfs_h, g);
396 rb_raise (rb_eArgError, "%s: used handle after closing it", "test0rintboolerr");
399 struct guestfs_int_bool *r;
401 r = guestfs_test0rintboolerr (g);
403 rb_raise (e_Error, "%s", guestfs_last_error (g));
405 VALUE rv = rb_ary_new2 (2);
406 rb_ary_push (rv, INT2NUM (r->i));
407 rb_ary_push (rv, INT2NUM (r->b));
408 guestfs_free_int_bool (r);
412 static VALUE ruby_guestfs_test0rpvlist (VALUE gv, VALUE valv)
415 Data_Get_Struct (gv, guestfs_h, g);
417 rb_raise (rb_eArgError, "%s: used handle after closing it", "test0rpvlist");
419 const char *val = StringValueCStr (valv);
421 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
422 "val", "test0rpvlist");
424 struct guestfs_lvm_pv_list *r;
426 r = guestfs_test0rpvlist (g, val);
428 rb_raise (e_Error, "%s", guestfs_last_error (g));
430 VALUE rv = rb_ary_new2 (r->len);
432 for (i = 0; i < r->len; ++i) {
433 VALUE hv = rb_hash_new ();
434 rb_hash_aset (rv, rb_str_new2 ("pv_name"), rb_str_new2 (r->val[i].pv_name));
435 rb_hash_aset (rv, rb_str_new2 ("pv_uuid"), rb_str_new (r->val[i].pv_uuid, 32));
436 rb_hash_aset (rv, rb_str_new2 ("pv_fmt"), rb_str_new2 (r->val[i].pv_fmt));
437 rb_hash_aset (rv, rb_str_new2 ("pv_size"), ULL2NUM (r->val[i].pv_size));
438 rb_hash_aset (rv, rb_str_new2 ("dev_size"), ULL2NUM (r->val[i].dev_size));
439 rb_hash_aset (rv, rb_str_new2 ("pv_free"), ULL2NUM (r->val[i].pv_free));
440 rb_hash_aset (rv, rb_str_new2 ("pv_used"), ULL2NUM (r->val[i].pv_used));
441 rb_hash_aset (rv, rb_str_new2 ("pv_attr"), rb_str_new2 (r->val[i].pv_attr));
442 rb_hash_aset (rv, rb_str_new2 ("pv_pe_count"), ULL2NUM (r->val[i].pv_pe_count));
443 rb_hash_aset (rv, rb_str_new2 ("pv_pe_alloc_count"), ULL2NUM (r->val[i].pv_pe_alloc_count));
444 rb_hash_aset (rv, rb_str_new2 ("pv_tags"), rb_str_new2 (r->val[i].pv_tags));
445 rb_hash_aset (rv, rb_str_new2 ("pe_start"), ULL2NUM (r->val[i].pe_start));
446 rb_hash_aset (rv, rb_str_new2 ("pv_mda_count"), ULL2NUM (r->val[i].pv_mda_count));
447 rb_hash_aset (rv, rb_str_new2 ("pv_mda_free"), ULL2NUM (r->val[i].pv_mda_free));
448 rb_ary_push (rv, hv);
450 guestfs_free_lvm_pv_list (r);
454 static VALUE ruby_guestfs_test0rpvlisterr (VALUE gv)
457 Data_Get_Struct (gv, guestfs_h, g);
459 rb_raise (rb_eArgError, "%s: used handle after closing it", "test0rpvlisterr");
462 struct guestfs_lvm_pv_list *r;
464 r = guestfs_test0rpvlisterr (g);
466 rb_raise (e_Error, "%s", guestfs_last_error (g));
468 VALUE rv = rb_ary_new2 (r->len);
470 for (i = 0; i < r->len; ++i) {
471 VALUE hv = rb_hash_new ();
472 rb_hash_aset (rv, rb_str_new2 ("pv_name"), rb_str_new2 (r->val[i].pv_name));
473 rb_hash_aset (rv, rb_str_new2 ("pv_uuid"), rb_str_new (r->val[i].pv_uuid, 32));
474 rb_hash_aset (rv, rb_str_new2 ("pv_fmt"), rb_str_new2 (r->val[i].pv_fmt));
475 rb_hash_aset (rv, rb_str_new2 ("pv_size"), ULL2NUM (r->val[i].pv_size));
476 rb_hash_aset (rv, rb_str_new2 ("dev_size"), ULL2NUM (r->val[i].dev_size));
477 rb_hash_aset (rv, rb_str_new2 ("pv_free"), ULL2NUM (r->val[i].pv_free));
478 rb_hash_aset (rv, rb_str_new2 ("pv_used"), ULL2NUM (r->val[i].pv_used));
479 rb_hash_aset (rv, rb_str_new2 ("pv_attr"), rb_str_new2 (r->val[i].pv_attr));
480 rb_hash_aset (rv, rb_str_new2 ("pv_pe_count"), ULL2NUM (r->val[i].pv_pe_count));
481 rb_hash_aset (rv, rb_str_new2 ("pv_pe_alloc_count"), ULL2NUM (r->val[i].pv_pe_alloc_count));
482 rb_hash_aset (rv, rb_str_new2 ("pv_tags"), rb_str_new2 (r->val[i].pv_tags));
483 rb_hash_aset (rv, rb_str_new2 ("pe_start"), ULL2NUM (r->val[i].pe_start));
484 rb_hash_aset (rv, rb_str_new2 ("pv_mda_count"), ULL2NUM (r->val[i].pv_mda_count));
485 rb_hash_aset (rv, rb_str_new2 ("pv_mda_free"), ULL2NUM (r->val[i].pv_mda_free));
486 rb_ary_push (rv, hv);
488 guestfs_free_lvm_pv_list (r);
492 static VALUE ruby_guestfs_test0rvglist (VALUE gv, VALUE valv)
495 Data_Get_Struct (gv, guestfs_h, g);
497 rb_raise (rb_eArgError, "%s: used handle after closing it", "test0rvglist");
499 const char *val = StringValueCStr (valv);
501 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
502 "val", "test0rvglist");
504 struct guestfs_lvm_vg_list *r;
506 r = guestfs_test0rvglist (g, val);
508 rb_raise (e_Error, "%s", guestfs_last_error (g));
510 VALUE rv = rb_ary_new2 (r->len);
512 for (i = 0; i < r->len; ++i) {
513 VALUE hv = rb_hash_new ();
514 rb_hash_aset (rv, rb_str_new2 ("vg_name"), rb_str_new2 (r->val[i].vg_name));
515 rb_hash_aset (rv, rb_str_new2 ("vg_uuid"), rb_str_new (r->val[i].vg_uuid, 32));
516 rb_hash_aset (rv, rb_str_new2 ("vg_fmt"), rb_str_new2 (r->val[i].vg_fmt));
517 rb_hash_aset (rv, rb_str_new2 ("vg_attr"), rb_str_new2 (r->val[i].vg_attr));
518 rb_hash_aset (rv, rb_str_new2 ("vg_size"), ULL2NUM (r->val[i].vg_size));
519 rb_hash_aset (rv, rb_str_new2 ("vg_free"), ULL2NUM (r->val[i].vg_free));
520 rb_hash_aset (rv, rb_str_new2 ("vg_sysid"), rb_str_new2 (r->val[i].vg_sysid));
521 rb_hash_aset (rv, rb_str_new2 ("vg_extent_size"), ULL2NUM (r->val[i].vg_extent_size));
522 rb_hash_aset (rv, rb_str_new2 ("vg_extent_count"), ULL2NUM (r->val[i].vg_extent_count));
523 rb_hash_aset (rv, rb_str_new2 ("vg_free_count"), ULL2NUM (r->val[i].vg_free_count));
524 rb_hash_aset (rv, rb_str_new2 ("max_lv"), ULL2NUM (r->val[i].max_lv));
525 rb_hash_aset (rv, rb_str_new2 ("max_pv"), ULL2NUM (r->val[i].max_pv));
526 rb_hash_aset (rv, rb_str_new2 ("pv_count"), ULL2NUM (r->val[i].pv_count));
527 rb_hash_aset (rv, rb_str_new2 ("lv_count"), ULL2NUM (r->val[i].lv_count));
528 rb_hash_aset (rv, rb_str_new2 ("snap_count"), ULL2NUM (r->val[i].snap_count));
529 rb_hash_aset (rv, rb_str_new2 ("vg_seqno"), ULL2NUM (r->val[i].vg_seqno));
530 rb_hash_aset (rv, rb_str_new2 ("vg_tags"), rb_str_new2 (r->val[i].vg_tags));
531 rb_hash_aset (rv, rb_str_new2 ("vg_mda_count"), ULL2NUM (r->val[i].vg_mda_count));
532 rb_hash_aset (rv, rb_str_new2 ("vg_mda_free"), ULL2NUM (r->val[i].vg_mda_free));
533 rb_ary_push (rv, hv);
535 guestfs_free_lvm_vg_list (r);
539 static VALUE ruby_guestfs_test0rvglisterr (VALUE gv)
542 Data_Get_Struct (gv, guestfs_h, g);
544 rb_raise (rb_eArgError, "%s: used handle after closing it", "test0rvglisterr");
547 struct guestfs_lvm_vg_list *r;
549 r = guestfs_test0rvglisterr (g);
551 rb_raise (e_Error, "%s", guestfs_last_error (g));
553 VALUE rv = rb_ary_new2 (r->len);
555 for (i = 0; i < r->len; ++i) {
556 VALUE hv = rb_hash_new ();
557 rb_hash_aset (rv, rb_str_new2 ("vg_name"), rb_str_new2 (r->val[i].vg_name));
558 rb_hash_aset (rv, rb_str_new2 ("vg_uuid"), rb_str_new (r->val[i].vg_uuid, 32));
559 rb_hash_aset (rv, rb_str_new2 ("vg_fmt"), rb_str_new2 (r->val[i].vg_fmt));
560 rb_hash_aset (rv, rb_str_new2 ("vg_attr"), rb_str_new2 (r->val[i].vg_attr));
561 rb_hash_aset (rv, rb_str_new2 ("vg_size"), ULL2NUM (r->val[i].vg_size));
562 rb_hash_aset (rv, rb_str_new2 ("vg_free"), ULL2NUM (r->val[i].vg_free));
563 rb_hash_aset (rv, rb_str_new2 ("vg_sysid"), rb_str_new2 (r->val[i].vg_sysid));
564 rb_hash_aset (rv, rb_str_new2 ("vg_extent_size"), ULL2NUM (r->val[i].vg_extent_size));
565 rb_hash_aset (rv, rb_str_new2 ("vg_extent_count"), ULL2NUM (r->val[i].vg_extent_count));
566 rb_hash_aset (rv, rb_str_new2 ("vg_free_count"), ULL2NUM (r->val[i].vg_free_count));
567 rb_hash_aset (rv, rb_str_new2 ("max_lv"), ULL2NUM (r->val[i].max_lv));
568 rb_hash_aset (rv, rb_str_new2 ("max_pv"), ULL2NUM (r->val[i].max_pv));
569 rb_hash_aset (rv, rb_str_new2 ("pv_count"), ULL2NUM (r->val[i].pv_count));
570 rb_hash_aset (rv, rb_str_new2 ("lv_count"), ULL2NUM (r->val[i].lv_count));
571 rb_hash_aset (rv, rb_str_new2 ("snap_count"), ULL2NUM (r->val[i].snap_count));
572 rb_hash_aset (rv, rb_str_new2 ("vg_seqno"), ULL2NUM (r->val[i].vg_seqno));
573 rb_hash_aset (rv, rb_str_new2 ("vg_tags"), rb_str_new2 (r->val[i].vg_tags));
574 rb_hash_aset (rv, rb_str_new2 ("vg_mda_count"), ULL2NUM (r->val[i].vg_mda_count));
575 rb_hash_aset (rv, rb_str_new2 ("vg_mda_free"), ULL2NUM (r->val[i].vg_mda_free));
576 rb_ary_push (rv, hv);
578 guestfs_free_lvm_vg_list (r);
582 static VALUE ruby_guestfs_test0rlvlist (VALUE gv, VALUE valv)
585 Data_Get_Struct (gv, guestfs_h, g);
587 rb_raise (rb_eArgError, "%s: used handle after closing it", "test0rlvlist");
589 const char *val = StringValueCStr (valv);
591 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
592 "val", "test0rlvlist");
594 struct guestfs_lvm_lv_list *r;
596 r = guestfs_test0rlvlist (g, val);
598 rb_raise (e_Error, "%s", guestfs_last_error (g));
600 VALUE rv = rb_ary_new2 (r->len);
602 for (i = 0; i < r->len; ++i) {
603 VALUE hv = rb_hash_new ();
604 rb_hash_aset (rv, rb_str_new2 ("lv_name"), rb_str_new2 (r->val[i].lv_name));
605 rb_hash_aset (rv, rb_str_new2 ("lv_uuid"), rb_str_new (r->val[i].lv_uuid, 32));
606 rb_hash_aset (rv, rb_str_new2 ("lv_attr"), rb_str_new2 (r->val[i].lv_attr));
607 rb_hash_aset (rv, rb_str_new2 ("lv_major"), ULL2NUM (r->val[i].lv_major));
608 rb_hash_aset (rv, rb_str_new2 ("lv_minor"), ULL2NUM (r->val[i].lv_minor));
609 rb_hash_aset (rv, rb_str_new2 ("lv_kernel_major"), ULL2NUM (r->val[i].lv_kernel_major));
610 rb_hash_aset (rv, rb_str_new2 ("lv_kernel_minor"), ULL2NUM (r->val[i].lv_kernel_minor));
611 rb_hash_aset (rv, rb_str_new2 ("lv_size"), ULL2NUM (r->val[i].lv_size));
612 rb_hash_aset (rv, rb_str_new2 ("seg_count"), ULL2NUM (r->val[i].seg_count));
613 rb_hash_aset (rv, rb_str_new2 ("origin"), rb_str_new2 (r->val[i].origin));
614 rb_hash_aset (rv, rb_str_new2 ("snap_percent"), rb_dbl2big (r->val[i].snap_percent));
615 rb_hash_aset (rv, rb_str_new2 ("copy_percent"), rb_dbl2big (r->val[i].copy_percent));
616 rb_hash_aset (rv, rb_str_new2 ("move_pv"), rb_str_new2 (r->val[i].move_pv));
617 rb_hash_aset (rv, rb_str_new2 ("lv_tags"), rb_str_new2 (r->val[i].lv_tags));
618 rb_hash_aset (rv, rb_str_new2 ("mirror_log"), rb_str_new2 (r->val[i].mirror_log));
619 rb_hash_aset (rv, rb_str_new2 ("modules"), rb_str_new2 (r->val[i].modules));
620 rb_ary_push (rv, hv);
622 guestfs_free_lvm_lv_list (r);
626 static VALUE ruby_guestfs_test0rlvlisterr (VALUE gv)
629 Data_Get_Struct (gv, guestfs_h, g);
631 rb_raise (rb_eArgError, "%s: used handle after closing it", "test0rlvlisterr");
634 struct guestfs_lvm_lv_list *r;
636 r = guestfs_test0rlvlisterr (g);
638 rb_raise (e_Error, "%s", guestfs_last_error (g));
640 VALUE rv = rb_ary_new2 (r->len);
642 for (i = 0; i < r->len; ++i) {
643 VALUE hv = rb_hash_new ();
644 rb_hash_aset (rv, rb_str_new2 ("lv_name"), rb_str_new2 (r->val[i].lv_name));
645 rb_hash_aset (rv, rb_str_new2 ("lv_uuid"), rb_str_new (r->val[i].lv_uuid, 32));
646 rb_hash_aset (rv, rb_str_new2 ("lv_attr"), rb_str_new2 (r->val[i].lv_attr));
647 rb_hash_aset (rv, rb_str_new2 ("lv_major"), ULL2NUM (r->val[i].lv_major));
648 rb_hash_aset (rv, rb_str_new2 ("lv_minor"), ULL2NUM (r->val[i].lv_minor));
649 rb_hash_aset (rv, rb_str_new2 ("lv_kernel_major"), ULL2NUM (r->val[i].lv_kernel_major));
650 rb_hash_aset (rv, rb_str_new2 ("lv_kernel_minor"), ULL2NUM (r->val[i].lv_kernel_minor));
651 rb_hash_aset (rv, rb_str_new2 ("lv_size"), ULL2NUM (r->val[i].lv_size));
652 rb_hash_aset (rv, rb_str_new2 ("seg_count"), ULL2NUM (r->val[i].seg_count));
653 rb_hash_aset (rv, rb_str_new2 ("origin"), rb_str_new2 (r->val[i].origin));
654 rb_hash_aset (rv, rb_str_new2 ("snap_percent"), rb_dbl2big (r->val[i].snap_percent));
655 rb_hash_aset (rv, rb_str_new2 ("copy_percent"), rb_dbl2big (r->val[i].copy_percent));
656 rb_hash_aset (rv, rb_str_new2 ("move_pv"), rb_str_new2 (r->val[i].move_pv));
657 rb_hash_aset (rv, rb_str_new2 ("lv_tags"), rb_str_new2 (r->val[i].lv_tags));
658 rb_hash_aset (rv, rb_str_new2 ("mirror_log"), rb_str_new2 (r->val[i].mirror_log));
659 rb_hash_aset (rv, rb_str_new2 ("modules"), rb_str_new2 (r->val[i].modules));
660 rb_ary_push (rv, hv);
662 guestfs_free_lvm_lv_list (r);
666 static VALUE ruby_guestfs_test0rstat (VALUE gv, VALUE valv)
669 Data_Get_Struct (gv, guestfs_h, g);
671 rb_raise (rb_eArgError, "%s: used handle after closing it", "test0rstat");
673 const char *val = StringValueCStr (valv);
675 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
676 "val", "test0rstat");
678 struct guestfs_stat *r;
680 r = guestfs_test0rstat (g, val);
682 rb_raise (e_Error, "%s", guestfs_last_error (g));
684 VALUE rv = rb_hash_new ();
685 rb_hash_aset (rv, rb_str_new2 ("dev"), ULL2NUM (r->dev));
686 rb_hash_aset (rv, rb_str_new2 ("ino"), ULL2NUM (r->ino));
687 rb_hash_aset (rv, rb_str_new2 ("mode"), ULL2NUM (r->mode));
688 rb_hash_aset (rv, rb_str_new2 ("nlink"), ULL2NUM (r->nlink));
689 rb_hash_aset (rv, rb_str_new2 ("uid"), ULL2NUM (r->uid));
690 rb_hash_aset (rv, rb_str_new2 ("gid"), ULL2NUM (r->gid));
691 rb_hash_aset (rv, rb_str_new2 ("rdev"), ULL2NUM (r->rdev));
692 rb_hash_aset (rv, rb_str_new2 ("size"), ULL2NUM (r->size));
693 rb_hash_aset (rv, rb_str_new2 ("blksize"), ULL2NUM (r->blksize));
694 rb_hash_aset (rv, rb_str_new2 ("blocks"), ULL2NUM (r->blocks));
695 rb_hash_aset (rv, rb_str_new2 ("atime"), ULL2NUM (r->atime));
696 rb_hash_aset (rv, rb_str_new2 ("mtime"), ULL2NUM (r->mtime));
697 rb_hash_aset (rv, rb_str_new2 ("ctime"), ULL2NUM (r->ctime));
702 static VALUE ruby_guestfs_test0rstaterr (VALUE gv)
705 Data_Get_Struct (gv, guestfs_h, g);
707 rb_raise (rb_eArgError, "%s: used handle after closing it", "test0rstaterr");
710 struct guestfs_stat *r;
712 r = guestfs_test0rstaterr (g);
714 rb_raise (e_Error, "%s", guestfs_last_error (g));
716 VALUE rv = rb_hash_new ();
717 rb_hash_aset (rv, rb_str_new2 ("dev"), ULL2NUM (r->dev));
718 rb_hash_aset (rv, rb_str_new2 ("ino"), ULL2NUM (r->ino));
719 rb_hash_aset (rv, rb_str_new2 ("mode"), ULL2NUM (r->mode));
720 rb_hash_aset (rv, rb_str_new2 ("nlink"), ULL2NUM (r->nlink));
721 rb_hash_aset (rv, rb_str_new2 ("uid"), ULL2NUM (r->uid));
722 rb_hash_aset (rv, rb_str_new2 ("gid"), ULL2NUM (r->gid));
723 rb_hash_aset (rv, rb_str_new2 ("rdev"), ULL2NUM (r->rdev));
724 rb_hash_aset (rv, rb_str_new2 ("size"), ULL2NUM (r->size));
725 rb_hash_aset (rv, rb_str_new2 ("blksize"), ULL2NUM (r->blksize));
726 rb_hash_aset (rv, rb_str_new2 ("blocks"), ULL2NUM (r->blocks));
727 rb_hash_aset (rv, rb_str_new2 ("atime"), ULL2NUM (r->atime));
728 rb_hash_aset (rv, rb_str_new2 ("mtime"), ULL2NUM (r->mtime));
729 rb_hash_aset (rv, rb_str_new2 ("ctime"), ULL2NUM (r->ctime));
734 static VALUE ruby_guestfs_test0rstatvfs (VALUE gv, VALUE valv)
737 Data_Get_Struct (gv, guestfs_h, g);
739 rb_raise (rb_eArgError, "%s: used handle after closing it", "test0rstatvfs");
741 const char *val = StringValueCStr (valv);
743 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
744 "val", "test0rstatvfs");
746 struct guestfs_statvfs *r;
748 r = guestfs_test0rstatvfs (g, val);
750 rb_raise (e_Error, "%s", guestfs_last_error (g));
752 VALUE rv = rb_hash_new ();
753 rb_hash_aset (rv, rb_str_new2 ("bsize"), ULL2NUM (r->bsize));
754 rb_hash_aset (rv, rb_str_new2 ("frsize"), ULL2NUM (r->frsize));
755 rb_hash_aset (rv, rb_str_new2 ("blocks"), ULL2NUM (r->blocks));
756 rb_hash_aset (rv, rb_str_new2 ("bfree"), ULL2NUM (r->bfree));
757 rb_hash_aset (rv, rb_str_new2 ("bavail"), ULL2NUM (r->bavail));
758 rb_hash_aset (rv, rb_str_new2 ("files"), ULL2NUM (r->files));
759 rb_hash_aset (rv, rb_str_new2 ("ffree"), ULL2NUM (r->ffree));
760 rb_hash_aset (rv, rb_str_new2 ("favail"), ULL2NUM (r->favail));
761 rb_hash_aset (rv, rb_str_new2 ("fsid"), ULL2NUM (r->fsid));
762 rb_hash_aset (rv, rb_str_new2 ("flag"), ULL2NUM (r->flag));
763 rb_hash_aset (rv, rb_str_new2 ("namemax"), ULL2NUM (r->namemax));
768 static VALUE ruby_guestfs_test0rstatvfserr (VALUE gv)
771 Data_Get_Struct (gv, guestfs_h, g);
773 rb_raise (rb_eArgError, "%s: used handle after closing it", "test0rstatvfserr");
776 struct guestfs_statvfs *r;
778 r = guestfs_test0rstatvfserr (g);
780 rb_raise (e_Error, "%s", guestfs_last_error (g));
782 VALUE rv = rb_hash_new ();
783 rb_hash_aset (rv, rb_str_new2 ("bsize"), ULL2NUM (r->bsize));
784 rb_hash_aset (rv, rb_str_new2 ("frsize"), ULL2NUM (r->frsize));
785 rb_hash_aset (rv, rb_str_new2 ("blocks"), ULL2NUM (r->blocks));
786 rb_hash_aset (rv, rb_str_new2 ("bfree"), ULL2NUM (r->bfree));
787 rb_hash_aset (rv, rb_str_new2 ("bavail"), ULL2NUM (r->bavail));
788 rb_hash_aset (rv, rb_str_new2 ("files"), ULL2NUM (r->files));
789 rb_hash_aset (rv, rb_str_new2 ("ffree"), ULL2NUM (r->ffree));
790 rb_hash_aset (rv, rb_str_new2 ("favail"), ULL2NUM (r->favail));
791 rb_hash_aset (rv, rb_str_new2 ("fsid"), ULL2NUM (r->fsid));
792 rb_hash_aset (rv, rb_str_new2 ("flag"), ULL2NUM (r->flag));
793 rb_hash_aset (rv, rb_str_new2 ("namemax"), ULL2NUM (r->namemax));
798 static VALUE ruby_guestfs_test0rhashtable (VALUE gv, VALUE valv)
801 Data_Get_Struct (gv, guestfs_h, g);
803 rb_raise (rb_eArgError, "%s: used handle after closing it", "test0rhashtable");
805 const char *val = StringValueCStr (valv);
807 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
808 "val", "test0rhashtable");
812 r = guestfs_test0rhashtable (g, val);
814 rb_raise (e_Error, "%s", guestfs_last_error (g));
816 VALUE rv = rb_hash_new ();
818 for (i = 0; r[i] != NULL; i+=2) {
819 rb_hash_aset (rv, rb_str_new2 (r[i]), rb_str_new2 (r[i+1]));
827 static VALUE ruby_guestfs_test0rhashtableerr (VALUE gv)
830 Data_Get_Struct (gv, guestfs_h, g);
832 rb_raise (rb_eArgError, "%s: used handle after closing it", "test0rhashtableerr");
837 r = guestfs_test0rhashtableerr (g);
839 rb_raise (e_Error, "%s", guestfs_last_error (g));
841 VALUE rv = rb_hash_new ();
843 for (i = 0; r[i] != NULL; i+=2) {
844 rb_hash_aset (rv, rb_str_new2 (r[i]), rb_str_new2 (r[i+1]));
852 static VALUE ruby_guestfs_launch (VALUE gv)
855 Data_Get_Struct (gv, guestfs_h, g);
857 rb_raise (rb_eArgError, "%s: used handle after closing it", "launch");
862 r = guestfs_launch (g);
864 rb_raise (e_Error, "%s", guestfs_last_error (g));
869 static VALUE ruby_guestfs_wait_ready (VALUE gv)
872 Data_Get_Struct (gv, guestfs_h, g);
874 rb_raise (rb_eArgError, "%s: used handle after closing it", "wait_ready");
879 r = guestfs_wait_ready (g);
881 rb_raise (e_Error, "%s", guestfs_last_error (g));
886 static VALUE ruby_guestfs_kill_subprocess (VALUE gv)
889 Data_Get_Struct (gv, guestfs_h, g);
891 rb_raise (rb_eArgError, "%s: used handle after closing it", "kill_subprocess");
896 r = guestfs_kill_subprocess (g);
898 rb_raise (e_Error, "%s", guestfs_last_error (g));
903 static VALUE ruby_guestfs_add_drive (VALUE gv, VALUE filenamev)
906 Data_Get_Struct (gv, guestfs_h, g);
908 rb_raise (rb_eArgError, "%s: used handle after closing it", "add_drive");
910 const char *filename = StringValueCStr (filenamev);
912 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
913 "filename", "add_drive");
917 r = guestfs_add_drive (g, filename);
919 rb_raise (e_Error, "%s", guestfs_last_error (g));
924 static VALUE ruby_guestfs_add_cdrom (VALUE gv, VALUE filenamev)
927 Data_Get_Struct (gv, guestfs_h, g);
929 rb_raise (rb_eArgError, "%s: used handle after closing it", "add_cdrom");
931 const char *filename = StringValueCStr (filenamev);
933 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
934 "filename", "add_cdrom");
938 r = guestfs_add_cdrom (g, filename);
940 rb_raise (e_Error, "%s", guestfs_last_error (g));
945 static VALUE ruby_guestfs_add_drive_ro (VALUE gv, VALUE filenamev)
948 Data_Get_Struct (gv, guestfs_h, g);
950 rb_raise (rb_eArgError, "%s: used handle after closing it", "add_drive_ro");
952 const char *filename = StringValueCStr (filenamev);
954 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
955 "filename", "add_drive_ro");
959 r = guestfs_add_drive_ro (g, filename);
961 rb_raise (e_Error, "%s", guestfs_last_error (g));
966 static VALUE ruby_guestfs_config (VALUE gv, VALUE qemuparamv, VALUE qemuvaluev)
969 Data_Get_Struct (gv, guestfs_h, g);
971 rb_raise (rb_eArgError, "%s: used handle after closing it", "config");
973 const char *qemuparam = StringValueCStr (qemuparamv);
975 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
976 "qemuparam", "config");
977 const char *qemuvalue = !NIL_P (qemuvaluev) ? StringValueCStr (qemuvaluev) : NULL;
981 r = guestfs_config (g, qemuparam, qemuvalue);
983 rb_raise (e_Error, "%s", guestfs_last_error (g));
988 static VALUE ruby_guestfs_set_qemu (VALUE gv, VALUE qemuv)
991 Data_Get_Struct (gv, guestfs_h, g);
993 rb_raise (rb_eArgError, "%s: used handle after closing it", "set_qemu");
995 const char *qemu = StringValueCStr (qemuv);
997 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1002 r = guestfs_set_qemu (g, qemu);
1004 rb_raise (e_Error, "%s", guestfs_last_error (g));
1009 static VALUE ruby_guestfs_get_qemu (VALUE gv)
1012 Data_Get_Struct (gv, guestfs_h, g);
1014 rb_raise (rb_eArgError, "%s: used handle after closing it", "get_qemu");
1019 r = guestfs_get_qemu (g);
1021 rb_raise (e_Error, "%s", guestfs_last_error (g));
1023 return rb_str_new2 (r);
1026 static VALUE ruby_guestfs_set_path (VALUE gv, VALUE pathv)
1029 Data_Get_Struct (gv, guestfs_h, g);
1031 rb_raise (rb_eArgError, "%s: used handle after closing it", "set_path");
1033 const char *path = StringValueCStr (pathv);
1035 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1036 "path", "set_path");
1040 r = guestfs_set_path (g, path);
1042 rb_raise (e_Error, "%s", guestfs_last_error (g));
1047 static VALUE ruby_guestfs_get_path (VALUE gv)
1050 Data_Get_Struct (gv, guestfs_h, g);
1052 rb_raise (rb_eArgError, "%s: used handle after closing it", "get_path");
1057 r = guestfs_get_path (g);
1059 rb_raise (e_Error, "%s", guestfs_last_error (g));
1061 return rb_str_new2 (r);
1064 static VALUE ruby_guestfs_set_append (VALUE gv, VALUE appendv)
1067 Data_Get_Struct (gv, guestfs_h, g);
1069 rb_raise (rb_eArgError, "%s: used handle after closing it", "set_append");
1071 const char *append = StringValueCStr (appendv);
1073 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1074 "append", "set_append");
1078 r = guestfs_set_append (g, append);
1080 rb_raise (e_Error, "%s", guestfs_last_error (g));
1085 static VALUE ruby_guestfs_get_append (VALUE gv)
1088 Data_Get_Struct (gv, guestfs_h, g);
1090 rb_raise (rb_eArgError, "%s: used handle after closing it", "get_append");
1095 r = guestfs_get_append (g);
1097 rb_raise (e_Error, "%s", guestfs_last_error (g));
1099 return rb_str_new2 (r);
1102 static VALUE ruby_guestfs_set_autosync (VALUE gv, VALUE autosyncv)
1105 Data_Get_Struct (gv, guestfs_h, g);
1107 rb_raise (rb_eArgError, "%s: used handle after closing it", "set_autosync");
1109 int autosync = RTEST (autosyncv);
1113 r = guestfs_set_autosync (g, autosync);
1115 rb_raise (e_Error, "%s", guestfs_last_error (g));
1120 static VALUE ruby_guestfs_get_autosync (VALUE gv)
1123 Data_Get_Struct (gv, guestfs_h, g);
1125 rb_raise (rb_eArgError, "%s: used handle after closing it", "get_autosync");
1130 r = guestfs_get_autosync (g);
1132 rb_raise (e_Error, "%s", guestfs_last_error (g));
1137 static VALUE ruby_guestfs_set_verbose (VALUE gv, VALUE verbosev)
1140 Data_Get_Struct (gv, guestfs_h, g);
1142 rb_raise (rb_eArgError, "%s: used handle after closing it", "set_verbose");
1144 int verbose = RTEST (verbosev);
1148 r = guestfs_set_verbose (g, verbose);
1150 rb_raise (e_Error, "%s", guestfs_last_error (g));
1155 static VALUE ruby_guestfs_get_verbose (VALUE gv)
1158 Data_Get_Struct (gv, guestfs_h, g);
1160 rb_raise (rb_eArgError, "%s: used handle after closing it", "get_verbose");
1165 r = guestfs_get_verbose (g);
1167 rb_raise (e_Error, "%s", guestfs_last_error (g));
1172 static VALUE ruby_guestfs_is_ready (VALUE gv)
1175 Data_Get_Struct (gv, guestfs_h, g);
1177 rb_raise (rb_eArgError, "%s: used handle after closing it", "is_ready");
1182 r = guestfs_is_ready (g);
1184 rb_raise (e_Error, "%s", guestfs_last_error (g));
1189 static VALUE ruby_guestfs_is_config (VALUE gv)
1192 Data_Get_Struct (gv, guestfs_h, g);
1194 rb_raise (rb_eArgError, "%s: used handle after closing it", "is_config");
1199 r = guestfs_is_config (g);
1201 rb_raise (e_Error, "%s", guestfs_last_error (g));
1206 static VALUE ruby_guestfs_is_launching (VALUE gv)
1209 Data_Get_Struct (gv, guestfs_h, g);
1211 rb_raise (rb_eArgError, "%s: used handle after closing it", "is_launching");
1216 r = guestfs_is_launching (g);
1218 rb_raise (e_Error, "%s", guestfs_last_error (g));
1223 static VALUE ruby_guestfs_is_busy (VALUE gv)
1226 Data_Get_Struct (gv, guestfs_h, g);
1228 rb_raise (rb_eArgError, "%s: used handle after closing it", "is_busy");
1233 r = guestfs_is_busy (g);
1235 rb_raise (e_Error, "%s", guestfs_last_error (g));
1240 static VALUE ruby_guestfs_get_state (VALUE gv)
1243 Data_Get_Struct (gv, guestfs_h, g);
1245 rb_raise (rb_eArgError, "%s: used handle after closing it", "get_state");
1250 r = guestfs_get_state (g);
1252 rb_raise (e_Error, "%s", guestfs_last_error (g));
1257 static VALUE ruby_guestfs_set_busy (VALUE gv)
1260 Data_Get_Struct (gv, guestfs_h, g);
1262 rb_raise (rb_eArgError, "%s: used handle after closing it", "set_busy");
1267 r = guestfs_set_busy (g);
1269 rb_raise (e_Error, "%s", guestfs_last_error (g));
1274 static VALUE ruby_guestfs_set_ready (VALUE gv)
1277 Data_Get_Struct (gv, guestfs_h, g);
1279 rb_raise (rb_eArgError, "%s: used handle after closing it", "set_ready");
1284 r = guestfs_set_ready (g);
1286 rb_raise (e_Error, "%s", guestfs_last_error (g));
1291 static VALUE ruby_guestfs_end_busy (VALUE gv)
1294 Data_Get_Struct (gv, guestfs_h, g);
1296 rb_raise (rb_eArgError, "%s: used handle after closing it", "end_busy");
1301 r = guestfs_end_busy (g);
1303 rb_raise (e_Error, "%s", guestfs_last_error (g));
1308 static VALUE ruby_guestfs_mount (VALUE gv, VALUE devicev, VALUE mountpointv)
1311 Data_Get_Struct (gv, guestfs_h, g);
1313 rb_raise (rb_eArgError, "%s: used handle after closing it", "mount");
1315 const char *device = StringValueCStr (devicev);
1317 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1319 const char *mountpoint = StringValueCStr (mountpointv);
1321 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1322 "mountpoint", "mount");
1326 r = guestfs_mount (g, device, mountpoint);
1328 rb_raise (e_Error, "%s", guestfs_last_error (g));
1333 static VALUE ruby_guestfs_sync (VALUE gv)
1336 Data_Get_Struct (gv, guestfs_h, g);
1338 rb_raise (rb_eArgError, "%s: used handle after closing it", "sync");
1343 r = guestfs_sync (g);
1345 rb_raise (e_Error, "%s", guestfs_last_error (g));
1350 static VALUE ruby_guestfs_touch (VALUE gv, VALUE pathv)
1353 Data_Get_Struct (gv, guestfs_h, g);
1355 rb_raise (rb_eArgError, "%s: used handle after closing it", "touch");
1357 const char *path = StringValueCStr (pathv);
1359 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1364 r = guestfs_touch (g, path);
1366 rb_raise (e_Error, "%s", guestfs_last_error (g));
1371 static VALUE ruby_guestfs_cat (VALUE gv, VALUE pathv)
1374 Data_Get_Struct (gv, guestfs_h, g);
1376 rb_raise (rb_eArgError, "%s: used handle after closing it", "cat");
1378 const char *path = StringValueCStr (pathv);
1380 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1385 r = guestfs_cat (g, path);
1387 rb_raise (e_Error, "%s", guestfs_last_error (g));
1389 VALUE rv = rb_str_new2 (r);
1394 static VALUE ruby_guestfs_ll (VALUE gv, VALUE directoryv)
1397 Data_Get_Struct (gv, guestfs_h, g);
1399 rb_raise (rb_eArgError, "%s: used handle after closing it", "ll");
1401 const char *directory = StringValueCStr (directoryv);
1403 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1408 r = guestfs_ll (g, directory);
1410 rb_raise (e_Error, "%s", guestfs_last_error (g));
1412 VALUE rv = rb_str_new2 (r);
1417 static VALUE ruby_guestfs_ls (VALUE gv, VALUE directoryv)
1420 Data_Get_Struct (gv, guestfs_h, g);
1422 rb_raise (rb_eArgError, "%s: used handle after closing it", "ls");
1424 const char *directory = StringValueCStr (directoryv);
1426 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1431 r = guestfs_ls (g, directory);
1433 rb_raise (e_Error, "%s", guestfs_last_error (g));
1436 for (i = 0; r[i] != NULL; ++i) len++;
1437 VALUE rv = rb_ary_new2 (len);
1438 for (i = 0; r[i] != NULL; ++i) {
1439 rb_ary_push (rv, rb_str_new2 (r[i]));
1446 static VALUE ruby_guestfs_list_devices (VALUE gv)
1449 Data_Get_Struct (gv, guestfs_h, g);
1451 rb_raise (rb_eArgError, "%s: used handle after closing it", "list_devices");
1456 r = guestfs_list_devices (g);
1458 rb_raise (e_Error, "%s", guestfs_last_error (g));
1461 for (i = 0; r[i] != NULL; ++i) len++;
1462 VALUE rv = rb_ary_new2 (len);
1463 for (i = 0; r[i] != NULL; ++i) {
1464 rb_ary_push (rv, rb_str_new2 (r[i]));
1471 static VALUE ruby_guestfs_list_partitions (VALUE gv)
1474 Data_Get_Struct (gv, guestfs_h, g);
1476 rb_raise (rb_eArgError, "%s: used handle after closing it", "list_partitions");
1481 r = guestfs_list_partitions (g);
1483 rb_raise (e_Error, "%s", guestfs_last_error (g));
1486 for (i = 0; r[i] != NULL; ++i) len++;
1487 VALUE rv = rb_ary_new2 (len);
1488 for (i = 0; r[i] != NULL; ++i) {
1489 rb_ary_push (rv, rb_str_new2 (r[i]));
1496 static VALUE ruby_guestfs_pvs (VALUE gv)
1499 Data_Get_Struct (gv, guestfs_h, g);
1501 rb_raise (rb_eArgError, "%s: used handle after closing it", "pvs");
1506 r = guestfs_pvs (g);
1508 rb_raise (e_Error, "%s", guestfs_last_error (g));
1511 for (i = 0; r[i] != NULL; ++i) len++;
1512 VALUE rv = rb_ary_new2 (len);
1513 for (i = 0; r[i] != NULL; ++i) {
1514 rb_ary_push (rv, rb_str_new2 (r[i]));
1521 static VALUE ruby_guestfs_vgs (VALUE gv)
1524 Data_Get_Struct (gv, guestfs_h, g);
1526 rb_raise (rb_eArgError, "%s: used handle after closing it", "vgs");
1531 r = guestfs_vgs (g);
1533 rb_raise (e_Error, "%s", guestfs_last_error (g));
1536 for (i = 0; r[i] != NULL; ++i) len++;
1537 VALUE rv = rb_ary_new2 (len);
1538 for (i = 0; r[i] != NULL; ++i) {
1539 rb_ary_push (rv, rb_str_new2 (r[i]));
1546 static VALUE ruby_guestfs_lvs (VALUE gv)
1549 Data_Get_Struct (gv, guestfs_h, g);
1551 rb_raise (rb_eArgError, "%s: used handle after closing it", "lvs");
1556 r = guestfs_lvs (g);
1558 rb_raise (e_Error, "%s", guestfs_last_error (g));
1561 for (i = 0; r[i] != NULL; ++i) len++;
1562 VALUE rv = rb_ary_new2 (len);
1563 for (i = 0; r[i] != NULL; ++i) {
1564 rb_ary_push (rv, rb_str_new2 (r[i]));
1571 static VALUE ruby_guestfs_pvs_full (VALUE gv)
1574 Data_Get_Struct (gv, guestfs_h, g);
1576 rb_raise (rb_eArgError, "%s: used handle after closing it", "pvs_full");
1579 struct guestfs_lvm_pv_list *r;
1581 r = guestfs_pvs_full (g);
1583 rb_raise (e_Error, "%s", guestfs_last_error (g));
1585 VALUE rv = rb_ary_new2 (r->len);
1587 for (i = 0; i < r->len; ++i) {
1588 VALUE hv = rb_hash_new ();
1589 rb_hash_aset (rv, rb_str_new2 ("pv_name"), rb_str_new2 (r->val[i].pv_name));
1590 rb_hash_aset (rv, rb_str_new2 ("pv_uuid"), rb_str_new (r->val[i].pv_uuid, 32));
1591 rb_hash_aset (rv, rb_str_new2 ("pv_fmt"), rb_str_new2 (r->val[i].pv_fmt));
1592 rb_hash_aset (rv, rb_str_new2 ("pv_size"), ULL2NUM (r->val[i].pv_size));
1593 rb_hash_aset (rv, rb_str_new2 ("dev_size"), ULL2NUM (r->val[i].dev_size));
1594 rb_hash_aset (rv, rb_str_new2 ("pv_free"), ULL2NUM (r->val[i].pv_free));
1595 rb_hash_aset (rv, rb_str_new2 ("pv_used"), ULL2NUM (r->val[i].pv_used));
1596 rb_hash_aset (rv, rb_str_new2 ("pv_attr"), rb_str_new2 (r->val[i].pv_attr));
1597 rb_hash_aset (rv, rb_str_new2 ("pv_pe_count"), ULL2NUM (r->val[i].pv_pe_count));
1598 rb_hash_aset (rv, rb_str_new2 ("pv_pe_alloc_count"), ULL2NUM (r->val[i].pv_pe_alloc_count));
1599 rb_hash_aset (rv, rb_str_new2 ("pv_tags"), rb_str_new2 (r->val[i].pv_tags));
1600 rb_hash_aset (rv, rb_str_new2 ("pe_start"), ULL2NUM (r->val[i].pe_start));
1601 rb_hash_aset (rv, rb_str_new2 ("pv_mda_count"), ULL2NUM (r->val[i].pv_mda_count));
1602 rb_hash_aset (rv, rb_str_new2 ("pv_mda_free"), ULL2NUM (r->val[i].pv_mda_free));
1603 rb_ary_push (rv, hv);
1605 guestfs_free_lvm_pv_list (r);
1609 static VALUE ruby_guestfs_vgs_full (VALUE gv)
1612 Data_Get_Struct (gv, guestfs_h, g);
1614 rb_raise (rb_eArgError, "%s: used handle after closing it", "vgs_full");
1617 struct guestfs_lvm_vg_list *r;
1619 r = guestfs_vgs_full (g);
1621 rb_raise (e_Error, "%s", guestfs_last_error (g));
1623 VALUE rv = rb_ary_new2 (r->len);
1625 for (i = 0; i < r->len; ++i) {
1626 VALUE hv = rb_hash_new ();
1627 rb_hash_aset (rv, rb_str_new2 ("vg_name"), rb_str_new2 (r->val[i].vg_name));
1628 rb_hash_aset (rv, rb_str_new2 ("vg_uuid"), rb_str_new (r->val[i].vg_uuid, 32));
1629 rb_hash_aset (rv, rb_str_new2 ("vg_fmt"), rb_str_new2 (r->val[i].vg_fmt));
1630 rb_hash_aset (rv, rb_str_new2 ("vg_attr"), rb_str_new2 (r->val[i].vg_attr));
1631 rb_hash_aset (rv, rb_str_new2 ("vg_size"), ULL2NUM (r->val[i].vg_size));
1632 rb_hash_aset (rv, rb_str_new2 ("vg_free"), ULL2NUM (r->val[i].vg_free));
1633 rb_hash_aset (rv, rb_str_new2 ("vg_sysid"), rb_str_new2 (r->val[i].vg_sysid));
1634 rb_hash_aset (rv, rb_str_new2 ("vg_extent_size"), ULL2NUM (r->val[i].vg_extent_size));
1635 rb_hash_aset (rv, rb_str_new2 ("vg_extent_count"), ULL2NUM (r->val[i].vg_extent_count));
1636 rb_hash_aset (rv, rb_str_new2 ("vg_free_count"), ULL2NUM (r->val[i].vg_free_count));
1637 rb_hash_aset (rv, rb_str_new2 ("max_lv"), ULL2NUM (r->val[i].max_lv));
1638 rb_hash_aset (rv, rb_str_new2 ("max_pv"), ULL2NUM (r->val[i].max_pv));
1639 rb_hash_aset (rv, rb_str_new2 ("pv_count"), ULL2NUM (r->val[i].pv_count));
1640 rb_hash_aset (rv, rb_str_new2 ("lv_count"), ULL2NUM (r->val[i].lv_count));
1641 rb_hash_aset (rv, rb_str_new2 ("snap_count"), ULL2NUM (r->val[i].snap_count));
1642 rb_hash_aset (rv, rb_str_new2 ("vg_seqno"), ULL2NUM (r->val[i].vg_seqno));
1643 rb_hash_aset (rv, rb_str_new2 ("vg_tags"), rb_str_new2 (r->val[i].vg_tags));
1644 rb_hash_aset (rv, rb_str_new2 ("vg_mda_count"), ULL2NUM (r->val[i].vg_mda_count));
1645 rb_hash_aset (rv, rb_str_new2 ("vg_mda_free"), ULL2NUM (r->val[i].vg_mda_free));
1646 rb_ary_push (rv, hv);
1648 guestfs_free_lvm_vg_list (r);
1652 static VALUE ruby_guestfs_lvs_full (VALUE gv)
1655 Data_Get_Struct (gv, guestfs_h, g);
1657 rb_raise (rb_eArgError, "%s: used handle after closing it", "lvs_full");
1660 struct guestfs_lvm_lv_list *r;
1662 r = guestfs_lvs_full (g);
1664 rb_raise (e_Error, "%s", guestfs_last_error (g));
1666 VALUE rv = rb_ary_new2 (r->len);
1668 for (i = 0; i < r->len; ++i) {
1669 VALUE hv = rb_hash_new ();
1670 rb_hash_aset (rv, rb_str_new2 ("lv_name"), rb_str_new2 (r->val[i].lv_name));
1671 rb_hash_aset (rv, rb_str_new2 ("lv_uuid"), rb_str_new (r->val[i].lv_uuid, 32));
1672 rb_hash_aset (rv, rb_str_new2 ("lv_attr"), rb_str_new2 (r->val[i].lv_attr));
1673 rb_hash_aset (rv, rb_str_new2 ("lv_major"), ULL2NUM (r->val[i].lv_major));
1674 rb_hash_aset (rv, rb_str_new2 ("lv_minor"), ULL2NUM (r->val[i].lv_minor));
1675 rb_hash_aset (rv, rb_str_new2 ("lv_kernel_major"), ULL2NUM (r->val[i].lv_kernel_major));
1676 rb_hash_aset (rv, rb_str_new2 ("lv_kernel_minor"), ULL2NUM (r->val[i].lv_kernel_minor));
1677 rb_hash_aset (rv, rb_str_new2 ("lv_size"), ULL2NUM (r->val[i].lv_size));
1678 rb_hash_aset (rv, rb_str_new2 ("seg_count"), ULL2NUM (r->val[i].seg_count));
1679 rb_hash_aset (rv, rb_str_new2 ("origin"), rb_str_new2 (r->val[i].origin));
1680 rb_hash_aset (rv, rb_str_new2 ("snap_percent"), rb_dbl2big (r->val[i].snap_percent));
1681 rb_hash_aset (rv, rb_str_new2 ("copy_percent"), rb_dbl2big (r->val[i].copy_percent));
1682 rb_hash_aset (rv, rb_str_new2 ("move_pv"), rb_str_new2 (r->val[i].move_pv));
1683 rb_hash_aset (rv, rb_str_new2 ("lv_tags"), rb_str_new2 (r->val[i].lv_tags));
1684 rb_hash_aset (rv, rb_str_new2 ("mirror_log"), rb_str_new2 (r->val[i].mirror_log));
1685 rb_hash_aset (rv, rb_str_new2 ("modules"), rb_str_new2 (r->val[i].modules));
1686 rb_ary_push (rv, hv);
1688 guestfs_free_lvm_lv_list (r);
1692 static VALUE ruby_guestfs_read_lines (VALUE gv, VALUE pathv)
1695 Data_Get_Struct (gv, guestfs_h, g);
1697 rb_raise (rb_eArgError, "%s: used handle after closing it", "read_lines");
1699 const char *path = StringValueCStr (pathv);
1701 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1702 "path", "read_lines");
1706 r = guestfs_read_lines (g, path);
1708 rb_raise (e_Error, "%s", guestfs_last_error (g));
1711 for (i = 0; r[i] != NULL; ++i) len++;
1712 VALUE rv = rb_ary_new2 (len);
1713 for (i = 0; r[i] != NULL; ++i) {
1714 rb_ary_push (rv, rb_str_new2 (r[i]));
1721 static VALUE ruby_guestfs_aug_init (VALUE gv, VALUE rootv, VALUE flagsv)
1724 Data_Get_Struct (gv, guestfs_h, g);
1726 rb_raise (rb_eArgError, "%s: used handle after closing it", "aug_init");
1728 const char *root = StringValueCStr (rootv);
1730 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1731 "root", "aug_init");
1732 int flags = NUM2INT (flagsv);
1736 r = guestfs_aug_init (g, root, flags);
1738 rb_raise (e_Error, "%s", guestfs_last_error (g));
1743 static VALUE ruby_guestfs_aug_close (VALUE gv)
1746 Data_Get_Struct (gv, guestfs_h, g);
1748 rb_raise (rb_eArgError, "%s: used handle after closing it", "aug_close");
1753 r = guestfs_aug_close (g);
1755 rb_raise (e_Error, "%s", guestfs_last_error (g));
1760 static VALUE ruby_guestfs_aug_defvar (VALUE gv, VALUE namev, VALUE exprv)
1763 Data_Get_Struct (gv, guestfs_h, g);
1765 rb_raise (rb_eArgError, "%s: used handle after closing it", "aug_defvar");
1767 const char *name = StringValueCStr (namev);
1769 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1770 "name", "aug_defvar");
1771 const char *expr = !NIL_P (exprv) ? StringValueCStr (exprv) : NULL;
1775 r = guestfs_aug_defvar (g, name, expr);
1777 rb_raise (e_Error, "%s", guestfs_last_error (g));
1782 static VALUE ruby_guestfs_aug_defnode (VALUE gv, VALUE namev, VALUE exprv, VALUE valv)
1785 Data_Get_Struct (gv, guestfs_h, g);
1787 rb_raise (rb_eArgError, "%s: used handle after closing it", "aug_defnode");
1789 const char *name = StringValueCStr (namev);
1791 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1792 "name", "aug_defnode");
1793 const char *expr = StringValueCStr (exprv);
1795 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1796 "expr", "aug_defnode");
1797 const char *val = StringValueCStr (valv);
1799 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1800 "val", "aug_defnode");
1802 struct guestfs_int_bool *r;
1804 r = guestfs_aug_defnode (g, name, expr, val);
1806 rb_raise (e_Error, "%s", guestfs_last_error (g));
1808 VALUE rv = rb_ary_new2 (2);
1809 rb_ary_push (rv, INT2NUM (r->i));
1810 rb_ary_push (rv, INT2NUM (r->b));
1811 guestfs_free_int_bool (r);
1815 static VALUE ruby_guestfs_aug_get (VALUE gv, VALUE pathv)
1818 Data_Get_Struct (gv, guestfs_h, g);
1820 rb_raise (rb_eArgError, "%s: used handle after closing it", "aug_get");
1822 const char *path = StringValueCStr (pathv);
1824 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1829 r = guestfs_aug_get (g, path);
1831 rb_raise (e_Error, "%s", guestfs_last_error (g));
1833 VALUE rv = rb_str_new2 (r);
1838 static VALUE ruby_guestfs_aug_set (VALUE gv, VALUE pathv, VALUE valv)
1841 Data_Get_Struct (gv, guestfs_h, g);
1843 rb_raise (rb_eArgError, "%s: used handle after closing it", "aug_set");
1845 const char *path = StringValueCStr (pathv);
1847 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1849 const char *val = StringValueCStr (valv);
1851 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1856 r = guestfs_aug_set (g, path, val);
1858 rb_raise (e_Error, "%s", guestfs_last_error (g));
1863 static VALUE ruby_guestfs_aug_insert (VALUE gv, VALUE pathv, VALUE labelv, VALUE beforev)
1866 Data_Get_Struct (gv, guestfs_h, g);
1868 rb_raise (rb_eArgError, "%s: used handle after closing it", "aug_insert");
1870 const char *path = StringValueCStr (pathv);
1872 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1873 "path", "aug_insert");
1874 const char *label = StringValueCStr (labelv);
1876 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1877 "label", "aug_insert");
1878 int before = RTEST (beforev);
1882 r = guestfs_aug_insert (g, path, label, before);
1884 rb_raise (e_Error, "%s", guestfs_last_error (g));
1889 static VALUE ruby_guestfs_aug_rm (VALUE gv, VALUE pathv)
1892 Data_Get_Struct (gv, guestfs_h, g);
1894 rb_raise (rb_eArgError, "%s: used handle after closing it", "aug_rm");
1896 const char *path = StringValueCStr (pathv);
1898 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1903 r = guestfs_aug_rm (g, path);
1905 rb_raise (e_Error, "%s", guestfs_last_error (g));
1910 static VALUE ruby_guestfs_aug_mv (VALUE gv, VALUE srcv, VALUE destv)
1913 Data_Get_Struct (gv, guestfs_h, g);
1915 rb_raise (rb_eArgError, "%s: used handle after closing it", "aug_mv");
1917 const char *src = StringValueCStr (srcv);
1919 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1921 const char *dest = StringValueCStr (destv);
1923 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1928 r = guestfs_aug_mv (g, src, dest);
1930 rb_raise (e_Error, "%s", guestfs_last_error (g));
1935 static VALUE ruby_guestfs_aug_match (VALUE gv, VALUE pathv)
1938 Data_Get_Struct (gv, guestfs_h, g);
1940 rb_raise (rb_eArgError, "%s: used handle after closing it", "aug_match");
1942 const char *path = StringValueCStr (pathv);
1944 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1945 "path", "aug_match");
1949 r = guestfs_aug_match (g, path);
1951 rb_raise (e_Error, "%s", guestfs_last_error (g));
1954 for (i = 0; r[i] != NULL; ++i) len++;
1955 VALUE rv = rb_ary_new2 (len);
1956 for (i = 0; r[i] != NULL; ++i) {
1957 rb_ary_push (rv, rb_str_new2 (r[i]));
1964 static VALUE ruby_guestfs_aug_save (VALUE gv)
1967 Data_Get_Struct (gv, guestfs_h, g);
1969 rb_raise (rb_eArgError, "%s: used handle after closing it", "aug_save");
1974 r = guestfs_aug_save (g);
1976 rb_raise (e_Error, "%s", guestfs_last_error (g));
1981 static VALUE ruby_guestfs_aug_load (VALUE gv)
1984 Data_Get_Struct (gv, guestfs_h, g);
1986 rb_raise (rb_eArgError, "%s: used handle after closing it", "aug_load");
1991 r = guestfs_aug_load (g);
1993 rb_raise (e_Error, "%s", guestfs_last_error (g));
1998 static VALUE ruby_guestfs_aug_ls (VALUE gv, VALUE pathv)
2001 Data_Get_Struct (gv, guestfs_h, g);
2003 rb_raise (rb_eArgError, "%s: used handle after closing it", "aug_ls");
2005 const char *path = StringValueCStr (pathv);
2007 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2012 r = guestfs_aug_ls (g, path);
2014 rb_raise (e_Error, "%s", guestfs_last_error (g));
2017 for (i = 0; r[i] != NULL; ++i) len++;
2018 VALUE rv = rb_ary_new2 (len);
2019 for (i = 0; r[i] != NULL; ++i) {
2020 rb_ary_push (rv, rb_str_new2 (r[i]));
2027 static VALUE ruby_guestfs_rm (VALUE gv, VALUE pathv)
2030 Data_Get_Struct (gv, guestfs_h, g);
2032 rb_raise (rb_eArgError, "%s: used handle after closing it", "rm");
2034 const char *path = StringValueCStr (pathv);
2036 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2041 r = guestfs_rm (g, path);
2043 rb_raise (e_Error, "%s", guestfs_last_error (g));
2048 static VALUE ruby_guestfs_rmdir (VALUE gv, VALUE pathv)
2051 Data_Get_Struct (gv, guestfs_h, g);
2053 rb_raise (rb_eArgError, "%s: used handle after closing it", "rmdir");
2055 const char *path = StringValueCStr (pathv);
2057 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2062 r = guestfs_rmdir (g, path);
2064 rb_raise (e_Error, "%s", guestfs_last_error (g));
2069 static VALUE ruby_guestfs_rm_rf (VALUE gv, VALUE pathv)
2072 Data_Get_Struct (gv, guestfs_h, g);
2074 rb_raise (rb_eArgError, "%s: used handle after closing it", "rm_rf");
2076 const char *path = StringValueCStr (pathv);
2078 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2083 r = guestfs_rm_rf (g, path);
2085 rb_raise (e_Error, "%s", guestfs_last_error (g));
2090 static VALUE ruby_guestfs_mkdir (VALUE gv, VALUE pathv)
2093 Data_Get_Struct (gv, guestfs_h, g);
2095 rb_raise (rb_eArgError, "%s: used handle after closing it", "mkdir");
2097 const char *path = StringValueCStr (pathv);
2099 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2104 r = guestfs_mkdir (g, path);
2106 rb_raise (e_Error, "%s", guestfs_last_error (g));
2111 static VALUE ruby_guestfs_mkdir_p (VALUE gv, VALUE pathv)
2114 Data_Get_Struct (gv, guestfs_h, g);
2116 rb_raise (rb_eArgError, "%s: used handle after closing it", "mkdir_p");
2118 const char *path = StringValueCStr (pathv);
2120 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2125 r = guestfs_mkdir_p (g, path);
2127 rb_raise (e_Error, "%s", guestfs_last_error (g));
2132 static VALUE ruby_guestfs_chmod (VALUE gv, VALUE modev, VALUE pathv)
2135 Data_Get_Struct (gv, guestfs_h, g);
2137 rb_raise (rb_eArgError, "%s: used handle after closing it", "chmod");
2139 int mode = NUM2INT (modev);
2140 const char *path = StringValueCStr (pathv);
2142 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2147 r = guestfs_chmod (g, mode, path);
2149 rb_raise (e_Error, "%s", guestfs_last_error (g));
2154 static VALUE ruby_guestfs_chown (VALUE gv, VALUE ownerv, VALUE groupv, VALUE pathv)
2157 Data_Get_Struct (gv, guestfs_h, g);
2159 rb_raise (rb_eArgError, "%s: used handle after closing it", "chown");
2161 int owner = NUM2INT (ownerv);
2162 int group = NUM2INT (groupv);
2163 const char *path = StringValueCStr (pathv);
2165 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2170 r = guestfs_chown (g, owner, group, path);
2172 rb_raise (e_Error, "%s", guestfs_last_error (g));
2177 static VALUE ruby_guestfs_exists (VALUE gv, VALUE pathv)
2180 Data_Get_Struct (gv, guestfs_h, g);
2182 rb_raise (rb_eArgError, "%s: used handle after closing it", "exists");
2184 const char *path = StringValueCStr (pathv);
2186 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2191 r = guestfs_exists (g, path);
2193 rb_raise (e_Error, "%s", guestfs_last_error (g));
2198 static VALUE ruby_guestfs_is_file (VALUE gv, VALUE pathv)
2201 Data_Get_Struct (gv, guestfs_h, g);
2203 rb_raise (rb_eArgError, "%s: used handle after closing it", "is_file");
2205 const char *path = StringValueCStr (pathv);
2207 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2212 r = guestfs_is_file (g, path);
2214 rb_raise (e_Error, "%s", guestfs_last_error (g));
2219 static VALUE ruby_guestfs_is_dir (VALUE gv, VALUE pathv)
2222 Data_Get_Struct (gv, guestfs_h, g);
2224 rb_raise (rb_eArgError, "%s: used handle after closing it", "is_dir");
2226 const char *path = StringValueCStr (pathv);
2228 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2233 r = guestfs_is_dir (g, path);
2235 rb_raise (e_Error, "%s", guestfs_last_error (g));
2240 static VALUE ruby_guestfs_pvcreate (VALUE gv, VALUE devicev)
2243 Data_Get_Struct (gv, guestfs_h, g);
2245 rb_raise (rb_eArgError, "%s: used handle after closing it", "pvcreate");
2247 const char *device = StringValueCStr (devicev);
2249 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2250 "device", "pvcreate");
2254 r = guestfs_pvcreate (g, device);
2256 rb_raise (e_Error, "%s", guestfs_last_error (g));
2261 static VALUE ruby_guestfs_vgcreate (VALUE gv, VALUE volgroupv, VALUE physvolsv)
2264 Data_Get_Struct (gv, guestfs_h, g);
2266 rb_raise (rb_eArgError, "%s: used handle after closing it", "vgcreate");
2268 const char *volgroup = StringValueCStr (volgroupv);
2270 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2271 "volgroup", "vgcreate");
2275 len = RARRAY_LEN (physvolsv);
2276 physvols = guestfs_safe_malloc (g, sizeof (char *) * (len+1));
2277 for (i = 0; i < len; ++i) {
2278 VALUE v = rb_ary_entry (physvolsv, i);
2279 physvols[i] = StringValueCStr (v);
2281 physvols[len] = NULL;
2286 r = guestfs_vgcreate (g, volgroup, physvols);
2289 rb_raise (e_Error, "%s", guestfs_last_error (g));
2294 static VALUE ruby_guestfs_lvcreate (VALUE gv, VALUE logvolv, VALUE volgroupv, VALUE mbytesv)
2297 Data_Get_Struct (gv, guestfs_h, g);
2299 rb_raise (rb_eArgError, "%s: used handle after closing it", "lvcreate");
2301 const char *logvol = StringValueCStr (logvolv);
2303 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2304 "logvol", "lvcreate");
2305 const char *volgroup = StringValueCStr (volgroupv);
2307 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2308 "volgroup", "lvcreate");
2309 int mbytes = NUM2INT (mbytesv);
2313 r = guestfs_lvcreate (g, logvol, volgroup, mbytes);
2315 rb_raise (e_Error, "%s", guestfs_last_error (g));
2320 static VALUE ruby_guestfs_mkfs (VALUE gv, VALUE fstypev, VALUE devicev)
2323 Data_Get_Struct (gv, guestfs_h, g);
2325 rb_raise (rb_eArgError, "%s: used handle after closing it", "mkfs");
2327 const char *fstype = StringValueCStr (fstypev);
2329 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2331 const char *device = StringValueCStr (devicev);
2333 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2338 r = guestfs_mkfs (g, fstype, device);
2340 rb_raise (e_Error, "%s", guestfs_last_error (g));
2345 static VALUE ruby_guestfs_sfdisk (VALUE gv, VALUE devicev, VALUE cylsv, VALUE headsv, VALUE sectorsv, VALUE linesv)
2348 Data_Get_Struct (gv, guestfs_h, g);
2350 rb_raise (rb_eArgError, "%s: used handle after closing it", "sfdisk");
2352 const char *device = StringValueCStr (devicev);
2354 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2355 "device", "sfdisk");
2356 int cyls = NUM2INT (cylsv);
2357 int heads = NUM2INT (headsv);
2358 int sectors = NUM2INT (sectorsv);
2362 len = RARRAY_LEN (linesv);
2363 lines = guestfs_safe_malloc (g, sizeof (char *) * (len+1));
2364 for (i = 0; i < len; ++i) {
2365 VALUE v = rb_ary_entry (linesv, i);
2366 lines[i] = StringValueCStr (v);
2373 r = guestfs_sfdisk (g, device, cyls, heads, sectors, lines);
2376 rb_raise (e_Error, "%s", guestfs_last_error (g));
2381 static VALUE ruby_guestfs_write_file (VALUE gv, VALUE pathv, VALUE contentv, VALUE sizev)
2384 Data_Get_Struct (gv, guestfs_h, g);
2386 rb_raise (rb_eArgError, "%s: used handle after closing it", "write_file");
2388 const char *path = StringValueCStr (pathv);
2390 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2391 "path", "write_file");
2392 const char *content = StringValueCStr (contentv);
2394 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2395 "content", "write_file");
2396 int size = NUM2INT (sizev);
2400 r = guestfs_write_file (g, path, content, size);
2402 rb_raise (e_Error, "%s", guestfs_last_error (g));
2407 static VALUE ruby_guestfs_umount (VALUE gv, VALUE pathordevicev)
2410 Data_Get_Struct (gv, guestfs_h, g);
2412 rb_raise (rb_eArgError, "%s: used handle after closing it", "umount");
2414 const char *pathordevice = StringValueCStr (pathordevicev);
2416 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2417 "pathordevice", "umount");
2421 r = guestfs_umount (g, pathordevice);
2423 rb_raise (e_Error, "%s", guestfs_last_error (g));
2428 static VALUE ruby_guestfs_mounts (VALUE gv)
2431 Data_Get_Struct (gv, guestfs_h, g);
2433 rb_raise (rb_eArgError, "%s: used handle after closing it", "mounts");
2438 r = guestfs_mounts (g);
2440 rb_raise (e_Error, "%s", guestfs_last_error (g));
2443 for (i = 0; r[i] != NULL; ++i) len++;
2444 VALUE rv = rb_ary_new2 (len);
2445 for (i = 0; r[i] != NULL; ++i) {
2446 rb_ary_push (rv, rb_str_new2 (r[i]));
2453 static VALUE ruby_guestfs_umount_all (VALUE gv)
2456 Data_Get_Struct (gv, guestfs_h, g);
2458 rb_raise (rb_eArgError, "%s: used handle after closing it", "umount_all");
2463 r = guestfs_umount_all (g);
2465 rb_raise (e_Error, "%s", guestfs_last_error (g));
2470 static VALUE ruby_guestfs_lvm_remove_all (VALUE gv)
2473 Data_Get_Struct (gv, guestfs_h, g);
2475 rb_raise (rb_eArgError, "%s: used handle after closing it", "lvm_remove_all");
2480 r = guestfs_lvm_remove_all (g);
2482 rb_raise (e_Error, "%s", guestfs_last_error (g));
2487 static VALUE ruby_guestfs_file (VALUE gv, VALUE pathv)
2490 Data_Get_Struct (gv, guestfs_h, g);
2492 rb_raise (rb_eArgError, "%s: used handle after closing it", "file");
2494 const char *path = StringValueCStr (pathv);
2496 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2501 r = guestfs_file (g, path);
2503 rb_raise (e_Error, "%s", guestfs_last_error (g));
2505 VALUE rv = rb_str_new2 (r);
2510 static VALUE ruby_guestfs_command (VALUE gv, VALUE argumentsv)
2513 Data_Get_Struct (gv, guestfs_h, g);
2515 rb_raise (rb_eArgError, "%s: used handle after closing it", "command");
2520 len = RARRAY_LEN (argumentsv);
2521 arguments = guestfs_safe_malloc (g, sizeof (char *) * (len+1));
2522 for (i = 0; i < len; ++i) {
2523 VALUE v = rb_ary_entry (argumentsv, i);
2524 arguments[i] = StringValueCStr (v);
2526 arguments[len] = NULL;
2531 r = guestfs_command (g, arguments);
2534 rb_raise (e_Error, "%s", guestfs_last_error (g));
2536 VALUE rv = rb_str_new2 (r);
2541 static VALUE ruby_guestfs_command_lines (VALUE gv, VALUE argumentsv)
2544 Data_Get_Struct (gv, guestfs_h, g);
2546 rb_raise (rb_eArgError, "%s: used handle after closing it", "command_lines");
2551 len = RARRAY_LEN (argumentsv);
2552 arguments = guestfs_safe_malloc (g, sizeof (char *) * (len+1));
2553 for (i = 0; i < len; ++i) {
2554 VALUE v = rb_ary_entry (argumentsv, i);
2555 arguments[i] = StringValueCStr (v);
2557 arguments[len] = NULL;
2562 r = guestfs_command_lines (g, arguments);
2565 rb_raise (e_Error, "%s", guestfs_last_error (g));
2568 for (i = 0; r[i] != NULL; ++i) len++;
2569 VALUE rv = rb_ary_new2 (len);
2570 for (i = 0; r[i] != NULL; ++i) {
2571 rb_ary_push (rv, rb_str_new2 (r[i]));
2578 static VALUE ruby_guestfs_stat (VALUE gv, VALUE pathv)
2581 Data_Get_Struct (gv, guestfs_h, g);
2583 rb_raise (rb_eArgError, "%s: used handle after closing it", "stat");
2585 const char *path = StringValueCStr (pathv);
2587 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2590 struct guestfs_stat *r;
2592 r = guestfs_stat (g, path);
2594 rb_raise (e_Error, "%s", guestfs_last_error (g));
2596 VALUE rv = rb_hash_new ();
2597 rb_hash_aset (rv, rb_str_new2 ("dev"), ULL2NUM (r->dev));
2598 rb_hash_aset (rv, rb_str_new2 ("ino"), ULL2NUM (r->ino));
2599 rb_hash_aset (rv, rb_str_new2 ("mode"), ULL2NUM (r->mode));
2600 rb_hash_aset (rv, rb_str_new2 ("nlink"), ULL2NUM (r->nlink));
2601 rb_hash_aset (rv, rb_str_new2 ("uid"), ULL2NUM (r->uid));
2602 rb_hash_aset (rv, rb_str_new2 ("gid"), ULL2NUM (r->gid));
2603 rb_hash_aset (rv, rb_str_new2 ("rdev"), ULL2NUM (r->rdev));
2604 rb_hash_aset (rv, rb_str_new2 ("size"), ULL2NUM (r->size));
2605 rb_hash_aset (rv, rb_str_new2 ("blksize"), ULL2NUM (r->blksize));
2606 rb_hash_aset (rv, rb_str_new2 ("blocks"), ULL2NUM (r->blocks));
2607 rb_hash_aset (rv, rb_str_new2 ("atime"), ULL2NUM (r->atime));
2608 rb_hash_aset (rv, rb_str_new2 ("mtime"), ULL2NUM (r->mtime));
2609 rb_hash_aset (rv, rb_str_new2 ("ctime"), ULL2NUM (r->ctime));
2614 static VALUE ruby_guestfs_lstat (VALUE gv, VALUE pathv)
2617 Data_Get_Struct (gv, guestfs_h, g);
2619 rb_raise (rb_eArgError, "%s: used handle after closing it", "lstat");
2621 const char *path = StringValueCStr (pathv);
2623 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2626 struct guestfs_stat *r;
2628 r = guestfs_lstat (g, path);
2630 rb_raise (e_Error, "%s", guestfs_last_error (g));
2632 VALUE rv = rb_hash_new ();
2633 rb_hash_aset (rv, rb_str_new2 ("dev"), ULL2NUM (r->dev));
2634 rb_hash_aset (rv, rb_str_new2 ("ino"), ULL2NUM (r->ino));
2635 rb_hash_aset (rv, rb_str_new2 ("mode"), ULL2NUM (r->mode));
2636 rb_hash_aset (rv, rb_str_new2 ("nlink"), ULL2NUM (r->nlink));
2637 rb_hash_aset (rv, rb_str_new2 ("uid"), ULL2NUM (r->uid));
2638 rb_hash_aset (rv, rb_str_new2 ("gid"), ULL2NUM (r->gid));
2639 rb_hash_aset (rv, rb_str_new2 ("rdev"), ULL2NUM (r->rdev));
2640 rb_hash_aset (rv, rb_str_new2 ("size"), ULL2NUM (r->size));
2641 rb_hash_aset (rv, rb_str_new2 ("blksize"), ULL2NUM (r->blksize));
2642 rb_hash_aset (rv, rb_str_new2 ("blocks"), ULL2NUM (r->blocks));
2643 rb_hash_aset (rv, rb_str_new2 ("atime"), ULL2NUM (r->atime));
2644 rb_hash_aset (rv, rb_str_new2 ("mtime"), ULL2NUM (r->mtime));
2645 rb_hash_aset (rv, rb_str_new2 ("ctime"), ULL2NUM (r->ctime));
2650 static VALUE ruby_guestfs_statvfs (VALUE gv, VALUE pathv)
2653 Data_Get_Struct (gv, guestfs_h, g);
2655 rb_raise (rb_eArgError, "%s: used handle after closing it", "statvfs");
2657 const char *path = StringValueCStr (pathv);
2659 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2662 struct guestfs_statvfs *r;
2664 r = guestfs_statvfs (g, path);
2666 rb_raise (e_Error, "%s", guestfs_last_error (g));
2668 VALUE rv = rb_hash_new ();
2669 rb_hash_aset (rv, rb_str_new2 ("bsize"), ULL2NUM (r->bsize));
2670 rb_hash_aset (rv, rb_str_new2 ("frsize"), ULL2NUM (r->frsize));
2671 rb_hash_aset (rv, rb_str_new2 ("blocks"), ULL2NUM (r->blocks));
2672 rb_hash_aset (rv, rb_str_new2 ("bfree"), ULL2NUM (r->bfree));
2673 rb_hash_aset (rv, rb_str_new2 ("bavail"), ULL2NUM (r->bavail));
2674 rb_hash_aset (rv, rb_str_new2 ("files"), ULL2NUM (r->files));
2675 rb_hash_aset (rv, rb_str_new2 ("ffree"), ULL2NUM (r->ffree));
2676 rb_hash_aset (rv, rb_str_new2 ("favail"), ULL2NUM (r->favail));
2677 rb_hash_aset (rv, rb_str_new2 ("fsid"), ULL2NUM (r->fsid));
2678 rb_hash_aset (rv, rb_str_new2 ("flag"), ULL2NUM (r->flag));
2679 rb_hash_aset (rv, rb_str_new2 ("namemax"), ULL2NUM (r->namemax));
2684 static VALUE ruby_guestfs_tune2fs_l (VALUE gv, VALUE devicev)
2687 Data_Get_Struct (gv, guestfs_h, g);
2689 rb_raise (rb_eArgError, "%s: used handle after closing it", "tune2fs_l");
2691 const char *device = StringValueCStr (devicev);
2693 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2694 "device", "tune2fs_l");
2698 r = guestfs_tune2fs_l (g, device);
2700 rb_raise (e_Error, "%s", guestfs_last_error (g));
2702 VALUE rv = rb_hash_new ();
2704 for (i = 0; r[i] != NULL; i+=2) {
2705 rb_hash_aset (rv, rb_str_new2 (r[i]), rb_str_new2 (r[i+1]));
2713 static VALUE ruby_guestfs_blockdev_setro (VALUE gv, VALUE devicev)
2716 Data_Get_Struct (gv, guestfs_h, g);
2718 rb_raise (rb_eArgError, "%s: used handle after closing it", "blockdev_setro");
2720 const char *device = StringValueCStr (devicev);
2722 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2723 "device", "blockdev_setro");
2727 r = guestfs_blockdev_setro (g, device);
2729 rb_raise (e_Error, "%s", guestfs_last_error (g));
2734 static VALUE ruby_guestfs_blockdev_setrw (VALUE gv, VALUE devicev)
2737 Data_Get_Struct (gv, guestfs_h, g);
2739 rb_raise (rb_eArgError, "%s: used handle after closing it", "blockdev_setrw");
2741 const char *device = StringValueCStr (devicev);
2743 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2744 "device", "blockdev_setrw");
2748 r = guestfs_blockdev_setrw (g, device);
2750 rb_raise (e_Error, "%s", guestfs_last_error (g));
2755 static VALUE ruby_guestfs_blockdev_getro (VALUE gv, VALUE devicev)
2758 Data_Get_Struct (gv, guestfs_h, g);
2760 rb_raise (rb_eArgError, "%s: used handle after closing it", "blockdev_getro");
2762 const char *device = StringValueCStr (devicev);
2764 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2765 "device", "blockdev_getro");
2769 r = guestfs_blockdev_getro (g, device);
2771 rb_raise (e_Error, "%s", guestfs_last_error (g));
2776 static VALUE ruby_guestfs_blockdev_getss (VALUE gv, VALUE devicev)
2779 Data_Get_Struct (gv, guestfs_h, g);
2781 rb_raise (rb_eArgError, "%s: used handle after closing it", "blockdev_getss");
2783 const char *device = StringValueCStr (devicev);
2785 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2786 "device", "blockdev_getss");
2790 r = guestfs_blockdev_getss (g, device);
2792 rb_raise (e_Error, "%s", guestfs_last_error (g));
2797 static VALUE ruby_guestfs_blockdev_getbsz (VALUE gv, VALUE devicev)
2800 Data_Get_Struct (gv, guestfs_h, g);
2802 rb_raise (rb_eArgError, "%s: used handle after closing it", "blockdev_getbsz");
2804 const char *device = StringValueCStr (devicev);
2806 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2807 "device", "blockdev_getbsz");
2811 r = guestfs_blockdev_getbsz (g, device);
2813 rb_raise (e_Error, "%s", guestfs_last_error (g));
2818 static VALUE ruby_guestfs_blockdev_setbsz (VALUE gv, VALUE devicev, VALUE blocksizev)
2821 Data_Get_Struct (gv, guestfs_h, g);
2823 rb_raise (rb_eArgError, "%s: used handle after closing it", "blockdev_setbsz");
2825 const char *device = StringValueCStr (devicev);
2827 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2828 "device", "blockdev_setbsz");
2829 int blocksize = NUM2INT (blocksizev);
2833 r = guestfs_blockdev_setbsz (g, device, blocksize);
2835 rb_raise (e_Error, "%s", guestfs_last_error (g));
2840 static VALUE ruby_guestfs_blockdev_getsz (VALUE gv, VALUE devicev)
2843 Data_Get_Struct (gv, guestfs_h, g);
2845 rb_raise (rb_eArgError, "%s: used handle after closing it", "blockdev_getsz");
2847 const char *device = StringValueCStr (devicev);
2849 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2850 "device", "blockdev_getsz");
2854 r = guestfs_blockdev_getsz (g, device);
2856 rb_raise (e_Error, "%s", guestfs_last_error (g));
2861 static VALUE ruby_guestfs_blockdev_getsize64 (VALUE gv, VALUE devicev)
2864 Data_Get_Struct (gv, guestfs_h, g);
2866 rb_raise (rb_eArgError, "%s: used handle after closing it", "blockdev_getsize64");
2868 const char *device = StringValueCStr (devicev);
2870 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2871 "device", "blockdev_getsize64");
2875 r = guestfs_blockdev_getsize64 (g, device);
2877 rb_raise (e_Error, "%s", guestfs_last_error (g));
2882 static VALUE ruby_guestfs_blockdev_flushbufs (VALUE gv, VALUE devicev)
2885 Data_Get_Struct (gv, guestfs_h, g);
2887 rb_raise (rb_eArgError, "%s: used handle after closing it", "blockdev_flushbufs");
2889 const char *device = StringValueCStr (devicev);
2891 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2892 "device", "blockdev_flushbufs");
2896 r = guestfs_blockdev_flushbufs (g, device);
2898 rb_raise (e_Error, "%s", guestfs_last_error (g));
2903 static VALUE ruby_guestfs_blockdev_rereadpt (VALUE gv, VALUE devicev)
2906 Data_Get_Struct (gv, guestfs_h, g);
2908 rb_raise (rb_eArgError, "%s: used handle after closing it", "blockdev_rereadpt");
2910 const char *device = StringValueCStr (devicev);
2912 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2913 "device", "blockdev_rereadpt");
2917 r = guestfs_blockdev_rereadpt (g, device);
2919 rb_raise (e_Error, "%s", guestfs_last_error (g));
2924 static VALUE ruby_guestfs_upload (VALUE gv, VALUE filenamev, VALUE remotefilenamev)
2927 Data_Get_Struct (gv, guestfs_h, g);
2929 rb_raise (rb_eArgError, "%s: used handle after closing it", "upload");
2931 const char *filename = StringValueCStr (filenamev);
2933 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2934 "filename", "upload");
2935 const char *remotefilename = StringValueCStr (remotefilenamev);
2936 if (!remotefilename)
2937 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2938 "remotefilename", "upload");
2942 r = guestfs_upload (g, filename, remotefilename);
2944 rb_raise (e_Error, "%s", guestfs_last_error (g));
2949 static VALUE ruby_guestfs_download (VALUE gv, VALUE remotefilenamev, VALUE filenamev)
2952 Data_Get_Struct (gv, guestfs_h, g);
2954 rb_raise (rb_eArgError, "%s: used handle after closing it", "download");
2956 const char *remotefilename = StringValueCStr (remotefilenamev);
2957 if (!remotefilename)
2958 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2959 "remotefilename", "download");
2960 const char *filename = StringValueCStr (filenamev);
2962 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2963 "filename", "download");
2967 r = guestfs_download (g, remotefilename, filename);
2969 rb_raise (e_Error, "%s", guestfs_last_error (g));
2974 static VALUE ruby_guestfs_checksum (VALUE gv, VALUE csumtypev, VALUE pathv)
2977 Data_Get_Struct (gv, guestfs_h, g);
2979 rb_raise (rb_eArgError, "%s: used handle after closing it", "checksum");
2981 const char *csumtype = StringValueCStr (csumtypev);
2983 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2984 "csumtype", "checksum");
2985 const char *path = StringValueCStr (pathv);
2987 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2988 "path", "checksum");
2992 r = guestfs_checksum (g, csumtype, path);
2994 rb_raise (e_Error, "%s", guestfs_last_error (g));
2996 VALUE rv = rb_str_new2 (r);
3001 static VALUE ruby_guestfs_tar_in (VALUE gv, VALUE tarfilev, VALUE directoryv)
3004 Data_Get_Struct (gv, guestfs_h, g);
3006 rb_raise (rb_eArgError, "%s: used handle after closing it", "tar_in");
3008 const char *tarfile = StringValueCStr (tarfilev);
3010 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3011 "tarfile", "tar_in");
3012 const char *directory = StringValueCStr (directoryv);
3014 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3015 "directory", "tar_in");
3019 r = guestfs_tar_in (g, tarfile, directory);
3021 rb_raise (e_Error, "%s", guestfs_last_error (g));
3026 static VALUE ruby_guestfs_tar_out (VALUE gv, VALUE directoryv, VALUE tarfilev)
3029 Data_Get_Struct (gv, guestfs_h, g);
3031 rb_raise (rb_eArgError, "%s: used handle after closing it", "tar_out");
3033 const char *directory = StringValueCStr (directoryv);
3035 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3036 "directory", "tar_out");
3037 const char *tarfile = StringValueCStr (tarfilev);
3039 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3040 "tarfile", "tar_out");
3044 r = guestfs_tar_out (g, directory, tarfile);
3046 rb_raise (e_Error, "%s", guestfs_last_error (g));
3051 static VALUE ruby_guestfs_tgz_in (VALUE gv, VALUE tarballv, VALUE directoryv)
3054 Data_Get_Struct (gv, guestfs_h, g);
3056 rb_raise (rb_eArgError, "%s: used handle after closing it", "tgz_in");
3058 const char *tarball = StringValueCStr (tarballv);
3060 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3061 "tarball", "tgz_in");
3062 const char *directory = StringValueCStr (directoryv);
3064 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3065 "directory", "tgz_in");
3069 r = guestfs_tgz_in (g, tarball, directory);
3071 rb_raise (e_Error, "%s", guestfs_last_error (g));
3076 static VALUE ruby_guestfs_tgz_out (VALUE gv, VALUE directoryv, VALUE tarballv)
3079 Data_Get_Struct (gv, guestfs_h, g);
3081 rb_raise (rb_eArgError, "%s: used handle after closing it", "tgz_out");
3083 const char *directory = StringValueCStr (directoryv);
3085 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3086 "directory", "tgz_out");
3087 const char *tarball = StringValueCStr (tarballv);
3089 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3090 "tarball", "tgz_out");
3094 r = guestfs_tgz_out (g, directory, tarball);
3096 rb_raise (e_Error, "%s", guestfs_last_error (g));
3101 static VALUE ruby_guestfs_mount_ro (VALUE gv, VALUE devicev, VALUE mountpointv)
3104 Data_Get_Struct (gv, guestfs_h, g);
3106 rb_raise (rb_eArgError, "%s: used handle after closing it", "mount_ro");
3108 const char *device = StringValueCStr (devicev);
3110 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3111 "device", "mount_ro");
3112 const char *mountpoint = StringValueCStr (mountpointv);
3114 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3115 "mountpoint", "mount_ro");
3119 r = guestfs_mount_ro (g, device, mountpoint);
3121 rb_raise (e_Error, "%s", guestfs_last_error (g));
3126 static VALUE ruby_guestfs_mount_options (VALUE gv, VALUE optionsv, VALUE devicev, VALUE mountpointv)
3129 Data_Get_Struct (gv, guestfs_h, g);
3131 rb_raise (rb_eArgError, "%s: used handle after closing it", "mount_options");
3133 const char *options = StringValueCStr (optionsv);
3135 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3136 "options", "mount_options");
3137 const char *device = StringValueCStr (devicev);
3139 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3140 "device", "mount_options");
3141 const char *mountpoint = StringValueCStr (mountpointv);
3143 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3144 "mountpoint", "mount_options");
3148 r = guestfs_mount_options (g, options, device, mountpoint);
3150 rb_raise (e_Error, "%s", guestfs_last_error (g));
3155 static VALUE ruby_guestfs_mount_vfs (VALUE gv, VALUE optionsv, VALUE vfstypev, VALUE devicev, VALUE mountpointv)
3158 Data_Get_Struct (gv, guestfs_h, g);
3160 rb_raise (rb_eArgError, "%s: used handle after closing it", "mount_vfs");
3162 const char *options = StringValueCStr (optionsv);
3164 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3165 "options", "mount_vfs");
3166 const char *vfstype = StringValueCStr (vfstypev);
3168 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3169 "vfstype", "mount_vfs");
3170 const char *device = StringValueCStr (devicev);
3172 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3173 "device", "mount_vfs");
3174 const char *mountpoint = StringValueCStr (mountpointv);
3176 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3177 "mountpoint", "mount_vfs");
3181 r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint);
3183 rb_raise (e_Error, "%s", guestfs_last_error (g));
3188 static VALUE ruby_guestfs_debug (VALUE gv, VALUE subcmdv, VALUE extraargsv)
3191 Data_Get_Struct (gv, guestfs_h, g);
3193 rb_raise (rb_eArgError, "%s: used handle after closing it", "debug");
3195 const char *subcmd = StringValueCStr (subcmdv);
3197 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3202 len = RARRAY_LEN (extraargsv);
3203 extraargs = guestfs_safe_malloc (g, sizeof (char *) * (len+1));
3204 for (i = 0; i < len; ++i) {
3205 VALUE v = rb_ary_entry (extraargsv, i);
3206 extraargs[i] = StringValueCStr (v);
3208 extraargs[len] = NULL;
3213 r = guestfs_debug (g, subcmd, extraargs);
3216 rb_raise (e_Error, "%s", guestfs_last_error (g));
3218 VALUE rv = rb_str_new2 (r);
3223 static VALUE ruby_guestfs_lvremove (VALUE gv, VALUE devicev)
3226 Data_Get_Struct (gv, guestfs_h, g);
3228 rb_raise (rb_eArgError, "%s: used handle after closing it", "lvremove");
3230 const char *device = StringValueCStr (devicev);
3232 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3233 "device", "lvremove");
3237 r = guestfs_lvremove (g, device);
3239 rb_raise (e_Error, "%s", guestfs_last_error (g));
3244 static VALUE ruby_guestfs_vgremove (VALUE gv, VALUE vgnamev)
3247 Data_Get_Struct (gv, guestfs_h, g);
3249 rb_raise (rb_eArgError, "%s: used handle after closing it", "vgremove");
3251 const char *vgname = StringValueCStr (vgnamev);
3253 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3254 "vgname", "vgremove");
3258 r = guestfs_vgremove (g, vgname);
3260 rb_raise (e_Error, "%s", guestfs_last_error (g));
3265 static VALUE ruby_guestfs_pvremove (VALUE gv, VALUE devicev)
3268 Data_Get_Struct (gv, guestfs_h, g);
3270 rb_raise (rb_eArgError, "%s: used handle after closing it", "pvremove");
3272 const char *device = StringValueCStr (devicev);
3274 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3275 "device", "pvremove");
3279 r = guestfs_pvremove (g, device);
3281 rb_raise (e_Error, "%s", guestfs_last_error (g));
3286 static VALUE ruby_guestfs_set_e2label (VALUE gv, VALUE devicev, VALUE labelv)
3289 Data_Get_Struct (gv, guestfs_h, g);
3291 rb_raise (rb_eArgError, "%s: used handle after closing it", "set_e2label");
3293 const char *device = StringValueCStr (devicev);
3295 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3296 "device", "set_e2label");
3297 const char *label = StringValueCStr (labelv);
3299 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3300 "label", "set_e2label");
3304 r = guestfs_set_e2label (g, device, label);
3306 rb_raise (e_Error, "%s", guestfs_last_error (g));
3311 static VALUE ruby_guestfs_get_e2label (VALUE gv, VALUE devicev)
3314 Data_Get_Struct (gv, guestfs_h, g);
3316 rb_raise (rb_eArgError, "%s: used handle after closing it", "get_e2label");
3318 const char *device = StringValueCStr (devicev);
3320 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3321 "device", "get_e2label");
3325 r = guestfs_get_e2label (g, device);
3327 rb_raise (e_Error, "%s", guestfs_last_error (g));
3329 VALUE rv = rb_str_new2 (r);
3334 static VALUE ruby_guestfs_set_e2uuid (VALUE gv, VALUE devicev, VALUE uuidv)
3337 Data_Get_Struct (gv, guestfs_h, g);
3339 rb_raise (rb_eArgError, "%s: used handle after closing it", "set_e2uuid");
3341 const char *device = StringValueCStr (devicev);
3343 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3344 "device", "set_e2uuid");
3345 const char *uuid = StringValueCStr (uuidv);
3347 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3348 "uuid", "set_e2uuid");
3352 r = guestfs_set_e2uuid (g, device, uuid);
3354 rb_raise (e_Error, "%s", guestfs_last_error (g));
3359 static VALUE ruby_guestfs_get_e2uuid (VALUE gv, VALUE devicev)
3362 Data_Get_Struct (gv, guestfs_h, g);
3364 rb_raise (rb_eArgError, "%s: used handle after closing it", "get_e2uuid");
3366 const char *device = StringValueCStr (devicev);
3368 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3369 "device", "get_e2uuid");
3373 r = guestfs_get_e2uuid (g, device);
3375 rb_raise (e_Error, "%s", guestfs_last_error (g));
3377 VALUE rv = rb_str_new2 (r);
3382 static VALUE ruby_guestfs_fsck (VALUE gv, VALUE fstypev, VALUE devicev)
3385 Data_Get_Struct (gv, guestfs_h, g);
3387 rb_raise (rb_eArgError, "%s: used handle after closing it", "fsck");
3389 const char *fstype = StringValueCStr (fstypev);
3391 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3393 const char *device = StringValueCStr (devicev);
3395 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3400 r = guestfs_fsck (g, fstype, device);
3402 rb_raise (e_Error, "%s", guestfs_last_error (g));
3407 static VALUE ruby_guestfs_zero (VALUE gv, VALUE devicev)
3410 Data_Get_Struct (gv, guestfs_h, g);
3412 rb_raise (rb_eArgError, "%s: used handle after closing it", "zero");
3414 const char *device = StringValueCStr (devicev);
3416 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3421 r = guestfs_zero (g, device);
3423 rb_raise (e_Error, "%s", guestfs_last_error (g));
3428 static VALUE ruby_guestfs_grub_install (VALUE gv, VALUE rootv, VALUE devicev)
3431 Data_Get_Struct (gv, guestfs_h, g);
3433 rb_raise (rb_eArgError, "%s: used handle after closing it", "grub_install");
3435 const char *root = StringValueCStr (rootv);
3437 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3438 "root", "grub_install");
3439 const char *device = StringValueCStr (devicev);
3441 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3442 "device", "grub_install");
3446 r = guestfs_grub_install (g, root, device);
3448 rb_raise (e_Error, "%s", guestfs_last_error (g));
3453 static VALUE ruby_guestfs_cp (VALUE gv, VALUE srcv, VALUE destv)
3456 Data_Get_Struct (gv, guestfs_h, g);
3458 rb_raise (rb_eArgError, "%s: used handle after closing it", "cp");
3460 const char *src = StringValueCStr (srcv);
3462 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3464 const char *dest = StringValueCStr (destv);
3466 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3471 r = guestfs_cp (g, src, dest);
3473 rb_raise (e_Error, "%s", guestfs_last_error (g));
3478 static VALUE ruby_guestfs_cp_a (VALUE gv, VALUE srcv, VALUE destv)
3481 Data_Get_Struct (gv, guestfs_h, g);
3483 rb_raise (rb_eArgError, "%s: used handle after closing it", "cp_a");
3485 const char *src = StringValueCStr (srcv);
3487 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3489 const char *dest = StringValueCStr (destv);
3491 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3496 r = guestfs_cp_a (g, src, dest);
3498 rb_raise (e_Error, "%s", guestfs_last_error (g));
3503 static VALUE ruby_guestfs_mv (VALUE gv, VALUE srcv, VALUE destv)
3506 Data_Get_Struct (gv, guestfs_h, g);
3508 rb_raise (rb_eArgError, "%s: used handle after closing it", "mv");
3510 const char *src = StringValueCStr (srcv);
3512 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3514 const char *dest = StringValueCStr (destv);
3516 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3521 r = guestfs_mv (g, src, dest);
3523 rb_raise (e_Error, "%s", guestfs_last_error (g));
3528 static VALUE ruby_guestfs_drop_caches (VALUE gv, VALUE whattodropv)
3531 Data_Get_Struct (gv, guestfs_h, g);
3533 rb_raise (rb_eArgError, "%s: used handle after closing it", "drop_caches");
3535 int whattodrop = NUM2INT (whattodropv);
3539 r = guestfs_drop_caches (g, whattodrop);
3541 rb_raise (e_Error, "%s", guestfs_last_error (g));
3546 static VALUE ruby_guestfs_dmesg (VALUE gv)
3549 Data_Get_Struct (gv, guestfs_h, g);
3551 rb_raise (rb_eArgError, "%s: used handle after closing it", "dmesg");
3556 r = guestfs_dmesg (g);
3558 rb_raise (e_Error, "%s", guestfs_last_error (g));
3560 VALUE rv = rb_str_new2 (r);
3565 static VALUE ruby_guestfs_ping_daemon (VALUE gv)
3568 Data_Get_Struct (gv, guestfs_h, g);
3570 rb_raise (rb_eArgError, "%s: used handle after closing it", "ping_daemon");
3575 r = guestfs_ping_daemon (g);
3577 rb_raise (e_Error, "%s", guestfs_last_error (g));
3582 static VALUE ruby_guestfs_equal (VALUE gv, VALUE file1v, VALUE file2v)
3585 Data_Get_Struct (gv, guestfs_h, g);
3587 rb_raise (rb_eArgError, "%s: used handle after closing it", "equal");
3589 const char *file1 = StringValueCStr (file1v);
3591 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3593 const char *file2 = StringValueCStr (file2v);
3595 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3600 r = guestfs_equal (g, file1, file2);
3602 rb_raise (e_Error, "%s", guestfs_last_error (g));
3607 static VALUE ruby_guestfs_strings (VALUE gv, VALUE pathv)
3610 Data_Get_Struct (gv, guestfs_h, g);
3612 rb_raise (rb_eArgError, "%s: used handle after closing it", "strings");
3614 const char *path = StringValueCStr (pathv);
3616 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3621 r = guestfs_strings (g, path);
3623 rb_raise (e_Error, "%s", guestfs_last_error (g));
3626 for (i = 0; r[i] != NULL; ++i) len++;
3627 VALUE rv = rb_ary_new2 (len);
3628 for (i = 0; r[i] != NULL; ++i) {
3629 rb_ary_push (rv, rb_str_new2 (r[i]));
3636 static VALUE ruby_guestfs_strings_e (VALUE gv, VALUE encodingv, VALUE pathv)
3639 Data_Get_Struct (gv, guestfs_h, g);
3641 rb_raise (rb_eArgError, "%s: used handle after closing it", "strings_e");
3643 const char *encoding = StringValueCStr (encodingv);
3645 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3646 "encoding", "strings_e");
3647 const char *path = StringValueCStr (pathv);
3649 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3650 "path", "strings_e");
3654 r = guestfs_strings_e (g, encoding, path);
3656 rb_raise (e_Error, "%s", guestfs_last_error (g));
3659 for (i = 0; r[i] != NULL; ++i) len++;
3660 VALUE rv = rb_ary_new2 (len);
3661 for (i = 0; r[i] != NULL; ++i) {
3662 rb_ary_push (rv, rb_str_new2 (r[i]));
3669 static VALUE ruby_guestfs_hexdump (VALUE gv, VALUE pathv)
3672 Data_Get_Struct (gv, guestfs_h, g);
3674 rb_raise (rb_eArgError, "%s: used handle after closing it", "hexdump");
3676 const char *path = StringValueCStr (pathv);
3678 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3683 r = guestfs_hexdump (g, path);
3685 rb_raise (e_Error, "%s", guestfs_last_error (g));
3687 VALUE rv = rb_str_new2 (r);
3692 static VALUE ruby_guestfs_zerofree (VALUE gv, VALUE devicev)
3695 Data_Get_Struct (gv, guestfs_h, g);
3697 rb_raise (rb_eArgError, "%s: used handle after closing it", "zerofree");
3699 const char *device = StringValueCStr (devicev);
3701 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3702 "device", "zerofree");
3706 r = guestfs_zerofree (g, device);
3708 rb_raise (e_Error, "%s", guestfs_last_error (g));
3713 static VALUE ruby_guestfs_pvresize (VALUE gv, VALUE devicev)
3716 Data_Get_Struct (gv, guestfs_h, g);
3718 rb_raise (rb_eArgError, "%s: used handle after closing it", "pvresize");
3720 const char *device = StringValueCStr (devicev);
3722 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3723 "device", "pvresize");
3727 r = guestfs_pvresize (g, device);
3729 rb_raise (e_Error, "%s", guestfs_last_error (g));
3734 static VALUE ruby_guestfs_sfdisk_N (VALUE gv, VALUE devicev, VALUE nv, VALUE cylsv, VALUE headsv, VALUE sectorsv, VALUE linev)
3737 Data_Get_Struct (gv, guestfs_h, g);
3739 rb_raise (rb_eArgError, "%s: used handle after closing it", "sfdisk_N");
3741 const char *device = StringValueCStr (devicev);
3743 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3744 "device", "sfdisk_N");
3745 int n = NUM2INT (nv);
3746 int cyls = NUM2INT (cylsv);
3747 int heads = NUM2INT (headsv);
3748 int sectors = NUM2INT (sectorsv);
3749 const char *line = StringValueCStr (linev);
3751 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3752 "line", "sfdisk_N");
3756 r = guestfs_sfdisk_N (g, device, n, cyls, heads, sectors, line);
3758 rb_raise (e_Error, "%s", guestfs_last_error (g));
3763 static VALUE ruby_guestfs_sfdisk_l (VALUE gv, VALUE devicev)
3766 Data_Get_Struct (gv, guestfs_h, g);
3768 rb_raise (rb_eArgError, "%s: used handle after closing it", "sfdisk_l");
3770 const char *device = StringValueCStr (devicev);
3772 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3773 "device", "sfdisk_l");
3777 r = guestfs_sfdisk_l (g, device);
3779 rb_raise (e_Error, "%s", guestfs_last_error (g));
3781 VALUE rv = rb_str_new2 (r);
3786 static VALUE ruby_guestfs_sfdisk_kernel_geometry (VALUE gv, VALUE devicev)
3789 Data_Get_Struct (gv, guestfs_h, g);
3791 rb_raise (rb_eArgError, "%s: used handle after closing it", "sfdisk_kernel_geometry");
3793 const char *device = StringValueCStr (devicev);
3795 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3796 "device", "sfdisk_kernel_geometry");
3800 r = guestfs_sfdisk_kernel_geometry (g, device);
3802 rb_raise (e_Error, "%s", guestfs_last_error (g));
3804 VALUE rv = rb_str_new2 (r);
3809 static VALUE ruby_guestfs_sfdisk_disk_geometry (VALUE gv, VALUE devicev)
3812 Data_Get_Struct (gv, guestfs_h, g);
3814 rb_raise (rb_eArgError, "%s: used handle after closing it", "sfdisk_disk_geometry");
3816 const char *device = StringValueCStr (devicev);
3818 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3819 "device", "sfdisk_disk_geometry");
3823 r = guestfs_sfdisk_disk_geometry (g, device);
3825 rb_raise (e_Error, "%s", guestfs_last_error (g));
3827 VALUE rv = rb_str_new2 (r);
3832 static VALUE ruby_guestfs_vg_activate_all (VALUE gv, VALUE activatev)
3835 Data_Get_Struct (gv, guestfs_h, g);
3837 rb_raise (rb_eArgError, "%s: used handle after closing it", "vg_activate_all");
3839 int activate = RTEST (activatev);
3843 r = guestfs_vg_activate_all (g, activate);
3845 rb_raise (e_Error, "%s", guestfs_last_error (g));
3850 static VALUE ruby_guestfs_vg_activate (VALUE gv, VALUE activatev, VALUE volgroupsv)
3853 Data_Get_Struct (gv, guestfs_h, g);
3855 rb_raise (rb_eArgError, "%s: used handle after closing it", "vg_activate");
3857 int activate = RTEST (activatev);
3861 len = RARRAY_LEN (volgroupsv);
3862 volgroups = guestfs_safe_malloc (g, sizeof (char *) * (len+1));
3863 for (i = 0; i < len; ++i) {
3864 VALUE v = rb_ary_entry (volgroupsv, i);
3865 volgroups[i] = StringValueCStr (v);
3867 volgroups[len] = NULL;
3872 r = guestfs_vg_activate (g, activate, volgroups);
3875 rb_raise (e_Error, "%s", guestfs_last_error (g));
3880 static VALUE ruby_guestfs_lvresize (VALUE gv, VALUE devicev, VALUE mbytesv)
3883 Data_Get_Struct (gv, guestfs_h, g);
3885 rb_raise (rb_eArgError, "%s: used handle after closing it", "lvresize");
3887 const char *device = StringValueCStr (devicev);
3889 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3890 "device", "lvresize");
3891 int mbytes = NUM2INT (mbytesv);
3895 r = guestfs_lvresize (g, device, mbytes);
3897 rb_raise (e_Error, "%s", guestfs_last_error (g));
3902 static VALUE ruby_guestfs_resize2fs (VALUE gv, VALUE devicev)
3905 Data_Get_Struct (gv, guestfs_h, g);
3907 rb_raise (rb_eArgError, "%s: used handle after closing it", "resize2fs");
3909 const char *device = StringValueCStr (devicev);
3911 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3912 "device", "resize2fs");
3916 r = guestfs_resize2fs (g, device);
3918 rb_raise (e_Error, "%s", guestfs_last_error (g));
3923 static VALUE ruby_guestfs_find (VALUE gv, VALUE directoryv)
3926 Data_Get_Struct (gv, guestfs_h, g);
3928 rb_raise (rb_eArgError, "%s: used handle after closing it", "find");
3930 const char *directory = StringValueCStr (directoryv);
3932 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3933 "directory", "find");
3937 r = guestfs_find (g, directory);
3939 rb_raise (e_Error, "%s", guestfs_last_error (g));
3942 for (i = 0; r[i] != NULL; ++i) len++;
3943 VALUE rv = rb_ary_new2 (len);
3944 for (i = 0; r[i] != NULL; ++i) {
3945 rb_ary_push (rv, rb_str_new2 (r[i]));
3952 static VALUE ruby_guestfs_e2fsck_f (VALUE gv, VALUE devicev)
3955 Data_Get_Struct (gv, guestfs_h, g);
3957 rb_raise (rb_eArgError, "%s: used handle after closing it", "e2fsck_f");
3959 const char *device = StringValueCStr (devicev);
3961 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3962 "device", "e2fsck_f");
3966 r = guestfs_e2fsck_f (g, device);
3968 rb_raise (e_Error, "%s", guestfs_last_error (g));
3973 static VALUE ruby_guestfs_sleep (VALUE gv, VALUE secsv)
3976 Data_Get_Struct (gv, guestfs_h, g);
3978 rb_raise (rb_eArgError, "%s: used handle after closing it", "sleep");
3980 int secs = NUM2INT (secsv);
3984 r = guestfs_sleep (g, secs);
3986 rb_raise (e_Error, "%s", guestfs_last_error (g));
3991 static VALUE ruby_guestfs_ntfs_3g_probe (VALUE gv, VALUE rwv, VALUE devicev)
3994 Data_Get_Struct (gv, guestfs_h, g);
3996 rb_raise (rb_eArgError, "%s: used handle after closing it", "ntfs_3g_probe");
3998 int rw = RTEST (rwv);
3999 const char *device = StringValueCStr (devicev);
4001 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
4002 "device", "ntfs_3g_probe");
4006 r = guestfs_ntfs_3g_probe (g, rw, device);
4008 rb_raise (e_Error, "%s", guestfs_last_error (g));
4013 static VALUE ruby_guestfs_sh (VALUE gv, VALUE commandv)
4016 Data_Get_Struct (gv, guestfs_h, g);
4018 rb_raise (rb_eArgError, "%s: used handle after closing it", "sh");
4020 const char *command = StringValueCStr (commandv);
4022 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
4027 r = guestfs_sh (g, command);
4029 rb_raise (e_Error, "%s", guestfs_last_error (g));
4031 VALUE rv = rb_str_new2 (r);
4036 static VALUE ruby_guestfs_sh_lines (VALUE gv, VALUE commandv)
4039 Data_Get_Struct (gv, guestfs_h, g);
4041 rb_raise (rb_eArgError, "%s: used handle after closing it", "sh_lines");
4043 const char *command = StringValueCStr (commandv);
4045 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
4046 "command", "sh_lines");
4050 r = guestfs_sh_lines (g, command);
4052 rb_raise (e_Error, "%s", guestfs_last_error (g));
4055 for (i = 0; r[i] != NULL; ++i) len++;
4056 VALUE rv = rb_ary_new2 (len);
4057 for (i = 0; r[i] != NULL; ++i) {
4058 rb_ary_push (rv, rb_str_new2 (r[i]));
4065 static VALUE ruby_guestfs_glob_expand (VALUE gv, VALUE patternv)
4068 Data_Get_Struct (gv, guestfs_h, g);
4070 rb_raise (rb_eArgError, "%s: used handle after closing it", "glob_expand");
4072 const char *pattern = StringValueCStr (patternv);
4074 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
4075 "pattern", "glob_expand");
4079 r = guestfs_glob_expand (g, pattern);
4081 rb_raise (e_Error, "%s", guestfs_last_error (g));
4084 for (i = 0; r[i] != NULL; ++i) len++;
4085 VALUE rv = rb_ary_new2 (len);
4086 for (i = 0; r[i] != NULL; ++i) {
4087 rb_ary_push (rv, rb_str_new2 (r[i]));
4094 /* Initialize the module. */
4095 void Init__guestfs ()
4097 m_guestfs = rb_define_module ("Guestfs");
4098 c_guestfs = rb_define_class_under (m_guestfs, "Guestfs", rb_cObject);
4099 e_Error = rb_define_class_under (m_guestfs, "Error", rb_eStandardError);
4101 rb_define_module_function (m_guestfs, "create", ruby_guestfs_create, 0);
4102 rb_define_method (c_guestfs, "close", ruby_guestfs_close, 0);
4104 rb_define_method (c_guestfs, "test0",
4105 ruby_guestfs_test0, 7);
4106 rb_define_method (c_guestfs, "test0rint",
4107 ruby_guestfs_test0rint, 1);
4108 rb_define_method (c_guestfs, "test0rinterr",
4109 ruby_guestfs_test0rinterr, 0);
4110 rb_define_method (c_guestfs, "test0rint64",
4111 ruby_guestfs_test0rint64, 1);
4112 rb_define_method (c_guestfs, "test0rint64err",
4113 ruby_guestfs_test0rint64err, 0);
4114 rb_define_method (c_guestfs, "test0rbool",
4115 ruby_guestfs_test0rbool, 1);
4116 rb_define_method (c_guestfs, "test0rboolerr",
4117 ruby_guestfs_test0rboolerr, 0);
4118 rb_define_method (c_guestfs, "test0rconststring",
4119 ruby_guestfs_test0rconststring, 1);
4120 rb_define_method (c_guestfs, "test0rconststringerr",
4121 ruby_guestfs_test0rconststringerr, 0);
4122 rb_define_method (c_guestfs, "test0rstring",
4123 ruby_guestfs_test0rstring, 1);
4124 rb_define_method (c_guestfs, "test0rstringerr",
4125 ruby_guestfs_test0rstringerr, 0);
4126 rb_define_method (c_guestfs, "test0rstringlist",
4127 ruby_guestfs_test0rstringlist, 1);
4128 rb_define_method (c_guestfs, "test0rstringlisterr",
4129 ruby_guestfs_test0rstringlisterr, 0);
4130 rb_define_method (c_guestfs, "test0rintbool",
4131 ruby_guestfs_test0rintbool, 1);
4132 rb_define_method (c_guestfs, "test0rintboolerr",
4133 ruby_guestfs_test0rintboolerr, 0);
4134 rb_define_method (c_guestfs, "test0rpvlist",
4135 ruby_guestfs_test0rpvlist, 1);
4136 rb_define_method (c_guestfs, "test0rpvlisterr",
4137 ruby_guestfs_test0rpvlisterr, 0);
4138 rb_define_method (c_guestfs, "test0rvglist",
4139 ruby_guestfs_test0rvglist, 1);
4140 rb_define_method (c_guestfs, "test0rvglisterr",
4141 ruby_guestfs_test0rvglisterr, 0);
4142 rb_define_method (c_guestfs, "test0rlvlist",
4143 ruby_guestfs_test0rlvlist, 1);
4144 rb_define_method (c_guestfs, "test0rlvlisterr",
4145 ruby_guestfs_test0rlvlisterr, 0);
4146 rb_define_method (c_guestfs, "test0rstat",
4147 ruby_guestfs_test0rstat, 1);
4148 rb_define_method (c_guestfs, "test0rstaterr",
4149 ruby_guestfs_test0rstaterr, 0);
4150 rb_define_method (c_guestfs, "test0rstatvfs",
4151 ruby_guestfs_test0rstatvfs, 1);
4152 rb_define_method (c_guestfs, "test0rstatvfserr",
4153 ruby_guestfs_test0rstatvfserr, 0);
4154 rb_define_method (c_guestfs, "test0rhashtable",
4155 ruby_guestfs_test0rhashtable, 1);
4156 rb_define_method (c_guestfs, "test0rhashtableerr",
4157 ruby_guestfs_test0rhashtableerr, 0);
4158 rb_define_method (c_guestfs, "launch",
4159 ruby_guestfs_launch, 0);
4160 rb_define_method (c_guestfs, "wait_ready",
4161 ruby_guestfs_wait_ready, 0);
4162 rb_define_method (c_guestfs, "kill_subprocess",
4163 ruby_guestfs_kill_subprocess, 0);
4164 rb_define_method (c_guestfs, "add_drive",
4165 ruby_guestfs_add_drive, 1);
4166 rb_define_method (c_guestfs, "add_cdrom",
4167 ruby_guestfs_add_cdrom, 1);
4168 rb_define_method (c_guestfs, "add_drive_ro",
4169 ruby_guestfs_add_drive_ro, 1);
4170 rb_define_method (c_guestfs, "config",
4171 ruby_guestfs_config, 2);
4172 rb_define_method (c_guestfs, "set_qemu",
4173 ruby_guestfs_set_qemu, 1);
4174 rb_define_method (c_guestfs, "get_qemu",
4175 ruby_guestfs_get_qemu, 0);
4176 rb_define_method (c_guestfs, "set_path",
4177 ruby_guestfs_set_path, 1);
4178 rb_define_method (c_guestfs, "get_path",
4179 ruby_guestfs_get_path, 0);
4180 rb_define_method (c_guestfs, "set_append",
4181 ruby_guestfs_set_append, 1);
4182 rb_define_method (c_guestfs, "get_append",
4183 ruby_guestfs_get_append, 0);
4184 rb_define_method (c_guestfs, "set_autosync",
4185 ruby_guestfs_set_autosync, 1);
4186 rb_define_method (c_guestfs, "get_autosync",
4187 ruby_guestfs_get_autosync, 0);
4188 rb_define_method (c_guestfs, "set_verbose",
4189 ruby_guestfs_set_verbose, 1);
4190 rb_define_method (c_guestfs, "get_verbose",
4191 ruby_guestfs_get_verbose, 0);
4192 rb_define_method (c_guestfs, "is_ready",
4193 ruby_guestfs_is_ready, 0);
4194 rb_define_method (c_guestfs, "is_config",
4195 ruby_guestfs_is_config, 0);
4196 rb_define_method (c_guestfs, "is_launching",
4197 ruby_guestfs_is_launching, 0);
4198 rb_define_method (c_guestfs, "is_busy",
4199 ruby_guestfs_is_busy, 0);
4200 rb_define_method (c_guestfs, "get_state",
4201 ruby_guestfs_get_state, 0);
4202 rb_define_method (c_guestfs, "set_busy",
4203 ruby_guestfs_set_busy, 0);
4204 rb_define_method (c_guestfs, "set_ready",
4205 ruby_guestfs_set_ready, 0);
4206 rb_define_method (c_guestfs, "end_busy",
4207 ruby_guestfs_end_busy, 0);
4208 rb_define_method (c_guestfs, "mount",
4209 ruby_guestfs_mount, 2);
4210 rb_define_method (c_guestfs, "sync",
4211 ruby_guestfs_sync, 0);
4212 rb_define_method (c_guestfs, "touch",
4213 ruby_guestfs_touch, 1);
4214 rb_define_method (c_guestfs, "cat",
4215 ruby_guestfs_cat, 1);
4216 rb_define_method (c_guestfs, "ll",
4217 ruby_guestfs_ll, 1);
4218 rb_define_method (c_guestfs, "ls",
4219 ruby_guestfs_ls, 1);
4220 rb_define_method (c_guestfs, "list_devices",
4221 ruby_guestfs_list_devices, 0);
4222 rb_define_method (c_guestfs, "list_partitions",
4223 ruby_guestfs_list_partitions, 0);
4224 rb_define_method (c_guestfs, "pvs",
4225 ruby_guestfs_pvs, 0);
4226 rb_define_method (c_guestfs, "vgs",
4227 ruby_guestfs_vgs, 0);
4228 rb_define_method (c_guestfs, "lvs",
4229 ruby_guestfs_lvs, 0);
4230 rb_define_method (c_guestfs, "pvs_full",
4231 ruby_guestfs_pvs_full, 0);
4232 rb_define_method (c_guestfs, "vgs_full",
4233 ruby_guestfs_vgs_full, 0);
4234 rb_define_method (c_guestfs, "lvs_full",
4235 ruby_guestfs_lvs_full, 0);
4236 rb_define_method (c_guestfs, "read_lines",
4237 ruby_guestfs_read_lines, 1);
4238 rb_define_method (c_guestfs, "aug_init",
4239 ruby_guestfs_aug_init, 2);
4240 rb_define_method (c_guestfs, "aug_close",
4241 ruby_guestfs_aug_close, 0);
4242 rb_define_method (c_guestfs, "aug_defvar",
4243 ruby_guestfs_aug_defvar, 2);
4244 rb_define_method (c_guestfs, "aug_defnode",
4245 ruby_guestfs_aug_defnode, 3);
4246 rb_define_method (c_guestfs, "aug_get",
4247 ruby_guestfs_aug_get, 1);
4248 rb_define_method (c_guestfs, "aug_set",
4249 ruby_guestfs_aug_set, 2);
4250 rb_define_method (c_guestfs, "aug_insert",
4251 ruby_guestfs_aug_insert, 3);
4252 rb_define_method (c_guestfs, "aug_rm",
4253 ruby_guestfs_aug_rm, 1);
4254 rb_define_method (c_guestfs, "aug_mv",
4255 ruby_guestfs_aug_mv, 2);
4256 rb_define_method (c_guestfs, "aug_match",
4257 ruby_guestfs_aug_match, 1);
4258 rb_define_method (c_guestfs, "aug_save",
4259 ruby_guestfs_aug_save, 0);
4260 rb_define_method (c_guestfs, "aug_load",
4261 ruby_guestfs_aug_load, 0);
4262 rb_define_method (c_guestfs, "aug_ls",
4263 ruby_guestfs_aug_ls, 1);
4264 rb_define_method (c_guestfs, "rm",
4265 ruby_guestfs_rm, 1);
4266 rb_define_method (c_guestfs, "rmdir",
4267 ruby_guestfs_rmdir, 1);
4268 rb_define_method (c_guestfs, "rm_rf",
4269 ruby_guestfs_rm_rf, 1);
4270 rb_define_method (c_guestfs, "mkdir",
4271 ruby_guestfs_mkdir, 1);
4272 rb_define_method (c_guestfs, "mkdir_p",
4273 ruby_guestfs_mkdir_p, 1);
4274 rb_define_method (c_guestfs, "chmod",
4275 ruby_guestfs_chmod, 2);
4276 rb_define_method (c_guestfs, "chown",
4277 ruby_guestfs_chown, 3);
4278 rb_define_method (c_guestfs, "exists",
4279 ruby_guestfs_exists, 1);
4280 rb_define_method (c_guestfs, "is_file",
4281 ruby_guestfs_is_file, 1);
4282 rb_define_method (c_guestfs, "is_dir",
4283 ruby_guestfs_is_dir, 1);
4284 rb_define_method (c_guestfs, "pvcreate",
4285 ruby_guestfs_pvcreate, 1);
4286 rb_define_method (c_guestfs, "vgcreate",
4287 ruby_guestfs_vgcreate, 2);
4288 rb_define_method (c_guestfs, "lvcreate",
4289 ruby_guestfs_lvcreate, 3);
4290 rb_define_method (c_guestfs, "mkfs",
4291 ruby_guestfs_mkfs, 2);
4292 rb_define_method (c_guestfs, "sfdisk",
4293 ruby_guestfs_sfdisk, 5);
4294 rb_define_method (c_guestfs, "write_file",
4295 ruby_guestfs_write_file, 3);
4296 rb_define_method (c_guestfs, "umount",
4297 ruby_guestfs_umount, 1);
4298 rb_define_method (c_guestfs, "mounts",
4299 ruby_guestfs_mounts, 0);
4300 rb_define_method (c_guestfs, "umount_all",
4301 ruby_guestfs_umount_all, 0);
4302 rb_define_method (c_guestfs, "lvm_remove_all",
4303 ruby_guestfs_lvm_remove_all, 0);
4304 rb_define_method (c_guestfs, "file",
4305 ruby_guestfs_file, 1);
4306 rb_define_method (c_guestfs, "command",
4307 ruby_guestfs_command, 1);
4308 rb_define_method (c_guestfs, "command_lines",
4309 ruby_guestfs_command_lines, 1);
4310 rb_define_method (c_guestfs, "stat",
4311 ruby_guestfs_stat, 1);
4312 rb_define_method (c_guestfs, "lstat",
4313 ruby_guestfs_lstat, 1);
4314 rb_define_method (c_guestfs, "statvfs",
4315 ruby_guestfs_statvfs, 1);
4316 rb_define_method (c_guestfs, "tune2fs_l",
4317 ruby_guestfs_tune2fs_l, 1);
4318 rb_define_method (c_guestfs, "blockdev_setro",
4319 ruby_guestfs_blockdev_setro, 1);
4320 rb_define_method (c_guestfs, "blockdev_setrw",
4321 ruby_guestfs_blockdev_setrw, 1);
4322 rb_define_method (c_guestfs, "blockdev_getro",
4323 ruby_guestfs_blockdev_getro, 1);
4324 rb_define_method (c_guestfs, "blockdev_getss",
4325 ruby_guestfs_blockdev_getss, 1);
4326 rb_define_method (c_guestfs, "blockdev_getbsz",
4327 ruby_guestfs_blockdev_getbsz, 1);
4328 rb_define_method (c_guestfs, "blockdev_setbsz",
4329 ruby_guestfs_blockdev_setbsz, 2);
4330 rb_define_method (c_guestfs, "blockdev_getsz",
4331 ruby_guestfs_blockdev_getsz, 1);
4332 rb_define_method (c_guestfs, "blockdev_getsize64",
4333 ruby_guestfs_blockdev_getsize64, 1);
4334 rb_define_method (c_guestfs, "blockdev_flushbufs",
4335 ruby_guestfs_blockdev_flushbufs, 1);
4336 rb_define_method (c_guestfs, "blockdev_rereadpt",
4337 ruby_guestfs_blockdev_rereadpt, 1);
4338 rb_define_method (c_guestfs, "upload",
4339 ruby_guestfs_upload, 2);
4340 rb_define_method (c_guestfs, "download",
4341 ruby_guestfs_download, 2);
4342 rb_define_method (c_guestfs, "checksum",
4343 ruby_guestfs_checksum, 2);
4344 rb_define_method (c_guestfs, "tar_in",
4345 ruby_guestfs_tar_in, 2);
4346 rb_define_method (c_guestfs, "tar_out",
4347 ruby_guestfs_tar_out, 2);
4348 rb_define_method (c_guestfs, "tgz_in",
4349 ruby_guestfs_tgz_in, 2);
4350 rb_define_method (c_guestfs, "tgz_out",
4351 ruby_guestfs_tgz_out, 2);
4352 rb_define_method (c_guestfs, "mount_ro",
4353 ruby_guestfs_mount_ro, 2);
4354 rb_define_method (c_guestfs, "mount_options",
4355 ruby_guestfs_mount_options, 3);
4356 rb_define_method (c_guestfs, "mount_vfs",
4357 ruby_guestfs_mount_vfs, 4);
4358 rb_define_method (c_guestfs, "debug",
4359 ruby_guestfs_debug, 2);
4360 rb_define_method (c_guestfs, "lvremove",
4361 ruby_guestfs_lvremove, 1);
4362 rb_define_method (c_guestfs, "vgremove",
4363 ruby_guestfs_vgremove, 1);
4364 rb_define_method (c_guestfs, "pvremove",
4365 ruby_guestfs_pvremove, 1);
4366 rb_define_method (c_guestfs, "set_e2label",
4367 ruby_guestfs_set_e2label, 2);
4368 rb_define_method (c_guestfs, "get_e2label",
4369 ruby_guestfs_get_e2label, 1);
4370 rb_define_method (c_guestfs, "set_e2uuid",
4371 ruby_guestfs_set_e2uuid, 2);
4372 rb_define_method (c_guestfs, "get_e2uuid",
4373 ruby_guestfs_get_e2uuid, 1);
4374 rb_define_method (c_guestfs, "fsck",
4375 ruby_guestfs_fsck, 2);
4376 rb_define_method (c_guestfs, "zero",
4377 ruby_guestfs_zero, 1);
4378 rb_define_method (c_guestfs, "grub_install",
4379 ruby_guestfs_grub_install, 2);
4380 rb_define_method (c_guestfs, "cp",
4381 ruby_guestfs_cp, 2);
4382 rb_define_method (c_guestfs, "cp_a",
4383 ruby_guestfs_cp_a, 2);
4384 rb_define_method (c_guestfs, "mv",
4385 ruby_guestfs_mv, 2);
4386 rb_define_method (c_guestfs, "drop_caches",
4387 ruby_guestfs_drop_caches, 1);
4388 rb_define_method (c_guestfs, "dmesg",
4389 ruby_guestfs_dmesg, 0);
4390 rb_define_method (c_guestfs, "ping_daemon",
4391 ruby_guestfs_ping_daemon, 0);
4392 rb_define_method (c_guestfs, "equal",
4393 ruby_guestfs_equal, 2);
4394 rb_define_method (c_guestfs, "strings",
4395 ruby_guestfs_strings, 1);
4396 rb_define_method (c_guestfs, "strings_e",
4397 ruby_guestfs_strings_e, 2);
4398 rb_define_method (c_guestfs, "hexdump",
4399 ruby_guestfs_hexdump, 1);
4400 rb_define_method (c_guestfs, "zerofree",
4401 ruby_guestfs_zerofree, 1);
4402 rb_define_method (c_guestfs, "pvresize",
4403 ruby_guestfs_pvresize, 1);
4404 rb_define_method (c_guestfs, "sfdisk_N",
4405 ruby_guestfs_sfdisk_N, 6);
4406 rb_define_method (c_guestfs, "sfdisk_l",
4407 ruby_guestfs_sfdisk_l, 1);
4408 rb_define_method (c_guestfs, "sfdisk_kernel_geometry",
4409 ruby_guestfs_sfdisk_kernel_geometry, 1);
4410 rb_define_method (c_guestfs, "sfdisk_disk_geometry",
4411 ruby_guestfs_sfdisk_disk_geometry, 1);
4412 rb_define_method (c_guestfs, "vg_activate_all",
4413 ruby_guestfs_vg_activate_all, 1);
4414 rb_define_method (c_guestfs, "vg_activate",
4415 ruby_guestfs_vg_activate, 2);
4416 rb_define_method (c_guestfs, "lvresize",
4417 ruby_guestfs_lvresize, 2);
4418 rb_define_method (c_guestfs, "resize2fs",
4419 ruby_guestfs_resize2fs, 1);
4420 rb_define_method (c_guestfs, "find",
4421 ruby_guestfs_find, 1);
4422 rb_define_method (c_guestfs, "e2fsck_f",
4423 ruby_guestfs_e2fsck_f, 1);
4424 rb_define_method (c_guestfs, "sleep",
4425 ruby_guestfs_sleep, 1);
4426 rb_define_method (c_guestfs, "ntfs_3g_probe",
4427 ruby_guestfs_ntfs_3g_probe, 2);
4428 rb_define_method (c_guestfs, "sh",
4429 ruby_guestfs_sh, 1);
4430 rb_define_method (c_guestfs, "sh_lines",
4431 ruby_guestfs_sh_lines, 1);
4432 rb_define_method (c_guestfs, "glob_expand",
4433 ruby_guestfs_glob_expand, 1);