Generated code for mknod, mkfifo, mknod_b, mknod_c, umask.
[libguestfs.git] / ruby / ext / guestfs / _guestfs.c
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.
4  *
5  * Copyright (C) 2009 Red Hat Inc.
6  *
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.
11  *
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.
16  *
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
20  */
21
22 #include <stdio.h>
23 #include <stdlib.h>
24
25 #include <ruby.h>
26
27 #include "guestfs.h"
28
29 #include "extconf.h"
30
31 /* For Ruby < 1.9 */
32 #ifndef RARRAY_LEN
33 #define RARRAY_LEN(r) (RARRAY((r))->len)
34 #endif
35
36 static VALUE m_guestfs;                 /* guestfs module */
37 static VALUE c_guestfs;                 /* guestfs_h handle */
38 static VALUE e_Error;                   /* used for all errors */
39
40 static void ruby_guestfs_free (void *p)
41 {
42   if (!p) return;
43   guestfs_close ((guestfs_h *) p);
44 }
45
46 static VALUE ruby_guestfs_create (VALUE m)
47 {
48   guestfs_h *g;
49
50   g = guestfs_create ();
51   if (!g)
52     rb_raise (e_Error, "failed to create guestfs handle");
53
54   /* Don't print error messages to stderr by default. */
55   guestfs_set_error_handler (g, NULL, NULL);
56
57   /* Wrap it, and make sure the close function is called when the
58    * handle goes away.
59    */
60   return Data_Wrap_Struct (c_guestfs, NULL, ruby_guestfs_free, g);
61 }
62
63 static VALUE ruby_guestfs_close (VALUE gv)
64 {
65   guestfs_h *g;
66   Data_Get_Struct (gv, guestfs_h, g);
67
68   ruby_guestfs_free (g);
69   DATA_PTR (gv) = NULL;
70
71   return Qnil;
72 }
73
74 static VALUE ruby_guestfs_test0 (VALUE gv, VALUE strv, VALUE optstrv, VALUE strlistv, VALUE bv, VALUE integerv, VALUE fileinv, VALUE fileoutv)
75 {
76   guestfs_h *g;
77   Data_Get_Struct (gv, guestfs_h, g);
78   if (!g)
79     rb_raise (rb_eArgError, "%s: used handle after closing it", "test0");
80
81   Check_Type (strv, T_STRING);
82   const char *str = StringValueCStr (strv);
83   if (!str)
84     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
85               "str", "test0");
86   const char *optstr = !NIL_P (optstrv) ? StringValueCStr (optstrv) : NULL;
87   char **strlist;
88   Check_Type (strlistv, T_ARRAY);
89   {
90     int i, len;
91     len = RARRAY_LEN (strlistv);
92     strlist = guestfs_safe_malloc (g, sizeof (char *) * (len+1));
93     for (i = 0; i < len; ++i) {
94       VALUE v = rb_ary_entry (strlistv, i);
95       strlist[i] = StringValueCStr (v);
96     }
97     strlist[len] = NULL;
98   }
99   int b = RTEST (bv);
100   int integer = NUM2INT (integerv);
101   Check_Type (fileinv, T_STRING);
102   const char *filein = StringValueCStr (fileinv);
103   if (!filein)
104     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
105               "filein", "test0");
106   Check_Type (fileoutv, T_STRING);
107   const char *fileout = StringValueCStr (fileoutv);
108   if (!fileout)
109     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
110               "fileout", "test0");
111
112   int r;
113
114   r = guestfs_test0 (g, str, optstr, strlist, b, integer, filein, fileout);
115   free (strlist);
116   if (r == -1)
117     rb_raise (e_Error, "%s", guestfs_last_error (g));
118
119   return Qnil;
120 }
121
122 static VALUE ruby_guestfs_test0rint (VALUE gv, VALUE valv)
123 {
124   guestfs_h *g;
125   Data_Get_Struct (gv, guestfs_h, g);
126   if (!g)
127     rb_raise (rb_eArgError, "%s: used handle after closing it", "test0rint");
128
129   Check_Type (valv, T_STRING);
130   const char *val = StringValueCStr (valv);
131   if (!val)
132     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
133               "val", "test0rint");
134
135   int r;
136
137   r = guestfs_test0rint (g, val);
138   if (r == -1)
139     rb_raise (e_Error, "%s", guestfs_last_error (g));
140
141   return INT2NUM (r);
142 }
143
144 static VALUE ruby_guestfs_test0rinterr (VALUE gv)
145 {
146   guestfs_h *g;
147   Data_Get_Struct (gv, guestfs_h, g);
148   if (!g)
149     rb_raise (rb_eArgError, "%s: used handle after closing it", "test0rinterr");
150
151
152   int r;
153
154   r = guestfs_test0rinterr (g);
155   if (r == -1)
156     rb_raise (e_Error, "%s", guestfs_last_error (g));
157
158   return INT2NUM (r);
159 }
160
161 static VALUE ruby_guestfs_test0rint64 (VALUE gv, VALUE valv)
162 {
163   guestfs_h *g;
164   Data_Get_Struct (gv, guestfs_h, g);
165   if (!g)
166     rb_raise (rb_eArgError, "%s: used handle after closing it", "test0rint64");
167
168   Check_Type (valv, T_STRING);
169   const char *val = StringValueCStr (valv);
170   if (!val)
171     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
172               "val", "test0rint64");
173
174   int64_t r;
175
176   r = guestfs_test0rint64 (g, val);
177   if (r == -1)
178     rb_raise (e_Error, "%s", guestfs_last_error (g));
179
180   return ULL2NUM (r);
181 }
182
183 static VALUE ruby_guestfs_test0rint64err (VALUE gv)
184 {
185   guestfs_h *g;
186   Data_Get_Struct (gv, guestfs_h, g);
187   if (!g)
188     rb_raise (rb_eArgError, "%s: used handle after closing it", "test0rint64err");
189
190
191   int64_t r;
192
193   r = guestfs_test0rint64err (g);
194   if (r == -1)
195     rb_raise (e_Error, "%s", guestfs_last_error (g));
196
197   return ULL2NUM (r);
198 }
199
200 static VALUE ruby_guestfs_test0rbool (VALUE gv, VALUE valv)
201 {
202   guestfs_h *g;
203   Data_Get_Struct (gv, guestfs_h, g);
204   if (!g)
205     rb_raise (rb_eArgError, "%s: used handle after closing it", "test0rbool");
206
207   Check_Type (valv, T_STRING);
208   const char *val = StringValueCStr (valv);
209   if (!val)
210     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
211               "val", "test0rbool");
212
213   int r;
214
215   r = guestfs_test0rbool (g, val);
216   if (r == -1)
217     rb_raise (e_Error, "%s", guestfs_last_error (g));
218
219   return INT2NUM (r);
220 }
221
222 static VALUE ruby_guestfs_test0rboolerr (VALUE gv)
223 {
224   guestfs_h *g;
225   Data_Get_Struct (gv, guestfs_h, g);
226   if (!g)
227     rb_raise (rb_eArgError, "%s: used handle after closing it", "test0rboolerr");
228
229
230   int r;
231
232   r = guestfs_test0rboolerr (g);
233   if (r == -1)
234     rb_raise (e_Error, "%s", guestfs_last_error (g));
235
236   return INT2NUM (r);
237 }
238
239 static VALUE ruby_guestfs_test0rconststring (VALUE gv, VALUE valv)
240 {
241   guestfs_h *g;
242   Data_Get_Struct (gv, guestfs_h, g);
243   if (!g)
244     rb_raise (rb_eArgError, "%s: used handle after closing it", "test0rconststring");
245
246   Check_Type (valv, T_STRING);
247   const char *val = StringValueCStr (valv);
248   if (!val)
249     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
250               "val", "test0rconststring");
251
252   const char *r;
253
254   r = guestfs_test0rconststring (g, val);
255   if (r == NULL)
256     rb_raise (e_Error, "%s", guestfs_last_error (g));
257
258   return rb_str_new2 (r);
259 }
260
261 static VALUE ruby_guestfs_test0rconststringerr (VALUE gv)
262 {
263   guestfs_h *g;
264   Data_Get_Struct (gv, guestfs_h, g);
265   if (!g)
266     rb_raise (rb_eArgError, "%s: used handle after closing it", "test0rconststringerr");
267
268
269   const char *r;
270
271   r = guestfs_test0rconststringerr (g);
272   if (r == NULL)
273     rb_raise (e_Error, "%s", guestfs_last_error (g));
274
275   return rb_str_new2 (r);
276 }
277
278 static VALUE ruby_guestfs_test0rstring (VALUE gv, VALUE valv)
279 {
280   guestfs_h *g;
281   Data_Get_Struct (gv, guestfs_h, g);
282   if (!g)
283     rb_raise (rb_eArgError, "%s: used handle after closing it", "test0rstring");
284
285   Check_Type (valv, T_STRING);
286   const char *val = StringValueCStr (valv);
287   if (!val)
288     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
289               "val", "test0rstring");
290
291   char *r;
292
293   r = guestfs_test0rstring (g, val);
294   if (r == NULL)
295     rb_raise (e_Error, "%s", guestfs_last_error (g));
296
297   VALUE rv = rb_str_new2 (r);
298   free (r);
299   return rv;
300 }
301
302 static VALUE ruby_guestfs_test0rstringerr (VALUE gv)
303 {
304   guestfs_h *g;
305   Data_Get_Struct (gv, guestfs_h, g);
306   if (!g)
307     rb_raise (rb_eArgError, "%s: used handle after closing it", "test0rstringerr");
308
309
310   char *r;
311
312   r = guestfs_test0rstringerr (g);
313   if (r == NULL)
314     rb_raise (e_Error, "%s", guestfs_last_error (g));
315
316   VALUE rv = rb_str_new2 (r);
317   free (r);
318   return rv;
319 }
320
321 static VALUE ruby_guestfs_test0rstringlist (VALUE gv, VALUE valv)
322 {
323   guestfs_h *g;
324   Data_Get_Struct (gv, guestfs_h, g);
325   if (!g)
326     rb_raise (rb_eArgError, "%s: used handle after closing it", "test0rstringlist");
327
328   Check_Type (valv, T_STRING);
329   const char *val = StringValueCStr (valv);
330   if (!val)
331     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
332               "val", "test0rstringlist");
333
334   char **r;
335
336   r = guestfs_test0rstringlist (g, val);
337   if (r == NULL)
338     rb_raise (e_Error, "%s", guestfs_last_error (g));
339
340   int i, len = 0;
341   for (i = 0; r[i] != NULL; ++i) len++;
342   VALUE rv = rb_ary_new2 (len);
343   for (i = 0; r[i] != NULL; ++i) {
344     rb_ary_push (rv, rb_str_new2 (r[i]));
345     free (r[i]);
346   }
347   free (r);
348   return rv;
349 }
350
351 static VALUE ruby_guestfs_test0rstringlisterr (VALUE gv)
352 {
353   guestfs_h *g;
354   Data_Get_Struct (gv, guestfs_h, g);
355   if (!g)
356     rb_raise (rb_eArgError, "%s: used handle after closing it", "test0rstringlisterr");
357
358
359   char **r;
360
361   r = guestfs_test0rstringlisterr (g);
362   if (r == NULL)
363     rb_raise (e_Error, "%s", guestfs_last_error (g));
364
365   int i, len = 0;
366   for (i = 0; r[i] != NULL; ++i) len++;
367   VALUE rv = rb_ary_new2 (len);
368   for (i = 0; r[i] != NULL; ++i) {
369     rb_ary_push (rv, rb_str_new2 (r[i]));
370     free (r[i]);
371   }
372   free (r);
373   return rv;
374 }
375
376 static VALUE ruby_guestfs_test0rintbool (VALUE gv, VALUE valv)
377 {
378   guestfs_h *g;
379   Data_Get_Struct (gv, guestfs_h, g);
380   if (!g)
381     rb_raise (rb_eArgError, "%s: used handle after closing it", "test0rintbool");
382
383   Check_Type (valv, T_STRING);
384   const char *val = StringValueCStr (valv);
385   if (!val)
386     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
387               "val", "test0rintbool");
388
389   struct guestfs_int_bool *r;
390
391   r = guestfs_test0rintbool (g, val);
392   if (r == NULL)
393     rb_raise (e_Error, "%s", guestfs_last_error (g));
394
395   VALUE rv = rb_ary_new2 (2);
396   rb_ary_push (rv, INT2NUM (r->i));
397   rb_ary_push (rv, INT2NUM (r->b));
398   guestfs_free_int_bool (r);
399   return rv;
400 }
401
402 static VALUE ruby_guestfs_test0rintboolerr (VALUE gv)
403 {
404   guestfs_h *g;
405   Data_Get_Struct (gv, guestfs_h, g);
406   if (!g)
407     rb_raise (rb_eArgError, "%s: used handle after closing it", "test0rintboolerr");
408
409
410   struct guestfs_int_bool *r;
411
412   r = guestfs_test0rintboolerr (g);
413   if (r == NULL)
414     rb_raise (e_Error, "%s", guestfs_last_error (g));
415
416   VALUE rv = rb_ary_new2 (2);
417   rb_ary_push (rv, INT2NUM (r->i));
418   rb_ary_push (rv, INT2NUM (r->b));
419   guestfs_free_int_bool (r);
420   return rv;
421 }
422
423 static VALUE ruby_guestfs_test0rpvlist (VALUE gv, VALUE valv)
424 {
425   guestfs_h *g;
426   Data_Get_Struct (gv, guestfs_h, g);
427   if (!g)
428     rb_raise (rb_eArgError, "%s: used handle after closing it", "test0rpvlist");
429
430   Check_Type (valv, T_STRING);
431   const char *val = StringValueCStr (valv);
432   if (!val)
433     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
434               "val", "test0rpvlist");
435
436   struct guestfs_lvm_pv_list *r;
437
438   r = guestfs_test0rpvlist (g, val);
439   if (r == NULL)
440     rb_raise (e_Error, "%s", guestfs_last_error (g));
441
442   VALUE rv = rb_ary_new2 (r->len);
443   int i;
444   for (i = 0; i < r->len; ++i) {
445     VALUE hv = rb_hash_new ();
446     rb_hash_aset (rv, rb_str_new2 ("pv_name"), rb_str_new2 (r->val[i].pv_name));
447     rb_hash_aset (rv, rb_str_new2 ("pv_uuid"), rb_str_new (r->val[i].pv_uuid, 32));
448     rb_hash_aset (rv, rb_str_new2 ("pv_fmt"), rb_str_new2 (r->val[i].pv_fmt));
449     rb_hash_aset (rv, rb_str_new2 ("pv_size"), ULL2NUM (r->val[i].pv_size));
450     rb_hash_aset (rv, rb_str_new2 ("dev_size"), ULL2NUM (r->val[i].dev_size));
451     rb_hash_aset (rv, rb_str_new2 ("pv_free"), ULL2NUM (r->val[i].pv_free));
452     rb_hash_aset (rv, rb_str_new2 ("pv_used"), ULL2NUM (r->val[i].pv_used));
453     rb_hash_aset (rv, rb_str_new2 ("pv_attr"), rb_str_new2 (r->val[i].pv_attr));
454     rb_hash_aset (rv, rb_str_new2 ("pv_pe_count"), ULL2NUM (r->val[i].pv_pe_count));
455     rb_hash_aset (rv, rb_str_new2 ("pv_pe_alloc_count"), ULL2NUM (r->val[i].pv_pe_alloc_count));
456     rb_hash_aset (rv, rb_str_new2 ("pv_tags"), rb_str_new2 (r->val[i].pv_tags));
457     rb_hash_aset (rv, rb_str_new2 ("pe_start"), ULL2NUM (r->val[i].pe_start));
458     rb_hash_aset (rv, rb_str_new2 ("pv_mda_count"), ULL2NUM (r->val[i].pv_mda_count));
459     rb_hash_aset (rv, rb_str_new2 ("pv_mda_free"), ULL2NUM (r->val[i].pv_mda_free));
460     rb_ary_push (rv, hv);
461   }
462   guestfs_free_lvm_pv_list (r);
463   return rv;
464 }
465
466 static VALUE ruby_guestfs_test0rpvlisterr (VALUE gv)
467 {
468   guestfs_h *g;
469   Data_Get_Struct (gv, guestfs_h, g);
470   if (!g)
471     rb_raise (rb_eArgError, "%s: used handle after closing it", "test0rpvlisterr");
472
473
474   struct guestfs_lvm_pv_list *r;
475
476   r = guestfs_test0rpvlisterr (g);
477   if (r == NULL)
478     rb_raise (e_Error, "%s", guestfs_last_error (g));
479
480   VALUE rv = rb_ary_new2 (r->len);
481   int i;
482   for (i = 0; i < r->len; ++i) {
483     VALUE hv = rb_hash_new ();
484     rb_hash_aset (rv, rb_str_new2 ("pv_name"), rb_str_new2 (r->val[i].pv_name));
485     rb_hash_aset (rv, rb_str_new2 ("pv_uuid"), rb_str_new (r->val[i].pv_uuid, 32));
486     rb_hash_aset (rv, rb_str_new2 ("pv_fmt"), rb_str_new2 (r->val[i].pv_fmt));
487     rb_hash_aset (rv, rb_str_new2 ("pv_size"), ULL2NUM (r->val[i].pv_size));
488     rb_hash_aset (rv, rb_str_new2 ("dev_size"), ULL2NUM (r->val[i].dev_size));
489     rb_hash_aset (rv, rb_str_new2 ("pv_free"), ULL2NUM (r->val[i].pv_free));
490     rb_hash_aset (rv, rb_str_new2 ("pv_used"), ULL2NUM (r->val[i].pv_used));
491     rb_hash_aset (rv, rb_str_new2 ("pv_attr"), rb_str_new2 (r->val[i].pv_attr));
492     rb_hash_aset (rv, rb_str_new2 ("pv_pe_count"), ULL2NUM (r->val[i].pv_pe_count));
493     rb_hash_aset (rv, rb_str_new2 ("pv_pe_alloc_count"), ULL2NUM (r->val[i].pv_pe_alloc_count));
494     rb_hash_aset (rv, rb_str_new2 ("pv_tags"), rb_str_new2 (r->val[i].pv_tags));
495     rb_hash_aset (rv, rb_str_new2 ("pe_start"), ULL2NUM (r->val[i].pe_start));
496     rb_hash_aset (rv, rb_str_new2 ("pv_mda_count"), ULL2NUM (r->val[i].pv_mda_count));
497     rb_hash_aset (rv, rb_str_new2 ("pv_mda_free"), ULL2NUM (r->val[i].pv_mda_free));
498     rb_ary_push (rv, hv);
499   }
500   guestfs_free_lvm_pv_list (r);
501   return rv;
502 }
503
504 static VALUE ruby_guestfs_test0rvglist (VALUE gv, VALUE valv)
505 {
506   guestfs_h *g;
507   Data_Get_Struct (gv, guestfs_h, g);
508   if (!g)
509     rb_raise (rb_eArgError, "%s: used handle after closing it", "test0rvglist");
510
511   Check_Type (valv, T_STRING);
512   const char *val = StringValueCStr (valv);
513   if (!val)
514     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
515               "val", "test0rvglist");
516
517   struct guestfs_lvm_vg_list *r;
518
519   r = guestfs_test0rvglist (g, val);
520   if (r == NULL)
521     rb_raise (e_Error, "%s", guestfs_last_error (g));
522
523   VALUE rv = rb_ary_new2 (r->len);
524   int i;
525   for (i = 0; i < r->len; ++i) {
526     VALUE hv = rb_hash_new ();
527     rb_hash_aset (rv, rb_str_new2 ("vg_name"), rb_str_new2 (r->val[i].vg_name));
528     rb_hash_aset (rv, rb_str_new2 ("vg_uuid"), rb_str_new (r->val[i].vg_uuid, 32));
529     rb_hash_aset (rv, rb_str_new2 ("vg_fmt"), rb_str_new2 (r->val[i].vg_fmt));
530     rb_hash_aset (rv, rb_str_new2 ("vg_attr"), rb_str_new2 (r->val[i].vg_attr));
531     rb_hash_aset (rv, rb_str_new2 ("vg_size"), ULL2NUM (r->val[i].vg_size));
532     rb_hash_aset (rv, rb_str_new2 ("vg_free"), ULL2NUM (r->val[i].vg_free));
533     rb_hash_aset (rv, rb_str_new2 ("vg_sysid"), rb_str_new2 (r->val[i].vg_sysid));
534     rb_hash_aset (rv, rb_str_new2 ("vg_extent_size"), ULL2NUM (r->val[i].vg_extent_size));
535     rb_hash_aset (rv, rb_str_new2 ("vg_extent_count"), ULL2NUM (r->val[i].vg_extent_count));
536     rb_hash_aset (rv, rb_str_new2 ("vg_free_count"), ULL2NUM (r->val[i].vg_free_count));
537     rb_hash_aset (rv, rb_str_new2 ("max_lv"), ULL2NUM (r->val[i].max_lv));
538     rb_hash_aset (rv, rb_str_new2 ("max_pv"), ULL2NUM (r->val[i].max_pv));
539     rb_hash_aset (rv, rb_str_new2 ("pv_count"), ULL2NUM (r->val[i].pv_count));
540     rb_hash_aset (rv, rb_str_new2 ("lv_count"), ULL2NUM (r->val[i].lv_count));
541     rb_hash_aset (rv, rb_str_new2 ("snap_count"), ULL2NUM (r->val[i].snap_count));
542     rb_hash_aset (rv, rb_str_new2 ("vg_seqno"), ULL2NUM (r->val[i].vg_seqno));
543     rb_hash_aset (rv, rb_str_new2 ("vg_tags"), rb_str_new2 (r->val[i].vg_tags));
544     rb_hash_aset (rv, rb_str_new2 ("vg_mda_count"), ULL2NUM (r->val[i].vg_mda_count));
545     rb_hash_aset (rv, rb_str_new2 ("vg_mda_free"), ULL2NUM (r->val[i].vg_mda_free));
546     rb_ary_push (rv, hv);
547   }
548   guestfs_free_lvm_vg_list (r);
549   return rv;
550 }
551
552 static VALUE ruby_guestfs_test0rvglisterr (VALUE gv)
553 {
554   guestfs_h *g;
555   Data_Get_Struct (gv, guestfs_h, g);
556   if (!g)
557     rb_raise (rb_eArgError, "%s: used handle after closing it", "test0rvglisterr");
558
559
560   struct guestfs_lvm_vg_list *r;
561
562   r = guestfs_test0rvglisterr (g);
563   if (r == NULL)
564     rb_raise (e_Error, "%s", guestfs_last_error (g));
565
566   VALUE rv = rb_ary_new2 (r->len);
567   int i;
568   for (i = 0; i < r->len; ++i) {
569     VALUE hv = rb_hash_new ();
570     rb_hash_aset (rv, rb_str_new2 ("vg_name"), rb_str_new2 (r->val[i].vg_name));
571     rb_hash_aset (rv, rb_str_new2 ("vg_uuid"), rb_str_new (r->val[i].vg_uuid, 32));
572     rb_hash_aset (rv, rb_str_new2 ("vg_fmt"), rb_str_new2 (r->val[i].vg_fmt));
573     rb_hash_aset (rv, rb_str_new2 ("vg_attr"), rb_str_new2 (r->val[i].vg_attr));
574     rb_hash_aset (rv, rb_str_new2 ("vg_size"), ULL2NUM (r->val[i].vg_size));
575     rb_hash_aset (rv, rb_str_new2 ("vg_free"), ULL2NUM (r->val[i].vg_free));
576     rb_hash_aset (rv, rb_str_new2 ("vg_sysid"), rb_str_new2 (r->val[i].vg_sysid));
577     rb_hash_aset (rv, rb_str_new2 ("vg_extent_size"), ULL2NUM (r->val[i].vg_extent_size));
578     rb_hash_aset (rv, rb_str_new2 ("vg_extent_count"), ULL2NUM (r->val[i].vg_extent_count));
579     rb_hash_aset (rv, rb_str_new2 ("vg_free_count"), ULL2NUM (r->val[i].vg_free_count));
580     rb_hash_aset (rv, rb_str_new2 ("max_lv"), ULL2NUM (r->val[i].max_lv));
581     rb_hash_aset (rv, rb_str_new2 ("max_pv"), ULL2NUM (r->val[i].max_pv));
582     rb_hash_aset (rv, rb_str_new2 ("pv_count"), ULL2NUM (r->val[i].pv_count));
583     rb_hash_aset (rv, rb_str_new2 ("lv_count"), ULL2NUM (r->val[i].lv_count));
584     rb_hash_aset (rv, rb_str_new2 ("snap_count"), ULL2NUM (r->val[i].snap_count));
585     rb_hash_aset (rv, rb_str_new2 ("vg_seqno"), ULL2NUM (r->val[i].vg_seqno));
586     rb_hash_aset (rv, rb_str_new2 ("vg_tags"), rb_str_new2 (r->val[i].vg_tags));
587     rb_hash_aset (rv, rb_str_new2 ("vg_mda_count"), ULL2NUM (r->val[i].vg_mda_count));
588     rb_hash_aset (rv, rb_str_new2 ("vg_mda_free"), ULL2NUM (r->val[i].vg_mda_free));
589     rb_ary_push (rv, hv);
590   }
591   guestfs_free_lvm_vg_list (r);
592   return rv;
593 }
594
595 static VALUE ruby_guestfs_test0rlvlist (VALUE gv, VALUE valv)
596 {
597   guestfs_h *g;
598   Data_Get_Struct (gv, guestfs_h, g);
599   if (!g)
600     rb_raise (rb_eArgError, "%s: used handle after closing it", "test0rlvlist");
601
602   Check_Type (valv, T_STRING);
603   const char *val = StringValueCStr (valv);
604   if (!val)
605     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
606               "val", "test0rlvlist");
607
608   struct guestfs_lvm_lv_list *r;
609
610   r = guestfs_test0rlvlist (g, val);
611   if (r == NULL)
612     rb_raise (e_Error, "%s", guestfs_last_error (g));
613
614   VALUE rv = rb_ary_new2 (r->len);
615   int i;
616   for (i = 0; i < r->len; ++i) {
617     VALUE hv = rb_hash_new ();
618     rb_hash_aset (rv, rb_str_new2 ("lv_name"), rb_str_new2 (r->val[i].lv_name));
619     rb_hash_aset (rv, rb_str_new2 ("lv_uuid"), rb_str_new (r->val[i].lv_uuid, 32));
620     rb_hash_aset (rv, rb_str_new2 ("lv_attr"), rb_str_new2 (r->val[i].lv_attr));
621     rb_hash_aset (rv, rb_str_new2 ("lv_major"), ULL2NUM (r->val[i].lv_major));
622     rb_hash_aset (rv, rb_str_new2 ("lv_minor"), ULL2NUM (r->val[i].lv_minor));
623     rb_hash_aset (rv, rb_str_new2 ("lv_kernel_major"), ULL2NUM (r->val[i].lv_kernel_major));
624     rb_hash_aset (rv, rb_str_new2 ("lv_kernel_minor"), ULL2NUM (r->val[i].lv_kernel_minor));
625     rb_hash_aset (rv, rb_str_new2 ("lv_size"), ULL2NUM (r->val[i].lv_size));
626     rb_hash_aset (rv, rb_str_new2 ("seg_count"), ULL2NUM (r->val[i].seg_count));
627     rb_hash_aset (rv, rb_str_new2 ("origin"), rb_str_new2 (r->val[i].origin));
628     rb_hash_aset (rv, rb_str_new2 ("snap_percent"), rb_dbl2big (r->val[i].snap_percent));
629     rb_hash_aset (rv, rb_str_new2 ("copy_percent"), rb_dbl2big (r->val[i].copy_percent));
630     rb_hash_aset (rv, rb_str_new2 ("move_pv"), rb_str_new2 (r->val[i].move_pv));
631     rb_hash_aset (rv, rb_str_new2 ("lv_tags"), rb_str_new2 (r->val[i].lv_tags));
632     rb_hash_aset (rv, rb_str_new2 ("mirror_log"), rb_str_new2 (r->val[i].mirror_log));
633     rb_hash_aset (rv, rb_str_new2 ("modules"), rb_str_new2 (r->val[i].modules));
634     rb_ary_push (rv, hv);
635   }
636   guestfs_free_lvm_lv_list (r);
637   return rv;
638 }
639
640 static VALUE ruby_guestfs_test0rlvlisterr (VALUE gv)
641 {
642   guestfs_h *g;
643   Data_Get_Struct (gv, guestfs_h, g);
644   if (!g)
645     rb_raise (rb_eArgError, "%s: used handle after closing it", "test0rlvlisterr");
646
647
648   struct guestfs_lvm_lv_list *r;
649
650   r = guestfs_test0rlvlisterr (g);
651   if (r == NULL)
652     rb_raise (e_Error, "%s", guestfs_last_error (g));
653
654   VALUE rv = rb_ary_new2 (r->len);
655   int i;
656   for (i = 0; i < r->len; ++i) {
657     VALUE hv = rb_hash_new ();
658     rb_hash_aset (rv, rb_str_new2 ("lv_name"), rb_str_new2 (r->val[i].lv_name));
659     rb_hash_aset (rv, rb_str_new2 ("lv_uuid"), rb_str_new (r->val[i].lv_uuid, 32));
660     rb_hash_aset (rv, rb_str_new2 ("lv_attr"), rb_str_new2 (r->val[i].lv_attr));
661     rb_hash_aset (rv, rb_str_new2 ("lv_major"), ULL2NUM (r->val[i].lv_major));
662     rb_hash_aset (rv, rb_str_new2 ("lv_minor"), ULL2NUM (r->val[i].lv_minor));
663     rb_hash_aset (rv, rb_str_new2 ("lv_kernel_major"), ULL2NUM (r->val[i].lv_kernel_major));
664     rb_hash_aset (rv, rb_str_new2 ("lv_kernel_minor"), ULL2NUM (r->val[i].lv_kernel_minor));
665     rb_hash_aset (rv, rb_str_new2 ("lv_size"), ULL2NUM (r->val[i].lv_size));
666     rb_hash_aset (rv, rb_str_new2 ("seg_count"), ULL2NUM (r->val[i].seg_count));
667     rb_hash_aset (rv, rb_str_new2 ("origin"), rb_str_new2 (r->val[i].origin));
668     rb_hash_aset (rv, rb_str_new2 ("snap_percent"), rb_dbl2big (r->val[i].snap_percent));
669     rb_hash_aset (rv, rb_str_new2 ("copy_percent"), rb_dbl2big (r->val[i].copy_percent));
670     rb_hash_aset (rv, rb_str_new2 ("move_pv"), rb_str_new2 (r->val[i].move_pv));
671     rb_hash_aset (rv, rb_str_new2 ("lv_tags"), rb_str_new2 (r->val[i].lv_tags));
672     rb_hash_aset (rv, rb_str_new2 ("mirror_log"), rb_str_new2 (r->val[i].mirror_log));
673     rb_hash_aset (rv, rb_str_new2 ("modules"), rb_str_new2 (r->val[i].modules));
674     rb_ary_push (rv, hv);
675   }
676   guestfs_free_lvm_lv_list (r);
677   return rv;
678 }
679
680 static VALUE ruby_guestfs_test0rstat (VALUE gv, VALUE valv)
681 {
682   guestfs_h *g;
683   Data_Get_Struct (gv, guestfs_h, g);
684   if (!g)
685     rb_raise (rb_eArgError, "%s: used handle after closing it", "test0rstat");
686
687   Check_Type (valv, T_STRING);
688   const char *val = StringValueCStr (valv);
689   if (!val)
690     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
691               "val", "test0rstat");
692
693   struct guestfs_stat *r;
694
695   r = guestfs_test0rstat (g, val);
696   if (r == NULL)
697     rb_raise (e_Error, "%s", guestfs_last_error (g));
698
699   VALUE rv = rb_hash_new ();
700   rb_hash_aset (rv, rb_str_new2 ("dev"), ULL2NUM (r->dev));
701   rb_hash_aset (rv, rb_str_new2 ("ino"), ULL2NUM (r->ino));
702   rb_hash_aset (rv, rb_str_new2 ("mode"), ULL2NUM (r->mode));
703   rb_hash_aset (rv, rb_str_new2 ("nlink"), ULL2NUM (r->nlink));
704   rb_hash_aset (rv, rb_str_new2 ("uid"), ULL2NUM (r->uid));
705   rb_hash_aset (rv, rb_str_new2 ("gid"), ULL2NUM (r->gid));
706   rb_hash_aset (rv, rb_str_new2 ("rdev"), ULL2NUM (r->rdev));
707   rb_hash_aset (rv, rb_str_new2 ("size"), ULL2NUM (r->size));
708   rb_hash_aset (rv, rb_str_new2 ("blksize"), ULL2NUM (r->blksize));
709   rb_hash_aset (rv, rb_str_new2 ("blocks"), ULL2NUM (r->blocks));
710   rb_hash_aset (rv, rb_str_new2 ("atime"), ULL2NUM (r->atime));
711   rb_hash_aset (rv, rb_str_new2 ("mtime"), ULL2NUM (r->mtime));
712   rb_hash_aset (rv, rb_str_new2 ("ctime"), ULL2NUM (r->ctime));
713   free (r);
714   return rv;
715 }
716
717 static VALUE ruby_guestfs_test0rstaterr (VALUE gv)
718 {
719   guestfs_h *g;
720   Data_Get_Struct (gv, guestfs_h, g);
721   if (!g)
722     rb_raise (rb_eArgError, "%s: used handle after closing it", "test0rstaterr");
723
724
725   struct guestfs_stat *r;
726
727   r = guestfs_test0rstaterr (g);
728   if (r == NULL)
729     rb_raise (e_Error, "%s", guestfs_last_error (g));
730
731   VALUE rv = rb_hash_new ();
732   rb_hash_aset (rv, rb_str_new2 ("dev"), ULL2NUM (r->dev));
733   rb_hash_aset (rv, rb_str_new2 ("ino"), ULL2NUM (r->ino));
734   rb_hash_aset (rv, rb_str_new2 ("mode"), ULL2NUM (r->mode));
735   rb_hash_aset (rv, rb_str_new2 ("nlink"), ULL2NUM (r->nlink));
736   rb_hash_aset (rv, rb_str_new2 ("uid"), ULL2NUM (r->uid));
737   rb_hash_aset (rv, rb_str_new2 ("gid"), ULL2NUM (r->gid));
738   rb_hash_aset (rv, rb_str_new2 ("rdev"), ULL2NUM (r->rdev));
739   rb_hash_aset (rv, rb_str_new2 ("size"), ULL2NUM (r->size));
740   rb_hash_aset (rv, rb_str_new2 ("blksize"), ULL2NUM (r->blksize));
741   rb_hash_aset (rv, rb_str_new2 ("blocks"), ULL2NUM (r->blocks));
742   rb_hash_aset (rv, rb_str_new2 ("atime"), ULL2NUM (r->atime));
743   rb_hash_aset (rv, rb_str_new2 ("mtime"), ULL2NUM (r->mtime));
744   rb_hash_aset (rv, rb_str_new2 ("ctime"), ULL2NUM (r->ctime));
745   free (r);
746   return rv;
747 }
748
749 static VALUE ruby_guestfs_test0rstatvfs (VALUE gv, VALUE valv)
750 {
751   guestfs_h *g;
752   Data_Get_Struct (gv, guestfs_h, g);
753   if (!g)
754     rb_raise (rb_eArgError, "%s: used handle after closing it", "test0rstatvfs");
755
756   Check_Type (valv, T_STRING);
757   const char *val = StringValueCStr (valv);
758   if (!val)
759     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
760               "val", "test0rstatvfs");
761
762   struct guestfs_statvfs *r;
763
764   r = guestfs_test0rstatvfs (g, val);
765   if (r == NULL)
766     rb_raise (e_Error, "%s", guestfs_last_error (g));
767
768   VALUE rv = rb_hash_new ();
769   rb_hash_aset (rv, rb_str_new2 ("bsize"), ULL2NUM (r->bsize));
770   rb_hash_aset (rv, rb_str_new2 ("frsize"), ULL2NUM (r->frsize));
771   rb_hash_aset (rv, rb_str_new2 ("blocks"), ULL2NUM (r->blocks));
772   rb_hash_aset (rv, rb_str_new2 ("bfree"), ULL2NUM (r->bfree));
773   rb_hash_aset (rv, rb_str_new2 ("bavail"), ULL2NUM (r->bavail));
774   rb_hash_aset (rv, rb_str_new2 ("files"), ULL2NUM (r->files));
775   rb_hash_aset (rv, rb_str_new2 ("ffree"), ULL2NUM (r->ffree));
776   rb_hash_aset (rv, rb_str_new2 ("favail"), ULL2NUM (r->favail));
777   rb_hash_aset (rv, rb_str_new2 ("fsid"), ULL2NUM (r->fsid));
778   rb_hash_aset (rv, rb_str_new2 ("flag"), ULL2NUM (r->flag));
779   rb_hash_aset (rv, rb_str_new2 ("namemax"), ULL2NUM (r->namemax));
780   free (r);
781   return rv;
782 }
783
784 static VALUE ruby_guestfs_test0rstatvfserr (VALUE gv)
785 {
786   guestfs_h *g;
787   Data_Get_Struct (gv, guestfs_h, g);
788   if (!g)
789     rb_raise (rb_eArgError, "%s: used handle after closing it", "test0rstatvfserr");
790
791
792   struct guestfs_statvfs *r;
793
794   r = guestfs_test0rstatvfserr (g);
795   if (r == NULL)
796     rb_raise (e_Error, "%s", guestfs_last_error (g));
797
798   VALUE rv = rb_hash_new ();
799   rb_hash_aset (rv, rb_str_new2 ("bsize"), ULL2NUM (r->bsize));
800   rb_hash_aset (rv, rb_str_new2 ("frsize"), ULL2NUM (r->frsize));
801   rb_hash_aset (rv, rb_str_new2 ("blocks"), ULL2NUM (r->blocks));
802   rb_hash_aset (rv, rb_str_new2 ("bfree"), ULL2NUM (r->bfree));
803   rb_hash_aset (rv, rb_str_new2 ("bavail"), ULL2NUM (r->bavail));
804   rb_hash_aset (rv, rb_str_new2 ("files"), ULL2NUM (r->files));
805   rb_hash_aset (rv, rb_str_new2 ("ffree"), ULL2NUM (r->ffree));
806   rb_hash_aset (rv, rb_str_new2 ("favail"), ULL2NUM (r->favail));
807   rb_hash_aset (rv, rb_str_new2 ("fsid"), ULL2NUM (r->fsid));
808   rb_hash_aset (rv, rb_str_new2 ("flag"), ULL2NUM (r->flag));
809   rb_hash_aset (rv, rb_str_new2 ("namemax"), ULL2NUM (r->namemax));
810   free (r);
811   return rv;
812 }
813
814 static VALUE ruby_guestfs_test0rhashtable (VALUE gv, VALUE valv)
815 {
816   guestfs_h *g;
817   Data_Get_Struct (gv, guestfs_h, g);
818   if (!g)
819     rb_raise (rb_eArgError, "%s: used handle after closing it", "test0rhashtable");
820
821   Check_Type (valv, T_STRING);
822   const char *val = StringValueCStr (valv);
823   if (!val)
824     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
825               "val", "test0rhashtable");
826
827   char **r;
828
829   r = guestfs_test0rhashtable (g, val);
830   if (r == NULL)
831     rb_raise (e_Error, "%s", guestfs_last_error (g));
832
833   VALUE rv = rb_hash_new ();
834   int i;
835   for (i = 0; r[i] != NULL; i+=2) {
836     rb_hash_aset (rv, rb_str_new2 (r[i]), rb_str_new2 (r[i+1]));
837     free (r[i]);
838     free (r[i+1]);
839   }
840   free (r);
841   return rv;
842 }
843
844 static VALUE ruby_guestfs_test0rhashtableerr (VALUE gv)
845 {
846   guestfs_h *g;
847   Data_Get_Struct (gv, guestfs_h, g);
848   if (!g)
849     rb_raise (rb_eArgError, "%s: used handle after closing it", "test0rhashtableerr");
850
851
852   char **r;
853
854   r = guestfs_test0rhashtableerr (g);
855   if (r == NULL)
856     rb_raise (e_Error, "%s", guestfs_last_error (g));
857
858   VALUE rv = rb_hash_new ();
859   int i;
860   for (i = 0; r[i] != NULL; i+=2) {
861     rb_hash_aset (rv, rb_str_new2 (r[i]), rb_str_new2 (r[i+1]));
862     free (r[i]);
863     free (r[i+1]);
864   }
865   free (r);
866   return rv;
867 }
868
869 static VALUE ruby_guestfs_launch (VALUE gv)
870 {
871   guestfs_h *g;
872   Data_Get_Struct (gv, guestfs_h, g);
873   if (!g)
874     rb_raise (rb_eArgError, "%s: used handle after closing it", "launch");
875
876
877   int r;
878
879   r = guestfs_launch (g);
880   if (r == -1)
881     rb_raise (e_Error, "%s", guestfs_last_error (g));
882
883   return Qnil;
884 }
885
886 static VALUE ruby_guestfs_wait_ready (VALUE gv)
887 {
888   guestfs_h *g;
889   Data_Get_Struct (gv, guestfs_h, g);
890   if (!g)
891     rb_raise (rb_eArgError, "%s: used handle after closing it", "wait_ready");
892
893
894   int r;
895
896   r = guestfs_wait_ready (g);
897   if (r == -1)
898     rb_raise (e_Error, "%s", guestfs_last_error (g));
899
900   return Qnil;
901 }
902
903 static VALUE ruby_guestfs_kill_subprocess (VALUE gv)
904 {
905   guestfs_h *g;
906   Data_Get_Struct (gv, guestfs_h, g);
907   if (!g)
908     rb_raise (rb_eArgError, "%s: used handle after closing it", "kill_subprocess");
909
910
911   int r;
912
913   r = guestfs_kill_subprocess (g);
914   if (r == -1)
915     rb_raise (e_Error, "%s", guestfs_last_error (g));
916
917   return Qnil;
918 }
919
920 static VALUE ruby_guestfs_add_drive (VALUE gv, VALUE filenamev)
921 {
922   guestfs_h *g;
923   Data_Get_Struct (gv, guestfs_h, g);
924   if (!g)
925     rb_raise (rb_eArgError, "%s: used handle after closing it", "add_drive");
926
927   Check_Type (filenamev, T_STRING);
928   const char *filename = StringValueCStr (filenamev);
929   if (!filename)
930     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
931               "filename", "add_drive");
932
933   int r;
934
935   r = guestfs_add_drive (g, filename);
936   if (r == -1)
937     rb_raise (e_Error, "%s", guestfs_last_error (g));
938
939   return Qnil;
940 }
941
942 static VALUE ruby_guestfs_add_cdrom (VALUE gv, VALUE filenamev)
943 {
944   guestfs_h *g;
945   Data_Get_Struct (gv, guestfs_h, g);
946   if (!g)
947     rb_raise (rb_eArgError, "%s: used handle after closing it", "add_cdrom");
948
949   Check_Type (filenamev, T_STRING);
950   const char *filename = StringValueCStr (filenamev);
951   if (!filename)
952     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
953               "filename", "add_cdrom");
954
955   int r;
956
957   r = guestfs_add_cdrom (g, filename);
958   if (r == -1)
959     rb_raise (e_Error, "%s", guestfs_last_error (g));
960
961   return Qnil;
962 }
963
964 static VALUE ruby_guestfs_add_drive_ro (VALUE gv, VALUE filenamev)
965 {
966   guestfs_h *g;
967   Data_Get_Struct (gv, guestfs_h, g);
968   if (!g)
969     rb_raise (rb_eArgError, "%s: used handle after closing it", "add_drive_ro");
970
971   Check_Type (filenamev, T_STRING);
972   const char *filename = StringValueCStr (filenamev);
973   if (!filename)
974     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
975               "filename", "add_drive_ro");
976
977   int r;
978
979   r = guestfs_add_drive_ro (g, filename);
980   if (r == -1)
981     rb_raise (e_Error, "%s", guestfs_last_error (g));
982
983   return Qnil;
984 }
985
986 static VALUE ruby_guestfs_config (VALUE gv, VALUE qemuparamv, VALUE qemuvaluev)
987 {
988   guestfs_h *g;
989   Data_Get_Struct (gv, guestfs_h, g);
990   if (!g)
991     rb_raise (rb_eArgError, "%s: used handle after closing it", "config");
992
993   Check_Type (qemuparamv, T_STRING);
994   const char *qemuparam = StringValueCStr (qemuparamv);
995   if (!qemuparam)
996     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
997               "qemuparam", "config");
998   const char *qemuvalue = !NIL_P (qemuvaluev) ? StringValueCStr (qemuvaluev) : NULL;
999
1000   int r;
1001
1002   r = guestfs_config (g, qemuparam, qemuvalue);
1003   if (r == -1)
1004     rb_raise (e_Error, "%s", guestfs_last_error (g));
1005
1006   return Qnil;
1007 }
1008
1009 static VALUE ruby_guestfs_set_qemu (VALUE gv, VALUE qemuv)
1010 {
1011   guestfs_h *g;
1012   Data_Get_Struct (gv, guestfs_h, g);
1013   if (!g)
1014     rb_raise (rb_eArgError, "%s: used handle after closing it", "set_qemu");
1015
1016   Check_Type (qemuv, T_STRING);
1017   const char *qemu = StringValueCStr (qemuv);
1018   if (!qemu)
1019     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1020               "qemu", "set_qemu");
1021
1022   int r;
1023
1024   r = guestfs_set_qemu (g, qemu);
1025   if (r == -1)
1026     rb_raise (e_Error, "%s", guestfs_last_error (g));
1027
1028   return Qnil;
1029 }
1030
1031 static VALUE ruby_guestfs_get_qemu (VALUE gv)
1032 {
1033   guestfs_h *g;
1034   Data_Get_Struct (gv, guestfs_h, g);
1035   if (!g)
1036     rb_raise (rb_eArgError, "%s: used handle after closing it", "get_qemu");
1037
1038
1039   const char *r;
1040
1041   r = guestfs_get_qemu (g);
1042   if (r == NULL)
1043     rb_raise (e_Error, "%s", guestfs_last_error (g));
1044
1045   return rb_str_new2 (r);
1046 }
1047
1048 static VALUE ruby_guestfs_set_path (VALUE gv, VALUE pathv)
1049 {
1050   guestfs_h *g;
1051   Data_Get_Struct (gv, guestfs_h, g);
1052   if (!g)
1053     rb_raise (rb_eArgError, "%s: used handle after closing it", "set_path");
1054
1055   Check_Type (pathv, T_STRING);
1056   const char *path = StringValueCStr (pathv);
1057   if (!path)
1058     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1059               "path", "set_path");
1060
1061   int r;
1062
1063   r = guestfs_set_path (g, path);
1064   if (r == -1)
1065     rb_raise (e_Error, "%s", guestfs_last_error (g));
1066
1067   return Qnil;
1068 }
1069
1070 static VALUE ruby_guestfs_get_path (VALUE gv)
1071 {
1072   guestfs_h *g;
1073   Data_Get_Struct (gv, guestfs_h, g);
1074   if (!g)
1075     rb_raise (rb_eArgError, "%s: used handle after closing it", "get_path");
1076
1077
1078   const char *r;
1079
1080   r = guestfs_get_path (g);
1081   if (r == NULL)
1082     rb_raise (e_Error, "%s", guestfs_last_error (g));
1083
1084   return rb_str_new2 (r);
1085 }
1086
1087 static VALUE ruby_guestfs_set_append (VALUE gv, VALUE appendv)
1088 {
1089   guestfs_h *g;
1090   Data_Get_Struct (gv, guestfs_h, g);
1091   if (!g)
1092     rb_raise (rb_eArgError, "%s: used handle after closing it", "set_append");
1093
1094   Check_Type (appendv, T_STRING);
1095   const char *append = StringValueCStr (appendv);
1096   if (!append)
1097     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1098               "append", "set_append");
1099
1100   int r;
1101
1102   r = guestfs_set_append (g, append);
1103   if (r == -1)
1104     rb_raise (e_Error, "%s", guestfs_last_error (g));
1105
1106   return Qnil;
1107 }
1108
1109 static VALUE ruby_guestfs_get_append (VALUE gv)
1110 {
1111   guestfs_h *g;
1112   Data_Get_Struct (gv, guestfs_h, g);
1113   if (!g)
1114     rb_raise (rb_eArgError, "%s: used handle after closing it", "get_append");
1115
1116
1117   const char *r;
1118
1119   r = guestfs_get_append (g);
1120   if (r == NULL)
1121     rb_raise (e_Error, "%s", guestfs_last_error (g));
1122
1123   return rb_str_new2 (r);
1124 }
1125
1126 static VALUE ruby_guestfs_set_autosync (VALUE gv, VALUE autosyncv)
1127 {
1128   guestfs_h *g;
1129   Data_Get_Struct (gv, guestfs_h, g);
1130   if (!g)
1131     rb_raise (rb_eArgError, "%s: used handle after closing it", "set_autosync");
1132
1133   int autosync = RTEST (autosyncv);
1134
1135   int r;
1136
1137   r = guestfs_set_autosync (g, autosync);
1138   if (r == -1)
1139     rb_raise (e_Error, "%s", guestfs_last_error (g));
1140
1141   return Qnil;
1142 }
1143
1144 static VALUE ruby_guestfs_get_autosync (VALUE gv)
1145 {
1146   guestfs_h *g;
1147   Data_Get_Struct (gv, guestfs_h, g);
1148   if (!g)
1149     rb_raise (rb_eArgError, "%s: used handle after closing it", "get_autosync");
1150
1151
1152   int r;
1153
1154   r = guestfs_get_autosync (g);
1155   if (r == -1)
1156     rb_raise (e_Error, "%s", guestfs_last_error (g));
1157
1158   return INT2NUM (r);
1159 }
1160
1161 static VALUE ruby_guestfs_set_verbose (VALUE gv, VALUE verbosev)
1162 {
1163   guestfs_h *g;
1164   Data_Get_Struct (gv, guestfs_h, g);
1165   if (!g)
1166     rb_raise (rb_eArgError, "%s: used handle after closing it", "set_verbose");
1167
1168   int verbose = RTEST (verbosev);
1169
1170   int r;
1171
1172   r = guestfs_set_verbose (g, verbose);
1173   if (r == -1)
1174     rb_raise (e_Error, "%s", guestfs_last_error (g));
1175
1176   return Qnil;
1177 }
1178
1179 static VALUE ruby_guestfs_get_verbose (VALUE gv)
1180 {
1181   guestfs_h *g;
1182   Data_Get_Struct (gv, guestfs_h, g);
1183   if (!g)
1184     rb_raise (rb_eArgError, "%s: used handle after closing it", "get_verbose");
1185
1186
1187   int r;
1188
1189   r = guestfs_get_verbose (g);
1190   if (r == -1)
1191     rb_raise (e_Error, "%s", guestfs_last_error (g));
1192
1193   return INT2NUM (r);
1194 }
1195
1196 static VALUE ruby_guestfs_is_ready (VALUE gv)
1197 {
1198   guestfs_h *g;
1199   Data_Get_Struct (gv, guestfs_h, g);
1200   if (!g)
1201     rb_raise (rb_eArgError, "%s: used handle after closing it", "is_ready");
1202
1203
1204   int r;
1205
1206   r = guestfs_is_ready (g);
1207   if (r == -1)
1208     rb_raise (e_Error, "%s", guestfs_last_error (g));
1209
1210   return INT2NUM (r);
1211 }
1212
1213 static VALUE ruby_guestfs_is_config (VALUE gv)
1214 {
1215   guestfs_h *g;
1216   Data_Get_Struct (gv, guestfs_h, g);
1217   if (!g)
1218     rb_raise (rb_eArgError, "%s: used handle after closing it", "is_config");
1219
1220
1221   int r;
1222
1223   r = guestfs_is_config (g);
1224   if (r == -1)
1225     rb_raise (e_Error, "%s", guestfs_last_error (g));
1226
1227   return INT2NUM (r);
1228 }
1229
1230 static VALUE ruby_guestfs_is_launching (VALUE gv)
1231 {
1232   guestfs_h *g;
1233   Data_Get_Struct (gv, guestfs_h, g);
1234   if (!g)
1235     rb_raise (rb_eArgError, "%s: used handle after closing it", "is_launching");
1236
1237
1238   int r;
1239
1240   r = guestfs_is_launching (g);
1241   if (r == -1)
1242     rb_raise (e_Error, "%s", guestfs_last_error (g));
1243
1244   return INT2NUM (r);
1245 }
1246
1247 static VALUE ruby_guestfs_is_busy (VALUE gv)
1248 {
1249   guestfs_h *g;
1250   Data_Get_Struct (gv, guestfs_h, g);
1251   if (!g)
1252     rb_raise (rb_eArgError, "%s: used handle after closing it", "is_busy");
1253
1254
1255   int r;
1256
1257   r = guestfs_is_busy (g);
1258   if (r == -1)
1259     rb_raise (e_Error, "%s", guestfs_last_error (g));
1260
1261   return INT2NUM (r);
1262 }
1263
1264 static VALUE ruby_guestfs_get_state (VALUE gv)
1265 {
1266   guestfs_h *g;
1267   Data_Get_Struct (gv, guestfs_h, g);
1268   if (!g)
1269     rb_raise (rb_eArgError, "%s: used handle after closing it", "get_state");
1270
1271
1272   int r;
1273
1274   r = guestfs_get_state (g);
1275   if (r == -1)
1276     rb_raise (e_Error, "%s", guestfs_last_error (g));
1277
1278   return INT2NUM (r);
1279 }
1280
1281 static VALUE ruby_guestfs_set_busy (VALUE gv)
1282 {
1283   guestfs_h *g;
1284   Data_Get_Struct (gv, guestfs_h, g);
1285   if (!g)
1286     rb_raise (rb_eArgError, "%s: used handle after closing it", "set_busy");
1287
1288
1289   int r;
1290
1291   r = guestfs_set_busy (g);
1292   if (r == -1)
1293     rb_raise (e_Error, "%s", guestfs_last_error (g));
1294
1295   return Qnil;
1296 }
1297
1298 static VALUE ruby_guestfs_set_ready (VALUE gv)
1299 {
1300   guestfs_h *g;
1301   Data_Get_Struct (gv, guestfs_h, g);
1302   if (!g)
1303     rb_raise (rb_eArgError, "%s: used handle after closing it", "set_ready");
1304
1305
1306   int r;
1307
1308   r = guestfs_set_ready (g);
1309   if (r == -1)
1310     rb_raise (e_Error, "%s", guestfs_last_error (g));
1311
1312   return Qnil;
1313 }
1314
1315 static VALUE ruby_guestfs_end_busy (VALUE gv)
1316 {
1317   guestfs_h *g;
1318   Data_Get_Struct (gv, guestfs_h, g);
1319   if (!g)
1320     rb_raise (rb_eArgError, "%s: used handle after closing it", "end_busy");
1321
1322
1323   int r;
1324
1325   r = guestfs_end_busy (g);
1326   if (r == -1)
1327     rb_raise (e_Error, "%s", guestfs_last_error (g));
1328
1329   return Qnil;
1330 }
1331
1332 static VALUE ruby_guestfs_set_memsize (VALUE gv, VALUE memsizev)
1333 {
1334   guestfs_h *g;
1335   Data_Get_Struct (gv, guestfs_h, g);
1336   if (!g)
1337     rb_raise (rb_eArgError, "%s: used handle after closing it", "set_memsize");
1338
1339   int memsize = NUM2INT (memsizev);
1340
1341   int r;
1342
1343   r = guestfs_set_memsize (g, memsize);
1344   if (r == -1)
1345     rb_raise (e_Error, "%s", guestfs_last_error (g));
1346
1347   return Qnil;
1348 }
1349
1350 static VALUE ruby_guestfs_get_memsize (VALUE gv)
1351 {
1352   guestfs_h *g;
1353   Data_Get_Struct (gv, guestfs_h, g);
1354   if (!g)
1355     rb_raise (rb_eArgError, "%s: used handle after closing it", "get_memsize");
1356
1357
1358   int r;
1359
1360   r = guestfs_get_memsize (g);
1361   if (r == -1)
1362     rb_raise (e_Error, "%s", guestfs_last_error (g));
1363
1364   return INT2NUM (r);
1365 }
1366
1367 static VALUE ruby_guestfs_mount (VALUE gv, VALUE devicev, VALUE mountpointv)
1368 {
1369   guestfs_h *g;
1370   Data_Get_Struct (gv, guestfs_h, g);
1371   if (!g)
1372     rb_raise (rb_eArgError, "%s: used handle after closing it", "mount");
1373
1374   Check_Type (devicev, T_STRING);
1375   const char *device = StringValueCStr (devicev);
1376   if (!device)
1377     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1378               "device", "mount");
1379   Check_Type (mountpointv, T_STRING);
1380   const char *mountpoint = StringValueCStr (mountpointv);
1381   if (!mountpoint)
1382     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1383               "mountpoint", "mount");
1384
1385   int r;
1386
1387   r = guestfs_mount (g, device, mountpoint);
1388   if (r == -1)
1389     rb_raise (e_Error, "%s", guestfs_last_error (g));
1390
1391   return Qnil;
1392 }
1393
1394 static VALUE ruby_guestfs_sync (VALUE gv)
1395 {
1396   guestfs_h *g;
1397   Data_Get_Struct (gv, guestfs_h, g);
1398   if (!g)
1399     rb_raise (rb_eArgError, "%s: used handle after closing it", "sync");
1400
1401
1402   int r;
1403
1404   r = guestfs_sync (g);
1405   if (r == -1)
1406     rb_raise (e_Error, "%s", guestfs_last_error (g));
1407
1408   return Qnil;
1409 }
1410
1411 static VALUE ruby_guestfs_touch (VALUE gv, VALUE pathv)
1412 {
1413   guestfs_h *g;
1414   Data_Get_Struct (gv, guestfs_h, g);
1415   if (!g)
1416     rb_raise (rb_eArgError, "%s: used handle after closing it", "touch");
1417
1418   Check_Type (pathv, T_STRING);
1419   const char *path = StringValueCStr (pathv);
1420   if (!path)
1421     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1422               "path", "touch");
1423
1424   int r;
1425
1426   r = guestfs_touch (g, path);
1427   if (r == -1)
1428     rb_raise (e_Error, "%s", guestfs_last_error (g));
1429
1430   return Qnil;
1431 }
1432
1433 static VALUE ruby_guestfs_cat (VALUE gv, VALUE pathv)
1434 {
1435   guestfs_h *g;
1436   Data_Get_Struct (gv, guestfs_h, g);
1437   if (!g)
1438     rb_raise (rb_eArgError, "%s: used handle after closing it", "cat");
1439
1440   Check_Type (pathv, T_STRING);
1441   const char *path = StringValueCStr (pathv);
1442   if (!path)
1443     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1444               "path", "cat");
1445
1446   char *r;
1447
1448   r = guestfs_cat (g, path);
1449   if (r == NULL)
1450     rb_raise (e_Error, "%s", guestfs_last_error (g));
1451
1452   VALUE rv = rb_str_new2 (r);
1453   free (r);
1454   return rv;
1455 }
1456
1457 static VALUE ruby_guestfs_ll (VALUE gv, VALUE directoryv)
1458 {
1459   guestfs_h *g;
1460   Data_Get_Struct (gv, guestfs_h, g);
1461   if (!g)
1462     rb_raise (rb_eArgError, "%s: used handle after closing it", "ll");
1463
1464   Check_Type (directoryv, T_STRING);
1465   const char *directory = StringValueCStr (directoryv);
1466   if (!directory)
1467     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1468               "directory", "ll");
1469
1470   char *r;
1471
1472   r = guestfs_ll (g, directory);
1473   if (r == NULL)
1474     rb_raise (e_Error, "%s", guestfs_last_error (g));
1475
1476   VALUE rv = rb_str_new2 (r);
1477   free (r);
1478   return rv;
1479 }
1480
1481 static VALUE ruby_guestfs_ls (VALUE gv, VALUE directoryv)
1482 {
1483   guestfs_h *g;
1484   Data_Get_Struct (gv, guestfs_h, g);
1485   if (!g)
1486     rb_raise (rb_eArgError, "%s: used handle after closing it", "ls");
1487
1488   Check_Type (directoryv, T_STRING);
1489   const char *directory = StringValueCStr (directoryv);
1490   if (!directory)
1491     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1492               "directory", "ls");
1493
1494   char **r;
1495
1496   r = guestfs_ls (g, directory);
1497   if (r == NULL)
1498     rb_raise (e_Error, "%s", guestfs_last_error (g));
1499
1500   int i, len = 0;
1501   for (i = 0; r[i] != NULL; ++i) len++;
1502   VALUE rv = rb_ary_new2 (len);
1503   for (i = 0; r[i] != NULL; ++i) {
1504     rb_ary_push (rv, rb_str_new2 (r[i]));
1505     free (r[i]);
1506   }
1507   free (r);
1508   return rv;
1509 }
1510
1511 static VALUE ruby_guestfs_list_devices (VALUE gv)
1512 {
1513   guestfs_h *g;
1514   Data_Get_Struct (gv, guestfs_h, g);
1515   if (!g)
1516     rb_raise (rb_eArgError, "%s: used handle after closing it", "list_devices");
1517
1518
1519   char **r;
1520
1521   r = guestfs_list_devices (g);
1522   if (r == NULL)
1523     rb_raise (e_Error, "%s", guestfs_last_error (g));
1524
1525   int i, len = 0;
1526   for (i = 0; r[i] != NULL; ++i) len++;
1527   VALUE rv = rb_ary_new2 (len);
1528   for (i = 0; r[i] != NULL; ++i) {
1529     rb_ary_push (rv, rb_str_new2 (r[i]));
1530     free (r[i]);
1531   }
1532   free (r);
1533   return rv;
1534 }
1535
1536 static VALUE ruby_guestfs_list_partitions (VALUE gv)
1537 {
1538   guestfs_h *g;
1539   Data_Get_Struct (gv, guestfs_h, g);
1540   if (!g)
1541     rb_raise (rb_eArgError, "%s: used handle after closing it", "list_partitions");
1542
1543
1544   char **r;
1545
1546   r = guestfs_list_partitions (g);
1547   if (r == NULL)
1548     rb_raise (e_Error, "%s", guestfs_last_error (g));
1549
1550   int i, len = 0;
1551   for (i = 0; r[i] != NULL; ++i) len++;
1552   VALUE rv = rb_ary_new2 (len);
1553   for (i = 0; r[i] != NULL; ++i) {
1554     rb_ary_push (rv, rb_str_new2 (r[i]));
1555     free (r[i]);
1556   }
1557   free (r);
1558   return rv;
1559 }
1560
1561 static VALUE ruby_guestfs_pvs (VALUE gv)
1562 {
1563   guestfs_h *g;
1564   Data_Get_Struct (gv, guestfs_h, g);
1565   if (!g)
1566     rb_raise (rb_eArgError, "%s: used handle after closing it", "pvs");
1567
1568
1569   char **r;
1570
1571   r = guestfs_pvs (g);
1572   if (r == NULL)
1573     rb_raise (e_Error, "%s", guestfs_last_error (g));
1574
1575   int i, len = 0;
1576   for (i = 0; r[i] != NULL; ++i) len++;
1577   VALUE rv = rb_ary_new2 (len);
1578   for (i = 0; r[i] != NULL; ++i) {
1579     rb_ary_push (rv, rb_str_new2 (r[i]));
1580     free (r[i]);
1581   }
1582   free (r);
1583   return rv;
1584 }
1585
1586 static VALUE ruby_guestfs_vgs (VALUE gv)
1587 {
1588   guestfs_h *g;
1589   Data_Get_Struct (gv, guestfs_h, g);
1590   if (!g)
1591     rb_raise (rb_eArgError, "%s: used handle after closing it", "vgs");
1592
1593
1594   char **r;
1595
1596   r = guestfs_vgs (g);
1597   if (r == NULL)
1598     rb_raise (e_Error, "%s", guestfs_last_error (g));
1599
1600   int i, len = 0;
1601   for (i = 0; r[i] != NULL; ++i) len++;
1602   VALUE rv = rb_ary_new2 (len);
1603   for (i = 0; r[i] != NULL; ++i) {
1604     rb_ary_push (rv, rb_str_new2 (r[i]));
1605     free (r[i]);
1606   }
1607   free (r);
1608   return rv;
1609 }
1610
1611 static VALUE ruby_guestfs_lvs (VALUE gv)
1612 {
1613   guestfs_h *g;
1614   Data_Get_Struct (gv, guestfs_h, g);
1615   if (!g)
1616     rb_raise (rb_eArgError, "%s: used handle after closing it", "lvs");
1617
1618
1619   char **r;
1620
1621   r = guestfs_lvs (g);
1622   if (r == NULL)
1623     rb_raise (e_Error, "%s", guestfs_last_error (g));
1624
1625   int i, len = 0;
1626   for (i = 0; r[i] != NULL; ++i) len++;
1627   VALUE rv = rb_ary_new2 (len);
1628   for (i = 0; r[i] != NULL; ++i) {
1629     rb_ary_push (rv, rb_str_new2 (r[i]));
1630     free (r[i]);
1631   }
1632   free (r);
1633   return rv;
1634 }
1635
1636 static VALUE ruby_guestfs_pvs_full (VALUE gv)
1637 {
1638   guestfs_h *g;
1639   Data_Get_Struct (gv, guestfs_h, g);
1640   if (!g)
1641     rb_raise (rb_eArgError, "%s: used handle after closing it", "pvs_full");
1642
1643
1644   struct guestfs_lvm_pv_list *r;
1645
1646   r = guestfs_pvs_full (g);
1647   if (r == NULL)
1648     rb_raise (e_Error, "%s", guestfs_last_error (g));
1649
1650   VALUE rv = rb_ary_new2 (r->len);
1651   int i;
1652   for (i = 0; i < r->len; ++i) {
1653     VALUE hv = rb_hash_new ();
1654     rb_hash_aset (rv, rb_str_new2 ("pv_name"), rb_str_new2 (r->val[i].pv_name));
1655     rb_hash_aset (rv, rb_str_new2 ("pv_uuid"), rb_str_new (r->val[i].pv_uuid, 32));
1656     rb_hash_aset (rv, rb_str_new2 ("pv_fmt"), rb_str_new2 (r->val[i].pv_fmt));
1657     rb_hash_aset (rv, rb_str_new2 ("pv_size"), ULL2NUM (r->val[i].pv_size));
1658     rb_hash_aset (rv, rb_str_new2 ("dev_size"), ULL2NUM (r->val[i].dev_size));
1659     rb_hash_aset (rv, rb_str_new2 ("pv_free"), ULL2NUM (r->val[i].pv_free));
1660     rb_hash_aset (rv, rb_str_new2 ("pv_used"), ULL2NUM (r->val[i].pv_used));
1661     rb_hash_aset (rv, rb_str_new2 ("pv_attr"), rb_str_new2 (r->val[i].pv_attr));
1662     rb_hash_aset (rv, rb_str_new2 ("pv_pe_count"), ULL2NUM (r->val[i].pv_pe_count));
1663     rb_hash_aset (rv, rb_str_new2 ("pv_pe_alloc_count"), ULL2NUM (r->val[i].pv_pe_alloc_count));
1664     rb_hash_aset (rv, rb_str_new2 ("pv_tags"), rb_str_new2 (r->val[i].pv_tags));
1665     rb_hash_aset (rv, rb_str_new2 ("pe_start"), ULL2NUM (r->val[i].pe_start));
1666     rb_hash_aset (rv, rb_str_new2 ("pv_mda_count"), ULL2NUM (r->val[i].pv_mda_count));
1667     rb_hash_aset (rv, rb_str_new2 ("pv_mda_free"), ULL2NUM (r->val[i].pv_mda_free));
1668     rb_ary_push (rv, hv);
1669   }
1670   guestfs_free_lvm_pv_list (r);
1671   return rv;
1672 }
1673
1674 static VALUE ruby_guestfs_vgs_full (VALUE gv)
1675 {
1676   guestfs_h *g;
1677   Data_Get_Struct (gv, guestfs_h, g);
1678   if (!g)
1679     rb_raise (rb_eArgError, "%s: used handle after closing it", "vgs_full");
1680
1681
1682   struct guestfs_lvm_vg_list *r;
1683
1684   r = guestfs_vgs_full (g);
1685   if (r == NULL)
1686     rb_raise (e_Error, "%s", guestfs_last_error (g));
1687
1688   VALUE rv = rb_ary_new2 (r->len);
1689   int i;
1690   for (i = 0; i < r->len; ++i) {
1691     VALUE hv = rb_hash_new ();
1692     rb_hash_aset (rv, rb_str_new2 ("vg_name"), rb_str_new2 (r->val[i].vg_name));
1693     rb_hash_aset (rv, rb_str_new2 ("vg_uuid"), rb_str_new (r->val[i].vg_uuid, 32));
1694     rb_hash_aset (rv, rb_str_new2 ("vg_fmt"), rb_str_new2 (r->val[i].vg_fmt));
1695     rb_hash_aset (rv, rb_str_new2 ("vg_attr"), rb_str_new2 (r->val[i].vg_attr));
1696     rb_hash_aset (rv, rb_str_new2 ("vg_size"), ULL2NUM (r->val[i].vg_size));
1697     rb_hash_aset (rv, rb_str_new2 ("vg_free"), ULL2NUM (r->val[i].vg_free));
1698     rb_hash_aset (rv, rb_str_new2 ("vg_sysid"), rb_str_new2 (r->val[i].vg_sysid));
1699     rb_hash_aset (rv, rb_str_new2 ("vg_extent_size"), ULL2NUM (r->val[i].vg_extent_size));
1700     rb_hash_aset (rv, rb_str_new2 ("vg_extent_count"), ULL2NUM (r->val[i].vg_extent_count));
1701     rb_hash_aset (rv, rb_str_new2 ("vg_free_count"), ULL2NUM (r->val[i].vg_free_count));
1702     rb_hash_aset (rv, rb_str_new2 ("max_lv"), ULL2NUM (r->val[i].max_lv));
1703     rb_hash_aset (rv, rb_str_new2 ("max_pv"), ULL2NUM (r->val[i].max_pv));
1704     rb_hash_aset (rv, rb_str_new2 ("pv_count"), ULL2NUM (r->val[i].pv_count));
1705     rb_hash_aset (rv, rb_str_new2 ("lv_count"), ULL2NUM (r->val[i].lv_count));
1706     rb_hash_aset (rv, rb_str_new2 ("snap_count"), ULL2NUM (r->val[i].snap_count));
1707     rb_hash_aset (rv, rb_str_new2 ("vg_seqno"), ULL2NUM (r->val[i].vg_seqno));
1708     rb_hash_aset (rv, rb_str_new2 ("vg_tags"), rb_str_new2 (r->val[i].vg_tags));
1709     rb_hash_aset (rv, rb_str_new2 ("vg_mda_count"), ULL2NUM (r->val[i].vg_mda_count));
1710     rb_hash_aset (rv, rb_str_new2 ("vg_mda_free"), ULL2NUM (r->val[i].vg_mda_free));
1711     rb_ary_push (rv, hv);
1712   }
1713   guestfs_free_lvm_vg_list (r);
1714   return rv;
1715 }
1716
1717 static VALUE ruby_guestfs_lvs_full (VALUE gv)
1718 {
1719   guestfs_h *g;
1720   Data_Get_Struct (gv, guestfs_h, g);
1721   if (!g)
1722     rb_raise (rb_eArgError, "%s: used handle after closing it", "lvs_full");
1723
1724
1725   struct guestfs_lvm_lv_list *r;
1726
1727   r = guestfs_lvs_full (g);
1728   if (r == NULL)
1729     rb_raise (e_Error, "%s", guestfs_last_error (g));
1730
1731   VALUE rv = rb_ary_new2 (r->len);
1732   int i;
1733   for (i = 0; i < r->len; ++i) {
1734     VALUE hv = rb_hash_new ();
1735     rb_hash_aset (rv, rb_str_new2 ("lv_name"), rb_str_new2 (r->val[i].lv_name));
1736     rb_hash_aset (rv, rb_str_new2 ("lv_uuid"), rb_str_new (r->val[i].lv_uuid, 32));
1737     rb_hash_aset (rv, rb_str_new2 ("lv_attr"), rb_str_new2 (r->val[i].lv_attr));
1738     rb_hash_aset (rv, rb_str_new2 ("lv_major"), ULL2NUM (r->val[i].lv_major));
1739     rb_hash_aset (rv, rb_str_new2 ("lv_minor"), ULL2NUM (r->val[i].lv_minor));
1740     rb_hash_aset (rv, rb_str_new2 ("lv_kernel_major"), ULL2NUM (r->val[i].lv_kernel_major));
1741     rb_hash_aset (rv, rb_str_new2 ("lv_kernel_minor"), ULL2NUM (r->val[i].lv_kernel_minor));
1742     rb_hash_aset (rv, rb_str_new2 ("lv_size"), ULL2NUM (r->val[i].lv_size));
1743     rb_hash_aset (rv, rb_str_new2 ("seg_count"), ULL2NUM (r->val[i].seg_count));
1744     rb_hash_aset (rv, rb_str_new2 ("origin"), rb_str_new2 (r->val[i].origin));
1745     rb_hash_aset (rv, rb_str_new2 ("snap_percent"), rb_dbl2big (r->val[i].snap_percent));
1746     rb_hash_aset (rv, rb_str_new2 ("copy_percent"), rb_dbl2big (r->val[i].copy_percent));
1747     rb_hash_aset (rv, rb_str_new2 ("move_pv"), rb_str_new2 (r->val[i].move_pv));
1748     rb_hash_aset (rv, rb_str_new2 ("lv_tags"), rb_str_new2 (r->val[i].lv_tags));
1749     rb_hash_aset (rv, rb_str_new2 ("mirror_log"), rb_str_new2 (r->val[i].mirror_log));
1750     rb_hash_aset (rv, rb_str_new2 ("modules"), rb_str_new2 (r->val[i].modules));
1751     rb_ary_push (rv, hv);
1752   }
1753   guestfs_free_lvm_lv_list (r);
1754   return rv;
1755 }
1756
1757 static VALUE ruby_guestfs_read_lines (VALUE gv, VALUE pathv)
1758 {
1759   guestfs_h *g;
1760   Data_Get_Struct (gv, guestfs_h, g);
1761   if (!g)
1762     rb_raise (rb_eArgError, "%s: used handle after closing it", "read_lines");
1763
1764   Check_Type (pathv, T_STRING);
1765   const char *path = StringValueCStr (pathv);
1766   if (!path)
1767     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1768               "path", "read_lines");
1769
1770   char **r;
1771
1772   r = guestfs_read_lines (g, path);
1773   if (r == NULL)
1774     rb_raise (e_Error, "%s", guestfs_last_error (g));
1775
1776   int i, len = 0;
1777   for (i = 0; r[i] != NULL; ++i) len++;
1778   VALUE rv = rb_ary_new2 (len);
1779   for (i = 0; r[i] != NULL; ++i) {
1780     rb_ary_push (rv, rb_str_new2 (r[i]));
1781     free (r[i]);
1782   }
1783   free (r);
1784   return rv;
1785 }
1786
1787 static VALUE ruby_guestfs_aug_init (VALUE gv, VALUE rootv, VALUE flagsv)
1788 {
1789   guestfs_h *g;
1790   Data_Get_Struct (gv, guestfs_h, g);
1791   if (!g)
1792     rb_raise (rb_eArgError, "%s: used handle after closing it", "aug_init");
1793
1794   Check_Type (rootv, T_STRING);
1795   const char *root = StringValueCStr (rootv);
1796   if (!root)
1797     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1798               "root", "aug_init");
1799   int flags = NUM2INT (flagsv);
1800
1801   int r;
1802
1803   r = guestfs_aug_init (g, root, flags);
1804   if (r == -1)
1805     rb_raise (e_Error, "%s", guestfs_last_error (g));
1806
1807   return Qnil;
1808 }
1809
1810 static VALUE ruby_guestfs_aug_close (VALUE gv)
1811 {
1812   guestfs_h *g;
1813   Data_Get_Struct (gv, guestfs_h, g);
1814   if (!g)
1815     rb_raise (rb_eArgError, "%s: used handle after closing it", "aug_close");
1816
1817
1818   int r;
1819
1820   r = guestfs_aug_close (g);
1821   if (r == -1)
1822     rb_raise (e_Error, "%s", guestfs_last_error (g));
1823
1824   return Qnil;
1825 }
1826
1827 static VALUE ruby_guestfs_aug_defvar (VALUE gv, VALUE namev, VALUE exprv)
1828 {
1829   guestfs_h *g;
1830   Data_Get_Struct (gv, guestfs_h, g);
1831   if (!g)
1832     rb_raise (rb_eArgError, "%s: used handle after closing it", "aug_defvar");
1833
1834   Check_Type (namev, T_STRING);
1835   const char *name = StringValueCStr (namev);
1836   if (!name)
1837     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1838               "name", "aug_defvar");
1839   const char *expr = !NIL_P (exprv) ? StringValueCStr (exprv) : NULL;
1840
1841   int r;
1842
1843   r = guestfs_aug_defvar (g, name, expr);
1844   if (r == -1)
1845     rb_raise (e_Error, "%s", guestfs_last_error (g));
1846
1847   return INT2NUM (r);
1848 }
1849
1850 static VALUE ruby_guestfs_aug_defnode (VALUE gv, VALUE namev, VALUE exprv, VALUE valv)
1851 {
1852   guestfs_h *g;
1853   Data_Get_Struct (gv, guestfs_h, g);
1854   if (!g)
1855     rb_raise (rb_eArgError, "%s: used handle after closing it", "aug_defnode");
1856
1857   Check_Type (namev, T_STRING);
1858   const char *name = StringValueCStr (namev);
1859   if (!name)
1860     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1861               "name", "aug_defnode");
1862   Check_Type (exprv, T_STRING);
1863   const char *expr = StringValueCStr (exprv);
1864   if (!expr)
1865     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1866               "expr", "aug_defnode");
1867   Check_Type (valv, T_STRING);
1868   const char *val = StringValueCStr (valv);
1869   if (!val)
1870     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1871               "val", "aug_defnode");
1872
1873   struct guestfs_int_bool *r;
1874
1875   r = guestfs_aug_defnode (g, name, expr, val);
1876   if (r == NULL)
1877     rb_raise (e_Error, "%s", guestfs_last_error (g));
1878
1879   VALUE rv = rb_ary_new2 (2);
1880   rb_ary_push (rv, INT2NUM (r->i));
1881   rb_ary_push (rv, INT2NUM (r->b));
1882   guestfs_free_int_bool (r);
1883   return rv;
1884 }
1885
1886 static VALUE ruby_guestfs_aug_get (VALUE gv, VALUE pathv)
1887 {
1888   guestfs_h *g;
1889   Data_Get_Struct (gv, guestfs_h, g);
1890   if (!g)
1891     rb_raise (rb_eArgError, "%s: used handle after closing it", "aug_get");
1892
1893   Check_Type (pathv, T_STRING);
1894   const char *path = StringValueCStr (pathv);
1895   if (!path)
1896     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1897               "path", "aug_get");
1898
1899   char *r;
1900
1901   r = guestfs_aug_get (g, path);
1902   if (r == NULL)
1903     rb_raise (e_Error, "%s", guestfs_last_error (g));
1904
1905   VALUE rv = rb_str_new2 (r);
1906   free (r);
1907   return rv;
1908 }
1909
1910 static VALUE ruby_guestfs_aug_set (VALUE gv, VALUE pathv, VALUE valv)
1911 {
1912   guestfs_h *g;
1913   Data_Get_Struct (gv, guestfs_h, g);
1914   if (!g)
1915     rb_raise (rb_eArgError, "%s: used handle after closing it", "aug_set");
1916
1917   Check_Type (pathv, T_STRING);
1918   const char *path = StringValueCStr (pathv);
1919   if (!path)
1920     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1921               "path", "aug_set");
1922   Check_Type (valv, T_STRING);
1923   const char *val = StringValueCStr (valv);
1924   if (!val)
1925     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1926               "val", "aug_set");
1927
1928   int r;
1929
1930   r = guestfs_aug_set (g, path, val);
1931   if (r == -1)
1932     rb_raise (e_Error, "%s", guestfs_last_error (g));
1933
1934   return Qnil;
1935 }
1936
1937 static VALUE ruby_guestfs_aug_insert (VALUE gv, VALUE pathv, VALUE labelv, VALUE beforev)
1938 {
1939   guestfs_h *g;
1940   Data_Get_Struct (gv, guestfs_h, g);
1941   if (!g)
1942     rb_raise (rb_eArgError, "%s: used handle after closing it", "aug_insert");
1943
1944   Check_Type (pathv, T_STRING);
1945   const char *path = StringValueCStr (pathv);
1946   if (!path)
1947     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1948               "path", "aug_insert");
1949   Check_Type (labelv, T_STRING);
1950   const char *label = StringValueCStr (labelv);
1951   if (!label)
1952     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1953               "label", "aug_insert");
1954   int before = RTEST (beforev);
1955
1956   int r;
1957
1958   r = guestfs_aug_insert (g, path, label, before);
1959   if (r == -1)
1960     rb_raise (e_Error, "%s", guestfs_last_error (g));
1961
1962   return Qnil;
1963 }
1964
1965 static VALUE ruby_guestfs_aug_rm (VALUE gv, VALUE pathv)
1966 {
1967   guestfs_h *g;
1968   Data_Get_Struct (gv, guestfs_h, g);
1969   if (!g)
1970     rb_raise (rb_eArgError, "%s: used handle after closing it", "aug_rm");
1971
1972   Check_Type (pathv, T_STRING);
1973   const char *path = StringValueCStr (pathv);
1974   if (!path)
1975     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1976               "path", "aug_rm");
1977
1978   int r;
1979
1980   r = guestfs_aug_rm (g, path);
1981   if (r == -1)
1982     rb_raise (e_Error, "%s", guestfs_last_error (g));
1983
1984   return INT2NUM (r);
1985 }
1986
1987 static VALUE ruby_guestfs_aug_mv (VALUE gv, VALUE srcv, VALUE destv)
1988 {
1989   guestfs_h *g;
1990   Data_Get_Struct (gv, guestfs_h, g);
1991   if (!g)
1992     rb_raise (rb_eArgError, "%s: used handle after closing it", "aug_mv");
1993
1994   Check_Type (srcv, T_STRING);
1995   const char *src = StringValueCStr (srcv);
1996   if (!src)
1997     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1998               "src", "aug_mv");
1999   Check_Type (destv, T_STRING);
2000   const char *dest = StringValueCStr (destv);
2001   if (!dest)
2002     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2003               "dest", "aug_mv");
2004
2005   int r;
2006
2007   r = guestfs_aug_mv (g, src, dest);
2008   if (r == -1)
2009     rb_raise (e_Error, "%s", guestfs_last_error (g));
2010
2011   return Qnil;
2012 }
2013
2014 static VALUE ruby_guestfs_aug_match (VALUE gv, VALUE pathv)
2015 {
2016   guestfs_h *g;
2017   Data_Get_Struct (gv, guestfs_h, g);
2018   if (!g)
2019     rb_raise (rb_eArgError, "%s: used handle after closing it", "aug_match");
2020
2021   Check_Type (pathv, T_STRING);
2022   const char *path = StringValueCStr (pathv);
2023   if (!path)
2024     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2025               "path", "aug_match");
2026
2027   char **r;
2028
2029   r = guestfs_aug_match (g, path);
2030   if (r == NULL)
2031     rb_raise (e_Error, "%s", guestfs_last_error (g));
2032
2033   int i, len = 0;
2034   for (i = 0; r[i] != NULL; ++i) len++;
2035   VALUE rv = rb_ary_new2 (len);
2036   for (i = 0; r[i] != NULL; ++i) {
2037     rb_ary_push (rv, rb_str_new2 (r[i]));
2038     free (r[i]);
2039   }
2040   free (r);
2041   return rv;
2042 }
2043
2044 static VALUE ruby_guestfs_aug_save (VALUE gv)
2045 {
2046   guestfs_h *g;
2047   Data_Get_Struct (gv, guestfs_h, g);
2048   if (!g)
2049     rb_raise (rb_eArgError, "%s: used handle after closing it", "aug_save");
2050
2051
2052   int r;
2053
2054   r = guestfs_aug_save (g);
2055   if (r == -1)
2056     rb_raise (e_Error, "%s", guestfs_last_error (g));
2057
2058   return Qnil;
2059 }
2060
2061 static VALUE ruby_guestfs_aug_load (VALUE gv)
2062 {
2063   guestfs_h *g;
2064   Data_Get_Struct (gv, guestfs_h, g);
2065   if (!g)
2066     rb_raise (rb_eArgError, "%s: used handle after closing it", "aug_load");
2067
2068
2069   int r;
2070
2071   r = guestfs_aug_load (g);
2072   if (r == -1)
2073     rb_raise (e_Error, "%s", guestfs_last_error (g));
2074
2075   return Qnil;
2076 }
2077
2078 static VALUE ruby_guestfs_aug_ls (VALUE gv, VALUE pathv)
2079 {
2080   guestfs_h *g;
2081   Data_Get_Struct (gv, guestfs_h, g);
2082   if (!g)
2083     rb_raise (rb_eArgError, "%s: used handle after closing it", "aug_ls");
2084
2085   Check_Type (pathv, T_STRING);
2086   const char *path = StringValueCStr (pathv);
2087   if (!path)
2088     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2089               "path", "aug_ls");
2090
2091   char **r;
2092
2093   r = guestfs_aug_ls (g, path);
2094   if (r == NULL)
2095     rb_raise (e_Error, "%s", guestfs_last_error (g));
2096
2097   int i, len = 0;
2098   for (i = 0; r[i] != NULL; ++i) len++;
2099   VALUE rv = rb_ary_new2 (len);
2100   for (i = 0; r[i] != NULL; ++i) {
2101     rb_ary_push (rv, rb_str_new2 (r[i]));
2102     free (r[i]);
2103   }
2104   free (r);
2105   return rv;
2106 }
2107
2108 static VALUE ruby_guestfs_rm (VALUE gv, VALUE pathv)
2109 {
2110   guestfs_h *g;
2111   Data_Get_Struct (gv, guestfs_h, g);
2112   if (!g)
2113     rb_raise (rb_eArgError, "%s: used handle after closing it", "rm");
2114
2115   Check_Type (pathv, T_STRING);
2116   const char *path = StringValueCStr (pathv);
2117   if (!path)
2118     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2119               "path", "rm");
2120
2121   int r;
2122
2123   r = guestfs_rm (g, path);
2124   if (r == -1)
2125     rb_raise (e_Error, "%s", guestfs_last_error (g));
2126
2127   return Qnil;
2128 }
2129
2130 static VALUE ruby_guestfs_rmdir (VALUE gv, VALUE pathv)
2131 {
2132   guestfs_h *g;
2133   Data_Get_Struct (gv, guestfs_h, g);
2134   if (!g)
2135     rb_raise (rb_eArgError, "%s: used handle after closing it", "rmdir");
2136
2137   Check_Type (pathv, T_STRING);
2138   const char *path = StringValueCStr (pathv);
2139   if (!path)
2140     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2141               "path", "rmdir");
2142
2143   int r;
2144
2145   r = guestfs_rmdir (g, path);
2146   if (r == -1)
2147     rb_raise (e_Error, "%s", guestfs_last_error (g));
2148
2149   return Qnil;
2150 }
2151
2152 static VALUE ruby_guestfs_rm_rf (VALUE gv, VALUE pathv)
2153 {
2154   guestfs_h *g;
2155   Data_Get_Struct (gv, guestfs_h, g);
2156   if (!g)
2157     rb_raise (rb_eArgError, "%s: used handle after closing it", "rm_rf");
2158
2159   Check_Type (pathv, T_STRING);
2160   const char *path = StringValueCStr (pathv);
2161   if (!path)
2162     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2163               "path", "rm_rf");
2164
2165   int r;
2166
2167   r = guestfs_rm_rf (g, path);
2168   if (r == -1)
2169     rb_raise (e_Error, "%s", guestfs_last_error (g));
2170
2171   return Qnil;
2172 }
2173
2174 static VALUE ruby_guestfs_mkdir (VALUE gv, VALUE pathv)
2175 {
2176   guestfs_h *g;
2177   Data_Get_Struct (gv, guestfs_h, g);
2178   if (!g)
2179     rb_raise (rb_eArgError, "%s: used handle after closing it", "mkdir");
2180
2181   Check_Type (pathv, T_STRING);
2182   const char *path = StringValueCStr (pathv);
2183   if (!path)
2184     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2185               "path", "mkdir");
2186
2187   int r;
2188
2189   r = guestfs_mkdir (g, path);
2190   if (r == -1)
2191     rb_raise (e_Error, "%s", guestfs_last_error (g));
2192
2193   return Qnil;
2194 }
2195
2196 static VALUE ruby_guestfs_mkdir_p (VALUE gv, VALUE pathv)
2197 {
2198   guestfs_h *g;
2199   Data_Get_Struct (gv, guestfs_h, g);
2200   if (!g)
2201     rb_raise (rb_eArgError, "%s: used handle after closing it", "mkdir_p");
2202
2203   Check_Type (pathv, T_STRING);
2204   const char *path = StringValueCStr (pathv);
2205   if (!path)
2206     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2207               "path", "mkdir_p");
2208
2209   int r;
2210
2211   r = guestfs_mkdir_p (g, path);
2212   if (r == -1)
2213     rb_raise (e_Error, "%s", guestfs_last_error (g));
2214
2215   return Qnil;
2216 }
2217
2218 static VALUE ruby_guestfs_chmod (VALUE gv, VALUE modev, VALUE pathv)
2219 {
2220   guestfs_h *g;
2221   Data_Get_Struct (gv, guestfs_h, g);
2222   if (!g)
2223     rb_raise (rb_eArgError, "%s: used handle after closing it", "chmod");
2224
2225   int mode = NUM2INT (modev);
2226   Check_Type (pathv, T_STRING);
2227   const char *path = StringValueCStr (pathv);
2228   if (!path)
2229     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2230               "path", "chmod");
2231
2232   int r;
2233
2234   r = guestfs_chmod (g, mode, path);
2235   if (r == -1)
2236     rb_raise (e_Error, "%s", guestfs_last_error (g));
2237
2238   return Qnil;
2239 }
2240
2241 static VALUE ruby_guestfs_chown (VALUE gv, VALUE ownerv, VALUE groupv, VALUE pathv)
2242 {
2243   guestfs_h *g;
2244   Data_Get_Struct (gv, guestfs_h, g);
2245   if (!g)
2246     rb_raise (rb_eArgError, "%s: used handle after closing it", "chown");
2247
2248   int owner = NUM2INT (ownerv);
2249   int group = NUM2INT (groupv);
2250   Check_Type (pathv, T_STRING);
2251   const char *path = StringValueCStr (pathv);
2252   if (!path)
2253     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2254               "path", "chown");
2255
2256   int r;
2257
2258   r = guestfs_chown (g, owner, group, path);
2259   if (r == -1)
2260     rb_raise (e_Error, "%s", guestfs_last_error (g));
2261
2262   return Qnil;
2263 }
2264
2265 static VALUE ruby_guestfs_exists (VALUE gv, VALUE pathv)
2266 {
2267   guestfs_h *g;
2268   Data_Get_Struct (gv, guestfs_h, g);
2269   if (!g)
2270     rb_raise (rb_eArgError, "%s: used handle after closing it", "exists");
2271
2272   Check_Type (pathv, T_STRING);
2273   const char *path = StringValueCStr (pathv);
2274   if (!path)
2275     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2276               "path", "exists");
2277
2278   int r;
2279
2280   r = guestfs_exists (g, path);
2281   if (r == -1)
2282     rb_raise (e_Error, "%s", guestfs_last_error (g));
2283
2284   return INT2NUM (r);
2285 }
2286
2287 static VALUE ruby_guestfs_is_file (VALUE gv, VALUE pathv)
2288 {
2289   guestfs_h *g;
2290   Data_Get_Struct (gv, guestfs_h, g);
2291   if (!g)
2292     rb_raise (rb_eArgError, "%s: used handle after closing it", "is_file");
2293
2294   Check_Type (pathv, T_STRING);
2295   const char *path = StringValueCStr (pathv);
2296   if (!path)
2297     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2298               "path", "is_file");
2299
2300   int r;
2301
2302   r = guestfs_is_file (g, path);
2303   if (r == -1)
2304     rb_raise (e_Error, "%s", guestfs_last_error (g));
2305
2306   return INT2NUM (r);
2307 }
2308
2309 static VALUE ruby_guestfs_is_dir (VALUE gv, VALUE pathv)
2310 {
2311   guestfs_h *g;
2312   Data_Get_Struct (gv, guestfs_h, g);
2313   if (!g)
2314     rb_raise (rb_eArgError, "%s: used handle after closing it", "is_dir");
2315
2316   Check_Type (pathv, T_STRING);
2317   const char *path = StringValueCStr (pathv);
2318   if (!path)
2319     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2320               "path", "is_dir");
2321
2322   int r;
2323
2324   r = guestfs_is_dir (g, path);
2325   if (r == -1)
2326     rb_raise (e_Error, "%s", guestfs_last_error (g));
2327
2328   return INT2NUM (r);
2329 }
2330
2331 static VALUE ruby_guestfs_pvcreate (VALUE gv, VALUE devicev)
2332 {
2333   guestfs_h *g;
2334   Data_Get_Struct (gv, guestfs_h, g);
2335   if (!g)
2336     rb_raise (rb_eArgError, "%s: used handle after closing it", "pvcreate");
2337
2338   Check_Type (devicev, T_STRING);
2339   const char *device = StringValueCStr (devicev);
2340   if (!device)
2341     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2342               "device", "pvcreate");
2343
2344   int r;
2345
2346   r = guestfs_pvcreate (g, device);
2347   if (r == -1)
2348     rb_raise (e_Error, "%s", guestfs_last_error (g));
2349
2350   return Qnil;
2351 }
2352
2353 static VALUE ruby_guestfs_vgcreate (VALUE gv, VALUE volgroupv, VALUE physvolsv)
2354 {
2355   guestfs_h *g;
2356   Data_Get_Struct (gv, guestfs_h, g);
2357   if (!g)
2358     rb_raise (rb_eArgError, "%s: used handle after closing it", "vgcreate");
2359
2360   Check_Type (volgroupv, T_STRING);
2361   const char *volgroup = StringValueCStr (volgroupv);
2362   if (!volgroup)
2363     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2364               "volgroup", "vgcreate");
2365   char **physvols;
2366   Check_Type (physvolsv, T_ARRAY);
2367   {
2368     int i, len;
2369     len = RARRAY_LEN (physvolsv);
2370     physvols = guestfs_safe_malloc (g, sizeof (char *) * (len+1));
2371     for (i = 0; i < len; ++i) {
2372       VALUE v = rb_ary_entry (physvolsv, i);
2373       physvols[i] = StringValueCStr (v);
2374     }
2375     physvols[len] = NULL;
2376   }
2377
2378   int r;
2379
2380   r = guestfs_vgcreate (g, volgroup, physvols);
2381   free (physvols);
2382   if (r == -1)
2383     rb_raise (e_Error, "%s", guestfs_last_error (g));
2384
2385   return Qnil;
2386 }
2387
2388 static VALUE ruby_guestfs_lvcreate (VALUE gv, VALUE logvolv, VALUE volgroupv, VALUE mbytesv)
2389 {
2390   guestfs_h *g;
2391   Data_Get_Struct (gv, guestfs_h, g);
2392   if (!g)
2393     rb_raise (rb_eArgError, "%s: used handle after closing it", "lvcreate");
2394
2395   Check_Type (logvolv, T_STRING);
2396   const char *logvol = StringValueCStr (logvolv);
2397   if (!logvol)
2398     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2399               "logvol", "lvcreate");
2400   Check_Type (volgroupv, T_STRING);
2401   const char *volgroup = StringValueCStr (volgroupv);
2402   if (!volgroup)
2403     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2404               "volgroup", "lvcreate");
2405   int mbytes = NUM2INT (mbytesv);
2406
2407   int r;
2408
2409   r = guestfs_lvcreate (g, logvol, volgroup, mbytes);
2410   if (r == -1)
2411     rb_raise (e_Error, "%s", guestfs_last_error (g));
2412
2413   return Qnil;
2414 }
2415
2416 static VALUE ruby_guestfs_mkfs (VALUE gv, VALUE fstypev, VALUE devicev)
2417 {
2418   guestfs_h *g;
2419   Data_Get_Struct (gv, guestfs_h, g);
2420   if (!g)
2421     rb_raise (rb_eArgError, "%s: used handle after closing it", "mkfs");
2422
2423   Check_Type (fstypev, T_STRING);
2424   const char *fstype = StringValueCStr (fstypev);
2425   if (!fstype)
2426     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2427               "fstype", "mkfs");
2428   Check_Type (devicev, T_STRING);
2429   const char *device = StringValueCStr (devicev);
2430   if (!device)
2431     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2432               "device", "mkfs");
2433
2434   int r;
2435
2436   r = guestfs_mkfs (g, fstype, device);
2437   if (r == -1)
2438     rb_raise (e_Error, "%s", guestfs_last_error (g));
2439
2440   return Qnil;
2441 }
2442
2443 static VALUE ruby_guestfs_sfdisk (VALUE gv, VALUE devicev, VALUE cylsv, VALUE headsv, VALUE sectorsv, VALUE linesv)
2444 {
2445   guestfs_h *g;
2446   Data_Get_Struct (gv, guestfs_h, g);
2447   if (!g)
2448     rb_raise (rb_eArgError, "%s: used handle after closing it", "sfdisk");
2449
2450   Check_Type (devicev, T_STRING);
2451   const char *device = StringValueCStr (devicev);
2452   if (!device)
2453     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2454               "device", "sfdisk");
2455   int cyls = NUM2INT (cylsv);
2456   int heads = NUM2INT (headsv);
2457   int sectors = NUM2INT (sectorsv);
2458   char **lines;
2459   Check_Type (linesv, T_ARRAY);
2460   {
2461     int i, len;
2462     len = RARRAY_LEN (linesv);
2463     lines = guestfs_safe_malloc (g, sizeof (char *) * (len+1));
2464     for (i = 0; i < len; ++i) {
2465       VALUE v = rb_ary_entry (linesv, i);
2466       lines[i] = StringValueCStr (v);
2467     }
2468     lines[len] = NULL;
2469   }
2470
2471   int r;
2472
2473   r = guestfs_sfdisk (g, device, cyls, heads, sectors, lines);
2474   free (lines);
2475   if (r == -1)
2476     rb_raise (e_Error, "%s", guestfs_last_error (g));
2477
2478   return Qnil;
2479 }
2480
2481 static VALUE ruby_guestfs_write_file (VALUE gv, VALUE pathv, VALUE contentv, VALUE sizev)
2482 {
2483   guestfs_h *g;
2484   Data_Get_Struct (gv, guestfs_h, g);
2485   if (!g)
2486     rb_raise (rb_eArgError, "%s: used handle after closing it", "write_file");
2487
2488   Check_Type (pathv, T_STRING);
2489   const char *path = StringValueCStr (pathv);
2490   if (!path)
2491     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2492               "path", "write_file");
2493   Check_Type (contentv, T_STRING);
2494   const char *content = StringValueCStr (contentv);
2495   if (!content)
2496     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2497               "content", "write_file");
2498   int size = NUM2INT (sizev);
2499
2500   int r;
2501
2502   r = guestfs_write_file (g, path, content, size);
2503   if (r == -1)
2504     rb_raise (e_Error, "%s", guestfs_last_error (g));
2505
2506   return Qnil;
2507 }
2508
2509 static VALUE ruby_guestfs_umount (VALUE gv, VALUE pathordevicev)
2510 {
2511   guestfs_h *g;
2512   Data_Get_Struct (gv, guestfs_h, g);
2513   if (!g)
2514     rb_raise (rb_eArgError, "%s: used handle after closing it", "umount");
2515
2516   Check_Type (pathordevicev, T_STRING);
2517   const char *pathordevice = StringValueCStr (pathordevicev);
2518   if (!pathordevice)
2519     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2520               "pathordevice", "umount");
2521
2522   int r;
2523
2524   r = guestfs_umount (g, pathordevice);
2525   if (r == -1)
2526     rb_raise (e_Error, "%s", guestfs_last_error (g));
2527
2528   return Qnil;
2529 }
2530
2531 static VALUE ruby_guestfs_mounts (VALUE gv)
2532 {
2533   guestfs_h *g;
2534   Data_Get_Struct (gv, guestfs_h, g);
2535   if (!g)
2536     rb_raise (rb_eArgError, "%s: used handle after closing it", "mounts");
2537
2538
2539   char **r;
2540
2541   r = guestfs_mounts (g);
2542   if (r == NULL)
2543     rb_raise (e_Error, "%s", guestfs_last_error (g));
2544
2545   int i, len = 0;
2546   for (i = 0; r[i] != NULL; ++i) len++;
2547   VALUE rv = rb_ary_new2 (len);
2548   for (i = 0; r[i] != NULL; ++i) {
2549     rb_ary_push (rv, rb_str_new2 (r[i]));
2550     free (r[i]);
2551   }
2552   free (r);
2553   return rv;
2554 }
2555
2556 static VALUE ruby_guestfs_umount_all (VALUE gv)
2557 {
2558   guestfs_h *g;
2559   Data_Get_Struct (gv, guestfs_h, g);
2560   if (!g)
2561     rb_raise (rb_eArgError, "%s: used handle after closing it", "umount_all");
2562
2563
2564   int r;
2565
2566   r = guestfs_umount_all (g);
2567   if (r == -1)
2568     rb_raise (e_Error, "%s", guestfs_last_error (g));
2569
2570   return Qnil;
2571 }
2572
2573 static VALUE ruby_guestfs_lvm_remove_all (VALUE gv)
2574 {
2575   guestfs_h *g;
2576   Data_Get_Struct (gv, guestfs_h, g);
2577   if (!g)
2578     rb_raise (rb_eArgError, "%s: used handle after closing it", "lvm_remove_all");
2579
2580
2581   int r;
2582
2583   r = guestfs_lvm_remove_all (g);
2584   if (r == -1)
2585     rb_raise (e_Error, "%s", guestfs_last_error (g));
2586
2587   return Qnil;
2588 }
2589
2590 static VALUE ruby_guestfs_file (VALUE gv, VALUE pathv)
2591 {
2592   guestfs_h *g;
2593   Data_Get_Struct (gv, guestfs_h, g);
2594   if (!g)
2595     rb_raise (rb_eArgError, "%s: used handle after closing it", "file");
2596
2597   Check_Type (pathv, T_STRING);
2598   const char *path = StringValueCStr (pathv);
2599   if (!path)
2600     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2601               "path", "file");
2602
2603   char *r;
2604
2605   r = guestfs_file (g, path);
2606   if (r == NULL)
2607     rb_raise (e_Error, "%s", guestfs_last_error (g));
2608
2609   VALUE rv = rb_str_new2 (r);
2610   free (r);
2611   return rv;
2612 }
2613
2614 static VALUE ruby_guestfs_command (VALUE gv, VALUE argumentsv)
2615 {
2616   guestfs_h *g;
2617   Data_Get_Struct (gv, guestfs_h, g);
2618   if (!g)
2619     rb_raise (rb_eArgError, "%s: used handle after closing it", "command");
2620
2621   char **arguments;
2622   Check_Type (argumentsv, T_ARRAY);
2623   {
2624     int i, len;
2625     len = RARRAY_LEN (argumentsv);
2626     arguments = guestfs_safe_malloc (g, sizeof (char *) * (len+1));
2627     for (i = 0; i < len; ++i) {
2628       VALUE v = rb_ary_entry (argumentsv, i);
2629       arguments[i] = StringValueCStr (v);
2630     }
2631     arguments[len] = NULL;
2632   }
2633
2634   char *r;
2635
2636   r = guestfs_command (g, arguments);
2637   free (arguments);
2638   if (r == NULL)
2639     rb_raise (e_Error, "%s", guestfs_last_error (g));
2640
2641   VALUE rv = rb_str_new2 (r);
2642   free (r);
2643   return rv;
2644 }
2645
2646 static VALUE ruby_guestfs_command_lines (VALUE gv, VALUE argumentsv)
2647 {
2648   guestfs_h *g;
2649   Data_Get_Struct (gv, guestfs_h, g);
2650   if (!g)
2651     rb_raise (rb_eArgError, "%s: used handle after closing it", "command_lines");
2652
2653   char **arguments;
2654   Check_Type (argumentsv, T_ARRAY);
2655   {
2656     int i, len;
2657     len = RARRAY_LEN (argumentsv);
2658     arguments = guestfs_safe_malloc (g, sizeof (char *) * (len+1));
2659     for (i = 0; i < len; ++i) {
2660       VALUE v = rb_ary_entry (argumentsv, i);
2661       arguments[i] = StringValueCStr (v);
2662     }
2663     arguments[len] = NULL;
2664   }
2665
2666   char **r;
2667
2668   r = guestfs_command_lines (g, arguments);
2669   free (arguments);
2670   if (r == NULL)
2671     rb_raise (e_Error, "%s", guestfs_last_error (g));
2672
2673   int i, len = 0;
2674   for (i = 0; r[i] != NULL; ++i) len++;
2675   VALUE rv = rb_ary_new2 (len);
2676   for (i = 0; r[i] != NULL; ++i) {
2677     rb_ary_push (rv, rb_str_new2 (r[i]));
2678     free (r[i]);
2679   }
2680   free (r);
2681   return rv;
2682 }
2683
2684 static VALUE ruby_guestfs_stat (VALUE gv, VALUE pathv)
2685 {
2686   guestfs_h *g;
2687   Data_Get_Struct (gv, guestfs_h, g);
2688   if (!g)
2689     rb_raise (rb_eArgError, "%s: used handle after closing it", "stat");
2690
2691   Check_Type (pathv, T_STRING);
2692   const char *path = StringValueCStr (pathv);
2693   if (!path)
2694     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2695               "path", "stat");
2696
2697   struct guestfs_stat *r;
2698
2699   r = guestfs_stat (g, path);
2700   if (r == NULL)
2701     rb_raise (e_Error, "%s", guestfs_last_error (g));
2702
2703   VALUE rv = rb_hash_new ();
2704   rb_hash_aset (rv, rb_str_new2 ("dev"), ULL2NUM (r->dev));
2705   rb_hash_aset (rv, rb_str_new2 ("ino"), ULL2NUM (r->ino));
2706   rb_hash_aset (rv, rb_str_new2 ("mode"), ULL2NUM (r->mode));
2707   rb_hash_aset (rv, rb_str_new2 ("nlink"), ULL2NUM (r->nlink));
2708   rb_hash_aset (rv, rb_str_new2 ("uid"), ULL2NUM (r->uid));
2709   rb_hash_aset (rv, rb_str_new2 ("gid"), ULL2NUM (r->gid));
2710   rb_hash_aset (rv, rb_str_new2 ("rdev"), ULL2NUM (r->rdev));
2711   rb_hash_aset (rv, rb_str_new2 ("size"), ULL2NUM (r->size));
2712   rb_hash_aset (rv, rb_str_new2 ("blksize"), ULL2NUM (r->blksize));
2713   rb_hash_aset (rv, rb_str_new2 ("blocks"), ULL2NUM (r->blocks));
2714   rb_hash_aset (rv, rb_str_new2 ("atime"), ULL2NUM (r->atime));
2715   rb_hash_aset (rv, rb_str_new2 ("mtime"), ULL2NUM (r->mtime));
2716   rb_hash_aset (rv, rb_str_new2 ("ctime"), ULL2NUM (r->ctime));
2717   free (r);
2718   return rv;
2719 }
2720
2721 static VALUE ruby_guestfs_lstat (VALUE gv, VALUE pathv)
2722 {
2723   guestfs_h *g;
2724   Data_Get_Struct (gv, guestfs_h, g);
2725   if (!g)
2726     rb_raise (rb_eArgError, "%s: used handle after closing it", "lstat");
2727
2728   Check_Type (pathv, T_STRING);
2729   const char *path = StringValueCStr (pathv);
2730   if (!path)
2731     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2732               "path", "lstat");
2733
2734   struct guestfs_stat *r;
2735
2736   r = guestfs_lstat (g, path);
2737   if (r == NULL)
2738     rb_raise (e_Error, "%s", guestfs_last_error (g));
2739
2740   VALUE rv = rb_hash_new ();
2741   rb_hash_aset (rv, rb_str_new2 ("dev"), ULL2NUM (r->dev));
2742   rb_hash_aset (rv, rb_str_new2 ("ino"), ULL2NUM (r->ino));
2743   rb_hash_aset (rv, rb_str_new2 ("mode"), ULL2NUM (r->mode));
2744   rb_hash_aset (rv, rb_str_new2 ("nlink"), ULL2NUM (r->nlink));
2745   rb_hash_aset (rv, rb_str_new2 ("uid"), ULL2NUM (r->uid));
2746   rb_hash_aset (rv, rb_str_new2 ("gid"), ULL2NUM (r->gid));
2747   rb_hash_aset (rv, rb_str_new2 ("rdev"), ULL2NUM (r->rdev));
2748   rb_hash_aset (rv, rb_str_new2 ("size"), ULL2NUM (r->size));
2749   rb_hash_aset (rv, rb_str_new2 ("blksize"), ULL2NUM (r->blksize));
2750   rb_hash_aset (rv, rb_str_new2 ("blocks"), ULL2NUM (r->blocks));
2751   rb_hash_aset (rv, rb_str_new2 ("atime"), ULL2NUM (r->atime));
2752   rb_hash_aset (rv, rb_str_new2 ("mtime"), ULL2NUM (r->mtime));
2753   rb_hash_aset (rv, rb_str_new2 ("ctime"), ULL2NUM (r->ctime));
2754   free (r);
2755   return rv;
2756 }
2757
2758 static VALUE ruby_guestfs_statvfs (VALUE gv, VALUE pathv)
2759 {
2760   guestfs_h *g;
2761   Data_Get_Struct (gv, guestfs_h, g);
2762   if (!g)
2763     rb_raise (rb_eArgError, "%s: used handle after closing it", "statvfs");
2764
2765   Check_Type (pathv, T_STRING);
2766   const char *path = StringValueCStr (pathv);
2767   if (!path)
2768     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2769               "path", "statvfs");
2770
2771   struct guestfs_statvfs *r;
2772
2773   r = guestfs_statvfs (g, path);
2774   if (r == NULL)
2775     rb_raise (e_Error, "%s", guestfs_last_error (g));
2776
2777   VALUE rv = rb_hash_new ();
2778   rb_hash_aset (rv, rb_str_new2 ("bsize"), ULL2NUM (r->bsize));
2779   rb_hash_aset (rv, rb_str_new2 ("frsize"), ULL2NUM (r->frsize));
2780   rb_hash_aset (rv, rb_str_new2 ("blocks"), ULL2NUM (r->blocks));
2781   rb_hash_aset (rv, rb_str_new2 ("bfree"), ULL2NUM (r->bfree));
2782   rb_hash_aset (rv, rb_str_new2 ("bavail"), ULL2NUM (r->bavail));
2783   rb_hash_aset (rv, rb_str_new2 ("files"), ULL2NUM (r->files));
2784   rb_hash_aset (rv, rb_str_new2 ("ffree"), ULL2NUM (r->ffree));
2785   rb_hash_aset (rv, rb_str_new2 ("favail"), ULL2NUM (r->favail));
2786   rb_hash_aset (rv, rb_str_new2 ("fsid"), ULL2NUM (r->fsid));
2787   rb_hash_aset (rv, rb_str_new2 ("flag"), ULL2NUM (r->flag));
2788   rb_hash_aset (rv, rb_str_new2 ("namemax"), ULL2NUM (r->namemax));
2789   free (r);
2790   return rv;
2791 }
2792
2793 static VALUE ruby_guestfs_tune2fs_l (VALUE gv, VALUE devicev)
2794 {
2795   guestfs_h *g;
2796   Data_Get_Struct (gv, guestfs_h, g);
2797   if (!g)
2798     rb_raise (rb_eArgError, "%s: used handle after closing it", "tune2fs_l");
2799
2800   Check_Type (devicev, T_STRING);
2801   const char *device = StringValueCStr (devicev);
2802   if (!device)
2803     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2804               "device", "tune2fs_l");
2805
2806   char **r;
2807
2808   r = guestfs_tune2fs_l (g, device);
2809   if (r == NULL)
2810     rb_raise (e_Error, "%s", guestfs_last_error (g));
2811
2812   VALUE rv = rb_hash_new ();
2813   int i;
2814   for (i = 0; r[i] != NULL; i+=2) {
2815     rb_hash_aset (rv, rb_str_new2 (r[i]), rb_str_new2 (r[i+1]));
2816     free (r[i]);
2817     free (r[i+1]);
2818   }
2819   free (r);
2820   return rv;
2821 }
2822
2823 static VALUE ruby_guestfs_blockdev_setro (VALUE gv, VALUE devicev)
2824 {
2825   guestfs_h *g;
2826   Data_Get_Struct (gv, guestfs_h, g);
2827   if (!g)
2828     rb_raise (rb_eArgError, "%s: used handle after closing it", "blockdev_setro");
2829
2830   Check_Type (devicev, T_STRING);
2831   const char *device = StringValueCStr (devicev);
2832   if (!device)
2833     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2834               "device", "blockdev_setro");
2835
2836   int r;
2837
2838   r = guestfs_blockdev_setro (g, device);
2839   if (r == -1)
2840     rb_raise (e_Error, "%s", guestfs_last_error (g));
2841
2842   return Qnil;
2843 }
2844
2845 static VALUE ruby_guestfs_blockdev_setrw (VALUE gv, VALUE devicev)
2846 {
2847   guestfs_h *g;
2848   Data_Get_Struct (gv, guestfs_h, g);
2849   if (!g)
2850     rb_raise (rb_eArgError, "%s: used handle after closing it", "blockdev_setrw");
2851
2852   Check_Type (devicev, T_STRING);
2853   const char *device = StringValueCStr (devicev);
2854   if (!device)
2855     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2856               "device", "blockdev_setrw");
2857
2858   int r;
2859
2860   r = guestfs_blockdev_setrw (g, device);
2861   if (r == -1)
2862     rb_raise (e_Error, "%s", guestfs_last_error (g));
2863
2864   return Qnil;
2865 }
2866
2867 static VALUE ruby_guestfs_blockdev_getro (VALUE gv, VALUE devicev)
2868 {
2869   guestfs_h *g;
2870   Data_Get_Struct (gv, guestfs_h, g);
2871   if (!g)
2872     rb_raise (rb_eArgError, "%s: used handle after closing it", "blockdev_getro");
2873
2874   Check_Type (devicev, T_STRING);
2875   const char *device = StringValueCStr (devicev);
2876   if (!device)
2877     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2878               "device", "blockdev_getro");
2879
2880   int r;
2881
2882   r = guestfs_blockdev_getro (g, device);
2883   if (r == -1)
2884     rb_raise (e_Error, "%s", guestfs_last_error (g));
2885
2886   return INT2NUM (r);
2887 }
2888
2889 static VALUE ruby_guestfs_blockdev_getss (VALUE gv, VALUE devicev)
2890 {
2891   guestfs_h *g;
2892   Data_Get_Struct (gv, guestfs_h, g);
2893   if (!g)
2894     rb_raise (rb_eArgError, "%s: used handle after closing it", "blockdev_getss");
2895
2896   Check_Type (devicev, T_STRING);
2897   const char *device = StringValueCStr (devicev);
2898   if (!device)
2899     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2900               "device", "blockdev_getss");
2901
2902   int r;
2903
2904   r = guestfs_blockdev_getss (g, device);
2905   if (r == -1)
2906     rb_raise (e_Error, "%s", guestfs_last_error (g));
2907
2908   return INT2NUM (r);
2909 }
2910
2911 static VALUE ruby_guestfs_blockdev_getbsz (VALUE gv, VALUE devicev)
2912 {
2913   guestfs_h *g;
2914   Data_Get_Struct (gv, guestfs_h, g);
2915   if (!g)
2916     rb_raise (rb_eArgError, "%s: used handle after closing it", "blockdev_getbsz");
2917
2918   Check_Type (devicev, T_STRING);
2919   const char *device = StringValueCStr (devicev);
2920   if (!device)
2921     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2922               "device", "blockdev_getbsz");
2923
2924   int r;
2925
2926   r = guestfs_blockdev_getbsz (g, device);
2927   if (r == -1)
2928     rb_raise (e_Error, "%s", guestfs_last_error (g));
2929
2930   return INT2NUM (r);
2931 }
2932
2933 static VALUE ruby_guestfs_blockdev_setbsz (VALUE gv, VALUE devicev, VALUE blocksizev)
2934 {
2935   guestfs_h *g;
2936   Data_Get_Struct (gv, guestfs_h, g);
2937   if (!g)
2938     rb_raise (rb_eArgError, "%s: used handle after closing it", "blockdev_setbsz");
2939
2940   Check_Type (devicev, T_STRING);
2941   const char *device = StringValueCStr (devicev);
2942   if (!device)
2943     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2944               "device", "blockdev_setbsz");
2945   int blocksize = NUM2INT (blocksizev);
2946
2947   int r;
2948
2949   r = guestfs_blockdev_setbsz (g, device, blocksize);
2950   if (r == -1)
2951     rb_raise (e_Error, "%s", guestfs_last_error (g));
2952
2953   return Qnil;
2954 }
2955
2956 static VALUE ruby_guestfs_blockdev_getsz (VALUE gv, VALUE devicev)
2957 {
2958   guestfs_h *g;
2959   Data_Get_Struct (gv, guestfs_h, g);
2960   if (!g)
2961     rb_raise (rb_eArgError, "%s: used handle after closing it", "blockdev_getsz");
2962
2963   Check_Type (devicev, T_STRING);
2964   const char *device = StringValueCStr (devicev);
2965   if (!device)
2966     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2967               "device", "blockdev_getsz");
2968
2969   int64_t r;
2970
2971   r = guestfs_blockdev_getsz (g, device);
2972   if (r == -1)
2973     rb_raise (e_Error, "%s", guestfs_last_error (g));
2974
2975   return ULL2NUM (r);
2976 }
2977
2978 static VALUE ruby_guestfs_blockdev_getsize64 (VALUE gv, VALUE devicev)
2979 {
2980   guestfs_h *g;
2981   Data_Get_Struct (gv, guestfs_h, g);
2982   if (!g)
2983     rb_raise (rb_eArgError, "%s: used handle after closing it", "blockdev_getsize64");
2984
2985   Check_Type (devicev, T_STRING);
2986   const char *device = StringValueCStr (devicev);
2987   if (!device)
2988     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2989               "device", "blockdev_getsize64");
2990
2991   int64_t r;
2992
2993   r = guestfs_blockdev_getsize64 (g, device);
2994   if (r == -1)
2995     rb_raise (e_Error, "%s", guestfs_last_error (g));
2996
2997   return ULL2NUM (r);
2998 }
2999
3000 static VALUE ruby_guestfs_blockdev_flushbufs (VALUE gv, VALUE devicev)
3001 {
3002   guestfs_h *g;
3003   Data_Get_Struct (gv, guestfs_h, g);
3004   if (!g)
3005     rb_raise (rb_eArgError, "%s: used handle after closing it", "blockdev_flushbufs");
3006
3007   Check_Type (devicev, T_STRING);
3008   const char *device = StringValueCStr (devicev);
3009   if (!device)
3010     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3011               "device", "blockdev_flushbufs");
3012
3013   int r;
3014
3015   r = guestfs_blockdev_flushbufs (g, device);
3016   if (r == -1)
3017     rb_raise (e_Error, "%s", guestfs_last_error (g));
3018
3019   return Qnil;
3020 }
3021
3022 static VALUE ruby_guestfs_blockdev_rereadpt (VALUE gv, VALUE devicev)
3023 {
3024   guestfs_h *g;
3025   Data_Get_Struct (gv, guestfs_h, g);
3026   if (!g)
3027     rb_raise (rb_eArgError, "%s: used handle after closing it", "blockdev_rereadpt");
3028
3029   Check_Type (devicev, T_STRING);
3030   const char *device = StringValueCStr (devicev);
3031   if (!device)
3032     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3033               "device", "blockdev_rereadpt");
3034
3035   int r;
3036
3037   r = guestfs_blockdev_rereadpt (g, device);
3038   if (r == -1)
3039     rb_raise (e_Error, "%s", guestfs_last_error (g));
3040
3041   return Qnil;
3042 }
3043
3044 static VALUE ruby_guestfs_upload (VALUE gv, VALUE filenamev, VALUE remotefilenamev)
3045 {
3046   guestfs_h *g;
3047   Data_Get_Struct (gv, guestfs_h, g);
3048   if (!g)
3049     rb_raise (rb_eArgError, "%s: used handle after closing it", "upload");
3050
3051   Check_Type (filenamev, T_STRING);
3052   const char *filename = StringValueCStr (filenamev);
3053   if (!filename)
3054     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3055               "filename", "upload");
3056   Check_Type (remotefilenamev, T_STRING);
3057   const char *remotefilename = StringValueCStr (remotefilenamev);
3058   if (!remotefilename)
3059     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3060               "remotefilename", "upload");
3061
3062   int r;
3063
3064   r = guestfs_upload (g, filename, remotefilename);
3065   if (r == -1)
3066     rb_raise (e_Error, "%s", guestfs_last_error (g));
3067
3068   return Qnil;
3069 }
3070
3071 static VALUE ruby_guestfs_download (VALUE gv, VALUE remotefilenamev, VALUE filenamev)
3072 {
3073   guestfs_h *g;
3074   Data_Get_Struct (gv, guestfs_h, g);
3075   if (!g)
3076     rb_raise (rb_eArgError, "%s: used handle after closing it", "download");
3077
3078   Check_Type (remotefilenamev, T_STRING);
3079   const char *remotefilename = StringValueCStr (remotefilenamev);
3080   if (!remotefilename)
3081     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3082               "remotefilename", "download");
3083   Check_Type (filenamev, T_STRING);
3084   const char *filename = StringValueCStr (filenamev);
3085   if (!filename)
3086     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3087               "filename", "download");
3088
3089   int r;
3090
3091   r = guestfs_download (g, remotefilename, filename);
3092   if (r == -1)
3093     rb_raise (e_Error, "%s", guestfs_last_error (g));
3094
3095   return Qnil;
3096 }
3097
3098 static VALUE ruby_guestfs_checksum (VALUE gv, VALUE csumtypev, VALUE pathv)
3099 {
3100   guestfs_h *g;
3101   Data_Get_Struct (gv, guestfs_h, g);
3102   if (!g)
3103     rb_raise (rb_eArgError, "%s: used handle after closing it", "checksum");
3104
3105   Check_Type (csumtypev, T_STRING);
3106   const char *csumtype = StringValueCStr (csumtypev);
3107   if (!csumtype)
3108     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3109               "csumtype", "checksum");
3110   Check_Type (pathv, T_STRING);
3111   const char *path = StringValueCStr (pathv);
3112   if (!path)
3113     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3114               "path", "checksum");
3115
3116   char *r;
3117
3118   r = guestfs_checksum (g, csumtype, path);
3119   if (r == NULL)
3120     rb_raise (e_Error, "%s", guestfs_last_error (g));
3121
3122   VALUE rv = rb_str_new2 (r);
3123   free (r);
3124   return rv;
3125 }
3126
3127 static VALUE ruby_guestfs_tar_in (VALUE gv, VALUE tarfilev, VALUE directoryv)
3128 {
3129   guestfs_h *g;
3130   Data_Get_Struct (gv, guestfs_h, g);
3131   if (!g)
3132     rb_raise (rb_eArgError, "%s: used handle after closing it", "tar_in");
3133
3134   Check_Type (tarfilev, T_STRING);
3135   const char *tarfile = StringValueCStr (tarfilev);
3136   if (!tarfile)
3137     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3138               "tarfile", "tar_in");
3139   Check_Type (directoryv, T_STRING);
3140   const char *directory = StringValueCStr (directoryv);
3141   if (!directory)
3142     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3143               "directory", "tar_in");
3144
3145   int r;
3146
3147   r = guestfs_tar_in (g, tarfile, directory);
3148   if (r == -1)
3149     rb_raise (e_Error, "%s", guestfs_last_error (g));
3150
3151   return Qnil;
3152 }
3153
3154 static VALUE ruby_guestfs_tar_out (VALUE gv, VALUE directoryv, VALUE tarfilev)
3155 {
3156   guestfs_h *g;
3157   Data_Get_Struct (gv, guestfs_h, g);
3158   if (!g)
3159     rb_raise (rb_eArgError, "%s: used handle after closing it", "tar_out");
3160
3161   Check_Type (directoryv, T_STRING);
3162   const char *directory = StringValueCStr (directoryv);
3163   if (!directory)
3164     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3165               "directory", "tar_out");
3166   Check_Type (tarfilev, T_STRING);
3167   const char *tarfile = StringValueCStr (tarfilev);
3168   if (!tarfile)
3169     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3170               "tarfile", "tar_out");
3171
3172   int r;
3173
3174   r = guestfs_tar_out (g, directory, tarfile);
3175   if (r == -1)
3176     rb_raise (e_Error, "%s", guestfs_last_error (g));
3177
3178   return Qnil;
3179 }
3180
3181 static VALUE ruby_guestfs_tgz_in (VALUE gv, VALUE tarballv, VALUE directoryv)
3182 {
3183   guestfs_h *g;
3184   Data_Get_Struct (gv, guestfs_h, g);
3185   if (!g)
3186     rb_raise (rb_eArgError, "%s: used handle after closing it", "tgz_in");
3187
3188   Check_Type (tarballv, T_STRING);
3189   const char *tarball = StringValueCStr (tarballv);
3190   if (!tarball)
3191     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3192               "tarball", "tgz_in");
3193   Check_Type (directoryv, T_STRING);
3194   const char *directory = StringValueCStr (directoryv);
3195   if (!directory)
3196     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3197               "directory", "tgz_in");
3198
3199   int r;
3200
3201   r = guestfs_tgz_in (g, tarball, directory);
3202   if (r == -1)
3203     rb_raise (e_Error, "%s", guestfs_last_error (g));
3204
3205   return Qnil;
3206 }
3207
3208 static VALUE ruby_guestfs_tgz_out (VALUE gv, VALUE directoryv, VALUE tarballv)
3209 {
3210   guestfs_h *g;
3211   Data_Get_Struct (gv, guestfs_h, g);
3212   if (!g)
3213     rb_raise (rb_eArgError, "%s: used handle after closing it", "tgz_out");
3214
3215   Check_Type (directoryv, T_STRING);
3216   const char *directory = StringValueCStr (directoryv);
3217   if (!directory)
3218     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3219               "directory", "tgz_out");
3220   Check_Type (tarballv, T_STRING);
3221   const char *tarball = StringValueCStr (tarballv);
3222   if (!tarball)
3223     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3224               "tarball", "tgz_out");
3225
3226   int r;
3227
3228   r = guestfs_tgz_out (g, directory, tarball);
3229   if (r == -1)
3230     rb_raise (e_Error, "%s", guestfs_last_error (g));
3231
3232   return Qnil;
3233 }
3234
3235 static VALUE ruby_guestfs_mount_ro (VALUE gv, VALUE devicev, VALUE mountpointv)
3236 {
3237   guestfs_h *g;
3238   Data_Get_Struct (gv, guestfs_h, g);
3239   if (!g)
3240     rb_raise (rb_eArgError, "%s: used handle after closing it", "mount_ro");
3241
3242   Check_Type (devicev, T_STRING);
3243   const char *device = StringValueCStr (devicev);
3244   if (!device)
3245     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3246               "device", "mount_ro");
3247   Check_Type (mountpointv, T_STRING);
3248   const char *mountpoint = StringValueCStr (mountpointv);
3249   if (!mountpoint)
3250     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3251               "mountpoint", "mount_ro");
3252
3253   int r;
3254
3255   r = guestfs_mount_ro (g, device, mountpoint);
3256   if (r == -1)
3257     rb_raise (e_Error, "%s", guestfs_last_error (g));
3258
3259   return Qnil;
3260 }
3261
3262 static VALUE ruby_guestfs_mount_options (VALUE gv, VALUE optionsv, VALUE devicev, VALUE mountpointv)
3263 {
3264   guestfs_h *g;
3265   Data_Get_Struct (gv, guestfs_h, g);
3266   if (!g)
3267     rb_raise (rb_eArgError, "%s: used handle after closing it", "mount_options");
3268
3269   Check_Type (optionsv, T_STRING);
3270   const char *options = StringValueCStr (optionsv);
3271   if (!options)
3272     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3273               "options", "mount_options");
3274   Check_Type (devicev, T_STRING);
3275   const char *device = StringValueCStr (devicev);
3276   if (!device)
3277     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3278               "device", "mount_options");
3279   Check_Type (mountpointv, T_STRING);
3280   const char *mountpoint = StringValueCStr (mountpointv);
3281   if (!mountpoint)
3282     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3283               "mountpoint", "mount_options");
3284
3285   int r;
3286
3287   r = guestfs_mount_options (g, options, device, mountpoint);
3288   if (r == -1)
3289     rb_raise (e_Error, "%s", guestfs_last_error (g));
3290
3291   return Qnil;
3292 }
3293
3294 static VALUE ruby_guestfs_mount_vfs (VALUE gv, VALUE optionsv, VALUE vfstypev, VALUE devicev, VALUE mountpointv)
3295 {
3296   guestfs_h *g;
3297   Data_Get_Struct (gv, guestfs_h, g);
3298   if (!g)
3299     rb_raise (rb_eArgError, "%s: used handle after closing it", "mount_vfs");
3300
3301   Check_Type (optionsv, T_STRING);
3302   const char *options = StringValueCStr (optionsv);
3303   if (!options)
3304     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3305               "options", "mount_vfs");
3306   Check_Type (vfstypev, T_STRING);
3307   const char *vfstype = StringValueCStr (vfstypev);
3308   if (!vfstype)
3309     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3310               "vfstype", "mount_vfs");
3311   Check_Type (devicev, T_STRING);
3312   const char *device = StringValueCStr (devicev);
3313   if (!device)
3314     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3315               "device", "mount_vfs");
3316   Check_Type (mountpointv, T_STRING);
3317   const char *mountpoint = StringValueCStr (mountpointv);
3318   if (!mountpoint)
3319     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3320               "mountpoint", "mount_vfs");
3321
3322   int r;
3323
3324   r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint);
3325   if (r == -1)
3326     rb_raise (e_Error, "%s", guestfs_last_error (g));
3327
3328   return Qnil;
3329 }
3330
3331 static VALUE ruby_guestfs_debug (VALUE gv, VALUE subcmdv, VALUE extraargsv)
3332 {
3333   guestfs_h *g;
3334   Data_Get_Struct (gv, guestfs_h, g);
3335   if (!g)
3336     rb_raise (rb_eArgError, "%s: used handle after closing it", "debug");
3337
3338   Check_Type (subcmdv, T_STRING);
3339   const char *subcmd = StringValueCStr (subcmdv);
3340   if (!subcmd)
3341     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3342               "subcmd", "debug");
3343   char **extraargs;
3344   Check_Type (extraargsv, T_ARRAY);
3345   {
3346     int i, len;
3347     len = RARRAY_LEN (extraargsv);
3348     extraargs = guestfs_safe_malloc (g, sizeof (char *) * (len+1));
3349     for (i = 0; i < len; ++i) {
3350       VALUE v = rb_ary_entry (extraargsv, i);
3351       extraargs[i] = StringValueCStr (v);
3352     }
3353     extraargs[len] = NULL;
3354   }
3355
3356   char *r;
3357
3358   r = guestfs_debug (g, subcmd, extraargs);
3359   free (extraargs);
3360   if (r == NULL)
3361     rb_raise (e_Error, "%s", guestfs_last_error (g));
3362
3363   VALUE rv = rb_str_new2 (r);
3364   free (r);
3365   return rv;
3366 }
3367
3368 static VALUE ruby_guestfs_lvremove (VALUE gv, VALUE devicev)
3369 {
3370   guestfs_h *g;
3371   Data_Get_Struct (gv, guestfs_h, g);
3372   if (!g)
3373     rb_raise (rb_eArgError, "%s: used handle after closing it", "lvremove");
3374
3375   Check_Type (devicev, T_STRING);
3376   const char *device = StringValueCStr (devicev);
3377   if (!device)
3378     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3379               "device", "lvremove");
3380
3381   int r;
3382
3383   r = guestfs_lvremove (g, device);
3384   if (r == -1)
3385     rb_raise (e_Error, "%s", guestfs_last_error (g));
3386
3387   return Qnil;
3388 }
3389
3390 static VALUE ruby_guestfs_vgremove (VALUE gv, VALUE vgnamev)
3391 {
3392   guestfs_h *g;
3393   Data_Get_Struct (gv, guestfs_h, g);
3394   if (!g)
3395     rb_raise (rb_eArgError, "%s: used handle after closing it", "vgremove");
3396
3397   Check_Type (vgnamev, T_STRING);
3398   const char *vgname = StringValueCStr (vgnamev);
3399   if (!vgname)
3400     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3401               "vgname", "vgremove");
3402
3403   int r;
3404
3405   r = guestfs_vgremove (g, vgname);
3406   if (r == -1)
3407     rb_raise (e_Error, "%s", guestfs_last_error (g));
3408
3409   return Qnil;
3410 }
3411
3412 static VALUE ruby_guestfs_pvremove (VALUE gv, VALUE devicev)
3413 {
3414   guestfs_h *g;
3415   Data_Get_Struct (gv, guestfs_h, g);
3416   if (!g)
3417     rb_raise (rb_eArgError, "%s: used handle after closing it", "pvremove");
3418
3419   Check_Type (devicev, T_STRING);
3420   const char *device = StringValueCStr (devicev);
3421   if (!device)
3422     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3423               "device", "pvremove");
3424
3425   int r;
3426
3427   r = guestfs_pvremove (g, device);
3428   if (r == -1)
3429     rb_raise (e_Error, "%s", guestfs_last_error (g));
3430
3431   return Qnil;
3432 }
3433
3434 static VALUE ruby_guestfs_set_e2label (VALUE gv, VALUE devicev, VALUE labelv)
3435 {
3436   guestfs_h *g;
3437   Data_Get_Struct (gv, guestfs_h, g);
3438   if (!g)
3439     rb_raise (rb_eArgError, "%s: used handle after closing it", "set_e2label");
3440
3441   Check_Type (devicev, T_STRING);
3442   const char *device = StringValueCStr (devicev);
3443   if (!device)
3444     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3445               "device", "set_e2label");
3446   Check_Type (labelv, T_STRING);
3447   const char *label = StringValueCStr (labelv);
3448   if (!label)
3449     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3450               "label", "set_e2label");
3451
3452   int r;
3453
3454   r = guestfs_set_e2label (g, device, label);
3455   if (r == -1)
3456     rb_raise (e_Error, "%s", guestfs_last_error (g));
3457
3458   return Qnil;
3459 }
3460
3461 static VALUE ruby_guestfs_get_e2label (VALUE gv, VALUE devicev)
3462 {
3463   guestfs_h *g;
3464   Data_Get_Struct (gv, guestfs_h, g);
3465   if (!g)
3466     rb_raise (rb_eArgError, "%s: used handle after closing it", "get_e2label");
3467
3468   Check_Type (devicev, T_STRING);
3469   const char *device = StringValueCStr (devicev);
3470   if (!device)
3471     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3472               "device", "get_e2label");
3473
3474   char *r;
3475
3476   r = guestfs_get_e2label (g, device);
3477   if (r == NULL)
3478     rb_raise (e_Error, "%s", guestfs_last_error (g));
3479
3480   VALUE rv = rb_str_new2 (r);
3481   free (r);
3482   return rv;
3483 }
3484
3485 static VALUE ruby_guestfs_set_e2uuid (VALUE gv, VALUE devicev, VALUE uuidv)
3486 {
3487   guestfs_h *g;
3488   Data_Get_Struct (gv, guestfs_h, g);
3489   if (!g)
3490     rb_raise (rb_eArgError, "%s: used handle after closing it", "set_e2uuid");
3491
3492   Check_Type (devicev, T_STRING);
3493   const char *device = StringValueCStr (devicev);
3494   if (!device)
3495     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3496               "device", "set_e2uuid");
3497   Check_Type (uuidv, T_STRING);
3498   const char *uuid = StringValueCStr (uuidv);
3499   if (!uuid)
3500     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3501               "uuid", "set_e2uuid");
3502
3503   int r;
3504
3505   r = guestfs_set_e2uuid (g, device, uuid);
3506   if (r == -1)
3507     rb_raise (e_Error, "%s", guestfs_last_error (g));
3508
3509   return Qnil;
3510 }
3511
3512 static VALUE ruby_guestfs_get_e2uuid (VALUE gv, VALUE devicev)
3513 {
3514   guestfs_h *g;
3515   Data_Get_Struct (gv, guestfs_h, g);
3516   if (!g)
3517     rb_raise (rb_eArgError, "%s: used handle after closing it", "get_e2uuid");
3518
3519   Check_Type (devicev, T_STRING);
3520   const char *device = StringValueCStr (devicev);
3521   if (!device)
3522     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3523               "device", "get_e2uuid");
3524
3525   char *r;
3526
3527   r = guestfs_get_e2uuid (g, device);
3528   if (r == NULL)
3529     rb_raise (e_Error, "%s", guestfs_last_error (g));
3530
3531   VALUE rv = rb_str_new2 (r);
3532   free (r);
3533   return rv;
3534 }
3535
3536 static VALUE ruby_guestfs_fsck (VALUE gv, VALUE fstypev, VALUE devicev)
3537 {
3538   guestfs_h *g;
3539   Data_Get_Struct (gv, guestfs_h, g);
3540   if (!g)
3541     rb_raise (rb_eArgError, "%s: used handle after closing it", "fsck");
3542
3543   Check_Type (fstypev, T_STRING);
3544   const char *fstype = StringValueCStr (fstypev);
3545   if (!fstype)
3546     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3547               "fstype", "fsck");
3548   Check_Type (devicev, T_STRING);
3549   const char *device = StringValueCStr (devicev);
3550   if (!device)
3551     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3552               "device", "fsck");
3553
3554   int r;
3555
3556   r = guestfs_fsck (g, fstype, device);
3557   if (r == -1)
3558     rb_raise (e_Error, "%s", guestfs_last_error (g));
3559
3560   return INT2NUM (r);
3561 }
3562
3563 static VALUE ruby_guestfs_zero (VALUE gv, VALUE devicev)
3564 {
3565   guestfs_h *g;
3566   Data_Get_Struct (gv, guestfs_h, g);
3567   if (!g)
3568     rb_raise (rb_eArgError, "%s: used handle after closing it", "zero");
3569
3570   Check_Type (devicev, T_STRING);
3571   const char *device = StringValueCStr (devicev);
3572   if (!device)
3573     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3574               "device", "zero");
3575
3576   int r;
3577
3578   r = guestfs_zero (g, device);
3579   if (r == -1)
3580     rb_raise (e_Error, "%s", guestfs_last_error (g));
3581
3582   return Qnil;
3583 }
3584
3585 static VALUE ruby_guestfs_grub_install (VALUE gv, VALUE rootv, VALUE devicev)
3586 {
3587   guestfs_h *g;
3588   Data_Get_Struct (gv, guestfs_h, g);
3589   if (!g)
3590     rb_raise (rb_eArgError, "%s: used handle after closing it", "grub_install");
3591
3592   Check_Type (rootv, T_STRING);
3593   const char *root = StringValueCStr (rootv);
3594   if (!root)
3595     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3596               "root", "grub_install");
3597   Check_Type (devicev, T_STRING);
3598   const char *device = StringValueCStr (devicev);
3599   if (!device)
3600     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3601               "device", "grub_install");
3602
3603   int r;
3604
3605   r = guestfs_grub_install (g, root, device);
3606   if (r == -1)
3607     rb_raise (e_Error, "%s", guestfs_last_error (g));
3608
3609   return Qnil;
3610 }
3611
3612 static VALUE ruby_guestfs_cp (VALUE gv, VALUE srcv, VALUE destv)
3613 {
3614   guestfs_h *g;
3615   Data_Get_Struct (gv, guestfs_h, g);
3616   if (!g)
3617     rb_raise (rb_eArgError, "%s: used handle after closing it", "cp");
3618
3619   Check_Type (srcv, T_STRING);
3620   const char *src = StringValueCStr (srcv);
3621   if (!src)
3622     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3623               "src", "cp");
3624   Check_Type (destv, T_STRING);
3625   const char *dest = StringValueCStr (destv);
3626   if (!dest)
3627     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3628               "dest", "cp");
3629
3630   int r;
3631
3632   r = guestfs_cp (g, src, dest);
3633   if (r == -1)
3634     rb_raise (e_Error, "%s", guestfs_last_error (g));
3635
3636   return Qnil;
3637 }
3638
3639 static VALUE ruby_guestfs_cp_a (VALUE gv, VALUE srcv, VALUE destv)
3640 {
3641   guestfs_h *g;
3642   Data_Get_Struct (gv, guestfs_h, g);
3643   if (!g)
3644     rb_raise (rb_eArgError, "%s: used handle after closing it", "cp_a");
3645
3646   Check_Type (srcv, T_STRING);
3647   const char *src = StringValueCStr (srcv);
3648   if (!src)
3649     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3650               "src", "cp_a");
3651   Check_Type (destv, T_STRING);
3652   const char *dest = StringValueCStr (destv);
3653   if (!dest)
3654     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3655               "dest", "cp_a");
3656
3657   int r;
3658
3659   r = guestfs_cp_a (g, src, dest);
3660   if (r == -1)
3661     rb_raise (e_Error, "%s", guestfs_last_error (g));
3662
3663   return Qnil;
3664 }
3665
3666 static VALUE ruby_guestfs_mv (VALUE gv, VALUE srcv, VALUE destv)
3667 {
3668   guestfs_h *g;
3669   Data_Get_Struct (gv, guestfs_h, g);
3670   if (!g)
3671     rb_raise (rb_eArgError, "%s: used handle after closing it", "mv");
3672
3673   Check_Type (srcv, T_STRING);
3674   const char *src = StringValueCStr (srcv);
3675   if (!src)
3676     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3677               "src", "mv");
3678   Check_Type (destv, T_STRING);
3679   const char *dest = StringValueCStr (destv);
3680   if (!dest)
3681     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3682               "dest", "mv");
3683
3684   int r;
3685
3686   r = guestfs_mv (g, src, dest);
3687   if (r == -1)
3688     rb_raise (e_Error, "%s", guestfs_last_error (g));
3689
3690   return Qnil;
3691 }
3692
3693 static VALUE ruby_guestfs_drop_caches (VALUE gv, VALUE whattodropv)
3694 {
3695   guestfs_h *g;
3696   Data_Get_Struct (gv, guestfs_h, g);
3697   if (!g)
3698     rb_raise (rb_eArgError, "%s: used handle after closing it", "drop_caches");
3699
3700   int whattodrop = NUM2INT (whattodropv);
3701
3702   int r;
3703
3704   r = guestfs_drop_caches (g, whattodrop);
3705   if (r == -1)
3706     rb_raise (e_Error, "%s", guestfs_last_error (g));
3707
3708   return Qnil;
3709 }
3710
3711 static VALUE ruby_guestfs_dmesg (VALUE gv)
3712 {
3713   guestfs_h *g;
3714   Data_Get_Struct (gv, guestfs_h, g);
3715   if (!g)
3716     rb_raise (rb_eArgError, "%s: used handle after closing it", "dmesg");
3717
3718
3719   char *r;
3720
3721   r = guestfs_dmesg (g);
3722   if (r == NULL)
3723     rb_raise (e_Error, "%s", guestfs_last_error (g));
3724
3725   VALUE rv = rb_str_new2 (r);
3726   free (r);
3727   return rv;
3728 }
3729
3730 static VALUE ruby_guestfs_ping_daemon (VALUE gv)
3731 {
3732   guestfs_h *g;
3733   Data_Get_Struct (gv, guestfs_h, g);
3734   if (!g)
3735     rb_raise (rb_eArgError, "%s: used handle after closing it", "ping_daemon");
3736
3737
3738   int r;
3739
3740   r = guestfs_ping_daemon (g);
3741   if (r == -1)
3742     rb_raise (e_Error, "%s", guestfs_last_error (g));
3743
3744   return Qnil;
3745 }
3746
3747 static VALUE ruby_guestfs_equal (VALUE gv, VALUE file1v, VALUE file2v)
3748 {
3749   guestfs_h *g;
3750   Data_Get_Struct (gv, guestfs_h, g);
3751   if (!g)
3752     rb_raise (rb_eArgError, "%s: used handle after closing it", "equal");
3753
3754   Check_Type (file1v, T_STRING);
3755   const char *file1 = StringValueCStr (file1v);
3756   if (!file1)
3757     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3758               "file1", "equal");
3759   Check_Type (file2v, T_STRING);
3760   const char *file2 = StringValueCStr (file2v);
3761   if (!file2)
3762     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3763               "file2", "equal");
3764
3765   int r;
3766
3767   r = guestfs_equal (g, file1, file2);
3768   if (r == -1)
3769     rb_raise (e_Error, "%s", guestfs_last_error (g));
3770
3771   return INT2NUM (r);
3772 }
3773
3774 static VALUE ruby_guestfs_strings (VALUE gv, VALUE pathv)
3775 {
3776   guestfs_h *g;
3777   Data_Get_Struct (gv, guestfs_h, g);
3778   if (!g)
3779     rb_raise (rb_eArgError, "%s: used handle after closing it", "strings");
3780
3781   Check_Type (pathv, T_STRING);
3782   const char *path = StringValueCStr (pathv);
3783   if (!path)
3784     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3785               "path", "strings");
3786
3787   char **r;
3788
3789   r = guestfs_strings (g, path);
3790   if (r == NULL)
3791     rb_raise (e_Error, "%s", guestfs_last_error (g));
3792
3793   int i, len = 0;
3794   for (i = 0; r[i] != NULL; ++i) len++;
3795   VALUE rv = rb_ary_new2 (len);
3796   for (i = 0; r[i] != NULL; ++i) {
3797     rb_ary_push (rv, rb_str_new2 (r[i]));
3798     free (r[i]);
3799   }
3800   free (r);
3801   return rv;
3802 }
3803
3804 static VALUE ruby_guestfs_strings_e (VALUE gv, VALUE encodingv, VALUE pathv)
3805 {
3806   guestfs_h *g;
3807   Data_Get_Struct (gv, guestfs_h, g);
3808   if (!g)
3809     rb_raise (rb_eArgError, "%s: used handle after closing it", "strings_e");
3810
3811   Check_Type (encodingv, T_STRING);
3812   const char *encoding = StringValueCStr (encodingv);
3813   if (!encoding)
3814     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3815               "encoding", "strings_e");
3816   Check_Type (pathv, T_STRING);
3817   const char *path = StringValueCStr (pathv);
3818   if (!path)
3819     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3820               "path", "strings_e");
3821
3822   char **r;
3823
3824   r = guestfs_strings_e (g, encoding, path);
3825   if (r == NULL)
3826     rb_raise (e_Error, "%s", guestfs_last_error (g));
3827
3828   int i, len = 0;
3829   for (i = 0; r[i] != NULL; ++i) len++;
3830   VALUE rv = rb_ary_new2 (len);
3831   for (i = 0; r[i] != NULL; ++i) {
3832     rb_ary_push (rv, rb_str_new2 (r[i]));
3833     free (r[i]);
3834   }
3835   free (r);
3836   return rv;
3837 }
3838
3839 static VALUE ruby_guestfs_hexdump (VALUE gv, VALUE pathv)
3840 {
3841   guestfs_h *g;
3842   Data_Get_Struct (gv, guestfs_h, g);
3843   if (!g)
3844     rb_raise (rb_eArgError, "%s: used handle after closing it", "hexdump");
3845
3846   Check_Type (pathv, T_STRING);
3847   const char *path = StringValueCStr (pathv);
3848   if (!path)
3849     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3850               "path", "hexdump");
3851
3852   char *r;
3853
3854   r = guestfs_hexdump (g, path);
3855   if (r == NULL)
3856     rb_raise (e_Error, "%s", guestfs_last_error (g));
3857
3858   VALUE rv = rb_str_new2 (r);
3859   free (r);
3860   return rv;