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