Generated code for 'add_drive_ro' call.
[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 = !NIL_P (optstrv) ? StringValueCStr (optstrv) : NULL;
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 = RTEST (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_add_drive_ro (VALUE gv, VALUE filenamev)
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", "add_drive_ro");
950
951   const char *filename = StringValueCStr (filenamev);
952   if (!filename)
953     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
954               "filename", "add_drive_ro");
955
956   int r;
957
958   r = guestfs_add_drive_ro (g, filename);
959   if (r == -1)
960     rb_raise (e_Error, "%s", guestfs_last_error (g));
961
962   return Qnil;
963 }
964
965 static VALUE ruby_guestfs_config (VALUE gv, VALUE qemuparamv, VALUE qemuvaluev)
966 {
967   guestfs_h *g;
968   Data_Get_Struct (gv, guestfs_h, g);
969   if (!g)
970     rb_raise (rb_eArgError, "%s: used handle after closing it", "config");
971
972   const char *qemuparam = StringValueCStr (qemuparamv);
973   if (!qemuparam)
974     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
975               "qemuparam", "config");
976   const char *qemuvalue = !NIL_P (qemuvaluev) ? StringValueCStr (qemuvaluev) : NULL;
977
978   int r;
979
980   r = guestfs_config (g, qemuparam, qemuvalue);
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_set_qemu (VALUE gv, VALUE qemuv)
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", "set_qemu");
993
994   const char *qemu = StringValueCStr (qemuv);
995   if (!qemu)
996     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
997               "qemu", "set_qemu");
998
999   int r;
1000
1001   r = guestfs_set_qemu (g, qemu);
1002   if (r == -1)
1003     rb_raise (e_Error, "%s", guestfs_last_error (g));
1004
1005   return Qnil;
1006 }
1007
1008 static VALUE ruby_guestfs_get_qemu (VALUE gv)
1009 {
1010   guestfs_h *g;
1011   Data_Get_Struct (gv, guestfs_h, g);
1012   if (!g)
1013     rb_raise (rb_eArgError, "%s: used handle after closing it", "get_qemu");
1014
1015
1016   const char *r;
1017
1018   r = guestfs_get_qemu (g);
1019   if (r == NULL)
1020     rb_raise (e_Error, "%s", guestfs_last_error (g));
1021
1022   return rb_str_new2 (r);
1023 }
1024
1025 static VALUE ruby_guestfs_set_path (VALUE gv, VALUE pathv)
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", "set_path");
1031
1032   const char *path = StringValueCStr (pathv);
1033   if (!path)
1034     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1035               "path", "set_path");
1036
1037   int r;
1038
1039   r = guestfs_set_path (g, path);
1040   if (r == -1)
1041     rb_raise (e_Error, "%s", guestfs_last_error (g));
1042
1043   return Qnil;
1044 }
1045
1046 static VALUE ruby_guestfs_get_path (VALUE gv)
1047 {
1048   guestfs_h *g;
1049   Data_Get_Struct (gv, guestfs_h, g);
1050   if (!g)
1051     rb_raise (rb_eArgError, "%s: used handle after closing it", "get_path");
1052
1053
1054   const char *r;
1055
1056   r = guestfs_get_path (g);
1057   if (r == NULL)
1058     rb_raise (e_Error, "%s", guestfs_last_error (g));
1059
1060   return rb_str_new2 (r);
1061 }
1062
1063 static VALUE ruby_guestfs_set_append (VALUE gv, VALUE appendv)
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", "set_append");
1069
1070   const char *append = StringValueCStr (appendv);
1071   if (!append)
1072     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1073               "append", "set_append");
1074
1075   int r;
1076
1077   r = guestfs_set_append (g, append);
1078   if (r == -1)
1079     rb_raise (e_Error, "%s", guestfs_last_error (g));
1080
1081   return Qnil;
1082 }
1083
1084 static VALUE ruby_guestfs_get_append (VALUE gv)
1085 {
1086   guestfs_h *g;
1087   Data_Get_Struct (gv, guestfs_h, g);
1088   if (!g)
1089     rb_raise (rb_eArgError, "%s: used handle after closing it", "get_append");
1090
1091
1092   const char *r;
1093
1094   r = guestfs_get_append (g);
1095   if (r == NULL)
1096     rb_raise (e_Error, "%s", guestfs_last_error (g));
1097
1098   return rb_str_new2 (r);
1099 }
1100
1101 static VALUE ruby_guestfs_set_autosync (VALUE gv, VALUE autosyncv)
1102 {
1103   guestfs_h *g;
1104   Data_Get_Struct (gv, guestfs_h, g);
1105   if (!g)
1106     rb_raise (rb_eArgError, "%s: used handle after closing it", "set_autosync");
1107
1108   int autosync = RTEST (autosyncv);
1109
1110   int r;
1111
1112   r = guestfs_set_autosync (g, autosync);
1113   if (r == -1)
1114     rb_raise (e_Error, "%s", guestfs_last_error (g));
1115
1116   return Qnil;
1117 }
1118
1119 static VALUE ruby_guestfs_get_autosync (VALUE gv)
1120 {
1121   guestfs_h *g;
1122   Data_Get_Struct (gv, guestfs_h, g);
1123   if (!g)
1124     rb_raise (rb_eArgError, "%s: used handle after closing it", "get_autosync");
1125
1126
1127   int r;
1128
1129   r = guestfs_get_autosync (g);
1130   if (r == -1)
1131     rb_raise (e_Error, "%s", guestfs_last_error (g));
1132
1133   return INT2NUM (r);
1134 }
1135
1136 static VALUE ruby_guestfs_set_verbose (VALUE gv, VALUE verbosev)
1137 {
1138   guestfs_h *g;
1139   Data_Get_Struct (gv, guestfs_h, g);
1140   if (!g)
1141     rb_raise (rb_eArgError, "%s: used handle after closing it", "set_verbose");
1142
1143   int verbose = RTEST (verbosev);
1144
1145   int r;
1146
1147   r = guestfs_set_verbose (g, verbose);
1148   if (r == -1)
1149     rb_raise (e_Error, "%s", guestfs_last_error (g));
1150
1151   return Qnil;
1152 }
1153
1154 static VALUE ruby_guestfs_get_verbose (VALUE gv)
1155 {
1156   guestfs_h *g;
1157   Data_Get_Struct (gv, guestfs_h, g);
1158   if (!g)
1159     rb_raise (rb_eArgError, "%s: used handle after closing it", "get_verbose");
1160
1161
1162   int r;
1163
1164   r = guestfs_get_verbose (g);
1165   if (r == -1)
1166     rb_raise (e_Error, "%s", guestfs_last_error (g));
1167
1168   return INT2NUM (r);
1169 }
1170
1171 static VALUE ruby_guestfs_is_ready (VALUE gv)
1172 {
1173   guestfs_h *g;
1174   Data_Get_Struct (gv, guestfs_h, g);
1175   if (!g)
1176     rb_raise (rb_eArgError, "%s: used handle after closing it", "is_ready");
1177
1178
1179   int r;
1180
1181   r = guestfs_is_ready (g);
1182   if (r == -1)
1183     rb_raise (e_Error, "%s", guestfs_last_error (g));
1184
1185   return INT2NUM (r);
1186 }
1187
1188 static VALUE ruby_guestfs_is_config (VALUE gv)
1189 {
1190   guestfs_h *g;
1191   Data_Get_Struct (gv, guestfs_h, g);
1192   if (!g)
1193     rb_raise (rb_eArgError, "%s: used handle after closing it", "is_config");
1194
1195
1196   int r;
1197
1198   r = guestfs_is_config (g);
1199   if (r == -1)
1200     rb_raise (e_Error, "%s", guestfs_last_error (g));
1201
1202   return INT2NUM (r);
1203 }
1204
1205 static VALUE ruby_guestfs_is_launching (VALUE gv)
1206 {
1207   guestfs_h *g;
1208   Data_Get_Struct (gv, guestfs_h, g);
1209   if (!g)
1210     rb_raise (rb_eArgError, "%s: used handle after closing it", "is_launching");
1211
1212
1213   int r;
1214
1215   r = guestfs_is_launching (g);
1216   if (r == -1)
1217     rb_raise (e_Error, "%s", guestfs_last_error (g));
1218
1219   return INT2NUM (r);
1220 }
1221
1222 static VALUE ruby_guestfs_is_busy (VALUE gv)
1223 {
1224   guestfs_h *g;
1225   Data_Get_Struct (gv, guestfs_h, g);
1226   if (!g)
1227     rb_raise (rb_eArgError, "%s: used handle after closing it", "is_busy");
1228
1229
1230   int r;
1231
1232   r = guestfs_is_busy (g);
1233   if (r == -1)
1234     rb_raise (e_Error, "%s", guestfs_last_error (g));
1235
1236   return INT2NUM (r);
1237 }
1238
1239 static VALUE ruby_guestfs_get_state (VALUE gv)
1240 {
1241   guestfs_h *g;
1242   Data_Get_Struct (gv, guestfs_h, g);
1243   if (!g)
1244     rb_raise (rb_eArgError, "%s: used handle after closing it", "get_state");
1245
1246
1247   int r;
1248
1249   r = guestfs_get_state (g);
1250   if (r == -1)
1251     rb_raise (e_Error, "%s", guestfs_last_error (g));
1252
1253   return INT2NUM (r);
1254 }
1255
1256 static VALUE ruby_guestfs_set_busy (VALUE gv)
1257 {
1258   guestfs_h *g;
1259   Data_Get_Struct (gv, guestfs_h, g);
1260   if (!g)
1261     rb_raise (rb_eArgError, "%s: used handle after closing it", "set_busy");
1262
1263
1264   int r;
1265
1266   r = guestfs_set_busy (g);
1267   if (r == -1)
1268     rb_raise (e_Error, "%s", guestfs_last_error (g));
1269
1270   return Qnil;
1271 }
1272
1273 static VALUE ruby_guestfs_set_ready (VALUE gv)
1274 {
1275   guestfs_h *g;
1276   Data_Get_Struct (gv, guestfs_h, g);
1277   if (!g)
1278     rb_raise (rb_eArgError, "%s: used handle after closing it", "set_ready");
1279
1280
1281   int r;
1282
1283   r = guestfs_set_ready (g);
1284   if (r == -1)
1285     rb_raise (e_Error, "%s", guestfs_last_error (g));
1286
1287   return Qnil;
1288 }
1289
1290 static VALUE ruby_guestfs_end_busy (VALUE gv)
1291 {
1292   guestfs_h *g;
1293   Data_Get_Struct (gv, guestfs_h, g);
1294   if (!g)
1295     rb_raise (rb_eArgError, "%s: used handle after closing it", "end_busy");
1296
1297
1298   int r;
1299
1300   r = guestfs_end_busy (g);
1301   if (r == -1)
1302     rb_raise (e_Error, "%s", guestfs_last_error (g));
1303
1304   return Qnil;
1305 }
1306
1307 static VALUE ruby_guestfs_mount (VALUE gv, VALUE devicev, VALUE mountpointv)
1308 {
1309   guestfs_h *g;
1310   Data_Get_Struct (gv, guestfs_h, g);
1311   if (!g)
1312     rb_raise (rb_eArgError, "%s: used handle after closing it", "mount");
1313
1314   const char *device = StringValueCStr (devicev);
1315   if (!device)
1316     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1317               "device", "mount");
1318   const char *mountpoint = StringValueCStr (mountpointv);
1319   if (!mountpoint)
1320     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1321               "mountpoint", "mount");
1322
1323   int r;
1324
1325   r = guestfs_mount (g, device, mountpoint);
1326   if (r == -1)
1327     rb_raise (e_Error, "%s", guestfs_last_error (g));
1328
1329   return Qnil;
1330 }
1331
1332 static VALUE ruby_guestfs_sync (VALUE gv)
1333 {
1334   guestfs_h *g;
1335   Data_Get_Struct (gv, guestfs_h, g);
1336   if (!g)
1337     rb_raise (rb_eArgError, "%s: used handle after closing it", "sync");
1338
1339
1340   int r;
1341
1342   r = guestfs_sync (g);
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_touch (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", "touch");
1355
1356   const char *path = StringValueCStr (pathv);
1357   if (!path)
1358     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1359               "path", "touch");
1360
1361   int r;
1362
1363   r = guestfs_touch (g, path);
1364   if (r == -1)
1365     rb_raise (e_Error, "%s", guestfs_last_error (g));
1366
1367   return Qnil;
1368 }
1369
1370 static VALUE ruby_guestfs_cat (VALUE gv, VALUE pathv)
1371 {
1372   guestfs_h *g;
1373   Data_Get_Struct (gv, guestfs_h, g);
1374   if (!g)
1375     rb_raise (rb_eArgError, "%s: used handle after closing it", "cat");
1376
1377   const char *path = StringValueCStr (pathv);
1378   if (!path)
1379     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1380               "path", "cat");
1381
1382   char *r;
1383
1384   r = guestfs_cat (g, path);
1385   if (r == NULL)
1386     rb_raise (e_Error, "%s", guestfs_last_error (g));
1387
1388   VALUE rv = rb_str_new2 (r);
1389   free (r);
1390   return rv;
1391 }
1392
1393 static VALUE ruby_guestfs_ll (VALUE gv, VALUE directoryv)
1394 {
1395   guestfs_h *g;
1396   Data_Get_Struct (gv, guestfs_h, g);
1397   if (!g)
1398     rb_raise (rb_eArgError, "%s: used handle after closing it", "ll");
1399
1400   const char *directory = StringValueCStr (directoryv);
1401   if (!directory)
1402     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1403               "directory", "ll");
1404
1405   char *r;
1406
1407   r = guestfs_ll (g, directory);
1408   if (r == NULL)
1409     rb_raise (e_Error, "%s", guestfs_last_error (g));
1410
1411   VALUE rv = rb_str_new2 (r);
1412   free (r);
1413   return rv;
1414 }
1415
1416 static VALUE ruby_guestfs_ls (VALUE gv, VALUE directoryv)
1417 {
1418   guestfs_h *g;
1419   Data_Get_Struct (gv, guestfs_h, g);
1420   if (!g)
1421     rb_raise (rb_eArgError, "%s: used handle after closing it", "ls");
1422
1423   const char *directory = StringValueCStr (directoryv);
1424   if (!directory)
1425     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1426               "directory", "ls");
1427
1428   char **r;
1429
1430   r = guestfs_ls (g, directory);
1431   if (r == NULL)
1432     rb_raise (e_Error, "%s", guestfs_last_error (g));
1433
1434   int i, len = 0;
1435   for (i = 0; r[i] != NULL; ++i) len++;
1436   VALUE rv = rb_ary_new2 (len);
1437   for (i = 0; r[i] != NULL; ++i) {
1438     rb_ary_push (rv, rb_str_new2 (r[i]));
1439     free (r[i]);
1440   }
1441   free (r);
1442   return rv;
1443 }
1444
1445 static VALUE ruby_guestfs_list_devices (VALUE gv)
1446 {
1447   guestfs_h *g;
1448   Data_Get_Struct (gv, guestfs_h, g);
1449   if (!g)
1450     rb_raise (rb_eArgError, "%s: used handle after closing it", "list_devices");
1451
1452
1453   char **r;
1454
1455   r = guestfs_list_devices (g);
1456   if (r == NULL)
1457     rb_raise (e_Error, "%s", guestfs_last_error (g));
1458
1459   int i, len = 0;
1460   for (i = 0; r[i] != NULL; ++i) len++;
1461   VALUE rv = rb_ary_new2 (len);
1462   for (i = 0; r[i] != NULL; ++i) {
1463     rb_ary_push (rv, rb_str_new2 (r[i]));
1464     free (r[i]);
1465   }
1466   free (r);
1467   return rv;
1468 }
1469
1470 static VALUE ruby_guestfs_list_partitions (VALUE gv)
1471 {
1472   guestfs_h *g;
1473   Data_Get_Struct (gv, guestfs_h, g);
1474   if (!g)
1475     rb_raise (rb_eArgError, "%s: used handle after closing it", "list_partitions");
1476
1477
1478   char **r;
1479
1480   r = guestfs_list_partitions (g);
1481   if (r == NULL)
1482     rb_raise (e_Error, "%s", guestfs_last_error (g));
1483
1484   int i, len = 0;
1485   for (i = 0; r[i] != NULL; ++i) len++;
1486   VALUE rv = rb_ary_new2 (len);
1487   for (i = 0; r[i] != NULL; ++i) {
1488     rb_ary_push (rv, rb_str_new2 (r[i]));
1489     free (r[i]);
1490   }
1491   free (r);
1492   return rv;
1493 }
1494
1495 static VALUE ruby_guestfs_pvs (VALUE gv)
1496 {
1497   guestfs_h *g;
1498   Data_Get_Struct (gv, guestfs_h, g);
1499   if (!g)
1500     rb_raise (rb_eArgError, "%s: used handle after closing it", "pvs");
1501
1502
1503   char **r;
1504
1505   r = guestfs_pvs (g);
1506   if (r == NULL)
1507     rb_raise (e_Error, "%s", guestfs_last_error (g));
1508
1509   int i, len = 0;
1510   for (i = 0; r[i] != NULL; ++i) len++;
1511   VALUE rv = rb_ary_new2 (len);
1512   for (i = 0; r[i] != NULL; ++i) {
1513     rb_ary_push (rv, rb_str_new2 (r[i]));
1514     free (r[i]);
1515   }
1516   free (r);
1517   return rv;
1518 }
1519
1520 static VALUE ruby_guestfs_vgs (VALUE gv)
1521 {
1522   guestfs_h *g;
1523   Data_Get_Struct (gv, guestfs_h, g);
1524   if (!g)
1525     rb_raise (rb_eArgError, "%s: used handle after closing it", "vgs");
1526
1527
1528   char **r;
1529
1530   r = guestfs_vgs (g);
1531   if (r == NULL)
1532     rb_raise (e_Error, "%s", guestfs_last_error (g));
1533
1534   int i, len = 0;
1535   for (i = 0; r[i] != NULL; ++i) len++;
1536   VALUE rv = rb_ary_new2 (len);
1537   for (i = 0; r[i] != NULL; ++i) {
1538     rb_ary_push (rv, rb_str_new2 (r[i]));
1539     free (r[i]);
1540   }
1541   free (r);
1542   return rv;
1543 }
1544
1545 static VALUE ruby_guestfs_lvs (VALUE gv)
1546 {
1547   guestfs_h *g;
1548   Data_Get_Struct (gv, guestfs_h, g);
1549   if (!g)
1550     rb_raise (rb_eArgError, "%s: used handle after closing it", "lvs");
1551
1552
1553   char **r;
1554
1555   r = guestfs_lvs (g);
1556   if (r == NULL)
1557     rb_raise (e_Error, "%s", guestfs_last_error (g));
1558
1559   int i, len = 0;
1560   for (i = 0; r[i] != NULL; ++i) len++;
1561   VALUE rv = rb_ary_new2 (len);
1562   for (i = 0; r[i] != NULL; ++i) {
1563     rb_ary_push (rv, rb_str_new2 (r[i]));
1564     free (r[i]);
1565   }
1566   free (r);
1567   return rv;
1568 }
1569
1570 static VALUE ruby_guestfs_pvs_full (VALUE gv)
1571 {
1572   guestfs_h *g;
1573   Data_Get_Struct (gv, guestfs_h, g);
1574   if (!g)
1575     rb_raise (rb_eArgError, "%s: used handle after closing it", "pvs_full");
1576
1577
1578   struct guestfs_lvm_pv_list *r;
1579
1580   r = guestfs_pvs_full (g);
1581   if (r == NULL)
1582     rb_raise (e_Error, "%s", guestfs_last_error (g));
1583
1584   VALUE rv = rb_ary_new2 (r->len);
1585   int i;
1586   for (i = 0; i < r->len; ++i) {
1587     VALUE hv = rb_hash_new ();
1588     rb_hash_aset (rv, rb_str_new2 ("pv_name"), rb_str_new2 (r->val[i].pv_name));
1589     rb_hash_aset (rv, rb_str_new2 ("pv_uuid"), rb_str_new (r->val[i].pv_uuid, 32));
1590     rb_hash_aset (rv, rb_str_new2 ("pv_fmt"), rb_str_new2 (r->val[i].pv_fmt));
1591     rb_hash_aset (rv, rb_str_new2 ("pv_size"), ULL2NUM (r->val[i].pv_size));
1592     rb_hash_aset (rv, rb_str_new2 ("dev_size"), ULL2NUM (r->val[i].dev_size));
1593     rb_hash_aset (rv, rb_str_new2 ("pv_free"), ULL2NUM (r->val[i].pv_free));
1594     rb_hash_aset (rv, rb_str_new2 ("pv_used"), ULL2NUM (r->val[i].pv_used));
1595     rb_hash_aset (rv, rb_str_new2 ("pv_attr"), rb_str_new2 (r->val[i].pv_attr));
1596     rb_hash_aset (rv, rb_str_new2 ("pv_pe_count"), ULL2NUM (r->val[i].pv_pe_count));
1597     rb_hash_aset (rv, rb_str_new2 ("pv_pe_alloc_count"), ULL2NUM (r->val[i].pv_pe_alloc_count));
1598     rb_hash_aset (rv, rb_str_new2 ("pv_tags"), rb_str_new2 (r->val[i].pv_tags));
1599     rb_hash_aset (rv, rb_str_new2 ("pe_start"), ULL2NUM (r->val[i].pe_start));
1600     rb_hash_aset (rv, rb_str_new2 ("pv_mda_count"), ULL2NUM (r->val[i].pv_mda_count));
1601     rb_hash_aset (rv, rb_str_new2 ("pv_mda_free"), ULL2NUM (r->val[i].pv_mda_free));
1602     rb_ary_push (rv, hv);
1603   }
1604   guestfs_free_lvm_pv_list (r);
1605   return rv;
1606 }
1607
1608 static VALUE ruby_guestfs_vgs_full (VALUE gv)
1609 {
1610   guestfs_h *g;
1611   Data_Get_Struct (gv, guestfs_h, g);
1612   if (!g)
1613     rb_raise (rb_eArgError, "%s: used handle after closing it", "vgs_full");
1614
1615
1616   struct guestfs_lvm_vg_list *r;
1617
1618   r = guestfs_vgs_full (g);
1619   if (r == NULL)
1620     rb_raise (e_Error, "%s", guestfs_last_error (g));
1621
1622   VALUE rv = rb_ary_new2 (r->len);
1623   int i;
1624   for (i = 0; i < r->len; ++i) {
1625     VALUE hv = rb_hash_new ();
1626     rb_hash_aset (rv, rb_str_new2 ("vg_name"), rb_str_new2 (r->val[i].vg_name));
1627     rb_hash_aset (rv, rb_str_new2 ("vg_uuid"), rb_str_new (r->val[i].vg_uuid, 32));
1628     rb_hash_aset (rv, rb_str_new2 ("vg_fmt"), rb_str_new2 (r->val[i].vg_fmt));
1629     rb_hash_aset (rv, rb_str_new2 ("vg_attr"), rb_str_new2 (r->val[i].vg_attr));
1630     rb_hash_aset (rv, rb_str_new2 ("vg_size"), ULL2NUM (r->val[i].vg_size));
1631     rb_hash_aset (rv, rb_str_new2 ("vg_free"), ULL2NUM (r->val[i].vg_free));
1632     rb_hash_aset (rv, rb_str_new2 ("vg_sysid"), rb_str_new2 (r->val[i].vg_sysid));
1633     rb_hash_aset (rv, rb_str_new2 ("vg_extent_size"), ULL2NUM (r->val[i].vg_extent_size));
1634     rb_hash_aset (rv, rb_str_new2 ("vg_extent_count"), ULL2NUM (r->val[i].vg_extent_count));
1635     rb_hash_aset (rv, rb_str_new2 ("vg_free_count"), ULL2NUM (r->val[i].vg_free_count));
1636     rb_hash_aset (rv, rb_str_new2 ("max_lv"), ULL2NUM (r->val[i].max_lv));
1637     rb_hash_aset (rv, rb_str_new2 ("max_pv"), ULL2NUM (r->val[i].max_pv));
1638     rb_hash_aset (rv, rb_str_new2 ("pv_count"), ULL2NUM (r->val[i].pv_count));
1639     rb_hash_aset (rv, rb_str_new2 ("lv_count"), ULL2NUM (r->val[i].lv_count));
1640     rb_hash_aset (rv, rb_str_new2 ("snap_count"), ULL2NUM (r->val[i].snap_count));
1641     rb_hash_aset (rv, rb_str_new2 ("vg_seqno"), ULL2NUM (r->val[i].vg_seqno));
1642     rb_hash_aset (rv, rb_str_new2 ("vg_tags"), rb_str_new2 (r->val[i].vg_tags));
1643     rb_hash_aset (rv, rb_str_new2 ("vg_mda_count"), ULL2NUM (r->val[i].vg_mda_count));
1644     rb_hash_aset (rv, rb_str_new2 ("vg_mda_free"), ULL2NUM (r->val[i].vg_mda_free));
1645     rb_ary_push (rv, hv);
1646   }
1647   guestfs_free_lvm_vg_list (r);
1648   return rv;
1649 }
1650
1651 static VALUE ruby_guestfs_lvs_full (VALUE gv)
1652 {
1653   guestfs_h *g;
1654   Data_Get_Struct (gv, guestfs_h, g);
1655   if (!g)
1656     rb_raise (rb_eArgError, "%s: used handle after closing it", "lvs_full");
1657
1658
1659   struct guestfs_lvm_lv_list *r;
1660
1661   r = guestfs_lvs_full (g);
1662   if (r == NULL)
1663     rb_raise (e_Error, "%s", guestfs_last_error (g));
1664
1665   VALUE rv = rb_ary_new2 (r->len);
1666   int i;
1667   for (i = 0; i < r->len; ++i) {
1668     VALUE hv = rb_hash_new ();
1669     rb_hash_aset (rv, rb_str_new2 ("lv_name"), rb_str_new2 (r->val[i].lv_name));
1670     rb_hash_aset (rv, rb_str_new2 ("lv_uuid"), rb_str_new (r->val[i].lv_uuid, 32));
1671     rb_hash_aset (rv, rb_str_new2 ("lv_attr"), rb_str_new2 (r->val[i].lv_attr));
1672     rb_hash_aset (rv, rb_str_new2 ("lv_major"), ULL2NUM (r->val[i].lv_major));
1673     rb_hash_aset (rv, rb_str_new2 ("lv_minor"), ULL2NUM (r->val[i].lv_minor));
1674     rb_hash_aset (rv, rb_str_new2 ("lv_kernel_major"), ULL2NUM (r->val[i].lv_kernel_major));
1675     rb_hash_aset (rv, rb_str_new2 ("lv_kernel_minor"), ULL2NUM (r->val[i].lv_kernel_minor));
1676     rb_hash_aset (rv, rb_str_new2 ("lv_size"), ULL2NUM (r->val[i].lv_size));
1677     rb_hash_aset (rv, rb_str_new2 ("seg_count"), ULL2NUM (r->val[i].seg_count));
1678     rb_hash_aset (rv, rb_str_new2 ("origin"), rb_str_new2 (r->val[i].origin));
1679     rb_hash_aset (rv, rb_str_new2 ("snap_percent"), rb_dbl2big (r->val[i].snap_percent));
1680     rb_hash_aset (rv, rb_str_new2 ("copy_percent"), rb_dbl2big (r->val[i].copy_percent));
1681     rb_hash_aset (rv, rb_str_new2 ("move_pv"), rb_str_new2 (r->val[i].move_pv));
1682     rb_hash_aset (rv, rb_str_new2 ("lv_tags"), rb_str_new2 (r->val[i].lv_tags));
1683     rb_hash_aset (rv, rb_str_new2 ("mirror_log"), rb_str_new2 (r->val[i].mirror_log));
1684     rb_hash_aset (rv, rb_str_new2 ("modules"), rb_str_new2 (r->val[i].modules));
1685     rb_ary_push (rv, hv);
1686   }
1687   guestfs_free_lvm_lv_list (r);
1688   return rv;
1689 }
1690
1691 static VALUE ruby_guestfs_read_lines (VALUE gv, VALUE pathv)
1692 {
1693   guestfs_h *g;
1694   Data_Get_Struct (gv, guestfs_h, g);
1695   if (!g)
1696     rb_raise (rb_eArgError, "%s: used handle after closing it", "read_lines");
1697
1698   const char *path = StringValueCStr (pathv);
1699   if (!path)
1700     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1701               "path", "read_lines");
1702
1703   char **r;
1704
1705   r = guestfs_read_lines (g, path);
1706   if (r == NULL)
1707     rb_raise (e_Error, "%s", guestfs_last_error (g));
1708
1709   int i, len = 0;
1710   for (i = 0; r[i] != NULL; ++i) len++;
1711   VALUE rv = rb_ary_new2 (len);
1712   for (i = 0; r[i] != NULL; ++i) {
1713     rb_ary_push (rv, rb_str_new2 (r[i]));
1714     free (r[i]);
1715   }
1716   free (r);
1717   return rv;
1718 }
1719
1720 static VALUE ruby_guestfs_aug_init (VALUE gv, VALUE rootv, VALUE flagsv)
1721 {
1722   guestfs_h *g;
1723   Data_Get_Struct (gv, guestfs_h, g);
1724   if (!g)
1725     rb_raise (rb_eArgError, "%s: used handle after closing it", "aug_init");
1726
1727   const char *root = StringValueCStr (rootv);
1728   if (!root)
1729     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1730               "root", "aug_init");
1731   int flags = NUM2INT (flagsv);
1732
1733   int r;
1734
1735   r = guestfs_aug_init (g, root, flags);
1736   if (r == -1)
1737     rb_raise (e_Error, "%s", guestfs_last_error (g));
1738
1739   return Qnil;
1740 }
1741
1742 static VALUE ruby_guestfs_aug_close (VALUE gv)
1743 {
1744   guestfs_h *g;
1745   Data_Get_Struct (gv, guestfs_h, g);
1746   if (!g)
1747     rb_raise (rb_eArgError, "%s: used handle after closing it", "aug_close");
1748
1749
1750   int r;
1751
1752   r = guestfs_aug_close (g);
1753   if (r == -1)
1754     rb_raise (e_Error, "%s", guestfs_last_error (g));
1755
1756   return Qnil;
1757 }
1758
1759 static VALUE ruby_guestfs_aug_defvar (VALUE gv, VALUE namev, VALUE exprv)
1760 {
1761   guestfs_h *g;
1762   Data_Get_Struct (gv, guestfs_h, g);
1763   if (!g)
1764     rb_raise (rb_eArgError, "%s: used handle after closing it", "aug_defvar");
1765
1766   const char *name = StringValueCStr (namev);
1767   if (!name)
1768     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1769               "name", "aug_defvar");
1770   const char *expr = !NIL_P (exprv) ? StringValueCStr (exprv) : NULL;
1771
1772   int r;
1773
1774   r = guestfs_aug_defvar (g, name, expr);
1775   if (r == -1)
1776     rb_raise (e_Error, "%s", guestfs_last_error (g));
1777
1778   return INT2NUM (r);
1779 }
1780
1781 static VALUE ruby_guestfs_aug_defnode (VALUE gv, VALUE namev, VALUE exprv, VALUE valv)
1782 {
1783   guestfs_h *g;
1784   Data_Get_Struct (gv, guestfs_h, g);
1785   if (!g)
1786     rb_raise (rb_eArgError, "%s: used handle after closing it", "aug_defnode");
1787
1788   const char *name = StringValueCStr (namev);
1789   if (!name)
1790     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1791               "name", "aug_defnode");
1792   const char *expr = StringValueCStr (exprv);
1793   if (!expr)
1794     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1795               "expr", "aug_defnode");
1796   const char *val = StringValueCStr (valv);
1797   if (!val)
1798     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1799               "val", "aug_defnode");
1800
1801   struct guestfs_int_bool *r;
1802
1803   r = guestfs_aug_defnode (g, name, expr, val);
1804   if (r == NULL)
1805     rb_raise (e_Error, "%s", guestfs_last_error (g));
1806
1807   VALUE rv = rb_ary_new2 (2);
1808   rb_ary_push (rv, INT2NUM (r->i));
1809   rb_ary_push (rv, INT2NUM (r->b));
1810   guestfs_free_int_bool (r);
1811   return rv;
1812 }
1813
1814 static VALUE ruby_guestfs_aug_get (VALUE gv, VALUE pathv)
1815 {
1816   guestfs_h *g;
1817   Data_Get_Struct (gv, guestfs_h, g);
1818   if (!g)
1819     rb_raise (rb_eArgError, "%s: used handle after closing it", "aug_get");
1820
1821   const char *path = StringValueCStr (pathv);
1822   if (!path)
1823     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1824               "path", "aug_get");
1825
1826   char *r;
1827
1828   r = guestfs_aug_get (g, path);
1829   if (r == NULL)
1830     rb_raise (e_Error, "%s", guestfs_last_error (g));
1831
1832   VALUE rv = rb_str_new2 (r);
1833   free (r);
1834   return rv;
1835 }
1836
1837 static VALUE ruby_guestfs_aug_set (VALUE gv, VALUE pathv, VALUE valv)
1838 {
1839   guestfs_h *g;
1840   Data_Get_Struct (gv, guestfs_h, g);
1841   if (!g)
1842     rb_raise (rb_eArgError, "%s: used handle after closing it", "aug_set");
1843
1844   const char *path = StringValueCStr (pathv);
1845   if (!path)
1846     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1847               "path", "aug_set");
1848   const char *val = StringValueCStr (valv);
1849   if (!val)
1850     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1851               "val", "aug_set");
1852
1853   int r;
1854
1855   r = guestfs_aug_set (g, path, val);
1856   if (r == -1)
1857     rb_raise (e_Error, "%s", guestfs_last_error (g));
1858
1859   return Qnil;
1860 }
1861
1862 static VALUE ruby_guestfs_aug_insert (VALUE gv, VALUE pathv, VALUE labelv, VALUE beforev)
1863 {
1864   guestfs_h *g;
1865   Data_Get_Struct (gv, guestfs_h, g);
1866   if (!g)
1867     rb_raise (rb_eArgError, "%s: used handle after closing it", "aug_insert");
1868
1869   const char *path = StringValueCStr (pathv);
1870   if (!path)
1871     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1872               "path", "aug_insert");
1873   const char *label = StringValueCStr (labelv);
1874   if (!label)
1875     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1876               "label", "aug_insert");
1877   int before = RTEST (beforev);
1878
1879   int r;
1880
1881   r = guestfs_aug_insert (g, path, label, before);
1882   if (r == -1)
1883     rb_raise (e_Error, "%s", guestfs_last_error (g));
1884
1885   return Qnil;
1886 }
1887
1888 static VALUE ruby_guestfs_aug_rm (VALUE gv, VALUE pathv)
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_rm");
1894
1895   const char *path = StringValueCStr (pathv);
1896   if (!path)
1897     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1898               "path", "aug_rm");
1899
1900   int r;
1901
1902   r = guestfs_aug_rm (g, path);
1903   if (r == -1)
1904     rb_raise (e_Error, "%s", guestfs_last_error (g));
1905
1906   return INT2NUM (r);
1907 }
1908
1909 static VALUE ruby_guestfs_aug_mv (VALUE gv, VALUE srcv, VALUE destv)
1910 {
1911   guestfs_h *g;
1912   Data_Get_Struct (gv, guestfs_h, g);
1913   if (!g)
1914     rb_raise (rb_eArgError, "%s: used handle after closing it", "aug_mv");
1915
1916   const char *src = StringValueCStr (srcv);
1917   if (!src)
1918     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1919               "src", "aug_mv");
1920   const char *dest = StringValueCStr (destv);
1921   if (!dest)
1922     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1923               "dest", "aug_mv");
1924
1925   int r;
1926
1927   r = guestfs_aug_mv (g, src, dest);
1928   if (r == -1)
1929     rb_raise (e_Error, "%s", guestfs_last_error (g));
1930
1931   return Qnil;
1932 }
1933
1934 static VALUE ruby_guestfs_aug_match (VALUE gv, VALUE pathv)
1935 {
1936   guestfs_h *g;
1937   Data_Get_Struct (gv, guestfs_h, g);
1938   if (!g)
1939     rb_raise (rb_eArgError, "%s: used handle after closing it", "aug_match");
1940
1941   const char *path = StringValueCStr (pathv);
1942   if (!path)
1943     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1944               "path", "aug_match");
1945
1946   char **r;
1947
1948   r = guestfs_aug_match (g, path);
1949   if (r == NULL)
1950     rb_raise (e_Error, "%s", guestfs_last_error (g));
1951
1952   int i, len = 0;
1953   for (i = 0; r[i] != NULL; ++i) len++;
1954   VALUE rv = rb_ary_new2 (len);
1955   for (i = 0; r[i] != NULL; ++i) {
1956     rb_ary_push (rv, rb_str_new2 (r[i]));
1957     free (r[i]);
1958   }
1959   free (r);
1960   return rv;
1961 }
1962
1963 static VALUE ruby_guestfs_aug_save (VALUE gv)
1964 {
1965   guestfs_h *g;
1966   Data_Get_Struct (gv, guestfs_h, g);
1967   if (!g)
1968     rb_raise (rb_eArgError, "%s: used handle after closing it", "aug_save");
1969
1970
1971   int r;
1972
1973   r = guestfs_aug_save (g);
1974   if (r == -1)
1975     rb_raise (e_Error, "%s", guestfs_last_error (g));
1976
1977   return Qnil;
1978 }
1979
1980 static VALUE ruby_guestfs_aug_load (VALUE gv)
1981 {
1982   guestfs_h *g;
1983   Data_Get_Struct (gv, guestfs_h, g);
1984   if (!g)
1985     rb_raise (rb_eArgError, "%s: used handle after closing it", "aug_load");
1986
1987
1988   int r;
1989
1990   r = guestfs_aug_load (g);
1991   if (r == -1)
1992     rb_raise (e_Error, "%s", guestfs_last_error (g));
1993
1994   return Qnil;
1995 }
1996
1997 static VALUE ruby_guestfs_aug_ls (VALUE gv, VALUE pathv)
1998 {
1999   guestfs_h *g;
2000   Data_Get_Struct (gv, guestfs_h, g);
2001   if (!g)
2002     rb_raise (rb_eArgError, "%s: used handle after closing it", "aug_ls");
2003
2004   const char *path = StringValueCStr (pathv);
2005   if (!path)
2006     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2007               "path", "aug_ls");
2008
2009   char **r;
2010
2011   r = guestfs_aug_ls (g, path);
2012   if (r == NULL)
2013     rb_raise (e_Error, "%s", guestfs_last_error (g));
2014
2015   int i, len = 0;
2016   for (i = 0; r[i] != NULL; ++i) len++;
2017   VALUE rv = rb_ary_new2 (len);
2018   for (i = 0; r[i] != NULL; ++i) {
2019     rb_ary_push (rv, rb_str_new2 (r[i]));
2020     free (r[i]);
2021   }
2022   free (r);
2023   return rv;
2024 }
2025
2026 static VALUE ruby_guestfs_rm (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", "rm");
2032
2033   const char *path = StringValueCStr (pathv);
2034   if (!path)
2035     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2036               "path", "rm");
2037
2038   int r;
2039
2040   r = guestfs_rm (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_rmdir (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", "rmdir");
2053
2054   const char *path = StringValueCStr (pathv);
2055   if (!path)
2056     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2057               "path", "rmdir");
2058
2059   int r;
2060
2061   r = guestfs_rmdir (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_rm_rf (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", "rm_rf");
2074
2075   const char *path = StringValueCStr (pathv);
2076   if (!path)
2077     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2078               "path", "rm_rf");
2079
2080   int r;
2081
2082   r = guestfs_rm_rf (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 (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");
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");
2100
2101   int r;
2102
2103   r = guestfs_mkdir (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_mkdir_p (VALUE gv, 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", "mkdir_p");
2116
2117   const char *path = StringValueCStr (pathv);
2118   if (!path)
2119     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2120               "path", "mkdir_p");
2121
2122   int r;
2123
2124   r = guestfs_mkdir_p (g, path);
2125   if (r == -1)
2126     rb_raise (e_Error, "%s", guestfs_last_error (g));
2127
2128   return Qnil;
2129 }
2130
2131 static VALUE ruby_guestfs_chmod (VALUE gv, VALUE modev, VALUE pathv)
2132 {
2133   guestfs_h *g;
2134   Data_Get_Struct (gv, guestfs_h, g);
2135   if (!g)
2136     rb_raise (rb_eArgError, "%s: used handle after closing it", "chmod");
2137
2138   int mode = NUM2INT (modev);
2139   const char *path = StringValueCStr (pathv);
2140   if (!path)
2141     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2142               "path", "chmod");
2143
2144   int r;
2145
2146   r = guestfs_chmod (g, mode, path);
2147   if (r == -1)
2148     rb_raise (e_Error, "%s", guestfs_last_error (g));
2149
2150   return Qnil;
2151 }
2152
2153 static VALUE ruby_guestfs_chown (VALUE gv, VALUE ownerv, VALUE groupv, VALUE pathv)
2154 {
2155   guestfs_h *g;
2156   Data_Get_Struct (gv, guestfs_h, g);
2157   if (!g)
2158     rb_raise (rb_eArgError, "%s: used handle after closing it", "chown");
2159
2160   int owner = NUM2INT (ownerv);
2161   int group = NUM2INT (groupv);
2162   const char *path = StringValueCStr (pathv);
2163   if (!path)
2164     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2165               "path", "chown");
2166
2167   int r;
2168
2169   r = guestfs_chown (g, owner, group, path);
2170   if (r == -1)
2171     rb_raise (e_Error, "%s", guestfs_last_error (g));
2172
2173   return Qnil;
2174 }
2175
2176 static VALUE ruby_guestfs_exists (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", "exists");
2182
2183   const char *path = StringValueCStr (pathv);
2184   if (!path)
2185     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2186               "path", "exists");
2187
2188   int r;
2189
2190   r = guestfs_exists (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_file (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_file");
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_file");
2208
2209   int r;
2210
2211   r = guestfs_is_file (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_is_dir (VALUE gv, VALUE pathv)
2219 {
2220   guestfs_h *g;
2221   Data_Get_Struct (gv, guestfs_h, g);
2222   if (!g)
2223     rb_raise (rb_eArgError, "%s: used handle after closing it", "is_dir");
2224
2225   const char *path = StringValueCStr (pathv);
2226   if (!path)
2227     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2228               "path", "is_dir");
2229
2230   int r;
2231
2232   r = guestfs_is_dir (g, path);
2233   if (r == -1)
2234     rb_raise (e_Error, "%s", guestfs_last_error (g));
2235
2236   return INT2NUM (r);
2237 }
2238
2239 static VALUE ruby_guestfs_pvcreate (VALUE gv, VALUE devicev)
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", "pvcreate");
2245
2246   const char *device = StringValueCStr (devicev);
2247   if (!device)
2248     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2249               "device", "pvcreate");
2250
2251   int r;
2252
2253   r = guestfs_pvcreate (g, device);
2254   if (r == -1)
2255     rb_raise (e_Error, "%s", guestfs_last_error (g));
2256
2257   return Qnil;
2258 }
2259
2260 static VALUE ruby_guestfs_vgcreate (VALUE gv, VALUE volgroupv, VALUE physvolsv)
2261 {
2262   guestfs_h *g;
2263   Data_Get_Struct (gv, guestfs_h, g);
2264   if (!g)
2265     rb_raise (rb_eArgError, "%s: used handle after closing it", "vgcreate");
2266
2267   const char *volgroup = StringValueCStr (volgroupv);
2268   if (!volgroup)
2269     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2270               "volgroup", "vgcreate");
2271   char **physvols;  {
2272     int i, len;
2273     len = RARRAY_LEN (physvolsv);
2274     physvols = guestfs_safe_malloc (g, sizeof (char *) * (len+1));
2275     for (i = 0; i < len; ++i) {
2276       VALUE v = rb_ary_entry (physvolsv, i);
2277       physvols[i] = StringValueCStr (v);
2278     }
2279     physvols[len] = NULL;
2280   }
2281
2282   int r;
2283
2284   r = guestfs_vgcreate (g, volgroup, physvols);
2285   free (physvols);
2286   if (r == -1)
2287     rb_raise (e_Error, "%s", guestfs_last_error (g));
2288
2289   return Qnil;
2290 }
2291
2292 static VALUE ruby_guestfs_lvcreate (VALUE gv, VALUE logvolv, VALUE volgroupv, VALUE mbytesv)
2293 {
2294   guestfs_h *g;
2295   Data_Get_Struct (gv, guestfs_h, g);
2296   if (!g)
2297     rb_raise (rb_eArgError, "%s: used handle after closing it", "lvcreate");
2298
2299   const char *logvol = StringValueCStr (logvolv);
2300   if (!logvol)
2301     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2302               "logvol", "lvcreate");
2303   const char *volgroup = StringValueCStr (volgroupv);
2304   if (!volgroup)
2305     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2306               "volgroup", "lvcreate");
2307   int mbytes = NUM2INT (mbytesv);
2308
2309   int r;
2310
2311   r = guestfs_lvcreate (g, logvol, volgroup, mbytes);
2312   if (r == -1)
2313     rb_raise (e_Error, "%s", guestfs_last_error (g));
2314
2315   return Qnil;
2316 }
2317
2318 static VALUE ruby_guestfs_mkfs (VALUE gv, VALUE fstypev, VALUE devicev)
2319 {
2320   guestfs_h *g;
2321   Data_Get_Struct (gv, guestfs_h, g);
2322   if (!g)
2323     rb_raise (rb_eArgError, "%s: used handle after closing it", "mkfs");
2324
2325   const char *fstype = StringValueCStr (fstypev);
2326   if (!fstype)
2327     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2328               "fstype", "mkfs");
2329   const char *device = StringValueCStr (devicev);
2330   if (!device)
2331     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2332               "device", "mkfs");
2333
2334   int r;
2335
2336   r = guestfs_mkfs (g, fstype, device);
2337   if (r == -1)
2338     rb_raise (e_Error, "%s", guestfs_last_error (g));
2339
2340   return Qnil;
2341 }
2342
2343 static VALUE ruby_guestfs_sfdisk (VALUE gv, VALUE devicev, VALUE cylsv, VALUE headsv, VALUE sectorsv, VALUE linesv)
2344 {
2345   guestfs_h *g;
2346   Data_Get_Struct (gv, guestfs_h, g);
2347   if (!g)
2348     rb_raise (rb_eArgError, "%s: used handle after closing it", "sfdisk");
2349
2350   const char *device = StringValueCStr (devicev);
2351   if (!device)
2352     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2353               "device", "sfdisk");
2354   int cyls = NUM2INT (cylsv);
2355   int heads = NUM2INT (headsv);
2356   int sectors = NUM2INT (sectorsv);
2357   char **lines;  {
2358     int i, len;
2359     len = RARRAY_LEN (linesv);
2360     lines = guestfs_safe_malloc (g, sizeof (char *) * (len+1));
2361     for (i = 0; i < len; ++i) {
2362       VALUE v = rb_ary_entry (linesv, i);
2363       lines[i] = StringValueCStr (v);
2364     }
2365     lines[len] = NULL;
2366   }
2367
2368   int r;
2369
2370   r = guestfs_sfdisk (g, device, cyls, heads, sectors, lines);
2371   free (lines);
2372   if (r == -1)
2373     rb_raise (e_Error, "%s", guestfs_last_error (g));
2374
2375   return Qnil;
2376 }
2377
2378 static VALUE ruby_guestfs_write_file (VALUE gv, VALUE pathv, VALUE contentv, VALUE sizev)
2379 {
2380   guestfs_h *g;
2381   Data_Get_Struct (gv, guestfs_h, g);
2382   if (!g)
2383     rb_raise (rb_eArgError, "%s: used handle after closing it", "write_file");
2384
2385   const char *path = StringValueCStr (pathv);
2386   if (!path)
2387     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2388               "path", "write_file");
2389   const char *content = StringValueCStr (contentv);
2390   if (!content)
2391     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2392               "content", "write_file");
2393   int size = NUM2INT (sizev);
2394
2395   int r;
2396
2397   r = guestfs_write_file (g, path, content, size);
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_umount (VALUE gv, VALUE pathordevicev)
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", "umount");
2410
2411   const char *pathordevice = StringValueCStr (pathordevicev);
2412   if (!pathordevice)
2413     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2414               "pathordevice", "umount");
2415
2416   int r;
2417
2418   r = guestfs_umount (g, pathordevice);
2419   if (r == -1)
2420     rb_raise (e_Error, "%s", guestfs_last_error (g));
2421
2422   return Qnil;
2423 }
2424
2425 static VALUE ruby_guestfs_mounts (VALUE gv)
2426 {
2427   guestfs_h *g;
2428   Data_Get_Struct (gv, guestfs_h, g);
2429   if (!g)
2430     rb_raise (rb_eArgError, "%s: used handle after closing it", "mounts");
2431
2432
2433   char **r;
2434
2435   r = guestfs_mounts (g);
2436   if (r == NULL)
2437     rb_raise (e_Error, "%s", guestfs_last_error (g));
2438
2439   int i, len = 0;
2440   for (i = 0; r[i] != NULL; ++i) len++;
2441   VALUE rv = rb_ary_new2 (len);
2442   for (i = 0; r[i] != NULL; ++i) {
2443     rb_ary_push (rv, rb_str_new2 (r[i]));
2444     free (r[i]);
2445   }
2446   free (r);
2447   return rv;
2448 }
2449
2450 static VALUE ruby_guestfs_umount_all (VALUE gv)
2451 {
2452   guestfs_h *g;
2453   Data_Get_Struct (gv, guestfs_h, g);
2454   if (!g)
2455     rb_raise (rb_eArgError, "%s: used handle after closing it", "umount_all");
2456
2457
2458   int r;
2459
2460   r = guestfs_umount_all (g);
2461   if (r == -1)
2462     rb_raise (e_Error, "%s", guestfs_last_error (g));
2463
2464   return Qnil;
2465 }
2466
2467 static VALUE ruby_guestfs_lvm_remove_all (VALUE gv)
2468 {
2469   guestfs_h *g;
2470   Data_Get_Struct (gv, guestfs_h, g);
2471   if (!g)
2472     rb_raise (rb_eArgError, "%s: used handle after closing it", "lvm_remove_all");
2473
2474
2475   int r;
2476
2477   r = guestfs_lvm_remove_all (g);
2478   if (r == -1)
2479     rb_raise (e_Error, "%s", guestfs_last_error (g));
2480
2481   return Qnil;
2482 }
2483
2484 static VALUE ruby_guestfs_file (VALUE gv, VALUE pathv)
2485 {
2486   guestfs_h *g;
2487   Data_Get_Struct (gv, guestfs_h, g);
2488   if (!g)
2489     rb_raise (rb_eArgError, "%s: used handle after closing it", "file");
2490
2491   const char *path = StringValueCStr (pathv);
2492   if (!path)
2493     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2494               "path", "file");
2495
2496   char *r;
2497
2498   r = guestfs_file (g, path);
2499   if (r == NULL)
2500     rb_raise (e_Error, "%s", guestfs_last_error (g));
2501
2502   VALUE rv = rb_str_new2 (r);
2503   free (r);
2504   return rv;
2505 }
2506
2507 static VALUE ruby_guestfs_command (VALUE gv, VALUE argumentsv)
2508 {
2509   guestfs_h *g;
2510   Data_Get_Struct (gv, guestfs_h, g);
2511   if (!g)
2512     rb_raise (rb_eArgError, "%s: used handle after closing it", "command");
2513
2514   char **arguments;  {
2515     int i, len;
2516     len = RARRAY_LEN (argumentsv);
2517     arguments = guestfs_safe_malloc (g, sizeof (char *) * (len+1));
2518     for (i = 0; i < len; ++i) {
2519       VALUE v = rb_ary_entry (argumentsv, i);
2520       arguments[i] = StringValueCStr (v);
2521     }
2522     arguments[len] = NULL;
2523   }
2524
2525   char *r;
2526
2527   r = guestfs_command (g, arguments);
2528   free (arguments);
2529   if (r == NULL)
2530     rb_raise (e_Error, "%s", guestfs_last_error (g));
2531
2532   VALUE rv = rb_str_new2 (r);
2533   free (r);
2534   return rv;
2535 }
2536
2537 static VALUE ruby_guestfs_command_lines (VALUE gv, VALUE argumentsv)
2538 {
2539   guestfs_h *g;
2540   Data_Get_Struct (gv, guestfs_h, g);
2541   if (!g)
2542     rb_raise (rb_eArgError, "%s: used handle after closing it", "command_lines");
2543
2544   char **arguments;  {
2545     int i, len;
2546     len = RARRAY_LEN (argumentsv);
2547     arguments = guestfs_safe_malloc (g, sizeof (char *) * (len+1));
2548     for (i = 0; i < len; ++i) {
2549       VALUE v = rb_ary_entry (argumentsv, i);
2550       arguments[i] = StringValueCStr (v);
2551     }
2552     arguments[len] = NULL;
2553   }
2554
2555   char **r;
2556
2557   r = guestfs_command_lines (g, arguments);
2558   free (arguments);
2559   if (r == NULL)
2560     rb_raise (e_Error, "%s", guestfs_last_error (g));
2561
2562   int i, len = 0;
2563   for (i = 0; r[i] != NULL; ++i) len++;
2564   VALUE rv = rb_ary_new2 (len);
2565   for (i = 0; r[i] != NULL; ++i) {
2566     rb_ary_push (rv, rb_str_new2 (r[i]));
2567     free (r[i]);
2568   }
2569   free (r);
2570   return rv;
2571 }
2572
2573 static VALUE ruby_guestfs_stat (VALUE gv, VALUE pathv)
2574 {
2575   guestfs_h *g;
2576   Data_Get_Struct (gv, guestfs_h, g);
2577   if (!g)
2578     rb_raise (rb_eArgError, "%s: used handle after closing it", "stat");
2579
2580   const char *path = StringValueCStr (pathv);
2581   if (!path)
2582     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2583               "path", "stat");
2584
2585   struct guestfs_stat *r;
2586
2587   r = guestfs_stat (g, path);
2588   if (r == NULL)
2589     rb_raise (e_Error, "%s", guestfs_last_error (g));
2590
2591   VALUE rv = rb_hash_new ();
2592   rb_hash_aset (rv, rb_str_new2 ("dev"), ULL2NUM (r->dev));
2593   rb_hash_aset (rv, rb_str_new2 ("ino"), ULL2NUM (r->ino));
2594   rb_hash_aset (rv, rb_str_new2 ("mode"), ULL2NUM (r->mode));
2595   rb_hash_aset (rv, rb_str_new2 ("nlink"), ULL2NUM (r->nlink));
2596   rb_hash_aset (rv, rb_str_new2 ("uid"), ULL2NUM (r->uid));
2597   rb_hash_aset (rv, rb_str_new2 ("gid"), ULL2NUM (r->gid));
2598   rb_hash_aset (rv, rb_str_new2 ("rdev"), ULL2NUM (r->rdev));
2599   rb_hash_aset (rv, rb_str_new2 ("size"), ULL2NUM (r->size));
2600   rb_hash_aset (rv, rb_str_new2 ("blksize"), ULL2NUM (r->blksize));
2601   rb_hash_aset (rv, rb_str_new2 ("blocks"), ULL2NUM (r->blocks));
2602   rb_hash_aset (rv, rb_str_new2 ("atime"), ULL2NUM (r->atime));
2603   rb_hash_aset (rv, rb_str_new2 ("mtime"), ULL2NUM (r->mtime));
2604   rb_hash_aset (rv, rb_str_new2 ("ctime"), ULL2NUM (r->ctime));
2605   free (r);
2606   return rv;
2607 }
2608
2609 static VALUE ruby_guestfs_lstat (VALUE gv, VALUE pathv)
2610 {
2611   guestfs_h *g;
2612   Data_Get_Struct (gv, guestfs_h, g);
2613   if (!g)
2614     rb_raise (rb_eArgError, "%s: used handle after closing it", "lstat");
2615
2616   const char *path = StringValueCStr (pathv);
2617   if (!path)
2618     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2619               "path", "lstat");
2620
2621   struct guestfs_stat *r;
2622
2623   r = guestfs_lstat (g, path);
2624   if (r == NULL)
2625     rb_raise (e_Error, "%s", guestfs_last_error (g));
2626
2627   VALUE rv = rb_hash_new ();
2628   rb_hash_aset (rv, rb_str_new2 ("dev"), ULL2NUM (r->dev));
2629   rb_hash_aset (rv, rb_str_new2 ("ino"), ULL2NUM (r->ino));
2630   rb_hash_aset (rv, rb_str_new2 ("mode"), ULL2NUM (r->mode));
2631   rb_hash_aset (rv, rb_str_new2 ("nlink"), ULL2NUM (r->nlink));
2632   rb_hash_aset (rv, rb_str_new2 ("uid"), ULL2NUM (r->uid));
2633   rb_hash_aset (rv, rb_str_new2 ("gid"), ULL2NUM (r->gid));
2634   rb_hash_aset (rv, rb_str_new2 ("rdev"), ULL2NUM (r->rdev));
2635   rb_hash_aset (rv, rb_str_new2 ("size"), ULL2NUM (r->size));
2636   rb_hash_aset (rv, rb_str_new2 ("blksize"), ULL2NUM (r->blksize));
2637   rb_hash_aset (rv, rb_str_new2 ("blocks"), ULL2NUM (r->blocks));
2638   rb_hash_aset (rv, rb_str_new2 ("atime"), ULL2NUM (r->atime));
2639   rb_hash_aset (rv, rb_str_new2 ("mtime"), ULL2NUM (r->mtime));
2640   rb_hash_aset (rv, rb_str_new2 ("ctime"), ULL2NUM (r->ctime));
2641   free (r);
2642   return rv;
2643 }
2644
2645 static VALUE ruby_guestfs_statvfs (VALUE gv, VALUE pathv)
2646 {
2647   guestfs_h *g;
2648   Data_Get_Struct (gv, guestfs_h, g);
2649   if (!g)
2650     rb_raise (rb_eArgError, "%s: used handle after closing it", "statvfs");
2651
2652   const char *path = StringValueCStr (pathv);
2653   if (!path)
2654     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2655               "path", "statvfs");
2656
2657   struct guestfs_statvfs *r;
2658
2659   r = guestfs_statvfs (g, path);
2660   if (r == NULL)
2661     rb_raise (e_Error, "%s", guestfs_last_error (g));
2662
2663   VALUE rv = rb_hash_new ();
2664   rb_hash_aset (rv, rb_str_new2 ("bsize"), ULL2NUM (r->bsize));
2665   rb_hash_aset (rv, rb_str_new2 ("frsize"), ULL2NUM (r->frsize));
2666   rb_hash_aset (rv, rb_str_new2 ("blocks"), ULL2NUM (r->blocks));
2667   rb_hash_aset (rv, rb_str_new2 ("bfree"), ULL2NUM (r->bfree));
2668   rb_hash_aset (rv, rb_str_new2 ("bavail"), ULL2NUM (r->bavail));
2669   rb_hash_aset (rv, rb_str_new2 ("files"), ULL2NUM (r->files));
2670   rb_hash_aset (rv, rb_str_new2 ("ffree"), ULL2NUM (r->ffree));
2671   rb_hash_aset (rv, rb_str_new2 ("favail"), ULL2NUM (r->favail));
2672   rb_hash_aset (rv, rb_str_new2 ("fsid"), ULL2NUM (r->fsid));
2673   rb_hash_aset (rv, rb_str_new2 ("flag"), ULL2NUM (r->flag));
2674   rb_hash_aset (rv, rb_str_new2 ("namemax"), ULL2NUM (r->namemax));
2675   free (r);
2676   return rv;
2677 }
2678
2679 static VALUE ruby_guestfs_tune2fs_l (VALUE gv, VALUE devicev)
2680 {
2681   guestfs_h *g;
2682   Data_Get_Struct (gv, guestfs_h, g);
2683   if (!g)
2684     rb_raise (rb_eArgError, "%s: used handle after closing it", "tune2fs_l");
2685
2686   const char *device = StringValueCStr (devicev);
2687   if (!device)
2688     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2689               "device", "tune2fs_l");
2690
2691   char **r;
2692
2693   r = guestfs_tune2fs_l (g, device);
2694   if (r == NULL)
2695     rb_raise (e_Error, "%s", guestfs_last_error (g));
2696
2697   VALUE rv = rb_hash_new ();
2698   int i;
2699   for (i = 0; r[i] != NULL; i+=2) {
2700     rb_hash_aset (rv, rb_str_new2 (r[i]), rb_str_new2 (r[i+1]));
2701     free (r[i]);
2702     free (r[i+1]);
2703   }
2704   free (r);
2705   return rv;
2706 }
2707
2708 static VALUE ruby_guestfs_blockdev_setro (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_setro");
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_setro");
2719
2720   int r;
2721
2722   r = guestfs_blockdev_setro (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_setrw (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_setrw");
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_setrw");
2740
2741   int r;
2742
2743   r = guestfs_blockdev_setrw (g, device);
2744   if (r == -1)
2745     rb_raise (e_Error, "%s", guestfs_last_error (g));
2746
2747   return Qnil;
2748 }
2749
2750 static VALUE ruby_guestfs_blockdev_getro (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_getro");
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_getro");
2761
2762   int r;
2763
2764   r = guestfs_blockdev_getro (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_getss (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_getss");
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_getss");
2782
2783   int r;
2784
2785   r = guestfs_blockdev_getss (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_getbsz (VALUE gv, VALUE devicev)
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_getbsz");
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_getbsz");
2803
2804   int r;
2805
2806   r = guestfs_blockdev_getbsz (g, device);
2807   if (r == -1)
2808     rb_raise (e_Error, "%s", guestfs_last_error (g));
2809
2810   return INT2NUM (r);
2811 }
2812
2813 static VALUE ruby_guestfs_blockdev_setbsz (VALUE gv, VALUE devicev, VALUE blocksizev)
2814 {
2815   guestfs_h *g;
2816   Data_Get_Struct (gv, guestfs_h, g);
2817   if (!g)
2818     rb_raise (rb_eArgError, "%s: used handle after closing it", "blockdev_setbsz");
2819
2820   const char *device = StringValueCStr (devicev);
2821   if (!device)
2822     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2823               "device", "blockdev_setbsz");
2824   int blocksize = NUM2INT (blocksizev);
2825
2826   int r;
2827
2828   r = guestfs_blockdev_setbsz (g, device, blocksize);
2829   if (r == -1)
2830     rb_raise (e_Error, "%s", guestfs_last_error (g));
2831
2832   return Qnil;
2833 }
2834
2835 static VALUE ruby_guestfs_blockdev_getsz (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_getsz");
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_getsz");
2846
2847   int64_t r;
2848
2849   r = guestfs_blockdev_getsz (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_getsize64 (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_getsize64");
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_getsize64");
2867
2868   int64_t r;
2869
2870   r = guestfs_blockdev_getsize64 (g, device);
2871   if (r == -1)
2872     rb_raise (e_Error, "%s", guestfs_last_error (g));
2873
2874   return ULL2NUM (r);
2875 }
2876
2877 static VALUE ruby_guestfs_blockdev_flushbufs (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_flushbufs");
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_flushbufs");
2888
2889   int r;
2890
2891   r = guestfs_blockdev_flushbufs (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_blockdev_rereadpt (VALUE gv, VALUE devicev)
2899 {
2900   guestfs_h *g;
2901   Data_Get_Struct (gv, guestfs_h, g);
2902   if (!g)
2903     rb_raise (rb_eArgError, "%s: used handle after closing it", "blockdev_rereadpt");
2904
2905   const char *device = StringValueCStr (devicev);
2906   if (!device)
2907     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2908               "device", "blockdev_rereadpt");
2909
2910   int r;
2911
2912   r = guestfs_blockdev_rereadpt (g, device);
2913   if (r == -1)
2914     rb_raise (e_Error, "%s", guestfs_last_error (g));
2915
2916   return Qnil;
2917 }
2918
2919 static VALUE ruby_guestfs_upload (VALUE gv, VALUE filenamev, VALUE remotefilenamev)
2920 {
2921   guestfs_h *g;
2922   Data_Get_Struct (gv, guestfs_h, g);
2923   if (!g)
2924     rb_raise (rb_eArgError, "%s: used handle after closing it", "upload");
2925
2926   const char *filename = StringValueCStr (filenamev);
2927   if (!filename)
2928     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2929               "filename", "upload");
2930   const char *remotefilename = StringValueCStr (remotefilenamev);
2931   if (!remotefilename)
2932     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2933               "remotefilename", "upload");
2934
2935   int r;
2936
2937   r = guestfs_upload (g, filename, remotefilename);
2938   if (r == -1)
2939     rb_raise (e_Error, "%s", guestfs_last_error (g));
2940
2941   return Qnil;
2942 }
2943
2944 static VALUE ruby_guestfs_download (VALUE gv, VALUE remotefilenamev, VALUE filenamev)
2945 {
2946   guestfs_h *g;
2947   Data_Get_Struct (gv, guestfs_h, g);
2948   if (!g)
2949     rb_raise (rb_eArgError, "%s: used handle after closing it", "download");
2950
2951   const char *remotefilename = StringValueCStr (remotefilenamev);
2952   if (!remotefilename)
2953     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2954               "remotefilename", "download");
2955   const char *filename = StringValueCStr (filenamev);
2956   if (!filename)
2957     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2958               "filename", "download");
2959
2960   int r;
2961
2962   r = guestfs_download (g, remotefilename, filename);
2963   if (r == -1)
2964     rb_raise (e_Error, "%s", guestfs_last_error (g));
2965
2966   return Qnil;
2967 }
2968
2969 static VALUE ruby_guestfs_checksum (VALUE gv, VALUE csumtypev, VALUE pathv)
2970 {
2971   guestfs_h *g;
2972   Data_Get_Struct (gv, guestfs_h, g);
2973   if (!g)
2974     rb_raise (rb_eArgError, "%s: used handle after closing it", "checksum");
2975
2976   const char *csumtype = StringValueCStr (csumtypev);
2977   if (!csumtype)
2978     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2979               "csumtype", "checksum");
2980   const char *path = StringValueCStr (pathv);
2981   if (!path)
2982     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2983               "path", "checksum");
2984
2985   char *r;
2986
2987   r = guestfs_checksum (g, csumtype, path);
2988   if (r == NULL)
2989     rb_raise (e_Error, "%s", guestfs_last_error (g));
2990
2991   VALUE rv = rb_str_new2 (r);
2992   free (r);
2993   return rv;
2994 }
2995
2996 static VALUE ruby_guestfs_tar_in (VALUE gv, VALUE tarfilev, VALUE directoryv)
2997 {
2998   guestfs_h *g;
2999   Data_Get_Struct (gv, guestfs_h, g);
3000   if (!g)
3001     rb_raise (rb_eArgError, "%s: used handle after closing it", "tar_in");
3002
3003   const char *tarfile = StringValueCStr (tarfilev);
3004   if (!tarfile)
3005     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3006               "tarfile", "tar_in");
3007   const char *directory = StringValueCStr (directoryv);
3008   if (!directory)
3009     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3010               "directory", "tar_in");
3011
3012   int r;
3013
3014   r = guestfs_tar_in (g, tarfile, directory);
3015   if (r == -1)
3016     rb_raise (e_Error, "%s", guestfs_last_error (g));
3017
3018   return Qnil;
3019 }
3020
3021 static VALUE ruby_guestfs_tar_out (VALUE gv, VALUE directoryv, VALUE tarfilev)
3022 {
3023   guestfs_h *g;
3024   Data_Get_Struct (gv, guestfs_h, g);
3025   if (!g)
3026     rb_raise (rb_eArgError, "%s: used handle after closing it", "tar_out");
3027
3028   const char *directory = StringValueCStr (directoryv);
3029   if (!directory)
3030     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3031               "directory", "tar_out");
3032   const char *tarfile = StringValueCStr (tarfilev);
3033   if (!tarfile)
3034     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3035               "tarfile", "tar_out");
3036
3037   int r;
3038
3039   r = guestfs_tar_out (g, directory, tarfile);
3040   if (r == -1)
3041     rb_raise (e_Error, "%s", guestfs_last_error (g));
3042
3043   return Qnil;
3044 }
3045
3046 static VALUE ruby_guestfs_tgz_in (VALUE gv, VALUE tarballv, VALUE directoryv)
3047 {
3048   guestfs_h *g;
3049   Data_Get_Struct (gv, guestfs_h, g);
3050   if (!g)
3051     rb_raise (rb_eArgError, "%s: used handle after closing it", "tgz_in");
3052
3053   const char *tarball = StringValueCStr (tarballv);
3054   if (!tarball)
3055     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3056               "tarball", "tgz_in");
3057   const char *directory = StringValueCStr (directoryv);
3058   if (!directory)
3059     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3060               "directory", "tgz_in");
3061
3062   int r;
3063
3064   r = guestfs_tgz_in (g, tarball, directory);
3065   if (r == -1)
3066     rb_raise (e_Error, "%s", guestfs_last_error (g));
3067
3068   return Qnil;
3069 }
3070
3071 static VALUE ruby_guestfs_tgz_out (VALUE gv, VALUE directoryv, VALUE tarballv)
3072 {
3073   guestfs_h *g;
3074   Data_Get_Struct (gv, guestfs_h, g);
3075   if (!g)
3076     rb_raise (rb_eArgError, "%s: used handle after closing it", "tgz_out");
3077
3078   const char *directory = StringValueCStr (directoryv);
3079   if (!directory)
3080     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3081               "directory", "tgz_out");
3082   const char *tarball = StringValueCStr (tarballv);
3083   if (!tarball)
3084     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3085               "tarball", "tgz_out");
3086
3087   int r;
3088
3089   r = guestfs_tgz_out (g, directory, tarball);
3090   if (r == -1)
3091     rb_raise (e_Error, "%s", guestfs_last_error (g));
3092
3093   return Qnil;
3094 }
3095
3096 static VALUE ruby_guestfs_mount_ro (VALUE gv, VALUE devicev, VALUE mountpointv)
3097 {
3098   guestfs_h *g;
3099   Data_Get_Struct (gv, guestfs_h, g);
3100   if (!g)
3101     rb_raise (rb_eArgError, "%s: used handle after closing it", "mount_ro");
3102
3103   const char *device = StringValueCStr (devicev);
3104   if (!device)
3105     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3106               "device", "mount_ro");
3107   const char *mountpoint = StringValueCStr (mountpointv);
3108   if (!mountpoint)
3109     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3110               "mountpoint", "mount_ro");
3111
3112   int r;
3113
3114   r = guestfs_mount_ro (g, device, mountpoint);
3115   if (r == -1)
3116     rb_raise (e_Error, "%s", guestfs_last_error (g));
3117
3118   return Qnil;
3119 }
3120
3121 static VALUE ruby_guestfs_mount_options (VALUE gv, VALUE optionsv, VALUE devicev, VALUE mountpointv)
3122 {
3123   guestfs_h *g;
3124   Data_Get_Struct (gv, guestfs_h, g);
3125   if (!g)
3126     rb_raise (rb_eArgError, "%s: used handle after closing it", "mount_options");
3127
3128   const char *options = StringValueCStr (optionsv);
3129   if (!options)
3130     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3131               "options", "mount_options");
3132   const char *device = StringValueCStr (devicev);
3133   if (!device)
3134     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3135               "device", "mount_options");
3136   const char *mountpoint = StringValueCStr (mountpointv);
3137   if (!mountpoint)
3138     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3139               "mountpoint", "mount_options");
3140
3141   int r;
3142
3143   r = guestfs_mount_options (g, options, device, mountpoint);
3144   if (r == -1)
3145     rb_raise (e_Error, "%s", guestfs_last_error (g));
3146
3147   return Qnil;
3148 }
3149
3150 static VALUE ruby_guestfs_mount_vfs (VALUE gv, VALUE optionsv, VALUE vfstypev, VALUE devicev, VALUE mountpointv)
3151 {
3152   guestfs_h *g;
3153   Data_Get_Struct (gv, guestfs_h, g);
3154   if (!g)
3155     rb_raise (rb_eArgError, "%s: used handle after closing it", "mount_vfs");
3156
3157   const char *options = StringValueCStr (optionsv);
3158   if (!options)
3159     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3160               "options", "mount_vfs");
3161   const char *vfstype = StringValueCStr (vfstypev);
3162   if (!vfstype)
3163     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3164               "vfstype", "mount_vfs");
3165   const char *device = StringValueCStr (devicev);
3166   if (!device)
3167     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3168               "device", "mount_vfs");
3169   const char *mountpoint = StringValueCStr (mountpointv);
3170   if (!mountpoint)
3171     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3172               "mountpoint", "mount_vfs");
3173
3174   int r;
3175
3176   r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint);
3177   if (r == -1)
3178     rb_raise (e_Error, "%s", guestfs_last_error (g));
3179
3180   return Qnil;
3181 }
3182
3183 static VALUE ruby_guestfs_debug (VALUE gv, VALUE subcmdv, VALUE extraargsv)
3184 {
3185   guestfs_h *g;
3186   Data_Get_Struct (gv, guestfs_h, g);
3187   if (!g)
3188     rb_raise (rb_eArgError, "%s: used handle after closing it", "debug");
3189
3190   const char *subcmd = StringValueCStr (subcmdv);
3191   if (!subcmd)
3192     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3193               "subcmd", "debug");
3194   char **extraargs;  {
3195     int i, len;
3196     len = RARRAY_LEN (extraargsv);
3197     extraargs = guestfs_safe_malloc (g, sizeof (char *) * (len+1));
3198     for (i = 0; i < len; ++i) {
3199       VALUE v = rb_ary_entry (extraargsv, i);
3200       extraargs[i] = StringValueCStr (v);
3201     }
3202     extraargs[len] = NULL;
3203   }
3204
3205   char *r;
3206
3207   r = guestfs_debug (g, subcmd, extraargs);
3208   free (extraargs);
3209   if (r == NULL)
3210     rb_raise (e_Error, "%s", guestfs_last_error (g));
3211
3212   VALUE rv = rb_str_new2 (r);
3213   free (r);
3214   return rv;
3215 }
3216
3217 static VALUE ruby_guestfs_lvremove (VALUE gv, VALUE devicev)
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", "lvremove");
3223
3224   const char *device = StringValueCStr (devicev);
3225   if (!device)
3226     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3227               "device", "lvremove");
3228
3229   int r;
3230
3231   r = guestfs_lvremove (g, device);
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_vgremove (VALUE gv, VALUE vgnamev)
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", "vgremove");
3244
3245   const char *vgname = StringValueCStr (vgnamev);
3246   if (!vgname)
3247     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3248               "vgname", "vgremove");
3249
3250   int r;
3251
3252   r = guestfs_vgremove (g, vgname);
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_pvremove (VALUE gv, VALUE devicev)
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", "pvremove");
3265
3266   const char *device = StringValueCStr (devicev);
3267   if (!device)
3268     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3269               "device", "pvremove");
3270
3271   int r;
3272
3273   r = guestfs_pvremove (g, device);
3274   if (r == -1)
3275     rb_raise (e_Error, "%s", guestfs_last_error (g));
3276
3277   return Qnil;
3278 }
3279
3280 static VALUE ruby_guestfs_set_e2label (VALUE gv, VALUE devicev, VALUE labelv)
3281 {
3282   guestfs_h *g;
3283   Data_Get_Struct (gv, guestfs_h, g);
3284   if (!g)
3285     rb_raise (rb_eArgError, "%s: used handle after closing it", "set_e2label");
3286
3287   const char *device = StringValueCStr (devicev);
3288   if (!device)
3289     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3290               "device", "set_e2label");
3291   const char *label = StringValueCStr (labelv);
3292   if (!label)
3293     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3294               "label", "set_e2label");
3295
3296   int r;
3297
3298   r = guestfs_set_e2label (g, device, label);
3299   if (r == -1)
3300     rb_raise (e_Error, "%s", guestfs_last_error (g));
3301
3302   return Qnil;
3303 }
3304
3305 static VALUE ruby_guestfs_get_e2label (VALUE gv, VALUE devicev)
3306 {
3307   guestfs_h *g;
3308   Data_Get_Struct (gv, guestfs_h, g);
3309   if (!g)
3310     rb_raise (rb_eArgError, "%s: used handle after closing it", "get_e2label");
3311
3312   const char *device = StringValueCStr (devicev);
3313   if (!device)
3314     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3315               "device", "get_e2label");
3316
3317   char *r;
3318
3319   r = guestfs_get_e2label (g, device);
3320   if (r == NULL)
3321     rb_raise (e_Error, "%s", guestfs_last_error (g));
3322
3323   VALUE rv = rb_str_new2 (r);
3324   free (r);
3325   return rv;
3326 }
3327
3328 static VALUE ruby_guestfs_set_e2uuid (VALUE gv, VALUE devicev, VALUE uuidv)
3329 {
3330   guestfs_h *g;
3331   Data_Get_Struct (gv, guestfs_h, g);
3332   if (!g)
3333     rb_raise (rb_eArgError, "%s: used handle after closing it", "set_e2uuid");
3334
3335   const char *device = StringValueCStr (devicev);
3336   if (!device)
3337     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3338               "device", "set_e2uuid");
3339   const char *uuid = StringValueCStr (uuidv);
3340   if (!uuid)
3341     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3342               "uuid", "set_e2uuid");
3343
3344   int r;
3345
3346   r = guestfs_set_e2uuid (g, device, uuid);
3347   if (r == -1)
3348     rb_raise (e_Error, "%s", guestfs_last_error (g));
3349
3350   return Qnil;
3351 }
3352
3353 static VALUE ruby_guestfs_get_e2uuid (VALUE gv, VALUE devicev)
3354 {
3355   guestfs_h *g;
3356   Data_Get_Struct (gv, guestfs_h, g);
3357   if (!g)
3358     rb_raise (rb_eArgError, "%s: used handle after closing it", "get_e2uuid");
3359
3360   const char *device = StringValueCStr (devicev);
3361   if (!device)
3362     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3363               "device", "get_e2uuid");
3364
3365   char *r;
3366
3367   r = guestfs_get_e2uuid (g, device);
3368   if (r == NULL)
3369     rb_raise (e_Error, "%s", guestfs_last_error (g));
3370
3371   VALUE rv = rb_str_new2 (r);
3372   free (r);
3373   return rv;
3374 }
3375
3376 static VALUE ruby_guestfs_fsck (VALUE gv, VALUE fstypev, VALUE devicev)
3377 {
3378   guestfs_h *g;
3379   Data_Get_Struct (gv, guestfs_h, g);
3380   if (!g)
3381     rb_raise (rb_eArgError, "%s: used handle after closing it", "fsck");
3382
3383   const char *fstype = StringValueCStr (fstypev);
3384   if (!fstype)
3385     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3386               "fstype", "fsck");
3387   const char *device = StringValueCStr (devicev);
3388   if (!device)
3389     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3390               "device", "fsck");
3391
3392   int r;
3393
3394   r = guestfs_fsck (g, fstype, device);
3395   if (r == -1)
3396     rb_raise (e_Error, "%s", guestfs_last_error (g));
3397
3398   return INT2NUM (r);
3399 }
3400
3401 static VALUE ruby_guestfs_zero (VALUE gv, 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", "zero");
3407
3408   const char *device = StringValueCStr (devicev);
3409   if (!device)
3410     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3411               "device", "zero");
3412
3413   int r;
3414
3415   r = guestfs_zero (g, device);
3416   if (r == -1)
3417     rb_raise (e_Error, "%s", guestfs_last_error (g));
3418
3419   return Qnil;
3420 }
3421
3422 static VALUE ruby_guestfs_grub_install (VALUE gv, VALUE rootv, VALUE devicev)
3423 {
3424   guestfs_h *g;
3425   Data_Get_Struct (gv, guestfs_h, g);
3426   if (!g)
3427     rb_raise (rb_eArgError, "%s: used handle after closing it", "grub_install");
3428
3429   const char *root = StringValueCStr (rootv);
3430   if (!root)
3431     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3432               "root", "grub_install");
3433   const char *device = StringValueCStr (devicev);
3434   if (!device)
3435     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3436               "device", "grub_install");
3437
3438   int r;
3439
3440   r = guestfs_grub_install (g, root, device);
3441   if (r == -1)
3442     rb_raise (e_Error, "%s", guestfs_last_error (g));
3443
3444   return Qnil;
3445 }
3446
3447 static VALUE ruby_guestfs_cp (VALUE gv, VALUE srcv, VALUE destv)
3448 {
3449   guestfs_h *g;
3450   Data_Get_Struct (gv, guestfs_h, g);
3451   if (!g)
3452     rb_raise (rb_eArgError, "%s: used handle after closing it", "cp");
3453
3454   const char *src = StringValueCStr (srcv);
3455   if (!src)
3456     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3457               "src", "cp");
3458   const char *dest = StringValueCStr (destv);
3459   if (!dest)
3460     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3461               "dest", "cp");
3462
3463   int r;
3464
3465   r = guestfs_cp (g, src, dest);
3466   if (r == -1)
3467     rb_raise (e_Error, "%s", guestfs_last_error (g));
3468
3469   return Qnil;
3470 }
3471
3472 static VALUE ruby_guestfs_cp_a (VALUE gv, VALUE srcv, VALUE destv)
3473 {
3474   guestfs_h *g;
3475   Data_Get_Struct (gv, guestfs_h, g);
3476   if (!g)
3477     rb_raise (rb_eArgError, "%s: used handle after closing it", "cp_a");
3478
3479   const char *src = StringValueCStr (srcv);
3480   if (!src)
3481     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3482               "src", "cp_a");
3483   const char *dest = StringValueCStr (destv);
3484   if (!dest)
3485     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3486               "dest", "cp_a");
3487
3488   int r;
3489
3490   r = guestfs_cp_a (g, src, dest);
3491   if (r == -1)
3492     rb_raise (e_Error, "%s", guestfs_last_error (g));
3493
3494   return Qnil;
3495 }
3496
3497 static VALUE ruby_guestfs_mv (VALUE gv, VALUE srcv, VALUE destv)
3498 {
3499   guestfs_h *g;
3500   Data_Get_Struct (gv, guestfs_h, g);
3501   if (!g)
3502     rb_raise (rb_eArgError, "%s: used handle after closing it", "mv");
3503
3504   const char *src = StringValueCStr (srcv);
3505   if (!src)
3506     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3507               "src", "mv");
3508   const char *dest = StringValueCStr (destv);
3509   if (!dest)
3510     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3511               "dest", "mv");
3512
3513   int r;
3514
3515   r = guestfs_mv (g, src, dest);
3516   if (r == -1)
3517     rb_raise (e_Error, "%s", guestfs_last_error (g));
3518
3519   return Qnil;
3520 }
3521
3522 static VALUE ruby_guestfs_drop_caches (VALUE gv, VALUE whattodropv)
3523 {
3524   guestfs_h *g;
3525   Data_Get_Struct (gv, guestfs_h, g);
3526   if (!g)
3527     rb_raise (rb_eArgError, "%s: used handle after closing it", "drop_caches");
3528
3529   int whattodrop = NUM2INT (whattodropv);
3530
3531   int r;
3532
3533   r = guestfs_drop_caches (g, whattodrop);
3534   if (r == -1)
3535     rb_raise (e_Error, "%s", guestfs_last_error (g));
3536
3537   return Qnil;
3538 }
3539
3540 static VALUE ruby_guestfs_dmesg (VALUE gv)
3541 {
3542   guestfs_h *g;
3543   Data_Get_Struct (gv, guestfs_h, g);
3544   if (!g)
3545     rb_raise (rb_eArgError, "%s: used handle after closing it", "dmesg");
3546
3547
3548   char *r;
3549
3550   r = guestfs_dmesg (g);
3551   if (r == NULL)
3552     rb_raise (e_Error, "%s", guestfs_last_error (g));
3553
3554   VALUE rv = rb_str_new2 (r);
3555   free (r);
3556   return rv;
3557 }
3558
3559 static VALUE ruby_guestfs_ping_daemon (VALUE gv)
3560 {
3561   guestfs_h *g;
3562   Data_Get_Struct (gv, guestfs_h, g);
3563   if (!g)
3564     rb_raise (rb_eArgError, "%s: used handle after closing it", "ping_daemon");
3565
3566
3567   int r;
3568
3569   r = guestfs_ping_daemon (g);
3570   if (r == -1)
3571     rb_raise (e_Error, "%s", guestfs_last_error (g));
3572
3573   return Qnil;
3574 }
3575
3576 static VALUE ruby_guestfs_equal (VALUE gv, VALUE file1v, VALUE file2v)
3577 {
3578   guestfs_h *g;
3579   Data_Get_Struct (gv, guestfs_h, g);
3580   if (!g)
3581     rb_raise (rb_eArgError, "%s: used handle after closing it", "equal");
3582
3583   const char *file1 = StringValueCStr (file1v);
3584   if (!file1)
3585     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3586               "file1", "equal");
3587   const char *file2 = StringValueCStr (file2v);
3588   if (!file2)
3589     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3590               "file2", "equal");
3591
3592   int r;
3593
3594   r = guestfs_equal (g, file1, file2);
3595   if (r == -1)
3596     rb_raise (e_Error, "%s", guestfs_last_error (g));
3597
3598   return INT2NUM (r);
3599 }
3600
3601 static VALUE ruby_guestfs_strings (VALUE gv, VALUE pathv)
3602 {
3603   guestfs_h *g;
3604   Data_Get_Struct (gv, guestfs_h, g);
3605   if (!g)
3606     rb_raise (rb_eArgError, "%s: used handle after closing it", "strings");
3607
3608   const char *path = StringValueCStr (pathv);
3609   if (!path)
3610     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3611               "path", "strings");
3612
3613   char **r;
3614
3615   r = guestfs_strings (g, path);
3616   if (r == NULL)
3617     rb_raise (e_Error, "%s", guestfs_last_error (g));
3618
3619   int i, len = 0;
3620   for (i = 0; r[i] != NULL; ++i) len++;
3621   VALUE rv = rb_ary_new2 (len);
3622   for (i = 0; r[i] != NULL; ++i) {
3623     rb_ary_push (rv, rb_str_new2 (r[i]));
3624     free (r[i]);
3625   }
3626   free (r);
3627   return rv;
3628 }
3629
3630 static VALUE ruby_guestfs_strings_e (VALUE gv, VALUE encodingv, VALUE pathv)
3631 {
3632   guestfs_h *g;
3633   Data_Get_Struct (gv, guestfs_h, g);
3634   if (!g)
3635     rb_raise (rb_eArgError, "%s: used handle after closing it", "strings_e");
3636
3637   const char *encoding = StringValueCStr (encodingv);
3638   if (!encoding)
3639     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3640               "encoding", "strings_e");
3641   const char *path = StringValueCStr (pathv);
3642   if (!path)
3643     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3644               "path", "strings_e");
3645
3646   char **r;
3647
3648   r = guestfs_strings_e (g, encoding, path);
3649   if (r == NULL)
3650     rb_raise (e_Error, "%s", guestfs_last_error (g));
3651
3652   int i, len = 0;
3653   for (i = 0; r[i] != NULL; ++i) len++;
3654   VALUE rv = rb_ary_new2 (len);
3655   for (i = 0; r[i] != NULL; ++i) {
3656     rb_ary_push (rv, rb_str_new2 (r[i]));
3657     free (r[i]);
3658   }
3659   free (r);
3660   return rv;
3661 }
3662
3663 static VALUE ruby_guestfs_hexdump (VALUE gv, VALUE pathv)
3664 {
3665   guestfs_h *g;
3666   Data_Get_Struct (gv, guestfs_h, g);
3667   if (!g)
3668     rb_raise (rb_eArgError, "%s: used handle after closing it", "hexdump");
3669
3670   const char *path = StringValueCStr (pathv);
3671   if (!path)
3672     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3673               "path", "hexdump");
3674
3675   char *r;
3676
3677   r = guestfs_hexdump (g, path);
3678   if (r == NULL)
3679     rb_raise (e_Error, "%s", guestfs_last_error (g));
3680
3681   VALUE rv = rb_str_new2 (r);
3682   free (r);
3683   return rv;
3684 }
3685
3686 static VALUE ruby_guestfs_zerofree (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", "zerofree");
3692
3693   const char *device = StringValueCStr (devicev);
3694   if (!device)
3695     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3696               "device", "zerofree");
3697
3698   int r;
3699
3700   r = guestfs_zerofree (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_pvresize (VALUE gv, VALUE devicev)
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", "pvresize");
3713
3714   const char *device = StringValueCStr (devicev);
3715   if (!device)
3716     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3717               "device", "pvresize");
3718
3719   int r;
3720
3721   r = guestfs_pvresize (g, device);
3722   if (r == -1)
3723     rb_raise (e_Error, "%s", guestfs_last_error (g));
3724
3725   return Qnil;
3726 }
3727
3728 static VALUE ruby_guestfs_sfdisk_N (VALUE gv, VALUE devicev, VALUE nv, VALUE cylsv, VALUE headsv, VALUE sectorsv, VALUE linev)
3729 {
3730   guestfs_h *g;
3731   Data_Get_Struct (gv, guestfs_h, g);
3732   if (!g)
3733     rb_raise (rb_eArgError, "%s: used handle after closing it", "sfdisk_N");
3734
3735   const char *device = StringValueCStr (devicev);
3736   if (!device)
3737     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3738               "device", "sfdisk_N");
3739   int n = NUM2INT (nv);
3740   int cyls = NUM2INT (cylsv);
3741   int heads = NUM2INT (headsv);
3742   int sectors = NUM2INT (sectorsv);
3743   const char *line = StringValueCStr (linev);
3744   if (!line)
3745     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3746               "line", "sfdisk_N");
3747
3748   int r;
3749
3750   r = guestfs_sfdisk_N (g, device, n, cyls, heads, sectors, line);
3751   if (r == -1)
3752     rb_raise (e_Error, "%s", guestfs_last_error (g));
3753
3754   return Qnil;
3755 }
3756
3757 static VALUE ruby_guestfs_sfdisk_l (VALUE gv, VALUE devicev)
3758 {
3759   guestfs_h *g;
3760   Data_Get_Struct (gv, guestfs_h, g);
3761   if (!g)
3762     rb_raise (rb_eArgError, "%s: used handle after closing it", "sfdisk_l");
3763
3764   const char *device = StringValueCStr (devicev);
3765   if (!device)
3766     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3767               "device", "sfdisk_l");
3768
3769   char *r;
3770
3771   r = guestfs_sfdisk_l (g, device);
3772   if (r == NULL)
3773     rb_raise (e_Error, "%s", guestfs_last_error (g));
3774
3775   VALUE rv = rb_str_new2 (r);
3776   free (r);
3777   return rv;
3778 }
3779
3780 static VALUE ruby_guestfs_sfdisk_kernel_geometry (VALUE gv, VALUE devicev)
3781 {
3782   guestfs_h *g;
3783   Data_Get_Struct (gv, guestfs_h, g);
3784   if (!g)
3785     rb_raise (rb_eArgError, "%s: used handle after closing it", "sfdisk_kernel_geometry");
3786
3787   const char *device = StringValueCStr (devicev);
3788   if (!device)
3789     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3790               "device", "sfdisk_kernel_geometry");
3791
3792   char *r;
3793
3794   r = guestfs_sfdisk_kernel_geometry (g, device);
3795   if (r == NULL)
3796     rb_raise (e_Error, "%s", guestfs_last_error (g));
3797
3798   VALUE rv = rb_str_new2 (r);
3799   free (r);
3800   return rv;
3801 }
3802
3803 static VALUE ruby_guestfs_sfdisk_disk_geometry (VALUE gv, VALUE devicev)
3804 {
3805   guestfs_h *g;
3806   Data_Get_Struct (gv, guestfs_h, g);
3807   if (!g)
3808     rb_raise (rb_eArgError, "%s: used handle after closing it", "sfdisk_disk_geometry");
3809
3810   const char *device = StringValueCStr (devicev);
3811   if (!device)
3812     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3813               "device", "sfdisk_disk_geometry");
3814
3815   char *r;
3816
3817   r = guestfs_sfdisk_disk_geometry (g, device);
3818   if (r == NULL)
3819     rb_raise (e_Error, "%s", guestfs_last_error (g));
3820
3821   VALUE rv = rb_str_new2 (r);
3822   free (r);
3823   return rv;
3824 }
3825
3826 static VALUE ruby_guestfs_vg_activate_all (VALUE gv, VALUE activatev)
3827 {
3828   guestfs_h *g;
3829   Data_Get_Struct (gv, guestfs_h, g);
3830   if (!g)
3831     rb_raise (rb_eArgError, "%s: used handle after closing it", "vg_activate_all");
3832
3833   int activate = RTEST (activatev);
3834
3835   int r;
3836
3837   r = guestfs_vg_activate_all (g, activate);
3838   if (r == -1)
3839     rb_raise (e_Error, "%s", guestfs_last_error (g));
3840
3841   return Qnil;
3842 }
3843
3844 static VALUE ruby_guestfs_vg_activate (VALUE gv, VALUE activatev, VALUE volgroupsv)
3845 {
3846   guestfs_h *g;
3847   Data_Get_Struct (gv, guestfs_h, g);
3848   if (!g)
3849     rb_raise (rb_eArgError, "%s: used handle after closing it", "vg_activate");
3850
3851   int activate = RTEST (activatev);
3852   char **volgroups;  {
3853     int i, len;
3854     len = RARRAY_LEN (volgroupsv);
3855     volgroups = guestfs_safe_malloc (g, sizeof (char *) * (len+1));
3856     for (i = 0; i < len; ++i) {
3857       VALUE v = rb_ary_entry (volgroupsv, i);
3858       volgroups[i] = StringValueCStr (v);
<