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