Generated code for 'du' command.
[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_mount (VALUE gv, VALUE devicev, VALUE mountpointv)
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", "mount");
1338
1339   Check_Type (devicev, T_STRING);
1340   const char *device = StringValueCStr (devicev);
1341   if (!device)
1342     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1343               "device", "mount");
1344   Check_Type (mountpointv, T_STRING);
1345   const char *mountpoint = StringValueCStr (mountpointv);
1346   if (!mountpoint)
1347     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1348               "mountpoint", "mount");
1349
1350   int r;
1351
1352   r = guestfs_mount (g, device, mountpoint);
1353   if (r == -1)
1354     rb_raise (e_Error, "%s", guestfs_last_error (g));
1355
1356   return Qnil;
1357 }
1358
1359 static VALUE ruby_guestfs_sync (VALUE gv)
1360 {
1361   guestfs_h *g;
1362   Data_Get_Struct (gv, guestfs_h, g);
1363   if (!g)
1364     rb_raise (rb_eArgError, "%s: used handle after closing it", "sync");
1365
1366
1367   int r;
1368
1369   r = guestfs_sync (g);
1370   if (r == -1)
1371     rb_raise (e_Error, "%s", guestfs_last_error (g));
1372
1373   return Qnil;
1374 }
1375
1376 static VALUE ruby_guestfs_touch (VALUE gv, VALUE pathv)
1377 {
1378   guestfs_h *g;
1379   Data_Get_Struct (gv, guestfs_h, g);
1380   if (!g)
1381     rb_raise (rb_eArgError, "%s: used handle after closing it", "touch");
1382
1383   Check_Type (pathv, T_STRING);
1384   const char *path = StringValueCStr (pathv);
1385   if (!path)
1386     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1387               "path", "touch");
1388
1389   int r;
1390
1391   r = guestfs_touch (g, path);
1392   if (r == -1)
1393     rb_raise (e_Error, "%s", guestfs_last_error (g));
1394
1395   return Qnil;
1396 }
1397
1398 static VALUE ruby_guestfs_cat (VALUE gv, VALUE pathv)
1399 {
1400   guestfs_h *g;
1401   Data_Get_Struct (gv, guestfs_h, g);
1402   if (!g)
1403     rb_raise (rb_eArgError, "%s: used handle after closing it", "cat");
1404
1405   Check_Type (pathv, T_STRING);
1406   const char *path = StringValueCStr (pathv);
1407   if (!path)
1408     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1409               "path", "cat");
1410
1411   char *r;
1412
1413   r = guestfs_cat (g, path);
1414   if (r == NULL)
1415     rb_raise (e_Error, "%s", guestfs_last_error (g));
1416
1417   VALUE rv = rb_str_new2 (r);
1418   free (r);
1419   return rv;
1420 }
1421
1422 static VALUE ruby_guestfs_ll (VALUE gv, VALUE directoryv)
1423 {
1424   guestfs_h *g;
1425   Data_Get_Struct (gv, guestfs_h, g);
1426   if (!g)
1427     rb_raise (rb_eArgError, "%s: used handle after closing it", "ll");
1428
1429   Check_Type (directoryv, T_STRING);
1430   const char *directory = StringValueCStr (directoryv);
1431   if (!directory)
1432     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1433               "directory", "ll");
1434
1435   char *r;
1436
1437   r = guestfs_ll (g, directory);
1438   if (r == NULL)
1439     rb_raise (e_Error, "%s", guestfs_last_error (g));
1440
1441   VALUE rv = rb_str_new2 (r);
1442   free (r);
1443   return rv;
1444 }
1445
1446 static VALUE ruby_guestfs_ls (VALUE gv, VALUE directoryv)
1447 {
1448   guestfs_h *g;
1449   Data_Get_Struct (gv, guestfs_h, g);
1450   if (!g)
1451     rb_raise (rb_eArgError, "%s: used handle after closing it", "ls");
1452
1453   Check_Type (directoryv, T_STRING);
1454   const char *directory = StringValueCStr (directoryv);
1455   if (!directory)
1456     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1457               "directory", "ls");
1458
1459   char **r;
1460
1461   r = guestfs_ls (g, directory);
1462   if (r == NULL)
1463     rb_raise (e_Error, "%s", guestfs_last_error (g));
1464
1465   int i, len = 0;
1466   for (i = 0; r[i] != NULL; ++i) len++;
1467   VALUE rv = rb_ary_new2 (len);
1468   for (i = 0; r[i] != NULL; ++i) {
1469     rb_ary_push (rv, rb_str_new2 (r[i]));
1470     free (r[i]);
1471   }
1472   free (r);
1473   return rv;
1474 }
1475
1476 static VALUE ruby_guestfs_list_devices (VALUE gv)
1477 {
1478   guestfs_h *g;
1479   Data_Get_Struct (gv, guestfs_h, g);
1480   if (!g)
1481     rb_raise (rb_eArgError, "%s: used handle after closing it", "list_devices");
1482
1483
1484   char **r;
1485
1486   r = guestfs_list_devices (g);
1487   if (r == NULL)
1488     rb_raise (e_Error, "%s", guestfs_last_error (g));
1489
1490   int i, len = 0;
1491   for (i = 0; r[i] != NULL; ++i) len++;
1492   VALUE rv = rb_ary_new2 (len);
1493   for (i = 0; r[i] != NULL; ++i) {
1494     rb_ary_push (rv, rb_str_new2 (r[i]));
1495     free (r[i]);
1496   }
1497   free (r);
1498   return rv;
1499 }
1500
1501 static VALUE ruby_guestfs_list_partitions (VALUE gv)
1502 {
1503   guestfs_h *g;
1504   Data_Get_Struct (gv, guestfs_h, g);
1505   if (!g)
1506     rb_raise (rb_eArgError, "%s: used handle after closing it", "list_partitions");
1507
1508
1509   char **r;
1510
1511   r = guestfs_list_partitions (g);
1512   if (r == NULL)
1513     rb_raise (e_Error, "%s", guestfs_last_error (g));
1514
1515   int i, len = 0;
1516   for (i = 0; r[i] != NULL; ++i) len++;
1517   VALUE rv = rb_ary_new2 (len);
1518   for (i = 0; r[i] != NULL; ++i) {
1519     rb_ary_push (rv, rb_str_new2 (r[i]));
1520     free (r[i]);
1521   }
1522   free (r);
1523   return rv;
1524 }
1525
1526 static VALUE ruby_guestfs_pvs (VALUE gv)
1527 {
1528   guestfs_h *g;
1529   Data_Get_Struct (gv, guestfs_h, g);
1530   if (!g)
1531     rb_raise (rb_eArgError, "%s: used handle after closing it", "pvs");
1532
1533
1534   char **r;
1535
1536   r = guestfs_pvs (g);
1537   if (r == NULL)
1538     rb_raise (e_Error, "%s", guestfs_last_error (g));
1539
1540   int i, len = 0;
1541   for (i = 0; r[i] != NULL; ++i) len++;
1542   VALUE rv = rb_ary_new2 (len);
1543   for (i = 0; r[i] != NULL; ++i) {
1544     rb_ary_push (rv, rb_str_new2 (r[i]));
1545     free (r[i]);
1546   }
1547   free (r);
1548   return rv;
1549 }
1550
1551 static VALUE ruby_guestfs_vgs (VALUE gv)
1552 {
1553   guestfs_h *g;
1554   Data_Get_Struct (gv, guestfs_h, g);
1555   if (!g)
1556     rb_raise (rb_eArgError, "%s: used handle after closing it", "vgs");
1557
1558
1559   char **r;
1560
1561   r = guestfs_vgs (g);
1562   if (r == NULL)
1563     rb_raise (e_Error, "%s", guestfs_last_error (g));
1564
1565   int i, len = 0;
1566   for (i = 0; r[i] != NULL; ++i) len++;
1567   VALUE rv = rb_ary_new2 (len);
1568   for (i = 0; r[i] != NULL; ++i) {
1569     rb_ary_push (rv, rb_str_new2 (r[i]));
1570     free (r[i]);
1571   }
1572   free (r);
1573   return rv;
1574 }
1575
1576 static VALUE ruby_guestfs_lvs (VALUE gv)
1577 {
1578   guestfs_h *g;
1579   Data_Get_Struct (gv, guestfs_h, g);
1580   if (!g)
1581     rb_raise (rb_eArgError, "%s: used handle after closing it", "lvs");
1582
1583
1584   char **r;
1585
1586   r = guestfs_lvs (g);
1587   if (r == NULL)
1588     rb_raise (e_Error, "%s", guestfs_last_error (g));
1589
1590   int i, len = 0;
1591   for (i = 0; r[i] != NULL; ++i) len++;
1592   VALUE rv = rb_ary_new2 (len);
1593   for (i = 0; r[i] != NULL; ++i) {
1594     rb_ary_push (rv, rb_str_new2 (r[i]));
1595     free (r[i]);
1596   }
1597   free (r);
1598   return rv;
1599 }
1600
1601 static VALUE ruby_guestfs_pvs_full (VALUE gv)
1602 {
1603   guestfs_h *g;
1604   Data_Get_Struct (gv, guestfs_h, g);
1605   if (!g)
1606     rb_raise (rb_eArgError, "%s: used handle after closing it", "pvs_full");
1607
1608
1609   struct guestfs_lvm_pv_list *r;
1610
1611   r = guestfs_pvs_full (g);
1612   if (r == NULL)
1613     rb_raise (e_Error, "%s", guestfs_last_error (g));
1614
1615   VALUE rv = rb_ary_new2 (r->len);
1616   int i;
1617   for (i = 0; i < r->len; ++i) {
1618     VALUE hv = rb_hash_new ();
1619     rb_hash_aset (rv, rb_str_new2 ("pv_name"), rb_str_new2 (r->val[i].pv_name));
1620     rb_hash_aset (rv, rb_str_new2 ("pv_uuid"), rb_str_new (r->val[i].pv_uuid, 32));
1621     rb_hash_aset (rv, rb_str_new2 ("pv_fmt"), rb_str_new2 (r->val[i].pv_fmt));
1622     rb_hash_aset (rv, rb_str_new2 ("pv_size"), ULL2NUM (r->val[i].pv_size));
1623     rb_hash_aset (rv, rb_str_new2 ("dev_size"), ULL2NUM (r->val[i].dev_size));
1624     rb_hash_aset (rv, rb_str_new2 ("pv_free"), ULL2NUM (r->val[i].pv_free));
1625     rb_hash_aset (rv, rb_str_new2 ("pv_used"), ULL2NUM (r->val[i].pv_used));
1626     rb_hash_aset (rv, rb_str_new2 ("pv_attr"), rb_str_new2 (r->val[i].pv_attr));
1627     rb_hash_aset (rv, rb_str_new2 ("pv_pe_count"), ULL2NUM (r->val[i].pv_pe_count));
1628     rb_hash_aset (rv, rb_str_new2 ("pv_pe_alloc_count"), ULL2NUM (r->val[i].pv_pe_alloc_count));
1629     rb_hash_aset (rv, rb_str_new2 ("pv_tags"), rb_str_new2 (r->val[i].pv_tags));
1630     rb_hash_aset (rv, rb_str_new2 ("pe_start"), ULL2NUM (r->val[i].pe_start));
1631     rb_hash_aset (rv, rb_str_new2 ("pv_mda_count"), ULL2NUM (r->val[i].pv_mda_count));
1632     rb_hash_aset (rv, rb_str_new2 ("pv_mda_free"), ULL2NUM (r->val[i].pv_mda_free));
1633     rb_ary_push (rv, hv);
1634   }
1635   guestfs_free_lvm_pv_list (r);
1636   return rv;
1637 }
1638
1639 static VALUE ruby_guestfs_vgs_full (VALUE gv)
1640 {
1641   guestfs_h *g;
1642   Data_Get_Struct (gv, guestfs_h, g);
1643   if (!g)
1644     rb_raise (rb_eArgError, "%s: used handle after closing it", "vgs_full");
1645
1646
1647   struct guestfs_lvm_vg_list *r;
1648
1649   r = guestfs_vgs_full (g);
1650   if (r == NULL)
1651     rb_raise (e_Error, "%s", guestfs_last_error (g));
1652
1653   VALUE rv = rb_ary_new2 (r->len);
1654   int i;
1655   for (i = 0; i < r->len; ++i) {
1656     VALUE hv = rb_hash_new ();
1657     rb_hash_aset (rv, rb_str_new2 ("vg_name"), rb_str_new2 (r->val[i].vg_name));
1658     rb_hash_aset (rv, rb_str_new2 ("vg_uuid"), rb_str_new (r->val[i].vg_uuid, 32));
1659     rb_hash_aset (rv, rb_str_new2 ("vg_fmt"), rb_str_new2 (r->val[i].vg_fmt));
1660     rb_hash_aset (rv, rb_str_new2 ("vg_attr"), rb_str_new2 (r->val[i].vg_attr));
1661     rb_hash_aset (rv, rb_str_new2 ("vg_size"), ULL2NUM (r->val[i].vg_size));
1662     rb_hash_aset (rv, rb_str_new2 ("vg_free"), ULL2NUM (r->val[i].vg_free));
1663     rb_hash_aset (rv, rb_str_new2 ("vg_sysid"), rb_str_new2 (r->val[i].vg_sysid));
1664     rb_hash_aset (rv, rb_str_new2 ("vg_extent_size"), ULL2NUM (r->val[i].vg_extent_size));
1665     rb_hash_aset (rv, rb_str_new2 ("vg_extent_count"), ULL2NUM (r->val[i].vg_extent_count));
1666     rb_hash_aset (rv, rb_str_new2 ("vg_free_count"), ULL2NUM (r->val[i].vg_free_count));
1667     rb_hash_aset (rv, rb_str_new2 ("max_lv"), ULL2NUM (r->val[i].max_lv));
1668     rb_hash_aset (rv, rb_str_new2 ("max_pv"), ULL2NUM (r->val[i].max_pv));
1669     rb_hash_aset (rv, rb_str_new2 ("pv_count"), ULL2NUM (r->val[i].pv_count));
1670     rb_hash_aset (rv, rb_str_new2 ("lv_count"), ULL2NUM (r->val[i].lv_count));
1671     rb_hash_aset (rv, rb_str_new2 ("snap_count"), ULL2NUM (r->val[i].snap_count));
1672     rb_hash_aset (rv, rb_str_new2 ("vg_seqno"), ULL2NUM (r->val[i].vg_seqno));
1673     rb_hash_aset (rv, rb_str_new2 ("vg_tags"), rb_str_new2 (r->val[i].vg_tags));
1674     rb_hash_aset (rv, rb_str_new2 ("vg_mda_count"), ULL2NUM (r->val[i].vg_mda_count));
1675     rb_hash_aset (rv, rb_str_new2 ("vg_mda_free"), ULL2NUM (r->val[i].vg_mda_free));
1676     rb_ary_push (rv, hv);
1677   }
1678   guestfs_free_lvm_vg_list (r);
1679   return rv;
1680 }
1681
1682 static VALUE ruby_guestfs_lvs_full (VALUE gv)
1683 {
1684   guestfs_h *g;
1685   Data_Get_Struct (gv, guestfs_h, g);
1686   if (!g)
1687     rb_raise (rb_eArgError, "%s: used handle after closing it", "lvs_full");
1688
1689
1690   struct guestfs_lvm_lv_list *r;
1691
1692   r = guestfs_lvs_full (g);
1693   if (r == NULL)
1694     rb_raise (e_Error, "%s", guestfs_last_error (g));
1695
1696   VALUE rv = rb_ary_new2 (r->len);
1697   int i;
1698   for (i = 0; i < r->len; ++i) {
1699     VALUE hv = rb_hash_new ();
1700     rb_hash_aset (rv, rb_str_new2 ("lv_name"), rb_str_new2 (r->val[i].lv_name));
1701     rb_hash_aset (rv, rb_str_new2 ("lv_uuid"), rb_str_new (r->val[i].lv_uuid, 32));
1702     rb_hash_aset (rv, rb_str_new2 ("lv_attr"), rb_str_new2 (r->val[i].lv_attr));
1703     rb_hash_aset (rv, rb_str_new2 ("lv_major"), ULL2NUM (r->val[i].lv_major));
1704     rb_hash_aset (rv, rb_str_new2 ("lv_minor"), ULL2NUM (r->val[i].lv_minor));
1705     rb_hash_aset (rv, rb_str_new2 ("lv_kernel_major"), ULL2NUM (r->val[i].lv_kernel_major));
1706     rb_hash_aset (rv, rb_str_new2 ("lv_kernel_minor"), ULL2NUM (r->val[i].lv_kernel_minor));
1707     rb_hash_aset (rv, rb_str_new2 ("lv_size"), ULL2NUM (r->val[i].lv_size));
1708     rb_hash_aset (rv, rb_str_new2 ("seg_count"), ULL2NUM (r->val[i].seg_count));
1709     rb_hash_aset (rv, rb_str_new2 ("origin"), rb_str_new2 (r->val[i].origin));
1710     rb_hash_aset (rv, rb_str_new2 ("snap_percent"), rb_dbl2big (r->val[i].snap_percent));
1711     rb_hash_aset (rv, rb_str_new2 ("copy_percent"), rb_dbl2big (r->val[i].copy_percent));
1712     rb_hash_aset (rv, rb_str_new2 ("move_pv"), rb_str_new2 (r->val[i].move_pv));
1713     rb_hash_aset (rv, rb_str_new2 ("lv_tags"), rb_str_new2 (r->val[i].lv_tags));
1714     rb_hash_aset (rv, rb_str_new2 ("mirror_log"), rb_str_new2 (r->val[i].mirror_log));
1715     rb_hash_aset (rv, rb_str_new2 ("modules"), rb_str_new2 (r->val[i].modules));
1716     rb_ary_push (rv, hv);
1717   }
1718   guestfs_free_lvm_lv_list (r);
1719   return rv;
1720 }
1721
1722 static VALUE ruby_guestfs_read_lines (VALUE gv, VALUE pathv)
1723 {
1724   guestfs_h *g;
1725   Data_Get_Struct (gv, guestfs_h, g);
1726   if (!g)
1727     rb_raise (rb_eArgError, "%s: used handle after closing it", "read_lines");
1728
1729   Check_Type (pathv, T_STRING);
1730   const char *path = StringValueCStr (pathv);
1731   if (!path)
1732     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1733               "path", "read_lines");
1734
1735   char **r;
1736
1737   r = guestfs_read_lines (g, path);
1738   if (r == NULL)
1739     rb_raise (e_Error, "%s", guestfs_last_error (g));
1740
1741   int i, len = 0;
1742   for (i = 0; r[i] != NULL; ++i) len++;
1743   VALUE rv = rb_ary_new2 (len);
1744   for (i = 0; r[i] != NULL; ++i) {
1745     rb_ary_push (rv, rb_str_new2 (r[i]));
1746     free (r[i]);
1747   }
1748   free (r);
1749   return rv;
1750 }
1751
1752 static VALUE ruby_guestfs_aug_init (VALUE gv, VALUE rootv, VALUE flagsv)
1753 {
1754   guestfs_h *g;
1755   Data_Get_Struct (gv, guestfs_h, g);
1756   if (!g)
1757     rb_raise (rb_eArgError, "%s: used handle after closing it", "aug_init");
1758
1759   Check_Type (rootv, T_STRING);
1760   const char *root = StringValueCStr (rootv);
1761   if (!root)
1762     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1763               "root", "aug_init");
1764   int flags = NUM2INT (flagsv);
1765
1766   int r;
1767
1768   r = guestfs_aug_init (g, root, flags);
1769   if (r == -1)
1770     rb_raise (e_Error, "%s", guestfs_last_error (g));
1771
1772   return Qnil;
1773 }
1774
1775 static VALUE ruby_guestfs_aug_close (VALUE gv)
1776 {
1777   guestfs_h *g;
1778   Data_Get_Struct (gv, guestfs_h, g);
1779   if (!g)
1780     rb_raise (rb_eArgError, "%s: used handle after closing it", "aug_close");
1781
1782
1783   int r;
1784
1785   r = guestfs_aug_close (g);
1786   if (r == -1)
1787     rb_raise (e_Error, "%s", guestfs_last_error (g));
1788
1789   return Qnil;
1790 }
1791
1792 static VALUE ruby_guestfs_aug_defvar (VALUE gv, VALUE namev, VALUE exprv)
1793 {
1794   guestfs_h *g;
1795   Data_Get_Struct (gv, guestfs_h, g);
1796   if (!g)
1797     rb_raise (rb_eArgError, "%s: used handle after closing it", "aug_defvar");
1798
1799   Check_Type (namev, T_STRING);
1800   const char *name = StringValueCStr (namev);
1801   if (!name)
1802     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1803               "name", "aug_defvar");
1804   const char *expr = !NIL_P (exprv) ? StringValueCStr (exprv) : NULL;
1805
1806   int r;
1807
1808   r = guestfs_aug_defvar (g, name, expr);
1809   if (r == -1)
1810     rb_raise (e_Error, "%s", guestfs_last_error (g));
1811
1812   return INT2NUM (r);
1813 }
1814
1815 static VALUE ruby_guestfs_aug_defnode (VALUE gv, VALUE namev, VALUE exprv, VALUE valv)
1816 {
1817   guestfs_h *g;
1818   Data_Get_Struct (gv, guestfs_h, g);
1819   if (!g)
1820     rb_raise (rb_eArgError, "%s: used handle after closing it", "aug_defnode");
1821
1822   Check_Type (namev, T_STRING);
1823   const char *name = StringValueCStr (namev);
1824   if (!name)
1825     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1826               "name", "aug_defnode");
1827   Check_Type (exprv, T_STRING);
1828   const char *expr = StringValueCStr (exprv);
1829   if (!expr)
1830     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1831               "expr", "aug_defnode");
1832   Check_Type (valv, T_STRING);
1833   const char *val = StringValueCStr (valv);
1834   if (!val)
1835     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1836               "val", "aug_defnode");
1837
1838   struct guestfs_int_bool *r;
1839
1840   r = guestfs_aug_defnode (g, name, expr, val);
1841   if (r == NULL)
1842     rb_raise (e_Error, "%s", guestfs_last_error (g));
1843
1844   VALUE rv = rb_ary_new2 (2);
1845   rb_ary_push (rv, INT2NUM (r->i));
1846   rb_ary_push (rv, INT2NUM (r->b));
1847   guestfs_free_int_bool (r);
1848   return rv;
1849 }
1850
1851 static VALUE ruby_guestfs_aug_get (VALUE gv, VALUE pathv)
1852 {
1853   guestfs_h *g;
1854   Data_Get_Struct (gv, guestfs_h, g);
1855   if (!g)
1856     rb_raise (rb_eArgError, "%s: used handle after closing it", "aug_get");
1857
1858   Check_Type (pathv, T_STRING);
1859   const char *path = StringValueCStr (pathv);
1860   if (!path)
1861     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1862               "path", "aug_get");
1863
1864   char *r;
1865
1866   r = guestfs_aug_get (g, path);
1867   if (r == NULL)
1868     rb_raise (e_Error, "%s", guestfs_last_error (g));
1869
1870   VALUE rv = rb_str_new2 (r);
1871   free (r);
1872   return rv;
1873 }
1874
1875 static VALUE ruby_guestfs_aug_set (VALUE gv, VALUE pathv, VALUE valv)
1876 {
1877   guestfs_h *g;
1878   Data_Get_Struct (gv, guestfs_h, g);
1879   if (!g)
1880     rb_raise (rb_eArgError, "%s: used handle after closing it", "aug_set");
1881
1882   Check_Type (pathv, T_STRING);
1883   const char *path = StringValueCStr (pathv);
1884   if (!path)
1885     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1886               "path", "aug_set");
1887   Check_Type (valv, T_STRING);
1888   const char *val = StringValueCStr (valv);
1889   if (!val)
1890     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1891               "val", "aug_set");
1892
1893   int r;
1894
1895   r = guestfs_aug_set (g, path, val);
1896   if (r == -1)
1897     rb_raise (e_Error, "%s", guestfs_last_error (g));
1898
1899   return Qnil;
1900 }
1901
1902 static VALUE ruby_guestfs_aug_insert (VALUE gv, VALUE pathv, VALUE labelv, VALUE beforev)
1903 {
1904   guestfs_h *g;
1905   Data_Get_Struct (gv, guestfs_h, g);
1906   if (!g)
1907     rb_raise (rb_eArgError, "%s: used handle after closing it", "aug_insert");
1908
1909   Check_Type (pathv, T_STRING);
1910   const char *path = StringValueCStr (pathv);
1911   if (!path)
1912     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1913               "path", "aug_insert");
1914   Check_Type (labelv, T_STRING);
1915   const char *label = StringValueCStr (labelv);
1916   if (!label)
1917     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1918               "label", "aug_insert");
1919   int before = RTEST (beforev);
1920
1921   int r;
1922
1923   r = guestfs_aug_insert (g, path, label, before);
1924   if (r == -1)
1925     rb_raise (e_Error, "%s", guestfs_last_error (g));
1926
1927   return Qnil;
1928 }
1929
1930 static VALUE ruby_guestfs_aug_rm (VALUE gv, VALUE pathv)
1931 {
1932   guestfs_h *g;
1933   Data_Get_Struct (gv, guestfs_h, g);
1934   if (!g)
1935     rb_raise (rb_eArgError, "%s: used handle after closing it", "aug_rm");
1936
1937   Check_Type (pathv, T_STRING);
1938   const char *path = StringValueCStr (pathv);
1939   if (!path)
1940     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1941               "path", "aug_rm");
1942
1943   int r;
1944
1945   r = guestfs_aug_rm (g, path);
1946   if (r == -1)
1947     rb_raise (e_Error, "%s", guestfs_last_error (g));
1948
1949   return INT2NUM (r);
1950 }
1951
1952 static VALUE ruby_guestfs_aug_mv (VALUE gv, VALUE srcv, VALUE destv)
1953 {
1954   guestfs_h *g;
1955   Data_Get_Struct (gv, guestfs_h, g);
1956   if (!g)
1957     rb_raise (rb_eArgError, "%s: used handle after closing it", "aug_mv");
1958
1959   Check_Type (srcv, T_STRING);
1960   const char *src = StringValueCStr (srcv);
1961   if (!src)
1962     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1963               "src", "aug_mv");
1964   Check_Type (destv, T_STRING);
1965   const char *dest = StringValueCStr (destv);
1966   if (!dest)
1967     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1968               "dest", "aug_mv");
1969
1970   int r;
1971
1972   r = guestfs_aug_mv (g, src, dest);
1973   if (r == -1)
1974     rb_raise (e_Error, "%s", guestfs_last_error (g));
1975
1976   return Qnil;
1977 }
1978
1979 static VALUE ruby_guestfs_aug_match (VALUE gv, VALUE pathv)
1980 {
1981   guestfs_h *g;
1982   Data_Get_Struct (gv, guestfs_h, g);
1983   if (!g)
1984     rb_raise (rb_eArgError, "%s: used handle after closing it", "aug_match");
1985
1986   Check_Type (pathv, T_STRING);
1987   const char *path = StringValueCStr (pathv);
1988   if (!path)
1989     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1990               "path", "aug_match");
1991
1992   char **r;
1993
1994   r = guestfs_aug_match (g, path);
1995   if (r == NULL)
1996     rb_raise (e_Error, "%s", guestfs_last_error (g));
1997
1998   int i, len = 0;
1999   for (i = 0; r[i] != NULL; ++i) len++;
2000   VALUE rv = rb_ary_new2 (len);
2001   for (i = 0; r[i] != NULL; ++i) {
2002     rb_ary_push (rv, rb_str_new2 (r[i]));
2003     free (r[i]);
2004   }
2005   free (r);
2006   return rv;
2007 }
2008
2009 static VALUE ruby_guestfs_aug_save (VALUE gv)
2010 {
2011   guestfs_h *g;
2012   Data_Get_Struct (gv, guestfs_h, g);
2013   if (!g)
2014     rb_raise (rb_eArgError, "%s: used handle after closing it", "aug_save");
2015
2016
2017   int r;
2018
2019   r = guestfs_aug_save (g);
2020   if (r == -1)
2021     rb_raise (e_Error, "%s", guestfs_last_error (g));
2022
2023   return Qnil;
2024 }
2025
2026 static VALUE ruby_guestfs_aug_load (VALUE gv)
2027 {
2028   guestfs_h *g;
2029   Data_Get_Struct (gv, guestfs_h, g);
2030   if (!g)
2031     rb_raise (rb_eArgError, "%s: used handle after closing it", "aug_load");
2032
2033
2034   int r;
2035
2036   r = guestfs_aug_load (g);
2037   if (r == -1)
2038     rb_raise (e_Error, "%s", guestfs_last_error (g));
2039
2040   return Qnil;
2041 }
2042
2043 static VALUE ruby_guestfs_aug_ls (VALUE gv, VALUE pathv)
2044 {
2045   guestfs_h *g;
2046   Data_Get_Struct (gv, guestfs_h, g);
2047   if (!g)
2048     rb_raise (rb_eArgError, "%s: used handle after closing it", "aug_ls");
2049
2050   Check_Type (pathv, T_STRING);
2051   const char *path = StringValueCStr (pathv);
2052   if (!path)
2053     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2054               "path", "aug_ls");
2055
2056   char **r;
2057
2058   r = guestfs_aug_ls (g, path);
2059   if (r == NULL)
2060     rb_raise (e_Error, "%s", guestfs_last_error (g));
2061
2062   int i, len = 0;
2063   for (i = 0; r[i] != NULL; ++i) len++;
2064   VALUE rv = rb_ary_new2 (len);
2065   for (i = 0; r[i] != NULL; ++i) {
2066     rb_ary_push (rv, rb_str_new2 (r[i]));
2067     free (r[i]);
2068   }
2069   free (r);
2070   return rv;
2071 }
2072
2073 static VALUE ruby_guestfs_rm (VALUE gv, VALUE pathv)
2074 {
2075   guestfs_h *g;
2076   Data_Get_Struct (gv, guestfs_h, g);
2077   if (!g)
2078     rb_raise (rb_eArgError, "%s: used handle after closing it", "rm");
2079
2080   Check_Type (pathv, T_STRING);
2081   const char *path = StringValueCStr (pathv);
2082   if (!path)
2083     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2084               "path", "rm");
2085
2086   int r;
2087
2088   r = guestfs_rm (g, path);
2089   if (r == -1)
2090     rb_raise (e_Error, "%s", guestfs_last_error (g));
2091
2092   return Qnil;
2093 }
2094
2095 static VALUE ruby_guestfs_rmdir (VALUE gv, VALUE pathv)
2096 {
2097   guestfs_h *g;
2098   Data_Get_Struct (gv, guestfs_h, g);
2099   if (!g)
2100     rb_raise (rb_eArgError, "%s: used handle after closing it", "rmdir");
2101
2102   Check_Type (pathv, T_STRING);
2103   const char *path = StringValueCStr (pathv);
2104   if (!path)
2105     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2106               "path", "rmdir");
2107
2108   int r;
2109
2110   r = guestfs_rmdir (g, path);
2111   if (r == -1)
2112     rb_raise (e_Error, "%s", guestfs_last_error (g));
2113
2114   return Qnil;
2115 }
2116
2117 static VALUE ruby_guestfs_rm_rf (VALUE gv, VALUE pathv)
2118 {
2119   guestfs_h *g;
2120   Data_Get_Struct (gv, guestfs_h, g);
2121   if (!g)
2122     rb_raise (rb_eArgError, "%s: used handle after closing it", "rm_rf");
2123
2124   Check_Type (pathv, T_STRING);
2125   const char *path = StringValueCStr (pathv);
2126   if (!path)
2127     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2128               "path", "rm_rf");
2129
2130   int r;
2131
2132   r = guestfs_rm_rf (g, path);
2133   if (r == -1)
2134     rb_raise (e_Error, "%s", guestfs_last_error (g));
2135
2136   return Qnil;
2137 }
2138
2139 static VALUE ruby_guestfs_mkdir (VALUE gv, VALUE pathv)
2140 {
2141   guestfs_h *g;
2142   Data_Get_Struct (gv, guestfs_h, g);
2143   if (!g)
2144     rb_raise (rb_eArgError, "%s: used handle after closing it", "mkdir");
2145
2146   Check_Type (pathv, T_STRING);
2147   const char *path = StringValueCStr (pathv);
2148   if (!path)
2149     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2150               "path", "mkdir");
2151
2152   int r;
2153
2154   r = guestfs_mkdir (g, path);
2155   if (r == -1)
2156     rb_raise (e_Error, "%s", guestfs_last_error (g));
2157
2158   return Qnil;
2159 }
2160
2161 static VALUE ruby_guestfs_mkdir_p (VALUE gv, VALUE pathv)
2162 {
2163   guestfs_h *g;
2164   Data_Get_Struct (gv, guestfs_h, g);
2165   if (!g)
2166     rb_raise (rb_eArgError, "%s: used handle after closing it", "mkdir_p");
2167
2168   Check_Type (pathv, T_STRING);
2169   const char *path = StringValueCStr (pathv);
2170   if (!path)
2171     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2172               "path", "mkdir_p");
2173
2174   int r;
2175
2176   r = guestfs_mkdir_p (g, path);
2177   if (r == -1)
2178     rb_raise (e_Error, "%s", guestfs_last_error (g));
2179
2180   return Qnil;
2181 }
2182
2183 static VALUE ruby_guestfs_chmod (VALUE gv, VALUE modev, VALUE pathv)
2184 {
2185   guestfs_h *g;
2186   Data_Get_Struct (gv, guestfs_h, g);
2187   if (!g)
2188     rb_raise (rb_eArgError, "%s: used handle after closing it", "chmod");
2189
2190   int mode = NUM2INT (modev);
2191   Check_Type (pathv, T_STRING);
2192   const char *path = StringValueCStr (pathv);
2193   if (!path)
2194     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2195               "path", "chmod");
2196
2197   int r;
2198
2199   r = guestfs_chmod (g, mode, path);
2200   if (r == -1)
2201     rb_raise (e_Error, "%s", guestfs_last_error (g));
2202
2203   return Qnil;
2204 }
2205
2206 static VALUE ruby_guestfs_chown (VALUE gv, VALUE ownerv, VALUE groupv, VALUE pathv)
2207 {
2208   guestfs_h *g;
2209   Data_Get_Struct (gv, guestfs_h, g);
2210   if (!g)
2211     rb_raise (rb_eArgError, "%s: used handle after closing it", "chown");
2212
2213   int owner = NUM2INT (ownerv);
2214   int group = NUM2INT (groupv);
2215   Check_Type (pathv, T_STRING);
2216   const char *path = StringValueCStr (pathv);
2217   if (!path)
2218     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2219               "path", "chown");
2220
2221   int r;
2222
2223   r = guestfs_chown (g, owner, group, path);
2224   if (r == -1)
2225     rb_raise (e_Error, "%s", guestfs_last_error (g));
2226
2227   return Qnil;
2228 }
2229
2230 static VALUE ruby_guestfs_exists (VALUE gv, VALUE pathv)
2231 {
2232   guestfs_h *g;
2233   Data_Get_Struct (gv, guestfs_h, g);
2234   if (!g)
2235     rb_raise (rb_eArgError, "%s: used handle after closing it", "exists");
2236
2237   Check_Type (pathv, T_STRING);
2238   const char *path = StringValueCStr (pathv);
2239   if (!path)
2240     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2241               "path", "exists");
2242
2243   int r;
2244
2245   r = guestfs_exists (g, path);
2246   if (r == -1)
2247     rb_raise (e_Error, "%s", guestfs_last_error (g));
2248
2249   return INT2NUM (r);
2250 }
2251
2252 static VALUE ruby_guestfs_is_file (VALUE gv, VALUE pathv)
2253 {
2254   guestfs_h *g;
2255   Data_Get_Struct (gv, guestfs_h, g);
2256   if (!g)
2257     rb_raise (rb_eArgError, "%s: used handle after closing it", "is_file");
2258
2259   Check_Type (pathv, T_STRING);
2260   const char *path = StringValueCStr (pathv);
2261   if (!path)
2262     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2263               "path", "is_file");
2264
2265   int r;
2266
2267   r = guestfs_is_file (g, path);
2268   if (r == -1)
2269     rb_raise (e_Error, "%s", guestfs_last_error (g));
2270
2271   return INT2NUM (r);
2272 }
2273
2274 static VALUE ruby_guestfs_is_dir (VALUE gv, VALUE pathv)
2275 {
2276   guestfs_h *g;
2277   Data_Get_Struct (gv, guestfs_h, g);
2278   if (!g)
2279     rb_raise (rb_eArgError, "%s: used handle after closing it", "is_dir");
2280
2281   Check_Type (pathv, T_STRING);
2282   const char *path = StringValueCStr (pathv);
2283   if (!path)
2284     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2285               "path", "is_dir");
2286
2287   int r;
2288
2289   r = guestfs_is_dir (g, path);
2290   if (r == -1)
2291     rb_raise (e_Error, "%s", guestfs_last_error (g));
2292
2293   return INT2NUM (r);
2294 }
2295
2296 static VALUE ruby_guestfs_pvcreate (VALUE gv, VALUE devicev)
2297 {
2298   guestfs_h *g;
2299   Data_Get_Struct (gv, guestfs_h, g);
2300   if (!g)
2301     rb_raise (rb_eArgError, "%s: used handle after closing it", "pvcreate");
2302
2303   Check_Type (devicev, T_STRING);
2304   const char *device = StringValueCStr (devicev);
2305   if (!device)
2306     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2307               "device", "pvcreate");
2308
2309   int r;
2310
2311   r = guestfs_pvcreate (g, device);
2312   if (r == -1)
2313     rb_raise (e_Error, "%s", guestfs_last_error (g));
2314
2315   return Qnil;
2316 }
2317
2318 static VALUE ruby_guestfs_vgcreate (VALUE gv, VALUE volgroupv, VALUE physvolsv)
2319 {
2320   guestfs_h *g;
2321   Data_Get_Struct (gv, guestfs_h, g);
2322   if (!g)
2323     rb_raise (rb_eArgError, "%s: used handle after closing it", "vgcreate");
2324
2325   Check_Type (volgroupv, T_STRING);
2326   const char *volgroup = StringValueCStr (volgroupv);
2327   if (!volgroup)
2328     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2329               "volgroup", "vgcreate");
2330   char **physvols;
2331   Check_Type (physvolsv, T_ARRAY);
2332   {
2333     int i, len;
2334     len = RARRAY_LEN (physvolsv);
2335     physvols = guestfs_safe_malloc (g, sizeof (char *) * (len+1));
2336     for (i = 0; i < len; ++i) {
2337       VALUE v = rb_ary_entry (physvolsv, i);
2338       physvols[i] = StringValueCStr (v);
2339     }
2340     physvols[len] = NULL;
2341   }
2342
2343   int r;
2344
2345   r = guestfs_vgcreate (g, volgroup, physvols);
2346   free (physvols);
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_lvcreate (VALUE gv, VALUE logvolv, VALUE volgroupv, VALUE mbytesv)
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", "lvcreate");
2359
2360   Check_Type (logvolv, T_STRING);
2361   const char *logvol = StringValueCStr (logvolv);
2362   if (!logvol)
2363     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2364               "logvol", "lvcreate");
2365   Check_Type (volgroupv, T_STRING);
2366   const char *volgroup = StringValueCStr (volgroupv);
2367   if (!volgroup)
2368     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2369               "volgroup", "lvcreate");
2370   int mbytes = NUM2INT (mbytesv);
2371
2372   int r;
2373
2374   r = guestfs_lvcreate (g, logvol, volgroup, mbytes);
2375   if (r == -1)
2376     rb_raise (e_Error, "%s", guestfs_last_error (g));
2377
2378   return Qnil;
2379 }
2380
2381 static VALUE ruby_guestfs_mkfs (VALUE gv, VALUE fstypev, VALUE devicev)
2382 {
2383   guestfs_h *g;
2384   Data_Get_Struct (gv, guestfs_h, g);
2385   if (!g)
2386     rb_raise (rb_eArgError, "%s: used handle after closing it", "mkfs");
2387
2388   Check_Type (fstypev, T_STRING);
2389   const char *fstype = StringValueCStr (fstypev);
2390   if (!fstype)
2391     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2392               "fstype", "mkfs");
2393   Check_Type (devicev, T_STRING);
2394   const char *device = StringValueCStr (devicev);
2395   if (!device)
2396     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2397               "device", "mkfs");
2398
2399   int r;
2400
2401   r = guestfs_mkfs (g, fstype, device);
2402   if (r == -1)
2403     rb_raise (e_Error, "%s", guestfs_last_error (g));
2404
2405   return Qnil;
2406 }
2407
2408 static VALUE ruby_guestfs_sfdisk (VALUE gv, VALUE devicev, VALUE cylsv, VALUE headsv, VALUE sectorsv, VALUE linesv)
2409 {
2410   guestfs_h *g;
2411   Data_Get_Struct (gv, guestfs_h, g);
2412   if (!g)
2413     rb_raise (rb_eArgError, "%s: used handle after closing it", "sfdisk");
2414
2415   Check_Type (devicev, T_STRING);
2416   const char *device = StringValueCStr (devicev);
2417   if (!device)
2418     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2419               "device", "sfdisk");
2420   int cyls = NUM2INT (cylsv);
2421   int heads = NUM2INT (headsv);
2422   int sectors = NUM2INT (sectorsv);
2423   char **lines;
2424   Check_Type (linesv, T_ARRAY);
2425   {
2426     int i, len;
2427     len = RARRAY_LEN (linesv);
2428     lines = guestfs_safe_malloc (g, sizeof (char *) * (len+1));
2429     for (i = 0; i < len; ++i) {
2430       VALUE v = rb_ary_entry (linesv, i);
2431       lines[i] = StringValueCStr (v);
2432     }
2433     lines[len] = NULL;
2434   }
2435
2436   int r;
2437
2438   r = guestfs_sfdisk (g, device, cyls, heads, sectors, lines);
2439   free (lines);
2440   if (r == -1)
2441     rb_raise (e_Error, "%s", guestfs_last_error (g));
2442
2443   return Qnil;
2444 }
2445
2446 static VALUE ruby_guestfs_write_file (VALUE gv, VALUE pathv, VALUE contentv, VALUE sizev)
2447 {
2448   guestfs_h *g;
2449   Data_Get_Struct (gv, guestfs_h, g);
2450   if (!g)
2451     rb_raise (rb_eArgError, "%s: used handle after closing it", "write_file");
2452
2453   Check_Type (pathv, T_STRING);
2454   const char *path = StringValueCStr (pathv);
2455   if (!path)
2456     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2457               "path", "write_file");
2458   Check_Type (contentv, T_STRING);
2459   const char *content = StringValueCStr (contentv);
2460   if (!content)
2461     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2462               "content", "write_file");
2463   int size = NUM2INT (sizev);
2464
2465   int r;
2466
2467   r = guestfs_write_file (g, path, content, size);
2468   if (r == -1)
2469     rb_raise (e_Error, "%s", guestfs_last_error (g));
2470
2471   return Qnil;
2472 }
2473
2474 static VALUE ruby_guestfs_umount (VALUE gv, VALUE pathordevicev)
2475 {
2476   guestfs_h *g;
2477   Data_Get_Struct (gv, guestfs_h, g);
2478   if (!g)
2479     rb_raise (rb_eArgError, "%s: used handle after closing it", "umount");
2480
2481   Check_Type (pathordevicev, T_STRING);
2482   const char *pathordevice = StringValueCStr (pathordevicev);
2483   if (!pathordevice)
2484     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2485               "pathordevice", "umount");
2486
2487   int r;
2488
2489   r = guestfs_umount (g, pathordevice);
2490   if (r == -1)
2491     rb_raise (e_Error, "%s", guestfs_last_error (g));
2492
2493   return Qnil;
2494 }
2495
2496 static VALUE ruby_guestfs_mounts (VALUE gv)
2497 {
2498   guestfs_h *g;
2499   Data_Get_Struct (gv, guestfs_h, g);
2500   if (!g)
2501     rb_raise (rb_eArgError, "%s: used handle after closing it", "mounts");
2502
2503
2504   char **r;
2505
2506   r = guestfs_mounts (g);
2507   if (r == NULL)
2508     rb_raise (e_Error, "%s", guestfs_last_error (g));
2509
2510   int i, len = 0;
2511   for (i = 0; r[i] != NULL; ++i) len++;
2512   VALUE rv = rb_ary_new2 (len);
2513   for (i = 0; r[i] != NULL; ++i) {
2514     rb_ary_push (rv, rb_str_new2 (r[i]));
2515     free (r[i]);
2516   }
2517   free (r);
2518   return rv;
2519 }
2520
2521 static VALUE ruby_guestfs_umount_all (VALUE gv)
2522 {
2523   guestfs_h *g;
2524   Data_Get_Struct (gv, guestfs_h, g);
2525   if (!g)
2526     rb_raise (rb_eArgError, "%s: used handle after closing it", "umount_all");
2527
2528
2529   int r;
2530
2531   r = guestfs_umount_all (g);
2532   if (r == -1)
2533     rb_raise (e_Error, "%s", guestfs_last_error (g));
2534
2535   return Qnil;
2536 }
2537
2538 static VALUE ruby_guestfs_lvm_remove_all (VALUE gv)
2539 {
2540   guestfs_h *g;
2541   Data_Get_Struct (gv, guestfs_h, g);
2542   if (!g)
2543     rb_raise (rb_eArgError, "%s: used handle after closing it", "lvm_remove_all");
2544
2545
2546   int r;
2547
2548   r = guestfs_lvm_remove_all (g);
2549   if (r == -1)
2550     rb_raise (e_Error, "%s", guestfs_last_error (g));
2551
2552   return Qnil;
2553 }
2554
2555 static VALUE ruby_guestfs_file (VALUE gv, VALUE pathv)
2556 {
2557   guestfs_h *g;
2558   Data_Get_Struct (gv, guestfs_h, g);
2559   if (!g)
2560     rb_raise (rb_eArgError, "%s: used handle after closing it", "file");
2561
2562   Check_Type (pathv, T_STRING);
2563   const char *path = StringValueCStr (pathv);
2564   if (!path)
2565     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2566               "path", "file");
2567
2568   char *r;
2569
2570   r = guestfs_file (g, path);
2571   if (r == NULL)
2572     rb_raise (e_Error, "%s", guestfs_last_error (g));
2573
2574   VALUE rv = rb_str_new2 (r);
2575   free (r);
2576   return rv;
2577 }
2578
2579 static VALUE ruby_guestfs_command (VALUE gv, VALUE argumentsv)
2580 {
2581   guestfs_h *g;
2582   Data_Get_Struct (gv, guestfs_h, g);
2583   if (!g)
2584     rb_raise (rb_eArgError, "%s: used handle after closing it", "command");
2585
2586   char **arguments;
2587   Check_Type (argumentsv, T_ARRAY);
2588   {
2589     int i, len;
2590     len = RARRAY_LEN (argumentsv);
2591     arguments = guestfs_safe_malloc (g, sizeof (char *) * (len+1));
2592     for (i = 0; i < len; ++i) {
2593       VALUE v = rb_ary_entry (argumentsv, i);
2594       arguments[i] = StringValueCStr (v);
2595     }
2596     arguments[len] = NULL;
2597   }
2598
2599   char *r;
2600
2601   r = guestfs_command (g, arguments);
2602   free (arguments);
2603   if (r == NULL)
2604     rb_raise (e_Error, "%s", guestfs_last_error (g));
2605
2606   VALUE rv = rb_str_new2 (r);
2607   free (r);
2608   return rv;
2609 }
2610
2611 static VALUE ruby_guestfs_command_lines (VALUE gv, VALUE argumentsv)
2612 {
2613   guestfs_h *g;
2614   Data_Get_Struct (gv, guestfs_h, g);
2615   if (!g)
2616     rb_raise (rb_eArgError, "%s: used handle after closing it", "command_lines");
2617
2618   char **arguments;
2619   Check_Type (argumentsv, T_ARRAY);
2620   {
2621     int i, len;
2622     len = RARRAY_LEN (argumentsv);
2623     arguments = guestfs_safe_malloc (g, sizeof (char *) * (len+1));
2624     for (i = 0; i < len; ++i) {
2625       VALUE v = rb_ary_entry (argumentsv, i);
2626       arguments[i] = StringValueCStr (v);
2627     }
2628     arguments[len] = NULL;
2629   }
2630
2631   char **r;
2632
2633   r = guestfs_command_lines (g, arguments);
2634   free (arguments);
2635   if (r == NULL)
2636     rb_raise (e_Error, "%s", guestfs_last_error (g));
2637
2638   int i, len = 0;
2639   for (i = 0; r[i] != NULL; ++i) len++;
2640   VALUE rv = rb_ary_new2 (len);
2641   for (i = 0; r[i] != NULL; ++i) {
2642     rb_ary_push (rv, rb_str_new2 (r[i]));
2643     free (r[i]);
2644   }
2645   free (r);
2646   return rv;
2647 }
2648
2649 static VALUE ruby_guestfs_stat (VALUE gv, VALUE pathv)
2650 {
2651   guestfs_h *g;
2652   Data_Get_Struct (gv, guestfs_h, g);
2653   if (!g)
2654     rb_raise (rb_eArgError, "%s: used handle after closing it", "stat");
2655
2656   Check_Type (pathv, T_STRING);
2657   const char *path = StringValueCStr (pathv);
2658   if (!path)
2659     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2660               "path", "stat");
2661
2662   struct guestfs_stat *r;
2663
2664   r = guestfs_stat (g, path);
2665   if (r == NULL)
2666     rb_raise (e_Error, "%s", guestfs_last_error (g));
2667
2668   VALUE rv = rb_hash_new ();
2669   rb_hash_aset (rv, rb_str_new2 ("dev"), ULL2NUM (r->dev));
2670   rb_hash_aset (rv, rb_str_new2 ("ino"), ULL2NUM (r->ino));
2671   rb_hash_aset (rv, rb_str_new2 ("mode"), ULL2NUM (r->mode));
2672   rb_hash_aset (rv, rb_str_new2 ("nlink"), ULL2NUM (r->nlink));
2673   rb_hash_aset (rv, rb_str_new2 ("uid"), ULL2NUM (r->uid));
2674   rb_hash_aset (rv, rb_str_new2 ("gid"), ULL2NUM (r->gid));
2675   rb_hash_aset (rv, rb_str_new2 ("rdev"), ULL2NUM (r->rdev));
2676   rb_hash_aset (rv, rb_str_new2 ("size"), ULL2NUM (r->size));
2677   rb_hash_aset (rv, rb_str_new2 ("blksize"), ULL2NUM (r->blksize));
2678   rb_hash_aset (rv, rb_str_new2 ("blocks"), ULL2NUM (r->blocks));
2679   rb_hash_aset (rv, rb_str_new2 ("atime"), ULL2NUM (r->atime));
2680   rb_hash_aset (rv, rb_str_new2 ("mtime"), ULL2NUM (r->mtime));
2681   rb_hash_aset (rv, rb_str_new2 ("ctime"), ULL2NUM (r->ctime));
2682   free (r);
2683   return rv;
2684 }
2685
2686 static VALUE ruby_guestfs_lstat (VALUE gv, VALUE pathv)
2687 {
2688   guestfs_h *g;
2689   Data_Get_Struct (gv, guestfs_h, g);
2690   if (!g)
2691     rb_raise (rb_eArgError, "%s: used handle after closing it", "lstat");
2692
2693   Check_Type (pathv, T_STRING);
2694   const char *path = StringValueCStr (pathv);
2695   if (!path)
2696     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2697               "path", "lstat");
2698
2699   struct guestfs_stat *r;
2700
2701   r = guestfs_lstat (g, path);
2702   if (r == NULL)
2703     rb_raise (e_Error, "%s", guestfs_last_error (g));
2704
2705   VALUE rv = rb_hash_new ();
2706   rb_hash_aset (rv, rb_str_new2 ("dev"), ULL2NUM (r->dev));
2707   rb_hash_aset (rv, rb_str_new2 ("ino"), ULL2NUM (r->ino));
2708   rb_hash_aset (rv, rb_str_new2 ("mode"), ULL2NUM (r->mode));
2709   rb_hash_aset (rv, rb_str_new2 ("nlink"), ULL2NUM (r->nlink));
2710   rb_hash_aset (rv, rb_str_new2 ("uid"), ULL2NUM (r->uid));
2711   rb_hash_aset (rv, rb_str_new2 ("gid"), ULL2NUM (r->gid));
2712   rb_hash_aset (rv, rb_str_new2 ("rdev"), ULL2NUM (r->rdev));
2713   rb_hash_aset (rv, rb_str_new2 ("size"), ULL2NUM (r->size));
2714   rb_hash_aset (rv, rb_str_new2 ("blksize"), ULL2NUM (r->blksize));
2715   rb_hash_aset (rv, rb_str_new2 ("blocks"), ULL2NUM (r->blocks));
2716   rb_hash_aset (rv, rb_str_new2 ("atime"), ULL2NUM (r->atime));
2717   rb_hash_aset (rv, rb_str_new2 ("mtime"), ULL2NUM (r->mtime));
2718   rb_hash_aset (rv, rb_str_new2 ("ctime"), ULL2NUM (r->ctime));
2719   free (r);
2720   return rv;
2721 }
2722
2723 static VALUE ruby_guestfs_statvfs (VALUE gv, VALUE pathv)
2724 {
2725   guestfs_h *g;
2726   Data_Get_Struct (gv, guestfs_h, g);
2727   if (!g)
2728     rb_raise (rb_eArgError, "%s: used handle after closing it", "statvfs");
2729
2730   Check_Type (pathv, T_STRING);
2731   const char *path = StringValueCStr (pathv);
2732   if (!path)
2733     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2734               "path", "statvfs");
2735
2736   struct guestfs_statvfs *r;
2737
2738   r = guestfs_statvfs (g, path);
2739   if (r == NULL)
2740     rb_raise (e_Error, "%s", guestfs_last_error (g));
2741
2742   VALUE rv = rb_hash_new ();
2743   rb_hash_aset (rv, rb_str_new2 ("bsize"), ULL2NUM (r->bsize));
2744   rb_hash_aset (rv, rb_str_new2 ("frsize"), ULL2NUM (r->frsize));
2745   rb_hash_aset (rv, rb_str_new2 ("blocks"), ULL2NUM (r->blocks));
2746   rb_hash_aset (rv, rb_str_new2 ("bfree"), ULL2NUM (r->bfree));
2747   rb_hash_aset (rv, rb_str_new2 ("bavail"), ULL2NUM (r->bavail));
2748   rb_hash_aset (rv, rb_str_new2 ("files"), ULL2NUM (r->files));
2749   rb_hash_aset (rv, rb_str_new2 ("ffree"), ULL2NUM (r->ffree));
2750   rb_hash_aset (rv, rb_str_new2 ("favail"), ULL2NUM (r->favail));
2751   rb_hash_aset (rv, rb_str_new2 ("fsid"), ULL2NUM (r->fsid));
2752   rb_hash_aset (rv, rb_str_new2 ("flag"), ULL2NUM (r->flag));
2753   rb_hash_aset (rv, rb_str_new2 ("namemax"), ULL2NUM (r->namemax));
2754   free (r);
2755   return rv;
2756 }
2757
2758 static VALUE ruby_guestfs_tune2fs_l (VALUE gv, VALUE devicev)
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", "tune2fs_l");
2764
2765   Check_Type (devicev, T_STRING);
2766   const char *device = StringValueCStr (devicev);
2767   if (!device)
2768     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2769               "device", "tune2fs_l");
2770
2771   char **r;
2772
2773   r = guestfs_tune2fs_l (g, device);
2774   if (r == NULL)
2775     rb_raise (e_Error, "%s", guestfs_last_error (g));
2776
2777   VALUE rv = rb_hash_new ();
2778   int i;
2779   for (i = 0; r[i] != NULL; i+=2) {
2780     rb_hash_aset (rv, rb_str_new2 (r[i]), rb_str_new2 (r[i+1]));
2781     free (r[i]);
2782     free (r[i+1]);
2783   }
2784   free (r);
2785   return rv;
2786 }
2787
2788 static VALUE ruby_guestfs_blockdev_setro (VALUE gv, VALUE devicev)
2789 {
2790   guestfs_h *g;
2791   Data_Get_Struct (gv, guestfs_h, g);
2792   if (!g)
2793     rb_raise (rb_eArgError, "%s: used handle after closing it", "blockdev_setro");
2794
2795   Check_Type (devicev, T_STRING);
2796   const char *device = StringValueCStr (devicev);
2797   if (!device)
2798     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2799               "device", "blockdev_setro");
2800
2801   int r;
2802
2803   r = guestfs_blockdev_setro (g, device);
2804   if (r == -1)
2805     rb_raise (e_Error, "%s", guestfs_last_error (g));
2806
2807   return Qnil;
2808 }
2809
2810 static VALUE ruby_guestfs_blockdev_setrw (VALUE gv, VALUE devicev)
2811 {
2812   guestfs_h *g;
2813   Data_Get_Struct (gv, guestfs_h, g);
2814   if (!g)
2815     rb_raise (rb_eArgError, "%s: used handle after closing it", "blockdev_setrw");
2816
2817   Check_Type (devicev, T_STRING);
2818   const char *device = StringValueCStr (devicev);
2819   if (!device)
2820     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2821               "device", "blockdev_setrw");
2822
2823   int r;
2824
2825   r = guestfs_blockdev_setrw (g, device);
2826   if (r == -1)
2827     rb_raise (e_Error, "%s", guestfs_last_error (g));
2828
2829   return Qnil;
2830 }
2831
2832 static VALUE ruby_guestfs_blockdev_getro (VALUE gv, VALUE devicev)
2833 {
2834   guestfs_h *g;
2835   Data_Get_Struct (gv, guestfs_h, g);
2836   if (!g)
2837     rb_raise (rb_eArgError, "%s: used handle after closing it", "blockdev_getro");
2838
2839   Check_Type (devicev, T_STRING);
2840   const char *device = StringValueCStr (devicev);
2841   if (!device)
2842     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2843               "device", "blockdev_getro");
2844
2845   int r;
2846
2847   r = guestfs_blockdev_getro (g, device);
2848   if (r == -1)
2849     rb_raise (e_Error, "%s", guestfs_last_error (g));
2850
2851   return INT2NUM (r);
2852 }
2853
2854 static VALUE ruby_guestfs_blockdev_getss (VALUE gv, VALUE devicev)
2855 {
2856   guestfs_h *g;
2857   Data_Get_Struct (gv, guestfs_h, g);
2858   if (!g)
2859     rb_raise (rb_eArgError, "%s: used handle after closing it", "blockdev_getss");
2860
2861   Check_Type (devicev, T_STRING);
2862   const char *device = StringValueCStr (devicev);
2863   if (!device)
2864     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2865               "device", "blockdev_getss");
2866
2867   int r;
2868
2869   r = guestfs_blockdev_getss (g, device);
2870   if (r == -1)
2871     rb_raise (e_Error, "%s", guestfs_last_error (g));
2872
2873   return INT2NUM (r);
2874 }
2875
2876 static VALUE ruby_guestfs_blockdev_getbsz (VALUE gv, VALUE devicev)
2877 {
2878   guestfs_h *g;
2879   Data_Get_Struct (gv, guestfs_h, g);
2880   if (!g)
2881     rb_raise (rb_eArgError, "%s: used handle after closing it", "blockdev_getbsz");
2882
2883   Check_Type (devicev, T_STRING);
2884   const char *device = StringValueCStr (devicev);
2885   if (!device)
2886     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2887               "device", "blockdev_getbsz");
2888
2889   int r;
2890
2891   r = guestfs_blockdev_getbsz (g, device);
2892   if (r == -1)
2893     rb_raise (e_Error, "%s", guestfs_last_error (g));
2894
2895   return INT2NUM (r);
2896 }
2897
2898 static VALUE ruby_guestfs_blockdev_setbsz (VALUE gv, VALUE devicev, VALUE blocksizev)
2899 {
2900   guestfs_h *g;
2901   Data_Get_Struct (gv, guestfs_h, g);
2902   if (!g)
2903     rb_raise (rb_eArgError, "%s: used handle after closing it", "blockdev_setbsz");
2904
2905   Check_Type (devicev, T_STRING);
2906   const char *device = StringValueCStr (devicev);
2907   if (!device)
2908     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2909               "device", "blockdev_setbsz");
2910   int blocksize = NUM2INT (blocksizev);
2911
2912   int r;
2913
2914   r = guestfs_blockdev_setbsz (g, device, blocksize);
2915   if (r == -1)
2916     rb_raise (e_Error, "%s", guestfs_last_error (g));
2917
2918   return Qnil;
2919 }
2920
2921 static VALUE ruby_guestfs_blockdev_getsz (VALUE gv, VALUE devicev)
2922 {
2923   guestfs_h *g;
2924   Data_Get_Struct (gv, guestfs_h, g);
2925   if (!g)
2926     rb_raise (rb_eArgError, "%s: used handle after closing it", "blockdev_getsz");
2927
2928   Check_Type (devicev, T_STRING);
2929   const char *device = StringValueCStr (devicev);
2930   if (!device)
2931     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2932               "device", "blockdev_getsz");
2933
2934   int64_t r;
2935
2936   r = guestfs_blockdev_getsz (g, device);
2937   if (r == -1)
2938     rb_raise (e_Error, "%s", guestfs_last_error (g));
2939
2940   return ULL2NUM (r);
2941 }
2942
2943 static VALUE ruby_guestfs_blockdev_getsize64 (VALUE gv, VALUE devicev)
2944 {
2945   guestfs_h *g;
2946   Data_Get_Struct (gv, guestfs_h, g);
2947   if (!g)
2948     rb_raise (rb_eArgError, "%s: used handle after closing it", "blockdev_getsize64");
2949
2950   Check_Type (devicev, T_STRING);
2951   const char *device = StringValueCStr (devicev);
2952   if (!device)
2953     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2954               "device", "blockdev_getsize64");
2955
2956   int64_t r;
2957
2958   r = guestfs_blockdev_getsize64 (g, device);
2959   if (r == -1)
2960     rb_raise (e_Error, "%s", guestfs_last_error (g));
2961
2962   return ULL2NUM (r);
2963 }
2964
2965 static VALUE ruby_guestfs_blockdev_flushbufs (VALUE gv, VALUE devicev)
2966 {
2967   guestfs_h *g;
2968   Data_Get_Struct (gv, guestfs_h, g);
2969   if (!g)
2970     rb_raise (rb_eArgError, "%s: used handle after closing it", "blockdev_flushbufs");
2971
2972   Check_Type (devicev, T_STRING);
2973   const char *device = StringValueCStr (devicev);
2974   if (!device)
2975     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2976               "device", "blockdev_flushbufs");
2977
2978   int r;
2979
2980   r = guestfs_blockdev_flushbufs (g, device);
2981   if (r == -1)
2982     rb_raise (e_Error, "%s", guestfs_last_error (g));
2983
2984   return Qnil;
2985 }
2986
2987 static VALUE ruby_guestfs_blockdev_rereadpt (VALUE gv, VALUE devicev)
2988 {
2989   guestfs_h *g;
2990   Data_Get_Struct (gv, guestfs_h, g);
2991   if (!g)
2992     rb_raise (rb_eArgError, "%s: used handle after closing it", "blockdev_rereadpt");
2993
2994   Check_Type (devicev, T_STRING);
2995   const char *device = StringValueCStr (devicev);
2996   if (!device)
2997     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2998               "device", "blockdev_rereadpt");
2999
3000   int r;
3001
3002   r = guestfs_blockdev_rereadpt (g, device);
3003   if (r == -1)
3004     rb_raise (e_Error, "%s", guestfs_last_error (g));
3005
3006   return Qnil;
3007 }
3008
3009 static VALUE ruby_guestfs_upload (VALUE gv, VALUE filenamev, VALUE remotefilenamev)
3010 {
3011   guestfs_h *g;
3012   Data_Get_Struct (gv, guestfs_h, g);
3013   if (!g)
3014     rb_raise (rb_eArgError, "%s: used handle after closing it", "upload");
3015
3016   Check_Type (filenamev, T_STRING);
3017   const char *filename = StringValueCStr (filenamev);
3018   if (!filename)
3019     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3020               "filename", "upload");
3021   Check_Type (remotefilenamev, T_STRING);
3022   const char *remotefilename = StringValueCStr (remotefilenamev);
3023   if (!remotefilename)
3024     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3025               "remotefilename", "upload");
3026
3027   int r;
3028
3029   r = guestfs_upload (g, filename, remotefilename);
3030   if (r == -1)
3031     rb_raise (e_Error, "%s", guestfs_last_error (g));
3032
3033   return Qnil;
3034 }
3035
3036 static VALUE ruby_guestfs_download (VALUE gv, VALUE remotefilenamev, VALUE filenamev)
3037 {
3038   guestfs_h *g;
3039   Data_Get_Struct (gv, guestfs_h, g);
3040   if (!g)
3041     rb_raise (rb_eArgError, "%s: used handle after closing it", "download");
3042
3043   Check_Type (remotefilenamev, T_STRING);
3044   const char *remotefilename = StringValueCStr (remotefilenamev);
3045   if (!remotefilename)
3046     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3047               "remotefilename", "download");
3048   Check_Type (filenamev, T_STRING);
3049   const char *filename = StringValueCStr (filenamev);
3050   if (!filename)
3051     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3052               "filename", "download");
3053
3054   int r;
3055
3056   r = guestfs_download (g, remotefilename, filename);
3057   if (r == -1)
3058     rb_raise (e_Error, "%s", guestfs_last_error (g));
3059
3060   return Qnil;
3061 }
3062
3063 static VALUE ruby_guestfs_checksum (VALUE gv, VALUE csumtypev, VALUE pathv)
3064 {
3065   guestfs_h *g;
3066   Data_Get_Struct (gv, guestfs_h, g);
3067   if (!g)
3068     rb_raise (rb_eArgError, "%s: used handle after closing it", "checksum");
3069
3070   Check_Type (csumtypev, T_STRING);
3071   const char *csumtype = StringValueCStr (csumtypev);
3072   if (!csumtype)
3073     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3074               "csumtype", "checksum");
3075   Check_Type (pathv, T_STRING);
3076   const char *path = StringValueCStr (pathv);
3077   if (!path)
3078     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3079               "path", "checksum");
3080
3081   char *r;
3082
3083   r = guestfs_checksum (g, csumtype, path);
3084   if (r == NULL)
3085     rb_raise (e_Error, "%s", guestfs_last_error (g));
3086
3087   VALUE rv = rb_str_new2 (r);
3088   free (r);
3089   return rv;
3090 }
3091
3092 static VALUE ruby_guestfs_tar_in (VALUE gv, VALUE tarfilev, VALUE directoryv)
3093 {
3094   guestfs_h *g;
3095   Data_Get_Struct (gv, guestfs_h, g);
3096   if (!g)
3097     rb_raise (rb_eArgError, "%s: used handle after closing it", "tar_in");
3098
3099   Check_Type (tarfilev, T_STRING);
3100   const char *tarfile = StringValueCStr (tarfilev);
3101   if (!tarfile)
3102     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3103               "tarfile", "tar_in");
3104   Check_Type (directoryv, T_STRING);
3105   const char *directory = StringValueCStr (directoryv);
3106   if (!directory)
3107     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3108               "directory", "tar_in");
3109
3110   int r;
3111
3112   r = guestfs_tar_in (g, tarfile, directory);
3113   if (r == -1)
3114     rb_raise (e_Error, "%s", guestfs_last_error (g));
3115
3116   return Qnil;
3117 }
3118
3119 static VALUE ruby_guestfs_tar_out (VALUE gv, VALUE directoryv, VALUE tarfilev)
3120 {
3121   guestfs_h *g;
3122   Data_Get_Struct (gv, guestfs_h, g);
3123   if (!g)
3124     rb_raise (rb_eArgError, "%s: used handle after closing it", "tar_out");
3125
3126   Check_Type (directoryv, T_STRING);
3127   const char *directory = StringValueCStr (directoryv);
3128   if (!directory)
3129     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3130               "directory", "tar_out");
3131   Check_Type (tarfilev, T_STRING);
3132   const char *tarfile = StringValueCStr (tarfilev);
3133   if (!tarfile)
3134     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3135               "tarfile", "tar_out");
3136
3137   int r;
3138
3139   r = guestfs_tar_out (g, directory, tarfile);
3140   if (r == -1)
3141     rb_raise (e_Error, "%s", guestfs_last_error (g));
3142
3143   return Qnil;
3144 }
3145
3146 static VALUE ruby_guestfs_tgz_in (VALUE gv, VALUE tarballv, VALUE directoryv)
3147 {
3148   guestfs_h *g;
3149   Data_Get_Struct (gv, guestfs_h, g);
3150   if (!g)
3151     rb_raise (rb_eArgError, "%s: used handle after closing it", "tgz_in");
3152
3153   Check_Type (tarballv, T_STRING);
3154   const char *tarball = StringValueCStr (tarballv);
3155   if (!tarball)
3156     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3157               "tarball", "tgz_in");
3158   Check_Type (directoryv, T_STRING);
3159   const char *directory = StringValueCStr (directoryv);
3160   if (!directory)
3161     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3162               "directory", "tgz_in");
3163
3164   int r;
3165
3166   r = guestfs_tgz_in (g, tarball, directory);
3167   if (r == -1)
3168     rb_raise (e_Error, "%s", guestfs_last_error (g));
3169
3170   return Qnil;
3171 }
3172
3173 static VALUE ruby_guestfs_tgz_out (VALUE gv, VALUE directoryv, VALUE tarballv)
3174 {
3175   guestfs_h *g;
3176   Data_Get_Struct (gv, guestfs_h, g);
3177   if (!g)
3178     rb_raise (rb_eArgError, "%s: used handle after closing it", "tgz_out");
3179
3180   Check_Type (directoryv, T_STRING);
3181   const char *directory = StringValueCStr (directoryv);
3182   if (!directory)
3183     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3184               "directory", "tgz_out");
3185   Check_Type (tarballv, T_STRING);
3186   const char *tarball = StringValueCStr (tarballv);
3187   if (!tarball)
3188     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3189               "tarball", "tgz_out");
3190
3191   int r;
3192
3193   r = guestfs_tgz_out (g, directory, tarball);
3194   if (r == -1)
3195     rb_raise (e_Error, "%s", guestfs_last_error (g));
3196
3197   return Qnil;
3198 }
3199
3200 static VALUE ruby_guestfs_mount_ro (VALUE gv, VALUE devicev, VALUE mountpointv)
3201 {
3202   guestfs_h *g;
3203   Data_Get_Struct (gv, guestfs_h, g);
3204   if (!g)
3205     rb_raise (rb_eArgError, "%s: used handle after closing it", "mount_ro");
3206
3207   Check_Type (devicev, T_STRING);
3208   const char *device = StringValueCStr (devicev);
3209   if (!device)
3210     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3211               "device", "mount_ro");
3212   Check_Type (mountpointv, T_STRING);
3213   const char *mountpoint = StringValueCStr (mountpointv);
3214   if (!mountpoint)
3215     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3216               "mountpoint", "mount_ro");
3217
3218   int r;
3219
3220   r = guestfs_mount_ro (g, device, mountpoint);
3221   if (r == -1)
3222     rb_raise (e_Error, "%s", guestfs_last_error (g));
3223
3224   return Qnil;
3225 }
3226
3227 static VALUE ruby_guestfs_mount_options (VALUE gv, VALUE optionsv, VALUE devicev, VALUE mountpointv)
3228 {
3229   guestfs_h *g;
3230   Data_Get_Struct (gv, guestfs_h, g);
3231   if (!g)
3232     rb_raise (rb_eArgError, "%s: used handle after closing it", "mount_options");
3233
3234   Check_Type (optionsv, T_STRING);
3235   const char *options = StringValueCStr (optionsv);
3236   if (!options)
3237     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3238               "options", "mount_options");
3239   Check_Type (devicev, T_STRING);
3240   const char *device = StringValueCStr (devicev);
3241   if (!device)
3242     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3243               "device", "mount_options");
3244   Check_Type (mountpointv, T_STRING);
3245   const char *mountpoint = StringValueCStr (mountpointv);
3246   if (!mountpoint)
3247     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3248               "mountpoint", "mount_options");
3249
3250   int r;
3251
3252   r = guestfs_mount_options (g, options, device, mountpoint);
3253   if (r == -1)
3254     rb_raise (e_Error, "%s", guestfs_last_error (g));
3255
3256   return Qnil;
3257 }
3258
3259 static VALUE ruby_guestfs_mount_vfs (VALUE gv, VALUE optionsv, VALUE vfstypev, VALUE devicev, VALUE mountpointv)
3260 {
3261   guestfs_h *g;
3262   Data_Get_Struct (gv, guestfs_h, g);
3263   if (!g)
3264     rb_raise (rb_eArgError, "%s: used handle after closing it", "mount_vfs");
3265
3266   Check_Type (optionsv, T_STRING);
3267   const char *options = StringValueCStr (optionsv);
3268   if (!options)
3269     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3270               "options", "mount_vfs");
3271   Check_Type (vfstypev, T_STRING);
3272   const char *vfstype = StringValueCStr (vfstypev);
3273   if (!vfstype)
3274     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3275               "vfstype", "mount_vfs");
3276   Check_Type (devicev, T_STRING);
3277   const char *device = StringValueCStr (devicev);
3278   if (!device)
3279     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3280               "device", "mount_vfs");
3281   Check_Type (mountpointv, T_STRING);
3282   const char *mountpoint = StringValueCStr (mountpointv);
3283   if (!mountpoint)
3284     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3285               "mountpoint", "mount_vfs");
3286
3287   int r;
3288
3289   r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint);
3290   if (r == -1)
3291     rb_raise (e_Error, "%s", guestfs_last_error (g));
3292
3293   return Qnil;
3294 }
3295
3296 static VALUE ruby_guestfs_debug (VALUE gv, VALUE subcmdv, VALUE extraargsv)
3297 {
3298   guestfs_h *g;
3299   Data_Get_Struct (gv, guestfs_h, g);
3300   if (!g)
3301     rb_raise (rb_eArgError, "%s: used handle after closing it", "debug");
3302
3303   Check_Type (subcmdv, T_STRING);
3304   const char *subcmd = StringValueCStr (subcmdv);
3305   if (!subcmd)
3306     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3307               "subcmd", "debug");
3308   char **extraargs;
3309   Check_Type (extraargsv, T_ARRAY);
3310   {
3311     int i, len;
3312     len = RARRAY_LEN (extraargsv);
3313     extraargs = guestfs_safe_malloc (g, sizeof (char *) * (len+1));
3314     for (i = 0; i < len; ++i) {
3315       VALUE v = rb_ary_entry (extraargsv, i);
3316       extraargs[i] = StringValueCStr (v);
3317     }
3318     extraargs[len] = NULL;
3319   }
3320
3321   char *r;
3322
3323   r = guestfs_debug (g, subcmd, extraargs);
3324   free (extraargs);
3325   if (r == NULL)
3326     rb_raise (e_Error, "%s", guestfs_last_error (g));
3327
3328   VALUE rv = rb_str_new2 (r);
3329   free (r);
3330   return rv;
3331 }
3332
3333 static VALUE ruby_guestfs_lvremove (VALUE gv, VALUE devicev)
3334 {
3335   guestfs_h *g;
3336   Data_Get_Struct (gv, guestfs_h, g);
3337   if (!g)
3338     rb_raise (rb_eArgError, "%s: used handle after closing it", "lvremove");
3339
3340   Check_Type (devicev, T_STRING);
3341   const char *device = StringValueCStr (devicev);
3342   if (!device)
3343     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3344               "device", "lvremove");
3345
3346   int r;
3347
3348   r = guestfs_lvremove (g, device);
3349   if (r == -1)
3350     rb_raise (e_Error, "%s", guestfs_last_error (g));
3351
3352   return Qnil;
3353 }
3354
3355 static VALUE ruby_guestfs_vgremove (VALUE gv, VALUE vgnamev)
3356 {
3357   guestfs_h *g;
3358   Data_Get_Struct (gv, guestfs_h, g);
3359   if (!g)
3360     rb_raise (rb_eArgError, "%s: used handle after closing it", "vgremove");
3361
3362   Check_Type (vgnamev, T_STRING);
3363   const char *vgname = StringValueCStr (vgnamev);
3364   if (!vgname)
3365     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3366               "vgname", "vgremove");
3367
3368   int r;
3369
3370   r = guestfs_vgremove (g, vgname);
3371   if (r == -1)
3372     rb_raise (e_Error, "%s", guestfs_last_error (g));
3373
3374   return Qnil;
3375 }
3376
3377 static VALUE ruby_guestfs_pvremove (VALUE gv, VALUE devicev)
3378 {
3379   guestfs_h *g;
3380   Data_Get_Struct (gv, guestfs_h, g);
3381   if (!g)
3382     rb_raise (rb_eArgError, "%s: used handle after closing it", "pvremove");
3383
3384   Check_Type (devicev, T_STRING);
3385   const char *device = StringValueCStr (devicev);
3386   if (!device)
3387     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3388               "device", "pvremove");
3389
3390   int r;
3391
3392   r = guestfs_pvremove (g, device);
3393   if (r == -1)
3394     rb_raise (e_Error, "%s", guestfs_last_error (g));
3395
3396   return Qnil;
3397 }
3398
3399 static VALUE ruby_guestfs_set_e2label (VALUE gv, VALUE devicev, VALUE labelv)
3400 {
3401   guestfs_h *g;
3402   Data_Get_Struct (gv, guestfs_h, g);
3403   if (!g)
3404     rb_raise (rb_eArgError, "%s: used handle after closing it", "set_e2label");
3405
3406   Check_Type (devicev, T_STRING);
3407   const char *device = StringValueCStr (devicev);
3408   if (!device)
3409     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3410               "device", "set_e2label");
3411   Check_Type (labelv, T_STRING);
3412   const char *label = StringValueCStr (labelv);
3413   if (!label)
3414     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3415               "label", "set_e2label");
3416
3417   int r;
3418
3419   r = guestfs_set_e2label (g, device, label);
3420   if (r == -1)
3421     rb_raise (e_Error, "%s", guestfs_last_error (g));
3422
3423   return Qnil;
3424 }
3425
3426 static VALUE ruby_guestfs_get_e2label (VALUE gv, VALUE devicev)
3427 {
3428   guestfs_h *g;
3429   Data_Get_Struct (gv, guestfs_h, g);
3430   if (!g)
3431     rb_raise (rb_eArgError, "%s: used handle after closing it", "get_e2label");
3432
3433   Check_Type (devicev, T_STRING);
3434   const char *device = StringValueCStr (devicev);
3435   if (!device)
3436     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3437               "device", "get_e2label");
3438
3439   char *r;
3440
3441   r = guestfs_get_e2label (g, device);
3442   if (r == NULL)
3443     rb_raise (e_Error, "%s", guestfs_last_error (g));
3444
3445   VALUE rv = rb_str_new2 (r);
3446   free (r);
3447   return rv;
3448 }
3449
3450 static VALUE ruby_guestfs_set_e2uuid (VALUE gv, VALUE devicev, VALUE uuidv)
3451 {
3452   guestfs_h *g;
3453   Data_Get_Struct (gv, guestfs_h, g);
3454   if (!g)
3455     rb_raise (rb_eArgError, "%s: used handle after closing it", "set_e2uuid");
3456
3457   Check_Type (devicev, T_STRING);
3458   const char *device = StringValueCStr (devicev);
3459   if (!device)
3460     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3461               "device", "set_e2uuid");
3462   Check_Type (uuidv, T_STRING);
3463   const char *uuid = StringValueCStr (uuidv);
3464   if (!uuid)
3465     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3466               "uuid", "set_e2uuid");
3467
3468   int r;
3469
3470   r = guestfs_set_e2uuid (g, device, uuid);
3471   if (r == -1)
3472     rb_raise (e_Error, "%s", guestfs_last_error (g));
3473
3474   return Qnil;
3475 }
3476
3477 static VALUE ruby_guestfs_get_e2uuid (VALUE gv, VALUE devicev)
3478 {
3479   guestfs_h *g;
3480   Data_Get_Struct (gv, guestfs_h, g);
3481   if (!g)
3482     rb_raise (rb_eArgError, "%s: used handle after closing it", "get_e2uuid");
3483
3484   Check_Type (devicev, T_STRING);
3485   const char *device = StringValueCStr (devicev);
3486   if (!device)
3487     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3488               "device", "get_e2uuid");
3489
3490   char *r;
3491
3492   r = guestfs_get_e2uuid (g, device);
3493   if (r == NULL)
3494     rb_raise (e_Error, "%s", guestfs_last_error (g));
3495
3496   VALUE rv = rb_str_new2 (r);
3497   free (r);
3498   return rv;
3499 }
3500
3501 static VALUE ruby_guestfs_fsck (VALUE gv, VALUE fstypev, VALUE devicev)
3502 {
3503   guestfs_h *g;
3504   Data_Get_Struct (gv, guestfs_h, g);
3505   if (!g)
3506     rb_raise (rb_eArgError, "%s: used handle after closing it", "fsck");
3507
3508   Check_Type (fstypev, T_STRING);
3509   const char *fstype = StringValueCStr (fstypev);
3510   if (!fstype)
3511     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3512               "fstype", "fsck");
3513   Check_Type (devicev, T_STRING);
3514   const char *device = StringValueCStr (devicev);
3515   if (!device)
3516     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3517               "device", "fsck");
3518
3519   int r;
3520
3521   r = guestfs_fsck (g, fstype, device);
3522   if (r == -1)
3523     rb_raise (e_Error, "%s", guestfs_last_error (g));
3524
3525   return INT2NUM (r);
3526 }
3527
3528 static VALUE ruby_guestfs_zero (VALUE gv, VALUE devicev)
3529 {
3530   guestfs_h *g;
3531   Data_Get_Struct (gv, guestfs_h, g);
3532   if (!g)
3533     rb_raise (rb_eArgError, "%s: used handle after closing it", "zero");
3534
3535   Check_Type (devicev, T_STRING);
3536   const char *device = StringValueCStr (devicev);
3537   if (!device)
3538     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3539               "device", "zero");
3540
3541   int r;
3542
3543   r = guestfs_zero (g, device);
3544   if (r == -1)
3545     rb_raise (e_Error, "%s", guestfs_last_error (g));
3546
3547   return Qnil;
3548 }
3549
3550 static VALUE ruby_guestfs_grub_install (VALUE gv, VALUE rootv, VALUE devicev)
3551 {
3552   guestfs_h *g;
3553   Data_Get_Struct (gv, guestfs_h, g);
3554   if (!g)
3555     rb_raise (rb_eArgError, "%s: used handle after closing it", "grub_install");
3556
3557   Check_Type (rootv, T_STRING);
3558   const char *root = StringValueCStr (rootv);
3559   if (!root)
3560     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3561               "root", "grub_install");
3562   Check_Type (devicev, T_STRING);
3563   const char *device = StringValueCStr (devicev);
3564   if (!device)
3565     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3566               "device", "grub_install");
3567
3568   int r;
3569
3570   r = guestfs_grub_install (g, root, device);
3571   if (r == -1)
3572     rb_raise (e_Error, "%s", guestfs_last_error (g));
3573
3574   return Qnil;
3575 }
3576
3577 static VALUE ruby_guestfs_cp (VALUE gv, VALUE srcv, VALUE destv)
3578 {
3579   guestfs_h *g;
3580   Data_Get_Struct (gv, guestfs_h, g);
3581   if (!g)
3582     rb_raise (rb_eArgError, "%s: used handle after closing it", "cp");
3583
3584   Check_Type (srcv, T_STRING);
3585   const char *src = StringValueCStr (srcv);
3586   if (!src)
3587     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3588               "src", "cp");
3589   Check_Type (destv, T_STRING);
3590   const char *dest = StringValueCStr (destv);
3591   if (!dest)
3592     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3593               "dest", "cp");
3594
3595   int r;
3596
3597   r = guestfs_cp (g, src, dest);
3598   if (r == -1)
3599     rb_raise (e_Error, "%s", guestfs_last_error (g));
3600
3601   return Qnil;
3602 }
3603
3604 static VALUE ruby_guestfs_cp_a (VALUE gv, VALUE srcv, VALUE destv)
3605 {
3606   guestfs_h *g;
3607   Data_Get_Struct (gv, guestfs_h, g);
3608   if (!g)
3609     rb_raise (rb_eArgError, "%s: used handle after closing it", "cp_a");
3610
3611   Check_Type (srcv, T_STRING);
3612   const char *src = StringValueCStr (srcv);
3613   if (!src)
3614     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3615               "src", "cp_a");
3616   Check_Type (destv, T_STRING);
3617   const char *dest = StringValueCStr (destv);
3618   if (!dest)
3619     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3620               "dest", "cp_a");
3621
3622   int r;
3623
3624   r = guestfs_cp_a (g, src, dest);
3625   if (r == -1)
3626     rb_raise (e_Error, "%s", guestfs_last_error (g));
3627
3628   return Qnil;
3629 }
3630
3631 static VALUE ruby_guestfs_mv (VALUE gv, VALUE srcv, VALUE destv)
3632 {
3633   guestfs_h *g;
3634   Data_Get_Struct (gv, guestfs_h, g);
3635   if (!g)
3636     rb_raise (rb_eArgError, "%s: used handle after closing it", "mv");
3637
3638   Check_Type (srcv, T_STRING);
3639   const char *src = StringValueCStr (srcv);
3640   if (!src)
3641     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3642               "src", "mv");
3643   Check_Type (destv, T_STRING);
3644   const char *dest = StringValueCStr (destv);
3645   if (!dest)
3646     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3647               "dest", "mv");
3648
3649   int r;
3650
3651   r = guestfs_mv (g, src, dest);
3652   if (r == -1)
3653     rb_raise (e_Error, "%s", guestfs_last_error (g));
3654
3655   return Qnil;
3656 }
3657
3658 static VALUE ruby_guestfs_drop_caches (VALUE gv, VALUE whattodropv)
3659 {
3660   guestfs_h *g;
3661   Data_Get_Struct (gv, guestfs_h, g);
3662   if (!g)
3663     rb_raise (rb_eArgError, "%s: used handle after closing it", "drop_caches");
3664
3665   int whattodrop = NUM2INT (whattodropv);
3666
3667   int r;
3668
3669   r = guestfs_drop_caches (g, whattodrop);
3670   if (r == -1)
3671     rb_raise (e_Error, "%s", guestfs_last_error (g));
3672
3673   return Qnil;
3674 }
3675
3676 static VALUE ruby_guestfs_dmesg (VALUE gv)
3677 {
3678   guestfs_h *g;
3679   Data_Get_Struct (gv, guestfs_h, g);
3680   if (!g)
3681     rb_raise (rb_eArgError, "%s: used handle after closing it", "dmesg");
3682
3683
3684   char *r;
3685
3686   r = guestfs_dmesg (g);
3687   if (r == NULL)
3688     rb_raise (e_Error, "%s", guestfs_last_error (g));
3689
3690   VALUE rv = rb_str_new2 (r);
3691   free (r);
3692   return rv;
3693 }
3694
3695 static VALUE ruby_guestfs_ping_daemon (VALUE gv)
3696 {
3697   guestfs_h *g;
3698   Data_Get_Struct (gv, guestfs_h, g);
3699   if (!g)
3700     rb_raise (rb_eArgError, "%s: used handle after closing it", "ping_daemon");
3701
3702
3703   int r;
3704
3705   r = guestfs_ping_daemon (g);
3706   if (r == -1)
3707     rb_raise (e_Error, "%s", guestfs_last_error (g));
3708
3709   return Qnil;
3710 }
3711
3712 static VALUE ruby_guestfs_equal (VALUE gv, VALUE file1v, VALUE file2v)
3713 {
3714   guestfs_h *g;
3715   Data_Get_Struct (gv, guestfs_h, g);
3716   if (!g)
3717     rb_raise (rb_eArgError, "%s: used handle after closing it", "equal");
3718
3719   Check_Type (file1v, T_STRING);
3720   const char *file1 = StringValueCStr (file1v);
3721   if (!file1)
3722     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3723               "file1", "equal");
3724   Check_Type (file2v, T_STRING);
3725   const char *file2 = StringValueCStr (file2v);
3726   if (!file2)
3727     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3728               "file2", "equal");
3729
3730   int r;
3731
3732   r = guestfs_equal (g, file1, file2);
3733   if (r == -1)
3734     rb_raise (e_Error, "%s", guestfs_last_error (g));
3735
3736   return INT2NUM (r);
3737 }
3738
3739 static VALUE ruby_guestfs_strings (VALUE gv, VALUE pathv)
3740 {
3741   guestfs_h *g;
3742   Data_Get_Struct (gv, guestfs_h, g);
3743   if (!g)
3744     rb_raise (rb_eArgError, "%s: used handle after closing it", "strings");
3745
3746   Check_Type (pathv, T_STRING);
3747   const char *path = StringValueCStr (pathv);
3748   if (!path)
3749     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3750               "path", "strings");
3751
3752   char **r;
3753
3754   r = guestfs_strings (g, path);
3755   if (r == NULL)
3756     rb_raise (e_Error, "%s", guestfs_last_error (g));
3757
3758   int i, len = 0;
3759   for (i = 0; r[i] != NULL; ++i) len++;
3760   VALUE rv = rb_ary_new2 (len);
3761   for (i = 0; r[i] != NULL; ++i) {
3762     rb_ary_push (rv, rb_str_new2 (r[i]));
3763     free (r[i]);
3764   }
3765   free (r);
3766   return rv;
3767 }
3768
3769 static VALUE ruby_guestfs_strings_e (VALUE gv, VALUE encodingv, VALUE pathv)
3770 {
3771   guestfs_h *g;
3772   Data_Get_Struct (gv, guestfs_h, g);
3773   if (!g)
3774     rb_raise (rb_eArgError, "%s: used handle after closing it", "strings_e");
3775
3776   Check_Type (encodingv, T_STRING);
3777   const char *encoding = StringValueCStr (encodingv);
3778   if (!encoding)
3779     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3780               "encoding", "strings_e");
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_e");
3786
3787   char **r;
3788
3789   r = guestfs_strings_e (g, encoding, 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_hexdump (VALUE gv, 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", "hexdump");
3810
3811   Check_Type (pathv, T_STRING);
3812   const char *path = StringValueCStr (pathv);
3813   if (!path)
3814     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3815               "path", "hexdump");
3816
3817   char *r;
3818
3819   r = guestfs_hexdump (g, path);
3820   if (r == NULL)
3821     rb_raise (e_Error, "%s", guestfs_last_error (g));
3822
3823   VALUE rv = rb_str_new2 (r);
3824   free (r);
3825   return rv;
3826 }
3827
3828 static VALUE ruby_guestfs_zerofree (VALUE gv, VALUE devicev)
3829 {
3830   guestfs_h *g;
3831   Data_Get_Struct (gv, guestfs_h, g);
3832   if (!g)
3833     rb_raise (rb_eArgError, "%s: used handle after closing it", "zerofree");
3834
3835   Check_Type (devicev, T_STRING);
3836   const char *device = StringValueCStr (devicev);
3837   if (!device)
3838     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3839               "device", "zerofree");
3840
3841   int r;
3842
3843   r = guestfs_zerofree (g, device);
3844   if (r == -1)
3845     rb_raise (e_Error, "%s", guestfs_last_error (g));
3846
3847   return Qnil;
3848 }
3849
3850 static VALUE ruby_guestfs_pvresize (VALUE gv, VALUE devicev)
3851 {
3852   guestfs_h *g;
3853   Data_Get_Struct (gv, guestfs_h, g);
3854   if (!g)
3855     rb_raise (rb_eArgError, "%s: used handle after closing it", "pvresize");
3856
3857   Check_Type (devicev, T_STRING);
3858   const char *device = StringValueCStr (devicev);
3859   if